stage4/generate_c/generate_c_typedecl.cc
changeset 328 66cd5d9893dd
parent 327 da78d0d93c75
child 329 882f5f1e5f6f
equal deleted inserted replaced
327:da78d0d93c75 328:66cd5d9893dd
    30 
    30 
    31   private:
    31   private:
    32     symbol_c* current_type_name;
    32     symbol_c* current_type_name;
    33     bool array_is_derived;
    33     bool array_is_derived;
    34     search_base_type_c search_base_type;
    34     search_base_type_c search_base_type;
       
    35     search_constant_type_c search_constant_type;
    35 
    36 
    36     generate_c_base_c *basedecl;
    37     generate_c_base_c *basedecl;
    37 
    38 
    38   public:
    39   public:
    39     generate_c_typedecl_c(stage4out_c *s4o_ptr, stage4out_c *s4o_incl_ptr): generate_c_base_c(s4o_ptr), s4o_incl(*s4o_incl_ptr) {
    40     generate_c_typedecl_c(stage4out_c *s4o_ptr, stage4out_c *s4o_incl_ptr): generate_c_base_c(s4o_ptr), s4o_incl(*s4o_incl_ptr) {
    40       current_typedefinition = none_td;
    41       current_typedefinition = none_td;
    41       current_basetypedeclaration = none_bd;
    42       current_basetypedeclaration = none_bd;
       
    43       current_type_name = NULL;
    42       basedecl = new generate_c_base_c(&s4o_incl);
    44       basedecl = new generate_c_base_c(&s4o_incl);
    43     }
    45     }
    44     generate_c_typedecl_c(stage4out_c *s4o_ptr): generate_c_base_c(s4o_ptr), s4o_incl(*s4o_ptr) {
    46     generate_c_typedecl_c(stage4out_c *s4o_ptr): generate_c_base_c(s4o_ptr), s4o_incl(*s4o_ptr) {
    45       current_typedefinition = none_td;
    47       current_typedefinition = none_td;
    46       current_basetypedeclaration = none_bd;
    48       current_basetypedeclaration = none_bd;
       
    49       current_type_name = NULL;
    47       basedecl = new generate_c_base_c(&s4o_incl);
    50       basedecl = new generate_c_base_c(&s4o_incl);
    48     }
    51     }
    49     ~generate_c_typedecl_c(void) {
    52     ~generate_c_typedecl_c(void) {
    50       delete basedecl;
    53       delete basedecl;
    51     }
    54     }
   175 /*  subrange_type_name ':' subrange_spec_init */
   178 /*  subrange_type_name ':' subrange_spec_init */
   176 void *visit(subrange_type_declaration_c *symbol) {
   179 void *visit(subrange_type_declaration_c *symbol) {
   177   TRACE("subrange_type_declaration_c");  
   180   TRACE("subrange_type_declaration_c");  
   178   
   181   
   179   current_typedefinition = subrange_td;
   182   current_typedefinition = subrange_td;
       
   183   current_type_name = symbol->subrange_type_name;
   180 
   184 
   181   s4o_incl.print("__DECLARE_DERIVED_TYPE(");
   185   s4o_incl.print("__DECLARE_DERIVED_TYPE(");
   182   symbol->subrange_type_name->accept(*basedecl);
   186   current_type_name->accept(*basedecl);
   183   s4o_incl.print(",");
   187   s4o_incl.print(",");
   184   current_basetypedeclaration = subrangebasetype_bd;
   188   current_basetypedeclaration = subrangebasetype_bd;
   185   symbol->subrange_spec_init->accept(*this);
   189   symbol->subrange_spec_init->accept(*this);
   186   current_basetypedeclaration = none_bd;
   190   current_basetypedeclaration = none_bd;
   187   s4o_incl.print(")\n");
   191   s4o_incl.print(")\n");
   188   
   192   
   189   current_type_name = symbol->subrange_type_name;
       
   190   
       
   191   current_basetypedeclaration = subrangetest_bd;
   193   current_basetypedeclaration = subrangetest_bd;
   192   symbol->subrange_spec_init->accept(*this);
   194   symbol->subrange_spec_init->accept(*this);
   193   current_basetypedeclaration = none_bd;
   195   current_basetypedeclaration = none_bd;
   194   
   196   
       
   197   current_type_name = NULL;
   195   current_typedefinition = none_td;
   198   current_typedefinition = none_td;
   196 
   199 
   197   return NULL;
   200   return NULL;
   198 }
   201 }
   199 
   202 
   294 /*  enumerated_type_name ':' enumerated_spec_init */
   297 /*  enumerated_type_name ':' enumerated_spec_init */
   295 void *visit(enumerated_type_declaration_c *symbol) {
   298 void *visit(enumerated_type_declaration_c *symbol) {
   296   TRACE("enumerated_type_declaration_c");
   299   TRACE("enumerated_type_declaration_c");
   297   
   300   
   298   current_typedefinition = enumerated_td;
   301   current_typedefinition = enumerated_td;
       
   302   current_type_name = symbol->enumerated_type_name;
   299 
   303 
   300   s4o_incl.print("__DECLARE_ENUMERATED_TYPE(");
   304   s4o_incl.print("__DECLARE_ENUMERATED_TYPE(");
   301   symbol->enumerated_type_name->accept(*basedecl);
   305   current_type_name->accept(*basedecl);
   302   s4o_incl.print(",\n");
   306   s4o_incl.print(",\n");
   303   s4o_incl.indent_right();
   307   s4o_incl.indent_right();
   304   symbol->enumerated_spec_init->accept(*this);
   308   symbol->enumerated_spec_init->accept(*this);
   305   s4o_incl.indent_left();
   309   s4o_incl.indent_left();
   306   s4o_incl.print(")\n");
   310   s4o_incl.print(")\n");
   307 
   311 
       
   312   current_type_name = NULL;
   308   current_typedefinition = none_td;
   313   current_typedefinition = none_td;
   309 
   314 
   310   return NULL;
   315   return NULL;
   311 }
   316 }
   312 
   317 
       
   318 /* enumerated_specification ASSIGN enumerated_value */
   313 void *visit(enumerated_spec_init_c *symbol) {
   319 void *visit(enumerated_spec_init_c *symbol) {
   314   TRACE("enumerated_spec_init_c");
   320   TRACE("enumerated_spec_init_c");
   315   if (current_typedefinition == enumerated_td)
   321   if (current_typedefinition == enumerated_td)
   316     symbol->enumerated_specification->accept(*this);
   322     symbol->enumerated_specification->accept(*this);
   317   else
   323   else
   326   return NULL;
   332   return NULL;
   327 }
   333 }
   328 
   334 
   329 /* enumerated_type_name '#' identifier */
   335 /* enumerated_type_name '#' identifier */
   330 void *visit(enumerated_value_c *symbol) {
   336 void *visit(enumerated_value_c *symbol) {
       
   337   symbol_c *value_type;
       
   338   if (current_typedefinition == enumerated_td)
       
   339     current_type_name->accept(*basedecl);
       
   340   else {
       
   341     value_type = (symbol_c *)symbol->accept(search_constant_type);
       
   342     if (value_type == NULL) ERROR;
       
   343 
       
   344     value_type->accept(*basedecl);
       
   345   }
       
   346   s4o_incl.print("_");
   331   symbol->value->accept(*basedecl);
   347   symbol->value->accept(*basedecl);
   332   return NULL;
   348   return NULL;
   333 }
   349 }
   334 
   350 
   335 /*  identifier ':' array_spec_init */
   351 /*  identifier ':' array_spec_init */
   336 void *visit(array_type_declaration_c *symbol) {
   352 void *visit(array_type_declaration_c *symbol) {
   337   TRACE("array_type_declaration_c");
   353   TRACE("array_type_declaration_c");
   338   
   354   
   339   current_typedefinition = array_td;
   355   current_typedefinition = array_td;
       
   356   current_type_name = symbol->identifier;
   340 
   357 
   341   array_is_derived = false;
   358   array_is_derived = false;
   342   current_basetypedeclaration = arrayderiveddeclaration_bd;
   359   current_basetypedeclaration = arrayderiveddeclaration_bd;
   343   symbol->array_spec_init->accept(*this);
   360   symbol->array_spec_init->accept(*this);
   344   current_basetypedeclaration = none_bd;
   361   current_basetypedeclaration = none_bd;
   345 
   362 
   346   if (array_is_derived)
   363   if (array_is_derived)
   347 	s4o_incl.print("__DECLARE_DERIVED_TYPE(");
   364 	s4o_incl.print("__DECLARE_DERIVED_TYPE(");
   348   else
   365   else
   349 	s4o_incl.print("__DECLARE_ARRAY_TYPE(");
   366 	s4o_incl.print("__DECLARE_ARRAY_TYPE(");
   350   symbol->identifier->accept(*basedecl);
   367   current_type_name->accept(*basedecl);
   351   s4o_incl.print(",");
   368   s4o_incl.print(",");
   352   current_basetypedeclaration = arraybasetypeincl_bd;
   369   current_basetypedeclaration = arraybasetypeincl_bd;
   353   symbol->array_spec_init->accept(*this);
   370   symbol->array_spec_init->accept(*this);
   354   current_basetypedeclaration = none_bd;
   371   current_basetypedeclaration = none_bd;
   355   if (!array_is_derived) {
   372   if (!array_is_derived) {
   360   }
   377   }
   361   s4o_incl.print(")\n");
   378   s4o_incl.print(")\n");
   362 
   379 
   363   if (search_base_type.type_is_subrange(symbol->identifier)) {
   380   if (search_base_type.type_is_subrange(symbol->identifier)) {
   364 	s4o.print("#define __CHECK_");
   381 	s4o.print("#define __CHECK_");
   365 	symbol->identifier->accept(*this);
   382 	current_type_name->accept(*this);
   366 	s4o.print(" __CHECK_");
   383 	s4o.print(" __CHECK_");
   367 	current_basetypedeclaration = arraybasetype_bd;
   384 	current_basetypedeclaration = arraybasetype_bd;
   368 	symbol->array_spec_init->accept(*this);
   385 	symbol->array_spec_init->accept(*this);
   369 	current_basetypedeclaration = none_bd;
   386 	current_basetypedeclaration = none_bd;
   370 	s4o.print("\n");
   387 	s4o.print("\n");
   371   }
   388   }
   372 
   389 
   373   current_type_name = symbol->identifier;
       
   374   current_basetypedeclaration = arraytranslateindex_bd;
   390   current_basetypedeclaration = arraytranslateindex_bd;
   375   symbol->array_spec_init->accept(*this);
   391   symbol->array_spec_init->accept(*this);
   376   current_basetypedeclaration = none_bd;
   392   current_basetypedeclaration = none_bd;
   377   s4o.print("\n");
   393   s4o.print("\n");
   378 
   394 
       
   395   current_type_name = NULL;
   379   current_typedefinition = none_td;
   396   current_typedefinition = none_td;
   380 
   397 
   381   return NULL;
   398   return NULL;
   382 }
   399 }
   383 
   400