New bitwise XOR operator specified by symbol ^ (caret). Iterator dereference is now done by prefixed * (star)

term.go: new priority priDereference
token.go: new member function Token.SetSymbol()
2025-01-03 07:33:17 +01:00 · 2025-01-03 07:28:30 +01:00 · 2025-01-03 07:27:49 +01:00 · 2025-01-03 06:32:55 +01:00 · 2025-01-03 05:43:50 +01:00 · 2025-01-03 05:40:24 +01:00
20 changed files with 595 additions and 340 deletions
--- a/dict-type.go
+++ b/dict-type.go
@ -33,7 +33,7 @@ func NewDict(dictAny map[any]any) (dict *DictType) {
 }

 func newDict(dictAny map[any]*term) (dict *DictType) {
-	// TODO Change wi a call to NewDict()
+	// TODO Change with a call to NewDict()
 	var d DictType
 	if dictAny != nil {
 		d = make(DictType, len(dictAny))
--- a/doc/Expr.adoc
+++ b/doc/Expr.adoc
@ -737,7 +737,7 @@ The table below shows all supported operators by decreasing priorities.
 .Operators priorities
 [cols="^3,^2,^2,^5,^6"]
 |===
-| Priority | Operators     | Position | Operation | Operands and results
+| Priority | Operator     | Position | Operation | Operands and results

 .2+|*ITEM*| [blue]`[`...`]` | _Postfix_ | _List item_| _list_ `[`  _integer_ `]` -> _any_
 | [blue]`[`...`]` | _Postfix_ | _Dict item_ | _dict_ `[` _any_ `]` -> _any_
@ -751,6 +751,8 @@ The table below shows all supported operators by decreasing priorities.
 .3+|*SIGN*| [blue]`+`, [blue]`-` | _Prefix_ | _Change-sign_| (`+`\|`-`) _number_ -> _number_
 | [blue]`#` | _Prefix_ | _Lenght-of_ | `#` _collection_ -> _integer_
 | [blue]`#` | _Prefix_ | _Size-of_ | `#` _iterator_ -> _integer_
+.2+|*BIT SHIFT*| [blue]`<<` | _Infix_ | _Left-Shift_ | _integer_ `<<` _integer_ -> _integer_
+| [blue]`>>` | _Infix_ | _Right-Shift_ | _integer_ `>>` _iterator_ -> _integer_
 .2+|*SELECT*| [blue]`? : ::` | _Multi-Infix_ | _Case-Selector_ | _any-expr_ `?` _case-list_ _case-expr_ `:` _case-list_ _case-expr_ ... `::` _default-expr_ -> _any_
 | [blue]`? : ::` | _Multi-Infix_ | _Index-Selector_ | _int-expr_ `?` _case-expr_ `:` _case-expr_ ... `::` _default-expr_ -> _any_
 .1+|*FRACT*| [blue]`:` | _Infix_ | _Fraction_ | _integer_ `:` _integer_ -> _fraction_
@ -767,9 +769,9 @@ The table below shows all supported operators by decreasing priorities.
 | [blue]`+` | _Infix_ |  _Dict-join_ | _dict_ `+` _dict_ -> _dict_
 | [blue]`-` | _Infix_ | _Subtraction_ | _number_ `-` _number_ -> _number_
 | [blue]`-` | _Infix_ | _List-difference_ | _list_ `-` _list_ -> _list_
-.1+|*BINARY NOT*| [blue]`~` | _Prefix_ | _Binary Not_ | `~` _number_ -> _number_
-.1+|*BINARY AND*| [blue]`&` | _Infix_ | _Binary And_ | _number_ `&` _number_ -> _number_
-.1+|*BINARY OR*| [blue]`\|` | _Infix_ | _Binary Or_ | _number_ `\|` _number_ -> _number_
+.1+|*BITWISE NOT*| [blue]`~` | _Prefix_ | _Binary Not_ | `~` _number_ -> _number_
+.1+|*BITWISE AND*| [blue]`&` | _Infix_ | _Binary And_ | _number_ `&` _number_ -> _number_
+.1+|*BITWISE OR*| [blue]`\|` | _Infix_ | _Binary Or_ | _number_ `\|` _number_ -> _number_
 .8+|*RELATION*| [blue]`<` | _Infix_ | _Less_ | _comparable_ `<` _comparable_ -> _boolean_
 | [blue]`\<=` | _Infix_ |  _less-equal_ | _comparable_ `\<=` _comparable_ -> _boolean_
 | [blue]`>` | _Infix_ |  _Greater_ | _comparable_ `>` _comparable_ -> _boolean_
@ -785,15 +787,47 @@ The table below shows all supported operators by decreasing priorities.
 | [blue]`\|\|` | _Infix_ | _Or_ | _boolean_ `\|\|` _boolean_ -> _boolean_
 .2+|*INSERT*| [blue]`+>` | _Infix_ | _Prepend_ | _any_ `+>` _list_ -> _list_
 | [blue]`<+` | _Infix_ | _Append_ | _list_ `<+` _any_ -> _list_
-.3+|*ASSIGN*| [blue]`=` | _Infix_ | _Assignment_ | _identifier_ `=` _any_ -> _any_
-| [blue]`>>` | _Infix_ | _Front-insert_ | _any_ `>>` _list_ -> _list_
-| [blue]`<<` | _Infix_ | _Back-insert_ | _list_ `<<` _any_ -> _list_
+.2+|*ASSIGN*| [blue]`=` | _Infix_ | _Assignment_ | _identifier_ `=` _any_ -> _any_
+4+| _See also the special assignment operators table below_
 .1+|*BUT*| [blue]`but` | _Infix_ | _But_ | _any_ `but` _any_ -> _any_
 .1+|*RANGE*| [blue]`:` | _Infix_ | _Index-range_ | _integer_ `:` _integer_ -> _integer-pair_
 |===

 //^1^ Experimental

+.Special assignment perators
+[cols="^2,^2,^4,^6"]
+|===
+| Priority | Operator    | Operation |Equivalent operation
+
+.9+|*ASSIGN*| [blue]`+=` | _Sum & Assign_ | _var_ `\+=` _expr_  +
+short for +
+_var_ `=` _value-of-var_ `+` _expr_
+| [blue]`-=` | _Subtract & Assign_ | _var_ `-=` _expr_  +
+short for +
+_var_ `=` _value-of-var_ `-` _expr_
+| [blue]`*=` | _Multiply & Assign_ | _var_ `\*=` _expr_  +
+short for +
+_var_ `=` _value-of-var_ `*` _expr_
+| [blue]`/=` | _Divide & Assign_ | _var_ `/=` _expr_  +
+short for +
+_var_ `=` _value-of-var_ `/` _expr_
+| [blue]`%=` | _Remainder & Assign_ | _var_ `%=` _expr_  +
+short for +
+_var_ `=` _value-of-var_ `%` _expr_
+| [blue]`&=` | _Bitwise and & Assign_ | _var_ `&=` _expr_  +
+short for +
+_var_ `=` _value-of-var_ `&` _expr_
+| [blue]`\|=` | _Bitwise or & Assign_ | _var_ `\|=` _expr_  +
+short for +
+_var_ `=` _value-of-var_ `\|` _expr_
+| [blue]`<\<=` | _Left shift & Assign_ | _var_ `<\<=` _expr_  +
+short for +
+_var_ `=` _value-of-var_ `<<` _expr_
+| [blue]`>>=` | _Right shift & Assign_ | _var_ `>>=` _expr_  +
+short for +
+_var_ `=` _value-of-var_ `>>` _expr_
+|===

 == Functions
 Functions in _Expr_ are very similar to functions available in many programming languages. Currently, _Expr_ supports two types of function, _expr-functions_ and _go-functions_.
@ -844,7 +878,7 @@ _param-name_ = _identifier_


 === _Golang_ function definition
-Description of how to define Golan functions and how to bind them to _Expr_ are topics treated in another document that I'll write, one day, maybe.
+Description of how to define Golang functions and how to bind them to _Expr_ are topics covered in another document that I'll write, one day, maybe.

 === Function calls
 To call a function, either Expr or Golang type, it is necessary to specify its name and, at least, its required parameters.
--- a/doc/Expr.html
+++ b/doc/Expr.html
@ -1909,7 +1909,7 @@ These operators have a high priority, in particular higher than the operator <co
 <thead>
 <tr>
 <th class="tableblock halign-center valign-top">Priority</th>
-<th class="tableblock halign-center valign-top">Operators</th>
+<th class="tableblock halign-center valign-top">Operator</th>
 <th class="tableblock halign-center valign-top">Position</th>
 <th class="tableblock halign-center valign-top">Operation</th>
 <th class="tableblock halign-center valign-top">Operands and results</th>
@ -1988,6 +1988,19 @@ These operators have a high priority, in particular higher than the operator <co
 <td class="tableblock halign-center valign-top"><p class="tableblock"><code>#</code> <em>iterator</em> &#8594; <em>integer</em></p></td>
 </tr>
 <tr>
+<td class="tableblock halign-center valign-top" rowspan="2"><p class="tableblock"><strong>BIT SHIFT</strong></p></td>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><code class="blue">&lt;&lt;</code></p></td>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><em>Infix</em></p></td>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><em>Left-Shift</em></p></td>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><em>integer</em> <code>&lt;&lt;</code> <em>integer</em> &#8594; <em>integer</em></p></td>
+</tr>
+<tr>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><code class="blue">&gt;&gt;</code></p></td>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><em>Infix</em></p></td>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><em>Right-Shift</em></p></td>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><em>integer</em> <code>&gt;&gt;</code> <em>iterator</em> &#8594; <em>integer</em></p></td>
+</tr>
+<tr>
 <td class="tableblock halign-center valign-top" rowspan="2"><p class="tableblock"><strong>SELECT</strong></p></td>
 <td class="tableblock halign-center valign-top"><p class="tableblock"><code class="blue">? : ::</code></p></td>
 <td class="tableblock halign-center valign-top"><p class="tableblock"><em>Multi-Infix</em></p></td>
@ -2088,21 +2101,21 @@ These operators have a high priority, in particular higher than the operator <co
 <td class="tableblock halign-center valign-top"><p class="tableblock"><em>list</em> <code>-</code> <em>list</em> &#8594; <em>list</em></p></td>
 </tr>
 <tr>
-<td class="tableblock halign-center valign-top"><p class="tableblock"><strong>BINARY NOT</strong></p></td>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><strong>BITWISE NOT</strong></p></td>
 <td class="tableblock halign-center valign-top"><p class="tableblock"><code class="blue">~</code></p></td>
 <td class="tableblock halign-center valign-top"><p class="tableblock"><em>Prefix</em></p></td>
 <td class="tableblock halign-center valign-top"><p class="tableblock"><em>Binary Not</em></p></td>
 <td class="tableblock halign-center valign-top"><p class="tableblock"><code>~</code> <em>number</em> &#8594; <em>number</em></p></td>
 </tr>
 <tr>
-<td class="tableblock halign-center valign-top"><p class="tableblock"><strong>BINARY AND</strong></p></td>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><strong>BITWISE AND</strong></p></td>
 <td class="tableblock halign-center valign-top"><p class="tableblock"><code class="blue">&amp;</code></p></td>
 <td class="tableblock halign-center valign-top"><p class="tableblock"><em>Infix</em></p></td>
 <td class="tableblock halign-center valign-top"><p class="tableblock"><em>Binary And</em></p></td>
 <td class="tableblock halign-center valign-top"><p class="tableblock"><em>number</em> <code>&amp;</code> <em>number</em> &#8594; <em>number</em></p></td>
 </tr>
 <tr>
-<td class="tableblock halign-center valign-top"><p class="tableblock"><strong>BINARY OR</strong></p></td>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><strong>BITWISE OR</strong></p></td>
 <td class="tableblock halign-center valign-top"><p class="tableblock"><code class="blue">|</code></p></td>
 <td class="tableblock halign-center valign-top"><p class="tableblock"><em>Infix</em></p></td>
 <td class="tableblock halign-center valign-top"><p class="tableblock"><em>Binary Or</em></p></td>
@ -2204,23 +2217,14 @@ These operators have a high priority, in particular higher than the operator <co
 <td class="tableblock halign-center valign-top"><p class="tableblock"><em>list</em> <code>&lt;+</code> <em>any</em> &#8594; <em>list</em></p></td>
 </tr>
 <tr>
-<td class="tableblock halign-center valign-top" rowspan="3"><p class="tableblock"><strong>ASSIGN</strong></p></td>
+<td class="tableblock halign-center valign-top" rowspan="2"><p class="tableblock"><strong>ASSIGN</strong></p></td>
 <td class="tableblock halign-center valign-top"><p class="tableblock"><code class="blue">=</code></p></td>
 <td class="tableblock halign-center valign-top"><p class="tableblock"><em>Infix</em></p></td>
 <td class="tableblock halign-center valign-top"><p class="tableblock"><em>Assignment</em></p></td>
 <td class="tableblock halign-center valign-top"><p class="tableblock"><em>identifier</em> <code>=</code> <em>any</em> &#8594; <em>any</em></p></td>
 </tr>
 <tr>
-<td class="tableblock halign-center valign-top"><p class="tableblock"><code class="blue">&gt;&gt;</code></p></td>
-<td class="tableblock halign-center valign-top"><p class="tableblock"><em>Infix</em></p></td>
-<td class="tableblock halign-center valign-top"><p class="tableblock"><em>Front-insert</em></p></td>
-<td class="tableblock halign-center valign-top"><p class="tableblock"><em>any</em> <code>&gt;&gt;</code> <em>list</em> &#8594; <em>list</em></p></td>
-</tr>
-<tr>
-<td class="tableblock halign-center valign-top"><p class="tableblock"><code class="blue">&lt;&lt;</code></p></td>
-<td class="tableblock halign-center valign-top"><p class="tableblock"><em>Infix</em></p></td>
-<td class="tableblock halign-center valign-top"><p class="tableblock"><em>Back-insert</em></p></td>
-<td class="tableblock halign-center valign-top"><p class="tableblock"><em>list</em> <code>&lt;&lt;</code> <em>any</em> &#8594; <em>list</em></p></td>
+<td class="tableblock halign-center valign-top" colspan="4"><p class="tableblock"><em>See also the special assignment operators table below</em></p></td>
 </tr>
 <tr>
 <td class="tableblock halign-center valign-top"><p class="tableblock"><strong>BUT</strong></p></td>
@ -2238,6 +2242,89 @@ These operators have a high priority, in particular higher than the operator <co
 </tr>
 </tbody>
 </table>
+<table class="tableblock frame-all grid-all stretch">
+<caption class="title">Table 9. Special assignment perators</caption>
+<colgroup>
+<col style="width: 14.2857%;">
+<col style="width: 14.2857%;">
+<col style="width: 28.5714%;">
+<col style="width: 42.8572%;">
+</colgroup>
+<thead>
+<tr>
+<th class="tableblock halign-center valign-top">Priority</th>
+<th class="tableblock halign-center valign-top">Operator</th>
+<th class="tableblock halign-center valign-top">Operation</th>
+<th class="tableblock halign-center valign-top">Equivalent operation</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+<td class="tableblock halign-center valign-top" rowspan="9"><p class="tableblock"><strong>ASSIGN</strong></p></td>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><code class="blue">+=</code></p></td>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><em>Sum &amp; Assign</em></p></td>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><em>var</em> <code>+=</code> <em>expr</em> <br>
+short for<br>
+<em>var</em> <code>=</code> <em>value-of-var</em> <code>+</code> <em>expr</em></p></td>
+</tr>
+<tr>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><code class="blue">-=</code></p></td>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><em>Subtract &amp; Assign</em></p></td>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><em>var</em> <code>-=</code> <em>expr</em> <br>
+short for<br>
+<em>var</em> <code>=</code> <em>value-of-var</em> <code>-</code> <em>expr</em></p></td>
+</tr>
+<tr>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><code class="blue">*=</code></p></td>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><em>Multiply &amp; Assign</em></p></td>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><em>var</em> <code>*=</code> <em>expr</em> <br>
+short for<br>
+<em>var</em> <code>=</code> <em>value-of-var</em> <code>*</code> <em>expr</em></p></td>
+</tr>
+<tr>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><code class="blue">/=</code></p></td>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><em>Divide &amp; Assign</em></p></td>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><em>var</em> <code>/=</code> <em>expr</em> <br>
+short for<br>
+<em>var</em> <code>=</code> <em>value-of-var</em> <code>/</code> <em>expr</em></p></td>
+</tr>
+<tr>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><code class="blue">%=</code></p></td>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><em>Remainder &amp; Assign</em></p></td>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><em>var</em> <code>%=</code> <em>expr</em> <br>
+short for<br>
+<em>var</em> <code>=</code> <em>value-of-var</em> <code>%</code> <em>expr</em></p></td>
+</tr>
+<tr>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><code class="blue">&amp;=</code></p></td>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><em>Bitwise and &amp; Assign</em></p></td>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><em>var</em> <code>&amp;=</code> <em>expr</em> <br>
+short for<br>
+<em>var</em> <code>=</code> <em>value-of-var</em> <code>&amp;</code> <em>expr</em></p></td>
+</tr>
+<tr>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><code class="blue">|=</code></p></td>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><em>Bitwise or &amp; Assign</em></p></td>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><em>var</em> <code>|=</code> <em>expr</em> <br>
+short for<br>
+<em>var</em> <code>=</code> <em>value-of-var</em> <code>|</code> <em>expr</em></p></td>
+</tr>
+<tr>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><code class="blue">&lt;&lt;=</code></p></td>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><em>Left shift &amp; Assign</em></p></td>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><em>var</em> <code>&lt;&lt;=</code> <em>expr</em> <br>
+short for<br>
+<em>var</em> <code>=</code> <em>value-of-var</em> <code>&lt;&lt;</code> <em>expr</em></p></td>
+</tr>
+<tr>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><code class="blue">&gt;&gt;=</code></p></td>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><em>Right shift &amp; Assign</em></p></td>
+<td class="tableblock halign-center valign-top"><p class="tableblock"><em>var</em> <code>&gt;&gt;=</code> <em>expr</em> <br>
+short for<br>
+<em>var</em> <code>=</code> <em>value-of-var</em> <code>&gt;&gt;</code> <em>expr</em></p></td>
+</tr>
+</tbody>
+</table>
 </div>
 </div>
 <div class="sect1">
@ -2309,7 +2396,7 @@ These operators have a high priority, in particular higher than the operator <co
 <div class="sect2">
 <h3 id="_golang_function_definition"><a class="anchor" href="#_golang_function_definition"></a><a class="link" href="#_golang_function_definition">6.2. <em>Golang</em> function definition</a></h3>
 <div class="paragraph">
-<p>Description of how to define Golan functions and how to bind them to <em>Expr</em> are topics treated in another document that I&#8217;ll write, one day, maybe.</p>
+<p>Description of how to define Golang functions and how to bind them to <em>Expr</em> are topics covered in another document that I&#8217;ll write, one day, maybe.</p>
 </div>
 </div>
 <div class="sect2">
@ -2488,7 +2575,7 @@ g(@p):any{}`
 </div>
 <div id="footer">
 <div id="footer-text">
-Last updated 2024-12-28 19:21:30 +0100
+Last updated 2025-01-03 05:42:18 +0100
 </div>
 </div>
 </body>
--- a/operator-assign.go
+++ b/operator-assign.go
@ -183,6 +183,16 @@ func evalOpAssign(ctx ExprContext, opTerm *term) (v any, err error) {
 				v, err = divValues(opTerm, leftValue, rightValue)
 			case SymPercEqual:
 				v, err = remainderValues(opTerm, leftValue, rightValue)
+			case SymAmpersandEqual:
+				v, err = bitwiseAnd(opTerm, leftValue, rightValue)
+			case SymVertBarEqual:
+				v, err = bitwiseOr(opTerm, leftValue, rightValue)
+			case SymCaretEqual:
+				v, err = bitwiseXor(opTerm, leftValue, rightValue)
+			case SymDoubleLessEqual:
+				v, err = bitLeftShift(opTerm, leftValue, rightValue)
+			case SymDoubleGreaterEqual:
+				v, err = bitRightShift(opTerm, leftValue, rightValue)
 			default:
 				err = opTerm.Errorf("unsupported assign operator %q", opTerm.source())
 			}
@ -201,4 +211,10 @@ func init() {
 	registerTermConstructor(SymMinusEqual, newOpAssignTerm)
 	registerTermConstructor(SymStarEqual, newOpAssignTerm)
 	registerTermConstructor(SymSlashEqual, newOpAssignTerm)
+	registerTermConstructor(SymPercEqual, newOpAssignTerm)
+	registerTermConstructor(SymDoubleLessEqual, newOpAssignTerm)
+	registerTermConstructor(SymDoubleGreaterEqual, newOpAssignTerm)
+	registerTermConstructor(SymAmpersandEqual, newOpAssignTerm)
+	registerTermConstructor(SymVertBarEqual, newOpAssignTerm)
+	registerTermConstructor(SymCaretEqual, newOpAssignTerm)
 }
--- a/operator-binary.go
+++ b/operator-binary.go
@ -1,104 +0,0 @@
-// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
-// All rights reserved.
-
-// operator-binary.go
-package expr
-
-//-------- NOT term
-
-func newBinNotTerm(tk *Token) (inst *term) {
-	return &term{
-		tk:       *tk,
-		children: make([]*term, 0, 1),
-		position: posPrefix,
-		priority: priBinNot,
-		evalFunc: evalBinaryNot,
-	}
-}
-
-func evalBinaryNot(ctx ExprContext, opTerm *term) (v any, err error) {
-	var value any
-
-	if value, err = opTerm.evalPrefix(ctx); err != nil {
-		return
-	}
-
-	if IsInteger(value) {
-		i, _ := value.(int64)
-		v = ^i
-	} else {
-		err = opTerm.errIncompatibleType(value)
-	}
-	return
-}
-
-//-------- Binary AND term
-
-func newBinAndTerm(tk *Token) (inst *term) {
-	return &term{
-		tk:       *tk,
-		children: make([]*term, 0, 2),
-		position: posInfix,
-		priority: priBinAnd,
-		evalFunc: evalBinaryAnd,
-	}
-}
-
-func evalBinaryAnd(ctx ExprContext, self *term) (v any, err error) {
-	var leftValue, rightValue any
-	var leftInt, rightInt int64
-	var lok, rok bool
-
-	if leftValue, rightValue, err = self.evalInfix(ctx); err != nil {
-		return
-	}
-
-	leftInt, lok = leftValue.(int64)
-	rightInt, rok = rightValue.(int64)
-
-	if lok && rok {
-		v = leftInt & rightInt
-	} else {
-		err = self.errIncompatibleTypes(leftValue, rightValue)
-	}
-	return
-}
-
-//-------- Binary OR term
-
-func newBinOrTerm(tk *Token) (inst *term) {
-	return &term{
-		tk:       *tk,
-		children: make([]*term, 0, 2),
-		position: posInfix,
-		priority: priBinOr,
-		evalFunc: evalBinaryOr,
-	}
-}
-
-func evalBinaryOr(ctx ExprContext, self *term) (v any, err error) {
-	var leftValue, rightValue any
-	var leftInt, rightInt int64
-	var lok, rok bool
-
-	if leftValue, rightValue, err = self.evalInfix(ctx); err != nil {
-		return
-	}
-
-	leftInt, lok = leftValue.(int64)
-	rightInt, rok = rightValue.(int64)
-
-	if lok && rok {
-		v = leftInt | rightInt
-	} else {
-		err = self.errIncompatibleTypes(leftValue, rightValue)
-	}
-	return
-}
-
-// init
-func init() {
-	registerTermConstructor(SymTilde, newBinNotTerm)
-	registerTermConstructor(SymAmpersand, newBinAndTerm)
-	registerTermConstructor(SymVertBar, newBinOrTerm)
-}
--- a/operator-bitwise.go
+++ b/operator-bitwise.go
@ -0,0 +1,154 @@
+// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
+// All rights reserved.
+
+// operator-bitwise.go
+package expr
+
+//-------- Bitwise NOT term
+
+func newBitwiseNotTerm(tk *Token) (inst *term) {
+	return &term{
+		tk:       *tk,
+		children: make([]*term, 0, 1),
+		position: posPrefix,
+		priority: priBitwiseNot,
+		evalFunc: evalBitwiseNot,
+	}
+}
+
+func evalBitwiseNot(ctx ExprContext, opTerm *term) (v any, err error) {
+	var value any
+
+	if value, err = opTerm.evalPrefix(ctx); err != nil {
+		return
+	}
+
+	if IsInteger(value) {
+		i, _ := value.(int64)
+		v = ^i
+	} else {
+		err = opTerm.errIncompatibleType(value)
+	}
+	return
+}
+
+//-------- Bitwise AND term
+
+func newBitwiseAndTerm(tk *Token) (inst *term) {
+	return &term{
+		tk:       *tk,
+		children: make([]*term, 0, 2),
+		position: posInfix,
+		priority: priBitwiseAnd,
+		evalFunc: evalBitwiseAnd,
+	}
+}
+
+func bitwiseAnd(opTerm *term, leftValue, rightValue any) (v any, err error) {
+	var leftInt, rightInt int64
+	var lok, rok bool
+
+	leftInt, lok = leftValue.(int64)
+	rightInt, rok = rightValue.(int64)
+
+	if lok && rok {
+		v = leftInt & rightInt
+	} else {
+		err = opTerm.errIncompatibleTypes(leftValue, rightValue)
+	}
+	return
+}
+
+func evalBitwiseAnd(ctx ExprContext, opTerm *term) (v any, err error) {
+	var leftValue, rightValue any
+
+	if leftValue, rightValue, err = opTerm.evalInfix(ctx); err != nil {
+		return
+	}
+	v, err = bitwiseAnd(opTerm, leftValue, rightValue)
+	return
+}
+
+//-------- Bitwise OR term
+
+func newBitwiseOrTerm(tk *Token) (inst *term) {
+	return &term{
+		tk:       *tk,
+		children: make([]*term, 0, 2),
+		position: posInfix,
+		priority: priBitwiseOr,
+		evalFunc: evalBitwiseOr,
+	}
+}
+
+func bitwiseOr(opTerm *term, leftValue, rightValue any) (v any, err error) {
+	var leftInt, rightInt int64
+	var lok, rok bool
+
+	leftInt, lok = leftValue.(int64)
+	rightInt, rok = rightValue.(int64)
+
+	if lok && rok {
+		v = leftInt | rightInt
+	} else {
+		err = opTerm.errIncompatibleTypes(leftValue, rightValue)
+	}
+	return
+}
+
+func evalBitwiseOr(ctx ExprContext, opTerm *term) (v any, err error) {
+	var leftValue, rightValue any
+
+	if leftValue, rightValue, err = opTerm.evalInfix(ctx); err != nil {
+		return
+	}
+
+	v, err = bitwiseOr(opTerm, leftValue, rightValue)
+	return
+}
+
+//-------- Bitwise XOR term
+
+func newBitwiseXorTerm(tk *Token) (inst *term) {
+	return &term{
+		tk:       *tk,
+		children: make([]*term, 0, 2),
+		position: posInfix,
+		priority: priBitwiseOr,
+		evalFunc: evalBitwiseXor,
+	}
+}
+
+func bitwiseXor(opTerm *term, leftValue, rightValue any) (v any, err error) {
+	var leftInt, rightInt int64
+	var lok, rok bool
+
+	leftInt, lok = leftValue.(int64)
+	rightInt, rok = rightValue.(int64)
+
+	if lok && rok {
+		v = leftInt ^ rightInt
+	} else {
+		err = opTerm.errIncompatibleTypes(leftValue, rightValue)
+	}
+	return
+}
+
+func evalBitwiseXor(ctx ExprContext, opTerm *term) (v any, err error) {
+	var leftValue, rightValue any
+
+	if leftValue, rightValue, err = opTerm.evalInfix(ctx); err != nil {
+		return
+	}
+
+	v, err = bitwiseXor(opTerm, leftValue, rightValue)
+	return
+}
+
+// init
+func init() {
+	registerTermConstructor(SymTilde, newBitwiseNotTerm)
+	registerTermConstructor(SymAmpersand, newBitwiseAndTerm)
+	registerTermConstructor(SymVertBar, newBitwiseOrTerm)
+	registerTermConstructor(SymCaret, newBitwiseXorTerm)
+}
--- a/operator-iter-value.go
+++ b/operator-iter-value.go
@ -11,7 +11,7 @@ func newIterValueTerm(tk *Token) (inst *term) {
 		tk:       *tk,
 		children: make([]*term, 0, 1),
 		position: posPrefix,
-		priority: priIterValue,
+		priority: priDereference,
 		evalFunc: evalIterValue,
 	}
 }
@ -33,6 +33,6 @@ func evalIterValue(ctx ExprContext, opTerm *term) (v any, err error) {

 // init
 func init() {
-//	registerTermConstructor(SymOpenClosedRound, newIterValueTerm)
-	registerTermConstructor(SymCaret, newIterValueTerm)
+	//	registerTermConstructor(SymOpenClosedRound, newIterValueTerm)
+	registerTermConstructor(SymDereference, newIterValueTerm)
 }
--- a/operator-shift.go
+++ b/operator-shift.go
@ -4,7 +4,7 @@
 // operator-shift.go
 package expr

-//-------- shift term
+//-------- bit right shift term

 func newRightShiftTerm(tk *Token) (inst *term) {
 	return &term{
@ -16,13 +16,7 @@ func newRightShiftTerm(tk *Token) (inst *term) {
 	}
 }

-func evalRightShift(ctx ExprContext, opTerm *term) (v any, err error) {
-	var leftValue, rightValue any
-
-	if leftValue, rightValue, err = opTerm.evalInfix(ctx); err != nil {
-		return
-	}
-
+func bitRightShift(opTerm *term, leftValue, rightValue any) (v any, err error) {
 	if IsInteger(leftValue) && IsInteger(rightValue) {
 		leftInt := leftValue.(int64)
 		rightInt := rightValue.(int64)
@ -33,6 +27,17 @@ func evalRightShift(ctx ExprContext, opTerm *term) (v any, err error) {
 	return
 }

+func evalRightShift(ctx ExprContext, opTerm *term) (v any, err error) {
+	var leftValue, rightValue any
+
+	if leftValue, rightValue, err = opTerm.evalInfix(ctx); err != nil {
+		return
+	}
+
+	v, err = bitRightShift(opTerm, leftValue, rightValue)
+	return
+}
+
 func newLeftShiftTerm(tk *Token) (inst *term) {
 	return &term{
 		tk:       *tk,
@ -43,13 +48,7 @@ func newLeftShiftTerm(tk *Token) (inst *term) {
 	}
 }

-func evalLeftShift(ctx ExprContext, opTerm *term) (v any, err error) {
-	var leftValue, rightValue any
-
-	if leftValue, rightValue, err = opTerm.evalInfix(ctx); err != nil {
-		return
-	}
-
+func bitLeftShift(opTerm *term, leftValue, rightValue any) (v any, err error) {
 	if IsInteger(leftValue) && IsInteger(rightValue) {
 		leftInt := leftValue.(int64)
 		rightInt := rightValue.(int64)
@ -60,23 +59,16 @@ func evalLeftShift(ctx ExprContext, opTerm *term) (v any, err error) {
 	return
 }

-// func evalAssignAppend(ctx ExprContext, self *term) (v any, err error) {
-// 	var leftValue, rightValue any
+func evalLeftShift(ctx ExprContext, opTerm *term) (v any, err error) {
+	var leftValue, rightValue any

-// 	if leftValue, rightValue, err = self.evalInfix(ctx); err != nil {
-// 		return
-// 	}
+	if leftValue, rightValue, err = opTerm.evalInfix(ctx); err != nil {
+		return
+	}

-// 	if IsList(leftValue) {
-// 		list, _ := leftValue.(*ListType)
-// 		newList := append(*list, rightValue)
-// 		v = &newList
-// 		if
-// 	} else {
-// 		err = self.errIncompatibleTypes(leftValue, rightValue)
-// 	}
-// 	return
-// }
+	v, err = bitLeftShift(opTerm, leftValue, rightValue)
+	return
+}

 // init
 func init() {
--- a/parser.go
+++ b/parser.go
@ -441,8 +441,10 @@ func (parser *parser) parseGeneral(scanner *scanner, ctx parserContext, termSymb
 				tk.Sym = SymChangeSign
 			} else if tk.Sym == SymPlus {
 				tk.Sym = SymUnchangeSign
+			} else if tk.IsSymbol(SymStar) {
+				tk.SetSymbol(SymDereference)
 			} else if tk.IsSymbol(SymExclamation) {
-				err = tk.Errorf("postfix opertor %q requires an operand on its left", tk)
+				err = tk.Errorf("postfix opertor %q requires an operand on its left side", tk)
 				break
 			}
 			firstToken = false
@ -481,7 +483,7 @@ func (parser *parser) parseGeneral(scanner *scanner, ctx parserContext, termSymb
 					currentTerm = mapTerm
 				}
 			}
-		case SymEqual, SymPlusEqual, SymMinusEqual, SymStarEqual, SymSlashEqual, SymPercEqual:
+		case SymEqual, SymPlusEqual, SymMinusEqual, SymStarEqual, SymSlashEqual, SymPercEqual, SymAmpersandEqual, SymVertBarEqual, SymDoubleLessEqual, SymDoubleGreaterEqual, SymCaretEqual:
 			currentTerm, err = tree.addToken(tk)
 			firstToken = true
 		case SymFuncDef:
@ -518,14 +520,11 @@ func (parser *parser) parseGeneral(scanner *scanner, ctx parserContext, termSymb
 					}
 				}
 			} else {
-				// if hasFlag(ctx, allowIndex) {
-				// 	tk.Sym = SymRange
-				// }
 				currentTerm, err = tree.addToken(tk)
-			}
-			if tk.IsOneOfA(SymColon, SymRange) {
-				// Colon outside a selector term acts like a separator
-				firstToken = true
+				if tk.IsOneOfA(SymColon, SymRange) {
+					// Colon outside a selector term acts like a separator
+					firstToken = true
+				}
 			}
 		default:
 			currentTerm, err = tree.addToken(tk)
--- a/scanner.go
+++ b/scanner.go
@ -169,13 +169,19 @@ func (scanner *scanner) fetchNextToken() (tk *Token) {
 		case '|':
 			if next, _ := scanner.peek(); next == '|' {
 				tk = scanner.moveOn(SymDoubleVertBar, ch, next)
+			} else if next, _ = scanner.peek(); next == '=' {
+				tk = scanner.moveOn(SymVertBarEqual, ch, next)
 			} else {
 				tk = scanner.makeToken(SymVertBar, ch)
 			}
 		case ',':
 			tk = scanner.makeToken(SymComma, ch)
 		case '^':
-			tk = scanner.makeToken(SymCaret, ch)
+			if next, _ := scanner.peek(); next == '=' {
+				tk = scanner.moveOn(SymCaretEqual, ch, next)
+			} else {
+				tk = scanner.makeToken(SymCaret, ch)
+			}
 		case ':':
 			if next, _ := scanner.peek(); next == ':' {
 				tk = scanner.moveOn(SymDoubleColon, ch, next)
@ -234,11 +240,17 @@ func (scanner *scanner) fetchNextToken() (tk *Token) {
 		case '&':
 			if next, _ := scanner.peek(); next == '&' {
 				tk = scanner.moveOn(SymDoubleAmpersand, ch, next)
+			} else if next, _ = scanner.peek(); next == '=' {
+				tk = scanner.moveOn(SymAmpersandEqual, ch, next)
 			} else {
 				tk = scanner.makeToken(SymAmpersand, ch)
 			}
 		case '%':
-			tk = scanner.makeToken(SymPercent, ch)
+			if next, _ := scanner.peek(); next == '=' {
+				tk = scanner.moveOn(SymPercEqual, ch, next)
+			} else {
+				tk = scanner.makeToken(SymPercent, ch)
+			}
 		case '#':
 			tk = scanner.makeToken(SymHash, ch)
 		case '@':
@ -267,7 +279,14 @@ func (scanner *scanner) fetchNextToken() (tk *Token) {
 			if next, _ := scanner.peek(); next == '=' {
 				tk = scanner.moveOn(SymLessOrEqual, ch, next)
 			} else if next == '<' {
-				tk = scanner.moveOn(SymDoubleLess, ch, next)
+				scanner.readChar()
+				next2, _ := scanner.readChar()
+				scanner.unreadChar()
+				if next2 == '=' {
+					tk = scanner.moveOn(SymDoubleLessEqual, ch, next, next2)
+				} else {
+					tk = scanner.accept(SymDoubleLess, ch, next)
+				}
 			} else if next == '>' {
 				tk = scanner.moveOn(SymLessGreater, ch, next)
 			} else if next == '+' {
@ -279,7 +298,14 @@ func (scanner *scanner) fetchNextToken() (tk *Token) {
 			if next, _ := scanner.peek(); next == '=' {
 				tk = scanner.moveOn(SymGreaterOrEqual, ch, next)
 			} else if next == '>' {
-				tk = scanner.moveOn(SymDoubleGreater, ch, next)
+				scanner.readChar()
+				next2, _ := scanner.readChar()
+				scanner.unreadChar()
+				if next2 == '=' {
+					tk = scanner.moveOn(SymDoubleGreaterEqual, ch, next, next2)
+				} else {
+					tk = scanner.accept(SymDoubleGreater, ch, next)
+				}
 			} else {
 				tk = scanner.makeToken(SymGreater, ch)
 			}
@ -634,9 +660,16 @@ func (scanner *scanner) translate(sym Symbol) Symbol {

 func (scanner *scanner) moveOn(sym Symbol, chars ...byte) (tk *Token) {
 	tk = NewToken(scanner.row, scanner.column, scanner.translate(sym), string(chars))
-	for i := 1; i < len(chars); i++ {
+	// for i := 1; i < len(chars); i++ {
+	if len(chars) > 1 {
 		scanner.readChar()
 	}
+	// }
+	return
+}
+
+func (scanner *scanner) accept(sym Symbol, chars ...byte) (tk *Token) {
+	tk = NewToken(scanner.row, scanner.column, scanner.translate(sym), string(chars))
 	return
 }

--- a/symbol-map.go
+++ b/symbol-map.go
@ -14,7 +14,7 @@ type symbolClass int16

 const (
 	symClassOperator symbolClass = iota
-	symClassPostOp
+	symClassCommand
 	symClassIdentifier
 	symClassDelimiter
 	symClassParenthesis
@ -24,79 +24,85 @@ const (
 )

 type symbolSpec struct {
-	repr string
-	kind symbolClass
+	repr   string
+	kind   symbolClass
+	opType termPosition
 }

 func init() {

 	symbolMap = map[Symbol]symbolSpec{
-		SymUnknown:         {"<unknown>", symClassOther}, //  -1: Unknown symbol
-		SymNone:            {"<null>", symClassOther},    //   0: Null value for variable of type symbol
-		SymError:           {"<error>", symClassOther},   //   1: Error reading from stream
-		SymEos:             {"<eos>", symClassOther},     //   2: End of stream
-		SymMinus:           {"-", symClassOperator},      //   3: '-'
-		SymMinusEqual:      {"-=", symClassOperator},     //   4: '-='
-		SymDoubleMinus:     {"--", symClassOperator},     //   5: '--'
-		SymPlus:            {"+", symClassOperator},      //   6: '+'
-		SymPlusEqual:       {"+=", symClassOperator},     //   7: '+='
-		SymDoublePlus:      {"++", symClassOperator},     //   8: '++'
-		SymStar:            {"*", symClassOperator},      //   9: '*'
-		SymDoubleStar:      {"**", symClassOperator},     //  10: '**'
-		SymSlash:           {"/", symClassOperator},      //  11: '/'
-		SymBackSlash:       {"\\", symClassOperator},     //  12: '\'
-		SymVertBar:         {"|", symClassOperator},      //  13: '|'
-		SymDoubleVertBar:   {"||", symClassOperator},     //  14: '||'
-		SymComma:           {",", symClassOperator},      //  15: ','
-		SymColon:           {":", symClassOperator},      //  16: ':'
-		SymSemiColon:       {";", symClassOperator},      //  17: ';'
-		SymDot:             {".", symClassOperator},      //  18: '.'
-		SymDotSlash:        {"./", symClassOperator},     //  19: './'
-		SymQuote:           {"'", symClassDelimiter},     //  20: '\''
-		SymDoubleQuote:     {"\"", symClassDelimiter},    //  21: '"'
-		SymBackTick:        {"`", symClassOperator},      //  22: '`'
-		SymExclamation:     {"!", symClassPostOp},        //  23: '!'
-		SymQuestion:        {"?", symClassOperator},      //  24: '?'
-		SymAmpersand:       {"&", symClassOperator},      //  25: '&'
-		SymDoubleAmpersand: {"&&", symClassOperator},     //  26: '&&'
-		SymPercent:         {"%", symClassOperator},      //  27: '%'
-		SymAt:              {"@", symClassOperator},      //  28: '@'
-		SymUndescore:       {"_", symClassOperator},      //  29: '_'
-		SymEqual:           {"=", symClassOperator},      //  30: '='
-		SymDoubleEqual:     {"==", symClassOperator},     //  31: '=='
-		SymLess:            {"<", symClassOperator},      //  32: '<'
-		SymLessOrEqual:     {"<=", symClassOperator},     //  33: '<='
-		SymGreater:         {">", symClassOperator},      //  34: '>'
-		SymGreaterOrEqual:  {">=", symClassOperator},     //  35: '>='
-		SymLessGreater:     {"<>", symClassOperator},     //  36: '<>'
-		SymNotEqual:        {"!=", symClassOperator},     //  37: '!='
-		SymDollar:          {"$", symClassOperator},      //  38: '$'
-		SymHash:            {"#", symClassOperator},      //  39: '#'
-		SymOpenRound:       {"(", symClassParenthesis},   //  40: '('
-		SymClosedRound:     {")", symClassParenthesis},   //  41: ')'
-		SymOpenSquare:      {"[", symClassParenthesis},   //  42: '['
-		SymClosedSquare:    {"]", symClassParenthesis},   //  43: ']'
-		SymOpenBrace:       {"{", symClassParenthesis},   //  44: '{'
-		SymClosedBrace:     {"}", symClassParenthesis},   //  45: '}'
-		SymTilde:           {"~", symClassOperator},      //  46: '~'
-		SymDoubleQuestion:  {"??", symClassOperator},     //  47: '??'
-		SymQuestionEqual:   {"?=", symClassOperator},     //  48: '?='
-		SymQuestionExclam:  {"?!", symClassOperator},     //  49: '?!'
-		SymDoubleAt:        {"@@", symClassOperator},     //  50: '@@'
-		SymDoubleColon:     {"::", symClassOperator},     //  51: '::'
-		SymDoubleGreater:   {">>", symClassOperator},     //  52: '>>'
-		SymDoubleLess:      {"<<", symClassOperator},     //  53: '<<'
-		SymCaret:           {"^", symClassOperator},      //  54: '^'
-		SymDollarRound:     {"$(", symClassOperator},     //  55: '$('
-		SymOpenClosedRound: {"()", symClassPostOp},       //  56: '()'
-		SymDoubleDollar:    {"$$", symClassOperator},     //  57: '$$'
-		SymDoubleDot:       {"..", symClassOperator},     //  58: '..'
-		SymTripleDot:       {"...", symClassOperator},    //  59: '...'
-		SymStarEqual:       {"*=", symClassOperator},     //  60: '*='
-		SymSlashEqual:      {"/=", symClassOperator},     //  61: '/='
-		SymPercEqual:       {"%=", symClassOperator},     //  62: '%='
-		SymPlusGreater:     {"+>", symClassOperator},     //  63: '+>'
-		SymLessPlus:        {"<+", symClassOperator},     //  64: '<+'
+		SymUnknown:            {"<unknown>", symClassOther, posLeaf},  //  -1: Unknown symbol
+		SymNone:               {"<null>", symClassOther, posLeaf},     //   0: Null value for variable of type symbol
+		SymError:              {"<error>", symClassOther, posLeaf},    //   1: Error reading from stream
+		SymEos:                {"<eos>", symClassOther, posLeaf},      //   2: End of stream
+		SymMinus:              {"-", symClassOperator, posInfix},      //   3: '-'
+		SymMinusEqual:         {"-=", symClassOperator, posInfix},     //   4: '-='
+		SymDoubleMinus:        {"--", symClassOperator, posPostfix},   //   5: '--'
+		SymPlus:               {"+", symClassOperator, posInfix},      //   6: '+'
+		SymPlusEqual:          {"+=", symClassOperator, posInfix},     //   7: '+='
+		SymDoublePlus:         {"++", symClassOperator, posPostfix},   //   8: '++'
+		SymStar:               {"*", symClassOperator, posInfix},      //   9: '*'
+		SymDoubleStar:         {"**", symClassOperator, posInfix},     //  10: '**'
+		SymSlash:              {"/", symClassOperator, posInfix},      //  11: '/'
+		SymBackSlash:          {"\\", symClassOperator, posLeaf},      //  12: '\'
+		SymVertBar:            {"|", symClassOperator, posInfix},      //  13: '|'
+		SymDoubleVertBar:      {"||", symClassOperator, posInfix},     //  14: '||'
+		SymComma:              {",", symClassOperator, posInfix},      //  15: ','
+		SymColon:              {":", symClassOperator, posInfix},      //  16: ':'
+		SymSemiColon:          {";", symClassOperator, posInfix},      //  17: ';'
+		SymDot:                {".", symClassOperator, posInfix},      //  18: '.'
+		SymDotSlash:           {"./", symClassOperator, posInfix},     //  19: './'
+		SymQuote:              {"'", symClassDelimiter, posLeaf},      //  20: '\''
+		SymDoubleQuote:        {"\"", symClassDelimiter, posLeaf},     //  21: '"'
+		SymBackTick:           {"`", symClassDelimiter, posLeaf},      //  22: '`'
+		SymExclamation:        {"!", symClassOperator, posPostfix},    //  23: '!'
+		SymQuestion:           {"?", symClassOperator, posInfix},      //  24: '?'
+		SymAmpersand:          {"&", symClassOperator, posInfix},      //  25: '&'
+		SymDoubleAmpersand:    {"&&", symClassOperator, posInfix},     //  26: '&&'
+		SymPercent:            {"%", symClassOperator, posInfix},      //  27: '%'
+		SymAt:                 {"@", symClassOperator, posPrefix},     //  28: '@'
+		SymUndescore:          {"_", symClassIdentifier, posLeaf},     //  29: '_'
+		SymEqual:              {"=", symClassOperator, posInfix},      //  30: '='
+		SymDoubleEqual:        {"==", symClassOperator, posInfix},     //  31: '=='
+		SymLess:               {"<", symClassOperator, posInfix},      //  32: '<'
+		SymLessOrEqual:        {"<=", symClassOperator, posInfix},     //  33: '<='
+		SymGreater:            {">", symClassOperator, posInfix},      //  34: '>'
+		SymGreaterOrEqual:     {">=", symClassOperator, posInfix},     //  35: '>='
+		SymLessGreater:        {"<>", symClassOperator, posInfix},     //  36: '<>'
+		SymNotEqual:           {"!=", symClassOperator, posInfix},     //  37: '!='
+		SymDollar:             {"$", symClassOperator, posPrefix},     //  38: '$'
+		SymHash:               {"#", symClassOperator, posPrefix},     //  39: '#'
+		SymOpenRound:          {"(", symClassParenthesis, posPrefix},  //  40: '('
+		SymClosedRound:        {")", symClassParenthesis, posPostfix}, //  41: ')'
+		SymOpenSquare:         {"[", symClassParenthesis, posPrefix},  //  42: '['
+		SymClosedSquare:       {"]", symClassParenthesis, posPostfix}, //  43: ']'
+		SymOpenBrace:          {"{", symClassParenthesis, posPrefix},  //  44: '{'
+		SymClosedBrace:        {"}", symClassParenthesis, posPostfix}, //  45: '}'
+		SymTilde:              {"~", symClassOperator, posPrefix},     //  46: '~'
+		SymDoubleQuestion:     {"??", symClassOperator, posInfix},     //  47: '??'
+		SymQuestionEqual:      {"?=", symClassOperator, posInfix},     //  48: '?='
+		SymQuestionExclam:     {"?!", symClassOperator, posInfix},     //  49: '?!'
+		SymDoubleAt:           {"@@", symClassCommand, posLeaf},       //  50: '@@'
+		SymDoubleColon:        {"::", symClassOperator, posInfix},     //  51: '::'
+		SymDoubleGreater:      {">>", symClassOperator, posInfix},     //  52: '>>'
+		SymDoubleLess:         {"<<", symClassOperator, posInfix},     //  53: '<<'
+		SymCaret:              {"^", symClassOperator, posInfix},      //  54: '^'
+		SymDollarRound:        {"$(", symClassOperator, posPrefix},    //  55: '$('
+		SymOpenClosedRound:    {"()", symClassOperator, posPostfix},   //  56: '()'
+		SymDoubleDollar:       {"$$", symClassCommand, posLeaf},       //  57: '$$'
+		SymDoubleDot:          {"..", symClassOperator, posInfix},     //  58: '..'
+		SymTripleDot:          {"...", symClassOperator, posPostfix},  //  59: '...'
+		SymStarEqual:          {"*=", symClassOperator, posInfix},     //  60: '*='
+		SymSlashEqual:         {"/=", symClassOperator, posInfix},     //  61: '/='
+		SymPercEqual:          {"%=", symClassOperator, posInfix},     //  62: '%='
+		SymDoubleLessEqual:    {"<<=", symClassOperator, posInfix},    //  63: '<<='
+		SymDoubleGreaterEqual: {">>=", symClassOperator, posInfix},    //  64: '>>='
+		SymAmpersandEqual:     {"&=", symClassOperator, posInfix},     //  65: '&='
+		SymVertBarEqual:       {"|=", symClassOperator, posInfix},     //  65: '|='
+		SymCaretEqual:         {"^=", symClassOperator, posInfix},     //  66: '^='
+		SymPlusGreater:        {"+>", symClassOperator, posInfix},     //  67: '+>'
+		SymLessPlus:           {"<+", symClassOperator, posInfix},     //  68: '<+'
 		// SymChangeSign
 		// SymUnchangeSign
 		// SymIdentifier
@ -123,17 +129,17 @@ func init() {
 		// // SymClosedComment                     //   0: '*/'
 		// // SymOneLineComment                    //   0: '//'
 		// keywordBase
-		SymKwAnd:     {"and", symClassOperator},
-		SymKwNot:     {"not", symClassOperator},
-		SymKwOr:      {"or", symClassOperator},
-		SymKwBut:     {"but", symClassOperator},
-		SymKwFunc:    {"func(", symClassDeclaration},
-		SymKwBuiltin: {"builtin", symClassOperator},
-		SymKwPlugin:  {"plugin", symClassOperator},
-		SymKwIn:      {"in", symClassOperator},
-		SymKwInclude: {"include", symClassOperator},
-		SymKwNil:     {"nil", symClassValue},
-		SymKwUnset:   {"unset", symClassOperator},
+		SymKwAnd:     {"and", symClassOperator, posInfix},
+		SymKwNot:     {"not", symClassOperator, posInfix},
+		SymKwOr:      {"or", symClassOperator, posInfix},
+		SymKwBut:     {"but", symClassOperator, posInfix},
+		SymKwFunc:    {"func(", symClassDeclaration, posPrefix},
+		SymKwBuiltin: {"builtin", symClassOperator, posPrefix},
+		SymKwPlugin:  {"plugin", symClassOperator, posPrefix},
+		SymKwIn:      {"in", symClassOperator, posInfix},
+		SymKwInclude: {"include", symClassOperator, posPrefix},
+		SymKwNil:     {"nil", symClassValue, posLeaf},
+		SymKwUnset:   {"unset", symClassOperator, posPrefix},
 	}
 }

@ -171,12 +177,19 @@ func StringEndsWithOperator(s string) bool {
 }

 func endingOperator(s string) (sym Symbol) {
+	var matchLength = 0
 	sym = SymNone
-	lower := strings.ToLower(s)
+	lower := strings.TrimRight(strings.ToLower(s), " \t")
 	for symbol, spec := range symbolMap {
-		if spec.kind == symClassOperator && strings.HasSuffix(lower, spec.repr) {
-			sym = symbol
-			break
+		if strings.HasSuffix(lower, spec.repr) {
+			if len(spec.repr) > matchLength {
+				matchLength = len(spec.repr)
+				if spec.kind == symClassOperator && (spec.opType == posInfix || spec.opType == posPrefix) {
+					sym = symbol
+				} else {
+					sym = SymNone
+				}
+			}
 		}
 	}
 	return
--- a/symbol.go
+++ b/symbol.go
@ -7,74 +7,80 @@ package expr
 type Symbol int16

 const (
-	SymUnknown         Symbol = iota - 1 //  -1: Unknown symbol
-	SymNone                              //   0: Null value for variable of type symbol
-	SymError                             //   1: Error reading from stream
-	SymEos                               //   2: End of stream
-	SymMinus                             //   3: '-'
-	SymMinusEqual                        //   4: '-='
-	SymDoubleMinus                       //   5: '--'
-	SymPlus                              //   6: '+'
-	SymPlusEqual                         //   7: '+='
-	SymDoublePlus                        //   8: '++'
-	SymStar                              //   9: '*'
-	SymDoubleStar                        //  10: '**'
-	SymSlash                             //  11: '/'
-	SymBackSlash                         //  12: '\'
-	SymVertBar                           //  13: '|'
-	SymDoubleVertBar                     //  14: '||'
-	SymComma                             //  15: ','
-	SymColon                             //  16: ':'
-	SymSemiColon                         //  17: ';'
-	SymDot                               //  18: '.'
-	SymDotSlash                          //  19: './'
-	SymQuote                             //  20: '\''
-	SymDoubleQuote                       //  21: '"'
-	SymBackTick                          //  22: '`'
-	SymExclamation                       //  23: '!'
-	SymQuestion                          //  24: '?'
-	SymAmpersand                         //  25: '&'
-	SymDoubleAmpersand                   //  26: '&&'
-	SymPercent                           //  27: '%'
-	SymAt                                //  28: '@'
-	SymUndescore                         //  29: '_'
-	SymEqual                             //  30: '='
-	SymDoubleEqual                       //  31: '=='
-	SymLess                              //  32: '<'
-	SymLessOrEqual                       //  33: '<='
-	SymGreater                           //  34: '>'
-	SymGreaterOrEqual                    //  35: '>='
-	SymLessGreater                       //  36: '<>'
-	SymNotEqual                          //  37: '!='
-	SymDollar                            //  38: '$'
-	SymHash                              //  39: '#'
-	SymOpenRound                         //  40: '('
-	SymClosedRound                       //  41: ')'
-	SymOpenSquare                        //  42: '['
-	SymClosedSquare                      //  43: ']'
-	SymOpenBrace                         //  44: '{'
-	SymClosedBrace                       //  45: '}'
-	SymTilde                             //  46: '~'
-	SymDoubleQuestion                    //  47: '??'
-	SymQuestionEqual                     //  48: '?='
-	SymQuestionExclam                    //  49: '?!'
-	SymDoubleAt                          //  50: '@@'
-	SymDoubleColon                       //  51: '::'
-	SymDoubleGreater                     //  52: '>>'
-	SymDoubleLess                        //  53: '<<'
-	SymCaret                             //  54: '^'
-	SymDollarRound                       //  55: '$('
-	SymOpenClosedRound                   //  56: '()'
-	SymDoubleDollar                      //  57: '$$'
-	SymDoubleDot                         //  58: '..'
-	SymTripleDot                         //  59: '...'
-	SymStarEqual                         //  60: '*='
-	SymSlashEqual                        //  61: '/='
-	SymPercEqual                         //  62: '%='
-	SymPlusGreater                       //  63: '+>'
-	SymLessPlus                          //  64: '<+'
+	SymUnknown            Symbol = iota - 1 //  -1: Unknown symbol
+	SymNone                                 //   0: Null value for variable of type symbol
+	SymError                                //   1: Error reading from stream
+	SymEos                                  //   2: End of stream
+	SymMinus                                //   3: '-'
+	SymMinusEqual                           //   4: '-='
+	SymDoubleMinus                          //   5: '--'
+	SymPlus                                 //   6: '+'
+	SymPlusEqual                            //   7: '+='
+	SymDoublePlus                           //   8: '++'
+	SymStar                                 //   9: '*'
+	SymDoubleStar                           //  10: '**'
+	SymSlash                                //  11: '/'
+	SymBackSlash                            //  12: '\'
+	SymVertBar                              //  13: '|'
+	SymDoubleVertBar                        //  14: '||'
+	SymComma                                //  15: ','
+	SymColon                                //  16: ':'
+	SymSemiColon                            //  17: ';'
+	SymDot                                  //  18: '.'
+	SymDotSlash                             //  19: './'
+	SymQuote                                //  20: '\''
+	SymDoubleQuote                          //  21: '"'
+	SymBackTick                             //  22: '`'
+	SymExclamation                          //  23: '!'
+	SymQuestion                             //  24: '?'
+	SymAmpersand                            //  25: '&'
+	SymDoubleAmpersand                      //  26: '&&'
+	SymPercent                              //  27: '%'
+	SymAt                                   //  28: '@'
+	SymUndescore                            //  29: '_'
+	SymEqual                                //  30: '='
+	SymDoubleEqual                          //  31: '=='
+	SymLess                                 //  32: '<'
+	SymLessOrEqual                          //  33: '<='
+	SymGreater                              //  34: '>'
+	SymGreaterOrEqual                       //  35: '>='
+	SymLessGreater                          //  36: '<>'
+	SymNotEqual                             //  37: '!='
+	SymDollar                               //  38: '$'
+	SymHash                                 //  39: '#'
+	SymOpenRound                            //  40: '('
+	SymClosedRound                          //  41: ')'
+	SymOpenSquare                           //  42: '['
+	SymClosedSquare                         //  43: ']'
+	SymOpenBrace                            //  44: '{'
+	SymClosedBrace                          //  45: '}'
+	SymTilde                                //  46: '~'
+	SymDoubleQuestion                       //  47: '??'
+	SymQuestionEqual                        //  48: '?='
+	SymQuestionExclam                       //  49: '?!'
+	SymDoubleAt                             //  50: '@@'
+	SymDoubleColon                          //  51: '::'
+	SymDoubleGreater                        //  52: '>>'
+	SymDoubleLess                           //  53: '<<'
+	SymCaret                                //  54: '^'
+	SymDollarRound                          //  55: '$('
+	SymOpenClosedRound                      //  56: '()'
+	SymDoubleDollar                         //  57: '$$'
+	SymDoubleDot                            //  58: '..'
+	SymTripleDot                            //  59: '...'
+	SymStarEqual                            //  60: '*='
+	SymSlashEqual                           //  61: '/='
+	SymPercEqual                            //  62: '%='
+	SymDoubleLessEqual                      //  63: '<<='
+	SymDoubleGreaterEqual                   //  64: '>>='
+	SymAmpersandEqual                       //  65: '&='
+	SymVertBarEqual                         //  65: '|='
+	SymCaretEqual                           //  66: '^='
+	SymPlusGreater                          //  67: '+>'
+	SymLessPlus                             //  68: '<+'
 	SymChangeSign
 	SymUnchangeSign
+	SymDereference
 	SymIdentifier
 	SymBool
 	SymInteger
--- a/t_expr_test.go
+++ b/t_expr_test.go
@ -29,7 +29,9 @@ func TestExpr(t *testing.T) {
 		/*  15 */ {`a=3; a*=2)+1; a`, nil, `[1:11] unexpected token ")"`},
 		/*  16 */ {`v=[2]; a=1; v[a-=1]=5; v[0]`, int64(5), nil},
 		/*  17 */ {`true ? {"a"} :: {"b"}`, "a", nil},
-		/*  18 */ {`
+		/*  18 */ {`$$`, NewDict(map[any]any{"variables": NewDict(nil), "functions": NewDict(nil)}), nil},
+		///*  19 */ {`$$global`, NewDict(map[any]any{"variables": NewDict(nil), "functions": NewDict(nil)}), nil},
+		/*  19 */ {`
 		ds={
 			"init":func(@end){@current=0 but true},
 			//"current":func(){current},
@ -44,6 +46,6 @@ func TestExpr(t *testing.T) {
 	}
 	// t.Setenv("EXPR_PATH", ".")

-	// runTestSuiteSpec(t, section, inputs, 6, 7, 8, 9)
+	// runTestSuiteSpec(t, section, inputs, 18)
 	runTestSuite(t, section, inputs)
 }
--- a/t_iterator_test.go
+++ b/t_iterator_test.go
@ -9,10 +9,10 @@ import "testing"
 func TestIteratorParser(t *testing.T) {
 	section := "Iterator"
 	inputs := []inputType{
-		/*   1 */ {`include "test-resources/iterator.expr"; it=$(ds,3); ^it`, int64(0), nil},
+		/*   1 */ {`include "test-resources/iterator.expr"; it=$(ds,3); *it`, int64(0), nil},
 		/*   2 */ {`include "test-resources/iterator.expr"; it=$(ds,3); it++; it++`, int64(1), nil},
 		/*   3 */ {`include "test-resources/iterator.expr"; it=$(ds,3); it++; it++; #it`, int64(3), nil},
-		/*   4 */ {`include "test-resources/iterator.expr"; it=$(ds,3); it++; it++; it.reset; ^it`, int64(0), nil},
+		/*   4 */ {`include "test-resources/iterator.expr"; it=$(ds,3); it++; it++; it.reset; *it`, int64(0), nil},
 		/*   5 */ {`builtin "math.arith"; include "test-resources/iterator.expr"; it=$(ds,3); add(it)`, int64(6), nil},
 		/*   6 */ {`builtin "math.arith"; include "test-resources/iterator.expr"; it=$(ds,3); mul(it)`, int64(0), nil},
 		/*   7 */ {`builtin "math.arith"; include "test-resources/file-reader.expr"; it=$(ds,"test-resources/int.list"); mul(it)`, int64(12000), nil},
--- a/t_list_test.go
+++ b/t_list_test.go
@ -38,9 +38,9 @@ func TestListParser(t *testing.T) {
 		/*  24 */ {`["a","b","c","d"][1]`, "b", nil},
 		/*  25 */ {`["a","b","c","d"][1,1]`, nil, `[1:19] one index only is allowed`},
 		/*  26 */ {`[0,1,2,3,4][:]`, newListA(int64(0), int64(1), int64(2), int64(3), int64(4)), nil},
-		/*  27 */ {`["a", "b", "c"] << ;`, nil, `[1:18] infix operator "<<" requires two non-nil operands, got 1`},
+		/*  27 */ {`["a", "b", "c"] <+ ;`, nil, `[1:18] infix operator "<+" requires two non-nil operands, got 1`},
 		/*  28 */ {`2 << 3;`, int64(16), nil},
-		/*  29 */ {`but >> ["a", "b", "c"]`, nil, `[1:6] infix operator ">>" requires two non-nil operands, got 0`},
+		/*  29 */ {`but +> ["a", "b", "c"]`, nil, `[1:6] infix operator "+>" requires two non-nil operands, got 0`},
 		/*  30 */ {`2 >> 3;`, int64(0), nil},
 		/*  31 */ {`a=[1,2]; a<+3`, newListA(int64(1), int64(2), int64(3)), nil},
 		/*  32 */ {`a=[1,2]; 5+>a`, newListA(int64(5), int64(1), int64(2)), nil},
--- a/t_operator_test.go
+++ b/t_operator_test.go
@ -14,10 +14,27 @@ func TestOperator(t *testing.T) {
 		/*   1 */ {`a=1; unset "a"; a`, nil, `undefined variable or function "a"`},
 		/*   2 */ {`a=1; unset ["a", "b"]`, int64(1), nil},
 		/*   3 */ {`f=func(){3}; unset "f()"`, int64(1), nil},
+		/*   4 */ {`a=1; a<<=1+0`, int64(2), nil},
+		/*   5 */ {`a=2; a>>=1+0`, int64(1), nil},
+		/*   6 */ {`1<<1`, int64(2), nil},
+		/*   7 */ {`1>>1`, int64(0), nil},
+		/*   8 */ {`1|2`, int64(3), nil},
+		/*   9 */ {`a=1; a|=2`, int64(3), nil},
+		/*  10 */ {`3&1`, int64(1), nil},
+		/*  11 */ {`a=3; a&=1`, int64(1), nil},
+		/*  12 */ {`~1`, int64(-2), nil},
+		/*  13 */ {`0x10`, int64(16), nil},
+		/*  14 */ {`0x1X`, nil, `[1:5] two adjacent operators: "1" and "X"`},
+		/*  15 */ {`0o10`, int64(8), nil},
+		/*  16 */ {`0b10`, int64(2), nil},
+		/*  17 */ {`~true`, nil, `[1:2] prefix/postfix operator "~" do not support operand 'true' [bool]`},
+		/*  18 */ {`1^2`, int64(3), nil},
+		/*  19 */ {`3^2`, int64(1), nil},
+		/*  19 */ {`a=1; a^=2`, int64(3), nil},
 	}

 	// t.Setenv("EXPR_PATH", ".")

-	//runTestSuiteSpec(t, section, inputs, 3)
+	// runTestSuiteSpec(t, section, inputs, 4)
 	runTestSuite(t, section, inputs)
 }
--- a/t_parser_test.go
+++ b/t_parser_test.go
@ -142,6 +142,6 @@ func TestGeneralParser(t *testing.T) {
 	}

 	// t.Setenv("EXPR_PATH", ".")
-	//runTestSuiteSpec(t, section, inputs, 130)
+	// runTestSuiteSpec(t, section, inputs, 114)
 	runTestSuite(t, section, inputs)
 }
--- a/t_strings_test.go
+++ b/t_strings_test.go
@ -9,6 +9,7 @@ import (
 )

 func TestStringsParser(t *testing.T) {
+	section := "String"
 	inputs := []inputType{
 		/*  1 */ {`"uno" + "due"`, `unodue`, nil},
 		/*  2 */ {`"uno" + 2`, `uno2`, nil},
@ -22,6 +23,6 @@ func TestStringsParser(t *testing.T) {
 		/* 10 */ {`"AF3B0Dz" / 0`, nil, "[1:12] division by zero"},
 	}

-	// runTestSuiteSpec(t, "String", inputs, 8)
-	runTestSuite(t, "String", inputs)
+	// runTestSuiteSpec(t, section, inputs, 8)
+	runTestSuite(t, section, inputs)
 }
--- a/term.go
+++ b/term.go
@ -20,9 +20,9 @@ const (
 	priAnd
 	priNot
 	priRelational
-	priBinOr
-	priBinAnd
-	priBinNot
+	priBitwiseOr
+	priBitwiseAnd
+	priBitwiseNot
 	priSum
 	priProduct
 	priFraction
@ -34,6 +34,7 @@ const (
 	priDefault
 	priIncDec
 	priDot
+	priDereference
 	priValue
 )

--- a/token.go
+++ b/token.go
@ -79,6 +79,10 @@ func (tk *Token) IsSymbol(sym Symbol) bool {
 	return tk.Sym == sym
 }

+func (tk *Token) SetSymbol(sym Symbol) {
+	tk.Sym = sym
+}
+
 func (tk *Token) Errorf(template string, args ...any) (err error) {
 	err = fmt.Errorf(fmt.Sprintf("[%d:%d] ", tk.row, tk.col)+template, args...)
 	return
Author	SHA1	Message	Date
Celestino Amoroso	760c1ee6da	New bitwise XOR operator specified by symbol ^ (caret). Iterator dereference is now done by prefixed * (star)	2025-01-03 07:33:17 +01:00
Celestino Amoroso	5ab6876ea1	term.go: new priority priDereference	2025-01-03 07:28:30 +01:00
Celestino Amoroso	6268abda8c	token.go: new member function Token.SetSymbol()	2025-01-03 07:27:49 +01:00
Celestino Amoroso	d25bd325b7	symbol-map.go: improved detection of incomplete operations	2025-01-03 06:32:55 +01:00
Celestino Amoroso	01c04feea5	Doc: bitwise operators in the main operator table and special assignment operators table	2025-01-03 05:43:50 +01:00
Celestino Amoroso	6fc689c46c	Added a test to the context type	2025-01-03 05:40:24 +01:00
Celestino Amoroso	eccb0c4dc9	Added new special operators like &= and <<=. Also made a litle change to scanner function moveOn(): now it moves on the last char passed and only if there are more than one chars.	2024-12-29 19:26:02 +01:00