Wsrtjtyk

I'm making a Sublime Text 3 language definition for syntax highlighting. The language is a simple 'expression language' (nothing to do with Java) that is used to display information from a media library on a display panel. The purpose of the syntax highlighting is to clarify exactly what will be displayed on the panel.

Accordingly, I would like to explicate exactly what a sequence of escape characters will look like when interpreted and shown on the display panel. The escape character is a forward-slash, and if you would like to display a literal forward-slash, you have to escape it with another. Therefore, a series of forward-slashes will result in every-other forward-slash being displayed on the panel. Additionally, if there is a special character after a forward-slash, it will be escaped - but if a special character is placed after TWO (or four, or six...) forward slashes, it will not be escaped, because the escape characters will cancel each other out.

The highlighting I would like to achieve (with example special character 's') is as follows:

I have to achieve this simply by feeding Sublime Text regular expressions, in YAML format, so the solution has to be one made purely of regex.

Is this possible? If so, how can I achieve it?

Finding odd numbers of slashes is not particularly useful. This is a parsing exercise of removing slashes. If the slash is followed by another slash, it's a literal slash, otherwise it's whatever follows.

But wait a minute, there's no difference there - no matter what the following char is, it's a literal, so...

Match all "slash-anychar" pairs using the regex /(.) and replace with the captured character.

In java:

str = str.replaceAll("/(.)", "$1");

In python:

str = re.sub('/(.)', '$1', str)

In perl:

$str =~ s//(.)/$1/

etc

Without more information on the structure of the syntax you currently have, it's hard to say for sure, but I think what you're looking for here is just a simple single match construct that matches the literal character / followed by any character that is allowed to be an escape character, which in your example is the character s and the character /.

You may be getting hung up on thinking that the regular expression that you're trying to create needs to find the biggest possible match containing any combination of escape sequences. However, the match rules that you provide are used as many times as needed to consume the input, so they only need to match single syntax constructs at a time.

A simple example of this in action is the following minimal syntax. The first two match constructs are just for example purposes in the image below; they implement a line comment and flagging an 's' as special when it's not escaped so that it's clearer when that is the case.

The third rule is what matches a valid escape sequence, which is a / followed by either another / (literal /) or an s (literal s).

The last rule, which is optional, matches a / character followed by anything that's not a valid escape character (including not being followed by anything) and marks it as invalid as a hint to the user that they've done something silly.

Here I've added a space character as a potentially valid escape for the purposes of invalid escape detection so that a trailing space following a bare / doesn't get the invalid scope as well. Without that, the syntax assumes you were trying to quote the space character.

%YAML 1.2

---

scope: source.example

contexts:

  main:

    # A simple single-line comment scope capture for nice output

    - match: '(#).*n?'

      captures:

        0: comment.line.number-sign.example

        1: punctuation.definition.comment.example

    # Just so we can apply a color to the letter s to know when it's "special"

    - match: 's'

      scope: entity.name.special

    # The set of things that can be valid escapes

    - match: '/[s/]'

      scope: constant.character.escape.example

    # If only s and / are valid escapes, make other escapes invalid, including

    # using a bare / with nothing following it.

    - match: '/[^s/ ]?'

      scope: invalid.illegal.escape.example

In a simple test, the results of this syntax would be:

Alright, so for what it's worth, I figured it out. This:

%YAML 1.2

---



file_extensions:

  - example



  scope: source.example



  contexts:

    main:

    # special color setup #



    - match: s

      scope: green





    # desired behaviour #



      - match: '(/)(.)?'

        captures:

          1: grey

          2: white

Gives you this: