blob: d8656613098ee2cd7902f4ce63cb9e784be98ad2 (
plain)
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
|
(***********************************************************************)
(* *)
(* Objective Caml *)
(* *)
(* Xavier Leroy, projet Cristal, INRIA Rocquencourt *)
(* *)
(* Copyright 1996 Institut National de Recherche en Informatique et *)
(* Automatique. Distributed only by permission. *)
(* *)
(***********************************************************************)
(* $Id$ *)
(* Representation of types and declarations *)
open Asttypes
(* Type expressions for the core language *)
type type_expr =
{ mutable desc: type_desc;
mutable level: int }
and type_desc =
Tvar
| Tarrow of type_expr * type_expr
| Ttuple of type_expr list
| Tconstr of Path.t * type_expr list * (Path.t * type_expr) list ref
| Tobject of type_expr * (Path.t * type_expr list) option ref
| Tfield of string * type_expr * type_expr
| Tnil
| Tlink of type_expr
(* Value descriptions *)
type value_description =
{ val_type: type_expr; (* Type of the value *)
val_kind: value_kind }
and value_kind =
Val_reg (* Regular value *)
| Val_prim of Primitive.description (* Primitive *)
| Val_ivar of mutable_flag (* Instance variable (mutable ?) *)
| Val_anc of (string * Ident.t) list (* Ancestor *)
(* Constructor descriptions *)
type constructor_description =
{ cstr_res: type_expr; (* Type of the result *)
cstr_args: type_expr list; (* Type of the arguments *)
cstr_arity: int; (* Number of arguments *)
cstr_tag: constructor_tag; (* Tag for heap blocks *)
cstr_consts: int; (* Number of constant constructors *)
cstr_nonconsts: int } (* Number of non-const constructors *)
and constructor_tag =
Cstr_constant of int (* Constant constructor (an int) *)
| Cstr_block of int (* Regular constructor (a block) *)
| Cstr_exception of Path.t (* Exception constructor *)
(* Record label descriptions *)
type label_description =
{ lbl_res: type_expr; (* Type of the result *)
lbl_arg: type_expr; (* Type of the argument *)
lbl_mut: mutable_flag; (* Is this a mutable field? *)
lbl_pos: int; (* Position in block *)
lbl_all: label_description array; (* All the labels in this type *)
lbl_repres: record_representation } (* Representation for this record *)
and record_representation =
Record_regular (* All fields are boxed / tagged *)
| Record_float (* All fields are floats *)
(* Type expressions for classes *)
module Vars : Map.S with type key = string
module Concr : Set.S with type elt = string
type class_type =
{ cty_params: type_expr list;
cty_args: type_expr list;
cty_vars: (mutable_flag * type_expr) Vars.t;
cty_self: type_expr;
cty_concr: Concr.t;
mutable cty_new: type_expr option }
(* Type definitions *)
type type_declaration =
{ type_params: type_expr list;
type_arity: int;
type_kind: type_kind;
type_manifest: type_expr option }
and type_kind =
Type_abstract
| Type_variant of (string * type_expr list) list
| Type_record of (string * mutable_flag * type_expr) list
type exception_declaration = type_expr list
(* Type expressions for the module language *)
type module_type =
Tmty_ident of Path.t
| Tmty_signature of signature
| Tmty_functor of Ident.t * module_type * module_type
and signature = signature_item list
and signature_item =
Tsig_value of Ident.t * value_description
| Tsig_type of Ident.t * type_declaration
| Tsig_exception of Ident.t * exception_declaration
| Tsig_module of Ident.t * module_type
| Tsig_modtype of Ident.t * modtype_declaration
| Tsig_class of Ident.t * class_type
and modtype_declaration =
Tmodtype_abstract
| Tmodtype_manifest of module_type
|
