workbench/tools/HDToolBox/hdtoolbox_support.c

   1 /*
   2     Copyright © 1995-2008, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 #include <proto/alib.h>
   7 #include <proto/exec.h>
   8 #include <proto/gadtools.h>
   9 #include <proto/intuition.h>
  10
  11 #include <intuition/intuition.h>
  12 #include <libraries/gadtools.h>
  13
  14 #include <ctype.h>
  15 #include <stdio.h>
  16 #include <stdlib.h>
  17
  18 #include "debug.h"
  19
  20 #define HDTB_HAVE_VARARGPROTOS
  21 #include "hdtoolbox_support.h"
  22 #include "platform.h"
  23
  24 struct Node *getNumNode(struct List *list, int num)
  25 {
  26     struct Node *node;
  27
  28     D(bug("[HDToolBox] getNumNode()\n"));
  29
  30     node = list->lh_Head;
  31     while ((num) && (node->ln_Succ))
  32     {
  33         node = node->ln_Succ;
  34         num--;
  35     }
  36     return node->ln_Succ ? node : 0;
  37 }
  38
  39 ULONG getNodeNum(struct Node *node)
  40 {
  41     ULONG num = 0;
  42
  43     D(bug("[HDToolBox] getNodeNum()\n"));
  44
  45     for (;;)
  46     {
  47         node = node->ln_Pred;
  48         if (node->ln_Pred == 0)
  49             return num;
  50         num++;
  51     }
  52 }
  53
  54 ULONG countNodes(struct List *list, UBYTE type)
  55 {
  56     ULONG count = 0;
  57     struct Node *node;
  58
  59     D(bug("[HDToolBox] countNodes()\n"));
  60
  61     node = list->lh_Head;
  62     while (node->ln_Succ)
  63     {
  64         if ((type == (UBYTE)-1) || (node->ln_Type == type))
  65             count++;
  66         node = node->ln_Succ;
  67     }
  68     return count;
  69 }
  70
  71 void typestrncpy(STRPTR dst, STRPTR src, ULONG len)
  72 {
  73     while (len)
  74     {
  75         if (isprint(*src))
  76             *dst++ = *src++;
  77         else
  78         {
  79             *dst++ = '\\';
  80             sprintf(dst,"%o", *src++);
  81             while (*dst)
  82                 dst++;
  83         }
  84         len--;
  85     }
  86 }
  87
  88 UWORD strcpyESC(STRPTR dst, STRPTR fmt)
  89 {
  90     UWORD count = 0;
  91
  92     while (*fmt)
  93     {
  94         if (*fmt == '\\')
  95         {
  96             fmt++;
  97             if (isdigit(*fmt))
  98             {
  99                 ULONG val=0;
 100
 101                 for(;;)
 102                 {
 103                     val += (*fmt-'0');
 104                     fmt++;
 105                     if (!isdigit(*fmt))
 106                         break;
 107                     val *= 8;
 108                 }
 109                 *dst++ = (UBYTE)val;
 110                 count++;
 111             }
 112             else
 113             {
 114                 D(bug("[HDToolBox] strcpyESC:%s-%ld: unknown escape sequence\n", __FILE__, __LINE__));
 115             }
 116         }
 117         else
 118         {
 119             *dst++ = *fmt++;
 120             count++;
 121         }
 122     }
 123     return count;
 124 }
 125
 126 /* size in kB */
 127 void getSizeStr(STRPTR str, ULONG size)
 128 {
 129     UBYTE c = 'M';
 130     ULONG r;
 131
 132     r = size % 1024;
 133     size = size / 1024;
 134     if (size > 512)
 135     {
 136         c='G';
 137         r = size % 1024;
 138         size = size / 1024;
 139     }
 140     r = r*10/1024;
 141     sprintf(str, "%d.%d%c",(int)size,(int)r,c);
 142 }
 143
 144 /* size in kB */
 145 ULONG sizeStrToUL(STRPTR str)
 146 {
 147     char *end;
 148     ULONG size;
 149     ULONG value = 0;
 150     ULONG div;
 151
 152     size = strtoul(str, &end, 0);
 153     if (*end == '.')
 154     {
 155         value = strtoul(end+1, &end, 0);
 156     }
 157     if (*end == 'M')
 158     {
 159         size *= 1024;
 160         div = 1024;
 161     }
 162     else if (*end == 'G')
 163     {
 164         size *= 1024*1024;
 165         div = 1024*1024;
 166     }
 167     else
 168     {
 169         /* assume bytes */
 170         value = 0;
 171         div = 0;
 172         size /= 1024; /* we want it in kB */
 173     }
 174     if (div)
 175     {
 176     ULONG d=1;
 177         do
 178         {
 179             d *= 10;
 180         } while ((value/d)>=1);
 181         value *= div;
 182         value /= d;
 183     }
 184     size += value;
 185     return size;
 186 }
 187
 188 LONG GetPartitionAttrsA(struct PartitionHandle *ph, IPTR tag, ... )
 189 {
 190 #ifdef __AROS__
 191     AROS_SLOWSTACKTAGS_PRE(tag)
 192     retval = GetPartitionAttrs(ph, AROS_SLOWSTACKTAGS_ARG(tag));
 193     AROS_SLOWSTACKTAGS_POST
 194 #else
 195     return GetPartitionAttrs(ph, (struct TagItem *)&tag);
 196 #endif
 197 }
 198
 199 LONG SetPartitionAttrsA(struct PartitionHandle *ph, IPTR tag, ... )
 200 {
 201 #ifdef __AROS__
 202     AROS_SLOWSTACKTAGS_PRE(tag)
 203     retval = SetPartitionAttrs(ph, AROS_SLOWSTACKTAGS_ARG(tag));
 204     AROS_SLOWSTACKTAGS_POST
 205 #else
 206     return SetPartitionAttrs(ph, (struct TagItem *)&tag);
 207 #endif
 208 }
 209
 210 LONG GetPartitionTableAttrsA(struct PartitionHandle *ph, IPTR tag, ... )
 211 {
 212 #ifdef __AROS__
 213     AROS_SLOWSTACKTAGS_PRE(tag)
 214     retval = GetPartitionTableAttrs(ph, AROS_SLOWSTACKTAGS_ARG(tag));
 215     AROS_SLOWSTACKTAGS_POST
 216 #else
 217     return GetPartitionTableAttrs(ph, (struct TagItem *)&tag);
 218 #endif
 219 }
 220
 221 ULONG getAttrInfo(const struct PartitionAttribute *attrlist, ULONG attr)
 222 {
 223     D(bug("[HDToolBox] getAttrInfo()\n"));
 224
 225     while (attrlist[0].attribute != PTA_DONE)
 226     {
 227         if (attrlist[0].attribute == attr)
 228             return attrlist[0].mode;
 229         attrlist++;
 230     }
 231     return 0;
 232 }
 233
 234 UBYTE getBitNum(ULONG val)
 235 {
 236     UBYTE count = 0;
 237
 238     if (val==0)
 239         return 0xFF;
 240
 241     for (;;)
 242     {
 243         val >>= 1;
 244         if (val==0)
 245             break;
 246         count++;
 247     }
 248     return count;
 249 }