rom/filesys/ram/support.c

   1 /*
   2
   3 File: support.c
   4 Author: Neil Cafferkey
   5 Copyright (C) 2001-2008 Neil Cafferkey
   6
   7 This file is free software; you can redistribute it and/or modify it
   8 under the terms of the GNU Lesser General Public License as
   9 published by the Free Software Foundation; either version 2.1 of the
  10 License, or (at your option) any later version.
  11
  12 This file is distributed in the hope that it will be useful, but
  13 WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  15 Lesser General Public License for more details.
  16
  17 You should have received a copy of the GNU Lesser General Public
  18 License along with this file; if not, write to the Free Software
  19 Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  20 MA 02111-1307, USA.
  21
  22 */
  23
  24
  25 #include "handler_protos.h"
  26
  27
  28
  29 /****i* ram.handler/SetString **********************************************
  30 *
  31 *   NAME
  32 *       SetString --
  33 *
  34 *   SYNOPSIS
  35 *       block_diff = SetString(field, new_str)
  36 *
  37 *       PINT SetString(TEXT **, TEXT *);
  38 *
  39 *   FUNCTION
  40 *
  41 *   INPUTS
  42 *
  43 *   RESULT
  44 *
  45 *   EXAMPLE
  46 *
  47 *   NOTES
  48 *
  49 *   BUGS
  50 *
  51 *   SEE ALSO
  52 *
  53 ****************************************************************************
  54 *
  55 */
  56
  57 PINT SetString(struct Handler *handler, TEXT **field, const TEXT *new_str)
  58 {
  59    LONG error = 0;
  60    UPINT size;
  61    TEXT *str_copy = NULL, *old_str;
  62    PINT block_diff = 0;
  63
  64    /* Allocate new string */
  65
  66    size = StrSize(new_str);
  67    if(size > 1)
  68    {
  69       str_copy = AllocPooled(handler->muddy_pool, size);
  70       if(str_copy != NULL)
  71       {
  72          CopyMem(new_str, str_copy, size);
  73       }
  74       else
  75          error = ERROR_DISK_FULL;
  76    }
  77    else
  78       size = 0;
  79
  80    if(error == 0)
  81    {
  82       /* Deallocate old string */
  83
  84       if(size > 0)
  85          block_diff = MEMBLOCKS(size);
  86       old_str = *field;
  87       if(old_str != NULL)
  88       {
  89          size = StrSize(old_str);
  90          FreePooled(handler->muddy_pool, old_str, size);
  91          block_diff -= MEMBLOCKS(size);
  92       }
  93
  94       /* Store new string */
  95
  96       *field = str_copy;
  97    }
  98
  99    /* Store error and return difference in block utilisation */
 100
 101    SetIoErr(error);
 102    return block_diff;
 103 }
 104
 105
 106
 107 /****i* ram.handler/SwapStrings ********************************************
 108 *
 109 *   NAME
 110 *       SwapStrings --
 111 *
 112 *   SYNOPSIS
 113 *       block_diff = SwapStrings(field1, field2)
 114 *
 115 *       PINT SwapStrings(TEXT **, TEXT **);
 116 *
 117 *   FUNCTION
 118 *
 119 *   INPUTS
 120 *
 121 *   RESULT
 122 *
 123 *   EXAMPLE
 124 *
 125 *   NOTES
 126 *
 127 *   BUGS
 128 *
 129 *   SEE ALSO
 130 *
 131 ****************************************************************************
 132 *
 133 */
 134
 135 PINT SwapStrings(TEXT **field1, TEXT **field2)
 136 {
 137    TEXT *str1, *str2;
 138    PINT block_diff = 0;
 139
 140    str1 = *field1;
 141    if(str1 != NULL)
 142       block_diff = MEMBLOCKS(StrSize(str1));
 143
 144    str2 = *field2;
 145    if(str2 != NULL)
 146       block_diff -= MEMBLOCKS(StrSize(str2));
 147
 148    *field1 = str2;
 149    *field2 = str1;
 150
 151    /* Return difference in block utilisation */
 152
 153    return block_diff;
 154 }
 155
 156
 157
 158 /****i* ram.handler/StrLen *************************************************
 159 *
 160 *   NAME
 161 *       StrLen --
 162 *
 163 *   SYNOPSIS
 164 *       length = StrLen(s)
 165 *
 166 *       UPINT StrLen(TEXT *);
 167 *
 168 *   FUNCTION
 169 *
 170 *   INPUTS
 171 *
 172 *   RESULT
 173 *
 174 *   EXAMPLE
 175 *
 176 *   NOTES
 177 *
 178 *   BUGS
 179 *
 180 *   SEE ALSO
 181 *
 182 ****************************************************************************
 183 *
 184 */
 185
 186 UPINT StrLen(const TEXT *s)
 187 {
 188    const TEXT *p;
 189
 190    for(p = s; *p != '\0'; p++);
 191    return p - s;
 192 }
 193
 194
 195
 196 /****i* ram.handler/StrSize ************************************************
 197 *
 198 *   NAME
 199 *       StrLen --
 200 *
 201 *   SYNOPSIS
 202 *       size = StrSize(s)
 203 *
 204 *       UPINT StrSize(TEXT *);
 205 *
 206 *   FUNCTION
 207 *
 208 *   INPUTS
 209 *       s - The string (may be NULL).
 210 *
 211 *   RESULT
 212 *       size - Size of the string in bytes including terminating NUL.
 213 *
 214 *   EXAMPLE
 215 *
 216 *   NOTES
 217 *
 218 *   BUGS
 219 *
 220 *   SEE ALSO
 221 *
 222 ****************************************************************************
 223 *
 224 */
 225
 226 UPINT StrSize(const TEXT *s)
 227 {
 228    const TEXT *p;
 229    UPINT length = 0;
 230
 231    p = s;
 232
 233    if(s != NULL)
 234    {
 235       while(*p != '\0')
 236          p++;
 237       length = p - s + 1;
 238    }
 239
 240    return length * sizeof(TEXT);
 241 }
 242
 243
 244
 245 /****i* ram.handler/FindNameNoCase *****************************************
 246 *
 247 *   NAME
 248 *       FindNameNoCase --
 249 *
 250 *   SYNOPSIS
 251 *       node = FindNameNoCase(handler, start, name)
 252 *
 253 *       struct Node *FindNameNoCase(struct Handler *handler, struct List *, TEXT *);
 254 *
 255 *   FUNCTION
 256 *
 257 *   INPUTS
 258 *
 259 *   RESULT
 260 *
 261 *   EXAMPLE
 262 *
 263 *   NOTES
 264 *
 265 *   BUGS
 266 *
 267 *   SEE ALSO
 268 *
 269 ****************************************************************************
 270 *
 271 */
 272
 273 struct Node *FindNameNoCase(struct Handler *handler, struct List *start, const TEXT *name)
 274 {
 275    struct Node *node, *next_node, *matching_node;
 276    TEXT *node_name;
 277
 278    matching_node = NULL;
 279    node = start->lh_Head;
 280
 281    while(node != NULL)
 282    {
 283       next_node = node->ln_Succ;
 284       if(next_node != NULL)
 285       {
 286          node_name = node->ln_Name;
 287          if(node_name != NULL)
 288             if(Stricmp(name, node_name) == 0)
 289             {
 290                matching_node = node;
 291                next_node = NULL;
 292             }
 293       }
 294       node = next_node;
 295    }
 296
 297    return matching_node;
 298 }
 299
 300
 301
 302 /****i* ram.handler/MyMakeDosEntry *****************************************
 303 *
 304 *   NAME
 305 *       MyMakeDosEntry --
 306 *
 307 *   SYNOPSIS
 308 *       dos_entry = MyMakeDosEntry(handler, name, type)
 309 *
 310 *       struct DosList *MyMakeDosEntry(struct Handler *handler, TEXT *, LONG);
 311 *
 312 *   FUNCTION
 313 *
 314 *   INPUTS
 315 *
 316 *   RESULT
 317 *
 318 *   EXAMPLE
 319 *
 320 *   NOTES
 321 *
 322 *   BUGS
 323 *
 324 *   SEE ALSO
 325 *
 326 ****************************************************************************
 327 *
 328 */
 329
 330 struct DosList *MyMakeDosEntry(struct Handler *handler, const TEXT *name, LONG type)
 331 {
 332    struct DosList *entry;
 333    LONG error = 0;
 334
 335    entry = AllocMem(sizeof(struct DosList), MEMF_CLEAR | MEMF_PUBLIC);
 336
 337    if(entry != NULL)
 338    {
 339       if(!MyRenameDosEntry(handler, entry, name))
 340          error = IoErr();
 341       entry->dol_Type = type;
 342    }
 343    else
 344       error = IoErr();
 345
 346    if(error != 0)
 347    {
 348       MyFreeDosEntry(handler, entry);
 349       entry = NULL;
 350    }
 351
 352    SetIoErr(error);
 353    return entry;
 354 }
 355
 356
 357
 358 /****i* ram.handler/MyFreeDosEntry *****************************************
 359 *
 360 *   NAME
 361 *       MyFreeDosEntry --
 362 *
 363 *   SYNOPSIS
 364 *       MyFreeDosEntry(handler, entry)
 365 *
 366 *       VOID MyFreeDosEntry(struct Handler *handler, struct DosList *);
 367 *
 368 *   FUNCTION
 369 *
 370 *   INPUTS
 371 *
 372 *   RESULT
 373 *
 374 *   EXAMPLE
 375 *
 376 *   NOTES
 377 *
 378 *   BUGS
 379 *
 380 *   SEE ALSO
 381 *
 382 ****************************************************************************
 383 *
 384 */
 385
 386 VOID MyFreeDosEntry(struct Handler *handler, struct DosList *entry)
 387 {
 388    if(entry != NULL)
 389    {
 390       MyRenameDosEntry(handler, entry, NULL);
 391       FreeMem(entry, sizeof(struct DosList));
 392    }
 393
 394    return;
 395 }
 396
 397
 398
 399 /****i* ram.handler/MyRenameDosEntry ***************************************
 400 *
 401 *   NAME
 402 *       MyRenameDosEntry --
 403 *
 404 *   SYNOPSIS
 405 *       success = MyRenameDosEntry(entry, name)
 406 *
 407 *       BOOL MyRenameDosEntry(struct DosList *, TEXT *);
 408 *
 409 *   FUNCTION
 410 *
 411 *   INPUTS
 412 *
 413 *   RESULT
 414 *
 415 *   EXAMPLE
 416 *
 417 *   NOTES
 418 *
 419 *   BUGS
 420 *
 421 *   SEE ALSO
 422 *
 423 ****************************************************************************
 424 *
 425 */
 426
 427 #ifdef __AROS__
 428 BOOL MyRenameDosEntry(struct Handler *handler, struct DosList *entry, const TEXT *name)
 429 {
 430    LONG error = 0;
 431    UPINT length;
 432    TEXT *name_copy, *old_name;
 433
 434    /* Allocate new string */
 435
 436    name_copy = NULL;
 437    if(name != NULL)
 438    {
 439       length = StrLen(name);
 440 #ifdef AROS_FAST_BPTR
 441       name_copy = AllocVec(length + 1, MEMF_PUBLIC);
 442       if(name_copy != NULL)
 443       {
 444          CopyMem(name, name_copy, length + 1);
 445       }
 446 #else
 447       name_copy = AllocVec(length + 2, MEMF_PUBLIC);
 448       if(name_copy != NULL)
 449       {
 450          name_copy[0] = (UBYTE)(length > 255 ? 255 : length);
 451          CopyMem(name, name_copy + 1, length + 1);
 452       }
 453 #endif
 454       else
 455          error = IoErr();
 456    }
 457
 458    /* Deallocate old string and set new one */
 459
 460    if(error == 0)
 461    {
 462       old_name = BADDR(entry->dol_Name);
 463       if(old_name != NULL)
 464          FreeVec(old_name);
 465       entry->dol_Name = MKBADDR(name_copy);
 466    }
 467
 468    /* Store error code and return success flag */
 469
 470    SetIoErr(error);
 471    return error == 0;
 472 }
 473
 474
 475
 476 #else
 477 BOOL MyRenameDosEntry(struct DosList *entry, const TEXT *name)
 478 {
 479    LONG error = 0;
 480    UPINT length;
 481    TEXT *name_copy, *old_name;
 482
 483    /* Allocate new string */
 484
 485    name_copy = NULL;
 486    if(name != NULL)
 487    {
 488       length = StrLen(name);
 489       name_copy = AllocVec(length + 2, MEMF_PUBLIC);
 490       if(name_copy != NULL)
 491       {
 492          CopyMem(name, name_copy + 1, length + 1);
 493          *name_copy = length;
 494       }
 495       else
 496          error = IoErr();
 497    }
 498
 499    /* Deallocate old string and set new one */
 500
 501    if(error == 0)
 502    {
 503       old_name = BADDR(entry->dol_Name);
 504       if(old_name != NULL)
 505          FreeVec(old_name);
 506       entry->dol_Name = MKBADDR(name_copy);
 507    }
 508
 509    /* Store error code and return success flag */
 510
 511    SetIoErr(error);
 512    return error == 0;
 513 }
 514
 515
 516
 517 #endif