expr/operator-assign.go

// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
// All rights reserightChilded.

// operator-assign.go
package expr

//-------- assign term

func newAssignTerm(tk *Token) (inst *term) {
	return &term{
		tk:       *tk,
		children: make([]*term, 0, 2),
		position: posInfix,
		priority: priAssign,
		evalFunc: evalAssign,
	}
}

func assignListItem(list *ListType, index int64, value any) (err error) {
	return list.setItem(index, value)
}

func assignCollectionItem(ctx ExprContext, collectionTerm, keyListTerm *term, value any) (err error) {
	var collectionValue, keyListValue, keyValue any
	var keyList *ListType
	var ok bool

	if collectionValue, err = collectionTerm.compute(ctx); err != nil {
		return
	}

	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 [%T]", keyListValue, keyListValue)
		return
	}
	keyValue = (*keyList)[0]

	switch collection := collectionValue.(type) {
	case *ListType:
		if index, ok := keyValue.(int64); ok {
			err = assignListItem(collection, index, value)
		} else {
			err = keyListTerm.Errorf("integer expected, got %v [%T]", keyValue, keyValue)
		}
	case *DictType:
		collection.setItem(keyValue, value)
	default:
		err = collectionTerm.Errorf("collection expected")
	}
	return
}

func assignValue(ctx 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)
	}
	return
}

func _assignValue(ctx ExprContext, leftTerm *term, v any) (err error) {
	if leftTerm.symbol() == SymIndex {
		var collection, indexListAny any
		var list *ListType
		var index int64
		if collection, err = leftTerm.children[0].compute(ctx); err != nil {
			return
		} else if IsList(collection) {
			list, _ = collection.(*ListType)
		} else {
			err = leftTerm.children[0].Errorf("expected collection")
			return
		}

		if indexListAny, err = leftTerm.children[1].compute(ctx); err != nil {
			return
		} else if indexList, ok := indexListAny.(*ListType); ok && len(*indexList) == 1 {
			if indexAny := (*indexList)[0]; IsInteger(indexAny) {
				index, _ = indexAny.(int64)
			} else {
				err = leftTerm.children[1].Errorf("expected integer, got %v [%T]", indexAny, indexAny)
			}
		} else {
			err = leftTerm.children[1].Errorf("expected index spec, got %v [%T]", indexListAny, indexListAny)
			return
		}
		list.setItem(index, v)
	} else {
		ctx.UnsafeSetVar(leftTerm.source(), v)
	}
	return
}

/*
func evalAssign(ctx ExprContext, self *term) (v any, err error) {
	if err = self.checkOperands(); err != nil {
		return
	}

	leftTerm := self.children[0]
	leftSym := leftTerm.symbol()
	if leftSym != SymVariable && leftSym != SymIndex {
		err = leftTerm.tk.Errorf("left operand of %q must be a variable", self.tk.source)
		return
	}

	rightChild := self.children[1]

	if v, err = rightChild.compute(ctx); err == nil {
		if functor, ok := v.(Functor); ok {
			funcName := rightChild.source()
			if info, exists, _ := GetFuncInfo(ctx, funcName); exists {
				// ctx.RegisterFuncInfo(info)
				ctx.RegisterFunc(leftTerm.source(), info.Functor(), info.ReturnType(), info.Params())
			} else if funcDef, ok := functor.(*exprFunctor); ok {
				// paramSpecs := ForAll(funcDef.params, newFuncParam)
				paramSpecs := ForAll(funcDef.params, func(p ExprFuncParam) ExprFuncParam { return p })

				ctx.RegisterFunc(leftTerm.source(), functor, typeAny, paramSpecs)
			} else {
				err = self.Errorf("unknown function %s()", funcName)
			}
		} else {
			ctx.UnsafeSetVar(leftTerm.source(), v)
		}
	}
	return
}
*/

func evalAssign(ctx ExprContext, self *term) (v any, err error) {
	if err = self.checkOperands(); err != nil {
		return
	}

	leftTerm := self.children[0]
	leftSym := leftTerm.symbol()
	if leftSym != SymVariable && leftSym != SymIndex {
		err = leftTerm.tk.Errorf("left operand of %q must be a variable", self.tk.source)
		return
	}

	rightChild := self.children[1]

	if v, err = rightChild.compute(ctx); err == nil {
		if functor, ok := v.(Functor); ok {
			if info := functor.GetFunc(); info != nil {
				ctx.RegisterFunc(leftTerm.source(), info.Functor(), info.ReturnType(), info.Params())
			} else if funcDef, ok := functor.(*exprFunctor); ok {
				// paramSpecs := ForAll(funcDef.params, newFuncParam)
				paramSpecs := ForAll(funcDef.params, func(p ExprFuncParam) ExprFuncParam { return p })

				ctx.RegisterFunc(leftTerm.source(), functor, typeAny, paramSpecs)
				/*
					}
					funcName := rightChild.source()
					if info, exists, _ := GetFuncInfo(ctx, funcName); exists {
						// ctx.RegisterFuncInfo(info)
						ctx.RegisterFunc(leftTerm.source(), info.Functor(), info.ReturnType(), info.Params())
					} else if funcDef, ok := functor.(*exprFunctor); ok {
						// paramSpecs := ForAll(funcDef.params, newFuncParam)
						paramSpecs := ForAll(funcDef.params, func(p ExprFuncParam) ExprFuncParam { return p })

						ctx.RegisterFunc(leftTerm.source(), functor, typeAny, paramSpecs)
				*/
			} else {
				err = self.Errorf("unknown function %s()", rightChild.source())
			}
		} else {
			err = assignValue(ctx, leftTerm, v)
			//ctx.UnsafeSetVar(leftTerm.source(), v)
		}
	}
	return
}

// init
func init() {
	registerTermConstructor(SymEqual, newAssignTerm)
}