go-pkg/expr
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

moved a subset of source file to the kern package

Browse Source
This commit is contained in:
Celestino Amoroso
2026-04-27 19:43:37 +02:00
parent f100adead3
commit 4d910dd069
107 changed files with 2080 additions and 1380 deletions
Download Patch File Download Diff File Expand all files Collapse all files
operator-assign.go
+38 -34
View File
@@ -4,6 +4,10 @@
// operator-assign.go
package expr
import (
"git.portale-stac.it/go-pkg/expr/kern"
)
//-------- assign term
func newAssignTerm(tk *Token) (inst *term) {
@@ -16,19 +20,19 @@ func newAssignTerm(tk *Token) (inst *term) {
}
}
func assignCollectionItem(ctx ExprContext, collectionTerm, keyListTerm *term, value any) (err error) {
func assignCollectionItem(ctx kern.ExprContext, collectionTerm, keyListTerm *term, value any) (err error) {
var collectionValue, keyListValue, keyValue any
var keyList *ListType
var keyList *kern.ListType
var ok bool
if collectionValue, err = collectionTerm.compute(ctx); err != nil {
if collectionValue, err = collectionTerm.Compute(ctx); err != nil {
return
}
if keyListValue, err = keyListTerm.compute(ctx); err != nil {
if keyListValue, err = keyListTerm.Compute(ctx); err != nil {
return
} else if keyList, ok = keyListValue.(*ListType); !ok || len(*keyList) != 1 {
err = keyListTerm.Errorf("index/key specification expected, got %v [%s]", keyListValue, TypeName(keyListValue))
} else if keyList, ok = keyListValue.(*kern.ListType); !ok || len(*keyList) != 1 {
err = keyListTerm.Errorf("index/key specification expected, got %v [%s]", keyListValue, kern.TypeName(keyListValue))
return
}
if keyValue = (*keyList)[0]; keyValue == nil {
@@ -37,30 +41,30 @@ func assignCollectionItem(ctx ExprContext, collectionTerm, keyListTerm *term, va
}
switch collection := collectionValue.(type) {
case *ListType:
case *kern.ListType:
if index, ok := keyValue.(int64); ok {
err = collection.setItem(index, value)
err = collection.SetItem(index, value)
} else {
err = keyListTerm.Errorf("integer expected, got %v [%s]", keyValue, TypeName(keyValue))
err = keyListTerm.Errorf("integer expected, got %v [%s]", keyValue, kern.TypeName(keyValue))
}
case *DictType:
err = collection.setItem(keyValue, value)
case *kern.DictType:
err = collection.SetItem(keyValue, value)
default:
err = collectionTerm.Errorf("collection expected")
}
return
}
func assignValue(ctx ExprContext, leftTerm *term, v any) (err error) {
func assignValue(ctx kern.ExprContext, leftTerm *term, v any) (err error) {
if leftTerm.symbol() == SymIndex {
err = assignCollectionItem(ctx, leftTerm.children[0], leftTerm.children[1], v)
} else {
ctx.UnsafeSetVar(leftTerm.source(), v)
ctx.UnsafeSetVar(leftTerm.Source(), v)
}
return
}
func evalAssign(ctx ExprContext, opTerm *term) (v any, err error) {
func evalAssign(ctx kern.ExprContext, opTerm *term) (v any, err error) {
if err = opTerm.checkOperands(); err != nil {
return
}
@@ -74,17 +78,17 @@ func evalAssign(ctx ExprContext, opTerm *term) (v any, err error) {
rightChild := opTerm.children[1]
if v, err = rightChild.compute(ctx); err == nil {
if functor, ok := v.(Functor); ok {
if v, err = rightChild.Compute(ctx); err == nil {
if functor, ok := v.(kern.Functor); ok {
if leftSym == SymVariable {
if info := functor.GetFunc(); info != nil {
ctx.RegisterFunc(leftTerm.source(), info.Functor(), info.ReturnType(), info.Params())
ctx.RegisterFunc(leftTerm.Source(), info.Functor(), info.ReturnType(), info.Params())
} else if funcDef, ok := functor.(*exprFunctor); ok {
paramSpecs := ForAll(funcDef.params, func(p ExprFuncParam) ExprFuncParam { return p })
paramSpecs := kern.ForAll(funcDef.params, func(p kern.ExprFuncParam) kern.ExprFuncParam { return p })
ctx.RegisterFunc(leftTerm.source(), functor, TypeAny, paramSpecs)
ctx.RegisterFunc(leftTerm.Source(), functor, kern.TypeAny, paramSpecs)
} else {
err = opTerm.Errorf("unknown function %s()", rightChild.source())
err = opTerm.Errorf("unknown function %s()", rightChild.Source())
}
} else {
err = assignValue(ctx, leftTerm, v)
@@ -111,19 +115,19 @@ func newOpAssignTerm(tk *Token) (inst *term) {
}
}
func getCollectionItemValue(ctx ExprContext, collectionTerm, keyListTerm *term) (value any, err error) {
func getCollectionItemValue(ctx kern.ExprContext, collectionTerm, keyListTerm *term) (value any, err error) {
var collectionValue, keyListValue, keyValue any
var keyList *ListType
var keyList *kern.ListType
var ok bool
if collectionValue, err = collectionTerm.compute(ctx); err != nil {
if collectionValue, err = collectionTerm.Compute(ctx); err != nil {
return
}
if keyListValue, err = keyListTerm.compute(ctx); err != nil {
if keyListValue, err = keyListTerm.Compute(ctx); err != nil {
return
} else if keyList, ok = keyListValue.(*ListType); !ok || len(*keyList) != 1 {
err = keyListTerm.Errorf("index/key specification expected, got %v [%s]", keyListValue, TypeName(keyListValue))
} else if keyList, ok = keyListValue.(*kern.ListType); !ok || len(*keyList) != 1 {
err = keyListTerm.Errorf("index/key specification expected, got %v [%s]", keyListValue, kern.TypeName(keyListValue))
return
}
if keyValue = (*keyList)[0]; keyValue == nil {
@@ -132,13 +136,13 @@ func getCollectionItemValue(ctx ExprContext, collectionTerm, keyListTerm *term)
}
switch collection := collectionValue.(type) {
case *ListType:
case *kern.ListType:
if index, ok := keyValue.(int64); ok {
value = (*collection)[index]
} else {
err = keyListTerm.Errorf("integer expected, got %v [%s]", keyValue, TypeName(keyValue))
err = keyListTerm.Errorf("integer expected, got %v [%s]", keyValue, kern.TypeName(keyValue))
}
case *DictType:
case *kern.DictType:
value = (*collection)[keyValue]
default:
err = collectionTerm.Errorf("collection expected")
@@ -146,16 +150,16 @@ func getCollectionItemValue(ctx ExprContext, collectionTerm, keyListTerm *term)
return
}
func getAssignValue(ctx ExprContext, leftTerm *term) (value any, err error) {
func getAssignValue(ctx kern.ExprContext, leftTerm *term) (value any, err error) {
if leftTerm.symbol() == SymIndex {
value, err = getCollectionItemValue(ctx, leftTerm.children[0], leftTerm.children[1])
} else {
value, _ = ctx.GetVar(leftTerm.source())
value, _ = ctx.GetVar(leftTerm.Source())
}
return
}
func evalOpAssign(ctx ExprContext, opTerm *term) (v any, err error) {
func evalOpAssign(ctx kern.ExprContext, opTerm *term) (v any, err error) {
var rightValue, leftValue any
if err = opTerm.checkOperands(); err != nil {
return
@@ -170,7 +174,7 @@ func evalOpAssign(ctx ExprContext, opTerm *term) (v any, err error) {
rightChild := opTerm.children[1]
if rightValue, err = rightChild.compute(ctx); err == nil {
if rightValue, err = rightChild.Compute(ctx); err == nil {
if leftValue, err = getAssignValue(ctx, leftTerm); err == nil {
switch opTerm.symbol() {
case SymPlusEqual:
@@ -194,7 +198,7 @@ func evalOpAssign(ctx ExprContext, opTerm *term) (v any, err error) {
case SymDoubleGreaterEqual:
v, err = bitRightShift(opTerm, leftValue, rightValue)
default:
err = opTerm.Errorf("unsupported assign operator %q", opTerm.source())
err = opTerm.Errorf("unsupported assign operator %q", opTerm.Source())
}
if err == nil {
err = assignValue(ctx, leftTerm, v)