Patrick
/
Nife_v0
1
0
Fork 0
Code Issues 0 Pull Requests 0 Releases 0 Wiki Activity
Nife version Beta
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
6 Commits
1 Branch
631 KiB
 
 
 
 
Tree: 883b36abe8
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '883b36abe8'
${ noResults }
Nife_v0/src/stackN.c

2068 lines
44 KiB
Raw Blame History 

  1. /* Copyright (C) 2011-2014  Patrick H. E. Foubet - S.E.R.I.A.N.E.

  2. 

  3. This program is free software: you can redistribute it and/or modify

  4. it under the terms of the GNU General Public License as published by

  5. the Free Software Foundation, either version 3 of the License, or any

  6. later version.

  7. 

  8. This program is distributed in the hope that it will be useful,

  9. but WITHOUT ANY WARRANTY; without even the implied warranty of

  10. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  11. GNU General Public License for more details.

  12. 

  13. You should have received a copy of the GNU General Public License

  14. along with this program.  If not, see <http://www.gnu.org/licenses/>

  15. *******************************************************************/

  16. /* stackN.c */

  17. #include "conf.h"

  18. 

  19. #include <stdio.h>

  20. #include <stdlib.h>

  21. #include <string.h>

  22. #include <strings.h>

  23. #include <sys/types.h>

  24. #include <math.h>

  25. 

  26. #include "nife.h"

  27. #include "mth.h"

  28. #include "err.h"

  29. #include "lib.h"

  30. #include "stackN.h"

  31. #include "stackL.h"

  32. #include "stackF.h"

  33. #include "stackV.h"

  34. #include "debug.h"

  35. #include "net.h"

  36. #include "scs.h"

  37. 

  38. #define _VERIF_STACK_ if (StackN == VIDE) { messErr(2); return; }

  39. 

  40. 

  41. void IF_vars(void)

  42. {

  43. char * L;

  44.     printf("DEBUG : ");

  45.     if (Debug) printf("ON"); else printf("OFF");

  46.     printf("\nDefault type=");

  47.     if (DOUBLE) printf("REAL"); else printf("INTEGER");

  48.     printf("\nPRINT MODE : ");

  49.     switch(MODEPR) {

  50.        case 1 :

  51.          printf("HEX");

  52.          break;

  53.        case 2 :

  54.          printf("OCT");

  55.          break;

  56.        case 3 :

  57.          printf("BIN");

  58.          break;

  59.        default :

  60.          printf("DEC");

  61.          break;

  62.     }

  63.     printf("\nDefault echo=");

  64.     if (ECHOOFF) printf("OFF"); else printf("ON");

  65.     printf("\nNetServer : \"%s\"",NetServer);

  66.     printf("\nSCS Key   : 0x%lx",(long)getScs());

  67.     printf("\nNetKey    : 0x%lx",(long)NetKey);

  68.     printf("\nVARS : ");

  69.     switch(VARS) {

  70.        case 1 :

  71.          printf("DOWN");

  72.          break;

  73.        case 2 :

  74.          printf("UP");

  75.          break;

  76.        default :

  77.          printf("OFF");

  78.          break;

  79.     }

  80.     printf("\nVariable Function : ");

  81.     if ((L=libByAddr(FCT_INST)) != NULL) printf("%s (std lib)",L);

  82.     else {

  83.       if ((L=fctByAddr(FCT_INST)) != NULL) printf("%s (user function)",L);

  84.         else {

  85.           if ((L=varByAddr(FCT_INST)) != NULL) printf("%s (variable)",L);

  86.           else printf("none");

  87.         }

  88.     }

  89.     printf("\nNBTAB=%d\nNBLIG=%d\n",NBTAB,NBLIG);

  90. }

  91. 

  92. void IF_REAL(void) { _MODIF_DOUBLE_(1); }

  93. void IF_INTEGER(void) { _MODIF_DOUBLE_(0); }

  94. 

  95. void IF_DEC(void) { _MODIF_MODEPR_(0); }

  96. void IF_HEX(void) { _MODIF_MODEPR_(1); }

  97. void IF_OCT(void) { _MODIF_MODEPR_(2); }

  98. void IF_BIN(void) { _MODIF_MODEPR_(3); }

  99. 

  100. void IF_ECHOFF(void) { _MODIF_ECHOOFF_(1); }

  101. void IF_ECHOON(void) { _MODIF_ECHOOFF_(0); }

  102. 

  103. /* IMPORTANT **************************

  104.    la taille t est codee sur 30 bits + a droite

  105.    B31 = 1 si Var

  106.    B32 = 1 si REAL 

  107. **********************/

  108. #define MSK_T    (uint32_t)(0x3FFFFFFF)

  109. #define MSK_V    (uint32_t)(0x40000000)

  110. #define MSK_R    (uint32_t)(0x80000000)

  111. 

  112. struct Num {

  113.     uint32_t t; /* taille : cf precisions ci-dessus */

  114.     uint32_t key; /* net key */

  115.     void *n;

  116.     union {

  117.       long long l;

  118.       double d;

  119.     };

  120. };

  121. 

  122. int lAdrNum(void)

  123. {

  124. struct Num N;

  125.    return((char*)&(N.l) - (char*)&(N.n));

  126. }

  127. 

  128. void putLong(long long l)

  129. {

  130. void * M;

  131. struct Num * N;

  132.     if ((M = malloc(sizeof(struct Num))) == NULL) stopErr("putLong","malloc");

  133.     N = (struct Num*)M;

  134.     N->t = 1;

  135.     N->n = StackN;

  136.     N->l = l;

  137.     _MODIF_STACKN_(M);

  138. }

  139. 

  140. void putDouble(double d)

  141. {

  142. void * M;

  143. struct Num * N;

  144.     if ((M = malloc(sizeof(struct Num))) == NULL) stopErr("putDouble","malloc");

  145.     N = (struct Num*)M;

  146.     N->t = 1 | MSK_R;

  147.     N->n = StackN;

  148.     N->d = d;

  149.     _MODIF_STACKN_(M);

  150. }

  151. 

  152. int putVal(char *V)

  153. {

  154. void * M;

  155. char * R;

  156. struct Num * N;

  157. long long l;

  158. double d;

  159. #ifdef DEBUG

  160.     printf("putVal (%s) \n",V);

  161. #endif

  162.     l = strtoll(V,&R,0);

  163.     if (strlen(R)==0) {

  164.        if ((M = malloc(sizeof(struct Num))) == NULL) stopErr("putVal","malloc");

  165.        N = (struct Num*)M;

  166.        N->t = 1;

  167.        N->n = StackN;

  168.        N->l = l;

  169.        if (fctEnCours) makeFct(T_NUM,M);

  170.        else _MODIF_STACKN_(M);

  171.        return 1;

  172.     } else {

  173.        d = strtod(V,&R);

  174.        if (strlen(R)==0) {

  175.          if ((M=malloc(sizeof(struct Num))) == NULL) stopErr("putVal","malloc");

  176.          N = (struct Num*)M;

  177.          N->t = 1 | MSK_R;

  178.          N->n = StackN;

  179.          N->d = d;

  180.          if (fctEnCours) makeFct(T_NUM,M);

  181.          else _MODIF_STACKN_(M);

  182.          return 1;

  183.        }

  184.     }

  185.     return 0;

  186. }

  187. 

  188. static int isScalar(void)

  189. {

  190. struct Num *Elt;

  191. int t;

  192.    if(StackN == VIDE) return 0;

  193.    Elt = (struct Num *)StackN;

  194.    if ((t = Elt->t&MSK_T) == 1) return 1;

  195.    return 0;

  196. }

  197. 

  198. static int dropElt(void)

  199. {

  200. struct Num *Elt;

  201.    if(StackN == VIDE) return 0;

  202.    Elt = (struct Num *)StackN;

  203.    _MODIF_STACKN_(Elt->n);

  204.    if (!(Elt->t&MSK_V)) free((void*)Elt);

  205.    return 1;

  206. }

  207. 

  208. void IF_drop(void)

  209. {

  210.    _VERIF_STACK_

  211.    dropElt();

  212. }

  213. 

  214. 

  215. static long long getVal(void)

  216. {

  217. struct Num *Elt;

  218.    Elt = (struct Num *)StackN;

  219.    if (Elt->t & MSK_R) return((long long)Elt->d);

  220.    else  return(Elt->l);

  221. }

  222. 

  223. void IF_vers(void)

  224. {

  225.     putDouble(atof(VERSION));

  226. }

  227. 

  228. /* fonction pour les autres */

  229. int getParLong(long *V)

  230. {

  231.    if (StackN == VIDE) { 

  232.         messErr(2); return 0 ;

  233.    }

  234.    if (!isScalar()) {

  235.         messErr(36); return 0 ;

  236.    }

  237.    *V = (long)getVal();

  238.    dropElt();

  239.    return 1;

  240. }

  241. 

  242. 

  243. void putVar(void * V)

  244. {

  245. struct Num *Elt;

  246.    if (V==VIDE) return;

  247.    Elt = (struct Num *)V;

  248.    Elt->n = StackN;

  249.    _MODIF_STACKN_(V);

  250. }

  251. 

  252. void * getVar(void)

  253. {

  254. void * N;

  255. struct Num *Elt;

  256.    N = StackN;

  257.    if (N != VIDE) {

  258.       Elt = (struct Num *)N;

  259.       _MODIF_STACKN_(Elt->n); /* drop no free !! */

  260.       Elt->n = VIDE;

  261.       Elt->t = Elt->t|MSK_V; /* VARIABLE ! */

  262.    }

  263.    return N;

  264. }

  265. 

  266. void IF_NBTAB(void)

  267. {

  268. long V;

  269.    if (getParLong(&V)) _MODIF_NBTAB_(V);

  270. }

  271. 

  272. void IF_NBLIG(void)

  273. {

  274. long V;

  275.    if (getParLong(&V)) _MODIF_NBLIG_(V);

  276. }

  277. 

  278. void IF_VAROFF(void) { _MODIF_VARS_(0); }

  279. void IF_VARDOWN(void) { _MODIF_VARS_(1); }

  280. void IF_VARUP(void) { _MODIF_VARS_(2); }

  281. 

  282. void insertVal(void*A)

  283. {

  284. void * M;

  285. struct Num *Elt;

  286.     if ((M = malloc(sizeof(struct Num))) == NULL) stopErr("insertVal","malloc");

  287.     bcopy(A,M,sizeof(struct Num));

  288.     Elt=(struct Num*)M;

  289.     Elt->n = StackN;

  290.     _MODIF_STACKN_(M);

  291. }

  292. 

  293. static void Ramp(int D)

  294. {

  295. long n, i, dep=1;

  296. void * M;

  297. struct Num * N;

  298. long long *T;

  299.    _VERIF_STACK_

  300.    if (!isScalar()) {

  301.        messErr(36); return;

  302.    }

  303.    n = (long)getVal();

  304.    dropElt();

  305.    if (n > 1) {

  306.     if (D) { /* double ramp */

  307.         dep = -n;

  308.         n = (2*n) +1;

  309.     }

  310.     if ((M = malloc(sizeof(struct Num)+((n-1)*(sizeof(double))))) == NULL)

  311.              stopErr("Ramp","malloc");

  312.     N = (struct Num*)M;

  313.     N->t = n;

  314.     N->n = StackN;

  315.     _MODIF_STACKN_(M);

  316.     T = &(N->l);

  317.     for(i=0;i<n;i++) T[i]=i+dep;

  318.    } else messErr(30);

  319. }

  320. 

  321. void IF_ramp(void)

  322. {

  323.     Ramp(0);

  324. }

  325. 

  326. void IF_dramp(void)

  327. {

  328.     Ramp(1);

  329. }

  330. 

  331. void IF_stack_clear(void)

  332. { 

  333.     while (StackN != VIDE) dropElt();

  334. }

  335. 

  336. static printLL(char * F, long long l)

  337. {

  338. char c, buf[68];

  339. unsigned long long v;

  340. int i;

  341.    switch(MODEPR) {

  342.    case 1 :

  343.       c='x';

  344.       printf("0x");

  345.       break;

  346.    case 2 :

  347.       c='o';

  348.       printf("0");

  349.       break;

  350.    case 3 :

  351.       c='b';

  352.       break;

  353.    default :

  354.       c='d';

  355.    }

  356.    if (c =='b') {

  357.      if (l) {

  358.       v = (unsigned long long)l;

  359.       buf[67]='\0';

  360.       i = 67;

  361.       while (v) {

  362.         i--;

  363.         if (v & 1) buf[i]='1';

  364.         else buf[i]='0';

  365.         v >>= 1;

  366.       }

  367.       printf("%s ",buf+i);

  368.      } else printf("0 ");

  369.    } else {

  370.       strcpy(buf,F);

  371.       buf[3]=c;

  372.       printf(buf,l);

  373.    }

  374. }

  375. 

  376. #define ELT_POINT -9

  377. static void printElt(struct Num * N, long I)

  378. {

  379. long n, i, m, nt, IB;

  380. long long *l;

  381. double *d;

  382.    IB = I;

  383.    n = N->t&MSK_T;

  384.    if (IB < 0) nt = 3;

  385.    else nt = NBTAB;

  386.    if (n > nt) m=nt-1;

  387.    else m=n-1;

  388.    if (I==ELT_POINT) {

  389.       IB=0;

  390.       n=2;

  391.       m=1;

  392.    }

  393.    if (IB) printf(" ");

  394.    if(N->t & MSK_R) {

  395.          if (n==1) printf("%g (REAL)",N->d);

  396.          else  {

  397.             d = &N->d;

  398.             for(i=0;i<m;i++) printf("%g ",*d++);

  399.             if (I==ELT_POINT) return;

  400.             if (n > nt) printf("... ");

  401.             printf("%g (REAL)[%ld]",*(&N->d+(n-1)),n);

  402.          }

  403.    } else {

  404.          if (n==1) {

  405.                printLL("%lld ",N->l);

  406.                printf("(INTEGER)");

  407.          } else  {

  408.             l = &N->l;

  409.             for(i=0;i<m;i++) printLL("%lld ",*l++);

  410.             if (I==ELT_POINT) return;

  411.             if (n > nt) printf("... ");

  412.             printLL("%lld ",*(&N->l+(n-1)));

  413.             printf("(INTEGER)[%ld]",n);

  414.          }

  415.    }

  416.    if ((IB>0) && (N->t&MSK_V)) printf(" Var. %s",varByAddrA((void*)N));

  417.    if (IB==1) printf(" <- top");

  418.    if (IB) printf("\n");

  419. }

  420. 

  421. void printNumber(void * E)

  422. {

  423.    printElt((struct Num*)E, 0);

  424. }

  425. 

  426. void numVarOff(void * A)

  427. {

  428. struct Num * N;

  429.    N = (struct Num*) A;

  430.    N->t = N->t & ~MSK_V;

  431. }

  432. 

  433. void IF_show_stack(void)

  434. {

  435. void * Next;

  436. struct Num * N;

  437. long i=0,Nbl;

  438. char s;

  439.     Nbl=NBLIG;

  440.     Next = StackN;

  441.     while (Next != VIDE) {

  442.        N = (struct Num*) Next;

  443.        i++;

  444.        if (i<=Nbl) printElt(N,i);

  445.        Next = N->n;

  446.     }

  447.     if (i<=Nbl) printf("<end of stack>\n");

  448.     else {

  449.        if (i==Nbl+1) s = ' ';

  450.        else s = 's';

  451.        printf(" ... and %ld other%c element%c !\n",i-Nbl,s,s);

  452.     }

  453. }

  454. 

  455. void IF_point(void)

  456. {

  457. struct Num *Elt;

  458.    _VERIF_STACK_

  459.    Elt = (struct Num *)StackN;

  460.    printElt(Elt,ELT_POINT);

  461.    /* printf("\n"); */

  462.    dropElt();

  463. }

  464. 

  465. void * duplicateNum(void * S, int vSoff)

  466. {

  467. struct Num *Elt, *NElt;

  468. void * M;

  469. uint32_t n;

  470. int s;

  471.     Elt = (struct Num*)S;

  472.     n = Elt->t&MSK_T;

  473.     s = sizeof(struct Num)+((n-1)*(sizeof(double)));

  474.     if ((M = malloc(s)) == NULL) stopErr("dupElt","malloc");

  475.     bcopy((void*)Elt,M,s);

  476.     NElt = (struct Num *)M;

  477.     NElt->n = VIDE;

  478.     NElt->t = Elt->t;

  479.     if (vSoff) Elt->t = Elt->t & ~MSK_V; /* Source no more a Var */

  480.     return(M);

  481. }

  482. 

  483. static void dupElt(struct Num * Elt)

  484. {

  485. struct Num *NElt;

  486. void * M;

  487. uint32_t n;

  488. int s;

  489.       n = Elt->t&MSK_T;

  490.       s = sizeof(struct Num)+((n-1)*(sizeof(double)));

  491.       if ((M = malloc(s)) == NULL) stopErr("dupElt","malloc");

  492.       bcopy((void*)Elt,M,s);

  493.       NElt = (struct Num *)M;

  494.       NElt->n = StackN;

  495.       NElt->t = Elt->t & ~MSK_V; /* au cas ou Var */

  496.       _MODIF_STACKN_(M);

  497. }

  498. 

  499. void IF_dup(void)

  500. {

  501.    _VERIF_STACK_

  502.    dupElt((struct Num *)StackN);

  503. }

  504. 

  505. void IF_swap(void)

  506. {

  507. struct Num *Elt, *Elt2;

  508.    _VERIF_STACK_

  509.    Elt = (struct Num *)StackN;

  510.    if (Elt->n != VIDE) {

  511.       _MODIF_STACKN_(Elt->n);

  512.       Elt2 = (struct Num *)StackN;

  513.       Elt->n = Elt2->n;

  514.       Elt2->n = (void*)Elt;

  515.    }

  516.    else messErr(4);

  517. }

  518. 

  519. void IF_over (void)

  520. {

  521. struct Num *Elt;

  522.    _VERIF_STACK_

  523.    Elt = (struct Num *)StackN;

  524.    if (Elt->n != VIDE)

  525.          dupElt((struct Num *)Elt->n);

  526.    else messErr(4);

  527. }

  528. 

  529. void IF_pick(void)

  530. {

  531. void * Next;

  532. struct Num * N;

  533. long n, i;

  534.   _VERIF_STACK_

  535.   if (!isScalar()) {

  536.        messErr(36); return;

  537.   }

  538.   n = (long)getVal();

  539.   dropElt();

  540.   if (n>0) {

  541.    Next = StackN;

  542.    i=1;

  543.    while (Next != VIDE) {

  544.        if (i==n) break;

  545.        N = (struct Num*) Next;

  546.        Next = N->n;

  547.        i++;

  548.    }

  549.    if (Next != VIDE) dupElt((struct Num *)Next);

  550.    else messErr(4);

  551.   } else messErr(29);

  552. }

  553. 

  554. static int rotateBid(long n, int d) /* d=0 : rot d=1 : unrot */

  555. {

  556. void **ANext;

  557. struct Num * N, *N1;

  558. long i;

  559.    ANext = _ADDR_STACKN_;

  560.    i=1;

  561.    while (*ANext != VIDE) {

  562.       if (i==n) break;

  563.       N = (struct Num*) *ANext;

  564.       ANext = &N->n;

  565.       i++;

  566.    }

  567.    if (*ANext != VIDE) {

  568.       N = (struct Num*) *ANext;

  569.       if (d) { /* unrot */

  570.          N1 = (struct Num*) StackN;

  571.          _MODIF_STACKN_(N1->n);

  572.          N1->n = N->n;

  573.          N->n = (void*)N1;

  574.       } else { /* rot */

  575.          *ANext = N->n;

  576.          N->n = StackN;

  577.          _MODIF_STACKN_((void*)N);

  578.       }

  579.       return 1;

  580.    } else return 0;

  581. }

  582. 

  583. void IF_rot(void)

  584. {

  585.    if (!rotateBid(3L,0)) messErr(4);

  586. }

  587. 

  588. void IF_unrot(void)

  589. {

  590.    if (!rotateBid(3L,1)) messErr(4);

  591. }

  592. 

  593. void IF_roll(void)

  594. {

  595. long n;

  596.   _VERIF_STACK_

  597.   if (!isScalar()) {

  598.        messErr(36); return;

  599.   }

  600.   n = (long)getVal();

  601.   dropElt();

  602.   if (n>1) {

  603.    if (!rotateBid(n,0)) messErr(4);

  604.   } else messErr(30);

  605. }

  606. 

  607. void IF_unroll(void)

  608. {

  609. long n;

  610.   _VERIF_STACK_

  611.   if (!isScalar()) {

  612.        messErr(36); return;

  613.   }

  614.   n = (long)getVal();

  615.   dropElt();

  616.   if (n>1) {

  617.    if (!rotateBid(n,1)) messErr(4);

  618.   } else messErr(30);

  619. }

  620. 

  621. void IF_depth(void)

  622. {

  623. void * Next;

  624. struct Num * N;

  625. long long i=0;

  626.     Next = StackN;

  627.     while (Next != VIDE) {

  628.        N = (struct Num*) Next;

  629.        i++;

  630.        Next = N->n;

  631.     }

  632.     putLong(i);

  633. }

  634. 

  635. int nbOnStack(void* A)

  636. {

  637. void * Next;

  638. struct Num * N;

  639. int i=0;

  640.     Next = StackN;

  641.     while (Next != VIDE) {

  642.        N = (struct Num*) Next;

  643.        if (Next == A) i++;

  644.        Next = N->n;

  645.     }

  646.     return i;

  647. }

  648. 

  649. static uint32_t nbSizeTypeOnStack(uint32_t n,uint32_t *T)

  650. {

  651. void * Next;

  652. struct Num * N;

  653. uint32_t i=0, D=0, S=0;

  654.     Next = StackN;

  655.     while (Next != VIDE) {

  656.        N = (struct Num*) Next;

  657.        S += N->t&MSK_T;

  658.        if (N->t&MSK_R) D=1;

  659.        Next = N->n;

  660.        i++;

  661.        if (i==n) break;

  662.     }

  663.     if (D) S = S|MSK_R;

  664.     *T = S;

  665.     return i;

  666. }

  667. 

  668. void IF_Ndrop(void)

  669. {

  670. long n, i;

  671.    _VERIF_STACK_

  672.    if (!isScalar()) {

  673.        messErr(36); return;

  674.    }

  675.    n = (long)getVal();

  676.    dropElt();

  677.    for(i=0;i<n;i++) if (!dropElt()) break;

  678.    if (i<n) messErr(4); /* erreur pour la rigueur ! */

  679. }

  680. 

  681. void IF_Ndup(void)

  682. {

  683. void *Next, *M, *NewS, **P;

  684. struct Num * Elt, * NElt;

  685. uint32_t n, i=0, t;

  686. int s;

  687.    _VERIF_STACK_

  688.    if (!isScalar()) {

  689.        messErr(36); return;

  690.    }

  691.    n = (long)getVal();

  692.    dropElt();

  693.    if (n>0) {

  694.     NewS=VIDE;

  695.     P=&NewS;

  696.     Next = StackN;

  697.     while (Next != VIDE) {

  698.        Elt = (struct Num*) Next;

  699.        t = Elt->t&MSK_T;

  700.        s = sizeof(struct Num)+((t-1)*(sizeof(double)));

  701.        if ((M = malloc(s)) == NULL) stopErr("IF_Ndup","malloc");

  702.        bcopy(Next,M,s);

  703.        *P = M;

  704.        NElt = (struct Num *)M;

  705.        NElt->t = NElt->t & ~MSK_V; /* au cas ou Var */

  706.        P=&NElt->n;

  707.        i++;

  708.        if (i==n) break;

  709.        Next = Elt->n;

  710.     }

  711.     NElt->n = StackN;

  712.     _MODIF_STACKN_(NewS);

  713.     if (i<n) messErr(4); /* erreur pour la rigueur ! */

  714.    } else messErr(29);

  715. }

  716. 

  717. static void toDouble(struct Num * N)

  718. {

  719. uint32_t n;

  720. int i;

  721. double *d;

  722. long long  *l;

  723.     if (N->t & MSK_R) return;

  724.     n = N->t&MSK_T;

  725.     d = &N->d;

  726.     l = &N->l;

  727.     for(i=0; i<n; i++) *d++ = (double)*l++;

  728.     N->t = N->t|MSK_R;

  729. }

  730. 

  731. /* NET Functions for STSP */

  732. 

  733. void IF_NetKey (void)

  734. {

  735.   _VERIF_STACK_

  736.   if (!isScalar()) {

  737.        messErr(36); return;

  738.   }

  739.   _MODIF_NetKey_((uint32_t)getVal());

  740.   dropElt();

  741. }

  742. 

  743. void IF_NetErrVal (void)

  744. {

  745.    putLong(-(long long)NetKey);

  746. }

  747. 

  748. void StackToNet(long n)

  749. {

  750. struct Num *Elt;

  751. int i;

  752. uint32_t t, l;

  753.    for (i=0; i<n ; i++) {

  754.       if(StackN == VIDE) break;

  755.       Elt = (struct Num *)StackN;

  756.       t = Elt->t&MSK_T;

  757.       l=(sizeof(struct Num)+((t-1)*(sizeof(double))));

  758.       Elt->key = NetKey;

  759.       sendDataC(StackN, l);

  760.       dropElt();

  761.    }

  762. }

  763. 

  764. int NetDepth(uint32_t k)

  765. {

  766. void * Next;

  767. struct Num * N;

  768. int v=0;

  769.     Next = StackN;

  770.     while (Next != VIDE) {

  771.        N = (struct Num*) Next;

  772.        if (N->key == k) v++;

  773.        Next = N->n;

  774.     }

  775.     return v;

  776. }

  777. 

  778. void NetToStack(int s, uint32_t k)

  779. {

  780. void * Next;

  781. struct Num * N;

  782. uint32_t t, l;

  783.     Next = StackN;

  784.     while (Next != VIDE) {

  785.        N = (struct Num*) Next;

  786.        if (N->key == k) {

  787.           t = N->t&MSK_T;

  788.           l=(sizeof(struct Num)+((t-1)*(sizeof(double))));

  789.           sendData(s, Next, l);

  790.        }

  791.        Next = N->n;

  792.     }

  793. }

  794. 

  795. void IF_show_netStack(uint32_t k)

  796. {

  797. void * Next;

  798. struct Num * N;

  799.     Next = StackN;

  800.     printf("<bottom of net stack>\n");

  801.     while (Next != VIDE) {

  802.        N = (struct Num*) Next;

  803.        if (k == UNI_KEY) {

  804.           printf("<0x%.8lx> ",(long)N->key);

  805.           printElt(N,(long)-1);

  806.        } else {

  807.           if (N->key == k) printElt(N,(long)-1);

  808.        }

  809.        Next = N->n;

  810.     }

  811.     printf("<top of net stack> key=0x%lx\n",(long)k);

  812. }

  813. 

  814. void IF_netDrop(uint32_t k)

  815. {

  816. void * Next, **ANext;

  817. struct Num * N;

  818.     Next = StackN;

  819.     ANext = _ADDR_STACKN_;

  820.     while (Next != VIDE) {

  821.        N = (struct Num*) Next;

  822.        if (k == N->key) {

  823.            *ANext = N->n;

  824.            free(Next);

  825.            Next = *ANext;

  826.            continue;

  827.        }

  828.        Next = N->n;

  829.        ANext = &(N->n);

  830.     }

  831. }

  832. 

  833. /* end of Net functions */

  834. 

  835. static void IF_fct_2(char O)

  836. {

  837. struct Num *Elt, *Elt2;

  838. long long ConstL, *l1, *l2;

  839. double ConstD, *d1, *d2;

  840. int D1=0, D2=0, T1, T2, i;

  841. int M_C, M_D, M_S; /* Mode Const : 1 ou 0 | Double : 1 ou 0 | Swap : 1 ou 0 */

  842. bool B=TRUE;

  843. 

  844.     _VERIF_STACK_

  845.     Elt = (struct Num *)StackN;

  846.     T1 = Elt->t&MSK_T;

  847.     D1 = Elt->t&MSK_R;

  848.     if (Elt->n == VIDE) {

  849.        messErr(4);

  850.        return;

  851.     }

  852.     Elt2 = (struct Num *)Elt->n;

  853.     T2 = Elt2->t&MSK_T;

  854.     D2 = Elt2->t&MSK_R;

  855.     /* si 2 tab de dim diff pas possible !! */

  856.     if ((T1>1) && (T2>1) && (T1!=T2)) {

  857.        messErr(3);

  858.        return;

  859.     }

  860.     M_S = M_C = M_D = 0;

  861.     if ((T1>1) && (T2==1)) {  /* on swap */

  862.        IF_swap();

  863.        D1=D2=0;

  864.        Elt = (struct Num *)StackN;

  865.        T1 = Elt->t&MSK_T;

  866.        D1 = Elt->t&MSK_R;

  867.        Elt2 = (struct Num *)Elt->n;

  868.        T2 = Elt2->t&MSK_T;

  869.        D2 = Elt2->t&MSK_R;

  870.        M_S=1;

  871.     }

  872.     if (D1!=D2) { /* on transforme long en double */

  873.         if (D2) toDouble(Elt); else toDouble(Elt2);

  874.         M_D = 1;

  875.     } else if(D1) M_D = 1;

  876.     l1 = &Elt->l;

  877.     l2 = &Elt2->l;

  878.     d1 = &Elt->d;

  879.     d2 = &Elt2->d;

  880.     if (T1==1) {

  881.         M_C=1;

  882.         if (M_D) ConstD = *d1;

  883.         else ConstL = *l1;

  884.     }

  885. /* pour debug

  886.     printf("T1=%d T2=%d M_C=%d M_D=%d M_S=%d ",T1,T2,M_C,M_D,M_S);

  887.     if (M_C)

  888.        if (M_D) printf("ConstD=%g",ConstD); else printf("ConstL=%lld",ConstL);

  889.     printf("\n");

  890. *****/

  891.     switch(O) {

  892.        case '+' :

  893.            if (M_C) {

  894.               if (M_D) for (i=0;i<T2;i++) *d2++ += ConstD;

  895.               else  for (i=0;i<T2;i++) *l2++ += ConstL;

  896.            } else {

  897.               if (M_D) for (i=0;i<T2;i++) *d2++ += *d1++;

  898.               else  for (i=0;i<T2;i++) *l2++ += *l1++;

  899.            }

  900.            break;

  901.        case '-' :

  902.            if (M_C) {

  903.               if (M_S) {

  904.                  if (M_D) for (i=0;i<T2;i++) *d2++ = ConstD - *d2;

  905.                  else  for (i=0;i<T2;i++) *l2++ = ConstL - *l2;

  906.               } else {

  907.                  if (M_D) for (i=0;i<T2;i++) *d2++ -= ConstD;

  908.                  else  for (i=0;i<T2;i++) *l2++ -= ConstL;

  909.               }

  910.            } else {

  911.               if (M_D) for (i=0;i<T2;i++) *d2++ -= *d1++;

  912.               else  for (i=0;i<T2;i++) *l2++ -= *l1++;

  913.            }

  914.            break;

  915.        case '*' :

  916.            if (M_C) {

  917.               if (M_D) for (i=0;i<T2;i++) *d2++ *= ConstD;

  918.               else  for (i=0;i<T2;i++) *l2++ *= ConstL;

  919.            } else {

  920.               if (M_D) for (i=0;i<T2;i++) *d2++ *= *d1++;

  921.               else  for (i=0;i<T2;i++) *l2++ *= *l1++;

  922.            }

  923.            break;

  924.        case '/' :

  925.            if (M_C) {

  926.               if (M_S) {

  927.                  if (M_D) for (i=0;i<T2;i++) *d2++ = ConstD / *d2;

  928.                  else  for (i=0;i<T2;i++) *l2++ = ConstL / *l2;

  929.               } else {

  930.                  if (M_D) for (i=0;i<T2;i++) *d2++ /= ConstD;

  931.                  else  for (i=0;i<T2;i++) *l2++ /= ConstL;

  932.               }

  933.            } else {

  934.               if (M_D) for (i=0;i<T2;i++) *d2++ /= *d1++;

  935.               else  for (i=0;i<T2;i++) *l2++ /= *l1++;

  936.            }

  937.            break;

  938.        case 'm' : /* min */

  939.          if (M_C) {

  940.            if (M_D) for(i=0;i<T2;i++) { if (*d2>ConstD) *d2=ConstD; d2++; }

  941.            else for(i=0;i<T2;i++) { if (*l2>ConstL) *l2=ConstL; l2++; }

  942.          } else {

  943.            if (M_D) for (i=0;i<T2;i++) { if (*d2>*d1) *d2=*d1; d2++; d1++; }

  944.            else  for (i=0;i<T2;i++) { if (*l2>*l1) *l2=*l1; l2++; l1++; }

  945.          }

  946.          break;

  947.        case 'M' : /* max */

  948.          if (M_C) {

  949.            if (M_D) for(i=0;i<T2;i++) { if (*d2<ConstD) *d2=ConstD; d2++; }

  950.            else for(i=0;i<T2;i++) { if (*l2<ConstL) *l2=ConstL; l2++; }

  951.          } else {

  952.            if (M_D) for (i=0;i<T2;i++) { if (*d2<*d1) *d2=*d1; d2++; d1++; }

  953.            else  for (i=0;i<T2;i++) { if (*l2<*l1) *l2=*l1; l2++; l1++; }

  954.          }

  955.          break;

  956.        case '%' : /* modulo */

  957.          if (M_C) {

  958.           if (M_S) {

  959.             if (M_D) for (i=0;i<T2;i++) *d2++ = fmod(ConstD,*d2);

  960.             else  for (i=0;i<T2;i++) *l2++ = ConstL % *l2;

  961.           } else {

  962.             if (M_D) for (i=0;i<T2;i++) *d2++ = fmod(*d2,ConstD);

  963.             else  for (i=0;i<T2;i++) *l2++ %= ConstL;

  964.           }

  965.          } else {

  966.           if (M_D) for (i=0;i<T2;i++) { *d2++ = fmod(*d2,*d1); d1++; }

  967.           else  for (i=0;i<T2;i++) *l2++ %= *l1++;

  968.          }

  969.          break;

  970.        case '^' : /* puissance */

  971.          if (! M_D) { /* passage en double force car + pratique */

  972.             toDouble(Elt); toDouble(Elt2);

  973.             if (M_C) ConstD=*d1;

  974.          }

  975.          if (M_C) {

  976.           if (M_S) {

  977.             for (i=0;i<T2;i++) *d2++ = pow(ConstD,*d2);

  978.           } else {

  979.             for (i=0;i<T2;i++) *d2++ = pow(*d2,ConstD);

  980.           }

  981.          } else {

  982.            for (i=0;i<T2;i++) { *d2++ = pow(*d2,*d1); d1++; }

  983.          }

  984.          break;

  985.        case '=' :  /* test egal */

  986.          if (M_C) {

  987.             if (M_D) for(i=0;i<T2;i++) {

  988.                  if (*d2 != ConstD) {B=FALSE; break;} d2++; }

  989.             else  for (i=0;i<T2;i++)  {

  990.                  if (*l2 != ConstL) {B=FALSE; break;} l2++; }

  991.          } else {

  992.             if (M_D) for (i=0;i<T2;i++) {

  993.                  if (*d2 != *d1) {B=FALSE; break;} d1++; d2++; }

  994.             else  for (i=0;i<T2;i++) {

  995.                  if (*l2 != *l1) {B=FALSE; break;} l1++; l2++; }

  996.          }

  997.          putBool(B);

  998.          dropElt(); /* suppression des 2 !! */

  999.          break;

  1000.        case '#' :  /* test different */

  1001.          if (M_C) {

  1002.             if (M_D) for(i=0;i<T2;i++) {

  1003.                  if (*d2 == ConstD) {B=FALSE; break;} d2++; }

  1004.             else  for (i=0;i<T2;i++)  {

  1005.                  if (*l2 == ConstL) {B=FALSE; break;} l2++; }

  1006.          } else {

  1007.             if (M_D) for (i=0;i<T2;i++) {

  1008.                  if (*d2 == *d1) {B=FALSE; break;} d1++; d2++; }

  1009.             else  for (i=0;i<T2;i++) {

  1010.                  if (*l2 == *l1) {B=FALSE; break;} l1++; l2++; }

  1011.          }

  1012.          putBool(B);

  1013.          dropElt(); /* suppression des 2 !! */

  1014.          break;

  1015.        case '<' :  /* test inf */

  1016.          if (M_C) {

  1017.            if (M_S) {

  1018.             if (M_D) for(i=0;i<T2;i++) {

  1019.                  if (*d2 < ConstD) {B=FALSE; break;} d2++; }

  1020.             else  for (i=0;i<T2;i++)  {

  1021.                  if (*l2 < ConstL) {B=FALSE; break;} l2++; }

  1022.            } else {

  1023.             if (M_D) for(i=0;i<T2;i++) {

  1024.                  if (*d2 >= ConstD) {B=FALSE; break;} d2++; }

  1025.             else  for (i=0;i<T2;i++)  {

  1026.                  if (*l2 >= ConstL) {B=FALSE; break;} l2++; }

  1027.            }

  1028.          } else {

  1029.             if (M_D) for (i=0;i<T2;i++) {

  1030.                  if (*d2 >= *d1) {B=FALSE; break;} d1++; d2++; }

  1031.             else  for (i=0;i<T2;i++) {

  1032.                  if (*l2 >= *l1) {B=FALSE; break;} l1++; l2++; }

  1033.          }

  1034.          putBool(B);

  1035.          dropElt(); /* suppression des 2 !! */

  1036.          break;

  1037.        case '>' :  /* test sup */

  1038.          if (M_C) {

  1039.            if (M_S) {

  1040.             if (M_D) for(i=0;i<T2;i++) {

  1041.                  if (*d2 > ConstD) {B=FALSE; break;} d2++; }

  1042.             else  for (i=0;i<T2;i++)  {

  1043.                  if (*l2 > ConstL) {B=FALSE; break;} l2++; }

  1044.            } else {

  1045.             if (M_D) for(i=0;i<T2;i++) {

  1046.                  if (*d2 <= ConstD) {B=FALSE; break;} d2++; }

  1047.             else  for (i=0;i<T2;i++)  {

  1048.                  if (*l2 <= ConstL) {B=FALSE; break;} l2++; }

  1049.            }

  1050.          } else {

  1051.             if (M_D) for (i=0;i<T2;i++) {

  1052.                  if (*d2 <= *d1) {B=FALSE; break;} d1++; d2++; }

  1053.             else  for (i=0;i<T2;i++) {

  1054.                  if (*l2 <= *l1) {B=FALSE; break;} l1++; l2++; }

  1055.          }

  1056.          putBool(B);

  1057.          dropElt(); /* suppression des 2 !! */

  1058.          break;

  1059.        case 'i' :  /* test inf ou egal */

  1060.          if (M_C) {

  1061.            if (M_S) {

  1062.             if (M_D) for(i=0;i<T2;i++) {

  1063.                  if (*d2 <= ConstD) {B=FALSE; break;} d2++; }

  1064.             else  for (i=0;i<T2;i++)  {

  1065.                  if (*l2 <= ConstL) {B=FALSE; break;} l2++; }

  1066.            } else {

  1067.             if (M_D) for(i=0;i<T2;i++) {

  1068.                  if (*d2 > ConstD) {B=FALSE; break;} d2++; }

  1069.             else  for (i=0;i<T2;i++)  {

  1070.                  if (*l2 > ConstL) {B=FALSE; break;} l2++; }

  1071.            }

  1072.          } else {

  1073.             if (M_D) for (i=0;i<T2;i++) {

  1074.                  if (*d2 > *d1) {B=FALSE; break;} d1++; d2++; }

  1075.             else  for (i=0;i<T2;i++) {

  1076.                  if (*l2 > *l1) {B=FALSE; break;} l1++; l2++; }

  1077.          }

  1078.          putBool(B);

  1079.          dropElt(); /* suppression des 2 !! */

  1080.          break;

  1081.        case 's' :  /* test sup ou egal */

  1082.          if (M_C) {

  1083.            if (M_S) {

  1084.             if (M_D) for(i=0;i<T2;i++) {

  1085.                  if (*d2 >= ConstD) {B=FALSE; break;} d2++; }

  1086.             else  for (i=0;i<T2;i++)  {

  1087.                  if (*l2 >= ConstL) {B=FALSE; break;} l2++; }

  1088.            } else {

  1089.             if (M_D) for(i=0;i<T2;i++) {

  1090.                  if (*d2 < ConstD) {B=FALSE; break;} d2++; }

  1091.             else  for (i=0;i<T2;i++)  {

  1092.                  if (*l2 < ConstL) {B=FALSE; break;} l2++; }

  1093.            }

  1094.          } else {

  1095.             if (M_D) for (i=0;i<T2;i++) {

  1096.                  if (*d2 < *d1) {B=FALSE; break;} d1++; d2++; }

  1097.             else  for (i=0;i<T2;i++) {

  1098.                  if (*l2 < *l1) {B=FALSE; break;} l1++; l2++; }

  1099.          }

  1100.          putBool(B);

  1101.          dropElt(); /* suppression des 2 !! */

  1102.          break;

  1103.        default :

  1104.          printf("%c : not yet implemented !\n",O);

  1105.        break;

  1106.     }

  1107.     dropElt(); /* suppression du 1er */

  1108. }

  1109. 

  1110. void IF_plus(void) { IF_fct_2('+'); }

  1111. void IF_moins(void) { IF_fct_2('-'); }

  1112. void IF_mult(void) { IF_fct_2('*'); }

  1113. void IF_div(void) { IF_fct_2('/'); }

  1114. void IF_min(void) { IF_fct_2('m'); }

  1115. void IF_max(void) { IF_fct_2('M'); }

  1116. void IF_modulo(void) { IF_fct_2('%'); }

  1117. void IF_puiss(void) { IF_fct_2('^'); }

  1118. void IF_neg(void)

  1119. {

  1120.     putLong((long long)-1);

  1121.     IF_mult();

  1122. }

  1123. 

  1124. void IF_Legal(void) { IF_fct_2('='); }

  1125. void IF_Ldiff(void) { IF_fct_2('#'); }

  1126. void IF_Lsup(void) { IF_fct_2('>'); }

  1127. void IF_Linf(void) { IF_fct_2('<'); }

  1128. void IF_Lsupeg(void) { IF_fct_2('s'); }

  1129. void IF_Linfeg(void) { IF_fct_2('i'); }

  1130. 

  1131. void IF_fctD_1(double(*f)(double))

  1132. {

  1133. struct Num *Elt;

  1134. uint32_t n;

  1135. long long *L;

  1136. double *D;

  1137. int i;

  1138.    _VERIF_STACK_

  1139.    Elt = (struct Num *)StackN;

  1140.    n = Elt->t&MSK_T;

  1141.    if (Elt->t&MSK_R) { /* double */

  1142.       D = &(Elt->d);

  1143.       for(i=0;i<n;i++) *D++ = f(*D);

  1144.    } else {

  1145.       D = &(Elt->d);

  1146.       L = &(Elt->l);

  1147.       for(i=0;i<n;i++) *D++ = f((double)*L++);

  1148.       Elt->t = Elt->t | MSK_R;

  1149.    }

  1150. }

  1151. 

  1152. void IF_fctB_1(long long (*f1)(long long), double(*f2)(double))

  1153. {

  1154. struct Num *Elt;

  1155. uint32_t n;

  1156. long long *L;

  1157. double *D;

  1158. int i;

  1159.    _VERIF_STACK_

  1160.    Elt = (struct Num *)StackN;

  1161.    n = Elt->t&MSK_T;

  1162.    if (Elt->t&MSK_R) { /* double */

  1163.       D = &(Elt->d);

  1164.       for(i=0;i<n;i++) *D++ = f2(*D);

  1165.    } else {

  1166.       L = &(Elt->l);

  1167.       for(i=0;i<n;i++) *L++ = f1(*L);

  1168.    }

  1169. }

  1170. 

  1171. void IF_fctD_1L(long long(*f)(double))

  1172. {

  1173. struct Num *Elt;

  1174. uint32_t n;

  1175. long long *L;

  1176. double *D;

  1177. int i;

  1178.    _VERIF_STACK_

  1179.    Elt = (struct Num *)StackN;

  1180.    n = Elt->t&MSK_T;

  1181.    if (Elt->t&MSK_R) { /* double */

  1182.       D = &(Elt->d);

  1183.       L = &(Elt->l);

  1184.       for(i=0;i<n;i++) *L++ = f(*D++);

  1185.       Elt->t = Elt->t & ~MSK_R; /* change type */

  1186.    }

  1187.    /* rien si long */

  1188. }

  1189. 

  1190. void IF_fctD_1LB(long long(*f)(double))

  1191. {

  1192. struct Num *Elt;

  1193. uint32_t n;

  1194. long long *L;

  1195. double *D;

  1196. int i;

  1197.    _VERIF_STACK_

  1198.    Elt = (struct Num *)StackN;

  1199.    n = Elt->t&MSK_T;

  1200.    D = &(Elt->d);

  1201.    L = &(Elt->l);

  1202.    if (Elt->t&MSK_R) { /* double */

  1203.       for(i=0;i<n;i++) *L++ = f(*D++);

  1204.       Elt->t = Elt->t & ~MSK_R; /* change type */

  1205.    } else {

  1206.       for(i=0;i<n;i++) *L++ = f(*L);

  1207.    }

  1208. }

  1209. 

  1210. void IF_inFile_1d(FILE * fd, char delim, int virg)

  1211. {

  1212. struct Num *Elt;

  1213. uint32_t n;

  1214. long long *L;

  1215. double *D;

  1216. int i;

  1217. char buf[40], *pt;

  1218.    _VERIF_STACK_

  1219.    Elt = (struct Num *)StackN;

  1220.    n = Elt->t&MSK_T;

  1221.    if (Elt->t&MSK_R) { /* double */

  1222.       D = &(Elt->d);

  1223.       for(i=0;i<n;i++) {

  1224.          sprintf(buf,"%.15f%c",*D++,delim);

  1225.          pt = buf + strlen(buf) - 2;

  1226.          while (*pt == '0') pt--;

  1227.          pt++;

  1228.          *pt++ = delim;

  1229.          *pt='\0';

  1230.          if (virg)

  1231.             if ((pt = strchr(buf, (int)'.')) != NULL) *pt = ',';

  1232.          fprintf(fd,buf);

  1233.       }

  1234.    } else {

  1235.       L = &(Elt->l);

  1236.       for(i=0;i<n;i++) fprintf(fd,"%lld%c",*L++,delim);

  1237.    }

  1238.    fprintf(fd,"\n");

  1239.    dropElt(); /* suppression */

  1240. }

  1241. 

  1242. void IF_inFile_1(FILE * fd)

  1243. {

  1244. struct Num *Elt;

  1245. uint32_t n;

  1246. long long *L;

  1247. double *D;

  1248. int i;

  1249.    _VERIF_STACK_

  1250.    Elt = (struct Num *)StackN;

  1251.    n = Elt->t&MSK_T;

  1252.    if (Elt->t&MSK_R) { /* double */

  1253.       D = &(Elt->d);

  1254.       for(i=0;i<n;i++) fprintf(fd,"%d %g\n",i,*D++);

  1255.    } else {

  1256.       L = &(Elt->l);

  1257.       for(i=0;i<n;i++) fprintf(fd,"%d %lld\n",i,*L++);

  1258.    }

  1259. }

  1260. 

  1261. void IF_inFile_2(FILE * fd)

  1262. {

  1263. struct Num *Elt, *Elt2;

  1264. uint32_t n, n2;

  1265. long long *L, *L2;

  1266. double *D, *D2;

  1267. int i;

  1268.    _VERIF_STACK_

  1269.    Elt = (struct Num *)StackN;

  1270.    n = Elt->t&MSK_T;

  1271.    Elt2 = Elt->n;

  1272.    n2 = Elt2->t&MSK_T;

  1273.    if (n>n2) n=n2;

  1274.    if (Elt->t&MSK_R) { /* double */

  1275.       D = &(Elt->d);

  1276.       if (Elt2->t&MSK_R) { /* double */

  1277.          D2 = &(Elt2->d);

  1278.          for(i=0;i<n;i++) fprintf(fd,"%g %g\n",*D2++,*D++);

  1279.       } else {

  1280.          L2 = &(Elt2->l);

  1281.          for(i=0;i<n;i++) fprintf(fd,"%lld %g\n",*L2++,*D++);

  1282.       }

  1283.    } else {

  1284.       L = &(Elt->l);

  1285.       if (Elt2->t&MSK_R) { /* double */

  1286.          D2 = &(Elt2->d);

  1287.          for(i=0;i<n;i++) fprintf(fd,"%g %lld\n",*D2++,*L++);

  1288.       } else {

  1289.          L2 = &(Elt2->l);

  1290.          for(i=0;i<n;i++) fprintf(fd,"%lld %lld\n",*L2++,*L++);

  1291.       }

  1292.    }

  1293. }

  1294. 

  1295. static int dimTab(void * A)

  1296. {

  1297. struct Num *N;

  1298. uint32_t l;

  1299.     if (A==VIDE) return 0L;

  1300.     N = (struct Num*)A;

  1301.     l = N->t&MSK_T;

  1302.     return (int)l;

  1303. }

  1304. 

  1305. static long transLongTo(long long * C)

  1306. {

  1307. struct Num *Elt;

  1308. int i;

  1309. uint32_t l;

  1310. long long *L;

  1311. double *D;

  1312.    Elt = (struct Num *)StackN;

  1313.    l = Elt->t&MSK_T;

  1314.    L = &(Elt->l)+l-1;

  1315.    D = &(Elt->d)+l-1;

  1316.    if (Elt->t & MSK_R)

  1317.       for (i=0;i<l;i++) *C--=(long long)*D--;

  1318.    else

  1319.       for (i=0;i<l;i++) *C--=*L--;

  1320.    dropElt();

  1321.    return(l);

  1322. }

  1323. 

  1324. static long transDoubTo(double * C)

  1325. {

  1326. struct Num *Elt;

  1327. int i;

  1328. uint32_t l;

  1329. long long *L;

  1330. double *D;

  1331.    Elt = (struct Num *)StackN;

  1332.    l = Elt->t&MSK_T;

  1333.    L = &(Elt->l)+l-1;

  1334.    D = &(Elt->d)+l-1;

  1335.    if (Elt->t & MSK_R)

  1336.       for (i=0;i<l;i++) *C--=*D--;

  1337.    else

  1338.       for (i=0;i<l;i++) *C--=(double)*L--;

  1339.    dropElt();

  1340.    return(l);

  1341. }

  1342. 

  1343. void IF_toArray( void )

  1344. {

  1345. uint32_t n, i, l, T, t;

  1346. long long  *L;

  1347. double *D;

  1348. void * M;

  1349. struct Num *N;

  1350.   _VERIF_STACK_

  1351.   if (!isScalar()) {

  1352.        messErr(36); return;

  1353.   }

  1354.   n = (uint32_t)getVal();

  1355.   dropElt();

  1356.   if (n>1) {

  1357.    i = nbSizeTypeOnStack(n,&t);

  1358.    if (i<n) messErr(4);

  1359.    else {

  1360.       T = t & MSK_T;      

  1361.       if ((M = malloc(sizeof(struct Num)+((T-1)*(sizeof(double))))) == NULL)

  1362.              stopErr("IF_toArray","malloc");

  1363.       N = (struct Num*)M;

  1364.       N->t = t;

  1365.       if (t & MSK_R) {

  1366.          D = &(N->d)+(T-1);

  1367.          for(i=0;i<n;i++) { l=transDoubTo(D); D -= l; }

  1368.       } else {

  1369.          L = &(N->l)+(T-1);

  1370.          for(i=0;i<n;i++) { l=transLongTo(L); L -= l; }

  1371.       }

  1372.       /* on the stack */

  1373.       N->n = StackN;

  1374.       _MODIF_STACKN_(M);

  1375.    }

  1376.   } else messErr(30);

  1377. }

  1378. 

  1379. static void toScalar( int s )

  1380. {

  1381. struct Num *Elt;

  1382. uint32_t l;

  1383. int i;

  1384. double *D;

  1385. long long * L;

  1386.    _VERIF_STACK_

  1387.    Elt = (struct Num *)StackN;

  1388.    l = Elt->t&MSK_T;

  1389.    if (l==1) return;

  1390.    _MODIF_STACKN_(Elt->n); /* depile */

  1391.    if (s) {

  1392.       L = &(Elt->l);

  1393.       D = &(Elt->d);

  1394.       if (Elt->t & MSK_R)

  1395.          for(i=0;i<l;i++) putDouble(*D++);

  1396.       else 

  1397.          for(i=0;i<l;i++) putLong(*L++);

  1398.    } else {

  1399.       L = &(Elt->l)+l-1;

  1400.       D = &(Elt->d)+l-1;

  1401.       if (Elt->t & MSK_R)

  1402.          for(i=0;i<l;i++) putDouble(*D--);

  1403.       else 

  1404.          for(i=0;i<l;i++) putLong(*L--);

  1405.    }

  1406.    if (!(Elt->t&MSK_V)) free((void*)Elt);

  1407. }

  1408. 

  1409. void IF_toScalar( void )

  1410. {

  1411.     toScalar(1);

  1412. }

  1413. 

  1414. void IF_toScalarR( void )

  1415. {

  1416.     toScalar(0);

  1417. }

  1418. 

  1419. static void tabShift(void **A,long s)

  1420. {

  1421. struct Num *Elt, *NElt;

  1422. void * M;

  1423. long j, k;

  1424. uint32_t l;

  1425. long long *L, *NL;

  1426.    _VERIF_STACK_

  1427.    Elt = (struct Num *)*A;

  1428.    l = Elt->t&MSK_T;

  1429.    if (l==1) return;

  1430.    if (s>0)

  1431.       while (s>=l) s-=l;

  1432.    else  while (-s>=l) s+=l;

  1433.    if (s==0) return;

  1434.    if (s>0) j=s;

  1435.    else j=l+s;

  1436.    k = sizeof(struct Num)+((l-1)*(sizeof(double)));

  1437.    if ((M = malloc(k)) == NULL) stopErr("tabShift","malloc");

  1438.    NElt = (struct Num *)M;

  1439.    *A = M;

  1440.    NElt->t = Elt->t;

  1441.    NElt->n = Elt->n;

  1442.    L = &(Elt->l);

  1443.    NL = &(NElt->l);

  1444.    k=l-j;

  1445.    bcopy((void*)&L[0],(void*)&NL[j],k*sizeof(long long));

  1446.    bcopy((void*)&L[k],(void*)&NL[0],j*sizeof(long long));

  1447.    if (!(Elt->t&MSK_V)) free((void*)Elt);

  1448. }

  1449. 

  1450. void IF_TShiftR( void )

  1451. {

  1452.    tabShift(_ADDR_STACKN_,1);

  1453. }

  1454. 

  1455. void IF_TShiftL( void )

  1456. {

  1457.    tabShift(_ADDR_STACKN_,-1);

  1458. }

  1459. 

  1460. static void nTabShift( int v )

  1461. {

  1462. void ** ANext;

  1463. struct Num * N;

  1464. long i=0, n;

  1465.    _VERIF_STACK_

  1466.    if (!isScalar()) {

  1467.        messErr(36); return;

  1468.    }

  1469.    n = (long)getVal();

  1470.    dropElt();

  1471.    if (n>0) {

  1472.     ANext = _ADDR_STACKN_;

  1473.     while (*ANext != VIDE) {

  1474.        tabShift(ANext,v);

  1475.        N = (struct Num*) *ANext;

  1476.        ANext = &(N->n);

  1477.        i++;

  1478.        if (i==n) break;

  1479.     }

  1480.    } else messErr(29);

  1481. }

  1482. 

  1483. void IF_NTShiftR( void )

  1484. {

  1485.    nTabShift(1);

  1486. }

  1487. 

  1488. void IF_NTShiftL( void )

  1489. {

  1490.    nTabShift(-1);

  1491. }

  1492. 

  1493. void IF_TNShiftR( void )

  1494. {

  1495. long n;

  1496.    _VERIF_STACK_

  1497.    if (!isScalar()) {

  1498.        messErr(36); return;

  1499.    }

  1500.    n = (long)getVal();

  1501.    dropElt();

  1502.    tabShift(_ADDR_STACKN_,n);

  1503. }

  1504. 

  1505. void IF_TNShiftL( void )

  1506. {

  1507. long n;

  1508.    _VERIF_STACK_

  1509.    if (!isScalar()) {

  1510.        messErr(36); return;

  1511.    }

  1512.    n = (long)getVal();

  1513.    dropElt();

  1514.    tabShift(_ADDR_STACKN_,-n);

  1515. }

  1516. 

  1517. static void nTNShift( int s )

  1518. {

  1519. long n;

  1520.    _VERIF_STACK_

  1521.    if (!isScalar()) {

  1522.        messErr(36); return;

  1523.    }

  1524.    n = (long)getVal();

  1525.    dropElt();

  1526.    nTabShift(n*s);

  1527. }

  1528. 

  1529. void IF_NTNShiftR( void )

  1530. {

  1531.     nTNShift(1);

  1532. }

  1533. 

  1534. void IF_NTNShiftL( void )

  1535. {

  1536.     nTNShift(-1);

  1537. }

  1538. 

  1539. static void subTab(void **pA , long n, char r) /* r=1 : right else left */

  1540. {

  1541. struct Num *Elt, *Elt2;

  1542. uint32_t l;

  1543. long k;

  1544. long long *L, *Lf;

  1545. void *A, * M;

  1546. double *D, *Df;

  1547. 

  1548.    _VERIF_STACK_

  1549.    A = *pA;

  1550.    Elt = (struct Num *)A;

  1551.    l = Elt->t&MSK_T;

  1552.    if (l==n) return;

  1553.    k = sizeof(struct Num)+((n-1)*(sizeof(long long)));

  1554.    if ((M = malloc(k)) == NULL) stopErr("subTab","malloc");

  1555.    Elt2 = (struct Num *)M;

  1556.    Elt2->n = Elt->n;

  1557.    Elt2->t = (Elt->t&MSK_R) | n;

  1558.    *pA = M;

  1559.    if (n<l) {

  1560.       L = &(Elt->l);

  1561.       if (r) L += (l-n);

  1562.       bcopy((void*)L,(void*)&(Elt2->l),n*sizeof(long long));

  1563.    } else { /* fill with zero */

  1564.       L = &(Elt2->l);

  1565.       if (!r) L += (n-l);

  1566.       bcopy((void*)&(Elt->l),(void*)L,l*sizeof(long long));

  1567.       if (Elt->t&MSK_R) {

  1568.          D = &(Elt2->d);

  1569.          if (r) D += l;

  1570.          Df = D + (n-l);

  1571.          while (D < Df) *D++ = (double)0;

  1572.       } else {

  1573.          L = &(Elt2->l);

  1574.          if (r) L += l;

  1575.          Lf = L + (n-l);

  1576.          while (L < Lf) *L++ = 0L;

  1577.       }

  1578.    }

  1579.    if (!(Elt->t&MSK_V)) free(A);

  1580. }

  1581. 

  1582. void IF_subTab(void)

  1583. {

  1584. long n;

  1585.    _VERIF_STACK_

  1586.    if (!isScalar()) {

  1587.        messErr(36); return;

  1588.    }

  1589.    n = (long)getVal();

  1590.    dropElt();

  1591.    if (n>0) subTab(_ADDR_STACKN_, n, 0);

  1592.    else messErr(29);

  1593. }

  1594. 

  1595. void IF_subTabR(void)

  1596. {

  1597. long n;

  1598.    _VERIF_STACK_

  1599.    if (!isScalar()) {

  1600.        messErr(36); return;

  1601.    }

  1602.    n = (long)getVal();

  1603.    dropElt();

  1604.    if (n>0) subTab(_ADDR_STACKN_, n, (char)1);

  1605.    else messErr(29);

  1606. }

  1607. 

  1608. static void NSubTab( char r )

  1609. {

  1610. void **pNext;

  1611. struct Num * N;

  1612. long i=0, n, l;

  1613.    _VERIF_STACK_

  1614.    if (!isScalar()) {

  1615.        messErr(36); return;

  1616.    }

  1617.    l = (long)getVal();

  1618.    dropElt();

  1619.    if (l>0) {

  1620.     if (!isScalar()) {

  1621.        messErr(36); return;

  1622.     }

  1623.     n = (long)getVal();

  1624.     dropElt();

  1625.     if (n>0) {

  1626.      pNext = _ADDR_STACKN_;

  1627.      while (*pNext != VIDE) {

  1628.        subTab(pNext,l,r);

  1629.        N = (struct Num*) *pNext;

  1630.        pNext = &(N->n);

  1631.        i++;

  1632.        if (i==n) break;

  1633.      }

  1634.     } else messErr(29);

  1635.    } else messErr(29);

  1636. }

  1637. 

  1638. void IF_NsubTab(void)

  1639. {

  1640.     NSubTab((char)0);

  1641. }

  1642. 

  1643. void IF_NsubTabR(void)

  1644. {

  1645.     NSubTab((char)1);

  1646. }

  1647. 

  1648. static void tabRev( void* A )

  1649. {

  1650. struct Num *Elt;

  1651. uint32_t l;

  1652. double *D, *FD, vD;

  1653. long long * L, *FL, vL;

  1654.    _VERIF_STACK_

  1655.    Elt = (struct Num *)A;

  1656.    l = Elt->t&MSK_T;

  1657.    if (l==1) return;

  1658.    if (Elt->t & MSK_R) {

  1659.       D = &(Elt->d);

  1660.       FD = D+l-1;

  1661.       while (D<FD) {

  1662.         vD=*D; *D=*FD; *FD=vD;

  1663.         D++; FD--;

  1664.       }

  1665.    } else  {

  1666.       L = &(Elt->l);

  1667.       FL=L+l-1;

  1668.       while (L<FL) {

  1669.         vL=*L; *L=*FL; *FL=vL;

  1670.         L++; FL--;

  1671.       }

  1672.    }

  1673. }

  1674. 

  1675. void IF_TabRev( void )

  1676. {

  1677.     tabRev(StackN);

  1678. }

  1679. 

  1680. void IF_NTabRev( void )

  1681. {

  1682. void * Next;

  1683. struct Num * N;

  1684. long i=0, n;

  1685.    _VERIF_STACK_

  1686.    if (!isScalar()) {

  1687.        messErr(36); return;

  1688.    }

  1689.    n = (long)getVal();

  1690.    dropElt();

  1691.    if (n>0) {

  1692.     Next = StackN;

  1693.     while (Next != VIDE) {

  1694.        N = (struct Num*) Next;

  1695.        tabRev(Next);

  1696.        Next = N->n;

  1697.        i++;

  1698.        if (i==n) break;

  1699.     }

  1700.    } else messErr(29);

  1701. }

  1702. 

  1703. static void tabTransp (int sens)

  1704. {

  1705. void * Next, *Next2, **Suiv, *SNext, **Last;

  1706. struct Num * N, *N2;

  1707. long i=0, j, n;

  1708. uint32_t l;

  1709. short Doub=0;

  1710. double *D, *D2;

  1711. long long *L, *L2;

  1712.   _VERIF_STACK_

  1713.   if (!isScalar()) {

  1714.        messErr(36); return;

  1715.   }

  1716.   n = (long)getVal();

  1717.   dropElt();

  1718.   if (n>0) {

  1719.    if (n==1) {

  1720.       if (sens) toScalar(1);

  1721.       else toScalar(0);

  1722.       return;

  1723.    }

  1724.    /* the n elts on stack must have the same dim */

  1725.    Next = StackN;

  1726.    while (Next != VIDE) {

  1727.       N = (struct Num*) Next;

  1728.       if (i) {

  1729.          if (l != (N->t&MSK_T)) break;

  1730.       } else l = N->t&MSK_T;

  1731.       if (N->t&MSK_R) Doub=1;

  1732.       i++;

  1733.       if (i==n) break;

  1734.       Next = N->n;

  1735.    }

  1736.    if (i!=n) {

  1737.      if (Next == VIDE) messErr(4);

  1738.      else messErr(3);

  1739.    } else {

  1740.      /* make l elts of dim n */

  1741.      Suiv = &Next2;

  1742.      for (i=0;i<l;i++) {

  1743.         if ((*Suiv=malloc(sizeof(struct Num)+((n-1)*(sizeof(double)))))==NULL)

  1744.            stopErr("tabTransp","malloc");

  1745.         N2 = (struct Num*) *Suiv;

  1746.         N2->t = n;

  1747.         if (Doub) N2->t |= MSK_R;

  1748.         /* remplissage */

  1749.         if (sens) {

  1750.            j=0;

  1751.            if (sens==1) {

  1752.               N2->n = SNext;

  1753.               SNext = Next2;

  1754.               if (i==0) Last = &(N2->n);

  1755.            } else

  1756.               Suiv = &N2->n;

  1757.         } else {

  1758.            j=n-1;

  1759.            Suiv = &N2->n;

  1760.         }

  1761.         if (Doub) {

  1762.            D2 = &(N2->d);

  1763.         } else {

  1764.            L2 = &(N2->l);

  1765.         }

  1766.         Next = StackN;

  1767.         while (Next != VIDE) {

  1768.            N = (struct Num*) Next;

  1769.            if (Doub) {

  1770.               if (N->t&MSK_R) {

  1771.                  D = &(N->d); 

  1772.                  if (sens) D+=(l-i-1);

  1773.                  else D+=i;

  1774.                  *(D2+j) = *D;

  1775.               } else {

  1776.                  L = &(N->l);

  1777.                  if (sens) L+=(l-i-1);

  1778.                  else L+=i;

  1779.                  *(D2+j) = (double)*L;

  1780.               }

  1781.            } else {

  1782.               L = &(N->l);

  1783.               if (sens) L+=(l-i-1);

  1784.               else L+=i;

  1785.               *(L2+j) = *L;

  1786.               /* printf("%ld ",*L); */

  1787.            }

  1788.            if (sens) {

  1789.               j++;

  1790.               if (j>=n) break;

  1791.            } else {

  1792.               j--;

  1793.               if (j<0) break;

  1794.            }

  1795.            Next = N->n;

  1796.         }

  1797.         /* printf("\n"); */

  1798.      }

  1799.      if (sens!=1) Last = &(N2->n);

  1800.      /* drop n elts */

  1801.      for (i=0;i<n;i++) dropElt();

  1802.      /* put new elts on the stack */

  1803.      *Last = StackN;

  1804.      _MODIF_STACKN_(Next2);

  1805.    }

  1806.   } else messErr(29);

  1807. }

  1808. 

  1809. void IF_TabTransp (void) /* crot */

  1810. {

  1811.    tabTransp(0);

  1812. }

  1813. 

  1814. void IF_TabTranspN (void) /* transpose */

  1815. {

  1816.    tabTransp(1);

  1817. }

  1818. 

  1819. void IF_TabTranspT (void) /* trot */

  1820. {

  1821.    tabTransp(-1);

  1822. }

  1823. 

  1824. int is1Tab(void)

  1825. {

  1826.     if (dimTab(StackN) < 2L) return 0;

  1827.     return 1;

  1828. }

  1829. 

  1830. int is2Tab(void)

  1831. {

  1832. struct Num *N;

  1833.     if (dimTab(StackN) < 2L) return 0;

  1834.     N = (struct Num*)StackN;

  1835.     if (dimTab(N->n) < 2L) return 0;

  1836.     return 1;

  1837. }

  1838. 

  1839. int isNTabSameDim(int n)

  1840. {

  1841. void * Next;

  1842. struct Num * N;

  1843. long i=0;

  1844. uint32_t l;

  1845.    /* the n elts on stack must have the same dim */

  1846.    Next = StackN;

  1847.    while (Next != VIDE) {

  1848.       N = (struct Num*) Next;

  1849.       if (i) {

  1850.          if (l != (long)(N->t&MSK_T)) break;

  1851.       } else l = N->t&MSK_T;

  1852.       i++;

  1853.       if (i==n) return 1; /* OK */

  1854.       Next = N->n;

  1855.    }

  1856.    return 0;

  1857. }

  1858. 

  1859. /* []functions ****/

  1860. 

  1861. static void TAB_Fct(char C)

  1862. {

  1863. struct Num *Elt;

  1864. uint32_t n;

  1865. long long *L, L1, L2;

  1866. double *D, D1, D2;

  1867. int i;

  1868.   _VERIF_STACK_

  1869.   Elt = (struct Num *)StackN;

  1870.   n = Elt->t&MSK_T;

  1871.   if (n>1) {

  1872.     if (Elt->t&MSK_R) { /* double */

  1873.       switch(C) {

  1874.         case 'm' :

  1875.           D1 = Elt->d;

  1876.           D = &(Elt->d)+1;

  1877.           for(i=1;i<n;i++) { if (*D<D1) D1=*D; D++; }

  1878.           putDouble(D1);

  1879.           break;

  1880.         case 'M' :

  1881.           D1 = Elt->d;

  1882.           D = &(Elt->d)+1;

  1883.           for(i=1;i<n;i++) { if (*D>D1) D1=*D; D++; }

  1884.           putDouble(D1);

  1885.           break;

  1886.         case '+' :

  1887.           D1 = Elt->d;

  1888.           D = &(Elt->d)+1;

  1889.           for(i=1;i<n;i++)  D1 += *D++;

  1890.           putDouble(D1);

  1891.           break;

  1892.         case '*' :

  1893.           D1 = Elt->d;

  1894.           D = &(Elt->d)+1;

  1895.           for(i=1;i<n;i++)  D1 *= *D++;

  1896.           putDouble(D1);

  1897.           break;

  1898.         default :  /* E = extrems */

  1899.           D1 = D2 = Elt->d;

  1900.           D = &(Elt->d)+1;

  1901.           for(i=1;i<n;i++) {

  1902.               if (*D>D2) D2=*D;

  1903.               if (*D<D1) D1=*D; D++;

  1904.           }

  1905.           putDouble(D1);

  1906.           IF_swap();

  1907.           putDouble(D2);

  1908.           break;

  1909.       }

  1910.     } else {

  1911.       switch(C) {

  1912.         case 'm' :

  1913.           L1 = Elt->l;

  1914.           L = &(Elt->l)+1;

  1915.           for(i=1;i<n;i++) { if (*L<L1) L1=*L; L++; }

  1916.           putLong(L1);

  1917.           break;

  1918.         case 'M' :

  1919.           L1 = Elt->l;

  1920.           L = &(Elt->l)+1;

  1921.           for(i=1;i<n;i++) { if (*L>L1) L1=*L; L++; }

  1922.           putLong(L1);

  1923.           break;

  1924.         case '+' :

  1925.           L1 = Elt->l;

  1926.           L = &(Elt->l)+1;

  1927.           for(i=1;i<n;i++)  L1 += *L++;

  1928.           putLong(L1);

  1929.           break;

  1930.         case '*' :

  1931.           L1 = Elt->l;

  1932.           L = &(Elt->l)+1;

  1933.           for(i=1;i<n;i++)  L1 *= *L++;

  1934.           putLong(L1);

  1935.           break;

  1936.         default :  /* E = extrems */

  1937.           L1 = L2 = Elt->l;

  1938.           L = &(Elt->l)+1;

  1939.           for(i=1;i<n;i++) {

  1940.               if (*L>L2) L2=*L;

  1941.               if (*L<L1) L1=*L; L++;

  1942.           }

  1943.           putLong(L1);

  1944.           IF_swap();

  1945.           putLong(L2);

  1946.           break;

  1947.       }

  1948.     }

  1949.     IF_swap();

  1950.     dropElt();

  1951.   } else messErr(12);

  1952. }

  1953. 

  1954. void IF_TABMin(void) { TAB_Fct('m'); }

  1955. void IF_TABMax(void) { TAB_Fct('M'); }

  1956. void IF_TABProd(void) { TAB_Fct('*'); }

  1957. void IF_TABSum(void) { TAB_Fct('+'); }

  1958. void IF_TABMinMax(void) { TAB_Fct('E'); }

  1959. 

  1960. #define LENT 20

  1961. void dump_eltN(int fd, void *A, uint32_t MSK)

  1962. {

  1963. struct Num * N;

  1964. long l;

  1965. long long v;

  1966. uint32_t t;

  1967.        N = (struct Num*)A;

  1968.        t = N->t;

  1969.        if ((MSK) && (t & MSK_V)) {

  1970.           v = (long long)iVarByAddrA(A);

  1971.           t = 1 | MSK_V;

  1972.           write(fd, (void*)&t, sizeof(t));

  1973.           write(fd, (void*)&v, sizeof(v));

  1974.        } else {

  1975.           /* t &= ~MSK_V; */

  1976.           write(fd, (void*)&t, sizeof(t));

  1977.           l = t & MSK_T;

  1978.           write(fd, (void*)&(N->l), (size_t)(l*sizeof(double)));

  1979.        }

  1980. }

  1981. 

  1982. static int NbARIV;

  1983. void restore_links_stackN(void)

  1984. {

  1985. void **ANext, *A;

  1986. struct Num * N, *T;

  1987.     if (NbARIV == 0) return;

  1988.     ANext = &StackN;

  1989.     while (*ANext != VIDE) {

  1990.        N = (struct Num*) *ANext;

  1991.        if (N->t & MSK_V) {

  1992.           A = varAddrAByInd(N->l);

  1993.           T = (struct Num*) A;

  1994.           T->n = N->n;

  1995.           *ANext = A;

  1996.           free((void*)N);

  1997.        }

  1998.        ANext = &(N->n);

  1999.     }

  2000.     rest_links_pr(NbARIV, "variable", "numerical");

  2001. }

  2002. 

  2003. void dump_stackN(int fd)

  2004. {

  2005. void * Next;

  2006. struct Num * N;

  2007. uint32_t n=0;

  2008. int i,j;

  2009.     Next = StackN;

  2010.     while (Next != VIDE) {

  2011.        N = (struct Num*) Next;

  2012.        n++;

  2013.        Next = N->n;

  2014.     }

  2015.     write(fd, (void*)&n, sizeof(n));

  2016.     for (i=n; i>0; i--) {

  2017.         Next = StackN;

  2018.         j=0;

  2019.         while (Next != VIDE) {

  2020.            N = (struct Num*) Next;

  2021.            j++;

  2022.            if (i==j) break;

  2023.            Next = N->n;

  2024.         }

  2025.         dump_eltN(fd, Next, MSK_V);

  2026.     }

  2027.     dump_rest_pr(0,n,"numerical");

  2028. }

  2029. 

  2030. static void * restore_eltN_l(int fd, int K)

  2031. {

  2032. uint32_t t, u;

  2033. int s;

  2034. void * M;

  2035. struct Num * N;

  2036.         read(fd, (void*)&t, sizeof(t));

  2037.         u = t & MSK_T;

  2038.         if ((t & MSK_V) && K) NbARIV++;

  2039.         /* printf("%u : %d\n", u, NbARIV); /* debug */

  2040.         s = sizeof(struct Num)+((u-1)*(sizeof(double)));

  2041.         if ((M = malloc(s)) == NULL) stopErr("restore_eltN","malloc");

  2042.         N = (struct Num*)M;

  2043.         N->t = t;

  2044.         N->n = StackN;

  2045.         read(fd, (void*)&(N->l), u*sizeof(double));

  2046.         return M;

  2047. }

  2048. 

  2049. void * restore_eltN(int fd)

  2050. {

  2051.     return restore_eltN_l(fd,0);

  2052. }

  2053. 

  2054. void restore_stackN(int fd)

  2055. {

  2056. uint32_t n=0, i;

  2057. void * M;

  2058.     NbARIV = 0;

  2059.     if (read(fd, (void*)&n, sizeof(n)) != sizeof(n)) return;

  2060.     IF_stack_clear();

  2061.     for (i=0; i<n; i++) {

  2062.         M = restore_eltN_l(fd,1);

  2063.         _MODIF_STACKN_(M);

  2064.     }

  2065.     dump_rest_pr(1,n,"numerical");

  2066. }