Commit | Line | Data |
---|---|---|
7f918cf1 CE |
1 | (* Copyright (C) 1999-2006 Henry Cejtin, Matthew Fluet, Suresh |
2 | * Jagannathan, and Stephen Weeks. | |
3 | * | |
4 | * MLton is released under a BSD-style license. | |
5 | * See the file MLton-LICENSE for details. | |
6 | *) | |
7 | ||
8 | signature TRACE_CONTROL = | |
9 | sig | |
10 | (* controls what tracing info is gathered *) | |
11 | val always: unit -> unit (* always gather info *) | |
12 | val flagged: unit -> unit (* only on flagged functions *) | |
13 | val never: unit -> unit (* never gather info *) | |
14 | ||
15 | (* value of newly created flag *) | |
16 | val default: bool ref | |
17 | ||
18 | (* turn on/off tracing for given functions *) | |
19 | val on: string list -> unit | |
20 | val off: string list -> unit | |
21 | ||
22 | (* turn on/off tracing for all functions *) | |
23 | val all: unit -> unit | |
24 | val none: unit -> unit | |
25 | ||
26 | (* returns functions that are on/off *) | |
27 | val whatsOn: unit -> string list | |
28 | val whatsOff: unit -> string list | |
29 | end | |
30 | ||
31 | signature TRACE = | |
32 | sig | |
33 | structure Immediate: | |
34 | sig | |
35 | include TRACE_CONTROL | |
36 | ||
37 | datatype debug = | |
38 | None | |
39 | | Terminal | |
40 | | Out of Out.t | |
41 | ||
42 | (* | |
43 | * If !debug = Terminal, debugging messages are printed to /dev/tty. | |
44 | * If !debug = Out os, then messages will be sent to os. | |
45 | * If !debug = None, then messages will be ignored. | |
46 | *) | |
47 | val debug: debug ref | |
48 | val message: Layout.t -> unit | |
49 | val messageStr: string -> unit | |
50 | (* inChildProcess is called by Process so that trace will know if it | |
51 | * is in a child, and therefore it will prefix all messages with the | |
52 | * pid of the current process. | |
53 | *) | |
54 | val inChildProcess: unit -> unit | |
55 | (* !showTime = true iff messages are preceded by the current time *) | |
56 | val showTime: bool ref | |
57 | end | |
58 | structure Delayed: | |
59 | sig | |
60 | include TRACE_CONTROL | |
61 | val keepAll: bool ref | |
62 | end | |
63 | structure Time: TRACE_CONTROL | |
64 | ||
65 | val never: unit -> unit | |
66 | val always: unit -> unit | |
67 | val flagged: unit -> unit | |
68 | val traceable: unit -> string list | |
69 | val outputTraceable: unit -> unit | |
70 | val reset: unit -> unit | |
71 | ||
72 | (*---------- Delayed Feedback ----------*) | |
73 | structure Computation: COMPUTATION | |
74 | ||
75 | (* clear computation history *) | |
76 | val clear: unit -> unit | |
77 | ||
78 | (* get computation history *) | |
79 | val computation: unit -> Computation.t | |
80 | ||
81 | (* show computation history *) | |
82 | val history: unit -> unit | |
83 | ||
84 | (* show computation history, without arguments or results *) | |
85 | val calls: unit -> unit | |
86 | ||
87 | val times: unit -> unit | |
88 | ||
89 | (* enter the inspector *) | |
90 | val inspect: unit -> unit | |
91 | ||
92 | (*---------- Instrumentation ----------*) | |
93 | ||
94 | val traceCall: string -> ('a -> 'b) -> 'a -> 'b | |
95 | ||
96 | type info | |
97 | val info: string -> info | |
98 | ||
99 | val traceInfo: | |
100 | info | |
101 | * ('a -> Layout.t) | |
102 | * ('b -> Layout.t) | |
103 | * ('a -> bool * ('b -> bool)) | |
104 | -> ('a -> 'b) | |
105 | -> ('a -> 'b) | |
106 | ||
107 | val traceInfo': | |
108 | info | |
109 | * ('a -> Layout.t) | |
110 | * ('b -> Layout.t) | |
111 | -> ('a -> 'b) | |
112 | -> ('a -> 'b) | |
113 | ||
114 | (* type ('a, 'b) check = ('a -> Layout.t) * ('a -> bool * 'b) | |
115 | * | |
116 | * type ('a, 'b) z = | |
117 | * 'a -> ((unit -> Layout.t) | |
118 | * * (unit -> bool) | |
119 | * * 'a | |
120 | * * 'b) | |
121 | * | |
122 | * val traceInfo: | |
123 | * info | |
124 | * * ('a, ('b, unit) check) check | |
125 | * -> ('a -> 'b) | |
126 | * -> 'a | |
127 | * -> 'b | |
128 | *) | |
129 | ||
130 | val assertTrue: 'a -> (bool * ('b -> bool)) | |
131 | ||
132 | val traceAssert: | |
133 | string | |
134 | * ('a -> Layout.t) | |
135 | * ('b -> Layout.t) | |
136 | * ('a -> bool * ('b -> bool)) | |
137 | -> ('a -> 'b) | |
138 | -> ('a -> 'b) | |
139 | ||
140 | val trace: | |
141 | string | |
142 | * ('a -> Layout.t) | |
143 | * ('b -> Layout.t) | |
144 | -> ('a -> 'b) | |
145 | -> ('a -> 'b) | |
146 | ||
147 | val trace0: | |
148 | string | |
149 | * ('a -> Layout.t) | |
150 | -> (unit -> 'a) | |
151 | -> (unit -> 'a) | |
152 | ||
153 | val trace2: | |
154 | string | |
155 | * ('a -> Layout.t) | |
156 | * ('b -> Layout.t) | |
157 | * ('c -> Layout.t) | |
158 | -> ('a * 'b -> 'c) | |
159 | -> ('a * 'b -> 'c) | |
160 | ||
161 | val trace3: | |
162 | string | |
163 | * ('a -> Layout.t) | |
164 | * ('b -> Layout.t) | |
165 | * ('c -> Layout.t) | |
166 | * ('d -> Layout.t) | |
167 | -> ('a * 'b * 'c -> 'd) | |
168 | -> ('a * 'b * 'c -> 'd) | |
169 | ||
170 | val trace4: | |
171 | string | |
172 | * ('a -> Layout.t) | |
173 | * ('b -> Layout.t) | |
174 | * ('c -> Layout.t) | |
175 | * ('d -> Layout.t) | |
176 | * ('e -> Layout.t) | |
177 | -> ('a * 'b * 'c * 'd -> 'e) | |
178 | -> ('a * 'b * 'c * 'd -> 'e) | |
179 | ||
180 | val trace5: | |
181 | string | |
182 | * ('a -> Layout.t) | |
183 | * ('b -> Layout.t) | |
184 | * ('c -> Layout.t) | |
185 | * ('d -> Layout.t) | |
186 | * ('e -> Layout.t) | |
187 | * ('f -> Layout.t) | |
188 | -> ('a * 'b * 'c * 'd * 'e -> 'f) | |
189 | -> ('a * 'b * 'c * 'd * 'e -> 'f) | |
190 | ||
191 | val traceRec: | |
192 | string | |
193 | * ('a -> Layout.t) | |
194 | * ('b -> Layout.t) | |
195 | -> (('a -> 'b) -> ('a -> 'b)) | |
196 | -> 'a -> 'b | |
197 | end |