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 - language - compile.c (source / functions) Hit Total Coverage
Test: PARI/GP v2.8.0 lcov report (development 18616-fe48336) Lines: 1297 1453 89.3 %
Date: 2016-02-14 Functions: 77 80 96.2 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 706 893 79.1 %

           Branch data     Line data    Source code
       1                 :            : /* Copyright (C) 2006  The PARI group.
       2                 :            : 
       3                 :            : This file is part of the PARI 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                 :            : #include "pari.h"
      15                 :            : #include "paripriv.h"
      16                 :            : #include "anal.h"
      17                 :            : #include "tree.h"
      18                 :            : #include "opcode.h"
      19                 :            : 
      20                 :            : #define tree pari_tree
      21                 :            : 
      22                 :            : enum COflags {COsafelex=1, COsafedyn=2};
      23                 :            : 
      24                 :            : /***************************************************************************
      25                 :            :  **                                                                       **
      26                 :            :  **                           String constant expansion                   **
      27                 :            :  **                                                                       **
      28                 :            :  ***************************************************************************/
      29                 :            : 
      30                 :            : static char *
      31                 :    1112315 : translate(const char **src, char *s)
      32                 :            : {
      33                 :    1112315 :   const char *t = *src;
      34         [ +  - ]:    7967287 :   while (*t)
      35                 :            :   {
      36         [ +  + ]:    7967791 :     while (*t == '\\')
      37                 :            :     {
      38   [ -  +  +  + ]:        504 :       switch(*++t)
      39                 :            :       {
      40                 :          0 :         case 'e':  *s='\033'; break; /* escape */
      41                 :        322 :         case 'n':  *s='\n'; break;
      42                 :         14 :         case 't':  *s='\t'; break;
      43         [ -  + ]:        168 :         default:   *s=*t; if (!*t) { *src=s; return NULL; }
      44                 :            :       }
      45                 :        504 :       t++; s++;
      46                 :            :     }
      47         [ +  + ]:    7967287 :     if (*t == '"')
      48                 :            :     {
      49         [ +  - ]:    1112315 :       if (t[1] != '"') break;
      50                 :          0 :       t += 2; continue;
      51                 :            :     }
      52                 :    6854972 :     *s++ = *t++;
      53                 :            :   }
      54                 :    1112315 :   *s=0; *src=t; return s;
      55                 :            : }
      56                 :            : 
      57                 :            : static void
      58                 :          0 : matchQ(const char *s, char *entry)
      59                 :            : {
      60         [ #  # ]:          0 :   if (*s != '"')
      61                 :          0 :     pari_err(e_SYNTAX,"expected character: '\"' instead of",s,entry);
      62                 :          0 : }
      63                 :            : 
      64                 :            : /*  Read a "string" from src. Format then copy it, starting at s. Return
      65                 :            :  *  pointer to char following the end of the input string */
      66                 :            : char *
      67                 :          0 : pari_translate_string(const char *src, char *s, char *entry)
      68                 :            : {
      69                 :          0 :   matchQ(src, entry); src++; s = translate(&src, s);
      70         [ #  # ]:          0 :   if (!s) pari_err(e_SYNTAX,"run-away string",src,entry);
      71                 :          0 :   matchQ(src, entry); return (char*)src+1;
      72                 :            : }
      73                 :            : 
      74                 :            : static GEN
      75                 :    1112315 : strntoGENexp(const char *str, long len)
      76                 :            : {
      77                 :    1112315 :   GEN z = cgetg(1+nchar2nlong(len-1), t_STR);
      78                 :    1112315 :   const char *t = str+1;
      79         [ -  + ]:    1112315 :   if (!translate(&t, GSTR(z))) compile_err("run-away string",str);
      80                 :    1112315 :   return z;
      81                 :            : }
      82                 :            : 
      83                 :            : /***************************************************************************
      84                 :            :  **                                                                       **
      85                 :            :  **                           Byte-code compiler                          **
      86                 :            :  **                                                                       **
      87                 :            :  ***************************************************************************/
      88                 :            : 
      89                 :            : typedef enum {Llocal, Lmy} Ltype;
      90                 :            : 
      91                 :            : struct vars_s
      92                 :            : {
      93                 :            :   Ltype type; /*Only Llocal and Lmy are allowed */
      94                 :            :   int inl;
      95                 :            :   entree *ep;
      96                 :            : };
      97                 :            : 
      98                 :            : struct frame_s
      99                 :            : {
     100                 :            :   long pc;
     101                 :            :   GEN frame;
     102                 :            : };
     103                 :            : 
     104                 :            : static THREAD pari_stack s_opcode, s_operand, s_data, s_lvar;
     105                 :            : static THREAD pari_stack s_dbginfo, s_frame;
     106                 :            : static THREAD char *opcode;
     107                 :            : static THREAD long *operand;
     108                 :            : static THREAD GEN *data;
     109                 :            : static THREAD long offset;
     110                 :            : static THREAD struct vars_s *localvars;
     111                 :            : static THREAD const char **dbginfo, *dbgstart;
     112                 :            : static THREAD struct frame_s *frames;
     113                 :            : 
     114                 :            : void
     115                 :       5798 : pari_init_compiler(void)
     116                 :            : {
     117                 :       5798 :   pari_stack_init(&s_opcode,sizeof(*opcode),(void **)&opcode);
     118                 :       5667 :   pari_stack_init(&s_operand,sizeof(*operand),(void **)&operand);
     119                 :       5669 :   pari_stack_init(&s_data,sizeof(*data),(void **)&data);
     120                 :       5653 :   pari_stack_init(&s_lvar,sizeof(*localvars),(void **)&localvars);
     121                 :       5669 :   pari_stack_init(&s_dbginfo,sizeof(*dbginfo),(void **)&dbginfo);
     122                 :       5788 :   pari_stack_init(&s_frame,sizeof(*frames),(void **)&frames);
     123                 :       5786 :   offset=-1;
     124                 :       5786 : }
     125                 :            : void
     126                 :       1822 : pari_close_compiler(void)
     127                 :            : {
     128                 :       1822 :   pari_stack_delete(&s_opcode);
     129                 :       1822 :   pari_stack_delete(&s_operand);
     130                 :       1822 :   pari_stack_delete(&s_data);
     131                 :       1822 :   pari_stack_delete(&s_lvar);
     132                 :       1822 : }
     133                 :            : 
     134                 :            : struct codepos
     135                 :            : {
     136                 :            :   long opcode, data, localvars, frames;
     137                 :            :   long offset;
     138                 :            :   const char *dbgstart;
     139                 :            : };
     140                 :            : 
     141                 :            : static void
     142                 :     176938 : getcodepos(struct codepos *pos)
     143                 :            : {
     144                 :     176938 :   pos->opcode=s_opcode.n;
     145                 :     176938 :   pos->data=s_data.n;
     146                 :     176938 :   pos->offset=offset;
     147                 :     176938 :   pos->localvars=s_lvar.n;
     148                 :     176938 :   pos->dbgstart=dbgstart;
     149                 :     176938 :   pos->frames=s_frame.n;
     150                 :     176938 :   offset=s_data.n-1;
     151                 :     176938 : }
     152                 :            : 
     153                 :            : void
     154                 :        161 : compilestate_reset(void)
     155                 :            : {
     156                 :        161 :   s_opcode.n=0;
     157                 :        161 :   s_operand.n=0;
     158                 :        161 :   s_dbginfo.n=0;
     159                 :        161 :   s_data.n=0;
     160                 :        161 :   s_lvar.n=0;
     161                 :        161 :   s_frame.n=0;
     162                 :        161 :   offset=-1;
     163                 :        161 :   dbgstart=NULL;
     164                 :        161 : }
     165                 :            : 
     166                 :            : void
     167                 :    1374053 : compilestate_save(struct pari_compilestate *comp)
     168                 :            : {
     169                 :    1374053 :   comp->opcode=s_opcode.n;
     170                 :    1374053 :   comp->operand=s_operand.n;
     171                 :    1374053 :   comp->data=s_data.n;
     172                 :    1374053 :   comp->offset=offset;
     173                 :    1374053 :   comp->localvars=s_lvar.n;
     174                 :    1374053 :   comp->dbgstart=dbgstart;
     175                 :    1374053 :   comp->dbginfo=s_dbginfo.n;
     176                 :    1374053 :   comp->frames=s_frame.n;
     177                 :    1374053 : }
     178                 :            : 
     179                 :            : void
     180                 :      73071 : compilestate_restore(struct pari_compilestate *comp)
     181                 :            : {
     182                 :      73071 :   s_opcode.n=comp->opcode;
     183                 :      73071 :   s_operand.n=comp->operand;
     184                 :      73071 :   s_data.n=comp->data;
     185                 :      73071 :   offset=comp->offset;
     186                 :      73071 :   s_lvar.n=comp->localvars;
     187                 :      73071 :   dbgstart=comp->dbgstart;
     188                 :      73071 :   s_dbginfo.n=comp->dbginfo;
     189                 :      73071 :   s_frame.n=comp->frames;
     190                 :      73071 : }
     191                 :            : 
     192                 :            : static GEN
     193                 :     176931 : getfunction(const struct codepos *pos, long arity, long nbmvar, GEN text, long gap)
     194                 :            : {
     195                 :     176931 :   long lop =s_opcode.n+1-pos->opcode;
     196                 :     176931 :   long ldat=s_data.n+1-pos->data;
     197                 :     176931 :   long lfram=s_frame.n+1-pos->frames;
     198 [ +  + ][ +  + ]:     176931 :   GEN cl=cgetg(nbmvar?8:(text?7:6),t_CLOSURE);
     199                 :            :   GEN frpc, fram, dbg;
     200                 :            :   char *s;
     201                 :            :   long i;
     202                 :     176931 :   cl[1] = arity;
     203                 :     176931 :   gel(cl,2) = cgetg(nchar2nlong(lop)+1, t_STR);
     204                 :     176931 :   gel(cl,3) = cgetg(lop,  t_VECSMALL);
     205                 :     176931 :   gel(cl,4) = cgetg(ldat, t_VEC);
     206                 :     176931 :   dbg = cgetg(lop,  t_VECSMALL);
     207                 :     176931 :   frpc = cgetg(lfram,  t_VECSMALL);
     208                 :     176931 :   fram = cgetg(lfram,  t_VEC);
     209                 :     176931 :   gel(cl,5) = mkvec3(dbg, frpc, fram);
     210         [ +  + ]:     176931 :   if (text) gel(cl,6) = text;
     211         [ +  + ]:     176931 :   if (nbmvar) gel(cl,7) = zerovec(nbmvar);
     212                 :     176931 :   s=GSTR(gel(cl,2))-1;
     213         [ +  + ]:   29360100 :   for(i=1;i<lop;i++)
     214                 :            :   {
     215                 :   29183169 :     s[i] = opcode[i+pos->opcode-1];
     216                 :   29183169 :     mael(cl, 3, i) = operand[i+pos->opcode-1];
     217                 :   29183169 :     dbg[i] = dbginfo[i+pos->opcode-1]-dbgstart;
     218         [ +  + ]:   29183169 :     if (dbg[i]<0) dbg[i]+=gap;
     219                 :            :   }
     220                 :     176931 :   s[i]=0;
     221                 :     176931 :   s_opcode.n=pos->opcode;
     222                 :     176931 :   s_operand.n=pos->opcode;
     223                 :     176931 :   s_dbginfo.n=pos->opcode;
     224         [ +  + ]:    1825605 :   for(i=1;i<ldat;i++)
     225         [ +  - ]:    1648674 :     if(data[i+pos->data-1])
     226                 :            :     {
     227                 :    1648674 :       gmael(cl, 4, i) = gcopy(data[i+pos->data-1]);
     228                 :    1648674 :       gunclone(data[i+pos->data-1]);
     229                 :            :     }
     230                 :     176931 :   s_data.n=pos->data;
     231 [ +  + ][ +  + ]:     213790 :   while (s_lvar.n>pos->localvars && !localvars[s_lvar.n-1].inl)
     232                 :      36859 :     s_lvar.n--;
     233         [ +  + ]:     215039 :   for(i=1;i<lfram;i++)
     234                 :            :   {
     235                 :      38108 :     long j=i+pos->frames-1;
     236                 :      38108 :     frpc[i] = frames[j].pc-pos->opcode+1;
     237                 :      38108 :     gel(fram, i) = gcopy(frames[j].frame);
     238                 :      38108 :     gunclone(frames[j].frame);
     239                 :            :   }
     240                 :     176931 :   s_frame.n=pos->frames;
     241                 :     176931 :   offset=pos->offset;
     242                 :     176931 :   dbgstart=pos->dbgstart;
     243                 :     176931 :   return cl;
     244                 :            : }
     245                 :            : 
     246                 :            : static GEN
     247                 :      34846 : getclosure(struct codepos *pos)
     248                 :            : {
     249                 :      34846 :   return getfunction(pos,0,0,NULL,0);
     250                 :            : }
     251                 :            : 
     252                 :            : static void
     253                 :   29181559 : op_push_loc(op_code o, long x, const char *loc)
     254                 :            : {
     255                 :   29181559 :   long n=pari_stack_new(&s_opcode);
     256                 :   29181559 :   long m=pari_stack_new(&s_operand);
     257                 :   29181559 :   long d=pari_stack_new(&s_dbginfo);
     258                 :   29181559 :   opcode[n]=o;
     259                 :   29181559 :   operand[m]=x;
     260                 :   29181559 :   dbginfo[d]=loc;
     261                 :   29181559 : }
     262                 :            : 
     263                 :            : static void
     264                 :   28353147 : op_push(op_code o, long x, long n)
     265                 :            : {
     266                 :   28353147 :   op_push_loc(o,x,tree[n].str);
     267                 :   28353147 : }
     268                 :            : 
     269                 :            : static void
     270                 :       1624 : op_insert_loc(long k, op_code o, long x, const char *loc)
     271                 :            : {
     272                 :            :   long i;
     273                 :       1624 :   long n=pari_stack_new(&s_opcode);
     274                 :       1624 :   (void) pari_stack_new(&s_operand);
     275                 :       1624 :   (void) pari_stack_new(&s_dbginfo);
     276         [ +  + ]:     339257 :   for (i=n-1; i>=k; i--)
     277                 :            :   {
     278                 :     337633 :     opcode[i+1] = opcode[i];
     279                 :     337633 :     operand[i+1]= operand[i];
     280                 :     337633 :     dbginfo[i+1]= dbginfo[i];
     281                 :            :   }
     282                 :       1624 :   opcode[k]  = o;
     283                 :       1624 :   operand[k] = x;
     284                 :       1624 :   dbginfo[k] = loc;
     285                 :       1624 : }
     286                 :            : 
     287                 :            : static long
     288                 :    1648674 : data_push(GEN x)
     289                 :            : {
     290                 :    1648674 :   long n=pari_stack_new(&s_data);
     291         [ +  - ]:    1648674 :   data[n] = x?gclone(x):x;
     292                 :    1648674 :   return n-offset;
     293                 :            : }
     294                 :            : 
     295                 :            : static void
     296                 :      70549 : var_push(entree *ep, Ltype type)
     297                 :            : {
     298                 :      70549 :   long n=pari_stack_new(&s_lvar);
     299                 :      70549 :   localvars[n].ep   = ep;
     300                 :      70549 :   localvars[n].inl  = 0;
     301                 :      70549 :   localvars[n].type = type;
     302                 :      70549 : }
     303                 :            : 
     304                 :            : static void
     305                 :      38108 : frame_push(GEN x)
     306                 :            : {
     307                 :      38108 :   long n=pari_stack_new(&s_frame);
     308                 :      38108 :   frames[n].pc = s_opcode.n-1;
     309                 :      38108 :   frames[n].frame = gclone(x);
     310                 :      38108 : }
     311                 :            : 
     312                 :            : static GEN
     313                 :         35 : pack_localvars(void)
     314                 :            : {
     315                 :         35 :   GEN pack=cgetg(3,t_VEC);
     316                 :         35 :   long i,l=s_lvar.n;
     317                 :         35 :   GEN t=cgetg(1+l,t_VECSMALL);
     318                 :         35 :   GEN e=cgetg(1+l,t_VECSMALL);
     319                 :         35 :   gel(pack,1)=t;
     320                 :         35 :   gel(pack,2)=e;
     321         [ +  + ]:         91 :   for(i=1;i<=l;i++)
     322                 :            :   {
     323                 :         56 :     t[i]=localvars[i-1].type;
     324                 :         56 :     e[i]=(long)localvars[i-1].ep;
     325                 :            :   }
     326                 :         35 :   return pack;
     327                 :            : }
     328                 :            : 
     329                 :            : void
     330                 :        175 : push_frame(GEN C, long lpc, long dummy)
     331                 :            : {
     332                 :        175 :   const char *code=closure_codestr(C);
     333                 :        175 :   GEN oper=closure_get_oper(C);
     334                 :        175 :   GEN dbg=closure_get_dbg(C);
     335                 :        175 :   GEN frpc=gel(dbg,2);
     336                 :        175 :   GEN fram=gel(dbg,3);
     337                 :        175 :   long pc, j=1, lfr = lg(frpc);
     338         [ +  + ]:        175 :   if (lpc==-1)
     339                 :            :   {
     340                 :            :     long k;
     341                 :         42 :     GEN e = gel(fram, 1);
     342         [ +  + ]:         84 :     for(k=1; k<lg(e); k++)
     343         [ +  + ]:         42 :       var_push(dummy?NULL:(entree*)e[k], Lmy);
     344                 :        175 :     return;
     345                 :            :   }
     346 [ +  + ][ +  + ]:        175 :   if (lg(C)<8) while (j<lfr && frpc[j]==0) j++;
                 [ +  + ]
     347         [ +  + ]:       1393 :   for(pc=0; pc<=lpc; pc++)
     348                 :            :   {
     349 [ +  + ][ +  - ]:       1260 :     if (pc>0 && (code[pc]==OClocalvar || code[pc]==OClocalvar0))
                 [ -  + ]
     350                 :          0 :       var_push((entree*)oper[pc],Llocal);
     351 [ +  + ][ +  + ]:       1260 :     if (j<lfr && pc==frpc[j])
     352                 :            :     {
     353                 :            :       long k;
     354                 :        112 :       GEN e = gel(fram,j);
     355         [ +  + ]:        294 :       for(k=1; k<lg(e); k++)
     356         [ +  + ]:        182 :         var_push(dummy?NULL:(entree*)e[k], Lmy);
     357                 :        112 :       j++;
     358                 :            :     }
     359                 :            :   }
     360                 :            : }
     361                 :            : 
     362                 :            : void
     363                 :          0 : debug_context(void)
     364                 :            : {
     365                 :            :   long i;
     366         [ #  # ]:          0 :   for(i=0;i<s_lvar.n;i++)
     367                 :            :   {
     368                 :          0 :     entree *ep = localvars[i].ep;
     369                 :          0 :     Ltype type = localvars[i].type;
     370 [ #  # ][ #  # ]:          0 :     err_printf("%ld: %s: %s\n",i,(type==Lmy?"my":"local"),(ep?ep->name:"NULL"));
     371                 :            :   }
     372                 :          0 : }
     373                 :            : 
     374                 :            : GEN
     375                 :      10108 : localvars_read_str(const char *x, GEN pack)
     376                 :            : {
     377                 :            :   GEN code;
     378                 :      10108 :   long l=0;
     379         [ +  - ]:      10108 :   if (pack)
     380                 :            :   {
     381                 :      10108 :     GEN t=gel(pack,1);
     382                 :      10108 :     GEN e=gel(pack,2);
     383                 :            :     long i;
     384                 :      10108 :     l=lg(t)-1;
     385         [ +  + ]:      43568 :     for(i=1;i<=l;i++)
     386                 :      33460 :       var_push((entree*)e[i],(Ltype)t[i]);
     387                 :            :   }
     388                 :      10108 :   code = compile_str(x);
     389                 :      10101 :   s_lvar.n -= l;
     390                 :      10101 :   return closure_evalres(code);
     391                 :            : }
     392                 :            : 
     393                 :            : long
     394                 :          7 : localvars_find(GEN pack, entree *ep)
     395                 :            : {
     396                 :          7 :   GEN t=gel(pack,1);
     397                 :          7 :   GEN e=gel(pack,2);
     398                 :            :   long i;
     399                 :          7 :   long vn=0;
     400         [ -  + ]:          7 :   for(i=lg(e)-1;i>=1;i--)
     401                 :            :   {
     402         [ #  # ]:          0 :     if(t[i]==Lmy)
     403                 :          0 :       vn--;
     404         [ #  # ]:          0 :     if(e[i]==(long)ep)
     405         [ #  # ]:          0 :       return t[i]==Lmy?vn:0;
     406                 :            :   }
     407                 :          7 :   return 0;
     408                 :            : }
     409                 :            : 
     410                 :            : /*
     411                 :            :  Flags for copy optimisation:
     412                 :            :  -- Freturn: The result will be returned.
     413                 :            :  -- FLsurvive: The result must survive the closure.
     414                 :            :  -- FLnocopy: The result will never be updated nor part of a user variable.
     415                 :            :  -- FLnocopylex: The result will never be updated nor part of dynamic variable.
     416                 :            : */
     417                 :            : enum FLflag {FLreturn=1, FLsurvive=2, FLnocopy=4, FLnocopylex=8};
     418                 :            : 
     419                 :            : static void
     420                 :     164473 : copyifclone(long n, long mode, long flag, long mask)
     421                 :            : {
     422 [ +  + ][ +  + ]:     164473 :   if (mode==Ggen && !(flag&mask))
     423                 :            :   {
     424                 :      14756 :     op_push(OCcopyifclone,0,n);
     425 [ +  + ][ -  + ]:      14756 :     if (!(flag&FLsurvive) && DEBUGLEVEL)
     426                 :          0 :       pari_warn(warner,"compiler generates copy for `%.*s'",
     427                 :          0 :                        tree[n].len,tree[n].str);
     428                 :            :   }
     429                 :     164473 : }
     430                 :            : 
     431                 :            : static void compilenode(long n, int mode, long flag);
     432                 :            : 
     433                 :            : typedef enum {PPend,PPstd,PPdefault,PPdefaultmulti,PPstar,PPauto} PPproto;
     434                 :            : 
     435                 :            : static PPproto
     436                 :    7962546 : parseproto(char const **q, char *c, const char *str)
     437                 :            : {
     438                 :    7962546 :   char  const *p=*q;
     439                 :            :   long i;
     440   [ +  +  +  +  :    7962546 :   switch(*p)
                +  +  + ]
     441                 :            :   {
     442                 :            :   case 0:
     443                 :            :   case '\n':
     444                 :    3370733 :     return PPend;
     445                 :            :   case 'D':
     446      [ -  +  + ]:     278281 :     switch(p[1])
     447                 :            :     {
     448                 :            :     case 0:
     449                 :          0 :       compile_err("function has incomplete prototype",str);
     450                 :            :     case 'G':
     451                 :            :     case '&':
     452                 :            :     case 'W':
     453                 :            :     case 'V':
     454                 :            :     case 'I':
     455                 :            :     case 'E':
     456                 :            :     case 'J':
     457                 :            :     case 'n':
     458                 :            :     case 'P':
     459                 :            :     case 'r':
     460                 :            :     case 's':
     461                 :     151656 :       *c=p[1];
     462                 :     151656 :       *q=p+2;
     463                 :     151656 :       return PPdefault;
     464                 :            :     default:
     465 [ +  + ][ +  + ]:     760478 :       for(i=0;*p && i<2;p++) i+=*p==',';
     466         [ -  + ]:     126625 :       if (i<2)
     467                 :          0 :         compile_err("function has incomplete prototype",str);
     468                 :     126625 :       *c=p[-2];
     469                 :     126625 :       *q=p;
     470                 :     126625 :       return PPdefaultmulti;
     471                 :            :     }
     472                 :            :     break;
     473                 :            :   case 'C':
     474                 :            :   case 'p':
     475                 :            :   case 'b':
     476                 :            :   case 'P':
     477                 :            :   case 'f':
     478                 :     128637 :     *c=*p;
     479                 :     128637 :     *q=p+1;
     480                 :     128637 :     return PPauto;
     481                 :            :   case '&':
     482                 :        752 :     *c='*';
     483                 :        752 :     *q=p+1;
     484                 :        752 :     return PPstd;
     485                 :            :   case 'V':
     486         [ +  + ]:      35802 :     if (p[1]=='=')
     487                 :            :     {
     488         [ -  + ]:      33252 :       if (p[2]!='G')
     489                 :          0 :         compile_err("function prototype is not supported",str);
     490                 :      33252 :       *c='=';
     491                 :      33252 :       p+=2;
     492                 :            :     }
     493                 :            :     else
     494                 :       2550 :       *c=*p;
     495                 :      35802 :     *q=p+1;
     496                 :      35802 :     return PPstd;
     497                 :            :   case 'E':
     498                 :            :   case 's':
     499         [ +  + ]:      56509 :     if (p[1]=='*')
     500                 :            :     {
     501                 :      16587 :       *c=*p++;
     502                 :      16587 :       *q=p+1;
     503                 :      16587 :       return PPstar;
     504                 :            :     }
     505                 :            :     /*fall through*/
     506                 :            :   }
     507                 :    4131754 :   *c=*p;
     508                 :    4131754 :   *q=p+1;
     509                 :    7962546 :   return PPstd;
     510                 :            : }
     511                 :            : 
     512                 :            : static long
     513                 :     278096 : detag(long n)
     514                 :            : {
     515         [ -  + ]:     278096 :   while (tree[n].f==Ftag)
     516                 :          0 :     n=tree[n].x;
     517                 :     278096 :   return n;
     518                 :            : }
     519                 :            : 
     520                 :            : /* return type for GP functions */
     521                 :            : static op_code
     522                 :    3377999 : get_ret_type(const char **p, long arity, Gtype *t, long *flag)
     523                 :            : {
     524                 :    3377999 :   *flag = 0;
     525         [ +  + ]:    3377999 :   if (**p == 'v') { (*p)++; *t=Gvoid; return OCcallvoid; }
     526         [ +  + ]:    3245368 :   else if (**p == 'i') { (*p)++; *t=Gsmall;  return OCcallint; }
     527         [ +  + ]:    3241581 :   else if (**p == 'l') { (*p)++; *t=Gsmall;  return OCcalllong; }
     528         [ -  + ]:    3223832 :   else if (**p == 'u') { (*p)++; *t=Gusmall; return OCcalllong; }
     529         [ +  + ]:    3223832 :   else if (**p == 'm') { (*p)++; *flag = FLnocopy; }
     530         [ +  + ]:    3377999 :   *t=Ggen; return arity==2?OCcallgen2:OCcallgen;
     531                 :            : }
     532                 :            : 
     533                 :            : /*supported types:
     534                 :            :  * type: Gusmall, Gsmall, Ggen, Gvoid, Gvec, Gclosure
     535                 :            :  * mode: Gusmall, Gsmall, Ggen, Gvar, Gvoid
     536                 :            :  */
     537                 :            : static void
     538                 :    5304412 : compilecast_loc(int type, int mode, const char *loc)
     539                 :            : {
     540         [ +  + ]:    9166781 :   if (type==mode) return;
     541   [ -  +  +  +  :    3862376 :   switch (mode)
                   +  - ]
     542                 :            :   {
     543                 :            :   case Gusmall:
     544         [ #  # ]:          0 :     if (type==Ggen)        op_push_loc(OCitou,-1,loc);
     545         [ #  # ]:          0 :     else if (type==Gvoid)  op_push_loc(OCpushlong,0,loc);
     546         [ #  # ]:          0 :     else if (type!=Gsmall)
     547                 :          0 :       compile_err("this should be a small integer >=0",loc);
     548                 :          0 :     break;
     549                 :            :   case Gsmall:
     550         [ +  + ]:       2784 :     if (type==Ggen)        op_push_loc(OCitos,-1,loc);
     551         [ +  - ]:        175 :     else if (type==Gvoid)  op_push_loc(OCpushlong,0,loc);
     552         [ #  # ]:          0 :     else if (type!=Gusmall)
     553                 :          0 :       compile_err("this should be a small integer",loc);
     554                 :       2784 :     break;
     555                 :            :   case Ggen:
     556         [ +  + ]:    3850145 :     if (type==Gsmall)      op_push_loc(OCstoi,0,loc);
     557         [ -  + ]:    3841647 :     else if (type==Gusmall)op_push_loc(OCutoi,0,loc);
     558         [ +  + ]:    3841647 :     else if (type==Gvoid)  op_push_loc(OCpushgnil,0,loc);
     559                 :    3850145 :     break;
     560                 :            :   case Gvoid:
     561                 :       7543 :     op_push_loc(OCpop, 1,loc);
     562                 :       7543 :     break;
     563                 :            :   case Gvar:
     564         [ +  + ]:       1904 :     if (type==Ggen)        op_push_loc(OCvarn,-1,loc);
     565                 :          7 :     else compile_varerr(loc);
     566                 :       1897 :      break;
     567                 :            :   default:
     568                 :          0 :     pari_err_BUG("compilecast [unknown type]");
     569                 :            :   }
     570                 :            : }
     571                 :            : 
     572                 :            : static void
     573                 :    5302090 : compilecast(long n, int type, int mode) { compilecast_loc(type, mode, tree[n].str); }
     574                 :            : 
     575                 :            : static entree *
     576                 :      19838 : fetch_member_raw(const char *s, long len)
     577                 :            : {
     578                 :      19838 :   pari_sp av = avma;
     579                 :      19838 :   char *t = stack_malloc(len+2);
     580                 :            :   entree *ep;
     581                 :      19838 :   t[0] = '_'; strncpy(t+1, s, len); t[++len] = 0; /* prepend '_' */
     582                 :      19838 :   ep = fetch_entry_raw(t, len);
     583                 :      19838 :   avma = av; return ep;
     584                 :            : }
     585                 :            : static entree *
     586                 :    5594147 : getfunc(long n)
     587                 :            : {
     588                 :    5594147 :   long x=tree[n].x;
     589         [ +  + ]:    5594147 :   if (tree[x].x==CSTmember) /* str-1 points to '.' */
     590                 :      19838 :     return do_alias(fetch_member_raw(tree[x].str - 1, tree[x].len + 1));
     591                 :            :   else
     592                 :    5594147 :     return do_alias(fetch_entry_raw(tree[x].str, tree[x].len));
     593                 :            : }
     594                 :            : 
     595                 :            : static entree *
     596                 :     247597 : getentry(long n)
     597                 :            : {
     598                 :     247597 :   n = detag(n);
     599         [ -  + ]:     247597 :   if (tree[n].f!=Fentry)
     600                 :            :   {
     601         [ #  # ]:          0 :     if (tree[n].f==Fseq)
     602                 :          0 :       compile_err("unexpected character: ';'", tree[tree[n].y].str-1);
     603                 :          0 :     compile_varerr(tree[n].str);
     604                 :            :   }
     605                 :     247597 :   return getfunc(n);
     606                 :            : }
     607                 :            : 
     608                 :            : /* match Fentry that are not actually EpSTATIC functions called without parens*/
     609                 :            : static entree *
     610                 :      71458 : getvar(long n)
     611                 :            : {
     612                 :      71458 :   entree *ep = getentry(n);
     613         [ -  + ]:      71458 :   if (EpSTATIC(do_alias(ep)))
     614                 :          0 :     compile_varerr(tree[n].str);
     615                 :      71458 :   return ep;
     616                 :            : }
     617                 :            : 
     618                 :            : static long
     619                 :     213265 : getmvar(entree *ep)
     620                 :            : {
     621                 :            :   long i;
     622                 :     213265 :   long vn=0;
     623         [ +  + ]:     519498 :   for(i=s_lvar.n-1;i>=0;i--)
     624                 :            :   {
     625         [ +  + ]:     386039 :     if(localvars[i].type==Lmy)
     626                 :     385829 :       vn--;
     627         [ +  + ]:     386039 :     if(localvars[i].ep==ep)
     628         [ +  + ]:      79806 :       return localvars[i].type==Lmy?vn:0;
     629                 :            :   }
     630                 :     213265 :   return 0;
     631                 :            : }
     632                 :            : 
     633                 :            : static long
     634                 :       6515 : ctxmvar(void)
     635                 :            : {
     636                 :       6515 :   pari_sp av=avma;
     637                 :       6515 :   long i, n=0;
     638                 :            :   GEN ctx;
     639         [ +  + ]:      67886 :   for(i=s_lvar.n-1;i>=0;i--)
     640         [ +  - ]:      61371 :     if(localvars[i].type==Lmy)
     641                 :      61371 :       n++;
     642         [ +  + ]:       6515 :   if (n==0) return 0;
     643                 :       3718 :   ctx = cgetg(n+1,t_VECSMALL);
     644         [ +  + ]:      65089 :   for(n=0, i=0; i<s_lvar.n; i++)
     645         [ +  - ]:      61371 :     if(localvars[i].type==Lmy)
     646                 :      61371 :       ctx[++n]=(long)localvars[i].ep;
     647                 :       3718 :   frame_push(ctx);
     648                 :       6515 :   avma=av; return n;
     649                 :            : }
     650                 :            : 
     651                 :            : INLINE int
     652                 :   21354706 : is_func_named(entree *ep, const char *s)
     653                 :            : {
     654                 :   21354706 :   return !strcmp(ep->name, s);
     655                 :            : }
     656                 :            : 
     657                 :            : INLINE int
     658                 :       1907 : is_node_zero(long n)
     659                 :            : {
     660                 :       1907 :   n = detag(n);
     661 [ +  + ][ +  + ]:       1907 :   return (tree[n].f==Fsmall && tree[n].x==0);
     662                 :            : }
     663                 :            : 
     664                 :            : static void
     665                 :         35 : str_defproto(const char *p, const char *q, const char *loc)
     666                 :            : {
     667                 :         35 :   long len = p-4-q;
     668 [ +  - ][ -  + ]:         35 :   if (q[1]!='"' || q[len]!='"')
     669                 :          0 :     compile_err("default argument must be a string",loc);
     670                 :         35 :   op_push_loc(OCpushgen,data_push(strntoGENexp(q+1,len)),loc);
     671                 :         35 : }
     672                 :            : 
     673                 :            : static long
     674                 :   13012035 : countlisttogen(long n, Ffunc f)
     675                 :            : {
     676                 :            :   long x,i;
     677 [ +  + ][ +  + ]:   13012035 :   if (n==-1 || tree[n].f==Fnoarg) return 0;
     678         [ +  + ]:   30114718 :   for(x=n, i=0; tree[x].f==f ;x=tree[x].x, i++);
     679                 :   13012035 :   return i+1;
     680                 :            : }
     681                 :            : 
     682                 :            : static GEN
     683                 :   13011944 : listtogen(long n, Ffunc f)
     684                 :            : {
     685                 :   13011944 :   long x,i,nb = countlisttogen(n, f);
     686                 :   13011944 :   GEN z=cgetg(nb+1, t_VECSMALL);
     687         [ +  + ]:   13011944 :   if (nb)
     688                 :            :   {
     689         [ +  + ]:   30114487 :     for (x=n, i = nb-1; i>0; z[i+1]=tree[x].y, x=tree[x].x, i--);
     690                 :   11909722 :     z[1]=x;
     691                 :            :   }
     692                 :   13011944 :   return z;
     693                 :            : }
     694                 :            : 
     695                 :            : static long
     696                 :    5370622 : first_safe_arg(GEN arg, long mask)
     697                 :            : {
     698                 :    5370622 :   long lnc, l=lg(arg);
     699 [ +  + ][ +  + ]:   11634137 :   for (lnc=l-1; lnc>0 && (tree[arg[lnc]].flags&mask)==mask; lnc--);
     700                 :    5370622 :   return lnc;
     701                 :            : }
     702                 :            : 
     703                 :            : static void
     704                 :      33212 : checkdups(GEN arg, GEN vep)
     705                 :            : {
     706                 :      33212 :   long l=vecsmall_duplicate(vep);
     707         [ -  + ]:      33212 :   if (l!=0) compile_err("variable declared twice",tree[arg[l]].str);
     708                 :      33212 : }
     709                 :            : 
     710                 :            : enum {MAT_range,MAT_std,MAT_line,MAT_column,VEC_std};
     711                 :            : 
     712                 :            : static int
     713                 :       8987 : matindex_type(long n)
     714                 :            : {
     715                 :       8987 :   long x = tree[n].x, y = tree[n].y;
     716                 :       8987 :   long fxx = tree[tree[x].x].f, fxy = tree[tree[x].y].f;
     717         [ +  + ]:       8987 :   if (y==-1)
     718                 :            :   {
     719         [ +  + ]:       8168 :     if (fxy!=Fnoarg) return MAT_range;
     720         [ -  + ]:       8014 :     if (fxx==Fnoarg) compile_err("missing index",tree[n].str);
     721                 :       8014 :     return VEC_std;
     722                 :            :   }
     723                 :            :   else
     724                 :            :   {
     725                 :        819 :     long fyx = tree[tree[y].x].f, fyy = tree[tree[y].y].f;
     726 [ +  + ][ +  + ]:        819 :     if (fxy!=Fnoarg || fyy!=Fnoarg) return MAT_range;
     727 [ +  + ][ -  + ]:        693 :     if (fxx==Fnoarg && fyx==Fnoarg) compile_err("missing index",tree[n].str);
     728         [ +  + ]:        693 :     if (fxx==Fnoarg) return MAT_column;
     729         [ +  + ]:        434 :     if (fyx==Fnoarg) return MAT_line;
     730                 :       8987 :     return MAT_std;
     731                 :            :   }
     732                 :            : }
     733                 :            : 
     734                 :            : static entree *
     735                 :      22101 : getlvalue(long n)
     736                 :            : {
     737 [ +  + ][ +  - ]:      22591 :   while ((tree[n].f==Fmatcoeff && matindex_type(tree[n].y)!=MAT_range) || tree[n].f==Ftag)
                 [ -  + ]
     738                 :        490 :     n=tree[n].x;
     739                 :      22101 :   return getvar(n);
     740                 :            : }
     741                 :            : 
     742                 :            : INLINE void
     743                 :      20703 : compilestore(long vn, entree *ep, long n)
     744                 :            : {
     745         [ +  + ]:      20703 :   if (vn)
     746                 :       2792 :     op_push(OCstorelex,vn,n);
     747                 :            :   else
     748                 :      17911 :     op_push(OCstoredyn,(long)ep,n);
     749                 :      20703 : }
     750                 :            : 
     751                 :            : INLINE void
     752                 :        413 : compilenewptr(long vn, entree *ep, long n)
     753                 :            : {
     754         [ +  + ]:        413 :   if (vn)
     755                 :         91 :     op_push(OCnewptrlex,vn,n);
     756                 :            :   else
     757                 :        322 :     op_push(OCnewptrdyn,(long)ep,n);
     758                 :        413 : }
     759                 :            : 
     760                 :            : static void
     761                 :        903 : compilelvalue(long n)
     762                 :            : {
     763                 :        903 :   n = detag(n);
     764         [ +  + ]:        903 :   if (tree[n].f==Fentry)
     765                 :        413 :     return;
     766                 :            :   else
     767                 :            :   {
     768                 :        490 :     long x = tree[n].x, y = tree[n].y;
     769                 :        490 :     long yx = tree[y].x, yy = tree[y].y;
     770                 :        490 :     long m = matindex_type(y);
     771         [ -  + ]:        490 :     if (m == MAT_range)
     772                 :          0 :       compile_err("not an lvalue",tree[n].str);
     773 [ +  + ][ +  + ]:        490 :     if (m == VEC_std && tree[x].f==Fmatcoeff)
     774                 :            :     {
     775                 :         63 :       int mx = matindex_type(tree[x].y);
     776         [ -  + ]:         63 :       if (mx==MAT_line)
     777                 :            :       {
     778                 :          0 :         int xy = tree[x].y, xyx = tree[xy].x;
     779                 :          0 :         compilelvalue(tree[x].x);
     780                 :          0 :         compilenode(tree[xyx].x,Gsmall,0);
     781                 :          0 :         compilenode(tree[yx].x,Gsmall,0);
     782                 :          0 :         op_push(OCcompo2ptr,0,y);
     783                 :          0 :         return;
     784                 :            :       }
     785                 :            :     }
     786                 :        490 :     compilelvalue(x);
     787   [ +  +  +  +  :        490 :     switch(m)
                      - ]
     788                 :            :     {
     789                 :            :     case VEC_std:
     790                 :        287 :       compilenode(tree[yx].x,Gsmall,0);
     791                 :        287 :       op_push(OCcompo1ptr,0,y);
     792                 :        287 :       break;
     793                 :            :     case MAT_std:
     794                 :         77 :       compilenode(tree[yx].x,Gsmall,0);
     795                 :         77 :       compilenode(tree[yy].x,Gsmall,0);
     796                 :         77 :       op_push(OCcompo2ptr,0,y);
     797                 :         77 :       break;
     798                 :            :     case MAT_line:
     799                 :         70 :       compilenode(tree[yx].x,Gsmall,0);
     800                 :         70 :       op_push(OCcompoLptr,0,y);
     801                 :         70 :       break;
     802                 :            :     case MAT_column:
     803                 :         56 :       compilenode(tree[yy].x,Gsmall,0);
     804                 :         56 :       op_push(OCcompoCptr,0,y);
     805                 :        903 :       break;
     806                 :            :     }
     807                 :            :   }
     808                 :            : }
     809                 :            : 
     810                 :            : static void
     811                 :       7944 : compilematcoeff(long n, int mode)
     812                 :            : {
     813                 :       7944 :   long x=tree[n].x, y=tree[n].y;
     814                 :       7944 :   long yx=tree[y].x, yy=tree[y].y;
     815                 :       7944 :   long m=matindex_type(y);
     816                 :       7944 :   compilenode(x,Ggen,FLnocopy);
     817   [ +  +  +  +  :       7944 :   switch(m)
                   +  - ]
     818                 :            :   {
     819                 :            :   case VEC_std:
     820                 :       7377 :     compilenode(tree[yx].x,Gsmall,0);
     821                 :       7377 :     op_push(OCcompo1,mode,y);
     822                 :       7377 :     return;
     823                 :            :   case MAT_std:
     824                 :        119 :     compilenode(tree[yx].x,Gsmall,0);
     825                 :        119 :     compilenode(tree[yy].x,Gsmall,0);
     826                 :        119 :     op_push(OCcompo2,mode,y);
     827                 :        119 :     return;
     828                 :            :   case MAT_line:
     829                 :         21 :     compilenode(tree[yx].x,Gsmall,0);
     830                 :         21 :     op_push(OCcompoL,0,y);
     831                 :         21 :     compilecast(n,Gvec,mode);
     832                 :         21 :     return;
     833                 :            :   case MAT_column:
     834                 :        147 :     compilenode(tree[yy].x,Gsmall,0);
     835                 :        147 :     op_push(OCcompoC,0,y);
     836                 :        147 :     compilecast(n,Gvec,mode);
     837                 :        147 :     return;
     838                 :            :   case MAT_range:
     839                 :        280 :     compilenode(tree[yx].x,Gsmall,0);
     840                 :        280 :     compilenode(tree[yx].y,Gsmall,0);
     841         [ +  + ]:        280 :     if (yy==-1)
     842                 :        154 :       op_push(OCcallgen,(long)is_entry("_[_.._]"),n);
     843                 :            :     else
     844                 :            :     {
     845                 :        126 :       compilenode(tree[yy].x,Gsmall,0);
     846                 :        126 :       compilenode(tree[yy].y,Gsmall,0);
     847                 :        126 :       op_push(OCcallgen,(long)is_entry("_[_.._,_.._]"),n);
     848                 :            :     }
     849                 :        280 :     return;
     850                 :            :   default:
     851                 :       7944 :     pari_err_BUG("compilematcoeff");
     852                 :            :   }
     853                 :            : }
     854                 :            : 
     855                 :            : static void
     856                 :    6893916 : compilesmall(long n, long x, long mode)
     857                 :            : {
     858         [ +  + ]:    6893916 :   if (mode==Ggen)
     859                 :    6777562 :     op_push(OCpushstoi, x, n);
     860                 :            :   else
     861                 :            :   {
     862 [ -  + ][ #  # ]:     116354 :     if (mode==Gusmall && x < 0)
     863                 :          0 :       compile_err("this should be a small integer >=0",tree[n].str);
     864                 :     116354 :     op_push(OCpushlong, x, n);
     865                 :     116354 :     compilecast(n,Gsmall,mode);
     866                 :            :   }
     867                 :    6893909 : }
     868                 :            : 
     869                 :            : static void
     870                 :    3771576 : compilevec(long n, long mode, op_code op)
     871                 :            : {
     872                 :    3771576 :   pari_sp ltop=avma;
     873                 :    3771576 :   long x=tree[n].x;
     874                 :            :   long i;
     875                 :    3771576 :   GEN arg=listtogen(x,Fmatrixelts);
     876                 :    3771576 :   long l=lg(arg);
     877                 :    3771576 :   op_push(op,l,n);
     878         [ +  + ]:   15428182 :   for (i=1;i<l;i++)
     879                 :            :   {
     880                 :   11656606 :     compilenode(arg[i],Ggen,FLsurvive);
     881                 :   11656606 :     op_push(OCstackgen,i,n);
     882                 :            :   }
     883                 :    3771576 :   avma=ltop;
     884                 :    3771576 :   op_push(OCpop,1,n);
     885                 :    3771576 :   compilecast(n,Gvec,mode);
     886                 :    3771576 : }
     887                 :            : 
     888                 :            : static void
     889                 :       7056 : compilemat(long n, long mode)
     890                 :            : {
     891                 :       7056 :   pari_sp ltop=avma;
     892                 :       7056 :   long x=tree[n].x;
     893                 :            :   long i,j;
     894                 :       7056 :   GEN line=listtogen(x,Fmatrixlines);
     895                 :       7056 :   long lglin = lg(line), lgcol=0;
     896                 :       7056 :   op_push(OCpushlong, lglin,n);
     897         [ +  + ]:       7056 :   if (lglin==1)
     898                 :        672 :     op_push(OCmat,1,n);
     899         [ +  + ]:      37324 :   for(i=1;i<lglin;i++)
     900                 :            :   {
     901                 :      30268 :     GEN col=listtogen(line[i],Fmatrixelts);
     902                 :      30268 :     long l=lg(col), k;
     903         [ +  + ]:      30268 :     if (i==1)
     904                 :            :     {
     905                 :       6384 :       lgcol=l;
     906                 :       6384 :       op_push(OCmat,lgcol,n);
     907                 :            :     }
     908         [ -  + ]:      23884 :     else if (l!=lgcol)
     909                 :          0 :       compile_err("matrix must be rectangular",tree[line[i]].str);
     910                 :      30268 :     k=i;
     911         [ +  + ]:     206738 :     for(j=1;j<lgcol;j++)
     912                 :            :     {
     913                 :     176470 :       k-=lglin;
     914                 :     176470 :       compilenode(col[j], Ggen, FLsurvive);
     915                 :     176470 :       op_push(OCstackgen,k,n);
     916                 :            :     }
     917                 :            :   }
     918                 :       7056 :   avma=ltop;
     919                 :       7056 :   op_push(OCpop,1,n);
     920                 :       7056 :   compilecast(n,Gvec,mode);
     921                 :       7056 : }
     922                 :            : 
     923                 :            : 
     924                 :            : static GEN
     925                 :      33516 : cattovec(long n, long fnum)
     926                 :            : {
     927                 :      33516 :   long x=n, y, i=0, nb;
     928                 :            :   GEN stack;
     929         [ -  + ]:      33516 :   if (tree[n].f==Fnoarg) return cgetg(1,t_VECSMALL);
     930                 :            :   while(1)
     931                 :            :   {
     932                 :      33768 :     long xx=tree[x].x;
     933                 :      33768 :     long xy=tree[x].y;
     934 [ +  + ][ +  + ]:      33768 :     if (tree[x].f!=Ffunction || xx!=fnum) break;
     935                 :        252 :     x=tree[xy].x;
     936                 :        252 :     y=tree[xy].y;
     937         [ -  + ]:        252 :     if (tree[y].f==Fnoarg)
     938                 :          0 :       compile_err("unexpected character: ", tree[y].str);
     939                 :        252 :     i++;
     940                 :        252 :   }
     941         [ -  + ]:      33516 :   if (tree[x].f==Fnoarg)
     942                 :          0 :     compile_err("unexpected character: ", tree[x].str);
     943                 :      33516 :   nb=i+1;
     944                 :      33516 :   stack=cgetg(nb+1,t_VECSMALL);
     945         [ +  + ]:      33768 :   for(x=n;i>0;i--)
     946                 :            :   {
     947                 :        252 :     long y=tree[x].y;
     948                 :        252 :     x=tree[y].x;
     949                 :        252 :     stack[i+1]=tree[y].y;
     950                 :            :   }
     951                 :      33516 :   stack[1]=x;
     952                 :      33516 :   return stack;
     953                 :            : }
     954                 :            : 
     955                 :            : static GEN
     956                 :         18 : compilelambda(long n, long y, GEN vep, struct codepos *pos)
     957                 :            : {
     958         [ +  - ]:         18 :   long nbmvar, lev = vep ? lg(vep)-1 : 0;
     959                 :         18 :   GEN text=cgetg(3,t_VEC);
     960         [ +  - ]:         18 :   gel(text,1)=strtoGENstr(lev? ((entree*) vep[1])->name: "");
     961                 :         18 :   gel(text,2)=strntoGENstr(tree[y].str,tree[y].len);
     962                 :         18 :   nbmvar=ctxmvar()-lev;
     963         [ +  - ]:         18 :   if (lev) op_push(OCgetargs,lev,n);
     964                 :         18 :   compilenode(y,Ggen,FLsurvive|FLreturn);
     965                 :         18 :   return getfunction(pos,lev,nbmvar,text,2);
     966                 :            : }
     967                 :            : 
     968                 :            : static void
     969                 :      15249 : compilecall(long n, int mode, entree *ep)
     970                 :            : {
     971                 :      15249 :   pari_sp ltop=avma;
     972                 :            :   long j;
     973                 :      15249 :   long x=tree[n].x;
     974                 :      15249 :   long y=tree[n].y;
     975                 :      15249 :   GEN arg=listtogen(y,Flistarg);
     976                 :      15249 :   long nb=lg(arg)-1;
     977                 :      15249 :   long lnc=first_safe_arg(arg, COsafelex|COsafedyn);
     978                 :      15249 :   long lnl=first_safe_arg(arg, COsafelex);
     979 [ +  + ][ +  + ]:      15249 :   long fl = lnl==0? (lnc==0? FLnocopy: FLnocopylex): 0;
     980         [ +  + ]:      15249 :   if (ep==NULL)
     981                 :        224 :     compilenode(x, Ggen, fl);
     982                 :            :   else
     983                 :            :   {
     984                 :      15025 :     long vn=getmvar(ep);
     985         [ +  + ]:      15025 :     if (vn)
     986                 :        353 :       op_push(OCpushlex,vn,n);
     987                 :            :     else
     988                 :      14672 :       op_push(OCpushdyn,(long)ep,n);
     989                 :            :   }
     990         [ +  + ]:      40072 :   for (j=1;j<=nb;j++)
     991                 :            :   {
     992                 :      24823 :     long x = tree[arg[j]].x, f = tree[arg[j]].f;
     993         [ -  + ]:      24823 :     if (f==Fseq)
     994                 :          0 :       compile_err("unexpected ';'", tree[x].str+tree[x].len);
     995         [ +  + ]:      24823 :     else if (f!=Fnoarg)
     996         [ +  - ]:      24697 :       compilenode(arg[j], Ggen,j>=lnl?FLnocopylex:0);
     997                 :            :     else
     998                 :        126 :       op_push(OCpushlong,0,n);
     999                 :            :   }
    1000                 :      15249 :   op_push(OCcalluser,nb,x);
    1001                 :      15249 :   compilecast(n,Ggen,mode);
    1002                 :      15249 :   avma=ltop;
    1003                 :      15249 : }
    1004                 :            : 
    1005                 :            : static GEN
    1006                 :      34808 : compilefuncinline(long n, long c, long a, long flag, long isif, long lev, long *ev)
    1007                 :            : {
    1008                 :            :   struct codepos pos;
    1009         [ +  + ]:      34808 :   int type=c=='I'?Gvoid:Ggen;
    1010         [ +  + ]:      34808 :   long rflag=c=='I'?0:FLsurvive;
    1011                 :      34808 :   GEN vep = NULL;
    1012 [ +  + ][ +  + ]:      34808 :   if (isif && (flag&FLreturn)) rflag|=FLreturn;
    1013                 :      34808 :   getcodepos(&pos);
    1014         [ +  + ]:      34808 :   if (lev)
    1015                 :            :   {
    1016                 :            :     long i;
    1017                 :      29171 :     GEN varg=cgetg(lev+1,t_VECSMALL);
    1018                 :      29171 :     vep=cgetg(lev+1,t_VECSMALL);
    1019         [ +  + ]:      58543 :     for(i=0;i<lev;i++)
    1020                 :            :     {
    1021                 :            :       entree *ve;
    1022         [ -  + ]:      29372 :       if (ev[i]<0)
    1023                 :          0 :         compile_err("missing variable name", tree[a].str-1);
    1024                 :      29372 :       ve = getvar(ev[i]);
    1025                 :      29372 :       vep[i+1]=(long)ve;
    1026                 :      29372 :       varg[i+1]=ev[i];
    1027                 :      29372 :       var_push(ve,Lmy);
    1028                 :            :     }
    1029                 :      29171 :     checkdups(varg,vep);
    1030                 :      29171 :     frame_push(vep);
    1031                 :            :   }
    1032         [ +  + ]:      34808 :   if (c=='J')
    1033                 :         18 :     return compilelambda(n,a,vep,&pos);
    1034         [ +  + ]:      34790 :   else if (tree[a].f==Fnoarg)
    1035                 :         49 :     compilecast(a,Gvoid,type);
    1036                 :            :   else
    1037                 :      34741 :     compilenode(a,type,rflag);
    1038                 :      34808 :   return getclosure(&pos);
    1039                 :            : }
    1040                 :            : 
    1041                 :            : static long
    1042                 :       1431 : countvar(GEN arg)
    1043                 :            : {
    1044                 :       1431 :   long i, l = lg(arg);
    1045                 :       1431 :   long n = l-1;
    1046         [ +  + ]:       4700 :   for(i=1; i<l; i++)
    1047                 :            :   {
    1048                 :       3269 :     long a=arg[i];
    1049         [ +  + ]:       3269 :     if (tree[a].f==Fassign)
    1050                 :            :     {
    1051                 :       1781 :       long x = detag(tree[a].x);
    1052 [ +  + ][ +  - ]:       1781 :       if (tree[x].f==Fvec && tree[x].x>=0)
    1053                 :         91 :         n += countlisttogen(tree[x].x,Fmatrixelts)-1;
    1054                 :            :     }
    1055                 :            :   }
    1056                 :       1431 :   return n;
    1057                 :            : }
    1058                 :            : 
    1059                 :            : static void
    1060                 :          4 : compileuninline(GEN arg)
    1061                 :            : {
    1062                 :            :   long j;
    1063         [ -  + ]:          4 :   if (lg(arg) > 1)
    1064                 :          0 :     compile_err("too many arguments",tree[arg[1]].str);
    1065         [ +  + ]:         10 :   for(j=0; j<s_lvar.n; j++)
    1066         [ -  + ]:          6 :     if(!localvars[j].inl)
    1067                 :          0 :       pari_err(e_MISC,"uninline is only valid at top level");
    1068                 :          4 :   s_lvar.n = 0;
    1069                 :          4 : }
    1070                 :            : 
    1071                 :            : static void
    1072                 :       1424 : compilemy(GEN arg, const char *str, int inl)
    1073                 :            : {
    1074                 :       1424 :   long i, j, k, l = lg(arg);
    1075                 :       1424 :   long n = countvar(arg);
    1076                 :       1424 :   GEN vep = cgetg(n+1,t_VECSMALL);
    1077                 :       1424 :   GEN ver = cgetg(n+1,t_VECSMALL);
    1078         [ +  + ]:       1424 :   if (inl)
    1079                 :            :   {
    1080         [ -  + ]:          4 :     for(j=0; j<s_lvar.n; j++)
    1081         [ #  # ]:          0 :       if(!localvars[j].inl)
    1082                 :          0 :         pari_err(e_MISC,"inline is only valid at top level");
    1083                 :            :   }
    1084         [ +  + ]:       4658 :   for(k=0, i=1; i<l; i++)
    1085                 :            :   {
    1086                 :       3234 :     long a=arg[i];
    1087         [ +  + ]:       3234 :     if (tree[a].f==Fassign)
    1088                 :            :     {
    1089                 :       1753 :       long x = detag(tree[a].x);
    1090 [ +  + ][ +  - ]:       1753 :       if (tree[x].f==Fvec && tree[x].x>=0)
    1091                 :            :       {
    1092                 :         84 :         GEN vars = listtogen(tree[x].x,Fmatrixelts);
    1093                 :         84 :         long nv = lg(vars)-1;
    1094         [ +  + ]:        301 :         for (j=1; j<=nv; j++)
    1095                 :            :         {
    1096                 :        217 :           ver[++k] = vars[j];
    1097                 :        217 :           vep[k] = (long)getvar(ver[k]);
    1098                 :            :         }
    1099                 :         84 :         continue;
    1100                 :       1669 :       } else ver[++k] = x;
    1101                 :       1481 :     } else ver[++k] = a;
    1102                 :       3150 :     vep[k] = (long)getvar(ver[k]);
    1103                 :            :   }
    1104                 :       1424 :   checkdups(ver,vep);
    1105         [ +  + ]:       4791 :   for(i=1; i<=n; i++) var_push(NULL,Lmy);
    1106         [ +  + ]:       1424 :   op_push_loc(OCnewframe,inl?-n:n,str);
    1107                 :       1424 :   frame_push(vep);
    1108         [ +  + ]:       4658 :   for (k=0, i=1; i<l; i++)
    1109                 :            :   {
    1110                 :       3234 :     long a=arg[i];
    1111         [ +  + ]:       3234 :     if (tree[a].f==Fassign)
    1112                 :            :     {
    1113                 :       1753 :       long x = detag(tree[a].x);
    1114 [ +  + ][ +  - ]:       1753 :       if (tree[x].f==Fvec && tree[x].x>=0)
    1115                 :            :       {
    1116                 :         84 :         GEN vars = listtogen(tree[x].x,Fmatrixelts);
    1117                 :         84 :         long nv = lg(vars)-1;
    1118                 :         84 :         compilenode(tree[a].y,Ggen,FLnocopy);
    1119         [ +  - ]:         84 :         if (nv > 1) op_push(OCdup,nv-1,x);
    1120         [ +  + ]:        301 :         for (j=1; j<=nv; j++)
    1121                 :            :         {
    1122                 :        217 :           long v = detag(vars[j]);
    1123                 :        217 :           op_push(OCpushlong,j,v);
    1124                 :        217 :           op_push(OCcompo1,Ggen,v);
    1125                 :        217 :           k++;
    1126                 :        217 :           op_push(OCstorelex,-n+k-1,a);
    1127                 :        217 :           localvars[s_lvar.n-n+k-1].ep=(entree*)vep[k];
    1128                 :        217 :           localvars[s_lvar.n-n+k-1].inl=inl;
    1129                 :            :         }
    1130                 :         84 :         continue;
    1131                 :            :       }
    1132         [ +  + ]:       1669 :       else if (!is_node_zero(tree[a].y))
    1133                 :            :       {
    1134                 :       1634 :         compilenode(tree[a].y,Ggen,FLnocopy);
    1135                 :       1634 :         op_push(OCstorelex,-n+k,a);
    1136                 :            :       }
    1137                 :            :     }
    1138                 :       3150 :     k++;
    1139                 :       3150 :     localvars[s_lvar.n-n+k-1].ep=(entree*)vep[k];
    1140                 :       3150 :     localvars[s_lvar.n-n+k-1].inl=inl;
    1141                 :            :   }
    1142                 :       1424 : }
    1143                 :            : 
    1144                 :            : static long
    1145                 :         42 : localpush(op_code op, long a)
    1146                 :            : {
    1147                 :         42 :   entree *ep = getvar(a);
    1148                 :         42 :   long vep  = (long) ep;
    1149                 :         42 :   op_push(op,vep,a);
    1150                 :         42 :   var_push(ep,Llocal);
    1151                 :         42 :   return vep;
    1152                 :            : }
    1153                 :            : 
    1154                 :            : static void
    1155                 :          7 : compilelocal(GEN arg)
    1156                 :            : {
    1157                 :          7 :   long i, j, k, l = lg(arg);
    1158                 :          7 :   long n = countvar(arg);
    1159                 :          7 :   GEN vep = cgetg(n+1,t_VECSMALL);
    1160                 :          7 :   GEN ver = cgetg(n+1,t_VECSMALL);
    1161         [ +  + ]:         42 :   for(k=0, i=1; i<l; i++)
    1162                 :            :   {
    1163                 :         35 :     long a=arg[i];
    1164         [ +  + ]:         35 :     if (tree[a].f==Fassign)
    1165                 :            :     {
    1166                 :         28 :       long x = detag(tree[a].x);
    1167 [ +  + ][ +  - ]:         28 :       if (tree[x].f==Fvec && tree[x].x>=0)
    1168                 :            :       {
    1169                 :          7 :         GEN vars = listtogen(tree[x].x,Fmatrixelts);
    1170                 :          7 :         long nv = lg(vars)-1;
    1171                 :          7 :         compilenode(tree[a].y,Ggen,FLnocopy);
    1172         [ +  - ]:          7 :         if (nv > 1) op_push(OCdup,nv-1,x);
    1173         [ +  + ]:         21 :         for (j=1; j<=nv; j++)
    1174                 :            :         {
    1175                 :         14 :           long v = detag(vars[j]);
    1176                 :         14 :           op_push(OCpushlong,j,v);
    1177                 :         14 :           op_push(OCcompo1,Ggen,v);
    1178                 :         14 :           vep[++k] = localpush(OClocalvar, v);
    1179                 :         14 :           ver[k] = v;
    1180                 :            :         }
    1181                 :          7 :         continue;
    1182         [ +  + ]:         21 :       } else if (!is_node_zero(tree[a].y))
    1183                 :            :       {
    1184                 :         14 :         compilenode(tree[a].y,Ggen,FLnocopy);
    1185                 :         14 :         ver[++k] = x;
    1186                 :         14 :         vep[k] = localpush(OClocalvar, ver[k]);
    1187                 :         14 :         continue;
    1188                 :            :       }
    1189                 :            :       else
    1190                 :          7 :         ver[++k] = x;
    1191                 :            :     } else
    1192                 :          7 :       ver[++k] = a;
    1193                 :         14 :     vep[k] = localpush(OClocalvar0, ver[k]);
    1194                 :            :   }
    1195                 :          7 :   checkdups(ver,vep);
    1196                 :          7 : }
    1197                 :            : 
    1198                 :            : static void
    1199                 :    2667983 : compilefunc(entree *ep, long n, int mode, long flag)
    1200                 :            : {
    1201                 :    2667983 :   pari_sp ltop=avma;
    1202                 :            :   long j;
    1203                 :    2667983 :   long x=tree[n].x, y=tree[n].y;
    1204                 :            :   op_code ret_op;
    1205                 :            :   long ret_flag;
    1206                 :            :   Gtype ret_typ;
    1207                 :            :   char const *p,*q;
    1208                 :            :   char c;
    1209                 :    2667983 :   const char *flags = NULL;
    1210                 :            :   const char *str;
    1211                 :            :   PPproto mod;
    1212                 :    2667983 :   GEN arg=listtogen(y,Flistarg);
    1213                 :    2667983 :   long lnc=first_safe_arg(arg, COsafelex|COsafedyn);
    1214                 :    2667983 :   long lnl=first_safe_arg(arg, COsafelex);
    1215                 :    2667983 :   long nbpointers=0, nbopcodes;
    1216                 :    2667983 :   long nb=lg(arg)-1, lev=0;
    1217                 :            :   long ev[20];
    1218         [ +  + ]:    2667983 :   if (x>=OPnboperator)
    1219                 :     196990 :     str=tree[x].str;
    1220                 :            :   else
    1221                 :            :   {
    1222         [ +  + ]:    2470993 :     if (nb==2)
    1223                 :     274277 :       str=tree[arg[1]].str+tree[arg[1]].len;
    1224         [ +  + ]:    2196716 :     else if (nb==1)
    1225                 :    2196184 :       str=tree[arg[1]].str;
    1226                 :            :     else
    1227                 :        532 :       str=tree[n].str;
    1228         [ +  + ]:    2477163 :     while(*str==')') str++;
    1229                 :            :   }
    1230         [ -  + ]:    2667983 :   if (tree[n].f==Fassign)
    1231                 :            :   {
    1232                 :          0 :     nb=2; lnc=2; lnl=2; arg=mkvecsmall2(x,y);
    1233                 :            :   }
    1234         [ +  + ]:    2667983 :   else if (is_func_named(ep,"if"))
    1235                 :            :   {
    1236         [ +  + ]:       2714 :     if (nb>=4)
    1237                 :         70 :       ep=is_entry("_multi_if");
    1238         [ +  + ]:       2644 :     else if (mode==Gvoid)
    1239                 :       1108 :       ep=is_entry("_void_if");
    1240                 :            :   }
    1241 [ +  + ][ +  + ]:    2665269 :   else if (is_func_named(ep,"return") && (flag&FLreturn) && nb<=1)
                 [ +  - ]
    1242                 :            :   {
    1243         [ -  + ]:         70 :     if (nb==0) op_push(OCpushgnil,0,n);
    1244                 :         70 :     else compilenode(arg[1],Ggen,FLsurvive|FLreturn);
    1245                 :         70 :     avma=ltop;
    1246                 :            :     return;
    1247                 :            :   }
    1248         [ +  + ]:    2665199 :   else if (is_func_named(ep,"inline"))
    1249                 :            :   {
    1250                 :          4 :     compilemy(arg, str, 1);
    1251                 :          4 :     compilecast(n,Gvoid,mode);
    1252                 :          4 :     avma=ltop;
    1253                 :            :     return;
    1254                 :            :   }
    1255         [ +  + ]:    2665195 :   else if (is_func_named(ep,"uninline"))
    1256                 :            :   {
    1257                 :          4 :     compileuninline(arg);
    1258                 :          4 :     compilecast(n,Gvoid,mode);
    1259                 :          4 :     avma=ltop;
    1260                 :            :     return;
    1261                 :            :   }
    1262         [ +  + ]:    2665191 :   else if (is_func_named(ep,"my"))
    1263                 :            :   {
    1264                 :       1420 :     compilemy(arg, str, 0);
    1265                 :       1420 :     compilecast(n,Gvoid,mode);
    1266                 :       1420 :     avma=ltop;
    1267                 :            :     return;
    1268                 :            :   }
    1269         [ +  + ]:    2663771 :   else if (is_func_named(ep,"local"))
    1270                 :            :   {
    1271                 :          7 :     compilelocal(arg);
    1272                 :          7 :     compilecast(n,Gvoid,mode);
    1273                 :          7 :     avma=ltop;
    1274                 :            :     return;
    1275                 :            :   }
    1276                 :            :   /*We generate dummy code for global() for compatibility with gp2c*/
    1277         [ -  + ]:    2663764 :   else if (is_func_named(ep,"global"))
    1278                 :            :   {
    1279                 :            :     long i;
    1280         [ #  # ]:          0 :     for (i=1;i<=nb;i++)
    1281                 :            :     {
    1282                 :          0 :       long a=arg[i];
    1283                 :            :       long en;
    1284         [ #  # ]:          0 :       if (tree[a].f==Fassign)
    1285                 :            :       {
    1286                 :          0 :         compilenode(tree[a].y,Ggen,0);
    1287                 :          0 :         a=tree[a].x;
    1288                 :          0 :         en=(long)getvar(a);
    1289                 :          0 :         op_push(OCstoredyn,en,a);
    1290                 :            :       }
    1291                 :            :       else
    1292                 :            :       {
    1293                 :          0 :         en=(long)getvar(a);
    1294                 :          0 :         op_push(OCpushdyn,en,a);
    1295                 :          0 :         op_push(OCpop,1,a);
    1296                 :            :       }
    1297                 :            :     }
    1298                 :          0 :     compilecast(n,Gvoid,mode);
    1299                 :          0 :     avma=ltop;
    1300                 :            :     return;
    1301                 :            :   }
    1302         [ +  + ]:    2663764 :   else if (is_func_named(ep,"O"))
    1303                 :            :   {
    1304         [ -  + ]:       2800 :     if (nb!=1)
    1305                 :          0 :       compile_err("wrong number of arguments", tree[n].str+tree[n].len-1);
    1306                 :       2800 :     ep=is_entry("O(_^_)");
    1307 [ +  + ][ +  + ]:       2800 :     if (tree[arg[1]].f==Ffunction && tree[arg[1]].x==OPpow)
    1308                 :            :     {
    1309                 :       2079 :       arg = listtogen(tree[arg[1]].y,Flistarg);
    1310                 :       2079 :       nb  = lg(arg)-1;
    1311                 :       2079 :       lnc = first_safe_arg(arg,COsafelex|COsafedyn);
    1312                 :       2079 :       lnl = first_safe_arg(arg,COsafelex);
    1313                 :            :     }
    1314                 :            :   }
    1315 [ +  + ][ +  + ]:    2660964 :   else if (x==OPn && tree[y].f==Fsmall)
    1316                 :            :   {
    1317                 :    1956852 :     avma=ltop;
    1318                 :    1956852 :     compilesmall(y, -tree[y].x, mode);
    1319                 :            :     return;
    1320                 :            :   }
    1321 [ +  + ][ +  + ]:     704112 :   else if (x==OPtrans && tree[y].f==Fvec)
    1322                 :            :   {
    1323                 :       2107 :     avma=ltop;
    1324                 :       2107 :     compilevec(y, mode, OCcol);
    1325                 :            :     return;
    1326                 :            :   }
    1327 [ +  + ][ +  - ]:     702005 :   else if (x==OPpow && nb==2 && tree[arg[2]].f==Fsmall)
                 [ +  + ]
    1328                 :      35951 :     ep=is_entry("_^s");
    1329         [ -  + ]:     666054 :   else if (x==OPcat)
    1330                 :          0 :     compile_err("expected character: ',' or ')' instead of",
    1331                 :          0 :         tree[arg[1]].str+tree[arg[1]].len);
    1332                 :     707519 :   p=ep->code;
    1333         [ -  + ]:     707519 :   if (!ep->value)
    1334                 :          0 :     compile_err("unknown function",tree[n].str);
    1335                 :     707519 :   nbopcodes = s_opcode.n;
    1336                 :     707519 :   ret_op = get_ret_type(&p, ep->arity, &ret_typ, &ret_flag);
    1337                 :     707519 :   j=1;
    1338         [ +  + ]:     707519 :   if (*p)
    1339                 :            :   {
    1340                 :     700936 :     q=p;
    1341         [ +  + ]:    1982290 :     while((mod=parseproto(&p,&c,tree[n].str))!=PPend)
    1342                 :            :     {
    1343 [ +  + ][ +  + ]:    1281361 :       if (j<=nb && tree[arg[j]].f!=Fnoarg
    1344 [ +  + ][ +  + ]:    1163420 :           && (mod==PPdefault || mod==PPdefaultmulti))
    1345                 :      61299 :         mod=PPstd;
    1346   [ +  +  +  +  :    1281361 :       switch(mod)
                   +  - ]
    1347                 :            :       {
    1348                 :            :       case PPstd:
    1349         [ -  + ]:    1149707 :         if (j>nb) compile_err("too few arguments", tree[n].str+tree[n].len-1);
    1350 [ +  + ][ +  + ]:    1149707 :         if (c!='I' && c!='E' && c!='J')
                 [ +  + ]
    1351                 :            :         {
    1352                 :    1115207 :           long x = tree[arg[j]].x, f = tree[arg[j]].f;
    1353         [ -  + ]:    1115207 :           if (f==Fnoarg)
    1354                 :          0 :             compile_err("missing mandatory argument", tree[arg[j]].str);
    1355         [ -  + ]:    1115207 :           if (f==Fseq)
    1356                 :          0 :             compile_err("unexpected ';'", tree[x].str+tree[x].len);
    1357                 :            :         }
    1358   [ +  +  +  +  :    1149707 :         switch(c)
          -  +  +  +  +  
             +  +  +  - ]
    1359                 :            :         {
    1360                 :            :         case 'G':
    1361 [ +  + ][ +  + ]:     962303 :           compilenode(arg[j],Ggen,j>=lnl?(j>=lnc?FLnocopy:FLnocopylex):0);
    1362                 :     962303 :           j++;
    1363                 :     962303 :           break;
    1364                 :            :         case 'W':
    1365                 :            :           {
    1366                 :        133 :             long a = arg[j];
    1367                 :        133 :             entree *ep = getlvalue(a);
    1368                 :        133 :             long vn = getmvar(ep);
    1369         [ +  + ]:        133 :             if (vn) op_push(OCcowvarlex, vn, a);
    1370                 :        105 :             else op_push(OCcowvardyn, (long)ep, a);
    1371                 :        133 :             compilenode(arg[j++],Ggen,FLnocopy);
    1372                 :        133 :             break;
    1373                 :            :           }
    1374                 :            :         case 'M':
    1375         [ +  - ]:       5584 :           if (tree[arg[j]].f!=Fsmall)
    1376                 :            :           {
    1377         [ +  - ]:       5584 :             if (!flags) flags = ep->code;
    1378                 :       5584 :             flags = strchr(flags, '\n'); /* Skip to the following '\n' */
    1379         [ -  + ]:       5584 :             if (!flags)
    1380                 :          0 :               compile_err("missing flag in string function signature",
    1381                 :          0 :                            tree[n].str);
    1382                 :       5584 :             flags++;
    1383 [ +  - ][ +  - ]:       5584 :             if (tree[arg[j]].f==Fconst && tree[arg[j]].x==CSTstr)
    1384                 :       5584 :             {
    1385                 :       5584 :               GEN str=strntoGENexp(tree[arg[j]].str,tree[arg[j]].len);
    1386                 :       5584 :               op_push(OCpushlong, eval_mnemonic(str, flags),n);
    1387                 :       5584 :               j++;
    1388                 :            :             } else
    1389                 :            :             {
    1390                 :          0 :               compilenode(arg[j++],Ggen,0);
    1391                 :          0 :               op_push(OCpushlong,(long)flags,n);
    1392                 :          0 :               op_push(OCcallgen2,(long)is_entry("_eval_mnemonic"),n);
    1393                 :            :             }
    1394                 :       5584 :             break;
    1395                 :            :           }
    1396                 :            :         case 'P': case 'L':
    1397                 :     109985 :           compilenode(arg[j++],Gsmall,0);
    1398                 :     109985 :           break;
    1399                 :            :         case 'U':
    1400                 :          0 :           compilenode(arg[j++],Gusmall,0);
    1401                 :          0 :           break;
    1402                 :            :         case 'n':
    1403                 :       1904 :           compilenode(arg[j++],Gvar,0);
    1404                 :       1897 :           break;
    1405                 :            :         case '&': case '*':
    1406                 :            :           {
    1407                 :        936 :             long vn, a=arg[j++];
    1408                 :            :             entree *ep;
    1409         [ +  + ]:        936 :             if (c=='&')
    1410                 :            :             {
    1411         [ -  + ]:        560 :               if (tree[a].f!=Frefarg)
    1412                 :          0 :                 compile_err("expected character: '&'", tree[a].str);
    1413                 :        560 :               a=tree[a].x;
    1414                 :            :             }
    1415                 :        936 :             a=detag(a);
    1416                 :        936 :             ep=getlvalue(a);
    1417                 :        936 :             vn=getmvar(ep);
    1418         [ +  + ]:        936 :             if (tree[a].f==Fentry)
    1419                 :            :             {
    1420         [ +  + ]:        852 :               if (vn)
    1421                 :        250 :                 op_push(OCsimpleptrlex, vn,n);
    1422                 :            :               else
    1423                 :        602 :                 op_push(OCsimpleptrdyn, (long)ep,n);
    1424                 :            :             }
    1425                 :            :             else
    1426                 :            :             {
    1427                 :         84 :               compilenewptr(vn, ep, a);
    1428                 :         84 :               compilelvalue(a);
    1429                 :         84 :               op_push(OCpushptr, 0, a);
    1430                 :            :             }
    1431                 :        936 :             nbpointers++;
    1432                 :        936 :             break;
    1433                 :            :           }
    1434                 :            :         case 'I':
    1435                 :            :         case 'E':
    1436                 :            :         case 'J':
    1437                 :            :           {
    1438                 :      34500 :             long a = arg[j++];
    1439                 :      34500 :             GEN  d = compilefuncinline(n, c, a, flag, is_func_named(ep,"if"), lev, ev);
    1440                 :      34500 :             op_push(OCpushgen, data_push(d), a);
    1441         [ +  + ]:      34500 :             if (lg(d)==8) op_push(OCsaveframe,FLsurvive,n);
    1442                 :      34500 :             break;
    1443                 :            :           }
    1444                 :            :         case 'V':
    1445                 :            :           {
    1446                 :      12492 :             long a = arg[j++];
    1447                 :      12492 :             (void)getvar(a);
    1448                 :      12492 :             ev[lev++] = a;
    1449                 :      12492 :             break;
    1450                 :            :           }
    1451                 :            :         case '=':
    1452                 :            :           {
    1453                 :      16626 :             long a = arg[j++];
    1454                 :      16626 :             ev[lev++] = tree[a].x;
    1455                 :      16626 :             compilenode(tree[a].y, Ggen, FLnocopy);
    1456                 :            :           }
    1457                 :      16626 :           break;
    1458                 :            :         case 'r':
    1459                 :            :           {
    1460                 :       1063 :             long a=arg[j++];
    1461         [ +  + ]:       1063 :             if (tree[a].f==Fentry)
    1462                 :            :             {
    1463                 :        979 :               op_push(OCpushgen, data_push(strntoGENstr(tree[tree[a].x].str,
    1464                 :        979 :                                                         tree[tree[a].x].len)),n);
    1465                 :        979 :               op_push(OCtostr, -1,n);
    1466                 :            :             }
    1467                 :            :             else
    1468                 :            :             {
    1469                 :         84 :               compilenode(a,Ggen,FLnocopy);
    1470                 :         84 :               op_push(OCtostr, -1,n);
    1471                 :            :             }
    1472                 :       1063 :             break;
    1473                 :            :           }
    1474                 :            :         case 's':
    1475                 :            :           {
    1476                 :       4181 :             long a = arg[j++];
    1477                 :       4181 :             GEN g = cattovec(a, OPcat);
    1478                 :       4181 :             long l, nb = lg(g)-1;
    1479         [ +  + ]:       4181 :             if (nb==1)
    1480                 :            :             {
    1481                 :       4167 :               compilenode(g[1], Ggen, FLnocopy);
    1482                 :       4167 :               op_push(OCtostr, -1, a);
    1483                 :            :             } else
    1484                 :            :             {
    1485                 :         14 :               op_push(OCvec, nb+1, a);
    1486         [ +  + ]:         42 :               for(l=1; l<=nb; l++)
    1487                 :            :               {
    1488                 :         28 :                 compilenode(g[l], Ggen, FLsurvive);
    1489                 :         28 :                 op_push(OCstackgen,l, a);
    1490                 :            :               }
    1491                 :         14 :               op_push(OCpop, 1, a);
    1492                 :         14 :               op_push(OCcallgen,(long)is_entry("Str"), a);
    1493                 :         14 :               op_push(OCtostr, -1, a);
    1494                 :            :             }
    1495                 :       4181 :             break;
    1496                 :            :           }
    1497                 :            :         default:
    1498                 :          0 :           pari_err(e_MISC,"Unknown prototype code `%c' for `%.*s'",c,
    1499                 :          0 :               tree[x].len, tree[x].str);
    1500                 :            :         }
    1501                 :    1149700 :         break;
    1502                 :            :       case PPauto:
    1503   [ +  +  -  +  :      44817 :         switch(c)
                   -  - ]
    1504                 :            :         {
    1505                 :            :         case 'p':
    1506                 :      43473 :           op_push(OCprecreal,0,n);
    1507                 :      43473 :           break;
    1508                 :            :         case 'b':
    1509                 :       1309 :           op_push(OCbitprecreal,0,n);
    1510                 :       1309 :           break;
    1511                 :            :         case 'P':
    1512                 :          0 :           op_push(OCprecdl,0,n);
    1513                 :          0 :           break;
    1514                 :            :         case 'C':
    1515                 :         35 :           op_push(OCpushgen,data_push(pack_localvars()),n);
    1516                 :         35 :           break;
    1517                 :            :         case 'f':
    1518                 :            :           {
    1519                 :            :             static long foo;
    1520                 :          0 :             op_push(OCpushlong,(long)&foo,n);
    1521                 :          0 :             break;
    1522                 :            :           }
    1523                 :            :         }
    1524                 :      44817 :         break;
    1525                 :            :       case PPdefault:
    1526                 :      35805 :         j++;
    1527   [ +  +  +  +  :      35805 :         switch(c)
                      - ]
    1528                 :            :         {
    1529                 :            :         case 'G':
    1530                 :            :         case '&':
    1531                 :            :         case 'E':
    1532                 :            :         case 'I':
    1533                 :            :         case 'r':
    1534                 :            :         case 's':
    1535                 :      31548 :           op_push(OCpushlong,0,n);
    1536                 :      31548 :           break;
    1537                 :            :         case 'n':
    1538                 :       3807 :           op_push(OCpushlong,-1,n);
    1539                 :       3807 :           break;
    1540                 :            :         case 'V':
    1541                 :        331 :           ev[lev++] = -1;
    1542                 :        331 :           break;
    1543                 :            :         case 'P':
    1544                 :        119 :           op_push(OCprecdl,0,n);
    1545                 :        119 :           break;
    1546                 :            :         default:
    1547                 :          0 :           pari_err(e_MISC,"Unknown prototype code `%c' for `%.*s'",c,
    1548                 :          0 :               tree[x].len, tree[x].str);
    1549                 :            :         }
    1550                 :      35805 :         break;
    1551                 :            :       case PPdefaultmulti:
    1552                 :      42707 :         j++;
    1553   [ +  +  -  +  :      42707 :         switch(c)
                      - ]
    1554                 :            :         {
    1555                 :            :         case 'G':
    1556                 :        119 :           op_push(OCpushstoi,strtol(q+1,NULL,10),n);
    1557                 :        119 :           break;
    1558                 :            :         case 'L':
    1559                 :            :         case 'M':
    1560                 :      42567 :           op_push(OCpushlong,strtol(q+1,NULL,10),n);
    1561                 :      42567 :           break;
    1562                 :            :         case 'U':
    1563                 :          0 :           op_push(OCpushlong,(long)strtoul(q+1,NULL,10),n);
    1564                 :          0 :           break;
    1565                 :            :         case 'r':
    1566                 :            :         case 's':
    1567                 :         21 :           str_defproto(p, q, tree[n].str);
    1568                 :         21 :           op_push(OCtostr, -1, n);
    1569                 :         21 :           break;
    1570                 :            :         default:
    1571                 :          0 :           pari_err(e_MISC,"Unknown prototype code `%c' for `%.*s'",c,
    1572                 :          0 :               tree[x].len, tree[x].str);
    1573                 :            :         }
    1574                 :      42707 :         break;
    1575                 :            :       case PPstar:
    1576      [ +  +  - ]:       8325 :         switch(c)
    1577                 :            :         {
    1578                 :            :         case 'E':
    1579                 :            :           {
    1580                 :         70 :             long k, n=nb+1-j;
    1581                 :         70 :             GEN g=cgetg(n+1,t_VEC);
    1582                 :         70 :             int ismif = is_func_named(ep,"_multi_if");
    1583         [ +  + ]:        378 :             for(k=1; k<=n; k++)
    1584         [ +  - ]:        352 :               gel(g, k) = compilefuncinline(n, c, arg[j+k-1], flag,
    1585 [ +  + ][ +  + ]:        308 :                           ismif && (k==n || odd(k)), lev, ev);
            [ +  + ][ + ]
    1586                 :         70 :             op_push(OCpushgen, data_push(g), arg[j]);
    1587                 :         70 :             j=nb+1;
    1588                 :         70 :             break;
    1589                 :            :           }
    1590                 :            :         case 's':
    1591                 :            :           {
    1592                 :       8255 :             long n=nb+1-j;
    1593                 :            :             long k,l,l1,m;
    1594                 :       8255 :             GEN g=cgetg(n+1,t_VEC);
    1595         [ +  + ]:      20860 :             for(l1=0,k=1;k<=n;k++)
    1596                 :            :             {
    1597                 :      12605 :               gel(g,k)=cattovec(arg[j+k-1],OPcat);
    1598                 :      12605 :               l1+=lg(gel(g,k))-1;
    1599                 :            :             }
    1600                 :       8255 :             op_push_loc(OCvec, l1+1, str);
    1601         [ +  + ]:      20860 :             for(m=1,k=1;k<=n;k++)
    1602         [ +  + ]:      25322 :               for(l=1;l<lg(gel(g,k));l++,m++)
    1603                 :            :               {
    1604                 :      12717 :                 compilenode(mael(g,k,l),Ggen,FLsurvive);
    1605                 :      12717 :                 op_push(OCstackgen,m,mael(g,k,l));
    1606                 :            :               }
    1607                 :       8255 :             op_push_loc(OCpop, 1, str);
    1608                 :       8255 :             j=nb+1;
    1609                 :       8255 :             break;
    1610                 :            :           }
    1611                 :            :         default:
    1612                 :          0 :           pari_err(e_MISC,"Unknown prototype code `%c*' for `%.*s'",c,
    1613                 :          0 :               tree[x].len, tree[x].str);
    1614                 :            :         }
    1615                 :       8325 :         break;
    1616                 :            :       default:
    1617                 :          0 :         pari_err_BUG("compilefunc [unknown PPproto]");
    1618                 :            :       }
    1619                 :    1281354 :       q=p;
    1620                 :            :     }
    1621                 :            :   }
    1622         [ -  + ]:     707512 :   if (j<=nb)
    1623                 :          0 :     compile_err("too many arguments",tree[arg[j]].str);
    1624                 :     707512 :   op_push_loc(ret_op, (long) ep, str);
    1625 [ +  + ][ +  + ]:     707512 :   if ((ret_flag&FLnocopy) && !(flag&FLnocopy))
    1626                 :       8834 :     op_push_loc(OCcopy,0,str);
    1627 [ +  + ][ +  + ]:     707512 :   if (ret_typ==Ggen && nbpointers==0 && s_opcode.n>nbopcodes+128)
                 [ +  + ]
    1628                 :            :   {
    1629                 :       1624 :     op_insert_loc(nbopcodes,OCavma,0,str);
    1630                 :       1624 :     op_push_loc(OCgerepile,0,str);
    1631                 :            :   }
    1632                 :     707512 :   compilecast(n,ret_typ,mode);
    1633         [ +  + ]:     707512 :   if (nbpointers) op_push_loc(OCendptr,nbpointers, str);
    1634                 :    2667976 :   avma=ltop;
    1635                 :            : }
    1636                 :            : 
    1637                 :            : static void
    1638                 :       1185 : genclosurectx(const char *loc, long nbdata)
    1639                 :            : {
    1640                 :            :   long i;
    1641                 :       1185 :   GEN vep = cgetg(nbdata+1,t_VECSMALL);
    1642         [ +  + ]:       8554 :   for(i = 1; i <= nbdata; i++)
    1643                 :            :   {
    1644                 :       7369 :     vep[i] = 0;
    1645                 :       7369 :     op_push_loc(OCpushlex,-i,loc);
    1646                 :            :   }
    1647                 :       1185 :   frame_push(vep);
    1648                 :       1185 : }
    1649                 :            : 
    1650                 :            : static GEN
    1651                 :      12860 : genclosure(entree *ep, const char *loc, long  nbdata, int check)
    1652                 :            : {
    1653                 :      12860 :   pari_sp av = avma;
    1654                 :            :   struct codepos pos;
    1655                 :      12860 :   long nb=0;
    1656                 :      12860 :   const char *code=ep->code,*p,*q;
    1657                 :            :   char c;
    1658                 :            :   GEN text;
    1659                 :      12860 :   long index=ep->arity;
    1660                 :      12860 :   long arity=0, maskarg=0, maskarg0=0, stop=0, dovararg=0;
    1661                 :            :   PPproto mod;
    1662                 :            :   Gtype ret_typ;
    1663                 :            :   long ret_flag;
    1664                 :      12860 :   op_code ret_op=get_ret_type(&code,ep->arity,&ret_typ,&ret_flag);
    1665                 :      12860 :   p=code;
    1666         [ +  + ]:      30787 :   while ((mod=parseproto(&p,&c,NULL))!=PPend)
    1667                 :            :   {
    1668         [ +  + ]:      17927 :     if (mod==PPauto)
    1669                 :       6678 :       stop=1;
    1670                 :            :     else
    1671                 :            :     {
    1672         [ -  + ]:      11249 :       if (stop) return NULL;
    1673         [ -  + ]:      11249 :       if (c=='V') continue;
    1674                 :      11249 :       maskarg<<=1; maskarg0<<=1; arity++;
    1675      [ +  +  + ]:      11249 :       switch(mod)
    1676                 :            :       {
    1677                 :            :       case PPstd:
    1678                 :      10646 :         maskarg|=1L;
    1679                 :      10646 :         break;
    1680                 :            :       case PPdefault:
    1681         [ +  + ]:        254 :         switch(c)
    1682                 :            :         {
    1683                 :            :         case '&':
    1684                 :            :         case 'E':
    1685                 :            :         case 'I':
    1686                 :         14 :           maskarg0|=1L;
    1687                 :         14 :           break;
    1688                 :            :         }
    1689                 :        254 :         break;
    1690                 :            :       default:
    1691                 :        349 :         break;
    1692                 :            :       }
    1693                 :            :     }
    1694                 :            :   }
    1695 [ +  + ][ +  - ]:      12860 :   if (check && EpSTATIC(ep) && maskarg==0)
                 [ +  + ]
    1696                 :      10538 :     return gen_0;
    1697                 :       2322 :   getcodepos(&pos);
    1698                 :       2322 :   dbgstart = loc;
    1699         [ -  + ]:       2322 :   if (nbdata > arity)
    1700                 :          0 :     pari_err(e_MISC,"too many parameters for closure `%s'", ep->name);
    1701         [ +  + ]:       2322 :   if (nbdata) genclosurectx(loc, nbdata);
    1702                 :       2322 :   text = strtoGENstr(ep->name);
    1703                 :       2322 :   arity -= nbdata;
    1704         [ +  - ]:       2322 :   if (maskarg)  op_push_loc(OCcheckargs,maskarg,loc);
    1705         [ +  + ]:       2322 :   if (maskarg0) op_push_loc(OCcheckargs0,maskarg0,loc);
    1706                 :       2322 :   p=code;
    1707         [ +  + ]:      13781 :   while ((mod=parseproto(&p,&c,NULL))!=PPend)
    1708                 :            :   {
    1709         [ +  + ]:      11459 :     switch(mod)
    1710                 :            :     {
    1711                 :            :     case PPauto:
    1712   [ +  -  -  -  :        357 :       switch(c)
                   -  - ]
    1713                 :            :       {
    1714                 :            :       case 'p':
    1715                 :        357 :         op_push_loc(OCprecreal,0,loc);
    1716                 :        357 :         break;
    1717                 :            :       case 'b':
    1718                 :          0 :         op_push_loc(OCbitprecreal,0,loc);
    1719                 :          0 :         break;
    1720                 :            :       case 'P':
    1721                 :          0 :         op_push_loc(OCprecdl,0,loc);
    1722                 :          0 :         break;
    1723                 :            :       case 'C':
    1724                 :          0 :         op_push_loc(OCpushgen,data_push(pack_localvars()),loc);
    1725                 :          0 :         break;
    1726                 :            :       case 'f':
    1727                 :            :         {
    1728                 :            :           static long foo;
    1729                 :          0 :           op_push_loc(OCpushlong,(long)&foo,loc);
    1730                 :          0 :           break;
    1731                 :            :         }
    1732                 :            :       }
    1733                 :            :     default:
    1734                 :      11459 :       break;
    1735                 :            :     }
    1736                 :            :   }
    1737                 :       2322 :   q = p = code;
    1738         [ +  + ]:      13781 :   while ((mod=parseproto(&p,&c,NULL))!=PPend)
    1739                 :            :   {
    1740   [ +  +  +  +  :      11459 :     switch(mod)
                   +  - ]
    1741                 :            :     {
    1742                 :            :     case PPstd:
    1743   [ +  +  +  -  :      10646 :       switch(c)
                -  +  - ]
    1744                 :            :       {
    1745                 :            :       case 'G':
    1746                 :       8359 :         break;
    1747                 :            :       case 'M':
    1748                 :            :       case 'L':
    1749                 :        563 :         op_push_loc(OCitos,-index,loc);
    1750                 :        563 :         break;
    1751                 :            :       case 'U':
    1752                 :       1689 :         op_push_loc(OCitou,-index,loc);
    1753                 :       1689 :         break;
    1754                 :            :       case 'n':
    1755                 :          0 :         op_push_loc(OCvarn,-index,loc);
    1756                 :          0 :         break;
    1757                 :            :       case '&': case '*':
    1758                 :            :       case 'I':
    1759                 :            :       case 'E':
    1760                 :            :       case 'V':
    1761                 :            :       case '=':
    1762                 :          0 :         return NULL;
    1763                 :            :       case 'r':
    1764                 :            :       case 's':
    1765                 :         35 :         op_push_loc(OCtostr,-index,loc);
    1766                 :         35 :         break;
    1767                 :            :       }
    1768                 :      10646 :       break;
    1769                 :            :     case PPauto:
    1770                 :        357 :       break;
    1771                 :            :     case PPdefault:
    1772   [ +  +  +  - ]:        233 :       switch(c)
    1773                 :            :       {
    1774                 :            :       case 'G':
    1775                 :            :       case '&':
    1776                 :            :       case 'E':
    1777                 :            :       case 'I':
    1778                 :            :       case 'V':
    1779                 :            :       case 'r':
    1780                 :            :       case 's':
    1781                 :        142 :         break;
    1782                 :            :       case 'n':
    1783                 :         56 :         op_push_loc(OCvarn,-index,loc);
    1784                 :         56 :         break;
    1785                 :            :       case 'P':
    1786                 :         35 :         op_push_loc(OCprecdl,0,loc);
    1787                 :         35 :         op_push_loc(OCdefaultlong,-index,loc);
    1788                 :         35 :         break;
    1789                 :            :       default:
    1790                 :          0 :         pari_err(e_MISC,"Unknown prototype code `D%c' for `%s'",c,ep->name);
    1791                 :            :       }
    1792                 :        233 :       break;
    1793                 :            :     case PPdefaultmulti:
    1794   [ -  +  -  +  :        202 :       switch(c)
                      - ]
    1795                 :            :       {
    1796                 :            :       case 'G':
    1797                 :          0 :         op_push_loc(OCpushstoi,strtol(q+1,NULL,10),loc);
    1798                 :          0 :         op_push_loc(OCdefaultgen,-index,loc);
    1799                 :          0 :         break;
    1800                 :            :       case 'L':
    1801                 :            :       case 'M':
    1802                 :        188 :         op_push_loc(OCpushlong,strtol(q+1,NULL,10),loc);
    1803                 :        188 :         op_push_loc(OCdefaultlong,-index,loc);
    1804                 :        188 :         break;
    1805                 :            :       case 'U':
    1806                 :          0 :         op_push_loc(OCpushlong,(long)strtoul(q+1,NULL,10),loc);
    1807                 :          0 :         op_push_loc(OCdefaultulong,-index,loc);
    1808                 :            :       case 'r':
    1809                 :            :       case 's':
    1810                 :         14 :         str_defproto(p, q, loc);
    1811                 :         14 :         op_push_loc(OCdefaultgen,-index,loc);
    1812                 :         14 :         op_push_loc(OCtostr,-index,loc);
    1813                 :         14 :         break;
    1814                 :            :       default:
    1815                 :          0 :         pari_err(e_MISC,
    1816                 :            :             "Unknown prototype code `D...,%c,' for `%s'",c,ep->name);
    1817                 :            :       }
    1818                 :        202 :       break;
    1819                 :            :     case PPstar:
    1820      [ +  -  - ]:         21 :       switch(c)
    1821                 :            :       {
    1822                 :            :       case 's':
    1823                 :         21 :         dovararg = 1;
    1824                 :         21 :         break;
    1825                 :            :       case 'E':
    1826                 :          0 :         return NULL;
    1827                 :            :       default:
    1828                 :          0 :         pari_err(e_MISC,"Unknown prototype code `%c*' for `%s'",c,ep->name);
    1829                 :            :       }
    1830                 :         21 :       break;
    1831                 :            :     default:
    1832                 :          0 :       return NULL;
    1833                 :            :     }
    1834                 :      11459 :     index--;
    1835                 :      11459 :     q = p;
    1836                 :            :   }
    1837                 :       2322 :   op_push_loc(ret_op, (long) ep, loc);
    1838         [ -  + ]:       2322 :   if (ret_flag==FLnocopy) op_push_loc(OCcopy,0,loc);
    1839                 :       2322 :   compilecast_loc(ret_typ, Ggen, loc);
    1840         [ +  + ]:       2322 :   if (dovararg) nb|=VARARGBITS;
    1841                 :      12860 :   return gerepilecopy(av, getfunction(&pos,nb+arity,nbdata,text,0));
    1842                 :            : }
    1843                 :            : 
    1844                 :            : GEN
    1845                 :        611 : snm_closure(entree *ep, GEN data)
    1846                 :            : {
    1847                 :            :   long i;
    1848         [ +  + ]:        611 :   long n = data ? lg(data)-1: 0;
    1849                 :        611 :   GEN C = genclosure(ep,ep->name,n,0);
    1850         [ +  + ]:       2879 :   for(i=1; i<=n; i++)
    1851                 :       2268 :     gmael(C,7,i) = gel(data,i);
    1852                 :        611 :   return C;
    1853                 :            : }
    1854                 :            : 
    1855                 :            : GEN
    1856                 :        583 : strtoclosure(const char *s, long n,  ...)
    1857                 :            : {
    1858                 :        583 :   pari_sp av = avma;
    1859                 :        583 :   entree *ep = is_entry(s);
    1860                 :            :   GEN C;
    1861         [ -  + ]:        583 :   if (!ep) pari_err(e_NOTFUNC, strtoGENstr(s));
    1862                 :        583 :   ep = do_alias(ep);
    1863 [ -  + ][ #  # ]:        583 :   if ((!EpSTATIC(ep) && EpVALENCE(ep)!=EpINSTALL) || !ep->value)
                 [ -  + ]
    1864                 :          0 :     pari_err(e_MISC,"not a built-in/install'ed function: \"%s\"",s);
    1865                 :        583 :   C = genclosure(ep,ep->name,n,0);
    1866         [ -  + ]:        583 :   if (!C) pari_err(e_MISC,"function prototype unsupported: \"%s\"",s);
    1867                 :            :   else
    1868                 :            :   {
    1869                 :            :     va_list ap;
    1870                 :            :     long i;
    1871                 :        583 :     va_start(ap,n);
    1872         [ +  + ]:       5684 :     for(i=1; i<=n; i++)
    1873         [ +  + ]:       5101 :       gmael(C,7,i) = va_arg(ap, GEN);
    1874                 :        583 :     va_end(ap);
    1875                 :            :   }
    1876                 :        583 :   return gerepilecopy(av, C);
    1877                 :            : }
    1878                 :            : 
    1879                 :            : GEN
    1880                 :          7 : strtofunction(const char *s)
    1881                 :            : {
    1882                 :          7 :   return strtoclosure(s, 0);
    1883                 :            : }
    1884                 :            : 
    1885                 :            : GEN
    1886                 :         21 : call0(GEN fun, GEN args)
    1887                 :            : {
    1888         [ -  + ]:         21 :   if (!is_vec_t(typ(args))) pari_err_TYPE("call",args);
    1889      [ +  +  - ]:         21 :   switch(typ(fun))
    1890                 :            :   {
    1891                 :            :     case t_STR:
    1892                 :          7 :       fun = strtofunction(GSTR(fun));
    1893                 :            :     case t_CLOSURE: /* fall through */
    1894                 :         21 :       return closure_callgenvec(fun, args);
    1895                 :            :     default:
    1896                 :          0 :       pari_err_TYPE("call", fun);
    1897                 :         14 :       return NULL; /* NOT REACHED */
    1898                 :            :   }
    1899                 :            : }
    1900                 :            : 
    1901                 :            : static void
    1902                 :      11666 : closurefunc(entree *ep, long n, long mode)
    1903                 :            : {
    1904                 :      11666 :   pari_sp ltop=avma;
    1905                 :            :   GEN C;
    1906         [ -  + ]:      11666 :   if (!ep->value) compile_err("unknown function",tree[n].str);
    1907                 :      11666 :   C = genclosure(ep,tree[n].str,0,1);
    1908         [ -  + ]:      11666 :   if (!C) compile_err("sorry, closure not implemented",tree[n].str);
    1909         [ +  + ]:      11666 :   if (C==gen_0)
    1910                 :            :   {
    1911                 :      10538 :     compilefunc(ep,n,mode,0);
    1912                 :      11666 :     return;
    1913                 :            :   }
    1914                 :       1128 :   op_push(OCpushgen, data_push(C), n);
    1915                 :       1128 :   compilecast(n,Gclosure,mode);
    1916                 :       1128 :   avma=ltop;
    1917                 :            : }
    1918                 :            : 
    1919                 :            : static void
    1920                 :      13729 : compileseq(long n, int mode, long flag)
    1921                 :            : {
    1922                 :      13729 :   pari_sp av = avma;
    1923                 :      13729 :   GEN L = listtogen(n, Fseq);
    1924                 :      13729 :   long i, l = lg(L)-1;
    1925         [ +  + ]:      38605 :   for(i = 1; i < l; i++)
    1926                 :      24876 :     compilenode(L[i],Gvoid,0);
    1927                 :      13729 :   compilenode(L[l],mode,flag&(FLreturn|FLsurvive));
    1928                 :      13729 :   avma = av;
    1929                 :      13729 : }
    1930                 :            : 
    1931                 :            : static void
    1932                 :   13218867 : compilenode(long n, int mode, long flag)
    1933                 :            : {
    1934                 :            :   long x,y;
    1935                 :            : #ifdef STACK_CHECK
    1936 [ +  - ][ -  + ]:   13218867 :   if (PARI_stack_limit && (void*) &x <= PARI_stack_limit)
    1937                 :          0 :     pari_err(e_MISC, "expression nested too deeply");
    1938                 :            : #endif
    1939         [ -  + ]:   13218867 :   if (n<0) pari_err_BUG("compilenode");
    1940                 :   13218867 :   x=tree[n].x;
    1941                 :   13218867 :   y=tree[n].y;
    1942                 :            : 
    1943   [ +  +  +  +  :   13218867 :   switch(tree[n].f)
          +  +  +  -  +  
          +  +  +  -  +  
                      - ]
    1944                 :            :   {
    1945                 :            :   case Fseq:
    1946                 :      13729 :     compileseq(n, mode, flag);
    1947                 :            :     return;
    1948                 :            :   case Fmatcoeff:
    1949                 :       7944 :     compilematcoeff(n,mode);
    1950 [ +  + ][ +  + ]:       7944 :     if (mode==Ggen && !(flag&FLnocopy))
    1951                 :       1301 :       op_push(OCcopy,0,n);
    1952                 :            :     return;
    1953                 :            :   case Fassign:
    1954                 :      20801 :     x = detag(x);
    1955 [ +  + ][ +  - ]:      20801 :     if (tree[x].f==Fvec && tree[x].x>=0)
    1956                 :        175 :     {
    1957                 :        175 :       GEN vars = listtogen(tree[x].x,Fmatrixelts);
    1958         [ +  + ]:        175 :       long i, l = lg(vars)-1, d = mode==Gvoid? l-1: l;
    1959         [ +  + ]:        175 :       compilenode(y,Ggen,mode==Gvoid?FLnocopy:flag&FLsurvive);
    1960         [ +  + ]:        175 :       if (d) op_push(OCdup, d, x);
    1961         [ +  + ]:        581 :       for(i=1; i<=l; i++)
    1962                 :            :       {
    1963                 :        406 :         long a = detag(vars[i]);
    1964                 :        406 :         entree *ep=getlvalue(a);
    1965                 :        406 :         long vn=getmvar(ep);
    1966                 :        406 :         op_push(OCpushlong,i,a);
    1967                 :        406 :         op_push(OCcompo1,Ggen,a);
    1968         [ +  + ]:        406 :         if (tree[a].f==Fentry)
    1969                 :        399 :           compilestore(vn,ep,n);
    1970                 :            :         else
    1971                 :            :         {
    1972                 :          7 :           compilenewptr(vn,ep,n);
    1973                 :          7 :           compilelvalue(a);
    1974                 :          7 :           op_push(OCstoreptr,0,a);
    1975                 :            :         }
    1976                 :            :       }
    1977         [ +  + ]:        175 :       if (mode!=Gvoid)
    1978                 :         98 :         compilecast(n,Ggen,mode);
    1979                 :            :     }
    1980                 :            :     else
    1981                 :            :     {
    1982                 :      20626 :       entree *ep=getlvalue(x);
    1983                 :      20626 :       long vn=getmvar(ep);
    1984         [ +  + ]:      20626 :       if (tree[x].f!=Fentry)
    1985                 :            :       {
    1986                 :        322 :         compilenewptr(vn,ep,n);
    1987                 :        322 :         compilelvalue(x);
    1988                 :            :       }
    1989         [ +  + ]:      20626 :       compilenode(y,Ggen,mode==Gvoid?FLnocopy:flag&FLsurvive);
    1990         [ +  + ]:      20626 :       if (mode!=Gvoid)
    1991                 :      12903 :         op_push(OCdup,1,n);
    1992         [ +  + ]:      20626 :       if (tree[x].f==Fentry)
    1993                 :      20304 :         compilestore(vn,ep,n);
    1994                 :            :       else
    1995                 :        322 :         op_push(OCstoreptr,0,x);
    1996         [ +  + ]:      20626 :       if (mode!=Gvoid)
    1997                 :      20801 :         compilecast(n,Ggen,mode);
    1998                 :            :     }
    1999                 :            :     return;
    2000                 :            :   case Fconst:
    2001                 :            :     {
    2002                 :    1607292 :       pari_sp ltop=avma;
    2003         [ +  + ]:    1607292 :       if (tree[n].x!=CSTquote)
    2004                 :            :       {
    2005         [ +  - ]:    1605325 :         if (mode==Gvoid) return;
    2006         [ -  + ]:    1605325 :         if (mode==Gvar) compile_varerr(tree[n].str);
    2007                 :            :       }
    2008         [ -  + ]:    1607292 :       if (mode==Gsmall)
    2009                 :          0 :         compile_err("this should be a small integer", tree[n].str);
    2010   [ +  +  +  +  :    1607292 :       switch(tree[n].x)
                      - ]
    2011                 :            :       {
    2012                 :            :       case CSTreal:
    2013                 :       3186 :         op_push(OCpushreal, data_push(strntoGENstr(tree[n].str,tree[n].len)),n);
    2014                 :       3186 :         break;
    2015                 :            :       case CSTint:
    2016                 :     495443 :         op_push(OCpushgen,  data_push(strtoi((char*)tree[n].str)),n);
    2017                 :     495443 :         compilecast(n,Ggen, mode);
    2018                 :     495443 :         break;
    2019                 :            :       case CSTstr:
    2020                 :    1106696 :         op_push(OCpushgen,  data_push(strntoGENexp(tree[n].str,tree[n].len)),n);
    2021                 :    1106696 :         break;
    2022                 :            :       case CSTquote:
    2023                 :            :         { /* skip ' */
    2024                 :       1967 :           entree *ep = fetch_entry_raw(tree[n].str+1,tree[n].len-1);
    2025         [ -  + ]:       1967 :           if (EpSTATIC(ep)) compile_varerr(tree[n].str+1);
    2026                 :       1967 :           op_push(OCpushvar, (long)ep,n);
    2027                 :       1967 :           compilecast(n,Ggen, mode);
    2028                 :       1967 :           break;
    2029                 :            :         }
    2030                 :            :       default:
    2031                 :          0 :         pari_err_BUG("compilenode, unsupported constant");
    2032                 :            :       }
    2033                 :    1607292 :       avma=ltop;
    2034                 :            :       return;
    2035                 :            :     }
    2036                 :            :   case Fsmall:
    2037                 :    4937064 :     compilesmall(n, x, mode);
    2038                 :            :     return;
    2039                 :            :   case Fvec:
    2040                 :    3769469 :     compilevec(n, mode, OCvec);
    2041                 :            :     return;
    2042                 :            :   case Fmat:
    2043                 :       7056 :     compilemat(n, mode);
    2044                 :            :     return;
    2045                 :            :   case Frefarg:
    2046                 :          0 :     compile_err("unexpected character '&':",tree[n].str);
    2047                 :            :     return;
    2048                 :            :   case Fentry:
    2049                 :            :     {
    2050                 :     176139 :       entree *ep=getentry(n);
    2051                 :     176139 :       long vn=getmvar(ep);
    2052         [ +  + ]:     176139 :       if (vn)
    2053                 :            :       {
    2054                 :      76250 :         op_push(OCpushlex,(long)vn,n);
    2055                 :      76250 :         copyifclone(n,mode,flag,FLnocopy|FLnocopylex);
    2056                 :      76250 :         compilecast(n,Ggen,mode);
    2057                 :            :       }
    2058 [ +  + ][ +  + ]:      99889 :       else if (ep->valence==EpVAR || ep->valence==EpNEW)
    2059                 :            :       {
    2060 [ +  + ][ -  + ]:      88223 :         if (DEBUGLEVEL && mode==Gvoid)
    2061                 :          0 :           pari_warn(warner,"statement with no effect: `%s'",ep->name);
    2062                 :      88223 :         op_push(OCpushdyn,(long)ep,n);
    2063                 :      88223 :         copyifclone(n,mode,flag,FLnocopy);
    2064                 :      88223 :         compilecast(n,Ggen,mode);
    2065                 :            :       }
    2066                 :            :       else
    2067                 :     176139 :         closurefunc(ep,n,mode);
    2068                 :            :       return;
    2069                 :            :     }
    2070                 :            :   case Ffunction:
    2071                 :            :     {
    2072                 :    2672470 :       entree *ep=getfunc(n);
    2073 [ +  + ][ +  + ]:    2672470 :       if (EpVALENCE(ep)==EpVAR || EpVALENCE(ep)==EpNEW)
    2074                 :            :       {
    2075         [ -  + ]:      15025 :         if (tree[n].x<OPnboperator) /* should not happen */
    2076                 :          0 :           compile_err("operator unknown",tree[n].str);
    2077                 :      15025 :         compilecall(n,mode,ep);
    2078                 :            :       }
    2079                 :            :       else
    2080                 :    2672470 :         compilefunc(ep,n,mode,flag);
    2081                 :            :       return;
    2082                 :            :     }
    2083                 :            :   case Fcall:
    2084                 :        224 :     compilecall(n,mode,NULL);
    2085                 :            :     return;
    2086                 :            :   case Flambda:
    2087                 :            :     {
    2088                 :       6497 :       pari_sp ltop=avma;
    2089                 :            :       struct codepos pos;
    2090                 :       6497 :       GEN arg=listtogen(x,Flistarg);
    2091                 :       6497 :       long nb, lgarg, nbmvar, dovararg=0, gap;
    2092                 :       6497 :       long strict = GP_DATA->strictargs;
    2093                 :       6497 :       GEN vep = cgetg_copy(arg, &lgarg);
    2094                 :       6497 :       GEN text=cgetg(3,t_VEC);
    2095                 :       6497 :       gel(text,1)=strntoGENstr(tree[x].str,tree[x].len);
    2096                 :       6497 :       gel(text,2)=strntoGENstr(tree[y].str,tree[y].len);
    2097                 :       6497 :       getcodepos(&pos);
    2098                 :       6497 :       dbgstart=tree[x].str+tree[x].len;
    2099                 :       6497 :       gap = tree[y].str-dbgstart;
    2100                 :       6497 :       nbmvar=ctxmvar();
    2101                 :       6497 :       nb = lgarg-1;
    2102         [ +  + ]:       6497 :       if (nb)
    2103                 :            :       {
    2104                 :            :         long i;
    2105         [ +  + ]:       6694 :         for(i=1;i<=nb;i++)
    2106                 :            :         {
    2107                 :       4084 :           long a=arg[i];
    2108 [ +  + ][ +  + ]:       4084 :           if (i==nb && tree[a].f==Fvararg)
    2109                 :            :           {
    2110                 :         21 :             dovararg=1;
    2111                 :         21 :             vep[i]=(long)getvar(tree[a].x);
    2112                 :            :           }
    2113                 :            :           else
    2114         [ +  + ]:       4063 :             vep[i]=(long)getvar(tree[a].f==Fassign?tree[a].x:a);
    2115                 :       4084 :           var_push(NULL,Lmy);
    2116                 :            :         }
    2117                 :       2610 :         checkdups(arg,vep);
    2118                 :       2610 :         op_push(OCgetargs,nb,x);
    2119                 :       2610 :         frame_push(vep);
    2120         [ +  + ]:       6694 :         for (i=1;i<=nb;i++)
    2121                 :            :         {
    2122                 :       4084 :           long a=arg[i];
    2123                 :       4084 :           long y = tree[a].y;
    2124 [ +  + ][ +  - ]:       4084 :           if (tree[a].f==Fassign && (strict || !is_node_zero(y)))
                 [ +  + ]
    2125                 :            :           {
    2126         [ +  + ]:        140 :             if (tree[y].f==Fsmall)
    2127                 :         84 :               compilenode(y, Ggen, 0);
    2128                 :            :             else
    2129                 :            :             {
    2130                 :            :               struct codepos lpos;
    2131                 :         56 :               getcodepos(&lpos);
    2132                 :         56 :               compilenode(y, Ggen, 0);
    2133                 :         56 :               op_push(OCpushgen, data_push(getclosure(&lpos)),a);
    2134                 :            :             }
    2135                 :        140 :             op_push(OCdefaultarg,-nb+i-1,a);
    2136                 :            :           }
    2137                 :       4084 :           localvars[s_lvar.n-nb+i-1].ep=(entree*)vep[i];
    2138                 :            :         }
    2139                 :            :       }
    2140         [ +  + ]:       6497 :       if (strict)
    2141                 :          7 :         op_push(OCcheckuserargs,nb,x);
    2142                 :       6497 :       dbgstart=tree[y].str;
    2143 [ +  - ][ +  - ]:       6497 :       if (y>=0 && tree[y].f!=Fnoarg)
    2144                 :       6497 :         compilenode(y,Ggen,FLsurvive|FLreturn);
    2145                 :            :       else
    2146                 :          0 :         compilecast(n,Gvoid,Ggen);
    2147         [ +  + ]:       6497 :       if (dovararg) nb|=VARARGBITS;
    2148                 :       6497 :       op_push(OCpushgen, data_push(getfunction(&pos,nb,nbmvar,text,gap)),n);
    2149         [ +  + ]:       6497 :       if (nbmvar) op_push(OCsaveframe,!!(flag&FLsurvive),n);
    2150                 :       6497 :       compilecast(n, Gclosure, mode);
    2151                 :       6497 :       avma=ltop;
    2152                 :            :       return;
    2153                 :            :     }
    2154                 :            :   case Ftag:
    2155                 :          0 :     compilenode(x, mode,flag);
    2156                 :            :     return;
    2157                 :            :   case Fnoarg:
    2158                 :        182 :     compilecast(n,Gvoid,mode);
    2159                 :            :     return;
    2160                 :            :   default:
    2161                 :   13218853 :     pari_err_BUG("compilenode");
    2162                 :            :   }
    2163                 :            : }
    2164                 :            : 
    2165                 :            : GEN
    2166                 :     133206 : gp_closure(long n)
    2167                 :            : {
    2168                 :            :   struct codepos pos;
    2169                 :     133206 :   getcodepos(&pos);
    2170                 :     133206 :   dbgstart=tree[n].str;
    2171                 :     133206 :   compilenode(n,Ggen,FLsurvive|FLreturn);
    2172                 :     133199 :   return getfunction(&pos,0,0,strntoGENstr(tree[n].str,tree[n].len),0);
    2173                 :            : }
    2174                 :            : 
    2175                 :            : GEN
    2176                 :         49 : closure_deriv(GEN G)
    2177                 :            : {
    2178                 :         49 :   pari_sp ltop=avma;
    2179                 :            :   long i;
    2180                 :            :   struct codepos pos;
    2181                 :            :   const char *code;
    2182                 :            :   GEN text;
    2183                 :         49 :   long arity=closure_arity(G);
    2184 [ +  - ][ -  + ]:         49 :   if (arity==0 || closure_is_variadic(G))
    2185                 :          0 :     pari_err_TYPE("derivfun",G);
    2186         [ +  - ]:         49 :   if (typ(gel(G,6))==t_STR)
    2187                 :            :   {
    2188                 :         49 :     code = GSTR(gel(G,6));
    2189                 :         49 :     text = cgetg(1+nchar2nlong(2+strlen(code)),t_STR);
    2190                 :         49 :     sprintf(GSTR(text),"%s'",code);
    2191                 :            :   }
    2192                 :            :   else
    2193                 :            :   {
    2194                 :          0 :     code = GSTR(GENtoGENstr(G));
    2195                 :          0 :     text = cgetg(1+nchar2nlong(4+strlen(code)),t_STR);
    2196                 :          0 :     sprintf(GSTR(text),"(%s)'",code);
    2197                 :            :   }
    2198                 :         49 :   getcodepos(&pos);
    2199                 :         49 :   dbgstart=code;
    2200                 :         49 :   op_push_loc(OCgetargs, arity,code);
    2201                 :         49 :   op_push_loc(OCpushgen,data_push(G),code);
    2202                 :         49 :   op_push_loc(OCvec,arity+1,code);
    2203         [ +  + ]:         98 :   for (i=1;i<=arity;i++)
    2204                 :            :   {
    2205                 :         49 :     op_push_loc(OCpushlex,i-arity-1,code);
    2206                 :         49 :     op_push_loc(OCstackgen,i,code);
    2207                 :            :   }
    2208                 :         49 :   op_push_loc(OCpop,1,code);
    2209                 :         49 :   op_push_loc(OCprecreal,0,code);
    2210                 :         49 :   op_push_loc(OCcallgen,(long)is_entry("_derivfun"),code);
    2211                 :         49 :   return gerepilecopy(ltop, getfunction(&pos,arity,0,text,0));
    2212                 :            : }
    2213                 :            : 
    2214                 :            : static long
    2215                 :    3840802 : vec_optimize(GEN arg)
    2216                 :            : {
    2217                 :    3840802 :   long fl = COsafelex|COsafedyn;
    2218                 :            :   long i;
    2219         [ +  + ]:   15722172 :   for (i=1; i<lg(arg); i++)
    2220                 :            :   {
    2221                 :   11881377 :     optimizenode(arg[i]);
    2222                 :   11881370 :     fl &= tree[arg[i]].flags;
    2223                 :            :   }
    2224                 :    3840795 :   return fl;
    2225                 :            : }
    2226                 :            : 
    2227                 :            : static void
    2228                 :    3771807 : optimizevec(long n)
    2229                 :            : {
    2230                 :    3771807 :   pari_sp ltop=avma;
    2231                 :    3771807 :   long x = tree[n].x;
    2232                 :    3771807 :   GEN  arg = listtogen(x, Fmatrixelts);
    2233                 :    3771807 :   tree[n].flags = vec_optimize(arg);
    2234                 :    3771807 :   avma = ltop;
    2235                 :    3771807 : }
    2236                 :            : 
    2237                 :            : static void
    2238                 :       7056 : optimizemat(long n)
    2239                 :            : {
    2240                 :       7056 :   pari_sp ltop = avma;
    2241                 :       7056 :   long x = tree[n].x;
    2242                 :            :   long i;
    2243                 :       7056 :   GEN line = listtogen(x,Fmatrixlines);
    2244                 :       7056 :   long fl = COsafelex|COsafedyn;
    2245         [ +  + ]:      37324 :   for(i=1;i<lg(line);i++)
    2246                 :            :   {
    2247                 :      30268 :     GEN col=listtogen(line[i],Fmatrixelts);
    2248                 :      30268 :     fl &= vec_optimize(col);
    2249                 :            :   }
    2250                 :       7056 :   avma=ltop; tree[n].flags=fl;
    2251                 :       7056 : }
    2252                 :            : 
    2253                 :            : static void
    2254                 :       8420 : optimizematcoeff(long n)
    2255                 :            : {
    2256                 :       8420 :   long x=tree[n].x;
    2257                 :       8420 :   long y=tree[n].y;
    2258                 :       8420 :   long yx=tree[y].x;
    2259                 :       8420 :   long yy=tree[y].y;
    2260                 :            :   long fl;
    2261                 :       8420 :   optimizenode(x);
    2262                 :       8420 :   optimizenode(yx);
    2263                 :       8420 :   fl=tree[x].flags&tree[yx].flags;
    2264         [ +  + ]:       8420 :   if (yy>=0)
    2265                 :            :   {
    2266                 :        616 :     optimizenode(yy);
    2267                 :        616 :     fl&=tree[yy].flags;
    2268                 :            :   }
    2269                 :       8420 :   tree[n].flags=fl;
    2270                 :       8420 : }
    2271                 :            : 
    2272                 :            : 
    2273                 :            : static void
    2274                 :    2659048 : optimizefunc(entree *ep, long n)
    2275                 :            : {
    2276                 :    2659048 :   pari_sp av=avma;
    2277                 :            :   long j;
    2278                 :    2659048 :   long x=tree[n].x;
    2279                 :    2659048 :   long y=tree[n].y;
    2280                 :            :   Gtype t;
    2281                 :            :   PPproto mod;
    2282                 :    2659048 :   long fl=COsafelex|COsafedyn;
    2283                 :    2659048 :   const char *p=ep->code;
    2284                 :            :   char c;
    2285                 :    2659048 :   GEN arg = listtogen(y,Flistarg);
    2286                 :    2659048 :   long nb=lg(arg)-1, ret_flag;
    2287         [ +  + ]:    2659048 :   if (!p)
    2288                 :       1428 :     fl=0;
    2289                 :            :   else
    2290                 :    2657620 :     (void) get_ret_type(&p, 2, &t, &ret_flag);
    2291 [ +  + ][ +  + ]:    5311348 :   if (p && *p)
    2292                 :            :   {
    2293                 :    2652307 :     j=1;
    2294         [ +  + ]:    5921907 :     while((mod=parseproto(&p,&c,tree[n].str))!=PPend)
    2295                 :            :     {
    2296 [ +  + ][ +  + ]:    3269607 :       if (j<=nb && tree[arg[j]].f!=Fnoarg
    2297 [ +  + ][ +  + ]:    3120937 :           && (mod==PPdefault || mod==PPdefaultmulti))
    2298                 :      59395 :         mod=PPstd;
    2299   [ +  +  +  +  :    3269607 :       switch(mod)
                      - ]
    2300                 :            :       {
    2301                 :            :       case PPstd:
    2302         [ +  + ]:    3107357 :         if (j>nb) compile_err("too few arguments", tree[n].str+tree[n].len-1);
    2303 [ +  + ][ -  + ]:    3107350 :         if (tree[arg[j]].f==Fnoarg && c!='I' && c!='E')
                 [ #  # ]
    2304                 :          0 :           compile_err("missing mandatory argument", tree[arg[j]].str);
    2305   [ +  +  +  +  :    3107350 :         switch(c)
             +  +  +  - ]
    2306                 :            :         {
    2307                 :            :         case 'G':
    2308                 :            :         case 'n':
    2309                 :            :         case 'M':
    2310                 :            :         case 'L':
    2311                 :            :         case 'U':
    2312                 :            :         case 'P':
    2313                 :    3037300 :           optimizenode(arg[j]);
    2314                 :    3037300 :           fl&=tree[arg[j++]].flags;
    2315                 :    3037300 :           break;
    2316                 :            :         case 'I':
    2317                 :            :         case 'E':
    2318                 :            :         case 'J':
    2319                 :      34626 :           optimizenode(arg[j]);
    2320                 :      34626 :           fl&=tree[arg[j]].flags;
    2321                 :      34626 :           tree[arg[j++]].flags=COsafelex|COsafedyn;
    2322                 :      34626 :           break;
    2323                 :            :         case '&': case '*':
    2324                 :            :           {
    2325                 :        936 :             long a=arg[j];
    2326         [ +  + ]:        936 :             if (c=='&')
    2327                 :            :             {
    2328         [ -  + ]:        560 :               if (tree[a].f!=Frefarg)
    2329                 :          0 :                 compile_err("expected character: '&'", tree[a].str);
    2330                 :        560 :               a=tree[a].x;
    2331                 :            :             }
    2332                 :        936 :             optimizenode(a);
    2333                 :        936 :             tree[arg[j++]].flags=COsafelex|COsafedyn;
    2334                 :        936 :             fl=0;
    2335                 :        936 :             break;
    2336                 :            :           }
    2337                 :            :         case 'W':
    2338                 :        133 :           optimizenode(arg[j++]);
    2339                 :        133 :           fl=0;
    2340                 :        133 :           break;
    2341                 :            :         case 'V':
    2342                 :            :         case 'r':
    2343                 :      13548 :           tree[arg[j++]].flags=COsafelex|COsafedyn;
    2344                 :      13548 :           break;
    2345                 :            :         case '=':
    2346                 :            :           {
    2347                 :      16626 :             long a=arg[j++], y=tree[a].y;
    2348         [ -  + ]:      16626 :             if (tree[a].f!=Fassign)
    2349                 :          0 :               compile_err("expected character: '=' instead of",
    2350                 :          0 :                   tree[a].str+tree[a].len);
    2351                 :      16626 :             optimizenode(y);
    2352                 :      16626 :             fl&=tree[y].flags;
    2353                 :            :           }
    2354                 :      16626 :           break;
    2355                 :            :         case 's':
    2356                 :       4181 :           fl &= vec_optimize(cattovec(arg[j++], OPcat));
    2357                 :       4181 :           break;
    2358                 :            :         default:
    2359                 :          0 :           pari_err(e_MISC,"Unknown prototype code `%c' for `%.*s'",c,
    2360                 :          0 :               tree[x].len, tree[x].str);
    2361                 :            :         }
    2362                 :    3107350 :         break;
    2363                 :            :       case PPauto:
    2364                 :      76428 :         break;
    2365                 :            :       case PPdefault:
    2366                 :            :       case PPdefaultmulti:
    2367         [ +  + ]:      77623 :         if (j<=nb) optimizenode(arg[j++]);
    2368                 :      77623 :         break;
    2369                 :            :       case PPstar:
    2370      [ -  +  - ]:       8199 :         switch(c)
    2371                 :            :         {
    2372                 :            :         case 'E':
    2373                 :            :           {
    2374                 :          0 :             long n=nb+1-j;
    2375                 :            :             long k;
    2376         [ #  # ]:          0 :             for(k=1;k<=n;k++)
    2377                 :            :             {
    2378                 :          0 :               optimizenode(arg[j+k-1]);
    2379                 :          0 :               fl &= tree[arg[j+k-1]].flags;
    2380                 :            :             }
    2381                 :          0 :             j=nb+1;
    2382                 :          0 :             break;
    2383                 :            :           }
    2384                 :            :         case 's':
    2385                 :            :           {
    2386                 :       8199 :             long n=nb+1-j;
    2387                 :            :             long k;
    2388         [ +  + ]:      20748 :             for(k=1;k<=n;k++)
    2389                 :      12549 :               fl &= vec_optimize(cattovec(arg[j+k-1],OPcat));
    2390                 :       8199 :             j=nb+1;
    2391                 :       8199 :             break;
    2392                 :            :           }
    2393                 :            :         default:
    2394                 :          0 :           pari_err(e_MISC,"Unknown prototype code `%c*' for `%.*s'",c,
    2395                 :          0 :               tree[x].len, tree[x].str);
    2396                 :            :         }
    2397                 :       8199 :         break;
    2398                 :            :       default:
    2399                 :          0 :         pari_err_BUG("optimizefun [unknown PPproto]");
    2400                 :            :       }
    2401                 :            :     }
    2402                 :            :   }
    2403                 :       6741 :   else (void)vec_optimize(arg);
    2404                 :    2659041 :   avma=av; tree[n].flags=fl;
    2405                 :    2659041 : }
    2406                 :            : 
    2407                 :            : static void
    2408                 :      15256 : optimizecall(long n)
    2409                 :            : {
    2410                 :      15256 :   pari_sp av=avma;
    2411                 :      15256 :   long x=tree[n].x;
    2412                 :      15256 :   long y=tree[n].y;
    2413                 :      15256 :   GEN arg=listtogen(y,Flistarg);
    2414                 :      15256 :   optimizenode(x);
    2415                 :      15256 :   tree[n].flags = COsafelex&tree[x].flags&vec_optimize(arg);
    2416                 :      15249 :   avma=av;
    2417                 :      15249 : }
    2418                 :            : 
    2419                 :            : static void
    2420                 :      13722 : optimizeseq(long n)
    2421                 :            : {
    2422                 :      13722 :   pari_sp av = avma;
    2423                 :      13722 :   GEN L = listtogen(n, Fseq);
    2424                 :      13722 :   long i, l = lg(L)-1, flags=-1L;
    2425         [ +  + ]:      52313 :   for(i = 1; i <= l; i++)
    2426                 :            :   {
    2427                 :      38591 :     optimizenode(L[i]);
    2428                 :      38591 :     flags &= tree[L[i]].flags;
    2429                 :            :   }
    2430                 :      13722 :   avma = av;
    2431                 :      13722 :   tree[n].flags = flags;
    2432                 :      13722 : }
    2433                 :            : 
    2434                 :            : void
    2435                 :   15246368 : optimizenode(long n)
    2436                 :            : {
    2437                 :            :   long x,y;
    2438                 :            : #ifdef STACK_CHECK
    2439 [ +  - ][ -  + ]:   15246368 :   if (PARI_stack_limit && (void*) &x <= PARI_stack_limit)
    2440                 :          0 :     pari_err(e_MISC, "expression nested too deeply");
    2441                 :            : #endif
    2442         [ -  + ]:   15246368 :   if (n<0)
    2443                 :          0 :     pari_err_BUG("optimizenode");
    2444                 :   15246368 :   x=tree[n].x;
    2445                 :   15246368 :   y=tree[n].y;
    2446                 :            : 
    2447   [ +  +  +  +  :   15246368 :   switch(tree[n].f)
          +  +  +  +  -  
             +  +  +  -  
                      - ]
    2448                 :            :   {
    2449                 :            :   case Fseq:
    2450                 :      13722 :     optimizeseq(n);
    2451                 :            :     return;
    2452                 :            :   case Frange:
    2453                 :       9036 :     optimizenode(x);
    2454                 :       9036 :     optimizenode(y);
    2455                 :       9036 :     tree[n].flags=tree[x].flags&tree[y].flags;
    2456                 :       9036 :     break;
    2457                 :            :   case Fmatcoeff:
    2458                 :       8420 :     optimizematcoeff(n);
    2459                 :       8420 :     break;
    2460                 :            :   case Fassign:
    2461                 :      22561 :     optimizenode(x);
    2462                 :      22561 :     optimizenode(y);
    2463                 :      22561 :     tree[n].flags=0;
    2464                 :      22561 :     break;
    2465                 :            :   case Fnoarg:
    2466                 :            :   case Fsmall:
    2467                 :            :   case Fconst:
    2468                 :            :   case Fentry:
    2469                 :    8732965 :     tree[n].flags=COsafelex|COsafedyn;
    2470                 :            :     return;
    2471                 :            :   case Fvec:
    2472                 :    3771807 :     optimizevec(n);
    2473                 :            :     return;
    2474                 :            :   case Fmat:
    2475                 :       7056 :     optimizemat(n);
    2476                 :            :     return;
    2477                 :            :   case Frefarg:
    2478                 :          7 :     compile_err("unexpected character '&'",tree[n].str);
    2479                 :            :     return;
    2480                 :            :   case Fvararg:
    2481                 :          0 :     compile_err("unexpected characters '..'",tree[n].str);
    2482                 :            :     return;
    2483                 :            :   case Ffunction:
    2484                 :            :     {
    2485                 :    2674080 :       entree *ep=getfunc(n);
    2486 [ +  + ][ +  + ]:    2674080 :       if (EpVALENCE(ep)==EpVAR || EpVALENCE(ep)==EpNEW)
    2487                 :      15032 :         optimizecall(n);
    2488                 :            :       else
    2489                 :    2674073 :         optimizefunc(ep,n);
    2490                 :            :       return;
    2491                 :            :     }
    2492                 :            :   case Fcall:
    2493                 :        224 :     optimizecall(n);
    2494                 :            :     return;
    2495                 :            :   case Flambda:
    2496                 :       6490 :     optimizenode(y);
    2497                 :       6490 :     tree[n].flags=COsafelex|COsafedyn;
    2498                 :            :     return;
    2499                 :            :   case Ftag:
    2500                 :          0 :     optimizenode(x);
    2501                 :          0 :     tree[n].flags=tree[x].flags;
    2502                 :            :     return;
    2503                 :            :   default:
    2504                 :   15246347 :     pari_err_BUG("optimizenode");
    2505                 :            :   }
    2506                 :            : }

Generated by: LCOV version 1.9