home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Professional / OS2PRO194.ISO / os2 / progs / pari / pari_137 / src / anal.c < prev    next >
C/C++ Source or Header  |  1992-05-20  |  45KB  |  1,467 lines
  1. /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
  2. /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
  3. /*                                                                 */
  4. /*            Analyseur syntactique pour la calculette             */
  5. /*                                                                 */
  6. /*                       copyright Babe Cool                       */
  7. /*                                                                 */
  8. /*                                                                 */
  9. /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
  10. /*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
  11.  
  12. #include "genpari.h"
  13.  
  14. GEN seq(), expr(), exprcomp(), expradd(), terme(), facteur();
  15. GEN truc(), identifier(), constante();
  16. void skipseq(), skipexpr(), skipexprcomp(), skipexpradd(), skipterme();
  17. void skipfacteur(), skiptruc(), skipconstante(), skipidentifier();
  18. entree *findentry(), *skipentry();
  19.  
  20. static char *analyseurs,*labellist[100];
  21. static long analyseurtetpil;
  22.  
  23. GEN lisexpr(t)
  24.      char *t;
  25.      
  26. {
  27.   GEN res;
  28.   long av, oldtetpil = analyseurtetpil;
  29.   char *olds = analyseurs;
  30.   analyseurs = t; analyseurtetpil = av = avma;
  31.   res = expr();
  32.   res = gerepile(av, analyseurtetpil, res);      
  33.   analyseurtetpil = oldtetpil; analyseurs = olds;
  34.   return res;
  35. }
  36.  
  37. GEN readexpr(c)
  38.      char **c;
  39. {
  40.   char *olds = analyseurs, *oldc = *c;
  41.   analyseurs = oldc; skipexpr();
  42.   if ((*analyseurs) && !separe(*analyseurs)) err(caracer1, analyseurs);
  43.   *c = analyseurs; analyseurs = olds;
  44.   return lisexpr(oldc);
  45. }
  46.  
  47. GEN lisseq(t)
  48.      char *t;
  49. {
  50.   GEN res;
  51.   long av, oldtetpil = analyseurtetpil;
  52.   char *olds = analyseurs;
  53.   analyseurs = t; analyseurtetpil = av = avma;
  54.   res = seq();
  55.   res = gerepile(av, analyseurtetpil, res);      
  56.   analyseurtetpil = oldtetpil; analyseurs = olds;
  57.   return res;
  58. }
  59.  
  60. GEN readseq(c)
  61.      char **c;
  62. {
  63.   long i;
  64.   char *olds = analyseurs, *oldc = *c;
  65.   for(i=0;i<100;i++) labellist[i]=(char*)0;
  66.   analyseurs = oldc; skipseq();
  67.   *c = analyseurs; analyseurs = olds;
  68.   return lisseq(oldc);
  69. }
  70.  
  71. entree fonctions[]={
  72.   {"O",50,0,0},
  73.   {"abs",1,(void *)gabs,0},
  74.   {"acos",1,(void *)gacos,0},
  75.   {"acosh",1,(void *)gach,0},
  76.   {"addell",3,(void *)addell,0},
  77.   {"adj",1,(void *)adj,0},
  78.   {"agm",2,(void *)agm,0},
  79.   {"akell",2,(void *)akell,0},
  80.   {"algdep",23,(void *)algdep,0},
  81.   {"algdep2",33,(void *)algdep2,0},
  82.   {"anell",23,(void *)anell,0},
  83.   {"apell",2,(void *)apell,0},
  84.   {"apell2",2,(void *)apell2,0},
  85.   {"apprpadic",2,(void *)apprgen9,0},
  86.   {"arg",1,(void *)garg,0},
  87.   {"asin",1,(void *)gasin,0},
  88.   {"asinh",1,(void *)gash,0},
  89.   {"assmat",1,(void *)assmat,0},
  90.   {"atan",1,(void *)gatan,0},
  91.   {"atanh",1,(void *)gath,0},
  92.   {"base",13,(void *)base,0},
  93.   {"bernreal",11,(void *)bernreal,0},
  94.   {"bernvec",11,(void *)bernvec,0},
  95.   {"bezout",2,(void *)vecbezout,0},
  96.   {"bigomega",1,(void *)gbigomega,0},
  97.   {"bin",21,(void *)binome,0},
  98.   {"binary",1,(void *)binaire,0},
  99.   {"bittest",2,(void *)gbittest,0},
  100.   {"boundcf",21,(void *)gboundcf,0},
  101.   {"boundfact",21,(void *)boundfact,0},
  102.   {"box",59,(void *)rectbox,0},
  103.   {"buchimag",3,(void *)buchimag,0},
  104.   {"buchreal",4,(void *)buchreal,0},
  105.   {"ceil",1,(void *)gceil,0},
  106.   {"centerlift",1,(void *)centerlift,0},
  107.   {"cf",1,(void *)gcf,0},
  108.   {"cf2",2,(void *)gcf2,0},
  109.   {"changevar",2,(void *)changevar,0},
  110.   {"char",14,(void *)caradj0,0},
  111.   {"char1",14,(void *)caract,0},
  112.   {"char2",14,(void *)carhess,0},
  113.   {"chell",2,(void *)coordch,0},
  114.   {"chinese",2,(void *)chinois,0},
  115.   {"chptell",2,(void *)pointch,0},
  116.   {"classno",1,(void *)classno,0},
  117.   {"classno2",1,(void *)classno2,0},
  118.   {"coeff",21,(void *)truecoeff,0},
  119.   {"compo",21,(void *)compo,0},
  120.   {"compose",2,(void *)compose,0},
  121.   {"comprealraw",2,(void *)comprealraw,0},
  122.   {"concat",2,(void *)concat,0},
  123.   {"conj",1,(void *)gconj,0},
  124.   {"content",1,(void *)content,0},
  125.   {"convol",2,(void *)convol,0},
  126.   {"cos",1,(void *)gcos,0},
  127.   {"cosh",1,(void *)gch,0},
  128.   {"cursor",11,(void*)rectcursor,0},
  129.   {"cvtoi",13,(void *)gcvtoi,0},
  130.   {"cyclo",11,(void *)cyclo,0},
  131.   {"denom",1,(void *)denom,0},
  132.   {"deriv",14,(void *)deriv,0},
  133.   {"det",1,(void *)det,0},
  134.   {"det2",1,(void *)det2,0},
  135.   {"detr",1,(void *)detreel,0},
  136.   {"dilog",1,(void *)dilog,0},
  137.   {"disc",1,(void *)discsr,0},
  138.   {"discf",1,(void *)discf,0},
  139.   {"divisors",1,(void *)divisors,0},
  140.   {"divres",2,(void *)gdiventres,0},
  141.   {"divsum",22,(void *)divsomme,0},
  142.   {"draw",1,(void*)rectdraw,0},
  143.   {"eigen",1,(void *)eigen,0},
  144.   {"eint1",1,(void *)eint1,0},
  145.   {"erfc",1,(void *)gerfc,0},
  146.   {"eta",1,(void *)eta,0},
  147.   {"euler",0,(void *)mpeuler,0},
  148.   {"eval",1,(void *)geval,0},
  149.   {"exp",1,(void *)gexp,0},
  150.   {"extract",2,(void *)extract,0},
  151.   {"fact",11,(void *)mpfactr,0},
  152.   {"factfq",3,(void *)factmod9,0},
  153.   {"factmod",2,(void *)factmod,0},
  154.   {"factor",1,(void *)factor,0},
  155.   {"factoredbase",28,(void *)factoredbase,0},
  156.   {"factoreddiscf",2,(void *)factoreddiscf,0},
  157.   {"factoredpolred",2,(void *)factoredpolred,0},
  158.   {"factoredpolred2",2,(void *)factoredpolred2,0},
  159.   {"factornf",2,(void *)polfnf,0},
  160.   {"factorpadic",32,(void *)factorpadic,0},
  161.   {"factpol",21,(void *)factpol,0},
  162.   {"factpol2",21,(void *)factpol2,0},
  163.   {"fibo",11,(void *)fibo,0},
  164.   {"floor",1,(void *)gfloor,0},
  165.   {"for",83,(void *)forpari,0},
  166.   {"fordiv",84,(void *)fordiv,0},
  167.   {"forprime",83,(void *)forprime,0},
  168.   {"forstep",86,(void *)forstep,0},
  169.   {"frac",1,(void *)gfrac,0},
  170.   {"galois",1,(void *)galois,0},
  171.   {"galoisconj",1,(void *)galoisconj,0},
  172.   {"gamh",1,(void *)ggamd,0},
  173.   {"gamma",1,(void *)ggamma,0},
  174.   {"gauss",2,(void *)gauss,0},
  175.   {"gcd",2,(void *)ggcd,0},
  176.   {"globalred",1,(void *)globalreduction,0},
  177.   {"goto",61,0,0},
  178.   {"hclassno",1,(void *)classno3,0},
  179.   {"hell",2,(void *)ghell,0},
  180.   {"hell2",2,(void *)ghell2,0},
  181.   {"hell3",2,(void *)ghell3,0},
  182.   {"hermite",1,(void *)hnf,0},
  183.   {"hess",1,(void *)hess,0},
  184.   {"hilb",30,(void *) hil,0},
  185.   {"hilbert",11,(void *)hilb,0},
  186.   {"hilbp",20,(void *) hil,0},
  187.   {"hvector",22,(void *)vecteur,0},
  188.   {"hyperu",3,(void *)hyperu,0},
  189.   {"i",0,(void *)geni,0},
  190.   {"idmat",11,(void *)idmat,0},
  191.   {"if",80,0,0},
  192.   {"imag",1,(void *)gimag,0},
  193.   {"image",1,(void *)image,0},
  194.   {"image2",1,(void *)image2,0},
  195.   {"incgam",2,(void *)incgam,0},
  196.   {"incgam1",2,(void *)incgam1,0},
  197.   {"incgam2",2,(void *)incgam2,0},
  198.   {"incgam3",2,(void *)incgam3,0},
  199.   {"incgam4",3,(void *)incgam4,0},
  200.   {"indexrank",1,(void *)indexrank,0},
  201.   {"indsort",1,(void *)indexsort,0},
  202.   {"initalg",1,(void *)initalg,0},
  203.   {"initell",1,(void *)initell,0},
  204.   {"initell2",1,(void *)initell2,0},
  205.   {"initrect",34,(void*)initrect,0},
  206.   {"integ",14,(void *)integ,0},
  207.   {"intersect",2,(void *)intersect,0},
  208.   {"intgen",37,(void *)rombint,0},
  209.   {"intinf",37,(void *)qromi,0},
  210.   {"intnum",37,(void *)qromb,0},
  211.   {"intopen",37,(void *)qromo,0},
  212.   {"inverseimage",2,(void *)inverseimage,0},
  213.   {"isfund",1,(void *)gisfundamental,0},
  214.   {"isincl",2,(void *)nfincl,0},
  215.   {"isisom",2,(void *)nfiso,0},
  216.   {"isoncurve",20,(void *)oncurve,0},
  217.   {"isprime",1,(void *)gisprime,0},
  218.   {"ispsp",1,(void *)gispsp,0},
  219.   {"isqrt",1,(void *)racine,0},
  220.   {"issqfree",1,(void *)gissquarefree,0},
  221.   {"issquare",1,(void *)gcarreparfait,0},
  222.   {"jacobi",1,(void *)jacobi,0},
  223.   {"jbesselh",2,(void *)jbesselh,0},
  224.   {"jell",1,(void *)jell,0},
  225.   {"karamul",32,(void *)karamul,0},
  226.   {"kbessel",2,(void *)kbessel,0},
  227.   {"kbessel2",2,(void *)kbessel2,0},
  228.   {"ker",1,(void *)ker,0},
  229.   {"keri",1,(void *)keri,0},
  230.   {"kerint",1,(void *)kerint,0},
  231.   {"kerint1",1,(void *)kerint1,0},
  232.   {"kerint2",1,(void *)kerint2,0},
  233.   {"kerr",1,(void *)kerreel,0},
  234.   {"kill",85,0,0},
  235.   {"killrect",11,(void *)killrect,0},
  236.   {"kro",2,(void *)gkronecker,0},
  237.   {"label",60,0,0},
  238.   {"laplace",1,(void *)laplace,0},
  239.   {"lcm",2,(void *)glcm,0},
  240.   {"legendre",11,(void *)legendre,0},
  241.   {"length",1,(void *)glength,0},
  242.   {"lex",20,(void *)lexcmp,0},
  243.   {"lexsort",1,(void *)lexsort,0},
  244.   {"lift",1,(void *)lift,0},
  245.   {"lindep",1,(void *)lindep,0},
  246.   {"lindep2",23,(void *)lindep2,0},
  247.   {"line",59,(void *)rectline,0},
  248.   {"lines",35,(void *)rectlines,0},
  249.   {"lll",1,(void *)lll,0},
  250.   {"lll1",1,(void *)lll1,0},
  251.   {"lllgen",1,(void *)lllgen,0},
  252.   {"lllgram",1,(void *)lllgram,0},
  253.   {"lllgram1",1,(void *)lllgram1,0},
  254.   {"lllgramgen",1,(void *)lllgramgen,0},
  255.   {"lllgramint",1,(void *)lllgramint,0},
  256.   {"lllgramkerim",1,(void *)lllgramkerim,0},
  257.   {"lllgramkerimgen",1,(void *)lllgramkerimgen,0},
  258.   {"lllint",1,(void *)lllint,0},
  259.   {"lllkerim",1,(void *)lllkerim,0},
  260.   {"lllkerimgen",1,(void *)lllkerimgen,0},
  261.   {"lllrat",1,(void *)lllrat,0},
  262.   {"ln",1,(void *)glog,0},
  263.   {"lngamma",1,(void *)glngamma,0},
  264.   {"localred",2,(void *)localreduction,0},
  265.   {"log",1,(void *)glog,0},
  266.   {"logagm",1,(void *)glogagm,0},
  267.   {"lseriesell",4,(void *)lseriesell,0},
  268.   {"mat",1,(void *)gtomat,0},
  269.   {"matell",2,(void *)matell,0},
  270.   {"matextract",3,(void *)matextract,0},
  271.   {"matinvr",1,(void *)invmatreel,0},
  272.   {"matsize",1,(void *)matsize,0},
  273.   {"matrix",49,(void *)matrice,0},
  274.   {"matrixqz",2,(void *)matrixqz,0},
  275.   {"matrixqz2",1,(void *)matrixqz2,0},
  276.   {"matrixqz3",1,(void *)matrixqz3,0},
  277.   {"max",2,(void *)gmax,0},
  278.   {"min",2,(void *)gmin,0},
  279.   {"minim",33,(void *)minim,0},
  280.   {"mod",25,(void *)gmodulcp,0},
  281.   {"modp",25,(void *)gmodulo,0},
  282.   {"modreverse",1,(void *)polymodrecip,0},
  283.   {"move",34,(void*)rectmove,0},
  284.   {"mu",1,(void *)gmu,0},
  285.   {"newtonpoly",2,(void *)newtonpoly,0},
  286.   {"nextprime",1,(void *)bigprem,0},
  287.   {"norm",1,(void *)gnorm,0},
  288.   {"norml2",1,(void *)gnorml2,0},
  289.   {"nucomp",3,(void *)nucomp,0},
  290.   {"numdiv",1,(void *)numbdiv,0},
  291.   {"numer",1,(void *)numer,0},
  292.   {"nupow",2,(void *)nupow,0},
  293.   {"o",50,0,0},
  294.   {"omega",1,(void *)gomega,0},
  295.   {"ordell",2,(void *)ordell,0},
  296.   {"order",1,(void *)order,0},
  297.   {"ordred",1,(void *)ordred,0},
  298.   {"pascal",11,(void *)pasc,0},
  299.   {"permutation",24,(void *)permute,0},
  300.   {"pf",2,(void *)primeform,0},
  301.   {"phi",1,(void *)phi,0},
  302.   {"pi",0,(void *)mppi,0},
  303.   {"plot",37,(void *)plot,0},
  304.   {"ploth",37,(void *)ploth,0},
  305.   {"ploth2",37,(void *)ploth2,0},
  306.   {"plothraw",2,(void *)plothraw,0},
  307.   {"pnqn",1,(void *)pnqn,0},
  308.   {"point",34,(void *)rectpoint,0},
  309.   {"pointell",2,(void *)pointell,0},
  310.   {"points",35,(void *)rectpoints,0},
  311.   {"polint",31,(void *)polint,0},
  312.   {"polred",1,(void *)polred,0},
  313.   {"polred2",1,(void *)polred2,0},
  314.   {"polsym",21,(void *)polsym,0},
  315.   {"poly",14,(void *)gtopoly,0},
  316.   {"polylog",24,(void *)gpolylog,0},
  317.   {"polylogd",24,(void *)polylogd,0},
  318.   {"polylogdold",24,(void *)polylogdold,0},
  319.   {"polylogp",24,(void *)polylogp,0},
  320.   {"polyrev",14,(void *)gtopolyrev,0},
  321.   {"postdraw",1,(void *)postdraw,0},
  322.   {"postploth",37,(void *)postploth,0},
  323.   {"postploth2",37,(void *)postploth2,0},
  324.   {"postplothraw",2,(void *)postplothraw,0},
  325.   {"powell",3,(void *)powell,0},
  326.   {"powrealraw",23,(void *)powrealraw,0},
  327.   {"pprint",54,0,0},
  328.   {"pprint1",52,0,0},
  329.   {"prec",21,(void *)gprec,0},
  330.   {"prime",11,(void *)prime,0},
  331.   {"primes",11,(void *)primes,0},
  332.   {"primroot",1,(void *)gener,0},
  333.   {"print",53,0,0},
  334.   {"print1",51,0,0},
  335.   {"prod",48,(void *)produit,0},
  336.   {"prodeuler",37,(void *)prodeuler,0},
  337.   {"prodinf",27,(void *)prodinf,0},
  338.   {"prodinf1",27,(void *)prodinf1,0},
  339.   {"psi",1,(void *)gpsi,0},
  340.   {"qfi",3,(void *)qfi,0},
  341.   {"qfr",4,(void *)qfr,0},
  342.   {"quadgen",1,(void *)quadgen,0},   
  343.   {"quadpoly",1,(void *)quadpoly,0},   
  344.   {"random",0,(void *)genrand,0},
  345.   {"rank",10,(void *)rank,0},
  346.   {"rbox",34,(void *)rectrbox,0},      
  347.   {"read",56,0,0},
  348.   {"real",1,(void *)greal,0},
  349.   {"recip",1,(void *)polrecip,0},      
  350.   {"redcomp",1,(void *)redcomp,0},      
  351.   {"redreal",1,(void *)redreal,0},      
  352.   {"redrealnod",2,(void *)redrealnod,0},      
  353.   {"regula",1,(void *)regula,0}, 
  354.   {"reorder",1,(void *)reorder,0}, 
  355.   {"resultant",2,(void *)subres,0},    
  356.   {"resultant2",2,(void *)resultant2,0},    
  357.   {"reverse",1,(void *)recip,0}, 
  358.   {"rhoreal",1,(void *)rhoreal,0},      
  359.   {"rhorealnod",2,(void *)rhorealnod,0},      
  360.   {"rline",34,(void *)rectrline,0},      
  361.   {"rmove",34,(void *)rectrmove,0},      
  362.   {"rndtoi",13,(void *)grndtoi,0},
  363.   {"rootmod",2,(void *)rootmod,0},
  364.   {"rootmod2",2,(void *)rootmod2,0},
  365.   {"rootpadic",32,(void *)rootpadic,0},
  366.   {"roots",1,(void *)roots,0},
  367.   {"rootslong",1,(void *)rootslong,0},
  368.   {"rootsof1",10,(void *)rootsof1,0},
  369.   {"round",1,(void *)ground,0},
  370.   {"rounderror",10,(void *)rounderror,0},
  371.   {"rpoint",34,(void *)rectrpoint,0},      
  372.   {"series",14,(void *)gtoser,0},
  373.   {"setprecision",15,(void *)setprecr,0},
  374.   {"setserieslength",15,(void *)setserieslength,0},
  375.   {"shift",21,(void *)gshift,0},
  376.   {"shiftmul",21,(void *)gmul2n,0},
  377.   {"sigma",1,(void *)sumdiv,0},
  378.   {"sigmak",24,(void *)sumdivk,0},
  379.   {"sign",10,(void *)gsigne,0},
  380.   {"signat",1,(void *)signat,0},
  381.   {"simplify",1,(void *)simplify,0},
  382.   {"sin",1,(void *)gsin,0},
  383.   {"sinh",1,(void *)gsh,0},
  384.   {"size",10,(void *)gsize,0},
  385.   {"smallbase",13,(void *)smallbase,0},
  386.   {"smalldiscf",1,(void *)smalldiscf,0},
  387.   {"smallfact",1,(void *)smallfact,0},
  388.   {"smallinitell",1,(void *)smallinitell,0},
  389.   {"smallpolred",1,(void *)smallpolred,0},
  390.   {"smallpolred2",1,(void *)smallpolred2,0},
  391.   {"smith",1,(void *)smith,0},
  392.   {"smith2",1,(void *)smith2,0},
  393.   {"solve",37,(void *)zbrent,0},
  394.   {"sort",1,(void *)sort,0},
  395.   {"sqr",1,(void *)gsqr,0},
  396.   {"sqred",1,(void *)sqred,0},
  397.   {"sqrt",1,(void *)gsqrt,0},
  398.   {"srgcd",2,(void *)srgcd,0},
  399.   {"string",57,(void*)rectstring,0},
  400.   {"sturm",10,(void *)sturm,0},
  401.   {"sturmpart",30,(void *)sturmpart,0},
  402.   {"subell",3,(void *)subell,0},
  403.   {"subst",26,(void *)gsubst,0},
  404.   {"sum",48,(void *)somme,0},
  405.   {"sumalt",27,(void *)sumalt,0},
  406.   {"suminf",27,(void *)suminf,0},
  407.   {"sumpos",27,(void *)sumpos,0},
  408.   {"supplement",1,(void *)suppl,0},
  409.   {"tan",1,(void *)gtan,0},
  410.   {"tanh",1,(void *)gth,0},
  411.   {"taylor",12,(void *)tayl,0},
  412.   {"tchebi",11,(void *)tchebi,0},
  413.   {"tchirnhausen",1,(void *)tchirnhausen,0},
  414.   {"teich",1,(void *)teich,0},
  415.   {"texprint",55,0,0},
  416.   {"theta",2,(void *)theta,0},
  417.   {"thetanullk",21,(void *)thetanullk,0},
  418.   {"trace",1,(void *)trace,0},
  419.   {"trans",1,(void *)gtrans,0},
  420.   {"trunc",1,(void *)gtrunc,0},
  421.   {"type",1,(void *)gtype,0},
  422.   {"unit",1,(void *)fundunit,0},
  423.   {"until",82,0,0},
  424.   {"valuation",20,(void *)ggval,0},
  425.   {"vec",1,(void *)gtovec,0},
  426.   {"vecsort",21,(void *)vecsort,0},
  427.   {"vector",22,(void *)vecteur,0},
  428.   {"vvector",22,(void *)vvecteur,0},
  429.   {"wf",1,(void *)wf,0},
  430.   {"wf2",1,(void *)wf2,0},
  431.   {"while",81,0,0},
  432.   {"zell",2,(void *)zell,0},
  433.   {"zeta",1,(void *)gzeta,0},
  434.   {"zzzz",1,(void *)kerint2,0}
  435. };
  436.  
  437. long    NUMFUNC=sizeof(fonctions)/sizeof(entree);
  438.  
  439. static void matcherr(c)
  440.      char c;
  441. {
  442.   static char reste[100];
  443.   char *p;
  444.   long i;
  445.   
  446.   for(analyseurs--, p=reste, *p++=c, i=0; i<97; i++) *p++ = *analyseurs++;
  447.   *p = 0;err(matcher1,reste);
  448. }
  449.  
  450. #define match(c)  if(*analyseurs++ != c) matcherr(c)
  451.  
  452. GEN seq()
  453.      
  454. {
  455.   GEN res=gnil;
  456.   for(;;)
  457.     {
  458.       while(separe(*analyseurs)) analyseurs++;
  459.       if ((!*analyseurs) || (*analyseurs == ')') || (*analyseurs == ',')) return res;
  460.       res = expr();
  461.       if(!separe(*analyseurs)) return res;
  462.     }
  463. }
  464.  
  465. GEN expr()
  466. {
  467.   GEN (*func[4]) (),aux,e,e1,e2,e3;
  468.   long niveau;
  469.   
  470.   for(niveau=0;niveau<4;niveau++) func[niveau]=NULL;
  471.   e1=e2=e3=(GEN)0;
  472.   niveau=3;
  473.   for(;;)
  474.     switch(niveau)
  475.       {
  476.       case 3: aux=facteur();
  477.         if(func[3]) {analyseurtetpil=avma;e3=func[3](e3,aux);}
  478.         else e3=aux;
  479.         switch(*analyseurs)
  480.       {
  481.           case '*': analyseurs++;func[3]=gmul;break;
  482.           case '/': analyseurs++;func[3]=gdiv;break;
  483.           case '\\': analyseurs++;func[3]=gdivent;break;
  484.           case '%': analyseurs++;func[3]=gmod;break;
  485.           default: niveau--;func[3]=NULL;
  486.       }
  487.         break;
  488.       case 2: 
  489.         if(!e3) {niveau++;break;}
  490.         if(func[2]) {analyseurtetpil=avma;e2=func[2](e2,e3);}
  491.         else e2=e3;
  492.         e3=(GEN)0;
  493.         switch(*analyseurs)
  494.       {
  495.           case '+': analyseurs++;func[2]=gadd;niveau++;break;
  496.           case '-': analyseurs++;func[2]=gsub;niveau++;break;
  497.           default: niveau--;func[2]=NULL;
  498.       }
  499.         break;
  500.       case 1: 
  501.         if(!e2) {niveau++;break;}
  502.         if(func[1]) {analyseurtetpil=avma;e1=func[1](e1,e2);}
  503.         else e1=e2;
  504.         e2=(GEN)0;
  505.         switch(*analyseurs)
  506.       {
  507.           case '<': analyseurs++;
  508.             switch(*analyseurs)
  509.           {
  510.               case '=': analyseurs++;func[1]=gle;break;
  511.               case '>': analyseurs++;func[1]=gne;break;
  512.         default : func[1]=glt;
  513.           }
  514.             niveau++;break;
  515.           case '>': analyseurs++;
  516.             if((*analyseurs)=='=') {analyseurs++;func[1]=gge;}
  517.             else func[1]=ggt;
  518.             niveau++;break;
  519.           case '=': 
  520.             if((analyseurs[1])=='=') {analyseurs+=2;func[1]=geq;niveau++;}
  521.             break;
  522.           case '!': 
  523.             if((analyseurs[1])=='=') {analyseurs+=2;func[1]=gne;niveau++;}
  524.             break;
  525.           default: niveau--;func[1]=NULL;
  526.       }
  527.         break;
  528.       case 0: 
  529.         if(!e1) {niveau++;break;}
  530.         if(func[0]) {analyseurtetpil=avma;e=func[0](e,e1);}
  531.         else e=e1;
  532.         e1=(GEN)0;
  533.         switch(*analyseurs)
  534.       {
  535.           case '&': analyseurs++;if(*analyseurs=='&') analyseurs++;func[0]=gand;niveau++;break;
  536.           case '|': analyseurs++;if(*analyseurs=='|') analyseurs++;func[0]=gor;niveau++;break;
  537.           default: return e;
  538.       }
  539.       }
  540. }
  541.  
  542. GEN facteur()
  543. {
  544.   GEN tru,p1,arg,arg1;
  545.   long tx,c,e,av2,flcol,flrow;
  546.   long plus = (*analyseurs =='+')||(*analyseurs =='-')?(*analyseurs++=='+'):1;
  547.   tru=truc();
  548.   for (;;) switch(*analyseurs)
  549.     {
  550.     case '^': analyseurs++;p1=facteur();analyseurtetpil=avma; tru=gpui(tru,p1,prec);break;
  551.     case '~': analyseurs++;analyseurtetpil=avma;tru=gtrans(tru);break;
  552.     case '_': analyseurs++;analyseurtetpil=avma;tru=gconj(tru);break;
  553.     case '\'': analyseurs++;analyseurtetpil=avma;tru=deriv(tru,gvar9(tru));break;
  554.     case '[': 
  555.       tx=typ(p1=tru);
  556.       if((tx<17)||(tx>19)) err(caracer1,analyseurs);
  557.       analyseurs++;av2=avma;flcol=flrow=0;
  558.       if(tx<19)
  559.     {
  560.       arg=expr();if(typ(arg)!=1) err(caseer);
  561.       c=itos(arg);if((c<1)||(c>=lg(p1))) err(arrayer1);
  562.     }
  563.       else
  564.     {
  565.       if(lg(p1)==1) err(arrayer1);
  566.       if(*analyseurs==',')
  567.         {
  568.           analyseurs++;arg=expr();if(typ(arg)!=1) err(caseer);
  569.           c=itos(arg);if((c<1)||(c>=lg(p1))) err(arrayer1);
  570.           flcol=1;
  571.         }
  572.       else
  573.         {
  574.           arg=expr();if(typ(arg)!=1) err(caseer);
  575.           e=itos(arg);if((e<1)||(e>=lg(p1[1]))) err(arrayer1);
  576.           match(',');
  577.           if(*analyseurs==']') flrow=1;
  578.           else
  579.         {
  580.           arg1=expr();if(typ(arg1)!=1) err(caseer);
  581.           c=itos(arg1);
  582.           if((c<1)||(c>=lg(p1))) err(arrayer1);
  583.         }
  584.         }
  585.     }
  586.       match(']'); analyseurtetpil=avma=av2;
  587.       if((tx<19)||flcol) tru=gcopy(p1[c]);
  588.       else
  589.     {
  590.       if(flrow)
  591.         {
  592.           tru=cgetg(lg(p1),17);
  593.           for(c=1;c<lg(p1);c++) tru[c]=lcopy(((GEN)p1[c])[e]);
  594.         }
  595.       else tru = gcopy(((GEN)p1[c])[e]);
  596.     }
  597.       break;
  598.     case '!': analyseurs++;if((*analyseurs)!='=') {analyseurtetpil=avma;tru=mpfact(itos(tru));break;} else analyseurs--;
  599.     default: if(plus) return tru; else {analyseurtetpil=avma;return gneg(tru);}
  600.     }
  601. }
  602.  
  603. GEN truc()
  604. {
  605.   long i,n=0,j,p=0,m=1;
  606.   GEN *table,p1;
  607.   
  608.   if (isalpha(*analyseurs)) return identifier();
  609.   if (isdigit(*analyseurs) || (*analyseurs=='.')) return constante();
  610.   switch(*analyseurs++)
  611.     {
  612.     case '(': p1=expr();match(')');return p1;
  613.     case '[':
  614.       table = (GEN *)newbloc(paribuffsize>>1);
  615.       if (*analyseurs!=']') 
  616.     {do table[++n]=expr();while (*analyseurs++==',');analyseurs--;}
  617.       switch (*analyseurs++)
  618.     {
  619.         case ']': analyseurtetpil=avma;p1=cgetg(n+1,17);
  620.           for (i=1;i<=n;i++) p1[i]=lcopy(table[i]);
  621.           break;
  622.         case ';': m=n;do table[++n]=expr();while (*analyseurs++!=']');
  623.           if (n % m) err(recter1);
  624.           p=n/m;analyseurtetpil=avma;p1=cgetg(m+1,19);
  625.           for (i=1;i<=m;i++) p1[i]=(long)cgetg(p+1,18);
  626.           for (j=1;j<=m;j++)
  627.             for(i=1;i<=p;i++)
  628.               ((GEN)p1[j])[i]=lcopy(table[(i-1)*m+j]);
  629.           break;
  630.         default: err(vectmater1);
  631.     }
  632.       killbloc((GEN)table);
  633.       return p1;
  634.     case '%':
  635.       p=0;while((*analyseurs)=='`') {analyseurs++;p++;}
  636.       if(p>tglobal) err(referer1);
  637.       if(p) return g[tglobal-p];
  638.       while (isdigit(*analyseurs)) p = 10*p + *analyseurs++ - '0';
  639.       if(p>tglobal) err(referer2);
  640.       return g[p];
  641.     }
  642.   err(caracer1,analyseurs-1);
  643. }
  644.  
  645. int numvar(x)
  646.      GEN x;
  647. {
  648.   if(typ(x)!=10) err(numvarer);
  649.   if(lgef(x)!=4) err(numvarer);
  650.   if((!gcmp0(x[2])) || (!gcmp1(x[3]))) err(numvarer);
  651.   return varn(x);
  652. }
  653.  
  654.  
  655. GEN identifier()
  656. {
  657.   long c,e,va,m,nparam,i,av,av2,tx,flrow,flcol;
  658.   static long yatileugoto;
  659.   GEN arg,arg1,arg2,arg3,arg4,res=gnil,(*f)(),p1;
  660.   char *ch1, *ch2, *readbuffer;
  661.   entree *ep, *ep1, **p;
  662.   
  663.   ep = findentry();
  664.   if (ep->valence < 100) /* fonctions predefinies */
  665.     {
  666.       f = (GEN (*)())ep->value;
  667.       if (!ep->valence && (*analyseurs != '(')) return (*f)(prec);
  668.       match('(');
  669.       switch(ep->valence)
  670.     {
  671.     case 0: res=(*f)(prec);break;
  672.     case 1: arg=expr();analyseurtetpil=avma;
  673.       res=(*f)(arg,prec);break;
  674.     case 2: arg=expr();match(',');arg1=expr();
  675.       analyseurtetpil=avma;res=(*f)(arg,arg1,prec);break;
  676.     case 3: arg=expr();match(',');arg1=expr();
  677.       match(',');arg2=expr();analyseurtetpil=avma;
  678.       res=(*f)(arg,arg1,arg2,prec);break;
  679.     case 4: arg=expr();match(',');arg1=expr();
  680.       match(',');arg2=expr();match(',');arg3=expr();analyseurtetpil=avma;
  681.       res=(*f)(arg,arg1,arg2,arg3,prec);break;
  682.     case 10: p1=(*f)(expr());analyseurtetpil=avma;
  683.       res=stoi(p1);break;
  684.     case 11: arg=expr();if(typ(arg)!=1) err(caseer);
  685.       analyseurtetpil=avma;res=(*f)(itos(arg),prec);break;
  686.     case 12: arg=expr();match(',');arg1=expr();va=numvar(arg1);
  687.       analyseurtetpil=avma;res=(*f)(arg,va,precdl);break;
  688.     case 13: arg=expr();analyseurtetpil=avma;
  689.       res=(*f)(arg,&e);break;
  690.     case 14: arg=expr();match(',');arg1=expr();va=numvar(arg1);
  691.       analyseurtetpil=avma;res=(*f)(arg,va);break;
  692.     case 15: arg=expr();if(typ(arg)!=1) err(caseer);
  693.       analyseurtetpil=avma;res=stoi((*f)(itos(arg)));break;
  694.     case 20: arg=expr();match(',');
  695.       p1=(*f)(arg,expr());analyseurtetpil=avma;
  696.       res=stoi(p1);break;
  697.     case 21: arg=expr();match(',');arg1=expr();if(typ(arg1)!=1) err(caseer);
  698.       analyseurtetpil=avma;res=(*f)(arg,itos(arg1));break;
  699.     case 22: arg=expr();match(',');
  700.       if(!isalpha(*analyseurs)) err(varer1,analyseurs);
  701.       ep = findentry();if (ep->valence!=200) err(varer1,analyseurs);match(',');
  702.       analyseurtetpil=avma;
  703.       res=(*f)(ep,arg,analyseurs); skipexpr(); break;
  704.     case 23: arg=expr();match(',');arg1=expr();if(typ(arg1)!=1) err(caseer);
  705.       analyseurtetpil=avma;res=(*f)(arg,itos(arg1),prec);break;
  706.     case 24: arg=expr();if(typ(arg)!=1) err(caseer);
  707.       match(',');arg1=expr();analyseurtetpil=avma;
  708.       res=(*f)(itos(arg),arg1,prec);break;
  709.     case 25: arg=expr();match(',');arg1=expr();analyseurtetpil=avma;
  710.       res=(*f)(arg,arg1);break;
  711.     case 26: arg=expr();match(',');arg1=expr();
  712.       va=numvar(arg1);match(',');arg2=expr();
  713.       analyseurtetpil=avma;res=(*f)(arg,va,arg2);break;
  714.     case 27: if(!isalpha(*analyseurs)) err(varer1,analyseurs);
  715.       ep = findentry();match('='); if (ep->valence!=200) err(varer1,analyseurs);
  716.       arg=expr(); match(','); analyseurtetpil=avma;
  717.       res=(*f)(ep,arg,analyseurs,prec); skipexpr(); break;
  718.     case 28: arg=expr();match(',');arg1=expr();
  719.       analyseurtetpil=avma;res=(*f)(arg,arg1,&e);break;
  720.     case 29: arg=expr();match(',');arg1=expr();if(typ(arg1)!=1) err(caseer);
  721.       p1=(*f)(arg,itos(arg1));analyseurtetpil=avma;
  722.       res=stoi(p1);break;
  723.     case 30: arg=expr();match(',');arg1=expr();match(',');
  724.       p1=(*f)(arg,arg1,expr());analyseurtetpil=avma;
  725.       res=stoi(p1);break;
  726.     case 31: arg=expr();match(',');arg1=expr();match(',');
  727.       analyseurtetpil=avma;res=(*f)(arg,arg1,expr(),&arg2);cgiv(arg2);
  728.       break;
  729.     case 32: arg=expr();match(',');arg1=expr();match(',');arg2=expr();
  730.       if(typ(arg2)!=1) err(caseer);
  731.       analyseurtetpil=avma;res=(*f)(arg,arg1,itos(arg2));break;
  732.     case 33: arg=expr();match(',');arg1=expr();match(',');arg2=expr();
  733.       if((typ(arg2)!=1)||(typ(arg1)!=1)) err(caseer);
  734.       analyseurtetpil=avma;res=(*f)(arg,itos(arg1),itos(arg2),prec);break;
  735.     case 34: arg1=expr();match(',');arg2=expr();match(',');arg3=expr();
  736.       analyseurtetpil=avma;
  737.       res=(*f)(gtolong(arg1),gtolong(arg2),gtolong(arg3));
  738.       break;
  739.     case 35: arg=expr();match(',');arg1=expr();match(',');arg2=expr();
  740.       if(typ(arg)!=1) err(caseer);
  741.       analyseurtetpil=avma;res=(*f)(itos(arg),arg1,arg2);break;
  742.     case 37: if(!isalpha(*analyseurs)) err(varer1,analyseurs);
  743.       ep = findentry();match('='); if (ep->valence!=200) err(varer1,analyseurs);
  744.       arg=expr(); match(','); arg1=expr(); match(','); 
  745.       analyseurtetpil=avma;
  746.       res=(*f)(ep,arg,arg1,analyseurs,prec); skipexpr(); break;
  747.     case 48: arg=expr(); match(',');
  748.       if(!isalpha(*analyseurs)) err(varer1,analyseurs);
  749.       ep = findentry();match('='); if (ep->valence!=200) err(varer1,analyseurs);
  750.       arg1=expr(); match(','); arg2=expr(); match(',');
  751.       analyseurtetpil=avma;
  752.       res=(*f)(ep,arg,arg1,arg2,analyseurs,prec); skipexpr(); break;
  753.     case 49: arg=expr();match(','); arg1=expr(); match(',');
  754.       if(!isalpha(*analyseurs)) err(varer1,analyseurs);
  755.       ep = findentry();if (ep->valence!=200) err(varer1,analyseurs);match(',');
  756.       if(!isalpha(*analyseurs)) err(varer1,analyseurs);
  757.       ep1 = findentry();if (ep1->valence!=200) err(varer1,analyseurs);match(',');
  758.       analyseurtetpil=avma;
  759.       res=(*f)(ep,ep1,arg,arg1,analyseurs); skipexpr(); break;
  760.     case 50: p1=truc();
  761.       if (*analyseurs++=='^') 
  762.         {
  763.           arg=facteur();if(typ(arg)!=1) err(caseer);
  764.           e=itos(arg);
  765.         }
  766.       else {e = 1; analyseurs--;}
  767.       analyseurtetpil=avma; res = ggrando(p1,e); break;
  768.     case 51: case 52: case 53: case 54: case 55:
  769.       if (*analyseurs != ')') for(;;)
  770.         {
  771.           if (*analyseurs == '"')
  772.         {
  773.           analyseurs++;
  774.           while ((*analyseurs)&&(*analyseurs!='"')) pariputc(*analyseurs++);
  775.           match('"');
  776.         }
  777.           else
  778.         {
  779.           analyseurtetpil=avma;
  780.           if (ep->valence == 55) f = (GEN (*)()) texe;
  781.           else if(ep->valence&1) f = (GEN (*)()) brute;else f = (GEN (*)()) sor;
  782.           (*f)(res=expr(),glbfmt[0],glbfmt[2],glbfmt[1]);
  783.         }
  784.           if (*analyseurs == ')') break;
  785.           match(',');
  786.         }
  787.       if (ep->valence>52) pariputc('\n'); 
  788.       fflush(outfile); if (logfile) fflush(logfile); break;
  789.     case 56: 
  790.       readbuffer = (char *)newbloc(paribuffsize>>2);
  791.       while(!fgets(readbuffer, paribuffsize, infile)) switchin(NULL);
  792.       if (pariecho) pariputs(readbuffer);
  793.       else if (logfile) fputs(readbuffer, logfile);
  794.       res=lisseq(readbuffer);killbloc((GEN)readbuffer);break;
  795.     case 57:
  796.       arg=expr();if(typ(arg)!=1) err(caseer);
  797.       match(',');
  798.       if(*analyseurs!='"') arg1=expr();
  799.       else
  800.         {
  801.           match('"');ch1=(char*)malloc(256);m=0;
  802.           while ((m<256)&&(*analyseurs)&&(*analyseurs!='"'))
  803.         ch1[m++]=*analyseurs++;
  804.           match('"');arg1=cgetg(m+1,17);
  805.           for(i=1;i<=m;i++) arg1[i]=lstoi((long)ch1[i-1]);
  806.           free(ch1);
  807.         }
  808.       analyseurtetpil=avma;res=(*f)(itos(arg),arg1);
  809.       break;
  810.     case 59: arg=expr();match(',');arg1=expr();match(',');
  811.       arg2=expr();match(',');arg3=expr();match(',');arg4=expr();
  812.       analyseurtetpil=avma;
  813.       res=(*f)(gtolong(arg),gtolong(arg1),gtolong(arg2),gtolong(arg3),gtolong(arg4));
  814.       break;      
  815.     case 60: arg=expr();if(typ(arg)!=1) err(caseer);
  816.       m=itos(arg);if((m>=100)||(m<0)) err(labeler);
  817.       labellist[m]=analyseurs;break;
  818.     case 61: arg=expr();if(typ(arg)!=1) err(caseer);
  819.       m=itos(arg);if((m>=100)||(m<0)||(!labellist[m])) err(labeler);
  820.       analyseurs=labellist[m];yatileugoto=1;break;
  821.     case 80: av = avma; c=gcmp0(expr()); analyseurtetpil = avma = av; match(',');
  822.       if (c) {skipseq();match(',');res = seq();}
  823.       else 
  824.         {
  825.           yatileugoto=0;res = seq();
  826.           if(!yatileugoto) {match(',');skipseq();}
  827.         }
  828.       break;
  829.     case 81: analyseurtetpil = av = avma; ch1 = analyseurs;
  830.       while (!gcmp0(expr()))
  831.         {
  832.           analyseurtetpil = avma = av; match(',');
  833.           yatileugoto=0;seq();
  834.           if(!yatileugoto) analyseurs = ch1;else break;
  835.         }
  836.       if(!yatileugoto) {match(','); skipseq();}
  837.       break;
  838.     case 82: av = avma; ch1 = analyseurs;
  839.       skipexpr();
  840.       do 
  841.         {
  842.           analyseurtetpil = avma = av; match(','); 
  843.           yatileugoto=0;seq();
  844.           if(!yatileugoto) analyseurs = ch1;else break;
  845.         }
  846.       while (gcmp0(expr()));
  847.       if(!yatileugoto) {match(','); skipseq();}
  848.       break;
  849.     case 83: if(!isalpha(*analyseurs)) err(varer1,analyseurs);
  850.       ep = findentry();match('='); if (ep->valence!=200) err(varer1,analyseurs);
  851.       arg=expr(); match(','); arg1=expr(); match(','); 
  852.       analyseurtetpil=avma;
  853.       res=(*f)(ep,arg,arg1,analyseurs); skipseq(); break;
  854.     case 84: arg=expr();match(',');
  855.       if(!isalpha(*analyseurs)) err(varer1,analyseurs);
  856.       ep = findentry();if (ep->valence!=200) err(varer1,analyseurs);match(',');
  857.       analyseurtetpil=avma;
  858.       res=(*f)(ep,arg,analyseurs); skipseq(); break;
  859.     case 85: if(!isalpha(*analyseurs)) err(killer1);
  860.       ep = findentry(); if (ep->valence<100) err(killer1);
  861.       killvalue(ep);
  862.       if (ep->valence == 200) res = (GEN)ep->value;
  863.       else
  864.         {
  865.           for(i = 0; i<TBLSZ; i++)
  866.         if (hashtable[i] == ep) {hashtable[i] = ep->next; free(ep); break;}
  867.         else
  868.           for(ep1 = hashtable[i]; ep1; ep1 = ep1->next)
  869.             if (ep1->next == ep) {ep1->next = ep->next; free(ep); break;}
  870.         }
  871.       break;
  872.     case 86: if(!isalpha(*analyseurs)) err(varer1,analyseurs);
  873.       ep = findentry();match('='); if (ep->valence!=200) err(varer1,analyseurs);
  874.       arg=expr();match(',');arg1=expr();match(',');arg2=expr();match(',');
  875.       analyseurtetpil=avma;
  876.       res=(*f)(ep,arg,arg1,arg2,analyseurs); skipseq(); break;
  877.       
  878.     default: err(valencer1);
  879.     }
  880.       match(')');return res;
  881.     }
  882.   switch (ep->valence)
  883.     {
  884.     case 200: /* variables */
  885.       if((*analyseurs)=='[')
  886.     {
  887.       tx=typ(p1=(GEN)ep->value);
  888.       if((tx<17)||(tx>19)) err(caracer1,analyseurs);
  889.       analyseurs++;av2=avma;flcol=flrow=0;
  890.       if(tx<19)
  891.         {
  892.           arg=expr();if(typ(arg)!=1) err(caseer);
  893.           c=itos(arg);if((c<1)||(c>=lg(p1))) err(arrayer1);
  894.         }
  895.       else
  896.         {
  897.           if(lg(p1)==1) err(arrayer1);
  898.           if(*analyseurs==',')
  899.         {
  900.           analyseurs++;arg=expr();if(typ(arg)!=1) err(caseer);
  901.           c=itos(arg);if((c<1)||(c>=lg(p1))) err(arrayer1);
  902.           flcol=1;
  903.         }
  904.           else
  905.         {
  906.           arg=expr();if(typ(arg)!=1) err(caseer);
  907.           e=itos(arg);if((e<1)||(e>=lg(p1[1]))) err(arrayer1);
  908.           match(',');
  909.           if(*analyseurs==']') flrow=1;
  910.           else
  911.             {
  912.               arg1=expr();if(typ(arg1)!=1) err(caseer);
  913.               c=itos(arg1);
  914.               if((c<1)||(c>=lg(p1))) err(arrayer1);
  915.             }
  916.         }
  917.         }
  918.       match(']'); avma=av2;
  919.       if(((*analyseurs)=='=')&&(*(analyseurs+1)!='=')) 
  920.         {
  921.           analyseurs++;res=expr();
  922.           if((tx==19)&&(!flcol))
  923.         {
  924.           if(flrow)
  925.             {
  926.               if((typ(res)!=17)||(lg(res)!=lg(p1))) err(caseer2);
  927.               for(c=1;c<lg(p1);c++) ((GEN)p1[c])[e]=(long)res[c];
  928. /* maybe lcopy(res[c]) instead ? */
  929.             }
  930.           else ((GEN)p1[c])[e]=(long)res;
  931.         }
  932.           else 
  933.         {
  934.           if(flcol)
  935.             {
  936.               if((typ(res)!=18)||(lg(res)!=lg(p1[1]))) err(caseer2);
  937.             }
  938.           p1[c]=(long)res;
  939.         }
  940.           changevalue(ep, p1);p1=(GEN)ep->value;
  941.         }
  942.       analyseurtetpil=avma;
  943.       if((tx<19)||flcol) return (GEN)p1[c];
  944.       else
  945.         {
  946.           if(flrow) 
  947.         {
  948.           res=cgetg(lg(p1),17);
  949.           for(c=1;c<lg(p1);c++) res[c]=((GEN)p1[c])[e];
  950. /* maybe lcopy() instead */
  951.           return res;
  952.         }
  953.           else return (GEN)((GEN)p1[c])[e];
  954.         }
  955.     }
  956.       if(((*analyseurs)=='=')&&(*(analyseurs+1)!='=')) 
  957.     {
  958.       analyseurs++;changevalue(ep, expr()); 
  959.     }
  960.       analyseurtetpil=avma;return (GEN)ep->value;
  961.       
  962.     case 100: /* fonctions utilisateur */
  963.       ch1 = analyseurs;
  964.       match('(');
  965.       p = (entree **)ep->value;
  966.       nparam = (long)*p++;
  967.       arg1 = arg = cgetg(nparam+1, 17);
  968.       for(i = 0; (i < nparam) && (*analyseurs != ')'); i++)
  969.     {
  970.       if (i) match(',');
  971.       *++arg = (long)expr();
  972.     }
  973.       if ((*analyseurs==')') && ((analyseurs[1] != '=') || (analyseurs[2] == '=')))
  974.     {
  975.       analyseurs++;
  976.       while(i++ < nparam) *++arg = zero;
  977.       analyseurtetpil = avma;
  978.       for(i=0; i<nparam; i++) newvalue(*p++, *++arg1);
  979.       res = lisseq((char *)p);
  980.           res = forcecopy(res);
  981.       for(i = 0; i < nparam; i++) 
  982.             killvalue(*--p);
  983.       return res;
  984.     }
  985.       while (*analyseurs == ',') {analyseurs++; skipexpr();}
  986.       match(')');
  987.       if ((*analyseurs != '=') || (analyseurs[1] == '=')) err(nparamer1);
  988.       analyseurs = ch1;
  989.       killbloc(ep->value);
  990.       
  991.     case 101: /* nouvelle fonction */
  992.       
  993.       match('(');
  994.       ch1 = analyseurs;
  995.       for(nparam = 0; *analyseurs != ')'; nparam++)
  996.     {
  997.       if (nparam) match(',');
  998.       if (!isalpha(*analyseurs)) err(paramer1);
  999.       if (skipentry()->valence != 200) err(paramer1);
  1000.     }
  1001.       match(')'); match('='); ch2 = analyseurs; skipseq(); 
  1002.       p = (entree **)newbloc(nparam + (analyseurs - ch2) / 4 + 2);
  1003.       p[-1] = (entree *)ep->value;
  1004.       ep->value = (void *)p;
  1005.       *p++ = (entree *)nparam;
  1006.       ch2 = analyseurs; analyseurs = ch1;
  1007.       for(i = 0; i < nparam; i++)
  1008.     {
  1009.       if (i) match(',');
  1010.       *p++ = ep1 = findentry();
  1011.       if (ep1->valence != 200) err(paramer1);
  1012.     }      
  1013.       match(')'); match('=');
  1014.       strncpy((char *)p, analyseurs, ch2 - analyseurs);
  1015.       *((char *)p + (ch2 - analyseurs)) = 0;
  1016.       ep->valence = 100;
  1017.       analyseurs = ch2;
  1018.       return gnil;
  1019.       
  1020.     default: err(valencer1);
  1021.     }
  1022. }
  1023.  
  1024. static long  word(nb)
  1025.      long *nb;
  1026. {
  1027.   int m=0;
  1028.   for(*nb = 0; (*nb < 9) && isdigit(*analyseurs); (*nb)++)
  1029.     m = 10 * m + *analyseurs++-'0';
  1030.    return m;
  1031. }
  1032.  
  1033. GEN constante()
  1034. {
  1035.   static long pw10[] = {1, 10, 100, 1000, 10000, 100000,
  1036.                           1000000, 10000000, 100000000, 1000000000};
  1037.   long l,m=0,n=0,plus=1,nb, av = avma, limite=(avma + bot)/2;
  1038.   GEN z,y;
  1039.   
  1040.   analyseurtetpil=avma;
  1041.   y = stoi(word(&nb));
  1042.   while (isdigit(*analyseurs))
  1043.     {
  1044.       m = word(&nb); y = mulsi(pw10[nb], y);
  1045.       analyseurtetpil = avma;
  1046.       y = addsi(m, y);
  1047.       if (avma < limite)
  1048.         {
  1049.           y = gerepile(av, analyseurtetpil, y);
  1050.           analyseurtetpil = av;
  1051.         }
  1052.     }
  1053.   if ((*analyseurs!='.')&&(*analyseurs!='e')&&(*analyseurs!='E')) return y;
  1054.   if (*analyseurs=='.') 
  1055.     {
  1056.       analyseurs++;
  1057.       while (isdigit(*analyseurs))
  1058.         {
  1059.           m = word(&nb); y = mulsi(pw10[nb], y);
  1060.           analyseurtetpil = avma;
  1061.           y = addsi(m, y);
  1062.           if (avma < limite)
  1063.             {
  1064.               y = gerepile(av, analyseurtetpil, y);
  1065.               analyseurtetpil = av;
  1066.             }
  1067.           n -= nb;
  1068.         }
  1069.     }
  1070.   l=lgef(y);if(l<prec) l=prec;
  1071.   analyseurtetpil=avma;
  1072.   z=cgetr(l);affir(y,z);
  1073.   if ((*analyseurs=='e') || (*analyseurs=='E'))
  1074.     {
  1075.       analyseurs++;
  1076.       if (((*analyseurs)=='+') || ((*analyseurs)=='-')) plus=(*analyseurs++=='+');
  1077.       m = word(&nb);
  1078.       if(isdigit(*analyseurs)) err(expter1);
  1079.       if (plus) n += m;else n -= m;
  1080.     }
  1081.   if (n)
  1082.     {
  1083.       affsr(10, y = cgetr(l));
  1084.       y = gpuigs(y, abs(n));
  1085.       analyseurtetpil=avma;
  1086.       z = n > 0 ?  mulrr(z, y) : divrr(z, y);
  1087.     }
  1088.   return z;
  1089. }
  1090.  
  1091. entree *findentry()
  1092. {
  1093.   char *olds = analyseurs, *u, *v;
  1094.   long sv, n;
  1095.   GEN p1;
  1096.   entree *ep;
  1097.   
  1098.   for (n = 0; isalnum(*analyseurs); analyseurs++) n = n << 1 ^ *analyseurs;
  1099.   if (n < 0) n = -n; n %= TBLSZ;
  1100.   for(ep = hashtable[n]; ep; ep = ep->next)
  1101.     {
  1102.       for(u = ep->name, v = olds; (*u) && *u == *v; u++, v++);
  1103.       if (!*u && (v == analyseurs)) return ep;
  1104.     }
  1105.   sv = (*analyseurs == '(') ? 0 : 28;
  1106.   ep = (entree *)malloc(sizeof(entree) + sv + analyseurs - olds + 1);
  1107.   ep->name = (char *)ep + sizeof(entree) + sv;
  1108.   for (u = ep->name, v = olds; v < analyseurs;) *u++ = *v++; *u = 0;
  1109.   ep->value = (void *)((char *)ep + sizeof(entree));
  1110.   ep->next = hashtable[n];
  1111.   hashtable[n] = ep;
  1112.   p1 = (GEN)ep->value;
  1113.   if (*analyseurs == '(') ep->valence = 101;
  1114.   else
  1115.     {
  1116.       if (nvar == MAXVAR) err(trucer1);
  1117.       ep->valence = 200;
  1118.       p1[0] = 0x0a010004; p1[1] = 0x01000004 + (nvar << 16); p1[2] = zero; p1[3] = un;
  1119.       polx[nvar] = p1;
  1120.       polvar[nvar+1] = (long)p1;
  1121.       p1 += 4;
  1122.       p1[0] = 0x0a010003; p1[1] = 0x01000003 + (nvar << 16); p1[2] = un;
  1123.       polun[nvar] = p1;
  1124.       varentries[nvar++] = ep;
  1125.       setlg(polvar, nvar+1);
  1126.     }
  1127.   return ep;
  1128. }
  1129.  
  1130.  
  1131.  
  1132. void skipseq()
  1133. {
  1134.   for(;;)
  1135.     {
  1136.       while(separe(*analyseurs)) analyseurs++;
  1137.       if ((!*analyseurs) || (*analyseurs == ')') || (*analyseurs == ',')) return;
  1138.       skipexpr();
  1139.       if(!separe(*analyseurs)) return;
  1140.     }
  1141. }
  1142.  
  1143. void skipexpr()
  1144. {
  1145.   long niveau=3,e1,e2,e3;
  1146.   
  1147.   e1=e2=e3=0;
  1148.   for(;;)
  1149.     switch(niveau)
  1150.       {
  1151.       case 3: e3=1;skipfacteur();
  1152.         switch(*analyseurs)
  1153.       {
  1154.           case '*': 
  1155.           case '/': 
  1156.           case '\\':
  1157.           case '%': analyseurs++;break;
  1158.           default: niveau--;
  1159.       }
  1160.         break;
  1161.       case 2:
  1162.         if(!e3) {niveau++;break;}
  1163.         e3=0;e2=1;
  1164.         switch(*analyseurs)
  1165.       {
  1166.           case '+':
  1167.           case '-': analyseurs++;niveau++;break;
  1168.           default: niveau--;
  1169.       }
  1170.         break;
  1171.       case 1: 
  1172.         if(!e2) {niveau++;break;}
  1173.         e2=0;e1=1;
  1174.         switch(*analyseurs)
  1175.       {
  1176.           case '<': analyseurs++;
  1177.             switch(*analyseurs)
  1178.           {
  1179.               case '=':
  1180.               case '>': analyseurs++;niveau++;break;
  1181.         default : niveau++;break;
  1182.           }
  1183.             break;
  1184.           case '>': analyseurs++;
  1185.             if((*analyseurs)=='=') analyseurs++;
  1186.             niveau++; break;
  1187.           case '=': 
  1188.           case '!': 
  1189.             if((analyseurs[1])=='=') {analyseurs+=2;niveau++;}
  1190.             break;
  1191.           default: niveau--;
  1192.       }
  1193.         break;
  1194.       case 0: 
  1195.         if(!e1) {niveau++;break;}
  1196.         e1=0;
  1197.         switch(*analyseurs)
  1198.       {
  1199.           case '&': analyseurs++;if(*analyseurs=='&') analyseurs++;niveau++;break;
  1200.           case '|': analyseurs++;if(*analyseurs=='|') analyseurs++;niveau++;break;
  1201.           default: return;
  1202.       }
  1203.       }
  1204. }
  1205.  
  1206. void skipfacteur()
  1207. {
  1208.   if (((*analyseurs)=='+') || ((*analyseurs)=='-')) analyseurs++;
  1209.   skiptruc();
  1210.   for (;;) switch(*analyseurs)
  1211.     {
  1212.     case '^': analyseurs++;skipfacteur(); break;
  1213.     case '~': 
  1214.     case '_':
  1215.     case '\'': analyseurs++;break;
  1216.     case '[': 
  1217.       analyseurs++;
  1218.       if(*analyseurs == ',') {analyseurs++;skipexpr();}
  1219.       else
  1220.     {
  1221.       skipexpr();
  1222.       if(*analyseurs==',')
  1223.         {
  1224.           analyseurs++;if(*analyseurs != ']') skipexpr();
  1225.         }
  1226.     }
  1227.       match(']');break;
  1228.     case '!': analyseurs++;if((*analyseurs)!='=') break; else analyseurs--;
  1229.     default: return;
  1230.     }
  1231. }
  1232.  
  1233. void skiptruc()
  1234. {
  1235.   long n=0,p=0,m=1;
  1236.   
  1237.   if (isalpha(*analyseurs)) {skipidentifier(); return;}
  1238.   if (isdigit(*analyseurs) || (*analyseurs=='.')) {skipconstante(); return;}
  1239.   switch(*analyseurs++)
  1240.     {
  1241.     case '(': skipexpr();match(')');return;
  1242.     case '[': if (*analyseurs!=']') 
  1243.       {do {n++; skipexpr();} while (*analyseurs++==',');analyseurs--;}
  1244.       switch (*analyseurs++)
  1245.     {
  1246.         case ']': return;
  1247.         case ';': m=n;do {n++; skipexpr();} while (*analyseurs++!=']');
  1248.           if (n % m) err(recter1);
  1249.           return;
  1250.         default: err(vectmater1);
  1251.     }
  1252.     case '%':
  1253.       p=0;while((*analyseurs)=='`') {analyseurs++;p++;}
  1254.       if(p>tglobal) err(referer1);
  1255.       if(p) return;
  1256.       while (isdigit(*analyseurs)) p = 10*p + *analyseurs++ - '0';
  1257.       if(p>tglobal) err(referer1);
  1258.       return;
  1259.     }
  1260.   err(caracer1,analyseurs-1);
  1261. }
  1262.  
  1263. void skipidentifier()
  1264. {
  1265.   long nparam, i, m;
  1266.   entree *ep, **p;
  1267.   char *ch1;
  1268.   GEN arg;
  1269.  
  1270.   ep = skipentry();
  1271.   if (ep->valence < 100) /* fonctions predefinies */
  1272.     {
  1273.       if (!ep->valence && (*analyseurs != '(')) return;
  1274.       match('(');
  1275.       switch(ep->valence)
  1276.     {
  1277.     case 0:
  1278.     case 56: break;
  1279.     case 1:
  1280.     case 10:
  1281.     case 11:
  1282.     case 13:
  1283.     case 15:
  1284.     case 61: skipexpr(); break;
  1285.     case 60: arg=expr();if(typ(arg)!=1) err(caseer);
  1286.       m=itos(arg);if((m>=100)||(m<0)) err(labeler);
  1287.       labellist[m]=analyseurs;break;
  1288.     case 51: case 52: case 53: case 54: case 55:
  1289.       if (*analyseurs != ')') for(;;)
  1290.         {
  1291.           if (*analyseurs == '"')
  1292.         {
  1293.           analyseurs++;
  1294.           while ((*analyseurs)&&(*analyseurs!='"')) analyseurs++;
  1295.           match('"');
  1296.         }
  1297.           else skipexpr();
  1298.           if (*analyseurs == ')') break;
  1299.           match(',');
  1300.         }
  1301.       break;
  1302.     case 57:
  1303.       skipexpr();match(',');if(*analyseurs!='"') skipexpr();
  1304.       else
  1305.         {
  1306.           match('"');m=0;
  1307.           while ((m<256)&&(*analyseurs)&&(*analyseurs!='"')) 
  1308.         {m++;analyseurs++;}
  1309.           match('"');
  1310.         }
  1311.       break;
  1312.     case 2:
  1313.     case 12:
  1314.     case 14:
  1315.     case 20:
  1316.     case 21:
  1317.     case 23:
  1318.     case 24:
  1319.     case 25:
  1320.     case 28:
  1321.     case 29: skipexpr(); match(','); skipexpr(); break;
  1322.     case 22: skipexpr(); match(',');
  1323.       if(!isalpha(*analyseurs)) err(varer1,analyseurs);
  1324.       ep = skipentry(); if (ep->valence!=200) err(varer1,analyseurs);
  1325.       match(','); skipexpr(); break;
  1326.     case 27: if(!isalpha(*analyseurs)) err(varer1,analyseurs);
  1327.       ep = skipentry(); match('='); if (ep->valence!=200) err(varer1,analyseurs);
  1328.       skipexpr(); match(','); skipexpr(); break;
  1329.     case 3:
  1330.     case 26: 
  1331.     case 30:
  1332.     case 31:
  1333.     case 32:
  1334.     case 33:
  1335.     case 34:
  1336.     case 35: skipexpr();match(',');skipexpr();match(',');skipexpr();
  1337.       break;
  1338.     case 37: if(!isalpha(*analyseurs)) err(varer1,analyseurs);
  1339.       ep = skipentry(); match('='); if (ep->valence!=200) err(varer1,analyseurs);
  1340.       skipexpr(); match(','); skipexpr(); match(','); skipexpr();break;
  1341.     case 4: skipexpr();match(',');skipexpr();match(',');skipexpr();
  1342.       match(',');skipexpr();break;
  1343.     case 48: skipexpr(); match(',');
  1344.       if(!isalpha(*analyseurs)) err(varer1,analyseurs);
  1345.       ep = skipentry(); match('='); if (ep->valence!=200) err(varer1,analyseurs);
  1346.       skipexpr(); match(','); skipexpr(); match(','); skipexpr();break;
  1347.     case 49: skipexpr(); match(','); skipexpr(); match(',');
  1348.       if(!isalpha(*analyseurs)) err(varer1,analyseurs);
  1349.       ep = skipentry(); if (ep->valence!=200) err(varer1,analyseurs);
  1350.       match(',');if(!isalpha(*analyseurs)) err(varer1,analyseurs);
  1351.       ep = skipentry(); if (ep->valence!=200) err(varer1,analyseurs);
  1352.       match(','); skipexpr(); break;
  1353.     case 50: skiptruc();
  1354.       if (*analyseurs++=='^') skipfacteur();else analyseurs--;
  1355.       break;
  1356.     case 59: skipexpr();match(',');skipexpr();match(',');skipexpr();
  1357.       match(',');skipexpr();match(',');skipexpr();break;
  1358.     case 80: skipexpr(); match(','); skipseq(); match(','); skipseq(); break;
  1359.     case 81:
  1360.     case 82: skipexpr(); match(','); skipseq(); break;
  1361.     case 83: if(!isalpha(*analyseurs)) err(varer1,analyseurs);
  1362.       ep = skipentry(); match('='); if (ep->valence!=200) err(varer1,analyseurs);
  1363.       skipexpr(); match(','); skipexpr(); match(','); skipseq(); break;
  1364.     case 84: skipexpr(); match(',');
  1365.       if(!isalpha(*analyseurs)) err(varer1,analyseurs);
  1366.       ep = skipentry(); if (ep->valence!=200) err(varer1,analyseurs);
  1367.       match(','); skipseq(); break;
  1368.     case 85: if(!isalpha(*analyseurs)) err(killer1);
  1369.       ep = skipentry(); if (ep->valence<100) err(killer1);
  1370.       break;
  1371.     case 86: if(!isalpha(*analyseurs)) err(varer1,analyseurs);
  1372.       ep = skipentry(); match('='); if (ep->valence!=200) err(varer1,analyseurs);
  1373.       skipexpr();match(',');skipexpr();match(',');skipexpr();match(',');skipseq();break;
  1374.     default: err(valencer1);
  1375.     }
  1376.       match(')');
  1377.       return;
  1378.     }
  1379.   switch (ep->valence)
  1380.     {
  1381.     case 200: /* variables */
  1382.       if((*analyseurs)=='[')
  1383.     {
  1384.       analyseurs++;
  1385.       if(*analyseurs == ',') {analyseurs++;skipexpr();}
  1386.       else
  1387.         {
  1388.           skipexpr();
  1389.           if(*analyseurs == ',')
  1390.         {
  1391.           analyseurs++;if(*analyseurs != ']') skipexpr();
  1392.         }
  1393.         }
  1394.       match(']');
  1395.     }
  1396.       if(((*analyseurs)=='=')&&(*(analyseurs+1)!='=')) 
  1397.     {
  1398.       analyseurs++;skipexpr(); 
  1399.     }
  1400.       return;
  1401.       
  1402.     case 100: /* fonctions utilisateur */
  1403.       ch1 = analyseurs;
  1404.       match('(');
  1405.       p = (entree **)ep->value;
  1406.       nparam = (long)*p++;
  1407.       i = 0;
  1408.       for(i = 0; (i < nparam) && (*analyseurs != ')'); i++)
  1409.     {
  1410.       if (i) match(',');
  1411.       skipexpr();
  1412.     }
  1413.       if ((*analyseurs==')') && ((analyseurs[1] != '=') || (analyseurs[2] == '='))) {analyseurs++; return;}
  1414.       while (*analyseurs == ',') {analyseurs++; skipexpr();}
  1415.       match(')');
  1416.       if ((*analyseurs != '=') || (analyseurs[1] == '=')) err(nparamer1);
  1417.       analyseurs = ch1;
  1418.       
  1419.     case 101: /* nouvelle fonction */
  1420.       
  1421.       match('(');
  1422.       for(nparam = 0; *analyseurs != ')'; nparam++)
  1423.     {
  1424.       if (nparam) match(',');
  1425.       skipexpr();
  1426.     };
  1427.       match(')');
  1428.       if (*analyseurs == '=') {analyseurs++; skipseq();}
  1429.       return;
  1430.       
  1431.     default: err(valencer1);
  1432.     }
  1433. }
  1434.  
  1435. void skipconstante()
  1436. {  
  1437.   while (isdigit(*analyseurs)) analyseurs++;
  1438.   if ((*analyseurs!='.')&&(*analyseurs!='e')&&(*analyseurs!='E')) return;
  1439.   if (*analyseurs=='.') analyseurs++;
  1440.   while (isdigit(*analyseurs)) analyseurs++;
  1441.   if ((*analyseurs=='e') || (*analyseurs=='E'))
  1442.     {
  1443.       analyseurs++;
  1444.       if (((*analyseurs)=='+') || ((*analyseurs)=='-')) analyseurs++;
  1445.       while (isdigit(*analyseurs)) analyseurs++;
  1446.     }
  1447. }
  1448.  
  1449. entree fake101 = {"",101,0,0};
  1450. entree fake200 = {"",200,0,0};
  1451.  
  1452. entree *skipentry()
  1453. {
  1454.   char *u, *v, *olds = analyseurs;
  1455.   long n;
  1456.   entree *ep;
  1457.   
  1458.   for(n = 0; isalnum(*analyseurs); analyseurs++) n = n << 1 ^ *analyseurs;
  1459.   if (n < 0) n = -n; n %= TBLSZ;
  1460.   for(ep = hashtable[n]; ep; ep = ep->next)
  1461.     {
  1462.       for(u = ep->name, v = olds; (*u) && *u == *v; u++, v++);
  1463.       if (!*u && (v == analyseurs)) return ep;
  1464.     }
  1465.   return (*analyseurs == '(') ? &fake101 : &fake200;
  1466. }
  1467.