136 lines
2.7 KiB
Go
136 lines
2.7 KiB
Go
package parser
|
|
|
|
import (
|
|
"strings"
|
|
|
|
"asciigoat.org/core/lexer"
|
|
)
|
|
|
|
// AcceptQuotedString consumes a quoted string from the source
|
|
// and returns it unquoted and unescaped
|
|
func (p *TextParser) AcceptQuotedString() (string, bool, error) {
|
|
r, _, err := p.ReadRune()
|
|
switch {
|
|
case err != nil:
|
|
// nothing here
|
|
return "", false, err
|
|
case r != RuneQuotes:
|
|
// not for us
|
|
p.UnreadRune()
|
|
return "", false, nil
|
|
default:
|
|
// let's roll
|
|
s, err := lexQuotedString(p)
|
|
switch {
|
|
case err != nil:
|
|
// bad quoted string
|
|
return "", false, err
|
|
default:
|
|
// success
|
|
return s, true, nil
|
|
}
|
|
}
|
|
}
|
|
|
|
func lexQuotedString(p *TextParser) (string, *lexer.Error) {
|
|
s, ok, err := lexQuotedStringNoEscape(p)
|
|
switch {
|
|
case err != nil:
|
|
return "", err
|
|
case ok:
|
|
return s, nil
|
|
default:
|
|
// escape character detected
|
|
return lexQuotedStringEscaped(p)
|
|
}
|
|
}
|
|
|
|
func lexQuotedStringNoEscape(p *TextParser) (string, bool, *lexer.Error) {
|
|
for {
|
|
r, _, err := p.ReadRune()
|
|
switch {
|
|
case err != nil:
|
|
// incomplete
|
|
return "", false, NewErrIncompleteQuotedString(p)
|
|
case r == RuneQuotes:
|
|
// end, just remove the quotes
|
|
s := p.String()
|
|
l := len(s)
|
|
return s[1 : l-1], true, nil
|
|
case r == RuneEscape:
|
|
// things just got complicated...
|
|
p.UnreadRune()
|
|
return "", false, nil
|
|
case IsNewLine(r):
|
|
// new lines within quoted values are acceptable
|
|
p.UnreadRune()
|
|
p.AcceptNewLine()
|
|
default:
|
|
// continue
|
|
}
|
|
}
|
|
}
|
|
|
|
// Unquoted removes quotes the content and unescapes the content
|
|
func lexQuotedStringEscaped(p *TextParser) (string, *lexer.Error) {
|
|
var result strings.Builder
|
|
|
|
// append what was accepted before the escape character
|
|
_, _ = result.WriteString(p.String()[1:])
|
|
|
|
for {
|
|
r, _, err := p.ReadRune()
|
|
switch {
|
|
case err != nil:
|
|
// incomplete quoted
|
|
return "", NewErrIncompleteQuotedString(p)
|
|
case r == RuneQuotes:
|
|
// end
|
|
return result.String(), nil
|
|
case r == RuneEscape:
|
|
// escaped
|
|
r2, _, err := p.ReadRune()
|
|
switch {
|
|
case err != nil:
|
|
// incomplete escaped
|
|
return "", NewErrIncompleteEscaped(p)
|
|
case IsNewLine(r2):
|
|
// escaped new line, skip
|
|
p.UnreadRune()
|
|
p.AcceptNewLine()
|
|
default:
|
|
// TODO: check valid escape character and
|
|
// append to result
|
|
s := string([]rune{r, r2})
|
|
err := NewErrInvalidEscapeSequence(p, s)
|
|
return "", err
|
|
}
|
|
default:
|
|
// normal, append to result
|
|
_, _ = result.WriteRune(r)
|
|
}
|
|
}
|
|
}
|
|
|
|
// Unquoted removes quotes and unescapes the content
|
|
func Unquoted(s string) (string, error) {
|
|
var p TextParser
|
|
if s == "" {
|
|
return "", nil
|
|
}
|
|
|
|
p.InitString(s)
|
|
unquoted, ok, err := p.AcceptQuotedString()
|
|
switch {
|
|
case err != nil:
|
|
// bad string
|
|
return "", err
|
|
case ok:
|
|
// success
|
|
return unquoted, nil
|
|
default:
|
|
// not quoted
|
|
return s, nil
|
|
}
|
|
}
|