600   /* leave for derived classes... */

   635 

   601 

   602   

   739 SYM_REF2(array_variable_c, subscripted_variable, subscript_list)

   680 //SYM_REF2(array_variable_c, subscripted_variable, subscript_list)

   740 

   681 

   741 #endif

   848 

   788 /************************************************************************************************/

   849 

   789 /************************************************************************************************/

   850 

   790 /************************************************************************************************/

   851 

   791 /************************************************************************************************/

   852 

   792 /************************************************************************************************/

   853 

   793 /************************************************************************************************/

   854 

   794 /************************************************************************************************/

   795 /************************************************************************************************/

   796 /************************************************************************************************/

   797 /************************************************************************************************/

   798 

   799 

   800 

   801 /* generate_c_base_and_typeid_c

   802  * ----------------------------

   803  *   This is similar to the generate_c_base_c (from which it inherits), but it also handles

   804  *   all the derived datatypes. Note that it does not generate C code for the declaration of

   805  *   those datatypes (that is what generate_c_typedecl_c is for), but rather it merely

   806  *   generates the name/id of a derived datatype.

   807  *   Note too that not all derived datatypes in the IEC 61131-3 have a name (for example, 

   808  *   VAR a: ARRAY [3..5] of INT END_VAR), in which case an alias for this datatype should 

   809  *   have been previously generated by either generate_c_typedecl_c or generate_implicit_typedecl_c.

   810  */

   811 class generate_c_base_and_typeid_c: public generate_c_base_c {

   812 

   813   public:

   814      generate_c_base_and_typeid_c(stage4out_c *s4o_ptr): generate_c_base_c(s4o_ptr) {}

   815     ~generate_c_base_and_typeid_c(void) {}

   816 

   817 

   818 /*************************/

   819 /* B.1 - Common elements */

   820 /*************************/

   821 /*******************************************/

   822 /* B 1.1 - Letters, digits and identifiers */

   823 /*******************************************/

   824     void *visit(derived_datatype_identifier_c *symbol) {

   825       if (get_datatype_info_c::is_array(symbol->datatype)) {

   826         return symbol->datatype->accept(*this);

   827       }

   828       return print_token(symbol);

   829     }

   830 

   831 /*********************/

   832 /* B 1.2 - Constants */

   833 /*********************/

   834 /**********************/

   835 /* B.1.3 - Data types */

   836 /**********************/

   837 /***********************************/

   838 /* B 1.3.1 - Elementary Data Types */

   839 /***********************************/

   840 /********************************/

   841 /* B.1.3.2 - Generic data types */

   842 /********************************/

   843     /* Currently only used in REF_TO ANY, which is mapped onto (void *) */

   844     void *visit(generic_type_any_c *symbol)      {s4o.print("void");    return NULL;}

   845 

   846 /********************************/

   847 /* B 1.3.3 - Derived data types */

   848 /********************************/

   849 

   850 /*  subrange_type_name ':' subrange_spec_init */

   851 void *visit(subrange_type_declaration_c *symbol) {return symbol->subrange_type_name->accept(*this);}

   852 

   853 /* subrange_specification ASSIGN signed_integer */

   854 void *visit(subrange_spec_init_c *symbol) {return symbol->subrange_specification->accept(*this);}

   855 

   856 /*  integer_type_name '(' subrange')' */

   857 void *visit(subrange_specification_c *symbol) {return symbol->integer_type_name->accept(*this);}

   858 

   859 /*  enumerated_type_name ':' enumerated_spec_init */

   860 void *visit(enumerated_type_declaration_c *symbol) {return symbol->enumerated_type_name->accept(*this);}

   861 

   862 /* enumerated_specification ASSIGN enumerated_value */

   863 void *visit(enumerated_spec_init_c *symbol) {return symbol->enumerated_specification->accept(*this);}

   864 

   865 

   866 /* enumerated_type_name '#' identifier */

   867 /* Handled by generate_c_base_c class!!

   868 void *visit(enumerated_value_c *symbol) {}

   869 */

   870 

   871 /*  identifier ':' array_spec_init */

   872 void *visit(array_type_declaration_c *symbol) {

   873   int implicit_id_count = symbol->anotations_map.count("generate_c_annotaton__implicit_type_id");

   874   if (1 != implicit_id_count) ERROR;

   875   return symbol->anotations_map["generate_c_annotaton__implicit_type_id"]->accept(*this);

   876 }

   877 

   878 

   879 

   880 /* array_specification [ASSIGN array_initialization] */

   881 /* array_initialization may be NULL ! */

   882 void *visit(array_spec_init_c *symbol) {

   883   int implicit_id_count = symbol->anotations_map.count("generate_c_annotaton__implicit_type_id");

   884   if (1 == implicit_id_count) return symbol->anotations_map["generate_c_annotaton__implicit_type_id"]->accept(*this);

   885   if (0 == implicit_id_count) return symbol->datatype->accept(*this);

   886   return NULL;

   887 }

   888 

   889 /* ARRAY '[' array_subrange_list ']' OF non_generic_type_name */

   890 void *visit(array_specification_c *symbol) {

   891   int implicit_id_count = symbol->anotations_map.count("generate_c_annotaton__implicit_type_id");

   892   if (1 != implicit_id_count) ERROR;

   893   return symbol->anotations_map["generate_c_annotaton__implicit_type_id"]->accept(*this);

   894 }

   895 

   896 

   897 

   898 /*  simple_type_name ':' simple_spec_init */

   899 void *visit(simple_type_declaration_c *symbol) {return symbol->simple_type_name->accept(*this);}

   900 

   901 /* simple_specification [ASSIGN constant] */

   902 //SYM_REF2(simple_spec_init_c, simple_specification, constant)

   903 // <constant> may be NULL

   904 void *visit(simple_spec_init_c *symbol) {return symbol->simple_specification->accept(*this);}

   905 

   906 /*  structure_type_name ':' structure_specification */

   907 //SYM_REF2(structure_type_declaration_c, structure_type_name, structure_specification)

   908 void *visit(structure_type_declaration_c *symbol) {return symbol->structure_type_name->accept(*this);}

   909 

   910 /* structure_type_name ASSIGN structure_initialization */

   911 /* structure_initialization may be NULL ! */

   912 //SYM_REF2(initialized_structure_c, structure_type_name, structure_initialization)

   913 void *visit(initialized_structure_c *symbol) {return symbol->structure_type_name->accept(*this);}

   914 

   915 

   916 

   917 /* ref_spec:  REF_TO (non_generic_type_name | function_block_type_name) */

   918 // SYM_REF1(ref_spec_c, type_name)

   919 void *visit(ref_spec_c *symbol) { 

   920   int implicit_id_count = symbol->anotations_map.count("generate_c_annotaton__implicit_type_id");

   921   if (implicit_id_count  > 1) ERROR;

   922   if (implicit_id_count == 1) {

   923       /* this is part of an implicitly declared datatype (i.e. inside a variable decaration), for which an equivalent C datatype

   924        * has already been defined. So, we simly print out the id of that C datatpe...

   925        */

   926     return symbol->anotations_map["generate_c_annotaton__implicit_type_id"]->accept(*this);

   927   }

   928   /* This is NOT part of an implicitly declared datatype (i.e. we are being called from an visit(ref_type_decl_c *),

   929    * through the visit(ref_spec_init_c*)), so we need to simply print out the name of the datatype we reference to.

   930    */

   931   //debug_c::print(symbol); ERROR;

   932   symbol->type_name->accept(*this);

   933   s4o.print("*");

   934   return NULL;

   935 }

   936 

   937 /* For the moment, we do not support initialising reference data types */

   938 /* ref_spec_init: ref_spec [ ASSIGN ref_initialization ] */ 

   939 /* NOTE: ref_initialization may be NULL!! */

   940 // SYM_REF2(ref_spec_init_c, ref_spec, ref_initialization)

   941 void *visit(ref_spec_init_c *symbol) {

   942   /* NOTE  An ref_type_decl_c will be created in stage4 for each implicitly defined REF_TO datatype,

   943    *       and this generate_c_typedecl_c will be called to define that REF_TO datatype in C.

   944    *       However, every implictly defined REF_TO datatype with the exact same parameters will be mapped

   945    *       to the same identifier (e.g: __REF_TO_INT).

   946    *       In order for the C compiler not to find the same datatype being defined two or more times, 

   947    *       we will keep track of the datatypes that have already been declared, and henceforth

   948    *       only declare the datatypes that have not been previously defined.

   949    */

   950   int implicit_id_count = symbol->anotations_map.count("generate_c_annotaton__implicit_type_id");

   951   if (1  < implicit_id_count) ERROR;

   952   if (1 == implicit_id_count)

   953     return symbol->anotations_map["generate_c_annotaton__implicit_type_id"]->accept(*this);

   954   return symbol->ref_spec->accept(*this); // this is probably pointing to an identifier_c !!

   955 }

   956 

   957 /* ref_type_decl: identifier ':' ref_spec_init */

   958 // SYM_REF2(ref_type_decl_c, ref_type_name, ref_spec_init)

   959 void *visit(ref_type_decl_c *symbol) {

   960   TRACE("ref_type_decl_c");

   961   /* NOTE  An ref_type_decl_c will be created in stage4 for each implicitly defined REF_TO datatype,

   962    *       and this generate_c_typedecl_c will be called to define that REF_TO datatype in C.

   963    *       However, every implictly defined REF_TO datatype with the exact same parameters will be mapped

   964    *       to the same identifier (e.g: __REF_TO_INT).

   965    *       In order for the C compiler not to find the same datatype being defined two or more times, 

   966    *       we will keep track of the datatypes that have already been declared, and henceforth

   967    *       only declare the datatypes that have not been previously defined.

   968    */

   969   int implicit_id_count = symbol->anotations_map.count("generate_c_annotaton__implicit_type_id");

   970   if (0 != implicit_id_count) ERROR;

   971   //symbol->anotations_map["generate_c_annotaton__implicit_type_id"]->accept(generate_c_base);

   972   return symbol->ref_type_name->accept(*this);

   973 }

   974 

   975 

   976 }; /* class generate_c_base_and_typeid_c */

   977 

   978 

   979 

   980 

   981 

   982 

   983 

   984 

   985 

   986 

   987 

   988 

   989