home *** CD-ROM | disk | FTP | other *** search
/ No Fragments Archive 12: Textmags & Docs / nf_archive_12.iso / MAGS / SOURCES / ATARI_SRC.ZIP / atari source / HDX_BACK / HDX302.ST / PART.BAK < prev    next >
Encoding:
Text File  |  2001-02-09  |  7.7 KB  |  398 lines
  1. /* part.c */
  2.  
  3.  
  4. /*
  5.  * 24-Nov-88    jye.     change and add codes so that can be used for MS-DOS
  6.  */
  7. #include "obdefs.h"
  8. #include "gemdefs.h"
  9. #include "osbind.h"
  10. #include "mydefs.h"
  11. #include "part.h"
  12. #include "bsl.h"
  13. #include "hdx.h"
  14. #include "addr.h"
  15.  
  16.  
  17. extern char sbuf[];
  18. extern int rebootp;
  19. extern int npart;
  20. extern int uplim;
  21. extern long bslsiz;
  22. extern long gbslsiz();
  23. extern int noinfo;        /* 1: no information inside the wincap */
  24.  
  25. /*
  26.  * Complain about partition error.
  27.  *
  28.  */
  29. parterr(devno)
  30. int devno;
  31. {
  32.     char *pdev="X";
  33.     
  34.     *pdev = devno + '0';
  35.     (cantpart[PTNDEV].ob_spec)->te_ptext = pdev;
  36.     cantpart[PTNERROK].ob_state = NORMAL;
  37.     execform(cantpart);
  38.     return ERROR;
  39. }
  40.  
  41.  
  42. /*
  43.  * Fill in partition entry with default information
  44.  * and configuration values from the current "pr" wincap entry.
  45.  *
  46.  */
  47. fillpart(n, part)
  48. int n;
  49. PART *part;
  50. {
  51.     long num;
  52.     char *partid;
  53.     char *idstr = "XX";
  54.     char *wgetstr();
  55.  
  56.     idstr[1] = n + '0';
  57.  
  58.     /* see if `pX' is mentioned */
  59.     *idstr = 'p';
  60.     if (wgetnum(idstr, &num) == OK)
  61.     {
  62.     /* do the ST partition assignment */
  63.         npart++;
  64.         part->p_siz = (LONG)(num / 512);
  65.            part->p_flg = P_EXISTS;
  66.         if (part->p_siz < MB16)    {
  67.             part->p_id[0] = 'G';
  68.             part->p_id[1] = 'E';
  69.             part->p_id[2] = 'M';
  70.         } else {
  71.             part->p_id[0] = 'B';
  72.             part->p_id[1] = 'G';
  73.             part->p_id[2] = 'M';
  74.         }
  75.     }
  76. }
  77.  
  78.  
  79. /* set the partition informations to the partition structures */
  80.  
  81. setpart(part, pnam, hsize)
  82. PART *part;
  83. char *pnam;
  84. long hsize;
  85. {
  86.     long onepart, remain;
  87.     int i;
  88.  
  89.     npart = 4;
  90.     if ((!noinfo) && (*pnam))     {
  91.         /* there is a partition scheme inside the wincap */
  92.         msetpart(part, pnam, hsize);
  93.         return OK;
  94.     }
  95.     onepart = hsize/4;
  96.     remain = (hsize - onepart * 4) / 4;
  97.     for ( i = 0; i < 4; i++, part++)    {
  98.         if (i == 4)    {
  99.             part->p_siz = hsize - (onepart + remain) * 3;
  100.         } else {
  101.             part->p_siz = onepart+remain;
  102.         }
  103.            part->p_flg = P_EXISTS;
  104.         if (part->p_siz < MB16)    {
  105.                part->p_id[0] = 'G';
  106.                part->p_id[1] = 'E';
  107.                part->p_id[2] = 'M';
  108.         } else {
  109.                part->p_id[0] = 'B';
  110.                part->p_id[1] = 'G';
  111.                part->p_id[2] = 'M';
  112.         }
  113.     }
  114. }
  115.  
  116. /* set the partition informations from the 'pname'.     */
  117. /* For example, pname = 12-12-14-14                        */        
  118.  
  119. msetpart(part, pname, hsize)
  120. PART *part;
  121. char *pname;
  122. long hsize;
  123. {
  124.     long part1, part2, part3, part4, remain;
  125.     int i, np;
  126.  
  127.     npart = 4;
  128.     np = 4;
  129.     convs2i(pname, &part1, 1);        /* 1: get first ASCII */
  130.     if (convs2i(pname, &part2, 2) == 1)        {        /* 2: get second ASCII */
  131.         /* only one partition */
  132.         part2 = 0;
  133.         part3 = 0;
  134.         part4 = 0;
  135.         np = 1;
  136.     } else if (convs2i(pname, &part3, 3) == 2)    {    /* 3: get third ASCII */
  137.         /* only two partitions */
  138.         part3 = 0;
  139.         part4 = 0;
  140.         np = 2;
  141.     } else if (convs2i(pname, &part4, 4) == 3)    {    /* 4: get fourth ASCII */
  142.         /* only three partitions */
  143.         part4 = 0;
  144.         np = 3;
  145.     }
  146.     remain = (hsize - (part1 + part2 + part3 + part4)) / np;
  147.     if (np == 1)    {
  148.         part1 = hsize;
  149.     } else if (np == 2)    {
  150.         part1 += remain;
  151.         part2 = hsize - part1;
  152.     } else if (np == 3)    {
  153.         part1 += remain;
  154.         part2 += remain;
  155.         part3 = hsize - part1 - part2;
  156.     } else {
  157.         part1 += remain;
  158.         part2 += remain;
  159.         part3 += remain;
  160.         part4 = hsize - part1 - part2 - part3;
  161.     }
  162.     for ( i = 0; i < 4; i++, part++)    {
  163.         switch(i)    {
  164.             case 0:    part->p_siz = part1;
  165.                     break;
  166.             case 1:    part->p_siz = part2;
  167.                     break;
  168.             case 2:    part->p_siz = part3;
  169.                     break;
  170.             case 3:    part->p_siz = part4;
  171.                     break;
  172.         }
  173.         if (!part->p_siz) continue;
  174.            part->p_flg = P_EXISTS;
  175.         if (part->p_siz < MB16)    {
  176.                part->p_id[0] = 'G';
  177.                part->p_id[1] = 'E';
  178.                part->p_id[2] = 'M';
  179.         } else {
  180.                part->p_id[0] = 'B';
  181.                part->p_id[1] = 'G';
  182.                part->p_id[2] = 'M';
  183.         }
  184.     }
  185. }
  186.  
  187.  
  188. /* conver the string 12-12-14-14 to a integer */
  189.  
  190. convs2i(pname, num, flag)
  191.  
  192. char *pname;
  193. long *num;
  194. int flag;        /* 1: conver the first one. 3: conver the third one */
  195.  
  196. {
  197.     char tem[10], *ptr;
  198.     int i;
  199.     UWORD n=0;
  200.  
  201.     ptr = pname;
  202.     for (i = 0; i < 10; i++)
  203.         tem[i] = "\0";
  204.  
  205.     if (flag == 2)    {    /* conver the second one of pname */
  206.         while ((*ptr != '-') && (*ptr))      ptr++;
  207.         if (!*ptr)  return 1;    /* only one partition */
  208.         ptr++;
  209.     } else if (flag == 3)    {    /* conver the third one of 12-12-14-14 */
  210.         while (*ptr != '-')     ptr++;
  211.         ptr++;
  212.         while ((*ptr != '-') && (*ptr))      ptr++;
  213.         if (!*ptr) return 2;        /* only two partitions */
  214.         ptr++;
  215.     } else if (flag == 4)    {
  216.         while (*ptr != '-')     ptr++;
  217.         ptr++;
  218.         while (*ptr != '-')     ptr++;
  219.         ptr++;
  220.         while ((*ptr != '-') && (*ptr))      ptr++;
  221.         if (!*ptr) return 3;        /* only three partitions */
  222.         ptr++;
  223.     }
  224.     /* copy the string into the buf */
  225.     for (i = 0; (*ptr != '-')&&(*ptr); )    {
  226.         tem[i++] = *ptr++;
  227.     }
  228.  
  229.     /* conver the string to integer */
  230.     for (i = 0; tem[i] >= '0' && tem[i] <= '9'; ++i)
  231.         n = 10 * n + (UWORD)(tem[i] - '0');
  232.  
  233.     *num = (long)n * 2048;
  234.     if (!n) return(flag - 1);
  235.     return OK;
  236. }
  237.  
  238.  
  239.  
  240. /* set the menu partition scheme */
  241.  
  242. setschm(dsize, partnames)
  243.  
  244. long dsize;
  245. char *partnames;
  246.  
  247. {
  248.     int part12;
  249.     int part34;
  250.     int i;
  251.  
  252.     for (i = 0; i < NAMSIZ; i++)    {
  253.         partnames[i] = '\0';
  254.     }
  255.     part34 = dsize/(2048*4) - 2;
  256.     part12 = part34 + 4;
  257.     for (i = 0; i < 4; i++)    {
  258.         if (!part34)        /* add the remainder into part12 */
  259.             part12 += (dsize/2048 - 2 * part12) / 2;
  260.         itoas(partnames, part12, 0);
  261.         itoas(partnames, part34, 1);
  262.         if (part34 == 1)    {        
  263.             part12++;         /* add the remainder into part12 */
  264.             part34 = 0;
  265.         } else {
  266.             part34 -= 2;
  267.             part12 += 2;
  268.         }
  269.         if (part34 < 0) break;
  270.     }
  271. }
  272.  
  273.  
  274. /* convert the integer into ASCII and store it into a buffer like    */
  275. /* 12-12 if the integer is 12                                         */
  276.  
  277. itoas(buf, num, flag)
  278. char *buf;
  279. int num;
  280. int flag;         /* 1: put second part of scheme. Now buf = 12-12\0 */
  281.  
  282. {
  283.     int i=0, j;
  284.     char tem[10];
  285.  
  286.     if (*buf)    { /* 12-12-14-14\010-10\0 inside the buf */
  287.     skp:
  288.         while (*buf)    buf++;
  289.         if ((!flag) || (*(buf+1)))     buf++;        /* skip between string */
  290.         if (*buf)     {
  291.             goto skp;
  292.         }
  293.         if (flag)    {    /* put second part of scheme */ 
  294.             *buf++ = '-';
  295.         }
  296.     } 
  297.     /* conver the integer to ASCII */
  298.     do    {    /* generate digits in reverse order */
  299.         tem[i++] = num % 10 + '0';        /* get next digits */
  300.     } while ((num /= 10) > 0);            /* delete it */
  301.  
  302.     j = i;
  303.     for (; i > 0; )    {    /* reverse string 'buf' in place */
  304.         *buf++ = tem[--i];
  305.     }
  306.     *buf++ = '-';
  307.     for (; j > 0; )    {    /* reverse string 'buf' in place */
  308.         *buf++ = tem[--j];
  309.     }
  310.     *buf++ = '\0';
  311. }
  312.  
  313.  
  314. /*
  315.  * Force checksum of sector image to a value
  316.  */
  317. forcesum(image, sum)
  318. UWORD *image;
  319. UWORD sum;
  320. {
  321.     register int i;
  322.     register UWORD w;
  323.  
  324.     w = 0;
  325.     /* up limit is half of buffer size - 2 */
  326.     for (i = 0; i < ((UWORD)BPS/2 - 1); ++i)
  327.     w += *image++;
  328.     *image++ = sum - w;
  329. }
  330.  
  331.  
  332. /*
  333.  * Put word in memory in 8086 byte-reversed format.
  334.  *
  335.  */
  336. iw(wp, w)
  337. UWORD *wp;
  338. UWORD w;
  339. {
  340.     char *p;
  341.  
  342.     p = (char *)wp;
  343.     p[0] = (w & 0xff);
  344.     p[1] = ((w >> 8) & 0xff);
  345. }
  346.  
  347. /*
  348.  * Put long word in memory in 8086 word-reversed format.
  349.  *
  350.  */
  351. ilong(lp, l)
  352. long *lp;
  353. long l;
  354. {
  355.     UWORD *p;
  356.  
  357.     p = (UWORD *)lp;
  358.     iw(&p[0],(UWORD)(l & 0xffff));
  359.     iw(&p[1],(UWORD)((l >> 16) & 0xffff));
  360. }
  361.  
  362. /*
  363.  * Get long word in memory, from 8086 word-reversed format.
  364.  *
  365.  */
  366. glong(al, lp)   /* al is a swaped return long word,*/
  367.                 /* lp is a to be swaped long word */
  368. long *al;
  369. long *lp;
  370.  
  371. {
  372.    char *p, *q;
  373.  
  374.     p = (char *)al;
  375.     q = (char *)lp;
  376.     p[0] = q[3];
  377.     p[1] = q[2];
  378.     p[2] = q[1];
  379.     p[3] = q[0];
  380. }
  381.  
  382. /*
  383.  * Get word in memory, from 8086 byte-reversed format.
  384.  *
  385.  */
  386. UWORD gw(wp, aw)
  387. UWORD *wp;
  388. UWORD *aw;
  389. {
  390.     char *p, *q;
  391.  
  392.     p = (char *)wp;
  393.     q = (char *)aw;
  394.     q[0] = p[1];
  395.     q[1] = p[0];
  396.     return *aw;
  397. }
  398.