38 val thys = |
38 val thys = |
39 using(store.open_database(session_name))(db => |
39 using(store.open_database(session_name))(db => |
40 { |
40 { |
41 db.transaction { |
41 db.transaction { |
42 Export.read_theory_names(db, session_name).map((theory_name: String) => |
42 Export.read_theory_names(db, session_name).map((theory_name: String) => |
43 read_theory(db, session_name, theory_name, types = types, consts = consts, |
43 read_theory(Export.Provider.database(db, session_name, theory_name), |
|
44 session_name, theory_name, types = types, consts = consts, |
44 axioms = axioms, facts = facts, classes = classes, typedefs = typedefs, |
45 axioms = axioms, facts = facts, classes = classes, typedefs = typedefs, |
45 cache = Some(cache))) |
46 cache = Some(cache))) |
46 } |
47 } |
47 }) |
48 }) |
48 |
49 |
88 } |
89 } |
89 |
90 |
90 def empty_theory(name: String): Theory = |
91 def empty_theory(name: String): Theory = |
91 Theory(name, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil) |
92 Theory(name, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil) |
92 |
93 |
93 def read_theory(db: SQL.Database, session_name: String, theory_name: String, |
94 def read_theory(provider: Export.Provider, session_name: String, theory_name: String, |
94 types: Boolean = true, |
95 types: Boolean = true, |
95 consts: Boolean = true, |
96 consts: Boolean = true, |
96 axioms: Boolean = true, |
97 axioms: Boolean = true, |
97 facts: Boolean = true, |
98 facts: Boolean = true, |
98 classes: Boolean = true, |
99 classes: Boolean = true, |
100 classrel: Boolean = true, |
101 classrel: Boolean = true, |
101 arities: Boolean = true, |
102 arities: Boolean = true, |
102 cache: Option[Term.Cache] = None): Theory = |
103 cache: Option[Term.Cache] = None): Theory = |
103 { |
104 { |
104 val parents = |
105 val parents = |
105 Export.read_entry(db, session_name, theory_name, export_prefix + "parents") match { |
106 provider(export_prefix + "parents") match { |
106 case Some(entry) => split_lines(entry.uncompressed().text) |
107 case Some(entry) => split_lines(entry.uncompressed().text) |
107 case None => |
108 case None => |
108 error("Missing theory export in session " + quote(session_name) + ": " + |
109 error("Missing theory export in session " + quote(session_name) + ": " + |
109 quote(theory_name)) |
110 quote(theory_name)) |
110 } |
111 } |
111 val theory = |
112 val theory = |
112 Theory(theory_name, parents, |
113 Theory(theory_name, parents, |
113 if (types) read_types(db, session_name, theory_name) else Nil, |
114 if (types) read_types(provider) else Nil, |
114 if (consts) read_consts(db, session_name, theory_name) else Nil, |
115 if (consts) read_consts(provider) else Nil, |
115 if (axioms) read_axioms(db, session_name, theory_name) else Nil, |
116 if (axioms) read_axioms(provider) else Nil, |
116 if (facts) read_facts(db, session_name, theory_name) else Nil, |
117 if (facts) read_facts(provider) else Nil, |
117 if (classes) read_classes(db, session_name, theory_name) else Nil, |
118 if (classes) read_classes(provider) else Nil, |
118 if (typedefs) read_typedefs(db, session_name, theory_name) else Nil, |
119 if (typedefs) read_typedefs(provider) else Nil, |
119 if (classrel) read_classrel(db, session_name, theory_name) else Nil, |
120 if (classrel) read_classrel(provider) else Nil, |
120 if (arities) read_arities(db, session_name, theory_name) else Nil) |
121 if (arities) read_arities(provider) else Nil) |
121 if (cache.isDefined) theory.cache(cache.get) else theory |
122 if (cache.isDefined) theory.cache(cache.get) else theory |
122 } |
123 } |
123 |
124 |
124 |
125 |
125 /* entities */ |
126 /* entities */ |
144 (Entity(name, serial, pos), body) |
145 (Entity(name, serial, pos), body) |
145 case _ => err() |
146 case _ => err() |
146 } |
147 } |
147 } |
148 } |
148 |
149 |
149 def read_export[A](db: SQL.Database, session_name: String, theory_name: String, |
|
150 export_name: String, decode: XML.Body => List[A]): List[A] = |
|
151 { |
|
152 Export.read_entry(db, session_name, theory_name, export_prefix + export_name) match { |
|
153 case Some(entry) => decode(entry.uncompressed_yxml()) |
|
154 case None => Nil |
|
155 } |
|
156 } |
|
157 |
|
158 def read_entities[A](db: SQL.Database, session_name: String, theory_name: String, |
|
159 export_name: String, decode: XML.Tree => A): List[A] = |
|
160 { |
|
161 read_export(db, session_name, theory_name, export_name, |
|
162 (body: XML.Body) => body.map(decode(_))) |
|
163 } |
|
164 |
|
165 |
150 |
166 /* types */ |
151 /* types */ |
167 |
152 |
168 sealed case class Type(entity: Entity, args: List[String], abbrev: Option[Term.Typ]) |
153 sealed case class Type(entity: Entity, args: List[String], abbrev: Option[Term.Typ]) |
169 { |
154 { |
171 Type(entity.cache(cache), |
156 Type(entity.cache(cache), |
172 args.map(cache.string(_)), |
157 args.map(cache.string(_)), |
173 abbrev.map(cache.typ(_))) |
158 abbrev.map(cache.typ(_))) |
174 } |
159 } |
175 |
160 |
176 def read_types(db: SQL.Database, session_name: String, theory_name: String): List[Type] = |
161 def read_types(provider: Export.Provider): List[Type] = |
177 read_entities(db, session_name, theory_name, "types", |
162 provider.uncompressed_yxml(export_prefix + "types").map((tree: XML.Tree) => |
178 (tree: XML.Tree) => |
163 { |
|
164 val (entity, body) = decode_entity(tree) |
|
165 val (args, abbrev) = |
179 { |
166 { |
180 val (entity, body) = decode_entity(tree) |
167 import XML.Decode._ |
181 val (args, abbrev) = |
168 pair(list(string), option(Term_XML.Decode.typ))(body) |
182 { |
169 } |
183 import XML.Decode._ |
170 Type(entity, args, abbrev) |
184 pair(list(string), option(Term_XML.Decode.typ))(body) |
171 }) |
185 } |
|
186 Type(entity, args, abbrev) |
|
187 }) |
|
188 |
172 |
189 |
173 |
190 /* consts */ |
174 /* consts */ |
191 |
175 |
192 sealed case class Const( |
176 sealed case class Const( |
197 typargs.map(cache.string(_)), |
181 typargs.map(cache.string(_)), |
198 cache.typ(typ), |
182 cache.typ(typ), |
199 abbrev.map(cache.term(_))) |
183 abbrev.map(cache.term(_))) |
200 } |
184 } |
201 |
185 |
202 def read_consts(db: SQL.Database, session_name: String, theory_name: String): List[Const] = |
186 def read_consts(provider: Export.Provider): List[Const] = |
203 read_entities(db, session_name, theory_name, "consts", |
187 provider.uncompressed_yxml(export_prefix + "consts").map((tree: XML.Tree) => |
204 (tree: XML.Tree) => |
188 { |
|
189 val (entity, body) = decode_entity(tree) |
|
190 val (args, typ, abbrev) = |
205 { |
191 { |
206 val (entity, body) = decode_entity(tree) |
192 import XML.Decode._ |
207 val (args, typ, abbrev) = |
193 triple(list(string), Term_XML.Decode.typ, option(Term_XML.Decode.term))(body) |
208 { |
194 } |
209 import XML.Decode._ |
195 Const(entity, args, typ, abbrev) |
210 triple(list(string), Term_XML.Decode.typ, option(Term_XML.Decode.term))(body) |
196 }) |
211 } |
|
212 Const(entity, args, typ, abbrev) |
|
213 }) |
|
214 |
197 |
215 |
198 |
216 /* axioms and facts */ |
199 /* axioms and facts */ |
217 |
200 |
218 def decode_props(body: XML.Body): |
201 def decode_props(body: XML.Body): |
234 typargs.map({ case (name, sort) => (cache.string(name), cache.sort(sort)) }), |
217 typargs.map({ case (name, sort) => (cache.string(name), cache.sort(sort)) }), |
235 args.map({ case (name, typ) => (cache.string(name), cache.typ(typ)) }), |
218 args.map({ case (name, typ) => (cache.string(name), cache.typ(typ)) }), |
236 cache.term(prop)) |
219 cache.term(prop)) |
237 } |
220 } |
238 |
221 |
239 def read_axioms(db: SQL.Database, session_name: String, theory_name: String): List[Axiom] = |
222 def read_axioms(provider: Export.Provider): List[Axiom] = |
240 read_entities(db, session_name, theory_name, "axioms", |
223 provider.uncompressed_yxml(export_prefix + "axioms").map((tree: XML.Tree) => |
241 (tree: XML.Tree) => |
224 { |
242 { |
225 val (entity, body) = decode_entity(tree) |
243 val (entity, body) = decode_entity(tree) |
226 val (typargs, args, List(prop)) = decode_props(body) |
244 val (typargs, args, List(prop)) = decode_props(body) |
227 Axiom(entity, typargs, args, prop) |
245 Axiom(entity, typargs, args, prop) |
228 }) |
246 }) |
|
247 |
229 |
248 sealed case class Fact( |
230 sealed case class Fact( |
249 entity: Entity, |
231 entity: Entity, |
250 typargs: List[(String, Term.Sort)], |
232 typargs: List[(String, Term.Sort)], |
251 args: List[(String, Term.Typ)], |
233 args: List[(String, Term.Typ)], |
256 typargs.map({ case (name, sort) => (cache.string(name), cache.sort(sort)) }), |
238 typargs.map({ case (name, sort) => (cache.string(name), cache.sort(sort)) }), |
257 args.map({ case (name, typ) => (cache.string(name), cache.typ(typ)) }), |
239 args.map({ case (name, typ) => (cache.string(name), cache.typ(typ)) }), |
258 props.map(cache.term(_))) |
240 props.map(cache.term(_))) |
259 } |
241 } |
260 |
242 |
261 def read_facts(db: SQL.Database, session_name: String, theory_name: String): List[Fact] = |
243 def read_facts(provider: Export.Provider): List[Fact] = |
262 read_entities(db, session_name, theory_name, "facts", |
244 provider.uncompressed_yxml(export_prefix + "facts").map((tree: XML.Tree) => |
263 (tree: XML.Tree) => |
245 { |
264 { |
246 val (entity, body) = decode_entity(tree) |
265 val (entity, body) = decode_entity(tree) |
247 val (typargs, args, props) = decode_props(body) |
266 val (typargs, args, props) = decode_props(body) |
248 Fact(entity, typargs, args, props) |
267 Fact(entity, typargs, args, props) |
249 }) |
268 }) |
|
269 |
250 |
270 |
251 |
271 /* type classes */ |
252 /* type classes */ |
272 |
253 |
273 sealed case class Class( |
254 sealed case class Class( |
277 Class(entity.cache(cache), |
258 Class(entity.cache(cache), |
278 params.map({ case (name, typ) => (cache.string(name), cache.typ(typ)) }), |
259 params.map({ case (name, typ) => (cache.string(name), cache.typ(typ)) }), |
279 axioms.map(cache.term(_))) |
260 axioms.map(cache.term(_))) |
280 } |
261 } |
281 |
262 |
282 def read_classes(db: SQL.Database, session_name: String, theory_name: String): List[Class] = |
263 def read_classes(provider: Export.Provider): List[Class] = |
283 read_entities(db, session_name, theory_name, "classes", |
264 provider.uncompressed_yxml(export_prefix + "classes").map((tree: XML.Tree) => |
284 (tree: XML.Tree) => |
265 { |
|
266 val (entity, body) = decode_entity(tree) |
|
267 val (params, axioms) = |
285 { |
268 { |
286 val (entity, body) = decode_entity(tree) |
269 import XML.Decode._ |
287 val (params, axioms) = |
270 import Term_XML.Decode._ |
288 { |
271 pair(list(pair(string, typ)), list(term))(body) |
289 import XML.Decode._ |
272 } |
290 import Term_XML.Decode._ |
273 Class(entity, params, axioms) |
291 pair(list(pair(string, typ)), list(term))(body) |
274 }) |
292 } |
|
293 Class(entity, params, axioms) |
|
294 }) |
|
295 |
275 |
296 |
276 |
297 /* sort algebra */ |
277 /* sort algebra */ |
298 |
278 |
299 sealed case class Classrel(class_name: String, super_names: List[String]) |
279 sealed case class Classrel(class_name: String, super_names: List[String]) |
300 { |
280 { |
301 def cache(cache: Term.Cache): Classrel = |
281 def cache(cache: Term.Cache): Classrel = |
302 Classrel(cache.string(class_name), super_names.map(cache.string(_))) |
282 Classrel(cache.string(class_name), super_names.map(cache.string(_))) |
303 } |
283 } |
304 |
284 |
305 def read_classrel(db: SQL.Database, session_name: String, theory_name: String): List[Classrel] = |
285 def read_classrel(provider: Export.Provider): List[Classrel] = |
306 read_export(db, session_name, theory_name, "classrel", |
286 { |
307 (body: XML.Body) => |
287 val body = provider.uncompressed_yxml(export_prefix + "classrel") |
308 { |
288 val classrel = |
309 val classrel = |
289 { |
310 { |
290 import XML.Decode._ |
311 import XML.Decode._ |
291 list(pair(string, list(string)))(body) |
312 list(pair(string, list(string)))(body) |
292 } |
313 } |
293 for ((c, cs) <- classrel) yield Classrel(c, cs) |
314 for ((c, cs) <- classrel) yield Classrel(c, cs) |
294 } |
315 }) |
|
316 |
295 |
317 sealed case class Arity(type_name: String, domain: List[Term.Sort], codomain: String) |
296 sealed case class Arity(type_name: String, domain: List[Term.Sort], codomain: String) |
318 { |
297 { |
319 def cache(cache: Term.Cache): Arity = |
298 def cache(cache: Term.Cache): Arity = |
320 Arity(cache.string(type_name), domain.map(cache.sort(_)), cache.string(codomain)) |
299 Arity(cache.string(type_name), domain.map(cache.sort(_)), cache.string(codomain)) |
321 } |
300 } |
322 |
301 |
323 def read_arities(db: SQL.Database, session_name: String, theory_name: String): List[Arity] = |
302 def read_arities(provider: Export.Provider): List[Arity] = |
324 read_export(db, session_name, theory_name, "arities", |
303 { |
325 (body: XML.Body) => |
304 val body = provider.uncompressed_yxml(export_prefix + "arities") |
326 { |
305 val arities = |
327 val arities = |
306 { |
328 { |
307 import XML.Decode._ |
329 import XML.Decode._ |
308 import Term_XML.Decode._ |
330 import Term_XML.Decode._ |
309 list(triple(string, list(sort), string))(body) |
331 list(triple(string, list(sort), string))(body) |
310 } |
332 } |
311 for ((a, b, c) <- arities) yield Arity(a, b, c) |
333 for ((a, b, c) <- arities) yield Arity(a, b, c) |
312 } |
334 }) |
|
335 |
313 |
336 |
314 |
337 /* HOL typedefs */ |
315 /* HOL typedefs */ |
338 |
316 |
339 sealed case class Typedef(name: String, |
317 sealed case class Typedef(name: String, |
346 cache.string(rep_name), |
324 cache.string(rep_name), |
347 cache.string(abs_name), |
325 cache.string(abs_name), |
348 cache.string(axiom_name)) |
326 cache.string(axiom_name)) |
349 } |
327 } |
350 |
328 |
351 def read_typedefs(db: SQL.Database, session_name: String, theory_name: String): List[Typedef] = |
329 def read_typedefs(provider: Export.Provider): List[Typedef] = |
352 read_export(db, session_name, theory_name, "typedefs", |
330 { |
353 (body: XML.Body) => |
331 val body = provider.uncompressed_yxml(export_prefix + "typedefs") |
354 { |
332 val typedefs = |
355 val typedefs = |
333 { |
356 { |
334 import XML.Decode._ |
357 import XML.Decode._ |
335 import Term_XML.Decode._ |
358 import Term_XML.Decode._ |
336 list(pair(string, pair(typ, pair(typ, pair(string, pair(string, string))))))(body) |
359 list(pair(string, pair(typ, pair(typ, pair(string, pair(string, string))))))(body) |
337 } |
360 } |
338 for { (name, (rep_type, (abs_type, (rep_name, (abs_name, axiom_name))))) <- typedefs } |
361 for { (name, (rep_type, (abs_type, (rep_name, (abs_name, axiom_name))))) <- typedefs } |
339 yield Typedef(name, rep_type, abs_type, rep_name, abs_name, axiom_name) |
362 yield Typedef(name, rep_type, abs_type, rep_name, abs_name, axiom_name) |
340 } |
363 }) |
|
364 } |
341 } |