@@ -64,6 +64,7 @@ class smv_typecheckt:public typecheckt
64
64
void convert (exprt &, expr_modet);
65
65
66
66
void typecheck (exprt &, const typet &, modet);
67
+ void typecheck (exprt &, modet);
67
68
void typecheck_op (exprt &, const typet &, modet);
68
69
69
70
void typecheck () override ;
@@ -84,6 +85,7 @@ class smv_typecheckt:public typecheckt
84
85
void convert (smv_parse_treet::modulet::itemt &);
85
86
void typecheck (smv_parse_treet::modulet::itemt &);
86
87
void typecheck_expr_rec (exprt &, const typet &, modet);
88
+ void typecheck_expr_rec (exprt &, modet);
87
89
void convert_expr_to (exprt &, const typet &dest);
88
90
89
91
smv_parse_treet::modulet *modulep;
@@ -592,6 +594,40 @@ void smv_typecheckt::typecheck(
592
594
593
595
/* ******************************************************************\
594
596
597
+ Function: smv_typecheckt::typecheck
598
+
599
+ Inputs:
600
+
601
+ Outputs:
602
+
603
+ Purpose:
604
+
605
+ \*******************************************************************/
606
+
607
+ void smv_typecheckt::typecheck (exprt &expr, modet mode)
608
+ {
609
+ typecheck_expr_rec (expr, static_cast <const typet &>(get_nil_irep ()), mode);
610
+ }
611
+
612
+ /* ******************************************************************\
613
+
614
+ Function: smv_typecheckt::typecheck_expr_rec
615
+
616
+ Inputs:
617
+
618
+ Outputs:
619
+
620
+ Purpose:
621
+
622
+ \*******************************************************************/
623
+
624
+ void smv_typecheckt::typecheck_expr_rec (exprt &expr, modet mode)
625
+ {
626
+ typecheck_expr_rec (expr, static_cast <const typet &>(get_nil_irep ()), mode);
627
+ }
628
+
629
+ /* ******************************************************************\
630
+
595
631
Function: smv_typecheckt::typecheck_expr_rec
596
632
597
633
Inputs:
@@ -642,13 +678,26 @@ void smv_typecheckt::typecheck_expr_rec(
642
678
}
643
679
else if (
644
680
expr.id () == ID_and || expr.id () == ID_or || expr.id () == ID_xor ||
645
- expr.id () == ID_not)
681
+ expr.id () == ID_not || expr. id () == ID_implies )
646
682
{
647
- typecheck_op (expr, bool_typet (), mode);
683
+ for (auto &op : expr.operands ())
684
+ typecheck_expr_rec (op, mode);
685
+
686
+ expr.type () = bool_typet{};
687
+
688
+ for (auto &op : expr.operands ())
689
+ convert_expr_to (op, expr.type ());
648
690
}
649
691
else if (expr.id () == ID_smv_iff)
650
692
{
651
- typecheck_op (expr, bool_typet (), mode);
693
+ for (auto &op : expr.operands ())
694
+ typecheck_expr_rec (op, mode);
695
+
696
+ expr.type () = bool_typet{};
697
+
698
+ for (auto &op : expr.operands ())
699
+ convert_expr_to (op, expr.type ());
700
+
652
701
expr.set (ID_C_smv_iff, true );
653
702
expr.id (ID_equal);
654
703
}
@@ -670,30 +719,20 @@ void smv_typecheckt::typecheck_expr_rec(
670
719
671
720
expr.type ()=op_type;
672
721
}
673
- else if (expr.id ()==ID_implies)
674
- {
675
- if (expr.operands ().size ()!=2 )
676
- {
677
- throw errort ().with_location (expr.find_source_location ())
678
- << " Expected two operands for -> operator" ;
679
- }
680
-
681
- typecheck_op (expr, bool_typet (), mode);
682
- }
683
722
else if (expr.id ()==ID_equal || expr.id ()==ID_notequal ||
684
723
expr.id ()==ID_lt || expr.id ()==ID_le ||
685
724
expr.id ()==ID_gt || expr.id ()==ID_ge)
686
725
{
687
726
for (auto &op : expr.operands ())
688
- typecheck_expr_rec (op, static_cast < const typet &>( get_nil_irep ()), mode);
727
+ typecheck_expr_rec (op, mode);
689
728
690
729
if (expr.operands ().size ()!=2 )
691
730
{
692
731
throw errort ().with_location (expr.find_source_location ())
693
732
<< " Expected two operands for " << expr.id ();
694
733
}
695
734
696
- expr.type ()= bool_typet () ;
735
+ expr.type () = bool_typet{} ;
697
736
698
737
exprt &op0 = to_binary_expr (expr).op0 (), &op1 = to_binary_expr (expr).op1 ();
699
738
@@ -719,7 +758,8 @@ void smv_typecheckt::typecheck_expr_rec(
719
758
auto &if_expr = to_if_expr (expr);
720
759
auto &true_case = if_expr.true_case ();
721
760
auto &false_case = if_expr.false_case ();
722
- typecheck_expr_rec (if_expr.cond (), bool_typet{}, mode);
761
+ typecheck_expr_rec (if_expr.cond (), mode);
762
+ convert_expr_to (if_expr.cond (), bool_typet{});
723
763
typecheck_expr_rec (true_case, dest_type, mode);
724
764
typecheck_expr_rec (false_case, dest_type, mode);
725
765
expr.type () = dest_type;
@@ -880,7 +920,10 @@ void smv_typecheckt::typecheck_expr_rec(
880
920
for (auto &op : expr.operands ())
881
921
{
882
922
if (condition)
883
- typecheck_expr_rec (op, bool_typet (), mode);
923
+ {
924
+ typecheck_expr_rec (op, mode);
925
+ convert_expr_to (op, bool_typet{});
926
+ }
884
927
else
885
928
{
886
929
typecheck_expr_rec (
@@ -900,7 +943,10 @@ void smv_typecheckt::typecheck_expr_rec(
900
943
for (auto &op : expr.operands ())
901
944
{
902
945
if (condition)
903
- typecheck_expr_rec (op, bool_typet (), mode);
946
+ {
947
+ typecheck_expr_rec (op, mode);
948
+ convert_expr_to (op, bool_typet{});
949
+ }
904
950
else
905
951
typecheck_expr_rec (op, expr.type (), mode);
906
952
@@ -916,15 +962,19 @@ void smv_typecheckt::typecheck_expr_rec(
916
962
throw errort ().with_location (expr.source_location ())
917
963
<< " CTL operator not permitted here" ;
918
964
expr.type () = bool_typet ();
919
- typecheck_expr_rec (to_unary_expr (expr).op (), expr.type (), mode);
965
+ auto &op = to_unary_expr (expr).op ();
966
+ typecheck_expr_rec (op, mode);
967
+ convert_expr_to (op, expr.type ());
920
968
}
921
969
else if (expr.id () == ID_X || expr.id () == ID_F || expr.id () == ID_G)
922
970
{
923
971
if (mode != LTL)
924
972
throw errort ().with_location (expr.source_location ())
925
973
<< " LTL operator not permitted here" ;
926
- expr.type () = bool_typet ();
927
- typecheck_expr_rec (to_unary_expr (expr).op (), expr.type (), mode);
974
+ expr.type () = bool_typet{};
975
+ auto &op = to_unary_expr (expr).op ();
976
+ typecheck_expr_rec (op, mode);
977
+ convert_expr_to (op, expr.type ());
928
978
}
929
979
else if (
930
980
expr.id () == ID_EU || expr.id () == ID_ER || expr.id () == ID_AU ||
@@ -934,19 +984,23 @@ void smv_typecheckt::typecheck_expr_rec(
934
984
throw errort ().with_location (expr.source_location ())
935
985
<< " CTL operator not permitted here" ;
936
986
auto &binary_expr = to_binary_expr (expr);
937
- expr.type () = bool_typet ();
938
- typecheck_expr_rec (binary_expr.lhs (), expr.type (), mode);
939
- typecheck_expr_rec (binary_expr.rhs (), expr.type (), mode);
987
+ expr.type () = bool_typet{};
988
+ typecheck_expr_rec (binary_expr.lhs (), mode);
989
+ typecheck_expr_rec (binary_expr.rhs (), mode);
990
+ convert_expr_to (binary_expr.lhs (), expr.type ());
991
+ convert_expr_to (binary_expr.rhs (), expr.type ());
940
992
}
941
993
else if (expr.id () == ID_U || expr.id () == ID_R)
942
994
{
943
995
if (mode != LTL)
944
996
throw errort ().with_location (expr.source_location ())
945
997
<< " LTL operator not permitted here" ;
946
998
auto &binary_expr = to_binary_expr (expr);
947
- expr.type () = bool_typet ();
948
- typecheck_expr_rec (binary_expr.lhs (), expr.type (), mode);
949
- typecheck_expr_rec (binary_expr.rhs (), expr.type (), mode);
999
+ expr.type () = bool_typet{};
1000
+ typecheck_expr_rec (binary_expr.lhs (), mode);
1001
+ typecheck_expr_rec (binary_expr.rhs (), mode);
1002
+ convert_expr_to (binary_expr.lhs (), expr.type ());
1003
+ convert_expr_to (binary_expr.rhs (), expr.type ());
950
1004
}
951
1005
else if (expr.id ()==ID_typecast)
952
1006
{
@@ -990,7 +1044,7 @@ void smv_typecheckt::convert_expr_to(exprt &expr, const typet &type)
990
1044
smv_ranget e=convert_type (expr.type ());
991
1045
smv_ranget t=convert_type (type);
992
1046
993
- if (e.is_contained_in (t))
1047
+ if (e.is_contained_in (t) && expr. type (). id () != ID_enumeration )
994
1048
{
995
1049
if (e.is_singleton ())
996
1050
{
@@ -1222,7 +1276,8 @@ void smv_typecheckt::typecheck(
1222
1276
mode=OTHER;
1223
1277
}
1224
1278
1225
- typecheck (item.expr , bool_typet (), mode);
1279
+ typecheck (item.expr , mode);
1280
+ convert_expr_to (item.expr , bool_typet{});
1226
1281
}
1227
1282
1228
1283
/* ******************************************************************\
0 commit comments