2
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1 /*
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
2 +-----------------------------------------------------------------------------
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
3 | Project :
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
4 | Modul : cdc_std.c
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
5 +-----------------------------------------------------------------------------
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
6 | Copyright 2002 Texas Instruments Berlin, AG
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
7 | All rights reserved.
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
8 |
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
9 | This file is confidential and a trade secret of Texas
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
10 | Instruments Berlin, AG
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
11 | The receipt of or possession of this file does not convey
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
12 | any rights to reproduce or disclose its contents or to
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
13 | manufacture, use, or sell anything it may describe, in
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
14 | whole, or in part, without the specific written consent of
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
15 | Texas Instruments Berlin, AG.
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
16 +-----------------------------------------------------------------------------
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
17 | Purpose : Condat Conder Decoder
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
18 | Definitions of non protocol specific encoding and decoding
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
19 | functions
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
20 +-----------------------------------------------------------------------------
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
21 */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
22
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
23 #define CCD_STD_C
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
24
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
25 #ifdef _MSDOS
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
26 #include <dos.h>
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
27 #include <conio.h>
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
28 #endif
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
29
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
30 /*
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
31 * standard definitions like UCHAR, ERROR etc.
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
32 */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
33 #include "typedefs.h"
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
34 #include "header.h"
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
35 #include <string.h>
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
36
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
37 /*
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
38 * Prototypes of ccd (USE_DRIVER EQ undef) for prototypes only
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
39 * look at ccdapi.h.
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
40 */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
41 #undef USE_DRIVER
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
42 #include "ccdapi.h"
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
43
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
44 /*
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
45 * Types and functions for bit access and manipulation
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
46 */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
47 #include "ccd_globs.h"
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
48 #include "bitfun.h"
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
49
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
50 /*
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
51 * Declaration of coder/decoder tables and/or functions to access them
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
52 */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
53 #include "ccdtable.h"
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
54 #include "ccddata.h"
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
55
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
56 /*
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
57 * Prototypes of ccd internal functions
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
58 */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
59 #include "ccd.h"
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
60
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
61 /*
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
62 * Need memory allocation functions for dynamic arrays (pointers)
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
63 */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
64 #ifdef DYNAMIC_ARRAYS
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
65 #include "vsi.h"
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
66 #endif
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
67
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
68 #ifndef RUN_FLASH
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
69 /*
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
70 +--------------------------------------------------------------------+
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
71 | PROJECT : CCD (6144) MODULE : CCD |
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
72 | STATE : code ROUTINE : cdc_decodeElemvalue |
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
73 +--------------------------------------------------------------------+
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
74
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
75 PURPOSE : Performs a standard decoding for a given elem table entry.
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
76 This means for non structured elements that 1-n bits are
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
77 read from the bitstream and write to a C-Variable
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
78 in a machine dependent format. For structured elements
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
79 an (indirect) recursive call to cc_decodeComposition()
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
80 is performed. If the element is a bitbuffer with variable
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
81 size, the repeat value gives the number of bits to read
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
82 from the bitstream into the buffer. The maxBitpos
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
83 indicates the maximum valid position for the
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
84 readpointer of the bitstream while decoding this element.
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
85 If the readpointer break this boundary, this element will
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
86 not be decoded.
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
87 */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
88
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
89 void cdc_decodeElemvalue (ULONG e_ref, ULONG *repeat, T_CCD_Globs *globs)
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
90 {
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
91 UBYTE *ActStructpos;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
92 ULONG i;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
93 UBYTE spareLen;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
94
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
95 /*
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
96 * element is a bit field of variable length
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
97 */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
98 if ((melem[e_ref].repType == 'b') || (melem[e_ref].repType == 's'))
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
99 {
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
100 if (*repeat > (ULONG) (globs->maxBitpos-globs->bitpos))
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
101 {
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
102 ccd_recordFault (globs, ERR_MAX_REPEAT, CONTINUE,
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
103 (USHORT) e_ref, globs->pstruct + globs->pstructOffs);
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
104 *repeat = MINIMUM (*repeat, (ULONG) (globs->maxBitpos-globs->bitpos));
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
105 }
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
106 if (melem[e_ref].repType == 'b')
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
107 {
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
108 if (mvar[melem[e_ref].elemRef].cType EQ 'X')
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
109 bf_readBitChunk (*repeat, globs);
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
110 else
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
111 bf_readBits (*repeat, globs);
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
112 }
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
113 else
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
114 {
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
115 U16 finalBP = globs->bitpos + (USHORT) *repeat;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
116 /* Store the limit. This comp may contain other comps as bitstring. */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
117 globs->maxBitpos = finalBP;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
118 ActStructpos = globs->pstruct;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
119 globs->pstruct += globs->pstructOffs;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
120 #ifdef DEBUG_CCD
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
121 #ifdef CCD_SYMBOLS
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
122 TRACE_CCD (globs, "decoding composition %s as a bit array",
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
123 mcomp[melem[e_ref].elemRef].name);
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
124 #else
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
125 TRACE_CCD (globs, "decoding composition %d", melem[e_ref].elemRef);
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
126 #endif
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
127 #endif
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
128
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
129 ccd_decodeComposition ((ULONG) (melem[e_ref].elemRef), globs);
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
130 if (finalBP < globs->bitpos)
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
131 {
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
132 ccd_recordFault (globs, ERR_BITSTR_COMP, CONTINUE, (USHORT) e_ref,
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
133 globs->pstruct + globs->pstructOffs);
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
134 }
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
135 bf_setBitpos (finalBP, globs);
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
136 /* Update maxBitpos to avoid an early end of decoding. */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
137 globs->maxBitpos = globs->buflen;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
138 globs->pstruct = ActStructpos;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
139 }
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
140 }
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
141 else
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
142 {
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
143 /*
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
144 * For pointer types, globs->pstruct is already set to point to
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
145 * the new memory area, and these types are not treated differently
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
146 * from non-pointer types.
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
147 */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
148 i=0;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
149 switch (melem[e_ref].elemType)
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
150 {
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
151 case 'R': /* Pointer to (possible array of) basetype */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
152 case 'F': /* Code-transparent pointer to (possible array of) basetype */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
153 case 'V':
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
154 while (i < *repeat)
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
155 {
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
156 if (globs->bitpos < globs->maxBitpos)
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
157 {
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
158 #ifdef DEBUG_CCD
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
159 #ifdef CCD_SYMBOLS
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
160 TRACE_CCD (globs, "decoding var %s",
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
161 ccddata_get_alias((USHORT) e_ref, 1));
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
162 #else
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
163 TRACE_CCD (globs, "decoding var %d", melem[e_ref].elemRef);
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
164 #endif
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
165 #endif
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
166 if (mvar[melem[e_ref].elemRef].cType EQ 'X')
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
167 bf_readBitChunk (mvar[melem[e_ref].elemRef].bSize, globs);
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
168 else
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
169 bf_readBits (mvar[melem[e_ref].elemRef].bSize, globs);
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
170
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
171 globs->pstructOffs += mvar[melem[e_ref].elemRef].cSize;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
172
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
173 i++;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
174 }
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
175 else
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
176 {
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
177 if (melem[e_ref].repType != 'i')
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
178 {
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
179 ccd_recordFault (globs, ERR_ELEM_LEN, CONTINUE, (USHORT) e_ref,
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
180 globs->pstruct + globs->pstructOffs);
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
181 }
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
182 break;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
183 }
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
184 }
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
185 break;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
186
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
187 case 'D': /* Pointer to a composition */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
188 case 'P': /* Code transparent pointer to a comp */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
189 case 'C': /* Element is a composition. */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
190 case 'U': /* Element is a union. */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
191 /*
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
192 * Store the actual structure position.
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
193 */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
194 ActStructpos = globs->pstruct;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
195
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
196 globs->pstruct += globs->pstructOffs;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
197
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
198 while (i < *repeat)
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
199 {
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
200 if (globs->bitpos < globs->maxBitpos)
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
201 {
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
202 #ifdef DEBUG_CCD
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
203 #ifdef CCD_SYMBOLS
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
204 TRACE_CCD (globs, "decoding composition %s",
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
205 mcomp[melem[e_ref].elemRef].name);
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
206 #else
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
207 TRACE_CCD (globs, "decoding composition %d", melem[e_ref].elemRef);
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
208 #endif
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
209 #endif
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
210 /*
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
211 * recursiv call
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
212 */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
213 ccd_decodeComposition ((ULONG) (melem[e_ref].elemRef), globs);
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
214 globs->pstruct += mcomp[melem[e_ref].elemRef].cSize;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
215
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
216 i++;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
217 }
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
218 else
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
219 {
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
220 if (melem[e_ref].repType != 'i')
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
221 {
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
222 ccd_recordFault (globs, ERR_ELEM_LEN, CONTINUE, (USHORT) e_ref,
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
223 globs->pstruct + globs->pstructOffs);
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
224 }
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
225 break;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
226 }
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
227 }
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
228 /*
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
229 * restore the write pointer
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
230 */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
231 globs->pstruct = ActStructpos;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
232 break;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
233
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
234 case 'S': /* Element is a spare. */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
235 {
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
236 spareLen = spare[melem[e_ref].elemRef].bSize;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
237 /*
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
238 * Do not decode padding bits. They are not relevant.
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
239 * Just adjust the position pointer in the bit stream buffer.
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
240 */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
241 while (i < *repeat)
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
242 {
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
243 if (globs->bitpos < globs->maxBitpos)
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
244 {
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
245 #ifdef DEBUG_CCD
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
246 TRACE_CCD (globs, "decoding spare");
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
247 #endif
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
248 bf_incBitpos (spareLen, globs);
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
249 i++;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
250 }
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
251 else
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
252 break;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
253 }
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
254 break;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
255 }
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
256 }
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
257 *repeat = i;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
258 }
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
259 }
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
260 #endif /* !RUN_FLASH */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
261
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
262 #ifndef RUN_FLASH
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
263 /*
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
264 +--------------------------------------------------------------------+
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
265 | PROJECT : CCD (6144) MODULE : CCD |
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
266 | STATE : code ROUTINE : cdc_encodeElemvalue |
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
267 +--------------------------------------------------------------------+
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
268
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
269 PURPOSE : Performs a standard encoding for a given elem table entry.
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
270 This means for non structured elements that 1-n bits are
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
271 read from the bitstream and write to a C-Variable
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
272 in a machine dependent format. For structured elements
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
273 an (indirect) recursive call to cc_decodeComposition()
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
274 is performed. If the element is a bitbuffer with variable
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
275 size, the repeat value gives the number of bits to write
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
276 from the buffer into the bitstream.
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
277 */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
278
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
279 void cdc_encodeElemvalue (ULONG e_ref, ULONG repeat, T_CCD_Globs *globs)
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
280 {
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
281 UBYTE *ActStructpos = NULL;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
282 ULONG i;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
283 UBYTE spareLen;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
284
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
285 /*
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
286 * Element is a bit field of variable length.
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
287 */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
288 if (melem[e_ref].repType == 'b')
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
289 {
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
290 if (mvar[melem[e_ref].elemRef].cType EQ 'X')
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
291 bf_writeBitChunk (repeat, globs);
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
292 else
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
293 bf_writeBits (repeat, globs);
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
294 }
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
295 /*
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
296 * Element is a structured IE defined as bit string.
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
297 */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
298 else if (melem[e_ref].repType == 's')
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
299 {
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
300 U16 finalBP = (USHORT) (globs->bitpos + repeat);
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
301 ActStructpos = globs->pstruct;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
302 globs->pstruct += globs->pstructOffs;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
303 #ifdef DEBUG_CCD
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
304 #ifdef CCD_SYMBOLS
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
305 TRACE_CCD (globs, "encoding composition %s as a bit array",
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
306 mcomp[melem[e_ref].elemRef].name);
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
307 #else
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
308 TRACE_CCD (globs, "encoding composition %d", melem[e_ref].elemRef);
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
309 #endif
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
310 #endif
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
311
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
312 ccd_encodeComposition ((ULONG) melem[e_ref].elemRef, globs);
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
313 if (finalBP < globs->bitpos)
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
314 {
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
315 ccd_recordFault (globs, ERR_BITSTR_COMP, CONTINUE, (USHORT) e_ref,
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
316 globs->pstruct + globs->pstructOffs);
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
317 }
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
318 bf_setBitpos (finalBP, globs);
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
319 globs->pstruct = ActStructpos;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
320 }
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
321 else
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
322 {
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
323 /*
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
324 * For pointer types, globs->pstruct is already set to point to
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
325 * the new memory area, and these types are not treated differently
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
326 * from non-pointer types.
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
327 */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
328 switch(melem[e_ref].elemType)
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
329 {
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
330 case 'R': /* Pointer to (possible array of) basetype */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
331 case 'F': /* Code-transparent pointer to (possible array of) basetype */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
332 case 'V':
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
333 for (i=0; i<repeat; i++)
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
334 {
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
335 #ifdef DEBUG_CCD
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
336 #ifdef CCD_SYMBOLS
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
337 TRACE_CCD (globs, "encoding var %s",
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
338 ccddata_get_alias((USHORT) e_ref, 1));
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
339 #else
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
340 TRACE_CCD (globs, "encoding var %s", melem[e_ref].elemRef);
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
341 #endif
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
342 #endif
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
343 if (mvar[melem[e_ref].elemRef].cType EQ 'X')
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
344 bf_writeBitChunk (mvar[melem[e_ref].elemRef].bSize, globs);
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
345 else
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
346 bf_writeBits (mvar[melem[e_ref].elemRef].bSize, globs);
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
347
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
348 globs->pstructOffs += mvar[melem[e_ref].elemRef].cSize;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
349 }
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
350 break;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
351
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
352 case 'D': /* Pointer to a composition (already dereferenced) */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
353 case 'P': /* Code transparent pointer to a comp (already dereferenced) */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
354 case 'C': /* Element is a composition. */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
355 case 'U': /* Element is a union. */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
356 /*
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
357 * store the actual structure position
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
358 */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
359 ActStructpos = globs->pstruct;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
360
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
361 globs->pstruct += globs->pstructOffs;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
362
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
363 for (i=0; i<repeat; i++)
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
364 {
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
365 #ifdef DEBUG_CCD
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
366 #ifdef CCD_SYMBOLS
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
367 TRACE_CCD (globs, "encoding composition %s",
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
368 mcomp[melem[e_ref].elemRef].name);
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
369 #else
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
370 TRACE_CCD (globs, "encoding composition %d", melem[e_ref].elemRef);
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
371 #endif
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
372 #endif
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
373 ccd_encodeComposition ((ULONG) melem[e_ref].elemRef, globs); /* recursiv call */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
374 globs->pstruct += mcomp[melem[e_ref].elemRef].cSize;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
375 }
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
376 /*
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
377 * restore the write pointer
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
378 */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
379 globs->pstruct = ActStructpos;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
380 break;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
381
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
382 case 'S': /* element is a spare */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
383 {
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
384 spareLen = spare[melem[e_ref].elemRef].bSize;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
385
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
386 /*
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
387 * encode the spare
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
388 */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
389 for (i=0; i < repeat; i++)
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
390 {
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
391 #ifdef DEBUG_CCD
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
392 TRACE_CCD (globs, "encoding spare");
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
393 #endif
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
394 bf_codeLongNumber (spareLen, spare[melem[e_ref].elemRef].value, globs);
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
395 }
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
396 break;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
397 }
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
398 }
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
399 }
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
400 }
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
401 #endif /* !RUN_FLASH */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
402
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
403 #ifndef RUN_FLASH
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
404 /*
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
405 +--------------------------------------------------------------------+
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
406 | PROJECT : CCD (6144) MODULE : CCD |
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
407 | STATE : code ROUTINE : cdc_STD_decode |
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
408 +--------------------------------------------------------------------+
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
409
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
410 PURPOSE : Performs a standard decoding for a given elem table entry.
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
411 This means for non structured elements that 1-n bits are
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
412 read from the bitstream and write to a C-Variable
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
413 in a machine dependent format. For structured elements
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
414 an (indirect) recursive call to cc_decodeComposition()
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
415 is performed.
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
416 The element may be conditional and/or repeatable.
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
417 */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
418
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
419 SHORT cdc_std_decode (const ULONG c_ref, const ULONG e_ref, T_CCD_Globs *globs)
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
420 {
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
421 ULONG repeat, amount, act_offset;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
422 BOOL is_variable;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
423 U8 *old_pstruct = NULL;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
424 ULONG cix_ref, num_prolog_steps, prolog_step_ref;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
425
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
426 #ifdef DEBUG_CCD
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
427 #ifndef CCD_SYMBOLS
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
428 TRACE_CCD (globs, "cdc_std_decode()");
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
429 #else
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
430 TRACE_CCD (globs, "cdc_std_decode() %s", ccddata_get_alias((USHORT) e_ref, 1));
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
431 #endif
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
432 #endif
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
433
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
434 cix_ref = melem[e_ref].calcIdxRef;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
435 num_prolog_steps = calcidx[cix_ref].numPrologSteps;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
436 prolog_step_ref = calcidx[cix_ref].prologStepRef;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
437
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
438 /*
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
439 * if this element is conditional, check the condition
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
440 */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
441 if (calcidx[cix_ref].numCondCalcs NEQ 0
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
442 AND ! ccd_conditionOK (e_ref, globs))
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
443 return 1;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
444
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
445 /*
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
446 * if this element has a defined prologue
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
447 * we have to process it before decoding the bitstream
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
448 * If there are some epilogue expressions to be processed for this element
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
449 * (rare cases) the result here will be a reading of 0 to an internal
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
450 * register. The valid processing of expression takes place after the
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
451 * decoding of the element.
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
452 */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
453 if (num_prolog_steps)
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
454 {
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
455 ccd_performOperations (num_prolog_steps, prolog_step_ref, globs);
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
456 }
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
457
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
458 /*
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
459 * if this element is repeatable, and the number of
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
460 * repeats depends on another element, calculate the repeater
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
461 */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
462 if (melem[e_ref].repType NEQ ' ')
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
463 {
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
464 is_variable = ccd_calculateRep (e_ref, &repeat, &act_offset, globs);
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
465 }
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
466 else
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
467 {
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
468 repeat = 1;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
469 is_variable = FALSE;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
470 }
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
471
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
472 if (melem[e_ref].elemType NEQ 'S')
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
473 {
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
474 /*
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
475 * Element is not a SPARE.
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
476 * Setup the offset into the C-structure for this element
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
477 */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
478 globs->pstructOffs = melem[e_ref].structOffs;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
479
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
480 if (melem[e_ref].optional)
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
481 {
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
482 /* 20010621 MVJ: Dynamic array addition.
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
483 * Postpone optional flag setting for non-code transparent
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
484 * pointer types ('P', 'Q', 'R').
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
485 * For these types, the optional flag is the pointer itself.
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
486 * These types cannot be set yet, as the pointer may be
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
487 * preceeded by a counter octet, a union tag id octet etc.
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
488 */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
489 if (melem[e_ref].elemType < 'P' OR melem[e_ref].elemType > 'R')
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
490 globs->pstruct[globs->pstructOffs++] = (UBYTE) TRUE;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
491 }
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
492
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
493 if (is_variable)
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
494 {
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
495 /*
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
496 * for variable sized elements store the min-value
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
497 * as counter into the C-Structure (c_xxx).
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
498 */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
499 if (act_offset > 65535)
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
500 *(ULONG *) (globs->pstruct + globs->pstructOffs++) = repeat;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
501 else if (act_offset > 255)
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
502 *(USHORT *) (globs->pstruct + globs->pstructOffs++) = (USHORT) repeat;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
503 else
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
504 globs->pstruct[globs->pstructOffs] = (UBYTE) repeat;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
505
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
506 globs->pstructOffs++;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
507 }
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
508 }
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
509 #ifdef DYNAMIC_ARRAYS
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
510 /*
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
511 * MVJ: Dynamic array addition.
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
512 * Check for pointer types; allocate memory if necessary.
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
513 */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
514 if ( is_pointer_type(e_ref) ) {
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
515 U32 cSize;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
516 U8 *addr;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
517
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
518 /*
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
519 * Find size to allocate;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
520 * - Read from mcomp or mvar according to type
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
521 */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
522 cSize = (ULONG)((melem[e_ref].elemType EQ 'V' OR
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
523 melem[e_ref].elemType EQ 'R')
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
524 ? mvar[melem[e_ref].elemRef].cSize
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
525 : mcomp[melem[e_ref].elemRef].cSize
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
526 ) * repeat;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
527
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
528 /*
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
529 * Allocate additional memory
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
530 */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
531 addr = (U8 *)DP_ALLOC( cSize, globs->alloc_head, DP_NO_FRAME_GUESS);
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
532
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
533 /* If no memory, log error and return immediately */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
534 if (addr EQ NULL) {
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
535 ccd_setError (globs, ERR_NO_MEM,
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
536 BREAK,
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
537 (USHORT) -1);
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
538 return 1;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
539 }
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
540 else
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
541 memset (addr, 0, (size_t)cSize);
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
542
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
543 /*
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
544 * Memory allocated;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
545 * 1. Save old "globs->pstruct" variables
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
546 * 2. Store pointer to freshly allocated memory area in structure
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
547 * 3. Initialize pstruct to point to the freshly allocated memory area.
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
548 * 4. Initialize pstructOffs to 0 to start decoding at offset 0
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
549 * in the new memory area.
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
550 */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
551 old_pstruct = globs->pstruct;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
552 *(U8 **)(globs->pstruct + globs->pstructOffs) = addr;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
553 globs->pstruct = addr;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
554 globs->pstructOffs = 0;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
555 }
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
556 #endif
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
557
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
558 amount = repeat;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
559
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
560 cdc_decodeElemvalue (e_ref, &amount, globs);
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
561
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
562 /*
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
563 * process the epilogue expression for this element if there is any
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
564 */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
565 if (num_prolog_steps)
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
566 {
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
567 if ( (calc[prolog_step_ref+1].operation EQ 'K')
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
568 || (calc[prolog_step_ref+1].operation EQ 'C')
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
569 || (calc[prolog_step_ref+1].operation EQ 's'))
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
570 {
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
571 ccd_performOperations (num_prolog_steps, prolog_step_ref, globs);
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
572 }
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
573 }
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
574
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
575 #ifdef DYNAMIC_ARRAYS
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
576 /*
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
577 * Restore globs->pstruct for possible use below
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
578 */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
579 if (old_pstruct NEQ NULL)
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
580 {
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
581 globs->pstruct = old_pstruct;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
582 }
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
583 #endif
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
584 if (amount NEQ repeat AND is_variable)
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
585 {
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
586 /*
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
587 * if the decoded elements are not equal the specified
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
588 * repeat value, because the bitstream or the IE ended,
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
589 * store the new c_xxx value.
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
590 */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
591 globs->pstructOffs = melem[e_ref].structOffs;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
592
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
593 if (melem[e_ref].optional)
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
594 globs->pstructOffs++;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
595
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
596 if (act_offset > 65535)
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
597 *(ULONG *) (globs->pstruct + globs->pstructOffs) = amount;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
598 else if (act_offset > 255)
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
599 *(USHORT *) (globs->pstruct + globs->pstructOffs) = (USHORT) amount;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
600 else
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
601 globs->pstruct[globs->pstructOffs] = (UBYTE) amount;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
602
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
603 if (melem[e_ref].repType NEQ 'i')
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
604 {
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
605 /*
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
606 * if this element is not of the repeat style 'interval'
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
607 * ([X..Y] where X and Y are constants) we have to generate
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
608 * an ccd error because some outstanding repeats are missing.
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
609 */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
610 ccd_setError (globs, ERR_MAND_ELEM_MISS, CONTINUE, (USHORT) -1);
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
611 }
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
612 }
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
613
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
614 return 1;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
615 }
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
616 #endif /* !RUN_FLASH */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
617
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
618 #ifndef RUN_FLASH
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
619 /*
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
620 +--------------------------------------------------------------------+
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
621 | PROJECT : CCD (6144) MODULE : CCD |
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
622 | STATE : code ROUTINE : cdc_std_encode |
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
623 +--------------------------------------------------------------------+
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
624
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
625 PURPOSE : Performs a standard encoding for a given elem table entry.
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
626 This means for non structured elements that m bytes read
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
627 from the C-Variable, converted to MSB-first format and
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
628 write 1-n bits at the end of the bitstream.
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
629 For structured elements an (indirect) recursive call
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
630 to ccd_encodeComposition() is performed.
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
631 The element may be conditional and/or repeatable.
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
632 */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
633
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
634 SHORT cdc_std_encode (const ULONG c_ref, const ULONG e_ref, T_CCD_Globs *globs)
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
635 {
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
636 ULONG repeat, max_rep;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
637 BOOL is_variable;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
638 ULONG cix_ref, num_prolog_steps, prolog_step_ref;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
639 #ifdef DYNAMIC_ARRAYS
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
640 U8 *old_pstruct = NULL;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
641 #endif
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
642
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
643 #ifdef DEBUG_CCD
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
644 #ifndef CCD_SYMBOLS
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
645 TRACE_CCD (globs, "cdc_std_encode()");
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
646 #else
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
647 TRACE_CCD (globs, "cdc_std_encode() %s", ccddata_get_alias((USHORT) e_ref, 1));
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
648 #endif
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
649 #endif
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
650
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
651 cix_ref = melem[e_ref].calcIdxRef;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
652 num_prolog_steps = calcidx[cix_ref].numPrologSteps;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
653 prolog_step_ref = calcidx[cix_ref].prologStepRef;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
654 /*
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
655 * if this element is conditional, check the condition
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
656 */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
657 if (calcidx[cix_ref].numCondCalcs NEQ 0
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
658 AND ! ccd_conditionOK (e_ref, globs))
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
659 return 1;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
660
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
661 /*
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
662 * if this element have a defined Prolog
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
663 * we have to process it before decoding the bitstream
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
664 */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
665 if (num_prolog_steps)
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
666 {
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
667 ccd_performOperations (num_prolog_steps, prolog_step_ref, globs);
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
668 }
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
669
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
670 if (melem[e_ref].elemType NEQ 'S')
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
671 {
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
672 /*
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
673 * Element is not a SPARE.
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
674 * Setup the readpointer into the C-structure for this element
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
675 * MVJ: In case of pointer types, the pstructOffs must be
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
676 * the offset into the memory area pointed to. CCDGEN must
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
677 * ensure this holds true.
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
678 */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
679 globs->pstructOffs = melem[e_ref].structOffs;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
680
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
681 if (melem[e_ref].optional)
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
682 {
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
683 /*
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
684 * for optional elements check the valid-flag in the C-struct.
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
685 * Spare elements does not have a corresponding valid flag. For
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
686 * the spare elements we have to calculate and check the
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
687 * condition to decide if this elements have to be coded.
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
688 */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
689 /* 20010621 MVJ: Dynamic array addition.
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
690 * Postpone optional check for non-code transparent pointer
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
691 * types ('P', 'Q', 'R').
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
692 * For these types, the optional flag is the pointer itself.
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
693 * These types cannot be checked yet, as the pointer may be
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
694 * preceeded by a counter octet, a union tag id octet etc.
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
695 */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
696 if (melem[e_ref].elemType < 'P' OR melem[e_ref].elemType > 'R')
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
697 {
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
698 if (globs->pstruct[globs->pstructOffs++] == FALSE)
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
699 {
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
700 return 1;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
701 }
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
702 #ifdef DEBUG_CCD
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
703 else if (globs->pstruct [melem[e_ref].structOffs] != TRUE)
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
704 {
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
705 TRACE_CCD (globs, "Ambiguous value for valid flag!\n...assumed 1 for ccdID=%d",
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
706 e_ref);
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
707 }
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
708 #endif
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
709 }
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
710 }
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
711
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
712 if ((melem[e_ref].repType EQ 'v' OR melem[e_ref].repType EQ 'i'))
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
713 {
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
714 /*
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
715 * for variable sized elements read the amount
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
716 * of repeats out of the C-Structure (c_xxx).
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
717 * If the number of repeats given by the C-Structure
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
718 * exceeds the allowed value (maxRepeat) CCD gives a warning!
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
719 */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
720 if (melem[e_ref].maxRepeat > 255)
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
721 {
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
722 ULONG count = (ULONG) (* (USHORT *)(globs->pstruct + globs->pstructOffs++));
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
723 repeat = MINIMUM (count, (ULONG) melem[e_ref].maxRepeat);
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
724 if (repeat < count)
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
725 ccd_recordFault (globs, ERR_MAX_REPEAT, CONTINUE,
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
726 (USHORT) e_ref, globs->pstruct + globs->pstructOffs);
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
727 }
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
728 else
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
729 {
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
730 repeat = (ULONG)MINIMUM (globs->pstruct[globs->pstructOffs],
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
731 melem[e_ref].maxRepeat);
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
732 if ( repeat < (ULONG) (globs->pstruct[globs->pstructOffs]) )
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
733 ccd_recordFault (globs, ERR_MAX_REPEAT, CONTINUE,
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
734 (USHORT) e_ref, globs->pstruct + globs->pstructOffs);
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
735 }
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
736 globs->pstructOffs++;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
737 }
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
738 else
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
739 if (melem[e_ref].repType EQ 'c')
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
740 {
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
741 repeat = (ULONG) melem[e_ref].maxRepeat;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
742 }
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
743 else
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
744 if (melem[e_ref].repType == 's' || melem[e_ref].repType == 'b')
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
745 {
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
746 switch (melem[e_ref].elemType)
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
747 {
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
748 case 'R': /* Pointer to (possible array of) basetype */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
749 case 'F': /* Code-transparent pointer to (possible array of) basetype */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
750 case 'V':
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
751 globs->maxBitpos = globs->bitpos + mvar[melem[e_ref].elemRef].bSize;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
752 break;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
753 case 'D': /* Pointer to a composition */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
754 case 'P': /* Code transparent pointer to a comp */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
755 case 'C': /* Element is a composition. */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
756 case 'E': /* Pointer to a union */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
757 case 'Q': /* Code transparent pointer to a union */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
758 case 'U': /* Element is a union. */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
759 globs->maxBitpos = globs->bitpos + mcomp[melem[e_ref].elemRef].bSize;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
760 break;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
761 }
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
762
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
763 is_variable = ccd_calculateRep (e_ref, &repeat, &max_rep, globs);
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
764 }
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
765 else
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
766 repeat = 1;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
767
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
768 /* 20010621 MVJ: Dynamic array addition.
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
769 * Check for non-code transparent pointer types ('P', 'Q', 'R').
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
770 * For these types, the optional flag is the pointer itself.
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
771 * ASSUMPTION: The pointer may be preceeded by a counter octet,
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
772 * a union tag id octet etc., but it is up to CCDGEN to ensure
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
773 * word alignment (by inserting alignment bytes). Therefore
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
774 * we just read from globs->pstruct[globs->pstructOffs].
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
775 */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
776 #ifdef DEBUG_CCD
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
777 /* Check pointer alignment and re-align if necessary (should never happen) */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
778 if ( is_pointer_type(e_ref) AND ((globs->pstructOffs & 3) NEQ 0)) {
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
779 TRACE_CCD (globs, "cdc_STD_encode(): Pointer misaligned! pstruct=0x08x,"
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
780 " pstructOffs=0x%08x", globs->pstruct, globs->pstructOffs);
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
781 globs->pstructOffs = (globs->pstructOffs + 3) & 3;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
782 }
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
783 #endif
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
784 #ifdef DYNAMIC_ARRAYS
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
785 /*
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
786 * MVJ: Perform pointer dereference for pointer types.
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
787 * Also, check optionality for these types.
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
788 */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
789 if ( is_pointer_type(e_ref) ) {
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
790 U8 *deref_pstruct;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
791
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
792 /* Get pointer value */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
793 deref_pstruct = *(U8 **)&globs->pstruct[globs->pstructOffs];
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
794
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
795 /*
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
796 * Strictly speaking the 'D' to 'F' types should not need this
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
797 * check (should have returned after the optionality check above),
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
798 * but it will catch stray NULL pointers (or uninitialized
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
799 * valid flags)
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
800 */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
801 if (ccd_check_pointer(deref_pstruct) != ccdOK )
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
802 {
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
803 ccd_recordFault (globs, ERR_INVALID_PTR, BREAK, (USHORT) e_ref,
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
804 &globs->pstruct[globs->pstructOffs]);
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
805 return 1;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
806 }
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
807 /*
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
808 * Pointer not NULL;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
809 * 1. Save old globs->pstruct and assign pointer to globs->pstruct
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
810 * as new base.
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
811 * 2. Set pstructOffs to 0 (zero) as the next offset will start
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
812 * in the new memory area.
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
813 */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
814 old_pstruct = globs->pstruct;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
815 globs->pstruct = deref_pstruct;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
816 globs->pstructOffs = 0;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
817 }
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
818 #endif /* DYNAMIC_ARRAYS */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
819 }
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
820 else
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
821 {
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
822 /*
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
823 * for spare elements we have to calculate the conditions
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
824 * and the repetitions because there are no valid-flags and
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
825 * c_xxx variables in the C-structure to read.
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
826 */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
827 if (melem[e_ref].optional)
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
828 {
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
829 /*
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
830 * Spare elements does not have a corresponding valid flag.
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
831 * For the spare elements we have to calculate and check the
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
832 * condition to decide if this elements have to be coded.
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
833 */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
834 if (calcidx[cix_ref].numCondCalcs NEQ 0
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
835 AND ! ccd_conditionOK (e_ref, globs))
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
836 return 1;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
837 }
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
838 /*
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
839 * if this spare is repeatable, calculate the amount of
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
840 * repeats because there is no corresponding c_xxx element
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
841 * in the C-Structure.
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
842 */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
843 if (melem[e_ref].repType NEQ ' ')
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
844 {
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
845 globs->maxBitpos = globs->bitpos + spare[melem[e_ref].elemRef].bSize;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
846 is_variable = ccd_calculateRep (e_ref, &repeat, &max_rep, globs);
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
847 }
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
848 else
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
849 repeat = 1;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
850 }
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
851
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
852 cdc_encodeElemvalue (e_ref, repeat, globs);
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
853
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
854 #ifdef DYNAMIC_ARRAYS
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
855 if ( old_pstruct NEQ NULL )
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
856 globs->pstruct = old_pstruct;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
857 #endif
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
858
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
859 return 1;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
860 }
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
861 #endif /* !RUN_FLASH */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
862
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
863 /*
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
864 * some elementary bitfunctions
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
865 */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
866
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
867 /* LSB,MSB Definitions for the CPUs */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
868
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
869 #ifdef M_INTEL
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
870 #define MSB_POS 1
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
871 #define LSB_POS 0
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
872 #define MSW_POS 2
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
873 #define LSW_POS 0
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
874 #else /* M_INTEL */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
875 #ifdef M_MOTOROLA
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
876 #define MSB_POS 0
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
877 #define LSB_POS 1
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
878 #define MSW_POS 0
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
879 #define LSW_POS 2
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
880 #endif /* M_MOTOROLA */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
881 #endif /* M_INTEL */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
882
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
883 extern const ULONG ccd_bitfun_mask[];
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
884
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
885 /*
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
886 * Table of one-bit values (2^X)
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
887 * This unused variable is commented now in order to avoid some compiler
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
888 * warnings like: variable "shift" (line xxx) is not used
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
889
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
890 LOCAL const UBYTE shift[] =
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
891 {
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
892 128, 64, 32, 16, 8, 4, 2, 1
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
893 };
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
894 */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
895
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
896 #ifndef RUN_FLASH
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
897 /*
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
898 +--------------------------------------------------------------------+
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
899 | PROJECT : CCD (6144) MODULE : CCD |
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
900 | STATE : code ROUTINE : ccd_codeByte |
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
901 +--------------------------------------------------------------------+
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
902
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
903 PURPOSE: encodes the value of (value) into a CPU-dependent
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
904 bitstring. The length of the bitstring is specified
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
905 throu (bitlen). The function copies the bitstring into
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
906 the buffer (bitstream) at bit position (startbit).
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
907 The bitlen may be between 1 and 8.
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
908
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
909 */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
910
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
911 BYTE CCDDATA_PREF(ccd_codeByte) (UBYTE * bitstream,
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
912 USHORT startbit,
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
913 USHORT bitlen,
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
914 UBYTE value)
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
915 {
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
916 union
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
917 { /* Conversion structure 2 Byte <-> unsigned short */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
918 UBYTE c[2];
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
919 USHORT s;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
920 }
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
921 conv;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
922
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
923 UBYTE *p, lshift;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
924
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
925 USHORT m;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
926
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
927 p = bitstream + (startbit >> 3);
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
928
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
929 lshift = (16 - ((startbit & 7) + bitlen));
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
930
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
931 conv.c[MSB_POS] = p[0];
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
932
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
933 conv.c[LSB_POS] = p[1];
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
934
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
935 m = ((USHORT) ccd_bitfun_mask[bitlen]) << lshift;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
936
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
937 conv.s &= ~m;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
938
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
939 conv.s |= ((value << lshift) & m);
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
940
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
941 p[0] = conv.c[MSB_POS];
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
942
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
943 p[1] = conv.c[LSB_POS];
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
944
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
945 return ccdOK;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
946 }
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
947 #endif /* !RUN_FLASH */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
948
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
949 #ifndef RUN_FLASH
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
950 /*
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
951 +--------------------------------------------------------------------+
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
952 | PROJECT : CCD (6144) MODULE : CCD |
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
953 | STATE : code ROUTINE : ccd_decodeByte |
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
954 +--------------------------------------------------------------------+
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
955
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
956 PURPOSE: decodes (bitlen) bits from the (bitstream) at position
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
957 (startbit) and converts them to a numeric value (value)
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
958 The bitlen may be between 1 and 8.
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
959
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
960 */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
961
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
962 BYTE CCDDATA_PREF(ccd_decodeByte) (UBYTE *bitstream,
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
963 USHORT startbit,
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
964 USHORT bitlen,
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
965 UBYTE *value)
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
966 {
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
967 union
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
968 { /* Conversion structure 2 Byte <-> unsigned short */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
969 UBYTE c[2];
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
970 USHORT s;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
971 }
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
972 conv;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
973
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
974 UBYTE *p;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
975
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
976 p = bitstream + (startbit >> 3);
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
977
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
978 conv.c[MSB_POS] = *p++;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
979
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
980 conv.c[LSB_POS] = *p;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
981
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
982 conv.s >>= (16 - ((startbit & 7) + bitlen));
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
983
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
984 conv.s &= (USHORT) ccd_bitfun_mask[bitlen];
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
985
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
986 *value = (UBYTE) conv.s;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
987
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
988 return ccdOK;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
989 }
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
990 #endif /* !RUN_FLASH */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
991
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
992 #ifndef RUN_FLASH
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
993 /*
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
994 +--------------------------------------------------------------------+
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
995 | PROJECT : CCD (6144) MODULE : CCD |
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
996 | STATE : code ROUTINE : ccd_codeLong |
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
997 +--------------------------------------------------------------------+
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
998
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
999 PURPOSE: encodes the value of (value) into a CPU-dependent
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1000 bitstring. The length of the bitstring is specified
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1001 throu (bitlen). The function copies the bitstring into
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1002 the buffer (bitstream) at bit position (startbit).
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1003 The bitlen may be between 1 and 32.
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1004
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1005 */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1006
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1007 BYTE CCDDATA_PREF(ccd_codeLong) (UBYTE *bitstream,
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1008 USHORT startbit,
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1009 USHORT bitlen,
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1010 ULONG value)
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1011 {
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1012 UBYTE *p;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1013
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1014 union
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1015 { /* Conversion structure 4 Byte <-> unsigned long */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1016 UBYTE c[4];
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1017 ULONG l;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1018 }
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1019 conv;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1020
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1021 p = bitstream + (startbit >> 3);
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1022 startbit &= 7;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1023
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1024 conv.l = value & ccd_bitfun_mask[bitlen];
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1025 conv.l <<= (32-bitlen-startbit);
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1026
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1027 p[0] &= (UCHAR)~ccd_bitfun_mask[8-startbit];
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1028
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1029 switch ((USHORT)(startbit+bitlen-1) >> 3)
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1030 {
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1031 case 0:
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1032 p[0] |= conv.c[MSW_POS+MSB_POS];
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1033 break;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1034 case 1:
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1035 p[0] |= conv.c[MSW_POS+MSB_POS];
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1036 p[1] = conv.c[MSW_POS+LSB_POS];
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1037 break;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1038 case 2:
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1039 p[0] |= conv.c[MSW_POS+MSB_POS];
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1040 p[1] = conv.c[MSW_POS+LSB_POS];
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1041 p[2] = conv.c[LSW_POS+MSB_POS];
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1042 break;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1043 case 3:
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1044 p[0] |= conv.c[MSW_POS+MSB_POS];
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1045 p[1] = conv.c[MSW_POS+LSB_POS];
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1046 p[2] = conv.c[LSW_POS+MSB_POS];
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1047 p[3] = conv.c[LSW_POS+LSB_POS];
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1048 break;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1049 default:
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1050 p[0] |= conv.c[MSW_POS+MSB_POS];
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1051 p[1] = conv.c[MSW_POS+LSB_POS];
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1052 p[2] = conv.c[LSW_POS+MSB_POS];
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1053 p[3] = conv.c[LSW_POS+LSB_POS];
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1054 p[4] = (UBYTE) ((value & 0xff) << (8-startbit));
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1055 break;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1056 }
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1057 return ccdOK;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1058 }
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1059 #endif /* !RUN_FLASH */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1060
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1061 #ifndef RUN_FLASH
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1062 /*
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1063 +--------------------------------------------------------------------+
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1064 | PROJECT : CCD (6144) MODULE : CCD |
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1065 | STATE : code ROUTINE : ccd_decodeLong |
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1066 +--------------------------------------------------------------------+
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1067
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1068 PURPOSE: decodes (bitlen) bits from the (bitstream) at position
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1069 (startbit) and converts them to a numeric value (value)
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1070 The bitlen may be between 1 and 32.
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1071
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1072 */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1073
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1074 BYTE CCDDATA_PREF(ccd_decodeLong) (UBYTE *bitstream,
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1075 USHORT startbit,
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1076 USHORT bitlen,
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1077 ULONG *value)
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1078 {
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1079 UBYTE *p;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1080
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1081 union
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1082 { /* Conversion structure 4 Byte <-> unsigned long */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1083 UBYTE c[4];
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1084 ULONG l;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1085 }
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1086 conv;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1087
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1088 p = bitstream + (startbit >> 3);
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1089 startbit &= 7;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1090
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1091 conv.l = 0L;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1092 switch ((USHORT)(startbit+bitlen-1) >> 3)
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1093 {
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1094 case 0:
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1095 conv.c[MSW_POS+MSB_POS] = p[0];
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1096 conv.l <<= startbit;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1097 conv.l >>= (32-bitlen);
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1098 break;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1099 case 1:
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1100 conv.c[MSW_POS+MSB_POS] = p[0];
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1101 conv.c[MSW_POS+LSB_POS] = p[1];
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1102 conv.l <<= startbit;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1103 conv.l >>= (32-bitlen);
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1104 break;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1105 case 2:
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1106 conv.c[MSW_POS+MSB_POS] = p[0];
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1107 conv.c[MSW_POS+LSB_POS] = p[1];
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1108 conv.c[LSW_POS+MSB_POS] = p[2];
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1109 conv.l <<= startbit;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1110 conv.l >>= (32-bitlen);
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1111 break;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1112 case 3:
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1113 conv.c[MSW_POS+MSB_POS] = p[0];
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1114 conv.c[MSW_POS+LSB_POS] = p[1];
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1115 conv.c[LSW_POS+MSB_POS] = p[2];
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1116 conv.c[LSW_POS+LSB_POS] = p[3];
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1117 conv.l <<= startbit;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1118 conv.l >>= (32-bitlen);
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1119 break;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1120 default:
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1121 conv.c[MSW_POS+MSB_POS] = p[0];
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1122 conv.c[MSW_POS+LSB_POS] = p[1];
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1123 conv.c[LSW_POS+MSB_POS] = p[2];
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1124 conv.c[LSW_POS+LSB_POS] = p[3];
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1125 conv.l <<= startbit;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1126 conv.l >>= (32-bitlen);
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1127 conv.c[LSW_POS+LSB_POS] |= (p[4] >> (8-startbit));
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1128 break;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1129 }
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1130 *value = conv.l & ccd_bitfun_mask[bitlen];
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1131 return ccdOK;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1132 }
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1133 #endif /* !RUN_FLASH */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1134
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1135 #ifndef RUN_FLASH
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1136 /*
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1137 +--------------------------------------------------------------------+
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1138 | PROJECT : CCD (6144) MODULE : CCD |
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1139 | STATE : code ROUTINE : ccd_bitcopy |
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1140 +--------------------------------------------------------------------+
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1141
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1142 PURPOSE: copys bitlen bits from the source buffer to the destination
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1143 buffer. offset contains the position of the first bit in
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1144 the source bitfield. This function may perform a leftshift
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1145 to adjust the most significant bit on byte boundarys of the
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1146 first byte in dest.
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1147
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1148 */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1149
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1150 void CCDDATA_PREF(ccd_bitcopy) (UBYTE *dest,
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1151 UBYTE *source,
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1152 USHORT bitlen,
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1153 USHORT offset)
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1154 {
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1155 union
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1156 { /* Conversion structure 2 Byte <-> unsigned short */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1157 UBYTE c[2];
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1158 USHORT s;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1159 }
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1160 conv;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1161
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1162 USHORT l_shift = offset & 7;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1163 USHORT bytes_to_copy = (bitlen >> 3);
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1164
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1165 /*
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1166 * go to the byte that contains the first valid bit.
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1167 */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1168 source += (offset >> 3);
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1169
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1170
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1171 if (l_shift)
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1172 {
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1173 /*
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1174 * shift and copy each byte
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1175 */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1176 while (bytes_to_copy--)
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1177 {
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1178 conv.c[MSB_POS] = *source;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1179 source++;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1180 conv.c[LSB_POS] = *source;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1181 conv.s <<= l_shift;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1182 *dest = conv.c[MSB_POS];
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1183 dest++;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1184 }
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1185 }
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1186 else
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1187 {
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1188 /*
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1189 * no shift operation, do a memcopy;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1190 */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1191 while (bytes_to_copy--)
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1192 {
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1193 *dest = *source;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1194 dest++;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1195 source++;
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1196 }
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1197 }
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1198 /*
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1199 * cutoff the garbage at the end of the bitstream
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1200 */
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1201
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1202 *(dest-1) &= (UCHAR)(~ccd_bitfun_mask[(8-(bitlen&7))&7]);
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1203 }
|
Mychaela Falconia <falcon@freecalypso.org>
parents:
diff
changeset
|
1204 #endif /* !RUN_FLASH */
|
