boolean system

stdlib/bool.go

@@ -0,0 +1,155 @@
+/*   SHS: Syntactically Homogeneous Shell
+ *   Copyright (C) 2019  Aidan Hahn
+ *
+ *   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/>.
+ */
+
+package stdlib
+
+import (
+    "strconv"
+    "gitlab.com/whom/shs/log"
+    "gitlab.com/whom/shs/ast"
+)
+
+// lt, gt
+
+func not(in *ast.Token, vt ast.VarTable, ft ast.FuncTable) *ast.Token {
+    if in.Tag != ast.BOOL {
+        log.Log(log.ERR, "non-bool argument to 'not'", "not")
+        return nil
+    }
+
+    out := "T"
+    if in.Inner.(string) == "T" {
+        out = "F"
+    }
+
+    return &ast.Token{Tag: ast.BOOL, Inner: out}
+}
+
+func eq(in *ast.Token, vt ast.VarTable, ft ast.FuncTable) *ast.Token {
+    out := "T"
+    second := in.Next
+
+    if in.Tag != second.Tag {
+        out = "F"
+    } else {
+        switch in.Tag {
+        case ast.LIST:
+            // returns true if difference found
+            var consume_list func(*ast.Token, *ast.Token) bool
+            consume_list = func(l *ast.Token, r *ast.Token) bool {
+                if (l == nil && r != nil) || (r == nil && l != nil) {
+                    return true
+                }
+
+                if l.Tag != r.Tag {
+                    return true
+                }
+
+                l_iter := l
+                r_iter := r
+                for l_iter != nil {
+                    if r_iter == nil || l_iter.Tag != r_iter.Tag {
+                        return true
+                    }
+
+                    if l_iter.Tag == ast.LIST {
+                        diff := consume_list(l_iter.Inner.(*ast.Token),
+                                     r_iter.Inner.(*ast.Token))
+                        if diff {
+                            return true
+                        } 
+
+                    } else {
+                        if l_iter.Inner.(string) != r_iter.Inner.(string) {
+                            return true
+                        }
+                    }
+
+                    l_iter = l_iter.Next
+                    r_iter = r_iter.Next
+                }
+
+                if r_iter != nil {
+                    return true
+                } else {
+                    return false
+                }
+            }
+
+            if consume_list(in.Inner.(*ast.Token), second.Inner.(*ast.Token)) {
+                out = "F"
+            }
+
+        case ast.NUMBER, ast.STRING, ast.BOOL:
+            if in.Inner.(string) != second.Inner.(string) {
+                out = "F"
+            }
+        }
+    }
+
+    return &ast.Token{Tag: ast.BOOL, Inner: out}
+}
+
+func lt(in *ast.Token, vt ast.VarTable, ft ast.FuncTable) *ast.Token {
+    out := "T"
+
+    second := in.Next
+    if in.Tag != ast.NUMBER || second.Tag != ast.NUMBER {
+        log.Log(log.ERR, "non-number argument to numeric boolean operator", ">/<=")
+        return nil
+    }
+
+    l, _ := strconv.ParseInt(in.Inner.(string), 10, 64)
+    r, _ := strconv.ParseInt(second.Inner.(string), 10, 64)
+
+    if l >= r {
+        out = "F"
+    }
+
+    return &ast.Token{Tag: ast.BOOL, Inner: out}
+}
+
+func gt(in *ast.Token, vt ast.VarTable, ft ast.FuncTable) *ast.Token {
+    out := "T"
+
+    second := in.Next
+    if in.Tag != ast.NUMBER || second.Tag != ast.NUMBER {
+        log.Log(log.ERR, "non-number argument to numeric boolean operator", ">/<=")
+        return nil
+    }
+
+    l, _ := strconv.ParseInt(in.Inner.(string), 10, 64)
+    r, _ := strconv.ParseInt(second.Inner.(string), 10, 64)
+
+    if l <= r {
+        out = "F"
+    }
+
+    return &ast.Token{Tag: ast.BOOL, Inner: out}
+}
+
+func ne(in *ast.Token, vt ast.VarTable, ft ast.FuncTable) *ast.Token {
+    return not(eq(in, vt, ft), vt, ft)
+}
+
+func gte(in *ast.Token, vt ast.VarTable, ft ast.FuncTable) *ast.Token {
+    return not(lt(in, vt, ft), vt, ft)
+}
+
+func lte(in *ast.Token, vt ast.VarTable, ft ast.FuncTable) *ast.Token {
+    return not(gt(in, vt, ft), vt, ft)
+}