compiler2/ttcn3/RawAST.cc

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