home *** CD-ROM | disk | FTP | other *** search
/ Columbia Kermit / kermit.zip / panix / k95source.tar.gz / k95source.tar / fneval.c < prev    next >
C/C++ Source or Header  |  1997-03-31  |  24KB  |  892 lines
  1. From fdc@watsun.cc.columbia.edu Mon Mar 31 18:52:00 1997
  2. Flags: 000000000005
  3. Received: (from fdc@localhost)
  4.     by watsun.cc.columbia.edu (8.8.5/8.8.5) id SAA12688;
  5.     Mon, 31 Mar 1997 18:51:59 -0500 (EST)
  6. Date: Mon, 31 Mar 1997 18:51:59 -0500 (EST)
  7. From: Frank da Cruz <fdc@watsun.cc.columbia.edu>
  8. Message-Id: <199703312351.SAA12688@watsun.cc.columbia.edu>
  9. To: jaltman@watsun.cc.columbia.edu
  10. Subject: New fneval()
  11.  
  12. I'm also going to put this in the patch file, but without the #ifdef OS2
  13. parts...
  14.  
  15. ---(cut)---
  16. static char *                /* Evaluate builtin functions */
  17. fneval(fn,argp,argn,xp) char *fn, *argp[]; int argn; char * xp; {
  18.     int i, j, k, len1, len2, len3, n, x, y;
  19.     char *bp[FNARGS + 1];        /* Pointers to malloc'd strings */
  20.     char c;
  21.     char *p, *s;
  22.     char *val1, *val2;            /* Pointers to numeric string values */
  23. /*
  24.   IMPORTANT: Note that argn is not an accurate count of the number of
  25.   arguments.  We can't really tell if an argument is null until after we
  26.   execute the code below.  So argn is really the maximum number of arguments
  27.   we might have.  In particular note that argn is always at least 1, even
  28.   if the function is called with empty parentheses (but don't count on it).
  29. */
  30.     if (!fn) fn = "";            /* Protect against null pointers */
  31.     debug(F111,"fneval",fn,argn);
  32.     debug(F110,"fneval",argp[0],0);
  33.     if (argn > FNARGS) argn = FNARGS;    /* And too many arguments */
  34.  
  35.     y = lookup(fnctab,fn,nfuncs,&x);
  36.     if (y < 0)                /* bad function name */
  37.       return("");            /* so value is null */
  38.  
  39. #ifdef DEBUG
  40.     if (deblog) {
  41.     int j;
  42.     for (j = 0; j < argn; j++)
  43.       debug(F111,"fneval function arg",argp[j],j);
  44.     }
  45. #endif /* DEBUG */
  46. /*
  47.   \fliteral() and \fcontents() are special functions that do not evaluate
  48.   their arguments, and are treated specially here.  After these come the
  49.   functions whose arguments are evaluated in the normal way.
  50. */
  51.     if (y == FN_LIT) {            /* literal(arg1) */
  52.     debug(F110,"flit",xp,0);
  53.     return(xp ? xp : "");        /* return a pointer to arg itself */
  54.     }
  55.     if (y == FN_CON) {            /* Contents of variable, unexpanded. */
  56.     char c;
  57.     if (!(p = argp[0]) || !*p) return("");
  58.     p = brstrip(p);
  59.     if (*p == CMDQ) p++;
  60.     if ((c = *p) == '%') {        /* Scalar variable. */
  61.         c = *++p;            /* Get ID character. */
  62.         p = "";            /* Assume definition is empty */
  63.         if (!c) return(p);        /* Double paranoia */
  64.         if (c >= '0' && c <= '9') { /* Digit for macro arg */
  65.         if (maclvl < 0)        /* Digit variables are global */
  66.           p = g_var[c];        /* if no macro is active */
  67.         else            /* otherwise */
  68.           p = m_arg[maclvl][c - '0']; /* they're on the stack */
  69.         } else {
  70.         if (isupper(c)) c -= ('a'-'A');
  71.         p = g_var[c];        /* Letter for global variable */
  72.         }
  73.         return(p ? p : "");
  74.     }
  75.     if (c == '&') {            /* Array reference. */
  76.         int vbi, d;
  77.         if (arraynam(p,&vbi,&d) < 0) /* Get name and subscript */
  78.           return("");
  79.         if (chkarray(vbi,d) > 0) {    /* Array is declared? */
  80.         vbi -= ARRAYBASE;    /* Convert name to index */
  81.         if (a_dim[vbi] >= d) {    /* If subscript in range */
  82.             char **ap;
  83.             ap = a_ptr[vbi];    /* get data pointer */
  84.             if (ap) {        /* and if there is one */
  85.             return(ap[d]);    /* return what it points to */
  86.             }
  87.         }
  88.         } else return("");
  89.     }
  90.     }
  91.  
  92.     for (i = 0; i < FNARGS; i++)    /* Initialize all argument pointers */
  93.       bp[i] = NULL;
  94.  
  95.     for (i = 0; i < argn; i++) {    /* Loop to expand each argument */
  96.     n = MAXARGLEN;            /* Allow plenty of space */
  97.     bp[i] = s = malloc(n+1);    /* Allocate space for this argument */
  98.     if (bp[i] == NULL) {        /* handle failure to get space */
  99.         for (k = 0; k < i; k++) if (bp[k]) free(bp[k]);
  100.         debug(F101,"fneval malloc failure, arg","",i);
  101.         return("");
  102.     }
  103.     p = argp[i] ? argp[i] : "";    /* Point to this argument */
  104.  
  105. /*
  106.   Trim leading and trailing spaces from the original argument, before
  107.   evaluation.  This code new to edit 184.
  108. */
  109.     {
  110.         int x, j;
  111.         x = strlen(p);
  112.         if (*p == '{' && *(p+x-1) == '}') {
  113.         p[x-1] = NUL;
  114.         p++;
  115.         x -= 2;
  116.         } else {
  117.         j = x - 1;        /* Trim trailing whitespace */
  118.         while (j > 0 && (*(p + j) == SP || *(p + j) == HT))
  119.           *(p + j--) = NUL;
  120.         while (*p == SP || *p == HT) /* Strip leading whitespace */
  121.           p++;
  122.         }
  123.     }
  124.  
  125. /* Now evaluate the argument */
  126.  
  127.     if (zzstring(p,&s,&n) < 0) {    /* Expand arg into new space */
  128.         debug(F101,"fneval xxstring fails, arg","",i);
  129.         for (k = 0; k <= i; k++)    /* Free up previous space on error */
  130.           if (bp[k]) free(bp[k]);
  131.         return("");            /* and return null string. */
  132.     }
  133.     debug(F111,"fneval arg",bp[i],i);
  134.     }
  135.  
  136. #ifdef DEBUG
  137.     if (deblog) {
  138.     int j;
  139.     for (j = 0; j < argn; j++) {
  140.         debug(F111,"fneval arg post eval",argp[j],j);
  141.         debug(F111,"fneval evaluated arg",bp[j],j);
  142.     }
  143.     }
  144. #endif /* DEBUG */
  145. /*
  146.   At this point bp[0..argn-1] are not NULL and all must be freed
  147.   before returning.
  148. */
  149.     switch (y) {            /* Do function on expanded args */
  150.  
  151.       case FN_DEF:            /* \fdefinition(arg1) */
  152.     if (!bp[0]) return("");
  153.     k = mlook(mactab,bp[0],nmac);
  154.     p = (k > -1) ? mactab[k].mval : "";
  155.     for (k = 0; k < argn; k++) if (bp[k]) free(bp[k]);
  156.     return(p ? p : "");
  157.  
  158.       case FN_EVA:            /* \fevaluate(arg1) */
  159.     p = "";
  160.     if (argn > 0)
  161.       p = *(bp[0]) ? evala(bp[0]) : "";
  162.     for (k = 0; k < argn; k++) if (bp[k]) free(bp[k]);
  163.     return(p ? p : "");
  164.  
  165.       case FN_EXE:            /* \fexecute(arg1) */
  166.     if (argn < 1) return("");
  167.     j = (int)strlen(s = bp[0]);    /* Length of macro invocation */
  168.     p = "";                /* Initialize return value to null */
  169.     if (j) {            /* If there is a macro to execute */
  170.         while (*s == SP) s++,j--;    /* strip leading spaces */
  171.         p = s;            /* remember beginning of macro name */
  172.         for (i = 0; i < j; i++) {    /* find end of macro name */
  173.         if (*s == SP)
  174.           break;
  175.         s++;
  176.         }
  177.         if (*s == SP)     {    /* if there was a space after */
  178.         *s++ = NUL;        /* terminate the macro name */
  179.         while (*s == SP) s++;    /* skip past any extra spaces */
  180.         } else s = "";        /* maybe there are no arguments */
  181.         if (p && *p)
  182.           k = mlook(mactab,p,nmac);    /* Look up the macro name */
  183.         else k = -1;
  184. /*
  185.   This is just a WEE bit dangerous because we are copying up to 9 arguments
  186.   into the space reserved for one.  It won't overrun the buffer, but if there
  187.   are lots of long arguments we might lose some.  The other problem is that if
  188.   the macro has more than 3 arguments, the 4th through last are all
  189.   concatenated onto the third.  (The workaround is to use spaces rather than
  190.   commas to separate them.)  Leaving it like this to avoid having to allocate
  191.   tons more buffers.
  192. */
  193.         if (argn > 1) {        /* Commas used instead of spaces */
  194.         int i;
  195.         char *p = bp[0];    /* Reuse this space */
  196.         *p = NUL;        /* Make into dodo() arg list */
  197.         for (i = 1; i < argn; i++) {
  198.             strncat(p,bp[i],MAXARGLEN);
  199.             strncat(p," ",MAXARGLEN);
  200.         }            
  201.         s = bp[0];        /* Point to new list */
  202.         }
  203.         p = "";            /* Initialize return value */
  204.         if (k >= 0) {        /* If macro found in table */
  205.         /* Go set it up (like DO cmd) */
  206.         if ((j = dodo(k,s,cmdstk[cmdlvl].ccflgs)) > 0) {
  207.             if (cmpush() > -1) { /* Push command parser state */
  208.             extern int ifc;
  209.             int ifcsav = ifc; /* Push IF condition on stack */
  210.             k = parser(1);    /* Call parser to execute the macro */
  211.             cmpop();    /* Pop command parser */
  212.             ifc = ifcsav;    /* Restore IF condition */
  213.             if (k == 0) {    /* No errors, ignore action cmds. */
  214.                 p = mrval[maclvl+1]; /* If OK, set return value. */
  215.                 if (p == NULL) p = "";
  216.             }
  217.             } else {        /* Can't push any more */
  218.             debug(F100,"fexec pushed too deep","",0);
  219.                         printf("\n?\\fexec() too deeply nested\n");
  220.             while (cmpop() > -1) ;
  221.             p = "";
  222.             }
  223.         }
  224.         }
  225.     }
  226.     for (k = 0; k < argn; k++) if (bp[k]) free(bp[k]);
  227.     return(p ? p : "");
  228.  
  229.       case FN_FC:            /* \ffiles() - File count. */
  230.     if (argn < 1) return("0");
  231.     if (*(bp[0])) {
  232.         k = zxpand(bp[0]);
  233.         sprintf(fnval,"%d",k);
  234.         p = fnval;
  235.     } else p = "0";
  236.     for (k = 0; k < argn; k++) if (bp[k]) free(bp[k]);
  237.     return(p);
  238.  
  239.       case FN_FIL:            /* \fnextfile() - Next file in list. */
  240.     p = fnval;            /* (no args) */
  241.     *p = NUL;
  242.     znext(p);
  243.     for (k = 0; k < argn; k++) if (bp[k]) free(bp[k]);
  244.     return(p ? p : "");
  245.  
  246.       case FN_IND:            /* \findex(arg1,arg2,arg3) */
  247.       case FN_RIX:            /* \frindex(arg1,arg2,arg3) */
  248.     p = "0";
  249.     if (argn > 1) {            /* Only works if we have 2 or 3 args */
  250.         int start;
  251.         len1 = (int)strlen(bp[0]);    /* length of string to look for */
  252.         len2 = (int)strlen(s = bp[1]); /* length of string to look in */
  253.         if (len1 < 1 || len2 < 1)    /* Watch out for empty strings */
  254.           goto indexfin;
  255.         j = len2 - len1;        /* length difference */
  256.         start = (y == FN_IND) ? 0 : j; /* Starting position */
  257.         if (argn > 2) {
  258.         val1 = *(bp[2]) ? evala(bp[2]) : "";
  259.         if (chknum(val1)) {
  260.             int t;
  261.             t = atoi(val1) - 1;
  262.             if (t < 0) t = 0;
  263.             start = (y == FN_IND) ? t : start - t - 1;
  264.             if (start < 0) start = 0;
  265.         }
  266.         }
  267.         start = ckindex(bp[0],bp[1],start,(y==FN_IND)?0:1,inpcas[cmdlvl]);
  268.         sprintf(fnval,"%d",start);
  269.         p = fnval;
  270.     }
  271.       indexfin:
  272.     for (k = 0; k < argn; k++) if (bp[k]) free(bp[k]);
  273.     return(p);
  274.  
  275.       case FN_RPL:            /* \freplace(s1,s2,s3) */
  276.       /*
  277.     s = bp[0] = source string
  278.         bp[1] = match string
  279.         bp[2] = replacement string
  280.     p = fnval = destination (result) string
  281.       */
  282.     if (argn < 1) return("");
  283.     p = fnval;
  284.     if (argn < 2) {            /* Only works if we have 2 or 3 args */
  285.         strcpy(p,bp[0]);
  286.     } else  {            
  287.         len1 = (int)strlen(bp[0]);    /* length of string to look in */
  288.         len2 = (int)strlen(bp[1]);    /* length of string to look for */
  289.         len3 = (argn < 3) ? 0 : (int)strlen(bp[2]); /* Len of replacemnt */
  290.         j = len1 - len2 + 1;
  291.         if (j < 1 || len1 == 0 || len2 == 0) { /* Args out of whack */
  292.         strcpy(p,bp[0]);    /* so just return original string */
  293.         } else {
  294.         s = bp[0];        /* Point to beginning of string */
  295.         while (j--) {        /* For each character */
  296.             if (inpcas[cmdlvl] ?
  297.             !strncmp(bp[1],s,len2) :
  298.             !xxstrcmp(bp[1],s,len2) ) { /* To be replaced? */
  299.             if (len3) {            /* Yes, */
  300.                 strncpy(p,bp[2],len3);  /* replace it */
  301.                 p += len3;
  302.             }
  303.             s += len2;                /* and skip past it. */
  304.             } else {        /* No, */
  305.             *p++ = *s++;    /* just copy this character */
  306.             }
  307.         }
  308.         *p = NUL;
  309.         while (*p++ = *s++);
  310.         }
  311.     }
  312.     for (k = 0; k < argn; k++) if (bp[k]) free(bp[k]);
  313.     return(p = fnval);
  314.  
  315.       case FN_CHR:            /* \fcharacter(arg1) */
  316.     if (argn < 1) return("");
  317.     val1 = *(bp[0]) ? evala(bp[0]) : "";
  318.     if (chknum(val1)) {        /* Must be numeric */
  319.         i = atoi(val1);
  320.         if (i >= 0 && i < 256) {    /* Must be an 8-bit value */
  321.         p = fnval;
  322.         *p++ = (char) i;
  323.         *p = NUL;
  324.         p = fnval;
  325.         } else p = "";        /* Otherwise return empty string */
  326.     } else p = "";            /* Otherwise return empty string */
  327.     for (k = 0; k < argn; k++) if (bp[k]) free(bp[k]);
  328.     return(p);
  329.  
  330.       case FN_COD:            /* \fcode(char) */
  331.     if (argn < 1) return("");
  332.     if ((int)strlen(bp[0]) > 0) {
  333.         p = fnval;
  334.         i = *bp[0];
  335.         sprintf(p,"%d",(i & 0xff));
  336.     } else p = "";
  337.     for (k = 0; k < argn; k++) if (bp[k]) free(bp[k]);
  338.     return(p);
  339.  
  340.       case FN_LEN:            /* \flength(arg1) */
  341.     if (argn > 0) {
  342.         p = fnval;
  343.         sprintf(p,"%d",(int)strlen(bp[0]));
  344.     } else p = "0";
  345.     for (k = 0; k < argn; k++) if (bp[k]) free(bp[k]);
  346.     return(p);
  347.  
  348.       case FN_LOW:            /* \flower(arg1) */
  349.     if (argn < 1) return("");
  350.     s = bp[0];
  351.     p = fnval;
  352.  
  353.     while (*s) {
  354.         if (isupper(*s))
  355.           *p = (char) tolower(*s);
  356.         else
  357.           *p = *s;
  358.         p++; s++;
  359.     }
  360.     *p = NUL;
  361.     for (k = 0; k < argn; k++) if (bp[k]) free(bp[k]);
  362.     p = fnval;
  363.     return(p);
  364.  
  365.       case FN_MAX:            /* \fmax(arg1,arg2) */
  366.       case FN_MIN:            /* \fmin(arg1,arg2) */
  367.       case FN_MOD:            /* \fmod(arg1,arg2) */
  368.     if (argn < 2) return("");
  369.     val1 = *(bp[0]) ? evala(bp[0]) : "";
  370.     free(bp[0]);            /* Copy this because evala() returns */
  371.     bp[0] = malloc((int)strlen(val1)+1); /* pointer to same */
  372.     strcpy(bp[0],val1);
  373.     val1 = bp[0];            /* buffer next time. */
  374.     val2 = *(bp[1]) ? evala(bp[1]) : "";
  375.     if (chknum(val1) && chknum(val2)) {
  376.         i = atoi(val1);
  377.         j = atoi(val2);
  378.         switch (y) {
  379.           case FN_MAX:
  380.         if (j < i) j = i;
  381.         break;
  382.           case FN_MIN:
  383.         if (j > i) j = i;
  384.         break;
  385.           case FN_MOD:
  386.         if (j == 0) { p = ""; goto modfin; }
  387.         j = i % j;
  388.         break;
  389.         }
  390.         p = fnval;
  391.         sprintf(p,"%d",j);
  392.     } else p = "";
  393.       modfin:
  394.     for (k = 0; k < argn; k++) if (bp[k]) free(bp[k]);
  395.     return(p);
  396.  
  397.       case FN_SUB:            /* \fsubstr(arg1,arg2,arg3) */
  398.       case FN_RIG:            /* \fright(arg1,arg2) */
  399.     if (argn < 1) return("");
  400.     val1 = "";
  401.     if (argn > 1)
  402.       if (*(bp[1]))
  403.         val1 =  evala(bp[1]);
  404.     free(bp[1]);            /* Have to copy this */
  405.     bp[1] = malloc((int)strlen(val1)+1);
  406.     strcpy(bp[1],val1);
  407.     val1 = bp[1];
  408.     val2 = "";
  409.     if (argn > 2)
  410.       if (*(bp[2]))
  411.         val2 = evala(bp[2]);
  412.     if (
  413.         ((argn > 1) && (int)strlen(val1) && !rdigits(val1)) ||
  414.         ((y == FN_SUB) &&
  415.           ((argn > 2) && (int)strlen(val2) && !rdigits(val2)))
  416.         ) {
  417.         p = "";            /* if either, return null */
  418.     } else {
  419.         int lx;
  420.         p = fnval;            /* pointer to result */
  421.         lx = strlen(bp[0]);        /* length of arg1 */
  422.         if (y == FN_SUB) {        /* substring */
  423.         k = (argn > 2) ? atoi(val2) : MAXARGLEN; /* length */
  424.         j = (argn > 1) ? atoi(val1) : 1; /* start pos for substr */
  425.         } else {                 /* right */
  426.         k = (argn > 1) ? atoi(val1) : lx; /* length */
  427.         j = lx - k + 1;             /* start pos for right */
  428.         if (j < 1) j = 1;
  429.         }
  430.         if (k > 0 && j <= lx) {          /* if start pos in range */
  431.         s = bp[0]+j-1;             /* point to source string */
  432.         for (i = 0; (i < k) && (*p++ = *s++); i++) ;  /* copy */
  433.         }
  434.         *p = NUL;            /* terminate the result */
  435.         p = fnval;            /* and point to it. */
  436.     }
  437.     for (k = 0; k < argn; k++) if (bp[k]) free(bp[k]); /* Free temp mem */
  438.     return(p);
  439.  
  440.       case FN_UPP:            /* \fupper(arg1) */
  441.     s = bp[0] ? bp[0] : "";
  442.     p = fnval;
  443.     while (*s) {
  444.         if (islower(*s))
  445.           *p = (char) toupper(*s);
  446.         else
  447.           *p = *s;
  448.         p++; s++;
  449.     }
  450.     *p = NUL;
  451.     for (k = 0; k < argn; k++) if (bp[k]) free(bp[k]);
  452.     p = fnval;
  453.     return(p);
  454.  
  455.       case FN_REP:            /* \frepeat(text,number) */
  456.     if (argn < 1) return("");
  457.     p = fnval;            /* Return value */
  458.     *p = NUL;
  459.     val1 = "1";
  460.     if (argn > 1)
  461.       if (*(bp[1]))
  462.         val1 = evala(bp[1]);
  463.     if (chknum(val1)) {        /* Repeat count */
  464.         n = atoi(val1);
  465.         if (n > 0) {        /* Make n copies */
  466.         p = fnval;
  467.         *p = '\0';
  468.         k = (int)strlen(bp[0]);    /* Make sure string has some length */
  469.         if (k > 0) {
  470.             for (i = 0; i < n; i++) {
  471.             s = bp[0];
  472.             for (j = 0; j < k; j++) {
  473.                 if ((p - fnval) >= FNVALL) { /* Protect against */
  474.                 p = "";                 /* core dumps... */
  475.                 break;
  476.                 } else *p++ = *s++;
  477.             }
  478.             }
  479.             *p = NUL;
  480.         }
  481.         }
  482.     }
  483.     for (k = 0; k < argn; k++) if (bp[k]) free(bp[k]);
  484.     p = fnval;
  485.     return(p);
  486.  
  487. #ifndef NOFRILLS
  488.       case FN_REV:            /* \freverse() */
  489.     if (argn < 1) return("");
  490.     p = fnval;
  491.     yystring(bp[0],&p);
  492.     for (k = 0; k < argn; k++) if (bp[k]) free(bp[k]);
  493.     return(p);
  494. #endif /* NOFRILLS */
  495.  
  496.       case FN_RPA:            /* \frpad() and \flpad() */
  497.       case FN_LPA:
  498.     if (argn < 1) return("");
  499.     *fnval = NUL;            /* Return value */
  500.     val1 = "";
  501.     if (argn > 1)
  502.       if (*(bp[1]))
  503.         val1 = evala(bp[1]);
  504.     if (argn == 1 || !*val1) {    /* If a number wasn't given */
  505.         p = fnval;            /* just return the original string */
  506.         strncpy(p,bp[0],FNVALL);
  507.     } else if (chknum(val1)) {    /* Repeat count */
  508.         char pc;
  509.         n = atoi(val1);
  510.         if (n >= 0) {
  511.         p = fnval;
  512.         k = (int)strlen(bp[0]);    /* Length of string to be padded */
  513.         if (k >= n) {        /* It's already long enough */
  514.             strncpy(p,bp[0],FNVALL);
  515.         } else {
  516.             if (n + k <= FNVALL) {
  517.             pc = (char) ((argn < 3) ? SP : *bp[2]);
  518.             if (!pc) pc = SP;
  519.             if (y == FN_RPA) { /* RPAD */
  520.                 strncpy(p,bp[0],k);
  521.                 p += k;
  522.                 for (i = k; i < n; i++)
  523.                   *p++ = pc;
  524.             } else {    /* LPAD */
  525.                 n -= k;
  526.                 for (i = 0; i < n; i++)
  527.                   *p++ = pc;
  528.                 strncpy(p,bp[0],k);
  529.                 p += k;
  530.             }
  531.             }
  532.             *p = NUL;
  533.         }
  534.         }
  535.     }
  536.     for (k = 0; k < argn; k++) if (bp[k]) free(bp[k]);
  537.     p = fnval;
  538.     return(p);
  539.  
  540. #ifdef ZFCDAT
  541.       case FN_FD:            /* \fdate(filename) */
  542.     p = fnval;
  543.     *p = NUL;
  544.     if (argn > 0)
  545.       sprintf(fnval,"%s",*(bp[0]) ? zfcdat(bp[0]) : "");
  546.     for (k = 0; k < argn; k++) if (bp[k]) free(bp[k]);
  547.     return(p);
  548. #endif /* ZFCDAT */
  549.  
  550.       case FN_FS:            /* \fsize(filename) */
  551.     p = fnval;
  552.     *p = NUL;
  553.     if (argn > 0)
  554.       sprintf(fnval,"%ld",*(bp[0]) ? zchki(bp[0]) : 0L);
  555.     for (k = 0; k < argn; k++) if (bp[k]) free(bp[k]);
  556.     return(p);
  557.  
  558.       case FN_VER:            /* \fverify() */
  559.     p = "0";
  560.     if (argn > 1) {            /* Only works if we have 2 or 3 args */
  561.         int start;
  562.         char *s2, ch1, ch2;
  563.         start = 0;
  564.         if (argn > 2) {        /* Starting position specified */
  565.         val1 = *(bp[2]) ? evala(bp[2]) : "";
  566.         if (chknum(val1)) {
  567.             start = atoi(val1) /* - 1 */;
  568.             if (start < 0) start = 0;
  569.             if (start > (int)strlen(bp[1]))
  570.               goto verfin;
  571.         }
  572.         }
  573.         i = start;
  574.         p = "0";
  575.         for (s = bp[1] + start; *s; s++,i++) {
  576.         ch1 = *s;
  577.         if (!inpcas[cmdlvl]) if (islower(ch1)) ch1 = toupper(ch1);
  578.         j = 0;
  579.         for (s2 = bp[0]; *s2; s2++) {
  580.             ch2 = *s2;
  581.             if (!inpcas[cmdlvl]) if (islower(ch2)) ch2 = toupper(ch2);
  582.             if (ch1 == ch2) {
  583.             j = 1;
  584.             break;
  585.             }
  586.         }
  587.         if (j == 0) {
  588.             sprintf(fnval,"%d",i+1);
  589.             p = fnval;
  590.             break;
  591.         }
  592.         }
  593.     }
  594.       verfin:
  595.     for (k = 0; k < argn; k++) if (bp[k]) free(bp[k]);
  596.     return(p);
  597.  
  598.       case FN_IPA:            /* Find and return IP address */
  599.     if (argn > 0) {            /* in argument string. */
  600.         int start;
  601.         char *s2;
  602.         start = 0;
  603.         if (argn > 1) {        /* Starting position specified */
  604.         if (chknum(bp[1])) {
  605.             start = atoi(bp[1]) - 1;
  606.             if (start < 0) start = 0;
  607.         }
  608.         }
  609.         p = getip(bp[0]+start);
  610.     } else p = "";
  611.     for (k = 0; k < argn; k++) if (bp[k]) free(bp[k]);
  612.     return(p);
  613.  
  614. #ifdef OS2
  615.       case FN_CRY:
  616.     p = "";
  617.     if (argn > 0) {
  618.         p = fnval;
  619.         strcpy(p,bp[0]);
  620.             ck_encrypt(p);
  621.     }
  622.     for (k = 0; k < argn; k++) if (bp[k]) free(bp[k]);
  623.     return(p);
  624.  
  625.       case FN_OOX:
  626.     p = "";
  627.     if (argn > 0)
  628.       p = (char *) ck_oox(bp[0], (argn > 1) ? bp[1] : "");
  629.     for (k = 0; k < argn; k++) if (bp[k]) free(bp[k]);
  630.     return(p);
  631. #endif /* OS2 */
  632.  
  633.       case FN_HEX:            /* \fhexify(arg1) */
  634.     if (argn < 1) return("");
  635.     p = "";
  636.     if ((int)strlen(bp[0]) < (FNVALL / 2)) {
  637.         s = bp[0];
  638.         p = fnval;
  639.         while (*s) {
  640.         x = (*s >> 4) & 0x0f;
  641.         *p++ = hexdigits[x];
  642.         x = *s++ & 0x0f;
  643.         *p++ = hexdigits[x];        
  644.         }
  645.         *p = NUL;
  646.         p = fnval;
  647.     }
  648.     for (k = 0; k < argn; k++) if (bp[k]) free(bp[k]);
  649.     return(p);
  650.  
  651.       case FN_UNH: {            /* \funhex(arg1) */
  652.       int c[2], i;
  653.       if (argn < 1) return("");
  654.       p = "";
  655.       if ((int)strlen(bp[0]) < (FNVALL * 2)) {
  656.           s = bp[0];
  657.           p = fnval;
  658.           while (*s) {
  659.           for (i = 0; i < 2; i++) {
  660.               c[i] = *s++;
  661.               if (!c[i]) { p = ""; goto unhexfin; }
  662.               if (islower(c[i])) c[i] = toupper(c[i]);
  663.               if (c[i] >= '0' && c[i] <= '9')
  664.             c[i] -= 0x30;
  665.               else if (c[i] >= 'A' && c[i] <= 'F')
  666.             c[i] -= 0x37;
  667.               else { p = ""; goto unhexfin; }
  668.           }
  669.           *p++ = ((c[0] << 4) & 0xf0) | (c[1] & 0x0f);
  670.           }
  671.           *p = NUL;
  672.           p = fnval;
  673.       }
  674.   unhexfin:
  675.       for (k = 0; k < argn; k++) if (bp[k]) free(bp[k]);
  676.       return(p);
  677.       }
  678.  
  679.       case FN_BRK: {            /* \fbreak() */
  680.       char * c;            /* Characters to break on */
  681.       char c2, s2;
  682.       int start = 0;
  683.       int done = 0;
  684.       if (argn < 1) return("");
  685.       p = fnval;            /* Destination pointer */
  686.       *p = NUL;
  687.       if (argn > 2) {
  688.           s = bp[2] ? bp[2] : "";
  689.           if (chknum(s)) {
  690.           start = atoi(s);
  691.           if (start < 0) start = 0;
  692.           if (start > (int)strlen(bp[0]))
  693.             goto brkfin;
  694.           }
  695.       }
  696.       s = bp[0] + start;        /* Source pointer */
  697.  
  698.       while (*s && !done) {
  699.           s2 = *s;
  700.           if (!inpcas[cmdlvl] && islower(s2)) s2 = toupper(s2);
  701.           c = bp[1] ? bp[1] : "";    /* Character to break on */
  702.           while (*c) {
  703.           c2 = *c;
  704.           if (!inpcas[cmdlvl] && islower(c2)) c2 = toupper(c2);
  705.           if (c2 == s2) {
  706.               done = 1;
  707.               break;
  708.           }
  709.           c++;
  710.           }
  711.           if (done) break;
  712.           *p++ = *s++;
  713.       }
  714.       *p = NUL;            /* terminate the result */
  715.       p = fnval;            /* and point to it. */
  716.     brkfin:
  717.       for (k = 0; k < argn; k++) if (bp[k]) free(bp[k]);
  718.       return(p);
  719.       }
  720.  
  721.       case FN_SPN: {            /* \fspan() */
  722.       char *q;
  723.       char c1, c2;
  724.       int start = 0;
  725.       if (argn < 1) return("");
  726.       p = fnval;            /* Result pointer */
  727.       *p = NUL;
  728.       if (argn > 2) {        /* Starting position */
  729.           s = bp[2] ? bp[2] : "";
  730.           if (chknum(s)) {
  731.           start = atoi(s);
  732.           if (start < 0) start = 0;
  733.           }
  734.       }
  735.       s = bp[0] + start;        /* Source pointer */
  736.       if (argn > 1 &&
  737.           (int)strlen(bp[1]) > 0 &&
  738.           start <= (int)strlen(bp[0])) {
  739.           while (*s) {        /* Loop thru source string */
  740.           q = bp[1];        /* Span string */
  741.           c1 = *s;
  742.           if (!inpcas[cmdlvl])
  743.             if (islower(c1)) c1 = toupper(c1);
  744.           x = 0;
  745.           while (c2 = *q++) {
  746.               if (!inpcas[cmdlvl])
  747.             if (islower(c2)) c2 = toupper(c2);
  748.               if (c1 == c2) { x = 1; break; }
  749.           }
  750.           if (!x) break;
  751.           *p++ = *s++;
  752.           }
  753.           *p = NUL;            /* Terminate and return the result */
  754.           p = fnval;
  755.       }
  756.       for (k = 0; k < argn; k++) if (bp[k]) free(bp[k]);
  757.       return(p);
  758.       }
  759.  
  760.       case FN_TRM:            /* \ftrim(s1[,s2]) */
  761.       case FN_LTR:            /* \fltrim(s1[,s2]) */
  762.     if (argn < 1) return("");
  763.     if ((len1 = (int)strlen(bp[0])) > 0) {
  764.         if (len1 > FNVALL)
  765.           len1 = FNVALL;
  766.         s = " \t";
  767.         if (argn > 1)        /* Trim list given */
  768.           s = bp[1];
  769.         len2 = (int)strlen(s);
  770.         if (len2 < 1) {        /* or not... */
  771.         s = " \t";        /* Default is to trim whitespace */
  772.         len2 = 2;
  773.         }
  774.         if (y == FN_TRM) {        /* Trim from right */
  775.         char * q, p2, q2;
  776.         strncpy(fnval,bp[0],FNVALL); /* Copy string to output */
  777.         p = fnval + len1 - 1;    /* Point to last character */
  778.  
  779.         while (p >= (char *)fnval) { /* Go backwards */
  780.             q = s;        /* Point to trim list */
  781.             p2 = *p;
  782.             if (!inpcas[cmdlvl])
  783.               if (islower(p2)) p2 = toupper(p2);
  784.             while (*q) {    /* Is this char in trim list? */
  785.             q2 = *q;
  786.             if (!inpcas[cmdlvl])
  787.               if (islower(q2)) q2 = toupper(q2);
  788.             if (p2 == q2) {    /* Yes, null it out */
  789.                 *p = NUL;
  790.                 break;
  791.             }
  792.             q++;
  793.             }
  794.             if (!*q)        /* Trim list exhausted */
  795.               break;        /* So we're done. */
  796.             p--;        /* Else keep trimming */
  797.         }
  798.         } else {            /* Trim from left */
  799.         char * q, p2, q2;
  800.         p = bp[0];        /* Source */
  801.         while (*p) {
  802.             p2 = *p;
  803.             if (!inpcas[cmdlvl])
  804.               if (islower(p2)) p2 = toupper(p2);
  805.             q = s;
  806.             while (*q) {    /* Is this char in trim list? */
  807.             q2 = *q;
  808.             if (!inpcas[cmdlvl])
  809.               if (islower(q2)) q2 = toupper(q2);
  810.             if (p2 == q2) {    /* Yes, point past it */
  811.                 p++;    /* and try next source character */
  812.                 break;
  813.             }
  814.             q++;        /* No, try next trim character */
  815.             }
  816.             if (!*q)        /* Trim list exhausted */
  817.               break;        /* So we're done. */
  818.         }
  819.         strncpy(fnval,p,FNVALL);
  820.         }
  821.         p = fnval;
  822.     } else p = "";
  823.     for (k = 0; k < argn; k++) if (bp[k]) free(bp[k]);
  824.     return(p);
  825.  
  826.       case FN_CAP:            /* \fcapitalize(arg1) */
  827.     if (argn < 1) return("");
  828.     s = bp[0];
  829.     p = fnval;
  830.     x = 0;
  831.     while (c = *s++) {
  832.         if (isalpha(c)) {
  833.         if (x == 0) {
  834.             x = 1;
  835.             if (islower(c))
  836.               c = toupper(c);
  837.         } else if (isupper(c))
  838.           c = tolower(c);
  839.         }
  840.         *p++ = c;
  841.     }
  842.     *p = NUL;
  843.     for (k = 0; k < argn; k++) if (bp[k]) free(bp[k]);
  844.     p = fnval;
  845.     return(p);
  846.  
  847.       case FN_TOD:            /* Time of day to secs since midnite */
  848.     if (argn < 1) return("");
  849.     p = fnval;
  850.     sprintf(p,"%ld",tod2sec(bp[0]));
  851.     for (k = 0; k < argn; k++) if (bp[k]) free(bp[k]);
  852.     return(p);
  853.  
  854.       case FN_FFN:            /* Full pathname of file */
  855.     p = fnval;
  856.     *p = NUL;
  857.     if (argn > 0)
  858. #ifdef ZFNQFP
  859.       zfnqfp(bp[0],FNVALL,p);
  860. #else
  861.       strcpy(p,bp[0]);
  862. #endif /* ZFNQFP */
  863.     for (k = 0; k < argn; k++) if (bp[k]) free(bp[k]);
  864.     return(p ? p : "");
  865.  
  866.       case FN_CHK: {            /* \fchecksum() */
  867.       long chk = 0;
  868.       p = (argn > 0) ? bp[0] : "";
  869.       while (*p) chk += *p++;
  870.       sprintf(fnval,"%lu",chk);
  871.       for (k = 0; k < argn; k++) if (bp[k]) free(bp[k]);
  872.       return((char *)fnval);
  873.       }
  874.       case FN_CRC:            /* \fcrc16() */
  875.     *fnval = NUL;
  876.     if (argn > 0)
  877.       sprintf(fnval,"%u",chk3((CHAR *)bp[0],0));
  878.     for (k = 0; k < argn; k++) if (bp[k]) free(bp[k]);
  879.     return((char *)fnval);
  880.  
  881.       case FN_BSN:            /* \fbasename() */
  882.     if (argn > 0)
  883.       zstrip(bp[0],&p);
  884.     for (k = 0; k < argn; k++) if (bp[k]) free(bp[k]);
  885.     return(p);
  886.  
  887.       default:
  888.     return("");
  889.     }
  890. }
  891.  
  892.