Mercurial Mercurial > matiec / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
stage4/generate_c/generate_c_typedecl.cc
changeset 310 f111a6986c22
parent 309 f93bcada0f51
child 322 293967b9277d
equal deleted inserted replaced
309:f93bcada0f51 310:f111a6986c22 
    50       delete basedecl;
 
    50       delete basedecl;
 
    51     }
 
    51     }
 
    52 
    52 
    53     typedef enum {
 
    53     typedef enum {
 
    54       none_td,
 
    54       none_td,
 
       
    55       enumerated_td,
 
    55       subrange_td,
 
    56       subrange_td,
 
    56       array_td
 
    57       array_td,
 
       
    58       struct_td,
 
    57     } typedefinition_t;
 
    59     } typedefinition_t;
 
    58 
    60 
    59     typedefinition_t current_typedefinition;
 
    61     typedefinition_t current_typedefinition;
 
    60 
    62 
    61     typedef enum {
 
    63     typedef enum {
 
   172 /********************************/
 
   174 /********************************/
 
   173 /*  subrange_type_name ':' subrange_spec_init */
 
   175 /*  subrange_type_name ':' subrange_spec_init */
 
   174 void *visit(subrange_type_declaration_c *symbol) {
 
   176 void *visit(subrange_type_declaration_c *symbol) {
 
   175   TRACE("subrange_type_declaration_c");  
   177   TRACE("subrange_type_declaration_c");  
   176   
   178   
       
   179   current_typedefinition = subrange_td;
 
       
   180 
   177   s4o_incl.print("__DECLARE_DERIVED_TYPE(");
 
   181   s4o_incl.print("__DECLARE_DERIVED_TYPE(");
 
   178   current_basetypedeclaration = subrangebasetype_bd;
 
   182   current_basetypedeclaration = subrangebasetype_bd;
 
   179   symbol->subrange_spec_init->accept(*this);
 
   183   symbol->subrange_spec_init->accept(*this);
 
   180   current_basetypedeclaration = none_bd;
 
   184   current_basetypedeclaration = none_bd;
 
   181   s4o_incl.print(", ");
 
   185   s4o_incl.print(",");
 
   182   symbol->subrange_type_name->accept(*basedecl);
 
   186   symbol->subrange_type_name->accept(*basedecl);
 
   183   s4o_incl.print(")\n");
 
   187   s4o_incl.print(")\n");
 
   184   
   188   
   185   current_type_name = symbol->subrange_type_name;
 
   189   current_type_name = symbol->subrange_type_name;
 
   186   
   190   
   187   current_basetypedeclaration = subrangetest_bd;
 
   191   current_basetypedeclaration = subrangetest_bd;
 
   188   symbol->subrange_spec_init->accept(*this);
 
   192   symbol->subrange_spec_init->accept(*this);
 
   189   current_basetypedeclaration = none_bd;
 
   193   current_basetypedeclaration = none_bd;
 
   190   
   194   
       
   195   current_typedefinition = none_td;
 
       
   196 
   191   return NULL;
 
   197   return NULL;
 
   192 }
 
   198 }
 
   193 
   199 
   194 /* subrange_specification ASSIGN signed_integer */
 
   200 /* subrange_specification ASSIGN signed_integer */
 
   195 void *visit(subrange_spec_init_c *symbol) {
 
   201 void *visit(subrange_spec_init_c *symbol) {
 
   196   TRACE("subrange_spec_init_c");
 
   202   TRACE("subrange_spec_init_c");
 
   197   current_typedefinition = subrange_td;
 
       
   198   symbol->subrange_specification->accept(*this);
 
   203   symbol->subrange_specification->accept(*this);
 
   199   current_typedefinition = none_td;
 
       
   200   return NULL;
 
   204   return NULL;
 
   201 }
 
   205 }
 
   202 
   206 
   203 /*  integer_type_name '(' subrange')' */
 
   207 /*  integer_type_name '(' subrange')' */
 
   204 void *visit(subrange_specification_c *symbol) {
 
   208 void *visit(subrange_specification_c *symbol) {
 
   205   switch (current_basetypedeclaration) {
 
   209   if (current_typedefinition == subrange_td) {
 
   206     case subrangebasetype_bd:
 
   210     switch (current_basetypedeclaration) {
 
   207       symbol->integer_type_name->accept(*basedecl);
 
   211       case subrangebasetype_bd:
 
   208       break;
 
   212         symbol->integer_type_name->accept(*basedecl);
 
   209     case subrangetest_bd:
 
   213         break;
 
   210       if (symbol->subrange != NULL) {
 
   214       case subrangetest_bd:
 
   211         current_type_name->accept(*this);
 
   215         if (symbol->subrange != NULL) {
 
   212         s4o.print(" __CHECK_");
 
   216           current_type_name->accept(*this);
 
   213         current_type_name->accept(*this);
 
   217           s4o.print(" __CHECK_");
 
   214         s4o.print("(");
 
   218           current_type_name->accept(*this);
 
   215         current_type_name->accept(*this);
 
   219           s4o.print("(");
 
   216         s4o.print(" value) {\n");
 
   220           current_type_name->accept(*this);
 
   217         s4o.indent_right();
 
   221           s4o.print(" value) {\n");
 
   218         
   222           s4o.indent_right();
 
   219         if (search_base_type.type_is_subrange(symbol->integer_type_name)) {
 
   223 
   220           s4o.print(s4o.indent_spaces + "value = __CHECK_");
 
   224           if (search_base_type.type_is_subrange(symbol->integer_type_name)) {
 
       
   225             s4o.print(s4o.indent_spaces + "value = __CHECK_");
 
       
   226             symbol->integer_type_name->accept(*this);
 
       
   227             s4o.print("(value);\n");
 
       
   228           }
 
       
   229 
       
   230           symbol->subrange->accept(*this);
 
       
   231 
       
   232           s4o.indent_left();
 
       
   233           s4o.print("}\n");
 
       
   234         }
 
       
   235         else {
 
       
   236           s4o.print("#define __CHECK_");
 
       
   237           current_type_name->accept(*this);
 
       
   238           s4o.print(" __CHECK_");
 
   221           symbol->integer_type_name->accept(*this);
 
   239           symbol->integer_type_name->accept(*this);
 
   222           s4o.print("(value);\n");
 
   240           s4o.print("\n");
 
   223         }
 
   241         }
 
   224         
   242         break;
 
   225         symbol->subrange->accept(*this);
 
   243       default:
 
   226         
   244         break;
 
   227         s4o.indent_left();
 
   245     }
 
   228         s4o.print("}\n");
 
   246   }
 
   229       }
 
   247   else {
 
   230       else {
 
   248     symbol->integer_type_name->accept(*basedecl);
 
   231         s4o.print("#define __CHECK_");
 
       
   232         current_type_name->accept(*this);
 
       
   233         s4o.print(" __CHECK_");
 
       
   234         symbol->integer_type_name->accept(*this);
 
       
   235         s4o.print("\n");
 
       
   236       } 
       
   237       break;
 
       
   238     default:
 
       
   239       break;
 
       
   240   }
 
   249   }
 
   241   return NULL;
 
   250   return NULL;
 
   242 }
 
   251 }
 
   243 
   252 
   244 /*  signed_integer DOTDOT signed_integer */
 
   253 /*  signed_integer DOTDOT signed_integer */
 
   284 
   293 
   285 /*  enumerated_type_name ':' enumerated_spec_init */
 
   294 /*  enumerated_type_name ':' enumerated_spec_init */
 
   286 void *visit(enumerated_type_declaration_c *symbol) {
 
   295 void *visit(enumerated_type_declaration_c *symbol) {
 
   287   TRACE("enumerated_type_declaration_c");
 
   296   TRACE("enumerated_type_declaration_c");
 
   288   
   297   
       
   298   current_typedefinition = enumerated_td;
 
       
   299 
   289   s4o_incl.print("typedef enum {\n");
 
   300   s4o_incl.print("typedef enum {\n");
 
   290   s4o_incl.indent_right();
 
   301   s4o_incl.indent_right();
 
   291   symbol->enumerated_spec_init->accept(*this);
 
   302   symbol->enumerated_spec_init->accept(*this);
 
   292   s4o_incl.indent_left();
 
   303   s4o_incl.indent_left();
 
   293   s4o_incl.print("} ");
 
   304   s4o_incl.print("} ");
 
   294   symbol->enumerated_type_name->accept(*basedecl);
 
   305   symbol->enumerated_type_name->accept(*basedecl);
 
   295   s4o_incl.print(";\n");
 
   306   s4o_incl.print(";\n");
 
       
   307 
       
   308   current_typedefinition = none_td;
 
       
   309 
   296   return NULL;
 
   310   return NULL;
 
   297 }
 
   311 }
 
   298 
   312 
   299 void *visit(enumerated_spec_init_c *symbol) {
 
   313 void *visit(enumerated_spec_init_c *symbol) {
 
   300   TRACE("enumerated_spec_init_c");
 
   314   TRACE("enumerated_spec_init_c");
 
   301   symbol->enumerated_specification->accept(*this);
 
   315   if (current_typedefinition == enumerated_td)
 
       
   316     symbol->enumerated_specification->accept(*this);
 
       
   317   else
 
       
   318     symbol->enumerated_specification->accept(*basedecl);
 
   302   return NULL;
 
   319   return NULL;
 
   303 }
 
   320 }
 
   304 
   321 
   305 /* helper symbol for enumerated_specification->enumerated_spec_init */
 
   322 /* helper symbol for enumerated_specification->enumerated_spec_init */
 
   306 /* enumerated_value_list ',' enumerated_value */
 
   323 /* enumerated_value_list ',' enumerated_value */
 
   317 
   334 
   318 /*  identifier ':' array_spec_init */
 
   335 /*  identifier ':' array_spec_init */
 
   319 void *visit(array_type_declaration_c *symbol) {
 
   336 void *visit(array_type_declaration_c *symbol) {
 
   320   TRACE("array_type_declaration_c");
 
   337   TRACE("array_type_declaration_c");
 
   321   
   338   
       
   339   current_typedefinition = array_td;
 
       
   340 
   322   array_is_derived = false;
 
   341   array_is_derived = false;
 
   323   current_basetypedeclaration = arrayderiveddeclaration_bd;
 
   342   current_basetypedeclaration = arrayderiveddeclaration_bd;
 
   324   symbol->array_spec_init->accept(*this);
 
   343   symbol->array_spec_init->accept(*this);
 
   325   current_basetypedeclaration = none_bd;
 
   344   current_basetypedeclaration = none_bd;
 
   326 
   345 
   355   current_basetypedeclaration = arraytranslateindex_bd;
 
   374   current_basetypedeclaration = arraytranslateindex_bd;
 
   356   symbol->array_spec_init->accept(*this);
 
   375   symbol->array_spec_init->accept(*this);
 
   357   current_basetypedeclaration = none_bd;
 
   376   current_basetypedeclaration = none_bd;
 
   358   s4o.print("\n");
 
   377   s4o.print("\n");
 
   359   
   378   
       
   379   current_typedefinition = none_td;
 
       
   380 
   360   return NULL;
 
   381   return NULL;
 
   361 }
 
   382 }
 
   362 
   383 
   363 /* array_specification [ASSIGN array_initialization] */
 
   384 /* array_specification [ASSIGN array_initialization] */
 
   364 /* array_initialization may be NULL ! */
 
   385 /* array_initialization may be NULL ! */
 
   371     case arrayderiveddeclaration_bd:
 
   392     case arrayderiveddeclaration_bd:
 
   372       array_type_name = dynamic_cast<identifier_c *>(symbol->array_specification);
 
   393       array_type_name = dynamic_cast<identifier_c *>(symbol->array_specification);
 
   373       array_is_derived = array_type_name != NULL;
 
   394       array_is_derived = array_type_name != NULL;
 
   374       break;
 
   395       break;
 
   375     case arraytranslateindex_bd:
 
   396     case arraytranslateindex_bd:
 
   376       if (!array_is_derived) {
 
   397       if (!array_is_derived)
 
   377     	current_typedefinition = array_td;
 
       
   378     	symbol->array_specification->accept(*this);
 
   398     	symbol->array_specification->accept(*this);
 
   379     	current_typedefinition = none_td;
 
       
   380       }
 
       
   381 
   399 
   382       s4o.print("#define __");
 
   400       s4o.print("#define __");
 
   383       current_type_name->accept(*this);
 
   401       current_type_name->accept(*this);
 
   384       s4o.print("_TRANSIDX(row, index) __");
 
   402       s4o.print("_TRANSIDX(row, index) __");
 
   385       if (array_is_derived)
 
   403       if (array_is_derived)
 
   387       else
 
   405       else
 
   388          current_type_name->accept(*this);
 
   406          current_type_name->accept(*this);
 
   389       s4o.print("_TRANSIDX##row(index)");
 
   407       s4o.print("_TRANSIDX##row(index)");
 
   390       break;
 
   408       break;
 
   391     default:
 
   409     default:
 
   392       if (array_is_derived) {
 
   410       if (array_is_derived)
 
   393         symbol->array_specification->accept(*basedecl);
 
   411         symbol->array_specification->accept(*basedecl);
 
   394       }
 
   412       else
 
   395       else {
 
       
   396         current_typedefinition = array_td;
 
       
   397         symbol->array_specification->accept(*this);
 
   413         symbol->array_specification->accept(*this);
 
   398         current_typedefinition = none_td;
 
       
   399       }
 
       
   400       break;
 
   414       break;
 
   401   }
 
   415   }
 
   402   return NULL;
 
   416   return NULL;
 
   403 }
 
   417 }
 
   404 
   418 
   528 /*  structure_type_name ':' structure_specification */
 
   542 /*  structure_type_name ':' structure_specification */
 
   529 //SYM_REF2(structure_type_declaration_c, structure_type_name, structure_specification)
 
   543 //SYM_REF2(structure_type_declaration_c, structure_type_name, structure_specification)
 
   530 void *visit(structure_type_declaration_c *symbol) {
 
   544 void *visit(structure_type_declaration_c *symbol) {
 
   531   TRACE("structure_type_declaration_c");
 
   545   TRACE("structure_type_declaration_c");
 
   532 
   546 
       
   547   current_typedefinition = struct_td;
 
       
   548 
   533   s4o_incl.print("__DECLARE_STRUCT_TYPE(");
 
   549   s4o_incl.print("__DECLARE_STRUCT_TYPE(");
 
   534   symbol->structure_specification->accept(*this);
 
   550   symbol->structure_specification->accept(*this);
 
   535   s4o_incl.print(",");
 
   551   s4o_incl.print(",");
 
   536   symbol->structure_type_name->accept(*basedecl);
 
   552   symbol->structure_type_name->accept(*basedecl);
 
   537   s4o_incl.print(");\n");
 
   553   s4o_incl.print(");\n");
 
       
   554 
       
   555   current_typedefinition = none_td;
 
       
   556 
   538   return NULL;
 
   557   return NULL;
 
   539 }
 
   558 }
 
   540 
   559 
   541 /* structure_type_name ASSIGN structure_initialization */
 
   560 /* structure_type_name ASSIGN structure_initialization */
 
   542 /* structure_initialization may be NULL ! */
 
   561 /* structure_initialization may be NULL ! */
matiec