PIPS
|
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "boolean.h"
#include "arithmetique.h"
#include "vecteur.h"
#include "contrainte.h"
#include "sc.h"
#include "union.h"
#include <limits.h>
Go to the source code of this file.
Data Structures | |
union | YYSTYPE |
Value type. More... | |
union | yyalloc |
INFRINGES ON USER NAME SPACE. More... | |
Macros | |
#define | YYBISON 30802 |
A Bison parser, made by GNU Bison 3.8.2. More... | |
#define | YYBISON_VERSION "3.8.2" |
Bison version string. More... | |
#define | YYSKELETON_NAME "yacc.c" |
Skeleton name. More... | |
#define | YYPURE 0 |
Pure parsers. More... | |
#define | YYPUSH 0 |
Push parsers. More... | |
#define | YYPULL 1 |
Pull parsers. More... | |
#define | yyparse(void) slx_parse |
------—. More... | |
#define | yylex slx_lex |
#define | yyerror slx_error |
#define | yydebug slx_debug |
#define | yynerrs slx_nerrs |
#define | yylval slx_lval |
#define | yychar slx_char |
#define | OPINF 1 |
ode des operateurs de comparaison More... | |
#define | OPINFEGAL 2 |
#define | OPEGAL 3 |
#define | OPSUPEGAL 4 |
#define | OPSUP 5 |
#define | DROIT 1 |
#define | GAUCHE 2 |
#define | YY_CAST(Type, Val) ((Type) (Val)) |
#define NULL 0 More... | |
#define | YY_REINTERPRET_CAST(Type, Val) ((Type) (Val)) |
#define | YY_NULLPTR ((void*)0) |
#define | YY_SLX_Y_TAB_H_INCLUDED |
Use api.header.include to include this header instead of duplicating it here. More... | |
#define | YYDEBUG 0 |
Debug traces. More... | |
#define | YYTOKENTYPE |
Token kinds. More... | |
#define | YYEMPTY -2 |
Token kinds. More... | |
#define | YYEOF 0 |
#define | YYerror 256 |
#define | YYUNDEF 257 |
#define | ACCFERM 1 |
#define | ACCOUVR 2 |
#define | CONSTANTE 3 |
#define | EGAL 4 |
#define | IDENT 5 |
#define | INF 6 |
#define | INFEGAL 7 |
#define | MOINS 8 |
#define | PLUS 9 |
#define | SUP 10 |
#define | SUPEGAL 11 |
#define | VAR 12 |
#define | VIRG 13 |
#define | YYSTYPE_IS_TRIVIAL 1 |
#define | YYSTYPE_IS_DECLARED 1 |
#define | YYPTRDIFF_T long |
#define | YYPTRDIFF_MAXIMUM LONG_MAX |
#define | YYSIZE_T unsigned |
#define | YYSIZE_MAXIMUM |
#define | YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X)) |
#define | YY_(Msgid) Msgid |
#define | YY_ATTRIBUTE_PURE |
#define | YY_ATTRIBUTE_UNUSED |
#define | YY_USE(E) ((void) (E)) |
Suppress unused-variable warnings by "using" E. More... | |
#define | YY_INITIAL_VALUE(Value) Value |
Suppress an incorrect diagnostic about yylval being uninitialized. More... | |
#define | YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN |
#define | YY_IGNORE_MAYBE_UNINITIALIZED_END |
#define | YY_IGNORE_USELESS_CAST_BEGIN |
#define | YY_IGNORE_USELESS_CAST_END |
#define | YY_ASSERT(E) ((void) (0 && (E))) |
#define | YYSTACK_ALLOC YYMALLOC |
The parser invokes alloca or malloc; define the necessary symbols. More... | |
#define | YYSTACK_FREE YYFREE |
#define | YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM |
#define | YYMALLOC malloc |
#define | YYFREE free |
INFRINGES ON USER NAME SPACE. More... | |
#define | YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1) |
The size of the maximum gap between one aligned stack and the next. More... | |
#define | YYSTACK_BYTES(N) |
The size of an array large to enough to hold all stacks, each with N elements. More... | |
#define | YYCOPY_NEEDED 1 |
#define | YYSTACK_RELOCATE(Stack_alloc, Stack) |
Relocate STACK from its old location to the new one. More... | |
#define | YYCOPY(Dst, Src, Count) |
Copy COUNT objects from SRC to DST. More... | |
#define | YYFINAL 3 |
!YYCOPY_NEEDED More... | |
#define | YYLAST 31 |
YYLAST – Last index in YYTABLE. More... | |
#define | YYNTOKENS 16 |
YYNTOKENS – Number of terminals. More... | |
#define | YYNNTS 25 |
YYNNTS – Number of nonterminals. More... | |
#define | YYNRULES 40 |
YYNRULES – Number of rules. More... | |
#define | YYNSTATES 49 |
YYNSTATES – Number of states. More... | |
#define | YYMAXUTOK 257 |
YYMAXUTOK – Last valid token kind. More... | |
#define | YYTRANSLATE(YYX) |
YYTRANSLATE(TOKEN-NUM) – Symbol number corresponding to TOKEN-NUM as returned by yylex, with out-of-bounds checking. More... | |
#define | YY_ACCESSING_SYMBOL(State) YY_CAST (yysymbol_kind_t, yystos[State]) |
Accessing symbol of state STATE. More... | |
#define | YYPACT_NINF (-25) |
#define | yypact_value_is_default(Yyn) ((Yyn) == YYPACT_NINF) |
#define | YYTABLE_NINF (-40) |
#define | yytable_value_is_error(Yyn) 0 |
#define | yyerrok (yyerrstatus = 0) |
#define | yyclearin (yychar = YYEMPTY) |
#define | YYACCEPT goto yyacceptlab |
#define | YYABORT goto yyabortlab |
#define | YYERROR goto yyerrorlab |
#define | YYNOMEM goto yyexhaustedlab |
#define | YYRECOVERING() (!!yyerrstatus) |
#define | YYBACKUP(Token, Value) |
#define | YYERRCODE YYUNDEF |
Backward compatibility with an undocumented macro. More... | |
#define | YYDPRINTF(Args) ((void) 0) |
Enable debugging if requested. More... | |
#define | YY_SYMBOL_PRINT(Title, Kind, Value, Location) |
#define | YY_STACK_PRINT(Bottom, Top) |
#define | YY_REDUCE_PRINT(Rule) |
#define | YYINITDEPTH 200 |
!YYDEBUG More... | |
#define | YYMAXDEPTH 10000 |
YYMAXDEPTH – maximum size the stacks can grow to (effective only if the built-in stack extension method is used). More... | |
#define | YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N)) |
Typedefs | |
typedef enum yytokentype | yytoken_kind_t |
typedef union YYSTYPE | YYSTYPE |
typedef enum yysymbol_kind_t | yysymbol_kind_t |
typedef signed char | yytype_int8 |
On compilers that do not define PTRDIFF_MAX etc., make sure <limits.h> and (if available) <stdint.h> are included so that the code can choose integer types of a good width. More... | |
typedef short | yytype_int16 |
typedef unsigned char | yytype_uint8 |
Work around bug in HP-UX 11.23, which defines these macros incorrectly for preprocessor constants. More... | |
typedef unsigned short | yytype_uint16 |
typedef yytype_int8 | yy_state_t |
Stored state numbers (used for stacks). More... | |
typedef int | yy_state_fast_t |
State numbers in computations. More... | |
Functions | |
int | slx_lex () |
First part of user prologue. More... | |
int | slx_error () |
int | slx_parse (void) |
void * | malloc (YYSIZE_T) |
void | free (void *) |
static void | yydestruct (const char *yymsg, yysymbol_kind_t yykind, YYSTYPE *yyvaluep) |
-------------------------------------------—. More... | |
int | slx_error (char *s) |
Variables | |
char * | slx_text |
Psysteme | ps_yacc |
package sc More... | |
bool | syntax_error |
sl_gram.c More... | |
Value | valcst |
Value | fac |
int | sens |
facteur multiplicatif suivant qu'on analyse un terme More... | |
short int | cote |
indique le sens de l'inegalite sens = -1 ==> l'operateur est soit > ,soit >=, sens = 1 ==> l'operateur est soit <, soit <= More... | |
Value | b1 |
booleen indiquant quel membre est en cours d'analyse More... | |
Value | b2 |
Pcontrainte | eq |
element du vecteur colonne du systeme donne par l'analyse d'une contrainte More... | |
Pvecteur | cp |
pointeur sur l'egalite ou l'inegalite courante More... | |
short int | operat |
pointeur sur le membre courant More... | |
Pcontrainte | p_eg_fin |
dernier operateur rencontre More... | |
Pcontrainte | p_ineg_fin |
pointeur sur la derniere inegalite More... | |
Pvecteur | p_pred |
pointeur sur le predecesseur du couple courant More... | |
Pvecteur | p_membre_courant |
Psyslist | sl_yacc |
Pbase | ba_yacc |
Variable | va_yacc |
YYSTYPE | slx_lval |
static const yytype_int8 | yytranslate [] |
YYTRANSLATE[TOKEN-NUM] – Symbol number corresponding to TOKEN-NUM as returned by yylex. More... | |
static const yytype_int8 | yypact [] |
YYPACT[STATE-NUM] – Index in YYTABLE of the portion describing STATE-NUM. More... | |
static const yytype_int8 | yydefact [] |
YYDEFACT[STATE-NUM] – Default reduction number in state STATE-NUM. More... | |
static const yytype_int8 | yypgoto [] |
YYPGOTO[NTERM-NUM]. More... | |
static const yytype_int8 | yydefgoto [] |
YYDEFGOTO[NTERM-NUM]. More... | |
static const yytype_int8 | yytable [] |
YYTABLE[YYPACT[STATE-NUM]] – What to do in state STATE-NUM. More... | |
static const yytype_int8 | yycheck [] |
static const yytype_int8 | yystos [] |
YYSTOS[STATE-NUM] – The symbol kind of the accessing symbol of state STATE-NUM. More... | |
static const yytype_int8 | yyr1 [] |
YYR1[RULE-NUM] – Symbol kind of the left-hand side of rule RULE-NUM. More... | |
static const yytype_int8 | yyr2 [] |
YYR2[RULE-NUM] – Number of symbols on the right-hand side of rule RULE-NUM. More... | |
int | yychar |
Lookahead token kind. More... | |
YYSTYPE | yylval |
The semantic value of the lookahead symbol. More... | |
int | yynerrs |
Number of syntax errors so far. More... | |
#define YY_ACCESSING_SYMBOL | ( | State | ) | YY_CAST (yysymbol_kind_t, yystos[State]) |
#define YY_SLX_Y_TAB_H_INCLUDED |
#define YYBACKUP | ( | Token, | |
Value | |||
) |
#define YYBISON 30802 |
A Bison parser, made by GNU Bison 3.8.2.
Bison implementation for Yacc-like parsers in C
Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2021 Free Software Foundation, Inc.
This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License along with this program. If not, see https://www.gnu.org/licenses/.
As a special exception, you may create a larger work that contains part or all of the Bison parser skeleton and distribute that work under terms of your choice, so long as that work isn't itself a parser generator using the skeleton or a modified version thereof as a parser skeleton. Alternatively, if you modify or redistribute the parser skeleton itself, you may (at your option) remove this special exception, which will cause the skeleton and the resulting Bison output files to be licensed under the GNU General Public License without this special exception.
This special exception was added by the Free Software Foundation in version 2.2 of Bison.
C LALR(1) parser skeleton written by Richard Stallman, by simplifying the original so-called "semantic" parser.
DO NOT RELY ON FEATURES THAT ARE NOT DOCUMENTED in the manual, especially those whose name start with YY_ or yy_. They are private implementation details that can be changed or removed.
All symbols defined below should begin with yy or YY, to avoid infringing on user name space. This should be done even for local variables, as they might otherwise be expanded by user macros. There are some unavoidable exceptions within include files to define necessary library symbols; they are noted "INFRINGES ON
USER NAME SPACE" below.
Identify Bison output, and Bison version.
#define YYCOPY | ( | Dst, | |
Src, | |||
Count | |||
) |
Copy COUNT objects from SRC to DST.
The source and destination do not overlap.
#define YYDPRINTF | ( | Args | ) | ((void) 0) |
#define YYERRCODE YYUNDEF |
#define YYFINAL 3 |
#define YYINITDEPTH 200 |
#define YYMAXDEPTH 10000 |
YYMAXDEPTH – maximum size the stacks can grow to (effective only if the built-in stack extension method is used).
Do not make this value too large; the results are undefined if YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH) evaluated with infinite-precision integer arithmetic.
#define yypact_value_is_default | ( | Yyn | ) | ((Yyn) == YYPACT_NINF) |
#define yyparse | ( | void | ) | slx_parse |
------—.
Substitute the variable and function names.
| yyparse. | `-------—
Number of tokens to shift before error messages enabled.
Refer to the stacks through separate pointers, to allow yyoverflow to reallocate them elsewhere.
Their size.
The state stack: array, bottom, top.
The semantic value stack: array, bottom, top.
The return value of yyparse.
Lookahead symbol kind.
The variables used to return semantic value and location from the action routines.
The number of symbols on the RHS of the reduced rule. Keep to zero when no symbol should be popped.
Cause a token to be read.
--------------------------------------------------------—. | yynewstate – push a new state, which is found in yystate. | `---------------------------------------------------------—
In all cases, when you get here, the value and location stacks have just been pushed. So pushing a state here evens the stacks.
----------------------------------------------------------------—. | yysetstate – set current state (the top of the stack) to yystate. | `-----------------------------------------------------------------—
Get the current used size of the three stacks, in elements.
defined YYSTACK_RELOCATE
Extend the stack our own way.
!defined yyoverflow && !defined YYSTACK_RELOCATE
-------—. | yybackup. | `--------—
Do appropriate processing given the current state. Read a lookahead token if we need one and don't already have one.
First try to decide what to do without reference to lookahead token.
Not known => get a lookahead token if don't already have one.
YYCHAR is either empty, or end-of-input, or a valid lookahead.
The scanner already issued an error message, process directly to error recovery. But do not keep the error token as lookahead, it is too special and may lead us to an endless loop in error recovery.
If the proper action on seeing token YYTOKEN is to reduce or to detect an error, take that action.
Count tokens shifted since error; after three, turn off error status.
Shift the lookahead token.
Discard the shifted token.
-------------------------------------------------------—. | yydefault – do the default action for the current state. | `--------------------------------------------------------—
-------------------------—. | yyreduce – do a reduction. | `--------------------------—
yyn is the number of a rule to reduce with.
If YYLEN is nonzero, implement the default value of the action: '$$ = $1'.
Otherwise, the following line sets YYVAL to garbage. This behavior is undocumented and Bison users should not rely upon it. Assigning to YYVAL unconditionally makes the parser a bit smaller, and it avoids a GCC warning that YYVAL may be used uninitialized.
inisl: empty
Initialisation de la liste des systemes
endsl: empty
Fin de la list des systemes
newid: IDENT
inisys: empty
initialisation des parametres de la liste de systemes
et initialisation des variables
endsys: empty
on rajoute le systeme trouve a la liste
debeq: empty
feq: empty
$@1: empty
terme: const ident
ajout du couple (ident,const) a la contrainte courante
duplication du couple (ident,const) de la combinaison lineaire traitee
terme: const
terme: ident
ajout du couple (ident,1) a la contrainte courante
duplication du couple (ident,1) de la combinaison lineaire traitee
ident: IDENT
const: CONSTANTE
op: INF
op: INFEGAL
op: EGAL
op: SUP
op: SUPEGAL
addop: PLUS
addop: MOINS
fin_mult_membre: empty
User semantic actions sometimes alter yychar, and that requires that yytoken be updated with the new translation. We take the approach of translating immediately before every use of yytoken. One alternative is translating here after every semantic action, but that translation would be missed if the semantic action invokes YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an incorrect destructor might then be invoked immediately. In the case of YYERROR or YYBACKUP, subsequent parser actions might lead to an incorrect destructor call or verbose syntax error message before the lookahead is translated.
Now 'shift' the result of the reduction. Determine what state that goes to, based on the state we popped back to and the rule number reduced by.
----------------------------------—. | yyerrlab – here on detecting error. | `-----------------------------------—
Make sure we have latest lookahead translation. See comments at user semantic actions for why this is necessary.
If not already recovering from an error, report this error.
If just tried and failed to reuse lookahead token after an error, discard it.
Return failure if at end of input.
Else will try to reuse lookahead token after shifting the error token.
-----------------------------------------------—. | yyerrorlab – error raised explicitly by YYERROR. | `------------------------------------------------—
Pacify compilers when the user code never invokes YYERROR and the label yyerrorlab therefore never appears in user code.
Do not reclaim the symbols of the rule whose action triggered this YYERROR.
---------------------------------------------------------—. | yyerrlab1 – common code for both syntax error and YYERROR. | `----------------------------------------------------------—
Each real token shifted decrements this.
Pop stack until we find a state that shifts the error token.
Pop the current state because it cannot handle the error token.
Shift the error token.
---------------------------------—. | yyacceptlab – YYACCEPT comes here. | `----------------------------------—
-------------------------------—. | yyabortlab – YYABORT comes here. | `--------------------------------—
-------------------------------------------------------—. | yyexhaustedlab – YYNOMEM (memory exhaustion) comes here. | `--------------------------------------------------------—
------------------------------------------------------—. | yyreturnlab – parsing is finished, clean up and return. | `-------------------------------------------------------—
Make sure we have latest lookahead translation. See comments at user semantic actions for why this is necessary.
Do not reclaim the symbols of the rule whose action triggered this YYABORT or YYACCEPT.
#define YYPOPSTACK | ( | N | ) | (yyvsp -= (N), yyssp -= (N)) |
#define YYSIZE_MAXIMUM |
#define YYSTACK_ALLOC YYMALLOC |
#define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM |
#define YYSTACK_BYTES | ( | N | ) |
The size of an array large to enough to hold all stacks, each with N elements.
#define YYSTACK_RELOCATE | ( | Stack_alloc, | |
Stack | |||
) |
Relocate STACK from its old location to the new one.
The local variables YYSIZE and YYSTACKSIZE give the old and new number of elements in the stack, and YYPTR gives the new location of the stack. Advance YYPTR to a properly aligned location for the next stack.
#define YYTRANSLATE | ( | YYX | ) |
YYTRANSLATE(TOKEN-NUM) – Symbol number corresponding to TOKEN-NUM as returned by yylex, with out-of-bounds checking.
typedef int yy_state_fast_t |
typedef yytype_int8 yy_state_t |
typedef enum yysymbol_kind_t yysymbol_kind_t |
typedef enum yytokentype yytoken_kind_t |
typedef short yytype_int16 |
typedef signed char yytype_int8 |
On compilers that do not define PTRDIFF_MAX etc., make sure <limits.h> and (if available) <stdint.h> are included so that the code can choose integer types of a good width.
INFRINGES ON USER NAME SPACE Narrow types that promote to a signed type and that can represent a signed or unsigned integer of at least N bits. In tables they can save space and decrease cache pressure. Promoting to a signed type helps avoid bugs in integer arithmetic.
typedef unsigned short yytype_uint16 |
typedef unsigned char yytype_uint8 |
Work around bug in HP-UX 11.23, which defines these macros incorrectly for preprocessor constants.
This workaround can likely be removed in 2023, as HPE has promised support for HP-UX 11.23 (aka HP-UX 11i v2) only through the end of 2022; see Table 2 of https://h20195.www2.hpe.com/V2/getpdf.aspx/4AA4-7673ENW.pdf.
enum yysymbol_kind_t |
!YY_SLX_Y_TAB_H_INCLUDED
Symbol kind.
Definition at line 231 of file sl_gram.c.
enum yytokentype |
Definition at line 164 of file sl_gram.c.
void free | ( | void * | ) |
void* malloc | ( | YYSIZE_T | ) |
int slx_error | ( | ) |
int slx_error | ( | char * | s | ) |
procedure minimum de recouvrement d'erreurs
Definition at line 1702 of file sl_gram.c.
References fprintf(), slx_text, and syntax_error.
int slx_lex | ( | ) |
First part of user prologue.
int slx_parse | ( | void | ) |
|
static |
-------------------------------------------—.
| Release the memory associated to this symbol. | `--------------------------------------------—
Definition at line 983 of file sl_gram.c.
References YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN, YY_IGNORE_MAYBE_UNINITIALIZED_END, YY_SYMBOL_PRINT, and YY_USE.
|
extern |
booleen indiquant quel membre est en cours d'analyse
Definition at line 105 of file sc_gram.c.
Referenced by actual_convex_union(), append_to(), arguments_are_compatible(), base_add_variable(), base_difference(), base_included_p(), base_intersection(), base_union(), bases_strictly_equal_p(), basic_equal_p(), basic_maximum(), basic_union(), basic_union_arguments(), check_overlap_in_common(), compare_basic_p(), compatible_basic_p(), compute_region(), dependence_cone_positive(), do_convert_to_standard_operators(), elementary_convex_union(), eq_diff_const(), eq_sum_const(), generic_basic_equal_p(), is_inferior_basic(), logical_binary_function_to_transformer(), look_for_inner_loops(), look_for_nested_loop_statements(), mat_sys_conv(), MemberIdentifierToExpression(), normalize_intrinsic(), partial_eval_minus_c_operator(), partial_eval_plus_c_operator(), regions_must_convex_hull(), relation_to_transformer(), same_alignment_p(), same_basic_p(), sc_base_add_variable(), search_i_element(), simple_indices_p(), simple_pv_composition_with_transformer(), simplify_complex_expression(), sl_fprint_tab(), sub_basis_p(), TestCoupleOfReferences(), transformer_add_any_relation_information(), transformer_convex_hulls(), transitive_closure_from_two_bases(), type_this_entity_if_needed(), type_this_instruction(), typing_arguments(), typing_arguments_of_user_function(), typing_of_assign(), typing_power_operator(), and vect_add_variable().
|
extern |
|
extern |
pointeur sur l'egalite ou l'inegalite courante
pointeur sur l'egalite ou l'inegalite courante
Definition at line 87 of file sc_read.c.
Referenced by init_globals().
|
extern |
element du vecteur colonne du systeme donne par l'analyse d'une contrainte
element du vecteur colonne du systeme donne par l'analyse d'une contrainte
d'une contrainte
Definition at line 108 of file sc_gram.c.
Referenced by add_bounding_box_constraints(), add_equivalence_equality(), add_equivalenced_values(), add_or_kill_equivalenced_variables(), add_synonym_values(), add_type_information(), adg_sc_dup(), affine_to_transformer(), better_elim_var_with_eg(), bitwise_xor_to_transformer(), build_integer_sc_nredund(), build_transfer_equations(), build_transfer_matrix(), constraints_to_matrices(), constraints_with_sym_cst_to_matrices(), contrainte_var_min_coeff(), contraintes_with_sym_cst_to_matrices(), dj_system_complement(), eq_in_ineq(), eq_redund_with_sc_p(), eq_var_nophi_min_coeff(), eq_var_phi(), equations_to_bases(), extract_common_constraints(), extract_lattice(), extract_non_conflicting_statements(), extract_nredund_subsystem(), find_vbase(), fortran_user_function_call_to_transformer(), generic_equality_to_transformer(), gfc2pips_computeEquiv(), gomory_eq(), gomory_trait_eq(), logical_binary_function_to_transformer(), logical_constant_to_transformer(), logical_unary_operation_to_transformer(), loop_sc_to_matrices(), make_scanning_over_one_tile(), my_constraints_with_sym_cst_to_matrices(), my_sc_normalize(), new_elim_var_with_eg(), new_value_in_transfer_equation(), norm_syst(), parametric_transformer_empty_p(), pivoter_pas(), pu_contraintes_to_matrices(), region_sc_minimal(), region_sc_projection_ofl_along_parameter(), relation_to_transformer(), sc_add_normalize_eq(), sc_belongs_p(), sc_bounded_normalization(), sc_concatenate(), sc_consistent_p(), sc_copy(), sc_dup1(), sc_elim_double_constraints(), sc_elim_redund(), sc_elim_redund_with_first_ofl_ctrl(), sc_elim_simple_redund_with_eq(), sc_elim_simple_redund_with_ineq(), sc_elim_var(), sc_empty(), sc_empty_p(), sc_find_equalities(), sc_fusion(), sc_inequations_elim_redund(), sc_internal_p(), sc_invers(), sc_minmax_of_variable2(), sc_normalize(), sc_normalize2(), sc_oppose(), sc_projection_optim_along_vecteur_ofl(), sc_strong_normalize2(), sc_strong_normalize_and_check_feasibility(), sc_strong_normalize_and_check_feasibility2(), sc_supress_same_constraints(), sc_to_matrices(), sc_weak_consistent_p(), simple_addition_to_transformer(), simple_affine_to_transformer(), simplify_constraint_with_bounding_box(), simplify_deducable_variables(), simplify_float_constraint_system(), sys_int_redond(), sys_mat_conv(), test_borne(), tile_change_of_basis(), transfer_equation_p(), transformer_add_3d_affine_constraint(), transformer_add_condition_information_updown(), transformer_add_equality(), transformer_add_equality_with_affine_term(), transformer_add_equality_with_integer_constant(), transformer_add_identity(), transformer_add_inequality(), transformer_add_inequality_with_affine_term(), transformer_add_inequality_with_integer_constraint(), transformer_add_loop_index_initialization(), transformer_add_sign_information(), transformer_basic_fix_point(), transformer_convex_hulls(), transformer_derivative_constraints(), transformer_derivative_fix_point(), transformer_list_generic_transitive_closure(), translate_global_value(), update_coefficient_signs_in_constraints(), and var_pivotd().
|
extern |
|
extern |
dernier operateur rencontre
dernier operateur rencontre
Ces fonction ne sont utilisables que dans ce contexte particulier car elles utilisent des variables globales
* init_globals(): initialisation des variables globales * new_ident (ps,s) : - introduction de la nouvelle variable s dans la base * rec_ident (ps,s) : - recherche du rang de la variable s dans la base * creer_eg (p) : - ajout d'une egalite, dont les couples (variable,coefficient) sont pointes par p * creer_ineg (p): - ajout d'une inegalite, dont les couples (variable,coefficient) sont pointes par p
Corinne Ancourt
Modifications:
Introduites pour utilisation avec le module YACC gram.y pointeur sur la derniere egalite
Definition at line 76 of file sc_read.c.
Referenced by creer_eg(), and init_globals().
|
extern |
pointeur sur la derniere inegalite
Definition at line 79 of file sc_read.c.
Referenced by creer_ineg(), and init_globals().
|
extern |
pointeur sur le predecesseur du couple courant
Definition at line 82 of file sc_read.c.
Referenced by init_globals().
|
extern |
|
extern |
facteur multiplicatif suivant qu'on analyse un terme
introduit par un moins (-1) ou par un plus (1)
Definition at line 100 of file sc_gram.c.
Referenced by creer_ineg(), and get_vertex_by_string().
|
extern |
|
extern |
Referenced by slx_error().
bool syntax_error |
|
static |
|
static |
YYDEFACT[STATE-NUM] – Default reduction number in state STATE-NUM.
Performed when YYTABLE does not specify something else to do. Zero means the default is an error.
|
static |
YYSTYPE yylval |
|
static |
YYPACT[STATE-NUM] – Index in YYTABLE of the portion describing STATE-NUM.
|
static |
|
static |
|
static |
|
static |
YYSTOS[STATE-NUM] – The symbol kind of the accessing symbol of state STATE-NUM.
|
static |
YYTABLE[YYPACT[STATE-NUM]] – What to do in state STATE-NUM.
If positive, shift that token. If negative, reduce the rule whose number is the opposite. If YYTABLE_NINF, syntax error.
|
static |
YYTRANSLATE[TOKEN-NUM] – Symbol number corresponding to TOKEN-NUM as returned by yylex.