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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
hp_test2.c
资源名称：mysql-4.1.16-win-src.zip　[点击查看]
上传用户：romrleung
上传日期：2022-05-23
资源大小：18897k
文件大小：17k
源码类别：

MySQL数据库

开发平台：

Visual C++

hp_test2.c：源码内容
  1. /* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
  3.    This program is free software; you can redistribute it and/or modify
  4.    it under the terms of the GNU General Public License as published by
  5.    the Free Software Foundation; either version 2 of the License, or
  6.    (at your option) any later version.
  8.    This program is distributed in the hope that it will be useful,
  9.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11.    GNU General Public License for more details.
  13.    You should have received a copy of the GNU General Public License
  14.    along with this program; if not, write to the Free Software
  15.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  17. /* Test av isam-databas: stor test */
  19. #ifndef USE_MY_FUNC /* We want to be able to dbug this !! */
  20. #define USE_MY_FUNC
  21. #endif
  22. #ifdef DBUG_OFF
  23. #undef DBUG_OFF
  24. #endif
  25. #ifndef SAFEMALLOC
  26. #define SAFEMALLOC
  27. #endif
  29. #include "heapdef.h" /* Because of hp_find_block */
  30. #include <signal.h>
  32. #define MAX_RECORDS 100000
  33. #define MAX_KEYS 4
  35. static int get_options(int argc, char *argv[]);
  36. static int rnd(int max_value);
  37. static sig_handler endprog(int sig_number);
  39. static uint flag=0,verbose=0,testflag=0,recant=10000,silent=0;
  40. static uint keys=MAX_KEYS;
  41. static uint16 key1[1001];
  42. static my_bool key3[MAX_RECORDS];
  43. static int reclength=39;
  46. static int calc_check(byte *buf,uint length);
  47. static void make_record(char *record, uint n1, uint n2, uint n3,
  48. const char *mark, uint count);
  50. /* Main program */
  52. int main(int argc, char *argv[])
  53. {
  54.   register uint i,j;
  55.   uint ant,n1,n2,n3;
  56.   uint write_count,update,opt_delete,check2,dupp_keys,found_key;
  57.   int error;
  58.   ulong pos;
  59.   unsigned long key_check;
  60.   char record[128],record2[128],record3[128],key[10];
  61.   const char *filename,*filename2;
  62.   HP_INFO *file,*file2;
  63.   HP_KEYDEF keyinfo[MAX_KEYS];
  64.   HA_KEYSEG keyseg[MAX_KEYS*5];
  65.   HEAP_PTR position;
  66.   HP_CREATE_INFO hp_create_info;
  67.   CHARSET_INFO *cs= &my_charset_latin1;
  68.   MY_INIT(argv[0]); /* init my_sys library & pthreads */
  69.   LINT_INIT(position);
  71.   filename= "test2";
  72.   filename2= "test2_2";
  73.   file=file2=0;
  74.   get_options(argc,argv);
  75.   
  76.   bzero(&hp_create_info, sizeof(hp_create_info));
  78.   write_count=update=opt_delete=0;
  79.   key_check=0;
  81.   keyinfo[0].seg=keyseg;
  82.   keyinfo[0].keysegs=1;
  83.   keyinfo[0].flag= 0;
  84.   keyinfo[0].algorithm= HA_KEY_ALG_HASH;
  85.   keyinfo[0].seg[0].type=HA_KEYTYPE_BINARY;
  86.   keyinfo[0].seg[0].start=0;
  87.   keyinfo[0].seg[0].length=6;
  88.   keyinfo[0].seg[0].null_bit=0;
  89.   keyinfo[0].seg[0].charset=cs;
  90.   keyinfo[1].seg=keyseg+1;
  91.   keyinfo[1].keysegs=2;
  92.   keyinfo[1].flag=0;
  93.   keyinfo[1].algorithm= HA_KEY_ALG_HASH;
  94.   keyinfo[1].seg[0].type=HA_KEYTYPE_BINARY;
  95.   keyinfo[1].seg[0].start=7;
  96.   keyinfo[1].seg[0].length=6;
  97.   keyinfo[1].seg[0].null_bit=0;
  98.   keyinfo[1].seg[0].charset=cs;
  99.   keyinfo[1].seg[1].type=HA_KEYTYPE_TEXT;
  100.   keyinfo[1].seg[1].start=0; /* key in two parts */
  101.   keyinfo[1].seg[1].length=6;
  102.   keyinfo[1].seg[1].null_bit=0;
  103.   keyinfo[1].seg[1].charset=cs;
  104.   keyinfo[2].seg=keyseg+3;
  105.   keyinfo[2].keysegs=1;
  106.   keyinfo[2].flag=HA_NOSAME;
  107.   keyinfo[2].algorithm= HA_KEY_ALG_HASH;
  108.   keyinfo[2].seg[0].type=HA_KEYTYPE_BINARY;
  109.   keyinfo[2].seg[0].start=12;
  110.   keyinfo[2].seg[0].length=8;
  111.   keyinfo[2].seg[0].null_bit=0;
  112.   keyinfo[2].seg[0].charset=cs;
  113.   keyinfo[3].seg=keyseg+4;
  114.   keyinfo[3].keysegs=1;
  115.   keyinfo[3].flag=HA_NOSAME;
  116.   keyinfo[3].algorithm= HA_KEY_ALG_HASH;
  117.   keyinfo[3].seg[0].type=HA_KEYTYPE_BINARY;
  118.   keyinfo[3].seg[0].start=37;
  119.   keyinfo[3].seg[0].length=1;
  120.   keyinfo[3].seg[0].null_bit=1;
  121.   keyinfo[3].seg[0].null_pos=38;
  122.   keyinfo[3].seg[0].charset=cs;
  124.   bzero((char*) key1,sizeof(key1));
  125.   bzero((char*) key3,sizeof(key3));
  127.   printf("- Creating heap-filen");
  128.   if (heap_create(filename,keys,keyinfo,reclength,(ulong) flag*100000L, 
  129. (ulong) recant/2, &hp_create_info) ||
  130.       !(file= heap_open(filename, 2)))
  131.     goto err;
  132.   signal(SIGINT,endprog);
  134.   printf("- Writing records:sn");
  135.   strmov(record,"          ..... key");
  137.   for (i=0 ; i < recant ; i++)
  138.   {
  139.     n1=rnd(1000); n2=rnd(100); n3=rnd(min(recant*5,MAX_RECORDS));
  140.     make_record(record,n1,n2,n3,"Pos",write_count);
  142.     if (heap_write(file,record))
  143.     {
  144.       if (my_errno != HA_ERR_FOUND_DUPP_KEY || key3[n3] == 0)
  145.       {
  146. printf("Error: %d in write at record: %dn",my_errno,i);
  147. goto err;
  148.       }
  149.       if (verbose) printf("   Double key: %dn",n3);
  150.     }
  151.     else
  152.     {
  153.       if (key3[n3] == 1)
  154.       {
  155. printf("Error: Didn't get error when writing second key: '%8d'n",n3);
  156. goto err;
  157.       }
  158.       write_count++; key1[n1]++; key3[n3]=1;
  159.       key_check+=n1;
  160.     }
  161.     if (testflag == 1 && heap_check_heap(file,0))
  162.     {
  163.       puts("Heap keys crashed");
  164.       goto err;
  165.     }
  166.   }
  167.   if (testflag == 1)
  168.     goto end;
  169.   if (heap_check_heap(file,0))
  170.   {
  171.     puts("Heap keys crashed");
  172.     goto err;
  173.   }
  175.   printf("- Deleten");
  176.   for (i=0 ; i < write_count/10 ; i++)
  177.   {
  178.     for (j=rnd(1000)+1 ; j>0 && key1[j] == 0 ; j--) ;
  179.     if (j != 0)
  180.     {
  181.       sprintf(key,"%6d",j);
  182.       if (heap_rkey(file,record,0,key,6, HA_READ_KEY_EXACT))
  183.       {
  184. printf("can't find key1: "%s"n",key);
  185. goto err;
  186.       }
  187. #ifdef NOT_USED
  188.       if (file->current_ptr == hp_find_block(&file->s->block,0) ||
  189.   file->current_ptr == hp_find_block(&file->s->block,1))
  190. continue; /* Don't remove 2 first records */
  191. #endif
  192.       if (heap_delete(file,record))
  193.       {
  194. printf("error: %d; can't delete record: "%s"n", my_errno,record);
  195. goto err;
  196.       }
  197.       opt_delete++;
  198.       key1[atoi(record+keyinfo[0].seg[0].start)]--;
  199.       key3[atoi(record+keyinfo[2].seg[0].start)]=0;
  200.       key_check-=atoi(record);
  201.       if (testflag == 2 && heap_check_heap(file,0))
  202.       {
  203. puts("Heap keys crashed");
  204. goto err;
  205.       }
  206.     }
  207.     else
  208.       puts("Warning: Skipping delete test because no dupplicate keys");
  209.   }
  210.   if (testflag==2) goto end;
  211.   if (heap_check_heap(file,0))
  212.   {
  213.     puts("Heap keys crashed");
  214.     goto err;
  215.   }
  217.   printf("- Updaten");
  218.   for (i=0 ; i < write_count/10 ; i++)
  219.   {
  220.     n1=rnd(1000); n2=rnd(100); n3=rnd(min(recant*2,MAX_RECORDS));
  221.     make_record(record2, n1, n2, n3, "XXX", update);
  222.     if (rnd(2) == 1)
  223.     {
  224.       if (heap_scan_init(file))
  225. goto err;
  226.       j=rnd(write_count-opt_delete);
  227.       while ((error=heap_scan(file,record) == HA_ERR_RECORD_DELETED) ||
  228.      (!error && j))
  229.       {
  230. if (!error)
  231.   j--;
  232.       }
  233.       if (error)
  234. goto err;
  235.     }
  236.     else
  237.     {
  238.       for (j=rnd(1000)+1 ; j>0 && key1[j] == 0 ; j--) ;
  239.       if (!key1[j])
  240. continue;
  241.       sprintf(key,"%6d",j);
  242.       if (heap_rkey(file,record,0,key,6, HA_READ_KEY_EXACT))
  243.       {
  244. printf("can't find key1: "%s"n",key);
  245. goto err;
  246.       }
  247.     }
  248.     if (heap_update(file,record,record2))
  249.     {
  250.       if (my_errno != HA_ERR_FOUND_DUPP_KEY || key3[n3] == 0)
  251.       {
  252. printf("error: %d; can't update:nFrom: "%s"nTo:   "%s"n",
  253.        my_errno,record,record2);
  254. goto err;
  255.       }
  256.       if (verbose)
  257. printf("Double key when tried to update:nFrom: "%s"nTo:   "%s"n",record,record2);
  258.     }
  259.     else
  260.     {
  261.       key1[atoi(record+keyinfo[0].seg[0].start)]--;
  262.       key3[atoi(record+keyinfo[2].seg[0].start)]=0;
  263.       key1[n1]++; key3[n3]=1;
  264.       update++;
  265.       key_check=key_check-atoi(record)+n1;
  266.     }
  267.     if (testflag == 3 && heap_check_heap(file,0))
  268.     {
  269.       puts("Heap keys crashed");
  270.       goto err;
  271.     }
  272.   }
  273.   if (testflag == 3) goto end;
  274.   if (heap_check_heap(file,0))
  275.   {
  276.     puts("Heap keys crashed");
  277.     goto err;
  278.   }
  280.   for (i=999, dupp_keys=found_key=0 ; i>0 ; i--)
  281.   {
  282.     if (key1[i] > dupp_keys) { dupp_keys=key1[i]; found_key=i; }
  283.     sprintf(key,"%6d",found_key);
  284.   }
  286.   if (dupp_keys > 3)
  287.   {
  288.     if (!silent)
  289.       printf("- Read first key - next - delete - next -> lastn");
  290.     DBUG_PRINT("progpos",("first - next - delete - next -> last"));
  292.     if (heap_rkey(file,record,0,key,6, HA_READ_KEY_EXACT))
  293.       goto err;
  294.     if (heap_rnext(file,record3)) goto err;
  295.     if (heap_delete(file,record3)) goto err;
  296.     key_check-=atoi(record3);
  297.     key1[atoi(record+keyinfo[0].seg[0].start)]--;
  298.     key3[atoi(record+keyinfo[2].seg[0].start)]=0;
  299.     opt_delete++;
  300.     ant=2;
  301.     while ((error=heap_rnext(file,record3)) == 0 ||
  302.    error == HA_ERR_RECORD_DELETED)
  303.       if (! error)
  304. ant++;
  305.     if (ant != dupp_keys)
  306.     {
  307.       printf("next: I can only find: %d records of %dn",
  308.      ant,dupp_keys);
  309.       goto end;
  310.     }
  311.     dupp_keys--;
  312.     if (heap_check_heap(file,0))
  313.     {
  314.       puts("Heap keys crashed");
  315.       goto err;
  316.     }
  318.     if (!silent)
  319.       printf("- Read last key - delete - prev - prev - opt_delete - prev -> firstn");
  321.     if (heap_rlast(file,record3,0)) goto err;
  322.     if (heap_delete(file,record3)) goto err;
  323.     key_check-=atoi(record3);
  324.     key1[atoi(record+keyinfo[0].seg[0].start)]--;
  325.     key3[atoi(record+keyinfo[2].seg[0].start)]=0;
  326.     opt_delete++;
  327.     if (heap_rprev(file,record3) || heap_rprev(file,record3))
  328.       goto err;
  329.     if (heap_delete(file,record3)) goto err;
  330.     key_check-=atoi(record3);
  331.     key1[atoi(record+keyinfo[0].seg[0].start)]--;
  332.     key3[atoi(record+keyinfo[2].seg[0].start)]=0;
  333.     opt_delete++;
  334.     ant=3;
  335.     while ((error=heap_rprev(file,record3)) == 0 ||
  336.    error == HA_ERR_RECORD_DELETED)
  337.     {
  338.       if (! error)
  339. ant++;
  340.     }
  341.     if (ant != dupp_keys)
  342.     {
  343.       printf("next: I can only find: %d records of %dn",
  344.      ant,dupp_keys);
  345.       goto end;
  346.     }
  347.     dupp_keys-=2;
  348.     if (heap_check_heap(file,0))
  349.     {
  350.       puts("Heap keys crashed");
  351.       goto err;
  352.     }
  353.   }
  354.   else
  355.     puts("Warning: Not enough duplicated keys:  Skipping delete key check");
  357.   if (!silent)
  358.     printf("- Read (first) - next - delete - next -> lastn");
  359.   DBUG_PRINT("progpos",("first - next - delete - next -> last"));
  361.   if (heap_scan_init(file))
  362.     goto err;
  363.   while ((error=heap_scan(file,record3) == HA_ERR_RECORD_DELETED)) ;
  364.   if (error)
  365.     goto err;
  366.   if (heap_delete(file,record3)) goto err;
  367.   key_check-=atoi(record3);
  368.   opt_delete++;
  369.   key1[atoi(record+keyinfo[0].seg[0].start)]--;
  370.   key3[atoi(record+keyinfo[2].seg[0].start)]=0;
  371.   ant=0;
  372.   while ((error=heap_scan(file,record3)) == 0 ||
  373.  error == HA_ERR_RECORD_DELETED)
  374.     if (! error)
  375.       ant++;
  376.   if (ant != write_count-opt_delete)
  377.   {
  378.     printf("next: Found: %d records of %dn",ant,write_count-opt_delete);
  379.     goto end;
  380.   }
  381.   if (heap_check_heap(file,0))
  382.   {
  383.     puts("Heap keys crashed");
  384.     goto err;
  385.   }
  387.   puts("- Test if: Read rrnd - same - rkey - same");
  388.   DBUG_PRINT("progpos",("Read rrnd - same"));
  389.   pos=rnd(write_count-opt_delete-5)+5;
  390.   heap_scan_init(file);
  391.   i=5;
  392.   while ((error=heap_scan(file,record)) == HA_ERR_RECORD_DELETED ||
  393.  (error == 0 && pos))
  394.   {
  395.     if (!error)
  396.       pos--;
  397.     if (i-- == 0)
  398.     {
  399.       bmove(record3,record,reclength);
  400.       position=heap_position(file);
  401.     }
  402.   }
  403.   if (error)
  404.     goto err;
  405.   bmove(record2,record,reclength);
  406.   if (heap_rsame(file,record,-1) || heap_rsame(file,record2,2))
  407.     goto err;
  408.   if (bcmp(record2,record,reclength))
  409.   {
  410.     puts("heap_rsame didn't find right record");
  411.     goto end;
  412.   }
  414.   puts("- Test of read through position");
  415.   if (heap_rrnd(file,record,position))
  416.     goto err;
  417.   if (bcmp(record3,record,reclength))
  418.   {
  419.     puts("heap_frnd didn't find right record");
  420.     goto end;
  421.   }
  423.   printf("- heap_infon");
  424.   {
  425.     HEAPINFO info;
  426.     heap_info(file,&info,0);
  427.     /* We have to test with opt_delete +1 as this may be the case if the last
  428.        inserted row was a duplicate key */
  429.     if (info.records != write_count-opt_delete ||
  430. (info.deleted != opt_delete && info.deleted != opt_delete+1))
  431.     {
  432.       puts("Wrong info from heap_info");
  433.       printf("Got: records: %ld(%d)  deleted: %ld(%d)n",
  434.      info.records,write_count-opt_delete,info.deleted,opt_delete);
  435.     }
  436.   }
  438. #ifdef OLD_HEAP_VERSION
  439.   {
  440.     uint check;
  441.     printf("- Read through all records with rndn");
  442.     if (heap_extra(file,HA_EXTRA_RESET) || heap_extra(file,HA_EXTRA_CACHE))
  443.     {
  444.       puts("got error from heap_extra");
  445.       goto end;
  446.     }
  447.     ant=check=0;
  448.     while ((error=heap_rrnd(file,record,(ulong) -1)) != HA_ERR_END_OF_FILE &&
  449.    ant < write_count + 10)
  450.     {
  451.       if (!error)
  452.       {
  453. ant++;
  454. check+=calc_check(record,reclength);
  455.       }
  456.     }
  457.     if (ant != write_count-opt_delete)
  458.     {
  459.       printf("rrnd: I can only find: %d records of %dn", ant,
  460.      write_count-opt_delete);
  461.       goto end;
  462.     }
  463.     if (heap_extra(file,HA_EXTRA_NO_CACHE))
  464.     {
  465.       puts("got error from heap_extra(HA_EXTRA_NO_CACHE)");
  466.       goto end;
  467.     }
  468.   }
  469. #endif
  471.   printf("- Read through all records with scann");
  472.   if (heap_extra(file,HA_EXTRA_RESET) || heap_extra(file,HA_EXTRA_CACHE))
  473.   {
  474.     puts("got error from heap_extra");
  475.     goto end;
  476.   }
  477.   ant=check2=0;
  478.   heap_scan_init(file);
  479.   while ((error=heap_scan(file,record)) != HA_ERR_END_OF_FILE &&
  480.  ant < write_count + 10)
  481.   {
  482.     if (!error)
  483.     {
  484.       ant++;
  485.       check2+=calc_check(record,reclength);
  486.     }
  487.   }
  488.   if (ant != write_count-opt_delete)
  489.   {
  490.     printf("scan: I can only find: %d records of %dn", ant,
  491.    write_count-opt_delete);
  492.     goto end;
  493.   }
  494. #ifdef OLD_HEAP_VERSION
  495.   if (check != check2)
  496.   {
  497.     puts("scan: Checksum didn't match reading with rrnd");
  498.     goto end;
  499.   }
  500. #endif
  503.   if (heap_extra(file,HA_EXTRA_NO_CACHE))
  504.   {
  505.     puts("got error from heap_extra(HA_EXTRA_NO_CACHE)");
  506.     goto end;
  507.   }
  509.   for (i=999, dupp_keys=found_key=0 ; i>0 ; i--)
  510.   {
  511.     if (key1[i] > dupp_keys) { dupp_keys=key1[i]; found_key=i; }
  512.     sprintf(key,"%6d",found_key);
  513.   }
  514.   printf("- Read through all keys with first-next-last-prevn");
  515.   ant=0;
  516.   for (error=heap_rkey(file,record,0,key,6, HA_READ_KEY_EXACT);
  517.       ! error ;
  518.        error=heap_rnext(file,record))
  519.     ant++;
  520.   if (ant != dupp_keys)
  521.   {
  522.     printf("first-next: I can only find: %d records of %dn", ant,
  523.    dupp_keys);
  524.     goto end;
  525.   }
  527.   ant=0;
  528.   for (error=heap_rlast(file,record,0) ;
  529.       ! error ;
  530.       error=heap_rprev(file,record))
  531.   {
  532.     ant++;
  533.     check2+=calc_check(record,reclength);
  534.   }
  535.   if (ant != dupp_keys)
  536.   {
  537.     printf("last-prev: I can only find: %d records of %dn", ant,
  538.    dupp_keys);
  539.     goto end;
  540.   }
  542.   if (testflag == 4) goto end;
  544.   printf("- Reading through all rows through keysn");
  545.   if (!(file2=heap_open(filename, 2)))
  546.     goto err;
  547.   if (heap_scan_init(file))
  548.     goto err;
  549.   while ((error=heap_scan(file,record)) != HA_ERR_END_OF_FILE)
  550.   {
  551.     if (error == 0)
  552.     {
  553.       if (heap_rkey(file2,record2,2,record+keyinfo[2].seg[0].start,8,
  554.     HA_READ_KEY_EXACT))
  555.       {
  556. printf("can't find key3: "%.8s"n",
  557.        record+keyinfo[2].seg[0].start);
  558. goto err;
  559.       }
  560.     }
  561.   }
  562.   heap_close(file2);
  564.   printf("- Creating output heap-file 2n");
  565.   if (heap_create(filename2,1,keyinfo,reclength,0L,0L,&hp_create_info) ||
  566.       !(file2= heap_open(filename2, 2)))
  567.     goto err;
  569.   printf("- Copying and removing recordsn");
  570.   if (heap_scan_init(file))
  571.     goto err;
  572.   while ((error=heap_scan(file,record)) != HA_ERR_END_OF_FILE)
  573.   {
  574.     if (error == 0)
  575.     {
  576.       if (heap_write(file2,record))
  577. goto err;
  578.       key_check-=atoi(record);
  579.       write_count++;
  580.       if (heap_delete(file,record))
  581. goto err;
  582.       opt_delete++;
  583.     }
  584.     pos++;
  585.   }
  586.   printf("- Checking heap tablesn");
  587.   if (heap_check_heap(file,1) || heap_check_heap(file2,1))
  588.   {
  589.     puts("Heap keys crashed");
  590.     goto err;
  591.   }
  593.   if (my_errno != HA_ERR_END_OF_FILE)
  594.     printf("error: %d from heap_rrndn",my_errno);
  595.   if (key_check)
  596.     printf("error: Some read got wrong: check is %ldn",(long) key_check);
  598. end:
  599.   printf("nFollowing test have been made:n");
  600.   printf("Write records: %dnUpdate records: %dnDelete records: %dn", write_count,update,opt_delete);
  601.   heap_clear(file);
  602.   if (heap_close(file) || (file2 && heap_close(file2)))
  603.     goto err;
  604.   heap_delete_table(filename2);
  605.   heap_panic(HA_PANIC_CLOSE);
  606.   my_end(MY_GIVE_INFO);
  607.   return(0);
  608. err:
  609.   printf("Got error: %d when using heap-databasen",my_errno);
  610.   VOID(heap_close(file));
  611.   return(1);
  612. } /* main */
  615. /* Read options */
  617. static int get_options(int argc,char *argv[])
  618. {
  619.   char *pos,*progname;
  620.   DEBUGGER_OFF;
  622.   progname= argv[0];
  624.   while (--argc >0 && *(pos = *(++argv)) == '-' ) {
  625.     switch(*++pos) {
  626.     case 'B': /* Big file */
  627.       flag=1;
  628.       break;
  629.     case 'v': /* verbose */
  630.       verbose=1;
  631.       break;
  632.     case 'm': /* records */
  633.       recant=atoi(++pos);
  634.       break;
  635.     case 's':
  636.       silent=1;
  637.       break;
  638.     case 't':
  639.       testflag=atoi(++pos); /* testmod */
  640.       break;
  641.     case 'V':
  642.     case 'I':
  643.     case '?':
  644.       printf("%s  Ver 1.1 for %s at %sn",progname,SYSTEM_TYPE,MACHINE_TYPE);
  645.       puts("TCX Datakonsult AB, by Monty, for your professional usen");
  646.       printf("Usage: %s [-?ABIKLsWv] [-m#] [-t#]n",progname);
  647.       exit(0);
  648.     case '#':
  649.       DEBUGGER_ON;
  650.       DBUG_PUSH (++pos);
  651.       break;
  652.     }
  653.   }
  654.   return 0;
  655. } /* get options */
  657. /* Generate a random value in intervall 0 <=x <= n */
  659. static int rnd(int max_value)
  660. {
  661.   return (int) ((rand() & 32767)/32767.0*max_value);
  662. } /* rnd */
  665. static sig_handler endprog(int sig_number __attribute__((unused)))
  666. {
  667. #ifndef THREAD
  668.   if (my_dont_interrupt)
  669.     my_remember_signal(sig_number,endprog);
  670.   else
  671. #endif
  672.   {
  673.     heap_panic(HA_PANIC_CLOSE);
  674.     my_end(1);
  675.     exit(1);
  676.   }
  677. }
  679. static int calc_check(byte *buf, uint length)
  680. {
  681.   int check=0;
  682.   while (length--)
  683.     check+= (int) (uchar) *(buf++);
  684.   return check;
  685. }
  687. static void make_record(char *record, uint n1, uint n2, uint n3,
  688. const char *mark, uint count)
  689. {
  690.   bfill(record,reclength,' ');
  691.   sprintf(record,"%6d:%4d:%8d:%3.3s: %4d",
  692.   n1,n2,n3,mark,count);
  693.   record[37]='A'; /* Store A in null key */
  694.   record[38]=1; /* set as null */
  695. }