1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
1184
1185
1186
1187
1188
1189
1190
1191
1192
1193
1194
1195
1196
1197
1198
1199
1200
1201
1202
1203
1204
1205
1206
1207
1208
1209
1210
1211
1212
1213
1214
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
1251
1252
1253
1254
1255
1256
1257
1258
1259
1260
1261
1262
1263
1264
1265
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282
1283
1284
1285
1286
1287
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297
1298
1299
1300
1301
1302
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312
1313
1314
1315
1316
1317
1318
1319
1320
1321
1322
1323
1324
1325
1326
1327
1328
1329
1330
1331
1332
1333
1334
1335
1336
1337
1338
1339
1340
1341
1342
1343
1344
1345
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357
1358
1359
1360
1361
1362
1363
1364
1365
1366
1367
1368
1369
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
1393
1394
1395
1396
1397
1398
1399
1400
1401
1402
1403
1404
1405
1406
1407
1408
1409
1410
1411
1412
1413
1414
1415
1416
1417
1418
1419
1420
1421
1422
1423
1424
1425
1426
1427
1428
1429
1430
1431
1432
1433
1434
1435
1436
1437
1438
1439
1440
1441
1442
1443
1444
1445
1446
1447
1448
1449
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460
1461
1462
1463
1464
1465
1466
1467
1468
1469
1470
1471
1472
1473
1474
1475
1476
1477
1478
1479
1480
1481
1482
1483
1484
1485
1486
1487
1488
1489
1490
1491
1492
1493
1494
1495
1496
1497
1498
1499
1500
1501
1502
1503
1504
1505
1506
1507
1508
1509
1510
1511
1512
1513
1514
1515
1516
1517
1518
1519
1520
1521
1522
1523
1524
1525
1526
1527
1528
1529
1530
1531
1532
1533
1534
1535
1536
1537
1538
1539
1540
1541
1542
1543
1544
1545
1546
1547
1548
1549
1550
1551
1552
1553
1554
1555
1556
1557
1558
1559
1560
1561
1562
1563
1564
1565
1566
1567
1568
1569
1570
1571
1572
1573
1574
1575
1576
1577
1578
1579
1580
1581
1582
1583
1584
1585
1586
1587
1588
1589
1590
1591
1592
1593
1594
1595
1596
1597
1598
1599
1600
1601
1602
1603
1604
1605
1606
1607
1608
1609
1610
1611
1612
1613
1614
1615
1616
1617
1618
1619
1620
1621
1622
1623
1624
1625
1626
1627
1628
1629
1630
1631
1632
1633
1634
1635
1636
1637
1638
1639
1640
1641
1642
1643
1644
1645
1646
1647
1648
1649
1650
1651
1652
1653
1654
1655
1656
1657
1658
1659
1660
1661
1662
1663
1664
1665
1666
1667
1668
1669
1670
1671
1672
1673
1674
1675
1676
1677
1678
1679
1680
1681
1682
1683
1684
1685
1686
1687
1688
1689
1690
1691
1692
1693
1694
1695
1696
1697
1698
1699
1700
1701
1702
1703
1704
1705
1706
1707
1708
1709
1710
1711
1712
1713
1714
1715
1716
1717
1718
1719
1720
1721
1722
1723
1724
1725
1726
1727
1728
1729
1730
1731
1732
1733
1734
1735
1736
1737
1738
1739
1740
1741
1742
1743
1744
1745
1746
1747
1748
1749
1750
1751
1752
1753
1754
1755
1756
1757
1758
1759
1760
1761
1762
1763
1764
1765
1766
1767
1768
1769
1770
1771
1772
1773
1774
1775
1776
1777
1778
1779
1780
1781
1782
1783
1784
1785
1786
1787
1788
1789
1790
1791
1792
1793
1794
1795
1796
1797
1798
1799
1800
1801
1802
1803
1804
1805
1806
1807
1808
1809
1810
1811
1812
1813
1814
1815
1816
1817
1818
1819
1820
1821
1822
1823
1824
1825
1826
1827
1828
1829
1830
1831
1832
1833
1834
1835
1836
1837
1838
1839
1840
1841
1842
1843
1844
1845
1846
1847
1848
1849
1850
1851
1852
1853
1854
1855
1856
1857
1858
1859
1860
1861
1862
1863
1864
1865
1866
1867
1868
1869
1870
1871
1872
1873
1874
1875
1876
1877
1878
1879
1880
1881
1882
1883
1884
1885
1886
1887
1888
1889
1890
1891
1892
1893
1894
1895
1896
1897
1898
1899
1900
1901
1902
1903
1904
1905
1906
1907
1908
1909
1910
1911
1912
1913
1914
1915
1916
1917
1918
1919
1920
1921
1922
1923
1924
1925
1926
1927
1928
1929
1930
1931
1932
1933
1934
1935
1936
1937
1938
1939
1940
1941
1942
1943
1944
1945
1946
1947
1948
1949
1950
1951
1952
1953
1954
1955
1956
1957
1958
1959
1960
1961
1962
1963
1964
1965
1966
1967
1968
1969
1970
1971
1972
1973
1974
1975
1976
1977
1978
1979
1980
1981
1982
1983
1984
1985
1986
1987
1988
1989
1990
1991
1992
1993
1994
1995
1996
1997
1998
1999
2000
2001
2002
2003
2004
2005
2006
2007
2008
2009
2010
2011
2012
2013
2014
2015
2016
2017
2018
2019
2020
2021
2022
2023
2024
2025
2026
2027
2028
2029
2030
2031
2032
2033
2034
2035
2036
2037
2038
2039
2040
2041
2042
2043
2044
2045
2046
2047
2048
2049
2050
2051
2052
2053
2054
2055
2056
2057
2058
2059
2060
2061
2062
2063
2064
2065
2066
2067
2068
2069
2070
2071
2072
2073
2074
2075
2076
2077
2078
2079
2080
2081
2082
2083
2084
2085
2086
2087
2088
2089
2090
2091
2092
2093
2094
2095
2096
2097
2098
2099
2100
2101
2102
2103
2104
2105
2106
2107
2108
2109
2110
2111
2112
2113
2114
2115
2116
2117
2118
2119
2120
2121
2122
2123
2124
2125
2126
2127
2128
2129
2130
2131
2132
2133
2134
2135
2136
2137
2138
2139
2140
2141
2142
2143
2144
2145
2146
2147
2148
2149
2150
2151
2152
2153
2154
2155
2156
2157
2158
2159
2160
2161
2162
2163
2164
2165
2166
2167
2168
2169
2170
2171
2172
2173
2174
2175
2176
2177
2178
2179
2180
2181
|
(************************************************************************)
(* v * The Coq Proof Assistant / The Coq Development Team *)
(* <O___,, * INRIA - CNRS - LIX - LRI - PPS - Copyright 1999-2012 *)
(* \VV/ **************************************************************)
(* // * This file is distributed under the terms of the *)
(* * GNU Lesser General Public License Version 2.1 *)
(************************************************************************)
open Constrintern
open Patternops
open Pp
open Genredexpr
open Glob_term
open Glob_ops
open Tacred
open Errors
open Util
open Names
open Nameops
open Libnames
open Globnames
open Nametab
open Pfedit
open Proof_type
open Refiner
open Tacmach
open Tactic_debug
open Constrexpr
open Term
open Termops
open Tacexpr
open Genarg
open Stdarg
open Constrarg
open Printer
open Pretyping
open Evd
open Misctypes
open Locus
open Tacintern
open Taccoerce
open Proofview.Notations
let safe_msgnl s =
Proofview.NonLogical.catch
(Proofview.NonLogical.print (s++fnl()))
(fun _ -> Proofview.NonLogical.print (str "bug in the debugger: an exception is raised while printing debug information"++fnl()))
type value = tlevel generic_argument
(* Values for interpretation *)
type tacvalue =
| VRTactic (* variant of unit returned by match. For historical reasons. *)
| VFun of ltac_trace * value Id.Map.t *
Id.t option list * glob_tactic_expr
| VRec of value Id.Map.t ref * glob_tactic_expr
let (wit_tacvalue : (Empty.t, Empty.t, tacvalue) Genarg.genarg_type) =
Genarg.create_arg None "tacvalue"
let of_tacvalue v = in_gen (topwit wit_tacvalue) v
let to_tacvalue v = out_gen (topwit wit_tacvalue) v
module Value = Taccoerce.Value
let dloc = Loc.ghost
let catching_error call_trace fail e =
let inner_trace =
Option.default [] (Exninfo.get e ltac_trace_info)
in
if List.is_empty call_trace && List.is_empty inner_trace then fail e
else begin
assert (Errors.noncritical e); (* preserved invariant *)
let new_trace = inner_trace @ call_trace in
let located_exc = Exninfo.add e ltac_trace_info new_trace in
fail located_exc
end
module TacStore = Geninterp.TacStore
let f_avoid_ids : Id.t list TacStore.field = TacStore.field ()
(* ids inherited from the call context (needed to get fresh ids) *)
let f_debug : debug_info TacStore.field = TacStore.field ()
let f_trace : ltac_trace TacStore.field = TacStore.field ()
let catch_error call_trace f x =
try f x
with e when Errors.noncritical e ->
let e = Errors.push e in
catching_error call_trace raise e
let catch_error_tac call_trace tac =
Proofview.tclORELSE
tac
(catching_error call_trace Proofview.tclZERO)
(* Signature for interpretation: val_interp and interpretation functions *)
type interp_sign = Geninterp.interp_sign = {
lfun : value Id.Map.t;
extra : TacStore.t }
let curr_debug ist = match TacStore.get ist.extra f_debug with
| None -> DebugOff
| Some level -> level
(** TODO: unify printing of generic Ltac values in case of coercion failure. *)
(* Displays a value *)
let pr_value env v =
let v = Value.normalize v in
if has_type v (topwit wit_tacvalue) then str "a tactic"
else if has_type v (topwit wit_constr_context) then
let c = out_gen (topwit wit_constr_context) v in
match env with
| Some env -> pr_lconstr_env env c
| _ -> str "a term"
else if has_type v (topwit wit_constr) then
let c = out_gen (topwit wit_constr) v in
match env with
| Some env -> pr_lconstr_env env c
| _ -> str "a term"
else if has_type v (topwit wit_constr_under_binders) then
let c = out_gen (topwit wit_constr_under_binders) v in
match env with
| Some env -> pr_lconstr_under_binders_env env c
| _ -> str "a term"
else
str "a value of type" ++ spc () ++ pr_argument_type (genarg_tag v)
let pr_inspect env expr result =
let pp_expr = Pptactic.pr_glob_tactic env expr in
let pp_result =
if has_type result (topwit wit_tacvalue) then
match to_tacvalue result with
| VRTactic -> str "a VRTactic"
| VFun (_, il, ul, b) ->
let pp_body = Pptactic.pr_glob_tactic env b in
let pr_sep () = str ", " in
let pr_iarg (id, _) = pr_id id in
let pr_uarg = function
| None -> str "_"
| Some id -> pr_id id
in
let pp_iargs = prlist_with_sep pr_sep pr_iarg (Id.Map.bindings il) in
let pp_uargs = prlist_with_sep pr_sep pr_uarg ul in
str "a VFun with body " ++ fnl() ++ pp_body ++ fnl() ++
str "instantiated arguments " ++ fnl() ++ pp_iargs ++ fnl () ++
str "uninstantiated arguments " ++ fnl() ++ pp_uargs
| VRec _ -> str "a VRec"
else
let pp_type = pr_argument_type (genarg_tag result) in
str "an object of type" ++ spc () ++ pp_type
in
pp_expr ++ fnl() ++ str "this is " ++ pp_result
(* Transforms an id into a constr if possible, or fails with Not_found *)
let constr_of_id env id =
Term.mkVar (let _ = Environ.lookup_named id env in id)
(* To embed tactics *)
let ((tactic_in : (interp_sign -> glob_tactic_expr) -> Dyn.t),
(tactic_out : Dyn.t -> (interp_sign -> glob_tactic_expr))) =
Dyn.create "tactic"
let ((value_in : value -> Dyn.t),
(value_out : Dyn.t -> value)) = Dyn.create "value"
let valueIn t = TacDynamic (Loc.ghost, value_in t)
(** Generic arguments : table of interpretation functions *)
let push_trace call ist = match TacStore.get ist.extra f_trace with
| None -> [call]
| Some trace -> call :: trace
let extract_trace ist = match TacStore.get ist.extra f_trace with
| None -> []
| Some l -> l
let propagate_trace ist loc id v =
let v = Value.normalize v in
if has_type v (topwit wit_tacvalue) then
let tacv = to_tacvalue v in
match tacv with
| VFun (_,lfun,it,b) ->
let t = if List.is_empty it then b else TacFun (it,b) in
let ans = VFun (push_trace(loc,LtacVarCall (id,t)) ist,lfun,it,b) in
of_tacvalue ans
| _ -> v
else v
let append_trace trace v =
let v = Value.normalize v in
if has_type v (topwit wit_tacvalue) then
match to_tacvalue v with
| VFun (trace',lfun,it,b) -> of_tacvalue (VFun (trace'@trace,lfun,it,b))
| _ -> v
else v
(* Dynamically check that an argument is a tactic *)
let coerce_to_tactic loc id v =
let v = Value.normalize v in
let fail () = user_err_loc
(loc, "", str "Variable " ++ pr_id id ++ str " should be bound to a tactic.")
in
let v = Value.normalize v in
if has_type v (topwit wit_tacvalue) then
let tacv = to_tacvalue v in
match tacv with
| VFun _ | VRTactic -> v
| _ -> fail ()
else fail ()
(* External tactics *)
let print_xml_term = ref (fun _ -> failwith "print_xml_term unset")
let declare_xml_printer f = print_xml_term := f
let internalise_tacarg ch = G_xml.parse_tactic_arg ch
let extern_tacarg ch env sigma v = match Value.to_constr v with
| None ->
error "Only externing of closed terms is implemented."
| Some c -> !print_xml_term ch env sigma c
let extern_request ch req gl la =
output_string ch "<REQUEST req=\""; output_string ch req;
output_string ch "\">\n";
List.iter (pf_apply (extern_tacarg ch) gl) la;
output_string ch "</REQUEST>\n"
let value_of_ident id =
in_gen (topwit wit_intro_pattern) (Loc.ghost, IntroIdentifier id)
let (+++) lfun1 lfun2 = Id.Map.fold Id.Map.add lfun1 lfun2
let extend_values_with_bindings (ln,lm) lfun =
let of_cub c = match c with
| [], c -> Value.of_constr c
| _ -> in_gen (topwit wit_constr_under_binders) c
in
(* For compatibility, bound variables are visible only if no other
binding of the same name exists *)
let accu = Id.Map.map value_of_ident ln in
let accu = lfun +++ accu in
Id.Map.fold (fun id c accu -> Id.Map.add id (of_cub c) accu) lm accu
(***************************************************************************)
(* Evaluation/interpretation *)
let is_variable env id =
Id.List.mem id (ids_of_named_context (Environ.named_context env))
(* Debug reference *)
let debug = ref DebugOff
(* Sets the debugger mode *)
let set_debug pos = debug := pos
(* Gives the state of debug *)
let get_debug () = !debug
let debugging_step ist pp = match curr_debug ist with
| DebugOn lev ->
safe_msgnl (str "Level " ++ int lev ++ str": " ++ pp () ++ fnl())
| _ -> Proofview.NonLogical.ret ()
let debugging_exception_step ist signal_anomaly e pp =
let explain_exc =
if signal_anomaly then explain_logic_error
else explain_logic_error_no_anomaly in
debugging_step ist (fun () ->
pp() ++ spc() ++ str "raised the exception" ++ fnl() ++ !explain_exc e)
let error_ltac_variable loc id env v s =
user_err_loc (loc, "", str "Ltac variable " ++ pr_id id ++
strbrk " is bound to" ++ spc () ++ pr_value env v ++ spc () ++
strbrk "which cannot be coerced to " ++ str s ++ str".")
(* Raise Not_found if not in interpretation sign *)
let try_interp_ltac_var coerce ist env (loc,id) =
let v = Id.Map.find id ist.lfun in
try coerce v with CannotCoerceTo s -> error_ltac_variable loc id env v s
let interp_ltac_var coerce ist env locid =
try try_interp_ltac_var coerce ist env locid
with Not_found -> anomaly (str "Detected '" ++ Id.print (snd locid) ++ str "' as ltac var at interning time")
let interp_ident_gen fresh ist env id =
try try_interp_ltac_var (coerce_to_ident fresh env) ist (Some env) (dloc,id)
with Not_found -> id
let interp_ident = interp_ident_gen false
let interp_fresh_ident = interp_ident_gen true
let pf_interp_ident id gl = interp_ident_gen false id (pf_env gl)
(* Interprets an optional identifier which must be fresh *)
let interp_fresh_name ist env = function
| Anonymous -> Anonymous
| Name id -> Name (interp_fresh_ident ist env id)
let interp_intro_pattern_var loc ist env id =
try try_interp_ltac_var (coerce_to_intro_pattern env) ist (Some env) (loc,id)
with Not_found -> IntroIdentifier id
let interp_hint_base ist s =
try try_interp_ltac_var coerce_to_hint_base ist None (dloc,Id.of_string s)
with Not_found -> s
let interp_int ist locid =
try try_interp_ltac_var coerce_to_int ist None locid
with Not_found ->
user_err_loc(fst locid,"interp_int",
str "Unbound variable " ++ pr_id (snd locid) ++ str".")
let interp_int_or_var ist = function
| ArgVar locid -> interp_int ist locid
| ArgArg n -> n
let interp_int_or_var_as_list ist = function
| ArgVar (_,id as locid) ->
(try coerce_to_int_or_var_list (Id.Map.find id ist.lfun)
with Not_found | CannotCoerceTo _ -> [ArgArg (interp_int ist locid)])
| ArgArg n as x -> [x]
let interp_int_or_var_list ist l =
List.flatten (List.map (interp_int_or_var_as_list ist) l)
(* Interprets a bound variable (especially an existing hypothesis) *)
let interp_hyp ist env (loc,id as locid) =
(* Look first in lfun for a value coercible to a variable *)
try try_interp_ltac_var (coerce_to_hyp env) ist (Some env) locid
with Not_found ->
(* Then look if bound in the proof context at calling time *)
if is_variable env id then id
else Loc.raise loc (Logic.RefinerError (Logic.NoSuchHyp id))
let interp_hyp_list_as_list ist env (loc,id as x) =
try coerce_to_hyp_list env (Id.Map.find id ist.lfun)
with Not_found | CannotCoerceTo _ -> [interp_hyp ist env x]
let interp_hyp_list ist gl l =
List.flatten (List.map (interp_hyp_list_as_list ist gl) l)
let interp_move_location ist gl = function
| MoveAfter id -> MoveAfter (interp_hyp ist gl id)
| MoveBefore id -> MoveBefore (interp_hyp ist gl id)
| MoveFirst -> MoveFirst
| MoveLast -> MoveLast
let interp_reference ist env = function
| ArgArg (_,r) -> r
| ArgVar (loc, id) ->
try try_interp_ltac_var (coerce_to_reference env) ist (Some env) (loc, id)
with Not_found ->
try
let (v, _, _) = Environ.lookup_named id env in
VarRef v
with Not_found -> error_global_not_found_loc loc (qualid_of_ident id)
let interp_inductive ist = function
| ArgArg r -> r
| ArgVar locid -> interp_ltac_var coerce_to_inductive ist None locid
let try_interp_evaluable env (loc, id) =
let v = Environ.lookup_named id env in
match v with
| (_, Some _, _) -> EvalVarRef id
| _ -> error_not_evaluable (VarRef id)
let interp_evaluable ist env = function
| ArgArg (r,Some (loc,id)) ->
(* Maybe [id] has been introduced by Intro-like tactics *)
begin
try try_interp_evaluable env (loc, id)
with Not_found ->
match r with
| EvalConstRef _ -> r
| _ -> error_global_not_found_loc loc (qualid_of_ident id)
end
| ArgArg (r,None) -> r
| ArgVar (loc, id) ->
try try_interp_ltac_var (coerce_to_evaluable_ref env) ist (Some env) (loc, id)
with Not_found ->
try try_interp_evaluable env (loc, id)
with Not_found -> error_global_not_found_loc loc (qualid_of_ident id)
(* Interprets an hypothesis name *)
let interp_occurrences ist occs =
Locusops.occurrences_map (interp_int_or_var_list ist) occs
let interp_hyp_location ist gl ((occs,id),hl) =
((interp_occurrences ist occs,interp_hyp ist gl id),hl)
let interp_clause ist gl { onhyps=ol; concl_occs=occs } =
{ onhyps=Option.map(List.map (interp_hyp_location ist gl)) ol;
concl_occs=interp_occurrences ist occs }
(* Interpretation of constructions *)
(* Extract the constr list from lfun *)
let extract_ltac_constr_values ist env =
let fold id v accu =
try
let c = coerce_to_constr env v in
Id.Map.add id c accu
with CannotCoerceTo _ -> accu
in
Id.Map.fold fold ist.lfun Id.Map.empty
(** ppedrot: I have changed the semantics here. Before this patch, closure was
implemented as a list and a variable could be bound several times with
different types, resulting in its possible appearance on both sides. This
could barely be defined as a feature... *)
(* Extract the identifier list from lfun: join all branches (what to do else?)*)
let rec intropattern_ids (loc,pat) = match pat with
| IntroIdentifier id -> [id]
| IntroOrAndPattern ll ->
List.flatten (List.map intropattern_ids (List.flatten ll))
| IntroInjection l ->
List.flatten (List.map intropattern_ids l)
| IntroWildcard | IntroAnonymous | IntroFresh _ | IntroRewrite _
| IntroForthcoming _ -> []
let extract_ids ids lfun =
let fold id v accu =
let v = Value.normalize v in
if has_type v (topwit wit_intro_pattern) then
let (_, ipat) = out_gen (topwit wit_intro_pattern) v in
if Id.List.mem id ids then accu
else accu @ intropattern_ids (dloc, ipat)
else accu
in
Id.Map.fold fold lfun []
let default_fresh_id = Id.of_string "H"
let interp_fresh_id ist env l =
let ids = List.map_filter (function ArgVar (_, id) -> Some id | _ -> None) l in
let avoid = match TacStore.get ist.extra f_avoid_ids with
| None -> []
| Some l -> l
in
let avoid = (extract_ids ids ist.lfun) @ avoid in
let id =
if List.is_empty l then default_fresh_id
else
let s =
String.concat "" (List.map (function
| ArgArg s -> s
| ArgVar (_,id) -> Id.to_string (interp_ident ist env id)) l) in
let s = if Lexer.is_keyword s then s^"0" else s in
Id.of_string s in
Tactics.fresh_id_in_env avoid id env
let pf_interp_fresh_id ist gl = interp_fresh_id ist (pf_env gl)
let interp_gen kind ist allow_patvar flags env sigma (c,ce) =
let constrvars = extract_ltac_constr_values ist env in
let vars = (constrvars, ist.lfun) in
let c = match ce with
| None -> c
(* If at toplevel (ce<>None), the error can be due to an incorrect
context at globalization time: we retype with the now known
intros/lettac/inversion hypothesis names *)
| Some c ->
let ltacvars = Id.Map.domain constrvars in
let bndvars = Id.Map.domain ist.lfun in
let ltacdata = (ltacvars, bndvars) in
intern_gen kind ~allow_patvar ~ltacvars:ltacdata env c
in
let trace =
push_trace (loc_of_glob_constr c,LtacConstrInterp (c,vars)) ist in
let (evd,c) =
catch_error trace (understand_ltac flags sigma env vars kind) c
in
(* spiwack: to avoid unnecessary modifications of tacinterp, as this
function already use effect, I call [run] hoping it doesn't mess
up with any assumption. *)
Proofview.NonLogical.run (db_constr (curr_debug ist) env c);
(evd,c)
let constr_flags = {
use_typeclasses = true;
use_unif_heuristics = true;
use_hook = Some solve_by_implicit_tactic;
fail_evar = true;
expand_evars = true }
(* Interprets a constr; expects evars to be solved *)
let interp_constr_gen kind ist env sigma c =
interp_gen kind ist false constr_flags env sigma c
let interp_constr = interp_constr_gen WithoutTypeConstraint
let interp_type = interp_constr_gen IsType
let open_constr_use_classes_flags = {
use_typeclasses = true;
use_unif_heuristics = true;
use_hook = Some solve_by_implicit_tactic;
fail_evar = false;
expand_evars = true }
let open_constr_no_classes_flags = {
use_typeclasses = false;
use_unif_heuristics = true;
use_hook = Some solve_by_implicit_tactic;
fail_evar = false;
expand_evars = true }
let pure_open_constr_flags = {
use_typeclasses = false;
use_unif_heuristics = true;
use_hook = None;
fail_evar = false;
expand_evars = false }
(* Interprets an open constr *)
let interp_open_constr ?(expected_type=WithoutTypeConstraint) ist =
let flags =
if expected_type == WithoutTypeConstraint then open_constr_no_classes_flags
else open_constr_use_classes_flags in
interp_gen expected_type ist false flags
let interp_pure_open_constr ist =
interp_gen WithoutTypeConstraint ist false pure_open_constr_flags
let interp_typed_pattern ist env sigma (c,_) =
let sigma, c =
interp_gen WithoutTypeConstraint ist true pure_open_constr_flags env sigma c in
pattern_of_constr sigma c
(* Interprets a constr expression casted by the current goal *)
let pf_interp_casted_constr ist gl c =
interp_constr_gen (OfType (pf_concl gl)) ist (pf_env gl) (project gl) c
(* Interprets a constr expression *)
let pf_interp_constr ist gl =
interp_constr ist (pf_env gl) (project gl)
let interp_constr_in_compound_list inj_fun dest_fun interp_fun ist env sigma l =
let try_expand_ltac_var sigma x =
try match dest_fun x with
| GVar (_,id), _ ->
let v = Id.Map.find id ist.lfun in
sigma, List.map inj_fun (coerce_to_constr_list env v)
| _ ->
raise Not_found
with CannotCoerceTo _ | Not_found ->
(* dest_fun, List.assoc may raise Not_found *)
let sigma, c = interp_fun ist env sigma x in
sigma, [c] in
let sigma, l = List.fold_map try_expand_ltac_var sigma l in
sigma, List.flatten l
let interp_constr_list ist env sigma c =
interp_constr_in_compound_list (fun x -> x) (fun x -> x) interp_constr ist env sigma c
let interp_open_constr_list =
interp_constr_in_compound_list (fun x -> x) (fun x -> x) interp_open_constr
let interp_auto_lemmas ist env sigma lems =
let local_sigma, lems = interp_open_constr_list ist env sigma lems in
List.map (fun lem -> (local_sigma,lem)) lems
(* Interprets a type expression *)
let pf_interp_type ist gl =
interp_type ist (pf_env gl) (project gl)
let new_interp_type ist c =
let open Proofview.Goal in
let open Proofview.Notations in
let interp gl =
try
let (sigma, c) = interp_type ist (env gl) (sigma gl) c in
Proofview.V82.tclEVARS sigma <*> Proofview.tclUNIT c
with e when Proofview.V82.catchable_exception e ->
Proofview.tclZERO e
in
interp
(* Interprets a reduction expression *)
let interp_unfold ist env (occs,qid) =
(interp_occurrences ist occs,interp_evaluable ist env qid)
let interp_flag ist env red =
{ red with rConst = List.map (interp_evaluable ist env) red.rConst }
let interp_constr_with_occurrences ist sigma env (occs,c) =
let (sigma,c_interp) = interp_constr ist sigma env c in
sigma , (interp_occurrences ist occs, c_interp)
let interp_typed_pattern_with_occurrences ist env sigma (occs,c) =
let sign,p = interp_typed_pattern ist env sigma c in
sign, (interp_occurrences ist occs, p)
let interp_closed_typed_pattern_with_occurrences ist env sigma occl =
snd (interp_typed_pattern_with_occurrences ist env sigma occl)
let interp_constr_with_occurrences_and_name_as_list =
interp_constr_in_compound_list
(fun c -> ((AllOccurrences,c),Anonymous))
(function ((occs,c),Anonymous) when occs == AllOccurrences -> c
| _ -> raise Not_found)
(fun ist env sigma (occ_c,na) ->
let (sigma,c_interp) = interp_constr_with_occurrences ist env sigma occ_c in
sigma, (c_interp,
interp_fresh_name ist env na))
let interp_red_expr ist sigma env = function
| Unfold l -> sigma , Unfold (List.map (interp_unfold ist env) l)
| Fold l ->
let (sigma,l_interp) = interp_constr_list ist env sigma l in
sigma , Fold l_interp
| Cbv f -> sigma , Cbv (interp_flag ist env f)
| Cbn f -> sigma , Cbn (interp_flag ist env f)
| Lazy f -> sigma , Lazy (interp_flag ist env f)
| Pattern l ->
let (sigma,l_interp) =
Evd.MonadR.List.map_right
(fun c sigma -> interp_constr_with_occurrences ist env sigma c) l sigma
in
sigma , Pattern l_interp
| Simpl o ->
sigma , Simpl (Option.map (interp_closed_typed_pattern_with_occurrences ist env sigma) o)
| CbvVm o ->
sigma , CbvVm (Option.map (interp_closed_typed_pattern_with_occurrences ist env sigma) o)
| CbvNative o ->
sigma , CbvNative (Option.map (interp_closed_typed_pattern_with_occurrences ist env sigma) o)
| (Red _ | Hnf | ExtraRedExpr _ as r) -> sigma , r
let interp_may_eval f ist env sigma = function
| ConstrEval (r,c) ->
let (sigma,redexp) = interp_red_expr ist sigma env r in
let (sigma,c_interp) = f ist env sigma c in
sigma , (fst (Redexpr.reduction_of_red_expr env redexp) env sigma c_interp)
| ConstrContext ((loc,s),c) ->
(try
let (sigma,ic) = f ist env sigma c
and ctxt = coerce_to_constr_context (Id.Map.find s ist.lfun) in
sigma , subst_meta [ConstrMatching.special_meta,ic] ctxt
with
| Not_found ->
user_err_loc (loc, "interp_may_eval",
str "Unbound context identifier" ++ pr_id s ++ str"."))
| ConstrTypeOf c ->
let (sigma,c_interp) = f ist env sigma c in
sigma , Typing.type_of env sigma c_interp
| ConstrTerm c ->
try
f ist env sigma c
with reraise ->
let reraise = Errors.push reraise in
(* spiwack: to avoid unnecessary modifications of tacinterp, as this
function already use effect, I call [run] hoping it doesn't mess
up with any assumption. *)
Proofview.NonLogical.run (debugging_exception_step ist false reraise (fun () ->
str"interpretation of term " ++ pr_glob_constr_env env (fst c)));
raise reraise
(* Interprets a constr expression possibly to first evaluate *)
let interp_constr_may_eval ist env sigma c =
let (sigma,csr) =
try
interp_may_eval interp_constr ist env sigma c
with reraise ->
let reraise = Errors.push reraise in
(* spiwack: to avoid unnecessary modifications of tacinterp, as this
function already use effect, I call [run] hoping it doesn't mess
up with any assumption. *)
Proofview.NonLogical.run (debugging_exception_step ist false reraise (fun () -> str"evaluation of term"));
raise reraise
in
begin
(* spiwack: to avoid unnecessary modifications of tacinterp, as this
function already use effect, I call [run] hoping it doesn't mess
up with any assumption. *)
Proofview.NonLogical.run (db_constr (curr_debug ist) env csr);
sigma , csr
end
(** TODO: should use dedicated printers *)
let rec message_of_value gl v =
let v = Value.normalize v in
if has_type v (topwit wit_tacvalue) then str "<tactic>"
else if has_type v (topwit wit_constr) then
pr_constr_env (pf_env gl) (out_gen (topwit wit_constr) v)
else if has_type v (topwit wit_constr_under_binders) then
let c = out_gen (topwit wit_constr_under_binders) v in
pr_constr_under_binders_env (pf_env gl) c
else if has_type v (topwit wit_unit) then str "()"
else if has_type v (topwit wit_int) then int (out_gen (topwit wit_int) v)
else if has_type v (topwit wit_intro_pattern) then
Miscprint.pr_intro_pattern (out_gen (topwit wit_intro_pattern) v)
else if has_type v (topwit wit_constr_context) then
pr_constr_env (pf_env gl) (out_gen (topwit wit_constr_context) v)
else match Value.to_list v with
| Some l ->
let print v = message_of_value gl v in
prlist_with_sep spc print l
| None ->
str "<abstr>" (** TODO *)
let interp_message_token ist gl = function
| MsgString s -> str s
| MsgInt n -> int n
| MsgIdent (loc,id) ->
let v =
try Id.Map.find id ist.lfun
with Not_found -> user_err_loc (loc,"",pr_id id ++ str" not found.") in
message_of_value gl v
let interp_message_nl ist gl = function
| [] -> mt()
| l -> prlist_with_sep spc (interp_message_token ist gl) l ++ fnl()
let interp_message ist gl l =
(* Force evaluation of interp_message_token so that potential errors
are raised now and not at printing time *)
prlist (fun x -> spc () ++ x) (List.map (interp_message_token ist gl) l)
let rec interp_intro_pattern ist env = function
| loc, IntroOrAndPattern l ->
loc, IntroOrAndPattern (interp_or_and_intro_pattern ist env l)
| loc, IntroInjection l ->
loc, IntroInjection (interp_intro_pattern_list_as_list ist env l)
| loc, IntroIdentifier id ->
loc, interp_intro_pattern_var loc ist env id
| loc, IntroFresh id ->
loc, IntroFresh (interp_fresh_ident ist env id)
| loc, (IntroWildcard | IntroAnonymous | IntroRewrite _ | IntroForthcoming _)
as x -> x
and interp_or_and_intro_pattern ist env =
List.map (interp_intro_pattern_list_as_list ist env)
and interp_intro_pattern_list_as_list ist env = function
| [loc,IntroIdentifier id] as l ->
(try coerce_to_intro_pattern_list loc env (Id.Map.find id ist.lfun)
with Not_found | CannotCoerceTo _ ->
List.map (interp_intro_pattern ist env) l)
| l -> List.map (interp_intro_pattern ist env) l
let interp_in_hyp_as ist env (id,ipat) =
(interp_hyp ist env id,Option.map (interp_intro_pattern ist env) ipat)
let interp_quantified_hypothesis ist = function
| AnonHyp n -> AnonHyp n
| NamedHyp id ->
try try_interp_ltac_var coerce_to_quantified_hypothesis ist None(dloc,id)
with Not_found -> NamedHyp id
let interp_binding_name ist = function
| AnonHyp n -> AnonHyp n
| NamedHyp id ->
(* If a name is bound, it has to be a quantified hypothesis *)
(* user has to use other names for variables if these ones clash with *)
(* a name intented to be used as a (non-variable) identifier *)
try try_interp_ltac_var coerce_to_quantified_hypothesis ist None(dloc,id)
with Not_found -> NamedHyp id
let interp_declared_or_quantified_hypothesis ist env = function
| AnonHyp n -> AnonHyp n
| NamedHyp id ->
try try_interp_ltac_var
(coerce_to_decl_or_quant_hyp env) ist (Some env) (dloc,id)
with Not_found -> NamedHyp id
let interp_binding ist env sigma (loc,b,c) =
let sigma, c = interp_open_constr ist env sigma c in
sigma, (loc,interp_binding_name ist b,c)
let interp_bindings ist env sigma = function
| NoBindings ->
sigma, NoBindings
| ImplicitBindings l ->
let sigma, l = interp_open_constr_list ist env sigma l in
sigma, ImplicitBindings l
| ExplicitBindings l ->
let sigma, l = List.fold_map (interp_binding ist env) sigma l in
sigma, ExplicitBindings l
let interp_constr_with_bindings ist env sigma (c,bl) =
let sigma, bl = interp_bindings ist env sigma bl in
let sigma, c = interp_open_constr ist env sigma c in
sigma, (c,bl)
let interp_open_constr_with_bindings ist env sigma (c,bl) =
let sigma, bl = interp_bindings ist env sigma bl in
let sigma, c = interp_open_constr ist env sigma c in
sigma, (c, bl)
let loc_of_bindings = function
| NoBindings -> Loc.ghost
| ImplicitBindings l -> loc_of_glob_constr (fst (List.last l))
| ExplicitBindings l -> pi1 (List.last l)
let interp_open_constr_with_bindings_loc ist env sigma ((c,_),bl as cb) =
let loc1 = loc_of_glob_constr c in
let loc2 = loc_of_bindings bl in
let loc = if Loc.is_ghost loc2 then loc1 else Loc.merge loc1 loc2 in
let sigma, cb = interp_open_constr_with_bindings ist env sigma cb in
sigma, (loc,cb)
let interp_induction_arg ist gl arg =
let env = pf_env gl and sigma = project gl in
match arg with
| ElimOnConstr c ->
ElimOnConstr (interp_constr_with_bindings ist env sigma c)
| ElimOnAnonHyp n as x -> x
| ElimOnIdent (loc,id) ->
let error () = user_err_loc (loc, "",
strbrk "Cannot coerce " ++ pr_id id ++
strbrk " neither to a quantified hypothesis nor to a term.")
in
let try_cast_id id' =
if Tactics.is_quantified_hypothesis id' gl
then ElimOnIdent (loc,id')
else
(try ElimOnConstr (sigma,(constr_of_id env id',NoBindings))
with Not_found ->
user_err_loc (loc,"",
pr_id id ++ strbrk " binds to " ++ pr_id id' ++ strbrk " which is neither a declared or a quantified hypothesis."))
in
try
(** FIXME: should be moved to taccoerce *)
let v = Id.Map.find id ist.lfun in
let v = Value.normalize v in
if has_type v (topwit wit_intro_pattern) then
let v = out_gen (topwit wit_intro_pattern) v in
match v with
| _, IntroIdentifier id -> try_cast_id id
| _ -> error ()
else if has_type v (topwit wit_var) then
let id = out_gen (topwit wit_var) v in
try_cast_id id
else if has_type v (topwit wit_int) then
ElimOnAnonHyp (out_gen (topwit wit_int) v)
else match Value.to_constr v with
| None -> error ()
| Some c -> ElimOnConstr (sigma,(c,NoBindings))
with Not_found ->
(* We were in non strict (interactive) mode *)
if Tactics.is_quantified_hypothesis id gl then
ElimOnIdent (loc,id)
else
let c = (GVar (loc,id),Some (CRef (Ident (loc,id)))) in
let (sigma,c) = interp_constr ist env sigma c in
ElimOnConstr (sigma,(c,NoBindings))
(* Associates variables with values and gives the remaining variables and
values *)
let head_with_value (lvar,lval) =
let rec head_with_value_rec lacc = function
| ([],[]) -> (lacc,[],[])
| (vr::tvr,ve::tve) ->
(match vr with
| None -> head_with_value_rec lacc (tvr,tve)
| Some v -> head_with_value_rec ((v,ve)::lacc) (tvr,tve))
| (vr,[]) -> (lacc,vr,[])
| ([],ve) -> (lacc,[],ve)
in
head_with_value_rec [] (lvar,lval)
(** [interp_context ctxt] interprets a context (as in
{!Matching.matching_result}) into a context value of Ltac. *)
let interp_context ctxt = in_gen (topwit wit_constr_context) ctxt
(* Reads a pattern by substituting vars of lfun *)
let use_types = false
let eval_pattern lfun ist env sigma (_,pat as c) =
if use_types then
snd (interp_typed_pattern ist env sigma c)
else
instantiate_pattern sigma lfun pat
let read_pattern lfun ist env sigma = function
| Subterm (b,ido,c) -> Subterm (b,ido,eval_pattern lfun ist env sigma c)
| Term c -> Term (eval_pattern lfun ist env sigma c)
(* Reads the hypotheses of a Match Context rule *)
let cons_and_check_name id l =
if Id.List.mem id l then
user_err_loc (dloc,"read_match_goal_hyps",
strbrk ("Hypothesis pattern-matching variable "^(Id.to_string id)^
" used twice in the same pattern."))
else id::l
let rec read_match_goal_hyps lfun ist env sigma lidh = function
| (Hyp ((loc,na) as locna,mp))::tl ->
let lidh' = name_fold cons_and_check_name na lidh in
Hyp (locna,read_pattern lfun ist env sigma mp)::
(read_match_goal_hyps lfun ist env sigma lidh' tl)
| (Def ((loc,na) as locna,mv,mp))::tl ->
let lidh' = name_fold cons_and_check_name na lidh in
Def (locna,read_pattern lfun ist env sigma mv, read_pattern lfun ist env sigma mp)::
(read_match_goal_hyps lfun ist env sigma lidh' tl)
| [] -> []
(* Reads the rules of a Match Context or a Match *)
let rec read_match_rule lfun ist env sigma = function
| (All tc)::tl -> (All tc)::(read_match_rule lfun ist env sigma tl)
| (Pat (rl,mp,tc))::tl ->
Pat (read_match_goal_hyps lfun ist env sigma [] rl, read_pattern lfun ist env sigma mp,tc)
:: read_match_rule lfun ist env sigma tl
| [] -> []
(* misc *)
let mk_constr_value ist gl c =
let (sigma,c_interp) = pf_interp_constr ist gl c in
sigma, Value.of_constr c_interp
let mk_open_constr_value ist gl c =
let (sigma,c_interp) = pf_apply (interp_open_constr ist) gl c in
sigma, Value.of_constr c_interp
let mk_hyp_value ist gl c = Value.of_constr (mkVar (interp_hyp ist gl c))
let mk_int_or_var_value ist c = in_gen (topwit wit_int) (interp_int_or_var ist c)
let pack_sigma (sigma,c) = {it=c;sigma=sigma;}
let extend_gl_hyps { it=gl ; sigma=sigma } sign =
Goal.V82.new_goal_with sigma gl sign
(* Local exception, should not escape. No need to register. *)
exception NeedsAGoal
(* Interprets an ltac expression into a value, does not assume a goal *)
let val_interp_glob ist (tac:glob_tactic_expr) : typed_generic_argument =
match tac with
| TacFun (it,body) ->
let v = VFun (extract_trace ist,ist.lfun,it,body) in
of_tacvalue v
| TacLetIn _
| TacMatchGoal _
| TacMatch _
| TacArg _ -> raise NeedsAGoal
| t ->
let v = VFun (extract_trace ist,ist.lfun,[],t) in
of_tacvalue v
module GenargTac = Genarg.Monadic(Proofview.Monad)
(* Interprets an l-tac expression into a value *)
let rec val_interp ist (tac:glob_tactic_expr) (gl:'a Proofview.Goal.t) : typed_generic_argument Proofview.tactic =
let value_interp ist =
try Proofview.tclUNIT (val_interp_glob ist tac)
with NeedsAGoal ->
match tac with
(* Immediate evaluation *)
| TacLetIn (true,l,u) -> interp_letrec ist l u gl
| TacLetIn (false,l,u) -> interp_letin ist l u gl
| TacMatchGoal (lz,lr,lmr) -> interp_match_goal ist lz lr lmr gl
| TacMatch (lz,c,lmr) -> interp_match ist lz c lmr gl
| TacArg (loc,a) -> interp_tacarg ist a gl
(* Delayed evaluation, handled by val_interp_glob, above *)
| _ -> assert false
in check_for_interrupt ();
match curr_debug ist with
| DebugOn lev ->
let eval v =
let ist = { ist with extra = TacStore.set ist.extra f_debug v } in
value_interp ist
in
debug_prompt lev tac eval
| _ -> value_interp ist
and eval_tactic ist = function
| TacAtom (loc,t) ->
let call = LtacAtomCall t in
catch_error_tac (push_trace(loc,call) ist) (interp_atomic ist t)
| TacFun _ | TacLetIn _ -> assert false
| TacMatchGoal _ | TacMatch _ -> assert false
| TacId s ->
Proofview.tclTHEN
(Proofview.V82.tactic begin fun gl ->
tclIDTAC_MESSAGE (interp_message_nl ist gl s) gl
end)
(Proofview.tclLIFT (db_breakpoint (curr_debug ist) s))
| TacFail (n,s) ->
Proofview.V82.tactic begin fun gl ->
tclFAIL (interp_int_or_var ist n) (interp_message ist gl s) gl
end
| TacProgress tac -> Tacticals.New.tclPROGRESS (interp_tactic ist tac)
| TacShowHyps tac ->
Proofview.V82.tactic begin
tclSHOWHYPS (Proofview.V82.of_tactic (interp_tactic ist tac))
end
| TacAbstract (tac,ido) ->
Proofview.V82.tactic begin fun gl -> Tactics.tclABSTRACT
(Option.map (pf_interp_ident ist gl) ido) (interp_tactic ist tac) gl
end
| TacThen (t1,tf,t,tl) ->
if Array.length tf = 0 && Array.length tl = 0 then
Tacticals.New.tclTHEN (interp_tactic ist t1) (interp_tactic ist t)
else
Tacticals.New.tclTHENS3PARTS (interp_tactic ist t1)
(Array.map (interp_tactic ist) tf) (interp_tactic ist t) (Array.map (interp_tactic ist) tl)
| TacThens (t1,tl) -> Tacticals.New.tclTHENS (interp_tactic ist t1) (List.map (interp_tactic ist) tl)
| TacDo (n,tac) -> Tacticals.New.tclDO (interp_int_or_var ist n) (interp_tactic ist tac)
| TacTimeout (n,tac) -> Tacticals.New.tclTIMEOUT (interp_int_or_var ist n) (interp_tactic ist tac)
| TacTry tac -> Tacticals.New.tclTRY (interp_tactic ist tac)
| TacRepeat tac -> Tacticals.New.tclREPEAT (interp_tactic ist tac)
| TacOr (tac1,tac2) ->
Tacticals.New.tclOR (interp_tactic ist tac1) (interp_tactic ist tac2)
| TacOnce tac ->
Tacticals.New.tclONCE (interp_tactic ist tac)
| TacExactlyOnce tac ->
Tacticals.New.tclEXACTLY_ONCE (interp_tactic ist tac)
| TacOrelse (tac1,tac2) ->
Tacticals.New.tclORELSE (interp_tactic ist tac1) (interp_tactic ist tac2)
| TacFirst l -> Tacticals.New.tclFIRST (List.map (interp_tactic ist) l)
| TacSolve l -> Tacticals.New.tclSOLVE (List.map (interp_tactic ist) l)
| TacComplete tac -> Tacticals.New.tclCOMPLETE (interp_tactic ist tac)
| TacArg a -> interp_tactic ist (TacArg a)
| TacInfo tac ->
msg_warning
(strbrk "The general \"info\" tactic is currently not working." ++ fnl () ++
strbrk "Some specific verbose tactics may exist instead, such as info_trivial, info_auto, info_eauto.");
eval_tactic ist tac
and force_vrec ist v gl =
let v = Value.normalize v in
if has_type v (topwit wit_tacvalue) then
let v = to_tacvalue v in
match v with
| VRec (lfun,body) -> val_interp {ist with lfun = !lfun} body gl
| v -> Proofview.tclUNIT (of_tacvalue v)
else Proofview.tclUNIT v
and interp_ltac_reference loc' mustbetac ist r gl =
match r with
| ArgVar (loc,id) ->
let v =
try Id.Map.find id ist.lfun
with Not_found -> in_gen (topwit wit_var) id
in
force_vrec ist v gl >>= fun v ->
let v = propagate_trace ist loc id v in
if mustbetac then Proofview.tclUNIT (coerce_to_tactic loc id v) else Proofview.tclUNIT v
| ArgArg (loc,r) ->
let ids = extract_ids [] ist.lfun in
let loc_info = ((if Loc.is_ghost loc' then loc else loc'),LtacNameCall r) in
let extra = TacStore.set ist.extra f_avoid_ids ids in
let extra = TacStore.set extra f_trace (push_trace loc_info ist) in
let ist = { lfun = Id.Map.empty; extra = extra; } in
val_interp ist (Tacenv.interp_ltac r) gl
and interp_tacarg ist arg gl =
match arg with
| TacGeneric arg ->
Proofview.tclEVARMAP >>= fun sigma ->
Proofview.V82.wrap_exceptions begin fun () ->
let goal = Proofview.Goal.goal gl in
let (sigma,v) = Geninterp.generic_interp ist {Evd.it=goal;sigma} arg in
Proofview.V82.tclEVARS sigma <*>
Proofview.tclUNIT v
end
| Reference r -> interp_ltac_reference dloc false ist r gl
| ConstrMayEval c ->
Proofview.tclEVARMAP >>= fun sigma ->
Proofview.V82.wrap_exceptions begin fun () ->
let env = Proofview.Goal.env gl in
let (sigma,c_interp) = interp_constr_may_eval ist env sigma c in
Proofview.V82.tclEVARS sigma <*>
Proofview.tclUNIT (Value.of_constr c_interp)
end
| MetaIdArg (loc,_,id) -> assert false
| TacCall (loc,r,[]) ->
interp_ltac_reference loc true ist r gl
| TacCall (loc,f,l) ->
interp_ltac_reference loc true ist f gl >>= fun fv ->
Proofview.Monad.List.map (fun a -> interp_tacarg ist a gl) l >>= fun largs ->
interp_app loc ist fv largs gl
| TacExternal (loc,com,req,la) ->
Proofview.Monad.List.map (fun a -> interp_tacarg ist a gl) la >>= fun la_interp ->
Proofview.V82.wrap_exceptions begin fun () ->
interp_external loc ist gl com req la_interp
end
| TacFreshId l ->
Proofview.Goal.refresh_sigma gl >>= fun gl ->
(* spiwack: I'm probably being over-conservative here,
pf_interp_fresh_id shouldn't raise exceptions *)
Proofview.V82.wrap_exceptions begin fun () ->
let id = Tacmach.New.of_old (fun gl -> pf_interp_fresh_id ist gl l) gl in
Proofview.tclUNIT (in_gen (topwit wit_intro_pattern) (dloc, IntroIdentifier id))
end
| Tacexp t -> val_interp ist t gl
| TacDynamic(_,t) ->
let tg = (Dyn.tag t) in
if String.equal tg "tactic" then
val_interp ist (tactic_out t ist) gl
else if String.equal tg "value" then
Proofview.tclUNIT (value_out t)
else if String.equal tg "constr" then
Proofview.tclUNIT (Value.of_constr (constr_out t))
else
Errors.anomaly ~loc:dloc ~label:"Tacinterp.val_interp"
(str "Unknown dynamic: <" ++ str (Dyn.tag t) ++ str ">")
(* Interprets an application node *)
and interp_app loc ist fv largs gl =
let fail =
(* spiwack: quick hack, can be inlined. *)
try
user_err_loc (loc, "Tacinterp.interp_app",
(str"Illegal tactic application."))
with e -> Proofview.tclZERO e
in
let fv = Value.normalize fv in
if has_type fv (topwit wit_tacvalue) then
match to_tacvalue fv with
(* if var=[] and body has been delayed by val_interp, then body
is not a tactic that expects arguments.
Otherwise Ltac goes into an infinite loop (val_interp puts
a VFun back on body, and then interp_app is called again...) *)
| (VFun(trace,olfun,(_::_ as var),body)
|VFun(trace,olfun,([] as var),
(TacFun _|TacLetIn _|TacMatchGoal _|TacMatch _| TacArg _ as body))) ->
let (extfun,lvar,lval)=head_with_value (var,largs) in
let fold accu (id, v) = Id.Map.add id v accu in
let newlfun = List.fold_left fold olfun extfun in
if List.is_empty lvar then
begin Proofview.tclORELSE
begin
let ist = {
lfun = newlfun;
extra = TacStore.set ist.extra f_trace []; } in
catch_error_tac trace (val_interp ist body gl)
end
begin fun e ->
Proofview.tclLIFT (debugging_exception_step ist false e (fun () -> str "evaluation")) <*>
Proofview.tclZERO e
end
end >>= fun v ->
(* No errors happened, we propagate the trace *)
let v = append_trace trace v in
let env = Proofview.Goal.env gl in
Proofview.tclLIFT begin
debugging_step ist
(fun () ->
str"evaluation returns"++fnl()++pr_value (Some env) v)
end <*>
if List.is_empty lval then Proofview.tclUNIT v else interp_app loc ist v lval gl
else
Proofview.tclUNIT (of_tacvalue (VFun(trace,newlfun,lvar,body)))
| _ -> fail
else fail
(* Gives the tactic corresponding to the tactic value *)
and tactic_of_value ist vle =
let vle = Value.normalize vle in
if has_type vle (topwit wit_tacvalue) then
match to_tacvalue vle with
| VRTactic -> Proofview.tclUNIT ()
| VFun (trace,lfun,[],t) ->
let ist = {
lfun = lfun;
extra = TacStore.set ist.extra f_trace []; } in
let tac = eval_tactic ist t in
catch_error_tac trace tac
| (VFun _|VRec _) -> Proofview.tclZERO (UserError ("" , str "A fully applied tactic is expected."))
else if has_type vle (topwit wit_tactic) then
let tac = out_gen (topwit wit_tactic) vle in
eval_tactic ist tac
else Proofview.tclZERO (UserError ("" , str"Expression does not evaluate to a tactic."))
and eval_value ist tac gl =
val_interp ist tac gl >>= fun v ->
if has_type v (topwit wit_tacvalue) then match to_tacvalue v with
| VFun (trace,lfun,[],t) ->
let ist = {
lfun = lfun;
extra = TacStore.set ist.extra f_trace trace; } in
let tac = eval_tactic ist t in
catch_error_tac trace (tac <*> Proofview.tclUNIT (of_tacvalue VRTactic))
| _ -> Proofview.tclUNIT v
else Proofview.tclUNIT v
(* Interprets the clauses of a recursive LetIn *)
and interp_letrec ist llc u gl =
Proofview.tclUNIT () >>= fun () -> (* delay for the effects of [lref], just in case. *)
let lref = ref ist.lfun in
let fold accu ((_, id), b) =
let v = of_tacvalue (VRec (lref, TacArg (dloc, b))) in
Id.Map.add id v accu
in
let lfun = List.fold_left fold ist.lfun llc in
let () = lref := lfun in
let ist = { ist with lfun } in
val_interp ist u gl
(* Interprets the clauses of a LetIn *)
and interp_letin ist llc u gl =
let fold acc ((_, id), body) =
interp_tacarg ist body gl >>= fun v ->
Proofview.tclUNIT (Id.Map.add id v acc)
in
Proofview.Monad.List.fold_left fold ist.lfun llc >>= fun lfun ->
let ist = { ist with lfun } in
val_interp ist u gl
(** [interp_match_success lz ist succ] interprets a single matching success
(of type {!TacticMatching.t}). *)
and interp_match_success ist { TacticMatching.subst ; context ; terms ; lhs } gl =
let lctxt = Id.Map.map interp_context context in
let hyp_subst = Id.Map.map Value.of_constr terms in
let lfun = extend_values_with_bindings subst (lctxt +++ hyp_subst +++ ist.lfun) in
eval_value {ist with lfun=lfun} lhs gl
(** [interp_match_successes lz ist s] interprets the stream of
matching of successes [s]. If [lz] is set to true, then only the
first success is considered, otherwise further successes are tried
if the left-hand side fails. *)
and interp_match_successes lz ist s gl =
(** iterates [tclOR] lazily on the stream [t], if [t] is
exhausted, raises [e]. Beware: there is no [tclINDEPENDENT],
relying on the fact that it will always be applied to a single
goal, by virtue of an earlier [Proofview.Goal.enter]. *)
let rec tclOR_stream t e =
let open IStream in
match peek t with
| Cons (t1,t') ->
Proofview.tclORELSE
t1
begin fun e ->
(* Honors Ltac's failure level. *)
Tacticals.New.catch_failerror e <*> tclOR_stream t' e
end
| Nil ->
Proofview.tclZERO e
in
let matching_failure =
UserError ("Tacinterp.apply_match" , str "No matching clauses for match.")
in
let successes =
IStream.map (fun s -> interp_match_success ist s gl) s
in
if lz then
(** lazymatch *)
let open IStream in
begin match peek successes with
| Cons (s,_) -> s
| Nil -> Proofview.tclZERO matching_failure
end
else
(** match *)
Proofview.tclONCE (tclOR_stream successes matching_failure)
(* Interprets the Match expressions *)
and interp_match ist lz constr lmr gl =
begin Proofview.tclORELSE
(interp_ltac_constr ist constr gl)
begin function
| e ->
(* spiwack: [Errors.push] here is unlikely to do what
it's intended to, or anything meaningful for that
matter. *)
let e = Errors.push e in
Proofview.tclLIFT (debugging_exception_step ist true e
(fun () -> str "evaluation of the matched expression")) <*>
Proofview.tclZERO e
end
end >>= fun constr ->
Proofview.tclEVARMAP >>= fun sigma ->
Proofview.V82.wrap_exceptions begin fun () ->
let env = Proofview.Goal.env gl in
let ilr = read_match_rule (extract_ltac_constr_values ist env) ist env sigma lmr in
interp_match_successes lz ist (TacticMatching.match_term env sigma constr ilr) gl
end
(* Interprets the Match Context expressions *)
and interp_match_goal ist lz lr lmr gl =
Proofview.tclEVARMAP >>= fun sigma ->
Proofview.V82.wrap_exceptions begin fun () ->
let env = Proofview.Goal.env gl in
let hyps = Proofview.Goal.hyps gl in
let hyps = if lr then List.rev hyps else hyps in
let concl = Proofview.Goal.concl gl in
let ilr = read_match_rule (extract_ltac_constr_values ist env) ist env sigma lmr in
interp_match_successes lz ist (TacticMatching.match_goal env sigma hyps concl ilr) gl
end
and interp_external loc ist gl com req la =
Proofview.Goal.refresh_sigma gl >>= fun gl ->
let f ch = Tacmach.New.of_old (fun gl -> extern_request ch req gl la) gl in
let g ch = internalise_tacarg ch in
interp_tacarg ist (System.connect f g com) gl
(* Interprets extended tactic generic arguments *)
(* spiwack: interp_genarg has an argument [concl] for the case of
"casted open constr". And [gl] for [Geninterp]. I haven't changed
the interface for geninterp yet as it is used by ARGUMENT EXTEND
(in turn used by plugins). At the time I'm writing this comment
though, the only concerned plugins are the declarative mode (which
needs the [extra] field of goals to interprete rules) and ssreflect
(a handful of time). I believe we'd need to address "casted open
constr" and the declarative mode rules to provide a reasonable
interface. *)
and interp_genarg ist env sigma concl gl x =
let evdref = ref sigma in
let rec interp_genarg x =
match genarg_tag x with
| IntOrVarArgType ->
in_gen (topwit wit_int_or_var)
(ArgArg (interp_int_or_var ist (out_gen (glbwit wit_int_or_var) x)))
| IdentArgType ->
in_gen (topwit wit_ident)
(interp_fresh_ident ist env (out_gen (glbwit wit_ident) x))
| VarArgType ->
in_gen (topwit wit_var) (interp_hyp ist env (out_gen (glbwit wit_var) x))
| GenArgType ->
in_gen (topwit wit_genarg) (interp_genarg (out_gen (glbwit wit_genarg) x))
| ConstrArgType ->
let (sigma,c_interp) =
interp_constr ist env !evdref (out_gen (glbwit wit_constr) x)
in
evdref := sigma;
in_gen (topwit wit_constr) c_interp
| ConstrMayEvalArgType ->
let (sigma,c_interp) = interp_constr_may_eval ist env !evdref (out_gen (glbwit wit_constr_may_eval) x) in
evdref := sigma;
in_gen (topwit wit_constr_may_eval) c_interp
| QuantHypArgType ->
in_gen (topwit wit_quant_hyp)
(interp_declared_or_quantified_hypothesis ist env
(out_gen (glbwit wit_quant_hyp) x))
| RedExprArgType ->
let (sigma,r_interp) =
interp_red_expr ist !evdref env (out_gen (glbwit wit_red_expr) x)
in
evdref := sigma;
in_gen (topwit wit_red_expr) r_interp
| OpenConstrArgType ->
let expected_type = WithoutTypeConstraint in
in_gen (topwit wit_open_constr)
(interp_open_constr ~expected_type
ist env !evdref
(snd (out_gen (glbwit wit_open_constr) x)))
| ConstrWithBindingsArgType ->
in_gen (topwit wit_constr_with_bindings)
(pack_sigma (interp_constr_with_bindings ist env !evdref
(out_gen (glbwit wit_constr_with_bindings) x)))
| BindingsArgType ->
in_gen (topwit wit_bindings)
(pack_sigma (interp_bindings ist env !evdref (out_gen (glbwit wit_bindings) x)))
| ListArgType ConstrArgType ->
let (sigma,v) = interp_genarg_constr_list ist env !evdref x in
evdref := sigma;
v
| ListArgType VarArgType -> interp_genarg_var_list ist env x
| ListArgType _ -> app_list interp_genarg x
| OptArgType _ -> app_opt interp_genarg x
| PairArgType _ -> app_pair interp_genarg interp_genarg x
| ExtraArgType s ->
let (sigma,v) = Geninterp.generic_interp ist { Evd.it=gl;sigma=(!evdref) } x in
evdref:=sigma;
v
in
let v = interp_genarg x in
!evdref , v
and interp_genarg_constr_list ist env sigma x =
let lc = out_gen (glbwit (wit_list wit_constr)) x in
let (sigma,lc) = interp_constr_list ist env sigma lc in
sigma , in_gen (topwit (wit_list wit_constr)) lc
and interp_genarg_var_list ist env x =
let lc = out_gen (glbwit (wit_list wit_var)) x in
let lc = interp_hyp_list ist env lc in
in_gen (topwit (wit_list wit_var)) lc
(* Interprets tactic expressions : returns a "constr" *)
and interp_ltac_constr ist e gl =
begin Proofview.tclORELSE
(val_interp ist e gl)
begin function
| Not_found ->
begin
let env = Proofview.Goal.env gl in
Proofview.tclLIFT begin
debugging_step ist (fun () ->
str "evaluation failed for" ++ fnl() ++
Pptactic.pr_glob_tactic env e)
end
end <*>
Proofview.tclZERO Not_found
| e -> Proofview.tclZERO e
end
end >>= fun result ->
Proofview.V82.wrap_exceptions begin fun () ->
let env = Proofview.Goal.env gl in
let result = Value.normalize result in
try
let cresult = coerce_to_closed_constr env result in
Proofview.tclLIFT begin
debugging_step ist (fun () ->
Pptactic.pr_glob_tactic env e ++ fnl() ++
str " has value " ++ fnl() ++
pr_constr_env env cresult)
end <*>
Proofview.tclUNIT cresult
with CannotCoerceTo _ ->
let env = Proofview.Goal.env gl in
Proofview.tclZERO (UserError ( "",
errorlabstrm ""
(str "Must evaluate to a closed term" ++ fnl() ++
str "offending expression: " ++ fnl() ++ pr_inspect env e result)))
end
(* Interprets tactic expressions : returns a "tactic" *)
and interp_tactic ist tac =
(* spiwack: interpretes the following tactic out of a goal if
possible. It allows tactics on the right of a tclTHEN to manipulate
the generated subgoals globally. *)
try
tactic_of_value ist (val_interp_glob ist tac)
with NeedsAGoal ->
Proofview.Goal.enter begin fun gl ->
val_interp ist tac gl >>= fun v ->
tactic_of_value ist v
end
(* Interprets a primitive tactic *)
and interp_atomic ist tac =
match tac with
(* Basic tactics *)
| TacIntroPattern l ->
Proofview.Goal.raw_enter begin fun gl ->
let env = Proofview.Goal.env gl in
let patterns = interp_intro_pattern_list_as_list ist env l in
Tactics.intro_patterns patterns
end
| TacIntrosUntil hyp ->
begin try (* interp_quantified_hypothesis can raise an exception *)
Tactics.intros_until (interp_quantified_hypothesis ist hyp)
with e when Proofview.V82.catchable_exception e -> Proofview.tclZERO e
end
| TacIntroMove (ido,hto) ->
Proofview.Goal.raw_enter begin fun gl ->
let env = Proofview.Goal.env gl in
let mloc = interp_move_location ist env hto in
Tactics.intro_move (Option.map (interp_fresh_ident ist env) ido) mloc
end
| TacAssumption -> Tactics.assumption
| TacExact c ->
Proofview.V82.tactic begin fun gl ->
let (sigma,c_interp) = pf_interp_casted_constr ist gl c in
tclTHEN
(tclEVARS sigma)
(Tactics.exact_no_check c_interp)
gl
end
| TacExactNoCheck c ->
Proofview.V82.tactic begin fun gl ->
let (sigma,c_interp) = pf_interp_constr ist gl c in
tclTHEN
(tclEVARS sigma)
(Tactics.exact_no_check c_interp)
gl
end
| TacVmCastNoCheck c ->
Proofview.V82.tactic begin fun gl ->
let (sigma,c_interp) = pf_interp_constr ist gl c in
tclTHEN
(tclEVARS sigma)
(Tactics.vm_cast_no_check c_interp)
gl
end
| TacApply (a,ev,cb,cl) ->
Proofview.Goal.raw_enter begin fun gl ->
let env = Proofview.Goal.env gl in
let sigma = Proofview.Goal.sigma gl in
try (* interp_open_constr_with_bindings_loc can raise exceptions *)
let sigma, l =
List.fold_map (interp_open_constr_with_bindings_loc ist env) sigma cb
in
let tac = match cl with
| None -> fun l -> Proofview.V82.tactic (Tactics.apply_with_bindings_gen a ev l)
| Some cl ->
(fun l ->
Proofview.Goal.raw_enter begin fun gl ->
let env = Proofview.Goal.env gl in
let (id,cl) = interp_in_hyp_as ist env cl in
Tactics.apply_in a ev id l cl
end) in
Tacticals.New.tclWITHHOLES ev tac sigma l
with e when Proofview.V82.catchable_exception e -> Proofview.tclZERO e
end
| TacElim (ev,cb,cbo) ->
Proofview.Goal.raw_enter begin fun gl ->
let env = Proofview.Goal.env gl in
let sigma = Proofview.Goal.sigma gl in
try (* interpretation functions may raise exceptions *)
let sigma, cb = interp_constr_with_bindings ist env sigma cb in
let sigma, cbo = Option.fold_map (interp_constr_with_bindings ist env) sigma cbo in
Tacticals.New.tclWITHHOLES ev (Tactics.elim ev cb) sigma cbo
with e when Proofview.V82.catchable_exception e -> Proofview.tclZERO e
end
| TacElimType c ->
Proofview.V82.tactic begin fun gl ->
let (sigma,c_interp) = pf_interp_type ist gl c in
tclTHEN
(tclEVARS sigma)
(Tactics.elim_type c_interp)
gl
end
| TacCase (ev,cb) ->
Proofview.Goal.raw_enter begin fun gl ->
let sigma = Proofview.Goal.sigma gl in
let env = Proofview.Goal.env gl in
let sigma, cb = interp_constr_with_bindings ist env sigma cb in
Tacticals.New.tclWITHHOLES ev (Tactics.general_case_analysis ev) sigma cb
end
| TacCaseType c ->
Proofview.V82.tactic begin fun gl ->
let (sigma,c_interp) = pf_interp_type ist gl c in
tclTHEN
(tclEVARS sigma)
(Tactics.case_type c_interp)
gl
end
| TacFix (idopt,n) ->
Proofview.Goal.raw_enter begin fun gl ->
let env = Proofview.Goal.env gl in
Proofview.V82.tactic (Tactics.fix (Option.map (interp_fresh_ident ist env) idopt) n)
end
| TacMutualFix (id,n,l) ->
Proofview.V82.tactic begin fun gl ->
let env = pf_env gl in
let f sigma (id,n,c) =
let (sigma,c_interp) = pf_interp_type ist { gl with sigma=sigma } c in
sigma , (interp_fresh_ident ist env id,n,c_interp) in
let (sigma,l_interp) =
Evd.MonadR.List.map_right (fun c sigma -> f sigma c) l (project gl)
in
tclTHEN
(tclEVARS sigma)
(Tactics.mutual_fix (interp_fresh_ident ist env id) n l_interp 0)
gl
end
| TacCofix idopt ->
Proofview.Goal.raw_enter begin fun gl ->
let env = Proofview.Goal.env gl in
Proofview.V82.tactic (Tactics.cofix (Option.map (interp_fresh_ident ist env) idopt))
end
| TacMutualCofix (id,l) ->
Proofview.V82.tactic begin fun gl ->
let env = pf_env gl in
let f sigma (id,c) =
let (sigma,c_interp) = pf_interp_type ist { gl with sigma=sigma } c in
sigma , (interp_fresh_ident ist env id,c_interp) in
let (sigma,l_interp) =
Evd.MonadR.List.map_right (fun c sigma -> f sigma c) l (project gl)
in
tclTHEN
(tclEVARS sigma)
(Tactics.mutual_cofix (interp_fresh_ident ist env id) l_interp 0)
gl
end
| TacCut c ->
let open Proofview.Notations in
Proofview.Goal.raw_enter begin fun gl ->
new_interp_type ist c gl >>= Tactics.cut
end
| TacAssert (t,ipat,c) ->
Proofview.Goal.raw_enter begin fun gl ->
let env = Proofview.Goal.env gl in
let sigma = Proofview.Goal.sigma gl in
try (* intrerpreation function may raise exceptions *)
let (sigma,c) =
(if Option.is_empty t then interp_constr else interp_type) ist env sigma c
in
let patt = interp_intro_pattern ist env in
Tacticals.New.tclTHEN
(Proofview.V82.tclEVARS sigma)
(Tactics.forward (Option.map (interp_tactic ist) t)
(Option.map patt ipat) c)
with e when Proofview.V82.catchable_exception e -> Proofview.tclZERO e
end
| TacGeneralize cl ->
Proofview.V82.tactic begin fun gl ->
let sigma = project gl in
let env = pf_env gl in
let sigma, cl = interp_constr_with_occurrences_and_name_as_list ist env sigma cl in
tclWITHHOLES false (Tactics.Simple.generalize_gen) sigma cl gl
end
| TacGeneralizeDep c ->
Proofview.V82.tactic begin fun gl ->
let (sigma,c_interp) = pf_interp_constr ist gl c in
tclTHEN
(tclEVARS sigma)
(Tactics.generalize_dep c_interp)
gl
end
| TacLetTac (na,c,clp,b,eqpat) ->
Proofview.V82.nf_evar_goals <*>
Proofview.Goal.enter begin fun gl ->
let env = Proofview.Goal.env gl in
let sigma = Proofview.Goal.sigma gl in
let clp = interp_clause ist env clp in
let eqpat = Option.map (interp_intro_pattern ist env) eqpat in
if Locusops.is_nowhere clp then
(* We try to fully-typecheck the term *)
let (sigma,c_interp) =
Tacmach.New.of_old (fun gl -> pf_interp_constr ist gl c) gl
in
let let_tac b na c cl eqpat =
let id = Option.default (Loc.ghost,IntroAnonymous) eqpat in
let with_eq = if b then None else Some (true,id) in
Tactics.letin_tac with_eq na c None cl
in
Tacticals.New.tclTHEN
(Proofview.V82.tclEVARS sigma)
(let_tac b (interp_fresh_name ist env na) c_interp clp eqpat)
else
(* We try to keep the pattern structure as much as possible *)
begin try
let let_pat_tac b na c cl eqpat =
let id = Option.default (Loc.ghost,IntroAnonymous) eqpat in
let with_eq = if b then None else Some (true,id) in
Tactics.letin_pat_tac with_eq na c None cl
in
let_pat_tac b (interp_fresh_name ist env na)
(interp_pure_open_constr ist env sigma c) clp eqpat
with e when Proofview.V82.catchable_exception e -> Proofview.tclZERO e
end
end
(* Automation tactics *)
| TacTrivial (debug,lems,l) ->
Proofview.Goal.raw_enter begin fun gl ->
let env = Proofview.Goal.env gl in
let sigma = Proofview.Goal.sigma gl in
Auto.h_trivial ~debug
(interp_auto_lemmas ist env sigma lems)
(Option.map (List.map (interp_hint_base ist)) l)
end
| TacAuto (debug,n,lems,l) ->
Proofview.Goal.raw_enter begin fun gl ->
let env = Proofview.Goal.env gl in
let sigma = Proofview.Goal.sigma gl in
Auto.h_auto ~debug (Option.map (interp_int_or_var ist) n)
(interp_auto_lemmas ist env sigma lems)
(Option.map (List.map (interp_hint_base ist)) l)
end
(* Derived basic tactics *)
| TacSimpleInductionDestruct (isrec,h) ->
let h = interp_quantified_hypothesis ist h in
if isrec then Tactics.simple_induct h else Tactics.simple_destruct h
| TacInductionDestruct (isrec,ev,(l,el,cls)) ->
(* spiwack: some unknown part of destruct needs the goal to be
prenormalised. *)
Proofview.V82.nf_evar_goals <*>
Proofview.Goal.enter begin fun gl ->
let env = Proofview.Goal.env gl in
let l =
List.map begin fun (c,(ipato,ipats)) ->
let c = Tacmach.New.of_old (fun gl -> interp_induction_arg ist gl c) gl in
let interp_intro_pattern = interp_intro_pattern ist env in
c,
(Option.map interp_intro_pattern ipato,
Option.map interp_intro_pattern ipats)
end l
in
let sigma = Proofview.Goal.sigma gl in
let sigma,el =
Option.fold_map (interp_constr_with_bindings ist env) sigma el in
let interp_clause = interp_clause ist env in
let cls = Option.map interp_clause cls in
Tacticals.New.tclWITHHOLES ev (Tactics.induction_destruct isrec ev) sigma (l,el,cls)
end
| TacDoubleInduction (h1,h2) ->
let h1 = interp_quantified_hypothesis ist h1 in
let h2 = interp_quantified_hypothesis ist h2 in
Elim.h_double_induction h1 h2
| TacDecomposeAnd c ->
Proofview.Goal.enter begin fun gl ->
let (sigma,c_interp) = Tacmach.New.of_old (fun gl -> pf_interp_constr ist gl c) gl in
Tacticals.New.tclTHEN
(Proofview.V82.tclEVARS sigma)
(Elim.h_decompose_and c_interp)
end
| TacDecomposeOr c ->
Proofview.Goal.enter begin fun gl ->
let (sigma,c_interp) = Tacmach.New.of_old (fun gl -> pf_interp_constr ist gl c) gl in
Tacticals.New.tclTHEN
(Proofview.V82.tclEVARS sigma)
(Elim.h_decompose_or c_interp)
end
| TacDecompose (l,c) ->
Proofview.Goal.enter begin fun gl ->
let l = List.map (interp_inductive ist) l in
let (sigma,c_interp) = Tacmach.New.of_old (fun gl -> pf_interp_constr ist gl c) gl in
Tacticals.New.tclTHEN
(Proofview.V82.tclEVARS sigma)
(Elim.h_decompose l c_interp)
end
| TacSpecialize (n,cb) ->
Proofview.Goal.raw_enter begin fun gl ->
let env = Proofview.Goal.env gl in
let sigma = Proofview.Goal.sigma gl in
Proofview.V82.tactic begin fun gl ->
let sigma, cb = interp_constr_with_bindings ist env sigma cb in
tclWITHHOLES false (Tactics.specialize n) sigma cb gl
end
end
| TacLApply c ->
Proofview.V82.tactic begin fun gl ->
let (sigma,c_interp) = pf_interp_constr ist gl c in
tclTHEN
(tclEVARS sigma)
(Tactics.cut_and_apply c_interp)
gl
end
(* Context management *)
| TacClear (b,l) ->
Proofview.V82.tactic begin fun gl ->
let l = interp_hyp_list ist (pf_env gl) l in
if b then Tactics.keep l gl else Tactics.clear l gl
end
| TacClearBody l ->
Proofview.V82.tactic begin fun gl ->
Tactics.clear_body (interp_hyp_list ist (pf_env gl) l) gl
end
| TacMove (dep,id1,id2) ->
Proofview.V82.tactic begin fun gl ->
Tactics.move_hyp dep (interp_hyp ist (pf_env gl) id1)
(interp_move_location ist (pf_env gl) id2)
gl
end
| TacRename l ->
Proofview.V82.tactic begin fun gl ->
let env = pf_env gl in
Tactics.rename_hyp (List.map (fun (id1,id2) ->
interp_hyp ist env id1,
interp_fresh_ident ist env (snd id2)) l)
gl
end
| TacRevert l ->
Proofview.V82.tactic begin fun gl ->
Tactics.revert (interp_hyp_list ist (pf_env gl) l) gl
end
(* Constructors *)
| TacLeft (ev,bl) ->
Proofview.Goal.raw_enter begin fun gl ->
let env = Proofview.Goal.env gl in
let sigma = Proofview.Goal.sigma gl in
let sigma, bl = interp_bindings ist env sigma bl in
Tacticals.New.tclWITHHOLES ev (Tactics.left_with_bindings ev) sigma bl
end
| TacRight (ev,bl) ->
Proofview.Goal.raw_enter begin fun gl ->
let env = Proofview.Goal.env gl in
let sigma = Proofview.Goal.sigma gl in
let sigma, bl = interp_bindings ist env sigma bl in
Tacticals.New.tclWITHHOLES ev (Tactics.right_with_bindings ev) sigma bl
end
| TacSplit (ev,_,bll) ->
Proofview.Goal.raw_enter begin fun gl ->
let env = Proofview.Goal.env gl in
let sigma = Proofview.Goal.sigma gl in
let sigma, bll = List.fold_map (interp_bindings ist env) sigma bll in
Tacticals.New.tclWITHHOLES ev (Tactics.split_with_bindings ev) sigma bll
end
| TacAnyConstructor (ev,t) ->
Tactics.any_constructor ev (Option.map (interp_tactic ist) t)
| TacConstructor (ev,n,bl) ->
Proofview.Goal.raw_enter begin fun gl ->
let env = Proofview.Goal.env gl in
let sigma = Proofview.Goal.sigma gl in
let sigma, bl = interp_bindings ist env sigma bl in
Tacticals.New.tclWITHHOLES ev
(Tactics.constructor_tac ev None (interp_int_or_var ist n)) sigma bl
end
(* Conversion *)
| TacReduce (r,cl) ->
Proofview.V82.tactic begin fun gl ->
let (sigma,r_interp) = interp_red_expr ist (project gl) (pf_env gl) r in
tclTHEN
(tclEVARS sigma)
(Tactics.reduce r_interp (interp_clause ist (pf_env gl) cl))
gl
end
| TacChange (None,c,cl) ->
Proofview.V82.nf_evar_goals <*>
Proofview.V82.tactic begin fun gl ->
let is_onhyps = match cl.onhyps with
| None | Some [] -> true
| _ -> false
in
let is_onconcl = match cl.concl_occs with
| AllOccurrences | NoOccurrences -> true
| _ -> false
in
let (sigma,c_interp) =
if is_onhyps && is_onconcl
then pf_interp_type ist gl c
else pf_interp_constr ist gl c
in
tclTHEN
(tclEVARS sigma)
(Tactics.change None c_interp (interp_clause ist (pf_env gl) cl))
gl
end
| TacChange (Some op,c,cl) ->
Proofview.V82.nf_evar_goals <*>
Proofview.Goal.raw_enter begin fun gl ->
let env = Proofview.Goal.env gl in
let sigma = Proofview.Goal.sigma gl in
Proofview.V82.tactic begin fun gl ->
let sign,op = interp_typed_pattern ist env sigma op in
(* spiwack: (2012/04/18) the evar_map output by pf_interp_constr
is dropped as the evar_map taken as input (from
extend_gl_hyps) is incorrect. This means that evar
instantiated by pf_interp_constr may be lost, there. *)
let to_catch = function Not_found -> true | e -> Errors.is_anomaly e in
let (_,c_interp) =
try pf_interp_constr ist (extend_gl_hyps gl sign) c
with e when to_catch e (* Hack *) ->
errorlabstrm "" (strbrk "Failed to get enough information from the left-hand side to type the right-hand side.")
in
tclTHEN
(tclEVARS sigma)
(Tactics.change (Some op) c_interp (interp_clause ist env cl))
gl
end
end
(* Equivalence relations *)
| TacReflexivity -> Tactics.intros_reflexivity
| TacSymmetry c ->
Proofview.Goal.raw_enter begin fun gl ->
let env = Proofview.Goal.env gl in
let cl = interp_clause ist env c in
Tactics.intros_symmetry cl
end
| TacTransitivity c ->
begin match c with
| None -> Tactics.intros_transitivity None
| Some c ->
Proofview.Goal.enter begin fun gl ->
let (sigma,c_interp) =
Tacmach.New.of_old (fun gl -> pf_interp_constr ist gl c) gl
in
Tacticals.New.tclTHEN
(Proofview.V82.tclEVARS sigma)
(Tactics.intros_transitivity (Some c_interp))
end
end
(* Equality and inversion *)
| TacRewrite (ev,l,cl,by) ->
Proofview.Goal.raw_enter begin fun gl ->
let l = List.map (fun (b,m,c) ->
let f env sigma = interp_open_constr_with_bindings ist env sigma c in
(b,m,f)) l in
let env = Proofview.Goal.env gl in
let cl = interp_clause ist env cl in
Equality.general_multi_multi_rewrite ev l cl
(Option.map (fun by -> Tacticals.New.tclCOMPLETE (interp_tactic ist by),
Equality.Naive)
by)
end
| TacInversion (DepInversion (k,c,ids),hyp) ->
Proofview.Goal.enter begin fun gl ->
let env = Proofview.Goal.env gl in
let sigma = Proofview.Goal.sigma gl in
let (sigma,c_interp) =
match c with
| None -> sigma , None
| Some c ->
let (sigma,c_interp) =
Tacmach.New.of_old (fun gl -> pf_interp_constr ist gl c) gl
in
sigma , Some c_interp
in
let interp_intro_pattern = interp_intro_pattern ist env in
let dqhyps = interp_declared_or_quantified_hypothesis ist env hyp in
Inv.dinv k c_interp
(Option.map interp_intro_pattern ids)
dqhyps
end
| TacInversion (NonDepInversion (k,idl,ids),hyp) ->
Proofview.Goal.raw_enter begin fun gl ->
let env = Proofview.Goal.env gl in
let interp_intro_pattern = interp_intro_pattern ist env in
let hyps = interp_hyp_list ist env idl in
let dqhyps = interp_declared_or_quantified_hypothesis ist env hyp in
Inv.inv_clause k
(Option.map interp_intro_pattern ids)
hyps
dqhyps
end
| TacInversion (InversionUsing (c,idl),hyp) ->
Proofview.Goal.raw_enter begin fun gl ->
let env = Proofview.Goal.env gl in
let sigma = Proofview.Goal.sigma gl in
let (sigma,c_interp) = interp_constr ist env sigma c in
let dqhyps = interp_declared_or_quantified_hypothesis ist env hyp in
let hyps = interp_hyp_list ist env idl in
Proofview.V82.tclEVARS sigma <*>
Leminv.lemInv_clause dqhyps
c_interp
hyps
end
(* For extensions *)
| TacExtend (loc,opn,[]) ->
(* spiwack: a special case for tactics (from TACTIC EXTEND) without arguments to
be interpreted without a [Proofview.Goal.enter]. Eventually we should make
something more fine-grained by modifying [interp_genarg]. *)
let tac = Tacenv.interp_ml_tactic opn in
tac [] ist
| TacExtend (loc,opn,l) ->
Proofview.Goal.enter begin fun gl ->
let env = Proofview.Goal.env gl in
let goal_sigma = Proofview.Goal.sigma gl in
let concl = Proofview.Goal.concl gl in
let goal = Proofview.Goal.goal gl in
let tac = Tacenv.interp_ml_tactic opn in
let (sigma,args) =
Evd.MonadR.List.map_right
(fun a sigma -> interp_genarg ist env sigma concl goal a) l goal_sigma
in
Proofview.V82.tclEVARS sigma <*>
tac args ist
end
| TacAlias (loc,s,l) ->
let (_, body) = Tacenv.interp_alias s in
let rec f x gl = match genarg_tag x with
| QuantHypArgType | RedExprArgType
| ConstrWithBindingsArgType
| BindingsArgType
| OptArgType _ | PairArgType _ -> (** generic handler *)
Proofview.tclEVARMAP >>= fun sigma ->
Proofview.V82.wrap_exceptions begin fun () ->
let env = Proofview.Goal.env gl in
let concl = Proofview.Goal.concl gl in
let goal = Proofview.Goal.goal gl in
let (sigma, arg) = interp_genarg ist env sigma concl goal x in
Proofview.V82.tclEVARS sigma <*> Proofview.tclUNIT arg
end
| _ as tag -> (** Special treatment. TODO: use generic handler *)
Proofview.tclEVARMAP >>= fun sigma ->
Proofview.Goal.refresh_sigma gl >>= fun gl ->
Proofview.V82.wrap_exceptions begin fun () ->
let env = Proofview.Goal.env gl in
match tag with
| IntOrVarArgType ->
Proofview.tclUNIT (mk_int_or_var_value ist (out_gen (glbwit wit_int_or_var) x))
| IdentArgType ->
Proofview.tclUNIT (value_of_ident (interp_fresh_ident ist env
(out_gen (glbwit wit_ident) x)))
| VarArgType ->
Proofview.tclUNIT (mk_hyp_value ist env (out_gen (glbwit wit_var) x))
| GenArgType -> f (out_gen (glbwit wit_genarg) x) gl
| ConstrArgType ->
let (sigma,v) =
Tacmach.New.of_old (fun gl -> mk_constr_value ist gl (out_gen (glbwit wit_constr) x)) gl
in
Proofview.V82.tclEVARS sigma <*>
Proofview.tclUNIT v
| OpenConstrArgType ->
let (sigma,v) =
Tacmach.New.of_old (fun gl -> mk_open_constr_value ist gl (snd (out_gen (glbwit wit_open_constr) x))) gl in
Proofview.V82.tclEVARS sigma <*>
Proofview.tclUNIT v
| ConstrMayEvalArgType ->
let (sigma,c_interp) =
interp_constr_may_eval ist env sigma
(out_gen (glbwit wit_constr_may_eval) x)
in
Proofview.V82.tclEVARS sigma <*>
Proofview.tclUNIT (Value.of_constr c_interp)
| ListArgType ConstrArgType ->
let wit = glbwit (wit_list wit_constr) in
let (sigma,l_interp) = Tacmach.New.of_old begin fun gl ->
Evd.MonadR.List.map_right
(fun c sigma -> mk_constr_value ist { gl with sigma=sigma } c)
(out_gen wit x)
(project gl)
end gl in
Proofview.V82.tclEVARS sigma <*>
Proofview.tclUNIT (in_gen (topwit (wit_list wit_genarg)) l_interp)
| ListArgType VarArgType ->
let wit = glbwit (wit_list wit_var) in
Proofview.tclUNIT (
let ans = List.map (mk_hyp_value ist env) (out_gen wit x) in
in_gen (topwit (wit_list wit_genarg)) ans
)
| ListArgType IntOrVarArgType ->
let wit = glbwit (wit_list wit_int_or_var) in
let ans = List.map (mk_int_or_var_value ist) (out_gen wit x) in
Proofview.tclUNIT (in_gen (topwit (wit_list wit_genarg)) ans)
| ListArgType IdentArgType ->
let wit = glbwit (wit_list wit_ident) in
let mk_ident x = value_of_ident (interp_fresh_ident ist env x) in
let ans = List.map mk_ident (out_gen wit x) in
Proofview.tclUNIT (in_gen (topwit (wit_list wit_genarg)) ans)
| ListArgType t ->
GenargTac.app_list (fun y -> f y gl) x
| ExtraArgType _ ->
(** Special treatment of tactics *)
if has_type x (glbwit wit_tactic) then
let tac = out_gen (glbwit wit_tactic) x in
val_interp ist tac gl >>= fun v ->
Proofview.tclUNIT v
else
let goal = Proofview.Goal.goal gl in
let (newsigma,v) = Geninterp.generic_interp ist {Evd.it=goal;sigma} x in
Proofview.V82.tclEVARS newsigma <*>
Proofview.tclUNIT v
| _ -> assert false
end
in
Proofview.Goal.enter begin fun gl ->
let addvar (x, v) accu =
f v gl >>= fun v ->
Proofview.tclUNIT (Id.Map.add x v accu)
in
Proofview.Monad.List.fold_right addvar l ist.lfun >>= fun lfun ->
let trace = push_trace (loc,LtacNotationCall s) ist in
let ist = {
lfun = lfun;
extra = TacStore.set ist.extra f_trace trace; } in
interp_tactic ist body
end
(* Initial call for interpretation *)
let default_ist () =
let extra = TacStore.set TacStore.empty f_debug (get_debug ()) in
{ lfun = Id.Map.empty; extra = extra }
let eval_tactic t =
Proofview.tclUNIT () >>= fun () -> (* delay for [default_ist] *)
Proofview.tclLIFT db_initialize <*>
interp_tactic (default_ist ()) t
let eval_tactic_ist ist t =
Proofview.tclLIFT db_initialize <*>
interp_tactic ist t
(* globalization + interpretation *)
let interp_tac_gen lfun avoid_ids debug t =
Proofview.Goal.raw_enter begin fun gl ->
let env = Proofview.Goal.env gl in
let extra = TacStore.set TacStore.empty f_debug debug in
let extra = TacStore.set extra f_avoid_ids avoid_ids in
let ist = { lfun = lfun; extra = extra } in
let ltacvars = Id.Map.domain lfun in
interp_tactic ist
(intern_pure_tactic {
ltacvars; ltacrecvars = Id.Map.empty;
genv = env } t)
end
let interp t = interp_tac_gen Id.Map.empty [] (get_debug()) t
let _ = Proof_global.set_interp_tac interp
(* Used to hide interpretation for pretty-print, now just launch tactics *)
(* [global] means that [t] should be internalized outside of goals. *)
let hide_interp global t ot =
let hide_interp env =
let ist = { ltacvars = Id.Set.empty; ltacrecvars = Id.Map.empty;
genv = env } in
let te = intern_pure_tactic ist t in
let t = eval_tactic te in
match ot with
| None -> t
| Some t' -> Tacticals.New.tclTHEN t t'
in
if global then
Proofview.tclENV >>= fun env ->
hide_interp env
else
Proofview.Goal.raw_enter begin fun gl ->
hide_interp (Proofview.Goal.env gl)
end
(***************************************************************************)
(** Register standard arguments *)
let def_intern ist x = (ist, x)
let def_subst _ x = x
let def_interp ist gl x = (project gl, x)
let declare_uniform t =
Genintern.register_intern0 t def_intern;
Genintern.register_subst0 t def_subst;
Geninterp.register_interp0 t def_interp
let () =
declare_uniform wit_unit
let () =
declare_uniform wit_int
let () =
declare_uniform wit_bool
let () =
declare_uniform wit_string
let () =
declare_uniform wit_pre_ident
let () =
let interp ist gl ref = (project gl, interp_reference ist (pf_env gl) ref) in
Geninterp.register_interp0 wit_ref interp;
let interp ist gl pat = (project gl, interp_intro_pattern ist (pf_env gl) pat) in
Geninterp.register_interp0 wit_intro_pattern interp;
let interp ist gl s = (project gl, interp_sort s) in
Geninterp.register_interp0 wit_sort interp
let () =
let interp ist gl tac =
let f = VFun (extract_trace ist, ist.lfun, [], tac) in
(project gl, TacArg (dloc, valueIn (of_tacvalue f)))
in
Geninterp.register_interp0 wit_tactic interp
(***************************************************************************)
(* Other entry points *)
let interp_redexp env sigma r =
let ist = default_ist () in
let gist = { fully_empty_glob_sign with genv = env; } in
interp_red_expr ist sigma env (intern_red_expr gist r)
(***************************************************************************)
(* Embed tactics in raw or glob tactic expr *)
let globTacticIn t = TacArg (dloc,TacDynamic (dloc,tactic_in t))
let tacticIn t =
globTacticIn (fun ist ->
try glob_tactic (t ist)
with e when Errors.noncritical e -> anomaly ~label:"tacticIn"
(str "Incorrect tactic expression. Received exception is:" ++
Errors.print e))
(***************************************************************************)
(* Backwarding recursive needs of tactic glob/interp/eval functions *)
let _ =
let eval ty env sigma lfun arg =
let ist = { lfun = lfun; extra = TacStore.empty; } in
if has_type arg (glbwit wit_tactic) then
let tac = out_gen (glbwit wit_tactic) arg in
let tac = interp_tactic ist tac in
let prf = Proof.start sigma [env, ty] in
let (prf, _) = Proof.run_tactic env tac prf in
let sigma = Proof.in_proof prf (fun sigma -> sigma) in
let ans = match Proof.initial_goals prf with
| [c, _] -> c
| _ -> assert false
in
ans, sigma
else
failwith "not a tactic"
in
Hook.set Pretyping.genarg_interp_hook eval
let _ = Hook.set Auto.extern_interp
(fun l ->
let lfun = Id.Map.map (fun c -> Value.of_constr c) l in
let ist = { (default_ist ()) with lfun; } in
interp_tactic ist)
|