home *** CD-ROM | disk | FTP | other *** search
/ Software of the Month Club 1995 December / SOFM_Dec1995.bin / pc / dos / biz / pbase / pbase.cfx < prev    next >
Text File  |  1995-10-31  |  76KB  |  2,792 lines
  1.  
  2.  
  3. #define _ENTRY_
  4.  
  5. #ifdef __TURBOC__
  6.     #include <conio.h>
  7. #else
  8.     #include <graph.h>
  9. #endif
  10. #include <io.h>
  11. #include <stdio.h>
  12. #include <stdlib.h>
  13. #include <string.h>
  14. #include "db_lsc.h"
  15. #include "db_types.h"
  16. #include "db_conio.h"
  17. #include "db_curs.h"
  18. #include "db_date.h"
  19. #include "db_dos.h"
  20. #include "db_file.h"
  21. #include "extfhc.h"
  22. #include "db_funcs.h"
  23. #include "db_heap.h"
  24. #include "db_gvar.h"
  25. #include "db_key.h"
  26. #include "db_pswd.h"
  27. #include "db_sets.h"
  28. #include "db_str.h"
  29. #include "db_win.h"
  30. #include "db_mnu.h"
  31. #include "db_util.h"
  32. #include "db_work.h"
  33. #include "db_tree.h"
  34. #include "db_list.h"
  35. #include "db_man.h"
  36. #include "db_memo.h"
  37.  
  38. unsigned _stklen = 0x4000;  /* Default stack of 16 K */
  39.  
  40. string _tts, _tranString;   /* _tranString for internal generator use only */
  41.  
  42. /*********************************  TYPES  **********************************/
  43.  
  44. typedef struct {
  45.     char exeid[9];
  46.     byte anchor;
  47.    int  deltat;
  48. } defaultrec;
  49.  
  50. typedef enum {Cmd_No_Command,
  51.           Cmd_Next_Record,
  52.           Cmd_Prev_Record,
  53.           Cmd_Find_Record,
  54.           Cmd_Top_Record,
  55.           Cmd_Last_Record,
  56.           Cmd_Edit_Record,
  57.           Cmd_Add_Record,
  58.           Cmd_Copy_Record,
  59.           Cmd_Delete_Record,
  60.           Cmd_Next_File,
  61.           Cmd_Prev_File,
  62.           Cmd_Swap_Menu
  63. }commandtyp;
  64.  
  65. typedef struct {
  66.     byte  f;
  67.     byte  k;
  68.     byte  l;
  69.     uchar t;
  70. } lback;
  71.  
  72. typedef struct savmtyp {
  73.     pathstr savnam;
  74.     byte savno;
  75.     char savprompt[81];
  76.     pathstr savpath;
  77.     struct savmtyp *savprv;
  78. } savmtyp, *savmptr;
  79.  
  80. /*************************  INITIALIZED VARIABLES  **************************/
  81.  
  82. defaultrec def1 = {"öDBPSKL_",0,150};
  83.  
  84. namestr applname = "PBASE";
  85. pathstr localmenu = "PBASE.MEN";
  86.  
  87. #define maxfilno 12
  88. #define maxkeyno 16
  89.  
  90. str12 dbnames[maxfilno+1][maxkeyno+1] =     /* [1.. ,0.. ] */
  91.                     {
  92.                     {"","","","","","","","","","","","","","","","",""},
  93.                     {"PBASE1.DAT","PBASE1.K1","PBASE1.K2","PBASE1.K3","PBASE1.K4","PBASE1.K5","PBASE1.K6",
  94.                     "PBASE1.K7","PBASE1.K8","PBASE1.K9","PBASE1.K10","PBASE1.K11","PBASE1.K12","PBASE1.K13",
  95.                     "PBASE1.K14","",""},
  96.                     {"PBASE2.DAT","PBASE2.K1","","","","","","","","","","","","","","",""},
  97.                     {"PBASE3.DAT","PBASE3.K1","PBASE3.K2","","","","","","","","","","","","","",
  98.                     ""},
  99.                     {"PBASE4.DAT","PBASE4.K1","PBASE4.K2","PBASE4.K3","PBASE4.K4","PBASE4.K5","PBASE4.K6",
  100.                     "PBASE4.K7","PBASE4.K8","PBASE4.K9","PBASE4.K10","PBASE4.K11","PBASE4.K12","PBASE4.K13",
  101.                     "PBASE4.K14","PBASE4.K15","PBASE4.K16"},
  102.                     {"PBASE5.DAT","PBASE5.K1","","","","","","","","","","","","","","",""},
  103.                     {"PBASE6.DAT","PBASE6.K1","","","","","","","","","","","","","","",""},
  104.                     {"UCOUNT1.DAT","UCOUNT1.K1","UCOUNT1.K2","UCOUNT1.K3","UCOUNT1.K4","","","",
  105.                     "","","","","","","","",""},
  106.                     {"UCOMP1.DAT","UCOMP1.K1","UCOMP1.K2","","","","","","","","","","","","","",
  107.                     ""},
  108.                     {"UOCCUP1.DAT","UOCCUP1.K1","UOCCUP1.K2","","","","","","","","","","","","",
  109.                     "",""},
  110.                     {"UZIP1.DAT","UZIP1.K1","","","","","","","","","","","","","","",""},
  111.                     {"GRPACC1.DAT","GRPACC1.K1","GRPACC1.K2","","","","","","","","","","","","",
  112.                     "",""},
  113.                     {"UISSUE1.DAT","UISSUE1.K1","UISSUE1.K2","","","","","","","","","","","","",
  114.                     "",""}};
  115. long maxrec[maxfilno+1] =
  116.                     {0,
  117.                     2147483646,
  118.                     2147483646,
  119.                     2147483646,
  120.                     2147483646,
  121.                     2147483646,
  122.                     2147483646,
  123.                     2147483646,
  124.                     2147483646,
  125.                     2147483646,
  126.                     2147483646,
  127.                     2147483646,
  128.                     2147483646};
  129. byte keymode[maxfilno+1][maxkeyno+1] =       /* [1.. ,1.. ] */
  130.                     {
  131.                     {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
  132.                     {0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0},
  133.                     {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
  134.                     {0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
  135.                     {0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},
  136.                     {0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
  137.                     {0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
  138.                     {0,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0},
  139.                     {0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
  140.                     {0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
  141.                     {0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
  142.                     {0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
  143.                     {0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0}};
  144. byte keylen[maxfilno+1][maxkeyno+1] =        /* [1.. ,1.. ] */
  145.                     {
  146.                     {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
  147.                     {0,4,6,4,5,20,10,2,9,16,8,1,18,18,10,0,0},
  148.                     {0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
  149.                     {0,4,16,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
  150.                     {0,4,30,15,10,3,3,8,1,15,15,8,1,20,20,20,20},
  151.                     {0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
  152.                     {0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
  153.                     {0,30,8,4,20,0,0,0,0,0,0,0,0,0,0,0,0},
  154.                     {0,20,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
  155.                     {0,16,40,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
  156.                     {0,9,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
  157.                     {0,40,10,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
  158.                     {0,4,20,0,0,0,0,0,0,0,0,0,0,0,0,0,0}};
  159. byte keyseg1len[maxfilno+1][maxkeyno+1] =
  160.            {
  161.            {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
  162.            {0,4,6,4,5,20,10,2,9,16,8,1,18,18,10,0,0},
  163.            {0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
  164.            {0,4,16,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
  165.            {0,4,30,15,10,3,3,8,1,15,15,8,1,20,20,20,20},
  166.            {0,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
  167.            {0,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
  168.            {0,30,8,4,20,0,0,0,0,0,0,0,0,0,0,0,0},
  169.            {0,20,4,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
  170.            {0,16,40,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
  171.            {0,9,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
  172.            {0,40,10,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
  173.            {0,4,20,0,0,0,0,0,0,0,0,0,0,0,0,0,0}};
  174. char keyuse[maxfilno+1][maxkeyno+1] =       /* [1.. ,1.. ] */
  175.                     {
  176.                     {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
  177.                     {' ',_Display,_Edit,_Edit,_Edit,_Edit,_Edit,_Edit,_Edit,_Edit,_Edit,_Edit,_Edit,_Edit,_Edit,' ',' '},
  178.                     {' ',_Include,' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
  179.                     {' ',_Include,_Edit,' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
  180.                     {' ',_Include,_Edit,_Edit,_Edit,_Edit,_Edit,_Edit,_Edit,_Edit,_Edit,_Edit,_Edit,_Edit,_Edit,_Edit,_Edit},
  181.                     {' ',_Include,' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
  182.                     {' ',_Edit,' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
  183.                     {' ',_Include,_Include,_Include,_Include,' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
  184.                     {' ',_Include,_Include,' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
  185.                     {' ',_Include,_Include,' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
  186.                     {' ',_Include,' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
  187.                     {' ',_Include,_Include,' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
  188.                     {' ',_Include,_Include,' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '}};
  189. char keytype[maxfilno+1][maxkeyno+1] =      /* [1.. ,1.. ] */
  190.                     {
  191.                     {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
  192.                     {' ',_Num,_Ch,_Ch,_Ch,_Ch,_Ch,_Ch,_Ch,_Ch,_Ch,_Ch,_Ch,_Ch,_Num,' ',' '},
  193.                     {' ',_Num,' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
  194.                     {' ',_Num,_Ch,' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
  195.                     {' ',_Num,_Ch,_Ch,_Ch,_Ch,_Ch,_Ch,_Ch,_Ch,_Ch,_Ch,_Ch,_Ch,_Ch,_Ch,_Ch},
  196.                     {' ',_Num,' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
  197.                     {' ',_Ch,' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
  198.                     {' ',_Ch,_Num,_Num,_Ch,' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
  199.                     {' ',_Ch,_Num,' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
  200.                     {' ',_Ch,_Ch,' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
  201.                     {' ',_Ch,' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
  202.                     {' ',_Ch,_Ch,' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '},
  203.                     {' ',_Num,_Ch,' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '}};
  204. byte keyfld[maxfilno+1][maxkeyno+1] =       /* [1.. ,1.. ] */
  205.                     {
  206.                     {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
  207.                     {0,0,1,3,5,6,2,11,12,26,27,28,10,7,8,0,0},
  208.                     {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
  209.                     {0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
  210.                     {0,0,1,2,3,4,5,7,8,9,10,11,12,13,14,15,16},
  211.                     {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
  212.                     {0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
  213.                     {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
  214.                     {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
  215.                     {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
  216.                     {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
  217.                     {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
  218.                     {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}};
  219. findwtyp findscrpos[maxfilno+1][maxkeyno+1] = /* [1.. ,1.. ] */
  220.                     {
  221.                     {{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0}},
  222.                     {{0,0,0,0},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11}},
  223.                     {{0,0,0,0},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11}},
  224.                     {{0,0,0,0},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11}},
  225.                     {{0,0,0,0},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11}},
  226.                     {{0,0,0,0},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11}},
  227.                     {{0,0,0,0},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11}},
  228.                     {{0,0,0,0},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11}},
  229.                     {{0,0,0,0},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11}},
  230.                     {{0,0,0,0},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11}},
  231.                     {{0,0,0,0},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11}},
  232.                     {{0,0,0,0},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11}},
  233.                     {{0,0,0,0},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11},{20,10,40,11}}};
  234. bool filinuse[maxfilno+1] =
  235.                     {False,True,True,True,True,True,True,False,False,False,False,False,False};
  236. byte winforfile[maxfilno+1] =
  237.                     {0, 1, 2, 3, 4, 5, 6, 0, 0, 0, 0, 0, 0};
  238.  
  239.  
  240. byte tabsize[maxfilno+1] =
  241.                     {0,1,1,20,1,14,1,1,1,1,1,1,1};
  242.  
  243. lback linkback[maxfilno+1] =
  244.                     {{0,0,0,' '},{0,0,0,' '},{1,1,4,_Unique},
  245.                     {1,1,4,_Unique},{1,1,4,_Unique},
  246.                     {1,1,4,_Unique},{0,0,0,' '},
  247.                     {0,0,0,' '},{0,0,0,' '},
  248.                     {0,0,0,' '},{0,0,0,' '},
  249.                     {0,0,0,' '},{0,0,0,' '}};
  250.  
  251. str20 keynamtab[maxfilno+1][maxkeyno+1] =
  252.                     {
  253.                     {"",
  254.                     "",
  255.                     "",
  256.                     "",
  257.                     "",
  258.                     "",
  259.                     "",
  260.                     "",
  261.                     "",
  262.                     "",
  263.                     "",
  264.                     "",
  265.                     "",
  266.                     "",
  267.                     "",
  268.                     "",
  269.                     ""},
  270.                     {"",
  271.                     "ID",
  272.                     "LAST_NAME",
  273.                     "FIRST_NAME",
  274.                     "POSITION",
  275.                     "COMPANY",
  276.                     "HONR",
  277.                     "HOME_STATE",
  278.                     "HOME_ZIP",
  279.                     "STATUS",
  280.                     "LAST_CONTACT",
  281.                     "P_MARKED",
  282.                     "HOME_CITY",
  283.                     "HOME_ADDR1",
  284.                     "HOME_STREET_NUM",
  285.                     "",
  286.                     ""},
  287.                     {"",
  288.                     "ID",
  289.                     "",
  290.                     "",
  291.                     "",
  292.                     "",
  293.                     "",
  294.                     "",
  295.                     "",
  296.                     "",
  297.                     "",
  298.                     "",
  299.                     "",
  300.                     "",
  301.                     "",
  302.                     "",
  303.                     ""},
  304.                     {"",
  305.                     "ID",
  306.                     "GROUPS",
  307.                     "",
  308.                     "",
  309.                     "",
  310.                     "",
  311.                     "",
  312.                     "",
  313.                     "",
  314.                     "",
  315.                     "",
  316.                     "",
  317.                     "",
  318.                     "",
  319.                     "",
  320.                     ""},
  321.                     {"",
  322.                     "ID",
  323.                     "VOTER_COUNTY",
  324.                     "VOTER_CITY",
  325.                     "VOTER_PRECINCT",
  326.                     "VOTER_CONG_DIST",
  327.                     "VOTER_SCH_DIST",
  328.                     "VOTER_BIRTHDATE",
  329.                     "VOTER_SEX",
  330.                     "VOTER_ORIGIN",
  331.                     "VOTER_PARTY",
  332.                     "VOTER_LAST_VOTED",
  333.                     "VOTER_ABS",
  334.                     "VOTER_ISSUE1",
  335.                     "VOTER_ISSUE2",
  336.                     "VOTER_ISSUE3",
  337.                     "VOTER_ISSUE4"},
  338.                     {"",
  339.                     "ID",
  340.                     "",
  341.                     "",
  342.                     "",
  343.                     "",
  344.                     "",
  345.                     "",
  346.                     "",
  347.                     "",
  348.                     "",
  349.                     "",
  350.                     "",
  351.                     "",
  352.                     "",
  353.                     "",
  354.                     ""},
  355.                     {"",
  356.                     "BOGUS_ID",
  357.                     "",
  358.                     "",
  359.                     "",
  360.                     "",
  361.                     "",
  362.                     "",
  363.                     "",
  364.                     "",
  365.                     "",
  366.                     "",
  367.                     "",
  368.                     "",
  369.                     "",
  370.                     "",
  371.                     ""},
  372.                     {"",
  373.                     "VOTER_COUNTY",
  374.                     "COUNTY_SIZE",
  375.                     "ID",
  376.                     "COUNTY_SEAT",
  377.                     "",
  378.                     "",
  379.                     "",
  380.                     "",
  381.                     "",
  382.                     "",
  383.                     "",
  384.                     "",
  385.                     "",
  386.                     "",
  387.                     "",
  388.                     ""},
  389.                     {"",
  390.                     "COMPANY",
  391.                     "ID",
  392.                     "",
  393.                     "",
  394.                     "",
  395.                     "",
  396.                     "",
  397.                     "",
  398.                     "",
  399.                     "",
  400.                     "",
  401.                     "",
  402.                     "",
  403.                     "",
  404.                     "",
  405.                     ""},
  406.                     {"",
  407.                     "POSITION",
  408.                     "POS_DESC",
  409.                     "",
  410.                     "",
  411.                     "",
  412.                     "",
  413.                     "",
  414.                     "",
  415.                     "",
  416.                     "",
  417.                     "",
  418.                     "",
  419.                     "",
  420.                     "",
  421.                     "",
  422.                     ""},
  423.                     {"",
  424.                     "HOME_ZIP",
  425.                     "",
  426.                     "",
  427.                     "",
  428.                     "",
  429.                     "",
  430.                     "",
  431.                     "",
  432.                     "",
  433.                     "",
  434.                     "",
  435.                     "",
  436.                     "",
  437.                     "",
  438.                     "",
  439.                     ""},
  440.                     {"",
  441.                     "GROUPS",
  442.                     "GROUP_DESC",
  443.                     "",
  444.                     "",
  445.                     "",
  446.                     "",
  447.                     "",
  448.                     "",
  449.                     "",
  450.                     "",
  451.                     "",
  452.                     "",
  453.                     "",
  454.                     "",
  455.                     "",
  456.                     ""},
  457.                     {"",
  458.                     "ISSID",
  459.                     "VOTER_ISSUE",
  460.                     "",
  461.                     "",
  462.                     "",
  463.                     "",
  464.                     "",
  465.                     "",
  466.                     "",
  467.                     "",
  468.                     "",
  469.                     "",
  470.                     "",
  471.                     "",
  472.                     "",
  473.                     ""}};
  474.  
  475. bool menudriven = False;
  476.  
  477. /*******************************  VARIABLES  ********************************/
  478.  
  479. bool            switchtab,leaveclear;
  480. recnotyp        tabrecno;
  481. byte            tabidx[maxfilno+1];
  482. byte            tabused[maxfilno+1];
  483.  
  484. bool            pathSwap;
  485. savmptr         smc, svm;
  486. string          tempString;
  487. byte            menuanchor;
  488. bool            quit,fok,cleartop,scrn_active, listAndAdd;
  489. int             keynum,_trace,filno,scrno,dispsno;
  490. long            nextrec;
  491. keystr          key,skey,tempkey;
  492. mnufrec         dm;
  493. winfrec         uw,hw;
  494. winptr          twinp;
  495. int             dbsize[maxfilno+1];
  496. datafile        *datf[maxfilno+1];
  497. indexfile       *idxkey[maxfilno+1][maxkeyno+1];
  498. keystr          tkeytab[maxkeyno+1], savkey[maxkeyno+1];
  499. fldtyp          *keyseg1fld[maxfilno + 1][maxkeyno + 1];
  500.  
  501. string          savelnk[maxfilno+1];
  502.  
  503.  
  504. int             tv;
  505. char            lastrecop;
  506. commandtyp      command;
  507.  
  508. #include "PBASE1.STC"
  509. #include "PBASE2.STC"
  510. #include "PBASE3.STC"
  511. #include "PBASE4.STC"
  512. #include "PBASE5.STC"
  513. #include "PBASE6.STC"
  514. #include "UCOUNTY1.STC"
  515. #include "UCOMP1.STC"
  516. #include "UOCCUP1.STC"
  517. #include "UZIP1.STC"
  518. #include "GRPACCT1.STC"
  519. #include "UISSUE1.STC"
  520.  
  521. bool   custom_key(int scr, int fno, int *fld, uchar *key);
  522. void   getarec(int fno);
  523. void   putarec(int fno);
  524. void   displayrec(int fno, int sno);
  525. void   clear_rec(int fno);
  526. strptr list(strptr sout, int fno, int kno, keystr ks);
  527. strptr listadd(strptr sout, int fno, int kno, keystr aKey);
  528.  
  529. void tandk(int x, int y, winptr w)
  530. {
  531.     string ts;
  532.  
  533.     while (!kpressed()) {
  534.         if (mtime.x) writewxy(get_time(ts,(_timemode)(mtime.m)),0,mtime.x,mtime.y,NULL);
  535.         if (mksta.x) writewxy(keystat(ts,0),0,mksta.x,mksta.y,NULL);
  536.     }
  537. }
  538.  
  539. bool found(int fno, int kno, keystr chkkey)
  540. {
  541.     bool tok;
  542.     bool tfound;
  543.    keystr aKey;                                             /* SN 3.5 */
  544.  
  545.     tok = ok;
  546.     if ((fno != filno) && (keylen[fno][kno] > 0)) {
  547.       strcpy(aKey,chkkey);                                  /* SN 3.5 */
  548.       searchkey(idxkey[fno][kno], &recno[fno], aKey);       /* SN 3.5 */
  549.       ok = (bool)(ok && (strsearch(aKey, chkkey) == aKey)); /* SN 3.5 */
  550.         if (ok) switch (fno) {
  551.             case  1 : getrec(datf[1],recno[1],&PBASE1); break;
  552.             case  2 : getrec(datf[2],recno[2],&PBASE2); break;
  553.             case  3 : getrec(datf[3],recno[3],&PBASE3); break;
  554.             case  4 : getrec(datf[4],recno[4],&PBASE4); break;
  555.             case  5 : getrec(datf[5],recno[5],&PBASE5); break;
  556.             case  6 : getrec(datf[6],recno[6],&PBASE6); break;
  557.             case  7 : getrec(datf[7],recno[7],&UCOUNTY1); break;
  558.             case  8 : getrec(datf[8],recno[8],&UCOMP1); break;
  559.             case  9 : getrec(datf[9],recno[9],&UOCCUP1); break;
  560.             case 10 : getrec(datf[10],recno[10],&UZIP1); break;
  561.             case 11 : getrec(datf[11],recno[11],&GRPACCT1); break;
  562.             case 12 : getrec(datf[12],recno[12],&UISSUE1); break;
  563.         }
  564.         tfound = ok;
  565.     }
  566.     else tfound = False;
  567.  
  568.     ok = tok;
  569.    recavail[fno] = tfound;
  570.     return(tfound);
  571. }
  572.  
  573. #include "PBASE.EDT"
  574.  
  575. void openfiles(void)
  576. {
  577.     int    i, j, fo_i, fo_j;
  578.     string prepend;
  579.     int    tlen;
  580.     string ts;
  581.  
  582.     fo_i = fo_j = 0;
  583.  
  584.     initPBASE1();  dbsize[1] = PBASE1.datasize;
  585.     initPBASE2();  dbsize[2] = PBASE2.datasize;
  586.     initPBASE3();  dbsize[3] = PBASE3.datasize;
  587.     initPBASE4();  dbsize[4] = PBASE4.datasize;
  588.     initPBASE5();  dbsize[5] = PBASE5.datasize;
  589.     initPBASE6();  dbsize[6] = PBASE6.datasize;
  590.     initUCOUNTY1();  dbsize[7] = UCOUNTY1.datasize;
  591.     initUCOMP1();  dbsize[8] = UCOMP1.datasize;
  592.     initUOCCUP1();  dbsize[9] = UOCCUP1.datasize;
  593.     initUZIP1();  dbsize[10] = UZIP1.datasize;
  594.     initGRPACCT1();  dbsize[11] = GRPACCT1.datasize;
  595.     initUISSUE1();  dbsize[12] = UISSUE1.datasize;
  596.  
  597.     strip(prepend,datapath);
  598.     tlen = strlen(prepend);
  599.     if ((tlen > 0) && (prepend[tlen-1] != '\\')) {
  600.         prepend[tlen]   = '\\';
  601.       prepend[tlen+1] = '\0';
  602.     }
  603.  
  604.     fok = True;
  605.     for (i=1;i <= maxfilno; i++)
  606.         if (fok) {
  607.             datf[i] = db_malloc(sizeof(datafile));
  608.             strconcat(ts,prepend,dbnames[i][0],NULL);
  609.             openfile(datf[i],ts,dbsize[i]);
  610.             fok = (bool)(fok && ok);
  611.             if (fok) {
  612.                 fo_i = i;
  613.                 fo_j = 0;
  614.                 for (j=1; j <= maxkeyno; j++)
  615.                     if (fok && (keylen[i][j] > 0)) {
  616.                         idxkey[i][j] = db_malloc(sizeof(indexfile));
  617.                         strconcat(ts,prepend,dbnames[i][j],NULL);
  618.                         openindex(idxkey[i][j],ts,keylen[i][j],keymode[i][j]);
  619.                         fok = (bool)(fok && ok);
  620.                         if (fok) fo_j = j;
  621.                     }
  622.             }
  623.             else if (filinuse[i]) {
  624.                 strconcat(ts,prepend,dbnames[i][0],NULL);
  625.                 makefile(datf[i],ts,dbsize[i]);
  626.                 fok = ok;
  627.                 if (fok) {
  628.  
  629.  
  630.                     fo_i = i;  fo_j = 0;
  631.                     for (j=1; j <= maxkeyno; j++)
  632.                         if (fok && (keylen[i][j] > 0)) {
  633.                             idxkey[i][j] = db_malloc(sizeof(indexfile));
  634.                             strconcat(ts,prepend,dbnames[i][j],NULL);
  635.                             makeindex(idxkey[i][j],ts,keylen[i][j],keymode[i][j]);
  636.                             fok = (bool)(fok && ok);
  637.                             if (fok) {
  638.  
  639.                                 fo_j = j;
  640.  
  641.                             }
  642.                         }
  643.                 }
  644.             }
  645.         }
  646.     if (!fok)
  647.         for (i=1; i <= maxfilno; i++)
  648.             if (i <= fo_i) {
  649.                 closefile(datf[i]);
  650.                 db_free(datf[i]);
  651.                 for (j=1; j <= maxkeyno; j++)
  652.                     if ((i < fo_i) || (j <= fo_j))
  653.                         if (keylen[i][j] > 0) {
  654.                             closeindex(idxkey[i][j]);
  655.                             db_free(idxkey[i][j]);
  656.                         }
  657.             }
  658. }
  659.  
  660. void closefiles(void)
  661. {
  662.     int i,j;
  663.  
  664.     for (i=1; i <= maxfilno; i++) {
  665.         closefile(datf[i]); db_free(datf[i]);
  666.         for (j=1; j <= maxkeyno; j++) if (keylen[i][j] > 0) {
  667.             closeindex(idxkey[i][j]);
  668.      db_free(idxkey[i][j]);
  669.         }
  670.     }
  671. }
  672.  
  673.  
  674. strptr makekey(strptr sout, int fno, int kno)
  675. {
  676.     string ks, ts;
  677.    string tempString;
  678.  
  679.     ks[0] = '\0';
  680.  
  681.     switch (fno) {
  682.         case 1 : switch (kno) {
  683.             case 1 :
  684.                 strcat(ks,PBASE1.ID);
  685.             break;
  686.             case 2 :
  687.                 strcat(ks,strcopy(ts,PBASE1.LAST_NAME,0,6));
  688.             break;
  689.             case 3 :
  690.                 strcat(ks,strcopy(ts,PBASE1.FIRST_NAME,0,4));
  691.             break;
  692.             case 4 :
  693.                 strcat(ks,strcopy(ts,PBASE1.POSITION,0,5));
  694.             break;
  695.             case 5 :
  696.                 strcat(ks,PBASE1.COMPANY);
  697.             break;
  698.             case 6 :
  699.                 strcat(ks,PBASE1.HONR);
  700.             break;
  701.             case 7 :
  702.                 strcat(ks,PBASE1.HOME_STATE);
  703.             break;
  704.             case 8 :
  705.                 strcat(ks,PBASE1.HOME_ZIP);
  706.             break;
  707.             case 9 :
  708.                 strcat(ks,PBASE1.STATUS);
  709.             break;
  710.             case 10 :
  711.                 strcat(ks,PBASE1.LAST_CONTACT);
  712.             break;
  713.             case 11 :
  714.                 strcat(ks,PBASE1.P_MARKED);
  715.             break;
  716.             case 12 :
  717.                 strcat(ks,PBASE1.HOME_CITY);
  718.             break;
  719.             case 13 :
  720.                 strcat(ks,PBASE1.HOME_ADDR1);
  721.             break;
  722.             case 14 :
  723.                 strcat(ks,PBASE1.HOME_STREET_NUM);
  724.             break;
  725.         } break;  /* switch (kno) */
  726.         case 2 : switch (kno) {
  727.             case 1 :
  728.                 strcat(ks,PBASE2.ID);
  729.             break;
  730.         } break;  /* switch (kno) */
  731.         case 3 : switch (kno) {
  732.             case 1 :
  733.                 strcat(ks,PBASE3.ID);
  734.             break;
  735.             case 2 :
  736.                 strcat(ks,PBASE3.GROUPS);
  737.             break;
  738.         } break;  /* switch (kno) */
  739.         case 4 : switch (kno) {
  740.             case 1 :
  741.                 strcat(ks,PBASE4.ID);
  742.             break;
  743.             case 2 :
  744.                 strcat(ks,PBASE4.VOTER_COUNTY);
  745.             break;
  746.             case 3 :
  747.                 strcat(ks,PBASE4.VOTER_CITY);
  748.             break;
  749.             case 4 :
  750.                 strcat(ks,PBASE4.VOTER_PRECINCT);
  751.             break;
  752.             case 5 :
  753.                 strcat(ks,PBASE4.VOTER_CONG_DIST);
  754.             break;
  755.             case 6 :
  756.                 strcat(ks,PBASE4.VOTER_SCH_DIST);
  757.             break;
  758.             case 7 :
  759.                 strcat(ks,PBASE4.VOTER_BIRTHDATE);
  760.             break;
  761.             case 8 :
  762.                 strcat(ks,PBASE4.VOTER_SEX);
  763.             break;
  764.             case 9 :
  765.                 strcat(ks,PBASE4.VOTER_ORIGIN);
  766.             break;
  767.             case 10 :
  768.                 strcat(ks,PBASE4.VOTER_PARTY);
  769.             break;
  770.             case 11 :
  771.                 strcat(ks,PBASE4.VOTER_LAST_VOTED);
  772.             break;
  773.             case 12 :
  774.                 strcat(ks,PBASE4.VOTER_ABS);
  775.             break;
  776.             case 13 :
  777.                 strcat(ks,PBASE4.VOTER_ISSUE1);
  778.             break;
  779.             case 14 :
  780.                 strcat(ks,PBASE4.VOTER_ISSUE2);
  781.             break;
  782.             case 15 :
  783.                 strcat(ks,PBASE4.VOTER_ISSUE3);
  784.             break;
  785.             case 16 :
  786.                 strcat(ks,PBASE4.VOTER_ISSUE4);
  787.             break;
  788.         } break;  /* switch (kno) */
  789.         case 5 : switch (kno) {
  790.             case 1 :
  791.                 strcat(ks,PBASE5.ID);
  792.             break;
  793.         } break;  /* switch (kno) */
  794.         case 6 : switch (kno) {
  795.             case 1 :
  796.                 strcat(ks,PBASE6.BOGUS_ID);
  797.             break;
  798.         } break;  /* switch (kno) */
  799.         case 7 : switch (kno) {
  800.             case 1 :
  801.                 strcat(ks,UCOUNTY1.VOTER_COUNTY);
  802.             break;
  803.             case 2 :
  804.                 strcat(ks,UCOUNTY1.COUNTY_SIZE);
  805.             break;
  806.             case 3 :
  807.                 strcat(ks,UCOUNTY1.ID);
  808.             break;
  809.             case 4 :
  810.                 strcat(ks,UCOUNTY1.COUNTY_SEAT);
  811.             break;
  812.         } break;  /* switch (kno) */
  813.         case 8 : switch (kno) {
  814.             case 1 :
  815.                 strcat(ks,UCOMP1.COMPANY);
  816.             break;
  817.             case 2 :
  818.                 strcat(ks,UCOMP1.ID);
  819.             break;
  820.         } break;  /* switch (kno) */
  821.         case 9 : switch (kno) {
  822.             case 1 :
  823.                 strcat(ks,UOCCUP1.POSITION);
  824.             break;
  825.             case 2 :
  826.                 strcat(ks,UOCCUP1.POS_DESC);
  827.             break;
  828.         } break;  /* switch (kno) */
  829.         case 10 : switch (kno) {
  830.             case 1 :
  831.                 strcat(ks,UZIP1.HOME_ZIP);
  832.             break;
  833.         } break;  /* switch (kno) */
  834.         case 11 : switch (kno) {
  835.             case 1 :
  836.                 strcat(ks,GRPACCT1.GROUPS);
  837.             break;
  838.             case 2 :
  839.                 strcat(ks,strcopy(ts,GRPACCT1.GROUP_DESC,0,10));
  840.             break;
  841.         } break;  /* switch (kno) */
  842.         case 12 : switch (kno) {
  843.             case 1 :
  844.                 strcat(ks,UISSUE1.ISSID);
  845.             break;
  846.             case 2 :
  847.                 strcat(ks,UISSUE1.VOTER_ISSUE);
  848.             break;
  849.         } break;  /* switch (kno) */
  850.     }  /* switch (fno) */
  851.  
  852.     strcpy(sout,ks);
  853.     return(sout);
  854. }
  855.  
  856. strptr keyexpr(strptr sout, int fno, int kno, string kvar)
  857. {
  858.     string ts, ks;
  859.     byte   tlen;
  860.  
  861.     strcpy(ks,kvar);
  862.     tlen = strlen(ks);
  863.  
  864.     switch (fno) {
  865.         case 1 : switch (kno) {
  866.             case 1 :
  867.                 fstr(ts,valu(strcopy(ts,ks,0,4)),4,0);  memmove(&ks[0],ts,4);
  868.             break;
  869.             case 2 :
  870.                 strcpy(ts,upper(_tts,strcopy(ts,ks,0,6)));  memmove(&ks[0],ts,6);
  871.             break;
  872.             case 3 :
  873.                 strcpy(ts,upper(_tts,strcopy(ts,ks,0,4)));  memmove(&ks[0],ts,4);
  874.             break;
  875.             case 7 :
  876.                 strcpy(ts,upper(_tts,strcopy(ts,ks,0,2)));  memmove(&ks[0],ts,2);
  877.             break;
  878.             case 14 :
  879.                 fstr(ts,valu(strcopy(ts,ks,0,10)),10,0);  memmove(&ks[0],ts,10);
  880.             break;
  881.         } break;
  882.         case 2 : switch (kno) {
  883.             case 1 :
  884.                 fstr(ts,valu(strcopy(ts,ks,0,4)),4,0);  memmove(&ks[0],ts,4);
  885.             break;
  886.         } break;
  887.         case 3 : switch (kno) {
  888.             case 1 :
  889.                 fstr(ts,valu(strcopy(ts,ks,0,4)),4,0);  memmove(&ks[0],ts,4);
  890.             break;
  891.         } break;
  892.         case 4 : switch (kno) {
  893.             case 1 :
  894.                 fstr(ts,valu(strcopy(ts,ks,0,4)),4,0);  memmove(&ks[0],ts,4);
  895.             break;
  896.         } break;
  897.         case 5 : switch (kno) {
  898.             case 1 :
  899.                 fstr(ts,valu(strcopy(ts,ks,0,4)),4,0);  memmove(&ks[0],ts,4);
  900.             break;
  901.         } break;
  902.         case 7 : switch (kno) {
  903.             case 2 :
  904.                 fstr(ts,valu(strcopy(ts,ks,0,8)),8,0);  memmove(&ks[0],ts,8);
  905.             break;
  906.             case 3 :
  907.                 fstr(ts,valu(strcopy(ts,ks,0,4)),4,0);  memmove(&ks[0],ts,4);
  908.             break;
  909.         } break;
  910.         case 8 : switch (kno) {
  911.             case 2 :
  912.                 fstr(ts,valu(strcopy(ts,ks,0,4)),4,0);  memmove(&ks[0],ts,4);
  913.             break;
  914.         } break;
  915.         case 12 : switch (kno) {
  916.             case 1 :
  917.                 fstr(ts,valu(strcopy(ts,ks,0,4)),4,0);  memmove(&ks[0],ts,4);
  918.             break;
  919.         } break;
  920.     }
  921.  
  922.     ks[tlen] = Nul;
  923.     strcpy(sout,ks);
  924.     return(sout);
  925. }
  926.  
  927. strptr getakey(strptr sout, int fno, int kno)
  928. {
  929.     keyexpr(sout,fno,kno,makekey(sout,fno,kno));
  930.     return(sout);
  931. }
  932.  
  933. strptr getlink(strptr sout, int fno)
  934. {
  935.     string tkey;
  936.  
  937.     tkey[0] = '\0';
  938.  
  939.     getakey(tkey,linkback[fno].f,linkback[fno].k);
  940.  
  941.     strcopy(sout,tkey,0,linkback[fno].l);
  942.     return(sout);
  943. }
  944.  
  945. void edit_rec(int fld)
  946. {
  947.     edthook = tandk;
  948.  
  949.     PBASE_edt(filno,fld,tabidx[filno] - 1);
  950.  
  951.     edthook = NULL;
  952. }
  953.  
  954. bool status_ok(int fno)
  955. {
  956.     bool tok;
  957.     keystr tk1, tk2;
  958.  
  959.     tok = (bool)(usedrecs(datf[fno]) > 0);
  960.  
  961.     if (linkback[fno].f > 0) {
  962.         getlink(tk1,fno);
  963.         strcopy(tk2,getakey(tk2,fno,1),0,linkback[fno].l);
  964.         tok = (bool)(tok && recavail[linkback[fno].f] && (strcmp(tk1,tk2) == 0));
  965.     }
  966.  
  967.    recavail[fno] = tok;
  968.     return(tok);
  969. }
  970.  
  971. void clearbuf(ptr fb)
  972. {
  973.     word    w;
  974.     string  tpic;
  975.     fldblk *fblk;
  976.     fldtyp *ftp;
  977.  
  978.     fblk = fb;
  979.     for (w=0; w < fblk->numf; w++) {
  980.         ftp = &(*fblk->farr)[w];
  981.         expand(tpic,ftp->pic);
  982.         switch (ftp->typ) {
  983.             case _Ch   : fillstr(ftp->faddr,piclen(tpic,ftp->typ),' '); break;
  984.             case _Num  : fstr(ftp->faddr,0.0,_calc_int(tpic),_calc_frac(tpic)); break;
  985.  
  986.             case _Memo : memset(ftp->faddr,0,4); break;
  987.  
  988.         }
  989.     }
  990. }
  991.  
  992. void clearmemo(ptr fb)
  993. {
  994.     word w;
  995.     fldblk *fblk;
  996.     bool memofile;
  997.     fldtyp *ftp;
  998.  
  999.     fblk = fb;
  1000.     memofile = False;
  1001.     for (w=0; w < fblk->numf; w++) {
  1002.         ftp = &(*fblk->farr)[w];
  1003.         if (ftp->typ == _Memo) {
  1004.             memofile = True;
  1005.             memset(ftp->faddr,0,4);
  1006.         }
  1007.     }
  1008.     if (memofile)   displayrec(filno,scrno);
  1009. }
  1010.  
  1011. void clear_rec(int fno)
  1012. {
  1013.  
  1014.     int i;
  1015.  
  1016.     if (link == Up_N_Down)
  1017.         for (i=1; i <= maxfilno; i++)
  1018.             if (linkback[i].f == (byte)fno) clear_rec(i);
  1019.  
  1020.     if (cleartop || (fno != filno)) {
  1021.         switch (fno) {
  1022.             case  1 : clearbuf(&PBASE1.datasize); break;
  1023.             case  2 : clearbuf(&PBASE2.datasize); break;
  1024.             case  3 : clearbuf(&PBASE3.datasize); break;
  1025.             case  4 : clearbuf(&PBASE4.datasize); break;
  1026.             case  5 : clearbuf(&PBASE5.datasize); break;
  1027.             case  6 : clearbuf(&PBASE6.datasize); break;
  1028.             case  7 : clearbuf(&UCOUNTY1.datasize); break;
  1029.             case  8 : clearbuf(&UCOMP1.datasize); break;
  1030.             case  9 : clearbuf(&UOCCUP1.datasize); break;
  1031.             case 10 : clearbuf(&UZIP1.datasize); break;
  1032.             case 11 : clearbuf(&GRPACCT1.datasize); break;
  1033.             case 12 : clearbuf(&UISSUE1.datasize); break;
  1034.         }
  1035.         displayrec(fno,scrno);
  1036.     }
  1037. }
  1038.  
  1039. /* SN 3.5 - the whole function was created for this version 3.5 */
  1040.  
  1041. long add2CodeFile(int fileNumber)
  1042. {
  1043.    bool    saveOk,
  1044.         aOk;
  1045.    byte    keyNumber, keyNumberCount;
  1046.    keystr  aKey;
  1047.    char   *aBufferPtr,
  1048.            *aFieldPtr,
  1049.         errorMessage[256];
  1050.  
  1051.  
  1052.  
  1053.    saveOk                = ok;
  1054.    *(recno + fileNumber) = 0;
  1055.  
  1056.    switch(fileNumber) {
  1057.  
  1058.       case  7 : {
  1059.     aBufferPtr = (ptr)(&UCOUNTY1);
  1060.     aFieldPtr  = (ptr)(&UCOUNTY1.datasize);
  1061.       }
  1062.       break;
  1063.       case  8 : {
  1064.     aBufferPtr = (ptr)(&UCOMP1);
  1065.     aFieldPtr  = (ptr)(&UCOMP1.datasize);
  1066.       }
  1067.       break;
  1068.       case  9 : {
  1069.     aBufferPtr = (ptr)(&UOCCUP1);
  1070.     aFieldPtr  = (ptr)(&UOCCUP1.datasize);
  1071.       }
  1072.       break;
  1073.       case 10 : {
  1074.     aBufferPtr = (ptr)(&UZIP1);
  1075.     aFieldPtr  = (ptr)(&UZIP1.datasize);
  1076.       }
  1077.       break;
  1078.       case 11 : {
  1079.     aBufferPtr = (ptr)(&GRPACCT1);
  1080.     aFieldPtr  = (ptr)(&GRPACCT1.datasize);
  1081.       }
  1082.       break;
  1083.       case 12 : {
  1084.     aBufferPtr = (ptr)(&UISSUE1);
  1085.     aFieldPtr  = (ptr)(&UISSUE1.datasize);
  1086.       }
  1087.       break;
  1088.  
  1089.       default :
  1090.           aBufferPtr = aFieldPtr = 0;
  1091.           break;
  1092.    }
  1093.  
  1094.    if (aBufferPtr) {
  1095.       clearbuf(aFieldPtr);
  1096.       memmove(aBufferPtr, &recno[fileNumber], 4);
  1097.       do {
  1098.           ok = False;
  1099.           editdefaultdata(fileNumber, aFieldPtr);
  1100.           if (exitcode != QitKey) {
  1101.          addrec(datf[fileNumber], &recno[fileNumber], aBufferPtr);
  1102.          keyNumber = 0;
  1103.          ok        = True;
  1104.          while (ok && (keyNumber < maxkeyno)) {
  1105.                keyNumber++;
  1106.                if (keylen[fileNumber][keyNumber]) {
  1107.                    getakey(aKey, fileNumber, keyNumber);
  1108.                    addkey(idxkey[fileNumber][keyNumber], &recno[fileNumber], aKey);
  1109.                }
  1110.          }
  1111.          if (!ok) {
  1112.             audible(Error);
  1113.             dspmsge(LSC_BaseError, strconcat(errorMessage, LSC_KeyExists, "(", keynamtab[fileNumber][keyNumber], ")"), 4);
  1114.             for (keyNumberCount = 1; keyNumberCount < keyNumber; keyNumberCount++) {
  1115.                if (keylen[fileNumber][keyNumberCount]) {
  1116.                  getakey(aKey, fileNumber, keyNumberCount);
  1117.                  deletekey(idxkey[fileNumber][keyNumberCount], &recno[fileNumber], aKey);
  1118.                }
  1119.             }
  1120.  
  1121.             deleterec(datf[fileNumber], recno[fileNumber]);
  1122.  
  1123.             ok = False;
  1124.          }
  1125.  
  1126.           }
  1127.       }while (!ok && (exitcode != QitKey));
  1128.  
  1129.       if (exitcode == QitKey) {
  1130.           clearbuf(aFieldPtr);
  1131.           recno[fileNumber] = 0;
  1132.       }
  1133.    }
  1134.  
  1135.    ok       = saveOk;
  1136.    exitcode = Nul;
  1137.    return(recno[fileNumber]);
  1138. }
  1139.  
  1140. bool skip(char dirn, int fno)
  1141. {
  1142.     bool fval;
  1143.     string ts;
  1144.  
  1145.     fval = True;
  1146.     if (dirn == _Next) nextkey(idxkey[fno][1],&recno[fno],key);
  1147.     else               prevkey(idxkey[fno][1],&recno[fno],key);
  1148.  
  1149.     if (linkback[fno].f > 0) ok = (bool)(ok && (strsearch(key,getlink(ts,fno)) == key));
  1150.  
  1151.     if (!ok) {
  1152.         fval = False;
  1153.         if (dirn == _Next) prevkey(idxkey[fno][1],&recno[fno],key);
  1154.         else               nextkey(idxkey[fno][1],&recno[fno],key);
  1155.     }
  1156.     return(fval);
  1157. }
  1158.  
  1159. void getarec(int fno)
  1160. {
  1161.     int i;
  1162.     string tkey;
  1163.     string ts;
  1164.  
  1165.     bool tb;
  1166.  
  1167.     tkey[0] = '\0';
  1168.     recavail[fno] = ok;
  1169.     if (ok)
  1170.         switch (fno) {
  1171.             case  1 : getrec(datf[1],recno[1],&PBASE1); break;
  1172.             case  2 : getrec(datf[2],recno[2],&PBASE2); break;
  1173.             case  3 : getrec(datf[3],recno[3],&PBASE3); break;
  1174.             case  4 : getrec(datf[4],recno[4],&PBASE4); break;
  1175.             case  5 : getrec(datf[5],recno[5],&PBASE5); break;
  1176.             case  6 : getrec(datf[6],recno[6],&PBASE6); break;
  1177.             case  7 : getrec(datf[7],recno[7],&UCOUNTY1); break;
  1178.             case  8 : getrec(datf[8],recno[8],&UCOMP1); break;
  1179.             case  9 : getrec(datf[9],recno[9],&UOCCUP1); break;
  1180.             case 10 : getrec(datf[10],recno[10],&UZIP1); break;
  1181.             case 11 : getrec(datf[11],recno[11],&GRPACCT1); break;
  1182.             case 12 : getrec(datf[3],recno[12],&UISSUE1); break;
  1183.         }
  1184.     if ((!recavail[fno]) ||
  1185.             ((link != No_Link) && (_trace != fno) && !status_ok(fno))) {
  1186.         tb          = scrn_active;
  1187.         scrn_active = False;
  1188.         clear_rec(fno);
  1189.         scrn_active = tb;
  1190.         recavail[fno] = False;
  1191.     }
  1192.     if (link != No_Link) {
  1193.         if ((tabsize[fno] > 1) && (fno != filno) && !switchtab) {
  1194.             tabrecno[fno] = recno[fno]; tabidx[fno] = 1;
  1195.         }
  1196.         for (i=1; i <= maxfilno; i++)
  1197.             if (linkback[i].f == (byte)fno)
  1198.                 if (!status_ok(i)) {
  1199.                     getlink(tkey,i);
  1200.                     searchkey(idxkey[i][1],&recno[i],tkey);
  1201.                     ok = (bool)(ok && (strsearch(tkey,getlink(ts,i)) == tkey));
  1202.                     getarec(i); /* recursion */
  1203.                 }
  1204.     }
  1205.     if (fno == filno) ok = recavail[fno];
  1206. }
  1207.  
  1208. void putarec(int fno)
  1209. {
  1210.    if (recavail[fno]) {
  1211.        switch (fno) {
  1212.                case  1 : putrec(datf[1],recno[1],&PBASE1); break;
  1213.                case  2 : putrec(datf[2],recno[2],&PBASE2); break;
  1214.                case  3 : putrec(datf[3],recno[3],&PBASE3); break;
  1215.                case  4 : putrec(datf[4],recno[4],&PBASE4); break;
  1216.                case  5 : putrec(datf[5],recno[5],&PBASE5); break;
  1217.                case  6 : putrec(datf[6],recno[6],&PBASE6); break;
  1218.                case  7 : putrec(datf[7],recno[7],&UCOUNTY1); break;
  1219.                case  8 : putrec(datf[8],recno[8],&UCOMP1); break;
  1220.                case  9 : putrec(datf[9],recno[9],&UOCCUP1); break;
  1221.                case 10 : putrec(datf[10],recno[10],&UZIP1); break;
  1222.                case 11 : putrec(datf[11],recno[11],&GRPACCT1); break;
  1223.                case 12 : putrec(datf[12],recno[12],&UISSUE1); break;
  1224.        }
  1225.    }
  1226. }
  1227.  
  1228. void top_record(void)
  1229. {
  1230.     if (!linkback[filno].f) {
  1231.         clearkey(idxkey[filno][1]);
  1232.         nextkey(idxkey[filno][1],&recno[filno],key);
  1233.     }
  1234.     else {
  1235.         getlink(tempkey,filno);
  1236.         strcpy(skey,tempkey);
  1237.         searchkey(idxkey[filno][1],&recno[filno],tempkey);
  1238.         ok = (bool)(ok && (strsearch(tempkey,skey) == tempkey));
  1239.     }
  1240.     if (ok)
  1241.         getarec(filno);
  1242.     else {
  1243.         clear_rec(filno);
  1244.         recavail[filno] = False;
  1245.     }
  1246.     if (tabsize[filno] > 1) {
  1247.         tabrecno[filno] = recno[filno]; tabidx[filno] = 1;
  1248.     }
  1249.     displayrec(filno,scrno);
  1250. }
  1251.  
  1252. void findmulti(int fno, long *recn, strptr key2find)
  1253. {
  1254.     long saverecn;
  1255.     keystr savk2f;
  1256.  
  1257.     saverecn = *recn;
  1258.     strcpy(savk2f,key2find);
  1259.     searchkey(idxkey[fno][1],recn,key2find);
  1260.     ok = (bool)(ok && (strsearch(key2find,savk2f) == key2find));
  1261.     while ((*recn != saverecn) && ok) {
  1262.         nextkey(idxkey[fno][1],recn,key2find);
  1263.         ok = (bool)(ok && (strsearch(key2find,savk2f) == key2find));
  1264.     }
  1265. }
  1266.  
  1267. void gettabrec(byte fno)
  1268. {
  1269.     switch (fno) {
  1270.         case  3 : getrec(datf[3],tabrecno[3],&PBASE3); break;
  1271.         case  5 : getrec(datf[5],tabrecno[5],&PBASE5); break;
  1272.     }
  1273. }
  1274.  
  1275. void disptab(byte fno)
  1276. {
  1277.     byte incy;
  1278.     long srec;
  1279.     bool rec_ok;
  1280.     string tk;
  1281.  
  1282.     if (tabsize[fno] < 2) {
  1283.         incy = tabidx[fno]-1;
  1284.         PBASE_dsp(fno,dispsno,incy);
  1285.     }
  1286.     else {
  1287.         incy = 0;
  1288.         rec_ok = recavail[fno];
  1289.         if (rec_ok) {
  1290.             srec = recno[fno];
  1291.             if (!leaveclear || (linkback[fno].f != (byte)filno)) gettabrec(fno);
  1292.             getakey(tk,fno,1);
  1293.             findmulti(fno,&tabrecno[fno],tk);
  1294.             if (!ok) {
  1295.                 scrn_active = False;
  1296.                 clear_rec(fno);
  1297.                 scrn_active = True;
  1298.                 rec_ok = False;
  1299.             }
  1300.             if ((tabidx[fno] > tabsize[fno]) && (skip(_Next,fno))) {
  1301.                 tabidx[fno] = tabsize[fno];
  1302.                 tabrecno[fno] = recno[fno];
  1303.                 gettabrec(fno);
  1304.             }
  1305.             if ((tabidx[fno] == 0) && (skip(_Prev,fno))) {
  1306.                 tabidx[fno] = 1;
  1307.                 tabrecno[fno] = recno[fno];
  1308.                 gettabrec(fno);
  1309.             }
  1310.         }
  1311.         (uw.wa[dispsno])->disp = False;
  1312.         tabused[fno] = 0;
  1313.         do {
  1314.             PBASE_dsp(fno,dispsno,incy);
  1315.             incy++;
  1316.             if (rec_ok && (incy < tabsize[fno])) {
  1317.                 tabused[fno] = incy;
  1318.                 link = No_Link;
  1319.                 if ((!leaveclear || (linkback[fno].f != (byte)filno)) && recavail[fno]) {
  1320.                     if (skip(_Next,fno)) getarec(fno);
  1321.                     else {
  1322.                         scrn_active = False;
  1323.                         clear_rec(fno);
  1324.                         scrn_active = True;
  1325.                         rec_ok = False;
  1326.                     }
  1327.                 }
  1328.                 else {
  1329.                     scrn_active = False;
  1330.                     clear_rec(fno);
  1331.                     scrn_active = True;
  1332.                     rec_ok = False;
  1333.                 }
  1334.                 link = Up_N_Down;
  1335.             }
  1336.         } while (incy < tabsize[fno]);
  1337.         (uw.wa[dispsno])->disp = True; dispwindow(uw.wa[dispsno]);
  1338.         if (recavail[fno]) {
  1339.             recno[fno] = srec;
  1340.             if (!leaveclear || (linkback[fno].f != (byte)filno)) getarec(fno);
  1341.             else {
  1342.                 link = No_Link;
  1343.                 getarec(fno);
  1344.                 link = Up_N_Down;
  1345.             }
  1346.             getakey(tk,fno,1);
  1347.             findmulti(fno,&srec,tk);
  1348.         }
  1349.     }
  1350. }
  1351.  
  1352. void dispfields(int fno, int sno)
  1353. {
  1354.     dispsno = sno;
  1355.     switch (sno) {
  1356.         case 1 : 
  1357.             PBASE_dsp(1,sno,0);
  1358.         break;
  1359.         case 2 : 
  1360.             PBASE_dsp(2,sno,0);
  1361.         break;
  1362.         case 3 : 
  1363.             if (fno <= 3) disptab( 3);
  1364.         break;
  1365.         case 4 : 
  1366.             PBASE_dsp(4,sno,0);
  1367.         break;
  1368.         case 5 : 
  1369.             if (fno <= 5) disptab( 5);
  1370.         break;
  1371.         case 6 : 
  1372.             PBASE_dsp(6,sno,0);
  1373.         break;
  1374.     }
  1375. }
  1376.  
  1377. void displayrec(int fno, int sno)
  1378. {
  1379.     if (scrn_active) dispfields(fno,sno);
  1380. }
  1381.  
  1382. void switch_file(char mode)
  1383. {
  1384.     int fno,incr;
  1385.  
  1386.     scrn_active = True;
  1387.     if (mode == '+')      incr = 1;
  1388.    else if (mode == '-') incr = -1;
  1389.     else             incr = 0;
  1390.     fno = filno;
  1391.     do {
  1392.         filno += incr;
  1393.         if ((filno < 1) || (filno > maxfilno)) {
  1394.             incr = -incr; filno += incr;
  1395.             audible(Warning);
  1396.         }
  1397.     } while (!filinuse[filno] && (filno != fno));
  1398.  
  1399.     if (scrno < winforfile[filno]) displayrec(filno,scrno);
  1400.     while (scrno > winforfile[filno]) {
  1401.         hidewin(T_OFF,uw.wa[scrno]);
  1402.       scrno--;
  1403.     }
  1404.  
  1405.     while (scrno < winforfile[filno]) {
  1406.         scrno++;
  1407.       hidewin(T_ON,uw.wa[scrno]);
  1408.     }
  1409.  
  1410.     if (!status_ok(filno)) top_record(); else ok = True;
  1411.     switchtab = True;
  1412.     displayrec(filno,scrno);
  1413.     switchtab = False;
  1414. }
  1415.  
  1416. void traceback(int fno)
  1417. {
  1418.     string tk,sk;
  1419.     int f,k;
  1420.  
  1421.     f = linkback[fno].f;
  1422.     k = linkback[fno].k;
  1423.     _trace = f;
  1424.     if (recavail[fno]) {
  1425.         strcopy(tk,getakey(tk,fno,1),0,linkback[fno].l); strcpy(sk,tk);
  1426.         searchkey(idxkey[f][k],&recno[f],tk);
  1427.         ok = (bool)(ok && (strsearch(tk,sk) == tk));
  1428.         if (ok) {
  1429.             getarec(f);
  1430.             ok = status_ok(fno);
  1431.             if (tabsize[f] > 1) {
  1432.                 tabrecno[f] = recno[f]; tabidx[f] = 1;
  1433.             }
  1434.             if (ok && (k > 1)) {
  1435.                 getakey(tk,f,1);
  1436.                 findmulti(f,&recno[f],tk);
  1437.             }
  1438.         }
  1439.     }
  1440.     else ok = True;
  1441.  
  1442.     if (!ok) {
  1443.         audible(Error);
  1444.         dspmsge(LSC_BaseError,LSC_TracebackFailed,4.0);
  1445.         filno = 1;
  1446.         switch_file(' ');
  1447.         top_record();
  1448.     }
  1449.     else
  1450.         if (linkback[f].f > 0)
  1451.             traceback(f);
  1452.     _trace = 0;
  1453.     ok = status_ok(fno);
  1454. }
  1455.  
  1456. void align_tab(int fno)
  1457. {
  1458.     byte count;
  1459.     long srno;
  1460.     string ts;
  1461.  
  1462.     getakey(tempkey,fno,1);
  1463.     strcpy(skey,tempkey);
  1464.     srno = recno[fno];
  1465.     count = 1;
  1466.     do {
  1467.         prevkey(idxkey[fno][1],&recno[fno],tempkey);
  1468.         ok = (bool)(ok && (strsearch(tempkey,getlink(ts,fno)) == tempkey));
  1469.         if (ok) count++;
  1470.     } while ((count <= tabsize[fno]) && ok);
  1471.  
  1472.     if (!ok) nextkey(idxkey[fno][1],&recno[fno],tempkey);
  1473.     tabidx[fno]   = count;
  1474.    tabrecno[fno] = recno[fno];
  1475.     recno[fno]    = srno;
  1476.     findmulti(filno,&recno[fno],skey);
  1477. }
  1478.  
  1479. void displayall(void)
  1480. {
  1481.     int i;
  1482.  
  1483.     for (i=1; i <= filno; i++) (uw.wa[winforfile[i]])->disp = False;
  1484.     link = No_Link;
  1485.     for (i=1; i <= scrno; i++) displayrec(0,i);
  1486.     link = Up_N_Down;
  1487.     for (i=1; i <= filno; i++) hidewin(T_ON,uw.wa[winforfile[i]]);
  1488. }
  1489.  
  1490. void align_rec(long oldr)
  1491. {
  1492.     int i;
  1493.  
  1494.     ok           = True;
  1495.     _trace       = filno;
  1496.     recno[filno] = oldr;
  1497.     scrn_active  = False;
  1498.     if (oldr > 0) getarec(filno);
  1499.    else          recavail[filno] = False;
  1500.  
  1501.     if (recavail[filno]) {
  1502.         getakey(skey,filno,1);
  1503.         findmulti(filno,&oldr,skey);
  1504.         if (!ok) {
  1505.             audible(Error);
  1506.             dspmsge(LSC_BaseError,LSC_Mismatch,4.0);
  1507.             top_record();
  1508.         }
  1509.     }
  1510.     else top_record();
  1511.     if (linkback[filno].f > 0) traceback(filno);
  1512.     if (tabsize[filno] > 1) align_tab(filno);
  1513.     _trace = 0;
  1514.     scrn_active = True;
  1515.     displayall();
  1516. }
  1517.  
  1518. void next_record(char dirn)
  1519. {
  1520.     long savr;
  1521.  
  1522.     if (status_ok(filno)) {
  1523.         savr = recno[filno];
  1524.         if (skip(dirn,filno)) {
  1525.             getarec(filno);
  1526.             if (tabsize[filno] > 1)
  1527.                 if (dirn == _Next) tabidx[filno]++; else tabidx[filno]--;
  1528.             if (!recavail[filno]) align_rec(savr);
  1529.             else                  displayrec(filno,scrno);
  1530.         }
  1531.         else audible(Warning);
  1532.         if (!ok) top_record();
  1533.     }
  1534.     else audible(Warning);
  1535. }
  1536.  
  1537. void next_tab_page(char dirn)
  1538. {
  1539.     byte count;
  1540.  
  1541.     if ((tabsize[filno] > 1) && status_ok(filno)) {
  1542.         count = 1;
  1543.         while ((count < tabsize[filno]) && skip(dirn,filno)) count++;
  1544.         getarec(filno);
  1545.         align_tab(filno);
  1546.         displayrec(filno,scrno);
  1547.     }
  1548. }
  1549.  
  1550. void last_record(void)
  1551. {
  1552.     long savr;
  1553.  
  1554.     if (status_ok(filno)) {
  1555.         savr = recno[filno];
  1556.         if (linkback[filno].f == 0) {
  1557.             clearkey(idxkey[filno][1]);
  1558.             prevkey(idxkey[filno][1],&recno[filno],key);
  1559.         }
  1560.         else {
  1561.             getlink(tempkey,filno);
  1562.             strcpy(skey,tempkey);
  1563.             searchkey(idxkey[filno][1],&recno[filno],tempkey);
  1564.             ok = (bool)(ok && (strsearch(tempkey,skey) == tempkey));
  1565.             if (ok) {
  1566.                 while (ok) {
  1567.                     nextkey(idxkey[filno][1],&recno[filno],tempkey);
  1568.                     ok = (bool)(ok && (strsearch(tempkey,skey) == tempkey));
  1569.                 }
  1570.                 prevkey(idxkey[filno][1],&recno[filno],tempkey);
  1571.             }
  1572.         }
  1573.         if (!ok) top_record();
  1574.         else {
  1575.             getarec(filno);
  1576.             if (tabsize[filno] > 1) align_tab(filno);
  1577.             if (!recavail[filno]) align_rec(savr);
  1578.             else                  displayrec(filno,scrno);
  1579.         }
  1580.     }
  1581.     else audible(Warning);
  1582. }
  1583.  
  1584. strptr horizrec(strptr sout, uchar mode, byte fno, byte kno)
  1585. {
  1586.     string ts;
  1587.  
  1588.    strcpy(ts, "~");
  1589.     if (mode == _Header) {
  1590.         switch (fno) {
  1591.             case  1: 
  1592.             break;
  1593.             case  2: 
  1594.             break;
  1595.             case  3: 
  1596.             break;
  1597.             case  4: 
  1598.             break;
  1599.             case  5: 
  1600.             break;
  1601.             case  6: 
  1602.             break;
  1603.             case  7: 
  1604.             break;
  1605.             case  8: 
  1606.             break;
  1607.             case  9: 
  1608.             break;
  1609.             case 10: 
  1610.             break;
  1611.             case 11: 
  1612.             break;
  1613.             case 12: 
  1614.             break;
  1615.         }
  1616.         if (ts[0] == '~') strconcat(ts,LSC_DispSequence," ",keynamtab[fno][kno],NULL);
  1617.     }
  1618.     else {
  1619.         switch (fno) {
  1620.             case  1: 
  1621.                 if (ts[0] == '~') defaultdata(ts,&PBASE1.datasize);
  1622.             break;
  1623.             case  2: 
  1624.                 if (ts[0] == '~') defaultdata(ts,&PBASE2.datasize);
  1625.             break;
  1626.             case  3: 
  1627.                 if (ts[0] == '~') defaultdata(ts,&PBASE3.datasize);
  1628.             break;
  1629.             case  4: 
  1630.                 if (ts[0] == '~') defaultdata(ts,&PBASE4.datasize);
  1631.             break;
  1632.             case  5: 
  1633.                 if (ts[0] == '~') defaultdata(ts,&PBASE5.datasize);
  1634.             break;
  1635.             case  6: 
  1636.                 if (ts[0] == '~') defaultdata(ts,&PBASE6.datasize);
  1637.             break;
  1638.             case  7: 
  1639.                 if (ts[0] == '~') defaultdata(ts,&UCOUNTY1.datasize);
  1640.             break;
  1641.             case  8: 
  1642.                 if (ts[0] == '~') defaultdata(ts,&UCOMP1.datasize);
  1643.             break;
  1644.             case  9: 
  1645.                 if (ts[0] == '~') defaultdata(ts,&UOCCUP1.datasize);
  1646.             break;
  1647.             case 10: 
  1648.                 if (ts[0] == '~') defaultdata(ts,&UZIP1.datasize);
  1649.             break;
  1650.             case 11: 
  1651.                 if (ts[0] == '~') defaultdata(ts,&GRPACCT1.datasize);
  1652.             break;
  1653.             case 12: 
  1654.                 if (ts[0] == '~') defaultdata(ts,&UISSUE1.datasize);
  1655.             break;
  1656.         }
  1657.     }
  1658.     pad(sout,ts,255,Right);
  1659.     return(sout);
  1660. }
  1661.  
  1662. void display_the_find(long trecno, long oldnum)
  1663. {
  1664.     align_rec(trecno ? trecno : oldnum);
  1665. }
  1666.  
  1667. void find_record(void)
  1668. {
  1669.     int    tpos,i, dsplen;
  1670.     bool   tb,abort;
  1671.     char   temp_pic[DB_Klen+1];
  1672.     long   trecno,oldnum;
  1673.     char   chosen[21];
  1674.     string numstr, choosestr;
  1675.     string ts;
  1676.    string aPictureField;
  1677.    uchar  aFieldType;
  1678.  
  1679.    exitcode = ' ';
  1680.     if ((usedrecs(datf[filno]) > 0) && (filinuse[filno])) {
  1681.         oldnum = (recavail[filno]) ? recno[filno] : 0;
  1682.         if ((keynum > maxkeyno) || (keylen[filno][keynum] == 0)) keynum = 1;
  1683.         abort = False;
  1684.       dsplen       = 0;                                                                   /* SN 3.5 */
  1685.       for (i = 1; i <= maxkeyno; ++i) dsplen += strlen(keynamtab[filno][i]);              /* SN 3.5 */
  1686.       /* dsplen = (dsplen > 255) ? 14 : 20;   */                                               /* SN 3.5 */
  1687.        dsplen = 12;
  1688.        i            = keynum;
  1689.       choosestr[0] = '\0';
  1690.       numstr[0]    = '\0';
  1691.         do {
  1692.            if ((keylen[filno][i] != 0) && (keynamtab[filno][i][0] != '\0')) {
  1693.                 strconcat(numstr,numstr,istr(ts,(long)i,2),"|",NULL);
  1694.                 strconcat(choosestr,choosestr,pad(ts,keynamtab[filno][i],dsplen,Right),"|",NULL);  /* SN 3.5 */
  1695.             }
  1696.             i++;
  1697.             if (i > maxkeyno) i = 1;
  1698.         } while (i != keynum);
  1699.         gotoxy((scrwid-20)/2,scrhgt-maxkeyno-4);
  1700.         tb        = permitesc;
  1701.       permitesc = True;
  1702.  
  1703.       i         = strlen(numstr);
  1704.       if (!i) exitcode = QitKey;
  1705.       else    if (i == 3) strcopy(chosen, numstr, 0, 2);
  1706.           else        choose(key, numstr, choosestr, chosen);
  1707.  
  1708.         permitesc = tb;
  1709.         if (chosen[0] != 0) keynum = (int) ival(chosen);
  1710.         abort = (bool)(exitcode == QitKey);
  1711.         if (!abort) {
  1712.             strconcat(ts," ",LSC_EnterTheKey," : ",trim(ts,keynamtab[filno][keynum])," ",NULL);
  1713.             if (openwin(0,2,scrhgt-2,78,1,31,31,8,"─┐│┘─└│┌",TopCnt,ts)) {
  1714.                 twinp = curwin;
  1715.         twinp->disp = True;
  1716.         dispwindow(twinp);
  1717.                 fillstr(key,DB_Klen,' ');
  1718.                 strchcat(strip(temp_pic,istr(temp_pic,(long)DB_Klen,3)),Pic_X);
  1719.                 tpos = (78-(strlen(LSC_EnterOrEsc)+DB_Klen+2))/2;
  1720.                 writewxy(LSC_EnterOrEsc,31,(byte)tpos,1,twinp);
  1721.                 tpos = tpos + strlen(LSC_EnterOrEsc) + 1;
  1722.  
  1723. /* Written by SN 3.5 - Start */
  1724.  
  1725.         strcpy(aPictureField, keyseg1fld[filno][keynum]->pic);
  1726.         aFieldType = keyseg1fld[filno][keynum]->typ;
  1727.  
  1728.         expand(choosestr, aPictureField);
  1729.         switch (aFieldType) {
  1730.            case _Ch   : {
  1731.                    fillstr(choosestr, piclen(choosestr, aFieldType), ' ');
  1732.                    break;
  1733.                 }
  1734.            case _Num  : {
  1735.                    fstr(choosestr, 0.0, _calc_int(choosestr), _calc_frac(choosestr));
  1736.                    break;
  1737.                 }
  1738.         }
  1739.  
  1740.                 dsp_fld(tpos,1,choosestr, aFieldType, aPictureField, 1, 40, 0, twinp);
  1741.                 edt_fld(tpos,1,choosestr, aFieldType, aPictureField, 40, 0, twinp);
  1742.                 *skey = '\0';
  1743.         strcopy(key,choosestr,0,keyseg1len[filno][keynum]);
  1744.         if (aFieldType == _Num && (valu(key) == 0)) *key = '\0';
  1745.         pic_fld(choosestr, choosestr, aFieldType, 0, 0, aPictureField);
  1746.  
  1747. /* Written by SN 3.5 - Finish */
  1748.  
  1749.                 closewin(&twinp);
  1750.                 if (exitcode == Esc) goto Find_Exit;
  1751.                 if (!empty(key)) {
  1752.                     trim(key,keyexpr(key,filno,keynum,key));
  1753.            strcpy(skey,key);
  1754.                 }
  1755.                 searchkey(idxkey[filno][keynum],&recno[filno],key);
  1756.                 if ((!ok) || (strsearch(key,skey) != key)) {
  1757.                     audible(Warning);
  1758.            strconcat(ts, LSC_NoExactMatch, choosestr, NULL);
  1759.            strcopy (ts, ts, 0, 76);
  1760.            dspmsge("",ts,4.0);
  1761.                 }
  1762.                 tempkey[0] = '\0';
  1763.                 if (ok) {
  1764.                     nextkey(idxkey[filno][keynum],&recno[filno],key);
  1765.                     if (ok) strcpy(tempkey,key);
  1766.                     prevkey(idxkey[filno][keynum],&recno[filno],key);
  1767.                 }
  1768.                 else prevkey(idxkey[filno][keynum],&recno[filno],key);
  1769.                 if (!skey[0] || (strsearch(key,skey) != key) || (strsearch(tempkey,skey) == tempkey)) {
  1770.                     trecno = list_n_choose((byte)filno,(byte)keynum,key,idxkey[filno][keynum],findscrpos[filno][keynum]);
  1771.                     display_the_find(trecno,oldnum);
  1772.                 }
  1773.                 else align_rec(recno[filno]);
  1774.             }
  1775.         }
  1776.     }
  1777.     else audible(Warning);
  1778. Find_Exit : ;
  1779.    exitcode = ' ';
  1780. }
  1781.  
  1782. strptr list(strptr sout, int fno, int kno, keystr ks)
  1783. {
  1784.     long trecno;
  1785.     keystr lastks;
  1786.     bool tok;
  1787.     byte stabsiz;
  1788.  
  1789.     if (!listAndAdd) listing = True;
  1790.     if ((fno != filno) && (keylen[fno][kno] > 0)) {
  1791.         tok         = ok;
  1792.         scrn_active = False;
  1793.         strcpy(lastks,ks);
  1794.         clearkey(idxkey[fno][kno]);
  1795.         nextkey(idxkey[fno][kno],&recno[fno],lastks);
  1796.         lastks[0] = '\0';
  1797.       trecno = -1;
  1798.         if (ok) trecno = list_n_choose((byte)fno,(byte)kno,lastks,idxkey[fno][kno],findscrpos[fno][kno]);
  1799.       if (trecno == 0 && listAndAdd) trecno = add2CodeFile(fno);
  1800.         if (trecno > 0) {
  1801.             ok         = True;
  1802.             recno[fno] = trecno;
  1803.             link       = No_Link;
  1804.             getarec(fno);
  1805.             link       = Up_N_Down;
  1806.             strcopy(ks,makekey(lastks,fno,kno),0,strlen(ks));
  1807.         }
  1808.         else clear_rec(fno);
  1809.  
  1810.         ok          = tok;
  1811.         scrn_active = True;
  1812.         stabsiz = tabsize[filno];
  1813.         tabsize[filno] = 1;
  1814.         displayrec(filno,scrno);
  1815.         tabsize[filno] = stabsiz;
  1816.     }
  1817.     fldnum--;
  1818.     listing = False;
  1819.     sout[0] = '\0';
  1820.     return(sout);
  1821. }
  1822.  
  1823. /* SN 3.5 - The complete Function was created for 3.5 */
  1824.  
  1825. strptr listadd(strptr sout, int fno, int kno, keystr aKey)
  1826. {
  1827.    listAndAdd = True;
  1828.    list(sout, fno, kno, aKey);
  1829.    listAndAdd = False;
  1830.    return(sout);
  1831. }
  1832.  
  1833.  
  1834. void setlinkage(int fno)
  1835. {
  1836.     switch (fno) {
  1837.         case 2 : strcpy(PBASE2.ID,PBASE1.ID); break;
  1838.         case 3 : strcpy(PBASE3.ID,PBASE1.ID); break;
  1839.         case 4 : strcpy(PBASE4.ID,PBASE1.ID); break;
  1840.         case 5 : strcpy(PBASE5.ID,PBASE1.ID); break;
  1841.     }
  1842. }
  1843.  
  1844. void remove_keys(int badkey)
  1845. {
  1846.     long recd;
  1847.     int keyno;
  1848.  
  1849.     for (keyno = 1; keyno <= (badkey-1); keyno++)
  1850.         if (strcmp(savkey[keyno],tkeytab[keyno]) != 0) {
  1851.             recd = recno[filno];
  1852.             deletekey(idxkey[filno][keyno],&recd,tkeytab[keyno]);
  1853.         }
  1854. }
  1855.  
  1856. void putlink(int nummer)
  1857. {
  1858.     string tkey;
  1859.     long trecno;
  1860.     int tf;
  1861.  
  1862.     do {
  1863.         strcpy(key,savelnk[nummer]);
  1864.         strcpy(tkey,key);
  1865.         searchkey(idxkey[nummer][1],&recno[nummer],key);
  1866.         ok = (bool)(ok && (strsearch(key,tkey) == key));
  1867.         if (ok) {
  1868.             link = No_Link;
  1869.             getarec(nummer);
  1870.             link = Up_N_Down;
  1871.             for (tf = 1; tf <= maxkeyno; tf++)
  1872.                 getakey(savkey[tf],nummer,tf);
  1873.             for (tf = 1; tf <= maxfilno; tf++)
  1874.                 if (linkback[tf].f == nummer) getlink(savelnk[tf],tf);
  1875.             setlinkage(nummer);
  1876.             putarec(nummer);
  1877.             for (tf = 1; tf <= maxkeyno; tf++) {
  1878.                 getakey(tkey,nummer,tf);
  1879.                 if (strcmp(savkey[tf],tkey) != 0) {
  1880.                     deletekey(idxkey[nummer][tf],&recno[nummer],savkey[tf]);
  1881.                     addkey(idxkey[nummer][tf],&recno[nummer],tkey);
  1882.                 }
  1883.             }
  1884.             for (tf = 1; tf <= maxfilno; tf++)
  1885.                 if ((linkback[tf].f == nummer) &&       filinuse[tf] &&
  1886.                         (strcmp(savelnk[tf],getlink(tkey,tf)) != 0)) putlink(tf);
  1887.         }
  1888.     } while (ok);
  1889.     ok = True;
  1890. }
  1891.  
  1892. void edit_record(void)
  1893. {
  1894.     bool changedkey;
  1895.     int fno,tf,keyno;
  1896.     long trecno;
  1897.     keystr tk;
  1898.  
  1899.    editmode = True;
  1900.  
  1901.    lastrecop = _Edit;
  1902.  
  1903.     if (status_ok(filno)) {
  1904.         getarec(filno);
  1905.         displayrec(filno,scrno);
  1906.         for (keyno = 1; keyno <= maxkeyno; keyno++)
  1907.              getakey(savkey[keyno],filno,keyno);
  1908.         for (fno = 1; fno <= maxfilno; fno++) if (linkback[fno].f == filno)
  1909.             getlink(savelnk[fno],fno);
  1910.         edit_rec(0);
  1911.         changedkey = False;
  1912.         if (exitcode != QitKey) {
  1913.             keyno = 1;
  1914.             while ((keyno <= maxkeyno) && (exitcode != QitKey)) {
  1915.                 getakey(tkeytab[keyno],filno,keyno);
  1916.                 if (strcmp(tkeytab[keyno],savkey[keyno]) == 0)
  1917.                     ok = True;
  1918.                 else {
  1919.                     addkey(idxkey[filno][keyno],&recno[filno],tkeytab[keyno]);
  1920.                     if (!ok) {
  1921.                         remove_keys(keyno);
  1922.                         audible(Error);
  1923.                         dspmsge(LSC_BaseError,LSC_KeyExists,4.0);
  1924.                         edit_rec(keyfld[filno][keyno]);
  1925.                         keyno = 0;
  1926.                     }
  1927.                 }
  1928.                 keyno++;
  1929.             }
  1930.             if (exitcode != QitKey) {
  1931.                 for (keyno = 1; keyno <= maxkeyno; keyno++)
  1932.                     if (strcmp(tkeytab[keyno],savkey[keyno]) != 0) {
  1933.                         changedkey = True;
  1934.                         strcpy(tk,tkeytab[keyno]);
  1935.                         strcpy(tkeytab[keyno],savkey[keyno]);
  1936.                         strcpy(savkey[keyno],tk);
  1937.                     }
  1938.                 remove_keys(maxkeyno+1);
  1939.                 putarec(filno);
  1940.                 for (fno = 1; fno <= maxfilno; fno++)
  1941.                     if ((linkback[fno].f == filno) &&
  1942.                             (linkback[fno].t == _Unique) &&
  1943.                             filinuse[fno] &&
  1944.                             (strcmp(savelnk[fno],getlink(tk,fno)) != 0)) putlink(fno);
  1945.             }
  1946.             else ok = True;
  1947.         }
  1948.         getarec(filno);
  1949.         if ((tabsize[filno] > 1) && changedkey) {
  1950.             getakey(savkey[1],filno,1);
  1951.             findmulti(filno,&recno[filno],savkey[1]);
  1952.             align_tab(filno);
  1953.         }
  1954.         displayrec(filno,scrno);
  1955.  
  1956.    lastrecop = Nul;
  1957.  
  1958.    editmode = False;
  1959.     }
  1960. }
  1961.  
  1962. void deletememos(void *fb, void *buf, int fno)
  1963. {
  1964.     word w;
  1965.     long mrec,trec;
  1966.     genbuf sbuf;
  1967.     fldblk *fblk;
  1968.     fldtyp *fld;
  1969.     byteptr buffer;
  1970.  
  1971.     fblk = (fldblk *) fb;
  1972.     buffer = (byteptr) buf;
  1973.     memmove(&sbuf[1],buf,fblk->dsz);
  1974.     w = 0;
  1975.     do {
  1976.         fld = &(*fblk->farr)[w];
  1977.         if (fld->typ == _Memo) {
  1978.             memmove(&mrec,fld->faddr,4);
  1979.             while (mrec != 0) {
  1980.                 getrec(datf[fno],mrec,buf);
  1981.                 memmove(&trec,&buffer[(fblk->dsz-3)-1],4);
  1982.                 deleterec(datf[fno],mrec);
  1983.                 mrec = trec;
  1984.             }
  1985.             memmove(buf,&sbuf[1],fblk->dsz);
  1986.         }
  1987.         w++;
  1988.     } while (w < fblk->numf);
  1989. }
  1990.  
  1991.  
  1992. void delarec(int fno)
  1993. {
  1994.     string tkey,tkey2;
  1995.     bool savok;
  1996.     int i,keyno;
  1997.     long delrecno;
  1998.  
  1999.     getarec(fno);
  2000.     for (i = 1; i <= maxfilno; i++) {
  2001.         if ((linkback[i].t == _Unique) && (linkback[i].f == (byte)fno)) {
  2002.             if (filinuse[i]) {
  2003.                 getlink(tkey,i);
  2004.                 strcpy(tkey2,tkey);
  2005.                 do {
  2006.                     searchkey(idxkey[i][1],&recno[i],tkey2);
  2007.                     savok = (bool)(ok && (strsearch(tkey2,tkey) == tkey2));
  2008.                     if (savok) delarec(i);
  2009.                 } while (savok);
  2010.             }
  2011.         }
  2012.     }
  2013.     delrecno = recno[fno];
  2014.     switch (fno) {
  2015.         case  1 : deletememos(&PBASE1.datasize,&PBASE1,fno); break;
  2016.         case  2 : deletememos(&PBASE2.datasize,&PBASE2,fno); break;
  2017.         case  3 : deletememos(&PBASE3.datasize,&PBASE3,fno); break;
  2018.         case  4 : deletememos(&PBASE4.datasize,&PBASE4,fno); break;
  2019.         case  5 : deletememos(&PBASE5.datasize,&PBASE5,fno); break;
  2020.         case  6 : deletememos(&PBASE6.datasize,&PBASE6,fno); break;
  2021.         case  7 : deletememos(&UCOUNTY1.datasize,&UCOUNTY1,fno); break;
  2022.         case  8 : deletememos(&UCOMP1.datasize,&UCOMP1,fno); break;
  2023.         case  9 : deletememos(&UOCCUP1.datasize,&UOCCUP1,fno); break;
  2024.         case 10 : deletememos(&UZIP1.datasize,&UZIP1,fno); break;
  2025.         case 11 : deletememos(&GRPACCT1.datasize,&GRPACCT1,fno); break;
  2026.         case 12 : deletememos(&UISSUE1.datasize,&UISSUE1,fno); break;
  2027.     }
  2028.     deleterec(datf[fno], delrecno);
  2029.     for (keyno = 1; keyno <= maxkeyno; keyno++) {
  2030.         if (keylen[fno][keyno] > 0) {
  2031.             delrecno = recno[fno];
  2032.             getakey(tkey,fno,keyno);
  2033.             deletekey(idxkey[fno][keyno],&delrecno,tkey);
  2034.         }
  2035.     }
  2036. }
  2037.  
  2038. void delete_record(void)
  2039. {
  2040.     byte i,ch;
  2041.     long trecno;
  2042.     keystr nxtkey;
  2043.     bool tok,child;
  2044.     int tf;
  2045.     string msg;
  2046.  
  2047.    lastrecop = _Delete;
  2048.     if (status_ok(filno)) {
  2049.         getarec(filno);
  2050.         displayrec(filno,scrno);
  2051.         child = False;
  2052.         for (i = 1; i <= maxfilno; i++)
  2053.             child = (bool)(child || ((linkback[i].f == (byte)filno) && (filinuse[i])));
  2054.         strcpy(msg,(child) ? LSC_DelLinkedRec : LSC_ConfirmDelRec);
  2055.         do {
  2056.             dspmsge(LSC_Warning,msg,0.0);
  2057.             ch = upperch(getkey());
  2058.         } while ((ch !=_YES) && (ch != QitKey));
  2059.         if (ch == _YES) {
  2060.             trecno = recno[filno];
  2061.             prevkey(idxkey[filno][1],&recno[filno],key);
  2062.             if (ok) {
  2063.                 strcpy(nxtkey,key);
  2064.                 nextrec = recno[filno];
  2065.             }
  2066.             tok = ok;
  2067.             nextkey(idxkey[filno][1],&recno[filno],key);
  2068.             if (recno[filno] != trecno) {
  2069.                 audible(Error);
  2070.                 dspmsge(LSC_BaseError,LSC_CorruptIndex,4.0);
  2071.                 getarec(filno);
  2072.                 displayrec(filno,scrno);
  2073.             }
  2074.             else {
  2075.                 ok = True;
  2076.         message(NULL, LSC_Deleting);
  2077.                 delarec(filno);
  2078.         message(NULL, "");
  2079.                 if (tok) {
  2080.                     recno[filno] = nextrec;
  2081.                     findmulti(filno,&recno[filno],nxtkey);
  2082.                     if (ok) {
  2083.                         getarec(filno);
  2084.                         if (tabsize[filno] != 1) align_tab(filno);
  2085.                         if (status_ok(filno)) displayrec(filno,scrno); else top_record();
  2086.                     }
  2087.                     else top_record();
  2088.                 }
  2089.                 else top_record();
  2090.             }
  2091.         }
  2092.     }
  2093.     else audible(Warning);
  2094. }
  2095.  
  2096. strptr autoinc(keystr sout, int kno)
  2097. {
  2098.    float tl = 1;                                      /* SN 3.5 */
  2099.    char  tempString1[10],                             /* SN 3.5 */
  2100.     tempString2[10],                                   /* SN 3.5 */
  2101.     tempString3[10],                                   /* SN 3.5 */
  2102.     tempString4[10],                                   /* SN 3.5 */
  2103.     tempString5[10],                                   /* SN 3.5 */
  2104.     fileName[20];                                      /* SN 3.5 */
  2105.  
  2106.     clearkey(idxkey[filno][kno]);
  2107.     prevkey(idxkey[filno][kno],&recno[filno],key);
  2108.  
  2109.     if (!ok) strcpy(sout,"1");
  2110.     else     strip(sout,fstr(sout,valu(key)+1,11,0));
  2111.  
  2112.     return (strip(tempString1, sout));
  2113. }
  2114.  
  2115. void addarec(void)
  2116. {
  2117.     switch (filno) {
  2118.         case  1 : 
  2119.             PBASE1.recstat = 0;
  2120.             addrec(datf[1],&recno[1],&PBASE1);
  2121.         break;
  2122.         case  2 : 
  2123.             PBASE2.recstat = 0;
  2124.             addrec(datf[2],&recno[2],&PBASE2);
  2125.         break;
  2126.         case  3 : 
  2127.             PBASE3.recstat = 0;
  2128.             addrec(datf[3],&recno[3],&PBASE3);
  2129.         break;
  2130.         case  4 : 
  2131.             PBASE4.recstat = 0;
  2132.             addrec(datf[4],&recno[4],&PBASE4);
  2133.         break;
  2134.         case  5 : 
  2135.             PBASE5.recstat = 0;
  2136.             addrec(datf[5],&recno[5],&PBASE5);
  2137.         break;
  2138.         case  6 : 
  2139.             PBASE6.recstat = 0;
  2140.             addrec(datf[6],&recno[6],&PBASE6);
  2141.         break;
  2142.     }
  2143. }
  2144.  
  2145. void add_record(char func)
  2146. {
  2147.     byte stabsiz,stabidx;
  2148.     int fno;
  2149.     long savr,recd;
  2150.     int tf,keyno;
  2151.     bool rav;
  2152.     string tts;
  2153.  
  2154.    lastrecop = func;
  2155.     rav              = True;
  2156.     if (linkback[filno].f > 0) rav = recavail[linkback[filno].f];
  2157.     if ((usedrecs(datf[filno]) >= maxrec[filno]) || !rav) {
  2158.         if (rav) dspmsge("",LSC_MaxRecsReached,4.0);
  2159.         else     dspmsge("",LSC_NoParentRec,4.0);
  2160.     }
  2161.     else {
  2162.         if (ok) savr = recno[filno]; else savr = 0;
  2163.         scrn_active = False;
  2164.         cleartop = (bool)(func == 'A');
  2165.         clear_rec(filno);
  2166.         scrn_active = True;
  2167.         if (!cleartop)
  2168.             switch (filno) {
  2169.                 case  1 : clearmemo(&PBASE1.datasize); break;
  2170.                 case  2 : clearmemo(&PBASE2.datasize); break;
  2171.                 case  3 : clearmemo(&PBASE3.datasize); break;
  2172.                 case  4 : clearmemo(&PBASE4.datasize); break;
  2173.                 case  5 : clearmemo(&PBASE5.datasize); break;
  2174.                 case  6 : clearmemo(&PBASE6.datasize); break;
  2175.                 case  7 : clearmemo(&UCOUNTY1.datasize); break;
  2176.                 case  8 : clearmemo(&UCOMP1.datasize); break;
  2177.                 case  9 : clearmemo(&UOCCUP1.datasize); break;
  2178.                 case 10 : clearmemo(&UZIP1.datasize); break;
  2179.                 case 11 : clearmemo(&GRPACCT1.datasize); break;
  2180.                 case 12 : clearmemo(&UISSUE1.datasize); break;
  2181.             }
  2182.         cleartop = True;
  2183.         switch (filno) {
  2184.             case  1:
  2185.                 strcopy(PBASE1.STATUS,pad(tts,"Active",16,Right),0,16);
  2186.                 strcopy(PBASE1.LAST_CONTACT,pad(tts,sysdate(_tts),8,Right),0,8);
  2187.                 strcopy(PBASE1.ID,fstr(tts,valu(ltoa(txtinc(".\\pbinc.num",1),_tts,10)),4,0),0,4);
  2188.                 strcopy(PBASE1.HONR,pad(tts,"None",10,Right),0,10);
  2189.             break;
  2190.             case  2:
  2191.                 setlinkage(filno);
  2192.             break;
  2193.             case  3:
  2194.                 setlinkage(filno);
  2195.             break;
  2196.             case  4:
  2197.                 setlinkage(filno);
  2198.             break;
  2199.             case  5:
  2200.                 setlinkage(filno);
  2201.                 strcopy(PBASE5.TIME,pad(tts,"0001",4,Right),0,4);
  2202.             break;
  2203.         }
  2204.         stabsiz = 1;
  2205.         if (tabsize[filno] > 1) {
  2206.             stabidx = tabidx[filno];
  2207.             if (tabidx[filno] == tabsize[filno])
  2208.                 tabidx[filno] = 1;
  2209.             else
  2210.                 tabidx[filno] = tabused[filno]+1;
  2211.             stabsiz = tabsize[filno];
  2212.             tabsize[filno] = 1;
  2213.         }
  2214.         leaveclear = True;
  2215.         displayrec(filno,scrno);
  2216.         edit_rec(0);
  2217.         if (exitcode != QitKey) {
  2218.             addarec();
  2219.             for (keyno = 1; keyno <= maxkeyno; keyno++) savkey[keyno][0] = '\0';
  2220.             keyno = 1;
  2221.             ok      = True;
  2222.             while ((keyno <= maxkeyno) && (exitcode != QitKey)) {
  2223.                 if (keylen[filno][keyno] > 0) {
  2224.                     getakey(tkeytab[keyno],filno,keyno);
  2225.                     addkey(idxkey[filno][keyno],&recno[filno],tkeytab[keyno]);
  2226.                     if (!ok) {
  2227.                         remove_keys(keyno);
  2228.                         audible(Error);
  2229.                         dspmsge(LSC_BaseError,LSC_KeyExists,4.0);
  2230.                         edit_rec(keyfld[filno][keyno]);
  2231.                         if (exitcode == QitKey) {
  2232.                             recd = recno[filno];
  2233.                             deleterec(datf[filno],recd);
  2234.                             recno[filno] = savr;
  2235.                         }
  2236.                         else {
  2237.                             keyno = 0;
  2238.                             putarec(filno);
  2239.                         }
  2240.                     }
  2241.                 }
  2242.                 keyno++;
  2243.             }
  2244.         }
  2245.         else recno[filno] = savr;
  2246.         if (exitcode == QitKey) {
  2247.             if (stabsiz > 1) tabidx[filno] = stabidx;
  2248.             fno = filno;
  2249.             switch (fno) {
  2250.                 case  1 : deletememos(&PBASE1.datasize,&PBASE1,fno); break;
  2251.                 case  2 : deletememos(&PBASE2.datasize,&PBASE2,fno); break;
  2252.                 case  3 : deletememos(&PBASE3.datasize,&PBASE3,fno); break;
  2253.                 case  4 : deletememos(&PBASE4.datasize,&PBASE4,fno); break;
  2254.                 case  5 : deletememos(&PBASE5.datasize,&PBASE5,fno); break;
  2255.                 case  6 : deletememos(&PBASE6.datasize,&PBASE6,fno); break;
  2256.                 case  7 : deletememos(&UCOUNTY1.datasize,&UCOUNTY1,fno); break;
  2257.                 case  8 : deletememos(&UCOMP1.datasize,&UCOMP1,fno); break;
  2258.                 case  9 : deletememos(&UOCCUP1.datasize,&UOCCUP1,fno); break;
  2259.                 case 10 : deletememos(&UZIP1.datasize,&UZIP1,fno); break;
  2260.                 case 11 : deletememos(&GRPACCT1.datasize,&GRPACCT1,fno); break;
  2261.                 case 12 : deletememos(&UISSUE1.datasize,&UISSUE1,fno); break;
  2262.             }
  2263.         }
  2264.         if (stabsiz > 1) tabsize[filno] = stabsiz;
  2265.         leaveclear = False;
  2266.         ok = (bool)(ok || (savr > 0));
  2267.         getarec(filno);
  2268.         if ((exitcode != QitKey) && (tabsize[filno] > 1)) {
  2269.             getakey(skey,filno,1);
  2270.             findmulti(filno,&recno[filno],skey);
  2271.             align_tab(filno);
  2272.         }
  2273.         displayrec(filno,scrno);
  2274.     }
  2275.    lastrecop = Nul;
  2276. }
  2277.  
  2278. void initialize(void)
  2279. {
  2280.    keyseg1fld[ 1][ 1] = &PBASE1._ID;
  2281.    keyseg1fld[ 1][ 2] = &PBASE1._LAST_NAME;
  2282.    keyseg1fld[ 1][ 3] = &PBASE1._FIRST_NAME;
  2283.    keyseg1fld[ 1][ 4] = &PBASE1._POSITION;
  2284.    keyseg1fld[ 1][ 5] = &PBASE1._COMPANY;
  2285.    keyseg1fld[ 1][ 6] = &PBASE1._HONR;
  2286.    keyseg1fld[ 1][ 7] = &PBASE1._HOME_STATE;
  2287.    keyseg1fld[ 1][ 8] = &PBASE1._HOME_ZIP;
  2288.    keyseg1fld[ 1][ 9] = &PBASE1._STATUS;
  2289.    keyseg1fld[ 1][10] = &PBASE1._LAST_CONTACT;
  2290.    keyseg1fld[ 1][11] = &PBASE1._P_MARKED;
  2291.    keyseg1fld[ 1][12] = &PBASE1._HOME_CITY;
  2292.    keyseg1fld[ 1][13] = &PBASE1._HOME_ADDR1;
  2293.    keyseg1fld[ 1][14] = &PBASE1._HOME_STREET_NUM;
  2294.    keyseg1fld[ 2][ 1] = &PBASE2._ID;
  2295.    keyseg1fld[ 3][ 1] = &PBASE3._ID;
  2296.    keyseg1fld[ 3][ 2] = &PBASE3._GROUPS;
  2297.    keyseg1fld[ 4][ 1] = &PBASE4._ID;
  2298.    keyseg1fld[ 4][ 2] = &PBASE4._VOTER_COUNTY;
  2299.    keyseg1fld[ 4][ 3] = &PBASE4._VOTER_CITY;
  2300.    keyseg1fld[ 4][ 4] = &PBASE4._VOTER_PRECINCT;
  2301.    keyseg1fld[ 4][ 5] = &PBASE4._VOTER_CONG_DIST;
  2302.    keyseg1fld[ 4][ 6] = &PBASE4._VOTER_SCH_DIST;
  2303.    keyseg1fld[ 4][ 7] = &PBASE4._VOTER_BIRTHDATE;
  2304.    keyseg1fld[ 4][ 8] = &PBASE4._VOTER_SEX;
  2305.    keyseg1fld[ 4][ 9] = &PBASE4._VOTER_ORIGIN;
  2306.    keyseg1fld[ 4][10] = &PBASE4._VOTER_PARTY;
  2307.    keyseg1fld[ 4][11] = &PBASE4._VOTER_LAST_VOTED;
  2308.    keyseg1fld[ 4][12] = &PBASE4._VOTER_ABS;
  2309.    keyseg1fld[ 4][13] = &PBASE4._VOTER_ISSUE1;
  2310.    keyseg1fld[ 4][14] = &PBASE4._VOTER_ISSUE2;
  2311.    keyseg1fld[ 4][15] = &PBASE4._VOTER_ISSUE3;
  2312.    keyseg1fld[ 4][16] = &PBASE4._VOTER_ISSUE4;
  2313.    keyseg1fld[ 5][ 1] = &PBASE5._ID;
  2314.    keyseg1fld[ 6][ 1] = &PBASE6._BOGUS_ID;
  2315.    keyseg1fld[ 7][ 1] = &UCOUNTY1._VOTER_COUNTY;
  2316.    keyseg1fld[ 7][ 2] = &UCOUNTY1._COUNTY_SIZE;
  2317.    keyseg1fld[ 7][ 3] = &UCOUNTY1._ID;
  2318.    keyseg1fld[ 7][ 4] = &UCOUNTY1._COUNTY_SEAT;
  2319.    keyseg1fld[ 8][ 1] = &UCOMP1._COMPANY;
  2320.    keyseg1fld[ 8][ 2] = &UCOMP1._ID;
  2321.    keyseg1fld[ 9][ 1] = &UOCCUP1._POSITION;
  2322.    keyseg1fld[ 9][ 2] = &UOCCUP1._POS_DESC;
  2323.    keyseg1fld[10][ 1] = &UZIP1._HOME_ZIP;
  2324.    keyseg1fld[11][ 1] = &GRPACCT1._GROUPS;
  2325.    keyseg1fld[11][ 2] = &GRPACCT1._GROUP_DESC;
  2326.    keyseg1fld[12][ 1] = &UISSUE1._ISSID;
  2327.    keyseg1fld[12][ 2] = &UISSUE1._VOTER_ISSUE;
  2328.    command    = Cmd_No_Command;
  2329.    deltas     = def1.deltat;
  2330.     keynum     = 1;
  2331.     scrno      = 1;
  2332.     _trace     = 0;
  2333.     menuanchor = 0;
  2334.     link       = Up_N_Down;
  2335.     listing    = False;
  2336.    listAndAdd = False;
  2337.     leaveclear = False;
  2338.     switchtab = False;
  2339.     scrn_active = False;
  2340.     cleartop = True;
  2341.     for (filno = 1; filno <= maxfilno; filno++) {
  2342.         recno[filno] = 0;
  2343.         tabrecno[filno] = 0;
  2344.         clear_rec(filno);
  2345.         recavail[filno] = (bool)(usedrecs(datf[filno]) > 0);
  2346.         tabidx[filno] = 1; tabused[filno] = 0;
  2347.     }
  2348.     for (filno = 1; filno <= maxfilno; filno++) if (linkback[filno].f == 0) top_record();
  2349.     scrn_active = True;
  2350.     filno = 1;
  2351. }
  2352.  
  2353. bool custom_key(int scr, int fno, int *fld, uchar *key)
  2354. {
  2355.     bool tb;
  2356.  
  2357.     return(False);
  2358. }
  2359.  
  2360. void on_error(void)
  2361. {
  2362.     closefiles();
  2363. }
  2364.  
  2365. void swapmenu(void)
  2366. {
  2367.     bool savdisp;
  2368.     byte ni,tl,tw,tlen;
  2369.     itmptr titm;
  2370.     mnuptr m;
  2371.  
  2372.     savdisp = (bool)((dm.curmnu->winp != NULL) && dm.curmnu->winp->disp);
  2373.     if (savdisp) zapmnu(&dm,dm.curmnu);
  2374.     m = dm.curmnu;
  2375.     m->mtyp = (byte)((m->mtyp == Vert) ? 2 : Vert);
  2376.     tw = 1; ni = 0; tl = 0;
  2377.     titm = m->fitm;
  2378.     do {
  2379.         ni++; tl += m->mtyp;
  2380.         if (m->mtyp == Vert) { titm->ix = 2; titm->iy = ni; }
  2381.         else { titm->ix = tl; titm->iy = 1; }
  2382.         tlen = (byte)strlen(titm->prompt); tl += tlen;
  2383.         if (tlen > tw) tw = tlen;
  2384.         titm = titm->nitm;
  2385.     } while (titm != m->fitm);
  2386.     if (m->mtyp == Vert) { m->widm = tw+2; m->hgtm = ni; }
  2387.     else { m->widm = tl+m->mtyp-2; m->hgtm = 1; }
  2388.     if (m->mtyp != Vert) {
  2389.         m->ym = (m->xm == 2) ? 1 : scrhgt;
  2390.         m->xm = 1; m->mbchrs[0] = '\0';
  2391.     }
  2392.     else {
  2393.         if (m->ym == 1) { m->ym = 2; m->xm = scrwid-m->widm; }
  2394.         else { m->ym = scrhgt-m->hgtm; m->xm = 2; }
  2395.         m->mbchrs[0] = '─';
  2396.     }
  2397.     if (savdisp) dspmnu(&dm,dm.curmnu);
  2398.     menuanchor = (menuanchor+1) % 4;
  2399. }
  2400.  
  2401. void changeto(pathstr newpath, int *res)
  2402. {
  2403.     *res = (changedir(newpath)) ? 0 : 1;
  2404.     if (*res == 0) {
  2405.         getcurrentdir(datapath,0);
  2406.         pathSwap = True;
  2407.     }
  2408. }
  2409.  
  2410. void newload(mnufrec *m, pathstr newmenu)
  2411. {
  2412.     int i;
  2413.     pathstr newnam;
  2414.  
  2415.     strcpy(newnam,newmenu);
  2416.     svm = smc;
  2417.     smc = db_malloc(sizeof(savmtyp));
  2418.     smc->savprv = svm;
  2419.     strcpy(smc->savnam,m->mnufnam);
  2420.     smc->savno = m->curmnu->mno;
  2421.     strcpy(smc->savprompt,m->curitm->prompt);
  2422.     if (dm.curitm->selpath[0] != '\0') {
  2423.         getcurrentdir(smc->savpath,0);
  2424.         changeto(dm.curitm->selpath,&i);
  2425.     }
  2426.     else {
  2427.         i = 0;
  2428.         smc->savpath[0] = '\0';
  2429.     }
  2430.     if (i == 0) {
  2431.         disposemnus(&dm);
  2432.         strcpy(dm.mnufnam,newnam);
  2433.         initmnu(&dm,0,0,OnDisk);
  2434.         dispallwin();
  2435.         if (dm.curmnu == NULL) {
  2436.             if (smc->savpath[0] != '\0')
  2437.                 changeto(smc->savpath,&i);
  2438.                 strcpy(dm.mnufnam,smc->savnam);
  2439.                 initmnu(&dm,0,0,OnDisk);
  2440.                 dispallwin();
  2441.                 jumptomnu(&dm,smc->savno);
  2442.                 do
  2443.                     dm.curitm = dm.curitm->nitm;
  2444.                 while ((strcmp(smc->savnam,dm.curitm->prompt) != 0) &&
  2445.                                 (dm.curitm != dm.curmnu->fitm));
  2446.                 db_free(smc);
  2447.                 smc = svm;
  2448.             }
  2449.             else {
  2450.                 dspmnu(&dm,dm.curmnu);
  2451.             }
  2452.         }
  2453.         else {
  2454.             db_free(smc);
  2455.             smc = svm;
  2456.             doserr(3,dm.curitm->selpath);
  2457.         }
  2458.     pathSwap = True;
  2459. }
  2460.  
  2461. void setcommand(byte c_num)
  2462. {
  2463.     switch(c_num) {
  2464.       case 1 :  command = Cmd_Next_Record;    break;
  2465.       case 2 :  command = Cmd_Prev_Record;    break;
  2466.       case 3 :  command = Cmd_Find_Record;    break;
  2467.       case 4 :  command = Cmd_Top_Record;     break;
  2468.       case 5 :  command = Cmd_Last_Record;    break;
  2469.       case 6 :  command = Cmd_Edit_Record;    break;
  2470.       case 7 :  command = Cmd_Add_Record;     break;
  2471.       case 8 :  command = Cmd_Copy_Record;    break;
  2472.       case 9 :  command = Cmd_Delete_Record;  break;
  2473.       case 10 : command = Cmd_Next_File;      break;
  2474.       case 11 : command = Cmd_Prev_File;      break;
  2475.       case 12 : command = Cmd_Swap_Menu;      break;
  2476.    }
  2477. }
  2478.  
  2479.  
  2480. /***********************************************************************/
  2481. /*                                                                                                                                         */
  2482. /*              DO_PROC                 menu procedures                                                            */
  2483. /*                                                                                                                                         */
  2484. /***********************************************************************/
  2485.  
  2486. void do_proc(int procno, mnufrec *m)
  2487. {
  2488.    setcommand(procno);
  2489.    hidewin(T_OFF,dm.curmnu->winp);
  2490.     switch (procno) {
  2491.         case 1 : next_record(_Next); break;
  2492.         case 2 : next_record(_Prev); break;
  2493.         case 3 : find_record(); break;
  2494.         case 4 : if (status_ok(filno)) top_record(); else audible(Warning); break;
  2495.         case 5 : last_record(); break;
  2496.         case 6 : if (status_ok(filno)) {
  2497.             edit_record();
  2498.             getakey(key,filno,1);
  2499.             findmulti(filno,&recno[filno],key);
  2500.             if (!ok) top_record();
  2501.         }
  2502.         else audible(Warning); break;
  2503.         case 7 :
  2504.             add_record('A');
  2505.             getakey(key,filno,1);
  2506.             findmulti(filno,&recno[filno],key);
  2507.             if (!ok) top_record();
  2508.         break;
  2509.         case 8 : if (status_ok(filno)) {
  2510.             add_record('C');
  2511.             getakey(key,filno,1);
  2512.             findmulti(filno,&recno[filno],key);
  2513.             if (!ok) top_record();
  2514.         }
  2515.         else audible(Warning); break;
  2516.         case 9 : delete_record(); break;
  2517.         case 10: switch_file('+'); break;
  2518.         case 11: switch_file('-'); break;
  2519.         case 12: setdeltas(); break;
  2520.         case 13: swapmenu(); break;
  2521. /***************************************************************************
  2522. * [DG] 09/11/92 -- Added cases 101-116, which will switch instantly to     *
  2523. *                  files 1-16, by subtracting 100 from the case number.    *
  2524. *                  If the file number is larger than the maximum defined   *
  2525. *                  file, we switch to the highest valid file.              *
  2526. ***************************************************************************/
  2527.       case 101:
  2528.       case 102:
  2529.       case 103:
  2530.       case 104:
  2531.       case 105:
  2532.       case 106:
  2533.       case 107:
  2534.       case 108:
  2535.       case 109:
  2536.       case 110:
  2537.       case 111:
  2538.       case 112:
  2539.       case 113:
  2540.       case 114:
  2541.       case 115:
  2542.       case 116: filno = (procno - 100);
  2543.         if (filno > maxfilno)  filno = maxfilno;
  2544.         switch_file(' ');
  2545.         break;
  2546. /***********************/ /* [DG] End Modification */ /*******************/
  2547.     }
  2548.    hidewin(T_ON,dm.curmnu->winp);
  2549.    dispwindow(dm.curmnu->winp);
  2550. }
  2551.  
  2552. /*************************************************************************/
  2553.  
  2554.  
  2555. void do_ctl(mnufrec *m, itmptr itm)
  2556. {
  2557.     string ts;
  2558.     uchar yes[2],tpic[2];
  2559.  
  2560.     if ((m->curmnu != NULL) && (itm != NULL)) {
  2561.         switch (itm->seltyp) {
  2562.             case _Proc : do_proc((int) ival(itm->selact),m); break;
  2563.             case _Menu :
  2564.                 if ((ival(itm->selact) > 0) && (m->mat[(int) ival(itm->selact)-1] != NULL)) {
  2565.                     if (m->mat[(int) ival(itm->selact)-1]->winp != NULL)
  2566.                         jumptomnu(m,(byte) ival(itm->selact));
  2567.                     else {
  2568.                         m->mat[(int) ival(itm->selact)-1]->pmnu = m->curmnu->mno;
  2569.                         m->curmnu = m->mat[(int) ival(itm->selact)-1];
  2570.                         dspmnu(m,m->curmnu);
  2571.                         m->curitm = m->curmnu->litm;
  2572.                         m->level = 0;
  2573.                     }
  2574.                 }
  2575.             break;
  2576.             case _Quit :
  2577.                 dbgetstr(ts,_Ch,LSC_QuitDataBase,chstr(yes,_YES),chstr(tpic,Pic_U),"",chkyesno,nohelp);
  2578.                 quit = (bool)((ts[0] == _YES) && (exitcode != QitKey));
  2579.             break;
  2580.         }
  2581.     }
  2582. }
  2583.  
  2584. bool initdbm(void)
  2585. {
  2586.     strcpy(dm.mnufnam,localmenu);
  2587.     initmnu(&dm,0,0,OnDisk);
  2588.     return (bool)(dm.curmnu != NULL);
  2589. }
  2590.  
  2591. void datenpath(void)
  2592. {
  2593.     string ts;
  2594.  
  2595.     if (uw.bgw != NULL) {
  2596.         if (mdate.x != 0)
  2597.             if (mdate.m == 0)
  2598.                 writewxy(datum(ts,sysdate(ts)),0,mdate.x,mdate.y,uw.bgw);
  2599.             else
  2600.                 writewxy(slash(ts,sysdate(ts)),0,mdate.x,mdate.y,uw.bgw);
  2601.         if (mpath.x != 0) {
  2602.             strcpy(ts,datapath);
  2603.             if (strlen(ts) == 3) strcat(ts,applname);
  2604.             else { strcat(ts,"\\"); strcat(ts,applname); }
  2605.             writewxy(ts,0,mpath.x,mpath.y,uw.bgw);
  2606.         }
  2607.     }
  2608. }
  2609.  
  2610. void do_menu(void)
  2611. {
  2612.     byte b;
  2613.     uchar ctlkey;
  2614.     int err;
  2615.     string ts;
  2616.     uchar yes[2],tpic[2];
  2617.  
  2618.     set_addmember(ExitSet,AltX);
  2619.     if (initdbm()) {
  2620.         for (b = 0; b < def1.anchor; b++) swapmenu();
  2621.         strcat(strcpy(uw.wfnam,applname),".DBW");
  2622.         err = initwin(&uw);
  2623.         if (err == 0) {
  2624.             if ((dm.curmnu->ym == 25) && (scrhgt > 25)) dm.curmnu->ym = scrhgt;
  2625.             datenpath();
  2626.             if (uw.bgw != NULL) uw.bgw->disp = True;
  2627.             strcat(strcpy(hw.wfnam,applname),".DBH");
  2628.             initwin(&hw);
  2629.             dispallwin();
  2630.             hidewin(T_ON,uw.wa[1]);
  2631.             top_record();
  2632.             quit = False;
  2633.             dspmnu(&dm,dm.curmnu);
  2634.             do {
  2635.                 if (dm.curitm->sec > gvar->sec) {
  2636.                     if (dm.curmnu->mtyp == Vert) goud(&dm,Down);
  2637.            else                         gorl(&dm,Right);
  2638.                 }
  2639.                 hbar(&dm);
  2640.                 tandk(0,0,uw.wa[scrno]);
  2641.                 ctlkey = upperch(getkey());
  2642.                 if ((dm.curitm->sec > gvar->sec) &&
  2643.                         ((ctlkey != AltX) && (ctlkey != AltL) && (ctlkey != QitKey)))
  2644.                     dberrm(LSC_MustLogOn);
  2645. // [DG] 09/09/1992
  2646. // Restructured switch statement to allow (mostly) CUA-compliant hot-keys
  2647.                 switch (ctlkey) {
  2648.                   case Enter    : if (gvar->sec >= dm.curitm->sec)
  2649.                                           do_ctl(&dm,dm.curitm); break;
  2650.                   case HlpKey   : itemhelp(&dm); break;
  2651. /* Next */    case CtrlRArr : do_proc( 1,&dm); break;
  2652. /* Prev */    case CtrlLArr : do_proc( 2,&dm); break;
  2653. /* Find */    case AltS     : do_proc( 3,&dm); break;
  2654. /* Top  */    case Home     : do_proc( 4,&dm); break;
  2655. /* Last */    case EndKey   : do_proc( 5,&dm); break;
  2656. /* Edit */    case CtrlEnter: do_proc( 6,&dm); break;
  2657. /* Add  */    case Ins      : do_proc( 7,&dm); break;
  2658. /* Copy */    case CtrlC    : do_proc( 8,&dm); break;
  2659. /* Del  */    case Del      : do_proc( 9,&dm); break;
  2660. /* +Fil */    case PgDn     : do_proc(10,&dm); break;
  2661. /* -Fil */    case PgUp     : do_proc(11,&dm); break;
  2662. /* ScSv */        case AltV     : do_proc(12,&dm); break;
  2663.                   case UArr     : if (dm.curmnu->mtyp != Vert) do_proc(2,&dm);
  2664.                                          else goud(&dm,Up); break;
  2665.                   case DArr     : if (dm.curmnu->mtyp != Vert) do_proc(1,&dm);
  2666.                                          else goud(&dm,Down); break;
  2667.                   case LArr     : gorl(&dm,Left); break;
  2668.                   case RArr     : gorl(&dm,Right); break;
  2669.                   case CtrlPgUp : if (tabsize[filno] > 1)
  2670.                                          next_tab_page(_Prev); break;
  2671.                   case CtrlPgDn : if (tabsize[filno] > 1)
  2672.                                          next_tab_page(_Next); break;
  2673.                   case AltX     : dbgetstr(ts,_Ch,LSC_QuitDataBase,
  2674.                                          chstr(yes,_YES),chstr(tpic,Pic_U),"",
  2675.                                             chkyesno,nohelp);
  2676.                                          quit = (bool)((ts[0] == _YES) &&
  2677.                                                           (exitcode != QitKey));
  2678.                                break;
  2679.               case QitKey   : if ((dm.curmnu != NULL) &&
  2680.                   (dm.curmnu->pmnu != 0))
  2681.                 {
  2682.                                   zapmnu(&dm,dm.curmnu);
  2683.                                   dm.curmnu->litm = dm.curitm;
  2684.                                   dm.curmnu = dm.mat[dm.curmnu->pmnu-1];
  2685.                                   dm.curitm = dm.curmnu->litm;
  2686.                                   dm.level = 0;
  2687.                                   if (dm.curmnu->winp == NULL)
  2688.                   dspmnu(&dm,dm.curmnu);
  2689.                              }
  2690.                                else
  2691.                 {
  2692.                 if (filno > 1)
  2693.                   switch_file('-');
  2694.                                   else
  2695.                   {
  2696.                                      dbgetstr(ts,_Ch,LSC_QuitDataBase,
  2697.                        chstr(yes,_YES),
  2698.                        chstr(tpic,Pic_U),"",
  2699.                        chkyesno,nohelp);
  2700.                                      quit = (bool)((ts[0] == _YES) &&
  2701.                            (exitcode != QitKey));
  2702.                                 }
  2703.                              }
  2704.                                break;
  2705.                     default      : if (selitm(ctlkey,&dm))
  2706.                 {
  2707.                                    hbar(&dm);
  2708.                                    do_ctl(&dm,dm.curitm);
  2709.                                   }
  2710.                                break;
  2711. // End of changes
  2712.                 }
  2713.             } while (!quit);
  2714.         }
  2715.  
  2716.  
  2717.         else dberrm(strconcat(ts,DOSErr8," [",uw.wfnam,"]",NULL));
  2718.         if ((menuanchor != def1.anchor) || (deltas != def1.deltat)) {
  2719.             def1.anchor = menuanchor;
  2720.      def1.deltat = deltas;
  2721.             updexe(def1.exeid,sizeof(def1));
  2722.         }
  2723.         disposemnus(&dm);
  2724.         closeallwin();
  2725.     }
  2726.     else dberrm(strconcat(ts,_NoFiles," [",localmenu,"]",NULL));
  2727. }
  2728.  
  2729. void main(void)
  2730. {
  2731.     extfhc_init();
  2732.     db_curs_init();
  2733.     db_date_init();
  2734.     db_funcs_init();
  2735.     db_heap_init();
  2736.     db_gvar_init();
  2737.     db_key_init();
  2738.     db_pswd_init();
  2739.     db_win_init();
  2740.     db_util_init();
  2741.     db_work_init();
  2742.     db_tree_init();
  2743.     db_list_init();
  2744.     db_man_init();
  2745.     db_mnu_init();
  2746.     db_memo_init();
  2747.     multiuser = False;
  2748.     initedit();
  2749.     initindex();
  2750.     _keyexpr = keyexpr;
  2751.     _getarec = getarec;
  2752.     _horizrec = horizrec;
  2753.     clrscr();
  2754.     if (menudriven && !dbcaller) {
  2755.         audible(Error);
  2756.         dspmsge(LSC_BaseError,LSC_MenuDriven,4.0);
  2757.     }
  2758.     else if (!validpath()) {
  2759.         audible(Error);
  2760.         dspmsge(LSC_BaseError,LSC_AbortBadPath,4.0);
  2761.     }
  2762.     else {
  2763.         if (openwin(0,(byte)(80-strlen(LSC_Initializing))/2,12,
  2764.                                 (byte)strlen(LSC_Initializing),1,31,31,8,"─┐│┘─└│┌",TopCnt,"")) {
  2765.             twinp = curwin;
  2766.             writewxy(LSC_Initializing,31,1,1,twinp);
  2767.             hidewin(T_ON,twinp);
  2768.             openfiles();
  2769.             closewin(&twinp);
  2770.         }
  2771.         if (fok) {
  2772.             shutdown = on_error;
  2773.             initialize();
  2774.             initmanual("PBASE.MAN");
  2775.             do_menu();
  2776.             if (openwin(0,(80-strlen(LSC_ClosingFile))/2,12,
  2777.                                     (byte)strlen(LSC_ClosingFile),1,31,31,8,"─┐│┘─└│┌",TopCnt,"")) {
  2778.                 twinp = curwin;
  2779.                 writewxy(LSC_ClosingFile,31,1,1,twinp);
  2780.                 hidewin(T_ON,twinp);
  2781.                 closefiles();
  2782.                 closewin(&twinp);
  2783.             }
  2784.         }
  2785.         else {
  2786.             audible(Error);
  2787.             dspmsge(LSC_ErrNeededFiles,LSC_ErrMissingFile,5.0);
  2788.         }
  2789.     }
  2790.     clrscr();
  2791. }
  2792.