home *** CD-ROM | disk | FTP | other *** search
/ Liren Large Software Subsidy 7 / 07.iso / c / c160 / 1.ddi / SOURCE / E4FUNCTI.C < prev    next >
Encoding:
C/C++ Source or Header  |  1990-11-21  |  15.7 KB  |  564 lines
  1.  
  2. /*  e4functi.c  (c)Copyright Sequiter Software Inc., 1987-1990.    All rights reserved. */
  3.  
  4. #include "p4misc.h"
  5. #include "d4all.h"
  6. #include "e4parse.h"
  7. #include "u4error.h"
  8.  
  9. #include <string.h>
  10. #include <time.h>
  11.  
  12. #ifndef NO_POW
  13. #include <math.h>
  14. #endif
  15.  
  16. extern  BASE  *v4base ;
  17. extern  int    v4original_base_ref, v4cur_base ;
  18.  
  19. E4FUNCTIONS  v4functions[] =
  20. {
  21.    /* I_FIELD_STR, 0 */
  22.    {  0, 0,     "", (E4FUNC *) 0,      0,  T_STR, 0 },
  23.  
  24.    /* I_FIELD_LOG, 1 */
  25.    {  1, 0,     "", (E4FUNC *) 0,      0,  T_LOG, 0 },
  26.  
  27.    /* I_FIELD_DATE_D, 2 */
  28.    {  2, 0,     "", (E4FUNC *) 0,      0,  T_DATE_DOUB, 0 },
  29.  
  30.    /* I_FIELD_DATE_S, 3 */
  31.    {  3, 0,     "", (E4FUNC *) 0,      0,  T_DATE_STR, 0 },
  32.  
  33.    /* I_FIELD_NUM_D, 4 */
  34.    {  4, 0,     "", (E4FUNC *) 0,      0,  T_NUM_DOUB, 0 },
  35.  
  36.    /* I_FIELD_NUM_S, 5 */
  37.    {  5, 0,     "", (E4FUNC *) 0,      0,  T_NUM_STR, 0 },
  38.  
  39.    /* I_STRING, 6 */
  40.    {  6, 0,     "", (E4FUNC *) 0,      0,  T_STR, 0 },
  41.  
  42.    /* I_DOUBLE, 7 */
  43.    {  7, 0,     "", (E4FUNC *) 0,      0,  T_NUM_DOUB, 0 },
  44.  
  45.    {  8, 6,     ".TRUE.", e4true,  0,  T_LOG, 0 },
  46.    {  8, 3,     ".T.",    e4true,  0,  T_LOG, 0 },
  47.    { 10, 7,     ".FALSE.",e4false, 0,  T_LOG, 0 },
  48.    { 10, 3,     ".F.",    e4false, 0,  T_LOG, 0 },
  49.    { 12, 5,     ".NOT.",  e4not,   5,  T_LOG, 1, T_LOG },
  50.  
  51.    #ifdef NO_POW
  52.    { 17, 0,"", (E4FUNC *) 0,       9, T_NUM_DOUB, 2, T_NUM_DOUB, T_NUM_DOUB },
  53.    { 17, 0,"", (E4FUNC *) 0,       9, T_NUM_DOUB, 2, T_NUM_DOUB, T_NUM_DOUB },
  54.    #else
  55.    { 17, 1,"^",       e4power,       9, T_NUM_DOUB, 2, T_NUM_DOUB, T_NUM_DOUB },
  56.    { 17, 2,"**",      e4power,       9, T_NUM_DOUB, 2, T_NUM_DOUB, T_NUM_DOUB },
  57.    #endif
  58.  
  59.    { 19, 1,"#",       e4not_equal,  6, T_LOG, 2, T_STR, T_STR },
  60.    { 19, 2,"<>",      e4not_equal,  6, T_LOG, 2, T_STR, T_STR },
  61.    { 19, 2,"<>",      e4not_equal,  6, T_LOG, 2, T_NUM_DOUB, T_NUM_DOUB },
  62.    { 19, 2,"<>",      e4not_equal,  6, T_LOG, 2, T_DATE_DOUB, T_DATE_DOUB },
  63.    { 19, 2,"<>",      e4not_equal,  6, T_LOG, 2, T_LOG, T_LOG },
  64.  
  65.    { 21, 2,">=",      e4greater_eq, 6, T_LOG, 2, T_STR, T_STR },
  66.    { 21, 2,">=",      e4greater_eq, 6, T_LOG, 2, T_NUM_DOUB, T_NUM_DOUB },
  67.    { 21, 2,">=",      e4greater_eq, 6, T_LOG, 2, T_DATE_DOUB, T_DATE_DOUB },
  68.  
  69.    { 23, 2,"<=",      e4less_eq,    6, T_LOG, 2, T_STR, T_STR },
  70.    { 23, 2,"<=",      e4less_eq,    6, T_LOG, 2, T_NUM_DOUB, T_NUM_DOUB },
  71.    { 23, 2,"<=",      e4less_eq,    6, T_LOG, 2, T_DATE_DOUB, T_DATE_DOUB },
  72.  
  73.    { 25, 1,"+",       e4add,         7, T_NUM_DOUB,  2, T_NUM_DOUB, T_NUM_DOUB },
  74.    { 25, 1,"+",       e4add,         7, T_DATE_DOUB, 2, T_NUM_DOUB, T_DATE_DOUB },
  75.    { 25, 1,"+",       e4add,         7, T_DATE_DOUB, 2, T_DATE_DOUB, T_NUM_DOUB },
  76.    { 25, 1,"+",       e4concatenate, 7, T_STR,       2, T_STR, T_STR },
  77.  
  78.    { 30, 1,"-",       e4sub,         7, T_NUM_DOUB,  2, T_NUM_DOUB,    T_NUM_DOUB },
  79.    { 30, 1,"-",       e4sub,         7, T_NUM_DOUB,  2, T_DATE_DOUB, T_DATE_DOUB },
  80.    { 30, 1,"-",       e4sub,         7, T_DATE_DOUB, 2, T_DATE_DOUB, T_NUM_DOUB },
  81.    { 30, 1,"-",       e4concat_two,  7, T_STR, 2, T_STR, T_STR },
  82.  
  83.    { 40, 1,"*",       e4multiply,    8, T_NUM_DOUB, 2, T_NUM_DOUB, T_NUM_DOUB },
  84.    { 50, 1,"/",       e4divide,      8, T_NUM_DOUB, 2, T_NUM_DOUB, T_NUM_DOUB },
  85.  
  86.    { 70, 1,"$",       e4contain,    6, T_LOG, 2, T_STR, T_STR },
  87.  
  88.    { 80, 1,"=",       e4equal,      6, T_LOG, 2, T_STR, T_STR },
  89.    { 80, 1,"=",       e4equal,      6, T_LOG, 2, T_NUM_DOUB, T_NUM_DOUB },
  90.    { 80, 1,"=",       e4equal,      6, T_LOG, 2, T_DATE_DOUB, T_DATE_DOUB },
  91.    { 80, 1,"=",       e4equal,      6, T_LOG, 2, T_LOG, T_LOG },
  92.  
  93.    {100, 1,">",       e4greater,    6, T_LOG, 2, T_STR, T_STR },
  94.    {100, 1,">",       e4greater,    6, T_LOG, 2, T_NUM_DOUB, T_NUM_DOUB },
  95.    {100, 1,">",       e4greater,    6, T_LOG, 2, T_DATE_DOUB, T_DATE_DOUB },
  96.  
  97.    {110, 1,"<",       e4less,       6, T_LOG, 2, T_STR, T_STR },
  98.    {110, 1,"<",       e4less,       6, T_LOG, 2, T_NUM_DOUB, T_NUM_DOUB },
  99.    {110, 1,"<",       e4less,       6, T_LOG, 2, T_DATE_DOUB, T_DATE_DOUB },
  100.  
  101.    {150, 4,".OR.",    e4or,         3, T_LOG, 2, T_LOG, T_LOG },
  102.    {160, 5,".AND.",   e4and,        4, T_LOG, 2, T_LOG, T_LOG },
  103.  
  104.    {170, 4,"STOD",    e4stod,    0,  T_DATE_DOUB, 1, T_STR },
  105.    {175, 4,"CTOD",    e4ctod,    0,  T_DATE_DOUB, 1, T_STR },
  106.    {180, 4,"DTOS",    e4dtos,    0,  T_STR, 1, T_DATE_STR },
  107.    {180, 4,"DTOS",    e4dtos,    0,  T_STR, 1, T_DATE_DOUB },
  108.    {185, 4,"DTOC",    e4dtoc,    0,  T_STR, 1, T_DATE_STR },
  109.    {185, 4,"DTOC",    e4dtoc,    0,  T_STR, 1, T_DATE_DOUB },
  110.    {190, 4,"DATE",    e4date,    0,  T_DATE_DOUB, 0 },
  111.    {194, 3,"DAY",     e4day,     0,  T_NUM_DOUB, 1, T_DATE_DOUB },
  112.    {194, 3,"DAY",     e4day,     0,  T_NUM_DOUB, 1, T_DATE_STR },
  113.    {196, 5,"MONTH",   e4month,   0,  T_NUM_DOUB, 1, T_DATE_DOUB },
  114.    {196, 5,"MONTH",   e4month,   0,  T_NUM_DOUB, 1, T_DATE_STR },
  115.    {198, 4,"YEAR",    e4year,    0,  T_NUM_DOUB, 1, T_DATE_DOUB },
  116.    {198, 4,"YEAR",    e4year,    0,  T_NUM_DOUB, 1, T_DATE_STR },
  117.  
  118.    {200, 7,"DELETED", e4deleted, 0,  T_LOG, 0 },
  119.    {210, 3,"DEL",     e4del,     0,  T_STR, 0 },
  120.    {220, 3,"IIF",     e4iif,     0,  T_STR, 3, T_LOG, T_STR, T_STR },
  121.    {220, 3,"IIF",     e4iif,     0,  T_NUM_DOUB, 3, T_LOG, T_NUM_DOUB, T_NUM_DOUB },
  122.    {220, 3,"IIF",     e4iif,     0,  T_LOG, 3, T_LOG, T_LOG, T_LOG },
  123.    {220, 3,"IIF",     e4iif,     0,  T_DATE_DOUB, 3, T_LOG, T_DATE_DOUB, T_DATE_DOUB },
  124.    {230, 8,"RECCOUNT",e4reccount,0,  T_NUM_DOUB,  0 },
  125.    {240, 5,"RECNO",   e4recno,   0,  T_NUM_DOUB,  0 },
  126.    {250, 3,"STR",     e4str,     0,  T_STR, 3, T_NUM_DOUB, T_NUM_DOUB, T_NUM_DOUB },
  127.    {260, 6,"SUBSTR",  e4substr,  0,  T_STR, 3, T_STR, T_NUM_DOUB, T_NUM_DOUB },
  128.    {270, 4,"TIME",    e4time,    0,  T_STR, 0 },
  129.    {280, 5,"UPPER",   e4upper,   0,  T_STR, 1, T_STR },
  130.    {290, 3,"VAL",     e4val,     0,  T_NUM_DOUB, 1, T_STR },
  131.    {-1},
  132. } ;
  133.  
  134.  
  135. /* Function rules
  136.  
  137.    1.  Place the result back in parameter one.
  138.    2.  If the result is of length greater than the length of
  139.        parameter one, be aware that the result will overwrite
  140.        parameter two, ...
  141.    3.  If the type of the result is different than the type
  142.        of parameter one, place the result type in 'parms[0].type'.
  143.    4.  If the length of the result is different from the length
  144.        of parameter one, place the resulting length in 'parms[0].len'.
  145.    5.  If there is an error, put a length of '-1' in 'parms[0].len'.
  146. */
  147.  
  148. void  e4true( E4PARM *parms )
  149. {
  150.    if ( e4return_len(parms, sizeof(int)) < 0 )  return ;
  151.    parms[0].len =  sizeof(int) ;
  152.    *parms[0].p.i =  1 ;
  153.    parms[0].type =  T_LOG ;
  154. }
  155.  
  156. void  e4false( E4PARM *parms )
  157. {
  158.    if ( e4return_len(parms, sizeof(int)) < 0 )  return ;
  159.    parms[0].len =  sizeof(int) ;
  160.    *parms[0].p.i  =  0 ;
  161.    parms[0].type =  T_LOG ;
  162. }
  163.  
  164. void  e4add( E4PARM *parms )
  165. {
  166.    *parms[0].p.d +=  *parms[1].p.d ;
  167.    if ( parms[1].type == T_DATE_DOUB )
  168.       parms[0].type =  T_DATE_DOUB ;
  169. }
  170.  
  171. void  e4concatenate( E4PARM *parms )
  172. {
  173.    #ifdef PORTABLE
  174.       memcpy( parms[0].p.c+ parms[0].len, parms[1].p.c, (size_t) parms[1].len ) ;
  175.    #endif
  176.  
  177.    /* Unless there is extra alignment lJngth, the parameters are
  178.       already concatenated together. */
  179.    parms[0].len +=  parms[1].len ;
  180. }
  181.  
  182. void  e4sub( E4PARM *parms )
  183. {
  184.    *parms[0].p.d -=  *parms[1].p.d ;
  185.    if ( parms[0].type == parms[1].type )
  186.       parms[0].type =  T_NUM_DOUB ;
  187.    else
  188.       parms[0].type =  T_DATE_DOUB ;
  189. }
  190.  
  191. void  e4concat_two( E4PARM *parms )
  192. {
  193.    int   n, len ;
  194.    char *ptr ;
  195.  
  196.    /* Count the Number of Spaces to Move */
  197.    for( ptr =  parms[0].p.c + (len = parms[0].len-1), n=0;
  198.         len-- >= 0  && (*ptr == ' ' || *ptr == '\000');
  199.     n++, ptr-- ) ;
  200.  
  201.    memmove( parms[0].p.c+ (parms[0].len- n), parms[1].p.c, (size_t) parms[1].len) ;
  202.    memset( parms[0].p.c+ (parms[0].len -n) + parms[1].len, (int) ' ', (size_t) n ) ;
  203.  
  204.    parms[0].len +=  parms[1].len ;
  205. }
  206.  
  207. void  e4multiply( E4PARM *parms )
  208. {
  209.    *parms[0].p.d  *=  *parms[1].p.d ;
  210. }
  211.  
  212. void  e4divide( E4PARM *parms )
  213. {
  214.    *parms[0].p.d  /=  *parms[1].p.d ;
  215. }
  216.  
  217. #ifndef NO_POW
  218. void  e4power( E4PARM *parms )
  219. {
  220.    if ( e4return_len(parms, sizeof(double)) < 0 )  return ;
  221.    parms[0].len  =  sizeof(double) ;
  222.    parms[0].type =  T_NUM_DOUB ;
  223.    *parms[0].p.d =  pow( *parms[0].p.d, *parms[1].p.d ) ;
  224. }
  225. #endif
  226.  
  227. void  e4not_equal( E4PARM *parms )
  228. {
  229.    int  rc, len ; 
  230.  
  231.    switch( parms[1].type )
  232.    {
  233.       case T_STR:
  234.          if ( parms[0].len < parms[1].len )
  235.             len =  parms[0].len ;
  236.          else
  237.             len =  parms[1].len ;
  238.  
  239.      rc =  memcmp( parms[0].p.c, parms[1].p.c, (size_t) len) ;
  240.  
  241.          if ( rc == 0 )
  242.             if ( parms[0].len < parms[1].len )
  243.            rc = -1 ;
  244.          break ;
  245.  
  246.       case T_NUM_DOUB:
  247.       case T_DATE_DOUB:
  248.          if ( *parms[0].p.d <  *parms[1].p.d )
  249.             rc =  -1 ;
  250.          else
  251.          {
  252.             if ( *parms[0].p.d == *parms[1].p.d )
  253.                rc =  0 ;
  254.             else
  255.                rc =  1 ;
  256.          }
  257.          break ;
  258.  
  259.       case T_LOG:
  260.          /*  Equal if .T. and .T. or .F. .and .F. */
  261.          rc = ! (*parms[0].p.i &&    *parms[1].p.i  ||
  262.                ! *parms[0].p.i &&  ! *parms[1].p.i ) ;
  263.          break ;
  264.    }       
  265.  
  266.    parms[0].type =  T_LOG ;
  267.    parms[0].len  =  sizeof(int) ;
  268.    *parms[0].p.i =  rc ;
  269. }
  270.  
  271. void  e4equal( E4PARM *parms )
  272. {
  273.    e4not_equal( parms ) ;
  274.    *parms[0].p.i =  ! *parms[0].p.i ;
  275. }
  276.  
  277. void  e4greater( E4PARM *parms )
  278. {
  279.    e4not_equal( parms ) ;
  280.    *parms[0].p.i =  *parms[0].p.i > 0 ;
  281. }
  282.  
  283. void  e4less( E4PARM *parms )
  284. {
  285.    e4not_equal( parms ) ;
  286.    *parms[0].p.i =  *parms[0].p.i < 0 ;
  287. }
  288.  
  289. void  e4greater_eq( E4PARM *parms )
  290. {
  291.    e4not_equal( parms ) ;
  292.    *parms[0].p.i =  *parms[0].p.i >= 0 ;
  293. }
  294.  
  295. void  e4less_eq( E4PARM *parms )
  296. {
  297.    e4not_equal( parms ) ;
  298.    *parms[0].p.i =  *parms[0].p.i <= 0 ;
  299. }
  300.  
  301. void  e4not( E4PARM *parms )
  302. {
  303.    *parms[0].p.i =  ! *parms[0].p.i ;
  304. }
  305.  
  306. void  e4or( E4PARM *parms )
  307. {
  308.    *parms[0].p.i =  *parms[0].p.i || *parms[1].p.i ;
  309. }
  310.  
  311. void  e4and( E4PARM *parms )
  312. {
  313.    *parms[0].p.i =  *parms[0].p.i && *parms[1].p.i ;
  314. }
  315.  
  316. void  e4stod( E4PARM *parms )
  317. {
  318.    parms[0].type =  T_DATE_DOUB ;
  319.  
  320.    if ( c4dt_julian( parms[0].p.c, parms[0].p.d ) < 0 )
  321.    {
  322.       u4error( E_DATE, parms[0].p.c, (char *) 0 ) ;
  323.       parms[0].len =  -1 ;
  324.    }
  325. }
  326.  
  327. void  e4dtos( E4PARM *parms )
  328. {
  329.    double  start_date ;
  330.  
  331.    if ( parms[0].type == T_DATE_DOUB )
  332.    {
  333.       start_date =  *parms[0].p.d ;
  334.       c4dt_str( parms[0].p.c, &start_date )  ;
  335.    }
  336.    parms[0].type =  T_STR ;
  337. }
  338.  
  339. void  e4ctod( E4PARM *parms )
  340. {
  341.    char *ptr ;
  342.  
  343.    if ( e4return_len(parms, sizeof(double)) < 0 )  return ;
  344.  
  345.    parms[0].type =  T_DATE_DOUB ;
  346.  
  347.    ptr =  c4dt_unformat( parms[0].p.c, "MM/DD/YY" ) ;
  348.    if ( c4dt_julian( ptr, parms[0].p.d ) < 0 )
  349.    {
  350.       u4error( E_DATE, parms[0].p.c, (char *) 0 ) ;
  351.       parms[0].len =  -1 ;
  352.    }
  353.    else
  354.       parms[0].len =  sizeof(double) ;
  355. }
  356.  
  357. void  e4dtoc( E4PARM *parms )
  358. {
  359.    char *ptr ;
  360.    e4dtos( parms ) ;
  361.  
  362.    /* Now reformat from CCYYMMDD to MM/DD/YY */
  363.    ptr =  c4dt_format( parms[0].p.c, "MM/DD/YY" ) ;
  364.    memcpy( parms[0].p.c, ptr, (size_t) 8 ) ;
  365. }
  366.  
  367. void  e4date( E4PARM *parms )
  368. {
  369.    long        time_val ;
  370.    struct tm  *tm_ptr ;
  371.    char        dt[10] ;
  372.  
  373.    if ( e4return_len(parms, 8) < 0 )  return ;
  374.  
  375.    time ( (time_t *) &time_val) ;
  376.    tm_ptr =  localtime( (time_t *) &time_val) ;
  377.    c4ltoa( 1900L+ tm_ptr->tm_year, dt, -4 ) ;
  378.    c4ltoa( (long) tm_ptr->tm_mon+1, dt+4, -2 ) ;
  379.    c4ltoa( (long) tm_ptr->tm_mday, dt+6, -2 ) ;
  380.    c4dt_julian( dt, parms[0].p.d ) ;
  381.  
  382.    parms[0].len  =  sizeof(double) ;
  383.    parms[0].type =  T_DATE_DOUB ;
  384. }
  385.  
  386. void  e4day( E4PARM *parms )
  387. {
  388.    e4dtos( parms ) ;
  389.    *parms[0].p.d =  c4atod( parms[0].p.c+6, 2 ) ;
  390.    parms[0].type =  T_NUM_DOUB ;
  391. }
  392.  
  393. void  e4month( E4PARM *parms )
  394. {
  395.    e4dtos( parms ) ;
  396.    *parms[0].p.d =  c4atod( parms[0].p.c+4, 2 ) ;
  397.    parms[0].type =  T_NUM_DOUB ;
  398. }
  399.  
  400. void  e4year( E4PARM *parms )
  401. {
  402.    e4dtos( parms ) ;
  403.    *parms[0].p.d =  c4atod( parms[0].p.c, 4 ) ;
  404.    parms[0].type =  T_NUM_DOUB ;
  405. }
  406.  
  407. void  e4del( E4PARM *parms )
  408. {
  409.    if ( e4return_len(parms, sizeof(int)) < 0 )  return ;
  410.    *parms[0].p.c =  *v4base[v4original_base_ref].buffer ;
  411.    parms[0].len  =  1 ;
  412.    parms[0].type =  T_STR ;
  413. }
  414.  
  415. void  e4deleted( E4PARM *parms )
  416. {
  417.    if ( e4return_len(parms, sizeof(int)) < 0 )  return ;
  418.    *parms[0].p.i =  *v4base[v4original_base_ref].buffer == '*' ;
  419.    parms[0].len  =  sizeof(int) ;
  420.    parms[0].type =  T_LOG ;
  421. }
  422.  
  423. void  e4iif( E4PARM *parms )
  424. {
  425.    E4PARM  *ptr ;
  426.  
  427.    if ( *parms[0].p.i )
  428.       ptr =  parms+1 ;
  429.    else
  430.       ptr =  parms+2 ;
  431.  
  432.    memmove( parms[0].p.c, ptr->p.c, (size_t) ptr->len ) ;
  433.  
  434.    parms[0].type =  ptr->type ;
  435.    parms[0].len  =  ptr->len ;
  436. }
  437.  
  438. void  e4reccount( E4PARM *parms )
  439. {
  440.    int  save_ref ;
  441.  
  442.    save_ref      =  v4cur_base ;
  443.    v4cur_base    =  v4original_base_ref ;
  444.  
  445.    if ( e4return_len( parms, sizeof(double)) < 0 )  return ;
  446.    *parms[0].p.d =  (double) d4reccount() ;
  447.    parms[0].type =  T_NUM_DOUB ;
  448.    parms[0].len  =  sizeof(double) ;
  449.  
  450.    v4cur_base =  save_ref ;
  451. }
  452.  
  453. void  e4recno( E4PARM *parms )
  454. {
  455.    if ( e4return_len( parms, sizeof(double)) < 0 )  return ;
  456.    *parms[0].p.d =  (double) v4base[v4original_base_ref].rec_num ;
  457.    parms[0].type =  T_NUM_DOUB ;
  458.    parms[0].len  =  sizeof(double) ;
  459. }
  460.  
  461. void  e4str( E4PARM *parms )
  462. {
  463.    char *ptr ;
  464.    int   len ;
  465.  
  466.    len = (int) *parms[1].p.d ;
  467.    if ( e4return_len( parms, len) < 0 )  return ;
  468.  
  469.    ptr =  c4dtoa( *parms[0].p.d, len, (int) *parms[2].p.d ) ;
  470.    parms[0].type =  T_STR ;
  471.    parms[0].len  =  len ;
  472.    memcpy( parms[0].p.c, ptr, (size_t) len ) ;
  473. }
  474.  
  475. void  e4substr( E4PARM *parms )
  476. {
  477.    int  start_pos, len ;
  478.  
  479.    start_pos =  (int) *parms[1].p.d  - 1 ;
  480.    if ( start_pos < 0 )  start_pos =  0 ;
  481.    if ( start_pos > parms[0].len )
  482.    {
  483.       e4return_len( parms, 0 ) ;
  484.       return ;
  485.    }
  486.    len =  (int) *parms[2].p.d ;
  487.  
  488.    if ( len > parms[0].len - start_pos )
  489.       len =  parms[0].len - start_pos ;
  490.  
  491.    e4return_len( parms, len ) ;
  492.  
  493.    memmove( parms[0].p.c, parms[0].p.c+start_pos, (size_t) len ) ;
  494.    parms[0].len  =  len ;
  495. }
  496.  
  497. void  e4time( E4PARM *parms )
  498. {
  499.    long        time_val ;
  500.    struct tm  *tm_ptr ;
  501.    char       *r_ptr ;
  502.  
  503.    parms[0].type = T_STR ;
  504.    parms[0].len  =  8 ;
  505.    e4return_len( parms, 8 ) ;
  506.  
  507.    r_ptr =  parms[0].p.c ;
  508.  
  509.    time ( (time_t *) &time_val) ;
  510.    tm_ptr =  localtime( (time_t *) &time_val) ;
  511.  
  512.    c4ltoa( (long) tm_ptr->tm_hour, r_ptr, -2) ;
  513.    r_ptr+= 2 ;
  514.    *r_ptr++ = ':' ;
  515.    c4ltoa( (long) tm_ptr->tm_min, r_ptr, -2) ;
  516.    r_ptr+= 2;
  517.    *r_ptr++ = ':' ;
  518.    c4ltoa( (long) tm_ptr->tm_sec, r_ptr, -2) ;
  519.    r_ptr+= 2 ;
  520. }
  521.  
  522. void  e4upper( E4PARM *parms )
  523. {
  524.    if ( e4return_len( parms, parms[0].len+1 ) < 0 )  return ;
  525.  
  526.    parms[0].p.c[parms[0].len] = '\000' ;
  527.    u4upper( parms[0].p.c ) ;
  528. }
  529.  
  530. void  e4val( E4PARM *parms )
  531. {
  532.    if ( e4return_len(parms, (int) sizeof(double)) < 0 )  return ;
  533.    *parms[0].p.d =  c4atod( parms[0].p.c, (int) parms[0].len ) ;
  534.    parms[0].len  =  sizeof(double) ;
  535.    parms[0].type =  T_NUM_DOUB ;
  536. }
  537.  
  538. /* Is the first string contained in the second */
  539. void  e4contain( E4PARM *parms )  
  540. {
  541.    int   a_len, comp_len, i ;
  542.    char  first_char, *b_ptr ;
  543.  
  544.    parms[0].type =  T_LOG ;
  545.    e4return_len( parms, (int) sizeof(int) ) ;
  546.  
  547.    a_len      =  parms[0].len ;
  548.    first_char =  *parms[0].p.c ;
  549.    comp_len   =  parms[1].len - a_len ;
  550.    b_ptr      =  parms[1].p.c ;
  551.  
  552.    /* See if there is a match */
  553.    for ( i=0; i <= comp_len; i++ )
  554.       if ( first_char == b_ptr[i] )
  555.          if ( memcmp( parms[0].p.c, b_ptr+i, (size_t) a_len ) == 0 )
  556.          {
  557.         *parms[0].p.i =  1 ;
  558.         return ;
  559.      }
  560.  
  561.    *parms[0].p.i =  0 ;
  562.    parms[0].len  =  sizeof(int) ;
  563. }
  564.