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 #ifndef __AROS__
  89 UWORD strcpyESC(STRPTR dst, STRPTR fmt, ...){
  90 #else
  91 UWORD strcpyESC(STRPTR dst, STRPTR fmt){
  92 #endif
  93 #warning "TODO: Check varargs usage is correct"
  94     UWORD count = 0;
  95
  96     while (*fmt)
  97     {
  98         if (*fmt == '\\')
  99         {
 100             fmt++;
 101             if (isdigit(*fmt))
 102             {
 103                 ULONG val=0;
 104
 105                 for(;;)
 106                 {
 107                     val += (*fmt-'0');
 108                     fmt++;
 109                     if (!isdigit(*fmt))
 110                         break;
 111                     val *= 8;
 112                 }
 113                 *dst++ = (UBYTE)val;
 114                 count++;
 115             }
 116             else
 117             {
 118                 D(bug("[HDToolBox] strcpyESC:%s-%ld: unknown escape sequence\n", __FILE__, __LINE__));
 119             }
 120         }
 121         else
 122         {
 123             *dst++ = *fmt++;
 124             count++;
 125         }
 126     }
 127     return count;
 128 }
 129
 130 /* size in kB */
 131 void getSizeStr(STRPTR str, ULONG size)
 132 {
 133     UBYTE c = 'M';
 134     ULONG r;
 135
 136     r = size % 1024;
 137     size = size / 1024;
 138     if (size > 512)
 139     {
 140         c='G';
 141         r = size % 1024;
 142         size = size / 1024;
 143     }
 144     r = r*10/1024;
 145     sprintf(str, "%ld.%ld%c",size,r,c);
 146 }
 147
 148 /* size in kB */
 149 ULONG sizeStrToUL(STRPTR str)
 150 {
 151     char *end;
 152     ULONG size;
 153     ULONG value = 0;
 154     ULONG div;
 155
 156     size = strtoul(str, &end, 0);
 157     if (*end == '.')
 158     {
 159         value = strtoul(end+1, &end, 0);
 160     }
 161     if (*end == 'M')
 162     {
 163         size *= 1024;
 164         div = 1024;
 165     }
 166     else if (*end == 'G')
 167     {
 168         size *= 1024*1024;
 169         div = 1024*1024;
 170     }
 171     else
 172     {
 173         /* assume bytes */
 174         value = 0;
 175         div = 0;
 176         size /= 1024; /* we want it in kB */
 177     }
 178     if (div)
 179     {
 180     ULONG d=1;
 181         do
 182         {
 183             d *= 10;
 184         } while ((value/d)>=1);
 185         value *= div;
 186         value /= d;
 187     }
 188     size += value;
 189     return size;
 190 }
 191
 192 LONG GetPartitionAttrsA(struct PartitionHandle *ph, IPTR tag, ... )
 193 {
 194 #ifdef __AROS__
 195     AROS_SLOWSTACKTAGS_PRE(tag)
 196     retval = GetPartitionAttrs(ph, AROS_SLOWSTACKTAGS_ARG(tag));
 197     AROS_SLOWSTACKTAGS_POST
 198 #else
 199     return GetPartitionAttrs(ph, (struct TagItem *)&tag);
 200 #endif
 201 }
 202
 203 LONG SetPartitionAttrsA(struct PartitionHandle *ph, IPTR tag, ... )
 204 {
 205 #ifdef __AROS__
 206     AROS_SLOWSTACKTAGS_PRE(tag)
 207     retval = SetPartitionAttrs(ph, AROS_SLOWSTACKTAGS_ARG(tag));
 208     AROS_SLOWSTACKTAGS_POST
 209 #else
 210     return SetPartitionAttrs(ph, (struct TagItem *)&tag);
 211 #endif
 212 }
 213
 214 LONG GetPartitionTableAttrsA(struct PartitionHandle *ph, IPTR tag, ... )
 215 {
 216 #ifdef __AROS__
 217     AROS_SLOWSTACKTAGS_PRE(tag)
 218     retval = GetPartitionTableAttrs(ph, AROS_SLOWSTACKTAGS_ARG(tag));
 219     AROS_SLOWSTACKTAGS_POST
 220 #else
 221     return GetPartitionTableAttrs(ph, (struct TagItem *)&tag);
 222 #endif
 223 }
 224
 225 ULONG getAttrInfo(struct PartitionAttribute *attrlist, ULONG attr)
 226 {
 227     D(bug("[HDToolBox] getAttrInfo()\n"));
 228
 229     while (attrlist[0].attribute != PTA_DONE)
 230     {
 231         if (attrlist[0].attribute == attr)
 232             return attrlist[0].mode;
 233         attrlist++;
 234     }
 235     return 0;
 236 }
 237
 238 UBYTE getBitNum(ULONG val)
 239 {
 240     UBYTE count = 0;
 241
 242     if (val==0)
 243         return 0xFF;
 244
 245     for (;;)
 246     {
 247         val >>= 1;
 248         if (val==0)
 249             break;
 250         count++;
 251     }
 252     return count;
 253 }