6 #ifndef syntax_header_included
7 #define syntax_header_included
38 #define START_COMMENT_LINE "CcDd*!#\n"
49 #include "constants.h"
51 #define HASH_SIZE 1013
52 #define FORMATLENGTH (4096)
56 #define abs(v) (((v) < 0) ? -(v) : (v))
61 #define Warning(f,m) \
62 (user_warning(f,"Warning between lines %d and %d\n%s\n",line_b_I,line_e_I,m) )
64 #define FatalError(f,m) \
65 (pips_internal_error("Fatal error between lines %d and %d\n%s\n",line_b_I,line_e_I,m))
155 extern char lab_I[6];
162 extern bool ParserError(
const char *,
const char *);
165 extern bool parser(
const string );
The structure used to build lists in NewGen.
void UpdateFunctionalType(entity, list)
This function analyzes the CurrentFunction formal parameter list to determine the CurrentFunction fun...
void EndOfProcedure(void)
This function is called when the parsing of a procedure is completed.
bool entity_in_equivalence_chains_p(entity)
bool update_common_layout(entity, entity)
(Re)compute offests of all variables allocated in common c from module m and update (if necessary) th...
void DeclareVariable(entity, type, list, storage, value)
void DeclareVariable(e, t, d, s, v): update entity e description as declaration statements are encoun...
int get_current_number_of_alternate_returns(void)
instruction MakeZeroOrOneArgCallInst(char *, expression)
this function creates a simple Fortran statement such as RETURN, CONTINUE, ...
void set_current_label_string(string)
statement make_check_io_statement(string, expression, entity)
Generate a test to jump to l if flag f is TRUE Used to implement control effects of IO's due to ERR= ...
bool entity_in_equivalence_chain_p(entity, chain)
expression fix_if_condition(expression)
instruction MakeIoInstA(int, list, list)
this function creates an IO statement.
bool hpfc_parser(const string)
parser for HPFC.
entity MakeParameter(entity, expression)
lint
list FortranExpressionList(list)
Make sure that no call to implied do is in l.
int CapitalizeStmt(char[], int)
void update_functional_type_result(entity, type)
Update of the type returned by function f.
entity LocalToGlobal(entity)
int OffsetOfReference(reference)
This function computes the numerical offset of a variable element from the begining of the variable.
void parser_close_macros_support(void)
void DeclareIntrinsic(entity)
Intrinsic e is used in the current module.
cons * FormalParameters
the current function
void MakeCurrentFunction(type, int, const char *, list)
this function creates one entity cf that represents the Fortran function f being analyzed.
void retype_formal_parameters(void)
If an IMPLICIT statement is encountered, it must be applied to the formal parameters,...
entity NameToCommon(string)
entity DynamicArea
These global variables are declared in ri-util/util.c.
bool IsBlockStackFull(void)
bool ghost_variable_entity_p(entity)
expression MakeFortranBinaryCall(entity, expression, expression)
bool InParserError
Parser error handling.
type MakeResultType(entity, type)
The result type of a function may be carried by e, by r or be implicit.
void StoreEquivChain(chain)
This function is called when an equivalence chain has been completely parsed.
void UpdateFormalStorages(entity, list)
this function check and set if necessary the storage of formal parameters in lfp.
void CheckParenthesis(void)
void substitute_ghost_variable_in_statement(statement, entity, entity)
void SaveCommon(entity)
this function transforms a dynamic common into a static one.
void print_malloc_info(FILE *)
malloc-info.c
void ComputeEquivalences(void)
This function merges all the equivalence chains to take into account equivalences due to transitivity...
void uses_alternate_return(bool)
void ResetReturnCodeVariable(void)
expression MakeImpliedDo(syntax, range, cons *)
expressions from input output lists might contain implied do loops.
bool IsEffectiveFormalParameterP(entity)
void AddEntryTarget(statement)
bool parser_entity_macro_p(entity)
size_t common_to_size(entity)
void update_user_common_layouts(entity)
Check...
void parser_substitute_all_macros(statement)
void reify_ghost_variable_entity(entity)
It is possible to change one's mind and effectively use an entity which was previously assumed useles...
instruction MakeSimpleIoInst1(int, expression unit)
int get_statement_number(void)
eturn the line number of the statement being parsed
intptr_t CurrentTypeSize
the type in a type or dimension or common statement
void ResetChains(void)
undefine chains between two successives calls to parser
int line_b_I
Indicates where the current instruction (in fact statement) starts and ends in the input file and giv...
void AddEntryLabel(entity)
int SizeOfRange(range)
This function computes the size of a range, ie.
instruction MakeLogicalIfInst(expression, instruction)
this function creates a logical if statement.
void initialize_common_size_map(void)
entity MakeExternalFunction(entity, type)
void update_common_to_size(entity, size_t)
int CurrentOffsetOfArea(entity, entity)
void AddEntryEntity(entity)
void check_in_declarations(void)
void reset_first_statement(void)
bool ParserError(const char *, const char *)
void reset_substitute_expression_in_expression(void)
void check_first_statement(void)
This function is called each time an executable statement is encountered but is effective the first t...
void update_common_sizes(void)
bool IsBlockStackEmpty(void)
bool implicit_type_p(entity)
This function checks that entity e has an undefined or an implicit type which can be superseded by an...
instruction MakeAssignInst(syntax, expression)
this function creates an affectation statement.
void remove_module_entity(entity)
entity DeclareExternalFunction(entity)
void add_alternate_return(string)
void CheckAndInitializeStmt(void)
this function looks for undefined labels.
void set_common_to_size(entity, size_t)
void parser_init_macros_support(void)
macros.c
int GetChar(FILE *)
Routine de lecture physique.
void GenerateReturn(void)
Generate a unique call to RETURN per module.
void parser_reset_StmtHeap_buffer(void)
statement.c
void MakeBlockIfInst(expression, int)
this function and the two next ones create a block if statement.
bool first_executable_statement_seen(void)
list add_formal_return_code(list)
Update the formal and actual parameter lists by adding the return code variable as last argument.
void PrintData(cons *, cons *)
a debugging function, just in case ...
int SafeSizeOfArray(entity)
cproto-generated files
bool empty_current_label_string_p(void)
void parser_reset_all_reader_buffers(void)
instruction MakeEmptyInstructionBlock(void)
this function creates an empty block
list get_alternate_returns(void)
bool common_to_defined_size_p(entity)
void NewStmt(entity, statement)
this function stores a new association in table StmtHeap: the label of statement s is e.
instruction MakeAssignedGotoInst(list, entity)
void InitImplicit(void)
this function initializes the data structure used to compute implicit types
void BeginingOfParsing(void)
this function is called for each new file (FI: once?) FI: I do not understand how this works.
void remove_from_called_modules(entity)
macros are added, although they should not have been.
bool uses_alternate_return_p(void)
entity SafeLocalToGlobal(entity, type)
A local entity might have been created but found out later to be global, depending on the order of de...
void MakeWhileDoInst(expression, string)
This function creates a while do loop statement.
type MakeFortranType(tag, value)
this function creates a type that represents a fortran type.
void set_current_number_of_alternate_returns(void)
void SetChains(void)
initialize chains before each call to the parser
void PrintChains(equivalences)
two debugging functions, just in case ...
void reset_alternate_returns(void)
void * syn_alloc(yy_size_t)
void soft_reset_alternate_returns(void)
ParserError() cannot guess if it has been performed or not, because it is reinitialized before and af...
void cr_implicit(tag, int, int, int)
this function updates the data structure used to compute implicit types.
void parser_substitute_all_macros_in_expression(expression)
int MakeElseInst(bool)
This function is used to handle either an ELSE or an ELSEIF construct.
int syn_lex_destroy(void)
syntax MakeAtom(entity, cons *, expression, expression, int)
MakeAtom: this function creates a syntax, ie.
void init_parser_reader_properties(void)
entity MakeLabel(const char *)
void reset_current_number_of_alternate_returns(void)
void dump_current_statement(void)
bool first_format_statement_seen(void)
void ScanNewFile(void)
La fonction a appeler pour l'analyse d'un nouveau fichier.
void save_all_entities(void)
functions for the SAVE declaration
int ReadStmt(FILE *)
regroupement des lignes du statement en une unique ligne sans continuation
void ProcessEntries(void)
size_t FindMatchingPar(size_t)
void reset_current_label_string(void)
char vcid_syntax_expression[]
expression.c
void BeginingOfProcedure(void)
this function is called each time a new procedure is encountered.
list add_actual_return_code(list)
void save_initialized_variable(entity)
entity SafeFindOrCreateEntity(const char *, const char *)
Problem: A functional global entity may be referenced without parenthesis or CALL keyword in a functi...
instruction MakeEntry(entity, list)
An ENTRY statement is substituted by a labelled continue.
void parser_add_a_macro(call, expression)
instruction MakeArithmIfInst(expression, string, string, string)
this function transforms an arithmetic if statement into a set of regular tests.
void add_ghost_variable_entity(entity)
bool parser(const string)
void AddVariableToCommon(entity, entity)
This function adds a variable v to a common block c.
type ImplicitType(entity)
This function computes the Fortran implicit type of entity e.
char FormatValue[(4096)]
a string that will contain the value of the format in case of format statement
int ReadLine(FILE *)
All physical lines of a statement are put together in a unique buffer called "line_buffer".
void DeclarePointer(entity, entity, list)
atom MakeEquivAtom(syntax)
this function creates an atom of an equivalence chain.
entity MakeCommon(entity)
MakeCommon: This function creates a common block.
instruction MakeGotoInst(string)
this function creates a goto instruction.
void init_parser_properties(void)
void remove_ghost_variable_entities(bool)
instruction MakeAssignedOrComputedGotoInst(list, expression, bool)
void TypeFunctionalEntity(entity, type)
void ScanFormalParameters(entity, list)
this function scans the formal parameter list.
expression loop_to_implieddo(loop)
instruction MakeSimpleIoInst2(int, expression, list)
instruction MakeReturn(expression)
instruction make_goto_instruction(entity)
In a "go to" instruction, the label does not appear explictly.
entity NameToFunctionalEntity(string)
void SubstituteAlternateReturns(const char *)
return.c
void append_data_current_stmt_buffer_to_declarations(void)
void MakeDataStatement(list, list)
Receives as first input an implicit list of references, including implicit DO, and as second input an...
syntax CheckLeftHandSide(syntax)
If a left hand side is a call, it should be a substring operator or a macro.
void LinkInstToCurrentBlock(instruction, bool)
this function links the instruction i to the current block of statements.
void MakeFormalParameter(entity, entity, int)
This function transforms an untyped entity into a formal parameter.
void AbortOfProcedure(void)
char * syn_get_text(void)
FILE * syn_in
lex yacc interface
type CurrentType
to count control specifications in IO statements
void ResetBlockStack(void)
void parser_macro_expansion(expression)
statement MakeStatement(entity, instruction)
This function makes a statement.
void substitute_ghost_variable_in_expression(expression, entity, entity)
void add_entity_to_declarations(string, string, enum basic_utype tag, void *)
FI: I do not understand the naming here, or the parameter.
instruction PopBlock(void)
void syn_error(const char *)
entity make_Fortran_constant_entity(string, tag, size_t)
int IsCapKeyword(char *)
Fonction appelee par sslex sur la reduction de la regle de reconnaissance des mot clefs.
void AnalyzeData(list, list)
this function scans at the same time a list of datavar and a list of dataval.
bool SubstituteAlternateReturnsP(void)
int ChainIntersection(cons *, cons *)
this function returns true if the there is a variable that occurs in both atom lists.
void SaveChains(void)
Initialize the shared fields of aliased variables.
void reset_common_size_map(void)
void set_first_format_statement(void)
int FindDoWhile(void)
This function is redundant with FindDo() but much easier to understand.
void init_ghost_variable_entities(void)
procedure.c
cons * MergeTwoChains(cons *, cons *)
this function merges two equivalence chains whose intersection is not empty, ie.
instruction MakeIoInstB(int, expression, expression, expression, expression)
this function creates a BUFFER IN or BUFFER OUT io statement.
int AddOrMergeChain(chain)
this function adds a chain ct to the set of equivalences.
instruction MakeComputedGotoInst(list, expression)
statement MakeNewLabelledStatement(entity, instruction)
void ComputeAddresses(void)
This function computes an address for every variable.
void print_full_malloc_info(FILE *)
void update_called_modules(entity)
int PipsGetc(FILE *)
Routine de lecture pour l'analyseur lexical, lex ou flex.
bool EmptyEntryListsP(void)
bool ReturnCodeVariableP(entity)
void SaveEntity(entity)
These two functions transform a dynamic variable into a static one.
void MakeVariableStatic(entity, bool)
cons * MakeIoList(cons *)
This function takes a list of io elements (i, j, t(i,j)), and returns the same list,...
instruction MakeCallInst(entity, cons *)
this function creates a call statement.
int StmtEqualString(char *, int)
void syn_pop_buffer_state(void)
char vcid_syntax_equivalence[]
equivalence.c
void set_alternate_returns(void)
void MakeDoInst(syntax, range, string)
this function creates a do loop statement.
bool fortran_relevant_area_entity_p(entity)
These tests are needed to check area consistency when dumping or printing a symbol table.
void * syn_realloc(void *, yy_size_t)
statement ReuseLabelledStatement(statement, instruction)
expression MakeFortranUnaryCall(entity, expression)
entity GetReturnCodeVariable(void)
void reset_common_size_map_on_error(void)
int IsIntegerScalar(entity)
FI: should be moved in ri-util; this function returns true if e is a zero dimension variable of basic...
statement LabelToStmt(string)
this functions looks up in table StmtHeap for the statement s whose label is l.
void update_functional_type_with_actual_arguments(entity, list)
int ValueOfIthLowerBound(entity, int)
this function returns the size of the ith lower bound of a variable e.
string get_current_label_string(void)
const char * CurrentPackage
the name of the current package, i.e.
instruction generate_return_code_checks(list)
void AddEffectiveFormalParameter(entity)
Keep track of the formal parameters for the current module.
void PushBlock(instruction, string)
1.9.1