InutitionTC  0.30
printMessages.h
Go to the documentation of this file.
1 /****************************************************************************
2  * Copyright (C) 2016 by University of Warsaw *
3  * *
4  * This file is part of IntuitionTC. *
5  * *
6  ****************************************************************************/
14 #ifndef _PRINT_MESSAGES_H
15 #define _PRINT_MESSAGES_H 1
16 #include <stdlib.h>
17 #include "errorMessages.h"
18 #include "checker.h"
19 #ifdef _FRAMAC_
20 //#include <__fc_string_axiomatic.h>
21 
22 #endif
23 
24 
25 #include <stdlib.h>
26 #include "checker.h"
27 
28 #define PRINT_BUFFER_LEN 4096
29 extern char printBuffer[PRINT_BUFFER_LEN];
30 //@ logic size_t L_PRINT_BUFFER_LEN = (size_t)4096;
31 extern int printBufferOverflow;
32 
33 //size_t const CONST_PRINT_BUFFER_LEN = PRINT_BUFFER_LEN;
34 
35 //int const PRINT_BUFFER_LEN = 4096;
36 
37 
38 
39 #define printMessages_SIZE 35;
40 //@ logic size_t L_printMessages_SIZE = (size_t)36;
41 
42 
43 
44 //auxiliary table with constant printing strings
45 //I do not know why but I could not use printMessages_size and
46 //printMessages_number in declaration/definition
47 //I got a compilation error
48 
49 //extern char printMessages[printMessages_number][printMessages_size];
50 extern char* printMessages[];
51 
52 
53 #define PRINT_KSTAR 0
54 //@ logic size_t L_PRINT_KSTAR = (size_t) 0;
55 #define PRINT_PI 1
56 //@ logic size_t L_PRINT_PI = (size_t)1;
57 #define PRINT_COLONSPACES 2
58 //@ logic size_t L_PRINT_COLONSPACES = (size_t)2;
59 #define PRINT_DOT 3
60 //@ logic size_t L_PRINT_DOT = (size_t)3;
61 #define PRINT_LPAR 4
62 //@ logic size_t L_PRINT_LPAR = (size_t)4;
63 #define PRINT_RPAR 5
64 //@ logic size_t L_PRINT_RPAR = (size_t)5;
65 #define PRINT_A 6
66 //@ logic size_t L_PRINT_A = (size_t)6;
67 #define PRINT_COLON 7
68 //@ logic size_t L_PRINT_COLON = (size_t)7;
69 #define PRINT_E 8
70 //@ logic size_t L_PRINT_E = (size_t)8;
71 #define PRINT_AND 9
72 //@ logic size_t L_PRINT_AND = (size_t)9;
73 #define PRINT_OR 10
74 //@ logic size_t L_PRINT_OR = (size_t)10;
75 #define PRINT_BOT 11
76 //@ logic size_t L_PRINT_BOT = (size_t)11;
77 #define PRINT_EOL 12
78 //@ logic size_t L_PRINT_EOL = (size_t)12;
79 #define PRINT_LAMBDA 13
80 //@ logic size_t L_PRINT_LAMBDA = (size_t)13;
81 #define PRINT_LSQPAR 14
82 //@ logic size_t L_PRINT_LSQPAR = (size_t)14;
83 #define PRINT_RSQPAR_LCURPAR 15
84 //@ logic size_t L_PRINT_RSQPAR_LCURPAR = (size_t)15;
85 #define PRINT_RCURPAR 16
86 //@ logic size_t L_PRINT_RCURPAR = (size_t)16;
87 #define PRINT_ABSTRACT 17
88 //@ logic size_t L_PRINT_ABSTRAC = (size_t)17;
89 #define PRINT_COMMASPACE 18
90 //@ logic size_t L_PRINT_COMMASPACE = (size_t)18;
91 #define PRINT_RANGLE_EQ 19
92 //@ logic size_t L_PRINT_RANGLE_EQ = (size_t)19;
93 #define PRINT_IN 20
94 //@ logic size_t L_PRINT_IN = (size_t)20;
95 #define PRINT_LANGLE 21
96 //@ logic size_t L_PRINT_LANGLE = (size_t)21;
97 #define PRINT_RANGLE_LCURPAR 22
98 //@ logic size_t L_PRINT_LCURPAR = (size_t)22;
99 #define PRINT_PI1 23
100 //@ logic size_t L_PRINT_PI1 = (size_t)23;
101 #define PRINT_PI2 24
102 //@ logic size_t L_PRINT_PI2 = (size_t)24;
103 #define PRINT_IN1 25
104 //@ logic size_t L_PRINT_IN1 = (size_t)25;
105 #define PRINT_IN2 26
106 //@ logic size_t L_PRINT_IN2 = (size_t)26;
107 #define PRINT_CASE 27
108 //@ logic size_t L_PRINT_CASE = (size_t)27;
109 #define PRINT_IN_LEFT 28
110 //@ logic size_t L_PRINT_LEFT = (size_t)28;
111 #define PRINT_RIGHT 29
112 //@ logic size_t L_PRINT_RIGHT = (size_t)29;
113 #define PRINT_EPSILON 30
114 //@ logic size_t L_PRINT_EPSILON = (size_t)30;
115 #define PRINT_KIND_WRONG_ENUM 31
116 //@ logic size_t L_PRINT_KIND_WRONG_ENUM = (size_t)31;
117 #define PRINT_TYPE_WRONG_ENUM 32
118 //@ logic size_t L_PRINT_TYPE_WRONG_ENUM = (size_t)32;
119 #define PRINT_TERM_WRONG_ENUM 33
120 //@ logic size_t L_PRINT_TERM_WRONG_ENUM = (size_t)33;
121 #define PRINT_ARROW 34
122 //@ logic size_t L_PRINT_ARROW = (size_t)34;
123 #define PRINT_UNDERSCORE 35
124 //@ logic size_t L_PRINT_UNDERSCORE = (size_t)35;
125 
126 
127 
128 /*@ axiomatic print_messages_table {
129  @
130  @ predicate valid_printMessages(integer a) =
131  @ \forall size_t i; 0 <= i < L_printMessages_SIZE ==>
132  @ valid_string((char*)printMessages[i]);
133  @
134  @ axiom ax_valid_printMessages:
135  @ \forall size_t i; 0 <= i < L_printMessages_SIZE ==>
136  @ valid_string((char*)printMessages[i]);
137  @
138  @ }//print_messages_table
139  @*/
140 
141 
142 
143 
144 /*@ predicate printBufferValid(integer a) =
145  @ valid_string((char*)printBuffer) &&
146  @ strlen((char*)printBuffer) < 4096;
147  @
148  @*/
149 
150 /*@
151  @ // lemmas for printing Kinds, Terms, ...
152  @
153  @ axiomatic printing_lemmas {
154  @
155  @
156  @ lemma valid_Kind_to_valid_kPi{L}:
157  @ \forall Kind k;
158  @ valid_Kind{L}(k) ==>
159  @ (k.which)==eKpi ==>
160  @ valid_Kpi{L}(k.kPi);
161  @
162  @
163  @ lemma valid_Kind_ptr_to_valid_kPi_Kind_ptr{L}:
164  @ \forall Kind *k;
165  @ valid_Kind_ptr{L}(k) ==>
166  @ (k->which) == eKpi ==>
167  @ (valid_Kind_ptr{L}((k->kPi).kind));
168  @
169  @ lemma valid_Kind_ptr_to_valid_kPi_Type_ptr{L}:
170  @ \forall Kind *k;
171  @ valid_Kind_ptr{L}(k) ==>
172  @ (k->which) == eKpi ==>
173  @ (valid_Type_ptr{L}((k->kPi).type));
174  @
175  @ lemma valid_Kind_ptr_to_valid_string_kPi_ptr_Name{L}:
176  @ \forall Kind *k;
177  @ valid_Kind_ptr{L}(k) ==>
178  @ (k->which) == eKpi ==>
179  @ (valid_string{L}((k->kPi).name));
180  @
181  @ lemma valid_Type_ptr_to_valid_string_tVar_ptr_Name{L}:
182  @ \forall Type *k;
183  @ valid_Type_ptr{L}(k) ==>
184  @ (k->which) == etVar ==>
185  @ (valid_string{L}((k->tVar).name));
186  @
187  @ lemma valid_Type_ptr_to_valid_string_tAll_ptr_Name{L}:
188  @ \forall Type *k;
189  @ valid_Type_ptr{L}(k) ==>
190  @ (k->which) == etAll ==>
191  @ (valid_string{L}((k->tAll).name));
192  @
193  @ lemma valid_Type_ptr_to_valid_tAll_Type1_ptr{L}:
194  @ \forall Type *k;
195  @ valid_Type_ptr{L}(k) ==>
196  @ (k->which) == etAll ==>
197  @ (valid_Type_ptr{L}((k->tAll).type1));
198  @
199  @
200  @ lemma valid_Type_ptr_to_valid_tAll_Type2_ptr{L}:
201  @ \forall Type *k;
202  @ valid_Type_ptr{L}(k) ==>
203  @ (k->which) == etAll ==>
204  @ (valid_Type_ptr{L}((k->tAll).type2));
205  @
206  @
207  @ lemma valid_Type_ptr_to_valid_tApp_Type_ptr{L}:
208  @ \forall Type *k;
209  @ valid_Type_ptr{L}(k) ==>
210  @ (k->which) == etApp ==>
211  @ (valid_Type_ptr{L}((k->tApp).type));
212  @
213  @
214  @ lemma valid_Type_ptr_to_valid_tApp_Term_ptr{L}:
215  @ \forall Type *k;
216  @ valid_Type_ptr{L}(k) ==>
217  @ (k->which) == etApp ==>
218  @ (valid_Term_ptr{L}((k->tApp).term));
219  @
220  @
221  @ lemma valid_Type_ptr_to_valid_string_tExi_ptr_Name{L}:
222  @ \forall Type *k;
223  @ valid_Type_ptr{L}(k) ==>
224  @ (k->which) == etExi ==>
225  @ (valid_string{L}((k->tExi).name));
226  @
227  @ lemma valid_Type_ptr_to_valid_tExi_Type1_ptr{L}:
228  @ \forall Type *k;
229  @ valid_Type_ptr{L}(k) ==>
230  @ (k->which) == etExi ==>
231  @ (valid_Type_ptr{L}((k->tExi).type1));
232  @
233  @
234  @ lemma valid_Type_ptr_to_valid_tExi_Type2_ptr{L}:
235  @ \forall Type *k;
236  @ valid_Type_ptr{L}(k) ==>
237  @ (k->which) == etExi ==>
238  @ (valid_Type_ptr{L}((k->tExi).type2));
239  @
240  @
241  @
242  @ lemma valid_Type_ptr_to_valid_tAnd_Type1_ptr{L}:
243  @ \forall Type *k;
244  @ valid_Type_ptr{L}(k) ==>
245  @ (k->which) == etAnd ==>
246  @ (valid_Type_ptr{L}((k->tAnd).type1));
247  @
248  @
249  @ lemma valid_Type_ptr_to_valid_tAnd_Type2_ptr{L}:
250  @ \forall Type *k;
251  @ valid_Type_ptr{L}(k) ==>
252  @ (k->which) == etAnd ==>
253  @ (valid_Type_ptr{L}((k->tAnd).type2));
254  @
255  @
256  @ lemma valid_Type_ptr_to_valid_tOr_Type1_ptr{L}:
257  @ \forall Type *k;
258  @ valid_Type_ptr{L}(k) ==>
259  @ (k->which) == etOr ==>
260  @ (valid_Type_ptr{L}((k->tOr).type1));
261  @
262  @
263  @ lemma valid_Type_ptr_to_valid_tOr_Type2_ptr{L}:
264  @ \forall Type *k;
265  @ valid_Type_ptr{L}(k) ==>
266  @ (k->which) == etOr ==>
267  @ (valid_Type_ptr{L}((k->tOr).type2));
268  @
269  @
270  @ lemma valid_Term_ptr_to_valid_string_mVar_ptr_Name{L}:
271  @ \forall Term *k;
272  @ valid_Term_ptr{L}(k) ==>
273  @ (k->which) == emVar ==>
274  @ (valid_string{L}((k->mVar).name));
275  @
276  @
277  @ lemma valid_Term_ptr_to_valid_mApp_Term1_ptr{L}:
278  @ \forall Term *k;
279  @ valid_Term_ptr{L}(k) ==>
280  @ (k->which) == emApp ==>
281  @ (valid_Term_ptr{L}((k->mApp).term1));
282  @
283  @ lemma valid_Term_ptr_to_valid_mApp_Term2_ptr{L}:
284  @ \forall Term *k;
285  @ valid_Term_ptr{L}(k) ==>
286  @ (k->which) == emApp ==>
287  @ (valid_Term_ptr{L}((k->mApp).term2));
288  @
289  @
290  @ lemma valid_Term_ptr_to_valid_string_mLam_ptr_Name{L}:
291  @ \forall Term *k;
292  @ valid_Term_ptr{L}(k) ==>
293  @ (k->which) == emLam ==>
294  @ (valid_string{L}((k->mLam).name));
295  @
296  @
297  @ lemma valid_Term_ptr_to_valid_mLam_Type_ptr{L}:
298  @ \forall Term *k;
299  @ valid_Term_ptr{L}(k) ==>
300  @ (k->which) == emLam ==>
301  @ (valid_Type_ptr{L}((k->mLam).type));
302  @
303  @ lemma valid_Term_ptr_to_valid_mLam_Term_ptr{L}:
304  @ \forall Term *k;
305  @ valid_Term_ptr{L}(k) ==>
306  @ (k->which) == emLam ==>
307  @ (valid_Term_ptr{L}((k->mLam).term));
308  @
309  @
310  @ lemma valid_Term_ptr_to_valid_mWit_Term1_ptr{L}:
311  @ \forall Term *k;
312  @ valid_Term_ptr{L}(k) ==>
313  @ (k->which) == emWit ==>
314  @ (valid_Term_ptr{L}((k->mWit).term1));
315  @
316  @
317  @ lemma valid_Term_ptr_to_valid_mWit_Term2_ptr{L}:
318  @ \forall Term *k;
319  @ valid_Term_ptr{L}(k) ==>
320  @ (k->which) == emWit ==>
321  @ (valid_Term_ptr{L}((k->mWit).term2));
322  @
323  @ lemma valid_Term_ptr_to_valid_mWit_Type_ptr{L}:
324  @ \forall Term *k;
325  @ valid_Term_ptr{L}(k) ==>
326  @ (k->which) == emWit ==>
327  @ (valid_Type_ptr{L}((k->mWit).type));
328  @
329  @
330  @
331  @ lemma valid_Term_ptr_to_valid_string_mAbs_ptr_Name1{L}:
332  @ \forall Term *k;
333  @ valid_Term_ptr{L}(k) ==>
334  @ (k->which) == emAbs ==>
335  @ (valid_string{L}((k->mAbs).name1));
336  @
337  @ lemma valid_Term_ptr_to_valid_string_mAbs_ptr_Name3{L}:
338  @ \forall Term *k;
339  @ valid_Term_ptr{L}(k) ==>
340  @ (k->which) == emAbs ==>
341  @ (valid_string{L}((k->mAbs).name3));
342  @
343  @
344  @ lemma valid_Term_ptr_to_valid_mAbs_Type2_ptr{L}:
345  @ \forall Term *k;
346  @ valid_Term_ptr{L}(k) ==>
347  @ (k->which) == emAbs ==>
348  @ (valid_Type_ptr{L}((k->mAbs).type2));
349  @
350  @
351  @ lemma valid_Term_ptr_to_valid_mAbs_Type4_ptr{L}:
352  @ \forall Term *k;
353  @ valid_Term_ptr{L}(k) ==>
354  @ (k->which) == emAbs ==>
355  @ (valid_Type_ptr{L}((k->mAbs).type4));
356  @
357  @
358  @ lemma valid_Term_ptr_to_valid_mAbs_Term5_ptr{L}:
359  @ \forall Term *k;
360  @ valid_Term_ptr{L}(k) ==>
361  @ (k->which) == emAbs ==>
362  @ (valid_Term_ptr{L}((k->mAbs).term5));
363  @
364  @
365  @ lemma valid_Term_ptr_to_valid_mAbs_Term6_ptr{L}:
366  @ \forall Term *k;
367  @ valid_Term_ptr{L}(k) ==>
368  @ (k->which) == emAbs ==>
369  @ (valid_Term_ptr{L}((k->mAbs).term6));
370  @
371  @
372  @ lemma valid_Term_ptr_to_valid_mTup_Term1_ptr{L}:
373  @ \forall Term *k;
374  @ valid_Term_ptr{L}(k) ==>
375  @ (k->which) == emTup ==>
376  @ (valid_Term_ptr{L}((k->mTup).term1));
377  @
378  @
379  @ lemma valid_Term_ptr_to_valid_mTup_Term2_ptr{L}:
380  @ \forall Term *k;
381  @ valid_Term_ptr{L}(k) ==>
382  @ (k->which) == emTup ==>
383  @ (valid_Term_ptr{L}((k->mTup).term2));
384  @
385  @
386  @ lemma valid_Term_ptr_to_valid_mTup_Type_ptr{L}:
387  @ \forall Term *k;
388  @ valid_Term_ptr{L}(k) ==>
389  @ (k->which) == emTup ==>
390  @ (valid_Type_ptr{L}((k->mTup).type));
391  @
392  @
393  @
394  @ lemma valid_Term_ptr_to_valid_mPi1_Term_ptr{L}:
395  @ \forall Term *k;
396  @ valid_Term_ptr{L}(k) ==>
397  @ (k->which) == emPi1 ==>
398  @ (valid_Term_ptr{L}((k->mPi1).term));
399  @
400  @
401  @ lemma valid_Term_ptr_to_valid_mPi2_Term_ptr{L}:
402  @ \forall Term *k;
403  @ valid_Term_ptr{L}(k) ==>
404  @ (k->which) == emPi2 ==>
405  @ (valid_Term_ptr{L}((k->mPi2).term));
406  @
407  @
408  @ lemma valid_Term_ptr_to_valid_mIn1_Type_ptr{L}:
409  @ \forall Term *k;
410  @ valid_Term_ptr{L}(k) ==>
411  @ (k->which) == emIn1 ==>
412  @ (valid_Type_ptr{L}((k->mIn1).type));
413  @
414  @
415  @ lemma valid_Term_ptr_to_valid_mIn1_Term_ptr{L}:
416  @ \forall Term *k;
417  @ valid_Term_ptr{L}(k) ==>
418  @ (k->which) == emIn1 ==>
419  @ (valid_Term_ptr{L}((k->mIn1).term));
420  @
421  @
422  @ lemma valid_Term_ptr_to_valid_mIn2_Type_ptr{L}:
423  @ \forall Term *k;
424  @ valid_Term_ptr{L}(k) ==>
425  @ (k->which) == emIn2 ==>
426  @ (valid_Type_ptr{L}((k->mIn2).type));
427  @
428  @
429  @ lemma valid_Term_ptr_to_valid_mIn2_Term_ptr{L}:
430  @ \forall Term *k;
431  @ valid_Term_ptr{L}(k) ==>
432  @ (k->which) == emIn2 ==>
433  @ (valid_Term_ptr{L}((k->mIn2).term));
434  @
435  @
436  @ lemma valid_Term_ptr_to_valid_mCas_Term_ptr{L}:
437  @ \forall Term *k;
438  @ valid_Term_ptr{L}(k) ==>
439  @ (k->which) == emCas ==>
440  @ (valid_Term_ptr{L}((k->mCas).term));
441  @
442  @
443  @ lemma valid_Term_ptr_to_valid_string_mCas_casIn1_Name{L}:
444  @ \forall Term *k;
445  @ valid_Term_ptr{L}(k) ==>
446  @ (k->which) == emCas ==>
447  @ (valid_string{L}(((k->mCas).casIn1).name));
448  @
449  @
450  @ lemma valid_Term_ptr_to_valid_mCas_casIn1_Type_ptr{L}:
451  @ \forall Term *k;
452  @ valid_Term_ptr{L}(k) ==>
453  @ (k->which) == emCas ==>
454  @ (valid_Type_ptr{L}(((k->mCas).casIn1).type));
455  @
456  @
457  @ lemma valid_Term_ptr_to_valid_mCas_casIn1_Term_ptr{L}:
458  @ \forall Term *k;
459  @ valid_Term_ptr{L}(k) ==>
460  @ (k->which) == emCas ==>
461  @ (valid_Term_ptr{L}(((k->mCas).casIn1).term));
462  @
463  @
464  @ lemma valid_Term_ptr_to_valid_string_mCas_casIn2_Name{L}:
465  @ \forall Term *k;
466  @ valid_Term_ptr{L}(k) ==>
467  @ (k->which) == emCas ==>
468  @ (valid_string{L}(((k->mCas).casIn2).name));
469  @
470  @
471  @ lemma valid_Term_ptr_to_valid_mCas_casIn2_Type_ptr{L}:
472  @ \forall Term *k;
473  @ valid_Term_ptr{L}(k) ==>
474  @ (k->which) == emCas ==>
475  @ (valid_Type_ptr{L}(((k->mCas).casIn2).type));
476  @
477  @
478  @ lemma valid_Term_ptr_to_valid_mCas_casIn2_Term_ptr{L}:
479  @ \forall Term *k;
480  @ valid_Term_ptr{L}(k) ==>
481  @ (k->which) == emCas ==>
482  @ (valid_Term_ptr{L}(((k->mCas).casIn2).term));
483  @
484  @
485  @ lemma valid_Term_ptr_to_valid_mEps_Type_ptr{L}:
486  @ \forall Term *k;
487  @ valid_Term_ptr{L}(k) ==>
488  @ (k->which) == emEps ==>
489  @ (valid_Type_ptr{L}((k->mEps).type));
490  @
491  @
492  @ lemma valid_Term_ptr_to_valid_mEps_Term_ptr{L}:
493  @ \forall Term *k;
494  @ valid_Term_ptr{L}(k) ==>
495  @ (k->which) == emEps ==>
496  @ (valid_Term_ptr{L}((k->mEps).term));
497  @
498  @
499  @
500  @ lemma valid_Type_ptr_to_valid{L}:
501  @ \forall Type *k;
502  @ valid_Type_ptr{L}(k) ==> \valid{L}(k);
503  @
504  @ lemma valid_Type_ptr_to_valid_Type{L}:
505  @ \forall Type *k;
506  @ valid_Type_ptr{L}(k) ==> valid_Type{L}(*k);
507  @
508  @ lemma valid_Any_ptr_to_valid{L}:
509  @ \forall Any *k;
510  @ valid_Any_ptr{L}(k) ==> \valid{L}(k);
511  @
512  @ lemma valid_Term_ptr_to_valid{L}:
513  @ \forall Term *k;
514  @ valid_Term_ptr{L}(k) ==> \valid{L}(k);
515  @
516  @ lemma valid_Kind_ptr_to_valid{L}:
517  @ \forall Kind *k;
518  @ valid_Kind_ptr{L}(k) ==> \valid{L}(k);
519  @
520  @ lemma valid_Kind_ptr_to_valid_Kind{L}:
521  @ \forall Kind *k;
522  @ valid_Kind_ptr{L}(k) ==> valid_Kind{L}(*k);
523  @
524  @ }//printing_lemmas
525  @*/
526 
527 
528 
529 /*@
530  @ requires valid_string(s);
531  @ requires printBufferValid(0);
532  @ assigns printBuffer[0..4095], printBufferOverflow;
533  @ ensures printBufferValid(0);
534  @ ensures \result < 4096;
535  @*/
536 
537 int concatMessage(char *s);
538 
539 
540 
541 
542 
543 /*@
544  @ requires valid_string(a);
545  @ requires printBufferValid(0);
546  @ assigns printBuffer[0..4095], printBufferOverflow;
547  @ ensures printBufferValid(0);
548  @*/
549 void printMessage(char *a);
550 
551 
552 
553 
554 
555 /*@ requires \valid(k) && valid_Kind_ptr(k);
556  @ requires printBufferValid(0);
557  @ requires valid_printMessages(0);
558  @ requires errorBufferValid(0)&& errorNum < 2147483646;
559  @ assigns printBuffer[0..4095], errorBuffer[0..4095], errorNum, printBufferOverflow;
560  @ ensures printBufferValid(0);
561  @ ensures valid_printMessages(0);
562  @ ensures errorBufferValid(0);
563  @*/
564 
565 void printKind(Kind* k);
566 
567 /*@ requires \valid(t) && valid_Type_ptr(t);
568  @ requires printBufferValid(0);
569  @ requires valid_printMessages(0);
570  @ requires errorBufferValid(0)&& errorNum < 2147483646;
571  @ assigns printBuffer[0..4095], errorBuffer[0..4095], errorNum, printBufferOverflow;
572  @ ensures printBufferValid(0);
573  @ ensures valid_printMessages(0);
574  @ ensures errorBufferValid(0);
575  @*/
576 
577 void printType(Type* t);
578 
579 /*@ requires \valid(t) && valid_Term_ptr(t);
580  @ requires printBufferValid(0);
581  @ requires valid_printMessages(0);
582  @ requires errorBufferValid(0) && errorNum < 2147483646;
583  @ assigns printBuffer[0..4095], errorBuffer[0..4095], errorNum, printBufferOverflow;
584  @ ensures printBufferValid(0);
585  @ ensures valid_printMessages(0);
586  @ ensures errorBufferValid(0);
587  @*/
588 
589 void printTerm(Term* t);
590 
591 
592 
593 /*@ requires \valid(k) && valid_Kind_ptr(k);
594  @ requires printBufferValid(0);
595  @ requires valid_printMessages(0);
596  @ assigns printBuffer[0..4095], printBufferOverflow;
597  @ ensures printBufferValid(0);
598  @ ensures valid_printMessages(0);
599  @*/
600 
601 void _printKind(Kind* k);
602 
603 /*@ requires \valid(t) && valid_Type_ptr(t);
604  @ requires printBufferValid(0);
605  @ requires valid_printMessages(0);
606  @ assigns printBuffer[0..4095], printBufferOverflow;
607  @ ensures printBufferValid(0);
608  @ ensures valid_printMessages(0);
609  @*/
610 
611 void _printType(Type* t);
612 
613 /*@ requires \valid(t) && valid_Term_ptr(t);
614  @ requires printBufferValid(0);
615  @ requires valid_printMessages(0);
616  @ assigns printBuffer[0..4095], printBufferOverflow;
617  @ ensures printBufferValid(0);
618  @ ensures valid_printMessages(0);
619  @*/
620 
621 void _printTerm(Term* t);
622 
623 #endif
The representation of the kinds in the typesystem.
Definition: checker.h:68
Definitions of the base structures that represent the formulas and proofs.
Implementation of procedures that handle printing of error messages.
The representation of the types in the typesystem.
Definition: checker.h:146
The representation of the proof terms in the typesystem.
Definition: checker.h:298