home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / misc / volume44 / typhoon / part01 next >
Internet Message Format  |  1994-09-17  |  63KB
  1. From: zeppelin@login.dknet.dk (Thomas B. Pedersen)
  2. Newsgroups: comp.sources.misc
  3. Subject: v44i057:  typhoon - Typhoon Relational Database Management System, Part01/09
  4. Date: 17 Sep 1994 21:44:04 -0500
  5. Organization: Sterling Software
  6. Sender: kent@sparky.sterling.com
  7. Approved: kent@sparky.sterling.com
  8. Message-ID: <csm-v44i057=typhoon.214347@sparky.sterling.com>
  9. X-Md4-Signature: 3ed59d07df131f309b0ca3f158f1f885
  10.  
  11. Submitted-by: zeppelin@login.dknet.dk (Thomas B. Pedersen)
  12. Posting-number: Volume 44, Issue 57
  13. Archive-name: typhoon/part01
  14. Environment: SCO UNIX, Tandem NonStop UNIX, Sun Solaris, AIX, Linux, OS/2
  15.  
  16. Typhoon is a freely available relational database management system for
  17. the UNIX and OS/2 environments. 
  18.  
  19. This release has been prepared in a hurry to get it out as quickly as 
  20. possible. This means that the documentation is rather sparse, since I
  21. haven't had the time to write extensive documentation yet. However, most
  22. of you out there are pretty clever, so you'll probably do fine with the
  23. man pages and the examples.
  24.  
  25. The system works fine and is currently used in a number of professional
  26. applications in Denmark, some of them mission critical.
  27.  
  28. The system was originally inspired by Raima's db_VISTA (today Raima Data
  29. Manager) but is relational rather than network based. Typhoon lacks some of
  30. db_VISTA's features, but also contains a number of nice features not found in 
  31. db_VISTA.
  32.  
  33. All relations are defined in a so called Data Definition Language (ddl) file.
  34. You define the database relations like you would write a C structure with
  35. chars, ints, strings, multidimensional arrays, nested union and structures,
  36. etc. Then you define primary, alternate and foreign keys for each relation.
  37. The Data Definition Language Processor (ddlp) compiles the database defintion
  38. into a binary file which constitutes the database description. The database
  39. relations are accessed via C subroutines which manipulate individual records
  40. within a table.
  41.  
  42.     - Multiple open database
  43.     - Multi-field keys
  44.     - Nested structures in records
  45.     - Controlled unions
  46.     - Referential integrity
  47.     - Variable length fields
  48.     - Null keys (optional keys in db_VISTA, but easier to use)
  49.     - Dynamic opening and closing of database files
  50.  
  51. At present the database has no locking mechanism, believe it or not! The
  52. projects I have used it in, simply didn't need it, even though they were
  53. multi-user environments. But it's in the works!
  54.  
  55. I am currently working on extending the library to support the following:
  56.  
  57.     - Locking
  58.     - Logging
  59.     - Transactions 
  60.     - Paging (to improve performance)
  61.  
  62. The library functions will remain intact, except for a number of new functions.
  63. I expect these things to be ready before the end of the year. Beta testers
  64. are welcome.
  65.  
  66. The library comes with three additional utilities:
  67.  
  68.     dbdview        - Displayes the database definitions.
  69.     tyexport    - Exports tables from a database.
  70.     tyimport    - Imports tables into a database.
  71.  
  72. Originally the library also contained online backup, restore and a replication
  73. server. These tools would need a lot of extra documentation, so I have left
  74. them out for now (the code still contains support for these utilities).
  75. However, if enough people show interest I will probably release them also.
  76.  
  77. Bug reports and mail should be sent to 
  78.  
  79.     Thomas B. Pedersen
  80.     zeppelin@login.dkuug.dk
  81.  
  82. Also, if you have any suggestions as to how I can improve the library, 
  83. documentation or anything else, please don't hesitate to mail me.
  84.  
  85. Thomas B. Pedersen
  86. -------------------------------
  87. #! /bin/sh
  88. # This is a shell archive.  Remove anything before this line, then feed it
  89. # into a shell via "sh file" or similar.  To overwrite existing files,
  90. # type "sh file -c".
  91. # Contents:  typhoon typhoon/examples typhoon/man typhoon/src
  92. #   typhoon/src/bt_funcs.c typhoon/src/h typhoon/src/util
  93. #   typhoon/src/util/ddl.y typhoon/src/util/ddlp.c
  94. #   typhoon/src/util/lex.c
  95. # Wrapped by kent@sparky on Sat Sep 17 21:38:15 1994
  96. PATH=/bin:/usr/bin:/usr/ucb:/usr/local/bin:/usr/lbin:$PATH ; export PATH
  97. echo If this archive is complete, you will see the following message:
  98. echo '          "shar: End of archive 1 (of 9)."'
  99. if test ! -d 'typhoon' ; then
  100.     echo shar: Creating directory \"'typhoon'\"
  101.     mkdir 'typhoon'
  102. fi
  103. if test ! -d 'typhoon/examples' ; then
  104.     echo shar: Creating directory \"'typhoon/examples'\"
  105.     mkdir 'typhoon/examples'
  106. fi
  107. if test ! -d 'typhoon/man' ; then
  108.     echo shar: Creating directory \"'typhoon/man'\"
  109.     mkdir 'typhoon/man'
  110. fi
  111. if test ! -d 'typhoon/src' ; then
  112.     echo shar: Creating directory \"'typhoon/src'\"
  113.     mkdir 'typhoon/src'
  114. fi
  115. if test -f 'typhoon/src/bt_funcs.c' -a "${1}" != "-c" ; then 
  116.   echo shar: Will not clobber existing file \"'typhoon/src/bt_funcs.c'\"
  117. else
  118.   echo shar: Extracting \"'typhoon/src/bt_funcs.c'\" \(14705 characters\)
  119.   sed "s/^X//" >'typhoon/src/bt_funcs.c' <<'END_OF_FILE'
  120. X/*----------------------------------------------------------------------------
  121. X * File    : bt_funcs
  122. X * Library : typhoon
  123. X * OS      : UNIX, OS/2, DOS
  124. X * Author  : Thomas B. Pedersen
  125. X *
  126. X * Copyright (c) 1994 Thomas B. Pedersen.  All rights reserved.
  127. X *
  128. X * Permission is hereby granted, without written agreement and without
  129. X * license or royalty fees, to use, copy, modify, and distribute this
  130. X * software and its documentation for any purpose, provided that the above
  131. X * copyright notice and the following two  paragraphs appear (1) in all 
  132. X * source copies of this software and (2) in accompanying documentation
  133. X * wherever the programatic interface of this software, or any derivative
  134. X * of it, is described.
  135. X *
  136. X * IN NO EVENT SHALL THOMAS B. PEDERSEN BE LIABLE TO ANY PARTY FOR DIRECT,
  137. X * INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF
  138. X * THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF HE HAS BEEN 
  139. X * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  140. X *
  141. X * THOMAS B. PEDERSEN SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT
  142. X * NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  143. X * A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS ON AN "AS IS" 
  144. X * BASIS, AND THOMAS B. PEDERSEN HAS NO OBLIGATION TO PROVIDE MAINTENANCE,
  145. X * SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
  146. X *
  147. X * Description:
  148. X *
  149. X * Functions:
  150. X *     btree_add            - Insert a new key in a B-tree.
  151. X *     btree_find            - Find a key in a B-tree.
  152. X *     btree_exist            - See if a key exists in a B-tree.
  153. X *     btree_read            - Read the last key found.
  154. X *     btree_delall        - Delete all keys in a B-tree.
  155. X *   get_rightmostchild    - Find the rightmost child in a subtree.
  156. X *   get_leftmostchild    - Find the leftmost child in a subtree.
  157. X *     btree_frst            - Find the key with the lowest key value in a B-tree.
  158. X *     btree_last            - Find the key with the highest key value in a B-tree.
  159. X *     btree_prev            - Find the previous key in a B-tree.
  160. X *     btree_next            - Find the next key in a B-btree.
  161. X *
  162. X * $Log: bt_funcs.c,v $
  163. X * Revision 1.2  1994/09/17  16:00:11  tbp
  164. X * typhoon.h and environ.h are now included from <>.
  165. X *
  166. X * Revision 1.1  1994/09/13  21:28:28  tbp
  167. X * Added to repository.
  168. X * 
  169. X *
  170. X *--------------------------------------------------------------------------*/
  171. X
  172. Xstatic char rcsid[] = "$Id: bt_funcs.c,v 1.2 1994/09/17 16:00:11 tbp Exp $";
  173. X
  174. X#include <sys/types.h>
  175. X#include <string.h>
  176. X#include <stdio.h>
  177. X#include <fcntl.h>
  178. X#ifdef UNIX
  179. X#    include <unistd.h>
  180. X#else
  181. X#    include <io.h>
  182. X#endif
  183. X#include <typhoon.h>
  184. X#include "ty_dbd.h"
  185. X#include "ty_type.h"
  186. X#include "ty_prot.h"
  187. X#include "ty_glob.h"
  188. X#include "btree.h"
  189. X
  190. X/*--------------------------- Function prototypes --------------------------*/
  191. Xstatic void    get_rightmostchild        PRM( (INDEX *, ulong); )
  192. X       void    get_leftmostchild        PRM( (INDEX *, ulong); )
  193. Xstatic void    synchronize                PRM( (INDEX *); )
  194. X
  195. X
  196. X/*------------------------------- btree_add --------------------------------*\
  197. X *
  198. X * Purpose     : Inserts the key <key> in a B-tree index file.
  199. X *
  200. X * Parameters: I        - B-tree index file descriptor.
  201. X *               key        - Key value to insert.
  202. X *               ref        - Reference to insert together with key.
  203. X *
  204. X * Returns     : S_OKAY        - Key value successfully inserted in B-tree.
  205. X *               S_DUPLICATE    - The key value is already in the B-tree and
  206. X *                              duplicates are not allowed.
  207. X *
  208. X */
  209. X
  210. Xbtree_add(I, key, ref)
  211. XINDEX *I;
  212. Xvoid  *key;
  213. Xulong ref;
  214. X{
  215. X    ulong Ref;
  216. X    ix_addr Addr, moved, p;
  217. X    int i, mid;
  218. X
  219. X    I->curr = 0;
  220. X    I->hold = 0;
  221. X
  222. X    if( d_search(I, key, &p, &i) )
  223. X    {
  224. X        if( I->H.dups )
  225. X        {
  226. X            /* When a duplicate key is already in the tree, the current node
  227. X             * at this point may not be a leaf node. However, insertions
  228. X             * must always be performed in leaf nodes, so we must find the
  229. X             * rightmost entry in the left subtree 
  230. X             */
  231. X
  232. X            if( CHILD(I->node, i) )
  233. X            {
  234. X                get_rightmostchild(I, CHILD(I->node, i));
  235. X                i = I->path[I->level].i;
  236. X                p = I->path[I->level].a;
  237. X            }
  238. X        }
  239. X        else
  240. X            RETURN S_DUPLICATE;
  241. X    }
  242. X
  243. X    I->H.keys++;
  244. X    Addr = 0;
  245. X    Ref = ref;
  246. X    memcpy(I->curkey, key, I->H.keysize);
  247. X
  248. X    do
  249. X    {
  250. X        tupleins(I->node, i, 1);
  251. X        memcpy(KEY(I->node,i), I->curkey, I->H.keysize);
  252. X        CHILD(I->node,i+1) = Addr;
  253. X        REF(I->node,i) = Ref;
  254. X
  255. X        if( NSIZE(I->node) < (ulong)I->H.order )
  256. X        {
  257. X            NSIZE(I->node)++;
  258. X            nodewrite(I, I->node, p);
  259. X            btree_putheader(I);
  260. X            RETURN S_OKAY;
  261. X        }
  262. X 
  263. X        /* split node */
  264. X        mid = I->H.order / 2;
  265. X 
  266. X        /* write left part of node at its old position */
  267. X        NSIZE(I->node) = mid;
  268. X        nodewrite(I, I->node, p);
  269. X 
  270. X        /* Save mid K, A and R */
  271. X        memcpy(I->curkey, KEY(I->node,mid), I->H.keysize);
  272. X        Addr = CHILD(I->node, mid);
  273. X        Ref  = REF(I->node, mid);
  274. X 
  275. X        /* write right part of node at new position */
  276. X        NSIZE(I->node) = I->H.order - mid;
  277. X        memmove(&CHILD(I->node,0), &CHILD(I->node,mid+1), NSIZE(I->node) * I->tsize + sizeof(A_type));
  278. X        Addr = nodewrite(I, I->node, NEWPOS);
  279. X 
  280. X        if( (p = I->path[--I->level].a) != 0 )
  281. X        {
  282. X            noderead(I, I->node, p);                    /* p = I->path[p] */
  283. X/*            nodesearch(I,I->curkey,&i);*/
  284. X            i = I->path[I->level].i;
  285. X        }
  286. X    }
  287. X    while( p );
  288. X 
  289. X    /* Create a new root */
  290. X    noderead(I, I->node, 1);
  291. X    moved = nodewrite(I, I->node, NEWPOS);
  292. X
  293. X    memcpy(KEY(I->node,0), I->curkey, I->H.keysize);
  294. X    CHILD(I->node,0) = moved;
  295. X    CHILD(I->node,1) = Addr;
  296. X    REF(I->node,0) = Ref;
  297. X    NSIZE(I->node) = 1;
  298. X    nodewrite(I, I->node, 1);
  299. X    I->H.timestamp++;
  300. X    btree_putheader(I);
  301. X
  302. X    RETURN S_OKAY;
  303. X}
  304. X
  305. X
  306. X/*------------------------------- btree_find -------------------------------*\
  307. X *
  308. X * Purpose     : Searches for the key value <key> in a B-tree index file.
  309. X *
  310. X * Parameters: I            - B-tree index file descriptor.
  311. X *               key            - Key value to find.
  312. X *               ref            - Contains reference when function returns.
  313. X *
  314. X * Returns     : S_OKAY        - The key value was found. <ref> contains
  315. X *                              reference.
  316. X *               S_NOTFOUND    - The key value was not found.
  317. X *
  318. X */
  319. Xbtree_find(I, key, ref)
  320. XINDEX *I;
  321. Xvoid *key;
  322. Xulong *ref;
  323. X{
  324. X    ix_addr dummy;
  325. X    int i;
  326. X
  327. X    btree_getheader(I);        /* Inserted temporarily */
  328. X
  329. X    if( !d_search(I, key, &dummy, &i) )
  330. X    {
  331. X        /* Do only set hold if there are actually keys in the index */
  332. X        I->hold = I->H.keys > 0 ? 1 : 0;
  333. X        I->curr = 0;
  334. X        RETURN S_NOTFOUND;
  335. X    }
  336. X
  337. X    *ref = REF(I->node, i);
  338. X    memcpy(I->curkey, KEY(I->node, I->path[I->level].i), I->H.keysize);
  339. X    I->hold = 0;
  340. X    I->curr = 1;
  341. X    RETURN S_OKAY;
  342. X}
  343. X
  344. X
  345. X/*------------------------------- btree_keyread -------------------------------*\
  346. X *
  347. X * Purpose     : Copies the contents of the current key value to <buf>.
  348. X *
  349. X * Parameters: I        - B-tree index file descriptor.
  350. X *               buf        - Buffer to copy current key value to.
  351. X *
  352. X * Returns     : S_NOCR    - There is no current key.
  353. X *               S_OKAY    - Key value copied to <buf>.
  354. X *
  355. X */
  356. Xbtree_keyread(I, buf)
  357. XINDEX *I;
  358. Xvoid *buf;
  359. X{
  360. X    if( !I->curr )
  361. X        RETURN S_NOCR;
  362. X
  363. X    memcpy(buf, I->curkey, I->H.keysize);
  364. X    RETURN S_OKAY;
  365. X}
  366. X
  367. X
  368. X/*------------------------------ btree_delall ------------------------------*\
  369. X *
  370. X * Purpose     : Deletes all key values in a B-tree index file.
  371. X *
  372. X * Parameters: I        - B-tree index file descriptor.
  373. X *
  374. X * Returns     : S_OKAY    - All keys deleted.
  375. X *
  376. X */
  377. Xbtree_delall(I)
  378. XINDEX *I;
  379. X{
  380. X    btree_getheader(I);
  381. X    I->H.first_deleted = 0;
  382. X    I->H.keys = 0;
  383. X#ifdef UNIX
  384. X    os_close(open(I->fname, O_TRUNC));
  385. X#else
  386. X    chsize(I->fh, I->H.nodesize);
  387. X#endif
  388. X    I->curr = 0;
  389. X    I->hold = 0;
  390. X    btree_putheader(I);
  391. X
  392. X    RETURN S_OKAY;
  393. X}
  394. X
  395. X
  396. X/*
  397. X * The following macros are used to enhance the readability of the rest of the
  398. X * functions in this file. B-tree traversal can be rather tricky, with lots
  399. X * of pitfalls in it, but these macros should help a great deal. Here is a
  400. X * short explanation of the macros.
  401. X *
  402. X *    Keys        The number of keys in the current node.
  403. X *    Child(i)    The address of the i'th child in the current node.
  404. X *    Key(i)        Pointer to the i'th key in the current node.
  405. X *    Ref(i)        The reference of the i'th key in the current node.
  406. X *    Pos            The current position within the current node.
  407. X *    Addr        The current node address at the current level in the tree.
  408. X *    Level        The current level in the tree.
  409. X *
  410. X */
  411. X
  412. X#define Keys        NSIZE(I->node)
  413. X#define Child(i)    CHILD(I->node, i)
  414. X#define Key(i)        KEY(I->node, i)
  415. X#define Ref(i)        REF(I->node, i)
  416. X#define Pos            (I->path[I->level].i)
  417. X#define Addr        (I->path[I->level].a)
  418. X#define Level        (I->level)
  419. X
  420. X
  421. X/*--------------------------- get_rightmostchild ---------------------------*\
  422. X *
  423. X * Purpose     : Reads the rightmost key in a subtree with root address <addr>.
  424. X *
  425. X * Parameters: I        - B-tree index file descriptor.
  426. X *               addr        - The root address of the subtree.
  427. X *
  428. X * Returns     : Nothing.
  429. X *
  430. X */
  431. X
  432. Xstatic void get_rightmostchild(I, addr)
  433. XINDEX *I;
  434. Xulong addr;
  435. X{
  436. X    /* No tree has root at address 0 */
  437. X    if( !addr )
  438. X        return;
  439. X
  440. X    do
  441. X    {
  442. X        noderead(I, I->node, addr);
  443. X
  444. X        Level++;
  445. X        Addr = addr;
  446. X        Pos  = Keys;
  447. X    }
  448. X    while( addr = Child(Keys) );
  449. X}
  450. X
  451. X
  452. X/*--------------------------- get_leftmostchild ----------------------------*\
  453. X *
  454. X * Purpose     : Reads the leftmost key in a subtree with root address <addr>.
  455. X *
  456. X * Parameters: I        - B-tree index file descriptor.
  457. X *               addr        - The root address of the subtree.
  458. X *
  459. X * Returns     : Nothing.
  460. X *
  461. X */
  462. X
  463. Xvoid get_leftmostchild(I, addr)
  464. XINDEX *I;
  465. Xulong addr;
  466. X{
  467. X    /* No tree has root at address 0 */
  468. X    if( !addr )
  469. X        return;
  470. X
  471. X    do
  472. X    {
  473. X        noderead(I, I->node, addr);
  474. X
  475. X        Level++;
  476. X        Addr = addr;
  477. X        Pos  = 0;
  478. X    }
  479. X    while( addr = Child(0) );
  480. X}
  481. X
  482. X
  483. X/*------------------------------- btree_frst -------------------------------*\
  484. X *
  485. X * Purpose     : Read the smallest key value in a B-tree, i.e. the leftmost key.
  486. X *
  487. X * Parameters: I            - B-tree index file descriptor.
  488. X *               ref            - Contains reference when function returns.
  489. X *
  490. X * Returns     : S_OKAY        - The key was found. <ref> contains reference.
  491. X *               S_NOTFOUND    - The B-tree is empty.
  492. X *
  493. X */
  494. Xbtree_frst(I, ref)
  495. XINDEX *I;
  496. Xulong *ref;
  497. X{
  498. X    I->curr = 0;
  499. X    I->hold = 0;
  500. X    Level = 1;
  501. X    Addr = 1;
  502. X    Pos = 0;
  503. X
  504. X    /* Get the nost recent sequence number */
  505. X       btree_getheader(I);
  506. X    
  507. X    if( noderead(I, I->node, 1) == (ix_addr)-1 )
  508. X        RETURN S_NOTFOUND;
  509. X
  510. X    get_leftmostchild(I, Child(0));
  511. X
  512. X    I->curr = 1;
  513. X    *ref = Ref(Pos);
  514. X    memcpy(I->curkey, Key(Pos), I->H.keysize);
  515. X
  516. X    RETURN S_OKAY;
  517. X}
  518. X
  519. X
  520. X/*------------------------------- btree_last -------------------------------*\
  521. X *
  522. X * Purpose     : Read the greatest key value in a B-tree, i.e. the rightmost key.
  523. X *
  524. X * Parameters: I            - B-tree index file descriptor.
  525. X *               ref            - Contains reference when function returns.
  526. X *
  527. X * Returns     : S_OKAY        - The key was found. <ref> contains reference.
  528. X *               S_NOTFOUND    - The B-tree is empty.
  529. X *
  530. X */
  531. Xbtree_last(I, ref)
  532. XINDEX *I;
  533. Xulong *ref;
  534. X{
  535. X    I->curr = 0;
  536. X    I->hold = 0;
  537. X    Level = 1;
  538. X    Addr = 1;
  539. X
  540. X    /* Get the nost recent sequence number */
  541. X       btree_getheader(I);
  542. X    
  543. X    if( noderead(I, I->node, 1) == (ix_addr)-1 )
  544. X        RETURN S_NOTFOUND;
  545. X
  546. X    Pos = Keys;
  547. X    get_rightmostchild(I, Child(Keys));
  548. X
  549. X    /* Move pos one step leftwards so that Pos is the current key */
  550. X    Pos--;
  551. X    I->curr = 1;
  552. X    *ref = Ref(Pos);
  553. X    memcpy(I->curkey, Key(Pos), I->H.keysize);
  554. X
  555. X    RETURN S_OKAY;
  556. X}
  557. X
  558. X
  559. Xstatic void synchronize(I)
  560. XINDEX *I;
  561. X{
  562. X    ulong old_ts = I->H.timestamp;
  563. X    ulong ref;
  564. X
  565. X     btree_getheader(I);
  566. X
  567. X    if( old_ts != I->H.timestamp )
  568. X        btree_find(I, I->curkey, &ref);
  569. X}
  570. X
  571. X
  572. X
  573. X
  574. X/*------------------------------- btree_prev -------------------------------*\
  575. X *
  576. X * Purpose     : Find key value in a B-tree with less or equal (if duplicates)
  577. X *               key value that the current key. If there is no current key,
  578. X *               the function is equivalent to btree_last(). If the current
  579. X *               position before the call is the leftmost position in the tree,
  580. X *               S_NOTFOUND is returned.
  581. X *
  582. X * Parameters: I            - B-tree index file descriptor.
  583. X *               ref            - Contains reference if a key is found.
  584. X *
  585. X * Returns     : S_OKAY        - Key value found. <ref> contains reference.
  586. X *               S_NOTFOUND    - The key with the smallest value has already
  587. X *                              been reached.
  588. X *
  589. X */
  590. X
  591. Xbtree_prev(I,ref)
  592. XINDEX *I;
  593. Xulong *ref;
  594. X{
  595. X    if( I->shared )
  596. X        synchronize(I);
  597. X
  598. X    if( I->hold )
  599. X        goto out;
  600. X
  601. X    if( !I->curr )
  602. X        return btree_last(I, ref);
  603. X
  604. X    if( Child(Pos) > 0 )                        /* Non-leaf node            */
  605. X    {
  606. X        /* Get the rightmost child in the left subtree */
  607. X        get_rightmostchild(I, Child(Pos));
  608. X    }
  609. X    else if( Pos == 0 )                            /* Leaf node at first pos    */
  610. X    {
  611. X        /* Move upwards until a node with Pos > 0 or root is reached */
  612. X        while( Pos == 0 && Addr != 1 )
  613. X        {
  614. X            Level--;
  615. X            noderead(I, I->node, Addr);
  616. X        }
  617. X
  618. X        if( Pos == 0 && Addr == 1 )
  619. X        {
  620. X            I->curr = 0;
  621. X            RETURN S_NOTFOUND;
  622. X        }
  623. X    }
  624. X    Pos--;
  625. X
  626. Xout:
  627. X    I->curr = 1;
  628. X    I->hold = 0;
  629. X
  630. X    *ref = Ref(Pos);
  631. X    memcpy(I->curkey, Key(Pos), I->H.keysize);
  632. X
  633. X    RETURN S_OKAY;
  634. X}
  635. X
  636. X
  637. X/*------------------------------- btree_next -------------------------------*\
  638. X *
  639. X * Purpose     : Find key value in a B-tree with greater or equal (if duplicates)
  640. X *               key value that the current key. If there is no current key,
  641. X *               the function is equivalent to btree_frst(). If the current
  642. X *               position before the call is the rightmost position in the tree,
  643. X *               S_NOTFOUND is returned.
  644. X *
  645. X * Parameters: I            - B-tree index file descriptor.
  646. X *               ref            - Contains reference if a key is found.
  647. X *
  648. X * Returns     : S_OKAY        - Key value found. <ref> contains reference.
  649. X *               S_NOTFOUND    - The key with the greatest value has already
  650. X *                              been reached.
  651. X *
  652. X */
  653. Xbtree_next(I,ref)
  654. XINDEX *I;
  655. Xulong *ref;
  656. X{
  657. X    if( I->shared )
  658. X        synchronize(I);
  659. X
  660. X    if( I->hold )
  661. X    {
  662. X        /* An unsuccessful keyfind must be handled as a special case:
  663. X         * If we are at the rightmost position in a node, move upwards until
  664. X         * we reach a node where the position is not the rightmost. This
  665. X         * key should be the proper next key in the B-tree.
  666. X         */
  667. X
  668. X        while( Pos == Keys && Level > 1 )
  669. X        {
  670. X            Level--;
  671. X            noderead(I, I->node, Addr);
  672. X         }
  673. X
  674. X        if( Level == 1 && Pos == Keys )
  675. X            RETURN S_NOTFOUND;
  676. X
  677. X        goto out;
  678. X    }
  679. X
  680. X    if( !I->curr )
  681. X        return btree_frst(I, ref);
  682. X
  683. X    if( Child(Pos) > 0 )                        /* Non-leaf node            */
  684. X    {
  685. X        /* Get the leftmost child in the left subtree */
  686. X        Pos++;
  687. X        get_leftmostchild(I, Child(Pos));
  688. X    }
  689. X    else if( Pos >= Keys-1 )                    /* Leaf node at first pos    */
  690. X    {
  691. X#if 0
  692. X        if( Pos == Keys-1 && Addr == 1 )    94/03/17 TBP
  693. X#else
  694. X        if( Pos >= Keys-1 && Addr == 1 )
  695. X#endif
  696. X        {
  697. X            I->curr = 0;
  698. X            RETURN S_NOTFOUND;
  699. X        }
  700. X
  701. X        /* Move upwards until a node with Pos < Keys-1 or root is reached */
  702. X        do
  703. X        {
  704. X            Level--;
  705. X            noderead(I, I->node, Addr);
  706. X        }
  707. X        while( Pos >= Keys && Addr != 1 );
  708. X
  709. X        if( Pos == Keys && Addr == 1 )
  710. X        {
  711. X            I->curr = 0;
  712. X            RETURN S_NOTFOUND;
  713. X        }
  714. X    }
  715. X    else                                        /* Leaf node                */
  716. X        Pos++;
  717. X
  718. Xout:
  719. X    I->curr = 1;
  720. X    I->hold = 0;
  721. X
  722. X    *ref = Ref(Pos);
  723. X    memcpy(I->curkey, Key(Pos), I->H.keysize);
  724. X
  725. X    RETURN S_OKAY;
  726. X}
  727. X 
  728. X/* end-of-file */
  729. X
  730. END_OF_FILE
  731.   if test 14705 -ne `wc -c <'typhoon/src/bt_funcs.c'`; then
  732.     echo shar: \"'typhoon/src/bt_funcs.c'\" unpacked with wrong size!
  733.   fi
  734.   # end of 'typhoon/src/bt_funcs.c'
  735. fi
  736. if test ! -d 'typhoon/src/h' ; then
  737.     echo shar: Creating directory \"'typhoon/src/h'\"
  738.     mkdir 'typhoon/src/h'
  739. fi
  740. if test ! -d 'typhoon/src/util' ; then
  741.     echo shar: Creating directory \"'typhoon/src/util'\"
  742.     mkdir 'typhoon/src/util'
  743. fi
  744. if test -f 'typhoon/src/util/ddl.y' -a "${1}" != "-c" ; then 
  745.   echo shar: Will not clobber existing file \"'typhoon/src/util/ddl.y'\"
  746. else
  747.   echo shar: Extracting \"'typhoon/src/util/ddl.y'\" \(14286 characters\)
  748.   sed "s/^X//" >'typhoon/src/util/ddl.y' <<'END_OF_FILE'
  749. X/*----------------------------------------------------------------------------
  750. X * File    : ddl.y
  751. X * Program : ddlp
  752. X * OS      : UNIX, OS/2, DOS
  753. X * Author  : Thomas B. Pedersen
  754. X *
  755. X * Copyright (c) 1994 Thomas B. Pedersen.  All rights reserved.
  756. X *
  757. X * Permission is hereby granted, without written agreement and without
  758. X * license or royalty fees, to use, copy, modify, and distribute this
  759. X * software and its documentation for any purpose, provided that the above
  760. X * copyright notice and the following two  paragraphs appear (1) in all 
  761. X * source copies of this software and (2) in accompanying documentation
  762. X * wherever the programatic interface of this software, or any derivative
  763. X * of it, is described.
  764. X *
  765. X * IN NO EVENT SHALL THOMAS B. PEDERSEN BE LIABLE TO ANY PARTY FOR DIRECT,
  766. X * INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF
  767. X * THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF HE HAS BEEN 
  768. X * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  769. X *
  770. X * THOMAS B. PEDERSEN SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT
  771. X * NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  772. X * A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS ON AN "AS IS" 
  773. X * BASIS, AND THOMAS B. PEDERSEN HAS NO OBLIGATION TO PROVIDE MAINTENANCE,
  774. X * SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
  775. X *
  776. X * Description:
  777. X *   Grammar for ddl-files.
  778. X *
  779. X * $Id: ddl.y,v 1.2 1994/09/17 16:11:13 tbp Exp $
  780. X *
  781. X * $Log: ddl.y,v $
  782. X * Revision 1.2  1994/09/17  16:11:13  tbp
  783. X * Added include directive.
  784. X *
  785. X * Added included directive.
  786. X *
  787. X * Added include directive.
  788. X *
  789. X * Revision 1.1  1994/09/13  21:28:51  tbp
  790. X * Added to repository.
  791. X *
  792. X * Added to repository.
  793. X * 
  794. X *
  795. X *--------------------------------------------------------------------------*/
  796. X
  797. X%{
  798. X
  799. X#include <string.h>
  800. X#include <stdarg.h>
  801. X#include <typhoon.h>
  802. X#include "../ty_dbd.h"
  803. X#include "../ty_type.h"
  804. X#include "ddlp.h"
  805. X#include "ddlpsym.h"
  806. X#include "ddlpglob.h"
  807. X
  808. X/*--------------------------- Function prototypes --------------------------*/
  809. Xstatic void add_keymember               PRM( (sym_struct *, char *, int); )
  810. X
  811. X/*---------------------------- Global variables ----------------------------*/
  812. Xstatic unsigned type;               /* Holds FT_.. flags of current field    */
  813. Xstatic int keytype;                 /* Holds KT_... constants                */
  814. Xstatic sym_member *control_field;    /* Field that controls current union    */
  815. X
  816. X
  817. Xstatic fieldid[10];
  818. X
  819. X%}
  820. X
  821. X%union {
  822. X    int     val;
  823. X    char    is_union;
  824. X    char    s[IDENT_LEN+1];
  825. X}
  826. X
  827. X%start database
  828. X
  829. X%token                T_DATABASE T_KEY T_DATA T_FILE T_CONTAINS T_RECORD
  830. X%token                T_UNIQUE T_DEFINE T_CONTROLLED T_MAP T_ARROW
  831. X%token                T_PRIMARY T_ALTERNATE T_FOREIGN T_ON T_DELETE T_RESTRICT
  832. X%token                T_REFERENCES T_UPDATE T_CASCADE T_NULL
  833. X%token                T_CHAR T_SHORT T_INT T_LONG T_SIGNED T_UNSIGNED T_FLOAT 
  834. X%token                T_DOUBLE T_UCHAR T_USHORT T_ULONG T_STRUCT T_UNION
  835. X%token                T_COMPOUND T_ASC T_DESC T_VARIABLE T_BY
  836. X%token <s>            T_IDENT T_STRING
  837. X%token <val>        T_NUMBER T_CHARCONST
  838. X%token                '[' ']' '{' '}' ';' ',' '.' '>'
  839. X%token                '+' '-' '*' '/' '(' ')'
  840. X
  841. X%type <val>            expr opt_sortorder opt_unique opt_null pagesize action
  842. X%type <val>            map_id
  843. X%type <is_union>    struct_or_union
  844. X%type <s>            opt_ident key_type
  845. X
  846. X%left '+' '-'
  847. X%left '*' '/'
  848. X
  849. X%%
  850. X
  851. Xdatabase     : T_DATABASE T_IDENT '{' decl_list '}'
  852. X                 { strcpy(dbname, $2); }
  853. X             ;
  854. X
  855. Xpagesize    : /* use default page size */
  856. X                { $$ = 512;       }
  857. X            | '[' expr ']'
  858. X                {
  859. X                    if( $2 < 512 )
  860. X                    {
  861. X                        printf("Page size too small\n");
  862. X                        $$ = 512;
  863. X                    }
  864. X                    else
  865. X                        $$ = $2;
  866. X                }
  867. X            ;
  868. X
  869. Xdecl_list    : decl  
  870. X            | decl_list decl
  871. X            ;
  872. X
  873. Xdecl        : T_DATA T_FILE pagesize T_STRING T_CONTAINS T_IDENT ';'
  874. X                {
  875. X                    add_contains('d', $6, "");
  876. X                    add_file('d', $4, $3);
  877. X                }
  878. X            | T_KEY T_FILE pagesize T_STRING T_CONTAINS T_IDENT '.' key_type ';'
  879. X                {
  880. X                    char type = strcmp($8, "<ref>") ? 'k' : 'r';
  881. X
  882. X                    add_contains(type, $6, $8);
  883. X                    add_file(type, $4, $3);
  884. X                }
  885. X            | record_head '{' member_list opt_key_list '}'
  886. X                {
  887. X                    sym_endstruct();
  888. X                    record[records-1].size = structnest[curnest+1]->size;
  889. X                    structdef[record[records-1].structid].size = record[records-1].size;
  890. X                }
  891. X            | T_DEFINE T_IDENT expr    { add_define($2, $3);                    }
  892. X            | T_MAP '{' map_list '}'
  893. X            ;
  894. X
  895. Xrecord_head    : T_RECORD T_IDENT        { add_record($2);
  896. X                                      add_structdef($2, 0, 0);
  897. X                                      sym_addstruct($2, 0);                    }
  898. X            ;
  899. X
  900. Xkey_type    : T_IDENT                 { strcpy($$, $1);                         }
  901. X            | T_REFERENCES            { strcpy($$, "<ref>");                    }
  902. X            ;
  903. X
  904. Xmember_list    : member
  905. X            | member_list member
  906. X            ;
  907. X
  908. Xmember        : membertype T_IDENT opt_dimen ';'
  909. X                {
  910. X                    sym_addmember($2, type, NULL);
  911. X                    cur_str->last_member->id = fields;
  912. X
  913. X                    if( type != FT_STRUCT )
  914. X                        add_field($2, type);
  915. X
  916. X                    /* Increase the number of level-0 fields of the record */
  917. X                    if( curnest == 0 )
  918. X                        structdef[record[records-1].structid].members++;
  919. X
  920. X                    type = 0;
  921. X                }
  922. X            | struct_specifier ';'
  923. X            ;
  924. X
  925. Xopt_dimen    : 
  926. X            | dimension opt_varlen_decl
  927. X            ;
  928. X
  929. Xdimension    : array
  930. X            | dimension array
  931. X            ;
  932. X
  933. Xarray        : '[' expr ']'            { dim[dims++] = $2;                        }
  934. X            ;
  935. X
  936. X
  937. Xopt_varlen_decl
  938. X            :
  939. X            | T_VARIABLE T_BY T_IDENT
  940. X                { 
  941. X/*                    if( curnest != 1 )
  942. X                        yyerror("variable size fields cannot be nested");*/
  943. X
  944. X                    if( !(size_field = sym_findmember(structnest[0], $3)) )
  945. X                        yyerror("unknown struct member '%s'", $3);
  946. X                }
  947. X            ;
  948. X
  949. X
  950. X/*--------------------------------------------------------------------------*/
  951. X/*                        Key declaration part                              */
  952. X/*--------------------------------------------------------------------------*/
  953. X
  954. Xopt_key_list: opt_primary_key_decl
  955. X              opt_alternate_key_decl_list
  956. X              opt_foreign_key_decl_list
  957. X            ;
  958. X
  959. X/*--------------------------------------------------------------------------*/
  960. X/*                            Primary key                                   */
  961. X/*--------------------------------------------------------------------------*/
  962. X
  963. Xopt_primary_key_decl
  964. X            : /* No primary key */
  965. X            | T_PRIMARY key_decl ';'
  966. X                {
  967. X                    key[keys-1].type = KT_PRIMARY|KT_UNIQUE;
  968. X                }
  969. X            ;
  970. X
  971. X
  972. X/*--------------------------------------------------------------------------*/
  973. X/*                            Alternate key                                 */
  974. X/*--------------------------------------------------------------------------*/
  975. X
  976. Xopt_alternate_key_decl_list
  977. X            :
  978. X            | alternate_key_decl_list
  979. X            ;
  980. X
  981. Xalternate_key_decl_list
  982. X            : alternate_key_decl
  983. X            | alternate_key_decl_list alternate_key_decl
  984. X            ;
  985. X
  986. Xalternate_key_decl
  987. X            : T_ALTERNATE opt_unique key_decl opt_null ';'
  988. X                {
  989. X                    key[keys-1].type = KT_ALTERNATE | $2 | $4;
  990. X                }
  991. X            ;
  992. X
  993. X
  994. X/*--------------------------------------------------------------------------*/
  995. X/*                             Foreign key                                  */
  996. X/*--------------------------------------------------------------------------*/
  997. X
  998. Xopt_foreign_key_decl_list
  999. X            :
  1000. X            | foreign_key_decl_list
  1001. X            ;
  1002. X
  1003. Xforeign_key_decl_list
  1004. X            : foreign_key_decl
  1005. X            | foreign_key_decl_list foreign_key_decl
  1006. X            ;
  1007. X
  1008. X
  1009. Xforeign_key_decl
  1010. X            : T_FOREIGN key_decl T_REFERENCES T_IDENT 
  1011. X              T_ON T_UPDATE action 
  1012. X              T_ON T_DELETE action opt_null ';'
  1013. X                {
  1014. X                    /* Set the record's first_foreign field */
  1015. X                    if( record[records-1].first_foreign == -1 )
  1016. X                        record[records-1].first_foreign = keys-1;
  1017. X
  1018. X                    key[keys-1].type = KT_FOREIGN | $7 | $10 | $11;
  1019. X                    check_foreign_key($4, &key[keys-1]);
  1020. X                }
  1021. X            ;
  1022. X
  1023. Xaction        : T_RESTRICT            { $$ = KT_RESTRICT;                    }
  1024. X            | T_CASCADE             { $$ = KT_CASCADE;
  1025. X                                      yyerror("'cascade' not supported");
  1026. X                                     }
  1027. X            ;
  1028. X
  1029. X
  1030. X/*--------------------------------------------------------------------------*/
  1031. X/*    Key declaration rules used by primary, alternate and foreign keys     */
  1032. X/*--------------------------------------------------------------------------*/
  1033. X
  1034. Xopt_null    : /* not optional */
  1035. X                {
  1036. X                    $$ = 0;
  1037. X                }
  1038. X            | T_NULL T_BY T_IDENT    
  1039. X                {
  1040. X                    sym_member *mem;
  1041. X                    int type;
  1042. X
  1043. X                    if( !(mem = sym_findmember(cur_str, $3)) )
  1044. X                        yyerror("'%s' is not a member the record", $3);
  1045. X                    else
  1046. X                    {
  1047. X                        key[keys-1].null_indicator = mem->id;
  1048. X                        type = FT_GETBASIC(field[mem->id].type);
  1049. X
  1050. X                        if( type != FT_CHAR && type != FT_CHARSTR )
  1051. X                            yyerror("field determiner must be char or string");
  1052. X                    }
  1053. X
  1054. X                    $$ = KT_OPTIONAL;
  1055. X                }
  1056. X            ;
  1057. X
  1058. X
  1059. Xkey_decl    : key_decl_head comkey_member_list '}'
  1060. X                {
  1061. X                    sym_endstruct();
  1062. X
  1063. X                    /* Set the size of the compound key.
  1064. X                    * Foreign keys have special size.
  1065. X                    */
  1066. X                    if( KT_GETBASIC(key[keys-1].type) == KT_FOREIGN )
  1067. X                        key[keys-1].size = sizeof(REF_ENTRY);
  1068. X                    else
  1069. X                        key[keys-1].size = last_str->size;
  1070. X                }
  1071. X            | T_KEY T_IDENT
  1072. X                {
  1073. X                    sym_member *mem;
  1074. X
  1075. X                    if( !(mem = sym_findmember(cur_str, $2)) )
  1076. X                        yyerror("unknown field '%s'", $2);
  1077. X
  1078. X                    add_key($2);
  1079. X                    add_keyfield(mem->id, 1);
  1080. X
  1081. X                    key[keys-1].size = mem->size;
  1082. X                    field[mem->id].type |= FT_KEY;
  1083. X                    field[mem->id].keyid = keys-1;
  1084. X                }
  1085. X            ;
  1086. X
  1087. Xkey_decl_head
  1088. X            : T_KEY T_IDENT '{'
  1089. X                {
  1090. X                    /* Ensure that the key name is not also a field name */
  1091. X                    if( sym_findmember(cur_str, $2) ) 
  1092. X                        yyerror("the key '%s' is already a field name", $2);
  1093. X
  1094. X                    sym_addstruct($2, 0);
  1095. X                    add_key($2);
  1096. X                }
  1097. X            ;
  1098. X
  1099. X
  1100. X/*--------------------------------------------------------------------------*/
  1101. X/*                       Compound key declaration                           */
  1102. X/*--------------------------------------------------------------------------*/
  1103. X
  1104. Xcomkey_member_list
  1105. X            : comkey_member
  1106. X            | comkey_member_list ',' comkey_member
  1107. X            ;
  1108. X
  1109. Xcomkey_member
  1110. X            : T_IDENT opt_sortorder 
  1111. X                {
  1112. X                    add_keymember(structnest[curnest-1], $1, $2);   
  1113. X                }
  1114. X            ;
  1115. X
  1116. Xopt_unique    :                         { $$ = 0;              /* Not unique */}
  1117. X            | T_UNIQUE                { $$ = KT_UNIQUE;     /* Unique */    }
  1118. X            ;
  1119. X
  1120. Xopt_sortorder
  1121. X            : /* default */            { $$ = 1;        /* Ascending */     }
  1122. X            | T_ASC                    { $$ = 1;        /* Ascending */     }
  1123. X            | T_DESC                   { $$ = 0;        /* Descending */    }
  1124. X            ;
  1125. X
  1126. X/*--------------------------------------------------------------------------*/
  1127. X/*                      Structure member definition                         */
  1128. X/*--------------------------------------------------------------------------*/
  1129. X
  1130. Xmembertype    : int_type
  1131. X            | int_sign                { if( type == FT_UNSIGNED )
  1132. X                                          type |= FT_INT;                }
  1133. X            | int_sign int_type
  1134. X            | float_type
  1135. X            | u_type
  1136. X            | T_LONG float_type        { type |= FT_LONG;                    }
  1137. X            ;
  1138. X
  1139. Xint_type    : T_CHAR                 { type |= FT_CHAR;                     }
  1140. X            | T_SHORT                { type |= FT_SHORT;                    }
  1141. X            | T_INT                  { type |= FT_INT;                      }
  1142. X            | T_LONG                 { type |= FT_LONG;                     }
  1143. X            ;
  1144. X
  1145. Xint_sign    : T_SIGNED
  1146. X            | T_UNSIGNED            { type |= FT_UNSIGNED;                }
  1147. X            ;
  1148. X
  1149. Xfloat_type    : T_FLOAT                 { type |= FT_FLOAT;                 }
  1150. X            | T_DOUBLE                { type |= FT_DOUBLE;                }
  1151. X            ;
  1152. X
  1153. Xu_type        : T_UCHAR                 { type |= FT_UNSIGNED|FT_CHAR;         }
  1154. X              | T_USHORT                { type |= FT_UNSIGNED|FT_SHORT;        }
  1155. X              | T_ULONG                 { type |= FT_UNSIGNED|FT_LONG;         }
  1156. X              ;
  1157. X
  1158. Xexpr        : expr '+' expr            { $$ = $1 + $3; }
  1159. X            | expr '-' expr            { $$ = $1 - $3; }
  1160. X            | expr '*' expr            { $$ = $1 * $3; }
  1161. X            | expr '/' expr            { $$ = $1 / $3; }
  1162. X            | '(' expr ')'             { $$ = $2;      }
  1163. X            | T_NUMBER
  1164. X            ;
  1165. X
  1166. X/*--------------------------------------------------------------------------*/
  1167. X/*                       struct or union declaration                        */
  1168. X/*--------------------------------------------------------------------------*/
  1169. X
  1170. Xstruct_specifier
  1171. X            : struct_or_union_opt_ident '{' member_list '}' T_IDENT opt_dimen
  1172. X                {
  1173. X                    sym_struct *str;
  1174. X                    Field *fld;
  1175. X                    Structdef *strdef;
  1176. X
  1177. X                    sym_endstruct();
  1178. X
  1179. X                    str     = structnest[curnest + 1];
  1180. X                    fld     = &field[str->fieldid];
  1181. X                    strdef  = &structdef[ fld->structid ];
  1182. X
  1183. X                    strcpy(fld->name, $5);
  1184. X                    strdef->size    = str->size;
  1185. X                    strdef->members = str->members;
  1186. X
  1187. X                    sym_addmember($5, FT_STRUCT, structnest[curnest+1]);
  1188. X
  1189. X                    fld->size        = cur_str->last_member->size;
  1190. X                    fld->elemsize    = cur_str->last_member->elemsize;
  1191. X                    fld->offset        = cur_str->last_member->offset;
  1192. X
  1193. X                    if( size_field )
  1194. X                    {
  1195. X                        fld->type |= FT_VARIABLE;
  1196. X                        fld->keyid = size_field->id;
  1197. X                        size_field = NULL;
  1198. X                    }
  1199. X                }
  1200. X            | struct_or_union T_IDENT T_IDENT opt_dimen
  1201. X                {                                                  
  1202. X                    sym_struct *str = sym_findstruct($2, $1);
  1203. X
  1204. X                    if( str )
  1205. X                    {
  1206. X                        sym_addmember($3, FT_STRUCT, str);
  1207. X/*                        add_field($3, FT_STRUCT);*/
  1208. X                    }
  1209. X                    /* else error message */
  1210. X                }
  1211. X            ;
  1212. X
  1213. Xstruct_or_union_opt_ident
  1214. X            : struct_or_union opt_ident     
  1215. X                {
  1216. X                    add_field("<struct>", FT_STRUCT);
  1217. X                    sym_addstruct($2, $1);          
  1218. X                    cur_str->fieldid = fields-1;
  1219. X                    field[fields-1].structid = structdefs;
  1220. X
  1221. X                    add_structdef($2, $1, $1 ? control_field->id : 0);
  1222. X
  1223. X                    /* Increase the number of level-0 field of the record.
  1224. X                     * Actually, at this point the grammar we have moved to
  1225. X                     * level 1.
  1226. X                     */
  1227. X                    if( curnest == 1 )
  1228. X                        structdef[record[records-1].structid].members++;
  1229. X                }
  1230. X            ;
  1231. X
  1232. Xstruct_or_union
  1233. X            : T_STRUCT                              
  1234. X                {
  1235. X                    $$ = 0;
  1236. X                }
  1237. X            | T_UNION T_CONTROLLED T_BY T_IDENT
  1238. X                {
  1239. X                    $$ = 1;                                                               
  1240. X                    if( !(control_field = sym_findmember(cur_str, $4)) )
  1241. X                        yyerror("'%s' is not a member of the union/struct '%s'",
  1242. X                        $4, cur_str->name);
  1243. X                }
  1244. X            ;
  1245. X
  1246. Xopt_ident    :                        { *$$ = 0;                           }
  1247. X            | T_IDENT                { strcpy($$, $1);                    }
  1248. X            ;
  1249. X
  1250. X
  1251. X
  1252. X/*--------------------------------------------------------------------------*/
  1253. X/*                                 map_list                                    */
  1254. X/*--------------------------------------------------------------------------*/
  1255. X
  1256. Xmap_list    : map
  1257. X            | map_list map
  1258. X            ;
  1259. X
  1260. Xmap            : map_id T_ARROW map_id ';'    { header.sorttable[$1] = $3;    }
  1261. X            ;
  1262. X
  1263. Xmap_id        : T_CHARCONST                { $$ = $1;                        }
  1264. X            | T_NUMBER                    { $$ = $1;                        }
  1265. X            ;
  1266. X
  1267. X
  1268. X%%
  1269. X
  1270. X#include <stdio.h>
  1271. X
  1272. X
  1273. X
  1274. Xstatic void add_keymember(str, name, sortorder)
  1275. Xsym_struct *str;
  1276. Xchar *name;
  1277. Xint sortorder;
  1278. X{
  1279. X    sym_member *mem;
  1280. X
  1281. X    if( mem = sym_findmember(str, name) )
  1282. X    {
  1283. X        dims = mem->dims;
  1284. X        memcpy(dim, mem->dim, sizeof(*dim) * dims);
  1285. X        sym_addmember(name, mem->type, mem->struc);
  1286. X        add_keyfield(mem->id, sortorder);
  1287. X    }
  1288. X    else
  1289. X        yyerror("unknown struct member '%s'", name);
  1290. X}
  1291. X
  1292. X
  1293. X
  1294. X
  1295. Xextern errors;
  1296. X
  1297. Xyyerror(char *fmt ELLIPSIS)
  1298. X{
  1299. X    va_list ap;
  1300. X
  1301. X    printf("%s %d: ", ddlname, lex_lineno);
  1302. X    va_start(ap, fmt);
  1303. X    vprintf(fmt, ap);
  1304. X    puts("");
  1305. X    va_end(ap);
  1306. X    errors++;
  1307. X    return 0;
  1308. X}
  1309. X
  1310. X/* end-of-file */
  1311. END_OF_FILE
  1312.   if test 14286 -ne `wc -c <'typhoon/src/util/ddl.y'`; then
  1313.     echo shar: \"'typhoon/src/util/ddl.y'\" unpacked with wrong size!
  1314.   fi
  1315.   # end of 'typhoon/src/util/ddl.y'
  1316. fi
  1317. if test -f 'typhoon/src/util/ddlp.c' -a "${1}" != "-c" ; then 
  1318.   echo shar: Will not clobber existing file \"'typhoon/src/util/ddlp.c'\"
  1319. else
  1320.   echo shar: Extracting \"'typhoon/src/util/ddlp.c'\" \(21611 characters\)
  1321.   sed "s/^X//" >'typhoon/src/util/ddlp.c' <<'END_OF_FILE'
  1322. X/*----------------------------------------------------------------------------
  1323. X * File    : ddlp.c
  1324. X * Program : ddlp
  1325. X * OS      : UNIX, OS/2, DOS
  1326. X * Author  : Thomas B. Pedersen
  1327. X *
  1328. X * Copyright (c) 1994 Thomas B. Pedersen.  All rights reserved.
  1329. X *
  1330. X * Permission is hereby granted, without written agreement and without
  1331. X * license or royalty fees, to use, copy, modify, and distribute this
  1332. X * software and its documentation for any purpose, provided that the above
  1333. X * copyright notice and the following two  paragraphs appear (1) in all 
  1334. X * source copies of this software and (2) in accompanying documentation
  1335. X * wherever the programatic interface of this software, or any derivative
  1336. X * of it, is described.
  1337. X *
  1338. X * IN NO EVENT SHALL THOMAS B. PEDERSEN BE LIABLE TO ANY PARTY FOR DIRECT,
  1339. X * INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF
  1340. X * THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF HE HAS BEEN 
  1341. X * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  1342. X *
  1343. X * THOMAS B. PEDERSEN SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT
  1344. X * NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  1345. X * A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS ON AN "AS IS" 
  1346. X * BASIS, AND THOMAS B. PEDERSEN HAS NO OBLIGATION TO PROVIDE MAINTENANCE,
  1347. X * SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
  1348. X *
  1349. X * Description:
  1350. X *   Grammar for ddl-files.
  1351. X *
  1352. X * $Log: ddlp.c,v $
  1353. X * Revision 1.2  1994/09/17  16:00:51  tbp
  1354. X * typhoon.h and environ.h are now included from <>.
  1355. X *
  1356. X * Revision 1.1  1994/09/13  21:28:52  tbp
  1357. X * Added to repository.
  1358. X *
  1359. X * Added to repository.
  1360. X * 
  1361. X *
  1362. X *--------------------------------------------------------------------------*/
  1363. X
  1364. Xstatic char rcsid[] = "$Id: ddlp.c,v 1.2 1994/09/17 16:00:51 tbp Exp $";
  1365. X
  1366. X#include <stdio.h>
  1367. X#include <string.h>
  1368. X#include <ctype.h>
  1369. X#include <fcntl.h>
  1370. X#include <stdarg.h>
  1371. X#ifndef UNIX
  1372. X#  include <sys\types.h>
  1373. X#  include <sys\stat.h>
  1374. X#  include <stdlib.h>
  1375. X#  include <io.h>
  1376. X#endif
  1377. X#define DEFINE_GLOBALS
  1378. X#include <typhoon.h>
  1379. X#include "../ty_dbd.h"
  1380. X#include "../ty_type.h"
  1381. X#include "ddlp.h"
  1382. X#include "ddlpsym.h"
  1383. X#include "ddlpglob.h"
  1384. X#include "ddl_y.h"
  1385. X
  1386. X/*-------------------------- Function prototypes ---------------------------*/
  1387. Xint        yyparse                PRM( (void); )
  1388. Xvoid    align_offset        PRM( (unsigned *, int); )
  1389. Xvoid    check_consistency    PRM( (void); )
  1390. Xvoid    print_fieldname     PRM( (FILE *, int, Id); )
  1391. Xvoid    fix_file            PRM( (void); )
  1392. Xvoid    fix_fields            PRM( (void); )
  1393. X
  1394. X/*---------------------------- Global variables ----------------------------*/
  1395. XFILE *lex_file, *hfile;
  1396. Xint dbdfile;
  1397. X
  1398. Xstatic char paramhelp[] = "\
  1399. XSyntax: ddlp [option]... file[.ddl]\n\
  1400. XOptions:\n\
  1401. X    -a[1|2|4]   Set structure alignment (default is %d)\n\
  1402. X    -f          Only generate field constants for keys\n\
  1403. X    -h<file>    Use <file> as header file\n";
  1404. X
  1405. X
  1406. X
  1407. Xchar *strupr(s)
  1408. Xchar *s;
  1409. X{
  1410. X    char *olds = s;
  1411. X
  1412. X    while( *s )
  1413. X    {
  1414. X        *s = toupper(*s);
  1415. X        s++;
  1416. X    }
  1417. X
  1418. X    return olds;
  1419. X}
  1420. X
  1421. X
  1422. X#ifdef UNIX
  1423. X#ifndef __STDC__
  1424. Xchar *strstr(s1, s2)
  1425. Xchar *s1, *s2;
  1426. X{
  1427. X    int len = strlen(s2);
  1428. X
  1429. X    while( *s1 )
  1430. X    {
  1431. X        if( *s2 == *s1 )
  1432. X            if( !memcmp(*s1,s2,len) )
  1433. X            return s1;
  1434. X        s1++;
  1435. X    }
  1436. X    return NULL;
  1437. X}
  1438. X#endif
  1439. X#endif
  1440. X
  1441. X
  1442. Xistrcmp(s1, s2)
  1443. Xchar *s1, *s2;
  1444. X{
  1445. X       while( tolower(*s1) == tolower(*s2) && *s1 && *s2 )
  1446. X          s1++, s2++;
  1447. X   
  1448. X       return tolower(*s1) - tolower(*s2);
  1449. X}
  1450. X
  1451. X
  1452. X/*------------------------------ align_offset ------------------------------*\
  1453. X *
  1454. X * Purpose   : Align an address to fit the next field type.
  1455. X *
  1456. X * Parameters: offset   - Offset to align.
  1457. X *               type     - Field type (FT_...).
  1458. X *
  1459. X * Returns   : offset   - The aligned offset.
  1460. X *
  1461. X */
  1462. Xvoid align_offset(offset, type)
  1463. Xunsigned *offset;
  1464. Xint type;
  1465. X{
  1466. X    int rem = *offset % align;
  1467. X    int size;
  1468. X
  1469. X/*    if( type == FT_STRUCT )
  1470. X        return;*/
  1471. X
  1472. X    if( !rem || FT_GETBASIC(type) == FT_CHAR || !*offset )
  1473. X        return;
  1474. X
  1475. X    if( type == FT_STRUCT )
  1476. X        size = sizeof(long);
  1477. X    else
  1478. X        size = typeinfo[FT_GETBASIC(type) - 1].size;
  1479. X
  1480. X    if( rem == size )
  1481. X        return;
  1482. X
  1483. X    if( size < align - rem  )
  1484. X        *offset += rem;
  1485. X    else
  1486. X        *offset += align - rem;
  1487. X}
  1488. X
  1489. X
  1490. X/*--------------------------------- add_key --------------------------------*\
  1491. X *
  1492. X * Purpose   : Adds a key definition to the record currently being defined.
  1493. X *
  1494. X * Parameters: name     - Key name
  1495. X *
  1496. X * Returns   : Nothing.
  1497. X *
  1498. X */
  1499. Xvoid add_key(name)
  1500. Xchar *name;
  1501. X{
  1502. X    Key *k = key + keys++;
  1503. X
  1504. X    /* Add an entry to the key table */
  1505. X    k->first_keyfield = keyfields;
  1506. X    k->fields         = 0;
  1507. X    k->size           = 0;
  1508. X    strcpy(k->name, name);
  1509. X
  1510. X    /* Increase the number of keys in the record */
  1511. X    record[records-1].keys++;
  1512. X}
  1513. X
  1514. X
  1515. X/*------------------------------- add_keyfield -----------------------------*\
  1516. X *
  1517. X * Purpose   : Adds a field to the key currently being defined.
  1518. X *
  1519. X * Parameters: id       - Field id.
  1520. X *               ascending   - Is key sorted in ascending order?
  1521. X *
  1522. X * Returns   : Nothing.
  1523. X *
  1524. X */
  1525. X
  1526. Xvoid add_keyfield(id, ascending)
  1527. XId id;
  1528. Xint ascending;
  1529. X{
  1530. X    KeyField *keyfld = keyfield + keyfields++;
  1531. X
  1532. X    keyfld->field  = id;
  1533. X    keyfld->asc    = ascending;
  1534. X
  1535. X    /* The offset is only used in compound keys */
  1536. X    if( key[keys-1].fields )
  1537. X        keyfld->offset = cur_str->last_member->offset;
  1538. X    else
  1539. X        keyfld->offset = 0;
  1540. X
  1541. X    /* Increase the number of fields of the key currently being defined */
  1542. X    key[keys-1].fields++;
  1543. X}
  1544. X
  1545. X
  1546. Xvoid add_define(name, value)
  1547. Xchar *name;
  1548. Xint value;
  1549. X{
  1550. X    strcpy(define[defines].name, name);
  1551. X    define[defines++].value = value;
  1552. X}
  1553. X
  1554. X
  1555. Xvoid add_file(type, name, pagesize)
  1556. Xint type;
  1557. Xchar *name;
  1558. Xunsigned pagesize;
  1559. X{
  1560. X    file[files].id    = -1;             /* Unresolved           */
  1561. X    file[files].type  = type;
  1562. X    file[files].pagesize= pagesize;
  1563. X    strcpy(file[files++].name, name);
  1564. X}
  1565. X
  1566. X
  1567. X/*------------------------------ add_contains ------------------------------*\
  1568. X *
  1569. X * Purpose   : Add a new entry to the contains table. This table is used to
  1570. X *             determine which records and keys references and are referenced
  1571. X *             by the file table entries.
  1572. X *
  1573. X * Parameters: type     - 'k' = key, 'r' = record.
  1574. X *             record   - Record name.
  1575. X *             key      - Key name ("" if type is 'r').
  1576. X *
  1577. X * Returns   : Nothing.
  1578. X *
  1579. X */
  1580. Xvoid add_contains(type, record, key)
  1581. Xint type;
  1582. Xchar *record, *key;
  1583. X{
  1584. X    Contains *con = contains + conts++;
  1585. X
  1586. X    strcpy(con->record, record);
  1587. X    strcpy(con->key, key);
  1588. X    con->fileid = files;
  1589. X    con->type   = type;
  1590. X    con->line   = lex_lineno;
  1591. X}
  1592. X
  1593. X
  1594. X/*------------------------------- add_record -------------------------------*\
  1595. X *
  1596. X * Purpose   : This function adds a new entry to the record table. The fileid
  1597. X *             is set to -1 to indicate that the index into file[] is
  1598. X *             unresolved. This file be fixed by fix_file().
  1599. X *
  1600. X * Parameters: name  - Record name.
  1601. X *
  1602. X * Returns   : Nothing.
  1603. X *
  1604. X */
  1605. Xvoid add_record(name)
  1606. Xchar *name;
  1607. X{
  1608. X    Record *rec = record + records++;
  1609. X    int i;
  1610. X
  1611. X    /* Add an entry to the record table */
  1612. X    rec->first_field    = fields;
  1613. X    rec->first_key        = keys;
  1614. X    rec->first_foreign    = -1;
  1615. X    rec->size            = 0;
  1616. X    rec->is_vlr            = 0;
  1617. X    rec->fileid            = -1;
  1618. X    rec->structid        = structdefs;
  1619. X    strcpy(rec->name, name);
  1620. X
  1621. X    /* If this record has a reference file, <ref_file> must be set */
  1622. X    for( i=0; i<conts; i++ )
  1623. X        if( !strcmp(contains[i].record, name) && !strcmp(contains[i].key, "<ref>") )
  1624. X            break;
  1625. X
  1626. X    if( i < conts )
  1627. X        rec->ref_file = contains[i].fileid;
  1628. X    else
  1629. X        rec->ref_file = -1;
  1630. X
  1631. X    /* No variable length fields have occurred in this record so far */
  1632. X    varlen_field_occurred = 0;
  1633. X}
  1634. X
  1635. X
  1636. X/*------------------------------- add_field --------------------------------*\
  1637. X *
  1638. X * Purpose   : Adds a new entry to the field table.
  1639. X *
  1640. X *             If the <size_field> variable is not empty it contains the
  1641. X *             name of the field that determines the size of the field being
  1642. X *             added. Thus, if <size_field> is non-empty, the field being
  1643. X *             added is of variable length.
  1644. X *
  1645. X * Parameters: name  - Field name.
  1646. X *             type  - Field type. Contains FT_... flags.
  1647. X *
  1648. X * Returns   : Nothing.
  1649. X *
  1650. X */
  1651. Xvoid add_field(name, type)
  1652. Xchar *name;
  1653. Xint type;
  1654. X{
  1655. X    sym_member *mem = cur_str->last_member;
  1656. X    Field *fld = field + fields;
  1657. X    int i;
  1658. X
  1659. X    /* If the field is a char string the FT_CHARSTR flag must be set */
  1660. X    if( FT_GETBASIC(type) == FT_CHAR && mem->size > 1 )
  1661. X    {
  1662. X        type &= ~FT_BASIC;            /* Clear the basic flags and set        */
  1663. X        type |=  FT_CHARSTR;        /* the FT_CHARSTR flag instead             */
  1664. X    }
  1665. X
  1666. X    fld->recid     = records-1;        /* Link field to current record            */
  1667. X    fld->type      = type;
  1668. X    fld->nesting   = curnest;
  1669. X    strcpy(fld->name, name);
  1670. X
  1671. X    if( type != FT_STRUCT )
  1672. X    {
  1673. X        fld->size      = mem->size;
  1674. X        fld->offset    = mem->offset;
  1675. X        fld->elemsize  = mem->elemsize;
  1676. X    }
  1677. X
  1678. X    record[records-1].fields++;
  1679. X
  1680. X    /* Check if the current field is of variable length */
  1681. X    if( size_field )
  1682. X    {
  1683. X        if( mem->dims != 1 )
  1684. X            yyerror("variable size fields must be one-dimension arrays");
  1685. X
  1686. X        if( (size_field->type & (FT_SHORT|FT_UNSIGNED)) != (FT_SHORT|FT_UNSIGNED) )
  1687. X            yyerror("size field '%s' must be 'unsigned short'", size_field->name);
  1688. X
  1689. X        /* Store id of size field in keyid (dirty, but saves space) */
  1690. X        fld->keyid = size_field->id;
  1691. X        fld->type |= FT_VARIABLE;
  1692. X        record[records-1].is_vlr = 1;
  1693. X
  1694. X        size_field = NULL;
  1695. X
  1696. X        /* Ensure that no fixed length fields follow */
  1697. X        varlen_field_occurred = 1;
  1698. X    }
  1699. X    else if( varlen_field_occurred && curnest == 0 )
  1700. X        yyerror("fixed length field '%s' follows variable length field", name);
  1701. X
  1702. X    fields++;
  1703. X}
  1704. X
  1705. X
  1706. X
  1707. X/*------------------------------ add_structdef -----------------------------*\
  1708. X *
  1709. X * Purpose   : Add a structure definition.
  1710. X *
  1711. X * Parameters: name            - Structure name.
  1712. X *               is_union        - Is the structure a union.
  1713. X *               control_field- If <is_union> is true this is the id of the
  1714. X *                               control field.
  1715. X *
  1716. X * Returns   : Nothing.
  1717. X *
  1718. X */
  1719. Xvoid add_structdef(name, is_union, control_field)
  1720. Xchar *name;
  1721. Xint is_union, control_field;
  1722. X{
  1723. X    Structdef *str = structdef + structdefs++;
  1724. X
  1725. X    strcpy(str->name, name);
  1726. X    str->first_member = fields;
  1727. X    str->is_union     = is_union;
  1728. X
  1729. X    if( is_union )
  1730. X        str->control_field = control_field;
  1731. X}
  1732. X
  1733. X
  1734. X
  1735. X
  1736. X/*---------------------------- check_foreign_key ---------------------------*\
  1737. X *
  1738. X * Purpose   : Check that a foreign key matches its target (primary key).
  1739. X *
  1740. X * Parameters: name           - Target record name.
  1741. X *             foreign_key    - Pointer to foreign key.
  1742. X *
  1743. X * Returns   : Nothing.
  1744. X *
  1745. X */
  1746. Xvoid check_foreign_key(name, foreign_key)
  1747. Xchar *name;
  1748. XKey *foreign_key;
  1749. X{
  1750. X    Record        *rec;                  /* Ptr to parent record                 */
  1751. X    Key         *primary_key;        /* Ptr to parent's primary key             */
  1752. X    KeyField *primary_fld;            /* Ptr to first field of primary_key       */
  1753. X    KeyField *foreign_fld;            /* Ptr to first field of foreign_key       */
  1754. X    int i;
  1755. X
  1756. X    /* Check if the record has a primary key */
  1757. X    for( rec=record, i=0; i<records; rec++, i++ )
  1758. X        if( !strcmp(rec->name, name) )
  1759. X            break;
  1760. X
  1761. X    if( i == records )
  1762. X    {
  1763. X        yyerror("unknown target record '%s'", name);
  1764. X        return;
  1765. X    }
  1766. X
  1767. X    if( !rec->keys )
  1768. X    {
  1769. X        yyerror("The target '%s' has no primary key", name);
  1770. X        return;
  1771. X    }
  1772. X
  1773. X    primary_key = &key[ rec->first_key ];
  1774. X
  1775. X    if( KT_GETBASIC(primary_key->type) != KT_PRIMARY )
  1776. X    {
  1777. X        yyerror("The target '%s' has no primary key", name);
  1778. X        return;
  1779. X    }
  1780. X
  1781. X    if( primary_key->fields != foreign_key->fields )
  1782. X    {
  1783. X        yyerror("The foreign key '%s' does not match its target", name);
  1784. X        return;
  1785. X    }
  1786. X
  1787. X    primary_fld = &keyfield[ primary_key->first_keyfield ];
  1788. X    foreign_fld = &keyfield[ foreign_key->first_keyfield ];
  1789. X
  1790. X    /* Find the reference file of the parent */
  1791. X    foreign_key->parent  = rec - record;
  1792. X    rec->dependents++;
  1793. X
  1794. X
  1795. X    if( rec->ref_file == -1 )
  1796. X    {
  1797. X        yyerror("The parent table '%s' has no reference file", name);
  1798. X        return;
  1799. X    }
  1800. X
  1801. X    foreign_key->fileid = rec->ref_file;
  1802. X
  1803. X    /* Compare the format of the primary key with that of the foreign key */
  1804. X    for( i=0; i<primary_key->fields; i++, foreign_fld++, primary_fld++ )
  1805. X    {
  1806. X        if( FT_GETSIGNEDBASIC(field[primary_fld->field].type)  !=
  1807. X            FT_GETSIGNEDBASIC(field[foreign_fld->field].type) )
  1808. X            break;
  1809. X
  1810. X        /* Set sort order */
  1811. X        foreign_fld->asc = primary_fld->asc;
  1812. X    }
  1813. X
  1814. X    if( i < primary_key->fields )
  1815. X    {
  1816. X        yyerror("The foreign key '%s' does not match its target", name);
  1817. X        return;
  1818. X    }
  1819. X}
  1820. X
  1821. X
  1822. X/*-------------------------------- fix_file --------------------------------*\
  1823. X *
  1824. X * Purpose   : This function sets the fileid of all the records and the keys.
  1825. X *
  1826. X * Parameters: None.
  1827. X *
  1828. X * Returns   : Nothing.
  1829. X *
  1830. X */
  1831. Xvoid fix_file()
  1832. X{
  1833. X    Contains *con;
  1834. X    Record *rec;
  1835. X    int i, j, n;
  1836. X
  1837. X    for( i=0, con=contains; i<conts; i++, con++ )
  1838. X    {
  1839. X        /* First find the record entry of this contains */
  1840. X        for( j=0, rec=record; j<records; j++, rec++ )
  1841. X            if( !strcmp(rec->name, con->record) )
  1842. X                break;
  1843. X
  1844. X        if( j == records )
  1845. X        {
  1846. X            printf("unknown record '%s' in contains statement\n", con->record);
  1847. X            continue;
  1848. X        }
  1849. X
  1850. X        /* Link the record or the key to a file and vice versa */
  1851. X        switch( con->type )
  1852. X        {
  1853. X            case 'r':
  1854. X                break;
  1855. X
  1856. X            case 'd':
  1857. X                rec->fileid = con->fileid;
  1858. X
  1859. X                if( rec->is_vlr )
  1860. X                    file[i].type = 'v';
  1861. X                break;
  1862. X
  1863. X            case 'k':
  1864. X                for( n=rec->keys, j=rec->first_key; n--; j++ )
  1865. X                    if( !strcmp( key[j].name, con->key) )
  1866. X                        break;
  1867. X
  1868. X                if( KT_GETBASIC(key[j].type) == KT_FOREIGN )
  1869. X                {
  1870. X                    int tmp = lex_lineno;
  1871. X
  1872. X                    lex_lineno = con->line;
  1873. X                    yyerror("a foreign key cannot be contained in a file");
  1874. X                    lex_lineno = tmp;
  1875. X                    break;
  1876. X                }
  1877. X
  1878. X                if( n < 0 && strcmp(con->key, "<ref>") )
  1879. X                {
  1880. X                    printf("unknown key '%s' contained in file '%s'\n",
  1881. X                        con->key, file[con->fileid].name);
  1882. X                    continue;
  1883. X                }
  1884. X
  1885. X                key[j].fileid = con->fileid;
  1886. X                break;
  1887. X        }
  1888. X
  1889. X        con->entry = j;
  1890. X        file[i].id = j;
  1891. X    }
  1892. X
  1893. X    /* Check that each record is contained is contained in a data file and
  1894. X     * each key is contained in a key file
  1895. X     */
  1896. X    for( i=0, rec=record; i<records; i++, rec++ )
  1897. X    {
  1898. X        Key *keyptr;
  1899. X
  1900. X        /* Calculate the size of the preamble */
  1901. X        if( rec->first_foreign != -1 )
  1902. X            rec->preamble = (rec->keys - (rec->first_foreign - rec->first_key)) 
  1903. X                * sizeof(ulong);
  1904. X
  1905. X        if( rec->fileid == -1 )
  1906. X            printf("record '%s' is not contained in a file\n", rec->name);
  1907. X
  1908. X        /* If the key is not a foreign key, it must be contained in a file */
  1909. X        for( keyptr=&key[rec->first_key], j=0; j<rec->keys; j++, keyptr++ )
  1910. X        {
  1911. X            if( keyptr->fileid == -1 && KT_GETBASIC(keyptr->type) != KT_FOREIGN )
  1912. X            {
  1913. X                printf("key '%s.%s' is not contained in a file\n",
  1914. X                    rec->name, keyptr->name);
  1915. X            }
  1916. X         }
  1917. X    }
  1918. X}
  1919. X
  1920. X
  1921. X
  1922. X/*------------------------------- fix_fields -------------------------------*\
  1923. X *
  1924. X * Purpose   : The parser sets the FT_KEY flags on all fields that is a key
  1925. X *             or part of a key. This flag should be removed for foreign keys.
  1926. X *
  1927. X * Parameters: None.
  1928. X *
  1929. X * Returns   : Nothing.
  1930. X *
  1931. X */
  1932. Xvoid fix_fields()
  1933. X{
  1934. X    Field *fld = field;
  1935. X    int n = fields;
  1936. X   
  1937. X    while( n-- )
  1938. X    {
  1939. X        if( fld->type & FT_KEY )
  1940. X        {
  1941. X            if( KT_GETBASIC(key[fld->keyid].type) == KT_FOREIGN )
  1942. X            fld->type &= ~FT_KEY;
  1943. X        }
  1944. X        fld++;
  1945. X    }
  1946. X}
  1947. X
  1948. X
  1949. X/*---------------------------- print_fieldname -----------------------------*\
  1950. X *
  1951. X * Purpose   : Print a field name and its field id in the header file. If the
  1952. X *               field name is defined in more than one record it is prefixed
  1953. X *               with "<record name>_" to prevent name clashes.
  1954. X *
  1955. X * Parameters: file        - File descriptor.
  1956. X *               fieldno    - Field number.
  1957. X *               fieldid    - Field id.
  1958. X *
  1959. X * Returns   : Nothing.
  1960. X *
  1961. X */
  1962. Xvoid print_fieldname(file, fieldno, fieldid)
  1963. XFILE *file;
  1964. Xint fieldno;
  1965. XId fieldid;
  1966. X{
  1967. X    int i;
  1968. X    Field *fld = field + fieldno;
  1969. X    char *name = fld->name;
  1970. X
  1971. X    if( only_keys && !(field[fieldno].type & FT_KEY) )
  1972. X        return;
  1973. X
  1974. X    fprintf(file, "#define ");
  1975. X
  1976. X    for( i=0; i<fields; i++ )
  1977. X    {
  1978. X        if( field[i].nesting == 0 )
  1979. X        {
  1980. X            if( !strcmp(field[i].name, name) && i != fieldno )
  1981. X            {
  1982. X                /* Found a duplicate field name */
  1983. X                fprintf(file, "%s_", record[field[fieldno].recid].name);
  1984. X                break;
  1985. X            }
  1986. X        }
  1987. X    }
  1988. X
  1989. X    fprintf(file, "%s %ldL\n", name, fieldid);
  1990. X
  1991. X    if( !strcmp(name, "USERCLASS") )
  1992. X    {
  1993. X        puts("AAAAAAARRRRRRRRRGGGGGGGG!!!!!!");
  1994. X        printf("%d, %d\n", only_keys, field[fieldno].type & FT_KEY);
  1995. X    }
  1996. X}
  1997. X
  1998. X
  1999. X
  2000. X#ifdef PROTOTYPES
  2001. Xvoid err_quit(char *s, ...)
  2002. X#else
  2003. Xvoid err_quit(s)
  2004. Xchar *s;
  2005. X#endif
  2006. X{
  2007. X   va_list ap;
  2008. X   
  2009. X   va_start(ap, s);
  2010. X   vfprintf(stderr, s, ap);
  2011. X   puts("");
  2012. X   va_end(ap);
  2013. X   exit(1);
  2014. X}
  2015. X
  2016. X
  2017. Xstatic void init_vars()
  2018. X{
  2019. X    int i;
  2020. X
  2021. X    memset(&header,0,sizeof header);
  2022. X       strcpy(header.version, DBD_VERSION);
  2023. X
  2024. X    /* Initialize the sorttable */
  2025. X    for( i=0; i<256; i++ )
  2026. X        header.sorttable[i] = i;
  2027. X
  2028. X    for( i=0; i<'z'-'a'+1; i++ )
  2029. X        header.sorttable['A' + i] = 'a' + i;
  2030. X}
  2031. X
  2032. X
  2033. Xmain(argc, argv)
  2034. Xchar *argv[];
  2035. X{
  2036. X    char *realname;
  2037. X    char *p;
  2038. X    int i;
  2039. X    long n=0, prev;
  2040. X
  2041. X    puts("Typhoon Data Definition Language Processsor version 2.24");
  2042. X
  2043. X    if( argc == 1 )
  2044. X    {
  2045. X        printf(paramhelp, align);
  2046. X        exit(1);
  2047. X    }
  2048. X
  2049. X    /* Allocate tables */
  2050. X    record        = (Record   *)calloc(RECORDS_MAX   , sizeof(Record));
  2051. X    field        = (Field    *)calloc(FIELDS_MAX    , sizeof(Field));
  2052. X    file        = (File     *)calloc(FILES_MAX     , sizeof(File));
  2053. X    key            = (Key      *)calloc(KEYS_MAX      , sizeof(Key));
  2054. X    keyfield    = (KeyField *)calloc(KEYFIELDS_MAX , sizeof(KeyField));
  2055. X    structdef   = (Structdef*)calloc(STRUCTDEFS_MAX, sizeof(Structdef));
  2056. X
  2057. X    if( !(record && field && file && key && keyfield && structdef) )
  2058. X    {
  2059. X        puts("Not enough memory for tables");
  2060. X        exit(1);
  2061. X    }
  2062. X
  2063. X    /* Initialize tables */
  2064. X    for( i=0; i<KEYS_MAX; i++ )
  2065. X        key[i].fileid = -1;
  2066. X
  2067. X    /* Extract the real name of the file */
  2068. X    if( (realname = strrchr(argv[argc-1], DIR_SWITCH)) != NULL )
  2069. X        realname++;
  2070. X    else
  2071. X        realname = argv[argc-1];
  2072. X
  2073. X    /* remove .ddl extension if present */
  2074. X    if( p = strstr(realname, ".ddl") )
  2075. X        *p = 0;
  2076. X
  2077. X    /* generate file names for .ddl-file, .dbd-file and header file */
  2078. X    sprintf(ddlname, "%s.ddl", argv[argc-1]);
  2079. X    sprintf(dbdname, "%s.dbd", realname);
  2080. X    sprintf(hname, "%s.h", realname);
  2081. X
  2082. X    /* process command line options */
  2083. X    for( i=1; i<argc-1; i++ )
  2084. X    {
  2085. X        if( argv[i][0] == '-' || argv[i][0] == '/' )
  2086. X        {
  2087. X            switch( argv[i][1] )
  2088. X            {
  2089. X                case 'h':
  2090. X                    strcpy(hname, argv[i]+2);
  2091. X                    break;
  2092. X                case 'a':
  2093. X                    align = argv[i][2] - '0';
  2094. X                    if( align != 1 && align != 2 && align != 4 )
  2095. X                        err_quit("alignment must be 1, 2 or 4");
  2096. X                    break;
  2097. X                case 'f':
  2098. X                    only_keys = 1;
  2099. X                    break;
  2100. X                default:
  2101. X                    err_quit("unknown command line option");
  2102. X            }
  2103. X        }
  2104. X        else
  2105. X            err_quit("unknown command line option");
  2106. X    }
  2107. X
  2108. X    init_vars();
  2109. X
  2110. X    /* open files */
  2111. X    if( (lex_file=fopen(ddlname, "r")) == NULL )
  2112. X        err_quit("cannot open file '%s'", ddlname);
  2113. X
  2114. X    if( !(dbdfile=open(dbdname, O_RDWR|O_BINARY|O_TRUNC|O_CREAT, CREATMASK)) )
  2115. X        err_quit("cannot create .dbd file '%s'", dbdname);
  2116. X
  2117. X    if( (hfile=fopen(hname, "w")) == NULL )
  2118. X        err_quit("cannot create header file '%s'", hname);
  2119. X
  2120. X    /*---------- initialize h-file ----------*/
  2121. X    fprintf(hfile, "/*---------- headerfile for %s ----------*/\n", ddlname);
  2122. X    fprintf(hfile, "/* alignment is %d */\n\n", align);
  2123. X
  2124. X    /*---------- Initialize tables and parse input ----------*/
  2125. X    record[0].first_field = 0;
  2126. X
  2127. X    if( !yyparse() )
  2128. X    {
  2129. X        fix_file();
  2130. X        fix_fields();
  2131. X
  2132. X        header.files        = files;
  2133. X        header.keys            = keys;
  2134. X        header.keyfields    = keyfields;
  2135. X        header.records        = records;
  2136. X        header.fields        = fields;
  2137. X        header.structdefs    = structdefs;
  2138. X        header.alignment    = align;
  2139. X
  2140. X        /*---------- write dbd-file ----------*/
  2141. X        write(dbdfile, &header,        sizeof header);
  2142. X        write(dbdfile, file,        sizeof(file[0])        * files);
  2143. X        write(dbdfile, key,            sizeof(key[0])        * keys);
  2144. X        write(dbdfile, keyfield,    sizeof(keyfield[0])    * keyfields);
  2145. X        write(dbdfile, record,        sizeof(record[0])    * records);
  2146. X        write(dbdfile, field,        sizeof(field[0])    * fields);
  2147. X        write(dbdfile, structdef,    sizeof(structdef[0])* structdefs);
  2148. X
  2149. X        /*---------- write h-file ----------*/
  2150. X        fprintf(hfile, "/*---------- structures ----------*/\n");
  2151. X        print_structures();
  2152. X
  2153. X        fprintf(hfile, "/*---------- record names ----------*/\n");
  2154. X        for( i=0; i<records; i++ )
  2155. X            fprintf(hfile, "#define %s %ldL\n", strupr(record[i].name), (i+1) * REC_FACTOR);
  2156. X
  2157. X        for( i=0; i<fields; i++ )
  2158. X            strupr(field[i].name);
  2159. X
  2160. X        fprintf(hfile, "\n/*---------- field names ----------*/\n");
  2161. X        for( i=0, prev=-2; i<fields; i++, n++ )
  2162. X        {
  2163. X            if( field[i].nesting == 0 )
  2164. X            {
  2165. X                if( field[i].recid != prev )
  2166. X                    n = (field[i].recid+1) * REC_FACTOR + 1;
  2167. X
  2168. X                print_fieldname(hfile, i, n);
  2169. X                prev = field[i].recid;
  2170. X            }
  2171. X        }
  2172. X
  2173. X        /* Print all keys that are either a multi-field key or foreign key */
  2174. X        fprintf(hfile, "\n/*---------- key constants ----------*/\n");
  2175. X        for( i=0; i<keys; i++ )
  2176. X        {
  2177. X            /* If the key only has one field, and the name of the key is
  2178. X            * the same as the name of the field, then don't print the key name.
  2179. X            */
  2180. X            if( key[i].fields == 1 && 
  2181. X                !istrcmp(key[i].name, field[ keyfield[key[i].first_keyfield].field].name) )
  2182. X                    continue;   
  2183. X
  2184. X            if( KT_GETBASIC(key[i].type) != KT_FOREIGN )
  2185. X                   fprintf(hfile, "#define %s %d\n", strupr(key[i].name), i);
  2186. X        }
  2187. X
  2188. X        fprintf(hfile, "\n/*---------- integer constants ----------*/\n");
  2189. X        for( i=0; i<defines; i++ )
  2190. X            fprintf(hfile, "#define %s %d\n", define[i].name, define[i].value);
  2191. X    }
  2192. X
  2193. X    fclose(hfile);
  2194. X    fclose(lex_file);
  2195. X    close(dbdfile);
  2196. X
  2197. X    if( !errors )
  2198. X        printf("%d records, %d fields\n", records, fields);
  2199. X    else
  2200. X    {
  2201. X        unlink(dbdname);
  2202. X        unlink(hname);
  2203. X    }
  2204. X
  2205. X    free(record);
  2206. X    free(field);
  2207. X    free(file);
  2208. X    free(key);
  2209. X    free(keyfield);
  2210. X    free(structdef);
  2211. X
  2212. X    printf("%d lines, %d errors\n", lex_lineno, errors);
  2213. X
  2214. X    return errors != 0;
  2215. X}
  2216. X
  2217. X/* end-of-file */
  2218. END_OF_FILE
  2219.   if test 21611 -ne `wc -c <'typhoon/src/util/ddlp.c'`; then
  2220.     echo shar: \"'typhoon/src/util/ddlp.c'\" unpacked with wrong size!
  2221.   fi
  2222.   # end of 'typhoon/src/util/ddlp.c'
  2223. fi
  2224. if test -f 'typhoon/src/util/lex.c' -a "${1}" != "-c" ; then 
  2225.   echo shar: Will not clobber existing file \"'typhoon/src/util/lex.c'\"
  2226. else
  2227.   echo shar: Extracting \"'typhoon/src/util/lex.c'\" \(2849 characters\)
  2228.   sed "s/^X//" >'typhoon/src/util/lex.c' <<'END_OF_FILE'
  2229. X/*----------------------------------------------------------------------------
  2230. X * File    : @(#)lex.c       93/11/08         Copyright (c) 1993-94 CT Danmark
  2231. X * Compiler: UNIX C, Turbo C, Microsoft C
  2232. X * OS      : UNIX, OS/2, DOS
  2233. X * Author  : Thomas B. Pedersen
  2234. X *
  2235. X * Description:
  2236. X *   General functions for lexical analysers.
  2237. X *
  2238. X * Revision History
  2239. X * ----------------------------------------
  2240. X * 11-Nov-1993 tbp  Initial version.
  2241. X *
  2242. X *--------------------------------------------------------------------------*/
  2243. X
  2244. X/*-------------------------- Function prototypes ---------------------------*/
  2245. Xstatic int     keywordcmp        PRM( (char *, char *); )
  2246. X
  2247. X
  2248. X
  2249. Xvoid lex_skip_comment()
  2250. X{
  2251. X    int c, start;
  2252. X
  2253. X    start = lex_lineno;
  2254. X    for( ;; )
  2255. X    {
  2256. X        switch( getc(lex_file) )
  2257. X        {
  2258. X            case '*':
  2259. X                if( (c=getc(lex_file)) == '/' )
  2260. X                    return;
  2261. X                else
  2262. X                    ungetc(c, lex_file);
  2263. X                break;
  2264. X            case '\n':
  2265. X                lex_lineno++;
  2266. X                break;
  2267. X            case '/':
  2268. X                if( (c=getc(lex_file)) == '*' )        /* nested comment        */
  2269. X                    lex_skip_comment();
  2270. X                else
  2271. X                    ungetc(c, lex_file);
  2272. X                break;
  2273. X            case EOF:
  2274. X                fprintf(stderr, "unterminated comment starting in line %d\n", start);
  2275. X                exit(1);
  2276. X        }
  2277. X    }
  2278. X}
  2279. X
  2280. X
  2281. Xstatic keywordcmp(ck,ce)
  2282. Xchar *ck;
  2283. Xchar *ce;
  2284. X{
  2285. X    return strcmp(ck, ((LEX_KEYWORD *)ce)->s);
  2286. X}
  2287. X
  2288. X
  2289. X
  2290. Xlex_parse_keyword(char c)
  2291. X{
  2292. X    char *p = yylval.s;
  2293. X    int i;
  2294. X    LEX_KEYWORD *kword;
  2295. X
  2296. X    *p = c;
  2297. X
  2298. X    do
  2299. X        *++p = getc(lex_file);
  2300. X    while( isalnum(*p) || *p=='_' );
  2301. X
  2302. X    ungetc(*p, lex_file);
  2303. X    *p = '\0';
  2304. X
  2305. X    if( p - yylval.s > sizeof(yylval.s)-1 )
  2306. X    {
  2307. X        fprintf(stderr, "line %d: identifier too long, truncated\n", lex_lineno);
  2308. X        yylval.s[sizeof(yylval.s)-1] = '\0';
  2309. X    }
  2310. X
  2311. X    kword = (LEX_KEYWORD *)bsearch(yylval.s,
  2312. X                             lex_keywordtab,
  2313. X                            lex_keywords,
  2314. X                            sizeof(LEX_KEYWORD),
  2315. X                            (LEX_CMPFUNC)keywordcmp);
  2316. X    if( kword == NULL )
  2317. X    {
  2318. X#ifdef T_NUMBER
  2319. X        /* See if identifier is in define table */
  2320. X        for( i=0; i<defines; i++ )
  2321. X            if( !strcmp(yylval.s, define[i].name) )
  2322. X            {
  2323. X                yylval.val = define[i].value;
  2324. X                return T_NUMBER;
  2325. X            }
  2326. X#endif    
  2327. X        return T_IDENT;
  2328. X    }
  2329. X
  2330. X    return kword->token;
  2331. X}
  2332. X
  2333. X#ifdef T_NUMBER
  2334. Xlex_parse_number(char c)
  2335. X{
  2336. X      yylval.val = 0;
  2337. X    do
  2338. X    {
  2339. X        yylval.val = yylval.val * 10 + c - '0';
  2340. X        c = getc(lex_file);
  2341. X    }
  2342. X    while( isdigit(c) );
  2343. X    ungetc(c, lex_file);
  2344. X
  2345. X    return T_NUMBER;
  2346. X}
  2347. X#endif
  2348. X
  2349. X
  2350. X#ifdef T_STRING
  2351. Xlex_parse_string()
  2352. X{
  2353. X    char *p = yylval.s;
  2354. X
  2355. X    while( (*p = getc(lex_file)) != '"' )
  2356. X    {
  2357. X        if( *p == '\n' )
  2358. X            yyerror("newline in string");
  2359. X        else                
  2360. X            p++;
  2361. X    }
  2362. X
  2363. X    *p = '\0';
  2364. X
  2365. X    return T_STRING;
  2366. X}
  2367. X#endif
  2368. X
  2369. X#ifdef T_CHARCONST
  2370. Xlex_parse_charconst()
  2371. X{
  2372. X    /* ' has already been read */
  2373. X    yylval.val = getc(lex_file);
  2374. X    
  2375. X    if( getc(lex_file) != '\'' )
  2376. X        yyerror("unterminated character constant");
  2377. X        
  2378. X    return T_CHARCONST;
  2379. X}
  2380. X#endif
  2381. X
  2382. Xvoid lex_skip_line(void)
  2383. X{
  2384. X    int c;
  2385. X
  2386. X    while( (c = getc(lex_file)) != '\n' && c != EOF )
  2387. X        ;
  2388. X    if( c == EOF )
  2389. X        ungetc(EOF, lex_file);
  2390. X
  2391. X    lex_lineno++;
  2392. X}
  2393. X
  2394. X/* end-of-file */
  2395. X
  2396. END_OF_FILE
  2397.   if test 2849 -ne `wc -c <'typhoon/src/util/lex.c'`; then
  2398.     echo shar: \"'typhoon/src/util/lex.c'\" unpacked with wrong size!
  2399.   fi
  2400.   # end of 'typhoon/src/util/lex.c'
  2401. fi
  2402. echo shar: End of archive 1 \(of 9\).
  2403. cp /dev/null ark1isdone
  2404. MISSING=""
  2405. for I in 1 2 3 4 5 6 7 8 9 ; do
  2406.     if test ! -f ark${I}isdone ; then
  2407.     MISSING="${MISSING} ${I}"
  2408.     fi
  2409. done
  2410. if test "${MISSING}" = "" ; then
  2411.     echo You have unpacked all 9 archives.
  2412.     rm -f ark[1-9]isdone ark[1-9][0-9]isdone
  2413. else
  2414.     echo You still must unpack the following archives:
  2415.     echo "        " ${MISSING}
  2416. fi
  2417. exit 0
  2418. exit 0 # Just in case...
  2419.