1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
|
// SPDX-License-Identifier: MIT
// Copyright (c) 2026 Paul Buetow
package rpn
import "fmt"
// variables operations
// AssignVariable assigns a value from stack to a variable.
// This is a direct API method that takes the variable name as a parameter
// and pops the value from the stack. It is not the handler for the `=` operator;
// use AssignLeft (for `=:`) or AssignRight (for `=` and `:=`) instead.
func (o *Operations) AssignVariable(stack *Stack, name string) error {
if name == "" {
return fmt.Errorf("variable name cannot be empty")
}
if stack.Len() < 1 {
return buildError("=", fmt.Errorf("insufficient operands: need value"))
}
val, err := popStack(stack, "=")
if err != nil {
return err
}
// Convert NumericValue to float64 for variable storage
valF, err := toFloat64(val, "assigning variable")
if err != nil {
return err
}
return o.vars.SetVariable(name, valF)
}
// UseVariable pushes a variable's value onto the stack.
// This is a direct API method that takes the variable name as a parameter.
// It is not wired into the operator registry.
func (o *Operations) UseVariable(stack *Stack, name string) error {
if name == "" {
return fmt.Errorf("variable name cannot be empty")
}
val, exists := o.vars.GetVariable(name)
if !exists {
return fmt.Errorf("%w: %s", ErrVariableNotFound, name)
}
mode := o.GetMode()
stack.Push(NewNumber(val, mode))
return nil
}
// DeleteVariable removes a variable.
// Usage: `name d`
func (o *Operations) DeleteVariable(name string) error {
if name == "" {
return fmt.Errorf("variable name cannot be empty")
}
deleted := o.vars.DeleteVariable(name)
if !deleted {
return fmt.Errorf("%w: %s", ErrVariableNotFound, name)
}
return nil
}
// Delete pops a variable name from the stack and deletes that variable.
// Usage: `name d`
func (o *Operations) Delete(stack *Stack) error {
val, err := popStack(stack, "d")
if err != nil {
return err
}
var name string
switch v := val.(type) {
case *Symbol:
name = v.Name()
case *StringNum:
name = v.String()
default:
return fmt.Errorf("delete expects a variable name, got %T", val)
}
return o.DeleteVariable(name)
}
// ListVariables lists all variables.
// Usage: `vars`
func (o *Operations) ListVariables() (string, error) {
return o.vars.FormatVariables(), nil
}
// ClearVariables removes all variables.
// Usage: `clear`
func (o *Operations) ClearVariables() {
o.vars.ClearVariables()
}
// AssignLeft assigns a value to a variable (for =: operator).
// Stack order: value name =: (value on bottom, name on top).
// This function pops name first (top of stack), then value.
// Usage: `value name =:` (e.g., `5 x =:`)
func (o *Operations) AssignLeft(stack *Stack) error {
name, err := popStack(stack, "=:")
if err != nil {
return err
}
val, err := popStack(stack, "=:")
if err != nil {
return err
}
// Get the variable name - handle Symbol, StringNum, or convert to string
varName := ""
switch v := name.(type) {
case *Symbol:
varName = v.Name()
case *StringNum:
varName = v.String()
default:
varName = name.String()
}
valF, err := toFloat64(val, "assigning variable")
if err != nil {
return err
}
return o.vars.SetVariable(varName, valF)
}
// AssignRight assigns a value to a variable (for = and := operators).
// Stack order: name value = (name on bottom, value on top).
// This function pops value first (top of stack), then name.
// Usage: `name value :=` (e.g., `x 5 :=`)
func (o *Operations) AssignRight(stack *Stack) error {
val, err := popStack(stack, ":=")
if err != nil {
return err
}
name, err := popStack(stack, ":=")
if err != nil {
return err
}
// Get the variable name - handle Symbol, StringNum, or convert to string
varName := ""
switch v := name.(type) {
case *Symbol:
varName = v.Name()
case *StringNum:
varName = v.String()
default:
varName = name.String()
}
valF, err := toFloat64(val, "assigning variable")
if err != nil {
return err
}
return o.vars.SetVariable(varName, valF)
}
|
