1 /* Title: Pure/Thy/thy_header.scala
4 Static theory header information.
10 import scala.annotation.tailrec
11 import scala.collection.mutable
12 import scala.util.parsing.input.{Reader, CharSequenceReader}
13 import scala.util.matching.Regex
15 import java.io.{File => JFile}
18 object Thy_Header extends Parse.Parser
22 val IMPORTS = "imports"
23 val KEYWORDS = "keywords"
29 Scan.Lexicon("%", "(", ")", "::", ";", AND, BEGIN, HEADER, IMPORTS, KEYWORDS, THEORY, USES)
32 /* theory file name */
34 private val Base_Name = new Regex(""".*?([^/\\:]+)""")
35 private val Thy_Name = new Regex(""".*?([^/\\:]+)\.thy""")
37 def base_name(s: String): String =
38 s match { case Base_Name(name) => name case _ => error("Malformed import: " + quote(s)) }
40 def thy_name(s: String): Option[String] =
41 s match { case Thy_Name(name) => Some(name) case _ => None }
46 val header: Parser[Thy_Header] =
48 val file_name = atom("file name", _.is_name)
51 atom("outer syntax keyword kind", _.is_name) ~ tags ^^ { case x ~ y => (x, y) }
53 rep1(string) ~ opt(keyword("::") ~! keyword_kind ^^ { case _ ~ x => x }) ^^
54 { case xs ~ y => xs.map((_, y)) }
56 keyword_decl ~ rep(keyword(AND) ~! keyword_decl ^^ { case _ ~ x => x }) ^^
57 { case xs ~ yss => (xs :: yss).flatten }
60 keyword("(") ~! (file_name ~ keyword(")")) ^^ { case _ ~ (x ~ _) => (x, false) } |
61 file_name ^^ (x => (x, true))
65 (keyword(IMPORTS) ~! (rep1(theory_name)) ^^ { case _ ~ xs => xs }) ~
66 (opt(keyword(KEYWORDS) ~! keyword_decls) ^^ { case None => Nil case Some(_ ~ xs) => xs }) ~
67 (opt(keyword(USES) ~! (rep1(file))) ^^ { case None => Nil case Some(_ ~ xs) => xs }) ~
69 { case x ~ ys ~ zs ~ ws ~ _ => Thy_Header(x, ys, zs, ws) }
71 (keyword(HEADER) ~ tags) ~!
72 ((doc_source ~ rep(keyword(";")) ~ keyword(THEORY) ~ tags) ~> args) ^^ { case _ ~ x => x } |
73 (keyword(THEORY) ~ tags) ~! args ^^ { case _ ~ x => x }
77 /* read -- lazy scanning */
79 def read(reader: Reader[Char]): Thy_Header =
81 val token = lexicon.token(_ => false)
82 val toks = new mutable.ListBuffer[Token]
84 @tailrec def scan_to_begin(in: Reader[Char])
87 case lexicon.Success(tok, rest) =>
89 if (!tok.is_begin) scan_to_begin(rest)
95 parse(commit(header), Token.reader(toks.toList)) match {
96 case Success(result, _) => result
97 case bad => error(bad.toString)
101 def read(source: CharSequence): Thy_Header =
102 read(new CharSequenceReader(source))
104 def read(file: JFile): Thy_Header =
106 val reader = Scan.byte_reader(file)
107 try { read(reader).map(Standard_System.decode_permissive_utf8) }
108 finally { reader.close }
113 sealed case class Thy_Header(
114 name: String, imports: List[String],
115 keywords: List[Outer_Syntax.Decl],
116 uses: List[(String, Boolean)])
118 def map(f: String => String): Thy_Header =
119 Thy_Header(f(name), imports.map(f), keywords, uses.map(p => (f(p._1), p._2)))