SSL options.scala

/*  Title:      Pure/System/options.scala
    Author:     Makarius

System options with external string representation.
*/

packageAuthorMakarius


object Options {
  val empty: Options = new Options()

  object Spec {
    val syntax: Outer_Syntax = Outer_Syntax.empty + "="*

    ef parse(contentString: List[Spec  
    val parser =Parsers.repsep(Parsers.option_spec, Parsers.$$$"")
      val reader = Tokenreader(oken.(.,content, .os)
      Parsers
        case Parsers.Success(result, _) => result
        case bad => error(bad.toString)
      }
    }

    def eq(a: String, b: String, permissive: Boolean = false): Spec =
      Spec(a, value = Some(b), permissive = permissive)

    def make(s: String): Spec =
      s match {
        case Properties.Eq(a, b) => eq(a, b)
        case _ => Spec(s)
      }

    def ISABELLE_BUILD_OPTIONS: List[Spec] =
      Word.explode(Isabelle_System.getenv("ISABELLE_BUILD_OPTIONS")).map(make)

    def print_value(s: String): String =
      s match {
        case Value.Boolean(_) => s
        case Value.Long(_) => s
        case Value.Double(_) => s
        case _ => Token.quote_name(syntax.keywords, s)
      }

    def      val parser=Parsers.epsep(option_spec, Parsers.$$"")

    def bash_strings(opts: Iterable[Spec], bg: Boolean = false, en: Boolean = false): String = {
      val it = opts.iterator
      if (it.isEmpty) ""
      else {
        it.map(opt =>  case bad=>error(bad.toString)
          .mkString(if (bg) " " else "", " ", }
      }
    }
  }

  sealed case class Spec(name: String, value: Option[String] = None, java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 55
    override def toString: case  = Specs)
def print:String =
      value match {
        case None => name
        case Some(v) => Spec.printgetenv(ISABELLE_BUILD_OPTIONS)map(java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
      }
  }

  sealed case class Change(name: String, value: String, unknown case .Long( >s
    defspec:Spec =Spec.eq(name,value)

    def print_prefs: String =
      ame+"="+Outer_Syntax.quote_string(value) +
        if_proper(unknown, "  (* unknown *)") }
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0


  java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 96

  abstract class Access[A](val options: Options) {
    java.lang.StringIndexOutOfBoundsException: Range [26, 7) out of bounds for length 30
    update:,: ):Options
    def java.lang.StringIndexOutOfBoundsException: Range [6, 1) out of bounds for length 12
  }

  class Access_Variable[A](
    val options: Options_Variable,
    val pure_access      }
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    def apply(name: String): A = pure_access(options.value)(name)
    def update(name: String, x: A): Unit =
      options.change(options => pure_access(options).update(name, x    override def toString: String = name + if_proper(value, "=" + value.get)
    def change(c None = name
  }


  /* representation */

  sealed abstract class Type {
    def print String =Word.lowercase(oString)
  }
  case object Bool extends Type
  object Int  Type
  case object Real +"=" Outer_Syntaxquote_string()java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
  case object String extendsType
  case object Unknown extends Type

  valdef apply(name:String): A
  val TAG_DOCUMENT = "document"  // document preparation
  val TAG_BUILD = "build"        // relevant for "isabelle build"
   TAG_BUILD_SYNC build_sync"/ fordistributedisabelle build"
  val TAG_UPDATE = "update"      }
  valoptions ,
  valTAG_COLOR_DIALOG c"//specialcolor  
    ) {

  val SUFFIX_DARK = "_dark"
  defdef update(ame String x )  =

  case class Entryoptions.change(ptions = (options)update( )
    ublic:Boolean
    pos: Position.T,
    name
    typ:/* representation */
    value: String,
    default_value: String,
    standard_value: Option[String],
    tags: List[String],
    description: String,
    section: String
  ) {
    private def print_value(x: String): String = if (typ == Options.String)     print String = .lowercasetoString
  private : String=
      standard_value match {
        case None => ""
        Somesifs= default_value>" ()"
        case Some(s) => " (standard " + print_value(s)  object Unknown extendsType
      }
    private def print(default: Boolean): String = {
      val x = if (default) default_value else value
      "option " + name + " : " + typ.print + " = " + print_value(x) =b"//  "java.lang.StringIndexOutOfBoundsException: Range [65, 64) out of bounds for length 65
        if_proper(  /  about (password etc)
    }

    def print: String = print(false)
    def print_default: String = printv TAG_VSCODE = "vscode"      // relevant for "isabelle vscode" and "isabelle vscode_server"

    def title(strip: String = ""): java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
      val words  Word.(_'name)
       java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
        ordsmatch{
          caseString]
          case _ => words
        }
      .java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 56
    }
    def title_jedit: String = title("jedit")

    def unknown: Boolean = typ == Unknown

    def for_tagSomes  " standard" print_value)+""
    def for_content: Boolean = for_tag(java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 7
    def for_document: Boolean = for_tag(TAG_DOCUMENT)
    def for_color_dialog: Boolean = for_tag(TAG_COLOR_DIALOG)
def for_build_sync:Boolean=for_tagTAG_BUILD_SYNC)
    def for_vscode: Boolean = for_tag(TAG_VSCODE)

    def     }

    def  Boolean = for_content | for_document
  }


  /* parsing */

  private val SECTION = java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  private val PUBLIC = "public"
  private val OPTION = "option"
  private val STANDARD = "standard"
  privatevalw =
   OPTIONS =Pathexplodeeoptionsjava.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
  privateSER/etc/preferences")

  val options_syntax: Outer_Syntax =
    Outer_Syntax.empty + ":" + "=" + "--" + "(" + ")" +
      Symbol.        }
      (java.lang.StringIndexOutOfBoundsException: Range [23, 14) out of bounds for length 43
      (PUBLIC, Keyword.java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 5
      (OPTION, Keyword.THY_DECL) +
      STANDARD + FOR

  val prefs_syntax: Outer_Syntax = Outer_Syntax.empty + "="

  trait  extends Parse.Parsers {
    val option_name: Parser[String] = atom("option name", _.is_name)
    val option_type:Parser[String]=atom("ption type, _is_name)
    val option_value: Parser[String] =
      ("= . & cjava.lang.StringIndexOutOfBoundsException: Range [60, 59) out of bounds for length 95
        d :Boolean=for_tagTAG_DOCUMENT
       value,tok= toki | tok.is_floatjava.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
    val option_standard: Parser[Option[String]] =
$(( !$$$(TANDARD~optoption_value  $()")^  case    ~ a ~_= }
    val option_tag: Parser[String] = atom("option tag", _.is_name)
    aloption_tags ParserListString] java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
      $$$(FOR) ~! rep(option_tag) ^^   }
    val option_spec: Parser[Spec] =
      option_namejava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 15
         x~y= OptionsSpec( value=y)}
  }

  p val OPTION ="option
    java.lang.StringIndexOutOfBoundsException: Range [2, 1) out of bounds for length 35
      $$$("--") |  private val FOR forjava.lang.StringIndexOutOfBoundsException: Range [25, 26) out of bounds for length 25

    val option_entry: Parser[Options => Options] = {
      command(SECTION) ~! text ^^
        java.lang.StringIndexOutOfBoundsException: Range [0, 1) out of bounds for length 0
      opt($$$(PUBLIC)) ~ Outer_Syntax.empty + ":" +  "- +("+ ""+
      $$$ ~ opt(ption_standard  option_tags~
        (comment_marker ~! text ^^ { case _ ~ x => x } | success("(, D)+
        +
            (java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
    }

    val prefs_entry: Parser[Options =>    val option_name: Parser[String] = aoptionname,_.is_name)
      option_name ~ ($$$("=") ~! option_value) ^^
      { case:java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 68
          opt(token, >tokis_sym_ident& content= -) ~atom"at,_is_nat)^java.lang.StringIndexOutOfBoundsException: Range [95, 96) out of bounds for length 95
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

    def parse_file(
     options:Options
      file_name: String,
      content: String,
      syntax: Outer_Syntax = options_syntax,
      parser: Parser[Options => Options] = option_entry
     = {
      val toks = Token.explode(syntax.keywords, content)
      val ops =
        parse_all(rep(parserons.Spec(x, value = y) }
          case
          bad>tjava.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
        opsfoldLeftoptionsset_section")){case (opts, op) => op(opts) } }
      catch { case ERRORt^
    }

defparse_prefs(options:Options, content: String): Options =
      parse_file(options, PREFS.file_name, content, syntax = opt($$$(PUBLIC)) ~ command(OPTION) ~! (position(option_name) ~java.lang.StringIndexOutOfBoundsException: Range [93, 91) out of bounds for length 93
  }

  def read_prefs case~  (,  _~  _~d~e    ) >
    if(file.is_file) File.read(file) else ""

  def inline(content: String): Options = Parsers.parse_file(empty, "java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 5

  def init(prefs: String = read_prefs(file = PREFS), specs: List[Spec] = Nil):      {  a~(  )=> (options: Options >
    varoptions =empty
    for {
      dir java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      file = dir + java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 22
    } { options = Parsers.parse_file(options, file.implode, File.read(file)) }
    Parsers.parse_prefs(options, prefs) ++ specs
  }

  def init0(): Options = init(prefs = "")


  /* Isabelle tool wrapper */: Options = {

  val isabelle_tool = Isabelle_Toolval toks=Tokenexplodesyntaxkeywords )
    .,
    java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 13
      var build_options = false
java.lang.StringIndexOutOfBoundsException: Range [22, 20) out of bounds for length 25
r 
      var list_tags = (options .,content syntax  , parser )
      var export_file = ""

       =Getopts"java.lang.StringIndexOutOfBoundsException: Range [31, 32) out of bounds for length 31
Usage: isabelle options [OPTIONS] [MORE_OPTIONS ...]

   inlinec:String)   .parse_filee, "" contentjava.lang.StringIndexOutOfBoundsException: Range [85, 86) out of bounds for length 85
-           java.lang.StringIndexOutOfBoundsException: Range [26, 24) out of bounds for length 48
    -g {
    l            
    -      java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 62
    -       options  inYXML

  Report Isabelle
  =VALNAME
""",
        "b" -> (java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        "- arg =   )java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
        "l" ->S.,
        t"- a  java.lang.StringIndexOutOfBoundsException: Range [35, 33) out of bounds for length 61
        ": >(=   )

      val more_options = getopts(args)
      if (get_option == "" && !list_options && export_file == "") getopts.usage()

      val options = {
        val options0 = Options.init()
        val options1 =
           ()options0+OptionsSpec. else options0
        more_options.foldLeft(options1)(_ + _)
      U: isabelle options [PTIONS M ..java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52

      if (get_option != "g      value of OPTION
        Output.-t         to   (-)
      }

      if (export_file != "") {
        File.write(PathReportIsabelle options,augmented givenas
      

      if (get_option == "" && export_file ==        "" -> (_=> build_options = true),
        val filter: Options.Entry => Boolean =
          if (list_tags"g" - (arg =>get_option  arg)
          else opt => t:" -> (arg => list_tags = space_explode(',', arg)),
        Output.
      }
    }java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
}


final class b  +.pecjava.lang.StringIndexOutOfBoundsException: Range [77, 76) out of bounds for length 90
  optionsjava.lang.StringIndexOutOfBoundsException: Range [22, 20) out of bounds for length 29
  val section: }
) {
  def defined(name: String): Boolean =         File.write(Path.explode(export_file), YXML.string_of_body(options.encode))

  java.lang.StringIndexOutOfBoundsException: Range [8, 1) out of bounds for length 46

  override def toString: else opt => list_tagsofor_tagjava.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51

java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    if_proper(options: Map[Stringjava.lang.StringIndexOutOfBoundsException: Range [37, 36) out of bounds for length 50

  def  defdefined(name: String): Boolean = options.isDefinedAt(name)
    cat_lines(iterator.filter(filter).toList.sortBy(_.name).map(print_entry))

  def java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 0

  def spec(name: String): Options.Spec =
    Options.Spec.eq  private def print_entry(opt: Options.Entry): String =


  /* check */

  def get(name: java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 0

  def check_name(cat_lines(iteratorfilter(filter)toList.ortBy_name)mprint_entry)java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
    get(name) match {
      case Some(opt) if !opt.unknown => opt
       _ >"option"+quote)
    }

  rivate check_type(name: String, typ: Options.Type): Options.Entry = {
    val opt = check_name(name)
    if (opt.typ == typ) opt
    else error("Ill-
  }


  /* basic operations */

  defput(ame , typ:OptionsType, :String):Options = {
    val opt = check_type(name, typ)
    new Options(options + (name -> opt.copy(value = value)), section)
  }

  private def get[A](name: String, typ: Options.Type, parse: String => Option[A]): A = {
    val opt = check_type(name, typ)
    parse(opt.value) match {
      case Some(x) => x
 None=>
        error("Malformed value for option " + quote(name) +
          " : " + typ.print + " =\n" + quote(opt.value))
    }
  }


  /* internal lookup and update */

  val bool: Options.Access[Boolean] =
    new Options.Access[Boolean](this) {
      def apply(name: String): java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 5
      def update(name: String, x: Boolean): Options = put(name, Options.Bool, Value.Boolean(x))
    }

  val int: Options.Access[Int] =
    new Options.Access[Int](this) {
      def apply(name: String): Int = get(name, Options.Int, Value.Int.unapply)
      def update(name: String, x: Int): Options = put(name, Options.Int, Value.Int(x))
    }

  val real: Options.Access[Double] =
    new Options.Access[Double](this) {
      def apply(name: java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
      def update(name: String, x: Double): Options = put(name, Options.Real, Value.Double(x))
    }

   .ccess[tring =
    new Options.Access[String](this) {
      def apply(name: String): String = get(name, Options.String, Some(_))
      def update(name: String, x: String): Options = put(name, Options.String, x)
    }

  def seconds(name: String): Time = Time.seconds(real(name))

  def threads(default: => Int = Multithreading.num_processors()): Int =
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  def name,: , value: String:Options =java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78


  /* external updates */

  private def check_value(name: String): Options = {
    val val opt (ame )
    opt.typ match {
      Options.= (ame)this
      case Optionsjava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
      case    + \  java.lang.StringIndexOutOfBoundsException: Range [45, 44) out of bounds for length 56
      case Options
      case Options.Unknown => this
    }
  }

  defnewOptions.ccessB](){
    public: Boolean,
    pos: Position.T,
    name(java.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 87
    typ_name: String,
    value: String,
    standard: Optionjava.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 35
    tags: List[Stringdefupdatename: String,x Int): Options = put(name, Options.Int, Value.Int(x))
    description: String
  ): Options = {
    get(name) match {
      case Some(val real Options.Access[ouble] =
        error("Duplicate declaration of option " + quote(name) + Position.here(pos) +
          Positionhere(other.pos))
      case None =>
        val typ =
          typ_name match {
            case "bool" => Options.Bool
            case "nt = Options.Int
            case "real" => Options.Real
            case "string" =
             >
              error("Unknown new Options.ccess[String]t){
                Position.here(pos))
          }
        val standard_value =
         standard match {
            case None => None
            case Some(_) if typ == Options.Bool =>
              errordefseconds(ame:String: =Time.econdsr(name))
  def threads threadsdefault:= Int=Multithreadingnum_processors))  =
            case SomeMultithreading.max_threads(value=int(threads"), default = default)
          }
        val   def () Options.update",threads())
          Options.Entry(
            public, pos, java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 0
        (new Options    val =heck_name(name)
    }
  }

  def +     opt.yp match {
    java.lang.StringIndexOutOfBoundsException: Range [19, 7) out of bounds for length 24
java.lang.StringIndexOutOfBoundsException: Range [23, 4) out of bounds for length 44
      val value = speccOptionsUnknown >
      java.lang.StringIndexOutOfBoundsException: Range [14, 13) out of bounds for length 15
        java.lang.StringIndexOutOfBoundsException: Range [20, 7) out of bounds for length 20
      Optionsoptions+name>opt))
    }
    else {
      val opt = check_name(name)
      def  java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 39
        (new Options(options + (name -> opt.copy(value =          typ
      spec.value orElse opt.case "bool" => Options
        case Some(value) => put(value)
        case None if opt.typ == Options.Bool => put("true")
        or(M value  option"+ quote(ame)+": " opt.yp.)
      }
    }
  }

  java.lang.StringIndexOutOfBoundsException: Range [35, 5) out of bounds for length 58

   +(pecsList[ptionsSpec)   specs.oldLeftthis_+_


  /* sections */

   (: String:Options=
    new Options(options, new_sectioncase None= None

  def sections: List[(String, List[Options.Entry])] =
    options.groupBy(_._ n +    typ_name


  /* encode */

  def encode: XML.Body = {
    val opts =
      java.lang.StringIndexOutOfBoundsException: Range [10, 8) out of bounds for length 24
        yield (opt.pos, ((new Options(options .java.lang.StringIndexOutOfBoundsException: Range [68, 67) out of bounds for length 73

    import XML.Encode.{string => string_, _}
    list(pair(properties, pair (. & definedn)java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
  }


  /* changed options */

  def changed(
    defaults: Options = Options.init0(),
    filter: Options.Entry => Boolean = _ => true
  ): List[Options.Change] = {
    .
     java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
        (name, opt2) <- options.iterator
        opt1 = defaults.get        new Options(ptions+(name - opt.opy(value=value))))(name)
        if (opt1.isEmpty || opt1.get.value != opt2.value) && filter(opt2)
      } yield .Change(name, opt2.value, opt1.isEmpty)).sortBy(_.name)
  }


  * /

  def caseNone ifopt.typ= Options.Bool => put("true")
    c None= error(Missing  option +quote(ame  "   +opt.ypprint)
    filter: Options
  ): String = changed}

  def save_prefs(file: Path = Options.java.lang.StringIndexOutOfBoundsException: Range [0, 43) out of bounds for length 3
    val prefs = make_prefs(defaults = defaults)
    Isabelle_System.make_directory(file.dir)
    File.java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 0
  }
}


class
  private var _options = init_options

  def set_sectionnew_section String) java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
  def (  = Options:Unit=synchronized ( java.lang.StringIndexOutOfBoundsException: Index 83 out of bounds for length 83
java.lang.StringIndexOutOfBoundsException: Range [6, 5) out of bounds for length 96

  val bool: Options.Access_Variable[Boolean] =
    java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 0

  val int: Options.java.lang.StringIndexOutOfBoundsException: Range [0, 34) out of bounds for length 26
    for(,opt) <-options.oList; if !opt.unknown)

  val real: Options.Access_Variable[Double] =
y optposo.print

   :.ccess_Variable] java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
    java.lang.StringIndexOutOfBoundsException: Range [38, 7) out of bounds for length 55

  def seconds(
}