html_prettyprinter.c File Reference

#include <stdio.h>
#include <ctype.h>
#include "genC.h"
#include "linear.h"
#include "misc.h"
#include "pipsdbm.h"
#include "properties.h"
#include "ri-util.h"

Include dependency graph for html_prettyprinter.c:

Go to the source code of this file.

Macros
#define	NL   "\n"
#define	current_module_is_a_function()   (entity_function_p(get_current_module_entity()))
#define	html_print(format, args...)

Functions
static void	html_print_expression (expression e, bool cr)
static void	html_print_range (range r)
static void	html_print_statement (statement r)
static void	html_print_type (type t)
static void	html_print_value (value v)
static void	html_set_output (FILE *new_fp)
static void	begin_block (const char *block, bool cr)
static void	end_block (const char *block, bool cr)
void	html_output (const char *out, bool cr)
	html_prettyprinter.c More...
static void	html_print_entity_name (entity e)
static void	html_print_ram (ram r)
static void	html_print_formal (formal f)
static void	html_print_rom (_UNUSED_ unit r)
static void	html_print_code (code c)
static void	html_print_storage (storage s)
static void	html_print_basic (basic b)
static void	html_print_area (area a)
static void	html_print_qualifier (qualifier q)
static void	html_print_dimension (dimension d)
static void	html_print_variable (variable v)
static void	html_print_mode (mode m)
static void	html_print_parameter (parameter p)
static void	html_print_functional (functional f)
static void	html_print_constant (constant c)
void	html_print_entity_full (entity e)
static void	html_print_call (call c)
static void	html_print_unstructured (_UNUSED_ unstructured u)
static void	html_print_reference (reference r)
static void	html_print_subscript (subscript s)
static void	html_print_loop (loop l)
static void	html_print_whileloop (whileloop w)
static void	html_print_forloop (forloop f)
static void	html_print_sequence (sequence seq)
static void	html_print_test (test t)
void	html_print_symbol_table (void)
bool	html_prettyprint (const string mod_name)
bool	html_prettyprint_symbol_table (const string module)

Variables
static FILE *	out_fp = 0

Macro Definition Documentation

current_module_is_a_function

#define current_module_is_a_function

(

)

(entity_function_p(get_current_module_entity()))

Definition at line 59 of file html_prettyprinter.c.

html_print

#define html_print	(		format,
			args...
	)

Value:

{ \
  pips_assert("Output is set",out_fp); \
  fprintf(out_fp,format,##args); \
}

Definition at line 79 of file html_prettyprinter.c.

NL

#define NL   "\n"

Definition at line 56 of file html_prettyprinter.c.

Function Documentation

begin_block()

static void begin_block ( const char *  block, bool  cr  )

static

Definition at line 86 of file html_prettyprinter.c.

                                                    {
  if(cr) {
    html_print("<li class=\"%s blocked\"><span>%s</span><ul class=\"inlined\">" NL,
           block,
           block);
  } else {
    html_print("<li class=\"%s inlined\"><span>%s</span><ul class=\"inlined\">" NL,
           block,
           block);
  }
}

References html_print, and NL.

Referenced by html_prettyprint(), html_print_area(), html_print_basic(), html_print_call(), html_print_code(), html_print_constant(), html_print_dimension(), html_print_entity_full(), html_print_entity_name(), html_print_expression(), html_print_forloop(), html_print_formal(), html_print_functional(), html_print_loop(), html_print_mode(), html_print_parameter(), html_print_qualifier(), html_print_ram(), html_print_range(), html_print_reference(), html_print_rom(), html_print_sequence(), html_print_statement(), html_print_storage(), html_print_subscript(), html_print_symbol_table(), html_print_test(), html_print_type(), html_print_unstructured(), html_print_value(), html_print_variable(), and html_print_whileloop().

Here is the caller graph for this function:

end_block()

static void end_block ( const char *  block, bool  cr  )

static

Definition at line 98 of file html_prettyprinter.c.

                                                  {
  if(cr) {
    html_print("</ul></li><!-- %s -->" NL, block);
  } else
    html_print("</ul></li><!-- %s -->" NL, block);
}

References html_print, and NL.

Referenced by html_prettyprint(), html_print_area(), html_print_basic(), html_print_call(), html_print_code(), html_print_constant(), html_print_dimension(), html_print_entity_full(), html_print_entity_name(), html_print_expression(), html_print_forloop(), html_print_formal(), html_print_functional(), html_print_loop(), html_print_mode(), html_print_parameter(), html_print_qualifier(), html_print_ram(), html_print_range(), html_print_reference(), html_print_rom(), html_print_sequence(), html_print_statement(), html_print_storage(), html_print_subscript(), html_print_symbol_table(), html_print_test(), html_print_type(), html_print_unstructured(), html_print_value(), html_print_variable(), and html_print_whileloop().

Here is the caller graph for this function:

html_output()

void html_output	(	const char *	out,
		bool	cr
	)

html_prettyprinter.c

Parameters

out	ut
cr	r

Definition at line 105 of file html_prettyprinter.c.

                                           {
  if(cr) {
    html_print("<li><span>%s</span></li>" NL, out);
  } else {
    html_print("<li class=\"inlined\"><span>%s</span></li>" NL, out);
  }
}

References html_print, NL, and out.

Referenced by html_print_area(), html_print_basic(), html_print_constant(), html_print_entity_full(), html_print_entity_name(), html_print_expression(), html_print_formal(), html_print_mode(), html_print_parameter(), html_print_qualifier(), html_print_ram(), html_print_rom(), html_print_statement(), html_print_storage(), html_print_type(), html_print_unstructured(), html_print_value(), and html_print_whileloop().

Here is the caller graph for this function:

html_prettyprint()

bool html_prettyprint

(

const string

mod_name

)

Set the current module entity required to have many things working in PIPS:

The debug is now controled by this environment variable name:

Print current module

Parameters

mod_name

od_name

Definition at line 818 of file html_prettyprinter.c.

{
 
  statement module_statement = (statement)db_get_memory_resource(DBR_CODE,
                                                                 mod_name,
                                                                 true);
 
  set_current_module_statement(module_statement);
 
  /* Set the current module entity required to have many things
     working in PIPS: */
  set_current_module_entity(module_name_to_entity(mod_name));
 
 
  /* The debug is now controled by this environment variable name: */
  debug_on("HTML_PRETTYPRINT_DEBUG_LEVEL");
  pips_assert("Statement should be OK at entry...",
              statement_consistent_p(module_statement));
 
  // Prepare the output file
  string html_file_name = db_build_file_resource_name( "RI", mod_name, ".ri.html" );
  string output_file = strdup( concatenate( db_get_current_workspace_directory( ),
                                        "/",
                                        html_file_name,
                                        NULL ) );
  pips_debug(2,"Output in %s",output_file);
  FILE *fp = safe_fopen( output_file, "w" );
  html_set_output(fp);
 
  /* Print current module */
  html_print(NL "<li><ul class=\"module\">" NL);
  begin_block(mod_name, true);
  html_print_statement(module_statement);
  end_block(mod_name, true);
  html_print("<li class=\"endmodule\">&nbsp;</li>" NL "</ul></li>" NL);
 
 
  if(get_bool_property("HTML_PRETTYPRINT_SYMBOL_TABLE")) {
    html_print_symbol_table();
  }
 
  // Reset output file
  html_set_output(0);
  safe_fclose( fp, output_file );
 
 
  DB_PUT_FILE_RESOURCE( DBR_HTML_IR_FILE, strdup( mod_name ), html_file_name );
 
  reset_current_module_statement();
  reset_current_module_entity();
 
  return true;
}

References begin_block(), concatenate(), db_build_file_resource_name(), db_get_current_workspace_directory(), db_get_memory_resource(), DB_PUT_FILE_RESOURCE, debug_on, end_block(), get_bool_property(), html_print, html_print_statement(), html_print_symbol_table(), html_set_output(), module_name_to_entity(), module_statement, NL, pips_assert, pips_debug, reset_current_module_entity(), reset_current_module_statement(), safe_fclose(), safe_fopen(), set_current_module_entity(), set_current_module_statement(), statement_consistent_p(), and strdup().

Here is the call graph for this function:

html_prettyprint_symbol_table()

bool html_prettyprint_symbol_table

(

const string

module

)

Parameters

module

odule

Definition at line 872 of file html_prettyprinter.c.

{
  pips_debug(1, "working on %s", module);
 
  // Prepare the output file
  string html_file_name =
    db_build_file_resource_name( "Symbols", "", ".symbols.html" );
  string output_file =
    strdup( concatenate( db_get_current_workspace_directory( ),
                         "/", html_file_name, NULL ) );
  FILE *fp = safe_fopen( output_file, "w" );
  html_set_output(fp);
 
  // Reset output file
  html_set_output(0);
  safe_fclose( fp, output_file );
 
  DB_PUT_FILE_RESOURCE( DBR_HTML_IR_FILE, "", html_file_name );
 
  return true;
}

References concatenate(), db_build_file_resource_name(), db_get_current_workspace_directory(), DB_PUT_FILE_RESOURCE, html_set_output(), module, pips_debug, safe_fclose(), safe_fopen(), and strdup().

Here is the call graph for this function:

html_print_area()

static void html_print_area ( area  a )

static

Definition at line 275 of file html_prettyprinter.c.

                                    {
  begin_block("area", false);
 
  string buf;
  pips_assert("Asprintf !",
      asprintf( &buf, "Size : %d", (int) area_size( a ) ) > 0);
  html_output(buf, false);
  free(buf);
 
  html_output("Layout", false);
  FOREACH(entity, e, area_layout( a ) ) {
    html_print_entity_name(e);
  }
 
  end_block("area", false);
}

References area_layout, area_size, asprintf, begin_block(), buf, end_block(), FOREACH, free(), html_output(), html_print_entity_name(), and pips_assert.

Referenced by html_print_type().

Here is the call graph for this function:

Here is the caller graph for this function:

html_print_basic()

static void html_print_basic ( basic  b )

static

Definition at line 213 of file html_prettyprinter.c.

                                      {
  begin_block("basic", false);
  string buf;
 
  if(!b || b == basic_undefined) {
    html_output("undefined", false);
  } else {
    switch(basic_tag( b )) {
      case is_basic_int:
        html_output("int", false);
        pips_assert("Asprintf !", asprintf( &buf, "%d", (int)basic_int(b) ));
        html_output(buf, false);
        free(buf);
        break;
      case is_basic_float:
        html_output("float", false);
        pips_assert("Asprintf !", asprintf( &buf, "%f", (float)basic_int(b) ));
        html_output(buf, false);
        free(buf);
        break;
      case is_basic_logical:
        html_output("logical", false);
        pips_assert("Asprintf !", asprintf( &buf, "%d", (int)basic_int(b) ));
        html_output(buf, false);
        free(buf);
        break;
      case is_basic_overloaded:
        html_output("overloaded", false);
        html_output("unimplemented", false);
        break;
      case is_basic_complex:
        html_output("complex", false);
        html_output("unimplemented", false);
        break;
      case is_basic_string:
        html_output("string", false);
        html_print_value(basic_string(b));
        break;
      case is_basic_bit:
        html_output("bit", false);
        html_output("unimplemented", false);
        break;
      case is_basic_pointer:
        html_output("pointer", false);
        html_print_type(basic_pointer(b));
        break;
      case is_basic_derived:
        html_output("derived", false);
        html_print_entity_name(basic_derived(b));
        break;
      case is_basic_typedef:
        html_output("typedef", false);
        html_print_entity_name(basic_typedef(b));
        break;
      default:
        html_output("unknown", false);
        break;
    }
  }
  end_block("basic", false);
}

References asprintf, basic_derived, basic_int, basic_pointer, basic_string, basic_tag, basic_typedef, basic_undefined, begin_block(), buf, end_block(), free(), html_output(), html_print_entity_name(), html_print_type(), html_print_value(), is_basic_bit, is_basic_complex, is_basic_derived, is_basic_float, is_basic_int, is_basic_logical, is_basic_overloaded, is_basic_pointer, is_basic_string, is_basic_typedef, and pips_assert.

Referenced by html_print_variable().

Here is the call graph for this function:

Here is the caller graph for this function:

html_print_call()

static void html_print_call ( call  c )

static

Definition at line 531 of file html_prettyprinter.c.

                                    {
  bool cr = false;
  if(call_arguments( c )) {
    cr = true;
  }
  begin_block("call", cr);
 
  begin_block("function", cr);
  html_print_entity_name(call_function(c));
  end_block("function", cr);
 
  if(call_arguments( c )) {
    begin_block("arguments", cr);
    FOREACH(expression, e, call_arguments( c ) ) {
      html_print_expression(e, cr);
    }
    end_block("arguments", cr);
  }
  end_block("call", cr);
}

References begin_block(), call_arguments, call_function, end_block(), FOREACH, html_print_entity_name(), and html_print_expression().

Referenced by html_print_expression(), and html_print_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

html_print_code()

static void html_print_code ( code  c )

static

Definition at line 167 of file html_prettyprinter.c.

                                    {
  begin_block("code", true);
 
  list l = code_declarations(c);
  if(l) {
    begin_block("declarations", true);
    if(!ENDP(l)) {
      FOREACH(entity, e, l )
      {
        begin_block("", true);
        html_print_entity_name(e);
        end_block("", true);
      }
    }
    end_block("declarations", true);
  }
  end_block("code", true);
}

References begin_block(), code_declarations, end_block(), ENDP, FOREACH, and html_print_entity_name().

Referenced by html_print_value().

Here is the call graph for this function:

Here is the caller graph for this function:

html_print_constant()

static void html_print_constant ( constant  c )

static

Definition at line 440 of file html_prettyprinter.c.

                                            {
  begin_block("constant", false);
  if(!c || c == constant_undefined) {
    html_output("undefined", false);
  } else {
    switch(constant_tag( c )) {
      case is_constant_int: {
        string buf;
        pips_assert("Asprintf !",
            asprintf( &buf, "int : %d", (int) constant_int( c ) ) > 0 );
        html_output(buf, true);
        free(buf);
        break;
      }
      case is_constant_float: {
        string buf;
        pips_assert("Asprintf !",
            asprintf( &buf, "float : %f", (float) constant_float( c ) ) > 0 );
        html_output(buf, true);
        free(buf);
        break;
      }
      case is_constant_logical: {
        string buf;
        pips_assert("Asprintf !",
            asprintf( &buf, "Logical : %d", (int) constant_logical( c ) ) > 0 );
        html_output(buf, true);
        free(buf);
        break;
      }
      case is_constant_litteral:
        html_output("litteral", false);
        break;
      case is_constant_call:
        html_print_entity_name(constant_call(c));
        break;
      case is_constant_unknown:
        begin_block("unknown", false);
        break;
      default:
        html_output("error", false);
        break;
    }
  }
  end_block("constant", false);
}

References asprintf, begin_block(), buf, constant_call, constant_float, constant_int, constant_logical, constant_tag, constant_undefined, end_block(), free(), html_output(), html_print_entity_name(), is_constant_call, is_constant_float, is_constant_int, is_constant_litteral, is_constant_logical, is_constant_unknown, and pips_assert.

Referenced by html_print_value().

Here is the call graph for this function:

Here is the caller graph for this function:

html_print_dimension()

static void html_print_dimension ( dimension  d )

static

Definition at line 319 of file html_prettyprinter.c.

                                              {
  begin_block("dimension", true);
  html_print_expression(dimension_lower( d ), true);
  html_print_expression(dimension_upper( d ), true);
  end_block("dimension", true);
}

References begin_block(), dimension_lower, dimension_upper, end_block(), and html_print_expression().

Referenced by html_print_variable().

Here is the call graph for this function:

Here is the caller graph for this function:

html_print_entity_full()

void html_print_entity_full

(

entity

e

)

Definition at line 521 of file html_prettyprinter.c.

                                      {
  begin_block("entity", true);
  html_output(entity_name( e ), true);
  html_print_type(entity_type( e ));
  html_print_storage(entity_storage( e ));
  html_print_value(entity_initial( e ));
 
  end_block("entity", true);
}

References begin_block(), end_block(), entity_initial, entity_name, entity_storage, entity_type, html_output(), html_print_storage(), html_print_type(), and html_print_value().

Referenced by html_print_symbol_table().

Here is the call graph for this function:

Here is the caller graph for this function:

html_print_entity_name()

static void html_print_entity_name ( entity  e )

static

Definition at line 113 of file html_prettyprinter.c.

                                             {
  begin_block("entity", false);
  html_output(entity_name( e ), false);
  end_block("entity", false);
}

References begin_block(), end_block(), entity_name, and html_output().

Referenced by html_print_area(), html_print_basic(), html_print_call(), html_print_code(), html_print_constant(), html_print_formal(), html_print_loop(), html_print_ram(), html_print_reference(), html_print_statement(), html_print_storage(), and html_print_type().

Here is the call graph for this function:

Here is the caller graph for this function:

html_print_expression()

static void html_print_expression ( expression  e, bool  cr  )

static

Definition at line 593 of file html_prettyprinter.c.

                                                         {
  begin_block("expression", cr);
  begin_block("syntax", false);
 
  syntax s = expression_syntax(e);
  switch(syntax_tag(s)) {
    case is_syntax_call:
      html_print_call(syntax_call( s ));
      break;
    case is_syntax_range:
      html_print_range(syntax_range( s ));
      break;
    case is_syntax_reference:
      html_print_reference(syntax_reference( s ));
      break;
    case is_syntax_subscript:
      html_print_subscript(syntax_subscript( s ));
      break;
    case is_syntax_cast:
      html_output("cast unimplemented", false);
      break;
    case is_syntax_sizeofexpression:
      html_output("sizeofexpression unimplemented", false);
      break;
    case is_syntax_application:
      html_output("sizeofexpression unimplemented", false);
      break;
    case is_syntax_va_arg:
      html_output("va_arg unimplemented", false);
      break;
    default:
      pips_internal_error("unexpected syntax tag");
  }
 
  end_block("syntax", false);
  end_block("expression", cr);
}

References begin_block(), end_block(), expression_syntax, html_output(), html_print_call(), html_print_range(), html_print_reference(), html_print_subscript(), is_syntax_application, is_syntax_call, is_syntax_cast, is_syntax_range, is_syntax_reference, is_syntax_sizeofexpression, is_syntax_subscript, is_syntax_va_arg, pips_internal_error, syntax_call, syntax_range, syntax_reference, syntax_subscript, and syntax_tag.

Referenced by html_print_call(), html_print_dimension(), html_print_forloop(), html_print_range(), html_print_reference(), html_print_statement(), html_print_subscript(), html_print_test(), html_print_value(), and html_print_whileloop().

Here is the call graph for this function:

Here is the caller graph for this function:

html_print_forloop()

static void html_print_forloop ( forloop  f )

static

partial implementation...

Definition at line 691 of file html_prettyprinter.c.

                                          {
  /* partial implementation... */
 
  begin_block("forloop", true);
 
  begin_block("initialization", true);
  html_print_expression(forloop_initialization( f ), false);
  end_block("initialization", true);
 
  begin_block("condition", true);
  html_print_expression(forloop_condition( f ), false);
  end_block("condition", true);
 
  begin_block("increment", true);
  html_print_expression(forloop_increment( f ), false);
  end_block("increment", true);
 
  begin_block("body", false);
  html_print_statement(forloop_body( f ));
  end_block("body", false);
 
  end_block("forloop", true);
}

References begin_block(), end_block(), f(), forloop_body, forloop_condition, forloop_increment, forloop_initialization, html_print_expression(), and html_print_statement().

Referenced by html_print_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

html_print_formal()

static void html_print_formal ( formal  f )

static

Definition at line 144 of file html_prettyprinter.c.

                                        {
  begin_block("formal", true);
 
  begin_block("Function", false);
  html_print_entity_name(formal_function( f ));
  end_block("Function", false);
 
  string buf;
  pips_assert("Asprintf !",
      asprintf( &buf, "Offset : %d", (int) formal_offset( f ) ) > 0);
  html_output(buf, true);
 
  end_block("formal", true);
}

References asprintf, begin_block(), buf, end_block(), f(), formal_function, formal_offset, html_output(), html_print_entity_name(), and pips_assert.

Referenced by html_print_storage().

Here is the call graph for this function:

Here is the caller graph for this function:

html_print_functional()

static void html_print_functional ( functional  f )

static

Definition at line 368 of file html_prettyprinter.c.

                                                {
  begin_block("functional", true);
  FOREACH(parameter, param, functional_parameters( f ) ) {
    html_print_parameter(param);
  }
 
  begin_block("return", false);
  html_print_type(functional_result( f ));
  end_block("return", false);
 
  end_block("functional", true);
}

References begin_block(), end_block(), f(), FOREACH, functional_parameters, functional_result, html_print_parameter(), and html_print_type().

Referenced by html_print_type().

Here is the call graph for this function:

Here is the caller graph for this function:

html_print_loop()

static void html_print_loop ( loop  l )

static

partial implementation ???

Definition at line 645 of file html_prettyprinter.c.

                                    {
  begin_block("loop", true);
  /* partial implementation ??? */
 
  begin_block("index", false);
  html_print_entity_name(loop_index( l ));
  end_block("index", false);
 
  html_print_range(loop_range( l ));
 
  begin_block("body", false);
  html_print_statement(loop_body( l ));
  end_block("body", false);
 
  end_block("loop", true);
}

References begin_block(), end_block(), html_print_entity_name(), html_print_range(), html_print_statement(), loop_body, loop_index, and loop_range.

Referenced by html_print_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

html_print_mode()

static void html_print_mode ( mode  m )

static

Definition at line 340 of file html_prettyprinter.c.

                                    {
  begin_block("mode", false);
 
  switch(mode_tag( m )) {
    case is_mode_value:
      html_output("value", false);
      break;
    case is_mode_reference:
      html_output("reference", false);
      break;
    default:
      html_output("unknown", false);
      break;
  }
 
  end_block("mode", false);
}

References begin_block(), end_block(), html_output(), is_mode_reference, is_mode_value, and mode_tag.

Referenced by html_print_parameter().

Here is the call graph for this function:

Here is the caller graph for this function:

html_print_parameter()

static void html_print_parameter ( parameter  p )

static

Definition at line 358 of file html_prettyprinter.c.

                                              {
  begin_block("parameter", true);
 
  html_print_type(parameter_type( p ));
  html_print_mode(parameter_mode( p ));
  html_output("Dummy :  not implemented", true);
 
  end_block("parameter", true);
}

References begin_block(), end_block(), html_output(), html_print_mode(), html_print_type(), parameter_mode, and parameter_type.

Referenced by html_print_functional().

Here is the call graph for this function:

Here is the caller graph for this function:

html_print_qualifier()

static void html_print_qualifier ( qualifier  q )

static

Definition at line 292 of file html_prettyprinter.c.

                                              {
  begin_block("qualifier", false);
 
  switch(qualifier_tag( q )) {
    case is_qualifier_const:
      html_output("const", false);
      break;
    case is_qualifier_restrict:
      html_output("restrict", false);
      break;
    case is_qualifier_volatile:
      html_output("volatile", false);
      break;
    case is_qualifier_register:
      html_output("register", false);
      break;
    case is_qualifier_auto:
      html_output("auto", false);
      break;
    default:
      html_output("unknown", false);
      break;
  }
 
  end_block("qualifier", false);
}

References begin_block(), end_block(), html_output(), is_qualifier_auto, is_qualifier_const, is_qualifier_register, is_qualifier_restrict, is_qualifier_volatile, and qualifier_tag.

Referenced by html_print_variable().

Here is the call graph for this function:

Here is the caller graph for this function:

html_print_ram()

static void html_print_ram ( ram  r )

static

Definition at line 119 of file html_prettyprinter.c.

                                  {
  begin_block("ram", true);
 
  begin_block("Function", true);
  html_print_entity_name(ram_function( r ));
  end_block("Function", true);
 
  html_output(NL, false);
 
  begin_block("Section", true);
  html_print_entity_name(ram_section( r ));
  end_block("Section", true);
 
  string buf;
  pips_assert("Asprintf !",
      asprintf( &buf, "Offset : %d", (int) ram_offset( r ) ) > 0 );
  html_output(buf, true);
  free(buf);
  FOREACH(entity, e, ram_shared( r ) ) {
    html_print_entity_name(e);
  }
 
  end_block("ram", true);
}

References asprintf, begin_block(), buf, end_block(), FOREACH, free(), html_output(), html_print_entity_name(), NL, pips_assert, ram_function, ram_offset, ram_section, and ram_shared.

Referenced by html_print_storage().

Here is the call graph for this function:

Here is the caller graph for this function:

html_print_range()

static void html_print_range ( range  r )

static

Definition at line 631 of file html_prettyprinter.c.

                                      {
  begin_block("range", true);
  begin_block("lower", false);
  html_print_expression(range_lower( r ), false);
  end_block("lower", false);
  begin_block("upper", true);
  html_print_expression(range_upper( r ), false);
  end_block("upper", true);
  begin_block("increment", true);
  html_print_expression(range_increment( r ), false);
  end_block("increment", true);
  end_block("range", true);
}

References begin_block(), end_block(), html_print_expression(), range_increment, range_lower, and range_upper.

Referenced by html_print_expression(), and html_print_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

html_print_reference()

static void html_print_reference ( reference  r )

static

Definition at line 558 of file html_prettyprinter.c.

                                              {
  bool cr = false;
  if(reference_indices( r )) {
    cr = true;
  }
 
  begin_block("reference", cr);
  begin_block("variable", cr);
  html_print_entity_name(reference_variable( r ));
  end_block("variable", cr);
 
  if(reference_indices( r )) {
    begin_block("indices", cr);
    FOREACH(expression, e, reference_indices( r ) ) {
      html_print_expression(e, false);
    }
    end_block("indices", cr);
  }
 
  end_block("reference", cr);
}

References begin_block(), end_block(), FOREACH, html_print_entity_name(), html_print_expression(), reference_indices, and reference_variable.

Referenced by html_print_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

html_print_rom()

static void html_print_rom ( _UNUSED_ unit  r )

static

Definition at line 159 of file html_prettyprinter.c.

                                            {
  begin_block("rom", false);
 
  html_output("unit ? (not implemented)", false);
 
  end_block("rom", false);
}

References begin_block(), end_block(), and html_output().

Referenced by html_print_storage().

Here is the call graph for this function:

Here is the caller graph for this function:

html_print_sequence()

static void html_print_sequence ( sequence  seq )

static

Definition at line 715 of file html_prettyprinter.c.

                                              {
  begin_block("sequence", true);
  FOREACH( statement, s, sequence_statements( seq ) ) {
    html_print_statement(s);
  }
  end_block("sequence", true);
}

References begin_block(), end_block(), FOREACH, html_print_statement(), and sequence_statements.

Referenced by html_print_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

html_print_statement()

static void html_print_statement ( statement  r )

static

statement g = instruction_goto(i); entity el = statement_label(g); string l = entity_local_name(el) + sizeof(LABEL_PREFIX) -1; printf("%s", strdup( concatenate( "goto ", l, SEMICOLON, NULL ) ) );

add switch, forloop break, continue, return instructions here

Definition at line 743 of file html_prettyprinter.c.

                                              {
  begin_block("statement", true);
 
  if(statement_label(s) != entity_undefined) {
    begin_block("label", false);
    html_print_entity_name(statement_label(s));
    end_block("label", false);
  }
 
  list l = statement_declarations(s);
  if(!ENDP(l)) {
    begin_block("declarations", true);
    FOREACH( entity, e, l ) {
      html_print_entity_name(e);
    }
    end_block("declarations", true);
  }
 
  begin_block("instruction", true);
  instruction i = statement_instruction(s);
  switch(instruction_tag(i)) {
    case is_instruction_test:
      html_print_test(instruction_test( i ));
      break;
    case is_instruction_sequence:
      html_print_sequence(instruction_sequence( i ));
      break;
    case is_instruction_loop:
      html_print_loop(instruction_loop( i ));
      break;
    case is_instruction_whileloop:
      html_print_whileloop(instruction_whileloop( i ));
      break;
    case is_instruction_forloop:
      html_print_forloop(instruction_forloop( i ));
      break;
    case is_instruction_call:
      html_print_call(instruction_call( i ));
      break;
    case is_instruction_unstructured:
      html_print_unstructured(instruction_unstructured( i ));
      break;
    case is_instruction_expression:
      html_print_expression(instruction_expression( i ), false);
      break;
    case is_instruction_goto:
      /*      statement g = instruction_goto(i);
       entity el = statement_label(g);
       string l = entity_local_name(el) + sizeof(LABEL_PREFIX) -1;
       printf("%s", strdup( concatenate( "goto ", l, SEMICOLON, NULL ) ) );*/
      break;
      /* add switch, forloop break, continue, return instructions here*/
    default:
      html_output(" Instruction not implemented" NL, false);
      break;
  }
  end_block("instruction", true);
 
  end_block("statement", true);
}

References begin_block(), end_block(), ENDP, entity_undefined, FOREACH, html_output(), html_print_call(), html_print_entity_name(), html_print_expression(), html_print_forloop(), html_print_loop(), html_print_sequence(), html_print_test(), html_print_unstructured(), html_print_whileloop(), instruction_call, instruction_expression, instruction_forloop, instruction_loop, instruction_sequence, instruction_tag, instruction_test, instruction_unstructured, instruction_whileloop, is_instruction_call, is_instruction_expression, is_instruction_forloop, is_instruction_goto, is_instruction_loop, is_instruction_sequence, is_instruction_test, is_instruction_unstructured, is_instruction_whileloop, NL, statement_declarations, statement_instruction, and statement_label.

Referenced by html_prettyprint(), html_print_forloop(), html_print_loop(), html_print_sequence(), html_print_test(), and html_print_whileloop().

Here is the call graph for this function:

Here is the caller graph for this function:

html_print_storage()

static void html_print_storage ( storage  s )

static

Definition at line 186 of file html_prettyprinter.c.

                                          {
  begin_block("storage", true);
  if(storage_undefined_p(s)) {
    html_output("undefined", false);
  } else {
    switch(storage_tag( s )) {
      case is_storage_return:
        html_output("Return", false);
        html_print_entity_name(storage_return( s ));
        break;
      case is_storage_ram:
        html_print_ram(storage_ram( s ));
        break;
      case is_storage_formal:
        html_print_formal(storage_formal( s ));
        break;
      case is_storage_rom:
        html_print_rom(storage_rom( s));
        break;
      default:
        html_output("Unknown storage", true);
        break;
    }
  }
  end_block("storage", true);
}

References begin_block(), end_block(), html_output(), html_print_entity_name(), html_print_formal(), html_print_ram(), html_print_rom(), is_storage_formal, is_storage_ram, is_storage_return, is_storage_rom, storage_formal, storage_ram, storage_return, storage_rom, storage_tag, and storage_undefined_p.

Referenced by html_print_entity_full().

Here is the call graph for this function:

Here is the caller graph for this function:

html_print_subscript()

static void html_print_subscript ( subscript  s )

static

Definition at line 580 of file html_prettyprinter.c.

                                              {
  begin_block("subscript", false);
  begin_block("array", false);
  html_print_expression(subscript_array( s ), false);
  end_block("array", false);
  begin_block("indices", false);
  FOREACH(expression, e, subscript_indices( s ) ) {
    html_print_expression(e, false);
  }
  end_block("indices", false);
  end_block("subscript", false);
}

References begin_block(), end_block(), FOREACH, html_print_expression(), subscript_array, and subscript_indices.

Referenced by html_print_expression().

Here is the call graph for this function:

Here is the caller graph for this function:

html_print_symbol_table()

void html_print_symbol_table

(

void

)

Print symbol table

Definition at line 805 of file html_prettyprinter.c.

{
  /* Print symbol table */
  html_print(NL "<li><ul class=\"symbolTable\">" NL);
  begin_block("Symbol table", true);
  list entities = gen_filter_tabulated(gen_true, entity_domain);
  FOREACH(entity, e, entities ) {
    html_print_entity_full(e);
  }
  html_print("<li class=\"endSymbolTable\">&nbsp;</li>" NL "</ul></li>" NL);
  end_block("Symbol table", true);
}

References begin_block(), end_block(), entity_domain, FOREACH, gen_filter_tabulated(), gen_true(), html_print, html_print_entity_full(), and NL.

Referenced by html_prettyprint().

Here is the call graph for this function:

Here is the caller graph for this function:

html_print_test()

static void html_print_test ( test  t )

static

Definition at line 723 of file html_prettyprinter.c.

                                    {
  begin_block("test", true);
 
  begin_block("cond", true);
  html_print_expression(test_condition( t ), false);
  end_block("cond", true);
 
  begin_block("strue", false);
  html_print_statement(test_true( t ));
  end_block("strue", false);
 
  if(!empty_statement_p(test_false( t ))) {
    begin_block("sfalse", false);
    html_print_statement(test_false(t));
    end_block("sfalse", false);
  }
 
  end_block("test", true);
}

References begin_block(), empty_statement_p(), end_block(), html_print_expression(), html_print_statement(), test_condition, test_false, and test_true.

Referenced by html_print_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

html_print_type()

static void html_print_type ( type  t )

static

Definition at line 381 of file html_prettyprinter.c.

                                    {
  begin_block("type", true);
  if(t == type_undefined) {
    html_output("*undefined*", true);
  } else {
    switch(type_tag( t )) {
      case is_type_statement:
        html_output("Statement (unit ?) ", true);
        break;
      case is_type_area:
        html_print_area(type_area( t ));
        break;
      case is_type_variable:
        html_print_variable(type_variable( t ));
        break;
      case is_type_functional:
        html_print_functional(type_functional( t ));
        break;
      case is_type_varargs:
        html_output("VarArgs", true);
        html_print_type(type_varargs( t ));
        break;
      case is_type_unknown:
        html_output("Unknown", true);
        break;
      case is_type_void:
        html_output("Void", true);
        break;
      case is_type_struct:
        begin_block("Struct", true);
        FOREACH(entity, e, type_struct( t ) )
        {
          begin_block("field", true);
          html_print_entity_name(e);
          end_block("field", true);
        }
        end_block("Struct", true);
        break;
      case is_type_union:
        html_output("Union", true);
        FOREACH(entity, e, type_union( t ) )
        {
          html_print_entity_name(e);
        }
        break;
      case is_type_enum:
        html_output("Enum", true);
        FOREACH(entity, e, type_enum( t ) )
        {
          html_print_entity_name(e);
        }
        break;
      default:
        break;
    }
  }
  end_block("type", true);
}

References begin_block(), end_block(), FOREACH, html_output(), html_print_area(), html_print_entity_name(), html_print_functional(), html_print_variable(), is_type_area, is_type_enum, is_type_functional, is_type_statement, is_type_struct, is_type_union, is_type_unknown, is_type_varargs, is_type_variable, is_type_void, type_area, type_enum, type_functional, type_struct, type_tag, type_undefined, type_union, type_varargs, and type_variable.

Referenced by html_print_basic(), html_print_entity_full(), html_print_functional(), and html_print_parameter().

Here is the call graph for this function:

Here is the caller graph for this function:

html_print_unstructured()

static void html_print_unstructured ( _UNUSED_ unstructured  u )

static

Definition at line 552 of file html_prettyprinter.c.

                                                             {
  begin_block("unstructured", false);
  html_output("Not implemented", false);
  end_block("unstructured", false);
}

References begin_block(), end_block(), and html_output().

Referenced by html_print_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

html_print_value()

static void html_print_value ( value  v )

static

Definition at line 487 of file html_prettyprinter.c.

                                      {
  begin_block("value", false);
  if(!v || v == value_undefined) {
    html_output("undefined", false);
  } else {
    switch(value_tag( v )) {
      case is_value_code:
        html_print_code(value_code(v));
        break;
      case is_value_symbolic:
        html_output("symbolic", false);
        break;
      case is_value_constant:
        html_print_constant(value_constant(v));
        break;
      case is_value_intrinsic:
        html_output("intrinsic", false);
        break;
      case is_value_unknown:
        html_output("unknown", false);
        break;
      case is_value_expression:
        begin_block("expression", false);
        html_print_expression(value_expression( v ), false);
        end_block("expression", false);
        break;
      default:
        html_output("error", false);
        break;
    }
  }
  end_block("value", false);
}

References begin_block(), end_block(), html_output(), html_print_code(), html_print_constant(), html_print_expression(), is_value_code, is_value_constant, is_value_expression, is_value_intrinsic, is_value_symbolic, is_value_unknown, value_code, value_constant, value_expression, value_tag, and value_undefined.

Referenced by html_print_basic(), and html_print_entity_full().

Here is the call graph for this function:

Here is the caller graph for this function:

html_print_variable()

static void html_print_variable ( variable  v )

static

Definition at line 326 of file html_prettyprinter.c.

                                            {
  begin_block("variable", true);
 
  html_print_basic(variable_basic( v ));
  FOREACH(dimension, d, variable_dimensions( v ) ) {
    html_print_dimension(d);
  }
  FOREACH(qualifier, q, variable_qualifiers( v ) ) {
    html_print_qualifier(q);
  }
 
  end_block("variable", true);
}

References begin_block(), end_block(), FOREACH, html_print_basic(), html_print_dimension(), html_print_qualifier(), variable_basic, variable_dimensions, and variable_qualifiers.

Referenced by html_print_type().

Here is the call graph for this function:

Here is the caller graph for this function:

html_print_whileloop()

static void html_print_whileloop ( whileloop  w )

static

partial implementation... ??

o while and while do loops

Definition at line 662 of file html_prettyprinter.c.

                                              {
  /* partial implementation...  ?? */
 
  begin_block("whileloop", true);
 
  begin_block("condition", false);
  html_print_expression(whileloop_condition( w ), false);
  end_block("condition", false);
 
  begin_block("statement", false);
  html_print_statement(whileloop_body( w ));
  end_block("statement", false);
 
  begin_block("evaluation", false);
  evaluation eval = whileloop_evaluation(w);
  /*do while and while do loops */
  if(evaluation_before_p(eval))
    html_output("while() {}" NL, false);
  else
    html_output("do {} while(); " NL, false);
  end_block("evaluation", false);
 
  begin_block("body", false);
  html_print_statement(whileloop_body( w ));
  end_block("body", false);
 
  end_block("whileloop", true);
}

References begin_block(), end_block(), eval(), evaluation_before_p, html_output(), html_print_expression(), html_print_statement(), NL, whileloop_body, whileloop_condition, and whileloop_evaluation.

Referenced by html_print_statement().

Here is the call graph for this function:

Here is the caller graph for this function:

html_set_output()

static void html_set_output ( FILE *  new_fp )

static

Definition at line 72 of file html_prettyprinter.c.

                                          {
  out_fp = new_fp;
}

References out_fp.

Referenced by html_prettyprint(), and html_prettyprint_symbol_table().

Here is the caller graph for this function:

Variable Documentation

out_fp

FILE* out_fp = 0

static

Definition at line 69 of file html_prettyprinter.c.

Referenced by html_set_output().