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.
2 Commits
1 Branch
631 KiB
 
 
 
 
Tree: cfaac31344
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'cfaac31344'
${ noResults }
Nife_v0/src/lib.c

648 lines
17 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. #include "conf.h"

  17. /* lib.c  librairie de base */

  18. #include <stdio.h>

  19. #include <stdlib.h>

  20. #include <string.h>

  21. 

  22. #include "nife.h"

  23. #include "mth.h"

  24. #include "err.h"

  25. #include "histo.h"

  26. #include "foncs.h"

  27. #include "tasks.h"

  28. #include "stackN.h"

  29. #include "stackL.h"

  30. #include "stackC.h"

  31. #include "stackF.h"

  32. #include "stackV.h"

  33. #include "libmath.h"

  34. #include "help.h"

  35. #include "dev.h"

  36. #include "i2c.h"

  37. #include "net.h"

  38. #include "gplot.h"

  39. #include "debug.h"

  40. 

  41. /* familles des fonctions */

  42. #define F_CORE  1 /* Core */

  43. #define F_MATH  2 /* Mathematiques */

  44. #define F_PROG  4 /* Programmation, variables, tasks, ... */

  45. #define F_TOOL  8 /* External Tools Graphical or others */

  46. #define F_DEV  16 /* devices, comedi interfaces, ... */

  47. #define F_NET  32 /* networking functions */

  48. #define F_USR  64 /* user system functions */

  49. 

  50. struct fonction {

  51.     char * nam;

  52.     void (* fct)(void);

  53.     short typ; /* 0 fct, 1 instruction, 2 externe, 3 usr fct */

  54.     short fam; /* cf F_xxx ci-dessus */

  55. };

  56. 

  57. #define NBFONC 400

  58. #define NBCMOY 12	/* nb de car. en moyenne */

  59. static char Libelles[NBFONC*NBCMOY], *pLibs=Libelles;

  60. static struct fonction Fonctions[NBFONC];

  61. static int NBFonc=0; 

  62. int InstallOn=0;

  63. 

  64. static void IF_INSTALL(void) { InstallOn=1; }

  65. static void IF_INSTALLF(void) { InstallOn=2; }

  66. static void IF_INSTALLV(void) { InstallOn=3; }

  67. /* for dynamic functions */

  68. static void IF_DF_INIT(void) { InstallOn=8; }

  69. static void IF_DF_START(void) { InstallOn=9; }

  70. static void IF_DF_STOP(void) { InstallOn=10; }

  71. 

  72. static void addFoncT(char *l, void (*f)(void), short T, short F)

  73. {

  74. char *LMax;

  75.     if (NBFonc >= NBFONC) stopErr("addFonc : NBFONC !",NULL);

  76.     LMax = Libelles + (NBFONC*NBCMOY);

  77.     if (pLibs + strlen(l) + 1 >= LMax) stopErr("addFonc : Libelles !",NULL);

  78.     Fonctions[NBFonc].nam = pLibs;

  79.     Fonctions[NBFonc].typ = T;

  80.     Fonctions[NBFonc].fam = F;

  81.     Fonctions[NBFonc++].fct = f;

  82.     strcpy(pLibs,l);

  83.     pLibs += strlen(l);

  84.     *pLibs++ = '\0';

  85. }

  86. static void addFonc(char *l, void (*f)(void))

  87. {

  88.     addFoncT(l,f,0,F_CORE);

  89. }

  90. static void addFonM(char *l, void (*f)(void))

  91. {

  92.     addFoncT(l,f,0,F_MATH);

  93. }

  94. static void addFonP(char *l, void (*f)(void))

  95. {

  96.     addFoncT(l,f,0,F_PROG);

  97. }

  98. static void addFonG(char *l, void (*f)(void))

  99. {

  100.     addFoncT(l,f,0,F_TOOL);

  101. }

  102. static void addFonD(char *l, void (*f)(void))

  103. {

  104.     addFoncT(l,f,0,F_DEV);

  105. }

  106. static void addFonN(char *l, void (*f)(void))

  107. {

  108.     addFoncT(l,f,0,F_NET);

  109. }

  110. void addFonU(char *l, void *A)

  111. {

  112. PFV f;

  113.     f = (PFV)A;

  114.     addFoncT(l,f,0,F_USR);

  115. }

  116. static void addFonE(char *l, void (*f)(void), short F) /* External functions */

  117. {                                                      /* not beetween : and ;*/

  118.     addFoncT(l,f,2,F);

  119. }

  120. static void addInst(char *l, void (*f)(void))

  121. {

  122.     addFoncT(l,f,1,F_PROG);

  123. }

  124. 

  125. static char **ListFonc = (char**)NULL;

  126. 

  127. static void Show_library(int NbF)

  128. {

  129. int i,j=0;

  130.     for (i=0;i<NbF;i++) {

  131.         /* printf("%-13s",Fonctions[i].nam);*/

  132.         printf("%-13s",ListFonc[i]);

  133.         j++;

  134.         if (j == 6) {

  135.            j=0;

  136.            printf("\n");

  137.         }

  138.     }

  139.     if (j) printf("\n");

  140. }

  141. 

  142. static int triList(short F)

  143. {

  144. void * M;

  145. char * T;

  146. int i,j, NbF;

  147.    if (ListFonc != (char**)NULL) free((void*)ListFonc);

  148.    if ((M = malloc(sizeof(char*)* NBFonc)) == NULL) stopErr("triList","malloc");

  149.    ListFonc = (char**)M;

  150.    j=0;

  151.    for(i=0;i<NBFonc;i++) {

  152.       if (Fonctions[i].fam & F) ListFonc[j++]=Fonctions[i].nam;

  153.    }

  154.    NbF = j;

  155.    for(i=0; i<NbF-1; i++) /* avant NbF-2 */

  156.       for(j=i+1; j<NbF; j++)

  157.         if(strcmp(ListFonc[j],ListFonc[i]) < 0) {

  158.           T=ListFonc[i]; ListFonc[i]=ListFonc[j]; ListFonc[j]=T;

  159.         }

  160.    return NbF;

  161. }

  162. 

  163. void listLibBegin(char * b)

  164. {

  165. int i,j=0,l,n;

  166.    l=strlen(b);

  167.    n=triList(0xFF);

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

  169.       if (strncmp(ListFonc[i],b,l)==0){

  170.         printf("%-13s",ListFonc[i]);

  171.         j++;

  172.         if (j == 6) {

  173.            j=0;

  174.            printf("\n");

  175.         }

  176.       } else

  177.          if (strncmp(ListFonc[i],b,l)>0) break;

  178.    }

  179.    if (j) printf("\n");

  180. }

  181. 

  182. char * getLibBegin(char * b)

  183. {

  184. int i,l;

  185.    l=strlen(b);

  186.    for(i=0;i<NBFonc;i++) {

  187.       if (strncmp(Fonctions[i].nam,b,l)==0) break;

  188.    }

  189.    if (i==NBFonc) return NULL;

  190.    return Fonctions[i].nam;

  191. }

  192. 

  193. static char Rac[20]; /* longueur maxi d'une commande */

  194. int nbLibBegin(char * b, char ** r)

  195. {

  196. int i,n, first=1;

  197. unsigned int j, l,t=0;

  198.    n=triList(0xFF);

  199.    l=strlen(b);

  200.    *Rac='\0';

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

  202.         if (strncmp(ListFonc[i],b,l)>0) break;

  203.         if (strncmp(ListFonc[i],b,l)==0) {

  204.            t++;

  205.            if (first) {

  206.               strcpy(Rac,ListFonc[i]);

  207.               first=0;

  208.            } else {

  209.               if (strlen(Rac) > l) {

  210.                  for(j=l;j<strlen(Rac);j++)

  211.                      if (strncmp(Rac,ListFonc[i],j) != 0)  break;

  212.                  if (j!=strlen(Rac)) Rac[j-1]='\0';

  213.                  else 

  214.                     if (Rac[j-1] != ListFonc[i][j-1]) Rac[j-1]='\0';

  215.               }

  216.            }

  217.         }

  218.    }

  219.    if (strlen(Rac) > l) *r = Rac;

  220.    else *r = NULL;

  221.    return(t);

  222. }

  223. 

  224. void IF_show_liball(void)

  225. {

  226.    Show_library(triList(0xFF));

  227. }

  228. void IF_show_libstd(void)

  229. {

  230.    Show_library(triList(F_CORE));

  231. }

  232. void IF_show_libmath(void)

  233. {

  234.    Show_library(triList(F_MATH));

  235. }

  236. void IF_show_libprog(void)

  237. {

  238.    Show_library(triList(F_PROG));

  239. }

  240. void IF_show_libtools(void)

  241. {

  242.    Show_library(triList(F_TOOL));

  243. }

  244. void IF_show_libdev(void)

  245. {

  246.    Show_library(triList(F_DEV));

  247. }

  248. void IF_show_libnet(void)

  249. {

  250.    Show_library(triList(F_NET));

  251. }

  252. void IF_show_libusr(void)

  253. {

  254.    Show_library(triList(F_USR));

  255. }

  256. 

  257. void initLib(void)

  258. {

  259.     addFonc(".",IF_point);

  260.     addFonc("+",IF_plus);

  261.     addFonc("-",IF_moins);

  262.     addFonc("=",IF_Legal);

  263.     addFonc("<>",IF_Ldiff);

  264.     addFonc(">",IF_Lsup);

  265.     addFonc("<",IF_Linf);

  266.     addFonc(">=",IF_Lsupeg);

  267.     addFonc("<=",IF_Linfeg);

  268.     addFonc("*",IF_mult);

  269.     addFonc("/",IF_div);

  270.     addFonc("neg",IF_neg);

  271.     addFonc("min",IF_min);

  272.     addFonc("max",IF_max);

  273.     addFonc("modulo",IF_modulo);

  274.     addFonc("**",IF_puiss);

  275.     addFonc("[]-sub",IF_subTab);

  276.     addFonc("[]sub",IF_subTabR);

  277.     addFonc("*[]-sub",IF_NsubTab);

  278.     addFonc("*[]sub",IF_NsubTabR);

  279.     addFonc("[]rev",IF_TabRev);

  280.     addFonc("*[]rev",IF_NTabRev);

  281.     addFonc("[]crot",IF_TabTransp);

  282.     addFonc("[]transp",IF_TabTranspN);

  283.     addFonc("[]trot",IF_TabTranspT);

  284.     addFonc("[]>>",IF_TNShiftR);

  285.     addFonc("[]<<",IF_TNShiftL);

  286.     addFonc("*[]>>",IF_NTNShiftR);

  287.     addFonc("*[]<<",IF_NTNShiftL);

  288.     addFonc("[]>",IF_TShiftR);

  289.     addFonc("[]<",IF_TShiftL);

  290.     addFonc("*[]>",IF_NTShiftR);

  291.     addFonc("*[]<",IF_NTShiftL);

  292.     addFonc("[]min",IF_TABMin);

  293.     addFonc("[]max",IF_TABMax);

  294.     addFonc("[]sum",IF_TABSum);

  295.     addFonc("[]prod",IF_TABProd);

  296.     addFonc("[]min/max",IF_TABMinMax);

  297.     addFonc(">array",IF_toArray);

  298.     addFonc(">scalar",IF_toScalar);

  299.     addFonc(">-scalar",IF_toScalarR);

  300.     addFonc("\"",IF_debString);

  301.     addFonc("\"drop",IF_dropC);

  302.     addFonc("\"dup",IF_dupC);

  303.     addFonc("\"over",IF_overC);

  304.     addFonc("\"swap",IF_swapC);

  305.     addFonc("\"type",IF_typeC);

  306.     addFonc("\"cat",IF_catC);

  307.     addFonc("\"cats",IF_catsC);

  308.     addFonc("cr",IF_crC);

  309.     addFonc("\"time",IF_timeC);

  310.     addFonc("\"date",IF_dateC);

  311.     addFonc("sleep",IF_sleep);

  312.     addFonc("sh",IF_sh);

  313.     addFonc("?drop",IF_dropL);

  314.     addFonc("?dup",IF_dupL);

  315.     addFonc("?swap",IF_swapL);

  316.     addFonc("?over",IF_overL);

  317.     addFonc("?t/f",IF_typeL);

  318.     addFonc("and",IF_andL);

  319.     addFonc("or",IF_orL);

  320.     addFonc("xor",IF_xorL);

  321.     addFonP("fdrop",rmLastFct);

  322.     addFonE("del_func",IF_delFct, F_PROG);

  323.     addFonE("del_afunc",IF_delAFct, F_PROG);

  324.     addFonE("del_ofunc",IF_delOFct, F_PROG);

  325.     addFonE("fscan",IF_scanFct, F_PROG);

  326.     addFonc("?cs",IF_show_stackC);

  327.     addFonP("?f",IF_show_stackF);

  328.     /* addFonP("?l",IF_showFD); for debugging */

  329.     addFonP("?v",IF_show_stackV);

  330.     addFonE("del_var",IF_delVar,F_PROG);

  331.     addFonP("vdrop",rmLastVar);

  332.     addFonP("reset_var",IF_setVarI);

  333.     addFonP(">v",IF_setVarN);

  334.     addFonP("?>v",IF_setVarB);

  335.     addFonP("\">v",IF_setVarC);

  336.     addFonP("in",IF_setVarLF);

  337.     addFonP("install",IF_INSTALL);

  338.     addFonP("install_f",IF_INSTALLF);

  339.     addFonP("install_v",IF_INSTALLV);

  340.     addFonP("df_init",IF_DF_INIT);

  341.     addFonP("df_start",IF_DF_START);

  342.     addFonP("df_stop",IF_DF_STOP);

  343.     addFonc("?ls",IF_show_stackL);

  344.     addFonc("?s",IF_show_stack);

  345.     addFonc("?libs",IF_show_liball);

  346.     addFonc("?lib",IF_show_libstd);

  347.     addFonc("?libM",IF_show_libmath);

  348.     addFonc("?libT",IF_show_libtools);

  349.     addFonc("?libP",IF_show_libprog);

  350.     addFonc("?libD",IF_show_libdev);

  351.     addFonc("?libN",IF_show_libnet);

  352.     addFonc("?libU",IF_show_libusr);

  353.     addFonc("?lasterr",IF_showError);

  354.     addFonc("?err",IF_IsError);

  355.     addFonc("noerr",IF_NoError);

  356.     addFonc("messerr",IF_LibError);

  357.     addFonc("ls_clear",IF_stackL_clear);

  358.     addFonc("cs_clear",IF_stackC_clear);

  359.     addFonc("REAL",IF_REAL);

  360.     addFonc("INTEGER",IF_INTEGER);

  361.     addFonc("echo_on",IF_ECHOON);

  362.     addFonc("echo_off",IF_ECHOFF);

  363.     addFonc("DEBUG_I/O",D_Update);

  364.     addFonc("NBTAB",IF_NBTAB);

  365.     addFonc("NBLIG",IF_NBLIG);

  366.     addFonE("Var",IF_debVar, F_PROG);

  367.     addFonc("\"Var",IF_debVarCS);

  368.     addFonP("var_off",IF_VAROFF);

  369.     addFonP("var_up",IF_VARUP);

  370.     addFonP("var_down",IF_VARDOWN);

  371.     addFonc("?vars",IF_vars);

  372.     addFonc("drop",IF_drop);

  373.     addFonc("dup",IF_dup);

  374.     addFonc("swap",IF_swap);

  375.     addFonc("over",IF_over);

  376.     addFonc("pick",IF_pick);

  377.     addFonc("rot",IF_rot);

  378.     addFonc("unrot",IF_unrot);

  379.     addFonc("roll",IF_roll);

  380.     addFonc("unroll",IF_unroll);

  381.     addFonc("*drop",IF_Ndrop);

  382.     addFonc("*dup",IF_Ndup);

  383.     addFonc("depth",IF_depth);

  384.     addFonc("exit",IF_exit);

  385.     addFonc("false",IF_false);

  386.     addFonc("not",negBool);

  387.     addFonc("ramp",IF_ramp);

  388.     addFonc("dramp",IF_dramp);

  389.     addFonc("rusage",IF_resUsage);

  390.     addFonc("s_clear",IF_stack_clear);

  391.     addFonM("inv",IF_inv);

  392.     addFonM("sqrt",IF_sqrt);

  393.     addFonM("cbrt",IF_cbrt);

  394.     addFonM("round",IF_round);

  395.     addFonM("floor",IF_floor);

  396.     addFonM("ceil",IF_ceil);

  397.     addFonM("sgn",IF_sgn);

  398.     addFonM("abs",IF_abs);

  399.     addFonM("pi",IF_pi);

  400.     addFonM("sin",IF_sin);

  401.     addFonM("cos",IF_cos);

  402.     addFonM("tan",IF_tan);

  403.     addFonM("asin",IF_asin);

  404.     addFonM("acos",IF_acos);

  405.     addFonM("atan",IF_atan);

  406.     addFonM("sinh",IF_sinh);

  407.     addFonM("cosh",IF_cosh);

  408.     addFonM("tanh",IF_tanh);

  409.     addFonM("asinh",IF_asinh);

  410.     addFonM("acosh",IF_acosh);

  411.     addFonM("atanh",IF_atanh);

  412.     addFonM("ln",IF_ln);

  413.     addFonM("log",IF_log);

  414.     addFonM("exp",IF_exp);

  415.     addFonM("j0",IF_j0);

  416.     addFonM("j1",IF_j1);

  417.     addFonM("y0",IF_y0);

  418.     addFonM("y1",IF_y1);

  419.     addFonc("time",IF_time);

  420.     addFonc("true",IF_true);

  421.     addFonc("about",IF_about);

  422.     addFonc("vers",IF_vers);

  423.     addFonE("load",IF_Load, F_PROG);

  424.     addFonP("\"load",IF_LoadCS);

  425.     addFonP("\"exec",IF_ExecCS);

  426.     addFonP("\"execf",IF_ExecCSf);

  427.     addInst("\"execk",IF_EXEK);

  428.     addFonG(">csv",IF_toCsv);

  429.     addFonG("y_xgraph",IF_yXgraph);

  430.     addFonG("yt_xgraph",IF_ytXgraph);

  431.     addFonG("xy_xgraph",IF_xyXgraph);

  432.     addFonG("xyt_xgraph",IF_xytXgraph);

  433.     addFonG("?gp",IF_show_stackGP);

  434.     addFonG("gplot",IF_gplot_new);

  435.     addFonG("gplotM",IF_gplot_newM);

  436.     addFonG("gplotRaz",IF_delAllGP);

  437.     addFonG("gplotCmd",IF_gplot_commapp);

  438.     addFonG("gplotAdd",IF_gplot_append);

  439.     addFonG("gplotRepl",IF_gplot_replace);

  440.     addFonG("del_gplot",IF_gplot_del);

  441.     addFonG("gplotClear",IF_gplot_clear);

  442.     addFonP(":",IF_debFct);

  443.     addFonP(":!",IF_debFctS);

  444.     addFonP("Task",IF_NewTask);

  445.     addFonP("?t",IF_show_Tasks);

  446.     addFonP("?task_run",IF_statusTask);

  447.     addFonP("del_task",IF_delTask);

  448.     addFonP("\"f",IF_execCS);

  449.     addFonP("\"v",IF_execCSv);

  450.     addFonP("\"f?",IF_execCSl);

  451.     addFonP("\"v?",IF_execCSvl);

  452.     addFonP("stop_task",IF_stopTask);

  453.     addFonP("?console",IF_showCons);

  454.     addInst(";",IF_finFct);

  455.     addInst("'",IF_debBackC);

  456.     addInst("`",IF_debBackC1);

  457.     addInst("return",IF_RET);

  458.     addInst("if",IF_IF);

  459.     addInst("else",IF_ELSE);

  460.     addInst("then",IF_THEN);

  461.     addInst("begin",IF_BEGIN);

  462.     addInst("again",IF_AGAIN);

  463.     addInst("until",IF_UNTIL);

  464.     addInst("while",IF_WHILE);

  465.     addInst("repeat",IF_REPEAT);

  466.     addInst("do",IF_DO);

  467.     addFonc("do_leave",IF_DO_Leave);

  468.     addFonc("*do_leave",IF_DO_MLeave);

  469.     addFonc("do_next",IF_DO_Next);

  470.     /* addFonc("?do",IF_DO_Show); for debugging */

  471.     addFonc("ndo",IF_nDO);

  472.     addInst("loop",IF_LOOP);

  473.     addInst("+loop",IF_PLOOP);

  474.     addInst("I",IF_I_DO);

  475.     addInst("J",IF_J_DO);

  476.     addInst("K",IF_K_DO);

  477.     addInst("break",IF_BREAK);

  478.     addInst("myself",IF_MYSELF);

  479.     addInst("onerr:",IF_ONERR);

  480.     addInst("end:",IF_END);

  481.     addInst("goto_end",IF_JEND);

  482.     addFonE("help",IF_help, F_CORE);

  483.     addFonD("?dev",IF_listDev);

  484.     addFonD("dev_info",IF_showDev);

  485.     addFonD("dev_read",IF_devRead);

  486.     addFonD("dev_write",IF_devWrite);

  487.     addFonD("dev_dflt",IF_devDflt);

  488.     addFonD("?dev_dflt",IF_devShowDflt);

  489.     addFonD("dev_dflW",IF_devDflW);

  490.     addFonD("dev_dflR",IF_devDflR);

  491.     addFonD("?i2c",IF_listI2C);

  492.     addFonD("i2c_info",IF_showI2C);

  493.     addFonD("i2c_read",IF_I2CRead);

  494.     addFonD("i2c_write",IF_I2CWrite);

  495.     addFonN("?n",IF_netList);

  496.     addFonN("netOn",IF_netOn);

  497.     addFonN("netOff",IF_netOff);

  498.     addFonN("netDt>",IF_netDt);

  499.     addFonN("netExec",IF_netExec);

  500.     addFonN("netCompile",IF_netCompile);

  501.     addFonN("ndepth",IF_netDepth);

  502.     addFonN("stopServer",IF_netStopS);

  503.     addFonN("NetServer",IF_NetServer);

  504.     addFonN("srusage",IF_netRusage);

  505.     addFonN("NetKey",IF_NetKey);

  506.     addFonN("NetErr",IF_NetErrVal);

  507.     addFonN("Me",IF_Me);

  508.     addFonN("?ns",IF_netStackList);

  509.     addFonN(">net",IF_netU2S);

  510.     addFonN("net>",IF_netS2U);

  511.     addFonN("ndrop",IF_netDropS);

  512.     /* triList(); */

  513. }

  514. 

  515. void * libByName(char * L)

  516. {

  517. int i;

  518.     for (i=0;i<NBFonc;i++) {

  519.         if (strcmp(L,Fonctions[i].nam) == 0) {

  520.            if (Fonctions[i].typ) break;

  521.            else return((void*)Fonctions[i].fct);

  522.         }

  523.     }

  524.     return VIDE;

  525. }

  526. 

  527. int execLibNrpc(char *C)

  528. {

  529. int i;

  530.     if (sigsetjmp(ENV_INT,1)) {

  531.        return 0;

  532.     }

  533.     if (IF_execFct(C)) return 1;

  534.     for (i=0;i<NBFonc;i++) {

  535.         if (strcmp(C,Fonctions[i].nam) == 0) {

  536.            switch (Fonctions[i].typ) {

  537.             case 1:

  538.             case 3: /* usr fct */

  539.               return 0;

  540.               break;

  541.             default: /* typ = 0 et 2 */

  542.               Fonctions[i].fct();

  543.               break;

  544.            }

  545.            return 1;

  546.         }

  547.     }

  548.     if (IF_execVar(C)) return 1; /* VARS DOWN */

  549.     return 0;

  550. }

  551. 

  552. int execLib(char *C)

  553. {

  554. int i;

  555. void * A;

  556. short T=0;

  557.     InExec = C;

  558.     D_Trace(C);

  559.     if (sigsetjmp(ENV_INT,1)) {

  560.        interInfos("execLib",C);

  561.        return 1;

  562.     }

  563.     if (InstallOn) {

  564.       switch (InstallOn) {

  565.         case 1 : /* lib first */

  566.           A=libByName(C);

  567.           if (A==VIDE) {

  568.              A=fctByName(C);

  569.              if (A!=VIDE) T=2;

  570.           } else T=1;

  571.           break;

  572.         case 2 : /* user functions first */

  573.           A=fctByName(C);

  574.           if (A==VIDE) {

  575.              A=libByName(C);

  576.              if (A!=VIDE) T=1;

  577.           } else T=2;

  578.           break;

  579.         case 3 : /* variables only */

  580.           A=varByName(C);

  581.           if (A!=VIDE) T=3;

  582.           break;

  583.         case 8 : /* df_init */

  584.           A=fctByName(C);

  585.           updDynFct(A,0);

  586.           break;

  587.         case 9 : /* df_start */

  588.           A=fctByName(C);

  589.           updDynFct(A,1);

  590.           break;

  591.         case 10 : /* df_stop */

  592.           A=fctByName(C);

  593.           updDynFct(A,2);

  594.           break;

  595.         default :

  596.           break;

  597.       }

  598.       _MODIF_FCT_INST_(A);

  599.       _MODIF_FCT_TYP_(T);

  600.       InstallOn=0;

  601.       return 1;

  602.     }

  603.     if ((VARS==2) && (IF_execVar(C))) return 1; /* VARS UP */

  604.     if (IF_execFct(C)) return 1;

  605.     for (i=0;i<NBFonc;i++) {

  606.         /* printf("execLib : teste %s !\n", Fonctions[i].nam); */

  607.         if (strcmp(C,Fonctions[i].nam) == 0) {

  608.            switch (Fonctions[i].typ) {

  609.             case 1:

  610.               if (fctEnCours) Fonctions[i].fct();

  611.               else messErr(13);

  612.               break;

  613.             case 2:

  614.               if (fctEnCours) messErr(25);

  615.               else Fonctions[i].fct();

  616.               break;

  617.             case 3: /* usr fct */

  618.               break;

  619.             default: /* typ = 0 */

  620.               if (fctEnCours) {

  621.                  if (strcmp(C,":") == 0) messErr(15);

  622.                  else {

  623.                     if (strcmp(C,"\"") == 0)  Fonctions[i].fct();

  624.                     else makeFct(T_LIB,(void*)Fonctions[i].fct);

  625.                  }

  626.               } else Fonctions[i].fct();

  627.               break;

  628.            }

  629.            return 1;

  630.         }

  631.     }

  632.     if ((VARS==1) && (IF_execVar(C))) return 1; /* VARS DOWN */

  633.     /* printf("execLib : appel putVal(%s)\n",C); */

  634.     return(putVal(C));

  635. }

  636. 

  637. char * libByAddr(void *A)

  638. {

  639. PFC f;

  640. int i;

  641.     f = (PFC)A;

  642.     for (i=0;i<NBFonc;i++) {

  643.         if (f == (PFC)(Fonctions[i].fct)) return Fonctions[i].nam;

  644.     }

  645.     return NULL;

  646. }