FreeCalypso > hg > fc-selenite

comparison src/gpf/ccd/break_cond.c @ 5:1ea54a97e831

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
src/gpf: import of Magnetite src/gpf3
author Mychaela Falconia <falcon@freecalypso.org>
date Sun, 15 Jul 2018 08:11:07 +0000
parents
children
comparison
equal deleted inserted replaced
4:6e457872f745 5:1ea54a97e831
1 /*
2 +-----------------------------------------------------------------------------
3 | Project :
4 | Modul : break_cond.c
5 +-----------------------------------------------------------------------------
6 | Copyright 2004 Texas Instruments Deutschland GmbH
7 | All rights reserved.
8 |
9 | This file is confidential and a trade secret of Texas
10 | Instruments Berlin, AG
11 | The receipt of or possession of this file does not convey
12 | any rights to reproduce or disclose its contents or to
13 | manufacture, use, or sell anything it may describe, in
14 | whole, or in part, without the specific written consent of
15 | Texas Instruments Berlin, AG.
16 +-----------------------------------------------------------------------------
17 | Purpose : Definition of encoding and decoding functions for BREAK_COND
18 | elements
19 +-----------------------------------------------------------------------------
20 */
21
22
23 /*
24 * standard definitions like GLOBAL, UCHAR, ERROR etc.
25 */
26 #include "typedefs.h"
27 #include "header.h"
28
29 /*
30 * Prototypes of ccd (USE_DRIVER EQ undef) for prototypes only
31 * look at ccdapi.h
32 */
33 #undef USE_DRIVER
34 #include "ccdapi.h"
35
36 /*
37 * Types and functions for bit access and manipulation
38 */
39 #include "ccd_globs.h"
40 #include "bitfun.h"
41
42 /*
43 * Prototypes of ccd internal functions
44 */
45 #include "ccd.h"
46
47 /*
48 * Declaration of coder/decoder tables
49 */
50 #include "ccdtable.h"
51 #include "ccddata.h"
52
53 #ifndef RUN_INT_RAM
54 /*
55 +-----------------------------------------------------------------------------+
56 | PROJECT : CCD (6144) MODULE : CDC_GSM |
57 | STATE : code ROUTINE : cdc_break_cond_decode |
58 +-----------------------------------------------------------------------------+
59
60 PURPOSE : Decoding of the BREAK_COND element. This element consists of a V
61 component with a variable bit length and must be connected with a
62 special condition. This condition has to be a simple value, which
63 matches to the value range of BREAK_COND element itself.
64 This function performs a standard decoding for a given elem table
65 entry. This means for non structured elements that 1-n bits are
66 read from the bitstream and write to a C-Variable in a machine
67 dependent format.
68 After decoding of the requested number of bits the resulting value
69 will be compared with the constant given by the condition. In case
70 of equality the global variable globs->continue_array is set to
71 FALSE. This breaks decoding of the current superior composition
72 and finishes the array.
73 */
74 SHORT cdc_break_cond_decode (const ULONG c_ref, const ULONG e_ref, T_CCD_Globs *globs)
75 {
76 U8 break_ind = FALSE;
77 ULONG cix_ref, num_prolog_steps, prolog_step_ref;
78
79 #ifdef DEBUG_CCD
80 #ifndef CCD_SYMBOLS
81 TRACE_CCD (globs, "cdc_break_cond_decode()");
82 #else
83 TRACE_CCD (globs, "cdc_break_cond_decode() %s", ccddata_get_alias((USHORT) e_ref, 1));
84 #endif
85 #endif
86
87 cix_ref = melem[e_ref].calcIdxRef;
88 num_prolog_steps = calcidx[cix_ref].numPrologSteps;
89 prolog_step_ref = calcidx[cix_ref].prologStepRef;
90
91 /*
92 * if this element is conditional, check the condition
93 */
94 if (calcidx[cix_ref].numCondCalcs NEQ 0
95 AND ! ccd_conditionOK (e_ref, globs))
96 return 1;
97
98 /*
99 * if this element has a defined prologue
100 * we have to process it before decoding the bitstream
101 * If there are some epilogue expressions to be processed for this element
102 * (rare cases) the result here will be a reading of 0 to an internal
103 * register. The valid processing of expression takes place after the
104 * decoding of the element.
105 */
106 if (num_prolog_steps)
107 {
108 if (calc[prolog_step_ref].operation EQ 'P')
109 {
110 break_ind = TRUE;
111 }
112
113 ccd_performOperations (num_prolog_steps, prolog_step_ref, globs);
114 }
115
116 globs->pstructOffs = melem[e_ref].structOffs;
117
118
119 if (globs->bitpos < globs->maxBitpos)
120 {
121
122 if (mvar[melem[e_ref].elemRef].cType EQ 'X')
123 bf_readBitChunk (mvar[melem[e_ref].elemRef].bSize, globs);
124 else
125 bf_readBits (mvar[melem[e_ref].elemRef].bSize, globs);
126
127 if ( ( break_ind == TRUE ) && (num_prolog_steps > 0))
128 {
129 if ( calc[prolog_step_ref].operand ==
130 (U16) *(globs->pstruct + globs->pstructOffs) )
131 {
132 globs->continue_array = FALSE;
133 }
134 }
135
136 globs->pstructOffs += mvar[melem[e_ref].elemRef].cSize;
137 }
138 else
139 ccd_recordFault ( globs,
140 ERR_ELEM_LEN,
141 BREAK,
142 (USHORT) e_ref,
143 globs->pstruct + globs->pstructOffs);
144
145 /*
146 * process the epilogue expression for this element if there is any
147 */
148 if (num_prolog_steps)
149 {
150 if ( (calc[prolog_step_ref+1].operation EQ 'K')
151 || (calc[prolog_step_ref+1].operation EQ 'C')
152 || (calc[prolog_step_ref+1].operation EQ 's'))
153 {
154 ccd_performOperations (num_prolog_steps, prolog_step_ref, globs);
155 }
156 }
157
158 return 1;
159 }
160 #endif /* !RUN_INT_RAM */
161
162 #ifndef RUN_INT_RAM
163 /*
164 +-----------------------------------------------------------------------------+
165 | PROJECT : CCD (6144) MODULE : CDC_GSM |
166 | STATE : code ROUTINE : cdc_break_cond_encode |
167 +-----------------------------------------------------------------------------+
168
169 PURPOSE : encoding of the BREAK_COND element. This element consists of a V
170 component with a variable bit length and must be connected with a
171 special condition. This condition has to be a simple value, which
172 matches to the value range of BREAK_COND element itself.
173
174 */
175
176 SHORT cdc_break_cond_encode (const ULONG c_ref, const ULONG e_ref, T_CCD_Globs *globs)
177 {
178 U8 break_ind = FALSE;
179 ULONG cix_ref, num_prolog_steps, prolog_step_ref;
180
181 #ifdef DEBUG_CCD
182 #ifndef CCD_SYMBOLS
183 TRACE_CCD (globs, "cdc_break_cond_encode()");
184 #else
185 TRACE_CCD (globs, "cdc_break_cond_encode() %s", ccddata_get_alias((USHORT) e_ref, 1));
186 #endif
187 #endif
188
189 cix_ref = melem[e_ref].calcIdxRef;
190 num_prolog_steps = calcidx[cix_ref].numPrologSteps;
191 prolog_step_ref = calcidx[cix_ref].prologStepRef;
192
193 /*
194 * if this element is conditional, check the condition
195 */
196 if (calcidx[cix_ref].numCondCalcs NEQ 0
197 AND ! ccd_conditionOK (e_ref, globs))
198 return 1;
199
200 /*
201 * if this element have a defined Prolog
202 * we have to process it before decoding the bitstream
203 */
204 if (num_prolog_steps)
205 {
206 if (calc[prolog_step_ref].operation EQ 'P')
207 {
208 break_ind = TRUE;
209 }
210
211 ccd_performOperations (num_prolog_steps, prolog_step_ref, globs);
212 }
213
214 /*
215 * Element is not a SPARE.
216 * Setup the readpointer into the C-structure for this element
217 */
218 globs->pstructOffs = melem[e_ref].structOffs;
219
220 if (mvar[melem[e_ref].elemRef].cType EQ 'X')
221 bf_writeBitChunk (mvar[melem[e_ref].elemRef].bSize, globs);
222 else
223 bf_writeBits (mvar[melem[e_ref].elemRef].bSize, globs);
224
225 if ( ( break_ind == TRUE ) && (num_prolog_steps > 0))
226 {
227 if ( calc[prolog_step_ref].operand ==
228 (U16) *(globs->pstruct + globs->pstructOffs) )
229 {
230 globs->continue_array = FALSE;
231 }
232 }
233
234 globs->pstructOffs += mvar[melem[e_ref].elemRef].cSize;
235
236 return 1;
237 }
238 #endif /* !RUN_INT_RAM */