lourenco/mgmt
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

lang: ast, interfaces, interpolate: Remove the legacy pos

Browse Source 
This ports things to the new textarea. We need to plumb through things a
lot more, especially the string interpolation math to get the right
offsets everywhere, but that's coming.
This commit is contained in:
James Shubin
2025-06-06 00:58:30 -04:00
parent 86dfa5844a
commit cdc6743d83
4 changed files with 12 additions and 58 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
lang/ast/structs.go
View File

@@ -7495,14 +7495,6 @@ func (obj *ExprStr) Init(data *interfaces.Data) error {
// which need interpolation. If any are found, it returns a larger AST which has
// a function which returns a string as its root. Otherwise it returns itself.
func (obj *ExprStr) Interpolate() (interfaces.Expr, error) {
pos := &interfaces.Pos{
// XXX: populate this?
// column/line number, starting at 1
//Column: -1, // TODO
//Line: -1, // TODO
//Filename: "", // optional source filename, if known
}
data := &interfaces.Data{
// TODO: add missing fields here if/when needed
Fs: obj.data.Fs,
@@ -7526,7 +7518,7 @@ func (obj *ExprStr) Interpolate() (interfaces.Expr, error) {
},
}
result, err := obj.data.StrInterpolater(obj.V, pos, data)
result, err := obj.data.StrInterpolater(obj.V, &obj.Textarea, data)
if err != nil {
return nil, err
}

2
lang/interfaces/ast.go
View File

@@ -231,7 +231,7 @@ type Data struct {
// StrInterpolater is a function that needs to get passed in to run the
// string interpolation. This is passed in this way to avoid dependency
// cycles.
StrInterpolater func(string, *Pos, *Data) (Expr, error)
StrInterpolater func(string, *Textarea, *Data) (Expr, error)
// SourceFinder is a function that returns the contents of a source file
// when requested by filename. This data is used to annotate error

39
lang/interfaces/parser.go
View File

@@ -1,39 +0,0 @@
// Mgmt
// Copyright (C) James Shubin and the project contributors
// Written by James Shubin <james@shubin.ca> and the project contributors
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
//
// Additional permission under GNU GPL version 3 section 7
//
// If you modify this program, or any covered work, by linking or combining it
// with embedded mcl code and modules (and that the embedded mcl code and
// modules which link with this program, contain a copy of their source code in
// the authoritative form) containing parts covered by the terms of any other
// license, the licensors of this program grant you additional permission to
// convey the resulting work. Furthermore, the licensors of this program grant
// the original author, James Shubin, additional permission to update this
// additional permission if he deems it necessary to achieve the goals of this
// additional permission.
package interfaces
// Pos represents a position in the code. This is used by the parser and string
// interpolation.
// TODO: consider expanding with range characteristics.
type Pos struct {
Line int // line number starting at 1
Column int // column number starting at 1
Filename string // optional source filename, if known
}

19
lang/interpolate/interpolate.go
View File

@@ -57,21 +57,21 @@ const (
// StrInterpolate interpolates a string and returns the representative AST. If
// there was nothing to interpolate, this returns (nil, nil).
func StrInterpolate(str string, pos *interfaces.Pos, data *interfaces.Data) (interfaces.Expr, error) {
func StrInterpolate(str string, textarea *interfaces.Textarea, data *interfaces.Data) (interfaces.Expr, error) {
if data.Debug {
data.Logf("interpolating: %s", str)
}
if UseHilInterpolation {
return HilInterpolate(str, pos, data)
return HilInterpolate(str, textarea, data)
}
return RagelInterpolate(str, pos, data)
return RagelInterpolate(str, textarea, data)
}
// RagelInterpolate interpolates a string and returns the representative AST. It
// uses the ragel parser to perform the string interpolation. If there was
// nothing to interpolate, this returns (nil, nil).
func RagelInterpolate(str string, pos *interfaces.Pos, data *interfaces.Data) (interfaces.Expr, error) {
func RagelInterpolate(str string, textarea *interfaces.Textarea, data *interfaces.Data) (interfaces.Expr, error) {
sequence, err := Parse(str)
if err != nil {
return nil, errwrap.Wrapf(err, "parser failed")
@@ -125,13 +125,14 @@ func RagelInterpolate(str string, pos *interfaces.Pos, data *interfaces.Data) (i
// HilInterpolate interpolates a string and returns the representative AST. This
// particular implementation uses the hashicorp hil library and syntax to do so.
func HilInterpolate(str string, pos *interfaces.Pos, data *interfaces.Data) (interfaces.Expr, error) {
func HilInterpolate(str string, textarea *interfaces.Textarea, data *interfaces.Data) (interfaces.Expr, error) {
var line, column int = -1, -1
var filename string
if pos != nil {
line = pos.Line
column = pos.Column
filename = pos.Filename
if textarea != nil {
startLine, startColumn := textarea.Pos() // zero based
line = startLine
column = startColumn
filename = textarea.Filename() // TODO: .Path() instead?
}
hilPos := hilast.Pos{
Line: line,