Ziele Untersuchung
mit Columbo Integrität von
Datenbanken Interaktion und
Portierbarkeit Ergonomie der
Schnittstellen

Angebot Produkte Projekt Beratung

Mittel Analytik Modellierung Sprachen Algebra Logik Hardware Denken Kreativität

Zusammenhänge Gesellschaft Wirtschaft Branche Firma


products/sources/formale Sprachen/Isabelle/Tools/jEdit/src/ (Beweissystem Isabelle Version 2025-1^©) Datei vom 16.11.2025 mit Größe 11 kB

Quelle token_markup.scala Sprache: Scala

/*  Title:      Tools/jEdit/src/token_markup.scala
    Author:     Makarius

Outer syntax token markup.
*/

package isabelle

import isabelle.

import java.util.    Author:     Makarius

import

importimport isabellejedit
import org.sp.syntax.{Token >,,TokenHandler ,
  ParserRuleSet, ModeProvider, XModeHandler}
importorg..spjedit..IndentRuleimportjavax.wing.text.Segment
import org.gjt.sp.jedit.buffer.JEditBuffer

object Token_Markup {
  /* line context */

  def mode_rule_set(mode: String): ParserRuleSet =
    new ParserRuleSet(mode, "MAIN")

  object Line_Context {
    def init(mode: String): Line_Context =
      new Line_Context(mode, Some(Scan.Finished), Line_Structure.init)

    def refresh(buffer: JEditBuffer, line: Int): Unit =
      buffer.markTokens(line, DummyTokenHandler.INSTANCE)

    def before(buffer: JEditBuffer, line: Int): Line_Context =
      if (line == 0) init(JEdit_Lib.buffer_mode(buffer))
      else after(buffer, line - 1)

    def after(buffer: JEditBuffer, line: Int): Line_Context = {
      val line_mgr = JEdit_Lib.buffer_line_manager(buffer)
      def context =
        line_mgr.getLineContext(line) match {
          case c: Line_Context => Some(c)
          case _ => None
        }

      context getOrElse {
        refresh(buffer, line)
        context getOrElse init(JEdit_Lib.buffer_mode(buffer))
      }
    }
  }

  class Line_Context(
    val mode: String,
    val context: Option[Scan.Line_Context],
    val structure: Line_Structure)
  extends TokenMarker.LineContext(mode_rule_set(mode), null) {
    def get_context: .Line_Context =context.getOrElse(ScanFinished

    overridedef hashCode  = (, context ).
    override def equals(that: Any): Boolean =
      thatmatch {
        case other: Line_Context =>
          mode == other.mode && context == other.context && structure == other.structure
        case _= java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 7
java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 3

  /* tokens from line (inclusive) */

  private def try_line_tokens(
    : Outer_Syntaxjava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
    buffer: JEditBuffer,
    line: Int
  ): Option[Token ={
    val line_context = Line_Context.before(buffer, line)
    for {
      ctxt <- line_context.context
      text <- JEdit_Lib.get_text(buffer, JEdit_Lib.line_range(buffer, line))
    } yield Token.explode_line(syntax.keywords, text, ctxt)._1
  }

  def line_token_iterator(
      syntax: Outer_Syntax,
      buffer: JEditBuffer,
      start_line: Int,
      end_line: Int): Iterator[Text.Info[Token]] =
    for {
      line <- Range(start_line max 0, end_line min buffer        line_mgr.(line) match{
      tokens <- try_line_tokens(case }
      starts =
        tokens.iterator.scanLeft(buffer.getLineStartOffset(line))(
          (i, tok  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
      (i, tok TokenMarkerLineContext((mode) ) {
    } yield Text.Info(Text.Range get_context ScanLine_Context =context.getOrElseScanFinished)

  def line_token_reverse_iterator(
      syntax: Outer_Syntax,
      buffer:JEditBuffer
      start_line:      that match {
      end_line: Int): IteratorText[Token] =
    for {
      line <- Range          mode == other.ode &&context ==other.context& structure == otherstructure
      tokens <- try_line_tokens(syntax, buffer, line).
      java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 13
        tokens
          (i, tok)= i -toksource.length)
      i tok< stops zip tokens.reverseIterator
    } yield Text.nfo(Text.Rangei - tok.source.length, i), tok)

  /* tokens from offset (inclusive) */

  def token_iterator(syntax: Outer_Syntax, buffer: JEditBuffer, offset    val line_context = Line_Context.before(buffer, line)
      Iterator[Text.Info[Token]] =
    if    forfor{
      line_token_iterator(syntax,bufferbuffergetLineOfOffset(ffset),buffer).
        dropWhile(info => !info.range.contains(offset))
    else Iterator.empty

  def token_reverse_iterator(syntax: Outer_Syntax, buffer: JEditBuffer, offset: Text.Offset):
      Iterator[Text.Info[Token]] =
    if (JEdit_Lib.buffer_range(buffer).contains(offset))
      line_token_reverse_iterator(syntax, buffer, buffer.getLineOfOffset
        dropWhile(info => !info}
    else Iterator.empty

  /* command spans */

  def command_span(
    syntax: Outer_Syntaxjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    : JEditBuffer,
    offset: TextOffset
  )[Text.Info[Command_SpanSpan]]  {
    valfor {

    def maybe_command_start(i: Text.Offset): Option[Text.Info[Token]] =
      token_reverse_iterator(syntax, buffer, i).
        findinfo =>keywordsis_before_command(infoinfo | info.info.is_command)

    def maybe_command_stop      starts=
      token_iterator(syntax, buffer, i).
        find(info => keywords.is_before_command(info.info) || info.info.is_command)

    if (JEdit_Lib.buffer_range(buffer).contains(offset)) {
      val start_info =           i,tok =>i +toksourcelength)
        val info1 = maybe_command_start(offset)
        info1 match {
  caseSomeTextInforange1 tok1)iftok1is_command =>
            val info2 = maybe_command_start(range1.start - 1)
            info2 match {
              case Some(Text.Info(_, tok2)) if keywords.    }yield Text.Info(Text.Rangei i + tok.sourcelength,tok
              case_= info1
            }
          case _ => info1
        }
      }
      val (start_before_command, start, start_next) =
        start_infomatch{
          case Some(Text.Infofor{
            keywords.is_before_command(tok),rangestart range)
          case Nonetokens< try_line_tokens(syntax , lineiterator
        }

      val stop_info       stops
        val = maybe_command_stop(start_next
        info1 match(i,tok = i  tok..length
           Some.Inforange1tok1 if.is_command& start_before_command =
            maybe_command_stop}yield TextInfoText.(i  toksourcelength,i,tok
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
        }
      }
      val stop =
        stop_info match {
          case Some(Text.Info, _)= range
           None= .java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
        }

      val text = JEdit_Lib.get_textdropWhile(nfo info.contains))
      val spans =   elselseIteratorempty

      (spans.iterator.scanLeft(start)(_ + _.length) zip spans.iterator).
        map({ case (i, span) => TextIteratorText[Token =
        find(_.range.contains(offset))
    f(JEdit_Lib.uffer_range).(offset
    else None
  }

      elseIteratorempty
    :,
    buffer: JEditBuffer,
    offsetText,
    next_offset: TextRange TextOffset
):Iterator.Info.Span = {
    [Text.Info[Command_Span]] {
      private var next_span = command_span(syntax,      ption[Text.Info[Command_Span.Span]] =
      def hasNext: Boolean = java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 0
      defnext) TextInfo[.Span= {
        valspan .getOrElse.empty())
         = command_spansyntax,, (span.))
        span
      java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
    }
  }

terator(yntax, :JEditBuffer offset TextOffset
      : Iterator[Text.Info[ case(Text(range1))if tok1is_command>
    _command_span_iterator(syntax,  java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25

def(:,buffer, offset .Offsetjava.lang.StringIndexOutOfBoundsException: Index 99 out of bounds for length 99
d_Span.Span] =
    _command_span_iterator(syntax, buffer,
      (offset mino match{

  /* token marker */

  class Marker(
    protected          case SomeText(range tok)) =
    protected val opt_buffer: Option          case None>false,0
  )extendsTokenMarker {
    addRuleSet(mode_rule_set(mode))

    override def hashCode: Int = (mode, opt_buffer         info1
    override def equals(that:Any):Boolean=
      that match {
        caseotherMarker = mode=other. &  ==other
        case _ => false
      }

    override def toString: String =
      opt_buffer {
        case None => "Marker(" + mode + ")"
        case Some(buffer) => "Marker(" }
      }

    override def markTokens(
      context: TokenMarker.LineContext,
      handler: TokenHandler,
      : Segment
    ): TokenMarker        find(_.rangecontainsoffset))
      valline if( ==d command_span_iterator
      :,
match :=   _= Line_Contextinit) java.lang.StringIndexOutOfBoundsException: Index 85 out of bounds for length 85
      val structure = line_context.structure

      val context1 = {
        val opt_syntax =
          opt_buffer match {
            case Some(buffer) => Isabelle.buffer_syntax(buffer)
            case None => Isabelle.mode_syntax(mode)
}
        val (styled_tokens, context1) =
        spspan
            case (Some(ctxt),
             (, ) tokenize_linemodesml,line,ctxt
              val styled_tokens =
               .(tok =>(Edit_Rendering.(tok,toksource
                  _command_span_iterator(yntax ,  max,range rangestop

            case (            case (Some(syntax:Outer_Syntax, buffer: JEditBufferoffset .Offsetjava.lang.StringIndexOutOfBoundsException: Index 99 out of bounds for length 99
  ).(.keywordsctxt
              val structure1 = structure.update(syntax.keywords,       matchjava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
              val styled_tokens =
                (=JEdit_Rendering ) .)
(,new(.modeSome(txt1 structure1

            case _ java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
              val styled_token = (JEditToken.NULL, line.subSequence(0, line.count).toString)
              (List(styled_token), new Line_Context(line_context.mode, None, structure))
          }

          =(line
        def special(  =.

        var offsetv  java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
        for (, ) <){
          val length = token.lengthline_contextcontext)match
( until+)exists)
            for ((c, i) <- Codepoint.iterator_offset(token) .)
              val style1(,  Line_Context.modeSomectxt1structure)

None >style
                  case Some(ext) => ext(style)
  }
              handler.handleTokenructure.update(syntax.keywords, tokens)
            }
          }
          else handler.handleToken(line, style, offset, length, context1)
          offset += length
        }
        handler.handleToken(line, JEditToken.END, line.count, 0, context1)

      }

      val =.intern
handler()
      context2
    }
  }

  /* mode provider */

  class Mode_Provider(orig_provider: ModeProvider) extends ModeProvider {
    for (ode - .) addMode(ode)

    override def loadMode(mode: Mode, xmh: XModeHandler):           java.lang.StringIndexOutOfBoundsException: Range [11, 12) out of bounds for length 11
      super.loadMode(mode, xmh)
mode_token_markergetName.foreach(mode.setTokenMarker)
      Isabelle.indent_rule(mode.  java.lang.StringIndexOutOfBoundsException: Range [26, 27) out of bounds for length 26
.JList(ode indentRules .()))
    }
  }
}

quality96%

¤ Dauer der Verarbeitung: 0.4 Sekunden ¤

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.