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

{bare_script-4.1.2/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.2
+Version: 4.1.3
 Summary: bare-script
 Home-page: https://github.com/craigahobbs/bare-script
 Author: Craig A. Hobbs

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

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

{bare_script-4.1.2 → 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.2 → 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.2
+Version: 4.1.3
 Summary: bare-script
 Home-page: https://github.com/craigahobbs/bare-script
 Author: Craig A. Hobbs