home *** CD-ROM | disk | FTP | other *** search
/ Complete Linux / Complete Linux.iso / docs / apps / database / postgres / postgre4.z / postgre4 / src / lib / C / utilities.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-08-27  |  4.0 KB  |  211 lines
  1.  
  2. /*     
  3.  *      FILE
  4.  *         utilities
  5.  *     
  6.  *      DESCRIPTION
  7.  *         Utility routines for strings, vectoris, etc.
  8.  *    $Header: /private/postgres/src/lib/C/RCS/utilities.c,v 1.11 1991/02/26 18:47:42 sp Exp $
  9.  *     
  10.  *      EXPORTS
  11.  *             vectori-long-to-list
  12.  *             collect
  13.  *             same
  14.  *             last-element
  15.  *             number-list
  16.  *             mesg
  17.  *             copy-seq-tree
  18.  *             base-log
  19.  *             key-sort
  20.  *             current-process-identifier
  21.  *             current-user-identifier
  22.  *             add
  23.  *             sub
  24.  *             mul
  25.  *             div
  26.  */
  27.  
  28. #include <math.h>
  29. #include "nodes/pg_lisp.h"
  30. #include "tmp/c.h"
  31. #include "utils/log.h"
  32. #include "nodes/nodes.h"
  33.  
  34. /*         =================
  35.  *         GENERAL UTILITIES
  36.  *         =================
  37.  *         
  38.  *      - LISP-independent routines
  39.  *         
  40.  */
  41.  
  42. /*    
  43.  *        vectori-long-to-list
  44.  *    
  45.  *        Put the first 'n' non-zero longword values in 'vectori', starting at
  46.  *        vectori location 'start', into a list. 
  47.  *    
  48.  *        XXX No error-checking is done, so if 'n' <= 0 or either argument is
  49.  *            out-of-bounds for the vectori, you lose.
  50.  *    
  51.  *        Returns the list of extracted values.
  52.  *    
  53.  */
  54.  
  55. /*  .. index-info
  56.  */
  57.  
  58. LispValue
  59. vectori_long_to_list (vectori,start,n)
  60.      int *vectori;
  61.      int start,n ;
  62. {
  63.     LispValue retval = LispNil;
  64.     int i,j;
  65.  
  66.     for (i = start, j = 1; j < n ; j++, i++) {
  67.     retval = nappend1(retval,lispInteger(vectori[i]));
  68.     }
  69.     return(retval);
  70. }
  71.  
  72. /*    
  73.  *        collect
  74.  *    
  75.  *        Collects all members of 'list' that satisfy 'predicate'.
  76.  *    
  77.  */
  78.  
  79. /*  .. make-parameterized-plans, new-level-qual, pull-constant-clauses
  80.  *  .. pull-relation-level-clauses, update-clauses
  81.  */
  82.  
  83. LispValue
  84. collect (pred,list)
  85.      bool (*pred)();
  86.      LispValue list ;
  87. {
  88.     LispValue retval  = LispNil;
  89.     LispValue temp = LispNil;
  90.  
  91.     foreach (temp,list) {
  92.     if ((* pred)(CAR(temp)))
  93.       retval = nappend1(retval,CAR(temp));
  94.     }
  95.     return(retval);
  96. }
  97.  
  98. /*    
  99.  *        same
  100.  *    
  101.  *        Returns t if two lists contain the same elements.
  102.  *       now defined in lispdep.c
  103.  *    
  104.  */
  105.  
  106. /*  .. best-innerjoin, prune-joinrel
  107.  */
  108.  
  109.  
  110.  
  111. /*    
  112.  *        last-element
  113.  *    
  114.  *        Returns the last list member (not the last cons cell, like last).
  115.  *    
  116.  */
  117.  
  118. LispValue
  119. last_element (list)
  120.      LispValue list ;
  121. {
  122.     return (CAR ((LispValue)last (list)));
  123. }
  124.  
  125. /*    
  126.  *        copy-seq-tree
  127.  *    
  128.  *        Returns a copy of a tree of sequences.
  129.  *    
  130.  */
  131.  
  132. /*  .. fix-rangetable, make-rule-plans, new-rangetable-entry
  133.  *  .. new-unsorted-tlist, plan-union-query, print_plan, process-rules
  134.  *  .. subst-rangetable
  135.  */
  136.  
  137. LispValue 
  138. copy_seq_tree (seqtree)
  139.      LispValue seqtree;
  140. {
  141.     LispValue new_seqtree;
  142.     LispValue elem, new_elem;
  143.     LispValue i;
  144.  
  145.     /*
  146.      * handle the trivial case first.
  147.      */
  148.     if (null(seqtree))
  149.     return(LispNil);
  150.  
  151.     switch(seqtree->type) {
  152.     case PGLISP_ATOM:
  153.         new_seqtree = lispInteger(CAtom(seqtree));
  154.         NodeSetTag(new_seqtree,classTag(LispSymbol));
  155.         break;
  156.     case PGLISP_VECI:
  157.         elog(WARN,"copying vectors unsupported");
  158.         break;
  159.     case PGLISP_FLOAT:
  160.         elog(WARN,"copying floats unsupported");
  161.         break;
  162.     case PGLISP_INT:
  163.         new_seqtree = lispInteger(CInteger(seqtree));
  164.         break;
  165.     case PGLISP_STR:
  166.         new_seqtree = lispString(CString(seqtree));
  167.         break;
  168.     case PGLISP_DTPR:
  169.         /*
  170.          * recursivelly handle all the list elements...
  171.          */
  172.         new_seqtree = LispNil;
  173.         foreach (i,seqtree) {
  174.         elem = CAR(i);
  175.         new_elem = copy_seq_tree(elem);
  176.         new_seqtree = nappend1(new_seqtree,new_elem);
  177.         }
  178.         break;
  179.     default:
  180.         new_seqtree = (LispValue)NewNode(
  181.                 NodeTagGetSize(NodeType(seqtree)),
  182.                         NodeType(seqtree));
  183.         /*
  184.          * XXX!
  185.          * WARNING! we'd better use the copy functions here!
  186.          */
  187.         bcopy(seqtree,new_seqtree, NodeTagGetSize(NodeType(seqtree)));
  188.         break;
  189.     } /*switch*/
  190.  
  191.     return(new_seqtree);
  192. }
  193.  
  194.  
  195. double
  196. base_log(x,b)
  197.      double x,b;
  198. {
  199.     return(log(x)/log(b));
  200. }
  201.  
  202. max(foo,bar)
  203.      int foo,bar;
  204. {
  205.     if (foo > bar)
  206.       return(foo);
  207.     else
  208.       return(bar);
  209. }
  210.  
  211.