开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > SQL Server > 查看源码
ind_scan.c
资源名称：gnusql-0.7b5.1.tar.gz　[点击查看]
上传用户：dgyhgb
上传日期：2007-01-07
资源大小：676k
文件大小：18k
源码类别：

SQL Server

开发平台：

Unix_Linux

ind_scan.c：源码内容
  1. /*
  2.  *  ind_scan.c  - Index Control Programm
  3.  *               functions dealing with scanning of an index
  4.  *               Kernel of GNU SQL-server
  5.  *
  6.  * This file is a part of GNU SQL Server
  7.  *
  8.  *  Copyright (c) 1996, 1997, Free Software Foundation, Inc
  9.  *  Developed at the Institute of System Programming
  10.  *  This file is written by  Vera Ponomarenko
  11.  *
  12.  *  This program is free software; you can redistribute it and/or modify
  13.  *  it under the terms of the GNU General Public License as published by
  14.  *  the Free Software Foundation; either version 2 of the License, or
  15.  *  (at your option) any later version.
  16.  *
  17.  *  This program is distributed in the hope that it will be useful,
  18.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  19.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20.  *  GNU General Public License for more details.
  21.  *
  22.  *  You should have received a copy of the GNU General Public License
  23.  *  along with this program; if not, write to the Free Software
  24.  *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  25.  *
  26.  *  Contacts:   gss@ispras.ru
  27.  *
  28.  */
  30. /* $Id: ind_scan.c,v 1.245 1997/03/31 03:46:38 kml Exp $ */
  32. #include "xmem.h"
  33. #include "destrn.h"
  34. #include "sctp.h"
  35. #include "strml.h"
  36. #include "fdcltrn.h"
  38. extern struct des_field *d_f, *d_f2;
  39. extern u2_t seg_n;
  40. extern u2_t *afn;
  41. extern u2_t k_n;
  42. extern i4_t k2sz;
  44. static char *
  45. find_first_key (struct A *pg, u2_t pn)
  46. {
  47.   char *asp = NULL, *a;
  48.   u2_t cpn, ppn;
  49.   struct ind_page *indph;
  51.   while ((asp = getpg (pg, seg_n, pn, 's')) == NULL);
  52.   indph = (struct ind_page *) asp;
  53.   for (; indph->ind_wpage != LEAF;)
  54.     {
  55.       a = asp + indphsize + size2b;
  56.       a += kszcal (a, afn, d_f) + k2sz;
  57.       cpn = t2bunpack (a);
  58.       putwul (pg, 'n');
  59.       ppn = pg->p_pn;
  60.       while ((asp = getpg (pg, seg_n, cpn, 's')) == NULL);
  61.       indph = (struct ind_page *) asp;
  62.       BUF_unlock (seg_n, 1, &ppn);
  63.     }
  64.   return (asp);
  65. }
  67. #define BETWEEN_CMP  (t == SS || t == SES || t == SSE || t == SESE)
  69. static int
  70. cmp_with_dia (char *key, char *diasc, char *diaval)
  71. {
  72.   char *kval, *keyval;
  73.   i4_t sst, k1, ftype, v, v1;
  74.   char *a1, *a2;
  75.   u2_t k, nk, n1, n2;
  76.   unsigned char t;
  78.   sst = 1;
  79.   kval = keyval = key + scscal (key);
  80.   t = selsc1 (&diasc, sst++);
  81.   v = v1 = 0;
  82.   for (k = 0, k1 = 0; t != ENDSC && k < k_n && key < keyval; k++, k1++)
  83.     {
  84.       if (k1 == 7)
  85. {
  86.   k1 = 0;
  87.   key++;
  88. }
  89.       if ((*key & BITVL(k1)) != 0)
  90. {
  91.   if (t == EQUN)
  92.     return (1);
  93.   ftype = (d_f + afn[k])->field_type;
  94.   if (t == NEQUN || t == ANY)
  95.     kval = proval (kval, ftype);
  96.   else
  97.     {
  98.       switch (ftype)
  99. {
  100. case T1B:
  101.   diaval = ftint (t, diaval, &a1, &a2, size1b);
  102.   v = f1b (kval, a1, size1b, size1b);
  103.   if (BETWEEN_CMP)
  104.     v1 = f1b (kval, a2, size1b, size1b);
  105.   kval++;
  106.   break;
  107. case T2B:
  108.   diaval = ftint (t, diaval, &a1, &a2, size2b);
  109.   v = f2b (kval, a1, size2b, size2b);
  110.   if (BETWEEN_CMP)
  111.     v1 = f2b (kval, a2, size2b, size2b);
  112.   kval += size2b;
  113.   break;
  114. case T4B:
  115.   diaval = ftint (t, diaval, &a1, &a2, size4b);
  116.   v = f4b (kval, a1, size4b, size4b);
  117.   if (BETWEEN_CMP)
  118.     v1 = f4b (kval, a2, size4b, size4b);
  119.   kval += size4b;
  120.   break;
  121. case TFLOAT:
  122.   diaval = ftint (t, diaval, &a1, &a2, size4b);
  123.   v = flcmp (kval, a1, size4b, size4b);
  124.   if (BETWEEN_CMP)
  125.     v1 = flcmp (kval, a2, size4b, size4b);
  126.   kval += size4b;
  127.   break;
  128. case TFL:
  129.   nk = t2bunpack (kval);
  130.   kval += size2b;
  131.   diaval = ftch (t, diaval, &a1, &a2, &n1, &n2);
  132.   v = ffloat (kval, a1, nk, n1);
  133.   if (BETWEEN_CMP)
  134.     v1 = ffloat (kval, a2, nk, n2);
  135.   kval += nk;
  136.   break;
  137. case TCH:
  138.   nk = t2bunpack (kval);
  139.   kval += size2b;
  140.   diaval = ftch (t, diaval, &a1, &a2, &n1, &n2);
  141.   v = chcmp (kval, a1, nk, n1);
  142.   if (BETWEEN_CMP)
  143.     v1 = chcmp (kval, a2, nk, n2);
  144.   kval += nk;
  145.   break;
  146. default:
  147.   break;
  148. }
  150.       if (v == 0) /* current == first */
  151. {
  152.   if (t == SML)
  153.     return (EOI);
  154.   if (t == NEQ || t == GRT || t == SS || t == SSE)
  155.     return (1);
  156. }
  157.       else
  158. if (v > 0) /* current > first */
  159.   {
  160.     if (t == EQ || t == SML || t == SMLEQ)
  161.       return (EOI);
  162.     
  163.     if (BETWEEN_CMP)
  164.       if (v1 == 0) /* current == last */
  165. if (t == SS || t == SES)
  166.   return (EOI);
  167. else {}
  168.       else if (v1 > 0) /* current > last */
  169. return (EOI);
  170.   }
  171. else /* current < first */
  172.   {
  173.     if (!(t == NEQ || t == SML || t == SMLEQ))
  174.       return (1);
  175. }
  176.     }
  177. }
  178.       else
  179. { /* values are absent into the key */
  180.   if (!(t == EQUN || t == ANY))
  181.     return (EOI);
  182. }
  183.       t = selsc1 (&diasc, sst++);
  184.     }
  185.   if (key == keyval && t != ENDSC)
  186.     return (EOI);
  187.   return (OK);
  188. }
  190. #undef BETWEEN_CMP
  192. static char *
  193. find_next_agr (struct A *pg, char *diasc, char *diaval,
  194.                i4_t elsz, char *key, i4_t *agrloc)
  195. {
  196.   char *lastb, *agr, *asp = NULL;
  197.   struct ind_page *indph;
  198.   u2_t pn, ppn, n, off;
  199.   i4_t keysz, l;
  201.   asp = pg->p_shm;
  202.   pn = pg->p_pn;
  203.   indph = (struct ind_page *) asp;
  205.   for (;;)
  206.     {
  207.       off = indph->ind_off;
  208.       lastb = asp + off;
  209.       for (; key < lastb; key += keysz + n * elsz)
  210. {
  211.   agr = key;
  212.   n = t2bunpack (key);
  213.   key += size2b;
  214.   keysz = kszcal (key, afn, d_f);
  215.   if (diasc == NULL)
  216.     {
  217.       *agrloc = agr - asp;
  218.       return (key + keysz);
  219.     }
  220.   if ((l = cmp_with_dia (key, diasc, diaval)) == EOI)
  221.             return (NULL);
  222.   if (l == OK)
  223.     {
  224.       *agrloc = agr - asp;
  225.       return (key + keysz);
  226.     }
  227. }
  228.       pn = indph->ind_nextpn;
  229.       if (pn == (u2_t) ~ 0)
  230.         return (NULL);
  231.       putwul (pg, 'n');
  232.       ppn = pg->p_pn;
  233.       while ((asp = getpg (pg, seg_n, pn, 's')) == NULL);
  234.       indph = (struct ind_page *) asp;
  235.       BUF_unlock (seg_n, 1, &ppn);
  236.       key = asp + indphsize;
  237.     }
  238. }
  240. static char *
  241. first_key_frm (char *diasc, char *diaval, char *mas)
  242. {
  243.   char *a;
  244.   i4_t ftype;
  245.   u2_t size;
  246.   unsigned char t;
  248.   t = selsc1 (&diasc, 1);
  249.   if (t == EQ || t == GRT || t == GRTEQ || t == SS || t == SES || t == SSE || t == SESE)
  250.     {
  251.       a = mas;
  252.       ftype = (d_f + afn[0])->field_type;
  253.       if (ftype == TCH || ftype == TFL)
  254. {
  255.   size = t2bunpack (diaval);
  256.   diaval += size2b;
  257.   t2bpack (size, a);
  258.   a += size2b;
  259. }
  260.       else
  261. size = (d_f + afn[0])->field_size;
  262.       bcopy (diaval, a, size);
  263.     }
  264.   else
  265.     mas = NULL;
  266.   return (mas);
  267. }
  269. static int
  270. cmpfval (char *key, char *aval)
  271.      /* key - in the index, aval - from diasc */
  272. {
  273.   char *kval;
  274.   i4_t ftype, v = 0;
  275.   u2_t nk, n1;
  277.   kval = key + scscal (key);
  278.   if ((*key & BITVL(0)) != 0)
  279.     {
  280.       ftype = (d_f + afn[0])->field_type;
  281.       switch (ftype)
  282. {
  283. case T1B:
  284.   v = f1b (kval, aval, size1b, size1b);
  285.   break;
  286. case T2B:
  287.   v = f2b (kval, aval, size2b, size2b);
  288.   break;
  289. case T4B:
  290.   v = f4b (kval, aval, size4b, size4b);
  291.   break;
  292. case TFLOAT:
  293.   v = flcmp (kval, aval, size4b, size4b);
  294.   break;
  295. case TFL:
  296.   nk = t2bunpack (kval);
  297.   kval += size2b;
  298.   n1 = t2bunpack (aval);
  299.   aval += size2b;
  300.   v = ffloat (kval, aval, nk, n1);
  301.   break;
  302. case TCH:
  303.   nk = t2bunpack (kval);
  304.   kval += size2b;
  305.   n1 = t2bunpack (aval);
  306.   aval += size2b;
  307.   v = chcmp (kval, aval, nk, n1);
  308.   break;
  309. default:
  310.   break;
  311. }
  312.     }
  313.   else
  314.     v = 1;
  315.   return (v);
  316. }
  318. static char *
  319. flookup (struct A *pg, u2_t pn, char *key, i4_t infsz, char **rasp)
  320. {
  321.   char *asp = NULL, *a, *lastb;
  322.   u2_t ppn, off;
  323.   i4_t elsz;
  324.   u2_t n;
  325.   struct ind_page *indph;
  327.   while ((asp = getpg (pg, seg_n, pn, 's')) == NULL);
  328.   indph = (struct ind_page *) asp;
  329.   for (; indph->ind_wpage != LEAF;)
  330.     {
  331.       off = indph->ind_off;
  332.       lastb = asp + off;
  333.       elsz = k2sz + size2b;
  334.       for (a = asp + indphsize; a < lastb; a += kszcal (a, afn, d_f) + n * elsz)
  335. {
  336.   n = t2bunpack (a);
  337.   a += size2b;
  338.   if (cmpfval (a, key) >= 0)
  339.     {
  340.       a += kszcal (a, afn, d_f) + k2sz;
  341.       break;
  342.     }
  343. }
  344.       if (a == lastb)
  345. {
  346.   *rasp = asp;
  347.   return (a);
  348. }
  349.       pn = t2bunpack (a);
  350.       a += size2b;
  351.       putwul (pg, 'n');
  352.       ppn = pg->p_pn;
  353.       while ((asp = getpg (pg, seg_n, pn, 's')) == NULL);
  354.       indph = (struct ind_page *) asp;
  355.       BUF_unlock (seg_n, 1, &ppn);
  356.     }
  357.   elsz = k2sz + infsz;
  358.   off = indph->ind_off;
  359.   lastb = asp + off;
  360.   for (a = asp + indphsize; a < lastb; a += kszcal (a, afn, d_f) + n * elsz)
  361.     {
  362.       n = t2bunpack (a);
  363.       a += size2b;
  364.       if (cmpfval (a, key) >= 0)
  365. {
  366.   a -= size2b;
  367.   break;
  368. }
  369.     }
  370.   *rasp = asp;
  371.   return (a);
  372. }
  374. int
  375. fscan_ind (struct ldesscan *desscn, char *key2, char *inf, i4_t infsz, char modescan)
  376. {
  377.   char *a, *diasc, *diaval, *ckey;
  378.   u2_t rootpn, d_fn;
  379.   struct ldesind *desind;
  380.   struct A pg;
  381.   i4_t agrloc, keysz;
  382.   char *asp, *key;
  383.   char mas[BD_PAGESIZE];
  385.   desind = desscn->pdi;
  386.   rootpn = desind->ldi.rootpn;
  387.   seg_n = desind->i_segn;
  388.   diasc = desscn->dpnsc;
  389.   diaval = desscn->dpnsval;
  390.   afn = (u2_t *) (desind + 1);
  391.   k_n = desind->ldi.kifn & ~UNIQ & MSK21B;
  392.   d_f = desind->pdf;
  393.   d_fn = k_n;
  394.   if ((k_n % 2) != 0)
  395.     d_fn += 1;
  396.   d_f2 = (struct des_field *) (afn + d_fn);
  397.   k2sz = d_f2->field_size;
  398.   if (diasc != NULL)
  399.     {
  400.       diasc += size2b;
  401.       key = first_key_frm (diasc, diaval, mas);
  402.       if (key != NULL)
  403. {
  404.   a = flookup (&pg, rootpn, key, infsz, &asp);
  405. }
  406.       else
  407. {
  408.   asp = find_first_key (&pg, rootpn);
  409.   a = asp + indphsize;
  410. }
  411.       a = find_next_agr (&pg, diasc, diaval, k2sz + infsz, a, &agrloc);
  412.       asp = pg.p_shm;
  413.       if (a == NULL)
  414. {
  415.   desscn->curlpn = (u2_t) ~ 0;
  416.   putpg (&pg, 'n');
  417.   return (EOI);
  418. }
  419.     }
  420.   else
  421.     {
  422.       asp = find_first_key (&pg, rootpn);
  423.       if (((struct ind_page *) asp)->ind_off == indphsize)
  424. {
  425.   desscn->curlpn = (u2_t) ~ 0;
  426.   putpg (&pg, 'n');
  427.   return (EOI);
  428. }
  429.       a = asp + indphsize;
  430.       agrloc = a - asp;
  431.       a += size2b; 
  432.       a += kszcal (a, afn, d_f);
  433.     }
  434.   bcopy (a, key2, k2sz);
  435.   a += k2sz;
  436.   if (inf != NULL)
  437.     {
  438.       bcopy (a, inf, infsz);
  439.       a += infsz;
  440.     }
  441.   /* write cursors into desscn */
  442.   desscn->curlpn = pg.p_pn;
  443.   desscn->offa = agrloc;
  444.   desscn->offp = a - asp - k2sz - infsz;
  445.   desscn->sidmod = ((struct p_head *) asp)->idmod;
  446.   a = asp + agrloc + size2b;
  447.   keysz = kszcal (a, afn, d_f);
  448.   ckey = (char *) xmalloc (keysz);
  449.   desscn->cur_key = ckey;
  450.   bcopy (a, ckey, keysz);
  451.   if (modescan == FASTSCAN)
  452.     putwul (&pg, 'n');
  453.   else
  454.     putpg (&pg, 'n');
  455.   return (OK);
  456. }
  458. static
  459. int
  460. find_next_key(struct ldesscan *desscn, struct A *pg, char *diasc, char *diaval, i4_t elsz, char *agr, char *pnt, i4_t *agrloc, i4_t *lockey)
  461. {
  462.   i4_t agsz;
  463.   u2_t n;
  464.   char *asp;
  466.   asp = pg->p_shm;
  467.   *agrloc = agr - asp;
  468.   n = t2bunpack (agr);
  469.   agsz = size2b + kszcal (agr + size2b, afn, d_f) + n * elsz;
  470.   pnt += elsz;
  471.   if (pnt == agr + agsz)
  472.     {
  473.       pnt = find_next_agr (pg, diasc, diaval, elsz, pnt, agrloc);
  474.       if (pnt == NULL)
  475. {
  476.   putpg (pg, 'n');
  477.   desscn->curlpn = (u2_t) ~ 0;
  478.   return (EOI);
  479. }
  480.       asp = pg->p_shm;
  481.     }
  482.   *lockey = pnt - asp;
  483.   return (OK);
  484. }
  486. static
  487. char *
  488. look_up(struct A *pg, u2_t pn, char *key, char *key2, i4_t infsz, char **agr, char **loc)
  489. {
  490.   char *a, *lastb, *asp = NULL;
  491.   i4_t elsz, l, l2 = 0, ksz;
  492.   u2_t n, ppn;
  493.   struct ind_page *indph;
  495.   while ((asp = getpg (pg, seg_n, pn, 's')) == NULL);
  496.   indph = (struct ind_page *) asp;
  497.   elsz = k2sz + size2b;
  498.   for (; indph->ind_wpage != LEAF;)
  499.     {
  500.       lastb = asp + indph->ind_off;
  501.       for (a = asp + indphsize; a < lastb; )
  502. {
  503.   n = t2bunpack (a);
  504.   a += size2b;
  505.           ksz = kszcal (a, afn, d_f);
  506.   if ((l = cmpkeys (k_n, afn, d_f, a, key)) == 0)
  507.     {
  508.       a += ksz;
  509.               for (; n != 0; n--, a += elsz)
  510.                 if ((l2 = cmp2keys (d_f2->field_type, a, key2)) < 0)
  511.                   continue;
  512.                 else
  513.                   break;
  514.               if (n == 0 && l2 < 0)
  515.                 continue;
  516.               if (n == 0)
  517.                 a -= elsz;
  518.       break;
  519.     }
  520.           else if (l > 0)
  521.     {
  522.       a += ksz;
  523.       break;
  524.     }
  525.           a += ksz + n * elsz;
  526. }
  527.       if (a == lastb)
  528. {
  529.   *loc = NULL;
  530.   return (NULL);
  531. }
  532.       a += k2sz;
  533.       ppn = pn;
  534.       pn = t2bunpack (a);
  535.       putwul (pg, 'n');
  536.       while ((asp = getpg (pg, seg_n, pn, 's')) == NULL);
  537.       indph = (struct ind_page *) asp;
  538.       BUF_unlock (seg_n, 1, &ppn);
  539.     }
  540.   lastb = asp + indph->ind_off;
  541.   a = asp + indphsize;
  542.   if (a == lastb)
  543.     {
  544.       *loc = NULL;
  545.       return (NULL);
  546.     }
  547.   elsz = k2sz + infsz;
  548.   for (; a < lastb; a += kszcal (a, afn, d_f) + n * elsz)
  549.     {
  550.       *agr = a;
  551.       n = t2bunpack (a);
  552.       a += size2b;
  553.       if ((l = cmpkeys (k_n, afn, d_f, a, key)) == 0)
  554. {
  555.   a += kszcal (a, afn, d_f);
  556.   for (; n != 0; n--, a += elsz)
  557.     {
  558.       if ((l2 = cmp2keys (d_f2->field_type, a, key2)) < 0)
  559. continue;
  560.               if (l2 == 0)
  561.                 {
  562.                   *loc = a;
  563.                   return (a);
  564.                 }
  565.               *loc = a;
  566.               return (NULL);
  567.     }
  568.   *loc = a;
  569.           return (NULL);
  570. }
  571.       else if (l > 0)
  572. {
  573.   a += kszcal (a, afn, d_f);
  574.           *loc = a;
  575.   return (NULL);
  576. }
  577.     }
  578.   *loc = NULL;
  579.   return (NULL);
  580. }
  582. int
  583. scan_ind (struct ldesscan *desscn, char *key2, char *inf, i4_t infsz, char modescan)
  584. {
  585.   char *asp = NULL, *a, *lastb, *diasc, *diaval, *ckey;
  586.   u2_t pn, n, d_fn, off;
  587.   i4_t elsz, agrloc, loc;
  588.   struct ind_page *indph;
  589.   struct ldesind *desind;
  590.   struct A pg;
  591.   char *agr, *lockey;
  592.   i4_t keysz;
  593.   i4_t l, l2=0;
  595.   pn = desscn->curlpn;
  596.   if (pn == (u2_t) ~ 0)
  597.     return (EOI);
  598.   diasc = desscn->dpnsc + size2b;
  599.   diaval = desscn->dpnsval;
  600.   desind = desscn->pdi;
  601.   seg_n = desind->i_segn;
  602.   afn = (u2_t *) (desind + 1);
  603.   k_n = desind->ldi.kifn & ~UNIQ & MSK21B;
  604.   d_f = desind->pdf;
  605.   d_fn = k_n;
  606.   if ((k_n % 2) != 0)
  607.     d_fn += 1;
  608.   d_f2 = (struct des_field *) (afn + d_fn);
  609.   k2sz = d_f2->field_size;
  610.   elsz = k2sz + infsz;
  611.   if (modescan == FASTSCAN)
  612.     asp = getwl (&pg, seg_n, pn);
  613.   else
  614.     while ((asp = getpg (&pg, seg_n, pn, 's')) == NULL);
  616.   indph = (struct ind_page *) asp;
  617.   off = indph->ind_off;
  618.   lastb = asp + off;
  619.   if (desscn->sidmod != indph->ind_ph.idmod)
  620.     {
  621.       ckey = desscn->cur_key;
  622.       a = asp + indphsize;
  623.       if (a < lastb && cmpkeys (k_n, afn, d_f, a + size2b, ckey) <= 0)
  624.         {         /* look up in this page */
  625.           for (; a < lastb; a += kszcal (a, afn, d_f) + n * elsz)
  626.             {
  627.               agr = a;
  628.               n = t2bunpack (a);
  629.               a += size2b;
  630.               if ((l = cmpkeys (k_n, afn, d_f, a, ckey)) >= 0)
  631.                 {
  632.                   a += kszcal (a, afn, d_f);
  633.                   if (l == 0)         /* current key is present */
  634.                     {
  635.                       for (; n != 0; n--, a += elsz)
  636.                         if ((l2 = cmp2keys (d_f2->field_type, a, key2)) < 0)
  637.                           continue;
  638.                         else
  639.                           break;
  640.                       if (l2 == 0)     /* current key2 is present */
  641.                         {
  642.                           if (find_next_key (desscn, &pg, diasc, diaval, elsz, agr, a, &agrloc, &loc) == EOI)
  643.                             return (EOI);
  644.                           goto m1;
  645.                         }
  646.                       else             /* current key2 is absent */
  647.                         {
  648.                           agrloc = agr - asp;
  649.                           loc = a - asp;
  650.                           goto m1;
  651.                         }
  652.                     }
  653.                   else                 /* current key is absent */
  654.                     {
  655.                       if (cmp_with_dia (agr + size2b, diasc, diaval) == EOI)
  656.                         {
  657.                           putpg (&pg, 'n');
  658.                           return (EOI);
  659.                         }
  660.                       agrloc = agr - asp;      /* next key */
  661.                       loc = a - asp;
  662.                       goto m1;
  663.                     }
  664.                 }
  665.             }
  666.         }
  667.       putpg (&pg, 'n');
  668.       look_up(&pg, desind->ldi.rootpn, desscn->cur_key, key2, infsz, &agr, &lockey);
  669.       /*      a = icp_lookup (&pg, desind, desscn->cur_key, key2, infsz, &agr, &lockey);*/
  670.       asp = pg.p_shm;
  671.       if (lockey == NULL)
  672.         {
  673.           desscn->curlpn = (u2_t) ~ 0;
  674.           putpg (&pg, 'n');
  675.           return (EOI);
  676.         }
  677.       if (a == NULL)    /* current key is absent */
  678.         {
  679.           if (cmp_with_dia (agr + size2b, diasc, diaval) == EOI)
  680.             {
  681.               putpg (&pg, 'n');
  682.               return (EOI);
  683.             }
  684.           loc = lockey - asp;
  685.           agrloc = agr - asp;
  686.         }
  687.       else              /* current key is present */
  688.         {
  689.           if (find_next_key (desscn, &pg, diasc, diaval, elsz, agr, lockey, &agrloc, &loc) == EOI)
  690.             return (EOI);
  691.         }
  692.     }
  693.   else
  694.     {
  695.       agr = asp + desscn->offa;
  696.       a = asp + desscn->offp;
  697.       if (find_next_key (desscn, &pg, diasc, diaval, elsz, agr, a, &agrloc, &loc) == EOI)
  698.         return (EOI);
  699.     }
  700. m1:
  701.   asp = pg.p_shm;
  702.   a = asp + loc;
  703.   bcopy (a, key2, k2sz);
  704.   a += k2sz;
  705.   if (inf != NULL)
  706.     bcopy (a, inf, infsz);
  707.   /* write cursors into desscn */
  708.   desscn->curlpn = pg.p_pn;
  709.   desscn->offa = agrloc;
  710.   desscn->offp = loc;
  711.   desscn->sidmod = ((struct p_head *) asp)->idmod;
  712.   if (desscn->cur_key != NULL)
  713.     xfree (desscn->cur_key);
  714.   a = asp + agrloc + size2b;
  715.   keysz = kszcal (a, afn, d_f);
  716.   ckey = (char *) xmalloc (keysz);
  717.   desscn->cur_key = ckey;
  718.   bcopy (a, ckey, keysz);
  719.   if (modescan == SLOWSCAN)
  720.     putpg (&pg, 'n');
  721.   else
  722.     putwul (&pg, 'n');
  723.   return (OK);
  724. }
  726. char *
  727. icp_lookup (struct A *pg, struct ldesind *desind, char *key, char *key2, i4_t infsz, char **agr, char **loc)
  728. {
  729.   u2_t d_fn;
  731.   seg_n = desind->i_segn;
  732.   afn = (u2_t *) (desind + 1);
  733.   k_n = desind->ldi.kifn & ~UNIQ & MSK21B;
  734.   d_f = desind->pdf;
  735.   d_fn = k_n;
  736.   if ((k_n % 2) != 0)
  737.     d_fn += 1;
  738.   d_f2 = (struct des_field *) (afn + d_fn);
  739.   k2sz = d_f2->field_size;
  740.   return (look_up(pg, desind->ldi.rootpn, key, key2, infsz, agr, loc));
  741. }