Mercurial Mercurial > matiec / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
stage3/visit_expression_type.cc
changeset 266 2f6d8866ec8d
parent 263 bcb92f5b9a91
child 267 0a1204bcc9af
equal deleted inserted replaced
265:4d222f46f8cc 266:2f6d8866ec8d 
   650   bool error = false;
 
   650   bool error = false;
 
   651 
   651 
   652   if (!(this->*is_data_type)(left_type)) {
 
   652   if (!(this->*is_data_type)(left_type)) {
 
   653     if (debug) printf("visit_expression_type_c::compute_expression(): invalid left_type\n");
 
   653     if (debug) printf("visit_expression_type_c::compute_expression(): invalid left_type\n");
 
   654     if (left_expr != NULL)
 
   654     if (left_expr != NULL)
 
   655       STAGE3_ERROR(left_expr, left_expr, "Invalid data type of left operand.");
 
   655       STAGE3_ERROR(left_expr, left_expr, "Invalid data type of operand, or of data resulting from previous IL instructions.");
 
   656     error = true;
 
   656     error = true;
 
   657   }
 
   657   }
 
   658   if (!(this->*is_data_type)(right_type)) {
 
   658   if (!(this->*is_data_type)(right_type)) {
 
   659     if (debug) printf("visit_expression_type_c::compute_expression(): invalid right_type\n");
 
   659     if (debug) printf("visit_expression_type_c::compute_expression(): invalid right_type\n");
 
   660     if (right_expr != NULL)
 
   660     if (right_expr != NULL)
 
   661       STAGE3_ERROR(right_expr, right_expr, "Invalid data type of right operand.");
 
   661       STAGE3_ERROR(right_expr, right_expr, "Invalid data type of operand.");
 
   662     error = true;
 
   662     error = true;
 
   663   }
 
   663   }
 
   664   if (!is_compatible_type(left_type, right_type)) {
 
   664   if (!is_compatible_type(left_type, right_type)) {
 
   665     if (debug) printf("visit_expression_type_c::compute_expression(): left_type & right_type are incompatible\n");
 
   665     if (debug) printf("visit_expression_type_c::compute_expression(): left_type & right_type are incompatible\n");
 
   666     if ((left_expr != NULL) && (right_expr != NULL))
 
   666     if ((left_expr != NULL) && (right_expr != NULL))
 
   886 
   886 
   887 
   887 
   888 /* a helper function... */
 
   888 /* a helper function... */
 
   889 void *visit_expression_type_c::verify_null(symbol_c *symbol){
 
   889 void *visit_expression_type_c::verify_null(symbol_c *symbol){
 
   890   if(il_default_variable_type == NULL){
 
   890   if(il_default_variable_type == NULL){
 
   891     STAGE3_ERROR(symbol, symbol, "Il default variable can't be NULL.");
 
   891     STAGE3_ERROR(symbol, symbol, "Missing LD instruction (or equivalent) before this instruction.");
 
   892   }
 
   892   }
 
   893   if(il_operand_type == NULL){
 
   893   if(il_operand_type == NULL){
 
   894     STAGE3_ERROR(symbol, symbol, "function requires an operand.");
 
   894     STAGE3_ERROR(symbol, symbol, "This instruction requires an operand.");
 
   895   }
 
   895   }
 
   896   return NULL;
 
   896   return NULL;
 
   897 }
 
   897 }
 
   898 
   898 
   899 
   899 
   962 void *visit_expression_type_c::visit(il_simple_operation_c *symbol) {
 
   962 void *visit_expression_type_c::visit(il_simple_operation_c *symbol) {
 
   963   if (il_error)
 
   963   if (il_error)
 
   964     return NULL;
 
   964     return NULL;
 
   965 
   965 
   966   /* determine the data type of the operand */
 
   966   /* determine the data type of the operand */
 
       
   967   il_operand = symbol->il_operand;
 
   967   if (symbol->il_operand != NULL){
 
   968   if (symbol->il_operand != NULL){
 
   968     il_operand_type = base_type((symbol_c *)symbol->il_operand->accept(*this));
 
   969     il_operand_type = base_type((symbol_c *)symbol->il_operand->accept(*this));
 
   969   } else {
 
   970   } else {
 
   970     il_operand_type = NULL;
 
   971     il_operand_type = NULL;
 
   971   }
 
   972   }
 
   972   /* recursive call to see whether data types are compatible */
 
   973   /* recursive call to see whether data types are compatible */
 
   973   symbol->il_simple_operator->accept(*this);
 
   974   symbol->il_simple_operator->accept(*this);
 
   974 
   975 
   975   il_operand_type = NULL;
 
   976   il_operand_type = NULL;
 
       
   977   il_operand = NULL;
 
   976   return NULL;
 
   978   return NULL;
 
   977 }
 
   979 }
 
   978 
   980 
   979 // | function_name [il_operand_list] */
 
   981 // | function_name [il_operand_list] */
 
   980 //SYM_REF2(il_function_call_c, function_name, il_operand_list)
 
   982 //SYM_REF2(il_function_call_c, function_name, il_operand_list)
 
  1059   }
 
  1061   }
 
  1060 
  1062 
  1061   il_parenthesis_level--;
 
  1063   il_parenthesis_level--;
 
  1062   if (il_parenthesis_level < 0) ERROR;
 
  1064   if (il_parenthesis_level < 0) ERROR;
 
  1063 
  1065 
       
  1066   il_operand = symbol->simple_instr_list;
 
  1064   il_operand_type = il_default_variable_type;
 
  1067   il_operand_type = il_default_variable_type;
 
  1065   il_default_variable_type = il_default_variable_type_back;
 
  1068   il_default_variable_type = il_default_variable_type_back;
 
  1066 
  1069 
  1067   /* Now check the if the data type semantics of operation are correct,
 
  1070   /* Now check the if the data type semantics of operation are correct,
 
  1068    * but only if no previous error has been found...
 
  1071    * but only if no previous error has been found...
 
  1069    */
 
  1072    */
 
  1070   if (il_error)
 
  1073   if (!il_error)
 
  1071     return NULL;
 
  1074     symbol->il_expr_operator->accept(*this);
 
  1072   symbol->il_expr_operator->accept(*this);
 
  1075 
  1073 
  1076   il_operand_type = NULL;
 
       
  1077   il_operand = NULL;
 
  1074   return NULL;
 
  1078   return NULL;
 
  1075 }
 
  1079 }
 
  1076 
  1080 
  1077 
  1081 
  1078 #if 0
 
  1082 #if 0
 
  1250 // SYM_REF0(LDN_operator_c)
 
  1254 // SYM_REF0(LDN_operator_c)
 
  1251 void *visit_expression_type_c::visit(LDN_operator_c *symbol) {
 
  1255 void *visit_expression_type_c::visit(LDN_operator_c *symbol) {
 
  1252   if(il_operand_type == NULL)
 
  1256   if(il_operand_type == NULL)
 
  1253       STAGE3_ERROR(symbol, symbol, "LDN operator requires an operand.");
 
  1257       STAGE3_ERROR(symbol, symbol, "LDN operator requires an operand.");
 
  1254   if(!is_ANY_BIT_compatible(il_operand_type))
 
  1258   if(!is_ANY_BIT_compatible(il_operand_type))
 
  1255       STAGE3_ERROR(symbol, symbol, "invalid data type of LDN operand, should be of type ANY_BIT.");
 
  1259       STAGE3_ERROR(symbol, il_operand, "invalid data type of LDN operand, should be of type ANY_BIT.");
 
  1256   il_default_variable_type = il_operand_type;
 
  1260   il_default_variable_type = il_operand_type;
 
  1257   return NULL;
 
  1261   return NULL;
 
  1258 }
 
  1262 }
 
  1259 
  1263 
  1260 // SYM_REF0(ST_operator_c)
 
  1264 // SYM_REF0(ST_operator_c)
 
  1276     STAGE3_ERROR(symbol, symbol, "Type mismatch in ST operation.");
 
  1280     STAGE3_ERROR(symbol, symbol, "Type mismatch in ST operation.");
 
  1277   /* TODO: check whether il_operand_type is an LVALUE !! */
 
  1281   /* TODO: check whether il_operand_type is an LVALUE !! */
 
  1278   if(!is_ANY_BIT_compatible(il_default_variable_type))
 
  1282   if(!is_ANY_BIT_compatible(il_default_variable_type))
 
  1279       STAGE3_ERROR(symbol, symbol, "invalid data type of il_default_variable for STN operand, should be of type ANY_BIT.");
 
  1283       STAGE3_ERROR(symbol, symbol, "invalid data type of il_default_variable for STN operand, should be of type ANY_BIT.");
 
  1280   if(!is_ANY_BIT_compatible(il_operand_type))
 
  1284   if(!is_ANY_BIT_compatible(il_operand_type))
 
  1281       STAGE3_ERROR(symbol, symbol, "invalid data type of STN operand, should be of type ANY_BIT.");
 
  1285       STAGE3_ERROR(symbol, il_operand, "invalid data type of STN operand, should be of type ANY_BIT.");
 
  1282   /* data type of il_default_variable_type is unchanged... */
 
  1286   /* data type of il_default_variable_type is unchanged... */
 
  1283   // il_default_variable_type = il_default_variable_type;
 
  1287   // il_default_variable_type = il_default_variable_type;
 
  1284   return NULL;
 
  1288   return NULL;
 
  1285 }
 
  1289 }
 
  1286 
  1290 
  1287 //SYM_REF0(NOT_operator_c)
 
  1291 //SYM_REF0(NOT_operator_c)
 
  1288 void *visit_expression_type_c::visit(NOT_operator_c *symbol) {
 
  1292 void *visit_expression_type_c::visit(NOT_operator_c *symbol) {
 
  1289   if(il_operand_type != NULL){
 
  1293   if(il_operand_type != NULL){
 
  1290     STAGE3_ERROR(symbol, symbol, "NOT operator may not have an operand.");
 
  1294     STAGE3_ERROR(symbol, il_operand, "NOT operator may not have an operand.");
 
  1291     return NULL;
 
  1295     return NULL;
 
  1292   }
 
  1296   }
 
  1293   if(il_default_variable_type == NULL) {
 
  1297   if(il_default_variable_type == NULL) {
 
  1294     STAGE3_ERROR(symbol, symbol, "Il default variable should not be NULL.");
 
  1298     STAGE3_ERROR(symbol, symbol, "Il default variable should not be NULL.");
 
  1295     return NULL;
 
  1299     return NULL;
 
  1305 
  1309 
  1306 // SYM_REF0(S_operator_c)
 
  1310 // SYM_REF0(S_operator_c)
 
  1307 void *visit_expression_type_c::visit(S_operator_c *symbol) {
 
  1311 void *visit_expression_type_c::visit(S_operator_c *symbol) {
 
  1308   verify_null(symbol);
 
  1312   verify_null(symbol);
 
  1309   if (!is_BOOL_type(il_default_variable_type)) {STAGE3_ERROR(symbol, symbol, "IL default variable should be BOOL type.");}
 
  1313   if (!is_BOOL_type(il_default_variable_type)) {STAGE3_ERROR(symbol, symbol, "IL default variable should be BOOL type.");}
 
  1310   if (!is_BOOL_type(il_operand_type)) {STAGE3_ERROR(symbol, symbol, "operator S requires operand of type BOOL.");}
 
  1314   if (!is_BOOL_type(il_operand_type)) {STAGE3_ERROR(symbol, il_operand, "operator S requires operand of type BOOL.");}
 
  1311   /* TODO: check whether il_operand_type is an LVALUE !! */
 
  1315   /* TODO: check whether il_operand_type is an LVALUE !! */
 
  1312   /* data type of il_default_variable_type is unchanged... */
 
  1316   /* data type of il_default_variable_type is unchanged... */
 
  1313   // il_default_variable_type = il_default_variable_type;
 
  1317   // il_default_variable_type = il_default_variable_type;
 
  1314   return NULL;
 
  1318   return NULL;
 
  1315 }
 
  1319 }
 
  1316 
  1320 
  1317 // SYM_REF0(R_operator_c)
 
  1321 // SYM_REF0(R_operator_c)
 
  1318 void *visit_expression_type_c::visit(R_operator_c *symbol) {
 
  1322 void *visit_expression_type_c::visit(R_operator_c *symbol) {
 
  1319   verify_null(symbol);
 
  1323   verify_null(symbol);
 
  1320   if (!is_BOOL_type(il_default_variable_type)) {STAGE3_ERROR(symbol, symbol, "IL default variable should be BOOL type.");}
 
  1324   if (!is_BOOL_type(il_default_variable_type)) {STAGE3_ERROR(symbol, symbol, "IL default variable should be BOOL type.");}
 
  1321   if (!is_BOOL_type(il_operand_type)) {STAGE3_ERROR(symbol, symbol, "operator R requires operand of type BOOL.");}
 
  1325   if (!is_BOOL_type(il_operand_type)) {STAGE3_ERROR(symbol, il_operand, "operator R requires operand of type BOOL.");}
 
  1322   /* TODO: check whether il_operand_type is an LVALUE !! */
 
  1326   /* TODO: check whether il_operand_type is an LVALUE !! */
 
  1323   /* data type of il_default_variable_type is unchanged... */
 
  1327   /* data type of il_default_variable_type is unchanged... */
 
  1324   // il_default_variable_type = il_default_variable_type;
 
  1328   // il_default_variable_type = il_default_variable_type;
 
  1325   return NULL;
 
  1329   return NULL;
 
  1326 }
 
  1330 }
 
  1375 }
 
  1379 }
 
  1376 
  1380 
  1377 //SYM_REF0(AND_operator_c)
 
  1381 //SYM_REF0(AND_operator_c)
 
  1378 void *visit_expression_type_c::visit(AND_operator_c *symbol) {
 
  1382 void *visit_expression_type_c::visit(AND_operator_c *symbol) {
 
  1379   verify_null(symbol);
 
  1383   verify_null(symbol);
 
  1380   il_default_variable_type = compute_expression(il_default_variable_type,  il_operand_type, &visit_expression_type_c::is_ANY_BIT_compatible);
 
  1384   il_default_variable_type = compute_expression(il_default_variable_type, il_operand_type, &visit_expression_type_c::is_ANY_BIT_compatible,
 
       
  1385                                                 symbol                  , il_operand);
 
  1381   return NULL;
 
  1386   return NULL;
 
  1382 }
 
  1387 }
 
  1383 
  1388 
  1384 //SYM_REF0(OR_operator_c)
 
  1389 //SYM_REF0(OR_operator_c)
 
  1385 void *visit_expression_type_c::visit(OR_operator_c *symbol) {
 
  1390 void *visit_expression_type_c::visit(OR_operator_c *symbol) {
 
  1386   verify_null(symbol);
 
  1391   verify_null(symbol);
 
  1387   il_default_variable_type = compute_expression(il_default_variable_type,  il_operand_type, &visit_expression_type_c::is_ANY_BIT_compatible);
 
  1392   il_default_variable_type = compute_expression(il_default_variable_type, il_operand_type, &visit_expression_type_c::is_ANY_BIT_compatible,
 
       
  1393                                                 symbol                  , il_operand);
 
  1388   return NULL;
 
  1394   return NULL;
 
  1389 }
 
  1395 }
 
  1390 
  1396 
  1391 //SYM_REF0(XOR_operator_c)
 
  1397 //SYM_REF0(XOR_operator_c)
 
  1392 void *visit_expression_type_c::visit(XOR_operator_c *symbol) {
 
  1398 void *visit_expression_type_c::visit(XOR_operator_c *symbol) {
 
  1393   verify_null(symbol);
 
  1399   verify_null(symbol);
 
  1394   il_default_variable_type = compute_expression(il_default_variable_type,  il_operand_type, &visit_expression_type_c::is_ANY_BIT_compatible);
 
  1400   il_default_variable_type = compute_expression(il_default_variable_type, il_operand_type, &visit_expression_type_c::is_ANY_BIT_compatible,
 
       
  1401                                                 symbol                  , il_operand);
 
  1395   return NULL;
 
  1402   return NULL;
 
  1396 }
 
  1403 }
 
  1397 
  1404 
  1398 // SYM_REF0(ANDN_operator_c)
 
  1405 // SYM_REF0(ANDN_operator_c)
 
  1399 void *visit_expression_type_c::visit(ANDN_operator_c *symbol) {
 
  1406 void *visit_expression_type_c::visit(ANDN_operator_c *symbol) {
 
  1400   verify_null(symbol);
 
  1407   verify_null(symbol);
 
  1401   il_default_variable_type = compute_expression(il_default_variable_type,  il_operand_type, &visit_expression_type_c::is_ANY_BIT_compatible);
 
  1408   il_default_variable_type = compute_expression(il_default_variable_type, il_operand_type, &visit_expression_type_c::is_ANY_BIT_compatible,
 
       
  1409                                                 symbol                  , il_operand);
 
  1402   return NULL;
 
  1410   return NULL;
 
  1403 }
 
  1411 }
 
  1404 
  1412 
  1405 // SYM_REF0(ORN_operator_c)
 
  1413 // SYM_REF0(ORN_operator_c)
 
  1406 void *visit_expression_type_c::visit(ORN_operator_c *symbol) {
 
  1414 void *visit_expression_type_c::visit(ORN_operator_c *symbol) {
 
  1407   verify_null(symbol);
 
  1415   verify_null(symbol);
 
  1408   il_default_variable_type = compute_expression(il_default_variable_type,  il_operand_type, &visit_expression_type_c::is_ANY_BIT_compatible);
 
  1416   il_default_variable_type = compute_expression(il_default_variable_type, il_operand_type, &visit_expression_type_c::is_ANY_BIT_compatible,
 
       
  1417                                                 symbol                  , il_operand);
 
  1409   return NULL;
 
  1418   return NULL;
 
  1410 }
 
  1419 }
 
  1411 
  1420 
  1412 // SYM_REF0(XORN_operator_c)
 
  1421 // SYM_REF0(XORN_operator_c)
 
  1413 void *visit_expression_type_c::visit(XORN_operator_c *symbol) {
 
  1422 void *visit_expression_type_c::visit(XORN_operator_c *symbol) {
 
  1414   verify_null(symbol);
 
  1423   verify_null(symbol);
 
  1415   il_default_variable_type = compute_expression(il_default_variable_type,  il_operand_type, &visit_expression_type_c::is_ANY_BIT_compatible);
 
  1424   il_default_variable_type = compute_expression(il_default_variable_type, il_operand_type, &visit_expression_type_c::is_ANY_BIT_compatible,
 
       
  1425                                                 symbol                  , il_operand);
 
  1416   return NULL;
 
  1426   return NULL;
 
  1417 }
 
  1427 }
 
  1418 
  1428 
  1419 // SYM_REF0(ADD_operator_c)
 
  1429 // SYM_REF0(ADD_operator_c)
 
  1420 void *visit_expression_type_c::visit(ADD_operator_c *symbol) {
 
  1430 void *visit_expression_type_c::visit(ADD_operator_c *symbol) {
 
  1444   else if (is_type(left_type, dt_type_name_c)       && is_type(right_type, safetime_type_name_c))
 
  1454   else if (is_type(left_type, dt_type_name_c)       && is_type(right_type, safetime_type_name_c))
 
  1445     il_default_variable_type = &dt_type_name;
 
  1455     il_default_variable_type = &dt_type_name;
 
  1446   else if (is_type(left_type, safedt_type_name_c)   && is_type(right_type, safetime_type_name_c))
 
  1456   else if (is_type(left_type, safedt_type_name_c)   && is_type(right_type, safetime_type_name_c))
 
  1447     il_default_variable_type = &safedt_type_name;
 
  1457     il_default_variable_type = &safedt_type_name;
 
  1448 
  1458 
  1449   else il_default_variable_type = compute_expression(il_default_variable_type, il_operand_type, &visit_expression_type_c::is_ANY_MAGNITUDE_compatible);
 
  1459   else il_default_variable_type = compute_expression(il_default_variable_type, il_operand_type, &visit_expression_type_c::is_ANY_MAGNITUDE_compatible,
 
       
  1460                                                      symbol                  , il_operand);
 
  1450   return NULL;
 
  1461   return NULL;
 
  1451 }
 
  1462 }
 
  1452 
  1463 
  1453 // SYM_REF0(SUB_operator_c)
 
  1464 // SYM_REF0(SUB_operator_c)
 
  1454 void *visit_expression_type_c::visit(SUB_operator_c *symbol) {
 
  1465 void *visit_expression_type_c::visit(SUB_operator_c *symbol) {
 
  1505   else if (is_type(left_type, dt_type_name_c)       && is_type(right_type, safedt_type_name_c))
 
  1516   else if (is_type(left_type, dt_type_name_c)       && is_type(right_type, safedt_type_name_c))
 
  1506     il_default_variable_type = &time_type_name;
 
  1517     il_default_variable_type = &time_type_name;
 
  1507   else if (is_type(left_type, safedt_type_name_c)   && is_type(right_type, safedt_type_name_c))
 
  1518   else if (is_type(left_type, safedt_type_name_c)   && is_type(right_type, safedt_type_name_c))
 
  1508     il_default_variable_type = &safetime_type_name;
 
  1519     il_default_variable_type = &safetime_type_name;
 
  1509 
  1520 
  1510   else il_default_variable_type = compute_expression(il_default_variable_type, il_operand_type, &visit_expression_type_c::is_ANY_MAGNITUDE_compatible);
 
  1521   else il_default_variable_type = compute_expression(il_default_variable_type, il_operand_type, &visit_expression_type_c::is_ANY_MAGNITUDE_compatible,
 
       
  1522                                                      symbol                  , il_operand);
 
  1511   return NULL;
 
  1523   return NULL;
 
  1512 }
 
  1524 }
 
  1513 
  1525 
  1514 // SYM_REF0(MUL_operator_c)
 
  1526 // SYM_REF0(MUL_operator_c)
 
  1515 void *visit_expression_type_c::visit(MUL_operator_c *symbol) {
 
  1527 void *visit_expression_type_c::visit(MUL_operator_c *symbol) {
 
  1527    * this next line is really only to check for integers/reals of undefined type on 'right_type'... 
  1539    * this next line is really only to check for integers/reals of undefined type on 'right_type'... 
  1528    */
 
  1540    */
 
  1529   else if (is_type(left_type, safetime_type_name_c) && is_ANY_NUM_compatible(right_type))
 
  1541   else if (is_type(left_type, safetime_type_name_c) && is_ANY_NUM_compatible(right_type))
 
  1530     il_default_variable_type = &safetime_type_name;
 
  1542     il_default_variable_type = &safetime_type_name;
 
  1531 
  1543 
  1532   else il_default_variable_type = compute_expression(il_default_variable_type, il_operand_type, &visit_expression_type_c::is_ANY_NUM_compatible);
 
  1544   else il_default_variable_type = compute_expression(il_default_variable_type, il_operand_type, &visit_expression_type_c::is_ANY_NUM_compatible,
 
       
  1545                                                      symbol                  , il_operand);
 
  1533   return NULL;
 
  1546   return NULL;
 
  1534 }
 
  1547 }
 
  1535 
  1548 
  1536 // SYM_REF0(DIV_operator_c)
 
  1549 // SYM_REF0(DIV_operator_c)
 
  1537 void *visit_expression_type_c::visit(DIV_operator_c *symbol) {
 
  1550 void *visit_expression_type_c::visit(DIV_operator_c *symbol) {
 
  1549    * this next line is really only to check for integers/reals of undefined type on 'right_type'... 
  1562    * this next line is really only to check for integers/reals of undefined type on 'right_type'... 
  1550    */
 
  1563    */
 
  1551   else if (is_type(left_type, safetime_type_name_c) && is_ANY_NUM_compatible(right_type))
 
  1564   else if (is_type(left_type, safetime_type_name_c) && is_ANY_NUM_compatible(right_type))
 
  1552     il_default_variable_type = &safetime_type_name;
 
  1565     il_default_variable_type = &safetime_type_name;
 
  1553 
  1566 
  1554   else il_default_variable_type = compute_expression(il_default_variable_type, il_operand_type, &visit_expression_type_c::is_ANY_NUM_compatible);
 
  1567   else il_default_variable_type = compute_expression(il_default_variable_type, il_operand_type, &visit_expression_type_c::is_ANY_NUM_compatible,
 
       
  1568                                                      symbol                  , il_operand);
 
  1555   return NULL;
 
  1569   return NULL;
 
  1556 }
 
  1570 }
 
  1557 
  1571 
  1558 // SYM_REF0(MOD_operator_c)
 
  1572 // SYM_REF0(MOD_operator_c)
 
  1559 void *visit_expression_type_c::visit(MOD_operator_c *symbol) {
 
  1573 void *visit_expression_type_c::visit(MOD_operator_c *symbol) {
 
  1563 }
 
  1577 }
 
  1564 
  1578 
  1565 // SYM_REF0(GT_operator_c)
 
  1579 // SYM_REF0(GT_operator_c)
 
  1566 void *visit_expression_type_c::visit(GT_operator_c *symbol) {
 
  1580 void *visit_expression_type_c::visit(GT_operator_c *symbol) {
 
  1567   verify_null(symbol);
 
  1581   verify_null(symbol);
 
  1568   compute_expression(il_default_variable_type, il_operand_type, &visit_expression_type_c::is_ANY_ELEMENTARY_compatible);
 
  1582   compute_expression(il_default_variable_type, il_operand_type, &visit_expression_type_c::is_ANY_ELEMENTARY_compatible,
 
       
  1583                      symbol                  , il_operand);
 
  1569   il_default_variable_type = &search_expression_type_c::bool_type_name;
 
  1584   il_default_variable_type = &search_expression_type_c::bool_type_name;
 
  1570   return NULL;
 
  1585   return NULL;
 
  1571 }
 
  1586 }
 
  1572 
  1587 
  1573 //SYM_REF0(GE_operator_c)
 
  1588 //SYM_REF0(GE_operator_c)
 
  1574 void *visit_expression_type_c::visit(GE_operator_c *symbol) {
 
  1589 void *visit_expression_type_c::visit(GE_operator_c *symbol) {
 
  1575   verify_null(symbol);
 
  1590   verify_null(symbol);
 
  1576   compute_expression(il_default_variable_type, il_operand_type, &visit_expression_type_c::is_ANY_ELEMENTARY_compatible);
 
  1591   compute_expression(il_default_variable_type, il_operand_type, &visit_expression_type_c::is_ANY_ELEMENTARY_compatible,
 
       
  1592                      symbol                  , il_operand);
 
  1577   il_default_variable_type = &search_expression_type_c::bool_type_name;
 
  1593   il_default_variable_type = &search_expression_type_c::bool_type_name;
 
  1578   return NULL;
 
  1594   return NULL;
 
  1579 }
 
  1595 }
 
  1580 
  1596 
  1581 //SYM_REF0(EQ_operator_c)
 
  1597 //SYM_REF0(EQ_operator_c)
 
  1582 void *visit_expression_type_c::visit(EQ_operator_c *symbol) {
 
  1598 void *visit_expression_type_c::visit(EQ_operator_c *symbol) {
 
  1583   verify_null(symbol);
 
  1599   verify_null(symbol);
 
  1584   compute_expression(il_default_variable_type, il_operand_type, &visit_expression_type_c::is_ANY_ELEMENTARY_compatible);
 
  1600   compute_expression(il_default_variable_type, il_operand_type, &visit_expression_type_c::is_ANY_ELEMENTARY_compatible,
 
       
  1601                      symbol                  , il_operand);
 
  1585   il_default_variable_type = &search_expression_type_c::bool_type_name;
 
  1602   il_default_variable_type = &search_expression_type_c::bool_type_name;
 
  1586   return NULL;
 
  1603   return NULL;
 
  1587 }
 
  1604 }
 
  1588 
  1605 
  1589 //SYM_REF0(LT_operator_c)
 
  1606 //SYM_REF0(LT_operator_c)
 
  1590 void *visit_expression_type_c::visit(LT_operator_c *symbol) {
 
  1607 void *visit_expression_type_c::visit(LT_operator_c *symbol) {
 
  1591   verify_null(symbol);
 
  1608   verify_null(symbol);
 
  1592   compute_expression(il_default_variable_type, il_operand_type, &visit_expression_type_c::is_ANY_ELEMENTARY_compatible);
 
  1609   compute_expression(il_default_variable_type, il_operand_type, &visit_expression_type_c::is_ANY_ELEMENTARY_compatible,
 
       
  1610                      symbol                  , il_operand);
 
  1593   il_default_variable_type = &search_expression_type_c::bool_type_name;
 
  1611   il_default_variable_type = &search_expression_type_c::bool_type_name;
 
  1594   return NULL;
 
  1612   return NULL;
 
  1595 }
 
  1613 }
 
  1596 
  1614 
  1597 //SYM_REF0(LE_operator_c)
 
  1615 //SYM_REF0(LE_operator_c)
 
  1598 void *visit_expression_type_c::visit(LE_operator_c *symbol) {
 
  1616 void *visit_expression_type_c::visit(LE_operator_c *symbol) {
 
  1599   verify_null(symbol);
 
  1617   verify_null(symbol);
 
  1600   compute_expression(il_default_variable_type, il_operand_type, &visit_expression_type_c::is_ANY_ELEMENTARY_compatible);
 
  1618   compute_expression(il_default_variable_type, il_operand_type, &visit_expression_type_c::is_ANY_ELEMENTARY_compatible,
 
       
  1619                      symbol                  , il_operand);
 
  1601   il_default_variable_type = &search_expression_type_c::bool_type_name;
 
  1620   il_default_variable_type = &search_expression_type_c::bool_type_name;
 
  1602   return NULL;
 
  1621   return NULL;
 
  1603 }
 
  1622 }
 
  1604 
  1623 
  1605 //SYM_REF0(NE_operator_c)
 
  1624 //SYM_REF0(NE_operator_c)
 
  1606 void *visit_expression_type_c::visit(NE_operator_c *symbol) {
 
  1625 void *visit_expression_type_c::visit(NE_operator_c *symbol) {
 
  1607   verify_null(symbol);
 
  1626   verify_null(symbol);
 
  1608   compute_expression(il_default_variable_type, il_operand_type, &visit_expression_type_c::is_ANY_ELEMENTARY_compatible);
 
  1627   compute_expression(il_default_variable_type, il_operand_type, &visit_expression_type_c::is_ANY_ELEMENTARY_compatible,
 
       
  1628                      symbol                  , il_operand);
 
  1609   il_default_variable_type = &search_expression_type_c::bool_type_name;
 
  1629   il_default_variable_type = &search_expression_type_c::bool_type_name;
 
  1610   return NULL;
 
  1630   return NULL;
 
  1611 }
 
  1631 }
 
  1612 
  1632 
  1613 // SYM_REF0(CAL_operator_c)
 
  1633 // SYM_REF0(CAL_operator_c)
matiec