home *** CD-ROM | disk | FTP | other *** search
/ Shareware 1 2 the Maxx / sw_1.zip / sw_1 / UTILS / SPLITIT.ZIP / SPLITIT.C < prev    next >
Text File  |  1992-03-21  |  31KB  |  1,193 lines
  1. /* Splitit by Bill Buckels 1992 */
  2. /* Written in MIX POWER C       */
  3. /* LARGE memory MODEL           */
  4.  
  5. /* a binary file splitter. */
  6. /* note that this utility can create damage if used improperly   */
  7.  
  8. /* January 1992 */
  9. /* I have taken what I consider reasonable precautions and since */
  10. /* I really must get on with life I have deemed this utility     */
  11. /* fit for use by a careful public. */
  12.  
  13. /* February 1992 */
  14. /* The speed of reading and writing Binary Files byte by byte is */
  15. /* unacceptable and is therefore changed. */
  16.  
  17. #include <stdio.h>
  18. #include <string.h>
  19. #include <dos.h>
  20. #include <bios.h>
  21. #include <conio.h>
  22. #include <direct.h>
  23. #include <fcntl.h>
  24. #include <malloc.h>
  25. #include <io.h>
  26. #include <stdlib.h>
  27.  
  28.  
  29. /* a group of handy definitions */
  30.  
  31. #define BLACK   0
  32. #define BLUE    1
  33. #define GREEN   2
  34. #define CYAN    3
  35. #define RED     4
  36. #define MAGENTA 5
  37. #define BROWN   6
  38. #define WHITE   7
  39. #define GRAY      8
  40. #define LBLUE     9
  41. #define LGREEN    10
  42. #define LCYAN     11
  43. #define LRED      12
  44. #define LMAGENTA  13
  45. #define YELLOW    14
  46. #define BWHITE    15
  47.  
  48. #define ESCAPE  '\x1b'
  49. #define CGA  3
  50. #define HERCULES 99
  51.  
  52. int ADAPTER = CGA;
  53.  
  54. #define BLANK     32
  55. #define FAT       219
  56.  
  57.  
  58. #define ENTERKEY   '\x0d' /* character generated by the Enter Key          */
  59. #define ESCKEY     '\x1b' /* character generated by the Esc key            */
  60. #define FUNCKEY    '\x00' /* first character generated by function keys    */
  61. #define UPARROW    'H'    /* second character generated by up-arrow key    */
  62. #define DOWNARROW  'P'    /* second character generated by down-arrow key  */
  63. #define LTARROW    'K'    /* second character generated by left-arrow key  */
  64. #define RTARROW    'M'    /* second character generated by right-arrow key */
  65. #define PGUP       'I'    /* second character generated by page up key     */
  66. #define PGDOWN     'Q'    /* second character generated by page down key   */
  67.  
  68. /* starting at character 59*/
  69. #define F1         ';'    /* second character generated by fkeys */
  70. #define F2         '<'
  71. #define F3         '='
  72. #define F4         '>'
  73. #define F5         '?'
  74. #define F6         '@'
  75. #define F7         'A'
  76. #define F8         'B'
  77. #define F9         'C'
  78. #define F10        'D'
  79. /* ending at character 68  */
  80.  
  81. #define CRETURN '\x0d'
  82. #define LFEED   '\x0A'
  83. #define CTRLZ   '\x1a'
  84. #define DELETE  '\x7f'
  85.  
  86. #define SINGLE    218
  87. #define DOUBLE    201
  88.  
  89. char wildfiles[300][15];
  90.  
  91. int filecords[84][2]=
  92. {
  93.     2,  4,  2,  23,  2, 42,  2, 61,
  94.     3,  4,  3,  23,  3, 42,  3, 61,
  95.     4,  4,  4,  23,  4, 42,  4, 61,
  96.     5,  4,  5,  23,  5, 42,  5, 61,
  97.     6,  4,  6,  23,  6, 42,  6, 61,
  98.     7,  4,  7,  23,  7, 42,  7, 61,
  99.     8,  4,  8,  23,  8, 42,  8, 61,
  100.     9,  4,  9,  23,  9, 42,  9, 61,
  101.     10, 4, 10,  23, 10, 42, 10, 61,
  102.     11, 4, 11,  23, 11, 42, 11, 61,
  103.     12, 4, 12,  23, 12, 42, 12, 61,
  104.     13, 4, 13,  23, 13, 42, 13, 61,
  105.     14, 4, 14,  23, 14, 42, 14, 61,
  106.     15, 4, 15,  23, 15, 42, 15, 61,
  107.     16, 4, 16,  23, 16, 42, 16, 61,
  108.     17, 4, 17,  23, 17, 42, 17, 61,
  109.     18, 4, 18,  23, 18, 42, 18, 61,
  110.     19, 4, 19,  23, 19, 42, 19, 61,
  111.     20, 4, 20,  23, 20, 42, 20, 61,
  112.     21, 4, 21,  23, 21, 42, 21, 61,
  113.     22, 4, 22,  23, 22, 42, 22, 61};
  114.  
  115.  
  116. int getfiles(char *filetype)
  117. {
  118.  
  119.     char buffer[15];
  120.     int wildcounter=0;
  121.  
  122.     struct ffblk wild_card;
  123.  
  124.     memset(wildfiles,0,sizeof(wildfiles));
  125.     sprintf(buffer,"*.%s",filetype);
  126.  
  127.     if(findfirst(buffer,&wild_card,FA_NORMAL)==0)
  128.     {
  129.         strcpy(wildfiles[wildcounter],wild_card.ff_name);
  130.         wildcounter++;
  131.  
  132.     while(findnext(&wild_card)==0){
  133.            if(wildcounter<300)
  134.            {
  135.            strcpy(wildfiles[wildcounter],wild_card.ff_name);
  136.            wildcounter++;
  137.            }
  138.            }
  139.            }
  140.            if(wildcounter>1)qsort(wildfiles,wildcounter,15,strcmp);
  141. return wildcounter;
  142. }
  143.  
  144.  
  145. void cursoroff(void)
  146. {
  147.    union REGS regs;
  148.  
  149.    regs.h.ah = 0x01;
  150.    regs.x.cx = 0x2000;
  151.    int86(0x10,®s,®s);
  152. }
  153.  
  154.  
  155.  
  156. void cursoron(void)
  157. {
  158.    union REGS regs;
  159.  
  160.    regs.h.ah = 0x01;
  161.    regs.x.cx = 0x0607;
  162.    int86(0x10,®s,®s);
  163. }
  164.  
  165.  
  166. void cls(int BACK,int FRONT)
  167. {
  168.     union REGS reg;
  169.  
  170.     reg.h.ah = 6;
  171.     reg.h.al = 0;
  172.     reg.h.ch = 0;
  173.     reg.h.cl = 0;
  174.     reg.h.dh = 24;
  175.     reg.h.dl = 79;
  176.     reg.h.bh = (BACK << 4) + FRONT;
  177.     int86(0x10, ®, ®);
  178. }
  179.  
  180.  
  181. void DMC(int Row, int Column, unsigned BYTE, int BACK, int FRONT, int QUANT)
  182. {
  183.     /*  DMA replacement for writechs function */
  184.  
  185.     unsigned segment= 0xB000, offset;
  186.     int One_Too_Many = (QUANT+1);
  187.     int i, Attribute;
  188.  
  189.     Attribute = (BACK << 4) + FRONT;
  190.  
  191.     if(ADAPTER!=HERCULES)segment = 0xB800;    /* CGA or Equivalent */
  192.     offset = 160 * Row + 2 * Column ;
  193.     for (i=1; i< One_Too_Many ; i++){
  194.         poke(segment,offset, BYTE|Attribute<<8);
  195.         offset+=2;
  196.         }
  197. }
  198.  
  199.  
  200. void DMM(char *String, int Row, int Column, int BACK, int FRONT)
  201. {
  202.     /*  DMA replacement for puts
  203.         centre justified string    */
  204.  
  205.     unsigned Character, segment=0xB000, offset;
  206.     int Attribute;
  207.  
  208.     Attribute = (BACK << 4) + FRONT;
  209.  
  210.     Column =   ((Column+1)-(.5*(strlen(String))));
  211.  
  212.     if(ADAPTER != HERCULES)segment = 0xB800;    /* CGA or Equivalent */
  213.     offset = 160 * Row + 2 * Column ;
  214.     while ((Character = *String++)!=0){
  215.         if(Character!='\n'){
  216.         poke(segment,offset,Character|Attribute<<8);
  217.         offset+=2;
  218.         }
  219.         }
  220. }
  221.  
  222.  
  223. void DML(char *String, int Row, int Column, int BACK, int FRONT)
  224. {
  225.     /*  DMA replacement for puts
  226.         left justified string    */
  227.     unsigned Character, segment=0xB000, offset;
  228.     int Attribute;
  229.  
  230.     Attribute = (BACK << 4) + FRONT;
  231.  
  232.     if(ADAPTER!=HERCULES)segment = 0xB800; /* CGA or Equivalent */
  233.     offset = 160 * Row + 2 * Column ;
  234.     while ((Character = *String++)!=0){
  235.         if(Character!='\n'){
  236.         poke(segment,offset, Character|Attribute<<8);
  237.         offset +=2;
  238.         }
  239.     }
  240. }
  241.  
  242.  
  243. void BORDERBOX(int *cor,int fore, int bk,unsigned char BRDR)
  244. {
  245.  
  246. int trow=cor[0],tcol=cor[1],brow=cor[2],bcol=cor[3];
  247.     /* draws an outline only using a specified border character */
  248. int index;
  249. int homerow = (brow-1);
  250. int homecol = (tcol+1);
  251. int linelength = ((bcol) - (tcol+1));
  252.  
  253. int TLcorner,TRcorner,BLcorner,BRcorner,HORT,VERT;
  254.  
  255.           switch(BRDR){
  256.                case DOUBLE: {
  257.                             TLcorner = 201;
  258.                             TRcorner = 187;
  259.                             BLcorner = 200;
  260.                             BRcorner = 188;
  261.                             HORT = 205;
  262.                             VERT = 186;
  263.                             break;
  264.                         }
  265.                case SINGLE: {
  266.                             TLcorner = 218;
  267.                             TRcorner = 191;
  268.                             BLcorner = 192;
  269.                             BRcorner = 217;
  270.                             HORT = 196;
  271.                             VERT = 179;
  272.                             break;
  273.                         }
  274.                default:    {
  275.                             TLcorner = BRDR;
  276.                             TRcorner = BRDR;
  277.                             BLcorner = BRDR;
  278.                             BRcorner = BRDR;
  279.                             HORT = BRDR;
  280.                             VERT = BRDR;
  281.                         }
  282.             }
  283.    DMC(trow,tcol,TLcorner,bk,fore,1);         /* top */
  284.    DMC(trow,homecol,HORT,bk,fore,linelength);
  285.    DMC(trow,bcol,TRcorner,bk,fore,1);
  286.    for (index = (trow+1); index < brow; index++){
  287.        DMC(index,tcol,VERT,bk,fore,1);
  288.        DMC(index,bcol,VERT,bk,fore,1);
  289.        }
  290.    DMC(brow,tcol,BLcorner,bk,fore,1);
  291.    DMC(brow,homecol,HORT,bk,fore,linelength);
  292.    DMC(brow,bcol,BRcorner,bk,fore,1);        /* bottom */
  293. }
  294.  
  295.  
  296.  
  297. void getadaptertype(void)
  298. {
  299.     if(((biosequip() >>4) &3) <3)ADAPTER=CGA;
  300.     else ADAPTER=HERCULES;
  301.  
  302. }
  303.  
  304.  
  305.  
  306.  
  307. int splitit(char *name,
  308.             unsigned long checksum,
  309.             unsigned long target,
  310.             unsigned status)
  311. {
  312.     int fh,fh2;
  313.     char infile[66];
  314.     char buf[66];
  315.     char *wordptr;
  316.     char far *inbuff;
  317.  
  318.     unsigned c;
  319.     unsigned long ctr=0l,count=0l;
  320.     unsigned fctr = 1;
  321.     unsigned packet, remainder;
  322.     unsigned tester;
  323.     int DONE=0,i;
  324.  
  325.  
  326.     /* if the file is being trimmed we use the difference between */
  327.     /* the totalsize and the target to make the adjusted target.  */
  328.  
  329.     if(status==1)target=(checksum-target);
  330.  
  331.    printf("\nNow Splitting %s\n",name);
  332.    printf("%ld Bytes Filesize\n",checksum);
  333.  
  334.    strcpy(infile,name);
  335.    wordptr=strtok(infile,". ");
  336.    sprintf(buf,"%s.%0003d",infile,fctr);
  337.  
  338.    fh=open(name,O_RDONLY|O_BINARY);
  339.    fh2=open(buf,O_CREAT|O_TRUNC|O_WRONLY|O_BINARY,S_IWRITE);
  340.  
  341.    inbuff=malloc(16384);
  342.  
  343.    packet= (unsigned)(target/16384);
  344.    remainder = (unsigned)(target%16384);
  345.  
  346.  
  347.    printf("\rNow Creating %s",buf);
  348.  
  349.    DONE=0;
  350.  
  351.  
  352.    while(!DONE)
  353.     {
  354.  
  355.      /* write the packets */
  356.      for(i=0;i<packet;i++)
  357.      {
  358.         if((tester=read(fh,inbuff,16384))!=16384)
  359.         {
  360.             DONE=packet;
  361.             i=packet;
  362.         }
  363.  
  364.         if(tester<= 16384 && tester >0)
  365.         {
  366.             write(fh2,inbuff,tester);
  367.             ctr+=tester;
  368.         }
  369.      }
  370.  
  371.      /* write the remainder */
  372.      if(!DONE && remainder!=0)
  373.      {
  374.  
  375.       if((tester=read(fh,inbuff,remainder))!=remainder)DONE=remainder;
  376.  
  377.       if(tester<= remainder && tester >0)
  378.         {
  379.             write(fh2,inbuff,tester);
  380.             ctr+=tester;
  381.         }
  382.       }
  383.  
  384.  
  385.     if(ctr==target)
  386.      {
  387.  
  388.      switch(status)
  389.      {
  390.        case 2 :ctr=0;
  391.        case 1 :
  392.        case 0 :
  393.                 close(fh2);
  394.                 fctr++;
  395.                 sprintf(buf,"%s.%0003d",infile,fctr);
  396.                 printf("\rNow Creating %s",buf);
  397.                 fh2=open(buf,O_CREAT|O_TRUNC|O_WRONLY|O_BINARY,S_IWRITE);
  398.  
  399.        }
  400.        }
  401.  
  402.     }
  403.  
  404.  
  405.     printf("\rAll Done!                  \n",count);
  406.     close(fh);
  407.     close(fh2);
  408.     if(ctr==0)remove(buf);
  409.     free(inbuff);
  410.     return 0;
  411.  
  412. }
  413.  
  414. int textsplit(FILE *fp,
  415.             char *name,
  416.             unsigned long checksum,
  417.             unsigned long target)
  418. {
  419.  
  420.  
  421.  
  422.     FILE *fp2;
  423.     char buf[66];
  424.     char *wordptr;
  425.     unsigned c;
  426.     unsigned long ctr=0l,count=0l;
  427.     unsigned fctr = 1;
  428.     char filebuf[514];
  429.  
  430.    printf("\nNow Splitting %s\n",name);
  431.    printf("%ld Bytes Filesize\n",checksum);
  432.  
  433.  
  434.    wordptr=strtok(name,". ");
  435.    sprintf(buf,"%s.%0003d",name,fctr);
  436.    fp2=fopen(buf,"w");
  437.  
  438.    printf("0            : Line Number");
  439.  
  440.    while(fgets(filebuf,512,fp)!=NULL)
  441.     {
  442.  
  443.      ctr+=strlen(filebuf);
  444.      count++;
  445.      fputs(filebuf,fp2);
  446.  
  447.      if(ctr>=target)
  448.      {
  449.        ctr=0l;
  450.        fclose(fp2);
  451.        fctr++;
  452.        sprintf(buf,"%s.%0003d",name,fctr);
  453.        fp2=fopen(buf,"w");
  454.        }
  455.  
  456.      printf("\r%ld",count);
  457.     }
  458.  
  459.  
  460.     printf("\r%ld\n",count);
  461.     fclose(fp);
  462.     fclose(fp2);
  463.     if(ctr==0)remove(buf);
  464.     return 0;
  465.  
  466. }
  467.  
  468.  
  469. int joinit( char *name)
  470. {
  471.  
  472.     int fh,fh2;
  473.  
  474.     char *inbuff;
  475.     char temp[66];
  476.     char buf[66];
  477.     char *wordptr;
  478.     unsigned numbytes;
  479.  
  480.     unsigned c;
  481.     unsigned long count=0l;
  482.     unsigned fctr = 1;
  483.  
  484.     if((fh=open(name,O_CREAT|O_TRUNC|O_WRONLY|O_BINARY,S_IWRITE))==-1)
  485.        {
  486.         perror(name);
  487.         return -1;
  488.         }
  489.  
  490.    inbuff=malloc(16384);
  491.  
  492.    printf("\nNow Joining %s\n",name);
  493.  
  494.  
  495.    strcpy(temp,name);
  496.  
  497.    wordptr=strtok(temp,". ");
  498.    sprintf(buf,"%s.%0003d",temp,fctr);
  499.  
  500.  
  501.    /* read files until there aren't any more */
  502.    while((fh2=open(buf,O_RDONLY|O_BINARY))!=-1)
  503.    {
  504.    while( (numbytes=read(fh2,inbuff,16384)) >0)
  505.     {
  506.      write(fh,inbuff,numbytes);
  507.      count+=numbytes;
  508.      }
  509.     fctr++;
  510.     close(fh2);
  511.     sprintf(buf,"%s.%0003d",temp,fctr);
  512.     }
  513.  
  514.     printf("\rDone !           \n");
  515.     close(fh);
  516.     if(count==0)remove(name);
  517.     free(inbuff);
  518.     return 0;
  519.  
  520. }
  521.  
  522.  
  523.  
  524.  
  525.  
  526.  
  527. /* the main stuff */
  528. char *mainchoices[]={
  529.      "  B - Behead a file      (Split)  ",
  530.      "  T - Trim   a file      (Split)  ",
  531.      "  C - Chunk  a BIN file  (Split)  ",
  532.      "  A - Chunk  a TEXT file (Split)  ",
  533.      "  J - Join   a file      (Join)   ",
  534.      "  L - List current directory      ",
  535.      "  K - Kill   a file      (Erase)  ",
  536.      NULL};
  537.  
  538. int displayfiles()
  539. {
  540.    int i,j;
  541.    int filecount = getfiles("*");
  542.    int lastcount=0;
  543.    char c;
  544.    int background = BLUE, foreground = LCYAN;
  545.    int cor[4];
  546.    char errorbuf[128];
  547.    char dirname[67];
  548.    char dirbuffer[128];
  549.  
  550.  
  551.    int breverse=RED,freverse=BWHITE;
  552.    if(ADAPTER==HERCULES){
  553.                          breverse=WHITE;
  554.                          freverse=BLACK;
  555.                          }
  556.  
  557.    if(filecount==0)return 0;
  558.  
  559.    getcwd(dirname,66);
  560.    sprintf(dirbuffer," All Files in %s ",dirname);
  561.  
  562.  
  563.    RESTART:;
  564.  
  565.    cls(background, foreground);
  566.  
  567.    cor[0]=0;
  568.    cor[1]=0;
  569.    cor[2]=24;
  570.    cor[3]=79;
  571.  
  572.    BORDERBOX(cor,foreground,background,DOUBLE);
  573.    DMC(0,1,1,background,foreground,78);
  574.    DMM(dirbuffer,0,40,background,BWHITE);
  575.  
  576.  
  577.    DMM(
  578.  " Use Page Up or Down To View * ESCape to Return To Main Menu ",
  579.    24,40,background,BWHITE);
  580.  
  581.    TOP:;
  582.  
  583.    j=0;
  584.    for(i=lastcount;i<(lastcount+84);i++)
  585.    {
  586.        /* blot the old files */
  587.      DML("            ",filecords[j][0],filecords[j][1],
  588.        background,foreground);
  589.      if(i<filecount)
  590.        DML(wildfiles[i],filecords[j][0],filecords[j][1],
  591.        background,foreground);
  592.        j++;
  593.  
  594.     }
  595.  
  596.    while((c=getch())!=ESCKEY)
  597.    {
  598.  
  599.         if(c==FUNCKEY)
  600.         {
  601.             c=getch();
  602.             switch(c)
  603.             {
  604.               /* don't go past the first file */
  605.               case PGUP     : if(lastcount==0)break;
  606.                               lastcount-=84;
  607.                               goto TOP;
  608.  
  609.               /* don't go past the last file */
  610.               case PGDOWN   : if(i>=filecount)break;
  611.                               lastcount+=84;
  612.                               goto TOP;
  613.               }
  614.             }
  615.  
  616.     }
  617.    return 0;
  618.  
  619. }
  620.  
  621.  
  622. int getfilename()
  623. {
  624.    int i,j,k;
  625.    int hotfile= 0;
  626.    int coldfile=0;
  627.    int filecount = getfiles("*");
  628.    int lastcount=0;
  629.    char c;
  630.    int background = BLUE, foreground = LCYAN;
  631.    int cor[4];
  632.    char errorbuf[128];
  633.    char dirname[67];
  634.    char dirbuffer[128];
  635.  
  636.    int breverse=RED,freverse=BWHITE;
  637.    if(ADAPTER==HERCULES){
  638.                          breverse=WHITE;
  639.                          freverse=BLACK;
  640.                          }
  641.  
  642.    if(filecount==0)return -1;
  643.  
  644.    getcwd(dirname,66);
  645.    sprintf(dirbuffer," All Files in %s ",dirname);
  646.  
  647.    RESTART:;
  648.  
  649.    cls(background, foreground);
  650.  
  651.    cor[0]=0;
  652.    cor[1]=0;
  653.    cor[2]=24;
  654.    cor[3]=79;
  655.  
  656.    BORDERBOX(cor,foreground,background,DOUBLE);
  657.    DMC(0,1,1,background,foreground,78);
  658.  
  659.  
  660.    DMM(dirbuffer,0,40,background,BWHITE);
  661.  
  662.    DMM(
  663.  " Page Up or Down To View * Arrows Select * Enter to Choose * ESC exit ",
  664.    24,40,background,BWHITE);
  665.  
  666.    TOP:;
  667.  
  668.    j=0;
  669.    for(i=lastcount;i<(lastcount+84);i++)
  670.    {
  671.        /* blot the old files */
  672.      DML("            ",filecords[j][0],filecords[j][1],
  673.        background,foreground);
  674.      if(i<filecount)
  675.        DML(wildfiles[i],filecords[j][0],filecords[j][1],
  676.        background,foreground);
  677.        j++;
  678.  
  679.     }
  680.     hotfile =lastcount;
  681.     coldfile=lastcount;
  682.     j=0;
  683.     k=0;
  684.     DML(wildfiles[hotfile],filecords[j][0],filecords[j][1],
  685.         breverse,freverse);
  686.  
  687.  
  688.    while((c=getch())!=ENTERKEY)
  689.    {
  690.  
  691.         if(c==ESCKEY)return -1;
  692.  
  693.         if(c==FUNCKEY)
  694.         {
  695.             c=getch();
  696.             switch(c)
  697.             {
  698.               case UPARROW  :
  699.                                if(j==0)break;
  700.  
  701.                                j--;
  702.                                hotfile--;
  703.                                if(j==0)break;
  704.  
  705.                                j--;
  706.                                hotfile--;
  707.                                if(j==0)break;
  708.  
  709.                                j--;
  710.                                hotfile--;
  711.  
  712.               case LTARROW:    if(j==0)break;
  713.  
  714.                                j--;
  715.                                hotfile--;
  716.                                break;
  717.  
  718.               case DOWNARROW:
  719.                                if(j==83)break;
  720.                                if(hotfile==(filecount-1))break;
  721.  
  722.                                j++;
  723.                                hotfile++;
  724.                                if(j==83)break;
  725.                                if(hotfile==(filecount-1))break;
  726.  
  727.                                j++;
  728.                                hotfile++;
  729.                                if(j==83)break;
  730.                                if(hotfile==(filecount-1))break;
  731.  
  732.  
  733.                                j++;
  734.                                hotfile++;
  735.  
  736.               case RTARROW:    if(j==83)break;
  737.                                if(hotfile==(filecount-1))break;
  738.  
  739.                                j++;
  740.                                hotfile++;
  741.                                break;
  742.  
  743.               /* don't go past the first file */
  744.               case PGUP     : if(lastcount==0)break;
  745.                               lastcount-=84;
  746.                               goto TOP;
  747.  
  748.               /* don't go past the last file */
  749.               case PGDOWN   : if(i>=filecount)break;
  750.                               lastcount+=84;
  751.                               goto TOP;
  752.               }
  753.  
  754.             if(hotfile!=coldfile)
  755.             {
  756.              DML(wildfiles[coldfile],filecords[k][0],filecords[k][1],
  757.                  background,foreground);
  758.              k=j;
  759.              coldfile=hotfile;
  760.              DML(wildfiles[coldfile],filecords[k][0],filecords[k][1],
  761.                  breverse,freverse);
  762.              }
  763.  
  764.             }
  765.  
  766.  
  767.     }
  768.    return hotfile;
  769.  
  770. }
  771.  
  772.  
  773.  
  774.  
  775.  
  776. int mainlocation[]={ 6,8,10,12,14,16,18};
  777. int mainlimit=7;
  778. int hotmain= 0;
  779. int coldmain=0;
  780.  
  781. char *help[]={
  782. "This program is distributed without Warranty or liability",
  783. "",
  784. "Split Files Into Two or more Parts. Headers or Footers may be removed    ",
  785. "using this method. Files may also be joined again using the Join Option. ",
  786. "Splitit Offers Both interactive and command line usage modes.            ",
  787. "The commandline mode which is covered below allows Splitit to be         ",
  788. "called from a batch file and perform its handiwork non-interactively.    ",
  789. "",
  790. "Commandline:  SPLITIT [command] ROOTNAME.EXT [checksum-bytes]            ",
  791. "B  Behead     remove [checksum] bytes from the beginning of the file.    ",
  792. "              2-files are created... [ROOTNAME].001 and [ROOTNAME].002.  ",
  793. "T  Trim       remove [checksum] bytes from the end of the file.          ",
  794. "              2-files are created... [ROOTNAME].001 and [ROOTNAME].002.  ",
  795. "C  Chunk      break file into pieces (multiple files) of [checksum] bytes",
  796. "   BINARY     starting with  file [ROOTNAME].001, [ROOTNAME].002, etc.   ",
  797. "A  Chunk      break a file into pieces of [checksum] bytes same as binary",
  798. "   ASCII      but do not split lines of text. Use for BBS Logfiles, etc. ",
  799. "J  Join       Join a file that was previously split into pieces          ",
  800. "              (multiple files) starting with  file [ROOTNAME].001.       ",
  801. "              The [checksum] is not required for this option.            ",
  802.  
  803. NULL};
  804.  
  805.  
  806.  
  807.  
  808. main(int argc, char **argv)
  809. {
  810.  
  811.     char c;
  812.     int i,col=40;
  813.     int cor[4];
  814.     int background = BLUE, foreground = LCYAN;
  815.     int breverse=RED,freverse=BWHITE;
  816.     char *bigbuff,*screen;
  817.     char *ptr;
  818.     FILE *fp;
  819.     char name[66],targetbuf[66];
  820.     unsigned long checksum;
  821.     unsigned long target;
  822.     int status;
  823.     char scratch[66];
  824.  
  825.     /* command line version goes here */
  826.  
  827.     if(argc>2)
  828.      {
  829.  
  830.        c=toupper(argv[1][0]);
  831.        switch(c)
  832.        {
  833.         case 'J':
  834.         case 'C':
  835.         case 'T':
  836.         case 'B':
  837.         case 'A':
  838.  
  839.                  puts(
  840.                  "\nSplitit(C) Version 2.0ß Copyright 1992 by Bill Buckels");
  841.                  strcpy(name,argv[2]);
  842.                  status=strlen(name)-3;
  843.  
  844.                  if(status>3)
  845.                  {
  846.                    ptr=(char *)&name[status];
  847.                    if(atoi(ptr)>0)
  848.                    {
  849.                     printf("numeric file extension %s not allowed.\n",ptr);
  850.                     puts(" have a nice dos!");
  851.                     exit(0);
  852.                     }
  853.  
  854.                  }
  855.  
  856.                  if(c=='J')
  857.                  {
  858.                    if((fp=fopen(name,"rb"))==NULL)joinit(name);
  859.                    else
  860.                    {
  861.                     fclose(fp);
  862.                     puts("cannot overwrite existing files");
  863.                     }
  864.                    puts(" have a nice dos!");
  865.                    exit(0);
  866.                  }
  867.  
  868.                 /* binary file open */
  869.                 if(c!='A')
  870.                  {
  871.                  if((fp=fopen(name,"rb"))==NULL)
  872.                  {
  873.                  perror(name);
  874.                  puts(" have a nice dos!");
  875.                  exit(0);
  876.                  }
  877.                  }
  878.  
  879.                  /* split a text file */
  880.                  if(c=='A')
  881.                  {
  882.                  if((fp=fopen(name,"r"))==NULL)
  883.                  {
  884.                  perror(name);
  885.                  puts(" have a nice dos!");
  886.                  exit(0);
  887.                  }
  888.                  }
  889.  
  890.                 checksum=(unsigned long) filelength(fileno(fp));
  891.                 strcpy(targetbuf,argv[3]);
  892.                 target=(unsigned long)atol(targetbuf);
  893.  
  894.                 if(target >= checksum || target<1)
  895.                 {
  896.                   fclose(fp);
  897.                   puts("Sorry... invalid number of bytes in split.");
  898.                   exit(0);
  899.                   }
  900.  
  901.                 if(c=='B')status=0;
  902.                 if(c=='T')status=1;
  903.                 if(c=='C')status=2;
  904.                 if(c=='A')status=4;
  905.  
  906.                 if(c!='A')
  907.                 {
  908.                     fclose(fp);
  909.                     splitit(name,checksum,target,status);
  910.  
  911.                 }
  912.                 if(c=='A')textsplit(fp,name,checksum,target);
  913.                 puts("\nDone!");
  914.                 puts(" have a nice dos!");
  915.                 exit(0);
  916.                 }
  917.             }
  918.  
  919.     cor[0]=0;
  920.     cor[1]=0;
  921.     cor[2]=21;
  922.     cor[3]=79;
  923.  
  924.  
  925.     getadaptertype();
  926.     cursoroff();
  927.     bigbuff=malloc(4000);
  928.  
  929.     if(ADAPTER==HERCULES){
  930.                          screen=(char far *)0xb0000000l;
  931.                          breverse=WHITE;
  932.                          freverse=BLACK;
  933.                          }
  934.    screen=(char far*)0xb8000000l;
  935.  
  936.     RESTART:;
  937.  
  938.     cls(background,foreground);
  939.     cor[0]=0;
  940.     cor[1]=0;
  941.     cor[2]=2;
  942.     cor[3]=79;
  943.     BORDERBOX(cor,BWHITE,background,SINGLE);
  944.     cor[0]=5;
  945.     cor[2]=19;
  946.     BORDERBOX(cor,foreground,background,DOUBLE);
  947.     cor[0]=21;
  948.     cor[2]=24;
  949.     BORDERBOX(cor,BWHITE,background,SINGLE);
  950.  
  951.    DMM("Splitit(C) Version 2.0ß Copyright 1992 by Bill Buckels",
  952.    1,40,background,BWHITE);
  953.    DMM(
  954.    " F1 For HELP * Use Arrows to Select and Press Enter * ESCape to Exit ",
  955.         20,40,background,foreground);
  956.    DMM("Splits, Joins, and Kills Files in The Current Directory",
  957.    3,40,background,foreground);
  958.    DMM("Use With Care! Damage can be Caused if Your Disk Is Full!",
  959.    4,40,background,foreground);
  960.  
  961.  
  962.    DMM("Produced by Bill Buckels * (204) 452- 2815",
  963.    22,40,background,BWHITE);
  964.    DMM("982 Hector Ave. * Winnipeg, Manitoba, Cdn * R3M 2G6",
  965.    23,40,background,BWHITE);
  966.  
  967.    for(i=0;i<mainlimit;i++)
  968.        DMM(mainchoices[i],mainlocation[i],col,
  969.        background,foreground);
  970.  
  971.  
  972.        strcpy(scratch,mainchoices[hotmain]);
  973.        scratch[0]='';
  974.        scratch[strlen(scratch)-1]='';
  975.        DMM(scratch,mainlocation[hotmain],col,
  976.        breverse,freverse);
  977.  
  978.    while((c=getch())!=ESCKEY)
  979.     {
  980.            if(c==ENTERKEY)
  981.            {
  982.             switch(hotmain)
  983.             {
  984.  
  985.                 case 6: if((status=getfilename())==-1)goto RESTART;
  986.                         strcpy(name,wildfiles[status]);
  987.                         remove(name);
  988.                         goto RESTART;
  989.  
  990.                 case 5: displayfiles();
  991.                          goto RESTART;
  992.  
  993.       case 4:    /* Join files */
  994.  
  995.                  cls(BLACK,BWHITE);
  996.                  cursoron();
  997.                  poscurs(0,0);
  998.  
  999.                  printf("Enter File Name : ");
  1000.                  gets(name);
  1001.                  status=strlen(name)-3;
  1002.  
  1003.                  if(status>3)
  1004.                  {
  1005.                    ptr=(char *)&name[status];
  1006.                    if(atoi(ptr)>0)
  1007.                    {
  1008.                     printf("numeric file extension %s not allowed. ",ptr);
  1009.                     printf("press a key...");
  1010.                     if(getch()==0)getch();
  1011.                     cursoroff();
  1012.                     goto RESTART;
  1013.                     }
  1014.  
  1015.                  }
  1016.  
  1017.                  if((fp=fopen(name,"rb"))!=NULL)
  1018.                  {
  1019.                   fclose(fp);
  1020.                   puts("Cannot overwrite existing files...");
  1021.                   printf("press a key...");
  1022.                   if(getch()==0)getch();
  1023.                   cursoroff();
  1024.                   goto RESTART;
  1025.                   }
  1026.                  joinit(name);
  1027.                  printf("press a key...");
  1028.                  if(getch()==0)getch();
  1029.                  cursoroff();
  1030.                  goto RESTART;
  1031.  
  1032.               /* finished joining files */
  1033.       case 3:
  1034.       case 2:
  1035.  
  1036.       case 1:
  1037.       case 0:    if((status=getfilename())==-1)goto RESTART;
  1038.                  strcpy(name,wildfiles[status]);
  1039.                  status=strlen(name)-3;
  1040.  
  1041.                  cls(BLACK,BWHITE);
  1042.                  cursoron();
  1043.                  poscurs(0,0);
  1044.  
  1045.                  if(status>3)
  1046.                  {
  1047.                    ptr=(char *)&name[status];
  1048.                    if(atoi(ptr)>0)
  1049.                    {
  1050.                     printf("numeric file extension %s not allowed. ",ptr);
  1051.                     printf("press a key...");
  1052.                     if(getch()==0)getch();
  1053.                     cursoroff();
  1054.                     goto RESTART;
  1055.                     }
  1056.  
  1057.                  }
  1058.  
  1059.  
  1060.                  if(hotmain!=3)
  1061.                  {
  1062.                  if((fp=fopen(name,"rb"))==NULL)
  1063.                  {
  1064.                  perror(name);
  1065.                  printf("press a key...");
  1066.                  if(getch()==0)getch();
  1067.                  cursoroff();
  1068.                  goto RESTART;
  1069.                  }
  1070.                  }
  1071.  
  1072.                  /* split a text file */
  1073.                  if(hotmain==3)
  1074.                  {
  1075.                  if((fp=fopen(name,"r"))==NULL)
  1076.                  {
  1077.                  perror(name);
  1078.                  printf("press a key...");
  1079.                  if(getch()==0)getch();
  1080.                  cursoroff();
  1081.                  goto RESTART;
  1082.                  }
  1083.                  }
  1084.  
  1085.  
  1086.  
  1087.                 checksum=(unsigned long) filelength(fileno(fp));
  1088.                 printf("File %s is %ld bytes long...\n",name,checksum);
  1089.  
  1090.                 printf("Split Where (How many bytes) ? : ");
  1091.                 gets(targetbuf);
  1092.  
  1093.                 target=(unsigned long)atol(targetbuf);
  1094.  
  1095.                 if(target >= checksum || target<1)
  1096.                 {
  1097.                   fclose(fp);
  1098.                   printf("Sorry... %ld does not compute! ",target);
  1099.                   printf("press a key...");
  1100.                   if(getch()==0)getch();
  1101.                   cursoroff();
  1102.                   goto RESTART;
  1103.                   }
  1104.  
  1105.                 if(hotmain!=3)
  1106.                 {
  1107.                     fclose(fp);
  1108.                     splitit(name,checksum,target,hotmain);
  1109.  
  1110.                 }
  1111.                 if(hotmain==3)textsplit(fp,name,checksum,target);
  1112.                 printf("press a key...");
  1113.                 if(getch()==0)getch();
  1114.                 cursoroff();
  1115.                 goto RESTART;
  1116.  
  1117.             }
  1118.  
  1119.            }
  1120.  
  1121.         if(c==FUNCKEY)
  1122.         {
  1123.             c=getch();
  1124.             switch(c)
  1125.             {
  1126.  
  1127.               case F1       : memcpy(bigbuff,screen,4000);
  1128.                               cls(background,foreground);
  1129.                               cor[0]=1;
  1130.                               cor[1]=0;
  1131.                               cor[2]=22;
  1132.                               cor[3]=79;
  1133.                               BORDERBOX(cor,foreground,background,DOUBLE);
  1134.                               cor[0]=2;
  1135.                               cor[1]=1;
  1136.                               cor[2]=21;
  1137.                               cor[3]=78;
  1138.  
  1139.                         DMM("Splitit(C) Version 2.0ß by Bill Buckels",
  1140.                              0,40,
  1141.                              background,foreground);
  1142.                         DMM("Leave Yourself Lots Of Disk Space To Work In",
  1143.                              23,40,
  1144.                              background,BWHITE);
  1145.                         DMM("Press Any Key To Return To The Menu ",
  1146.                              24,40,background,foreground);
  1147.  
  1148.                         for(i=0;help[i]!=NULL;i++)
  1149.                             DMM(help[i],i+2,40,background,BWHITE);
  1150.  
  1151.                             if(getch()==0)getch();
  1152.                             memcpy(screen,bigbuff,4000);
  1153.                             break;
  1154.  
  1155.  
  1156.               case DOWNARROW  :
  1157.                               if(hotmain<(mainlimit-1))
  1158.                               hotmain++;
  1159.                               break;
  1160.  
  1161.               case UPARROW  : if(hotmain==0)break;
  1162.                               hotmain--;
  1163.                               break;
  1164.               }
  1165.             }
  1166.               if(hotmain!=coldmain)
  1167.               {
  1168.                 DMM(mainchoices[coldmain],
  1169.                     mainlocation[coldmain],col,
  1170.                     background,foreground);
  1171.  
  1172.                 strcpy(scratch,mainchoices[hotmain]);
  1173.                 scratch[0]='';
  1174.                 scratch[strlen(scratch)-1]='';
  1175.                 DMM(scratch,mainlocation[hotmain],col,
  1176.                 breverse,freverse);
  1177.                     coldmain=hotmain;
  1178.                     }
  1179.                 }
  1180.  
  1181.  
  1182.     cursoron();
  1183.     poscurs(0,0);
  1184.     free(bigbuff);
  1185.     cls(BLACK,BWHITE);
  1186.     puts(" Have A Nice DOS!");
  1187.     exit(0);
  1188.  
  1189. }
  1190.  
  1191.  
  1192.  
  1193.