25 #include "pips_config.h"
64 #define SEMICOLON ";" NL
67 #define OPENBRACKET "["
68 #define CLOSEBRACKET "]"
71 #define CLOSEPAREN ")"
74 #define CLOSEBRACE "}"
76 #define SHARPDEF "#define"
77 #define COMMENT "//" SPACE
80 #define INDENT "indent"
81 #define CROUGH ".crough"
83 #define INTERFACE "_interface.f08"
86 #define SCALAR_IN_SIG_EXT "_p4a_copy"
89 #define MAX_FCT "crough_max"
90 #define MIN_FCT "crough_min"
91 #define MAX_DEF "#define " MAX_FCT "(a,b) (((a)>(b))?(a):(b))\n"
92 #define MIN_DEF "#define " MIN_FCT "(a,b) (((a)<(b))?(a):(b))\n"
93 #define POW_PRE "crough_"
94 #define POW_DEF "#define " POW_PRE "powi(a,b) ((a)^(b))\n"
95 #define CMPLX_FCT "init_complex"
96 #define CMPLX_DEF "#define " CMPLX_FCT "(a,b) (a + b*I)\n"
112 #define current_module_is_a_function() \
113 (entity_function_p(get_current_module_entity()))
116 #define RESULT_NAME "result"
127 pips_debug (5,
"test if str : %s is a double value. %c 0 = \n", *str,
'0');
128 for (i = 0; ((*str)[i] !=
'\0') && (result ==
true); i++) {
129 bool cond = ((*str)[i] ==
'D') && (
match == 0);
134 result &= (((*str)[i] >=
'0') && ((*str)[i] <=
'9')) || ((*str)[i] ==
'.') || (cond);
136 pips_debug (5,
"end with i = %d, match = %d result = %s\n",
137 i,
match, (result)?
"true":
"false");
138 result &= ((*str)[i] ==
'\0') && (
match + 1 != i) && (
match != 0);
139 if (result ==
true) {
151 static char * const_to_c[][2] = { {
".true." ,
"1" } , {
".false." ,
"0" }};
152 static const int const_to_c_sz =
sizeof(const_to_c)/
sizeof(*const_to_c);
154 pips_debug (5,
"constant to convert : %s\n", *s);
158 for(i=0;i<const_to_c_sz;i++)
160 if(strcmp(name,const_to_c[i][0]) == 0 )
163 *s =
strdup(const_to_c[i][1]);
169 pips_debug (5,
"constant converted : %s\n", *s);
206 pips_debug (5,
"local name %s found\n", rname);
232 string result = NULL;
233 string previous = NULL;
239 (
string)
gen_car (n),
" = ",
"*",
240 (
string)
gen_car (r),
";\n", previous,
242 if (previous != NULL)
free (previous);
245 return (result == NULL) ?
strdup(
"") : result;
249 string result = NULL;
250 string previous = NULL;
258 (
string)
gen_car (n),
";\n", previous, NULL));
259 if (previous != NULL)
free (previous);
265 pips_debug (5,
"entity %s (%p) not restored\n",
270 return (result == NULL) ?
strdup(
"") : result;
309 string result =
"UNKNOWN_TYPE" SPACE;
320 result =
"void" SPACE;
325 result =
"struct" SPACE;
330 result =
"union" SPACE;
335 result =
"enum" SPACE;
347 const char* result =
"UNKNOWN_BASIC" SPACE;
353 if (user_type ==
false) {
355 case 1: result =
"char" SPACE;
357 case 2: result =
"short" SPACE;
359 case 4: result =
"int" SPACE;
361 case 6: result =
"long" SPACE;
363 case 8: result =
"long long" SPACE;
365 case 11: result =
"unsigned char" SPACE;
367 case 12: result =
"unsigned short" SPACE;
369 case 14: result =
"unsigned int" SPACE;
371 case 16: result =
"unsigned long" SPACE;
373 case 18: result =
"unsigned long long" SPACE;
375 case 21: result =
"signed char" SPACE;
377 case 22: result =
"signed short" SPACE;
379 case 24: result =
"signed int" SPACE;
381 case 26: result =
"signed long" SPACE;
383 case 28: result =
"signed long long" SPACE;
392 if (user_type ==
false) {
394 case 4: result =
"float" SPACE;
396 case 8: result =
"double" SPACE;
405 result =
"int" SPACE;
408 result =
"char" SPACE;
415 result =
"int" SPACE;
441 result =
"complex" SPACE;
446 return aresult ? aresult :
strdup(result);
491 if (fct_sig ==
true) {
580 string result = NULL;
618 asprintf(&result,
"static const %s %s = %s\n",sbasic,svar,sval);
645 string sptr, st, sd, svar, sq, ext;
708 "Bitfield to be finished...");
768 return result? result:
strdup(
"");
807 bool (*consider_this_entity)(
entity),
813 string result =
strdup(
"");
824 pips_debug(2,
"Prettyprinter declaration for variable :%s\n",tmp);
826 if (consider_this_entity(var))
841 if (lastsep && !first)
847 string result = NULL;
851 "#include \"math.h\"\n",
852 "#include \"stdlib.h\"\n",
853 "#include \"complex.h\"\n",
859 pips_debug (5,
"including the user file list %s\n", user_req);
861 string tmp =
strdup(user_req);
862 match = strtok (tmp,
" ,");
863 while (
match != NULL) {
867 match = strtok (NULL,
" ,");
874 pips_debug (5,
"includind the user define type file %s\n", user_req);
875 if (user_type ==
true) {
878 pips_debug (7,
"including the file %s\n", f_name);
883 pips_debug (5,
"include string : %s\n", result);
889 string result = NULL;
891 result =
strdup (
concatenate (
"// The macros to support some fortran intrinsics\n",
892 "// and complex declaration\n"
903 #define MAIN_DECLARATION "int main(int argc, char *argv[])" NL
916 string head, args, svar;
1096 pips_debug (7,
"find the C function for \"%s\" according to the basic\n",
1108 (table->
size == size)))
1126 pips_debug (7,
"let's analyse the expression to find the involved types\n");
1130 pips_assert (
"expression_to_type returns a basic undefined",
1136 basic old = res_basic;
1139 pips_assert (
"expression_to_type returns a basic undefined",
1144 string str_copy =
strdup (in_c);
1146 string result =
ppt_call (str_copy, le);
1163 pointer)?
"&" :
"", arg, NULL));
1169 string old = result;
1178 pips_assert (
"min and max should have at least 2 arguments", flag ==
true);
1188 pips_user_error (
"This intrinsic can not be tranbslated in c: %s\n", in_f);
1189 string result =
ppt_call (in_f, le);
1198 string result =
strdup (
"");
1199 pips_user_error(
"This intrinsic should not be found in a fortran code: %s\n",
1398 #define RET "return"
1399 #define CONT "continue"
1406 string result = NULL;
1432 string tmp = result;
1488 string result = NULL;
1496 result =
strdup(
"range not implemented");
1519 printf(
"Print trail: \n");
1523 for(cc=trail; !
ENDP(cc);
POP(cc))
1531 printf(
"Processing statement:\n");
1556 pips_assert(
"The successor is not a check io statement",
1585 bool no_endif =
false;
1591 printf(
"Result = %s\n",result);
1602 printf(
"This may happen after restructuring\n");
1608 printf(
"succ2 must be reached by GOTO\n");
1612 printf(
"str = %s\n",str);
1620 printf(
"succ1 must be reached by GOTO\n");
1628 printf(
"Both successors must be labelled\n");
1635 printf(
"str = %s\n",str);
1642 printf(
"Both successors must be textual predecessors \n");
1649 printf(
"str = %s\n",str);
1656 printf(
"Result = %s\n",result);
1658 printf(
"Result before = %s\n",result);
1661 printf(
"str before = %s\n",str);
1664 printf(
"Result after = %s\n",result);
1680 string cond, strue, sfalse;
1689 no_false?
"}" NL:
"} else {" NL,
1690 sfalse,
"}" NL, NULL));
1693 if (sfalse)
free(sfalse);
1702 string oldresult = result;
1723 if( strcmp(theincr,
"1")==0 )
1730 index,
"<=", up,
"; ",
1753 body,
"}" NL, NULL));
1756 body,
"}" NL,
"while (", cond,
");" NL, NULL));
1771 body,
"}" NL, NULL));
1793 result =
c_test(t,breakable);
1853 debug(2,
"\n In block declaration for variable :", tmp);
1873 const char* result =
"UNKNOWN_BASIC" SPACE;
1874 char * aresult=NULL;
1879 if (user_type ==
false) {
1886 result =
"integer (c_int)";
1891 result =
"integer (c_size_t)";
1923 if (user_type ==
false) {
1925 case 4: result =
"real (c_float)";
1927 case 8: result =
"real (c_double)";
1936 result =
"integer (c_int)";
1939 result =
"character (c_char)";
1946 if (
value ==
true) {
1954 result =
"type (c_ptr)";
1966 if (
value ==
true) {
1967 if(!aresult)aresult=
strdup(result);
1968 char * tmp =aresult;
1989 result =
strdup (
"type (c_ptr)");
2005 string result = NULL;
2009 result =
strdup (
"type (c_ptr), value");
2025 string args =
strdup (
"");
2026 string result = NULL;
2055 string args =
strdup (
"(");
2056 string result = NULL;
2081 string decls = NULL;
2082 string result = NULL;
2083 string signature = NULL;
2085 pips_assert(
"only available for subroutines, to be implemented for functions",
2094 "\t\tsubroutine ", name, signature,
2095 " bind(C, name = \"", name,
"\")\n",
2096 "\t\t\tuse iso_c_binding\n", decls,
2097 "\t\tend subroutine ", name,
2098 "\n\tend interface\n",
2099 "end module ", name,
"_interface\n",
2110 string head, decls, body, result, copy_in,
include, macro;
2119 printf(
"Module statement: \n");
2121 printf(
"and declarations: \n");
2154 string interface_code, interface, dir, filename;
2187 free (interface_code);
2197 string ppt, crough, dir, filename;
2200 list l_effect = NULL;
2214 debug_on(
"CPRETTYPRINTER_DEBUG_LEVEL");
2264 string crough, cpretty, dir, cmd;
2271 dir,
"/", crough,
" -st > ",
2272 dir,
"/", cpretty, NULL));
list gen_entity_cons(entity p, list l)
basic copy_basic(basic p)
BASIC.
expression copy_expression(expression p)
EXPRESSION.
void free_expression(expression p)
struct _newgen_struct_type_ * type
struct _newgen_struct_statement_ * statement
static bool variable_p(entity e)
static struct s_ppt * get_ppt(entity f)
return the prettyprinter structure for c.
static string scalar_prelude()
static bool argument_p(entity e)
static string c_call(call c, bool breakable)
static string c_type_string(type t)
static string interface_type_string(type t, bool value)
static string ppt_unary(const char *in_c, list le)
static void build_written_list(list l)
static string c_whileloop(whileloop w)
static string this_entity_cdeclaration(entity var, bool fct_sig)
static string interface_basic_string(basic b, bool value)
Convert the fortran basic to its interface string value.
static string ppt_unknown(const char *in_f, list le)
static string ppt_must_error(const char *in_f, _UNUSED_ list le)
static void const_wrapper(char **s)
static string c_declarations(entity module, bool(*consider_this_entity)(entity), string separator, bool lastsep, bool fct_sig)
static string c_unstructured(unstructured u, bool breakable)
static string c_statement(statement s, bool breakable)
static string c_sequence(sequence seq, bool breakable)
static c_full_name c_base_name_to_c_full_name[]
static string c_include(void)
static string c_head(entity module)
static string c_expression(expression, bool)
forward declaration.
static string c_qualifier_string(list l)
static string c_macro(void)
static string ppt_binary(const char *in_c, list le)
static bool expression_needs_parenthesis_p(expression)
static char * c_entity_local_name(entity var)
bool print_interface(const char *module_name)
cprettyprinter.c
static void get_c_full_name(string *base_in_c, basic b)
fill the c_base_name to get the c full name accorgind to its basic
#define SCALAR_IN_SIG_EXT
bool print_c_code(const char *module_name)
C indentation thru indent.
static bool scalar_by_pointer(entity var)
we want to decide if a scalar variable need to be passed by pointer or by value to a C function.
static string ppt_unary_post(const char *in_c, list le)
static string interface_code_string(entity module, _UNUSED_ statement stat)
static bool parameter_or_variable_p(entity e)
static string scalar_postlude()
static struct s_ppt intrinsic_to_c[]
#define current_module_is_a_function()
static string interface_argument_type_string(entity var)
return a string representation of the type to be used for a variable decalaration in an interface mod...
static string interface_signature(entity module)
return the interface signature for a module, i.e.
bool print_crough(const char *module_name)
static string ppt_min_max(const char *in_c, list le)
static string c_code_string(entity module, statement stat)
static string ppt_math(const char *in_c, list le)
static string c_reference(reference r)
Attention with Fortran: the indexes are reversed.
static string c_loop(loop l)
static string c_basic_string(basic b)
static bool parameter_p(entity e)
static string ppt_call(const char *in_c, list le)
SG: PBM spotted HERE.
#define MAIN_DECLARATION
returns the head of the function/subroutine/program.
static string c_test(test t, bool breakable)
static string c_forloop(forloop f)
static bool written_p(entity e)
static string interface_argument_declaration(entity module, string separator, string indent)
static string c_brace_expression_string(expression exp)
static bool convert_double_value(char **str)
test if the string looks like a REAL*8 (double in C) declaration i.e something like 987987D54654 : a ...
string(* prettyprinter)(const char *, list)
generate a basic c expression.
static string c_dim_string(list ldim, bool fct_sig)
static text include(const char *file)
if the common is declared similarly in all routines, generate "include 'COMMON.h'",...
#define effect_write_p(eff)
#define effect_any_entity(e)
some useful SHORTHANDS for EFFECT:
list effects_to_list(effects)
const char * local_name(const char *s)
Does not take care of block scopes and returns a pointer.
const char * module_name(const char *s)
Return the module part of an entity name.
FILE * safe_fopen(const char *filename, const char *what)
char * get_string_property(const char *)
int safe_fclose(FILE *stream, const char *filename)
bool get_bool_property(const string)
FC 2015-07-20: yuk, moved out to prevent an include cycle dependency include "properties....
#define call_constant_p(C)
void reset_current_module_entity(void)
Reset the current module entity.
void reset_current_module_statement(void)
Reset the current module statement.
statement set_current_module_statement(statement)
Set the current module statement.
entity set_current_module_entity(entity)
static.c
entity get_current_module_entity(void)
Get the entity of the current module.
#define ENDP(l)
Test if a list is empty.
list gen_nreverse(list cp)
reverse a list in place
#define POP(l)
Modify a list pointer to point on the next element of the list.
#define NIL
The empty list (nil in Lisp)
size_t gen_length(const list l)
void gen_free_string_list(list ls)
#define CAR(pcons)
Get the value of the first element of a list.
void gen_free_list(list l)
free the spine of the list
bool gen_in_list_p(const void *vo, const list lx)
tell whether vo belongs to lx
#define FOREACH(_fe_CASTER, _fe_item, _fe_list)
Apply/map an instruction block on all the elements of a list.
#define CDR(pcons)
Get the list less its first element.
list gen_string_cons(string s, const list l)
#define MAP(_map_CASTER, _map_item, _map_code, _map_list)
Apply/map an instruction block on all the elements of a list (old fashioned)
string db_get_memory_resource(const char *rname, const char *oname, bool pure)
Return the pointer to the resource, whatever it is.
#define DB_PUT_FILE_RESOURCE
Put a file resource into the current workspace database.
bool check_io_statement_p(statement)
bool empty_statement_p(statement)
Test if a statement is empty.
bool statement_does_return(statement)
Returns false is no syntactic control path exits s (i.e.
static Value eval(Pvecteur pv, Value val, Variable var)
enum language_utype get_prettyprint_language_tag()
void set_prettyprint_language_tag(enum language_utype lang)
set the prettyprint language from a language_utype argument
string db_build_file_resource_name(const char *rname, const char *oname, const char *suffix)
returns an allocated file name for a file resource.
#define pips_debug
these macros use the GNU extensions that allow variadic macros, including with an empty list.
#define pips_user_warning
#define pips_assert(what, predicate)
common macros, two flavors depending on NDEBUG
#define pips_internal_error
#define user_error(fn,...)
void debug(const int the_expected_debug_level, const char *calling_function_name, const char *a_message_format,...)
ARARGS0.
void safe_system(string)
system.c
#define MEMBER_SEP_STRING
void str_append(string *, string)
Append the suffix to the string.
string strlower(string, const char *)
void str_prepend(string *, string)
Prepend the prefix to the string.
string concatenate(const char *,...)
Return the concatenation of the given strings.
#define same_string_p(s1, s2)
int f(int off1, int off2, int n, float r[n], float a[n], float b[n])
string db_get_current_workspace_directory(void)
string expression_to_string(expression e)
string basic_to_string(basic)
void print_statement(statement)
Print a statement on stderr.
list unstructured_to_trail(unstructured)
#define NINT_CONVERSION_NAME
#define ATAN2_OPERATOR_NAME
#define DREAL_GENERIC_CONVERSION_NAME
#define MAX_OPERATOR_NAME
#define POWER_OPERATOR_NAME
#define LLE_OPERATOR_NAME
#define CABS_OPERATOR_NAME
#define CEXP_OPERATOR_NAME
#define PRINT_FUNCTION_NAME
#define IDNINT_CONVERSION_NAME
#define FLOAT_GENERIC_CONVERSION_NAME
#define TANH_OPERATOR_NAME
#define COS_OPERATOR_NAME
#define CDABS_OPERATOR_NAME
#define DSIGN_OPERATOR_NAME
#define READ_FUNCTION_NAME
#define ENDFILE_FUNCTION_NAME
#define SIGN_OPERATOR_NAME
#define DMIN1_OPERATOR_NAME
#define ABS_OPERATOR_NAME
#define DBLE_GENERIC_CONVERSION_NAME
#define DACOS_OPERATOR_NAME
#define COSH_OPERATOR_NAME
#define BUFFERIN_FUNCTION_NAME
#define DSQRT_OPERATOR_NAME
#define MINUS_OPERATOR_NAME
#define IDIM_OPERATOR_NAME
#define AINT_CONVERSION_NAME
#define DCMPLX_GENERIC_CONVERSION_NAME
#define DNINT_CONVERSION_NAME
#define CLOG_OPERATOR_NAME
#define DINT_CONVERSION_NAME
#define IABS_OPERATOR_NAME
#define LOG10_OPERATOR_NAME
#define LENGTH_OPERATOR_NAME
#define DCOSH_OPERATOR_NAME
#define DIM_OPERATOR_NAME
#define DIMAG_CONVERSION_NAME
#define SIN_OPERATOR_NAME
#define DLOG10_OPERATOR_NAME
#define DCONJG_OPERATOR_NAME
#define MAX0_OPERATOR_NAME
#define AMIN0_OPERATOR_NAME
#define BACKSPACE_FUNCTION_NAME
#define MIN0_OPERATOR_NAME
#define MAX1_OPERATOR_NAME
#define CONJG_OPERATOR_NAME
#define AMAX0_OPERATOR_NAME
#define expression_scalar_p(e)
#define REWIND_FUNCTION_NAME
#define DMAX1_OPERATOR_NAME
#define CDSQRT_OPERATOR_NAME
#define IFIX_GENERIC_CONVERSION_NAME
#define ACOS_OPERATOR_NAME
#define OPEN_FUNCTION_NAME
#define CDCOS_OPERATOR_NAME
#define CDLOG_OPERATOR_NAME
#define ALOG10_OPERATOR_NAME
#define LLT_OPERATOR_NAME
#define BUFFEROUT_FUNCTION_NAME
#define CCOS_OPERATOR_NAME
#define DPROD_OPERATOR_NAME
#define CDSIN_OPERATOR_NAME
#define ANINT_CONVERSION_NAME
#define INT_TO_CHAR_CONVERSION_NAME
#define CMPLX_GENERIC_CONVERSION_NAME
#define CHAR_TO_INT_CONVERSION_NAME
#define SQRT_OPERATOR_NAME
#define ATAN_OPERATOR_NAME
#define ISIGN_OPERATOR_NAME
#define INT_GENERIC_CONVERSION_NAME
generic conversion names.
#define LGE_OPERATOR_NAME
#define IMPLIED_DCOMPLEX_NAME
#define WRITE_FUNCTION_NAME
#define DABS_OPERATOR_NAME
#define CLOSE_FUNCTION_NAME
#define AMIN1_OPERATOR_NAME
#define DCOS_OPERATOR_NAME
#define EXP_OPERATOR_NAME
#define LOG_OPERATOR_NAME
#define DSIN_OPERATOR_NAME
#define CSQRT_OPERATOR_NAME
#define TAN_OPERATOR_NAME
#define DSINH_OPERATOR_NAME
#define AIMAG_CONVERSION_NAME
#define INDEX_OPERATOR_NAME
#define CDEXP_OPERATOR_NAME
#define FORMAT_FUNCTION_NAME
#define DATAN2_OPERATOR_NAME
#define DDIM_OPERATOR_NAME
#define SINH_OPERATOR_NAME
#define REAL_GENERIC_CONVERSION_NAME
#define MINUS_C_OPERATOR_NAME
#define DEXP_OPERATOR_NAME
#define DLOG_OPERATOR_NAME
#define C_OR_OPERATOR_NAME
#define CSIN_OPERATOR_NAME
#define SNGL_GENERIC_CONVERSION_NAME
#define DTANH_OPERATOR_NAME
#define DFLOAT_GENERIC_CONVERSION_NAME
#define ASIN_OPERATOR_NAME
#define AMAX1_OPERATOR_NAME
#define DASIN_OPERATOR_NAME
#define INQUIRE_FUNCTION_NAME
#define IDINT_GENERIC_CONVERSION_NAME
#define IMPLIED_COMPLEX_NAME
#define LGT_OPERATOR_NAME
#define MIN1_OPERATOR_NAME
#define DATAN_OPERATOR_NAME
#define DTAN_OPERATOR_NAME
#define MODULO_OPERATOR_NAME
#define PLUS_C_OPERATOR_NAME
#define ALOG_OPERATOR_NAME
#define MIN_OPERATOR_NAME
const char * entity_local_name(entity e)
entity_local_name modified so that it does not core when used in vect_fprint, since someone thought t...
bool entity_subroutine_p(entity e)
entity module_name_to_entity(const char *mn)
This is an alias for local_name_to_top_level_entity.
bool entity_main_module_p(entity e)
bool typedef_entity_p(entity e)
basic entity_basic(entity e)
return the basic associated to entity e if it's a function/variable/constant basic_undefined otherwis...
static int init
Maximal value set for Fortran 77.
void print_entities(list l)
entity CreateIntrinsic(string name)
this function does not create an intrinsic function because they must all be created beforehand by th...
entity entity_intrinsic(const char *name)
FI: I do not understand this function name (see next one!).
const char * label_local_name(entity e)
END_EOLE.
bool expression_integer_value(expression e, intptr_t *pval)
expression MakeBinaryCall(entity f, expression eg, expression ed)
Creates a call expression to a function with 2 arguments.
expression int_to_expression(_int i)
transform an int into an expression and generate the corresponding entity if necessary; it is not cle...
bool brace_expression_p(expression e)
Return bool indicating if expression e is a brace expression.
bool expression_equal_integer_p(expression exp, int i)
================================================================
int basic_type_size(basic)
See also SizeOfElements()
type expression_to_type(expression)
For an array declared as int a[10][20], the type returned for a[i] is int [20].
basic basic_maximum(basic, basic)
#define type_functional_p(x)
#define value_undefined_p(x)
#define functional_result(x)
#define storage_formal_p(x)
#define value_constant(x)
#define syntax_reference(x)
#define forloop_initialization(x)
#define QUALIFIER(x)
QUALIFIER.
#define reference_variable(x)
#define forloop_increment(x)
#define symbolic_constant(x)
#define instruction_loop(x)
#define type_functional(x)
#define instruction_goto(x)
#define dimension_lower(x)
#define whileloop_evaluation(x)
#define entity_storage(x)
#define code_declarations(x)
#define CONTROL(x)
CONTROL.
#define range_increment(x)
#define value_constant_p(x)
#define basic_overloaded_p(x)
#define value_symbolic(x)
#define EXPRESSION(x)
EXPRESSION.
#define statement_label(x)
#define constant_int_p(x)
@ is_instruction_unstructured
@ is_instruction_whileloop
@ is_instruction_sequence
#define instruction_tag(x)
#define value_symbolic_p(x)
#define functional_parameters(x)
#define sequence_statements(x)
#define dimension_upper(x)
#define reference_indices(x)
#define instruction_sequence(x)
#define instruction_forloop(x)
#define control_successors(x)
#define variable_qualifiers(x)
#define test_condition(x)
#define instruction_whileloop(x)
#define variable_dimensions(x)
#define whileloop_body(x)
#define statement_declarations(x)
#define statement_instruction(x)
#define instruction_call(x)
#define forloop_condition(x)
#define instruction_test_p(x)
#define call_arguments(x)
#define control_statement(x)
@ is_qualifier_static_dimension
#define instruction_test(x)
#define whileloop_condition(x)
#define value_expression_p(x)
#define expression_syntax(x)
#define storage_return_p(x)
#define evaluation_before_p(x)
#define type_variable_p(x)
#define value_expression(x)
#define instruction_unstructured(x)
#define variable_basic(x)
#define STATEMENT(x)
STATEMENT.
#define entity_initial(x)
struct _newgen_struct_match_ * match
int fprintf()
test sc_min : ce test s'appelle par : programme fichier1.data fichier2.data ...
The structure used to build lists in NewGen.
struct cons * cdr
The pointer to the next element.
#define exp
Avoid some warnings from "gcc -Wshadow".