chiark / gitweb /
Compiles but does not link. Before undo silly pad indirection.
[chiark-tcl.git] / hbytes / hbytes.c
1 /*
2  *
3  */
4
5 #include <string.h>
6
7 #include "hbytes.h"
8 #include "tables.h"
9
10 #define COMPLEX(hb) ((HBytes_ComplexValue*)hb->begin_complex)
11 #define SIMPLE_LEN(hb) ((Byte*)(hb)->end_0 - (Byte*)(hb)->begin_complex)
12
13 /* enquirers */
14
15 int hbytes_len(const HBytes_Value *hb) {
16   if (HBYTES_ISEMPTY(hb)) return 0;
17   else if (HBYTES_ISCOMPLEX(hb)) return COMPLEX(hb)->len;
18   else return SIMPLE_LEN(hb);
19 }
20
21 Byte *hbytes_data(const HBytes_Value *hb) {
22   if (HBYTES_ISEMPTY(hb)) return 0;
23   else if (HBYTES_ISCOMPLEX(hb)) return COMPLEX(hb)->dstart;
24   else return hb->begin_complex;
25 }
26
27 int hbytes_issentinel(const HBytes_Value *hb) {
28   return HBYTES_ISCOMPLEX(hb);
29 }
30
31 /* constructors */
32
33 void hbytes_empty(HBytes_Value *returns) {
34   returns->begin_complex= returns->end_0= 0;
35 }
36
37 void hbytes_sentinel(HBytes_Value *returns) {
38   returns->begin_complex= 0;
39   returns->end_0= (void*)&hbytes_type;
40 }
41
42 Byte *hbytes_arrayspace(HBytes_Value *returns, int l) {
43   if (!l) { hbytes_empty(returns); return 0; }
44   returns->begin_complex= TALLOC(l);
45   returns->end_0= returns->begin_complex + l;
46   return returns->begin_complex;
47 }
48   
49 void hbytes_array(HBytes_Value *returns, const Byte *array, int l) {
50   memcpy(hbytes_arrayspace(returns,l), array, l);
51 }
52
53 /* destructor */
54
55 void hbytes_free(HBytes_Value *frees) {
56   if (HBYTES_ISCOMPLEX(frees)) {
57     HBytes_ComplexValue *cx= COMPLEX(frees);
58     TFREE(cx->dstart - cx->prespace);
59   }
60   TFREE(frees->begin_complex);
61 }
62
63 /* mutators */
64
65 static HBytes_ComplexValue *complex(HBytes_Value *hb) {
66   HBytes_ComplexValue *cx;
67
68   if (HBYTES_ISCOMPLEX(hb)) return hb->begin_complex;
69
70   cx= TALLOC(sizeof(*cx));
71   cx->dstart= hb->begin_complex;
72   cx->len= cx->avail= SIMPLE_LEN(hb);
73   cx->prespace= 0;
74
75   hb->begin_complex= cx;
76   hb->end_0= 0;
77
78   return cx;
79 }
80
81 Byte *hbytes_prepend(HBytes_Value *hb, int el) {
82   HBytes_ComplexValue *cx;
83   int new_prespace;
84   Byte *old_block, *new_block, *new_dstart;
85
86   cx= complex(hb);
87   
88   if (cx->prespace < el) {
89     new_prespace= el*2 + cx->len;
90     old_block= cx->dstart - cx->prespace;
91     new_block= Tcl_Realloc(old_block, new_prespace + cx->avail);
92     new_dstart= new_block + new_prespace;
93     memmove(new_dstart, new_block + cx->prespace, cx->len);
94     cx->prespace= new_prespace;
95     cx->dstart= new_dstart;
96   }
97   cx->dstart -= el;
98   cx->prespace -= el;
99   cx->len += el;
100   cx->avail += el;
101   return cx->dstart;
102 }
103
104 Byte *hbytes_append(HBytes_Value *hb, int el) {
105   HBytes_ComplexValue *cx;
106   int new_len, new_avail;
107   Byte *newpart, *new_block, *old_block;
108
109   cx= complex(hb);
110
111   new_len= cx->len + el;
112   if (new_len > cx->avail) {
113     new_avail= new_len*2;
114     old_block= cx->dstart - cx->prespace;
115     new_block= Tcl_Realloc(old_block, cx->prespace + new_avail);
116     cx->dstart= new_block + cx->prespace;
117     cx->avail= new_avail;
118   }
119   newpart= cx->dstart + cx->len;
120   cx->len= new_len;
121   return newpart;
122 }
123
124 HBytes_ComplexValue *prechop(HBytes_Value *hb, int cl, const Byte **rv) {
125   HBytes_ComplexValue *cx;
126
127   if (cl<0) { *rv=0; return 0; }
128   if (cl==0) { *rv= (const void*)&hbytes_type; return 0; }
129   
130   cx= complex(hb);
131   if (cl > cx->len) { *rv=0; return 0; }
132   return cx;
133 }
134
135 const Byte *hbytes_unprepend(HBytes_Value *hb, int pl) {
136   const Byte *chopped;
137   HBytes_ComplexValue *cx= prechop(hb,pl,&chopped);
138   if (!cx) return chopped;
139
140   chopped= cx->dstart;
141   cx->dstart += pl;
142   cx->prespace += pl;
143   cx->len -= pl;
144   cx->avail -= pl;
145   return chopped;
146 }
147
148 const Byte *hbytes_unappend(HBytes_Value *hb, int sl) {
149   const Byte *chopped;
150   HBytes_ComplexValue *cx= prechop(hb,sl,&chopped);
151   if (!cx) return chopped;
152
153   cx->len -= sl;
154   return cx->dstart + cx->len;
155 }