workbench/libs/diskfont/basicfuncs.c

   1 /*
   2     Copyright © 1995-2004, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Some support functions
   6 */
   7
   8 /****************************************************************************************/
   9
  10 #include <dos/dos.h>
  11 #include <utility/tagitem.h>
  12 #include <proto/exec.h>
  13 #include <proto/utility.h>
  14
  15 #include <aros/debug.h>
  16
  17 #include "diskfont_intern.h"
  18
  19 /****************************************************************************************/
  20
  21 APTR AllocSegment
  22 (
  23     BPTR *prevsegment, ULONG segmentsize, ULONG memflags,
  24     struct DiskfontBase *DiskfontBase
  25 )
  26 {
  27     ULONG *mem;
  28
  29     if ((mem = AllocMem(segmentsize + sizeof(ULONG) + sizeof(BPTR), memflags)))
  30     {
  31         BPTR *membptr;
  32
  33         *mem++ = segmentsize + sizeof(ULONG) + sizeof(BPTR);
  34         if (prevsegment) prevsegment[-1] = MKBADDR(mem);
  35         membptr = (BPTR *) mem;
  36         *membptr++ = BNULL;
  37         mem = (ULONG *)membptr;
  38     }
  39
  40     return mem;
  41 }
  42
  43 /****************************************************************************************/
  44
  45 /************/
  46 /* ReadTags */
  47 /************/
  48
  49 /****************************************************************************************/
  50
  51 struct TagItem *ReadTags(BPTR fh, ULONG numtags, struct DiskfontBase *DiskfontBase)
  52 {
  53     struct TagItem  *taglist,
  54                     *tagptr;
  55
  56     D(bug("ReadTags(fh=%p, numtags=%u)\n", fh, numtags));
  57
  58     /* Allocate memory for the tags */
  59     taglist = AllocVec(
  60         numtags * sizeof(struct TagItem),
  61         MEMF_ANY);
  62
  63     if (!taglist)
  64         goto rt_failure;
  65
  66     tagptr = taglist;
  67
  68     /* Read the taglist into the buffer */
  69
  70     for (; numtags --; )
  71     {
  72         ULONG val;
  73
  74         if (!ReadLong( &DiskfontBase->dsh, &val, (void *)fh))
  75             goto readfail;
  76         tagptr->ti_Tag = val;
  77
  78         if (!ReadLong( &DiskfontBase->dsh, &val, (void *)fh ))
  79             goto readfail;
  80         tagptr->ti_Data = val;
  81
  82         tagptr ++;
  83     }
  84
  85     ReturnPtr ("ReadTags", struct TagItem*, taglist);
  86
  87 readfail:
  88     FreeVec(taglist);
  89 rt_failure:
  90
  91     ReturnPtr("ReadTags", struct TagItem*, NULL);
  92
  93 }
  94
  95 /****************************************************************************************/
  96
  97 /***************/
  98 /* ReadTagsNum */
  99 /***************/
 100
 101 /****************************************************************************************/
 102
 103 struct TagItem *ReadTagsNum(BPTR fh, ULONG *numtagsptr, struct DiskfontBase *DiskfontBase)
 104 {
 105     struct TagItem  *taglist;
 106     ULONG            numtags;
 107
 108     D(bug("ReadTagsNum(fh=%p, numtagptr=0x%lx)\n", fh, numtagsptr));
 109
 110     /* Allocate memory for the tags */
 111
 112     if (!ReadLong(&DiskfontBase->dsh, &numtags, (void *)fh))
 113         goto rt_failure;
 114
 115     taglist = ReadTags(fh, numtags, DiskfontBase);
 116     if (taglist == NULL)
 117         goto rt_failure;
 118
 119     if (numtagsptr != NULL)
 120         *numtagsptr = numtags;
 121
 122     ReturnPtr ("ReadTagsNum", struct TagItem*, taglist);
 123
 124 rt_failure:
 125     if (numtagsptr != NULL)
 126         *numtagsptr = 0;
 127
 128     ReturnPtr("ReadTagsNum", struct TagItem*, FALSE);
 129
 130 }
 131
 132 /****************************************************************************************/
 133
 134 /****************/
 135 /* WriteTagsNum */
 136 /****************/
 137
 138 /****************************************************************************************/
 139
 140 BOOL WriteTagsNum(BPTR fh, const struct TagItem *taglist, struct DiskfontBase *DiskfontBase)
 141 {
 142     struct TagItem *tag;
 143     ULONG num;
 144
 145     D(bug("WriteTags(fh=%p, taglists=%p)\n", fh, taglist));
 146
 147     num = NumTags(taglist, DiskfontBase);
 148
 149     if (!WriteLong(&DiskfontBase->dsh, num, (void *)fh))
 150         goto wt_failure;
 151
 152     for (; (tag = NextTagItem((struct TagItem **)&taglist)); )
 153     {
 154         if (!WriteLong( &DiskfontBase->dsh, tag->ti_Tag, (void *)fh ))
 155             goto wt_failure;
 156
 157         if (!WriteLong( &DiskfontBase->dsh, tag->ti_Data, (void *)fh))
 158             goto wt_failure;
 159     }
 160     WriteLong(&DiskfontBase->dsh, TAG_DONE, (void *)fh);
 161     WriteLong(&DiskfontBase->dsh, 0, (void *)fh);
 162
 163     ReturnBool ("WriteTags", TRUE);
 164
 165 wt_failure:
 166     ReturnBool ("WriteTags", FALSE);
 167 }
 168
 169 /****************************************************************************************/
 170
 171 /**************/
 172 /* NumTags    */
 173 /**************/
 174
 175 /****************************************************************************************/
 176
 177 ULONG NumTags(const struct TagItem *taglist, struct DiskfontBase *DiskfontBase)
 178 /* Counts the number of tags in at taglist including TAG_DONE */
 179
 180 {
 181     ULONG numtags = 0;
 182
 183     D(bug("NumTags(taglist=%p)\n", taglist));
 184
 185     for (; NextTagItem((struct TagItem **)&taglist); )
 186         numtags ++;
 187
 188     numtags ++; /* Count TAG_DONE */
 189
 190     ReturnInt ("NumTags", ULONG, numtags);
 191 }
 192
 193 /****************************************************************************************/
 194
 195 /****************/
 196 /* CopyTagItems */
 197 /****************/
 198
 199 /****************************************************************************************/
 200
 201 ULONG CopyTagItems
 202 (
 203     struct TagItem *desttaglist,
 204     const struct TagItem *sourcetaglist,
 205     struct DiskfontBase *DiskfontBase
 206 )
 207 /* Copies tags from a taglist to another memory location, returning
 208   the number of tags copied */
 209
 210 {
 211     ULONG numtags=0;
 212
 213     struct TagItem *tag;
 214
 215     D(bug("CopyTagItems(desttaglist=%p, sourcetaglist=%p)\n", desttaglist, sourcetaglist));
 216
 217     for (; (tag = NextTagItem((struct TagItem **)&sourcetaglist)); )
 218     {
 219         desttaglist->ti_Tag   = tag->ti_Tag;
 220         desttaglist->ti_Data  = tag->ti_Data;
 221
 222         desttaglist++;
 223         numtags++;
 224     }
 225
 226     /* Insert TAG_DONE */
 227     desttaglist->ti_Tag   = TAG_DONE;
 228     desttaglist->ti_Data  = 0L;
 229
 230     /* Count TAG_DONE */
 231     numtags++;
 232
 233     ReturnInt ("CopyTagItems", ULONG, numtags);
 234 }
 235
 236 /****************************************************************************************/