===========================================================
.___ __ __
_________________ __ __ __| _/|__|/ |_
/ ___\_` __ \__ \ | | \/ __ | | \\_ __\
/ /_/ > | \// __ \| | / /_/ | | || |
\___ /|__| (____ /____/\____ | |__||__|
/_____/ \/ \/
grep rough audit - static analysis tool
v2.8 written by @Wireghoul
=================================[justanotherhacker.com]===
sollya-7.0+ds/doc/chebyshevform.tex-56- $f(x)-\sum\limits_{i=0}^{n} \alpha_i\, T_i(y)= \delta$,
sollya-7.0+ds/doc/chebyshevform.tex:57: where $[a,b]=I, y=(2x-b-a)/(b-a)$ and $T_i(y)$ is the $i$-th Chebyshev polynomial
sollya-7.0+ds/doc/chebyshevform.tex-58- over $[-1,1]$.
##############################################
sollya-7.0+ds/doc/infnorm.tex-56- applied, e.g. $f([a,b]) \subseteq f(m) + [a-m,\,b-m] \cdot f'([a,\,b])$
sollya-7.0+ds/doc/infnorm.tex:57: where $m=\frac{a+b}{2}$. This rule is recursively applied $n$ times
sollya-7.0+ds/doc/infnorm.tex-58- where $n$ is the value of variable \textbf{taylorrecursions}. Roughly speaking,
##############################################
sollya-7.0+ds/doc/sollya.tex-1927-\end{center}
sollya-7.0+ds/doc/sollya.tex:1928:If \verb|arg| really is a structure, say with $N$ fields called ``fieldA'', \dots, ``fieldZ'', this functions sets \verb|*n| to~$N$, allocates and fills an array of $N$ strings and sets \verb|*names| so that it points to that segment of memory (hence \verb|(*names)[0]| is the string ``fieldA'', \dots, \verb|(*names)[N-1]| is the string ``fieldZ''). Moreover, it allocates memory for $N$ \verb|sollya_obj_t|, sets \verb|*objs| so that it points on that memory segment, and copies the contents of each of the $N$ fields at \verb|(*objs)[0]|, \dots, \verb|(*objs)[N-1]|. Finally it returns true. If \verb|arg| is not a structure, the function simply returns false without doing anything. Please note that since \verb|*names| and \verb|*objs| point to memory segments that have been dynamically allocated, they should manually be cleared by the user with \verb|sollya_lib_free| once they become useless.
sollya-7.0+ds/doc/sollya.tex-1929-
##############################################
sollya-7.0+ds/doc/taylorrecursions.tex-27- particular when there are problems of decorrelation), the evaluator of \sollya
sollya-7.0+ds/doc/taylorrecursions.tex:28: uses Taylor's rule: $f([a,b]) \subseteq f(m) + [a-m,\,b-m] \cdot f'([a,\,b])$ where $m=\frac{a+b}{2}$.
sollya-7.0+ds/doc/taylorrecursions.tex-29- This rule can be applied recursively.
##############################################
sollya-7.0+ds/help.h-166-#define HELP_HP_TEXT "Name: HP\n==> short form for halfprecision\n\nSee also: halfprecision\n"
sollya-7.0+ds/help.h:167:#define HELP_IMPLEMENTCONSTANT_TEXT "Name: implementconstant\n==> implements a constant in arbitrary precision\n\nLibrary names:\n void sollya_lib_implementconstant(sollya_obj_t, ...);\n void sollya_lib_v_implementconstant(sollya_obj_t, va_list);\n\nUsage: \n implementconstant({expr}) : constant -> void\n implementconstant({expr},{filename}) : (constant, string) -> void\n implementconstant({expr},{filename},{functionname}) : (constant, string, string) -> void\n\nDescription: \n * The command implementconstant implements the constant expression {expr} in \n arbitrary precision. More precisely, it generates the source code (written\n in C, and using MPFR) of a C function const_something with the following\n signature:\n \n void const_something (mpfr_ptr y, mp_prec_t prec)\n \n Let us denote by c the exact mathematical value of the constant defined by\n the expression {expr}. When called with arguments y and prec (where the\n variable y is supposed to be already initialized), the function\n mpfr_const_something sets the precision of y to a suitable precision and\n stores in it an approximate value of c such that\n |y-c| <= |c|*2^(1-prec).\n\n * When no filename {filename} is given or if default is given as\n {filename}, the source code produced by implementconstant is printed on\n standard output. Otherwise, when {filename} is given as a \n string of characters, the source code is output to a file \n named {filename}. If that file cannot be opened and/or \n written to, implementconstant fails and has no other effect.\n\n * When {functionname} is given as an argument to implementconstant and\n {functionname} evaluates to a string of characters, the default name\n for the C function const_something is\n replaced by {functionname}. When default is given as {functionname},\n the default name is used nevertheless, as if no {functionname}\n argument were given. When choosing a character sequence for\n {functionname}, the user should keep attention to the fact that\n {functionname} must be a valid C identifier in order to enable\n error-free compilation of the produced code.\n\n * If {expr} refers to a constant defined with libraryconstant, the produced\n code uses the external code implementing this constant. The user should\n keep in mind that it is up to them to make sure the symbol for that \n external code can get resolved when the newly generated code is to \n be loaded.\n\n * If a subexpression of {expr} evaluates to 0, implementconstant will most\n likely fail with an error message.\n\n * implementconstant is unable to implement constant expressions {expr} that\n contain procedure-based functions, i.e. functions created from Sollya\n procedures using the function construct. If {expr} contains such a\n procedure-based function, implementconstant prints a warning and fails\n silently. The reason for this lack of functionality is that the\n produced C source code, which is supposed to be compiled, would have\n to call back to the Sollya interpreter in order to evaluate the\n procedure-based function.\n\n * Similarly, implementconstant is currently unable to implement constant\n expressions {expr} that contain library-based functions, i.e.\n functions dynamically bound to Sollya using the library construct.\n If {expr} contains such a library-based function, implementconstant prints\n a warning and fails silently. Support for this feature is in principle\n feasible from a technical standpoint and might be added in a future\n release of Sollya.\n\n * Currently, non-differentiable functions such as double, doubledouble,\n tripledouble, single, halfprecision, quad, doubleextended, \n floor, ceil, nearestint are not supported by implementconstant. \n If implementconstant encounters one of them, a warning message is displayed \n and no code is produced. However, if autosimplify equals on, it is \n possible that Sollya silently simplifies subexpressions of {expr} \n containing such functions and that implementconstant successfully produces \n code for evaluating {expr}.\n\n * While it produces an MPFR-based C source code for {expr}, implementconstant\n takes architectural and system-dependent parameters into account. For\n example, it checks whether literal constants figuring in {expr} can be\n represented on a C long int type or if they must\n be stored in a different manner not to affect their accuracy. These\n tests, performed by Sollya during execution of implementconstant, depend\n themselves on the architecture Sollya is running on. Users should\n keep this matter in mind, especially when trying to compile source\n code on one machine whilst it has been produced on another.\n\nExample 1: \n > implementconstant(exp(1)+log(2)/sqrt(1/10)); \n\n [ The first 100 lines of the output have been removed ]\n\n modify or redistribute this generated code itself, or its skeleton,\n you may (at your option) remove this special exception, which will\n cause this generated code and its skeleton and the resulting Sollya\n output files to be licensed under the CeCILL-C licence without this\n special exception.\n \n This special exception was added by the Sollya copyright holders in\n version 4.1 of Sollya.\n \n */\n \n \n #include <mpfr.h>\n \n void\n const_something (mpfr_ptr y, mp_prec_t prec)\n {\n /* Declarations */\n mpfr_t tmp1;\n mpfr_t tmp2;\n mpfr_t tmp3;\n mpfr_t tmp4;\n mpfr_t tmp5;\n mpfr_t tmp6;\n mpfr_t tmp7;\n \n /* Initializations */\n mpfr_init2 (tmp2, prec+5);\n mpfr_init2 (tmp1, prec+3);\n mpfr_init2 (tmp4, prec+8);\n mpfr_init2 (tmp3, prec+7);\n mpfr_init2 (tmp6, prec+11);\n mpfr_init2 (tmp7, prec+11);\n mpfr_init2 (tmp5, prec+11);\n \n /* Core */\n mpfr_set_prec (tmp2, prec+4);\n mpfr_set_ui (tmp2, 1, MPFR_RNDN);\n mpfr_set_prec (tmp1, prec+3);\n mpfr_exp (tmp1, tmp2, MPFR_RNDN);\n mpfr_set_prec (tmp4, prec+8);\n mpfr_set_ui (tmp4, 2, MPFR_RNDN);\n mpfr_set_prec (tmp3, prec+7);\n mpfr_log (tmp3, tmp4, MPFR_RNDN);\n mpfr_set_prec (tmp6, prec+11);\n mpfr_set_ui (tmp6, 1, MPFR_RNDN);\n mpfr_set_prec (tmp7, prec+11);\n mpfr_set_ui (tmp7, 10, MPFR_RNDN);\n mpfr_set_prec (tmp5, prec+11);\n mpfr_div (tmp5, tmp6, tmp7, MPFR_RNDN);\n mpfr_set_prec (tmp4, prec+7);\n mpfr_sqrt (tmp4, tmp5, MPFR_RNDN);\n mpfr_set_prec (tmp2, prec+5);\n mpfr_div (tmp2, tmp3, tmp4, MPFR_RNDN);\n mpfr_set_prec (y, prec+3);\n mpfr_add (y, tmp1, tmp2, MPFR_RNDN);\n \n /* Cleaning stuff */\n mpfr_clear(tmp1);\n mpfr_clear(tmp2);\n mpfr_clear(tmp3);\n mpfr_clear(tmp4);\n mpfr_clear(tmp5);\n mpfr_clear(tmp6);\n mpfr_clear(tmp7);\n }\n\nExample 2: \n > implementconstant(sin(13/17),\"sine_of_thirteen_seventeenth.c\");\n > bashevaluate(\"tail -n 30 sine_of_thirteen_seventeenth.c\");\n #include <mpfr.h>\n \n void\n const_something (mpfr_ptr y, mp_prec_t prec)\n {\n /* Declarations */\n mpfr_t tmp1;\n mpfr_t tmp2;\n mpfr_t tmp3;\n \n /* Initializations */\n mpfr_init2 (tmp2, prec+6);\n mpfr_init2 (tmp3, prec+6);\n mpfr_init2 (tmp1, prec+6);\n \n /* Core */\n mpfr_set_prec (tmp2, prec+6);\n mpfr_set_ui (tmp2, 13, MPFR_RNDN);\n mpfr_set_prec (tmp3, prec+6);\n mpfr_set_ui (tmp3, 17, MPFR_RNDN);\n mpfr_set_prec (tmp1, prec+6);\n mpfr_div (tmp1, tmp2, tmp3, MPFR_RNDN);\n mpfr_set_prec (y, prec+2);\n mpfr_sin (y, tmp1, MPFR_RNDN);\n \n /* Cleaning stuff */\n mpfr_clear(tmp1);\n mpfr_clear(tmp2);\n mpfr_clear(tmp3);\n }\n\nExample 3: \n > implementconstant(asin(1/3 * pi),default,\"arcsin_of_one_third_pi\"); \n\n [ The first 100 lines of the output have been removed ]\n\n modify or redistribute this generated code itself, or its skeleton,\n you may (at your option) remove this special exception, which will\n cause this generated code and its skeleton and the resulting Sollya\n output files to be licensed under the CeCILL-C licence without this\n special exception.\n \n This special exception was added by the Sollya copyright holders in\n version 4.1 of Sollya.\n \n */\n \n \n #include <mpfr.h>\n \n void\n arcsin_of_one_third_pi (mpfr_ptr y, mp_prec_t prec)\n {\n /* Declarations */\n mpfr_t tmp1;\n mpfr_t tmp2;\n mpfr_t tmp3;\n \n /* Initializations */\n mpfr_init2 (tmp2, prec+8);\n mpfr_init2 (tmp3, prec+8);\n mpfr_init2 (tmp1, prec+8);\n \n /* Core */\n mpfr_set_prec (tmp2, prec+8);\n mpfr_const_pi (tmp2, MPFR_RNDN);\n mpfr_set_prec (tmp3, prec+8);\n mpfr_set_ui (tmp3, 3, MPFR_RNDN);\n mpfr_set_prec (tmp1, prec+8);\n mpfr_div (tmp1, tmp2, tmp3, MPFR_RNDN);\n mpfr_set_prec (y, prec+2);\n mpfr_asin (y, tmp1, MPFR_RNDN);\n \n /* Cleaning stuff */\n mpfr_clear(tmp1);\n mpfr_clear(tmp2);\n mpfr_clear(tmp3);\n }\n\nExample 4: \n > implementconstant(ceil(log(19 + 1/3)),\"constant_code.c\",\"magic_constant\");\n > bashevaluate(\"tail -n -9 constant_code.c\");\n void\n magic_constant (mpfr_ptr y, mp_prec_t prec)\n {\n /* Initializations */\n \n /* Core */\n mpfr_set_prec (y, prec);\n mpfr_set_ui (y, 3, MPFR_RNDN);\n }\n\nExample 5: \n > bashexecute(\"gcc -fPIC -Wall -c libraryconstantexample.c -I$HOME/.local/include\");\n > bashexecute(\"gcc -shared -o libraryconstantexample libraryconstantexample.o -lgmp -lmpfr\");\n > euler_gamma = libraryconstant(\"./libraryconstantexample\");\n > implementconstant(euler_gamma^(1/3), \"euler.c\");\n > bashevaluate(\"tail -n -17 euler.c\");\n void\n const_something (mpfr_ptr y, mp_prec_t prec)\n {\n /* Declarations */\n mpfr_t tmp1;\n \n /* Initializations */\n mpfr_init2 (tmp1, prec+1);\n \n /* Core */\n euler_gamma (tmp1, prec+1);\n mpfr_set_prec (y, prec+2);\n mpfr_root (y, tmp1, 3, MPFR_RNDN);\n \n /* Cleaning stuff */\n mpfr_clear(tmp1);\n }\n\nSee also: implementpoly, libraryconstant, library, function, bashevaluate\n"
sollya-7.0+ds/help.h-168-#define HELP_IMPLEMENTPOLY_TEXT "Name: implementpoly\n==> implements a polynomial using double, double-double and triple-double arithmetic and generates a Gappa proof\n\nLibrary names:\n sollya_obj_t sollya_lib_implementpoly(sollya_obj_t, sollya_obj_t,\n sollya_obj_t, sollya_obj_t,\n sollya_obj_t, sollya_obj_t, ...)\n sollya_obj_t sollya_lib_v_implementpoly(sollya_obj_t, sollya_obj_t,\n sollya_obj_t, sollya_obj_t,\n sollya_obj_t, sollya_obj_t, va_list)\n\nUsage: \n implementpoly({polynomial}, {range}, {error bound}, {format}, {functionname}, {filename}) : (function, range, constant, D|double|DD|doubledouble|TD|tripledouble, string, string) -> function\n implementpoly({polynomial}, {range}, {error bound}, {format}, {functionname}, {filename}, {honor coefficient precisions}) : (function, range, constant, D|double|DD|doubledouble|TD|tripledouble, string, string, honorcoeffprec) -> function\n implementpoly({polynomial}, {range}, {error bound}, {format}, {functionname}, {filename}, {proof filename}) : (function, range, constant, D|double|DD|doubledouble|TD|tripledouble, string, string, string) -> function\n implementpoly({polynomial}, {range}, {error bound}, {format}, {functionname}, {filename}, {honor coefficient precisions}, {proof filename}) : (function, range, constant, D|double|DD|doubledouble|TD|tripledouble, string, string, honorcoeffprec, string) -> function\n\nDescription: \n * The command implementpoly implements the polynomial {polynomial} in range\n {range} as a function called {functionname} in C code\n using double, double-double and triple-double arithmetic in a way that\n the rounding error (estimated at its first order) is bounded by {error bound}. \n The produced code is output in a file named {filename}. The\n argument {format} indicates the double, double-double or triple-double\n format of the variable in which the polynomial varies, influencing\n also in the signature of the C function.\n \n If a seventh or eighth argument {proof filename} is given and if this\n argument evaluates to a variable of type string, the command\n implementpoly will produce a Gappa proof that the\n rounding error is less than the given bound. This proof will be output\n in Gappa syntax in a file name {proof filename}.\n \n The command implementpoly returns the polynomial that has been\n implemented. As the command implementpoly tries to adapt the precision\n needed in each evaluation step to its strict minimum and as it applies\n renormalization to double-double and triple-double precision\n coefficients to bring them to a round-to-nearest expansion form, the\n returned polynomial may differ from the polynomial\n {polynomial}. Nevertheless the difference will be small enough that\n the rounding error bound with regard to the polynomial {polynomial}\n (estimated at its first order) will be less than the given error\n bound.\n \n If a seventh argument {honor coefficient precisions} is given and\n evaluates to a variable honorcoeffprec of type honorcoeffprec,\n implementpoly will honor the precision of the given polynomial\n {polynomials}. This means if a coefficient needs a double-double or a\n triple-double to be exactly stored, implementpoly will allocate appropriate\n space and use a double-double or triple-double operation even if the\n automatic (heuristic) determination implemented in command implementpoly\n indicates that the coefficient could be stored on less precision or,\n respectively, the operation could be performed with less\n precision. The use of honorcoeffprec has advantages and\n disadvantages. If the polynomial {polynomial} given has not been\n determined by a process considering directly polynomials with\n floating-point coefficients, honorcoeffprec should not be\n indicated. The implementpoly command can then determine the needed\n precision using the same error estimation as used for the\n determination of the precisions of the operations. Generally, the\n coefficients will get rounded to double, double-double and\n triple-double precision in a way that minimizes their number and\n respects the rounding error bound {error bound}. Indicating\n honorcoeffprec may in this case short-circuit most precision\n estimations leading to sub-optimal code. On the other hand, if the\n polynomial {polynomial} has been determined with floating-point\n precisions in mind, honorcoeffprec should be indicated because such\n polynomials often are very sensitive in terms of error propagation with\n regard to their coefficients' values. Indicating honorcoeffprec\n prevents the implementpoly command from rounding the coefficients and\n altering by many orders of magnitude the approximation error of the\n polynomial with regard to the function it approximates.\n \n The implementer behind the implementpoly command makes some assumptions on\n its input and verifies them. If some assumption cannot be verified,\n the implementation will not succeed and implementpoly will evaluate to a\n variable error of type error. The same behaviour is observed if\n some file is not writable or some other side-effect fails, e.g. if\n the implementer runs out of memory.\n \n As error estimation is performed only on the first order, the code\n produced by the implementpoly command should be considered valid iff a\n Gappa proof has been produced and successfully run\n in Gappa.\n\nExample 1: \n > implementpoly(1 - 1/6 * x^2 + 1/120 * x^4, [-1b-10;1b-10], 1b-30, D, \"p\",\"implementation.c\");\n 1 + x^2 * (-0.166666666666666657414808128123695496469736099243164 + x^2 * 8.3333333333333332176851016015461937058717012405396e-3)\n > bashevaluate(\"tail -n -29 implementation.c\");\n #define p_coeff_0h 1.00000000000000000000000000000000000000000000000000000000000000000000000000000000e+00\n #define p_coeff_2h -1.66666666666666657414808128123695496469736099243164062500000000000000000000000000e-01\n #define p_coeff_4h 8.33333333333333321768510160154619370587170124053955078125000000000000000000000000e-03\n \n \n void p(double *p_resh, double x) {\n double p_x_0_pow2h;\n \n \n p_x_0_pow2h = x * x;\n \n \n double p_t_1_0h;\n double p_t_2_0h;\n double p_t_3_0h;\n double p_t_4_0h;\n double p_t_5_0h;\n \n \n \n p_t_1_0h = p_coeff_4h;\n p_t_2_0h = p_t_1_0h * p_x_0_pow2h;\n p_t_3_0h = p_coeff_2h + p_t_2_0h;\n p_t_4_0h = p_t_3_0h * p_x_0_pow2h;\n p_t_5_0h = p_coeff_0h + p_t_4_0h;\n *p_resh = p_t_5_0h;\n \n \n }\n\nExample 2: \n > implementpoly(1 - 1/6 * x^2 + 1/120 * x^4, [-1b-10;1b-10], 1b-30, D, \"p\",\"implementation.c\",\"implementation.gappa\");\n 1 + x^2 * (-0.166666666666666657414808128123695496469736099243164 + x^2 * 8.3333333333333332176851016015461937058717012405396e-3)\n\nExample 3: \n > verbosity = 1!;\n > q = implementpoly(1 - dirtysimplify(TD(1/6)) * x^2,[-1b-10;1b-10],1b-60,DD,\"p\",\"implementation.c\");\n Warning: at least one of the coefficients of the given polynomial has been rounded in a way\n that the target precision can be achieved at lower cost. Nevertheless, the implemented polynomial\n is different from the given one.\n > printexpansion(q);\n 0x3ff0000000000000 + x^2 * 0xbfc5555555555555\n > r = implementpoly(1 - dirtysimplify(TD(1/6)) * x^2,[-1b-10;1b-10],1b-60,DD,\"p\",\"implementation.c\",honorcoeffprec);\n Warning: the inferred precision of the 2th coefficient of the polynomial is greater than\n the necessary precision computed for this step. This may make the automatic determination\n of precisions useless.\n > printexpansion(r);\n 0x3ff0000000000000 + x^2 * (0xbfc5555555555555 + 0xbc65555555555555 + 0xb905555555555555)\n\nExample 4: \n > p = 0x3ff0000000000000 + x * (0x3ff0000000000000 + x * (0x3fe0000000000000 + x * (0x3fc5555555555559 + x * (0x3fa55555555555bd + x * (0x3f811111111106e2 + x * (0x3f56c16c16bf5eb7 + x * (0x3f2a01a01a292dcd + x * (0x3efa01a0218a016a + x * (0x3ec71de360331aad + x * (0x3e927e42e3823bf3 + x * (0x3e5ae6b2710c2c9a + x * (0x3e2203730c0a7c1d + x * 0x3de5da557e0781df))))))))))));\n > q = implementpoly(p,[-1/2;1/2],1b-60,D,\"p\",\"implementation.c\",honorcoeffprec,\"implementation.gappa\");\n > if (q != p) then print(\"During implementation, rounding has happened.\") else print(\"Polynomial implemented as given.\");\t\n Polynomial implemented as given.\n\nSee also: honorcoeffprec, roundcoefficients, double, doubledouble, tripledouble, bashevaluate, printexpansion, error, remez, fpminimax, taylor, implementconstant\n"
##############################################
sollya-7.0+ds/internlexer.l-96-#undef fprintf
sollya-7.0+ds/internlexer.l:97:#define fprintf UNUSED_PARAM(yyscanner); sollyaFprintf
sollya-7.0+ds/internlexer.l-98-/* End of fprintf mess */
##############################################
sollya-7.0+ds/lexer.l-99-#undef fprintf
sollya-7.0+ds/lexer.l:100:#define fprintf UNUSED_PARAM(yyscanner); sollyaFprintf
sollya-7.0+ds/lexer.l-101-/* End of fprintf mess */
##############################################
sollya-7.0+ds/library.c-351- errorOccurred = 0;
sollya-7.0+ds/library.c:352: if (dladdr(func, &myInfo) != 0) {
sollya-7.0+ds/library.c-353- if ((myInfo.dli_sname != NULL) && (myInfo.dli_saddr != NULL)) {
##############################################
sollya-7.0+ds/minilexer.l-94-#undef fprintf
sollya-7.0+ds/minilexer.l:95:#define fprintf UNUSED_PARAM(yyscanner); sollyaFprintf
sollya-7.0+ds/minilexer.l-96-/* End of fprintf mess */
##############################################
sollya-7.0+ds/tests-tool/check.proto-2-then
sollya-7.0+ds/tests-tool/check.proto:3: srcdir=`dirname "$0"`
sollya-7.0+ds/tests-tool/check.proto-4- SOLLYA="${srcdir}/${SOLLYA}"
##############################################
sollya-7.0+ds/.pc/debianization.patch/configure.ac-112-AC_MSG_CHECKING([flex supports interactive and pure lexers])
sollya-7.0+ds/.pc/debianization.patch/configure.ac:113:if test `echo -e "%{\n%}\n\n%option always-interactive\n%option reentrant\n%option prefix=\"coucou\"\n%option bison-bridge\n%option nounput\n\n%%\n"test" { }\n%%\n" > conftest.l ; $LEX conftest.l > /dev/null 2> /dev/null ; echo $?; rm -f lex.coucou.c` -eq 0
sollya-7.0+ds/.pc/debianization.patch/configure.ac-114-then
##############################################
sollya-7.0+ds/.pc/debianization.patch/configure.ac-126-AC_MSG_CHECKING([bison supports interactive and pure parsers])
sollya-7.0+ds/.pc/debianization.patch/configure.ac:127:if test `echo -e "%{\n#define YYERROR_VERBOSE 1\n#define YYPARSE_PARAM scanner\n#define YYLEX_PARAM scanner\n%}\n\n%defines\n%name-prefix \"internyy\"\n%pure-parser\n\n%%\nstart: \".\"\n{ }\n;\n\n" > conftest.y ; $YACC conftest.y > /dev/null 2> /dev/null ; echo $?; rm -f y.tab.*` -eq 0
sollya-7.0+ds/.pc/debianization.patch/configure.ac-128-then
##############################################
sollya-7.0+ds/.pc/debianization.patch/configure.ac-340-then
sollya-7.0+ds/.pc/debianization.patch/configure.ac:341: AM_CPPFLAGS="$AM_CPPFLAGS "`$XML2CONFIG --cflags`
sollya-7.0+ds/.pc/debianization.patch/configure.ac-342-fi
##############################################
sollya-7.0+ds/.pc/debianization.patch/configure.ac-345-then
sollya-7.0+ds/.pc/debianization.patch/configure.ac:346: XML2LIBS=`$XML2CONFIG --libs --static`
sollya-7.0+ds/.pc/debianization.patch/configure.ac:347: XML2LIBSPURE=`$XML2CONFIG --libs | $SED -e 's/^-l//g;s/[[[:blank:]]]-l//g;'`
sollya-7.0+ds/.pc/debianization.patch/configure.ac-348- AC_SEARCH_LIBS([xmlTextReaderIsEmptyElement], [$XML2LIBSPURE], [], [], [$XML2LIBS])
##############################################
sollya-7.0+ds/.pc/debianization.patch/configure.ac-805- [[ Dl_info myInfo;
sollya-7.0+ds/.pc/debianization.patch/configure.ac:806: if (dladdr(main, &myInfo) != 0) return 0;
sollya-7.0+ds/.pc/debianization.patch/configure.ac-807- exit(1);]]
##############################################
sollya-7.0+ds/configure.ac-112-AC_MSG_CHECKING([flex supports interactive and pure lexers])
sollya-7.0+ds/configure.ac:113:if test `echo -e "%{\n%}\n\n%option always-interactive\n%option reentrant\n%option prefix=\"coucou\"\n%option bison-bridge\n%option nounput\n\n%%\n"test" { }\n%%\n" > conftest.l ; $LEX conftest.l > /dev/null 2> /dev/null ; echo $?; rm -f lex.coucou.c` -eq 0
sollya-7.0+ds/configure.ac-114-then
##############################################
sollya-7.0+ds/configure.ac-126-AC_MSG_CHECKING([bison supports interactive and pure parsers])
sollya-7.0+ds/configure.ac:127:if test `echo -e "%{\n#define YYERROR_VERBOSE 1\n#define YYPARSE_PARAM scanner\n#define YYLEX_PARAM scanner\n%}\n\n%defines\n%name-prefix \"internyy\"\n%pure-parser\n\n%%\nstart: \".\"\n{ }\n;\n\n" > conftest.y ; $YACC conftest.y > /dev/null 2> /dev/null ; echo $?; rm -f y.tab.*` -eq 0
sollya-7.0+ds/configure.ac-128-then
##############################################
sollya-7.0+ds/configure.ac-340-then
sollya-7.0+ds/configure.ac:341: AM_CPPFLAGS="$AM_CPPFLAGS "`$XML2CONFIG --cflags`
sollya-7.0+ds/configure.ac-342-fi
##############################################
sollya-7.0+ds/configure.ac-345-then
sollya-7.0+ds/configure.ac:346: XML2LIBS=`$XML2CONFIG --libs --static`
sollya-7.0+ds/configure.ac:347: XML2LIBSPURE=`$XML2CONFIG --libs | $SED -e 's/^-l//g;s/[[[:blank:]]]-l//g;'`
sollya-7.0+ds/configure.ac-348- AC_SEARCH_LIBS([xmlTextReaderIsEmptyElement], [$XML2LIBSPURE], [], [], [$XML2LIBS])
##############################################
sollya-7.0+ds/configure.ac-805- [[ Dl_info myInfo;
sollya-7.0+ds/configure.ac:806: if (dladdr(main, &myInfo) != 0) return 0;
sollya-7.0+ds/configure.ac-807- exit(1);]]