bare-script 3.4.0__tar.gz → 3.5.0__tar.gz

{bare_script-3.4.0/src/bare_script.egg-info → bare_script-3.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bare-script
-Version: 3.4.0
+Version: 3.5.0
 Summary: bare-script
 Home-page: https://github.com/craigahobbs/bare-script
 Author: Craig A. Hobbs

{bare_script-3.4.0 → bare_script-3.5.0}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = bare-script
-version = 3.4.0
+version = 3.5.0
 url = https://github.com/craigahobbs/bare-script
 author = Craig A. Hobbs
 author_email = craigahobbs@gmail.com

{bare_script-3.4.0 → bare_script-3.5.0}/src/bare_script/model.py

@@ -163,6 +163,12 @@ enum BinaryExpressionOperator
     # Subtraction
     "-"
 
+    # Bitwise left shift
+    "<<"
+
+    # Bitwise right shift
+    ">>"
+
     # Less than or equal
     "<="
 
@@ -181,6 +187,15 @@ enum BinaryExpressionOperator
     # Not equal
     "!="
 
+    # Bitwise AND
+    "&"
+
+    # Bitwise XOR
+    "^"
+
+    # Bitwise OR
+    "|"
+
     # Logical AND
     "&&"
 
@@ -207,6 +222,9 @@ enum UnaryExpressionOperator
     # Logical NOT
     "!"
 
+    # Bitwise NOT
+    "~"
+
 
 # A function expression
 struct FunctionExpression

{bare_script-3.4.0 → bare_script-3.5.0}/src/bare_script/parser.py

@@ -488,18 +488,23 @@ def _parse_binary_expression(expr_text, bin_left_expr=None):
 
 # Binary operator re-order map
 BINARY_REORDER = {
-    '**': {'*', '/', '%', '+', '-', '<=', '<', '>=', '>', '==', '!=', '&&', '||'},
-    '*': {'+', '-', '<=', '<', '>=', '>', '==', '!=', '&&', '||'},
-    '/': {'+', '-', '<=', '<', '>=', '>', '==', '!=', '&&', '||'},
-    '%': {'+', '-', '<=', '<', '>=', '>', '==', '!=', '&&', '||'},
-    '+': {'<=', '<', '>=', '>', '==', '!=', '&&', '||'},
-    '-': {'<=', '<', '>=', '>', '==', '!=', '&&', '||'},
-    '<=': {'==', '!=', '&&', '||'},
-    '<': {'==', '!=', '&&', '||'},
-    '>=': {'==', '!=', '&&', '||'},
-    '>': {'==', '!=', '&&', '||'},
-    '==': {'&&', '||'},
-    '!=': {'&&', '||'},
+    '**': {'*', '/', '%', '+', '-', '<<', '>>', '<=', '<', '>=', '>', '==', '!=', '&', '^', '|', '&&', '||'},
+    '*': {'+', '-', '<<', '>>', '<=', '<', '>=', '>', '==', '!=', '&', '^', '|', '&&', '||'},
+    '/': {'+', '-', '<<', '>>', '<=', '<', '>=', '>', '==', '!=', '&', '^', '|', '&&', '||'},
+    '%': {'+', '-', '<<', '>>', '<=', '<', '>=', '>', '==', '!=', '&', '^', '|', '&&', '||'},
+    '+': {'<<', '>>', '<=', '<', '>=', '>', '==', '!=', '&', '^', '|', '&&', '||'},
+    '-': {'<<', '>>', '<=', '<', '>=', '>', '==', '!=', '&', '^', '|', '&&', '||'},
+    '<<': {'<=', '<', '>=', '>', '==', '!=', '&', '^', '|', '&&', '||'},
+    '>>': {'<=', '<', '>=', '>', '==', '!=', '&', '^', '|', '&&', '||'},
+    '<=': {'==', '!=', '&', '^', '|', '&&', '||'},
+    '<': {'==', '!=', '&', '^', '|', '&&', '||'},
+    '>=': {'==', '!=', '&', '^', '|', '&&', '||'},
+    '>': {'==', '!=', '&', '^', '|', '&&', '||'},
+    '==': {'&', '^', '|', '&&', '||'},
+    '!=': {'&', '^', '|', '&&', '||'},
+    '&': {'^', '|', '&&', '||'},
+    '^': {'|', '&&', '||'},
+    '|': {'&&', '||'},
     '&&': {'||'},
     '||': set()
 }
@@ -517,6 +522,28 @@ def _parse_unary_expression(expr_text):
             raise BareScriptParserError('Unmatched parenthesis', expr_text)
         return [{'group': expr}, next_text[len(match_group_close.group(0)):]]
 
+    # Number?
+    match_number = _R_EXPR_NUMBER.match(expr_text)
+    if match_number:
+        number_str = match_number.group(1)
+        number = float(int(number_str, base=16)) if number_str.startswith('0x') else float(number_str)
+        expr = {'number': number}
+        return [expr, expr_text[len(match_number.group(0)):]]
+
+    # String?
+    match_string = _R_EXPR_STRING.match(expr_text)
+    if match_string:
+        string = _R_EXPR_STRING_ESCAPE.sub('\\1', match_string.group(1))
+        expr = {'string': string}
+        return [expr, expr_text[len(match_string.group(0)):]]
+
+    # String (double quotes)?
+    match_string_double = _R_EXPR_STRING_DOUBLE.match(expr_text)
+    if match_string_double:
+        string = _R_EXPR_STRING_DOUBLE_ESCAPE.sub('\\1', match_string_double.group(1))
+        expr = {'string': string}
+        return [expr, expr_text[len(match_string_double.group(0)):]]
+
     # Unary operator?
     match_unary = _R_EXPR_UNARY_OP.match(expr_text)
     if match_unary:
@@ -552,27 +579,6 @@ def _parse_unary_expression(expr_text):
         fn_expr = {'function': {'name': match_function_open.group(1), 'args': args}}
         return [fn_expr, arg_text]
 
-    # Number?
-    match_number = _R_EXPR_NUMBER.match(expr_text)
-    if match_number:
-        number = float(match_number.group(1))
-        expr = {'number': number}
-        return [expr, expr_text[len(match_number.group(0)):]]
-
-    # String?
-    match_string = _R_EXPR_STRING.match(expr_text)
-    if match_string:
-        string = _R_EXPR_STRING_ESCAPE.sub('\\1', match_string.group(1))
-        expr = {'string': string}
-        return [expr, expr_text[len(match_string.group(0)):]]
-
-    # String (double quotes)?
-    match_string_double = _R_EXPR_STRING_DOUBLE.match(expr_text)
-    if match_string_double:
-        string = _R_EXPR_STRING_DOUBLE_ESCAPE.sub('\\1', match_string_double.group(1))
-        expr = {'string': string}
-        return [expr, expr_text[len(match_string_double.group(0)):]]
-
     # Variable?
     match_variable = _R_EXPR_VARIABLE.match(expr_text)
     if match_variable:
@@ -590,14 +596,14 @@ def _parse_unary_expression(expr_text):
 
 
 # BareScript expression regex
-_R_EXPR_BINARY_OP = re.compile(r'^\s*(\*\*|\*|\/|%|\+|-|<=|<|>=|>|==|!=|&&|\|\|)')
-_R_EXPR_UNARY_OP = re.compile(r'^\s*(!|-)')
+_R_EXPR_BINARY_OP = re.compile(r'^\s*(\*\*|\*|\/|%|\+|-|<<|>>|<=|<|>=|>|==|!=|&&|\|\||&|\^|\|)')
+_R_EXPR_UNARY_OP = re.compile(r'^\s*(!|-|~)')
 _R_EXPR_FUNCTION_OPEN = re.compile(r'^\s*([A-Za-z_]\w+)\s*\(')
 _R_EXPR_FUNCTION_SEPARATOR = re.compile(r'^\s*,')
 _R_EXPR_FUNCTION_CLOSE = re.compile(r'^\s*\)')
 _R_EXPR_GROUP_OPEN = re.compile(r'^\s*\(')
 _R_EXPR_GROUP_CLOSE = re.compile(r'^\s*\)')
-_R_EXPR_NUMBER = re.compile(r'^\s*([+-]?\d+(?:\.\d*)?(?:e[+-]\d+)?)')
+_R_EXPR_NUMBER = re.compile(r'^\s*(0x[A-Fa-f0-9]+|[+-]?\d+(?:\.\d*)?(?:e[+-]?\d+)?)')
 _R_EXPR_STRING = re.compile(r"^\s*'((?:\\\\|\\'|[^'])*)'")
 _R_EXPR_STRING_ESCAPE = re.compile(r'\\([\\\'])')
 _R_EXPR_STRING_DOUBLE = re.compile(r'^\s*"((?:\\\\|\\"|[^"])*)"')

{bare_script-3.4.0 → bare_script-3.5.0}/src/bare_script/runtime.py

@@ -269,7 +269,8 @@ def evaluate_expression(expr, options=None, locals_=None, builtins=True):
         right_value = evaluate_expression(expr['binary']['right'], options, locals_, builtins)
         if bin_op == '+':
             # number + number
-            if isinstance(left_value, (int, float)) and isinstance(right_value, (int, float)):
+            if (isinstance(left_value, (int, float)) and not isinstance(left_value, bool) and
+                isinstance(right_value, (int, float)) and not isinstance(right_value, bool)):
                 return left_value + right_value
 
             # string + string
@@ -283,16 +284,19 @@ def evaluate_expression(expr, options=None, locals_=None, builtins=True):
                 return value_string(left_value) + right_value
 
             # datetime + number
-            elif isinstance(left_value, datetime.date) and isinstance(right_value, (int, float)):
+            elif (isinstance(left_value, datetime.date) and
+                  isinstance(right_value, (int, float)) and not isinstance(right_value, bool)):
                 left_dt = value_normalize_datetime(left_value)
                 return left_dt + datetime.timedelta(milliseconds=right_value)
-            elif isinstance(left_value, (int, float)) and isinstance(right_value, datetime.date):
+            elif (isinstance(left_value, (int, float)) and not isinstance(left_value, bool) and
+                  isinstance(right_value, datetime.date)):
                 right_dt = value_normalize_datetime(right_value)
                 return right_dt + datetime.timedelta(milliseconds=left_value)
 
         elif bin_op == '-':
             # number - number
-            if isinstance(left_value, (int, float)) and isinstance(right_value, (int, float)):
+            if (isinstance(left_value, (int, float)) and not isinstance(left_value, bool) and
+                isinstance(right_value, (int, float)) and not isinstance(right_value, bool)):
                 return left_value - right_value
 
             # datetime - datetime
@@ -303,12 +307,14 @@ def evaluate_expression(expr, options=None, locals_=None, builtins=True):
 
         elif bin_op == '*':
             # number * number
-            if isinstance(left_value, (int, float)) and isinstance(right_value, (int, float)):
+            if (isinstance(left_value, (int, float)) and not isinstance(left_value, bool) and
+                isinstance(right_value, (int, float)) and not isinstance(right_value, bool)):
                 return left_value * right_value
 
         elif bin_op == '/':
             # number / number
-            if isinstance(left_value, (int, float)) and isinstance(right_value, (int, float)):
+            if (isinstance(left_value, (int, float)) and not isinstance(left_value, bool) and
+                isinstance(right_value, (int, float)) and not isinstance(right_value, bool)):
                 return left_value / right_value
 
         elif bin_op == '==':
@@ -331,14 +337,46 @@ def evaluate_expression(expr, options=None, locals_=None, builtins=True):
 
         elif bin_op == '%':
             # number % number
-            if isinstance(left_value, (int, float)) and isinstance(right_value, (int, float)):
+            if (isinstance(left_value, (int, float)) and not isinstance(left_value, bool) and
+                isinstance(right_value, (int, float)) and not isinstance(right_value, bool)):
                 return left_value % right_value
 
-        else: # bin_op == '**'
+        elif bin_op == '**':
             # number ** number
-            if isinstance(left_value, (int, float)) and isinstance(right_value, (int, float)):
+            if (isinstance(left_value, (int, float)) and not isinstance(left_value, bool) and
+                isinstance(right_value, (int, float)) and not isinstance(right_value, bool)):
                 return left_value ** right_value
 
+        elif bin_op == '&':
+            # int & int
+            if (isinstance(left_value, (int, float)) and not isinstance(left_value, bool) and int(left_value) == left_value and
+                isinstance(right_value, (int, float)) and not isinstance(right_value, bool) and int(right_value) == right_value):
+                return int(left_value) & int(right_value)
+
+        elif bin_op == '|':
+            # int & int
+            if (isinstance(left_value, (int, float)) and not isinstance(left_value, bool) and int(left_value) == left_value and
+                isinstance(right_value, (int, float)) and not isinstance(right_value, bool) and int(right_value) == right_value):
+                return int(left_value) | int(right_value)
+
+        elif bin_op == '^':
+            # int & int
+            if (isinstance(left_value, (int, float)) and not isinstance(left_value, bool) and int(left_value) == left_value and
+                isinstance(right_value, (int, float)) and not isinstance(right_value, bool) and int(right_value) == right_value):
+                return int(left_value) ^ int(right_value)
+
+        elif bin_op == '<<':
+            # int & int
+            if (isinstance(left_value, (int, float)) and not isinstance(left_value, bool) and int(left_value) == left_value and
+                isinstance(right_value, (int, float)) and not isinstance(right_value, bool) and int(right_value) == right_value):
+                return int(left_value) << int(right_value)
+
+        else: # bin_op == '>>':
+            # int & int
+            if (isinstance(left_value, (int, float)) and not isinstance(left_value, bool) and int(left_value) == left_value and
+                isinstance(right_value, (int, float)) and not isinstance(right_value, bool) and int(right_value) == right_value):
+                return int(left_value) >> int(right_value)
+
         # Invalid operation values
         return None
 
@@ -348,8 +386,12 @@ def evaluate_expression(expr, options=None, locals_=None, builtins=True):
         value = evaluate_expression(expr['unary']['expr'], options, locals_, builtins)
         if unary_op == '!':
             return not value_boolean(value)
-        elif unary_op == '-' and isinstance(value, (int, float)):
-            return -value
+        elif unary_op == '-':
+            if isinstance(value, (int, float)) and not isinstance(value, bool):
+                return -value
+        else: # unary_op == '~':
+            if isinstance(value, (int, float)) and not isinstance(value, bool) and int(value) == value:
+                return ~int(value)
 
         # Invalid operation value
         return None

{bare_script-3.4.0 → bare_script-3.5.0}/src/bare_script/value.py

@@ -297,7 +297,7 @@ def value_args_validate(fn_args, args, error_return_value=None):
             continue
 
         # Invalid value?
-        if ((arg_type == 'number' and not isinstance(arg_value, (int, float))) or
+        if ((arg_type == 'number' and (not isinstance(arg_value, (int, float)) or isinstance(arg_value, bool))) or
             (arg_type == 'string' and not isinstance(arg_value, str)) or
             (arg_type == 'array' and not isinstance(arg_value, list)) or
             (arg_type == 'object' and not isinstance(arg_value, dict)) or

{bare_script-3.4.0 → bare_script-3.5.0/src/bare_script.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bare-script
-Version: 3.4.0
+Version: 3.5.0
 Summary: bare-script
 Home-page: https://github.com/craigahobbs/bare-script
 Author: Craig A. Hobbs