home *** CD-ROM | disk | FTP | other *** search
/ CP/M / CPM_CDROM.iso / lambda / soundpot / p / pcpip2.lbr / PCLIB.CZ / PCLIB.C
Encoding:
Text File  |  1993-10-25  |  3.6 KB  |  178 lines
  1. /* PCLIB.C                                */
  2. /* PCPIP miscellaneous routines           */
  3.  
  4. istring(string,max)
  5. char *string;
  6. int max;
  7. {    int c,count;
  8.     count = 0;
  9.     c = getchar();
  10.     if (c >= 'a' && c<= 'z')
  11.        c = c - 'a' + 'A';
  12.     while (c != 10 && count < max)
  13.        { *string = c;
  14.        string = string +1;
  15.        count = count +1;
  16.        c =getchar();
  17.            if (c >= 'a' && c<= 'z')
  18.          c = c - 'a' + 'A';
  19.        }
  20.     *string = '\0';
  21.     return;
  22. }
  23.  
  24. pchain(cluster,next,fat)
  25. int cluster,next;
  26. char *fat;
  27.     {
  28.     char c;
  29.     int offset;
  30.     char b1,b2,*bp;
  31.     int n1,n2,n3,bi1,bi2;
  32.     int w1,w2,w3,w4;
  33.  
  34. /* Get nibbles from previous fat      */
  35.     bi1 = 0;
  36.     bi2 = 0;
  37.     offset = cluster + cluster/2;
  38.     b1 = *(fat + offset);
  39.     b2 = *(fat + offset + 1);
  40.     bi1 = b1;
  41.     bi2 = b2;
  42.     bp = &bi1;
  43.     bp = bp+1;
  44.     *bp = 0;
  45.     bp = &bi2;
  46.     bp = bp+1;
  47.     *bp = 0;
  48.     w1 = bi1/16;
  49.     w3 = bi2/16;
  50.     w2 = bi1-(w1*16);
  51.     w4 = bi2-(w3*16);
  52. /* Break next cluster number into nibbles */
  53.     n1 = next/256;
  54.     n2 = (next - n1*256)/16;
  55.     n3 = next - n1*256 - n2*16;
  56.   
  57. /* Determine values for byte 1 and 2 */
  58.     if (2*(cluster/2) == cluster)
  59.        {
  60.        bi1 = n2*16 + n3;
  61.        bi2 = w3*16 + n1;
  62.        }
  63.  
  64.     if (2*(cluster/2) != cluster)
  65.        {
  66.        bi1 = n3*16 + w2;
  67.        bi2 = n1*16 + n2;
  68.        }
  69.  
  70. /* And store in the fat               */
  71.     b1 = bi1;
  72.     b2 = bi2;
  73.     *(fat + offset) = b1;
  74.     *(fat + offset + 1) = b2;
  75.     return;
  76. }
  77.  
  78. getfat(cluster,fat)
  79. int cluster;
  80. char *fat;
  81. /**************************************************/                    
  82. /* GETFAT                                         */
  83. /*                                                */
  84. /* Reads the FAT entry for the input cluster and  */
  85. /* returns the next cluster (FFF for EOF)         */
  86. /*                                                */
  87. /**************************************************/
  88. {
  89.     int offset,nextsec;
  90.     char b1,b2,*bp;
  91.     int n1,n2,n3,n4,bi1,bi2;
  92.     bi1 = 0;
  93.     bi2 = 0;
  94.     offset = cluster + cluster/2;
  95.     b1 = *(fat + offset);
  96.     b2 = *(fat + offset + 1);
  97.     bi1 = b1;
  98.     bi2 = b2;
  99.     bp = &bi1;
  100.     bp = bp+1;
  101.     *bp = 0;
  102.     bp = &bi2;
  103.     bp = bp+1;
  104.     *bp = 0;
  105.     n1 = bi1/16;
  106.     n3 = bi2/16;
  107.     n2 = bi1-(n1*16);
  108.     n4 = bi2-(n3*16);
  109.     if (2*(cluster/2) == cluster)
  110.                 nextsec = n4*256 + n1*16 + n2;
  111.     if (2*(cluster/2) != cluster)
  112.         nextsec = n3*256 + n4*16 + n1;
  113.     return(nextsec);
  114. }
  115.  
  116. getstring(len,string,addr)
  117. int len;
  118. char string[],*addr;
  119. {
  120.     int i,j;
  121.     char *dispaddr;
  122.     for (i = 0;i < len;i = i+1)
  123.         {
  124.         dispaddr = addr + i;
  125.         string[i] = *dispaddr;
  126.         }
  127.     string[len] = '\0';
  128.     return;
  129. }
  130.  
  131. cname(fname,name,ext)
  132. char fname[],name[],ext[];
  133. {    int i,j;
  134.     j = 0;
  135.     for (i = 0;i < 8;i = i+1)
  136.         {
  137.         if (name[i] != ' ' && name[i] != '\0')
  138.             {
  139.             fname[j] = name[i];
  140.             j = j+1;
  141.             }
  142.         }
  143.     for (i = 0;i < 3;i = i+1)
  144.         {
  145.         if (ext[i] != ' ' && ext[i] != '\0')
  146.             {
  147.             if (i == 0)
  148.              {fname[j] = '.';
  149.               j = j+1;
  150.              }
  151.             fname[j] = ext[i];
  152.             j = j+1;
  153.             }
  154.         }
  155.     fname[j] = '\0';
  156.     return;
  157. }
  158.  
  159. getone()
  160. /**************************************************/                    
  161. /* GETONE                                         */
  162. /*                                                */
  163. /* This routine accepts and returns a single      */
  164. /* character from the keyboard (must hit return)  */
  165. /*                                                */
  166. /**************************************************/
  167. {    int c,d;
  168.     c = getchar();
  169.     if (c >= 'A' && c<= 'Z')
  170.        c = c + 'a' - 'A';
  171.     d = c;
  172.     while (d != 10)
  173.        { d = getchar();
  174.        }
  175.     return c;
  176. }
  177. /********        END OF PCLIB.C      *************/
  178.