Mercurial Mercurial > matiec / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
stage4/generate_iec/generate_iec.cc
changeset 580 b6350d9f204d
parent 547 dab341e80664
child 596 4efb11e44065
equal deleted inserted replaced
579:983a3b743085 580:b6350d9f204d 
    42  * 4th stages.
 
    42  * 4th stages.
 
    43  */
 
    43  */
 
    44 
    44 
    45 
    45 
    46 
    46 
       
    47 /* Compile with the following option, to print out the const_value of each symbol, which was filled in by constant_folding_c during stage3 */
 
       
    48 // #define DEBUG_CONST_VALUE
 
    47 
    49 
    48 
    50 
    49 
    51 
    50 // #include <stdio.h>  /* required for NULL */
 
    52 // #include <stdio.h>  /* required for NULL */
 
    51 #include <string>
 
    53 #include <string>
 
    76     ~generate_iec_c(void) {}
 
    78     ~generate_iec_c(void) {}
 
    77 
    79 
    78 
    80 
    79   private:
 
    81   private:
 
    80 
    82 
       
    83     
       
    84 void print_const_value(symbol_c *symbol) {
 
       
    85 #ifdef DEBUG_CONST_VALUE
 
       
    86   if (NULL == symbol) return;
 
       
    87   bool first = true;
 
       
    88   
       
    89   if (NULL != symbol->const_value_uint64) {
 
       
    90     first?s4o.print("{"):s4o.print("; ");
 
       
    91     first = false;
 
       
    92     s4o.print("uint64:");
 
       
    93     if (symbol->const_value_uint64->status == symbol_c::cs_const_value)
 
       
    94       s4o.print_uint64(symbol->const_value_uint64->value);
 
       
    95     if (symbol->const_value_uint64->status == symbol_c::cs_overflow)
 
       
    96     s4o.print("OVERFLOW");
 
       
    97   }
 
       
    98   if (NULL != symbol->const_value_int64) {
 
       
    99     first?s4o.print("{"):s4o.print("; ");
 
       
   100     first = false;
 
       
   101     s4o.print("int64:");
 
       
   102     if (symbol->const_value_int64->status == symbol_c::cs_const_value)
 
       
   103       s4o.print_int64(symbol->const_value_int64->value);
 
       
   104     if (symbol->const_value_int64->status == symbol_c::cs_overflow)
 
       
   105     s4o.print("OVERFLOW");
 
       
   106   }
 
       
   107   if (NULL != symbol->const_value_real64) {
 
       
   108     first?s4o.print("{"):s4o.print("; ");
 
       
   109     first = false;
 
       
   110     s4o.print("real64:");
 
       
   111     if (symbol->const_value_real64->status == symbol_c::cs_const_value)
 
       
   112       s4o.print_real64(symbol->const_value_real64->value);
 
       
   113     if (symbol->const_value_real64->status == symbol_c::cs_overflow)
 
       
   114     s4o.print("OVERFLOW");
 
       
   115   }
 
       
   116   if (NULL != symbol->const_value_bool) {
 
       
   117     first?s4o.print("{"):s4o.print("; ");
 
       
   118     first = false;
 
       
   119     s4o.print("bool:");
 
       
   120     if (symbol->const_value_bool->status == symbol_c::cs_const_value)
 
       
   121       s4o.print((symbol->const_value_bool->value)?"true":"false");
 
       
   122     if (symbol->const_value_bool->status == symbol_c::cs_overflow)
 
       
   123     s4o.print("OVERFLOW");
 
       
   124   }
 
       
   125   if (!first) s4o.print("}");  
       
   126 #endif
 
       
   127   return;
 
       
   128 }
 
       
   129 
       
   130 
       
   131 
    81 void *print_token(token_c *token) {
 
   132 void *print_token(token_c *token) {
 
       
   133   print_const_value(token);
 
    82   return s4o.print(token->value);
 
   134   return s4o.print(token->value);
 
    83 }
 
   135 }
 
    84 
   136 
       
   137 
    85 void *print_literal(symbol_c *type, symbol_c *value) {
 
   138 void *print_literal(symbol_c *type, symbol_c *value) {
 
       
   139   print_const_value(value);
 
    86   if (NULL != type) {
 
   140   if (NULL != type) {
 
    87     type->accept(*this);
 
   141     type->accept(*this);
 
    88     s4o.print("#");
 
   142     s4o.print("#");
 
    89   }
 
   143   }
 
    90   value->accept(*this);
 
   144   value->accept(*this);
 
   110 
   164 
   111   return NULL;
 
   165   return NULL;
 
   112 }
 
   166 }
 
   113 
   167 
   114 
   168 
   115 void *print_binary_expression(symbol_c *l_exp,
 
   169 void *print_binary_expression(symbol_c *symbol,
 
       
   170 			      symbol_c *l_exp,
 
   116 			      symbol_c *r_exp,
 
   171 			      symbol_c *r_exp,
 
   117 			      const char *operation) {
 
   172 			      const char *operation) {
 
       
   173   print_const_value(symbol);
 
   118   s4o.print("(");
 
   174   s4o.print("(");
 
   119   l_exp->accept(*this);
 
   175   l_exp->accept(*this);
 
   120   s4o.print(operation);
 
   176   s4o.print(operation);
 
   121   r_exp->accept(*this);
 
   177   r_exp->accept(*this);
 
   122   s4o.print(")");
 
   178   s4o.print(")");
 
   123   return NULL;
 
   179   return NULL;
 
   124 }
 
   180 }
 
   125 
   181 
   126 void *print_unary_expression(symbol_c *exp,
 
   182 void *print_unary_expression(symbol_c *symbol,
 
       
   183 			     symbol_c *exp,
 
   127 			     const char *operation) {
 
   184 			     const char *operation) {
 
       
   185   print_const_value(symbol);
 
   128   s4o.print(operation);
 
   186   s4o.print(operation);
 
   129   exp->accept(*this);
 
   187   exp->accept(*this);
 
   130   return NULL;
 
   188   return NULL;
 
   131 }
 
   189 }
 
   132 
   190 
   190 
   248 
   191 /******************************/
 
   249 /******************************/
 
   192 /* B 1.2.1 - Numeric Literals */
 
   250 /* B 1.2.1 - Numeric Literals */
 
   193 /******************************/
 
   251 /******************************/
 
   194 void *visit(real_c *symbol)               {return print_token(symbol);}
 
   252 void *visit(real_c *symbol)               {return print_token(symbol);}
 
   195 void *visit(neg_real_c *symbol)           {return print_unary_expression(symbol->exp, "-");}
 
   253 void *visit(neg_real_c *symbol)           {return print_unary_expression(symbol, symbol->exp, "-");}
 
   196 void *visit(integer_c *symbol)            {return print_token(symbol);}
 
   254 void *visit(integer_c *symbol)            {return print_token(symbol);}
 
   197 void *visit(neg_integer_c *symbol)        {return print_unary_expression(symbol->exp, "-");}
 
   255 void *visit(neg_integer_c *symbol)        {return print_unary_expression(symbol, symbol->exp, "-");}
 
   198 void *visit(binary_integer_c *symbol)     {return print_token(symbol);}
 
   256 void *visit(binary_integer_c *symbol)     {return print_token(symbol);}
 
   199 void *visit(octal_integer_c *symbol)      {return print_token(symbol);}
 
   257 void *visit(octal_integer_c *symbol)      {return print_token(symbol);}
 
   200 void *visit(hex_integer_c *symbol)        {return print_token(symbol);}
 
   258 void *visit(hex_integer_c *symbol)        {return print_token(symbol);}
 
   201 
   259 
   202 void *visit(integer_literal_c *symbol)    {return print_literal(symbol->type, symbol->value);}
 
   260 void *visit(integer_literal_c *symbol)    {return print_literal(symbol->type, symbol->value);}
 
  1783 
  1841 
  1784 
  1842 
  1785 /***********************/
 
  1843 /***********************/
 
  1786 /* B 3.1 - Expressions */
 
  1844 /* B 3.1 - Expressions */
 
  1787 /***********************/
 
  1845 /***********************/
 
  1788 void *visit(or_expression_c *symbol) {return print_binary_expression(symbol->l_exp, symbol->r_exp, " OR ");}
 
  1846 void *visit(or_expression_c *symbol) {return print_binary_expression(symbol, symbol->l_exp, symbol->r_exp, " OR ");}
 
  1789 void *visit(xor_expression_c *symbol) {return print_binary_expression(symbol->l_exp, symbol->r_exp, " XOR ");}
 
  1847 void *visit(xor_expression_c *symbol) {return print_binary_expression(symbol, symbol->l_exp, symbol->r_exp, " XOR ");}
 
  1790 void *visit(and_expression_c *symbol) {return print_binary_expression(symbol->l_exp, symbol->r_exp, " AND ");}
 
  1848 void *visit(and_expression_c *symbol) {return print_binary_expression(symbol, symbol->l_exp, symbol->r_exp, " AND ");}
 
  1791 void *visit(equ_expression_c *symbol) {return print_binary_expression(symbol->l_exp, symbol->r_exp, " = ");}
 
  1849 void *visit(equ_expression_c *symbol) {return print_binary_expression(symbol, symbol->l_exp, symbol->r_exp, " = ");}
 
  1792 void *visit(notequ_expression_c *symbol) {return print_binary_expression(symbol->l_exp, symbol->r_exp, " <> ");}
 
  1850 void *visit(notequ_expression_c *symbol) {return print_binary_expression(symbol, symbol->l_exp, symbol->r_exp, " <> ");}
 
  1793 void *visit(lt_expression_c *symbol) {return print_binary_expression(symbol->l_exp, symbol->r_exp, " < ");}
 
  1851 void *visit(lt_expression_c *symbol) {return print_binary_expression(symbol, symbol->l_exp, symbol->r_exp, " < ");}
 
  1794 void *visit(gt_expression_c *symbol) {return print_binary_expression(symbol->l_exp, symbol->r_exp, " > ");}
 
  1852 void *visit(gt_expression_c *symbol) {return print_binary_expression(symbol, symbol->l_exp, symbol->r_exp, " > ");}
 
  1795 void *visit(le_expression_c *symbol) {return print_binary_expression(symbol->l_exp, symbol->r_exp, " <= ");}
 
  1853 void *visit(le_expression_c *symbol) {return print_binary_expression(symbol, symbol->l_exp, symbol->r_exp, " <= ");}
 
  1796 void *visit(ge_expression_c *symbol) {return print_binary_expression(symbol->l_exp, symbol->r_exp, " >= ");}
 
  1854 void *visit(ge_expression_c *symbol) {return print_binary_expression(symbol, symbol->l_exp, symbol->r_exp, " >= ");}
 
  1797 void *visit(add_expression_c *symbol) {return print_binary_expression(symbol->l_exp, symbol->r_exp, " + ");}
 
  1855 void *visit(add_expression_c *symbol) {return print_binary_expression(symbol, symbol->l_exp, symbol->r_exp, " + ");}
 
  1798 void *visit(sub_expression_c *symbol) {return print_binary_expression(symbol->l_exp, symbol->r_exp, " - ");}
 
  1856 void *visit(sub_expression_c *symbol) {return print_binary_expression(symbol, symbol->l_exp, symbol->r_exp, " - ");}
 
  1799 void *visit(mul_expression_c *symbol) {return print_binary_expression(symbol->l_exp, symbol->r_exp, " * ");}
 
  1857 void *visit(mul_expression_c *symbol) {return print_binary_expression(symbol, symbol->l_exp, symbol->r_exp, " * ");}
 
  1800 void *visit(div_expression_c *symbol) {return print_binary_expression(symbol->l_exp, symbol->r_exp, " / ");}
 
  1858 void *visit(div_expression_c *symbol) {return print_binary_expression(symbol, symbol->l_exp, symbol->r_exp, " / ");}
 
  1801 void *visit(mod_expression_c *symbol) {return print_binary_expression(symbol->l_exp, symbol->r_exp, " MOD ");}
 
  1859 void *visit(mod_expression_c *symbol) {return print_binary_expression(symbol, symbol->l_exp, symbol->r_exp, " MOD ");}
 
  1802 void *visit(power_expression_c *symbol) {return print_binary_expression(symbol->l_exp, symbol->r_exp, " ** ");}
 
  1860 void *visit(power_expression_c *symbol) {return print_binary_expression(symbol, symbol->l_exp, symbol->r_exp, " ** ");}
 
  1803 void *visit(neg_expression_c *symbol) {return print_unary_expression(symbol->exp, "-");}
 
  1861 void *visit(neg_expression_c *symbol) {return print_unary_expression(symbol, symbol->exp, "-");}
 
  1804 void *visit(not_expression_c *symbol) {return print_unary_expression(symbol->exp, "NOT ");}
 
  1862 void *visit(not_expression_c *symbol) {return print_unary_expression(symbol, symbol->exp, "NOT ");}
 
  1805 
  1863 
  1806 void *visit(function_invocation_c *symbol) {
 
  1864 void *visit(function_invocation_c *symbol) {
 
  1807   symbol->function_name->accept(*this);
 
  1865   symbol->function_name->accept(*this);
 
  1808   s4o.print("(");
 
  1866   s4o.print("(");
 
  1809 
  1867
matiec