171 lines
2.8 KiB
Go
171 lines
2.8 KiB
Go
package remap
|
|
|
|
import (
|
|
"regexp"
|
|
)
|
|
|
|
/*
|
|
Compile is a convenience shorthand for:
|
|
|
|
var err error
|
|
var r *remap.ReMap = new(remap.ReMap)
|
|
|
|
if r.Regexp, err = regexp.Compile(expr); err != nil {
|
|
// ...
|
|
}
|
|
|
|
It corresponds to [regexp.Compile].
|
|
*/
|
|
func Compile(expr string) (r *ReMap, err error) {
|
|
|
|
var p *regexp.Regexp
|
|
|
|
if p, err = regexp.Compile(expr); err != nil {
|
|
return
|
|
}
|
|
|
|
r = &ReMap{
|
|
Regexp: p,
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
/*
|
|
CompilePOSIX is a convenience shorthand for:
|
|
|
|
var err error
|
|
var r *remap.ReMap = new(remap.ReMap)
|
|
|
|
if r.Regexp, err = regexp.CompilePOSIX(expr); err != nil {
|
|
// ...
|
|
}
|
|
|
|
It corresponds to [regexp.CompilePOSIX].
|
|
*/
|
|
func CompilePOSIX(expr string) (r *ReMap, err error) {
|
|
|
|
var p *regexp.Regexp
|
|
|
|
if p, err = regexp.CompilePOSIX(expr); err != nil {
|
|
return
|
|
}
|
|
|
|
r = &ReMap{
|
|
Regexp: p,
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
/*
|
|
MustCompile is a convenience shorthand for:
|
|
|
|
var r *remap.ReMap = &remap.ReMap{
|
|
Regexp: regexp.MustCompile(expr),
|
|
}
|
|
|
|
It corresponds to [regexp.MustCompile].
|
|
*/
|
|
func MustCompile(expr string) (r *ReMap) {
|
|
|
|
var err error
|
|
var p *regexp.Regexp
|
|
|
|
// We panic ourselves instead of wrapping regexp.MustCompile.
|
|
// Makes debuggers a little more explicit.
|
|
if p, err = regexp.Compile(expr); err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
r = &ReMap{
|
|
Regexp: p,
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
/*
|
|
MustCompilePOSIX is a convenience shorthand for:
|
|
|
|
var r *remap.ReMap = &remap.ReMap{
|
|
Regexp: regexp.MustCompilePOSIX(expr),
|
|
}
|
|
|
|
It corresponds to [regexp.MustCompilePOSIX].
|
|
*/
|
|
func MustCompilePOSIX(expr string) (r *ReMap) {
|
|
|
|
var err error
|
|
var p *regexp.Regexp
|
|
|
|
// We panic ourselves instead of wrapping regexp.MustCompilePOSIX.
|
|
// Makes debuggers a little more explicit.
|
|
if p, err = regexp.CompilePOSIX(expr); err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
r = &ReMap{
|
|
Regexp: p,
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
/*
|
|
strIdxSlicer takes string s, and returns the substring marked by idxPair,
|
|
where:
|
|
|
|
idxPair = [2]int{
|
|
<substring START POSITION>,
|
|
<substring END BOUNDARY>,
|
|
}
|
|
|
|
That is, to get `oo` from `foobar`,
|
|
|
|
idxPair = [2]int{1, 3}
|
|
# NOT:
|
|
#idxPair = [2]int{1, 2}
|
|
|
|
subStr will be empty and matched will be false if:
|
|
|
|
* idxPair[0] < 0
|
|
* idxPair[1] < 0
|
|
|
|
It will panic with [ErrShortStr] if:
|
|
|
|
* idxPair[0] > len(s)-1
|
|
* idxPair[1] > len(s)
|
|
|
|
It will panic with [ErrInvalidIdxPair] if:
|
|
|
|
* idxPair[0] > idxPair[1]
|
|
|
|
It will properly handle single-character addresses (i.e. idxPair[0] == idxPair[1]).
|
|
*/
|
|
func strIdxSlicer(s string, idxPair [2]int) (subStr string, matched bool) {
|
|
|
|
if idxPair[0] < 0 || idxPair[1] < 0 {
|
|
return
|
|
}
|
|
matched = true
|
|
|
|
if (idxPair[0] > (len(s) - 1)) ||
|
|
(idxPair[1] > len(s)) {
|
|
panic(ErrShortStr)
|
|
}
|
|
if idxPair[0] > idxPair[1] {
|
|
panic(ErrInvalidIdxPair)
|
|
}
|
|
|
|
if idxPair[0] == idxPair[1] {
|
|
// single character
|
|
subStr = string(s[idxPair[0]])
|
|
} else {
|
|
// multiple characters
|
|
subStr = s[idxPair[0]:idxPair[1]]
|
|
}
|
|
|
|
return
|
|
}
|