home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / unix / volume8 / graph+ / part02 / fundeclr.c < prev   
Encoding:
C/C++ Source or Header  |  1987-03-01  |  9.2 KB  |  414 lines
  1. /*
  2.  * Copyright (C) 1986   Alan Kent
  3.  *
  4.  * Permission is granted to freely distribute part or
  5.  * all of this code as long as it is not for profit
  6.  * and this message is retained in the code.
  7.  *
  8.  * No resposibility is taken for any damage or incorect
  9.  * results this program generates.
  10.  * 
  11.  */
  12.  
  13.  
  14. #include <stdio.h>
  15. #include "graph.h"
  16. #include "y.tab.h"
  17. #include "math.h"
  18.  
  19.  
  20. extern double eval ();
  21. extern table_st *eval_tab ();
  22. extern double min_fun ();
  23. extern double max_fun ();
  24. extern double sum_fun ();
  25. extern double count_fun ();
  26. extern double average_fun ();
  27.  
  28.  
  29. #define MIN_FUN        ((attr_st *)2)
  30. #define MAX_FUN        ((attr_st *)3)
  31. #define SUM_FUN        ((attr_st *)4)
  32. #define COUNT_FUN    ((attr_st *)5)
  33. #define AVERAGE_FUN    ((attr_st *)6)
  34. #define LOG_FUN        ((attr_st *)7)
  35. #define LN_FUN        ((attr_st *)8)
  36. #define EXP_FUN        ((attr_st *)9)
  37. #define POWER_FUN    ((attr_st *)10)
  38. #define SQRT_FUN    ((attr_st *)11)
  39. #define FLOOR_FUN    ((attr_st *)12)
  40. #define CEIL_FUN    ((attr_st *)13)
  41. #define ABS_FUN        ((attr_st *)14)
  42. #define SIN_FUN        ((attr_st *)15)
  43. #define COS_FUN        ((attr_st *)16)
  44. #define ASIN_FUN    ((attr_st *)17)
  45. #define ACOS_FUN    ((attr_st *)18)
  46. #define ATAN_FUN    ((attr_st *)19)
  47. #define ATAN2_FUN    ((attr_st *)20)
  48. #define SINH_FUN    ((attr_st *)21)
  49. #define COSH_FUN    ((attr_st *)22)
  50. #define TANH_FUN    ((attr_st *)23)
  51. #define HYPOT_FUN    ((attr_st *)24)
  52. #define J0_FUN        ((attr_st *)26)
  53. #define J1_FUN        ((attr_st *)27)
  54. #define JN_FUN        ((attr_st *)28)
  55. #define Y0_FUN        ((attr_st *)29)
  56. #define Y1_FUN        ((attr_st *)30)
  57. #define YN_FUN        ((attr_st *)31)
  58.  
  59.  
  60. #define MAX_DEC        50
  61.  
  62.  
  63. static struct declare_st {
  64.     char *name;
  65.     parm_st *parm_list;
  66.     attr_st *expr;
  67.     tnode_st *tab_expr;
  68. } dec [ MAX_DEC ];
  69.  
  70. static int num_dec;
  71.  
  72.  
  73.  
  74. pdef_fun ()
  75. {
  76.     static parm_st ptab;
  77.     static parm_st pexpr1 , pexpr2;
  78.  
  79.     ptab.parm_type = TABLE;
  80.     ptab.ident = "";
  81.     ptab.next = NULL;
  82.  
  83.     pexpr1.parm_type = VALUE;
  84.     pexpr1.ident = "";
  85.     pexpr1.next = NULL;
  86.  
  87.     pexpr2.parm_type = VALUE;
  88.     pexpr2.ident = "";
  89.     pexpr2.next = &pexpr1;
  90.  
  91.     fun_declare ( "min" , &ptab , MIN_FUN , NULL );
  92.     fun_declare ( "max" , &ptab , MAX_FUN , NULL );
  93.     fun_declare ( "sum" , &ptab , SUM_FUN , NULL );
  94.     fun_declare ( "count" , &ptab , COUNT_FUN , NULL );
  95.     fun_declare ( "average" , &ptab , AVERAGE_FUN , NULL );
  96.  
  97.     fun_declare ( "sqrt" , &pexpr1 , SQRT_FUN , NULL );
  98.     fun_declare ( "log" , &pexpr1 , LOG_FUN , NULL );
  99.     fun_declare ( "ln" , &pexpr1 , LN_FUN , NULL );
  100.     fun_declare ( "exp" , &pexpr1 , EXP_FUN , NULL );
  101.     fun_declare ( "pow" , &pexpr2 , POWER_FUN , NULL );
  102.     fun_declare ( "floor" , &pexpr1 , FLOOR_FUN , NULL );
  103.     fun_declare ( "ceil" , &pexpr1 , CEIL_FUN , NULL );
  104.     fun_declare ( "abs" , &pexpr1 , ABS_FUN , NULL );
  105.  
  106.     fun_declare ( "sin" , &pexpr1 , SIN_FUN , NULL );
  107.     fun_declare ( "cos" , &pexpr1 , COS_FUN , NULL );
  108.     fun_declare ( "asin" , &pexpr1 , ASIN_FUN , NULL );
  109.     fun_declare ( "acos" , &pexpr1 , ACOS_FUN , NULL );
  110.     fun_declare ( "atan" , &pexpr1 , ATAN_FUN , NULL );
  111.     fun_declare ( "atan2" , &pexpr2 , ATAN2_FUN , NULL );
  112.     fun_declare ( "sinh" , &pexpr1 , SINH_FUN , NULL );
  113.     fun_declare ( "cosh" , &pexpr1 , COSH_FUN , NULL );
  114.     fun_declare ( "tanh" , &pexpr1 , TANH_FUN , NULL );
  115.  
  116.     fun_declare ( "hypot" , &pexpr2 , HYPOT_FUN , NULL );
  117.  
  118.     fun_declare ( "j0" , &pexpr1 , J0_FUN , NULL );
  119.     fun_declare ( "j1" , &pexpr1 , J1_FUN , NULL );
  120.     fun_declare ( "jn" , &pexpr2 , JN_FUN , NULL );
  121.     fun_declare ( "y0" , &pexpr1 , Y0_FUN , NULL );
  122.     fun_declare ( "y1" , &pexpr1 , Y1_FUN , NULL );
  123.     fun_declare ( "yn" , &pexpr2 , YN_FUN , NULL );
  124. }
  125.  
  126.  
  127. fun_declare ( name , parm_list , expr , tab_expr )
  128. char *name;
  129. parm_st *parm_list;
  130. attr_st *expr;
  131. tnode_st *tab_expr;
  132. {
  133.     int i;
  134.  
  135.     for ( i = 0; i < num_dec; i++ ) {
  136.     if ( strcmp ( name , dec[i].name ) == 0 ) {
  137.         abort ( "cannot redeclare functions: '%s'" , name );
  138.         return;
  139.     }
  140.     }
  141.     if ( num_dec >= MAX_DEC )
  142.     abort ( "Internal array overflow - too many functions declared" );
  143.     dec[num_dec].name = name;
  144.     dec[num_dec].parm_list = parm_list;
  145.     dec[num_dec].expr = expr;
  146.     dec[num_dec].tab_expr = tab_expr;
  147.     num_dec++;
  148. }
  149.  
  150.  
  151. double
  152. call_var_fun ( name , parm_list , table , row )
  153. char *name;
  154. parm_st *parm_list;
  155. table_st *table;
  156. int row;
  157. {
  158.     int i;
  159.     double value;
  160.     parm_st *p1 , *p2;
  161. #define MAX_TAB 3
  162. #define MAX_VAR 3
  163.     table_st *tab_parm[ MAX_TAB ];
  164.     double var_parm[ MAX_VAR ];
  165.     int tab_num , var_num;
  166.  
  167.     for ( i = 0; i < num_dec; i++ ) {
  168.     if ( strcmp ( dec[i].name , name ) == 0 ) {
  169.  
  170.         if ( dec[i].expr == NULL )
  171.         abort ( "value function with no expression found" );
  172.  
  173.         p1 = parm_list;
  174.         p2 = dec[i].parm_list;
  175.         var_num = 0;
  176.         tab_num = 0;
  177.         while ( p1 != NULL  &&  p2 != NULL ) {
  178.  
  179.         if ( p1->parm_type != p2->parm_type )
  180.             abort ( "type mismatch for parameter to function '%s'" , name );
  181.  
  182.         if ( p1->parm_type == TABLE ) {
  183.             tab_parm[ tab_num ] = eval_tab ( p1->tab_expr );
  184.             tab_declare ( p2->ident , tab_parm[ tab_num ] );
  185.             if ( tab_num + 1 < MAX_TAB )
  186.             tab_num++;
  187.         }
  188.         else {
  189.             var_parm[ var_num ] = eval ( table , row , p1->expr );
  190.             var_declare ( p2->ident , var_parm[ var_num ] );
  191.             if ( var_num + 1 < MAX_VAR )
  192.             var_num++;
  193.         }
  194.         p1 = p1->next;
  195.         p2 = p2->next;
  196.         }
  197.         if ( p1 != NULL  ||  p2 != NULL )
  198.         abort ( "illegal parameter list for function '%s'" , name );
  199.  
  200.         switch ( dec[i].expr ) {
  201.  
  202.         case MIN_FUN :
  203.         value = min_fun ( tab_parm[0] , 0 , tab_parm[0]->size );
  204.         break;
  205.  
  206.         case MAX_FUN :
  207.         value = max_fun ( tab_parm[0] , 0 , tab_parm[0]->size );
  208.         break;
  209.  
  210.         case SUM_FUN :
  211.         value = sum_fun ( tab_parm[0] , 0 , tab_parm[0]->size );
  212.         break;
  213.  
  214.         case COUNT_FUN :
  215.         value = count_fun ( tab_parm[0] , 0 , tab_parm[0]->size );
  216.         break;
  217.  
  218.         case AVERAGE_FUN :
  219.         value = average_fun ( tab_parm[0] , 0 , tab_parm[0]->size );
  220.         break;
  221.  
  222.         case LOG_FUN :
  223.         value = log10 ( var_parm[0] );
  224.         break;
  225.         
  226.         case LN_FUN :
  227.         value = log ( var_parm[0] );
  228.         break;
  229.  
  230.         case EXP_FUN :
  231.         value = exp ( var_parm[0] );
  232.         break;
  233.         
  234.         case POWER_FUN :
  235.         value = pow ( var_parm[0] , var_parm[1] );
  236.         break;
  237.         
  238.         case SQRT_FUN :
  239.         value = sqrt ( var_parm[0] );
  240.         break;
  241.         
  242.         case FLOOR_FUN :
  243.         value = floor ( var_parm[0] );
  244.         break;
  245.         
  246.         case CEIL_FUN :
  247.         value = ceil ( var_parm[0] );
  248.         break;
  249.         
  250.         case ABS_FUN :
  251.         value = fabs ( var_parm[0] );
  252.         break;
  253.         
  254.         case SIN_FUN :
  255.         value = sin ( var_parm[0] );
  256.         break;
  257.  
  258.         case COS_FUN :
  259.         value = cos ( var_parm[0] );
  260.         break;
  261.  
  262.         case ASIN_FUN :
  263.         value = asin ( var_parm[0] );
  264.         break;
  265.  
  266.         case ACOS_FUN :
  267.         value = acos ( var_parm[0] );
  268.         break;
  269.  
  270.         case ATAN_FUN :
  271.         value = atan ( var_parm[0] );
  272.         break;
  273.  
  274.         case ATAN2_FUN :
  275.         value = atan2 ( var_parm[0] , var_parm[1] );
  276.         break;
  277.  
  278.         case SINH_FUN :
  279.         value = sinh ( var_parm[0] );
  280.         break;
  281.  
  282.         case COSH_FUN :
  283.         value = cosh ( var_parm[0] );
  284.         break;
  285.  
  286.         case TANH_FUN :
  287.         value = tanh ( var_parm[0] );
  288.         break;
  289.  
  290.         case HYPOT_FUN :
  291.         value = hypot ( var_parm[0] , var_parm[1] );
  292.         break;
  293.  
  294.         case J0_FUN :
  295.         value = sin ( var_parm[0] );
  296.         break;
  297.  
  298.         case J1_FUN :
  299.         value = j1 ( var_parm[0] );
  300.         break;
  301.  
  302.         case JN_FUN :
  303.         value = jn ( var_parm[0] );
  304.         break;
  305.  
  306.         case Y0_FUN :
  307.         value = y0 ( var_parm[0] );
  308.         break;
  309.  
  310.         case Y1_FUN :
  311.         value = y1 ( var_parm[0] );
  312.         break;
  313.  
  314.         case YN_FUN :
  315.         value = yn ( var_parm[0] );
  316.         break;
  317.  
  318.         default :
  319.         value = eval ( table , row , dec[i].expr );
  320.         break;
  321.         }
  322.         return ( value );
  323.     }
  324.     }
  325.     abort ( "Undefined function '%s' referenced" , name );
  326. }
  327.  
  328.  
  329. table_st *
  330. call_tab_fun ( name , parm_list , table , row )
  331. char *name;
  332. parm_st *parm_list;
  333. table_st *table;
  334. int row;
  335. {
  336.     int i;
  337.     table_st *newtab;
  338.     parm_st *p1 , *p2;
  339.  
  340.     for ( i = 0; i < num_dec; i++ ) {
  341.     if ( strcmp ( dec[i].name , name ) == 0 ) {
  342.         if ( dec[i].tab_expr == NULL )
  343.         abort ( "table function with no expression found" );
  344.         p1 = parm_list;
  345.         p2 = dec[i].parm_list;
  346.         while ( p1 != NULL  &&  p2 != NULL ) {
  347.         if ( p1->parm_type != p2->parm_type )
  348.             abort ( "type mismatch for parameter to function '%s'" , name );
  349.         if ( p1->parm_type == TABLE )
  350.             tab_declare ( p2->ident , eval_tab ( p1->tab_expr ) );
  351.         else
  352.             var_declare ( p2->ident , eval ( table , row , p1->expr ) );
  353.         p1 = p1->next;
  354.         p2 = p2->next;
  355.         }
  356.         if ( p1 != NULL  ||  p2 != NULL )
  357.         abort ( "illegal parameter list for function '%s'" , name );
  358.         newtab = eval_tab ( dec[i].tab_expr );
  359.         return ( newtab );
  360.     }
  361.     }
  362.     abort ( "Undefined function '%s' referenced" , name );
  363. }
  364.  
  365.  
  366.  
  367. is_fvar_ident ( name )
  368. char *name;
  369. {
  370.     int i;
  371.  
  372.     for ( i = 0; i < num_dec; i++ ) {
  373.     if ( strcmp ( dec[i].name , name ) == 0 ) {
  374.         return ( dec[i].expr != NULL );
  375.     }
  376.     }
  377.     return ( 0 );
  378. }
  379.  
  380.  
  381.  
  382. is_ftab_ident ( name )
  383. char *name;
  384. {
  385.     int i;
  386.  
  387.     for ( i = 0; i < num_dec; i++ ) {
  388.     if ( strcmp ( dec[i].name , name ) == 0 ) {
  389.         return ( dec[i].expr == NULL );
  390.     }
  391.     }
  392.     return ( 0 );
  393. }
  394.  
  395.  
  396.  
  397. check_group_fun ( name )
  398. char *name;
  399. {
  400.     int i;
  401.  
  402.     for ( i = 0; i < num_dec; i++ ) {
  403.     if ( strcmp ( dec[i].name , name ) == 0 ) {
  404.         if ( dec[i].expr == NULL )
  405.         abort ( "function '%s' must return a value" , name );
  406.         if ( dec[i].parm_list == NULL
  407.         ||   dec[i].parm_list->next != NULL
  408.         ||   dec[i].parm_list->parm_type != TABLE )
  409.         abort ( "function '%s' expects a single table as parameters" );
  410.         return;
  411.     }
  412.     }
  413. }
  414.