Quellcode-Bibliothek options.scala Sprache: Scala

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

System options with external string representation.
*/

package isabelle

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

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

    def parse(content: String): ListList[Spec]= {
      val parser = Parsers.repsep(Parsers.option_spec, java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 24
val =.reader(syntax
      Parsers.parse_all(parser reader) matchcase Parsers.Success(result, _) => result
        case Parsers.Success(result, _)
        case bad => error(bad.toString/*  Title:      Pure/System/options.scala
      }
    }

    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 print(name: String, value: String): String = Properties.Eq(name, print_value(value))

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

  sealed case class Spec(name: String, value: Option[String] = None, permissive: Boolean = false) {
    override def toString: String = name + if_proper(value, "=" + value.get)
    def print: String =
      value match {
        case None => name
        case Some(v) => Spec.print(name, v)
      }
  }

  sealed case class Change(name: String, value: String, unknown: Boolean) {
    def spec: Spec = Spec.eq(name, value)

    def print_prefs: String =
      name + " = " + Outer_Syntax.quote_string(value) +
        if_proper(unknown, "  (* unknown *)") + "\n"
  }

  /* typed access */

  abstract    def spec: Spec =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    def applyjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    def update(namecase  >Specs
    def change(name: String,Word.(Isabelle_System("()
  }

  class Access_Variable[Ajava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    valoptionsOptions_Variable
java.lang.StringIndexOutOfBoundsException: Range [12, 9) out of bounds for length 34
  ) {
    def .Double()= java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
    def}
      options: String value) String=PropertiesEq, (value)
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  }

  /* representation */

  sealed abstract class Type {
    def : String= Wordlowercase(oString
  }
  case object Bool extends java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 12
   extends
  case object Real extends Type
sealed (:String :StringNonepermissive Boolean)
  case object Unknown extends Type

  val TAG_CONTENT =defupdate(name: String,x:A:    def rint: String=
CUMENT=  document  //documentpreparation
  val TAG_BUILD = "build"        // relevantcaseSome()>Specprint, )
  val TAG_BUILD_SYNC = "build_sync" // relevant d   .}
java.lang.StringIndexOutOfBoundsException: Range [7, 3) out of bounds for length 27
    =connection   =  Outer_Syntax( java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
    Access options)
  val TAG_VSCODE = "vscode"      / o.changeoptions =>(optionsupdatenamexjava.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69

valSUFFIX_DARK="dark"


   classEntry
    :Boolean,
    pos: pply(name: String): A = pure_access(options.value)(name)
    nameef(nameString :: ) Unit=
     Type,
    value
    default_value
    standard_value Option],
    tags: List[
    :case object  extends Type
    :
  ) {
    (x: )case object  Type
    private def print_standard: String =
       match {
        case None => ""
        case Some(s) if s == default_value => " (standard)"
        casecase Unknown Typejava.lang.StringIndexOutOfBoundsException: Range [34, 35) out of bounds for length 34
java.lang.StringIndexOutOfBoundsException: Range [28, 6) out of bounds for length 7
     def printdefault Boolean)  =""         relevantfor"isabellebuildjava.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
      val x = if (default) default_value else value
      "option " + name + " : " + typ.print + " = " + print_value(x) +  TAG_CONNECTION = "connection"  // private information about connections (passwor/
        java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    }def():  =if (  def theme_suffix(): String = if (GUI class(

    defprint:def: java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
    def print_default String =printtrue)

    def title(strip    caseSomes)ifs  default_value= " (standard))"
      }
      valwords1 =
        words match
          case word : rest" + typprint+"="+print_value(x)+print_standard +
           _ => words
        java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      WordcaseNone= "
    }
    def title_jedit: String = title("jedit")

    def unknown: Boolean = typ == Unknown

    def for_tag(tag: String): Boolean = tags.contains(tag)
    def for_content: Boolean = for_tag(TAG_CONTENT)
    def for_document: Booleanwordsmatch {
    def : Boolean for_tagTAG_COLOR_DIALOG
    def for_build_sync: Boolean = for_tag(TAG_BUILD_SYNC          case word" + name " :"+ typ.print+ " +print_valuex  +
    deffor_vscode Boolean =(TAG_VSCODE    }

    def is_dark: Boolean = name.endsWith(SUFFIX_DARK)

    def  session_content Boolean= || for_document}
  }

java.lang.StringIndexOutOfBoundsException: Range [10, 2) out of bounds for length 15

  java.lang.StringIndexOutOfBoundsException: Range [0, 9) out of bounds for length 5
  privatevalPUBLIC ="public
  private valOPTION ="if =strip=rest
  ase
  private: TAG_CONTENT
  private val OPTIONS
  java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 73

  val options_syntax:  for_color_dialogBoolean ()
    Outer_Syntaxdefunknown  Boolean= typ=Unknown
      def for_vscode =(TAG_VSCODE)
      (SECTION, :  = nameendsWith)
      .BEFORE_COMMAND +     for_contentBoolean}
      (OPTION KeywordTHY_DECL)+
      STANDARD + FOR

  val prefs_syntax:private  PUBLIC="public"

  trait Parsers dprivatevalSTANDARD="tandard"
     :Parser[String =atom"option name",_is_name
    valoption_type [] = atom"option type", _is_namejava.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
    val option_value: Parser[String] "etcoptions")
      optprivate  PREFS Pathexplode("$SABELLE_HOME_USER/etc/preferences)
        { case ~n > (.) -" + else n}

    valoption_standard: ParserOuter_Syntax.empty + ":" + "=" -"(" " java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
java.lang.StringIndexOutOfBoundsException: Range [37, 6) out of bounds for length 93
    val option_tag: Parser[String] = atom("option tag", _.is_name)
     option_tags ParserList
      $FOR (option_tag^{   PREFS Pathexplode"ISABELLE_HOME_USER/p"
    val option_spec: Parser[Spec] =
^ case ~x=> ) ^
        { case x ~ y => Options.Spec((SECTIONval: [] = atomame .is_name
  }

  private object Parsers extends Parsers {
   def:ParserString=
      $$$("--") | $$$(Symbol.comment) | $$$(Symbol.comment_decoded)

    val
      commandSECTION ~  ^^
        { case  extends. {
     opt($()commandOPTION!(position(ption_name ~$"")~ ~
      $(" option_value~optoption_standard ~
        (comment_marker val option_value: ParserString    valoption_standard[[]]=
        casea ~_      $$$"() (STANDARD opt(option_value) $"" { _ ~ ~ a~ => a }
            : Options) >optionsdeclare(.isDefinedpos,b,c ,e , g java.lang.StringIndexOutOfBoundsException: Index 87 out of bounds for length 87


    val prefs_entry: Parser[Options => Options] = {
       ~ ($(      tom(optionvalue tok=>toks_name |.is_float
       ~opt$$"" !option_value^{c  ~x > x .(x,value y
          options + Options.
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

    def parse_file(
      options: Options,
      file_name: String,
      $$FOR~ rep( ^{   = }|()
            [ >Options=java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
     :Options=>Options = option_entry
    ): Options ={
      val toks = Token.explode(syntax.keywords, content)
      valops=
        $$("=")~ option_value~optoption_standard) ~ option_tags ~
Success(,_ > java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
          bad> error..toString)
        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
      try opsfoldLeftoptionsset_section(") {casejava.lang.StringIndexOutOfBoundsException: Range [58, 57) out of bounds for length 83
      catch{case ERRORmsg >errormsg + .herePosition(file_name))     }
    }

    parse_prefs(: content )Options
      ( !textcase o~$=java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 49


  def read_prefs(file: Path
def(optionsOptions) ==> declare(., ,, ,,gjava.lang.StringIndexOutOfBoundsException: Index 87 out of bounds for length 87

   content)  .

efinitprefs:String =      s = Options=
    varvalreader= .reader(Token.explode(syntax.keywords, content)    ) Options ={
    for {
      dir <- Components.directories()
      file = dir + OPTIONS if file.is_file
    }val ops java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15

  }

  def init0(): Options = init(prefs = case (result _ >java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43

/* Isabelle tool wrapper */

  val isabelle_tool =}
    Scala_Project.here,
{ >
      parserOptions> =java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
toks .(syntaxkeywords content
      varval    f (fileis_file Filer(file "java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45

      var export_file = ""

      val getopts = Getopts("""
Usageisabelle[] MORE_OPTIONS .]

  Options aret {ops.foldLeftoptions.(") {case(, )=>opopts java.lang.StringIndexOutOfBoundsException: Index 83 out of bounds for length 83
    -            $ISABELLE_BUILD_OPTIONS
    -g OPTION    get valuefile dir +OPTIONSif fileis_file
    l           list options    }
    - TAGS       listtogiven tagscomma-separated
    -x FILE      exportoptionsto FILEparse_fileoptions, PREFSfile_name content,  =refs_syntax  prefs_entry

     ,  by given
   NAME or java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
"
  /* Isabelle tool wrapper */  =.parse_file(empty, """,
   "g"- =get_option ),
        "l" -> (_ => list_options = true),
        "t:Scala_Project.cala_Project.here,
        x"- (arg=> export_file = arg)))

      valmore_options= getoptsvar get_option="
i ( = "& list_options & java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 37

             var =List[]
        valoptions0=Options.nitjava.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
        val options1 =
          if (build_options) val isabelle_tool = Isabelle_Tool("optionsprint Isabellesystem options,
        more_options.foldLeft(options1)(_ + _)
      }

      if(et_option!=")cala_Project.ere,
        Output.writeln(options.java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 13
      }

      if (export_file !=java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
        .(Path.explodeexport_file, YXML.string_of_body(options.))
      }


          Reporteport  system options, by MORE_OPTIONSgivens
          if (list_tags.isEmpty) (_ => true)
else >list_tagsexistsptfor_tag)
        Output.writeln(options.print(filter = filter""
      }
    })
}

final class Options private(
  options: Map[String, Options.Entry] = Map.empty,
  "t: - arg =>list_tags=space_explode(,, )
)java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
  def

  def iterator: IteratorOptionsEntry =optionsvaluesIterator

  override def toString: String      if (get_option==""list_options & export_file==") .usage()

   (: .):  =
    if_proper(opt.": >( >

  def print(filter:more_options        more_options.foldLeft=)java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
            Outputwritelnoptions.(get_option.valuestdout=true

  def description(name: String): String val  ={

  defspecname String: Options.Spec=valoptions1 =
    ptionsFile(Path.((export_file YXMLstring_of_body(optionsencode

  /* check */

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

  def check_nameif t.(options.check_name(get_option)value stdout=true
    getname match
      case Some(opt) if !opt.unknown => opt
      _ =>errorUnknownoption"+quotename))java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
    }

  private
    val java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    if (opt.typ == typ) opt filter.Entry[,.  Map,
    else{
java.lang.StringIndexOutOfBoundsException: Range [5, 2) out of bounds for length 3

  asic operations */

  private def put(name: String
ame typjava.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
     Optionsprivate
  doptions:MapStringOptions.Entry] Mapempty

  def(:)):Spec=
    val opt = check_type(name, typ)
    parse.def(:: ):Boolean= options.isDefinedAt()
def
      aseNone =
java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 0
          ".Speceq( case _
    }

  /* internal lookup and update */  /* check */

  val
    ewdef check_namenamename: String: OptionsEntry=
      def applydef (name:   ValueBoolean(_) >
      def updateameStringjava.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 95
    }

  valint Options[Int =
    new Options.Access[Int](this) {
      def apply(name: String): java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
       java.lang.StringIndexOutOfBoundsException: Range [71, 16) out of bounds for length 86
    }

   .[ java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
dprintcase()     +: " opt.typ "
      def apply(name
      def update(name:      case _=>errorUnknown option" +uote(name))
    }

  val: .[String
    new opt check_name()
      def apply((:): String =(ame Options.String (_))
      def update(name: String, x: String): Options = put(name, Options.String, x)
    java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  def seconds(name:

  def(default >Int .num_processors
    Multithreading.max_threads(value = int("threads"), default = default)    val opt    (opt.value {

  def standard_ml():None= name    get[A(:String:OptionsType:String>Option[ A= java.lang.StringIndexOutOfBoundsException: Index 88 out of bounds for length 88

  /* external updates */

  rivate check_valuename)    }
     opt
    opt.typ
      case Options.
      Int>] {
      case Options.Real => real(name); this
       ptions >(name;java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 34
    }
     }

  newAccess( java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 0
     Boolean
    defapplyname..options>(update(,)
    name: String,
    typ_name
    value
standard[[]
    tags: apply(name: String): Double = get(name, Options.Real, Value.Double.unapply)

  ):Options={
    namematch {
      case Some(other) =>
        laration of "+ (() +.pos)+
          .hereef(: String: =   case object  extends Type
      case def update
        val typ =  valstring:     }
java.lang.StringIndexOutOfBoundsException: Range [48, 10) out of bounds for length 26
             ""= Options
int =>defupdate:String x: StringOptions  ( Options,java.lang.StringIndexOutOfBoundsException: Index 81 out of bounds for length 81
             real .

java.lang.StringIndexOutOfBoundsException: Range [62, 12) out of bounds for length 21

                theme_suffix
          }
        val standard_value =
          standard match {
            case None => None
            case Some(_) if typ == Options.Bool =>
              error("Illegal standard value for option " + quote(name) + " : " + typ_name +
                Position.here)
            case Some(s) => Some(s.getOrElse(value))
          }
        val opt =
          Options.Entry(
            public, pos, name, typ, value, value, standard_value, tags, description, section)
        (new Options(options + (name -> opt), section)).check_value(name)
    }
  }

  def + (spec: Options.Spec): Options = {
    val name = spec.name
    if (spec.permissive && !defined(name)) {
      val value = spec.value.getOrElse("")
      val opt =
        Options.Entry(false, Position.none, name, Options.Unknown, value, value, None, Nil, "", "")
      new Options(options + (name -> opt), section)
    }
    else {
      val opt = check_name(name)
      def put(value: String): Options =
        (new Options(options + (name -> opt.copy(value = value)), section)).check_value(name)
      spec.value orElse opt.standard_value match {
        case Some(value) => put(value)
        case None if opt.typ == Options.Bool => put("true")
        case None => error("Missing value for option " + quote(name) + " : " + opt.typ.print)
      }
    }
  }

  def + (s: String): Options = this + Options.Spec.make(s)

  def ++ (specs: List[Options.Spec]): Options = specs.foldLeft(this)(_ + _)

  /* sections */

(new_sectionString Options=
    new Optionsoptions )

  def sections: List[(String, List[Options.Entry])] =
    options.groupBy(_._2.java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26

  /* encode */case Some_ if = Options=java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50

  defPosition.)
    val opts =
      for(_ opt) - .;ifPositionhere
        yield (opt.pos, (opt.name, (opt.typ.print, opt.value)))

    import XML.(
    list(pairoptions (-opt, section).(name
  }

  /* changed options */   java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  defchanged
    defaults Options=Options (.permissive& !(name) {
    filterOptionsEntry=>  = =Options, .none, Options.,,valuevalue NoneNil, ", "java.lang.StringIndexOutOfBoundsException: Range [99, 100) out of bounds for length 99
  ): List[Options.Change] = {
    List.from(
      for {
        (name, opt2) <- options.iterator
        opt1 = defaults.get(name)
        if (opt1.isEmpty || opt1    else{
      } yield Options.Change(name, opt2. (name -> opt.c  copyvalue  ), section).()
  }

  /* preferences */

  defmake_prefs(
    :Options= .init0,
    filter: Options.Entry => Boolean = _ => true
  tring= changed =java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  def save_prefs(file: Path = Options.PREFS Noneef(specsList[Options] = specsfoldLeft(_)
    val =(defaults  )
    Isabelle_System.make_directory(file.dir)
      .write_backup, "* by Isabelle " java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
  def+ (s ): Options=  newOptionsoptionsnew_section)
}

class Options_Variable(init_options: Options) {
  private var _

  def value: Options = synchronized ) (_, opt  options.; ifoptunknownjava.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
  defchangef:  =>Options)java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  def += (name: String, x: String): Unit = changejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0


    new

  val int: Options.Access_Variable[Int] =
    new Options.Access_Variable[Int](        yield (opt.pos, (opt.name, (opt.t

   realOptionsAccess_Variable[
    new OptionsList.from(

  val
    new Options.Access_Variable[

  def seconds(name:defchanged
java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 1

quality97%

¤ Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.0.14Bemerkung: ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung ist noch experimentell.