1 /*

     2  * (c) 2003 Mario de Sousa

     3  *

     4  * Offered to the public under the terms of the GNU General Public License

     5  * as published by the Free Software Foundation; either version 2 of the

     6  * License, or (at your option) any later version.

     7  *

     8  * This program is distributed in the hope that it will be useful, but

     9  * WITHOUT ANY WARRANTY; without even the implied warranty of

    10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General

    11  * Public License for more details.

    12  *

    13  * This code is made available on the understanding that it will not be

    14  * used in safety-critical situations without a full and competent review.

    15  */

    16 

    17 /*

    18  * An IEC 61131-3 IL and ST compiler.

    19  *

    20  * Based on the

    21  * FINAL DRAFT - IEC 61131-3, 2nd Ed. (2001-12-10)

    22  *

    23  */

    24 

    25 

    26 /*

    27  * Conversion of variable declaration constructs.

    28  *

    29  * This is part of the 4th stage that generates

    30  * a c++ source program equivalent to the IL and ST

    31  * code.

    32  */

    33 

    34 

    35 

    36 

    37 //#include <stdio.h>  /* required for NULL */

    38 //#include <string>

    39 //#include <iostream>

    40 

    41 //#include "../../util/symtable.hh"

    42 

    43 

    44 

    45 

    46 

    47 

    48 

    49 

    50 

    51 /***********************************************************************/

    52 /***********************************************************************/

    53 /***********************************************************************/

    54 /***********************************************************************/

    55 /***********************************************************************/

    56 /***********************************************************************/

    57 /***********************************************************************/

    58 /***********************************************************************/

    59 

    60 

    61 

    62 

    63 class generate_cc_vardecl_c: protected generate_cc_typedecl_c {

    64 

    65   /* A Helper class to the main class... */

    66   /* print a string, except the first time it is called */

    67   /* used to print the separator "," before each variable

    68    * declaration, except the first...

    69    *

    70    * Needs to be done in a seperate class because this is called

    71    * from within various locations within the code.

    72    */

    73   class next_var_c {

    74     private:

    75       bool print_flag;

    76       std::string str1, str2;

    77 

    78       next_var_c *embedded_scope;

    79 

    80     public:

    81       next_var_c(std::string s1, std::string s2) {

    82         str1 = s1;

    83         str2 = s2;

    84         print_flag = false;

    85         embedded_scope = NULL;

    86       }

    87 

    88       std::string get(void) {

    89         if (NULL != embedded_scope)

    90           return embedded_scope->get();

    91 

    92         bool old_print_flag = print_flag;

    93         print_flag = true;

    94         if (!old_print_flag)

    95           return str1;

    96         else

    97           return str2;

    98       }

    99 

   100       /* Create a new next_var_c for an embedded scope.

   101        * From now on, every call to get() will return the

   102        * inner-most scope...!

   103        */

   104       void push(std::string s1, std::string s2) {

   105         if (NULL != embedded_scope)

   106           return embedded_scope->push(s1, s2);

   107 

   108         embedded_scope = new next_var_c(s1, s2);

   109         if (NULL == embedded_scope)

   110           ERROR;

   111         return;

   112       }

   113 

   114       /* Remove the inner-most scope... */

   115       void pop(void) {

   116         if (NULL != embedded_scope)

   117           return embedded_scope->pop();

   118 

   119         delete embedded_scope;

   120         embedded_scope = NULL;

   121       }

   122   };

   123 

   124   private:

   125     /* used to generate the ',' separating the parameters in a function call */

   126     next_var_c *nv;

   127 

   128 

   129   public:

   130     /* the types of variables that need to be processed... */

   131     static const unsigned int none_vt	  = 0x0000;

   132     static const unsigned int input_vt	  = 0x0001;  // VAR_INPUT

   133     static const unsigned int output_vt	  = 0x0002;  // VAR_OUTPUT

   134     static const unsigned int inoutput_vt = 0x0004;  // VAR_IN_OUT

   135     static const unsigned int private_vt  = 0x0008;  // VAR

   136     static const unsigned int temp_vt	  = 0x0010;  // VAR_TEMP

   137     static const unsigned int external_vt = 0x0020;  // VAR_EXTERNAL

   138     static const unsigned int global_vt   = 0x0040;  // VAR_GLOBAL

   139 						     //    Globals declared inside a resource will not be declared

   140 						     //    unless global_vt is acompanied by resource_vt

   141     static const unsigned int located_vt  = 0x0080;  // VAR <var_name> AT <location>

   142     static const unsigned int program_vt  = 0x0100;  // PROGRAM (inside a configuration!)

   143 						     //    Programs declared inside a resource will not be declared

   144 						     //    unless program_vt is acompanied by resource_vt

   145 

   146     static const unsigned int resource_vt = 0x8000;  // RESOURCE (inside a configuration!)

   147                                                      //    This, just of itself, will not print out any declarations!!

   148 						     //    It must be acompanied by either program_vt and/or global_vt

   149 

   150     /* How variables should be declared: as local variables or

   151      * variables within a function call interface.

   152      *

   153      * This will define the format of the output generated

   154      * by this class.

   155      *

   156      * finterface_vf: function interface parameters

   157      *               e.g.  f(  int a, long b, real c );

   158      *                         ---------------------

   159      *               This class/function will produce the

   160      *               underlined code of the above examples,

   161      *               and no more!!

   162      *

   163      * localinit_vf: local declaration. Will include variable

   164      *           initialisation if it is not a located variable.

   165      *           e.g.

   166      *                int a = 9;

   167      *                long b = 99;

   168      *                real c = 99.9;

   169      *

   170      * local_vf: local declaration. Will NOT include variable

   171      *           initialisation.

   172      *           e.g.

   173      *                int a;

   174      *                long b;

   175      *                real c;

   176      *

   177      * init_vf: local initialisation without declaration.

   178      *           e.g.

   179      *                a = 9;

   180      *                b = 99;

   181      *                c = 99.9;

   182      *

   183      * constructorinit_vf: initialising of member variables...

   184      *                e.g. for a constructor...

   185      *                class_name_c(void)

   186      *                : a(9), b(99), c(99.9)  { // code... }

   187      *                  --------------------

   188      *               This class/function will produce the

   189      *               underlined code of the above examples,

   190      *               and no more!!

   191      *

   192      * globalinit_vf: initialising of static c++ variables. These

   193      *                variables may have been declared as static inside

   194      *                a class, in which case the scope within which they were

   195      *                previously delcared must be passed as the second parameter

   196      *                to the print() function.

   197      *

   198      *                e.g.

   199      *                __plc_pt_c<INT, 8*sizeof(INT)> START_P::loc = __plc_pt_c<INT, 8*sizeof(INT)>("I2");

   200      */

   201     typedef enum {finterface_vf,

   202                     local_vf,

   203                     localstatic_vf,

   204 		    localinit_vf,

   205 		    init_vf,

   206 		    constructorinit_vf,

   207 		    globalinit_vf

   208 		   } varformat_t;

   209 

   210 

   211   private:

   212     /* variable used to store the types of variables that need to be processed... */

   213     /* Only set in the constructor...! */

   214     /* Will contain a set of values of generate_cc_vardecl_c::XXXX_vt */

   215     unsigned int wanted_vartype;

   216     /* variable used to store the type of variable currently being processed... */

   217     /* Will contain a single value of generate_cc_vardecl_c::XXXX_vt */

   218     unsigned int current_vartype;

   219 

   220     /* How variables should be declared: as local variables or

   221      * variables within a function interface...

   222      */

   223     /* Only set in the constructor...! */

   224     varformat_t wanted_varformat;

   225 

   226     /* The number of variables already declared. */

   227     /* Used to declare 'void' in case no variables are declared in a function interface... */

   228     int finterface_var_count;

   229 

   230 

   231 

   232     /* Holds the references to the type and initial value

   233      * of the variables currently being declared.

   234      * Please read the comment under var1_init_decl_c for further

   235      * details...

   236      *

   237      * We make an effort to keep these pointers pointing to NULL

   238      * whenever we are outside the scope of variable declaration

   239      * (i.e. when we are traversing a part of the parse tree which

   240      * is not part of variable declaration) in order tio try to catch

   241      * any bugs as soon as possible.

   242      */

   243     symbol_c *current_var_type_symbol;

   244     symbol_c *current_var_init_symbol;

   245     void update_type_init(symbol_c *symbol /* a spec_init_c, subrange_spec_init_c, etc... */ ) {

   246       this->current_var_type_symbol = spec_init_sperator_c::get_spec(symbol);

   247       this->current_var_init_symbol = spec_init_sperator_c::get_init(symbol);

   248       if (NULL == this->current_var_type_symbol)

   249         ERROR;

   250       if (NULL == this->current_var_init_symbol) {

   251         /* We try to find the data type's default value... */

   252         this->current_var_init_symbol = (symbol_c *)this->current_var_type_symbol->accept(*type_initial_value_c::instance());

   253       /* Note that Function Block 'data types' do not have a default value, so we cannot abort if no default value is found! */

   254       /*

   255       if (NULL == this->current_var_init_symbol)

   256         ERROR;

   257       */

   258       }

   259     }

   260 

   261     void void_type_init(void) {

   262       this->current_var_type_symbol = NULL;

   263       this->current_var_init_symbol = NULL;

   264     }

   265 

   266     /* Only used when wanted_varformat == globalinit_vf

   267      * Holds a pointer to an identifier_c, which in turns contains

   268      * the identifier of the scope within which the static member was

   269      * declared.

   270      */

   271     symbol_c *globalnamespace;

   272 

   273     /* Actually produce the output where variables are declared... */

   274     /* Note that located variables are the exception, they

   275      * being declared in the located_var_decl_c visitor...

   276      */

   277     void *declare_variables(symbol_c *symbol, bool is_fb = false) {

   278       list_c *list = dynamic_cast<list_c *>(symbol);

   279       /* should NEVER EVER occur!! */

   280       if (list == NULL) ERROR;

   281 

   282       /* now to produce the c equivalent... */

   283       if ((wanted_varformat == local_vf) ||

   284           (wanted_varformat == init_vf) ||

   285           (wanted_varformat == localinit_vf)) {

   286         for(int i = 0; i < list->n; i++) {

   287           s4o.print(s4o.indent_spaces);

   288           if (wanted_varformat != init_vf) {

   289             this->current_var_type_symbol->accept(*this);

   290             s4o.print(" ");

   291           }

   292           print_variable_prefix();

   293           list->elements[i]->accept(*this);

   294           if (wanted_varformat != local_vf) {

   295             if (this->current_var_init_symbol != NULL) {

   296               s4o.print(" = ");

   297               this->current_var_init_symbol->accept(*this);

   298             }

   299           }

   300           s4o.print(";\n");

   301         }

   302       }

   303 

   304       if (wanted_varformat == finterface_vf) {

   305         for(int i = 0; i < list->n; i++) {

   306           finterface_var_count++;

   307           s4o.print(nv->get());

   308           s4o.print("\n" + s4o.indent_spaces);

   309           this->current_var_type_symbol->accept(*this);

   310           if ((current_vartype & (output_vt | inoutput_vt)) != 0)

   311             s4o.print(" &");

   312           else

   313             s4o.print(" ");

   314           list->elements[i]->accept(*this);

   315           /* We do not print the initial value at function declaration!

   316            * It is up to the caller to pass the correct default value

   317            * if none is specified in the ST source code

   318            */

   319           /* if (this->current_var_init_symbol != NULL) {

   320                s4o.print(" = "); this->current_var_init_symbol->accept(*this);}

   321            */

   322         }

   323       }

   324 

   325       if (wanted_varformat == constructorinit_vf) {

   326         for(int i = 0; i < list->n; i++) {

   327           if (is_fb) {

   328             s4o.print(nv->get());

   329             this->current_var_type_symbol->accept(*this);

   330             s4o.print(FB_INIT_SUFFIX);

   331             s4o.print("(&");

   332             this->print_variable_prefix();

   333             list->elements[i]->accept(*this);

   334             s4o.print(");");

   335           }

   336           else if (this->current_var_init_symbol != NULL) {

   337             s4o.print(nv->get());

   338             this->print_variable_prefix();

   339             list->elements[i]->accept(*this);

   340             s4o.print(" = ");

   341             this->current_var_init_symbol->accept(*this);

   342             s4o.print(";");

   343           }

   344         }

   345       }

   346 

   347       return NULL;

   348     }

   349 

   350 

   351 

   352 

   353   public:

   354     generate_cc_vardecl_c(stage4out_c *s4o_ptr, varformat_t varformat, unsigned int vartype)

   355     : generate_cc_typedecl_c(s4o_ptr) {

   356       wanted_varformat = varformat;

   357       wanted_vartype   = vartype;

   358       current_vartype  = none_vt;

   359       current_var_type_symbol = NULL;

   360       current_var_init_symbol = NULL;

   361       globalnamespace         = NULL;

   362       nv = NULL;

   363     }

   364 

   365     ~generate_cc_vardecl_c(void) {}

   366 

   367 

   368     void print(symbol_c *symbol, symbol_c *scope = NULL, const char *variable_prefix = NULL) {

   369       this->set_variable_prefix(variable_prefix);

   370       if (globalinit_vf == wanted_varformat)

   371         globalnamespace = scope;

   372 

   373       finterface_var_count = 0;

   374 

   375       switch (wanted_varformat) {

   376         case constructorinit_vf: nv = new next_var_c("", "\n"+s4o.indent_spaces); break;

   377         case finterface_vf:      /* fall through... */

   378         case localinit_vf:       /* fall through... */

   379         case local_vf:           nv = new next_var_c("", ", "); break;

   380         default:                 nv = NULL;

   381       } /* switch() */

   382 

   383       symbol->accept(*this);

   384 

   385       /* special case... */

   386       if (wanted_varformat == finterface_vf)

   387         if (finterface_var_count == 0)

   388           s4o.print("void");

   389 

   390       delete nv;

   391       nv = NULL;

   392       globalnamespace = NULL;

   393     }

   394 

   395 

   396   protected:

   397 /***************************/

   398 /* B 0 - Programming Model */

   399 /***************************/

   400   /* leave for derived classes... */

   401 

   402 /*************************/

   403 /* B.1 - Common elements */

   404 /*************************/

   405 /*******************************************/

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

   407 /*******************************************/

   408   /* done in base class(es) */

   409 

   410 /*********************/

   411 /* B 1.2 - Constants */

   412 /*********************/

   413   /* originally empty... */

   414 

   415 /******************************/

   416 /* B 1.2.1 - Numeric Literals */

   417 /******************************/

   418   /* done in base class(es) */

   419 

   420 /*******************************/

   421 /* B.1.2.2   Character Strings */

   422 /*******************************/

   423   /* done in base class(es) */

   424 

   425 /***************************/

   426 /* B 1.2.3 - Time Literals */

   427 /***************************/

   428 /************************/

   429 /* B 1.2.3.1 - Duration */

   430 /************************/

   431   /* done in base class(es) */

   432 

   433 /************************************/

   434 /* B 1.2.3.2 - Time of day and Date */

   435 /************************************/

   436   /* done in base class(es) */

   437 

   438 /**********************/

   439 /* B.1.3 - Data types */

   440 /**********************/

   441 /***********************************/

   442 /* B 1.3.1 - Elementary Data Types */

   443 /***********************************/

   444   /* done in base class(es) */

   445 

   446 /********************************/

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

   448 /********************************/

   449   /* originally empty... */

   450 

   451 /********************************/

   452 /* B 1.3.3 - Derived data types */

   453 /********************************/

   454   /* done in base class(es) */

   455 

   456 /*********************/

   457 /* B 1.4 - Variables */

   458 /*********************/

   459   /* done in base class(es) */

   460 

   461 /********************************************/

   462 /* B.1.4.1   Directly Represented Variables */

   463 /********************************************/

   464   /* done in base class(es) */

   465 

   466 /*************************************/

   467 /* B.1.4.2   Multi-element Variables */

   468 /*************************************/

   469   /* done in base class(es) */

   470 

   471 /******************************************/

   472 /* B 1.4.3 - Declaration & Initialisation */

   473 /******************************************/

   474 void *visit(constant_option_c *symbol) {s4o.print("CONSTANT"); return NULL;}

   475 void *visit(retain_option_c *symbol) {s4o.print("RETAIN"); return NULL;}

   476 void *visit(non_retain_option_c *symbol) {s4o.print("NON_RETAIN"); return NULL;}

   477 

   478 void *visit(input_declarations_c *symbol) {

   479   TRACE("input_declarations_c");

   480   if ((wanted_vartype & input_vt) != 0) {

   481 /*

   482     // TO DO ...

   483     if (symbol->option != NULL)

   484       symbol->option->accept(*this);

   485 */

   486     //s4o.indent_right();

   487     current_vartype = input_vt;

   488     symbol->input_declaration_list->accept(*this);

   489     current_vartype = none_vt;

   490     //s4o.indent_left();

   491   }

   492   return NULL;

   493 }

   494 

   495 /* helper symbol for input_declarations */

   496 void *visit(input_declaration_list_c *symbol) {

   497   TRACE("input_declaration_list_c");

   498   print_list(symbol);

   499   return NULL;

   500 }

   501 

   502 void *visit(edge_declaration_c *symbol) {

   503   TRACE("edge_declaration_c");

   504   // TO DO ...

   505   symbol->var1_list->accept(*this);

   506   s4o.print(" : BOOL ");

   507   symbol->edge->accept(*this);

   508   return NULL;

   509 }

   510 

   511 void *visit(raising_edge_option_c *symbol) {

   512   // TO DO ...

   513   s4o.print("R_EDGE");

   514   return NULL;

   515 }

   516 

   517 

   518 #if 0

   519 /* var1_list ':' array_spec_init */

   520 SYM_REF2(array_var_init_decl_c, var1_list, array_spec_init)

   521 #endif

   522 

   523 /*  var1_list ':' initialized_structure */

   524 // SYM_REF2(structured_var_init_decl_c, var1_list, initialized_structure)

   525 void *visit(structured_var_init_decl_c *symbol) {

   526   TRACE("structured_var_init_decl_c");

   527   /* Please read the comments inside the var1_init_decl_c

   528    * visitor, as they apply here too.

   529    */

   530 

   531   /* Start off by setting the current_var_type_symbol and

   532    * current_var_init_symbol private variables...

   533    */

   534   update_type_init(symbol->initialized_structure);

   535 

   536   /* now to produce the c equivalent... */

   537   symbol->var1_list->accept(*this);

   538 

   539   /* Values no longer in scope, and therefore no longer used.

   540    * Make an effort to keep them set to NULL when not in use

   541    * in order to catch bugs as soon as possible...

   542    */

   543   void_type_init();

   544 

   545   return NULL;

   546 }

   547 

   548 /* fb_name_list ':' function_block_type_name ASSIGN structure_initialization */

   549 /* structure_initialization -> may be NULL ! */

   550 void *visit(fb_name_decl_c *symbol) {

   551   TRACE("fb_name_decl_c");

   552   /* Please read the comments inside the var1_init_decl_c

   553    * visitor, as they apply here too.

   554    */

   555 

   556   /* Start off by setting the current_var_type_symbol and

   557    * current_var_init_symbol private variables...

   558    */

   559   update_type_init(symbol);

   560 

   561   /* now to produce the c equivalent... */

   562   symbol->fb_name_list->accept(*this);

   563 

   564   /* Values no longer in scope, and therefore no longer used.

   565    * Make an effort to keep them set to NULL when not in use

   566    * in order to catch bugs as soon as possible...

   567    */

   568   void_type_init();

   569 

   570   return NULL;

   571 }

   572 

   573 /* fb_name_list ',' fb_name */

   574 void *visit(fb_name_list_c *symbol) {

   575   TRACE("fb_name_list_c");

   576   declare_variables(symbol, true);

   577   return NULL;

   578 }

   579 

   580 

   581 /* VAR_OUTPUT [RETAIN | NON_RETAIN] var_init_decl_list END_VAR */

   582 /* option -> may be NULL ! */

   583 void *visit(output_declarations_c *symbol) {

   584   TRACE("output_declarations_c");

   585   if ((wanted_vartype & output_vt) != 0) {

   586 /*

   587     // TO DO ...

   588     if (symbol->option != NULL)

   589       symbol->option->accept(*this);

   590 */

   591     //s4o.indent_right();

   592     current_vartype = output_vt;

   593     symbol->var_init_decl_list->accept(*this);

   594     current_vartype = none_vt;

   595     //s4o.indent_left();

   596   }

   597   return NULL;

   598 }

   599 

   600 /*  VAR_IN_OUT var_declaration_list END_VAR */

   601 void *visit(input_output_declarations_c *symbol) {

   602   TRACE("input_output_declarations_c");

   603   if ((wanted_vartype & inoutput_vt) != 0) {

   604     //s4o.indent_right();

   605     current_vartype = inoutput_vt;

   606     symbol->var_declaration_list->accept(*this);

   607     current_vartype = none_vt;

   608     //s4o.indent_left();

   609   }

   610   return NULL;

   611 }

   612 

   613 /* helper symbol for input_output_declarations */

   614 /* var_declaration_list var_declaration ';' */

   615 void *visit(var_declaration_list_c *symbol) {

   616   TRACE("var_declaration_list_c");

   617   print_list(symbol);

   618   return NULL;

   619 }

   620 

   621 #if 0

   622 /*  var1_list ':' array_specification */

   623 SYM_REF2(array_var_declaration_c, var1_list, array_specification)

   624 #endif

   625 

   626 /*  var1_list ':' structure_type_name */

   627 //SYM_REF2(structured_var_declaration_c, var1_list, structure_type_name)

   628 void *visit(structured_var_declaration_c *symbol) {

   629   TRACE("structured_var_declaration_c");

   630   /* Please read the comments inside the var1_init_decl_c

   631    * visitor, as they apply here too.

   632    */

   633 

   634   /* Start off by setting the current_var_type_symbol and

   635    * current_var_init_symbol private variables...

   636    */

   637   update_type_init(symbol->structure_type_name);

   638 

   639   /* now to produce the c equivalent... */

   640   symbol->var1_list->accept(*this);

   641 

   642   /* Values no longer in scope, and therefore no longer used.

   643    * Make an effort to keep them set to NULL when not in use

   644    * in order to catch bugs as soon as possible...

   645    */

   646   void_type_init();

   647 

   648   return NULL;

   649 }

   650 

   651 

   652 /* VAR [CONSTANT] var_init_decl_list END_VAR */

   653 /* option -> may be NULL ! */

   654 /* helper symbol for input_declarations */

   655 void *visit(var_declarations_c *symbol) {

   656   TRACE("var_declarations_c");

   657   if ((wanted_vartype & private_vt) != 0) {

   658 /*

   659     // TO DO ...

   660     if (symbol->option != NULL)

   661       symbol->option->accept(*this);

   662 */

   663     current_vartype = private_vt;

   664     symbol->var_init_decl_list->accept(*this);

   665     current_vartype = none_vt;

   666   }

   667   return NULL;

   668 }

   669 

   670 /*  VAR RETAIN var_init_decl_list END_VAR */

   671 void *visit(retentive_var_declarations_c *symbol) {

   672   TRACE("retentive_var_declarations_c");

   673   if ((wanted_vartype & private_vt) != 0) {

   674     current_vartype = private_vt;

   675     symbol->var_init_decl_list->accept(*this);

   676     current_vartype = none_vt;

   677   }

   678   return NULL;

   679 }

   680 

   681 /*  VAR [CONSTANT|RETAIN|NON_RETAIN] located_var_decl_list END_VAR */

   682 /* option -> may be NULL ! */

   683 //SYM_REF2(located_var_declarations_c, option, located_var_decl_list)

   684 void *visit(located_var_declarations_c *symbol) {

   685   TRACE("located_var_declarations_c");

   686   if ((wanted_vartype & located_vt) != 0) {

   687 /*

   688     // TO DO ...

   689     if (symbol->option != NULL)

   690       symbol->option->accept(*this);

   691 */

   692     current_vartype = located_vt;

   693     symbol->located_var_decl_list->accept(*this);

   694     current_vartype = none_vt;

   695   }

   696   return NULL;

   697 }

   698 

   699 /* helper symbol for located_var_declarations */

   700 /* located_var_decl_list located_var_decl ';' */

   701 //SYM_LIST(located_var_decl_list_c)

   702 void *visit(located_var_decl_list_c *symbol) {

   703   TRACE("located_var_decl_list_c");

   704   print_list(symbol);

   705   return NULL;

   706 }

   707 

   708 

   709 /*  [variable_name] location ':' located_var_spec_init */

   710 /* variable_name -> may be NULL ! */

   711 //SYM_REF4(located_var_decl_c, variable_name, location, located_var_spec_init, unused)

   712 void *visit(located_var_decl_c *symbol) {

   713   TRACE("located_var_decl_c");

   714   /* Please read the comments inside the var1_init_decl_c

   715    * visitor, as they apply here too.

   716    */

   717 

   718   /* Start off by setting the current_var_type_symbol and

   719    * current_var_init_symbol private variables...

   720    */

   721   update_type_init(symbol->located_var_spec_init);

   722 

   723   /* now to produce the c equivalent... */

   724   switch(wanted_varformat) {

   725     case local_vf:

   726       s4o.print(s4o.indent_spaces);

   727       this->current_var_type_symbol->accept(*this);

   728       s4o.print(" *");

   729       if (symbol->variable_name != NULL)

   730         symbol->variable_name->accept(*this);

   731       else

   732         symbol->location->accept(*this);

   733       s4o.print(";\n");

   734       break;

   735 

   736     case constructorinit_vf:

   737       s4o.print(nv->get());

   738       s4o.print("{extern ");

   739       this->current_var_type_symbol->accept(*this);

   740       s4o.print(" ");

   741       symbol->location->accept(*this);

   742       s4o.print("; ");

   743       print_variable_prefix();

   744       if (symbol->variable_name != NULL)

   745         symbol->variable_name->accept(*this);

   746       else

   747         symbol->location->accept(*this);

   748       s4o.print(" = &");

   749       symbol->location->accept(*this);

   750       s4o.print(";}");

   751       break;

   752 

   753     case globalinit_vf:

   754       s4o.print(s4o.indent_spaces + "__plc_pt_c<");

   755       this->current_var_type_symbol->accept(*this);

   756       s4o.print(", 8*sizeof(");

   757       this->current_var_type_symbol->accept(*this);

   758       s4o.print(")> ");

   759       if (this->globalnamespace != NULL) {

   760         this->globalnamespace->accept(*this);

   761         s4o.print("::");

   762       }

   763       if (symbol->variable_name != NULL)

   764         symbol->variable_name->accept(*this);

   765       else

   766         symbol->location->accept(*this);

   767 

   768       s4o.print(" = ");

   769 

   770       s4o.print(s4o.indent_spaces + "__plc_pt_c<");

   771       this->current_var_type_symbol->accept(*this);

   772       s4o.print(", 8*sizeof(");

   773       this->current_var_type_symbol->accept(*this);

   774       s4o.print(")>(\"");

   775       symbol->location->accept(*this);

   776       s4o.print("\"");

   777       if (this->current_var_init_symbol != NULL) {

   778         s4o.print(", ");

   779         this->current_var_init_symbol->accept(*this);

   780       }

   781       s4o.print(");\n");

   782       break;

   783 

   784     default:

   785       ERROR;

   786   } /* switch() */

   787 

   788   /* Values no longer in scope, and therefore no longer used.

   789    * Make an effort to keep them set to NULL when not in use

   790    * in order to catch bugs as soon as possible...

   791    */

   792   void_type_init();

   793 

   794   return NULL;

   795 }

   796 

   797 

   798 

   799 

   800 /*| VAR_EXTERNAL [CONSTANT] external_declaration_list END_VAR */

   801 /* option -> may be NULL ! */

   802 //SYM_REF2(external_var_declarations_c, option, external_declaration_list)

   803 void *visit(external_var_declarations_c *symbol) {

   804   TRACE("external_var_declarations_c");

   805   if ((wanted_vartype & external_vt) != 0) {

   806 /*

   807     // TODO ...

   808     if (symbol->option != NULL)

   809       symbol->option->accept(*this);

   810 */

   811     //s4o.indent_right();

   812     current_vartype = external_vt;

   813     symbol->external_declaration_list->accept(*this);

   814     current_vartype = none_vt;

   815     //s4o.indent_left();

   816   }

   817   return NULL;

   818 }

   819 

   820 /* helper symbol for external_var_declarations */

   821 /*| external_declaration_list external_declaration';' */

   822 //SYM_LIST(external_declaration_list_c)

   823 /* helper symbol for input_declarations */

   824 void *visit(external_declaration_list_c *symbol) {

   825   TRACE("external_declaration_list_c");

   826   print_list(symbol);

   827   return NULL;

   828 }

   829 

   830 

   831 /*  global_var_name ':' (simple_specification|subrange_specification|enumerated_specification|array_specification|prev_declared_structure_type_name|function_block_type_name */

   832 //SYM_REF2(external_declaration_c, global_var_name, specification)

   833 void *visit(external_declaration_c *symbol) {

   834   TRACE("external_declaration_c");

   835   /* Please read the comments inside the var1_init_decl_c

   836    * visitor, as they apply here too.

   837    */

   838 

   839   /* Start off by setting the current_var_type_symbol and

   840    * current_var_init_symbol private variables...

   841    */

   842   this->current_var_type_symbol = symbol->specification;

   843   this->current_var_init_symbol = NULL;

   844 

   845   /* now to produce the c equivalent... */

   846   switch (wanted_varformat) {

   847     case local_vf:

   848     case localinit_vf:

   849       s4o.print(s4o.indent_spaces);

   850       this->current_var_type_symbol->accept(*this);

   851       s4o.print(" *");

   852       symbol->global_var_name->accept(*this);

   853       if ((wanted_varformat == localinit_vf) &&

   854           (this->current_var_init_symbol != NULL)) {

   855         s4o.print(" = ");

   856         this->current_var_init_symbol->accept(*this);

   857       }

   858       s4o.print(";\n");

   859       break;

   860 

   861     case constructorinit_vf:

   862       s4o.print(nv->get());

   863       s4o.print("{extern ");

   864       this->current_var_type_symbol->accept(*this);

   865       s4o.print(" *");

   866       symbol->global_var_name->accept(*this);

   867       s4o.print("; ");

   868       print_variable_prefix();

   869       symbol->global_var_name->accept(*this);

   870       s4o.print(" = ");

   871       symbol->global_var_name->accept(*this);

   872       s4o.print(";}");

   873       break;

   874 

   875     case finterface_vf:

   876       finterface_var_count++;

   877       s4o.print(nv->get());

   878       this->current_var_type_symbol->accept(*this);

   879       s4o.print(" *");

   880       symbol->global_var_name->accept(*this);

   881       break;

   882 

   883     default:

   884       ERROR;

   885   }

   886 

   887   /* Values no longer in scope, and therefore no longer used.

   888    * Make an effort to keep them set to NULL when not in use

   889    * in order to catch bugs as soon as possible...

   890    */

   891   void_type_init();

   892 

   893   return NULL;

   894 }

   895 

   896 

   897 

   898 /*| VAR_GLOBAL [CONSTANT|RETAIN] global_var_decl_list END_VAR */

   899 /* option -> may be NULL ! */

   900 // SYM_REF2(global_var_declarations_c, option, global_var_decl_list)

   901 void *visit(global_var_declarations_c *symbol) {

   902   TRACE("global_var_declarations_c");

   903   if ((wanted_vartype & global_vt) != 0) {

   904 /*

   905     // TODO ...

   906     if (symbol->option != NULL)

   907       symbol->option->accept(*this);

   908 */

   909     //s4o.indent_right();

   910     unsigned int previous_vartype = current_vartype;

   911       // previous_vartype will be either none_vt, or resource_vt

   912     current_vartype = global_vt;

   913     symbol->global_var_decl_list->accept(*this);

   914     current_vartype = previous_vartype;

   915     //s4o.indent_left();

   916   }

   917   return NULL;

   918 }

   919 

   920 /* helper symbol for global_var_declarations */

   921 /*| global_var_decl_list global_var_decl ';' */

   922 //SYM_LIST(global_var_decl_list_c)

   923 void *visit(global_var_decl_list_c *symbol) {

   924   TRACE("global_var_decl_list_c");

   925   print_list(symbol);

   926   return NULL;

   927 }

   928 

   929 

   930 

   931 /*| global_var_spec ':' [located_var_spec_init|function_block_type_name] */

   932 /* type_specification ->may be NULL ! */

   933 // SYM_REF2(global_var_decl_c, global_var_spec, type_specification)

   934 void *visit(global_var_decl_c *symbol) {

   935   TRACE("global_var_decl_c");

   936   /* Please read the comments inside the var1_init_decl_c

   937    * visitor, as they apply here too.

   938    */

   939 

   940   /* Start off by setting the current_var_type_symbol and

   941    * current_var_init_symbol private variables...

   942    */

   943   update_type_init(symbol->type_specification);

   944 

   945   /* now to produce the c equivalent... */

   946   symbol->global_var_spec->accept(*this);

   947 

   948   /* Values no longer in scope, and therefore no longer used.

   949    * Make an effort to keep them set to NULL when not in use

   950    * in order to catch bugs as soon as possible...

   951    */

   952   void_type_init();

   953 

   954   return NULL;

   955 }

   956 

   957 

   958 /*| global_var_name location */

   959 // SYM_REF2(global_var_spec_c, global_var_name, location)

   960 void *visit(global_var_spec_c *symbol) {

   961   TRACE("global_var_spec_c");

   962 

   963   /* now to produce the c equivalent... */

   964   switch(wanted_varformat) {

   965     case local_vf:

   966     case localstatic_vf:

   967       /* NOTE: located variables must be declared static, as the connection to the

   968        * MatPLC point must be initialised at program startup, and not whenever

   969        * a new function block is instantiated!

   970        * Nevertheless, this construct never occurs inside a Function Block, but

   971        * only inside a configuration. In this case, only a single instance will

   972        * be created, directly at startup, so it is not necessary that the variables

   973        * be declared static.

   974        */

   975       s4o.print(s4o.indent_spaces);

   976       if (symbol->global_var_name != NULL) {

   977         s4o.print("extern ");

   978         this->current_var_type_symbol->accept(*this);

   979         s4o.print(" ");

   980         symbol->location->accept(*this);

   981         s4o.print(";\n");

   982         if (wanted_varformat == localstatic_vf)

   983           s4o.print("static ");

   984         this->current_var_type_symbol->accept(*this);

   985         s4o.print(" *");

   986         symbol->global_var_name->accept(*this);

   987         s4o.print(" = &");

   988         symbol->location->accept(*this);

   989         s4o.print(";\n");

   990       }

   991       break;

   992 

   993     case constructorinit_vf:

   994       s4o.print(nv->get());

   995       

   996       if (symbol->global_var_name != NULL) {

   997         s4o.print("*");

   998         symbol->global_var_name->accept(*this);

   999       }

  1000       else

  1001         symbol->location->accept(*this);

  1002       s4o.print(" = ");

  1003       if (this->current_var_init_symbol != NULL) {

  1004         this->current_var_init_symbol->accept(*this);

  1005       }

  1006       s4o.print(";");

  1007       break;

  1008 

  1009     default:

  1010       ERROR;

  1011   } /* switch() */

  1012 

  1013   return NULL;

  1014 }

  1015 

  1016 

  1017 

  1018 /*  AT direct_variable */

  1019 // SYM_REF2(location_c, direct_variable, unused)

  1020 void *visit(location_c *symbol) {

  1021   TRACE("location_c");

  1022   return symbol->direct_variable->accept(*this);

  1023 }

  1024 

  1025 

  1026 /*| global_var_list ',' global_var_name */

  1027 //SYM_LIST(global_var_list_c)

  1028 void *visit(global_var_list_c *symbol) {

  1029   TRACE("global_var_list_c");

  1030   list_c *list = dynamic_cast<list_c *>(symbol);

  1031   /* should NEVER EVER occur!! */

  1032   if (list == NULL) ERROR;

  1033 

  1034   /* now to produce the c equivalent... */

  1035   switch (wanted_varformat) {

  1036     case local_vf:

  1037     case localinit_vf:

  1038       for(int i = 0; i < list->n; i++) {

  1039         s4o.print(s4o.indent_spaces);

  1040         this->current_var_type_symbol->accept(*this);

  1041         s4o.print(" __");

  1042         list->elements[i]->accept(*this);

  1043         s4o.print(";\n");

  1044         this->current_var_type_symbol->accept(*this);

  1045         s4o.print(" *");

  1046         list->elements[i]->accept(*this);

  1047         s4o.print(" = &__");

  1048         list->elements[i]->accept(*this);

  1049 #if 0

  1050         if (wanted_varformat == localinit_vf) {

  1051           if (this->current_var_init_symbol != NULL) {

  1052             s4o.print(" = ");

  1053             this->current_var_init_symbol->accept(*this);

  1054           }

  1055         }

  1056 #endif

  1057         s4o.print(";\n");

  1058       }

  1059       break;

  1060 

  1061     case constructorinit_vf:

  1062       if (this->current_var_init_symbol != NULL) {

  1063         for(int i = 0; i < list->n; i++) {

  1064           s4o.print(nv->get());

  1065 

  1066           s4o.print("*");

  1067           list->elements[i]->accept(*this);

  1068           s4o.print(" = ");

  1069           this->current_var_init_symbol->accept(*this);

  1070           s4o.print(";");

  1071 #if 0

  1072  	  /* The following code would be for globalinit_vf !!

  1073 	   * But it is not currently required...

  1074 	   */

  1075 	  s4o.print(s4o.indent_spaces + "__ext_element_c<");

  1076           this->current_var_type_symbol->accept(*this);

  1077           s4o.print("> ");

  1078           if (this->globalnamespace != NULL) {

  1079             this->globalnamespace->accept(*this);

  1080             s4o.print("::");

  1081           }

  1082           list->elements[i]->accept(*this);

  1083 

  1084           if (this->current_var_init_symbol != NULL) {

  1085             s4o.print(" = ");

  1086             s4o.print("__ext_element_c<");

  1087             this->current_var_type_symbol->accept(*this);

  1088             s4o.print(">(");

  1089             this->current_var_init_symbol->accept(*this);

  1090             s4o.print(")");

  1091 	  }

  1092           s4o.print(";\n");

  1093 #endif

  1094         }

  1095       }

  1096       break;

  1097 

  1098     default:

  1099       ERROR; /* not supported, and not needed either... */

  1100   }

  1101 

  1102   return NULL;

  1103 }

  1104 

  1105 

  1106 #if 0

  1107 /*  var1_list ':' single_byte_string_spec */

  1108 SYM_REF2(single_byte_string_var_declaration_c, var1_list, single_byte_string_spec)

  1109 

  1110 /*  STRING ['[' integer ']'] [ASSIGN single_byte_character_string] */

  1111 /* integer ->may be NULL ! */

  1112 /* single_byte_character_string ->may be NULL ! */

  1113 SYM_REF2(single_byte_string_spec_c, integer, single_byte_character_string)

  1114 

  1115 /*  var1_list ':' double_byte_string_spec */

  1116 SYM_REF2(double_byte_string_var_declaration_c, var1_list, double_byte_string_spec)

  1117 

  1118 /*  WSTRING ['[' integer ']'] [ASSIGN double_byte_character_string] */

  1119 /* integer ->may be NULL ! */

  1120 /* double_byte_character_string ->may be NULL ! */

  1121 SYM_REF2(double_byte_string_spec_c, integer, double_byte_character_string)

  1122 

  1123 /*| VAR [RETAIN|NON_RETAIN] incompl_located_var_decl_list END_VAR */

  1124 /* option ->may be NULL ! */

  1125 SYM_REF2(incompl_located_var_declarations_c, option, incompl_located_var_decl_list)

  1126 

  1127 /* helper symbol for incompl_located_var_declarations */

  1128 /*| incompl_located_var_decl_list incompl_located_var_decl ';' */

  1129 SYM_LIST(incompl_located_var_decl_list_c)

  1130 

  1131 /*  variable_name incompl_location ':' var_spec */

  1132 SYM_REF4(incompl_located_var_decl_c, variable_name, incompl_location, var_spec, unused)

  1133 

  1134 /*  AT incompl_location_token */

  1135 SYM_TOKEN(incompl_location_c)

  1136 #endif