RegExp.kt

package com.maddyhome.idea.vim.regexp

import com.maddyhome.idea.vim.api.VimEditor
import com.maddyhome.idea.vim.api.getLineBuffer
import com.maddyhome.idea.vim.api.injector
import com.maddyhome.idea.vim.diagnostic.VimLogger
import com.maddyhome.idea.vim.helper.Msg
import org.jetbrains.annotations.NonNls
import java.util.*

@Deprecated("Please use VimRegex class instead")
internal class RegExp {
    /*
     * The first byte of the regexp internal "program" is actually this magic
     * number; the start node begins in the second byte.  It's used to catch the
     * most severe mutilation of the program by the caller.
     */
    /*
     * Opcode notes:
     *
     * BRANCH       The set of branches constituting a single choice are hooked
     *              together with their "next" pointers, since precedence prevents
     *              anything being concatenated to any individual branch.  The
     *              "next" pointer of the last BRANCH in a choice points to the
     *              thing following the whole choice.  This is also where the
     *              final "next" pointer of each individual branch points; each
     *              branch starts with the operand node of a BRANCH node.
     *
     * BACK         Normal "next" pointers all implicitly point forward; BACK
     *              exists to make loop structures possible.
     *
     * STAR,PLUS    '=', and complex '*' and '+', are implemented as circular
     *              BRANCH structures using BACK.  Simple cases (one character
     *              per match) are implemented with STAR and PLUS for speed
     *              and to minimize recursive plunges.
     *
     * BRACE_LIMITS This is always followed by a BRACE_SIMPLE or BRACE_COMPLEX
     *              node, and defines the min and max limits to be used for that
     *              node.
     *
     * MOPEN,MCLOSE ...are numbered at compile time.
     * ZOPEN,ZCLOSE ...ditto
     */
    /*
     * A node is one char of opcode followed by two chars of "next" pointer.
     * "Next" pointers are stored as two 8-bit bytes, high order first.  The
     * value is a positive offset from the opcode of the node containing it.
     * An operand, if any, simply follows the node.  (Note that much of the
     * code generation knows about this implicit relationship.)
     *
     * Using two bytes for the "next" pointer is vast overkill for most things,
     * but allows patterns to get big without disasters.
     */
  //    #define OP(p)           ((int)*(p))
  //    #define NEXT(p)         (((*((p) + 1) & 0377) << 8) + (*((p) + 2) & 0377))
  //    #define OPERAND(p)      ((p) + 3)
  /* Obtain an operand that was stored as four bytes, MSB first. */ //    #define OPERAND_MIN(p)  (((long)(p)[3] << 24) + ((long)(p)[4] << 16) \
  //    + ((long)(p)[5] << 8) + (long)(p)[6])
  /* Obtain a second operand stored as four bytes. */ //    #define OPERAND_MAX(p)  OPERAND_MIN((p) + 4)
  /* Obtain a second single-byte operand stored after a four bytes operand. */ //    #define OPERAND_CMP(p)  (p)[7]
    /*
     * Utility definitions.
     */
  //    #define UCHARAT(p)      ((int)*(char_u *)(p))
  /* Used for an error (down from) vim_regcomp(): give the error message, set rc_did_emsg and return null */ /*
    #define EMSG_RET_null(m)
    {
        EMSG(_(m));
        rc_did_emsg = true;
        return null;
    }
    #define EMSG_M_RET_null(m, c)
    {
        EMSG2(_(m), c ? "" : "\\");
        rc_did_emsg = true;
        return null;
    }
    #define EMSG_RET_FAIL(m)
    {
        EMSG(_(m));
        rc_did_emsg = true;
        return FAIL;
    }
    #define EMSG_ONE_RET_null
    */
  // EMSG_M_RET_null("E369: invalid item in %s%%[]", reg_magic == MAGIC_ALL)
  private fun EMSG_RET_null(key: String) {
    injector.messages.showStatusBarMessage(null, injector.messages.message(key))
  }

  private fun EMSG_M_RET_null(key: String, isMagic: Boolean) {
    val `val` = if (isMagic) "" else "\\"
    injector.messages.showStatusBarMessage(null, injector.messages.message(key, `val`))
  }

  private fun EMSG_ONE_RET_null() {
    EMSG_M_RET_null(Msg.E369, reg_magic == MAGIC_ALL)
  }

    /*
     * Return NOT_MULTI if c is not a "multi" operator.
     * Return MULTI_ONE if c is a single "multi" operator.
     * Return MULTI_MULT if c is a multi "multi" operator.
     */
  private fun re_multi_type(c: Int): Int {
    if (c == Magic.AT || c == Magic.EQUAL || c == Magic.QUESTION) {
      return MULTI_ONE
    }
    return if (c == Magic.STAR || c == Magic.PLUS || c == Magic.LCURLY) {
      MULTI_MULT
    } else {
      NOT_MULTI
    }
  }

    /*
     * Translate '\x' to its control character, except "\n", which is Magic.
     */
  private fun backslash_trans(c: Int): Int {
    when (c) {
      'r'.code -> return '\r'.code
      't'.code -> return '\t'.code
      'e'.code -> return 0x1b
      'b'.code -> return '\b'.code
    }
    return c
  }

    /*
     * Return true if compiled regular expression "prog" can match a line break.
     */
  fun re_multiline(prog: regprog_T): Int {
    return prog.regflags and RF_HASNL
  }

    /*
     * vim_regcomp - compile a regular expression into internal code
     *
     * We can't allocate space until we know how big the compiled form will be,
     * but we can't compile it (and thus know how big it is) until we've got a
     * place to put the code.  So we cheat:  we compile it twice, once with code
     * generation turned off and size counting turned on, and once "for real".
     * This also means that we don't allocate space until we are sure that the
     * thing really will compile successfully, and we never have to move the
     * code and thus invalidate pointers into it.  (Note that it has to be in
     * one piece because vim_free() must be able to free it all.)
     *
     * Whether upper/lower case is to be ignored is decided when executing the
     * program, it does not matter here.
     *
     * Beware that the optimization-preparation code in here knows about some
     * of the structure of the compiled regexp.
     */
  fun vim_regcomp(expr: String?, magic: Int): regprog_T? {
    val r: regprog_T
    var scan: CharPointer
    var longest: CharPointer?
    var len: Int
    val flags = Flags()
    if (expr == null) {
      injector.messages.showStatusBarMessage(null, injector.messages.message(Msg.e_null))
      return null
    }
    r = regprog_T()

        /*
         * Second pass: emit code.
         */regcomp_start(expr, magic)
    regcode = CharPointer(r.program)
    regc(REGMAGIC)
    if (reg(REG_NOPAREN, flags) == null) {
      return null
    }

    /* Dig out information for optimizations. */r.regstart = 0.toChar() /* Worst-case defaults. */
    r.reganch = 0.toChar()
    r.regmust = null
    r.regmlen = 0
    r.regflags = regflags
    if (flags.isSet(HASNL)) {
      r.regflags = r.regflags or RF_HASNL
    }
    /* Remember whether this pattern has any \z specials in it. */r.reghasz = re_has_z
    scan = CharPointer(r.program).ref(1) /* First BRANCH. */
    if (regnext(scan)!!.OP() == END) /* Only one top-level choice. */ {
      scan = scan.OPERAND()

      /* Starting-point info. */if (scan.OP() == BOL || scan.OP() == RE_BOF) {
        r.reganch++
        scan = regnext(scan)!!
      }
      if (scan.OP() == EXACTLY) {
        r.regstart = scan.OPERAND().charAt()
      } else if ((scan.OP() == BOW || scan.OP() == EOW || scan.OP() == NOTHING || scan.OP() == MOPEN || scan.OP() == NOPEN || scan.OP() == MCLOSE || scan.OP() == NCLOSE) &&
        regnext(scan)!!.OP() == EXACTLY
      ) {
        r.regstart = regnext(scan)!!.OPERAND().charAt()
      }

            /*
             * If there's something expensive in the r.e., find the longest
             * literal string that must appear and make it the regmust.  Resolve
             * ties in favor of later strings, since the regstart check works
             * with the beginning of the r.e. and avoiding duplication
             * strengthens checking.  Not a strong reason, but sufficient in the
             * absence of others.
             */
            /*
             * When the r.e. starts with BOW, it is faster to look for a regmust
             * first. Used a lot for "#" and "*" commands. (Added by mool).
             */if ((flags.isSet(SPSTART) || scan.OP() == BOW || scan.OP() == EOW) &&
        !flags.isSet(HASNL)
      ) {
        longest = null
        len = 0
        while (scan != null) {
          val so = scan.OPERAND()
          if (scan.OP() == EXACTLY && so.strlen() >= len) {
            longest = so.ref(0)
            len = so.strlen()
          }
          scan = regnext(scan)!!
        }
        if (longest != null) {
          r.regmust = longest.ref(0)
        }
        r.regmlen = len
      }
    }
    if (logger.isDebug()) logger.debug(regdump(expr, r))
    return r
  }

    /*
     * Setup to parse the regexp.  Used once to get the length and once to do it.
     */
  private fun regcomp_start(expr: String, magic: Int) {
    initchr(expr)
    reg_magic = if (magic != 0) {
      MAGIC_ON
    } else {
      MAGIC_OFF
    }
    num_complex_braces = 0
    regnpar = 1
    Arrays.fill(had_endbrace, false)
    regnzpar = 1
    re_has_z = 0.toChar()
    regflags = 0
    had_eol = false
  }

    /*
     * Check if during the previous call to vim_regcomp the EOL item "$" has been
     * found.  This is messy, but it works fine.
     */
  fun vim_regcomp_had_eol(): Boolean {
    return had_eol
  }

    /*
     * reg - regular expression, i.e. main body or parenthesized thing
     *
     * Caller must absorb opening parenthesis.
     *
     * Combining parenthesis handling with the base level of regular expression
     * is a trifle forced, but the need to tie the tails of the branches to what
     * follows makes it hard to avoid.
     */
  private fun reg(paren: Int, flagp: Flags): CharPointer? {
    var ret: CharPointer?
    var br: CharPointer?
    val ender: CharPointer
    var parno = 0
    val flags = Flags()
    flagp.init(HASWIDTH) /* Tentatively. */
    if (paren == REG_ZPAREN) {
      /* Make a ZOPEN node. */
      if (regnzpar >= NSUBEXP) {
        injector.messages.showStatusBarMessage(null, injector.messages.message(Msg.E50))
        return null
      }
      parno = regnzpar
      regnzpar++
      ret = regnode(ZOPEN + parno)
    } else if (paren == REG_PAREN) {
      /* Make a MOPEN node. */
      if (regnpar >= NSUBEXP) {
        EMSG_M_RET_null(Msg.E51, reg_magic == MAGIC_ALL)
        return null
      }
      parno = regnpar
      ++regnpar
      ret = regnode(MOPEN + parno)
    } else if (paren == REG_NPAREN) {
      /* Make a NOPEN node. */
      ret = regnode(NOPEN)
    } else {
      ret = null
    }

    /* Pick up the branches, linking them together. */br = regbranch(flags)
    if (br == null) {
      return null
    }
    if (ret != null) {
      regtail(ret, br) /* [MZ]OPEN -> first. */
    } else {
      ret = br.ref(0)
    }
        /* If one of the branches can be zero-width, the whole thing can.
         * If one of the branches has * at start or matches a line-break, the
         * whole thing can. */if (!flags.isSet(HASWIDTH)) {
      flagp.unset(HASWIDTH)
    }
    flagp.set(flags.get() and (SPSTART or HASNL))
    while (peekchr() == Magic.PIPE) {
      skipchr()
      br = regbranch(flags)
      if (br == null) {
        return null
      }
      regtail(ret, br) /* BRANCH -> BRANCH. */
      if (!flags.isSet(HASWIDTH)) {
        flagp.unset(HASWIDTH)
      }
      flagp.set(flags.get() and (SPSTART or HASNL))
    }

    /* Make a closing node, and hook it on the end. */ender =
      regnode(if (paren == REG_ZPAREN) ZCLOSE + parno else if (paren == REG_PAREN) MCLOSE + parno else if (paren == REG_NPAREN) NCLOSE else END)
    regtail(ret, ender)

    /* Hook the tails of the branches to the closing node. */br = ret.ref(0)
    while (br != null) {
      regoptail(br, ender)
      br = regnext(br)
    }

    /* Check for proper termination. */if (paren != REG_NOPAREN && getchr() != Magic.RPAREN) {
      return if (paren == REG_ZPAREN) {
        injector.messages.showStatusBarMessage(null, injector.messages.message(Msg.E52))
        null
      } else if (paren == REG_NPAREN) {
        EMSG_M_RET_null(Msg.E53, reg_magic == MAGIC_ALL)
        null
      } else {
        EMSG_M_RET_null(Msg.E54, reg_magic == MAGIC_ALL)
        null
      }
    } else if (paren == REG_NOPAREN && peekchr() != '\u0000'.code) {
      return if (curchr == Magic.LPAREN) {
        EMSG_M_RET_null(Msg.E55, reg_magic == MAGIC_ALL)
        null
      } else {
        injector.messages.showStatusBarMessage(null, injector.messages.message(Msg.e_trailing))
        null
      }
      /* NOTREACHED */
    }
        /*
         * Here we set the flag allowing back references to this set of
         * parentheses.
         */if (paren == REG_PAREN) {
      had_endbrace[parno] = true /* have seen the close paren */
    }
    return ret
  }

    /*
     * regbranch - one alternative of an | operator
     *
     * Implements the & operator.
     */
  private fun regbranch(flagp: Flags): CharPointer? {
    val ret: CharPointer
    var chain: CharPointer? = null
    var latest: CharPointer?
    val flags = Flags()
    flagp.init(WORST or HASNL) /* Tentatively. */
    ret = regnode(BRANCH)
    while (true) {
      latest = regconcat(flags)
      if (latest == null) {
        return null
      }

            /* If one of the branches has width, the whole thing has.  If one of
             * the branches anchors at start-of-line, the whole thing does. */flagp.set(flags.get() and (HASWIDTH or SPSTART))
            /* If one of the branches doesn't match a line-break, the whole thing
             * doesn't. */flagp.set(flagp.get() and (HASNL.inv() or (flags.get() and HASNL)))
      chain?.let { regtail(it, latest) }
      if (peekchr() != Magic.AMP) {
        break
      }
      skipchr()
      regtail(latest, regnode(END)) /* operand ends */
      reginsert(MATCH, latest.ref(0))
      chain = latest.ref(0)
    }
    return ret
  }

    /*
     * regbranch - one alternative of an | or & operator
     *
     * Implements the concatenation operator.
     */
  private fun regconcat(flagp: Flags): CharPointer? {
    var first: CharPointer? = null
    var chain: CharPointer? = null
    var latest: CharPointer?
    val flags = Flags()
    var cont = true
    flagp.init(WORST) /* Tentatively. */
    while (cont) {
      when (peekchr()) {
        '\u0000'.code, Magic.PIPE, Magic.AMP, Magic.RPAREN -> cont = false
        Magic.c -> {
          regflags = regflags or RF_ICASE
          skipchr_keepstart()
        }
        Magic.C -> {
          regflags = regflags or RF_NOICASE
          skipchr_keepstart()
        }
        Magic.v -> {
          reg_magic = MAGIC_ALL
          skipchr_keepstart()
          curchr = -1
        }
        Magic.m -> {
          reg_magic = MAGIC_ON
          skipchr_keepstart()
          curchr = -1
        }
        Magic.M -> {
          reg_magic = MAGIC_OFF
          skipchr_keepstart()
          curchr = -1
        }
        Magic.V -> {
          reg_magic = MAGIC_NONE
          skipchr_keepstart()
          curchr = -1
        }
        else -> {
          latest = regpiece(flags)
          if (latest == null) {
            return null
          }
          flagp.set(flags.get() and (HASWIDTH or HASNL))
          chain /* First piece. */?.let { regtail(it, latest) }
            ?: flagp.set(flags.get() and SPSTART)
          chain = latest.ref(0)
          if (first == null) {
            first = latest.ref(0)
          }
        }
      }
    }
    if (first == null) /* Loop ran zero times. */ {
      first = regnode(NOTHING)
    }
    return first
  }

    /*
     * regpiece - something followed by possible [*+=]
     *
     * Note that the branching code sequences used for = and the general cases
     * of * and + are somewhat optimized:  they use the same NOTHING node as
     * both the endmarker for their branch list and the body of the last branch.
     * It might seem that this node could be dispensed with entirely, but the
     * endmarker role is not redundant.
     */
  private fun regpiece(flagp: Flags): CharPointer? {
    val ret: CharPointer?
    val op: Int
    val next: CharPointer
    val flags = Flags()
    ret = regatom(flags)
    if (ret == null) {
      return null
    }
    op = peekchr()
    if (re_multi_type(op) == NOT_MULTI) {
      flagp.init(flags.get())
      return ret
    }
    if (!flags.isSet(HASWIDTH) && re_multi_type(op) == MULTI_MULT) {
      if (op == Magic.STAR) {
        EMSG_M_RET_null(Msg.E56, reg_magic >= MAGIC_ON)
        return null
      }
      if (op == Magic.PLUS) {
        EMSG_M_RET_null(Msg.E57, reg_magic == MAGIC_ALL)
        return null
      }
      /* "\{}" is checked below, it's allowed when there is an upper limit */
    }
    flagp.init(WORST or SPSTART or (flags.get() and HASNL)) /* default flags */
    skipchr()
    when (op) {
      Magic.STAR -> if (flags.isSet(SIMPLE)) {
        reginsert(STAR, ret.ref(0))
      } else {
        /* Emit x* as (x&|), where & means "self". */
        reginsert(BRANCH, ret.ref(0)) /* Either x */
        regoptail(ret, regnode(BACK)) /* and loop */
        regoptail(ret, ret) /* back */
        regtail(ret, regnode(BRANCH)) /* or */
        regtail(ret, regnode(NOTHING)) /* null. */
      }
      Magic.PLUS -> {
        if (flags.isSet(SIMPLE)) {
          reginsert(PLUS, ret.ref(0))
        } else {
          /* Emit x+ as x(&|), where & means "self". */
          next = regnode(BRANCH) /* Either */
          regtail(ret, next)
          regtail(regnode(BACK), ret) /* loop back */
          regtail(next, regnode(BRANCH)) /* or */
          regtail(ret, regnode(NOTHING)) /* null. */
        }
        flagp.init(WORST or HASWIDTH or (flags.get() and HASNL))
      }
      Magic.AT -> {
        var lop = END
        when (Magic.no_Magic(getchr())) {
          '='.code -> lop = MATCH
          '!'.code -> lop = NOMATCH
          '>'.code -> lop = SUBPAT
          '<'.code -> when (Magic.no_Magic(getchr())) {
            '='.code -> lop = BEHIND
            '!'.code -> lop = NOBEHIND
          }
        }
        if (lop == END) {
          EMSG_M_RET_null(Msg.E59, reg_magic == MAGIC_ALL)
          return null
        }
        /* Look behind must match with behind_pos. */if (lop == BEHIND || lop == NOBEHIND) {
          regtail(ret, regnode(BHPOS))
        }
        regtail(ret, regnode(END)) /* operand ends */
        reginsert(lop, ret.ref(0))
      }
      Magic.QUESTION, Magic.EQUAL -> {
        /* Emit x= as (x|) */reginsert(BRANCH, ret.ref(0)) /* Either x */
        regtail(ret, regnode(BRANCH)) /* or */
        next = regnode(NOTHING) /* null. */
        regtail(ret, next)
        regoptail(ret, next)
      }
      Magic.LCURLY -> {
        val limits = read_limits() ?: return null
        val maxval = limits.maxvalue
        val minval = limits.minvalue
        if (!flags.isSet(HASWIDTH) && (if (maxval > minval) maxval >= MAX_LIMIT else minval >= MAX_LIMIT)) {
          EMSG_M_RET_null(Msg.E58, reg_magic == MAGIC_ALL)
          return null
        }
        if (flags.isSet(SIMPLE)) {
          reginsert(BRACE_SIMPLE, ret.ref(0))
          reginsert_limits(BRACE_LIMITS, minval, maxval, ret.ref(0))
        } else {
          if (num_complex_braces >= 10) {
            EMSG_M_RET_null(Msg.E60, reg_magic == MAGIC_ALL)
            return null
          }
          reginsert(BRACE_COMPLEX + num_complex_braces, ret.ref(0))
          regoptail(ret, regnode(BACK))
          regoptail(ret, ret)
          reginsert_limits(BRACE_LIMITS, minval, maxval, ret.ref(0))
          ++num_complex_braces
        }
        if (minval > 0 && maxval > 0) {
          flagp.init(HASWIDTH or (flags.get() and HASNL))
        }
      }
    }
    if (re_multi_type(peekchr()) != NOT_MULTI) {
      /* Can't have a multi follow a multi. */
      if (peekchr() == Magic.STAR) {
        val `val` = if (reg_magic >= MAGIC_ON) "" else "\\"
        injector.messages.showStatusBarMessage(null, injector.messages.message(Msg.E61, `val`))
      } else {
        val `val` = if (reg_magic >= MAGIC_ON) "" else "\\"
        injector.messages.showStatusBarMessage(
          null,
          injector.messages.message(
            Msg.E62,
            `val`,
            Character.toString(Magic.no_Magic(peekchr()).toChar()),
          ),
        )
      }
      return null
    }
    return ret
  }

    /*
     * regatom - the lowest level
     *
     * Optimization:  gobbles an entire sequence of ordinary characters so that
     * it can turn them into a single node, which is smaller to store and
     * faster to run.  Don't do this when one_exactly is set.
     */
  private fun regatom(flagp: Flags): CharPointer? {
    var ret: CharPointer? = null
    val flags = Flags()
    val cpo_lit = false /* 'cpoptions' contains 'l' flag */
    var c: Int
    val classchars = ".iIkKfFpPsSdDxXoOwWhHaAlLuU"
    val classcodes = intArrayOf(
      ANY, IDENT, SIDENT, KWORD, SKWORD,
      FNAME, SFNAME, PRINT, SPRINT,
      WHITE, NWHITE, DIGIT, NDIGIT,
      HEX, NHEX, OCTAL, NOCTAL,
      WORD, NWORD, HEAD, NHEAD,
      ALPHA, NALPHA, LOWER, NLOWER,
      UPPER, NUPPER,
    )
    val p: CharPointer
    var extra = 0
    flagp.init(WORST) /* Tentatively. */
    c = getchr()
    var doCollection = false
    var doDefault = false
    when (c) {
      Magic.HAT -> ret = regnode(BOL)
      Magic.DOLLAR -> {
        ret = regnode(EOL)
        had_eol = true
      }
      Magic.LESS -> ret = regnode(BOW)
      Magic.GREATER -> ret = regnode(EOW)
      Magic.UNDER -> {
        c = Magic.no_Magic(getchr())
        if (c == '^'.code) /* "\_^" is start-of-line */ {
          ret = regnode(BOL)
        }
        if (c == '$'.code) /* "\_$" is end-of-line */ {
          ret = regnode(EOL)
          had_eol = true
        }
        extra = ADD_NL
        flagp.set(HASNL)

        /* "\_[" is character range plus newline */if (c == '['.code) {
          // goto collection;
          doCollection = true
        }
        val i = classchars.indexOf(Magic.no_Magic(c).toChar())
        if (i == -1) {
          injector.messages.showStatusBarMessage(null, injector.messages.message(Msg.E63))
          return null
        }
        ret = regnode(classcodes[i] + extra)
        flagp.set(HASWIDTH or SIMPLE)
      }
      Magic.DOT, Magic.i, Magic.I, Magic.k, Magic.K, Magic.f, Magic.F, Magic.p, Magic.P, Magic.s, Magic.S, Magic.d, Magic.D, Magic.x, Magic.X, Magic.o, Magic.O, Magic.w, Magic.W, Magic.h, Magic.H, Magic.a, Magic.A, Magic.l, Magic.L, Magic.u, Magic.U -> {
        val i = classchars.indexOf(Magic.no_Magic(c).toChar())
        if (i == -1) {
          injector.messages.showStatusBarMessage(null, injector.messages.message(Msg.E63))
          return null
        }
        ret = regnode(classcodes[i] + extra)
        flagp.set(HASWIDTH or SIMPLE)
      }
      Magic.n -> {
        ret = regnode(NEWL)
        flagp.set(HASWIDTH or HASNL)
      }
      Magic.LPAREN -> {
        if (one_exactly) {
          EMSG_ONE_RET_null()
          return null
        }
        ret = reg(REG_PAREN, flags)
        if (ret == null) {
          return null
        }
        flagp.set(flags.get() and (HASWIDTH or SPSTART or HASNL))
      }
      '\u0000'.code, Magic.PIPE, Magic.AMP, Magic.RPAREN -> {
        EMSG_RET_null(Msg.e_internal) /* Supposed to be caught earlier. */
        return null
      }
      Magic.EQUAL, Magic.QUESTION, Magic.PLUS, Magic.AT, Magic.LCURLY, Magic.STAR -> {
        c = Magic.no_Magic(c)
        val `val` = if (if (c == '*'.code) reg_magic >= MAGIC_ON else reg_magic == MAGIC_ALL) "" else "\\"
        injector.messages.showStatusBarMessage(
          null,
          injector.messages.message(
            Msg.E64,
            `val`,
            Character.toString(c.toChar()),
          ),
        )
        return null
      }
      Magic.TILDE -> if (reg_prev_sub != null) {
        val lp: CharPointer
        ret = regnode(EXACTLY)
        lp = reg_prev_sub.ref(0)
        while (!lp.isNul) {
          regc(lp.charAt().code)
        }
        lp.inc()
        regc('\u0000'.code)
        if (!reg_prev_sub.isNul) {
          flagp.set(HASWIDTH)
          if (lp.pointer() - reg_prev_sub.pointer() == 1) {
            flagp.set(SIMPLE)
          }
        }
      } else {
        injector.messages.showStatusBarMessage(null, injector.messages.message(Msg.e_nopresub))
        return null
      }
      Magic.N1, Magic.N2, Magic.N3, Magic.N4, Magic.N5, Magic.N6, Magic.N7, Magic.N8, Magic.N9 -> {
        val refnum: Int
        refnum = c - Magic.N0
                /*
                     * Check if the back reference is legal. We must have seen the
                     * close brace.
                     * TODO: Should also check that we don't refer to something
                     * that is repeated (+*=): what instance of the repetition
                     * should we match?
                     */if (!had_endbrace[refnum]) {
                    /* Trick: check if "@<=" or "@<!" follows, in which case
                         * the \1 can appear before the referenced match. */
          p = regparse!!.ref(0)
          while (!p.isNul) {
            if (p.charAt(0) == '@' && p.charAt(1) == '<' && (p.charAt(2) == '!' || p.charAt(2) == '=')) {
              break
            }
            p.inc()
          }
          if (p.isNul) {
            EMSG_RET_null(Msg.E65)
            return null
          }
        }
        ret = regnode(BACKREF + refnum)
      }
      Magic.z -> {
        c = Magic.no_Magic(getchr())
        when (c) {
          '('.code -> {
            if (reg_do_extmatch != REX_SET) {
              injector.messages.showStatusBarMessage(null, injector.messages.message(Msg.E66))
              return null
            }
            if (one_exactly) {
              EMSG_ONE_RET_null()
              return null
            }
            ret = reg(REG_ZPAREN, flags)
            if (ret == null) {
              return null
            }
            flagp.set(flags.get() and (HASWIDTH or SPSTART or HASNL))
            re_has_z = REX_SET.toChar()
          }
          '1'.code, '2'.code, '3'.code, '4'.code, '5'.code, '6'.code, '7'.code, '8'.code, '9'.code -> {
            if (reg_do_extmatch != REX_USE) {
              injector.messages.showStatusBarMessage(null, injector.messages.message(Msg.E67))
              return null
            }
            ret = regnode(ZREF + c - '0'.code)
            re_has_z = REX_USE.toChar()
          }
          's'.code -> ret = regnode(MOPEN)
          'e'.code -> ret = regnode(MCLOSE)
          else -> {
            injector.messages.showStatusBarMessage(null, injector.messages.message(Msg.E68))
            return null
          }
        }
      }
      Magic.PERCENT -> {
        c = Magic.no_Magic(getchr())
        when (c) {
          '('.code -> {
            if (one_exactly) {
              EMSG_ONE_RET_null()
              return null
            }
            ret = reg(REG_NPAREN, flags)
            if (ret == null) {
              return null
            }
            flagp.set(flags.get() and (HASWIDTH or SPSTART or HASNL))
          }
          '^'.code -> ret = regnode(RE_BOF)
          '$'.code -> ret = regnode(RE_EOF)
          '#'.code -> ret = regnode(CURSOR)
          '['.code -> if (one_exactly) /* doesn't nest */ {
            EMSG_ONE_RET_null()
            return null
          } else {
            val lastbranch: CharPointer
            var lastnode: CharPointer? = null
            var br: CharPointer?
            ret = null
            while (getchr().also { c = it } != ']'.code) {
              if (c == '\u0000'.code) {
                EMSG_M_RET_null(Msg.E69, reg_magic == MAGIC_ALL)
                return null
              }
              br = regnode(BRANCH)
              if (ret == null) {
                ret = br.ref(0)
              } else {
                regtail(lastnode!!, br)
              }
              ungetchr()
              one_exactly = true
              lastnode = regatom(flagp)
              one_exactly = false
              if (lastnode == null) {
                return null
              }
            }
            if (ret == null) {
              EMSG_M_RET_null(Msg.E70, reg_magic == MAGIC_ALL)
              return null
            }
            lastbranch = regnode(BRANCH)
            br = regnode(NOTHING)
            regtail(lastnode!!, br)
            regtail(lastbranch, br)
                        /* connect all branches to the NOTHING
                                 * branch at the end */br = ret.ref(0)
            while (br !== lastnode) {
              br = if (br!!.OP() == BRANCH) {
                regtail(br, lastbranch)
                br.OPERAND()
              } else {
                regnext(br)
              }
            }
            flagp.unset(HASWIDTH)
          }
          else -> {
            if (Character.isDigit(c.toChar()) || c == '<'.code || c == '>'.code) {
              var n = 0
              val cmp: Int
              cmp = c
              if (cmp == '<'.code || cmp == '>'.code) {
                c = getchr()
              }
              while (Character.isDigit(c.toChar())) {
                n = n * 10 + (c - '0'.code)
                c = getchr()
              }
              if (c == 'l'.code || c == 'c'.code || c == 'v'.code) {
                ret = if (c == 'l'.code) {
                  regnode(RE_LNUM)
                } else if (c == 'c'.code) {
                  regnode(RE_COL)
                } else {
                  regnode(RE_VCOL)
                }

                                /* put the number and the optional
                                     * comparator after the opcode */regcode = re_put_long(regcode!!.ref(0), n)
                regcode!!.set(cmp.toChar()).inc()
              }
            }
            EMSG_M_RET_null(Msg.E71, reg_magic == MAGIC_ALL)
            return null
          }
        }
      }
      Magic.LBRACE -> doCollection = true
      else -> doDefault = true
    }
    if (doCollection) {
      val lp: CharPointer

            /*
            * If there is no matching ']', we assume the '[' is a normal
            * character.  This makes 'incsearch' and ":help [" work.
            */lp = skip_anyof(regparse!!.ref(0))
      if (lp.charAt() == ']') /* there is a matching ']' */ {
        var startc = -1 /* > 0 when next '-' is a range */
        var endc: Int

                /*
                * In a character class, different parsing rules apply.
                * Not even \ is special anymore, nothing is.
                */if (regparse!!.charAt() == '^') /* Complement of range. */ {
          ret = regnode(ANYBUT + extra)
          regparse!!.inc()
        } else {
          ret = regnode(ANYOF + extra)
        }

        /* At the start ']' and '-' mean the literal character. */if (regparse!!.charAt() == ']' || regparse!!.charAt() == '-') {
          regc(regparse!!.charAt().code)
          regparse!!.inc()
        }
        while (!regparse!!.isNul && regparse!!.charAt() != ']') {
          if (regparse!!.charAt() == '-') {
            regparse!!.inc()
                        /* The '-' is not used for a range at the end and
                        * after or before a '\n'. */if (regparse!!.isNul || regparse!!.charAt() == ']' || startc == -1 ||
              regparse!!.charAt(0) == '\\' && regparse!!.charAt(1) == 'n'
            ) {
              regc('-'.code)
              startc = '-'.code /* [--x] is a range */
            } else {
              // endc = *regparse++;
              endc = regparse!!.charAt().code
              regparse!!.inc()
              if (startc > endc) {
                injector.messages.showStatusBarMessage(null, injector.messages.message(Msg.e_invrange))
                return null
              }
              while (++startc <= endc) {
                regc(startc)
              }
              startc = -1
            }
          } else if (regparse!!.charAt() == '\\' &&
            (
              REGEXP_INRANGE.indexOf(regparse!!.charAt(1)) != -1 || !cpo_lit &&
                REGEXP_ABBR.indexOf(regparse!!.charAt(1)) != -1
              )
          ) {
            regparse!!.inc()
            if (regparse!!.charAt() == 'n') {
              /* '\n' in range: also match NL */
              if (ret.charAt().code == ANYBUT) {
                ret.set((ANYBUT + ADD_NL).toChar())
              } else if (ret.charAt().code == ANYOF) {
                ret.set((ANYOF + ADD_NL).toChar())
              }
              /* else: must have had a \n already */flagp.set(HASNL)
              regparse!!.inc()
              startc = -1
            } else {
              startc = backslash_trans(regparse!!.charAt().code)
              regparse!!.inc()
              regc(startc)
            }
          } else if (regparse!!.charAt() == '[') {
            var c_class: Int
            var cu: Int
            c_class = skip_class_name(regparse!!)
            startc = -1
            when (c_class) {
              CharacterClasses.CLASS_NONE -> {
                /* literal '[', allow [[-x] as a range */startc = regparse!!.charAt().code
                regparse!!.inc()
                regc(startc)
              }
              CharacterClasses.CLASS_ALNUM -> {
                cu = 1
                while (cu <= 255) {
                  if (Character.isLetterOrDigit(cu.toChar())) {
                    regc(cu)
                  }
                  cu++
                }
              }
              CharacterClasses.CLASS_ALPHA -> {
                cu = 1
                while (cu <= 255) {
                  if (Character.isLetter(cu.toChar())) {
                    regc(cu)
                  }
                  cu++
                }
              }
              CharacterClasses.CLASS_BLANK -> {
                regc(' '.code)
                regc('\t'.code)
              }
              CharacterClasses.CLASS_CNTRL -> {
                cu = 1
                while (cu <= 255) {
                  if (Character.isISOControl(cu.toChar())) {
                    regc(cu)
                  }
                  cu++
                }
              }
              CharacterClasses.CLASS_DIGIT -> {
                cu = 1
                while (cu <= 255) {
                  if (Character.isDigit(cu.toChar())) {
                    regc(cu)
                  }
                  cu++
                }
              }
              CharacterClasses.CLASS_GRAPH -> {
                cu = 1
                while (cu <= 255) {
                  if (CharacterClasses.isGraph(cu.toChar())) {
                    regc(cu)
                  }
                  cu++
                }
              }
              CharacterClasses.CLASS_LOWER -> {
                cu = 1
                while (cu <= 255) {
                  if (Character.isLowerCase(cu.toChar())) {
                    regc(cu)
                  }
                  cu++
                }
              }
              CharacterClasses.CLASS_PRINT -> {
                cu = 1
                while (cu <= 255) {
                  if (CharacterClasses.isPrint(cu.toChar())) {
                    regc(cu)
                  }
                  cu++
                }
              }
              CharacterClasses.CLASS_PUNCT -> {
                cu = 1
                while (cu <= 255) {
                  if (CharacterClasses.isPunct(cu.toChar())) {
                    regc(cu)
                  }
                  cu++
                }
              }
              CharacterClasses.CLASS_SPACE -> {
                cu = 9
                while (cu <= 13) {
                  regc(cu)
                  cu++
                }
                regc(' '.code)
              }
              CharacterClasses.CLASS_UPPER -> {
                cu = 1
                while (cu <= 255) {
                  if (Character.isUpperCase(cu.toChar())) {
                    regc(cu)
                  }
                  cu++
                }
              }
              CharacterClasses.CLASS_XDIGIT -> {
                cu = 1
                while (cu <= 255) {
                  if (CharacterClasses.isHex(cu.toChar())) {
                    regc(cu)
                  }
                  cu++
                }
              }
              CharacterClasses.CLASS_TAB -> regc('\t'.code)
              CharacterClasses.CLASS_RETURN -> regc('\r'.code)
              CharacterClasses.CLASS_BACKSPACE -> regc('\b'.code)
              CharacterClasses.CLASS_ESCAPE -> regc('\u001b'.code)
            }
          } else {
            startc = regparse!!.charAt().code
            regparse!!.inc()
            regc(startc)
          }
        }
        regc('\u0000'.code)
        prevchr_len = 1 /* last char was the ']' */
        if (regparse!!.charAt() != ']') {
          injector.messages.showStatusBarMessage(null, injector.messages.message(Msg.e_toomsbra))
          return null
        }
        skipchr() /* let's be friends with the lexer again */
        flagp.set(HASWIDTH or SIMPLE)
      } else {
        doDefault = true
      }
    }
    /* FALLTHROUGH */if (doDefault) {
      var len: Int
      ret = regnode(EXACTLY)

            /*
            * Append characters as long as:
            * - there is no following multi, we then need the character in
            *   front of it as a single character operand
            * - not running into a Magic character
            * - "one_exactly" is not set
            * But always emit at least one character.  Might be a Multi,
            * e.g., a "[" without matching "]".
            */len = 0
      while (c != '\u0000'.code && (
          len == 0 || re_multi_type(peekchr()) == NOT_MULTI &&
            !one_exactly && !Magic.is_Magic(c)
          )
      ) {
        c = Magic.no_Magic(c)
        regc(c)
        c = getchr()
        ++len
      }
      ungetchr()
      regc('\u0000'.code)
      flagp.set(HASWIDTH)
      if (len == 1) {
        flagp.set(SIMPLE)
      }
    }
    return ret
  }

    /*
     * emit a node
     * Return pointer to generated code.
     */
  private fun regnode(op: Int): CharPointer {
    val ret: CharPointer
    ret = regcode!!.ref(0)
    regcode!!.set(op.toChar()).inc()
    regcode!!.set('\u0000').inc() /* Null "next" pointer. */
    regcode!!.set('\u0000').inc()
    return ret
  }

    /*
     * Emit (if appropriate) a byte of code
     */
  private fun regc(b: Int) {
    regcode!!.set(b.toChar()).inc()
  }

    /*
     * reginsert - insert an operator in front of already-emitted operand
     *
     * Means relocating the operand.
     */
  private fun reginsert(op: Int, opnd: CharPointer) {
    val src: CharPointer
    val dst: CharPointer
    val place: CharPointer
    src = regcode!!.ref(0)
    regcode!!.inc(3)
    dst = regcode!!.ref(0)
    while (src.pointer() > opnd.pointer()) {
      // *--dst = *--src;
      dst.dec().set(src.dec().charAt())
    }
    place = opnd.ref(0) /* Op node, where operand used to be. */
    place.set(op.toChar()).inc()
    place.set('\u0000').inc()
    place.set('\u0000')
  }

    /*
     * reginsert_limits - insert an operator in front of already-emitted operand.
     * The operator has the given limit values as operands.  Also set next pointer.
     *
     * Means relocating the operand.
     */
  private fun reginsert_limits(op: Int, minval: Int, maxval: Int, opnd: CharPointer) {
    val src: CharPointer
    val dst: CharPointer
    var place: CharPointer
    src = regcode!!.ref(0)
    regcode!!.inc(11)
    dst = regcode!!.ref(0)
    while (src.pointer() > opnd.pointer()) {
      // *--dst = *--src;
      dst.dec().set(src.dec().charAt())
    }
    place = opnd.ref(0) /* Op node, where operand used to be. */
    place.set(op.toChar()).inc()
    place.set('\u0000').inc()
    place.set('\u0000').inc()
    place = re_put_long(place.ref(0), minval)
    place = re_put_long(place.ref(0), maxval)
    regtail(opnd, place)
  }

    /*
     * Write a long as four bytes at "p" and return pointer to the next char.
     */
  private fun re_put_long(p: CharPointer, `val`: Int): CharPointer {
    p.set((`val` shr 24 and 0xff).toChar()).inc()
    p.set((`val` shr 16 and 0xff).toChar()).inc()
    p.set((`val` shr 8 and 0xff).toChar()).inc()
    p.set((`val` and 0xff).toChar()).inc()
    return p
  }

    /*
     * regtail - set the next-pointer at the end of a node chain
     */
  private fun regtail(p: CharPointer, `val`: CharPointer) {
    var scan: CharPointer
    val offset: Int

    /* Find last node. */scan = p.ref(0)
    while (true) {
      val temp = regnext(scan) ?: break
      scan = temp
    }
    offset = if (scan.OP() == BACK) {
      scan.pointer() - `val`.pointer()
    } else {
      `val`.pointer() - scan.pointer()
    }
    scan.ref(1).set((offset.toChar().code shr 8 and 0xff).toChar())
    scan.ref(2).set((offset and 0xff).toChar())
  }

    /*
     * regoptail - regtail on item after a BRANCH; nop if none
     */
  private fun regoptail(p: CharPointer?, `val`: CharPointer) {
    /* When op is neither BRANCH nor BRACE_COMPLEX0-9, it is "operandless" */
    if (p == null || p.OP() != BRANCH && (p.OP() < BRACE_COMPLEX || p.OP() > BRACE_COMPLEX + 9)) {
      return
    }
    regtail(p.OPERAND(), `val`)
  }

  private fun initchr(str: String) {
    regparse = CharPointer(str)
    prevchr_len = 0
    nextchr = -1
    prevchr = nextchr
    prevprevchr = prevchr
    curchr = prevprevchr
    at_start = true
    prev_at_start = false
  }

  private fun peekchr(): Int {
    if (curchr == -1) {
      when (regparse!!.charAt(0).also { curchr = it.code }) {
        '.', '[', '~' -> /* magic when 'magic' is on */if (reg_magic >= MAGIC_ON) {
          curchr = Magic.magic(curchr)
        }
        '(', ')', '{', '%', '+', '=', '?', '@', '!', '&', '|', '<', '>', '#', '"', '\'', ',', '-', ':', ';', '`', '/' -> /* magic only after "\v" */if (reg_magic == MAGIC_ALL) {
          curchr = Magic.magic(curchr)
        }
        '*' -> /* * is not magic as the very first character, eg "?*ptr" and when
                     * after '^', eg "/^*ptr" */if (reg_magic >= MAGIC_ON && !at_start && !(prev_at_start && prevchr == Magic.HAT)) {
          curchr = Magic.STAR
        }
        '^' -> /* '^' is only magic as the very first character and if it's after
                     * "\(", "\|", "\&' or "\n" */if (reg_magic >= MAGIC_OFF &&
          (
            at_start || reg_magic == MAGIC_ALL || prevchr == Magic.LPAREN || prevchr == Magic.PIPE || prevchr == Magic.AMP || prevchr == Magic.n || Magic.no_Magic(
              prevchr,
            ) == '('.code &&
              prevprevchr == Magic.PERCENT
            )
        ) {
          curchr = Magic.HAT
          at_start = true
          prev_at_start = false
        }
        '$' -> /* '$' is only magic as the very last char and if it's in front of
                     * either "\|", "\)", "\&", or "\n" */if (reg_magic >= MAGIC_OFF) {
          val p = regparse!!.ref(1)

          /* ignore \c \C \m and \M after '$' */while (p.charAt(0) == '\\' && (
              p.charAt(1) == 'c' || p.charAt(
                1,
              ) == 'C' || p.charAt(1) == 'm' || p.charAt(1) == 'M'
              )
          ) {
            p.inc(2)
          }
          if (p.charAt(0) == '\u0000' || p.charAt(0) == '\\' &&
            (p.charAt(1) == '|' || p.charAt(1) == '&' || p.charAt(1) == ')' || p.charAt(1) == 'n') || reg_magic == MAGIC_ALL
          ) {
            curchr = Magic.DOLLAR
          }
        }
        '\\' -> {
          val c = regparse!!.charAt(1).code
          if (c == '\u0000'.code) {
            curchr = '\\'.code /* trailing '\' */
          } else if (c <= '~'.code && META_flags[c] != 0) {
                        /*
                             * META contains everything that may be magic sometimes,
                             * except ^ and $ ("\^" and "\$" are only magic after
                             * "\v").  We now fetch the next character and toggle its
                             * magicness.  Therefore, \ is so meta-magic that it is
                             * not in META.
                             */
            curchr = -1
            prev_at_start = at_start
            at_start = false /* be able to say "/\*ptr" */
            regparse!!.inc()
            peekchr()
            regparse!!.dec()
            curchr = Magic.toggle_Magic(curchr)
          } else if (REGEXP_ABBR.indexOf(c.toChar()) != -1) {
                        /*
                             * Handle abbreviations, like "\t" for TAB -- webb
                             */
            curchr = backslash_trans(c)
          } else if (reg_magic == MAGIC_NONE && (c == '$'.code || c == '^'.code)) {
            curchr = Magic.toggle_Magic(c)
          } else {
                        /*
                             * Next character can never be (made) magic?
                             * Then backslashing it won't do anything.
                             */
            curchr = c
          }
        }
      }
    }
    return curchr
  }

    /*
     * Eat one lexed character.  Do this in a way that we can undo it.
     */
  private fun skipchr() {
    /* peekchr() eats a backslash, do the same here */
    prevchr_len = if (regparse!!.charAt() == '\\') {
      1
    } else {
      0
    }
    if (regparse!!.charAt(prevchr_len) != '\u0000') {
      ++prevchr_len
    }
    regparse!!.inc(prevchr_len)
    prev_at_start = at_start
    at_start = false
    prevprevchr = prevchr
    prevchr = curchr
    curchr = nextchr /* use previously unget char, or -1 */
    nextchr = -1
  }

    /*
     * Skip a character while keeping the value of prev_at_start for at_start.
     * prevchr and prevprevchr are also kept.
     */
  private fun skipchr_keepstart() {
    val `as` = prev_at_start
    val pr = prevchr
    val prpr = prevprevchr
    skipchr()
    at_start = `as`
    prevchr = pr
    prevprevchr = prpr
  }

  private fun getchr(): Int {
    val chr = peekchr()
    skipchr()
    return chr
  }

    /*
     * put character back.  Works only once!
     */
  private fun ungetchr() {
    nextchr = curchr
    curchr = prevchr
    prevchr = prevprevchr
    at_start = prev_at_start
    prev_at_start = false

        /* Backup regparse, so that it's at the same position as before the
         * getchr(). */regparse!!.dec(prevchr_len)
  }

    /*
     * read_limits - Read two integers to be taken as a minimum and maximum.
     * If the first character is '-', then the range is reversed.
     * Should end with 'end'.  If minval is missing, zero is default, if maxval is
     * missing, a very big number is the default.
     */
  private fun read_limits(): MinMax? {
    var reverse = false
    val first_char: CharPointer
    var minval: Int
    var maxval: Int
    if (regparse!!.charAt() == '-') {
      /* Starts with '-', so reverse the range later */
      regparse!!.inc()
      reverse = true
    }
    first_char = regparse!!.ref(0)
    minval = getdigits(regparse!!)
    maxval = if (regparse!!.charAt() == ',') /* There is a comma */ {
      if (Character.isDigit(regparse!!.inc().charAt())) {
        getdigits(regparse!!)
      } else {
        MAX_LIMIT
      }
    } else if (Character.isDigit(first_char.charAt())) {
      minval /* It was \{n} or \{-n} */
    } else {
      MAX_LIMIT /* It was \{} or \{-} */
    }
    if (regparse!!.charAt() == '\\') {
      regparse!!.inc() /* Allow either \{...} or \{...\} */
    }
    if (regparse!!.charAt() != '}' || maxval == 0 && minval == 0) {
      val `val` = if (reg_magic == MAGIC_ALL) "" else "\\"
      injector.messages.showStatusBarMessage(null, injector.messages.message(Msg.synerror, `val`))
      return null
    }

        /*
         * Reverse the range if there was a '-', or make sure it is in the right
         * order otherwise.
         */if (!reverse && minval > maxval || reverse && minval < maxval) {
      val tmp = minval
      minval = maxval
      maxval = tmp
    }
    skipchr() /* let's be friends with the lexer again */
    val res = MinMax()
    res.maxvalue = maxval
    res.minvalue = minval
    return res
  }

  private fun getdigits(p: CharPointer): Int {
    var res = 0
    var neg = false
    if (p.charAt() == '-') {
      neg = true
      p.inc()
    }
    while (Character.isDigit(p.charAt())) {
      res = res * 10 + p.charAt().digitToIntOrNull()!! ?: -1
      p.inc()
    }
    if (neg) {
      res = -res
    }
    return res
  }

    /*
     * vim_regexec and friends
     */
    /*
     * Get pointer to the line "lnum", which is relative to "reg_firstlnum".
     */
  private fun reg_getline(lnum: Int): CharPointer? {
        /* when looking behind for a match/no-match lnum is negative.  But we
         * can't go before line 1 */
    return if (reg_firstlnum + lnum < 0) {
      null
    } else {
      CharPointer(
        reg_buf!!.getLineBuffer(reg_firstlnum + lnum),
      )
    }

    // return ml_get_buf(reg_buf, reg_firstlnum + lnum, false);
  }

    /*
     * Match a regexp against a string.
     * "rmp->regprog" is a compiled regexp as returned by vim_regcomp().
     * Uses curbuf for line count and 'iskeyword'.
     *
     * Return true if there is a match, false if not.
     */
  fun vim_regexec(rmp: regmatch_T, line: CharPointer?, col: Int): Boolean {
    reg_match = rmp
    reg_mmatch = null
    reg_maxline = 0
    // reg_win = null;
    ireg_ic = rmp.rm_ic
    return vim_regexec_both(line, col) != 0
  }

    /*
     * Match a regexp against multiple lines.
     * "rmp->regprog" is a compiled regexp as returned by vim_regcomp().
     * Uses curbuf for line count and 'iskeyword'.
     *
     * Return zero if there is no match.  Return number of lines contained in the
     * match otherwise.
     */
  fun vim_regexec_multi(
    rmp: regmmatch_T, /*win_T win,*/
    buf: VimEditor?,
    lcount: Int,
    lnum: Int,
    col: Int,
  ): Int /* window in which to search or null */ /* buffer in which to search */ /* nr of line to start looking for match */ /* column to start looking for match */ {
    val r: Int
    // VimEditor save_curbuf = curbuf;
    reg_match = null
    reg_mmatch = rmp
    reg_buf = buf
    // reg_win = win;
    reg_firstlnum = lnum
    reg_maxline = lcount - lnum
    ireg_ic = rmp.rmm_ic

    /* Need to switch to buffer "buf" to make vim_iswordc() work. */
    // curbuf = buf;
    r = vim_regexec_both(null, col)
    // curbuf = save_curbuf;
    return r
  }

  fun vim_string_contains_regexp(rmp: regmmatch_T, string: String): Boolean {
    reg_match = null
    reg_mmatch = rmp
    ireg_ic = rmp.rmm_ic
    val prog: regprog_T?
    var s: CharPointer
    var retval = 0
    reg_tofree = null
    prog = reg_mmatch!!.regprog
    val line = CharPointer(string)
    reg_startpos = reg_mmatch!!.startpos
    reg_endpos = reg_mmatch!!.endpos

    /* Be paranoid... */if (prog == null) {
      injector.messages.showStatusBarMessage(null, injector.messages.message(Msg.e_null))
      return false
    }

    /* Check validity of program. */if (prog_magic_wrong()) {
      return false
    }

    /* If pattern contains "\c" or "\C": overrule value of ireg_ic */if (prog.regflags and RF_ICASE != 0) {
      ireg_ic = true
    } else if (prog.regflags and RF_NOICASE != 0) {
      ireg_ic = false
    }

    /* If there is a "must appear" string, look for it. */if (prog.regmust != null) {
      val c: Char
      c = prog.regmust!!.charAt()
      s = line
      while (cstrchr(s, c).also { s = it!! } != null) {
        if (cstrncmp(s, prog.regmust!!, prog.regmlen) == 0) {
          break /* Found it. */
        }
        s.inc()
      }
      if (s == null) /* Not present. */ {
        // goto the end;
        return false
      }
    }
    regline = line.ref(0)
    reglnum = 0
    out_of_stack = false
    val col = 0
    /* Simplest case: Anchored match need be tried only once. */
    val c: Char
    c = regline!!.charAt(col)
    if (prog.regstart == '\u0000' || prog.regstart == c ||
      ireg_ic && prog.regstart.lowercaseChar() == c.lowercaseChar()
    ) {
      retval = regtry(prog, col)
    }
    if (out_of_stack) {
      injector.messages.showStatusBarMessage(null, injector.messages.message(Msg.E363))
    }
    return retval > 0
  }

    /*
     * Match a regexp against a string ("line" points to the string) or multiple
     * lines ("line" is null, use reg_getline()).
     */
  private fun vim_regexec_both(line: CharPointer?, col: Int): Int /* column to start looking for match */ {
    var line = line
    var col = col
    val prog: regprog_T?
    var s: CharPointer?
    var retval: Int
    reg_tofree = null
    retval = 0
    if (reg_match == null) {
      prog = reg_mmatch!!.regprog
      line = reg_getline(0)
      reg_startpos = reg_mmatch!!.startpos
      reg_endpos = reg_mmatch!!.endpos
    } else {
      prog = reg_match!!.regprog
      reg_startp = reg_match!!.startp
      reg_endp = reg_match!!.endp
    }

    /* Be paranoid... */if (prog == null || line == null) {
      injector.messages.showStatusBarMessage(null, injector.messages.message(Msg.e_null))
      return retval
    }

    /* Check validity of program. */if (prog_magic_wrong()) {
      return retval
    }

    /* If pattern contains "\c" or "\C": overrule value of ireg_ic */if (prog.regflags and RF_ICASE != 0) {
      ireg_ic = true
    } else if (prog.regflags and RF_NOICASE != 0) {
      ireg_ic = false
    }

    /* If there is a "must appear" string, look for it. */if (prog.regmust != null) {
      val c: Char
      c = prog.regmust!!.charAt()
      s = line.ref(col)
      while (cstrchr(s!!, c).also { s = it } != null) {
        if (cstrncmp(s!!, prog.regmust!!, prog.regmlen) == 0) {
          break /* Found it. */
        }
        s!!.inc()
      }
      if (s == null) /* Not present. */ {
        // goto theend;
        return retval
      }
    }
    regline = line.ref(0)
    reglnum = 0
    out_of_stack = false

    /* Simplest case: Anchored match need be tried only once. */if (prog.reganch.code != 0) {
      val c: Char
      c = regline!!.charAt(col)
      retval = if (prog.regstart == '\u0000' || prog.regstart == c ||
        ireg_ic && prog.regstart.lowercaseChar() == c.lowercaseChar()
      ) {
        regtry(prog, col)
      } else {
        0
      }
    } else {
      /* Messy cases:  unanchored match. */
      while (!got_int && !out_of_stack) {
        if (prog.regstart != '\u0000') {
          /* Skip until the char we know it must start with. */
          s = cstrchr(regline!!.ref(col), prog.regstart)
          if (s == null) {
            retval = 0
            break
          }
          col = s!!.pointer() - regline!!.pointer()
        }
        retval = regtry(prog, col)
        if (retval > 0) {
          break
        }

        /* if not currently on the first line, get it again */if (reglnum != 0) {
          regline = reg_getline(0)
          reglnum = 0
        }
        if (regline!!.charAt(col) == '\u0000') {
          break
        }
        ++col
      }
    }
    if (out_of_stack) {
      injector.messages.showStatusBarMessage(null, injector.messages.message(Msg.E363))
    }

    /* Didn't find a match. */
    // vim_free(reg_tofree);
    return retval
  }

  class reg_extmatch_T {
    var matches = arrayOfNulls<String>(NSUBEXP)
  }

    /*
     * Create a new extmatch and mark it as referenced once.
     */
  private fun make_extmatch(): reg_extmatch_T {
    return reg_extmatch_T()
  }

    /*
     * Add a reference to an extmatch.
     */
    /*
    private reg_extmatch_T ref_extmatch(reg_extmatch_T em)
    {
        return em;
    }
    */
    /*
     * Remove a reference to an extmatch.  If there are no references left, free
     * the info.
     */
    /*
    private void unref_extmatch(reg_extmatch_T em)
    {
    }
    */
    /*
     * regtry - try match of "prog" with at regline["col"].
     * Returns 0 for failure, number of lines contained in the match otherwise.
     */
  private fun regtry(prog: regprog_T, col: Int): Int {
    reginput = regline!!.ref(col)
    need_clear_subexpr = true
    /* Clear the external match subpointers if necessary. */if (prog.reghasz.code == REX_SET) {
      need_clear_zsubexpr = true
    }
    if (regmatch(CharPointer(prog.program).ref(1))) {
      cleanup_subexpr()
      if (reg_match == null) {
        if (reg_startpos[0]!!.lnum < 0) {
          reg_startpos[0]!!.lnum = 0
          reg_startpos[0]!!.col = col
        }
        if (reg_endpos[0]!!.lnum < 0) {
          reg_endpos[0]!!.lnum = reglnum
          reg_endpos[0]!!.col = reginput!!.pointer() - regline!!.pointer()
        }
      } else {
        if (reg_startp[0] == null) {
          reg_startp[0] = regline!!.ref(col)
        }
        if (reg_endp[0] == null) {
          reg_endp[0] = reginput
        }
      }
      /* Package any found \z(...\) matches for export. Default is none. */
      // unref_extmatch(re_extmatch_out);
      re_extmatch_out = null
      if (prog.reghasz.code == REX_SET) {
        var i: Int
        cleanup_zsubexpr()
        re_extmatch_out = make_extmatch()
        i = 0
        while (i < NSUBEXP) {
          if (reg_match == null) {
            /* Only accept single line matches. */
            if (reg_startzpos[i]!!.lnum >= 0 && reg_endzpos[i]!!.lnum == reg_startzpos[i]!!.lnum) {
              re_extmatch_out!!.matches[i] = reg_getline(
                reg_startzpos[i]!!.lnum,
              )!!.ref(reg_startzpos[i]!!.col).substring(
                reg_endzpos[i]!!.col - reg_startzpos[i]!!.col,
              )
            }
          } else {
            if (reg_startzp[i] != null && reg_endzp[i] != null) {
              re_extmatch_out!!.matches[i] = reg_startzp[i]!!
                .substring(reg_endzp[i]!!.pointer() - reg_startzp[i]!!.pointer())
            }
          }
          i++
        }
      }
      return 1 + reglnum
    }
    return 0
  }

    /*
     * regmatch - main matching routine
     *
     * Conceptually the strategy is simple: Check to see whether the current
     * node matches, call self recursively to see whether the rest matches,
     * and then act accordingly.  In practice we make some effort to avoid
     * recursion, in particular by going through "ordinary" nodes (that don't
     * need to know whether the rest of the match failed) by a loop instead of
     * by recursion.
     *
     * Returns true when there is a match.  Leaves reginput and reglnum just after
     * the last matched character.
     * Returns false when there is no match.  Leaves reginput and reglnum in an
     * undefined state!
     */
  private fun regmatch(scan: CharPointer?): Boolean {
    var scan = scan
    var next: CharPointer? /* Next node. */
    var op: Int
    var c: Char

        /* Some patterns my cause a long time to match, even though they are not
         * illegal.  E.g., "\([a-z]\+\)\+Q".  Allow breaking them with CTRL-C. */
    // fast_breakcheck(); - TODO
    while (scan != null) {
      if (got_int || out_of_stack) {
        return false
      }
      next = regnext(scan)
      op = scan.OP()
      /* Check for character class with NL added. */if (WITH_NL(op) && reginput!!.isNul && reglnum < reg_maxline) {
        reg_nextline()
      } else {
        if (WITH_NL(op)) {
          op -= ADD_NL
        }
        c = reginput!!.charAt()
        when (op) {
          BOL -> if (!reginput!!.equals(regline)) {
            return false
          }
          EOL -> if (c != '\u0000') {
            return false
          }
          RE_BOF -> /* Passing -1 to the getline() function provided for the search
                         * should always return null if the current line is the first
                         * line of the file. */if (reglnum != 0 || !reginput!!.equals(regline) || reg_match == null && reg_getline(
              -1,
            ) != null
          ) {
            return false
          }
          RE_EOF -> if (reglnum != reg_maxline || c != '\u0000') {
            return false
          }
          CURSOR -> {
                        /* Check if the buffer is in a window and compare the
                         * reg_win->w_cursor position to the match position. */
            val curpos = reg_buf!!.currentCaret().getBufferPosition()
            if (reglnum + reg_firstlnum != curpos.line ||
              reginput!!.pointer() - regline!!.pointer() != curpos.column
            ) {
              return false
            }
          }
          RE_LNUM -> if (reg_match != null || !re_num_cmp(
              reglnum + reg_firstlnum,
              scan,
            )
          ) {
            return false
          }
          RE_COL -> if (!re_num_cmp(reginput!!.pointer() - regline!!.pointer() + 1, scan)) {
            return false
          }
          RE_VCOL -> {}
          BOW -> if (c == '\u0000') /* Can't match at end of line */ {
            return false
          } else {
            if (!CharacterClasses.isWord(c) || reginput!!.pointer() > regline!!.pointer() &&
              CharacterClasses.isWord(reginput!!.charAt(-1))
            ) {
              return false
            }
          }
          EOW -> {
            if (reginput!!.equals(regline)) /* Can't match at start of line */ {
              return false
            }
            if (!CharacterClasses.isWord(reginput!!.charAt(-1))) {
              return false
            }
            if (!reginput!!.isNul && CharacterClasses.isWord(c)) {
              return false
            }
          }
          ANY -> {
            if (c == '\u0000') {
              return false
            }
            reginput!!.inc()
          }
          IDENT -> {
            if (!Character.isJavaIdentifierPart(c)) {
              return false
            }
            reginput!!.inc()
          }
          SIDENT -> {
            if (Character.isDigit(reginput!!.charAt()) || !Character.isJavaIdentifierPart(c)) {
              return false
            }
            reginput!!.inc()
          }
          KWORD -> {
            if (!CharacterClasses.isWord(reginput!!.charAt())) {
              return false
            }
            reginput!!.inc()
          }
          SKWORD -> {
            if (Character.isDigit(reginput!!.charAt()) || !CharacterClasses.isWord(reginput!!.charAt())) {
              return false
            }
            reginput!!.inc()
          }
          FNAME -> {
            if (!CharacterClasses.isFile(c)) {
              return false
            }
            reginput!!.inc()
          }
          SFNAME -> {
            if (Character.isDigit(reginput!!.charAt()) || !CharacterClasses.isFile(c)) {
              return false
            }
            reginput!!.inc()
          }
          PRINT -> {
            if (!CharacterClasses.isPrint(reginput!!.charAt())) {
              return false
            }
            reginput!!.inc()
          }
          SPRINT -> {
            if (Character.isDigit(reginput!!.charAt()) || !CharacterClasses.isPrint(reginput!!.charAt())) {
              return false
            }
            reginput!!.inc()
          }
          WHITE -> {
            if (!CharacterClasses.isWhite(c)) {
              return false
            }
            reginput!!.inc()
          }
          NWHITE -> {
            if (c == '\u0000' || CharacterClasses.isWhite(c)) {
              return false
            }
            reginput!!.inc()
          }
          DIGIT -> {
            if (!Character.isDigit(c)) {
              return false
            }
            reginput!!.inc()
          }
          NDIGIT -> {
            if (c == '\u0000' || Character.isDigit(c)) {
              return false
            }
            reginput!!.inc()
          }
          HEX -> {
            if (!CharacterClasses.isHex(c)) {
              return false
            }
            reginput!!.inc()
          }
          NHEX -> {
            if (c == '\u0000' || CharacterClasses.isHex(c)) {
              return false
            }
            reginput!!.inc()
          }
          OCTAL -> {
            if (!CharacterClasses.isOctal(c)) {
              return false
            }
            reginput!!.inc()
          }
          NOCTAL -> {
            if (c == '\u0000' || CharacterClasses.isOctal(c)) {
              return false
            }
            reginput!!.inc()
          }
          WORD -> {
            if (!CharacterClasses.isWord(c)) {
              return false
            }
            reginput!!.inc()
          }
          NWORD -> {
            if (c == '\u0000' || CharacterClasses.isWord(c)) {
              return false
            }
            reginput!!.inc()
          }
          HEAD -> {
            if (!CharacterClasses.isHead(c)) {
              return false
            }
            reginput!!.inc()
          }
          NHEAD -> {
            if (c == '\u0000' || CharacterClasses.isHead(c)) {
              return false
            }
            reginput!!.inc()
          }
          ALPHA -> {
            if (!CharacterClasses.isAlpha(c)) {
              return false
            }
            reginput!!.inc()
          }
          NALPHA -> {
            if (c == '\u0000' || CharacterClasses.isAlpha(c)) {
              return false
            }
            reginput!!.inc()
          }
          LOWER -> {
            if (!CharacterClasses.isLower(c)) {
              return false
            }
            reginput!!.inc()
          }
          NLOWER -> {
            if (c == '\u0000' || CharacterClasses.isLower(c)) {
              return false
            }
            reginput!!.inc()
          }
          UPPER -> {
            if (!CharacterClasses.isUpper(c)) {
              return false
            }
            reginput!!.inc()
          }
          NUPPER -> {
            if (c == '\u0000' || CharacterClasses.isUpper(c)) {
              return false
            }
            reginput!!.inc()
          }
          EXACTLY -> {
            var len: Int
            var opnd: CharPointer
            opnd = scan.OPERAND()
            /* Inline the first byte, for speed. */if (opnd.charAt() != reginput!!.charAt() && (
                !ireg_ic ||
                  opnd.charAt().lowercaseChar() != reginput!!.charAt().lowercaseChar()
                )
            ) {
              return false
            }
            if (opnd.charAt(1) == '\u0000') {
              reginput!!.inc() /* matched a single char */
            } else {
              len = opnd.strlen()
              /* Need to match first byte again for multi-byte. */if (cstrncmp(
                  opnd,
                  reginput!!,
                  len,
                ) != 0
              ) {
                return false
              }
              reginput!!.inc(len)
            }
          }
          ANYOF, ANYBUT -> {
            if (c == '\u0000') {
              return false
            }
            if (cstrchr(scan.OPERAND(), c) == null == (op == ANYOF)) {
              return false
            }
            reginput!!.inc()
          }
          NOTHING -> {}
          BACK -> {}
          MOPEN, MOPEN + 1, MOPEN + 2, MOPEN + 3, MOPEN + 4, MOPEN + 5, MOPEN + 6, MOPEN + 7, MOPEN + 8, MOPEN + 9 -> {
            val no: Int
            val save = save_se_T()
            no = op - MOPEN
            cleanup_subexpr()
            save_se(save, reg_startpos[no]!!, reg_startp[no])
            if (regmatch(next)) {
              return true
            }
            restore_se(save, reg_startpos[no]!!, reg_startp[no])
            return false
          }
          NOPEN, NCLOSE -> return regmatch(next)
          ZOPEN + 1, ZOPEN + 2, ZOPEN + 3, ZOPEN + 4, ZOPEN + 5, ZOPEN + 6, ZOPEN + 7, ZOPEN + 8, ZOPEN + 9 -> {
            val no: Int
            val save = save_se_T()
            no = op - ZOPEN
            cleanup_zsubexpr()
            save_se(save, reg_startzpos[no]!!, reg_startzp[no])
            if (regmatch(next)) {
              return true
            }
            restore_se(save, reg_startzpos[no]!!, reg_startzp[no])
            return false
          }
          MCLOSE, MCLOSE + 1, MCLOSE + 2, MCLOSE + 3, MCLOSE + 4, MCLOSE + 5, MCLOSE + 6, MCLOSE + 7, MCLOSE + 8, MCLOSE + 9 -> {
            val no: Int
            val save = save_se_T()
            no = op - MCLOSE
            cleanup_subexpr()
            save_se(save, reg_endpos[no]!!, reg_endp[no])
            if (regmatch(next)) {
              return true
            }
            restore_se(save, reg_endpos[no]!!, reg_endp[no])
            return false
          }
          ZCLOSE + 1, ZCLOSE + 2, ZCLOSE + 3, ZCLOSE + 4, ZCLOSE + 5, ZCLOSE + 6, ZCLOSE + 7, ZCLOSE + 8, ZCLOSE + 9 -> {
            val no: Int
            val save = save_se_T()
            no = op - ZCLOSE
            cleanup_zsubexpr()
            save_se(save, reg_endzpos[no]!!, reg_endzp[no])
            if (regmatch(next)) {
              return true
            }
            restore_se(save, reg_endzpos[no]!!, reg_endzp[no])
            return false
          }
          BACKREF + 1, BACKREF + 2, BACKREF + 3, BACKREF + 4, BACKREF + 5, BACKREF + 6, BACKREF + 7, BACKREF + 8, BACKREF + 9 -> {
            var no: Int
            var len: Int
            var clnum: Int
            var ccol: Int
            var p: CharPointer?
            no = op - BACKREF
            cleanup_subexpr()
            if (reg_match != null) /* Single-line regexp */ {
              if (reg_endp[no] == null) {
                /* Backref was not set: Match an empty string. */
                len = 0
              } else {
                                /* Compare current input with back-ref in the same
                                     * line. */
                len = reg_endp[no]!!.pointer() - reg_startp[no]!!.pointer()
                if (cstrncmp(reg_startp[no]!!, reginput!!, len) != 0) {
                  return false
                }
              }
            } else /* Multi-line regexp */ {
              if (reg_endpos[no]!!.lnum < 0) {
                /* Backref was not set: Match an empty string. */
                len = 0
              } else {
                if (reg_startpos[no]!!.lnum == reglnum &&
                  reg_endpos[no]!!.lnum == reglnum
                ) {
                  /* Compare back-ref within the current line. */
                  len = reg_endpos[no]!!.col - reg_startpos[no]!!.col
                  if (cstrncmp(regline!!.ref(reg_startpos[no]!!.col), reginput!!, len) != 0) {
                    return false
                  }
                } else {
                                    /* Messy situation: Need to compare between two
                                         * lines. */
                  ccol = reg_startpos[no]!!.col
                  clnum = reg_startpos[no]!!.lnum
                  while (true) {
                                        /* Since getting one line may invalidate
                                             * the other, need to make copy.  Slow! */if (!regline!!.equals(reg_tofree)) {
                      reg_tofree = regline!!.ref(0)
                      reginput = reg_tofree!!.ref(reginput!!.pointer() - regline!!.pointer())
                      regline = reg_tofree!!.ref(0)
                    }

                    /* Get the line to compare with. */p = reg_getline(clnum)
                    len = if (clnum == reg_endpos[no]!!.lnum) {
                      reg_endpos[no]!!.col - ccol
                    } else {
                      p!!.ref(ccol).strlen()
                    }
                    if (cstrncmp(p!!.ref(ccol), reginput!!, len) != 0) {
                      return false /* doesn't match */
                    }
                    if (clnum == reg_endpos[no]!!.lnum) {
                      break /* match and at end! */
                    }
                    if (reglnum == reg_maxline) {
                      return false /* text too short */
                    }

                    /* Advance to next line. */reg_nextline()
                    ++clnum
                    ccol = 0
                    if (got_int || out_of_stack) {
                      return false
                    }
                  }

                                    /* found a match!  Note that regline may now point
                                         * to a copy of the line, that should not matter. */
                }
              }
            }

            /* Matched the backref, skip over it. */reginput!!.inc(len)
          }
          ZREF + 1, ZREF + 2, ZREF + 3, ZREF + 4, ZREF + 5, ZREF + 6, ZREF + 7, ZREF + 8, ZREF + 9 -> {
            var no: Int
            var len: Int
            cleanup_zsubexpr()
            no = op - ZREF
            val match = re_extmatch_in!!.matches[no]
            if (re_extmatch_in != null && match != null) {
              len = match.length
              if (cstrncmp(CharPointer(match), reginput!!, len) != 0) {
                return false
              }
              reginput!!.inc(len)
            } else {
              /* Backref was not set: Match an empty string. */
            }
          }
          BRANCH -> {
            if (next!!.OP() != BRANCH) /* No choice. */ {
              next = scan.OPERAND() /* Avoid recursion. */
            } else {
              val save = regsave_T()
              do {
                reg_save(save)
                if (regmatch(scan!!.OPERAND())) {
                  return true
                }
                reg_restore(save)
                scan = regnext(scan)
              } while (scan != null && scan.OP() == BRANCH)
              return false
              /* NOTREACHED */
            }
          }
          BRACE_LIMITS -> {
            var no: Int
            if (next!!.OP() == BRACE_SIMPLE) {
              bl_minval = scan.OPERAND_MIN()
              bl_maxval = scan.OPERAND_MAX()
            } else if (next.OP() >= BRACE_COMPLEX &&
              next.OP() < BRACE_COMPLEX + 10
            ) {
              no = next.OP() - BRACE_COMPLEX
              brace_min[no] = scan.OPERAND_MIN()
              brace_max[no] = scan.OPERAND_MAX()
              brace_count[no] = 0
            } else {
              injector.messages.showStatusBarMessage(null, injector.messages.message(Msg.e_internal))
              return false
            }
          }
          BRACE_COMPLEX, BRACE_COMPLEX + 1, BRACE_COMPLEX + 2, BRACE_COMPLEX + 3, BRACE_COMPLEX + 4, BRACE_COMPLEX + 5, BRACE_COMPLEX + 6, BRACE_COMPLEX + 7, BRACE_COMPLEX + 8, BRACE_COMPLEX + 9 -> {
            var no: Int
            val save = regsave_T()
            no = op - BRACE_COMPLEX
            ++brace_count[no]

            /* If not matched enough times yet, try one more */if (brace_count[no] <= (if (brace_min[no] <= brace_max[no]) brace_min[no] else brace_max[no])) {
              reg_save(save)
              if (regmatch(scan.OPERAND())) {
                return true
              }
              reg_restore(save)
              --brace_count[no] /* failed, decrement match count */
              return false
            }

            /* If matched enough times, may try matching some more */if (brace_min[no] <= brace_max[no]) {
              /* Range is the normal way around, use longest match */
              if (brace_count[no] <= brace_max[no]) {
                reg_save(save)
                if (regmatch(scan.OPERAND())) {
                  return true /* matched some more times */
                }
                reg_restore(save)
                --brace_count[no] /* matched just enough times */
                /* continue with the items after \{} */
              }
            } else {
              /* Range is backwards, use shortest match first */
              if (brace_count[no] <= brace_min[no]) {
                reg_save(save)
                if (regmatch(next)) {
                  return true
                }
                reg_restore(save)
                next = scan.OPERAND()
                /* must try to match one more item */
              }
            }
          }
          BRACE_SIMPLE, STAR, PLUS -> {
            val nextb: Char /* next byte */
            val nextb_ic: Char /* next byte reverse case */
            var count: Int
            val save = regsave_T()
            val minval: Int
            val maxval: Int

                        /*
                             * Lookahead to avoid useless match attempts when we know
                             * what character comes next.
                             */if (next!!.OP() == EXACTLY) {
              nextb = next.OPERAND().charAt()
              nextb_ic = if (ireg_ic) {
                if (Character.isUpperCase(nextb)) {
                  nextb.lowercaseChar()
                } else {
                  nextb.uppercaseChar()
                }
              } else {
                nextb
              }
            } else {
              nextb = '\u0000'
              nextb_ic = '\u0000'
            }
            if (op != BRACE_SIMPLE) {
              minval = if (op == STAR) 0 else 1
              maxval = MAX_LIMIT
            } else {
              minval = bl_minval
              maxval = bl_maxval
            }

                        /*
                             * When maxval > minval, try matching as much as possible, up
                             * to maxval.  When maxval < minval, try matching at least the
                             * minimal number (since the range is backwards, that's also
                             * maxval!).
                             */count = regrepeat(scan.OPERAND(), maxval)
            if (got_int) {
              return false
            }
            if (minval <= maxval) {
              /* Range is the normal way around, use longest match */
              while (count >= minval) {
                /* If it could match, try it. */
                if (nextb == '\u0000' || reginput!!.charAt() == nextb || reginput!!.charAt() == nextb_ic) {
                  reg_save(save)
                  if (regmatch(next)) {
                    return true
                  }
                  reg_restore(save)
                }
                /* Couldn't or didn't match -- back up one char. */if (--count < minval) {
                  break
                }
                if (reginput!!.equals(regline)) {
                  /* backup to last char of previous line */
                  --reglnum
                  regline = reg_getline(reglnum)
                  /* Just in case regrepeat() didn't count right. */if (regline == null) {
                    return false
                  }
                  reginput = regline!!.ref(regline!!.strlen())
                  // fast_breakcheck(); - TOOD
                  if (got_int || out_of_stack) {
                    return false
                  }
                } else {
                  reginput!!.dec()
                }
              }
            } else {
                            /* Range is backwards, use shortest match first.
                                 * Careful: maxval and minval are exchanged! */
              if (count < maxval) {
                return false
              }
              while (true) {
                /* If it could work, try it. */if (nextb == '\u0000' || reginput!!.charAt() == nextb || reginput!!.charAt() == nextb_ic) {
                  reg_save(save)
                  if (regmatch(next)) {
                    return true
                  }
                  reg_restore(save)
                }
                /* Couldn't or didn't match: try advancing one char. */if (count == minval || regrepeat(
                    scan.OPERAND(),
                    1,
                  ) == 0
                ) {
                  break
                }
                ++count
                if (got_int || out_of_stack) {
                  return false
                }
              }
            }
            return false
          }
          NOMATCH -> {
            val save = regsave_T()

                        /* If the operand matches, we fail.  Otherwise backup and
                             * continue with the next item. */reg_save(save)
            if (regmatch(scan.OPERAND())) {
              return false
            }
            reg_restore(save)
          }
          MATCH, SUBPAT -> {
            val save = regsave_T()

                        /* If the operand doesn't match, we fail.  Otherwise backup
                             * and continue with the next item. */reg_save(save)
            if (!regmatch(scan.OPERAND())) {
              return false
            }
            if (op == MATCH) /* zero-width */ {
              reg_restore(save)
            }
          }
          BEHIND, NOBEHIND -> {
            val save_after = regsave_T()
            val save_start = regsave_T()
            val save_behind_pos: regsave_T?
            val needmatch = op == BEHIND

                        /*
                             * Look back in the input of the operand matches or not. This
                             * must be done at every position in the input and checking if
                             * the match ends at the current position.
                             * First check if the next item matches, that's probably
                             * faster.
                             */reg_save(save_start)
            if (regmatch(next)) {
              /* save the position after the found match for next */
              reg_save(save_after)

                            /* start looking for a match with operand at the current
                                 * postion.  Go back one character until we find the
                                 * result, hitting the start of the line or the previous
                                 * line (for multi-line matching).
                                 * Set behind_pos to where the match should end, BHPOS
                                 * will match it. */save_behind_pos = if (behind_pos == null) {
                null
              } else {
                regsave_T(
                  behind_pos!!,
                )
              }
              behind_pos = regsave_T(save_start)
              while (true) {
                reg_restore(save_start)
                if (regmatch(scan.OPERAND()) && reg_save_equal(behind_pos!!)) {
                  behind_pos = save_behind_pos
                  /* found a match that ends where "next" started */if (needmatch) {
                    reg_restore(save_after)
                    return true
                  }
                  return false
                }
                                /*
                                     * No match: Go back one character.  May go to
                                     * previous line once.
                                     */if (reg_match == null) {
                  if (save_start.pos.col == 0) {
                    if (save_start.pos.lnum < behind_pos!!.pos.lnum ||
                      reg_getline(--save_start.pos.lnum) == null
                    ) {
                      break
                    }
                    reg_restore(save_start)
                    save_start.pos.col = regline!!.strlen()
                  } else {
                    --save_start.pos.col
                  }
                } else {
                  if (save_start.ptr === regline) {
                    break
                  }
                  save_start.ptr!!.dec()
                }
              }

              /* NOBEHIND succeeds when no match was found */behind_pos = save_behind_pos
              if (!needmatch) {
                reg_restore(save_after)
                return true
              }
            }
            return false
          }
          BHPOS -> if (reg_match == null) {
            if (behind_pos!!.pos.col != reginput!!.pointer() - regline!!.pointer() ||
              behind_pos!!.pos.lnum != reglnum
            ) {
              return false
            }
          } else if (behind_pos!!.ptr !== reginput) {
            return false
          }
          NEWL -> {
            if (c != '\u0000' || reglnum == reg_maxline) {
              return false
            }
            reg_nextline()
          }
          END -> return true /* Success! */
          else -> {
            injector.messages.showStatusBarMessage(null, injector.messages.message(Msg.e_re_corr))
            return false
          }
        }
      }
      scan = next
    }

        /*
         * We get here only if there's trouble -- normally "case END" is the
         * terminating point.
         */injector.messages.showStatusBarMessage(null, injector.messages.message(Msg.e_re_corr))
    return false
  }

    /*
     * regrepeat - repeatedly match something simple, return how many.
     * Advances reginput (and reglnum) to just after the matched chars.
     */
  private fun regrepeat(p: CharPointer, maxcount: Int): Int {
    var count = 0
    var scan: CharPointer
    val opnd: CharPointer
    var mask = 0
    var testval = 0
    scan = reginput!!.ref(0) /* Make local copy of reginput for speed. */
    opnd = p.OPERAND()
    when (p.OP()) {
      ANY, ANY + ADD_NL -> while (count < maxcount) {
                /* Matching anything means we continue until end-of-line (or
                     * end-of-file for ANY + ADD_NL), only limited by maxcount. */
        while (!scan.isNul && count < maxcount) {
          ++count
          scan.inc()
        }
        if (!WITH_NL(p.OP()) || reglnum == reg_maxline || count == maxcount) {
          break
        }
        ++count /* count the line-break */
        reg_nextline()
        scan = reginput!!.ref(0)
        if (got_int) {
          break
        }
      }
      IDENT, IDENT + ADD_NL -> {
        testval = 1
        while (count < maxcount) {
          if (Character.isJavaIdentifierPart(scan.charAt()) &&
            (testval == 1 || !Character.isDigit(scan.charAt()))
          ) {
            scan.inc()
          } else if (scan.isNul) {
            if (!WITH_NL(p.OP()) || reglnum == reg_maxline) {
              break
            }
            reg_nextline()
            scan = reginput!!.ref(0)
            if (got_int) {
              break
            }
          } else {
            break
          }
          ++count
        }
      }
      SIDENT, SIDENT + ADD_NL -> while (count < maxcount) {
        if (Character.isJavaIdentifierPart(scan.charAt()) &&
          (testval == 1 || !Character.isDigit(scan.charAt()))
        ) {
          scan.inc()
        } else if (scan.isNul) {
          if (!WITH_NL(p.OP()) || reglnum == reg_maxline) {
            break
          }
          reg_nextline()
          scan = reginput!!.ref(0)
          if (got_int) {
            break
          }
        } else {
          break
        }
        ++count
      }
      KWORD, KWORD + ADD_NL -> {
        testval = 1
        while (count < maxcount) {
          if (CharacterClasses.isWord(scan.charAt()) && (testval == 1 || !Character.isDigit(scan.charAt()))) {
            scan.inc()
          } else if (scan.isNul) {
            if (!WITH_NL(p.OP()) || reglnum == reg_maxline) {
              break
            }
            reg_nextline()
            scan = reginput!!.ref(0)
            if (got_int) {
              break
            }
          } else {
            break
          }
          ++count
        }
      }
      SKWORD, SKWORD + ADD_NL -> while (count < maxcount) {
        if (CharacterClasses.isWord(scan.charAt()) && (testval == 1 || !Character.isDigit(scan.charAt()))) {
          scan.inc()
        } else if (scan.isNul) {
          if (!WITH_NL(p.OP()) || reglnum == reg_maxline) {
            break
          }
          reg_nextline()
          scan = reginput!!.ref(0)
          if (got_int) {
            break
          }
        } else {
          break
        }
        ++count
      }
      FNAME, FNAME + ADD_NL -> {
        testval = 1
        while (count < maxcount) {
          if (CharacterClasses.isFile(scan.charAt()) && (testval == 1 || !Character.isDigit(scan.charAt()))) {
            scan.inc()
          } else if (scan.isNul) {
            if (!WITH_NL(p.OP()) || reglnum == reg_maxline) {
              break
            }
            reg_nextline()
            scan = reginput!!.ref(0)
            if (got_int) {
              break
            }
          } else {
            break
          }
          ++count
        }
      }
      SFNAME, SFNAME + ADD_NL -> while (count < maxcount) {
        if (CharacterClasses.isFile(scan.charAt()) && (testval == 1 || !Character.isDigit(scan.charAt()))) {
          scan.inc()
        } else if (scan.isNul) {
          if (!WITH_NL(p.OP()) || reglnum == reg_maxline) {
            break
          }
          reg_nextline()
          scan = reginput!!.ref(0)
          if (got_int) {
            break
          }
        } else {
          break
        }
        ++count
      }
      PRINT, PRINT + ADD_NL -> {
        testval = 1
        while (count < maxcount) {
          if (scan.isNul) {
            if (!WITH_NL(p.OP()) || reglnum == reg_maxline) {
              break
            }
            reg_nextline()
            scan = reginput!!.ref(0)
            if (got_int) {
              break
            }
          } else if (CharacterClasses.isPrint(scan.charAt()) &&
            (testval == 1 || !Character.isDigit(scan.charAt()))
          ) {
            scan.inc()
          } else {
            break
          }
          ++count
        }
      }
      SPRINT, SPRINT + ADD_NL -> while (count < maxcount) {
        if (scan.isNul) {
          if (!WITH_NL(p.OP()) || reglnum == reg_maxline) {
            break
          }
          reg_nextline()
          scan = reginput!!.ref(0)
          if (got_int) {
            break
          }
        } else if (CharacterClasses.isPrint(scan.charAt()) &&
          (testval == 1 || !Character.isDigit(scan.charAt()))
        ) {
          scan.inc()
        } else {
          break
        }
        ++count
      }
      WHITE, WHITE + ADD_NL -> {
        mask = CharacterClasses.RI_WHITE
        testval = mask
      }
      NWHITE, NWHITE + ADD_NL -> mask = CharacterClasses.RI_WHITE
      DIGIT, DIGIT + ADD_NL -> {
        mask = CharacterClasses.RI_DIGIT
        testval = mask
      }
      NDIGIT, NDIGIT + ADD_NL -> mask = CharacterClasses.RI_DIGIT
      HEX, HEX + ADD_NL -> {
        mask = CharacterClasses.RI_HEX
        testval = mask
      }
      NHEX, NHEX + ADD_NL -> mask = CharacterClasses.RI_HEX
      OCTAL, OCTAL + ADD_NL -> {
        mask = CharacterClasses.RI_OCTAL
        testval = mask
      }
      NOCTAL, NOCTAL + ADD_NL -> mask = CharacterClasses.RI_OCTAL
      WORD, WORD + ADD_NL -> {
        mask = CharacterClasses.RI_WORD
        testval = mask
      }
      NWORD, NWORD + ADD_NL -> mask = CharacterClasses.RI_WORD
      HEAD, HEAD + ADD_NL -> {
        mask = CharacterClasses.RI_HEAD
        testval = mask
      }
      NHEAD, NHEAD + ADD_NL -> mask = CharacterClasses.RI_HEAD
      ALPHA, ALPHA + ADD_NL -> {
        mask = CharacterClasses.RI_ALPHA
        testval = mask
      }
      NALPHA, NALPHA + ADD_NL -> mask = CharacterClasses.RI_ALPHA
      LOWER, LOWER + ADD_NL -> {
        mask = CharacterClasses.RI_LOWER
        testval = mask
      }
      NLOWER, NLOWER + ADD_NL -> mask = CharacterClasses.RI_LOWER
      UPPER, UPPER + ADD_NL -> {
        mask = CharacterClasses.RI_UPPER
        testval = mask
      }
      NUPPER, NUPPER + ADD_NL -> mask = CharacterClasses.RI_UPPER
      EXACTLY -> {
        val cu: Char
        val cl: Char

                /* This doesn't do a multi-byte character, because a MULTIBYTECODE
                     * would have been used for it. */if (ireg_ic) {
          cu = opnd.charAt().uppercaseChar()
          cl = opnd.charAt().lowercaseChar()
          while (count < maxcount && (scan.charAt() == cu || scan.charAt() == cl)) {
            count++
            scan.inc()
          }
        } else {
          cu = opnd.charAt()
          while (count < maxcount && scan.charAt() == cu) {
            count++
            scan.inc()
          }
        }
      }
      ANYOF, ANYOF + ADD_NL -> {
        testval = 1
        while (count < maxcount) {
          if (scan.isNul) {
            if (!WITH_NL(p.OP()) || reglnum == reg_maxline) {
              break
            }
            reg_nextline()
            scan = reginput!!.ref(0)
            if (got_int) {
              break
            }
          } else {
            if (cstrchr(opnd, scan.charAt()) == null == (testval == 1)) {
              break
            }
            scan.inc()
          }
          ++count
        }
      }
      ANYBUT, ANYBUT + ADD_NL -> while (count < maxcount) {
        if (scan.isNul) {
          if (!WITH_NL(p.OP()) || reglnum == reg_maxline) {
            break
          }
          reg_nextline()
          scan = reginput!!.ref(0)
          if (got_int) {
            break
          }
        } else {
          if (cstrchr(opnd, scan.charAt()) == null == (testval == 1)) {
            break
          }
          scan.inc()
        }
        ++count
      }
      NEWL -> while (count < maxcount && scan.isNul && reglnum < reg_maxline) {
        count++
        reg_nextline()
        scan = reginput!!.ref(0)
        if (got_int) {
          break
        }
      }
      else -> injector.messages.showStatusBarMessage(null, injector.messages.message(Msg.e_re_corr))
    }
    if (mask != 0) {
      while (count < maxcount) {
        if (scan.isNul) {
          if (!WITH_NL(p.OP()) || reglnum == reg_maxline) {
            break
          }
          reg_nextline()
          scan = reginput!!.ref(0)
          if (got_int) {
            break
          }
        } else if (CharacterClasses.isMask(scan.charAt(), mask, testval)) {
          scan.inc()
        } else {
          break
        }
        ++count
      }
    }
    reginput = scan.ref(0)
    return count
  }

    /*
     * regnext - dig the "next" pointer out of a node
     */
  private fun regnext(p: CharPointer): CharPointer? {
    val offset: Int
    offset = p.NEXT()
    if (offset == 0) {
      return null
    }
    return if (p.OP() == BACK) {
      p.ref(-offset)
    } else {
      p.ref(offset)
    }
  }

    /*
     * Check the regexp program for its magic number.
     * Return true if it's wrong.
     */
  private fun prog_magic_wrong(): Boolean {
    if ((if (reg_match == null) reg_mmatch!!.regprog!!.program else reg_match!!.regprog!!.program)[0].code != REGMAGIC) {
      injector.messages.showStatusBarMessage(null, injector.messages.message(Msg.e_re_corr))
      return true
    }
    return false
  }

    /*
     * Cleanup the subexpressions, if this wasn't done yet.
     * This construction is used to clear the subexpressions only when they are
     * used (to increase speed).
     */
  private fun cleanup_subexpr() {
    if (need_clear_subexpr) {
      if (reg_match == null) {
        /* Use 0xff to set lnum to -1 */
        for (i in 0 until NSUBEXP) {
          reg_startpos[i]!!.col = -1
          reg_startpos[i]!!.lnum = -1
          reg_endpos[i]!!.col = -1
          reg_endpos[i]!!.lnum = -1
        }
      } else {
        for (i in 0 until NSUBEXP) {
          reg_startp[i] = null
          reg_endp[i] = null
        }
      }
      need_clear_subexpr = false
    }
  }

  private fun cleanup_zsubexpr() {
    if (need_clear_zsubexpr) {
      if (reg_match == null) {
        /* Use 0xff to set lnum to -1 */
        for (i in 0 until NSUBEXP) {
          reg_startzpos[i]!!.col = -1
          reg_startzpos[i]!!.lnum = -1
          reg_endzpos[i]!!.col = -1
          reg_endzpos[i]!!.lnum = -1
        }
      } else {
        for (i in 0 until NSUBEXP) {
          reg_startzp[i] = null
          reg_endzp[i] = null
        }
      }
      need_clear_zsubexpr = false
    }
  }

    /*
     * Advance reglnum, regline and reginput to the next line.
     */
  private fun reg_nextline() {
    regline = reg_getline(++reglnum)
    reginput = regline!!.ref(0)
    // fast_breakcheck(); TODO
  }

    /*
     * Save the input line and position in a regsave_T.
     */
  private fun reg_save(save: regsave_T) {
    if (reg_match == null) {
      save.pos.col = reginput!!.pointer() - regline!!.pointer()
      save.pos.lnum = reglnum
    } else {
      save.ptr = reginput!!.ref(0)
    }
  }

    /*
     * Restore the input line and position from a regsave_T.
     */
  private fun reg_restore(save: regsave_T) {
    if (reg_match == null) {
      if (reglnum != save.pos.lnum) {
                /* only call reg_getline() when the line number changed to save
                 * a bit of time */
        reglnum = save.pos.lnum
        regline = reg_getline(reglnum)
      }
      reginput = regline!!.ref(save.pos.col)
    } else {
      reginput = save.ptr!!.ref(0)
    }
  }

    /*
     * Return true if current position is equal to saved position.
     */
  private fun reg_save_equal(save: regsave_T): Boolean {
    return if (reg_match == null) {
      reglnum == save.pos.lnum && reginput!!.equals(regline!!.ref(save.pos.col))
    } else {
      reginput!!.equals(save.ptr)
    }
  }

    /*
     * Tentatively set the sub-expression start to the current position (after
     * calling regmatch() they will have changed).  Need to save the existing
     * values for when there is no match.
     * Use pointer or position, depending on reg_match == null.
     */
  private fun save_se(savep: save_se_T, posp: lpos_T, pp: CharPointer?) {
    if (reg_match == null) {
      savep.pos.lnum = posp.lnum
      savep.pos.col = posp.col
      posp.lnum = reglnum
      posp.col = reginput!!.pointer() - regline!!.pointer()
    } else if (pp != null) {
      savep.ptr = pp.ref(0)
      pp.assign(reginput!!)
    }
  }

    /*
     * We were wrong, restore the sub-expressions.
     */
  private fun restore_se(savep: save_se_T, posp: lpos_T, pp: CharPointer?) {
    if (reg_match == null) {
      posp.col = savep.pos.col
      posp.lnum = savep.pos.lnum
    } else {
      pp?.assign(savep.ptr!!)
    }
  }

    /*
     * Compare a number with the operand of RE_LNUM, RE_COL or RE_VCOL.
     */
  private fun re_num_cmp(`val`: Int, scan: CharPointer): Boolean {
    val n = scan.OPERAND_MIN()
    if (scan.OPERAND_CMP() == '>') {
      return `val` > n
    }
    return if (scan.OPERAND_CMP() == '<') {
      `val` < n
    } else {
      `val` == n
    }
  }

    /*
     * Compare two strings, ignore case if ireg_ic set.
     * Return 0 if strings match, non-zero otherwise.
     */
  private fun cstrncmp(s1: CharPointer, s2: CharPointer, n: Int): Int {
    return s1.strncmp(s2, n, ireg_ic)
  }

    /*
     * cstrchr: This function is used a lot for simple searches, keep it fast!
     */
  private fun cstrchr(s: CharPointer, c: Char): CharPointer? {
    return if (!ireg_ic) {
      s.strchr(c)
    } else {
      s.istrchr(c)
    }

        /* tolower() and toupper() can be slow, comparing twice should be a lot
         * faster (esp. when using MS Visual C++!).
         * For UTF-8 need to use folded case. */
        /* was 1,173ms
        int cc;
        if (CharacterClasses.isUpper(c))
        {
            cc = Character.toLowerCase(c);
        }
        else if (CharacterClasses.isLower(c))
        {
            cc = Character.toUpperCase(c);
        }
        else
        {
            return s.strchr(c);
        }
        */

    /* Faster version for when there are no multi-byte characters. */
        /*
        CharPointer p = s.ref(0);
        char ch;
        while ((ch = p.charAt()) != '\u0000')
        {
            if (ch == c || ch == cc)
            {
                return p;
            }

            p.inc();
        }
        */

        /* was 2,053ms
        for (p = s.ref(0); !p.isNul(); p.inc())
        {
            char ch = p.charAt();
            if (ch == c || ch == cc)
            {
                return p;
            }
        }
        */

    // return null;
  }
  /***************************************************************
   * regsub stuff                             *
   */
    /*
     * regtilde(): Replace tildes in the pattern by the old pattern.
     *
     * Short explanation of the tilde: It stands for the previous replacement
     * pattern.  If that previous pattern also contains a ~ we should go back a
     * step further...  But we insert the previous pattern into the current one
     * and remember that.
     * This still does not handle the case where "magic" changes. TODO?
     *
     * The tildes are parsed once before the first call to vim_regsub().
     */
  // public CharPointer regtilde(CharPointer source, boolean magic)
  // {
  //    CharPointer newsub = source.ref(0);
  //    CharPointer tmpsub;
  //    CharPointer p;
  //    int len;
  //    int prevlen;
  //
  //    for (p = newsub.ref(0); !p.isNul(); p.inc())
  //    {
  //        if ((p.charAt() == '~' && magic != 0) || (p.charAt() == '\\' && p.charAt(1) == '~' && magic == 0))
  //        {
  //            if (reg_prev_sub != null)
  //            {
  //                /* length = len(newsub) - 1 + len(prev_sub) + 1 */
  //                prevlen = reg_prev_sub.strlen();
  //                tmpsub = alloc((unsigned)(STRLEN(newsub) + prevlen));
  //                if (tmpsub != null)
  //                {
  //                    /* copy prefix */
  //                    len = (int)(p - newsub);    /* not including ~ */
  //                    mch_memmove(tmpsub, newsub, (size_t)len);
  //                    /* interpretate tilde */
  //                    mch_memmove(tmpsub + len, reg_prev_sub, (size_t)prevlen);
  //                    /* copy postfix */
  //                    if (!magic)
  //                        ++p;                    /* back off \ */
  //                    STRCPY(tmpsub + len + prevlen, p + 1);
  //
  //                    if (newsub != source)       /* already allocated newsub */
  //                        vim_free(newsub);
  //                    newsub = tmpsub;
  //                    p = newsub + len + prevlen;
  //                }
  //            }
  //            else if (magic)
  //                STRCPY(p, p + 1);               /* remove '~' */
  //            else
  //                STRCPY(p, p + 2);               /* remove '\~' */
  //            --p;
  //        }
  //        else if (*p == '\\' && p[1])            /* skip escaped characters */
  //        ++p;
  //    }
  //
  //    vim_free(reg_prev_sub);
  //    if (newsub != source)       /* newsub was allocated, just keep it */
  //        reg_prev_sub = newsub;
  //    else                        /* no ~ found, need to save newsub  */
  //        reg_prev_sub = vim_strsave(newsub);
  //    return newsub;
  // }
  /**
   * vim_regsub() - perform substitutions after a vim_regexec() or
   * vim_regexec_multi() match.
   *
   *
   * If "copy" is true really copy into "dest".
   * If "copy" is false nothing is copied, this is just to find out the length
   * of the result.
   *
   *
   * If "backslash" is true, a backslash will be removed later, need to double
   * them to keep them, and insert a backslash before a CR to avoid it being
   * replaced with a line break later.
   *
   *
   * Note: The matched text must not change between the call of
   * vim_regexec()/vim_regexec_multi() and vim_regsub()!  It would make the back
   * references invalid!
   *
   *
   * Returns the size of the replacement, including terminating '\u0000'.
   */
  fun vim_regsub(rmp: regmatch_T?, source: CharPointer?, magic: Int, backslash: Boolean): String? {
    reg_match = rmp
    reg_mmatch = null
    reg_maxline = 0
    return vim_regsub_both(source, magic, backslash)
  }

  fun vim_regsub_multi(rmp: regmmatch_T?, lnum: Int, source: CharPointer?, magic: Int, backslash: Boolean): String? {
    reg_match = null
    reg_mmatch = rmp
    // reg_buf = curbuf;           /* always works on the current buffer! */
    reg_firstlnum = lnum
    reg_maxline = reg_buf!!.lineCount() - lnum
    return vim_regsub_both(source, magic, backslash)
  }

  private fun subappend(mode: Int, dst: StringBuffer, c: Char): Int {
    var mode = mode
    when (mode) {
      'u'.code -> {
        mode = 0
        dst.append(c.uppercaseChar())
      }
      'U'.code -> dst.append(c.uppercaseChar())
      'l'.code -> {
        mode = 0
        dst.append(c.lowercaseChar())
      }
      'L'.code -> dst.append(c.lowercaseChar())
      else -> dst.append(c)
    }
    return mode
  }

  private fun vim_regsub_both(source: CharPointer?, magic: Int, backslash: Boolean): String? {
    val src: CharPointer
    val dst = StringBuffer()
    var s: CharPointer?
    var c: Char
    var no = -1
    var clnum = 0 /* init for GCC */
    var len = 0 /* init for GCC */
    // CharPointer eval_result = null;
    var mode = 0

    /* Be paranoid... */if (source == null) {
      injector.messages.showStatusBarMessage(null, injector.messages.message(Msg.e_null))
      return null
    }
    if (prog_magic_wrong()) {
      return null
    }
    src = source.ref(0)

        /*
         * When the substitute part starts with "\=" evaluate it as an expression.
         */if (source.charAt(0) == '\\' && source.charAt(1) == '=') {
    } else {
      while (src.charAt().also { c = it } != '\u0000') {
        src.inc()
        if (c == '&' && magic != 0) {
          no = 0
        } else if (c == '\\' && !src.isNul) {
          if (src.charAt() == '&' && magic == 0) {
            src.inc()
            no = 0
          } else if ('0' <= src.charAt() && src.charAt() <= '9') {
            no = src.charAt() - '0'
            src.inc()
          } else if ("uUlLeE".indexOf(src.charAt()) != -1) {
            when (src.charAtInc()) {
              'u' -> {
                mode = 'u'.code
                continue
              }
              'U' -> {
                mode = 'U'.code
                continue
              }
              'l' -> {
                mode = 'l'.code
                continue
              }
              'L' -> {
                mode = 'L'.code
                continue
              }
              'e', 'E' -> {
                mode = 0
                continue
              }
            }
          }
        }
        if (no < 0) /* Ordinary character. */ {
          if (c == '\\' && !src.isNul) {
            /* Check for abbreviations -- webb */
            // In vim '\u0000' is represented in memory as '\n', and '\n' as '\r', see :help NL-used-for-Nul
            when (src.charAt()) {
              'r' -> {
                c = '\n'
                src.inc()
              }
              'n' -> {
                c = '\u0000'
                src.inc()
              }
              't' -> {
                c = '\t'
                src.inc()
              }
              'b' -> {
                c = '\b'
                src.inc()
              }
              else -> {
                if (backslash) {
                  dst.append('\\')
                }
                c = src.charAt()
                src.inc()
              }
            }
          }

          /* Write to buffer, if copy is set. */mode = subappend(mode, dst, c)
        } else {
          if (reg_match == null) {
            clnum = reg_mmatch!!.startpos[no]!!.lnum
            if (clnum < 0 || reg_mmatch!!.endpos[no]!!.lnum < 0) {
              s = null
            } else {
              s = reg_getline(clnum)!!.ref(reg_mmatch!!.startpos[no]!!.col)
              len = if (reg_mmatch!!.endpos[no]!!.lnum == clnum) {
                reg_mmatch!!.endpos[no]!!.col - reg_mmatch!!.startpos[no]!!.col
              } else {
                s.strlen()
              }
            }
          } else {
            s = reg_match!!.startp[no]
            if (reg_match!!.endp[no] == null) {
              s = null
            } else {
              len = reg_match!!.endp[no]!!.pointer() - s!!.pointer()
            }
          }
          if (s != null) {
            while (true) {
              if (len == 0) {
                if (reg_match == null) {
                  if (reg_mmatch!!.endpos[no]!!.lnum == clnum) {
                    break
                  }
                  dst.append('\r')
                  s = reg_getline(++clnum)
                  len = if (reg_mmatch!!.endpos[no]!!.lnum == clnum) {
                    reg_mmatch!!.endpos[no]!!.col
                  } else {
                    s!!.strlen()
                  }
                } else {
                  break
                }
              } else if (s!!.isNul) /* we hit '\u0000'. */ {
                injector.messages.showStatusBarMessage(null, injector.messages.message(Msg.e_re_damg))
                return dst.toString()
              } else {
                if (backslash && (s.charAt() == '\r' || s.charAt() == '\\')) {
                                    /*
                                     * Insert a backslash in front of a CR, otherwise
                                     * it will be replaced by a line break.
                                     * Number of backslashes will be halved later,
                                     * double them here.
                                     */
                  dst.append('\\')
                  dst.append(s.charAt())
                } else {
                  mode = subappend(mode, dst, s.charAt())
                }
                s.inc()
                --len
              }
            }
          }
          no = -1
        }
      }
    }
    return dst.toString()
  }

    /*
     * Used for the submatch() function: get the string from tne n'th submatch in
     * allocated memory.
     * Returns null when not in a ":s" command and for a non-existing submatch.
     */
    /*
    public String reg_submatch(int no)
    {
        StringBuffer retval = null;
        CharPointer s;
        int len;
        int round;
        int lnum;

        if (!can_f_submatch)
            return null;

        if (submatch_match == null)
        {
            // First round: compute the length and allocate memory.
            // Second round: copy the text.
            for (round = 1; round <= 2; ++round)
            {
                lnum = submatch_mmatch.startpos[no].lnum;
                if (lnum < 0 || submatch_mmatch.endpos[no].lnum < 0)
                {
                    return null;
                }

                s = reg_getline(lnum).ref(submatch_mmatch.startpos[no].col);
                if (s == null)  // anti-crash check, cannot happen?
                {
                    break;
                }
                if (submatch_mmatch.endpos[no].lnum == lnum)
                {
                    // Within one line: take form start to end col.
                    len = submatch_mmatch.endpos[no].col - submatch_mmatch.startpos[no].col;
                    if (round == 2)
                    {
                        retval.append(s.substring(len));
                    }
                    ++len;
                }
                else
                {
                    // Multiple lines: take start line from start col, middle
                    // lines completely and end line up to end col.
                    len = s.strlen();
                    if (round == 2)
                    {
                        retval.append(s.substring(len));
                    }
                    ++len;
                    ++lnum;
                    while (lnum < submatch_mmatch.endpos[no].lnum)
                    {
                        s = reg_getline(lnum++);
                        if (round == 2)
                        {
                            retval.append(s.substring(s.strlen()));
                        }
                        len += s.strlen();
                        if (round == 2)
                        {
                            retval.append('\n');
                        }
                        ++len;
                    }
                    if (round == 2)
                    {
                        retval.append(reg_getline(lnum).substring(submatch_mmatch.endpos[no].col));
                    }
                    len += submatch_mmatch.endpos[no].col;
                    if (round == 2)
                    {
                        //retval[len] = '\u0000';
                    }
                    ++len;
                }

                if (round == 1)
                {
                    retval = new StringBuffer();
                    if (s == null)
                        return null;
                }
            }
        }
        else
        {
            if (submatch_match.endp[no] == null)
            {
                retval = null;
            }
            else
            {
                s = submatch_match.startp[no];
                retval = new StringBuffer(s.substring(submatch_match.endp[no].pointer() - s.pointer()));
            }
        }

        return retval == null ? null : retval.toString();
    }
    */
    /*
     * regdump - dump a regexp onto stdout in vaguely comprehensible form
     */
  private fun regdump(pattern: String, r: regprog_T): String {
    val start: CharPointer
    val s: CharPointer
    var op = EXACTLY /* Arbitrary non-END op. */
    var next: CharPointer?
    var end: CharPointer? = null
    val res = StringBuilder()
    res.append("\nregcomp(").append(pattern).append("):\n")
    start = CharPointer(r.program)
    s = start.ref(1)
        /*
        * Loop until we find the END that isn't before a referred next (an END
        * can also appear in a NOMATCH operand).
        */while (op != END || !s.end()) {
      op = s.OP()
      res.append(s.pointer() - start.pointer())
      res.append(regprop(s))
      next = regnext(s)
      if (next == null) /* Next ptr. */ {
        res.append("(0)")
      } else {
        res.append("(").append(s.pointer() - start.pointer() + (next.pointer() - s.pointer())).append(")")
      }
      if (end == null || next != null && end.pointer() < next.pointer()) {
        end = next
      }
      if (op == BRACE_LIMITS) {
        /* Two short ints */
        res.append(" minval ")
        res.append(s.OPERAND_MIN())
        res.append(", maxval ")
        res.append(s.OPERAND_MAX())
        s.inc(8)
      }
      s.inc(3)
      if (op == ANYOF || op == ANYOF + ADD_NL || op == ANYBUT || op == ANYBUT + ADD_NL || op == EXACTLY) {
        /* Literal string, where present. */
        while (!s.isNul) {
          res.append(s.charAt())
          s.inc()
        }
        s.inc()
      }
      res.append("\n")
    }

    /* Header fields of interest. */if (r.regstart != '\u0000') {
      res.append("start `")
      if (r.regstart < ' ') {
        res.append("^").append('@' + r.regstart.code)
      } else {
        res.append(r.regstart)
      }
      res.append("' ")
      res.append(Integer.toString(r.regstart.code, 16))
    }
    if (r.reganch.code != 0) {
      res.append("anchored: ")
    }
    if (r.regmust != null) {
      res.append("must have \"").append(r.regmust!!.substring(r.regmust!!.strlen())).append("\"")
    }
    res.append("\n")
    return res.toString()
  }

    /*
* regprop - printable representation of opcode
*/
  private fun regprop(op: CharPointer): @NonNls String {
    val p: @NonNls String?
    val buf = StringBuilder()
    buf.append(':')
    p = when (op.OP()) {
      BOL -> "BOL"
      EOL -> "EOL"
      RE_BOF -> "BOF"
      RE_EOF -> "EOF"
      CURSOR -> "CURSOR"
      RE_LNUM -> "RE_LNUM"
      RE_COL -> "RE_COL"
      RE_VCOL -> "RE_VCOL"
      BOW -> "BOW"
      EOW -> "EOW"
      ANY -> "ANY"
      ANY + ADD_NL -> "ANY+NL"
      ANYOF -> "ANYOF"
      ANYOF + ADD_NL -> "ANYOF+NL"
      ANYBUT -> "ANYBUT"
      ANYBUT + ADD_NL -> "ANYBUT+NL"
      IDENT -> "IDENT"
      IDENT + ADD_NL -> "IDENT+NL"
      SIDENT -> "SIDENT"
      SIDENT + ADD_NL -> "SIDENT+NL"
      KWORD -> "KWORD"
      KWORD + ADD_NL -> "KWORD+NL"
      SKWORD -> "SKWORD"
      SKWORD + ADD_NL -> "SKWORD+NL"
      FNAME -> "FNAME"
      FNAME + ADD_NL -> "FNAME+NL"
      SFNAME -> "SFNAME"
      SFNAME + ADD_NL -> "SFNAME+NL"
      PRINT -> "PRINT"
      PRINT + ADD_NL -> "PRINT+NL"
      SPRINT -> "SPRINT"
      SPRINT + ADD_NL -> "SPRINT+NL"
      WHITE -> "WHITE"
      WHITE + ADD_NL -> "WHITE+NL"
      NWHITE -> "NWHITE"
      NWHITE + ADD_NL -> "NWHITE+NL"
      DIGIT -> "DIGIT"
      DIGIT + ADD_NL -> "DIGIT+NL"
      NDIGIT -> "NDIGIT"
      NDIGIT + ADD_NL -> "NDIGIT+NL"
      HEX -> "HEX"
      HEX + ADD_NL -> "HEX+NL"
      NHEX -> "NHEX"
      NHEX + ADD_NL -> "NHEX+NL"
      OCTAL -> "OCTAL"
      OCTAL + ADD_NL -> "OCTAL+NL"
      NOCTAL -> "NOCTAL"
      NOCTAL + ADD_NL -> "NOCTAL+NL"
      WORD -> "WORD"
      WORD + ADD_NL -> "WORD+NL"
      NWORD -> "NWORD"
      NWORD + ADD_NL -> "NWORD+NL"
      HEAD -> "HEAD"
      HEAD + ADD_NL -> "HEAD+NL"
      NHEAD -> "NHEAD"
      NHEAD + ADD_NL -> "NHEAD+NL"
      ALPHA -> "ALPHA"
      ALPHA + ADD_NL -> "ALPHA+NL"
      NALPHA -> "NALPHA"
      NALPHA + ADD_NL -> "NALPHA+NL"
      LOWER -> "LOWER"
      LOWER + ADD_NL -> "LOWER+NL"
      NLOWER -> "NLOWER"
      NLOWER + ADD_NL -> "NLOWER+NL"
      UPPER -> "UPPER"
      UPPER + ADD_NL -> "UPPER+NL"
      NUPPER -> "NUPPER"
      NUPPER + ADD_NL -> "NUPPER+NL"
      BRANCH -> "BRANCH"
      EXACTLY -> "EXACTLY"
      NOTHING -> "NOTHING"
      BACK -> "BACK"
      END -> "END"
      MOPEN -> "MATCH START"
      MOPEN + 1, MOPEN + 2, MOPEN + 3, MOPEN + 4, MOPEN + 5, MOPEN + 6, MOPEN + 7, MOPEN + 8, MOPEN + 9 -> {
        buf.append("MOPEN").append(op.OP() - MOPEN)
        null
      }
      MCLOSE -> "MATCH END"
      MCLOSE + 1, MCLOSE + 2, MCLOSE + 3, MCLOSE + 4, MCLOSE + 5, MCLOSE + 6, MCLOSE + 7, MCLOSE + 8, MCLOSE + 9 -> {
        buf.append("MCLOSE").append(op.OP() - MCLOSE)
        null
      }
      BACKREF + 1, BACKREF + 2, BACKREF + 3, BACKREF + 4, BACKREF + 5, BACKREF + 6, BACKREF + 7, BACKREF + 8, BACKREF + 9 -> {
        buf.append("BACKREF").append(op.OP() - BACKREF)
        null
      }
      NOPEN -> "NOPEN"
      NCLOSE -> "NCLOSE"
      ZOPEN + 1, ZOPEN + 2, ZOPEN + 3, ZOPEN + 4, ZOPEN + 5, ZOPEN + 6, ZOPEN + 7, ZOPEN + 8, ZOPEN + 9 -> {
        buf.append("ZOPEN").append(op.OP() - ZOPEN)
        null
      }
      ZCLOSE + 1, ZCLOSE + 2, ZCLOSE + 3, ZCLOSE + 4, ZCLOSE + 5, ZCLOSE + 6, ZCLOSE + 7, ZCLOSE + 8, ZCLOSE + 9 -> {
        buf.append("ZCLOSE").append(op.OP() - ZCLOSE)
        null
      }
      ZREF + 1, ZREF + 2, ZREF + 3, ZREF + 4, ZREF + 5, ZREF + 6, ZREF + 7, ZREF + 8, ZREF + 9 -> {
        buf.append("ZREF").append(op.OP() - ZREF)
        null
      }
      STAR -> "STAR"
      PLUS -> "PLUS"
      NOMATCH -> "NOMATCH"
      MATCH -> "MATCH"
      BEHIND -> "BEHIND"
      NOBEHIND -> "NOBEHIND"
      SUBPAT -> "SUBPAT"
      BRACE_LIMITS -> "BRACE_LIMITS"
      BRACE_SIMPLE -> "BRACE_SIMPLE"
      BRACE_COMPLEX, BRACE_COMPLEX + 1, BRACE_COMPLEX + 2, BRACE_COMPLEX + 3, BRACE_COMPLEX + 4, BRACE_COMPLEX + 5, BRACE_COMPLEX + 6, BRACE_COMPLEX + 7, BRACE_COMPLEX + 8, BRACE_COMPLEX + 9 -> {
        buf.append("BRACE_COMPLEX").append(op.OP() - BRACE_COMPLEX)
        null
      }
      NEWL -> "NEWL"
      else -> {
        buf.append("corrupt ").append(op.OP())
        null
      }
    }
    if (p != null) {
      buf.append(p)
    }
    return buf.toString()
  }

  class regprog_T {
    var regstart = 0.toChar()
    var reganch = 0.toChar()
    var regmust: CharPointer? = null
    var regmlen = 0
    var regflags = 0
    var reghasz = 0.toChar()
    var program = StringBuffer()
  }

  private class MinMax {
    var minvalue = 0
    var maxvalue = 0
  }

  class lpos_T {
    constructor(pos: lpos_T) {
      lnum = pos.lnum
      col = pos.col
    }

    constructor() {}

    @JvmField
    var lnum = 0

    @JvmField
    var col = 0
    override fun toString(): String {
      return "lpos: ($lnum, $col)"
    }
  }

    /*
    * Structure used to save the current input state, when it needs to be
    * restored after trying a match.  Used by reg_save() and reg_restore().
    */
  private class regsave_T {
    var ptr /* reginput pointer, for single-line regexp */: CharPointer? = null
    var pos = lpos_T() /* reginput pos, for multi-line regexp */

    constructor() {}
    constructor(rhs: regsave_T) {
      ptr = if (rhs.ptr == null) null else CharPointer("").assign(rhs.ptr!!)
      pos = lpos_T(rhs.pos)
    }
  }

  /* struct to save start/end pointer/position in for \(\) */
  private class save_se_T {
    var ptr: CharPointer? = null
    var pos = lpos_T()
  }

  class regmatch_T {
    var regprog: regprog_T? = null
    var startp = arrayOfNulls<CharPointer>(NSUBEXP)
    var endp = arrayOfNulls<CharPointer>(NSUBEXP)
    var rm_ic = false
  }

  class regmmatch_T {
    @JvmField
    var regprog: regprog_T? = null

    @JvmField
    var startpos = arrayOfNulls<lpos_T>(NSUBEXP)

    @JvmField
    var endpos = arrayOfNulls<lpos_T>(NSUBEXP)

    @JvmField
    var rmm_ic = false

    init {
      for (i in 0 until NSUBEXP) {
        startpos[i] = lpos_T()
        endpos[i] = lpos_T()
      }
    }
  }

  private val reg_do_extmatch = 0
  private val reg_prev_sub: CharPointer? = null
  private var regparse /* Input-scan pointer. */: CharPointer? = null
  private var prevchr_len /* byte length of previous char */ = 0
  private var num_complex_braces /* Complex \{...} count */ = 0
  private var regnpar /* () count. */ = 0
  private var regnzpar /* \z() count. */ = 0
  private var re_has_z /* \z item detected */ = 0.toChar()
  private var regcode /* Code-emit pointer */: CharPointer? = null
  private val had_endbrace = BooleanArray(NSUBEXP) /* flags, true if end of () found */
  private var regflags /* RF_ flags for prog */ = 0
  private val brace_min = IntArray(10) /* Minimums for complex brace repeats */
  private val brace_max = IntArray(10) /* Maximums for complex brace repeats */
  private val brace_count = IntArray(10) /* Current counts for complex brace repeats */
  private var had_eol /* true when EOL found by vim_regcomp() */ = false
  private var one_exactly = false /* only do one char for EXACTLY */
  private var reg_magic /* magicness of the pattern: */ = 0
  private var curchr = 0

    /*
    * getchr() - get the next character from the pattern. We know about
    * magic and such, so therefore we need a lexical analyzer.
    */
  /* static int       curchr; */
  private var prevprevchr = 0
  private var prevchr = 0
  private var nextchr /* used for ungetchr() */ = 0

    /*
    * Note: prevchr is sometimes -1 when we are not at the start,
    * eg in /[ ^I]^ the pattern was never found even if it existed, because ^ was
    * taken to be magic -- webb
    */
  private var at_start /* True when on the first character */ = false
  private var prev_at_start /* True when on the second character */ = false

    /*
    * Global work variables for vim_regexec().
    */
  /* The current match-position is remembered with these variables: */
  private var reglnum /* line number, relative to first line */ = 0
  private var regline /* start of current line */: CharPointer? = null
  private var reginput /* current input, points into "regline" */: CharPointer? = null
  private var need_clear_subexpr /* subexpressions still need to be
    * cleared */ = false
  private var need_clear_zsubexpr = false /* extmatch subexpressions
    * still need to be cleared */
  private var out_of_stack /* true when ran out of stack space */ = false

    /*
    * Internal copy of 'ignorecase'.  It is set at each call to vim_regexec().
    * Normally it gets the value of "rm_ic" or "rmm_ic", but when the pattern
    * contains '\c' or '\C' the value is overruled.
    */
  private var ireg_ic = false

    /*
    * Sometimes need to save a copy of a line.  Since alloc()/free() is very
    * slow, we keep one allocated piece of memory and only re-allocate it when
    * it's too small.  It's freed in vim_regexec_both() when finished.
    */
  private var reg_tofree: CharPointer? = null

  // private int reg_tofreelen;
    /*
    * These variables are set when executing a regexp to speed up the execution.
    * Which ones are set depends on whethere a single-line or multi-line match is
    * done:
    *                      single-line             multi-line
    * reg_match            &regmatch_T             null
    * reg_mmatch           null                    &regmmatch_T
    * reg_startp           reg_match->startp       <invalid>
    * reg_endp             reg_match->endp         <invalid>
    * reg_startpos         <invalid>               reg_mmatch->startpos
    * reg_endpos           <invalid>               reg_mmatch->endpos
    * reg_win              null                    window in which to search
    * reg_buf              <invalid>               buffer in which to search
    * reg_firstlnum        <invalid>               first line in which to search
    * reg_maxline          0                       last line nr
    */
  private var reg_match: regmatch_T? = null
  private var reg_mmatch: regmmatch_T? = null
  private var reg_startp = arrayOfNulls<CharPointer>(NSUBEXP)
  private var reg_endp = arrayOfNulls<CharPointer>(NSUBEXP)
  private var reg_startpos = arrayOfNulls<lpos_T>(NSUBEXP)
  private var reg_endpos = arrayOfNulls<lpos_T>(NSUBEXP)

  // static win_T            *reg_win;
  private var reg_buf: VimEditor? = null
  private var reg_firstlnum = 0
  private var reg_maxline = 0
  private var behind_pos: regsave_T? = null
  private val reg_startzp = arrayOfNulls<CharPointer>(NSUBEXP) /* Workspace to mark beginning */
  private val reg_endzp = arrayOfNulls<CharPointer>(NSUBEXP) /*   and end of \z(...\) matches */
  private val reg_startzpos = arrayOfNulls<lpos_T>(NSUBEXP) /* idem, beginning pos */
  private val reg_endzpos = arrayOfNulls<lpos_T>(NSUBEXP) /* idem, end pos */
  private val got_int = false

    /*
    * The arguments from BRACE_LIMITS are stored here.  They are actually local
    * to regmatch(), but they are here to reduce the amount of stack space used
    * (it can be called recursively many times).
    */
  private var bl_minval = 0
  private var bl_maxval = 0

  companion object {
    var re_extmatch_out: reg_extmatch_T? = null
    var re_extmatch_in: reg_extmatch_T? = null

        /*
     * The opcodes are:
     */
    /* definition                   number             opnd?    meaning */
    private const val END = 0 /*      End of program or NOMATCH operand. */
    private const val BOL = 1 /*      Match "" at beginning of line. */
    private const val EOL = 2 /*      Match "" at end of line. */
    private const val BRANCH = 3 /* node Match this alternative, or the next... */
    private const val BACK = 4 /*      Match "", "next" ptr points backward. */
    private const val EXACTLY = 5 /* str  Match this string. */
    private const val NOTHING = 6 /*      Match empty string. */
    private const val STAR = 7 /* node Match this (simple) thing 0 or more times. */
    private const val PLUS = 8 /* node Match this (simple) thing 1 or more times. */
    private const val MATCH = 9 /* node match the operand zero-width */
    private const val NOMATCH = 10 /* node check for no match with operand */
    private const val BEHIND = 11 /* node look behind for a match with operand */
    private const val NOBEHIND = 12 /* node look behind for no match with operand */
    private const val SUBPAT = 13 /* node match the operand here */
    private const val BRACE_SIMPLE = 14 /* node Match this (simple) thing between m and
                                                  *      n times (\{m,n\}). */
    private const val BOW = 15 /*      Match "" after [^a-zA-Z0-9_] */
    private const val EOW = 16 /*      Match "" at    [^a-zA-Z0-9_] */
    private const val BRACE_LIMITS = 17 /* nr nr  define the min & max for BRACE_SIMPLE
                                                  *      and BRACE_COMPLEX. */
    private const val NEWL = 18 /*      Match line-break */
    private const val BHPOS = 19 /*      End position for BEHIND or NOBEHIND */

    /* character classes: 20-48 normal, 50-78 include a line-break */
    private const val ADD_NL = 30
    private const val ANY = 20 /*      Match any one character. */
    private const val FIRST_NL = ANY + ADD_NL
    private const val ANYOF = 21 /* str  Match any character in this string. */
    private const val ANYBUT = 22 /* str  Match any character not in this
                                                  *      string. */
    private const val IDENT = 23 /*      Match identifier char */
    private const val SIDENT = 24 /*      Match identifier char but no digit */
    private const val KWORD = 25 /*      Match keyword char */
    private const val SKWORD = 26 /*      Match word char but no digit */
    private const val FNAME = 27 /*      Match file name char */
    private const val SFNAME = 28 /*      Match file name char but no digit */
    private const val PRINT = 29 /*      Match printable char */
    private const val SPRINT = 30 /*      Match printable char but no digit */
    private const val WHITE = 31 /*      Match whitespace char */
    private const val NWHITE = 32 /*      Match non-whitespace char */
    private const val DIGIT = 33 /*      Match digit char */
    private const val NDIGIT = 34 /*      Match non-digit char */
    private const val HEX = 35 /*      Match hex char */
    private const val NHEX = 36 /*      Match non-hex char */
    private const val OCTAL = 37 /*      Match octal char */
    private const val NOCTAL = 38 /*      Match non-octal char */
    private const val WORD = 39 /*      Match word char */
    private const val NWORD = 40 /*      Match non-word char */
    private const val HEAD = 41 /*      Match head char */
    private const val NHEAD = 42 /*      Match non-head char */
    private const val ALPHA = 43 /*      Match alpha char */
    private const val NALPHA = 44 /*      Match non-alpha char */
    private const val LOWER = 45 /*      Match lowercase char */
    private const val NLOWER = 46 /*      Match non-lowercase char */
    private const val UPPER = 47 /*      Match uppercase char */
    private const val NUPPER = 48 /*      Match non-uppercase char */
    private const val LAST_NL = NUPPER + ADD_NL
    private const val MOPEN = 80 /* -89       Mark this point in input as start of
                                                 *       \( subexpr.  MOPEN + 0 marks start of
                                                 *       match. */
    private const val MCLOSE = 90 /* -99       Analogous to MOPEN.  MCLOSE + 0 marks
                                                 *       end of match. */
    private const val BACKREF = 100 /* -109 node Match same string again \1-\9 */
    private const val ZOPEN = 110 /* -119      Mark this point in input as start of
                                                 *       \z( subexpr. */
    private const val ZCLOSE = 120 /* -129      Analogous to ZOPEN. */
    private const val ZREF = 130 /* -139 node Match external submatch \z1-\z9 */
    private const val BRACE_COMPLEX = 140 /* -149 node Match nodes between m & n times */
    private const val NOPEN = 150 /*      Mark this point in input as start of
                                                        \%( subexpr. */
    private const val NCLOSE = 151 /*      Analogous to NOPEN. */
    private const val RE_BOF = 201 /*      Match "" at beginning of file. */
    private const val RE_EOF = 202 /*      Match "" at end of file. */
    private const val CURSOR = 203 /*      Match location of cursor. */
    private const val RE_LNUM = 204 /* nr cmp  Match line number */
    private const val RE_COL = 205 /* nr cmp  Match column number */
    private const val RE_VCOL = 206 /* nr cmp  Match virtual column number */
    private const val REGMAGIC = 156
    private const val REX_SET = 1
    private const val REX_USE = 2
    private const val MAX_LIMIT = Int.MAX_VALUE
    private const val NOT_MULTI = 0
    private const val MULTI_ONE = 1
    private const val MULTI_MULT = 2

        /*
    * Flags to be passed up and down.
    */
    private const val HASWIDTH = 0x1 /* Known never to match null string. */
    private const val SIMPLE = 0x2 /* Simple enough to be STAR/PLUS operand. */
    private const val SPSTART = 0x4 /* Starts with * or +. */
    private const val HASNL = 0x8 /* Contains some \n. */
    private const val WORST = 0 /* Worst case. */

        /*
    * REGEXP_INRANGE contains all characters which are always special in a []
    * range after '\'.
    * REGEXP_ABBR contains all characters which act as abbreviations after '\'.
    * These are:
    *  \n  - New line (NL).
    *  \r  - Carriage Return (CR).
    *  \t  - Tab (TAB).
    *  \e  - Escape (ESC).
    *  \b  - Backspace (Ctrl_H).
    */
    private const val REGEXP_INRANGE = "]^-n\\"
    private const val REGEXP_ABBR = "nrteb"

    /* flags for regflags */
    private const val RF_ICASE = 1 /* ignore case */
    private const val RF_NOICASE = 2 /* don't ignore case */
    private const val RF_HASNL = 4 /* can match a NL */

        /*
     * Global work variables for vim_regcomp().
     */
    private const val NSUBEXP = 10
    private const val MAGIC_NONE = 1 /* "\V" very unmagic */
    private const val MAGIC_OFF = 2 /* "\M" or 'magic' off */
    private const val MAGIC_ON = 3 /* "\m" or 'magic' */
    private const val MAGIC_ALL = 4 /* "\v" very magic */

        /*
     * META contains all characters that may be magic, except '^' and '$'.
     */
    /* META[] is used often enough to justify turning it into a table. */
    private val META_flags = intArrayOf(
      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
      0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /*                 %  &     (  )  *  +        .    */
      0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1, 1, 0, 0, 1, 0, /*     1  2  3  4  5  6  7  8  9        <  =  >  ? */
      0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, /*  @  A     C  D     F     H  I     K  L  M     O */
      1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, /*  P        S     U  V  W  X        [           _ */
      1, 0, 0, 1, 0, 1, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1, /*     a     c  d     f     h  i     k  l  m  n  o */
      0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, /*  p        s     u  v  w  x     z  {  |     ~    */
      1, 0, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1,
    )

    /* arguments for reg() */
    private const val REG_NOPAREN = 0 /* toplevel reg() */
    private const val REG_PAREN = 1 /* \(\) */
    private const val REG_ZPAREN = 2 /* \z(\) */
    private const val REG_NPAREN = 3 /* \%(\) */
    private fun WITH_NL(op: Int): Boolean {
      return op >= FIRST_NL && op <= LAST_NL
    }

        /*
     * Check for a character class name.  "pp" points to the '['.
     * Returns one of the CLASS_ items. CLASS_NONE means that no item was
     * recognized.  Otherwise "pp" is advanced to after the item.
     */
    private fun skip_class_name(pp: CharPointer): Int {
      var i: Int
      if (pp.charAt(1) == ':') {
        i = 0
        while (i < (CharacterClasses.CLASS_NAMES?.size ?: 0)) {
          if (pp.ref(2)
              .strncmp(CharacterClasses.CLASS_NAMES!![i], CharacterClasses.CLASS_NAMES[i].length) == 0
          ) {
            pp.inc(CharacterClasses.CLASS_NAMES[i].length + 2)
            return i
          }
          ++i
        }
      }
      return CharacterClasses.CLASS_NONE
    }

        /*
     * Skip over a "[]" range.
     * "p" must point to the character after the '['.
     * The returned pointer is on the matching ']', or the terminating NUL.
     */
    private fun skip_anyof(p: CharPointer): CharPointer {
      if (p.charAt() == '^') /* Complement of range. */ {
        p.inc()
      }
      if (p.charAt() == ']' || p.charAt() == '-') {
        p.inc()
      }
      while (!p.end() && p.charAt() != ']') {
        if (p.charAt() == '-') {
          p.inc()
          if (!p.end() && p.charAt() != ']') {
            p.inc()
          }
        } else if (p.charAt() == '\\' &&
          (REGEXP_INRANGE.indexOf(p.charAt(1)) != -1 || REGEXP_ABBR.indexOf(p.charAt(1)) != -1)
        ) {
          p.inc(2)
        } else if (p.charAt() == '[') {
          if (skip_class_name(p) == CharacterClasses.CLASS_NONE) {
            p.inc() /* It was not a class name */
          }
        } else {
          p.inc()
        }
      }
      return p
    }

        /*
     * Skip past regular expression.
     * Stop at end of 'p' of where 'dirc' is found ('/', '?', etc).
     * Take care of characters with a backslash in front of it.
     * Skip strings inside [ and ].
     */
    @JvmStatic
    fun skip_regexp(p: CharPointer, dirc: Char, magic: Boolean): CharPointer {
      var p = p
      var mymagic: Int
      mymagic = if (magic) {
        MAGIC_ON
      } else {
        MAGIC_OFF
      }
      while (!p.end()) {
        if (p.charAt() == dirc) /* found end of regexp */ {
          break
        }
        if (p.charAt() == '[' && mymagic >= MAGIC_ON ||
          p.charAt() == '\\' && p.charAt(1) == '[' && mymagic <= MAGIC_OFF
        ) {
          p = skip_anyof(p.ref(1))
          if (p.end()) {
            break
          }
        } else if (p.charAt() == '\\' && p.charAt(1) != '\u0000') {
          p.inc() /* skip next character */
          if (p.charAt() == 'v') {
            mymagic = MAGIC_ALL
          } else if (p.charAt() == 'V') {
            mymagic = MAGIC_NONE
          }
        }
        p.inc()
      }
      return p
    }

    // private boolean can_f_submatch = false;      /* true when submatch() can be used */
        /* These pointers are used instead of reg_match and reg_mmatch for
    * reg_submatch().  Needed for when the substitution string is an expression
    * that contains a call to substitute() and submatch(). */
    // private regmatch_T       submatch_match;
    // private regmmatch_T      submatch_mmatch;
    private val logger: VimLogger = injector.getLogger<RegExp>(RegExp::class.java)
  }
}