Code coverage tests

This page documents the degree to which the PARI/GP source code is tested by our public test suite, distributed with the source distribution in directory src/test/. This is measured by the gcov utility; we then process gcov output using the lcov frond-end.

We test a few variants depending on Configure flags on the pari.math.u-bordeaux1.fr machine (x86_64 architecture), and agregate them in the final report:

The target is 90% coverage for all mathematical modules (given that branches depending on DEBUGLEVEL or DEBUGMEM are not covered). This script is run to produce the results below.

LCOV - code coverage report
Current view: top level - gp - gp.c (source / functions) Hit Total Coverage
Test: PARI/GP v2.8.0 lcov report (development 16962-5a32637) Lines: 199 342 58.2 %
Date: 2014-10-29 Functions: 17 29 58.6 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 79 194 40.7 %

           Branch data     Line data    Source code
       1                 :            : /* Copyright (C) 2000  The PARI group.
       2                 :            : 
       3                 :            : This file is part of the PARI/GP package.
       4                 :            : 
       5                 :            : PARI/GP is free software; you can redistribute it and/or modify it under the
       6                 :            : terms of the GNU General Public License as published by the Free Software
       7                 :            : Foundation. It is distributed in the hope that it will be useful, but WITHOUT
       8                 :            : ANY WARRANTY WHATSOEVER.
       9                 :            : 
      10                 :            : Check the License for details. You should have received a copy of it, along
      11                 :            : with the package; see the file 'COPYING'. If not, write to the Free Software
      12                 :            : Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */
      13                 :            : 
      14                 :            : /*******************************************************************/
      15                 :            : /**                                                               **/
      16                 :            : /**                        PARI CALCULATOR                        **/
      17                 :            : /**                                                               **/
      18                 :            : /*******************************************************************/
      19                 :            : #include "pari.h"
      20                 :            : #include "paripriv.h"
      21                 :            : #include "gp.h"
      22                 :            : 
      23                 :            : static jmp_buf *env;
      24                 :            : static pari_stack s_env;
      25                 :            : void (*cb_gp_output)(GEN z) = NULL;
      26                 :            : void (*cb_pari_end_output)(void) = NULL;
      27                 :            : 
      28                 :            : static void
      29                 :          0 : gp_ask_confirm(const char *s)
      30                 :            : {
      31                 :          0 :   err_printf(s);
      32                 :          0 :   err_printf(". OK ? (^C if not)\n");
      33                 :          0 :   pari_hit_return();
      34                 :          0 : }
      35                 :            : 
      36                 :            : /* numerr < 0: from SIGINT */
      37                 :            : static void
      38                 :        112 : gp_err_recover(long numerr)
      39                 :            : {
      40                 :        112 :   longjmp(env[s_env.n-1], numerr);
      41                 :            : }
      42                 :            : /* numerr < 0: from SIGINT */
      43                 :            : static void
      44                 :       5906 : gp_pre_recover(long numerr)
      45                 :            : {
      46         [ +  - ]:       5906 :   if (numerr>=0)
      47                 :            :   {
      48                 :       5906 :     out_puts(pariErr, "\n"); pariErr->flush();
      49                 :            :   }
      50                 :       5906 :   longjmp(env[s_env.n-1], numerr);
      51                 :            : }
      52                 :            : 
      53                 :            : static void
      54                 :      45884 : reset_ctrlc(void)
      55                 :            : {
      56                 :            : #if defined(_WIN32) || defined(__CYGWIN32__)
      57                 :            :   win32ctrlc = 0;
      58                 :            : #endif
      59                 :      45884 : }
      60                 :            : 
      61                 :            : static int
      62                 :      27060 : is_silent(char *s) { return s[strlen(s) - 1] == ';'; }
      63                 :            : 
      64                 :            : static int stdin_isatty = 0;
      65                 :            : static int
      66                 :       1223 : is_interactive(void)
      67 [ +  - ][ -  + ]:       1223 : { return pari_infile == stdin && stdin_isatty; }
      68                 :            : 
      69                 :            : /*******************************************************************/
      70                 :            : /**                                                               **/
      71                 :            : /**                        INITIALIZATION                         **/
      72                 :            : /**                                                               **/
      73                 :            : /*******************************************************************/
      74                 :            : static void
      75                 :          0 : print_shortversion(void)
      76                 :            : {
      77                 :          0 :   const ulong mask = (1UL<<PARI_VERSION_SHIFT) - 1;
      78                 :          0 :   ulong n = paricfg_version_code, major, minor, patch;
      79                 :            : 
      80                 :          0 :   patch = n & mask; n >>= PARI_VERSION_SHIFT;
      81                 :          0 :   minor = n & mask; n >>= PARI_VERSION_SHIFT;
      82                 :          0 :   major = n;
      83                 :          0 :   printf("%lu.%lu.%lu\n", major,minor,patch); exit(0);
      84                 :            : }
      85                 :            : 
      86                 :            : static void
      87                 :          0 : usage(char *s)
      88                 :            : {
      89                 :          0 :   printf("### Usage: %s [options] [GP files]\n", s);
      90                 :          0 :   printf("Available options:\n");
      91                 :          0 :   printf("  [-f,--fast]\t\tFast start: do not read .gprc\n");
      92                 :          0 :   printf("  [-q,--quiet]\t\tQuiet mode: do not print banner and history numbers\n");
      93                 :          0 :   printf("  [-s stacksize]\tStart with the PARI stack of given size (in bytes)\n");
      94                 :          0 :   printf("  [--default key=val]\tExecute default(key,val) on startup\n");
      95                 :          0 :   printf("  [--emacs]\t\tRun as if in Emacs shell\n");
      96                 :          0 :   printf("  [--help]\t\tPrint this message\n");
      97                 :          0 :   printf("  [--test]\t\tTest mode. No history, wrap long lines (bench only)\n");
      98                 :          0 :   printf("  [--texmacs]\t\tRun as if using TeXmacs frontend\n");
      99                 :          0 :   printf("  [--version]\t\tOutput version info and exit\n");
     100                 :          0 :   printf("  [--version-short]\tOutput version number and exit\n\n");
     101                 :          0 :   exit(0);
     102                 :            : }
     103                 :            : 
     104                 :            : static void
     105                 :          0 : gp_head(void)
     106                 :            : {
     107                 :          0 :   pari_print_version();
     108                 :          0 :   pari_putc('\n');
     109                 :          0 :   pari_center("Copyright (C) 2000-2014 The PARI Group");
     110                 :          0 :   pari_putc('\n');
     111                 :          0 :   print_text("PARI/GP is free software, covered by the GNU General Public \
     112                 :            : License, and comes WITHOUT ANY WARRANTY WHATSOEVER.");
     113                 :          0 :   pari_puts("\nType ? for help, \\q to quit.\n");
     114                 :          0 :   print_text("Type ?13 for how to get moral (and possibly technical) support.");
     115         [ #  # ]:          0 :   if (pari_mainstack->vsize)
     116                 :          0 :     pari_printf("\nparisizemax = %lu, primelimit = %lu",
     117                 :          0 :                 pari_mainstack->vsize,GP_DATA->primelimit);
     118                 :            :   else
     119                 :          0 :     pari_printf("\nparisize = %lu, primelimit = %lu",
     120                 :          0 :                 pari_mainstack->rsize,GP_DATA->primelimit);
     121         [ #  # ]:          0 :   if (pari_mt_nbthreads > 1)
     122                 :          0 :     pari_printf(", nbthreads = %lu", pari_mt_nbthreads);
     123                 :          0 :   pari_putc('\n');
     124                 :          0 : }
     125                 :            : 
     126                 :            : static char *
     127                 :          0 : read_arg(long *nread, char *t, long argc, char **argv)
     128                 :            : {
     129                 :          0 :   long i = *nread;
     130         [ #  # ]:          0 :   if (isdigit((int)*t)) return t;
     131 [ #  # ][ #  # ]:          0 :   if (*t || i==argc) usage(argv[0]);
     132                 :          0 :   *nread = i+1; return argv[i];
     133                 :            : }
     134                 :            : 
     135                 :            : static char *
     136                 :          0 : read_arg_equal(long *nread, char *t, long argc, char **argv)
     137                 :            : {
     138                 :          0 :   long i = *nread;
     139 [ #  # ][ #  # ]:          0 :   if (*t=='=' && isdigit((int)t[1])) return t+1;
     140 [ #  # ][ #  # ]:          0 :   if (*t || i==argc) usage(argv[0]);
     141                 :          0 :   *nread = i+1; return argv[i];
     142                 :            : }
     143                 :            : 
     144                 :            : static void
     145                 :          0 : init_trivial_stack(void)
     146                 :            : {
     147                 :          0 :   const size_t s = 2048;
     148                 :          0 :   pari_mainstack->size = s;
     149                 :          0 :   pari_mainstack->bot = (pari_sp)pari_malloc(s);
     150                 :          0 :   avma = pari_mainstack->top = pari_mainstack->bot + s;
     151                 :          0 : }
     152                 :            : 
     153                 :            : static void
     154                 :          0 : free_trivial_stack(void)
     155                 :            : {
     156                 :          0 :   free((void*)pari_mainstack->bot);
     157                 :          0 : }
     158                 :            : 
     159                 :            : typedef struct { char *key, *val; } pair_t;
     160                 :            : /* If ab of the form key=val, record pair in new stack entry
     161                 :            :  * P[n].key must be freed by caller to avoid memory leak */
     162                 :            : static void
     163                 :          0 : record_default(pari_stack *s_P, char *ab)
     164                 :            : {
     165                 :          0 :   pair_t *P = (pair_t*)*pari_stack_base(s_P);
     166                 :            :   char *k, *v;
     167                 :            :   long n;
     168                 :          0 :   ab = pari_strdup(ab);
     169                 :          0 :   parse_key_val(ab, &k, &v);
     170                 :          0 :   n = pari_stack_new(s_P);
     171                 :          0 :   P[n].key = k;
     172                 :          0 :   P[n].val = v;
     173                 :          0 : }
     174                 :            : static void
     175                 :       1201 : read_opt(pari_stack *p_A, long argc, char **argv)
     176                 :            : {
     177                 :            :   pair_t *P;
     178                 :            :   pari_stack s_P; /* key / value to record default() settings */
     179                 :       1201 :   char *b = NULL, *p = NULL, *s = NULL;
     180                 :       1201 :   ulong f = GP_DATA->flags;
     181                 :       1201 :   long i = 1, initrc = 1;
     182                 :            : 
     183                 :            :   (void)&p; (void)&b; (void)&s; /* -Wall gcc-2.95 */
     184                 :            : 
     185                 :       1201 :   pari_stack_init(&s_P,sizeof(*P),(void**)&P);
     186                 :       1201 :   pari_stack_alloc(&s_P, 64);
     187                 :       1201 :   pari_outfile = stderr;
     188         [ +  + ]:       3603 :   while (i < argc)
     189                 :            :   {
     190                 :       2402 :     char *t = argv[i];
     191                 :            : 
     192         [ -  + ]:       2402 :     if (*t++ != '-') break;
     193                 :       2402 :     i++;
     194                 :            : START:
     195   [ -  -  -  +  :       2402 :     switch(*t++)
             -  +  -  +  
                      - ]
     196                 :            :     {
     197                 :          0 :       case 'p': p = read_arg(&i,t,argc,argv); break;
     198                 :          0 :       case 's': s = read_arg(&i,t,argc,argv); break;
     199                 :            :       case 'e':
     200         [ #  # ]:          0 :         f |= gpd_EMACS; if (*t) goto START;
     201                 :          0 :         break;
     202                 :            :       case 'q':
     203         [ -  + ]:       1201 :         f |= gpd_QUIET; if (*t) goto START;
     204                 :       1201 :         break;
     205                 :            :       case 't':
     206         [ #  # ]:          0 :         f |= gpd_TEST; if (*t) goto START;
     207                 :          0 :         break;
     208                 :            :       case 'f':
     209         [ -  + ]:         11 :         initrc = 0; if (*t) goto START;
     210                 :         11 :         break;
     211                 :            :       case 'D':
     212 [ #  # ][ #  # ]:          0 :         if (*t || i == argc) usage(argv[0]);
     213                 :          0 :         record_default(&s_P, argv[i++]);
     214                 :          0 :         break;
     215                 :            :       case '-':
     216         [ -  + ]:       1190 :         if (strcmp(t, "version-short") == 0) { print_shortversion(); exit(0); }
     217         [ -  + ]:       1190 :         if (strcmp(t, "version") == 0) {
     218                 :          0 :           init_trivial_stack(); pari_print_version();
     219                 :          0 :           free_trivial_stack(); exit(0);
     220                 :            :         }
     221         [ -  + ]:       1190 :         if (strcmp(t, "default") == 0) {
     222         [ #  # ]:          0 :           if (i == argc) usage(argv[0]);
     223                 :          0 :           record_default(&s_P, argv[i++]);
     224                 :          0 :           break;
     225                 :            :         }
     226         [ -  + ]:       1190 :         if (strcmp(t, "texmacs") == 0) { f |= gpd_TEXMACS; break; }
     227         [ -  + ]:       1190 :         if (strcmp(t, "emacs") == 0) { f |= gpd_EMACS; break; }
     228         [ +  - ]:       1190 :         if (strcmp(t, "test") == 0) { f |= gpd_TEST; initrc = 0; break; }
     229         [ #  # ]:          0 :         if (strcmp(t, "quiet") == 0) { f |= gpd_QUIET; break; }
     230         [ #  # ]:          0 :         if (strcmp(t, "fast") == 0) { initrc = 0; break; }
     231         [ #  # ]:          0 :         if (strncmp(t, "primelimit",10) == 0) {p = read_arg_equal(&i,t+10,argc,argv); break; }
     232         [ #  # ]:          0 :         if (strncmp(t, "stacksize",9) == 0) {s = read_arg_equal(&i,t+9,argc,argv); break; }
     233                 :            :        /* fall through */
     234                 :            :       default:
     235                 :          0 :         usage(argv[0]);
     236                 :            :     }
     237                 :            :   }
     238                 :       1201 :   GP_DATA->flags = f;
     239                 :            : #ifdef READLINE
     240                 :       1201 :   GP_DATA->use_readline = stdin_isatty;
     241                 :            : #endif
     242         [ +  - ]:       1201 :   if (!is_interactive()) GP_DATA->breakloop = 0;
     243         [ -  + ]:       1201 :   if (initrc) gp_initrc(p_A);
     244         [ -  + ]:       1201 :   for ( ; i < argc; i++) pari_stack_pushp(p_A, pari_strdup(argv[i]));
     245                 :            : 
     246                 :            :   /* override the values from gprc */
     247         [ -  + ]:       1201 :   if (p) (void)sd_primelimit(p, d_INITRC);
     248         [ -  + ]:       1201 :   if (s) (void)sd_parisize(s, d_INITRC);
     249         [ -  + ]:       1201 :   for (i = 0; i < s_P.n; i++) {
     250                 :          0 :     setdefault(P[i].key, P[i].val, d_INITRC);
     251                 :          0 :     free((void*)P[i].key);
     252                 :            :   }
     253                 :       1201 :   pari_stack_delete(&s_P);
     254                 :       1201 :   pari_outfile = stdout;
     255                 :       1201 : }
     256                 :            : 
     257                 :            : /*******************************************************************/
     258                 :            : /**                                                               **/
     259                 :            : /**                            TEST MODE                          **/
     260                 :            : /**                                                               **/
     261                 :            : /*******************************************************************/
     262                 :            : static int
     263                 :      53661 : test_is_interactive(void) { return 0; }
     264                 :            : 
     265                 :            : static void
     266                 :      18542 : test_output(GEN z)
     267                 :            : {
     268                 :      18542 :   init_linewrap(76);
     269                 :      18542 :   gen_output(z, GP_DATA->fmt);
     270                 :      18542 :   pari_putc('\n');
     271                 :      18542 :   pari_flush();
     272                 :      18542 : }
     273                 :            : void
     274                 :       1190 : init_test(void)
     275                 :            : {
     276                 :       1190 :   disable_color = 1;
     277                 :       1190 :   init_linewrap(76);
     278                 :       1190 :   cb_gp_output = test_output;
     279                 :       1190 :   cb_pari_is_interactive = test_is_interactive;
     280                 :       1190 : }
     281                 :            : 
     282                 :            : /*******************************************************************/
     283                 :            : /**                                                               **/
     284                 :            : /**                   FORMAT GP OUTPUT                            **/
     285                 :            : /**                                                               **/
     286                 :            : /*******************************************************************/
     287                 :            :     /* REGULAR */
     288                 :            : static void
     289                 :          0 : normal_output(GEN z, long n)
     290                 :            : {
     291                 :          0 :   long l = 0;
     292                 :            :   char *s;
     293                 :            :   /* history number */
     294         [ #  # ]:          0 :   if (n)
     295                 :            :   {
     296                 :            :     char buf[64];
     297         [ #  # ]:          0 :     if (!(GP_DATA->flags & gpd_QUIET))
     298                 :            :     {
     299                 :          0 :       term_color(c_HIST);
     300                 :          0 :       sprintf(buf, "%%%ld = ", n);
     301                 :          0 :       pari_puts(buf);
     302                 :          0 :       l = strlen(buf);
     303                 :            :     }
     304                 :            :   }
     305                 :            :   /* output */
     306                 :          0 :   term_color(c_OUTPUT);
     307                 :          0 :   s = GENtostr(z);
     308         [ #  # ]:          0 :   if (GP_DATA->lim_lines)
     309                 :          0 :     lim_lines_output(s, l, GP_DATA->lim_lines);
     310                 :            :   else
     311                 :          0 :     pari_puts(s);
     312                 :          0 :   pari_free(s);
     313                 :          0 :   term_color(c_NONE); pari_putc('\n');
     314                 :          0 : }
     315                 :            : 
     316                 :            : static void
     317                 :      18542 : gp_output(GEN z)
     318                 :            : {
     319         [ +  - ]:      18542 :   if (cb_gp_output) { cb_gp_output(z); return; }
     320         [ #  # ]:          0 :   if (GP_DATA->fmt->prettyp == f_PRETTY)
     321         [ #  # ]:          0 :   { if (tex2mail_output(z, GP_DATA->hist->total)) return; }
     322                 :          0 :   normal_output(z, GP_DATA->hist->total);
     323                 :      18542 :   pari_flush();
     324                 :            : }
     325                 :            : 
     326                 :            : static GEN
     327                 :       1201 : gp_main_loop(long ismain)
     328                 :            : {
     329                 :       1201 :   VOLATILE GEN z = gnil;
     330                 :       1201 :   VOLATILE long t = 0;
     331                 :       1201 :   VOLATILE pari_sp av = avma;
     332                 :            :   filtre_t F;
     333                 :       1201 :   Buffer *b = filtered_buffer(&F);
     334                 :            :   struct gp_context rec;
     335                 :            :   long er;
     336         [ +  + ]:       1201 :   if ((er = setjmp(env[s_env.n-1])))
     337                 :            :   { /* recover: jump from error [ > 0 ] or allocatemem [ -1 ] */
     338         [ +  + ]:       6011 :     if (er > 0) { /* true error */
     339         [ -  + ]:       5906 :       if (!(GP_DATA->recover)) exit(1);
     340                 :       5906 :       gp_context_restore(&rec);
     341                 :            :       /* true error not from main instance, let caller sort it out */
     342         [ -  + ]:       5906 :       if (!ismain) { kill_buffers_upto_including(b); return NULL; }
     343                 :            :     } else { /* allocatemem */
     344                 :        105 :       filestate_restore(rec.file);
     345                 :        105 :       gp_context_save(&rec);
     346                 :            :     }
     347                 :       6011 :     avma = av = pari_mainstack->top;
     348                 :       6011 :     parivstack_reset();
     349                 :       6011 :     kill_buffers_upto(b);
     350                 :       6011 :     pari_alarm(0);
     351                 :            :   }
     352                 :            :   for(;;)
     353                 :            :   {
     354                 :      46968 :     gp_context_save(&rec);
     355         [ +  + ]:      46968 :     if (! gp_read_line(&F, NULL))
     356                 :            :     {
     357         [ +  - ]:       1189 :       if (popinfile()) gp_quit(0);
     358         [ #  # ]:          0 :       if (ismain) continue;
     359                 :          0 :       pop_buffer(); return z;
     360                 :            :     }
     361                 :      45779 :     avma = av;
     362         [ +  - ]:      45779 :     if (ismain)
     363                 :            :     {
     364                 :      45779 :       reset_ctrlc();
     365                 :      45779 :       timer_start(GP_DATA->T);
     366                 :      45779 :       pari_set_last_newline(1);
     367                 :            :     }
     368         [ +  + ]:      45779 :     if (gp_meta(b->buf,ismain)) continue;
     369                 :      39066 :     z = pari_compile_str(b->buf);
     370                 :      39045 :     z = closure_evalres(z);
     371         [ -  + ]:      33043 :     if (!ismain) continue;
     372                 :      33043 :     pari_alarm(0);
     373                 :            : 
     374         [ +  + ]:      33043 :     if (!pari_last_was_newline()) pari_putc('\n');
     375                 :            : 
     376                 :      33043 :     t = timer_delay(GP_DATA->T);
     377 [ +  + ][ -  + ]:      33043 :     if (t && GP_DATA->chrono)
     378                 :            :     {
     379                 :          0 :       pari_puts("time = ");
     380                 :          0 :       pari_puts(gp_format_time(t));
     381                 :            :     }
     382         [ +  - ]:      33043 :     if (GP_DATA->simplify) z = simplify_shallow(z);
     383                 :      33043 :     pari_add_hist(z, t);
     384 [ +  + ][ +  + ]:      33043 :     if (z != gnil && ! is_silent(b->buf) ) gp_output(z);
     385                 :      33043 :     parivstack_reset();
     386                 :      39756 :   }
     387                 :            : }
     388                 :            : 
     389                 :            : /* as gp_read_file, before running the main gp instance */
     390                 :            : static void
     391                 :          0 : read_main(const char *s)
     392                 :            : {
     393                 :            :   GEN z;
     394         [ #  # ]:          0 :   if (setjmp(env[s_env.n-1]))
     395                 :          0 :     z = NULL;
     396                 :            :   else {
     397                 :          0 :     FILE *f = switchin(s);
     398         [ #  # ]:          0 :     if (file_is_binary(f)) {
     399                 :          0 :       z = readbin(s,f, NULL);
     400                 :          0 :       popinfile();
     401                 :            :     }
     402                 :          0 :     else z = gp_main_loop(0);
     403                 :            :   }
     404         [ #  # ]:          0 :   if (!z) err_printf("... skipping file '%s'\n", s);
     405                 :          0 :   avma = pari_mainstack->top;
     406                 :          0 : }
     407                 :            : 
     408                 :            : static long frame_level=0, dbg_level = 0;
     409                 :            : 
     410                 :            : static int
     411                 :         49 : break_loop(int numerr)
     412                 :            : {
     413                 :            :   filtre_t F;
     414                 :            :   Buffer *b;
     415                 :         49 :   int sigint = numerr<0, go_on = sigint;
     416                 :            :   struct gp_context rec;
     417                 :            :   const char *prompt, *msg;
     418                 :         49 :   long nenv, oldframe_level = frame_level;
     419                 :            :   pari_sp av;
     420                 :            : 
     421         [ -  + ]:         49 :   if (numerr == e_SYNTAX) return 0;
     422         [ -  + ]:         49 :   if (numerr == e_STACK) { evalstate_clone(); avma = pari_mainstack->top; }
     423                 :            : 
     424                 :         49 :   b = filtered_buffer(&F);
     425                 :         49 :   nenv=pari_stack_new(&s_env);
     426                 :         49 :   prompt = break_loop_prompt(s_env.n-1);
     427                 :         49 :   gp_context_save(&rec);
     428                 :         49 :   iferr_env = NULL;
     429                 :         49 :   dbg_level = 0;
     430                 :         49 :   frame_level = closure_context(oldframe_level, dbg_level);
     431                 :         49 :   pari_infile = newfile(stdin, "stdin", mf_IN)->file;
     432                 :         49 :   term_color(c_ERR); pari_putc('\n');
     433         [ +  + ]:         49 :   if (sigint)
     434                 :          7 :     msg = "Break loop: <Return> to continue; 'break' to go back to GP prompt";
     435                 :            :   else
     436                 :         42 :     msg = "Break loop: type 'break' to go back to GP prompt";
     437                 :         49 :   print_errcontext(pariOut, msg, NULL, NULL);
     438                 :         49 :   term_color(c_NONE);
     439                 :         49 :   av = avma;
     440                 :            :   for(;;)
     441                 :            :   {
     442                 :            :     GEN x;
     443                 :            :     long er, br_status;
     444                 :        105 :     avma = av;
     445         [ +  + ]:        105 :     if ((er=setjmp(env[nenv])))
     446                 :            :     {
     447         [ +  + ]:         14 :       if (er < 0)
     448                 :            :       {
     449                 :          7 :         s_env.n = 1;
     450                 :          7 :         frame_level = oldframe_level;
     451                 :          7 :         longjmp(env[s_env.n-1], er);
     452                 :            :       }
     453                 :          7 :       gp_context_restore(&rec);
     454                 :          7 :       iferr_env = NULL;
     455                 :          7 :       closure_err(dbg_level);
     456                 :          7 :       (void) closure_context(oldframe_level, dbg_level);
     457                 :          7 :       pari_infile = newfile(stdin, "stdin", mf_IN)->file;
     458                 :            :     }
     459                 :        112 :     term_color(c_NONE);
     460         [ -  + ]:        112 :     if (!gp_read_line(&F, prompt))
     461                 :          0 :       br_status = br_BREAK; /* EOF */
     462                 :            :     else
     463                 :            :     {
     464                 :            :       /* Empty input ? Continue if entry on sigint (exit debugger frame) */
     465 [ +  + ][ -  + ]:        112 :       if (! *(b->buf) && sigint) break;
     466                 :        105 :       reset_ctrlc();
     467         [ -  + ]:        105 :       if (gp_meta(b->buf,0)) continue;
     468                 :        105 :       x = pari_compile_str(b->buf);
     469                 :        105 :       x = closure_evalbrk(x, &br_status);
     470                 :            :     }
     471      [ -  +  + ]:         91 :     switch (br_status)
     472                 :            :     {
     473                 :            :       case br_NEXT: case br_MULTINEXT:
     474                 :          0 :         popinfile(); /* exit frame. Don't exit debugger if s_env.n > 2 */
     475                 :          0 :         go_on = 0; goto BR_EXIT;
     476                 :            :       case br_BREAK: case br_RETURN:
     477                 :         35 :         killallfiles(); /* completely exit the debugger */
     478                 :         35 :         go_on = 0; goto BR_EXIT;
     479                 :            :     }
     480                 :            : 
     481 [ +  - ][ +  - ]:         56 :     if (x != gnil && !is_silent(b->buf))
     482                 :            :     {
     483                 :         56 :       term_color(c_OUTPUT);
     484                 :         56 :       gen_output(x, GP_DATA->fmt);
     485                 :         98 :       pari_putc('\n');
     486                 :            :     }
     487                 :         56 :   }
     488                 :            : BR_EXIT:
     489                 :         42 :   s_env.n=nenv;
     490                 :         42 :   frame_level = oldframe_level;
     491                 :         42 :   gp_context_restore(&rec);
     492                 :         42 :   pop_buffer(); return go_on;
     493                 :            : }
     494                 :            : 
     495                 :            : void
     496                 :          7 : dbg_up(long k)
     497                 :            : {
     498         [ -  + ]:          7 :   if (k<0) k=0;
     499                 :          7 :   dbg_level += k;
     500         [ -  + ]:          7 :   if (dbg_level>frame_level) dbg_level=frame_level;
     501                 :          7 :   gp_err_recover(e_NONE);
     502                 :          0 : }
     503                 :            : 
     504                 :            : void
     505                 :          0 : dbg_down(long k)
     506                 :            : {
     507         [ #  # ]:          0 :   if (k<0) k=0;
     508                 :          0 :   dbg_level -= k;
     509         [ #  # ]:          0 :   if (dbg_level<0) dbg_level=0;
     510                 :          0 :   gp_err_recover(e_NONE);
     511                 :          0 : }
     512                 :            : 
     513                 :            : GEN
     514         [ +  - ]:          7 : dbg_err(void) { GEN E = pari_err_last(); return E? gcopy(E):gnil; }
     515                 :            : 
     516                 :            : void
     517                 :          7 : pari_breakpoint(void)
     518                 :            : {
     519         [ -  + ]:          7 :   if (!pari_last_was_newline()) pari_putc('\n');
     520                 :          7 :   closure_err(0);
     521 [ +  - ][ +  - ]:          7 :   if (cb_pari_break_loop && cb_pari_break_loop(-1)) return;
     522                 :          0 :   cb_pari_err_recover(e_MISC);
     523                 :            : }
     524                 :            : 
     525                 :            : void
     526                 :       1189 : gp_quit(long code)
     527                 :            : {
     528                 :       1189 :   free_graph();
     529                 :       1189 :   pari_close();
     530                 :       1189 :   kill_buffers_upto(NULL);
     531         [ -  + ]:       1189 :   if (!(GP_DATA->flags & gpd_QUIET)) pari_puts("Goodbye!\n");
     532         [ -  + ]:       1189 :   if (cb_pari_end_output) cb_pari_end_output();
     533                 :       1189 :   exit(code);
     534                 :            : }
     535                 :            : 
     536                 :            : #ifdef __CYGWIN32__
     537                 :            : void
     538                 :            : cyg_environment(int argc, char ** argv)
     539                 :            : {
     540                 :            :   char *ti_dirs = getenv("TERMINFO_DIRS");
     541                 :            :   char *argv0, *p;
     542                 :            :   char *newdir;
     543                 :            :   long n;
     544                 :            : 
     545                 :            :   if (!argc || !argv) return;
     546                 :            :   argv0 = *argv;
     547                 :            :   if (!argv0 || !*argv0) return;
     548                 :            :   p = strrchr(argv0, '/');
     549                 :            :   if (!p)
     550                 :            :     p = argv0 = "";
     551                 :            :   else
     552                 :            :     p++;
     553                 :            :   n = p - argv0;
     554                 :            :   if (ti_dirs)
     555                 :            :   {
     556                 :            :     n += 14 + strlen(ti_dirs) + 1 + 8 + 1;
     557                 :            :     newdir = malloc(n);
     558                 :            :     if (!newdir) return;
     559                 :            :     snprintf(newdir, n-8, "TERMINFO_DIRS=%s:%s", ti_dirs, argv0);
     560                 :            :   }
     561                 :            :   else
     562                 :            :   {
     563                 :            :     n += 14 + 8 + 1;
     564                 :            :     newdir = malloc(n);
     565                 :            :     if (!newdir) return;
     566                 :            :     snprintf(newdir, n-8, "TERMINFO_DIRS=%s", argv0);
     567                 :            :   }
     568                 :            :   strcpy(newdir+n-9,"terminfo");
     569                 :            :   putenv(newdir);
     570                 :            : }
     571                 :            : #endif
     572                 :            : 
     573                 :            : #ifndef WINCE
     574                 :            : int
     575                 :       1201 : main(int argc, char **argv)
     576                 :            : {
     577                 :            : #else
     578                 :            : int
     579                 :            : WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
     580                 :            :         LPWSTR lpCmdLine, int nShowCmd)
     581                 :            : {
     582                 :            :   char **argv = NULL;
     583                 :            :   int argc = 1;
     584                 :            : #endif
     585                 :            :   char **A;
     586                 :            :   pari_stack s_A;
     587                 :            : 
     588                 :       1201 :   GP_DATA = default_gp_data();
     589                 :       1201 :   pari_stack_init(&s_env, sizeof(*env), (void**)&env);
     590                 :       1201 :   (void)pari_stack_new(&s_env);
     591                 :            : 
     592         [ -  + ]:       1201 :   if (setjmp(env[s_env.n-1]))
     593                 :            :   {
     594                 :          0 :     puts("### Errors on startup, exiting...\n\n");
     595                 :          0 :     exit(1);
     596                 :            :   }
     597                 :            : #ifdef __CYGWIN32__
     598                 :            :   cyg_environment(argc, argv);
     599                 :            : #endif
     600                 :       1201 :   stdin_isatty = pari_stdin_isatty();
     601                 :       1201 :   pari_init_defaults();
     602                 :       1201 :   pari_library_path = DL_DFLT_NAME;
     603                 :       1201 :   pari_stack_init(&s_A,sizeof(*A),(void**)&A);
     604                 :       1201 :   pari_init_opts(1000000 * sizeof(long), 0, INIT_SIGm | INIT_noPRIMEm);
     605                 :       1201 :   cb_pari_err_recover = gp_err_recover;
     606                 :       1201 :   cb_pari_pre_recover = gp_pre_recover;
     607                 :       1201 :   cb_pari_break_loop = break_loop;
     608                 :       1201 :   cb_pari_is_interactive = is_interactive;
     609                 :            : 
     610                 :       1201 :   read_opt(&s_A, argc,argv);
     611                 :       1201 :   initprimetable(GP_DATA->primelimit);
     612                 :            : #ifdef SIGALRM
     613                 :       1201 :   (void)os_signal(SIGALRM,gp_alarm_handler);
     614                 :            : #endif
     615                 :       1201 :   pari_add_module(functions_gp);
     616                 :       1201 :   pari_add_module(functions_highlevel);
     617                 :            : 
     618                 :       1201 :   init_graph();
     619                 :            : #ifdef READLINE
     620                 :       1201 :   init_readline();
     621                 :            : #endif
     622                 :       1201 :   cb_pari_quit = gp_quit;
     623                 :       1201 :   cb_pari_whatnow = whatnow;
     624                 :       1201 :   cb_pari_sigint = gp_sigint_fun;
     625                 :       1201 :   cb_pari_handle_exception = gp_handle_exception;
     626                 :       1201 :   cb_pari_ask_confirm = gp_ask_confirm;
     627                 :       1201 :   gp_expand_path(GP_DATA->path);
     628         [ -  + ]:       1201 :   if (GP_DATA->flags & gpd_EMACS) init_emacs();
     629         [ -  + ]:       1201 :   if (GP_DATA->flags & gpd_TEXMACS) init_texmacs();
     630         [ +  + ]:       1201 :   if (GP_DATA->flags & gpd_TEST) init_test();
     631                 :            : 
     632                 :       1201 :   timer_start(GP_DATA->T);
     633         [ -  + ]:       1201 :   if (!(GP_DATA->flags & gpd_QUIET)) gp_head();
     634         [ -  + ]:       1201 :   if (s_A.n)
     635                 :            :   {
     636                 :          0 :     FILE *l = pari_logfile;
     637                 :            :     long i;
     638                 :          0 :     pari_logfile = NULL;
     639         [ #  # ]:          0 :     for (i = 0; i < s_A.n; pari_free(A[i]),i++) read_main(A[i]);
     640                 :            :     /* Reading one of the input files above can set pari_logfile.
     641                 :            :      * Don't restore in that case. */
     642         [ #  # ]:          0 :     if (!pari_logfile) pari_logfile = l;
     643                 :            :   }
     644                 :       1201 :   pari_stack_delete(&s_A);
     645                 :       1201 :   (void)gp_main_loop(1);
     646                 :          0 :   gp_quit(0); return 0; /* not reached */
     647                 :            : }

Generated by: LCOV version 1.9