matiec: comparison stage3/visit_expression

equal deleted inserted replaced

-:db2ad6541d92
+:197ba42d78b2
 fprintf(stderr, "semantic error between (%d:%d) and (%d:%d): %s\n",                \
 FIRST_(symbol1,symbol2)->first_line, FIRST_(symbol1,symbol2)->first_column, \
 LAST_(symbol1,symbol2) ->last_line,  LAST_(symbol1,symbol2) ->last_column,  \
 msg);                                                                       \
 il_error = true;                                                                   \
+error_found = true;                                                                \
 }
 /* set to 1 to see debug info during execution */
 static int debug = 0;
-visit_expression_type_c::visit_expression_type_c(symbol_c *search_scope) {
+visit_expression_type_c::visit_expression_type_c(symbol_c *ignore) {
+error_found = false;
 }
 visit_expression_type_c::~visit_expression_type_c(void) {
 }
+bool visit_expression_type_c::get_error_found(void) {
+return error_found;
+}
 /* NOTE on data type handling and literals...
 * ==========================================
 *  In other words, when calling search_constant_type_c on these constants, it returns
 *  a xxxxx_type_name_c, and not one of the xxxx_literal_c !
 *
 *  When the following code handles a literal, it is really a literal of unknown data type.
 *    e.g.   42, may be considered an int, a byte, a word, etc...
+*
+* NOTE: type_symbol == NULL is valid!
+*       This will occur, for example, when and undefined/undeclared symbolic_variable is used in the program.
+*       This will not be of any type, so we always return false.
 */
 /* A helper function... */
 bool visit_expression_type_c::is_ANY_ELEMENTARY_type(symbol_c *type_symbol) {
-if (type_symbol == NULL) {ERROR;}
+if (type_symbol == NULL) {return false;}
 return is_ANY_MAGNITUDE_type(type_symbol)
 || is_ANY_BIT_type      (type_symbol)
 || is_ANY_STRING_type   (type_symbol)
 || is_ANY_DATE_type     (type_symbol);
 }
 /* A helper function... */
 bool visit_expression_type_c::is_ANY_SAFEELEMENTARY_type(symbol_c *type_symbol) {
-if (type_symbol == NULL) {ERROR;}
+if (type_symbol == NULL) {return false;}
 return is_ANY_SAFEMAGNITUDE_type(type_symbol)
 || is_ANY_SAFEBIT_type      (type_symbol)
 || is_ANY_SAFESTRING_type   (type_symbol)
 || is_ANY_SAFEDATE_type     (type_symbol);
 }
 /* A helper function... */
 bool visit_expression_type_c::is_ANY_ELEMENTARY_compatible(symbol_c *type_symbol) {
-if (type_symbol == NULL) {ERROR;}
+if (type_symbol == NULL) {return false;}
 /* NOTE: doing
 *          return is_ANY_SAFEELEMENTARY_type() || is_ANY_ELEMENTARY_type()
 *       is incorrect, as the literals would never be considered compatible...
 */
 return is_ANY_MAGNITUDE_compatible(type_symbol)
 }
 /* A helper function... */
 bool visit_expression_type_c::is_ANY_MAGNITUDE_type(symbol_c *type_symbol) {
-if (type_symbol == NULL) {ERROR;}
+if (type_symbol == NULL) {return false;}
 if (typeid(*type_symbol) == typeid(time_type_name_c)) {return true;}
 return is_ANY_NUM_type(type_symbol);
 }
 /* A helper function... */
 bool visit_expression_type_c::is_ANY_SAFEMAGNITUDE_type(symbol_c *type_symbol) {
-if (type_symbol == NULL) {ERROR;}
+if (type_symbol == NULL) {return false;}
 if (typeid(*type_symbol) == typeid(safetime_type_name_c)) {return true;}
 return is_ANY_SAFENUM_type(type_symbol);
 }
 /* A helper function... */
 bool visit_expression_type_c::is_ANY_MAGNITUDE_compatible(symbol_c *type_symbol) {
-if (type_symbol == NULL) {ERROR;}
+if (type_symbol == NULL) {return false;}
 if (is_ANY_MAGNITUDE_type    (type_symbol))              {return true;}
 if (is_ANY_SAFEMAGNITUDE_type(type_symbol))              {return true;}
 return is_ANY_NUM_compatible(type_symbol);
 }
 /* A helper function... */
 bool visit_expression_type_c::is_ANY_NUM_type(symbol_c *type_symbol) {
-if (type_symbol == NULL) {ERROR;}
+if (type_symbol == NULL) {return false;}
 if (is_ANY_REAL_type(type_symbol))                       {return true;}
 if (is_ANY_INT_type(type_symbol))                        {return true;}
 return false;
 }
 /* A helper function... */
 bool visit_expression_type_c::is_ANY_SAFENUM_type(symbol_c *type_symbol) {
-if (type_symbol == NULL) {ERROR;}
+if (type_symbol == NULL) {return false;}
 return is_ANY_SAFEREAL_type(type_symbol)
 || is_ANY_SAFEINT_type (type_symbol);
 }
 /* A helper function... */
 bool visit_expression_type_c::is_ANY_NUM_compatible(symbol_c *type_symbol) {
-if (type_symbol == NULL) {ERROR;}
+if (type_symbol == NULL) {return false;}
 if (is_ANY_REAL_compatible(type_symbol))                       {return true;}
 if (is_ANY_INT_compatible(type_symbol))                        {return true;}
 return false;
 }
 /* A helper function... */
 bool visit_expression_type_c::is_ANY_DATE_type(symbol_c *type_symbol) {
-if (type_symbol == NULL) {ERROR;}
+if (type_symbol == NULL) {return false;}
 if (typeid(*type_symbol) == typeid(date_type_name_c)) {return true;}
 if (typeid(*type_symbol) == typeid(tod_type_name_c))  {return true;}
 if (typeid(*type_symbol) == typeid(dt_type_name_c))   {return true;}
 return false;
 }
 /* A helper function... */
 bool visit_expression_type_c::is_ANY_SAFEDATE_type(symbol_c *type_symbol) {
-if (type_symbol == NULL) {ERROR;}
+if (type_symbol == NULL) {return false;}
 if (typeid(*type_symbol) == typeid(safedate_type_name_c)) {return true;}
 if (typeid(*type_symbol) == typeid(safetod_type_name_c))  {return true;}
 if (typeid(*type_symbol) == typeid(safedt_type_name_c))   {return true;}
 return false;
 }
 /* A helper function... */
 bool visit_expression_type_c::is_ANY_DATE_compatible(symbol_c *type_symbol) {
-if (type_symbol == NULL) {ERROR;}
+if (type_symbol == NULL) {return false;}
 if (is_ANY_DATE_type    (type_symbol))              {return true;}
 if (is_ANY_SAFEDATE_type(type_symbol))              {return true;}
 return false;
 }
 /* A helper function... */
 bool visit_expression_type_c::is_ANY_STRING_type(symbol_c *type_symbol) {
-if (type_symbol == NULL) {ERROR;}
+if (type_symbol == NULL) {return false;}
 if (typeid(*type_symbol) == typeid(string_type_name_c)) {return true;}
 if (typeid(*type_symbol) == typeid(wstring_type_name_c)) {return true;}
 // TODO literal_string ???
 return false;
 }
 /* A helper function... */
 bool visit_expression_type_c::is_ANY_SAFESTRING_type(symbol_c *type_symbol) {
-if (type_symbol == NULL) {ERROR;}
+if (type_symbol == NULL) {return false;}
 if (typeid(*type_symbol) == typeid(safestring_type_name_c)) {return true;}
 if (typeid(*type_symbol) == typeid(safewstring_type_name_c)) {return true;}
 return false;
 }
 /* A helper function... */
 bool visit_expression_type_c::is_ANY_STRING_compatible(symbol_c *type_symbol) {
-if (type_symbol == NULL) {ERROR;}
+if (type_symbol == NULL) {return false;}
 if (is_ANY_STRING_type    (type_symbol))              {return true;}
 if (is_ANY_SAFESTRING_type(type_symbol))              {return true;}
 return false;
 }
 /* A helper function... */
 bool visit_expression_type_c::is_ANY_INT_type(symbol_c *type_symbol) {
-if (type_symbol == NULL) {ERROR;}
+if (type_symbol == NULL) {return false;}
 if (typeid(*type_symbol) == typeid(sint_type_name_c))  {return true;}
 if (typeid(*type_symbol) == typeid(int_type_name_c))   {return true;}
 if (typeid(*type_symbol) == typeid(dint_type_name_c))  {return true;}
 if (typeid(*type_symbol) == typeid(lint_type_name_c))  {return true;}
 if (typeid(*type_symbol) == typeid(usint_type_name_c)) {return true;}
 return false;
 }
 /* A helper function... */
 bool visit_expression_type_c::is_ANY_SAFEINT_type(symbol_c *type_symbol) {
-if (type_symbol == NULL) {ERROR;}
+if (type_symbol == NULL) {return false;}
 if (typeid(*type_symbol) == typeid(safesint_type_name_c))  {return true;}
 if (typeid(*type_symbol) == typeid(safeint_type_name_c))   {return true;}
 if (typeid(*type_symbol) == typeid(safedint_type_name_c))  {return true;}
 if (typeid(*type_symbol) == typeid(safelint_type_name_c))  {return true;}
 if (typeid(*type_symbol) == typeid(safeusint_type_name_c)) {return true;}
 return false;
 }
 /* A helper function... */
 bool visit_expression_type_c::is_ANY_INT_compatible(symbol_c *type_symbol) {
-if (type_symbol == NULL) {ERROR;}
+if (type_symbol == NULL) {return false;}
 if (is_ANY_INT_type    (type_symbol))              {return true;}
 if (is_ANY_SAFEINT_type(type_symbol))              {return true;}
 if (is_literal_integer_type(type_symbol))          {return true;}
 return false;
 }
 /* A helper function... */
 bool visit_expression_type_c::is_ANY_REAL_type(symbol_c *type_symbol) {
-if (type_symbol == NULL) {ERROR;}
+if (type_symbol == NULL) {return false;}
 if (typeid(*type_symbol) == typeid(real_type_name_c))  {return true;}
 if (typeid(*type_symbol) == typeid(lreal_type_name_c)) {return true;}
 return false;
 }
 /* A helper function... */
 bool visit_expression_type_c::is_ANY_SAFEREAL_type(symbol_c *type_symbol) {
-if (type_symbol == NULL) {ERROR;}
+if (type_symbol == NULL) {return false;}
 if (typeid(*type_symbol) == typeid(safereal_type_name_c))  {return true;}
 if (typeid(*type_symbol) == typeid(safelreal_type_name_c)) {return true;}
 return false;
 }
 /* A helper function... */
 bool visit_expression_type_c::is_ANY_REAL_compatible(symbol_c *type_symbol) {
-if (type_symbol == NULL) {ERROR;}
+if (type_symbol == NULL) {return false;}
 if (is_ANY_REAL_type    (type_symbol))              {return true;}
 if (is_ANY_SAFEREAL_type(type_symbol))              {return true;}
 if (is_literal_real_type(type_symbol))              {return true;}
 return false;
 }
 /* A helper function... */
 bool visit_expression_type_c::is_ANY_BIT_type(symbol_c *type_symbol) {
-if (type_symbol == NULL) {ERROR;}
+if (type_symbol == NULL) {return false;}
 if (typeid(*type_symbol) == typeid(bool_type_name_c))     {return true;}
 if (typeid(*type_symbol) == typeid(byte_type_name_c))     {return true;}
 if (typeid(*type_symbol) == typeid(word_type_name_c))     {return true;}
 if (typeid(*type_symbol) == typeid(dword_type_name_c))    {return true;}
 if (typeid(*type_symbol) == typeid(lword_type_name_c))    {return true;}
 return false;
 }
 /* A helper function... */
 bool visit_expression_type_c::is_ANY_SAFEBIT_type(symbol_c *type_symbol) {
-if (type_symbol == NULL) {ERROR;}
+if (type_symbol == NULL) {return false;}
 if (typeid(*type_symbol) == typeid(safebool_type_name_c))     {return true;}
 if (typeid(*type_symbol) == typeid(safebyte_type_name_c))     {return true;}
 if (typeid(*type_symbol) == typeid(safeword_type_name_c))     {return true;}
 if (typeid(*type_symbol) == typeid(safedword_type_name_c))    {return true;}
 if (typeid(*type_symbol) == typeid(safelword_type_name_c))    {return true;}
 return false;
 }
 /* A helper function... */
 bool visit_expression_type_c::is_ANY_BIT_compatible(symbol_c *type_symbol) {
-if (type_symbol == NULL) {ERROR;}
+if (type_symbol == NULL) {return false;}
 if (is_ANY_BIT_type    (type_symbol))              {return true;}
 if (is_ANY_SAFEBIT_type(type_symbol))              {return true;}
 if (is_nonneg_literal_integer_type(type_symbol))   {return true;}
 if (is_literal_bool_type(type_symbol))             {return true;}
 return false;
 }
 /* A helper function... */
 bool visit_expression_type_c::is_BOOL_type(symbol_c *type_symbol) {
-if (type_symbol == NULL) {ERROR;}
+if (type_symbol == NULL) {return false;}
 if (typeid(*type_symbol) == typeid(bool_type_name_c))      {return true;}
 return false;
 }
 /* A helper function... */
 bool visit_expression_type_c::is_SAFEBOOL_type(symbol_c *type_symbol){
-if (type_symbol == NULL) {ERROR;}
+if (type_symbol == NULL) {return false;}
 if (typeid(*type_symbol) == typeid(safebool_type_name_c))  {return true;}
 return false;
 }
 /* A helper function... */
 bool visit_expression_type_c::is_ANY_BOOL_compatible(symbol_c *type_symbol) {
-if (type_symbol == NULL) {ERROR;}
+if (type_symbol == NULL) {return false;}
 if (is_BOOL_type    (type_symbol))              {return true;}
 if (is_SAFEBOOL_type(type_symbol))              {return true;}
 if (is_literal_bool_type(type_symbol))              {return true;}
 return false;
 }
 #define sizeoftype(symbol) get_sizeof_datatype_c::getsize(symbol)
 /* A helper function... */
 bool visit_expression_type_c::is_literal_integer_type(symbol_c *type_symbol) {
-if (type_symbol == NULL) {ERROR;}
+if (type_symbol == NULL) {return false;}
 if (typeid(*type_symbol) == typeid(neg_integer_c))        {return true;}
 return is_nonneg_literal_integer_type(type_symbol);
 }
 /* A helper function... */
 bool visit_expression_type_c::is_nonneg_literal_integer_type(symbol_c *type_symbol) {
-if (type_symbol == NULL) {ERROR;}
+if (type_symbol == NULL) {return false;}
 if (typeid(*type_symbol) == typeid(integer_c))        {return true;}
 if (typeid(*type_symbol) == typeid(binary_integer_c)) {return true;}
 if (typeid(*type_symbol) == typeid(octal_integer_c))  {return true;}
 if (typeid(*type_symbol) == typeid(hex_integer_c))    {return true;}
 return false;
 }
 /* A helper function... */
 bool visit_expression_type_c::is_literal_real_type(symbol_c *type_symbol) {
-if (type_symbol == NULL) {ERROR;}
+if (type_symbol == NULL) {return false;}
 if (typeid(*type_symbol) == typeid(real_c))     {return true;}
 if (typeid(*type_symbol) == typeid(neg_real_c)) {return true;}
 return false;
 }
 /* A helper function... */
 bool visit_expression_type_c::is_literal_bool_type(symbol_c *type_symbol) {
 bool_type_name_c bool_t;
-if (type_symbol == NULL) {ERROR;}
+if (type_symbol == NULL) {return false;}
 if (typeid(*type_symbol) == typeid(boolean_true_c))    {return true;}
 if (typeid(*type_symbol) == typeid(boolean_false_c))   {return true;}
 if (is_nonneg_literal_integer_type(type_symbol))
 if (sizeoftype(&bool_t) >= sizeoftype(type_symbol))  {return true;}
 return false;
 *
 * If two literals, then return the literal that requires more bits...
 */
 symbol_c *visit_expression_type_c::common_type__(symbol_c *first_type, symbol_c *second_type) {
-if (first_type == NULL && second_type == NULL) {ERROR;}
+if (first_type == NULL && second_type == NULL) {return NULL;}
 if (first_type == NULL)  {return second_type;}
 if (second_type == NULL) {return first_type;}
 if (is_literal_integer_type(first_type) && is_literal_integer_type(second_type))
 {return ((sizeoftype(first_type) > sizeoftype(second_type))? first_type:second_type);}
 /* Determine the common data type between two data types.
 * Unlike the common_type__() function, we stop the compiler with an ERROR
 *  if no common data type is found.
 */
 symbol_c *visit_expression_type_c::common_type(symbol_c *first_type, symbol_c *second_type) {
+/*
 symbol_c *res = common_type__(first_type, second_type);
 if (NULL == res) ERROR;
 return res;
+*/
+return common_type__(first_type, second_type);
 }
 /* Return TRUE if the second (value) data type may be assigned to a variable of the first (variable) data type
 * such as:
 *   etc...
 *
 * NOTE: It is assumed that the var_type is the data type of an lvalue
 */
 bool visit_expression_type_c::is_valid_assignment(symbol_c *var_type, symbol_c *value_type) {
-if (var_type == NULL)   {/* STAGE3_ERROR(value_type, value_type, "Var_type   == NULL"); */ ERROR;}
+if (var_type == NULL)   {/* STAGE3_ERROR(value_type, value_type, "Var_type   == NULL"); */ return false;}
-if (value_type == NULL) {/* STAGE3_ERROR(var_type,   var_type,   "Value_type == NULL"); */ ERROR;}
+if (value_type == NULL) {/* STAGE3_ERROR(var_type,   var_type,   "Value_type == NULL"); */ return false;}
-if (var_type == NULL || value_type == NULL) {ERROR;}
 symbol_c *common_type = common_type__(var_type, value_type);
 if (NULL == common_type)
 return false;
 return (typeid(*var_type) == typeid(*common_type));
 *    INT#10     AND 7.89    -> returns false
 *    SAFEBOOL#0 AND BOOL#1  -> returns true   !!!
 *   etc...
 */
 bool visit_expression_type_c::is_compatible_type(symbol_c *first_type, symbol_c *second_type) {
-if (first_type == NULL || second_type == NULL) {ERROR;}
+if (first_type == NULL || second_type == NULL) {return false;}
 return (NULL != common_type__(first_type, second_type));
 }
 /* A helper function... */
 /*
 symbol_c *visit_expression_type_c::compute_boolean_expression(symbol_c *left_type, symbol_c *right_type,
 is_data_type_t is_data_type) {
 */
-symbol_c *visit_expression_type_c::compute_expression(symbol_c *left_type, symbol_c *right_type,
+symbol_c *visit_expression_type_c::compute_expression(symbol_c *left_type,      symbol_c *right_type,     is_data_type_t is_data_type,
-is_data_type_t is_data_type) {
+						      symbol_c *left_expr, symbol_c *right_expr) {
 bool error = false;
 if (!(this->*is_data_type)(left_type)) {
-STAGE3_ERROR(left_type, left_type, "Invalid data type of left operand.");
+if (left_expr != NULL)
+STAGE3_ERROR(left_expr, left_expr, "Invalid data type of left operand.");
 error = true;
 }
 if (!(this->*is_data_type)(right_type)) {
-STAGE3_ERROR(right_type, right_type, "Invalid data type of right operand.");
+if (right_expr != NULL)
+STAGE3_ERROR(right_expr, right_expr, "Invalid data type of right operand.");
 error = true;
 }
 if (!is_compatible_type(left_type, right_type)) {
-STAGE3_ERROR(left_type, right_type, "Type mismatch between operands.");
+if ((left_expr != NULL) && (right_expr != NULL))
+STAGE3_ERROR(left_expr, right_expr, "Type mismatch between operands.");
 error = true;
 }
 if (error)
 return NULL;
 /* a helper function... */
 symbol_c *visit_expression_type_c::base_type(symbol_c *symbol) {
+/* NOTE: symbol == NULL is valid. It will occur when, for e.g., an undefined/undeclared symbolic_variable is used
+*       in the code.
+*/
+if (symbol == NULL) return NULL;
 return (symbol_c *)symbol->accept(search_base_type);
 }
 /* a helper function... */

changeset 262	197ba42d78b2
parent 260	70dfd493e639
child 263	bcb92f5b9a91