bare-script 4.1.1__tar.gz → 4.1.3__tar.gz

{bare_script-4.1.1/src/bare_script.egg-info → bare_script-4.1.3}/PKG-INFO

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

{bare_script-4.1.1 → bare_script-4.1.3}/setup.cfg

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

{bare_script-4.1.1 → bare_script-4.1.3}/src/bare_script/__init__.py

@@ -5,7 +5,7 @@
 bare-script package
 """
 
-import os as _os
+import os
 
 from .model import \
     lint_script, \
@@ -29,7 +29,7 @@ from .parser import \
 from .runtime import \
     BareScriptRuntimeError
 
-if not _os.environ.get('BARESCRIPT_RUNTIME_PY'): # pragma: no cover
+if not os.environ.get('BARESCRIPT_RUNTIME_PY'): # pragma: no cover
     try:
         from .runtime_c import evaluate_expression, execute_script
     except ImportError:

{bare_script-4.1.1 → bare_script-4.1.3}/src/bare_script/bare.py

@@ -7,7 +7,7 @@ bare-script command-line interface (CLI)
 
 import argparse
 from functools import partial
-import os as _os
+import os
 import sys
 import time
 
@@ -16,7 +16,7 @@ from .options import FETCH_SYSTEM_PREFIX, fetch_read_write, fetch_system, log_st
 from .parser import parse_expression, parse_script
 from .runtime import SYSTEM_GLOBAL_INCLUDES_NAME
 from .value import value_boolean
-if not _os.environ.get('BARESCRIPT_RUNTIME_PY'): # pragma: no cover
+if not os.environ.get('BARESCRIPT_RUNTIME_PY'): # pragma: no cover
     try:
         from .runtime_c import evaluate_expression, execute_script
     except ImportError:

{bare_script-4.1.1 → bare_script-4.1.3}/src/bare_script/library.py

@@ -11,7 +11,7 @@ import functools
 import importlib
 import json
 import math
-import os as _os
+import os
 import random
 import re
 import urllib
@@ -28,7 +28,7 @@ from .value import R_NUMBER_CLEANUP, ValueArgsError, value_args_model, value_arg
 # Helper to dynamically import evaluate_expression to avoid the circular dependency
 def _import_evaluate_expression():
     if not _EVALUATE_EXPRESSION:
-        if not _os.environ.get('BARESCRIPT_RUNTIME_PY'): # pragma: no cover
+        if not os.environ.get('BARESCRIPT_RUNTIME_PY'): # pragma: no cover
             try:
                 _EVALUATE_EXPRESSION.append(importlib.import_module('bare_script.runtime_c').evaluate_expression)
             except (ImportError, AttributeError):

{bare_script-4.1.1 → bare_script-4.1.3}/src/bare_script/parser.py

@@ -44,8 +44,9 @@ def parse_script(script_text, start_line_number=1, script_name=None):
     for ix_line_part, line_part in enumerate(lines):
         statements = function_def['function']['statements'] if function_def is not None else script['statements']
 
-        # Comment?
-        if _R_SCRIPT_COMMENT.match(line_part) is not None:
+        # Comment or empty line?
+        line_part_trimmed = line_part.lstrip()
+        if not line_part_trimmed or line_part_trimmed[0] == '#':
             continue
 
         # Set the line index
@@ -74,29 +75,12 @@ def parse_script(script_text, start_line_number=1, script_name=None):
         if ix_line != ix_line_part:
             statement_base['lineCount'] = (ix_line_part - ix_line) + 1
 
-        # Assignment?
-        match_assignment = _R_SCRIPT_ASSIGNMENT.match(line)
-        if match_assignment:
-            # Parse the expression
-            try:
-                assignment_expr = parse_expression(match_assignment.group('expr'), line_number, script_name, True)
-            except BareScriptParserError as error:
-                column_number = len(line) - len(match_assignment.group('expr')) + error.column_number
-                raise BareScriptParserError(error.error, line, column_number, start_line_number + ix_line, script_name)
-
-            # Add the expression statement
-            expr_statement = {
-                'expr': {
-                    'name': match_assignment.group('name'),
-                    'expr': assignment_expr,
-                    **statement_base
-                }
-            }
-            statements.append(expr_statement)
-            continue
+        # Determine the line's leading keyword for dispatch
+        match_keyword = _R_SCRIPT_KEYWORD.match(line)
+        keyword = match_keyword.group(1) if match_keyword else None
 
         # Function definition begin?
-        match_function_begin = _R_SCRIPT_FUNCTION_BEGIN.match(line)
+        match_function_begin = _R_SCRIPT_FUNCTION_BEGIN.match(line) if keyword in ('function', 'async') else None
         if match_function_begin:
             # Nested function definitions are not allowed
             if function_def is not None:
@@ -121,7 +105,7 @@ def parse_script(script_text, start_line_number=1, script_name=None):
             continue
 
         # Function definition end?
-        match_function_end = _R_SCRIPT_FUNCTION_END.match(line)
+        match_function_end = _R_SCRIPT_FUNCTION_END.match(line) if keyword == 'endfunction' else None
         if match_function_end:
             if function_def is None:
                 raise BareScriptParserError('No matching function definition', line, 1, start_line_number + ix_line, script_name)
@@ -138,7 +122,7 @@ def parse_script(script_text, start_line_number=1, script_name=None):
             continue
 
         # If-then begin?
-        match_if_begin = _R_SCRIPT_IF_BEGIN.match(line)
+        match_if_begin = _R_SCRIPT_IF_BEGIN.match(line) if keyword == 'if' else None
         if match_if_begin:
             # Parse the if-then expression
             try:
@@ -167,7 +151,7 @@ def parse_script(script_text, start_line_number=1, script_name=None):
             continue
 
         # Else-if-then?
-        match_if_else_if = _R_SCRIPT_IF_ELSE_IF.match(line)
+        match_if_else_if = _R_SCRIPT_IF_ELSE_IF.match(line) if keyword == 'elif' else None
         if match_if_else_if:
             # Get the else-if-then definition
             label_def_depth = function_label_def_depth if function_def is not None else 0
@@ -177,7 +161,9 @@ def parse_script(script_text, start_line_number=1, script_name=None):
 
             # Cannot come after the else-then statement
             if ifthen['hasElse']:
-                raise BareScriptParserError('Elif statement following else statement', line, 1, start_line_number + ix_line, script_name)
+                raise BareScriptParserError(
+                    'Elif statement following else statement', line, 1, start_line_number + ix_line, script_name
+                )
 
             # Parse teh else-if-then expression
             try:
@@ -204,7 +190,7 @@ def parse_script(script_text, start_line_number=1, script_name=None):
             continue
 
         # Else-then?
-        match_if_else = _R_SCRIPT_IF_ELSE.match(line)
+        match_if_else = _R_SCRIPT_IF_ELSE.match(line) if keyword == 'else' else None
         if match_if_else:
             # Get the if-then definition
             label_def_depth = function_label_def_depth if function_def is not None else 0
@@ -225,7 +211,7 @@ def parse_script(script_text, start_line_number=1, script_name=None):
             continue
 
         # If-then end?
-        match_if_end = _R_SCRIPT_IF_END.match(line)
+        match_if_end = _R_SCRIPT_IF_END.match(line) if keyword == 'endif' else None
         if match_if_end:
             # Pop the if-then definition
             label_def_depth = function_label_def_depth if function_def is not None else 0
@@ -242,7 +228,7 @@ def parse_script(script_text, start_line_number=1, script_name=None):
             continue
 
         # While-do begin?
-        match_while_begin = _R_SCRIPT_WHILE_BEGIN.match(line)
+        match_while_begin = _R_SCRIPT_WHILE_BEGIN.match(line) if keyword == 'while' else None
         if match_while_begin:
             # Parse the while-do expression
             try:
@@ -271,7 +257,7 @@ def parse_script(script_text, start_line_number=1, script_name=None):
             continue
 
         # While-do end?
-        match_while_end = _R_SCRIPT_WHILE_END.match(line)
+        match_while_end = _R_SCRIPT_WHILE_END.match(line) if keyword == 'endwhile' else None
         if match_while_end:
             # Pop the while-do definition
             label_def_depth = function_label_def_depth if function_def is not None else 0
@@ -290,7 +276,7 @@ def parse_script(script_text, start_line_number=1, script_name=None):
             continue
 
         # For-each begin?
-        match_for_begin = _R_SCRIPT_FOR_BEGIN.match(line)
+        match_for_begin = _R_SCRIPT_FOR_BEGIN.match(line) if keyword == 'for' else None
         if match_for_begin:
             # Add the for-each label
             foreach = {
@@ -335,14 +321,19 @@ def parse_script(script_text, start_line_number=1, script_name=None):
                 {'label': {'name': foreach['loop'], **statement_base}},
                 {'expr': {
                     'name': foreach['value'],
-                    'expr': {'function': {'name': 'arrayGet', 'args': [{'variable': foreach['values']}, {'variable': foreach['index']}]}},
+                    'expr': {
+                        'function': {
+                            'name': 'arrayGet',
+                            'args': [{'variable': foreach['values']}, {'variable': foreach['index']}]
+                        }
+                    },
                     **statement_base
                 }}
             ])
             continue
 
         # For-each end?
-        match_for_end = _R_SCRIPT_FOR_END.match(line)
+        match_for_end = _R_SCRIPT_FOR_END.match(line) if keyword == 'endfor' else None
         if match_for_end:
             # Pop the foreach definition
             label_def_depth = function_label_def_depth if function_def is not None else 0
@@ -364,7 +355,9 @@ def parse_script(script_text, start_line_number=1, script_name=None):
                 }},
                 {'jump': {
                     'label': foreach['loop'],
-                    'expr': {'binary': {'op': '<', 'left': {'variable': foreach['index']}, 'right': {'variable': foreach['length']}}},
+                    'expr': {
+                        'binary': {'op': '<', 'left': {'variable': foreach['index']}, 'right': {'variable': foreach['length']}}
+                    },
                     **statement_base
                 }},
                 {'label': {'name': foreach['done'], **statement_base}}
@@ -372,7 +365,7 @@ def parse_script(script_text, start_line_number=1, script_name=None):
             continue
 
         # Break statement?
-        match_break = _R_SCRIPT_BREAK.match(line)
+        match_break = _R_SCRIPT_BREAK.match(line) if keyword == 'break' else None
         if match_break:
             # Get the loop definition
             label_def_depth = function_label_def_depth if function_def is not None else 0
@@ -388,13 +381,15 @@ def parse_script(script_text, start_line_number=1, script_name=None):
             continue
 
         # Continue statement?
-        match_continue = _R_SCRIPT_CONTINUE.match(line)
+        match_continue = _R_SCRIPT_CONTINUE.match(line) if keyword == 'continue' else None
         if match_continue:
             # Get the loop definition
             label_def_depth = function_label_def_depth if function_def is not None else 0
             ix_label_def = next((i for i, d in reversed(list(enumerate(label_defs))) if 'if' not in d), -1)
             if ix_label_def < label_def_depth:
-                raise BareScriptParserError('Continue statement outside of loop', line, 1, start_line_number + ix_line, script_name)
+                raise BareScriptParserError(
+                    'Continue statement outside of loop', line, 1, start_line_number + ix_line, script_name
+                )
             label_def = label_defs[ix_label_def]
             label_key = next(iter(label_def))
             loop_def = label_def[label_key]
@@ -404,14 +399,8 @@ def parse_script(script_text, start_line_number=1, script_name=None):
             statements.append({'jump': {'label': loop_def['continue'], **statement_base}})
             continue
 
-        # Label definition?
-        match_label = _R_SCRIPT_LABEL.match(line)
-        if match_label:
-            statements.append({'label': {'name': match_label.group('name'), **statement_base}})
-            continue
-
         # Jump definition?
-        match_jump = _R_SCRIPT_JUMP.match(line)
+        match_jump = _R_SCRIPT_JUMP.match(line) if keyword in ('jump', 'jumpif') else None
         if match_jump:
             jump_statement = {'jump': {'label': match_jump.group('name'), **statement_base}}
             if match_jump.group('expr'):
@@ -424,12 +413,14 @@ def parse_script(script_text, start_line_number=1, script_name=None):
             continue
 
         # Return definition?
-        match_return = _R_SCRIPT_RETURN.match(line)
+        match_return = _R_SCRIPT_RETURN.match(line) if keyword == 'return' else None
         if match_return:
             return_statement = {'return': {**statement_base}}
             if match_return.group('expr'):
                 try:
-                    return_statement['return']['expr'] = parse_expression(match_return.group('expr'), line_number, script_name, True)
+                    return_statement['return']['expr'] = parse_expression(
+                        match_return.group('expr'), line_number, script_name, True
+                    )
                 except BareScriptParserError as error:
                     column_number = len(match_return.group('return')) - len(match_return.group('expr')) + error.column_number
                     raise BareScriptParserError(error.error, line, column_number, start_line_number + ix_line, script_name)
@@ -437,7 +428,7 @@ def parse_script(script_text, start_line_number=1, script_name=None):
             continue
 
         # Include definition?
-        match_include = _R_SCRIPT_INCLUDE.match(line) or _R_SCRIPT_INCLUDE_SYSTEM.match(line)
+        match_include = _R_SCRIPT_INCLUDE.match(line) or _R_SCRIPT_INCLUDE_SYSTEM.match(line) if keyword == 'include' else None
         if match_include:
             delim = match_include.group('delim')
             url = match_include.group('url') if delim == '<' else \
@@ -451,6 +442,35 @@ def parse_script(script_text, start_line_number=1, script_name=None):
             include_statement['include']['includes'].append({'url': url, 'system': True} if delim == '<' else {'url': url})
             continue
 
+        # Catch-all (line starts with an identifier but isn't a recognized control statement)
+        if keyword is not None:
+            # Assignment?
+            match_assignment = _R_SCRIPT_ASSIGNMENT.match(line)
+            if match_assignment:
+                # Parse the expression
+                try:
+                    assignment_expr = parse_expression(match_assignment.group('expr'), line_number, script_name, True)
+                except BareScriptParserError as error:
+                    column_number = len(line) - len(match_assignment.group('expr')) + error.column_number
+                    raise BareScriptParserError(error.error, line, column_number, start_line_number + ix_line, script_name)
+
+                # Add the expression statement
+                expr_statement = {
+                    'expr': {
+                        'name': match_assignment.group('name'),
+                        'expr': assignment_expr,
+                        **statement_base
+                    }
+                }
+                statements.append(expr_statement)
+                continue
+
+            # Label definition?
+            match_label = _R_SCRIPT_LABEL.match(line)
+            if match_label:
+                statements.append({'label': {'name': match_label.group('name'), **statement_base}})
+                continue
+
         # Expression
         try:
             expr_statement = {'expr': {'expr': parse_expression(line, line_number, script_name, True), **statement_base}}
@@ -471,7 +491,7 @@ def parse_script(script_text, start_line_number=1, script_name=None):
 # BareScript regex
 _R_SCRIPT_LINE_SPLIT = re.compile(r'\r?\n')
 _R_SCRIPT_CONTINUATION = re.compile(r'\\\s*$')
-_R_SCRIPT_COMMENT = re.compile(r'^\s*(?:#.*)?$')
+_R_SCRIPT_KEYWORD = re.compile(r'^\s*([A-Za-z_]\w*)')
 _R_SCRIPT_ASSIGNMENT = re.compile(r'^\s*(?P<name>[A-Za-z_]\w*)\s*=\s*(?P<expr>.+)$')
 _R_PART_COMMENT = r'\s*(#.*)?$'
 _R_SCRIPT_FUNCTION_BEGIN = re.compile(
@@ -516,7 +536,7 @@ def parse_expression(expr_text, line_number=None, script_name=None, array_litera
     :raises BareScriptParserError: A parsing error occurred
     """
     try:
-        expr, next_text = _parse_binary_expression(expr_text, None, array_literals)
+        expr, next_text = _parse_binary_expression(expr_text, array_literals)
         if next_text.strip() != '':
             raise BareScriptParserError('Syntax error', next_text, 1, line_number, script_name)
         return expr
@@ -526,42 +546,47 @@ def parse_expression(expr_text, line_number=None, script_name=None, array_litera
 
 
 # Helper function to parse a binary operator expression chain
-def _parse_binary_expression(expr_text, bin_left_expr, array_literals):
-    # Parse the binary operator's left unary expression if none was passed
-    if bin_left_expr is not None:
-        bin_text = expr_text
-        left_expr = bin_left_expr
-    else:
-        left_expr, bin_text = _parse_unary_expression(expr_text, array_literals)
-
-    # Match a binary operator - if not found, return the left expression
-    match_binary_op = _R_EXPR_BINARY_OP.match(bin_text)
-    if match_binary_op is None:
-        # End-of-line comment?
-        if _R_EXPR_COMMENT.match(bin_text):
-            bin_text = ''
-
-        return [left_expr, bin_text]
-    bin_op = match_binary_op.group(1)
-    right_text = bin_text[len(match_binary_op.group(0)):]
-
-    # Parse the right sub-expression
-    right_expr, next_text = _parse_unary_expression(right_text, array_literals)
-
-    # Create the binary expression - re-order for binary operators as necessary
-    bin_expr = None
-    if 'binary' in left_expr and bin_op in BINARY_REORDER and left_expr['binary']['op'] in BINARY_REORDER[bin_op]:
-        # Left expression has lower precedence - find where to put this expression within the left expression
-        bin_expr = left_expr
-        reorder_expr = left_expr
-        while 'binary' in reorder_expr['binary']['right'] and reorder_expr['binary']['right']['binary']['op'] in BINARY_REORDER[bin_op]:
-            reorder_expr = reorder_expr['binary']['right']
-        reorder_expr['binary']['right'] = {'binary': {'op': bin_op, 'left': reorder_expr['binary']['right'], 'right': right_expr}}
-    else:
-        bin_expr = {'binary': {'op': bin_op, 'left': left_expr, 'right': right_expr}}
+def _parse_binary_expression(expr_text, array_literals):
+    # Parse the binary operator's left unary expression
+    left_expr, bin_text = _parse_unary_expression(expr_text, array_literals)
+
+    # Consume binary operators while present, building up the binary expression tree
+    while True:
+        # Skip leading whitespace to find the first dispatch char
+        pos = 0
+        n = len(bin_text)
+        while pos < n and bin_text[pos] in ' \t\r\n\v\f':
+            pos += 1
+
+        # End of binary expression (empty, whitespace-only, or end-of-line comment)?
+        if pos >= n or bin_text[pos] == '#':
+            return [left_expr, '']
+
+        # Binary operator? First char must be one of "!%&*+-/<=>^|"
+        is_binary_op_start = bin_text[pos] in '!%&*+-/<=>^|'
+        match_binary_op = _R_EXPR_BINARY_OP.match(bin_text) if is_binary_op_start else None
+        if match_binary_op is None:
+            return [left_expr, bin_text]
+        bin_op = match_binary_op.group(1)
+        right_text = bin_text[len(match_binary_op.group(0)):]
+
+        # Parse the right sub-expression
+        right_expr, next_text = _parse_unary_expression(right_text, array_literals)
+
+        # Create the binary expression - re-order for binary operators as necessary
+        if 'binary' in left_expr and bin_op in BINARY_REORDER and left_expr['binary']['op'] in BINARY_REORDER[bin_op]:
+            # Left expression has lower precedence - find where to put this expression within the left expression
+            reorder_expr = left_expr
+            while ('binary' in reorder_expr['binary']['right']
+                   and reorder_expr['binary']['right']['binary']['op'] in BINARY_REORDER[bin_op]):
+                reorder_expr = reorder_expr['binary']['right']
+            reorder_expr['binary']['right'] = {
+                'binary': {'op': bin_op, 'left': reorder_expr['binary']['right'], 'right': right_expr}
+            }
+        else:
+            left_expr = {'binary': {'op': bin_op, 'left': left_expr, 'right': right_expr}}
 
-    # Parse the next binary expression in the chain
-    return _parse_binary_expression(next_text, bin_expr, array_literals)
+        bin_text = next_text
 
 
 # Binary operator re-order map
@@ -590,48 +615,54 @@ BINARY_REORDER = {
 
 # Helper function to parse a unary expression
 def _parse_unary_expression(expr_text, array_literals):
-    # Group open?
-    match_group_open = _R_EXPR_GROUP_OPEN.match(expr_text)
+    # Skip leading whitespace to find the first dispatch char
+    pos = 0
+    n = len(expr_text)
+    while pos < n and expr_text[pos] in ' \t\r\n\v\f':
+        pos += 1
+    if pos >= n:
+        raise BareScriptParserError('Syntax error', expr_text, 1, None, None)
+    c = expr_text[pos]
+
+    # Group? '('
+    match_group_open = _R_EXPR_GROUP_OPEN.match(expr_text) if c == '(' else None
     if match_group_open:
         group_text = expr_text[len(match_group_open.group(0)):]
-        expr, next_text = _parse_binary_expression(group_text, None, array_literals)
+        expr, next_text = _parse_binary_expression(group_text, array_literals)
         match_group_close = _R_EXPR_GROUP_CLOSE.match(next_text)
         if match_group_close is None:
             raise BareScriptParserError('Unmatched parenthesis', expr_text, 1, None, None)
         return [{'group': expr}, next_text[len(match_group_close.group(0)):]]
 
-    # Number?
-    match_number = _R_EXPR_NUMBER.match(expr_text)
+    # Number? digit, '+', or '-' (the '-' falls through to unary below if no number matches)
+    match_number = _R_EXPR_NUMBER.match(expr_text) if c.isdigit() or c in '+-' else None
     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)):]]
+        return [{'number': number}, expr_text[len(match_number.group(0)):]]
 
-    # String?
-    match_string = _R_EXPR_STRING.match(expr_text)
+    # String? '\''
+    match_string = _R_EXPR_STRING.match(expr_text) if c == "'" else None
     if match_string:
         string = _R_EXPR_STRING_ESCAPES.sub(_replace_string_escape, match_string.group(1))
-        expr = {'string': string}
-        return [expr, expr_text[len(match_string.group(0)):]]
+        return [{'string': string}, expr_text[len(match_string.group(0)):]]
 
-    # String (double quotes)?
-    match_string_double = _R_EXPR_STRING_DOUBLE.match(expr_text)
+    # String (double quotes)? '"'
+    match_string_double = _R_EXPR_STRING_DOUBLE.match(expr_text) if c == '"' else None
     if match_string_double:
         string = _R_EXPR_STRING_ESCAPES.sub(_replace_string_escape, match_string_double.group(1))
-        expr = {'string': string}
-        return [expr, expr_text[len(match_string_double.group(0)):]]
+        return [{'string': string}, expr_text[len(match_string_double.group(0)):]]
 
-    # Unary operator?
-    match_unary = _R_EXPR_UNARY_OP.match(expr_text)
+    # Unary operator? '!', '-', '~'
+    match_unary = _R_EXPR_UNARY_OP.match(expr_text) if c in '!-~' else None
     if match_unary:
         unary_text = expr_text[len(match_unary.group(0)):]
         expr, next_text = _parse_unary_expression(unary_text, array_literals)
-        unary_expr = {'unary': {'op': match_unary.group(1), 'expr': expr}}
-        return [unary_expr, next_text]
+        return [{'unary': {'op': match_unary.group(1), 'expr': expr}}, next_text]
 
-    # Function?
-    match_function_open = _R_EXPR_FUNCTION_OPEN.match(expr_text)
+    # Function call? identifier followed by '('
+    is_ident = c.isalpha() or c == '_'
+    match_function_open = _R_EXPR_FUNCTION_OPEN.match(expr_text) if is_ident else None
     if match_function_open:
         arg_text = expr_text[len(match_function_open.group(0)):]
         args = []
@@ -650,15 +681,19 @@ def _parse_unary_expression(expr_text, array_literals):
                 arg_text = arg_text[len(match_function_separator.group(0)):]
 
             # Get the argument
-            arg_expr, next_arg_text = _parse_binary_expression(arg_text, None, array_literals)
+            arg_expr, next_arg_text = _parse_binary_expression(arg_text, array_literals)
             args.append(arg_expr)
             arg_text = next_arg_text
 
-        fn_expr = {'function': {'name': match_function_open.group(1), 'args': args}}
-        return [fn_expr, arg_text]
+        return [{'function': {'name': match_function_open.group(1), 'args': args}}, arg_text]
 
-    # Object creation?
-    match_object_open = _R_EXPR_OBJECT_OPEN.match(expr_text)
+    # Variable
+    match_variable = _R_EXPR_VARIABLE.match(expr_text) if is_ident else None
+    if match_variable:
+        return [{'variable': match_variable.group(1)}, expr_text[len(match_variable.group(0)):]]
+
+    # Object creation? '{'
+    match_object_open = _R_EXPR_OBJECT_OPEN.match(expr_text) if c == '{' else None
     if match_object_open:
         arg_text = expr_text[len(match_object_open.group(0)):]
         args = []
@@ -677,7 +712,7 @@ def _parse_unary_expression(expr_text, array_literals):
                 arg_text = arg_text[len(match_object_separator.group(0)):]
 
             # Get the key
-            arg_key, arg_text = _parse_binary_expression(arg_text, None, array_literals)
+            arg_key, arg_text = _parse_binary_expression(arg_text, array_literals)
             args.append(arg_key)
 
             # Key/value separator
@@ -687,58 +722,46 @@ def _parse_unary_expression(expr_text, array_literals):
             arg_text = arg_text[len(match_object_separator_key.group(0)):]
 
             # Get the value
-            arg_value, arg_text = _parse_binary_expression(arg_text, None, array_literals)
+            arg_value, arg_text = _parse_binary_expression(arg_text, array_literals)
             args.append(arg_value)
 
-        fn_expr = {'function': {'name': 'objectNew', 'args': args}}
-        return [fn_expr, arg_text]
-
-    # Array creation?
-    if array_literals:
-        match_array_open = _R_EXPR_ARRAY_OPEN.match(expr_text)
-        if match_array_open:
-            arg_text = expr_text[len(match_array_open.group(0)):]
-            args = []
-            while True:
-                # Array close?
-                match_array_close = _R_EXPR_ARRAY_CLOSE.match(arg_text)
-                if match_array_close:
-                    arg_text = arg_text[len(match_array_close.group(0)):]
-                    break
-
-                # Array key separator
-                if args:
-                    match_array_separator = _R_EXPR_ARRAY_SEPARATOR.match(arg_text)
-                    if match_array_separator is None:
-                        raise BareScriptParserError('Syntax error', arg_text, 1, None, None)
-                    arg_text = arg_text[len(match_array_separator.group(0)):]
-
-                # Get the value
-                arg_value, arg_text = _parse_binary_expression(arg_text, None, array_literals)
-                args.append(arg_value)
-
-            fn_expr = {'function': {'name': 'arrayNew', 'args': args}}
-            return [fn_expr, arg_text]
-
-    # Variable?
-    match_variable = _R_EXPR_VARIABLE.match(expr_text)
-    if match_variable:
-        expr = {'variable': match_variable.group(1)}
-        return [expr, expr_text[len(match_variable.group(0)):]]
+        return [{'function': {'name': 'objectNew', 'args': args}}, arg_text]
+
+    # Array creation? '['
+    match_array_open = _R_EXPR_ARRAY_OPEN.match(expr_text) if c == '[' and array_literals else None
+    if match_array_open:
+        arg_text = expr_text[len(match_array_open.group(0)):]
+        args = []
+        while True:
+            # Array close?
+            match_array_close = _R_EXPR_ARRAY_CLOSE.match(arg_text)
+            if match_array_close:
+                arg_text = arg_text[len(match_array_close.group(0)):]
+                break
+
+            # Array key separator
+            if args:
+                match_array_separator = _R_EXPR_ARRAY_SEPARATOR.match(arg_text)
+                if match_array_separator is None:
+                    raise BareScriptParserError('Syntax error', arg_text, 1, None, None)
+                arg_text = arg_text[len(match_array_separator.group(0)):]
+
+            # Get the value
+            arg_value, arg_text = _parse_binary_expression(arg_text, array_literals)
+            args.append(arg_value)
+
+        return [{'function': {'name': 'arrayNew', 'args': args}}, arg_text]
 
-    # Variable (brackets)?
-    if not array_literals:
-        match_variable_ex = _R_EXPR_VARIABLE_EX.match(expr_text)
-        if match_variable_ex:
-            variable_name = _R_EXPR_VARIABLE_EX_ESCAPE.sub('\\1', match_variable_ex.group(1))
-            expr = {'variable': variable_name}
-            return [expr, expr_text[len(match_variable_ex.group(0)):]]
+    # Variable (brackets)? '['
+    match_variable_ex = _R_EXPR_VARIABLE_EX.match(expr_text) if c == '[' and not array_literals else None
+    if match_variable_ex:
+        variable_name = _R_EXPR_VARIABLE_EX_ESCAPE.sub('\\1', match_variable_ex.group(1))
+        return [{'variable': variable_name}, expr_text[len(match_variable_ex.group(0)):]]
 
     raise BareScriptParserError('Syntax error', expr_text, 1, None, None)
 
 
 # BareScript expression regex
-_R_EXPR_COMMENT = 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*\(')

{bare_script-4.1.1 → bare_script-4.1.3}/src/bare_script/runtime.py

@@ -224,13 +224,17 @@ def _script_function(script, function, args, options):
     if func_args is not None:
         args_length = len(args)
         func_args_length = len(func_args)
-        ix_arg_last = function.get('lastArgArray', None) and (func_args_length - 1)
-        for ix_arg in range(func_args_length):
-            arg_name = func_args[ix_arg]
-            if ix_arg < args_length:
-                func_locals[arg_name] = args[ix_arg] if ix_arg != ix_arg_last else args[ix_arg:]
-            else:
-                func_locals[arg_name] = [] if ix_arg == ix_arg_last else None
+        if function.get('lastArgArray'):
+            ix_arg_last = func_args_length - 1
+            for ix_arg in range(func_args_length):
+                arg_name = func_args[ix_arg]
+                if ix_arg < args_length:
+                    func_locals[arg_name] = args[ix_arg] if ix_arg != ix_arg_last else args[ix_arg:]
+                else:
+                    func_locals[arg_name] = [] if ix_arg == ix_arg_last else None
+        else:
+            for ix_arg in range(func_args_length):
+                func_locals[func_args[ix_arg]] = args[ix_arg] if ix_arg < args_length else None
     return _execute_script_helper(script, function['statements'], options, func_locals)
 
 
@@ -399,35 +403,35 @@ def evaluate_expression(expr, options=None, locals_=None, builtins=True, script=
                 (right_type is int or right_type is float)):
                 return left_value / right_value
 
-        elif bin_op == '==':
-            if (left_type is int or left_type is float) and (right_type is int or right_type is float):
-                return left_value == right_value
-            return value_compare(left_value, right_value) == 0
-
-        elif bin_op == '!=':
+        elif bin_op == '<':
             if (left_type is int or left_type is float) and (right_type is int or right_type is float):
-                return left_value != right_value
-            return value_compare(left_value, right_value) != 0
+                return left_value < right_value
+            return value_compare(left_value, right_value) < 0
 
         elif bin_op == '<=':
             if (left_type is int or left_type is float) and (right_type is int or right_type is float):
                 return left_value <= right_value
             return value_compare(left_value, right_value) <= 0
 
-        elif bin_op == '<':
+        elif bin_op == '>':
             if (left_type is int or left_type is float) and (right_type is int or right_type is float):
-                return left_value < right_value
-            return value_compare(left_value, right_value) < 0
+                return left_value > right_value
+            return value_compare(left_value, right_value) > 0
 
         elif bin_op == '>=':
             if (left_type is int or left_type is float) and (right_type is int or right_type is float):
                 return left_value >= right_value
             return value_compare(left_value, right_value) >= 0
 
-        elif bin_op == '>':
+        elif bin_op == '==':
             if (left_type is int or left_type is float) and (right_type is int or right_type is float):
-                return left_value > right_value
-            return value_compare(left_value, right_value) > 0
+                return left_value == right_value
+            return value_compare(left_value, right_value) == 0
+
+        elif bin_op == '!=':
+            if (left_type is int or left_type is float) and (right_type is int or right_type is float):
+                return left_value != right_value
+            return value_compare(left_value, right_value) != 0
 
         elif bin_op == '%':
             # number % number
@@ -443,32 +447,32 @@ def evaluate_expression(expr, options=None, locals_=None, builtins=True, script=
 
         elif bin_op == '&':
             # int & int
-            if ((left_type is int or left_type is float) and int(left_value) == left_value and
-                (right_type is int or right_type is float) and int(right_value) == right_value):
+            if ((left_type is int or (left_type is float and left_value.is_integer())) and
+                (right_type is int or (right_type is float and right_value.is_integer()))):
                 return int(left_value) & int(right_value)
 
         elif bin_op == '|':
             # int & int
-            if ((left_type is int or left_type is float) and int(left_value) == left_value and
-                (right_type is int or right_type is float) and int(right_value) == right_value):
+            if ((left_type is int or (left_type is float and left_value.is_integer())) and
+                (right_type is int or (right_type is float and right_value.is_integer()))):
                 return int(left_value) | int(right_value)
 
         elif bin_op == '^':
             # int & int
-            if ((left_type is int or left_type is float) and int(left_value) == left_value and
-                (right_type is int or right_type is float) and int(right_value) == right_value):
+            if ((left_type is int or (left_type is float and left_value.is_integer())) and
+                (right_type is int or (right_type is float and right_value.is_integer()))):
                 return int(left_value) ^ int(right_value)
 
         elif bin_op == '<<':
             # int & int
-            if ((left_type is int or left_type is float) and int(left_value) == left_value and
-                (right_type is int or right_type is float) and int(right_value) == right_value):
+            if ((left_type is int or (left_type is float and left_value.is_integer())) and
+                (right_type is int or (right_type is float and right_value.is_integer()))):
                 return int(left_value) << int(right_value)
 
         else: # bin_op == '>>':
             # int & int
-            if ((left_type is int or left_type is float) and int(left_value) == left_value and
-                (right_type is int or right_type is float) and int(right_value) == right_value):
+            if ((left_type is int or (left_type is float and left_value.is_integer())) and
+                (right_type is int or (right_type is float and right_value.is_integer()))):
                 return int(left_value) >> int(right_value)
 
         # Invalid operation values
@@ -486,7 +490,7 @@ def evaluate_expression(expr, options=None, locals_=None, builtins=True, script=
             if val_type is int or val_type is float:
                 return -value
         else: # unary_op == '~':
-            if (val_type is int or val_type is float) and int(value) == value:
+            if val_type is int or (val_type is float and value.is_integer()):
                 return ~int(value)
 
         # Invalid operation value

{bare_script-4.1.1 → bare_script-4.1.3}/src/bare_script/runtime_c.c

@@ -400,42 +400,58 @@ script_function_call(PyObject *script, PyObject *function, PyObject *args, PyObj
 
         PyObject *last_arg_array = dict_getitem_borrow(function, K_lastArgArray);
         if (PyErr_Occurred()) { Py_DECREF(func_locals); return NULL; }
-        Py_ssize_t ix_arg_last = -1;
-        if (last_arg_array != NULL && PyObject_IsTrue(last_arg_array) == 1) {
-            ix_arg_last = func_args_length - 1;
-        }
-
-        for (Py_ssize_t ix = 0; ix < func_args_length; ix++) {
-            PyObject *arg_name = PyList_GET_ITEM(func_args, ix);
-            PyObject *val = NULL;
-            int needs_decref = 0;
-            if (ix < args_length) {
-                if (ix == ix_arg_last) {
-                    /* args[ix:] */
-                    if (PyList_Check(args)) {
-                        val = PyList_GetSlice(args, ix, args_length);
+        int has_last_arg_array = (last_arg_array != NULL && PyObject_IsTrue(last_arg_array) == 1);
+
+        if (has_last_arg_array) {
+            Py_ssize_t ix_arg_last = func_args_length - 1;
+            for (Py_ssize_t ix = 0; ix < func_args_length; ix++) {
+                PyObject *arg_name = PyList_GET_ITEM(func_args, ix);
+                PyObject *val = NULL;
+                int needs_decref = 0;
+                if (ix < args_length) {
+                    if (ix == ix_arg_last) {
+                        /* args[ix:] */
+                        if (PyList_Check(args)) {
+                            val = PyList_GetSlice(args, ix, args_length);
+                        } else {
+                            val = PySequence_GetSlice(args, ix, args_length);
+                        }
+                        if (!val) { Py_DECREF(func_locals); return NULL; }
+                        needs_decref = 1;
                     } else {
-                        val = PySequence_GetSlice(args, ix, args_length);
+                        val = PySequence_GetItem(args, ix);
+                        if (!val) { Py_DECREF(func_locals); return NULL; }
+                        needs_decref = 1;
                     }
-                    if (!val) { Py_DECREF(func_locals); return NULL; }
-                    needs_decref = 1;
                 } else {
-                    val = PySequence_GetItem(args, ix);
-                    if (!val) { Py_DECREF(func_locals); return NULL; }
-                    needs_decref = 1;
+                    if (ix == ix_arg_last) {
+                        val = PyList_New(0);
+                        if (!val) { Py_DECREF(func_locals); return NULL; }
+                        needs_decref = 1;
+                    } else {
+                        val = Py_None;
+                    }
                 }
-            } else {
-                if (ix == ix_arg_last) {
-                    val = PyList_New(0);
+                int rc = PyDict_SetItem(func_locals, arg_name, val);
+                if (needs_decref) Py_DECREF(val);
+                if (rc < 0) { Py_DECREF(func_locals); return NULL; }
+            }
+        } else {
+            for (Py_ssize_t ix = 0; ix < func_args_length; ix++) {
+                PyObject *arg_name = PyList_GET_ITEM(func_args, ix);
+                PyObject *val;
+                int needs_decref = 0;
+                if (ix < args_length) {
+                    val = PySequence_GetItem(args, ix);
                     if (!val) { Py_DECREF(func_locals); return NULL; }
                     needs_decref = 1;
                 } else {
                     val = Py_None;
                 }
+                int rc = PyDict_SetItem(func_locals, arg_name, val);
+                if (needs_decref) Py_DECREF(val);
+                if (rc < 0) { Py_DECREF(func_locals); return NULL; }
             }
-            int rc = PyDict_SetItem(func_locals, arg_name, val);
-            if (needs_decref) Py_DECREF(val);
-            if (rc < 0) { Py_DECREF(func_locals); return NULL; }
         }
     }
 
@@ -588,12 +604,12 @@ op_to_id(PyObject *op)
     if (op == K_op_minus) return OP_MINUS;
     if (op == K_op_star) return OP_STAR;
     if (op == K_op_slash) return OP_SLASH;
-    if (op == K_op_eq) return OP_EQ;
-    if (op == K_op_ne) return OP_NE;
-    if (op == K_op_le) return OP_LE;
     if (op == K_op_lt) return OP_LT;
-    if (op == K_op_ge) return OP_GE;
+    if (op == K_op_le) return OP_LE;
     if (op == K_op_gt) return OP_GT;
+    if (op == K_op_ge) return OP_GE;
+    if (op == K_op_eq) return OP_EQ;
+    if (op == K_op_ne) return OP_NE;
     if (op == K_op_pct) return OP_PCT;
     if (op == K_op_star_star) return OP_STAR_STAR;
     if (op == K_op_amp_amp) return OP_AND_AND;
@@ -611,12 +627,12 @@ op_to_id(PyObject *op)
     if (PyUnicode_Compare(op, K_op_minus) == 0) return OP_MINUS;
     if (PyUnicode_Compare(op, K_op_star) == 0) return OP_STAR;
     if (PyUnicode_Compare(op, K_op_slash) == 0) return OP_SLASH;
-    if (PyUnicode_Compare(op, K_op_eq) == 0) return OP_EQ;
-    if (PyUnicode_Compare(op, K_op_ne) == 0) return OP_NE;
-    if (PyUnicode_Compare(op, K_op_le) == 0) return OP_LE;
     if (PyUnicode_Compare(op, K_op_lt) == 0) return OP_LT;
-    if (PyUnicode_Compare(op, K_op_ge) == 0) return OP_GE;
+    if (PyUnicode_Compare(op, K_op_le) == 0) return OP_LE;
     if (PyUnicode_Compare(op, K_op_gt) == 0) return OP_GT;
+    if (PyUnicode_Compare(op, K_op_ge) == 0) return OP_GE;
+    if (PyUnicode_Compare(op, K_op_eq) == 0) return OP_EQ;
+    if (PyUnicode_Compare(op, K_op_ne) == 0) return OP_NE;
     if (PyUnicode_Compare(op, K_op_pct) == 0) return OP_PCT;
     if (PyUnicode_Compare(op, K_op_star_star) == 0) return OP_STAR_STAR;
     if (PyUnicode_Compare(op, K_op_amp_amp) == 0) return OP_AND_AND;

{bare_script-4.1.1 → bare_script-4.1.3/src/bare_script.egg-info}/PKG-INFO

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