Commit | Line | Data |
---|---|---|
970ed795 | 1 | /////////////////////////////////////////////////////////////////////////////// |
3abe9331 | 2 | // Copyright (c) 2000-2015 Ericsson Telecom AB |
970ed795 EL |
3 | // All rights reserved. This program and the accompanying materials |
4 | // are made available under the terms of the Eclipse Public License v1.0 | |
5 | // which accompanies this distribution, and is available at | |
6 | // http://www.eclipse.org/legal/epl-v10.html | |
7 | /////////////////////////////////////////////////////////////////////////////// | |
8 | #include "../../common/memory.h" | |
9 | #include "RawAST.hh" | |
10 | #include <stdio.h> | |
11 | #include "../main.hh" | |
12 | ||
13 | RawAST::RawAST(){ | |
14 | init_rawast(false); | |
15 | } | |
16 | ||
17 | RawAST::RawAST(bool int_type){ | |
18 | init_rawast(int_type); | |
19 | } | |
20 | ||
21 | RawAST::RawAST(RawAST *other,bool int_type){ | |
22 | if(other){ | |
23 | fieldlength=other->fieldlength; | |
24 | comp=other->comp; | |
25 | byteorder=other->byteorder; | |
26 | align=other->align; | |
27 | bitorderinfield=other->bitorderinfield; | |
28 | bitorderinoctet=other->bitorderinoctet; | |
29 | extension_bit=other->extension_bit; | |
30 | hexorder=other->hexorder; | |
31 | padding=other->padding; | |
32 | prepadding=other->prepadding; | |
33 | padding_pattern_length=other->padding_pattern_length; | |
34 | if (other->padding_pattern != NULL) | |
35 | padding_pattern = mcopystr(other->padding_pattern); | |
36 | else padding_pattern = NULL; | |
37 | fieldorder=other->fieldorder; | |
38 | paddall=XDEFDEFAULT; | |
39 | repeatable=other->repeatable; | |
40 | ext_bit_goup_num=0; | |
41 | ext_bit_groups=NULL; | |
42 | lengthto_num=0; | |
43 | lengthto=NULL; | |
44 | pointerto=NULL; | |
45 | ptrbase=NULL; | |
46 | ptroffset=other->ptroffset; | |
47 | unit=other->unit; | |
48 | lengthindex=NULL; | |
49 | taglist.nElements=0; | |
50 | taglist.tag=NULL; | |
51 | crosstaglist.nElements=0; | |
52 | crosstaglist.tag=NULL; | |
53 | presence.fieldName=NULL; | |
54 | presence.nElements=0; | |
55 | presence.keyList=NULL; | |
56 | topleveleind=other->topleveleind; | |
57 | toplevel.bitorder=other->toplevel.bitorder; | |
58 | length_restrition=other->length_restrition; | |
3abe9331 | 59 | intx = other->intx; |
970ed795 EL |
60 | } |
61 | else init_rawast(int_type); | |
62 | } | |
63 | ||
64 | void RawAST::init_rawast(bool int_type){ | |
65 | fieldlength=int_type?8:0; | |
66 | comp=XDEFDEFAULT; | |
67 | byteorder=XDEFDEFAULT; | |
68 | align=XDEFDEFAULT; | |
69 | bitorderinfield=XDEFDEFAULT; | |
70 | bitorderinoctet=XDEFDEFAULT; | |
71 | extension_bit=XDEFDEFAULT; | |
72 | ext_bit_goup_num=0; | |
73 | ext_bit_groups=NULL; | |
74 | hexorder=XDEFDEFAULT; | |
75 | repeatable=XDEFDEFAULT; | |
76 | paddall=XDEFDEFAULT; | |
77 | padding=0; | |
78 | prepadding=0; | |
79 | padding_pattern_length=0; | |
80 | padding_pattern=NULL; | |
81 | fieldorder=XDEFDEFAULT; | |
82 | lengthto_num=0; | |
83 | lengthto=NULL; | |
84 | pointerto=NULL; | |
85 | ptrbase=NULL; | |
86 | ptroffset=0; | |
87 | unit=8; | |
88 | lengthindex=NULL; | |
89 | length_restrition=-1; | |
90 | taglist.nElements=0; | |
91 | taglist.tag=NULL; | |
92 | crosstaglist.nElements=0; | |
93 | crosstaglist.tag=NULL; | |
94 | presence.fieldName=NULL; | |
95 | presence.nElements=0; | |
96 | presence.keyList=NULL; | |
97 | topleveleind=0; | |
3abe9331 | 98 | intx = false; |
970ed795 EL |
99 | } |
100 | ||
101 | RawAST::~RawAST(){ | |
102 | if(lengthto_num){ | |
103 | for(int a=0;a<lengthto_num;a++){delete lengthto[a];} | |
104 | Free(lengthto); | |
105 | } | |
106 | if(pointerto!=NULL){delete pointerto;} | |
107 | if(ptrbase!=NULL){delete ptrbase;} | |
108 | if(padding_pattern!=NULL){Free(padding_pattern);} | |
109 | free_rawAST_tag_list(&taglist); | |
110 | free_rawAST_tag_list(&crosstaglist); | |
111 | free_rawAST_single_tag(&presence); | |
112 | if(lengthindex!=NULL) { | |
113 | for(int a=0;a<lengthindex->nElements;a++) delete lengthindex->names[a]; | |
114 | Free(lengthindex->names); | |
115 | Free(lengthindex); | |
116 | } | |
117 | if(ext_bit_goup_num){ | |
118 | for(int a=0;a<ext_bit_goup_num;a++){ | |
119 | delete ext_bit_groups[a].from; | |
120 | delete ext_bit_groups[a].to; | |
121 | } | |
122 | Free(ext_bit_groups); | |
123 | } | |
124 | ||
125 | } | |
126 | ||
127 | void RawAST::print_RawAST(){ | |
128 | printf("Fieldlength: %d\n\r",fieldlength); | |
129 | printf("comp: %d\n\r",comp); | |
130 | printf("byteorder: %d\n\r",byteorder); | |
131 | printf("align: %d\n\r",align); | |
132 | printf("bitorderinfield: %d\n\r",bitorderinfield); | |
133 | printf("bitorderinoctet: %d\n\r",bitorderinoctet); | |
134 | printf("extension_bit: %d\n\r",extension_bit); | |
135 | printf("hexorder: %d\n\r",hexorder); | |
136 | printf("fieldorder: %d\n\r",fieldorder); | |
137 | printf("ptroffset: %d\n\r",ptroffset); | |
138 | printf("unit: %d\n\r",unit); | |
139 | printf("repeatable: %d\n\r",repeatable); | |
140 | printf("presence:\n\r"); | |
141 | printf(" nElements:%d \n\r",presence.nElements); | |
142 | for(int a=0;a<presence.nElements;a++){ | |
143 | printf(" Element%d:\n\r",a); | |
144 | printf(" value:%s\n\r",presence.keyList[a].value); | |
145 | printf(" field:"); | |
146 | for(int b=0;b<presence.keyList[a].keyField->nElements;b++){ | |
147 | printf("%s.",presence.keyList[a].keyField->names[b]->get_name().c_str()); | |
148 | } | |
149 | printf("\n\r"); | |
150 | } | |
151 | printf("crosstag:\n\r"); | |
152 | printf(" nElements:%d \n\r",crosstaglist.nElements); | |
153 | for(int a=0;a<crosstaglist.nElements;a++){ | |
154 | printf(" Element%d:\n\r",a); | |
155 | printf(" fieldname:%s\n\r",crosstaglist.tag[a].fieldName | |
156 | ->get_name().c_str()); | |
157 | printf(" nElements:%d\n\r",crosstaglist.tag[a].nElements); | |
158 | for(int c=0;c<crosstaglist.tag[a].nElements;c++){ | |
159 | printf(" Element%d:\n\r",c); | |
160 | printf(" value:%s\n\r",crosstaglist.tag[a].keyList[c].value); | |
161 | printf(" field:"); | |
162 | for(int b=0;b<crosstaglist.tag[a].keyList[c].keyField->nElements;b++){ | |
163 | printf("%s.",crosstaglist.tag[a].keyList[c].keyField->names[b] | |
164 | ->get_name().c_str()); | |
165 | } | |
166 | printf("\n\r"); | |
167 | } | |
168 | } | |
169 | printf("Tag:\n\r"); | |
170 | printf(" nElements:%d \n\r",taglist.nElements); | |
171 | for(int a=0;a<taglist.nElements;a++){ | |
172 | printf(" Element%d:\n\r",a); | |
173 | printf(" fieldname:%s\n\r",taglist.tag[a].fieldName | |
174 | ->get_name().c_str()); | |
175 | printf(" nElements:%d\n\r",taglist.tag[a].nElements); | |
176 | for(int c=0;c<taglist.tag[a].nElements;c++){ | |
177 | printf(" Element%d:\n\r",c); | |
178 | printf(" value:%s\n\r",taglist.tag[a].keyList[c].value); | |
179 | printf(" field:"); | |
180 | for(int b=0;b<taglist.tag[a].keyList[c].keyField->nElements;b++){ | |
181 | printf("%s.",taglist.tag[a].keyList[c].keyField->names[b] | |
182 | ->get_name().c_str()); | |
183 | } | |
184 | printf("\n\r"); | |
185 | } | |
186 | } | |
3abe9331 | 187 | printf("%sIntX encoding\n\r", intx ? "" : "not "); |
970ed795 EL |
188 | } |
189 | ||
190 | void copy_rawAST_to_struct(RawAST *from, raw_attrib_struct *to){ | |
191 | to->fieldlength=from->fieldlength; | |
192 | to->comp=from->comp; | |
193 | to->byteorder=from->byteorder; | |
194 | to->align=from->align; | |
195 | to->bitorderinfield=from->bitorderinfield; | |
196 | to->bitorderinoctet=from->bitorderinoctet; | |
197 | to->extension_bit=from->extension_bit; | |
198 | to->ext_bit_goup_num=from->ext_bit_goup_num; | |
199 | if (from->ext_bit_goup_num > 0) | |
200 | to->ext_bit_groups = (rawAST_coding_ext_group*) | |
201 | Malloc(from->ext_bit_goup_num * sizeof(*to->ext_bit_groups)); | |
202 | else to->ext_bit_groups = NULL; | |
203 | to->hexorder=from->hexorder; | |
204 | to->padding=from->padding; | |
205 | to->lengthto_num=from->lengthto_num; | |
206 | if (from->lengthto_num > 0) | |
207 | to->lengthto = (int*)Malloc(from->lengthto_num * sizeof(int)); | |
208 | else to->lengthto = NULL; | |
209 | to->pointerto=-1; | |
210 | to->ptroffset=from->ptroffset; | |
211 | to->unit=from->unit; | |
212 | if (from->lengthindex != NULL) | |
213 | to->lengthindex = (rawAST_coding_fields*) | |
214 | Malloc(sizeof(rawAST_coding_fields)); | |
215 | else to->lengthindex = NULL; | |
216 | to->crosstaglist.nElements = from->crosstaglist.nElements; | |
217 | if (to->crosstaglist.nElements > 0) { | |
218 | to->crosstaglist.list = (rawAST_coding_taglist*) | |
219 | Malloc(to->crosstaglist.nElements * sizeof(rawAST_coding_taglist)); | |
220 | for (int i = 0; i < to->crosstaglist.nElements; i++) { | |
221 | to->crosstaglist.list[i].nElements = 0; | |
222 | to->crosstaglist.list[i].fields = NULL; | |
223 | } | |
224 | } else to->crosstaglist.list = NULL; | |
225 | to->taglist.nElements = from->taglist.nElements; | |
226 | if (to->taglist.nElements > 0) { | |
227 | to->taglist.list = (rawAST_coding_taglist*) | |
228 | Malloc(to->taglist.nElements * sizeof(rawAST_coding_taglist)); | |
229 | for (int i = 0; i < to->taglist.nElements; i++) { | |
230 | to->taglist.list[i].nElements = 0; | |
231 | to->taglist.list[i].fields = NULL; | |
232 | } | |
233 | } else to->taglist.list = NULL; | |
234 | to->presence.nElements = from->presence.nElements; | |
235 | if (to->presence.nElements > 0) | |
236 | to->presence.fields=(rawAST_coding_field_list*) | |
237 | Malloc(to->presence.nElements * sizeof(rawAST_coding_field_list)); | |
238 | else to->presence.fields = NULL; | |
239 | to->topleveleind=from->topleveleind; | |
240 | to->toplevel.bitorder=from->toplevel.bitorder; | |
241 | to->union_member_num=0; | |
242 | to->member_name=NULL; | |
243 | to->repeatable=from->repeatable; | |
244 | to->length = -1; | |
245 | } | |
246 | ||
247 | void free_raw_attrib_struct(raw_attrib_struct *raw) | |
248 | { | |
249 | // extension bit groups | |
250 | Free(raw->ext_bit_groups); | |
251 | // lengthto | |
252 | Free(raw->lengthto); | |
253 | // lengthindex | |
254 | Free(raw->lengthindex); | |
255 | // tag | |
256 | for (int i = 0; i < raw->taglist.nElements; i++) { | |
257 | for (int j = 0; j < raw->taglist.list[i].nElements; j++) | |
258 | Free(raw->taglist.list[i].fields[j].fields); | |
259 | Free(raw->taglist.list[i].fields); | |
260 | } | |
261 | Free(raw->taglist.list); | |
262 | // crosstag | |
263 | for (int i = 0; i < raw->crosstaglist.nElements; i++) { | |
264 | for (int j = 0; j < raw->crosstaglist.list[i].nElements; j++) | |
265 | Free(raw->crosstaglist.list[i].fields[j].fields); | |
266 | Free(raw->crosstaglist.list[i].fields); | |
267 | } | |
268 | Free(raw->crosstaglist.list); | |
269 | // presence | |
270 | for (int i = 0; i < raw->presence.nElements; i++) | |
271 | Free(raw->presence.fields[i].fields); | |
272 | Free(raw->presence.fields); | |
273 | // member name | |
274 | Free(raw->member_name); | |
275 | } | |
276 | ||
277 | int compare_raw_attrib(RawAST *a, RawAST *b){ | |
278 | if(a==NULL) return 0; | |
279 | if(a==b) return 0; | |
280 | if(b==NULL) return 1; | |
281 | return a->fieldlength!=b->fieldlength || | |
282 | a->comp!=b->comp || | |
283 | a->byteorder!=b->byteorder || | |
284 | a->align!=b->align || | |
285 | a->bitorderinfield!=b->bitorderinfield || | |
286 | a->bitorderinoctet!=b->bitorderinoctet || | |
287 | a->extension_bit!=b->extension_bit || | |
288 | a->hexorder!=b->hexorder || | |
289 | a->fieldorder!=b->fieldorder || | |
290 | a->topleveleind!=b->topleveleind || | |
291 | (a->topleveleind && a->toplevel.bitorder!=b->toplevel.bitorder) || | |
292 | a->padding!=b->padding || | |
293 | a->ptroffset!=b->ptroffset || | |
294 | a->repeatable!=b->repeatable || | |
3abe9331 | 295 | a->unit!=b->unit || |
296 | a->intx != b->intx; | |
970ed795 | 297 | } |