@pb-shrugged/tree-sitter-powerscript 0.0.1

package/grammar.js

@@ -0,0 +1,1381 @@
+/* eslint-disable object-curly-spacing */
+/**
+ * @file Powerscript grammar for tree-sitter
+ * @author Jose Cagnini
+ * @license MIT
+ */
+
+/// <reference types="tree-sitter-cli/dsl" />
+// @ts-check
+
+const PREC = {
+  OR: 1,
+  AND: 2,
+  EQUALITY: 3,
+  RELATIONAL: 4,
+  ADDITIVE: 5,
+  MULTIPLICATIVE: 6,
+  EXPONENTIATION: 7,
+  UNARY: 8,
+  UPDATE_UNARY: 9,
+  FIELD_ACCESS: 10,
+  METHOD_INVOCATION: 11,
+  IMMEDIATE_CASE: 12,
+  KEYWORD: 20,
+  IDENTIFIER_EXPRESSION: -1,
+};
+
+
+module.exports = grammar({
+  name: 'powerscript',
+
+  word: $ => $.identifier,
+
+  extras: $ => [
+    /\s/,
+    $.line_comment,
+    $.block_comment,
+    $.line_continuation,
+  ],
+
+  conflicts: $ => [
+    [$.inline_if_statement, $.if_then_statement],
+    [$.expression_statement, $.r_value_expression],
+    [$.parenthesized_expression, $.destroy_statement],
+    [$.halt_statement],
+    [$.assignment_statement, $.create_statement, $.r_value_expression],
+    [$.for_loop_statement, $.r_value_expression],
+    [$.return_statement],
+    [$.scriptable_block],
+  ],
+
+  rules: {
+
+    source_file: $ => seq(
+      optional($.export_header),
+      $.class_file,
+    ),
+
+    class_file: $ => repeat1(choice(
+      $.forward_declaration_section,
+      $.structure_definition,
+      $.global_variables_section,
+      $.shared_variables_section,
+      $.instance_variables_section,
+      $.class_type_definition,
+      $.global_var_declaration,
+      $.external_function_prototypes,
+      $.forward_function_prototypes,
+      $.event_definition,
+      $.function_definition,
+      $.on_event_definition,
+      // $.inner_class_type_definition,
+    )),
+
+    forward_declaration_section: $ => seq(
+      alias($.forward_keyword, $.forward_declaration_statement),
+      $.forward_declaration_statement_body,
+      $.forward_declaration_statement_end,
+    ),
+
+    forward_declaration_statement_body: $ => seq(
+      repeat1($.class_type_definition),
+      repeat($.global_variable_declaration),
+    ),
+
+    class_type_definition: $ => seq(
+      $.class_type_definition_statement,
+      optional($.class_type_definition_statement_body),
+      $.end_type_declaration_statement,
+    ),
+
+    class_type_definition_statement: $ => seq(
+      optional($.global_keyword),
+      $.type_keyword,
+      alias($.identifier, $.class_type_name),
+      $.from_keyword,
+      alias($.identifier, $.ancenstor_type_name),
+      optional(seq($.native_keyword, alias($.string_literal, $.dll_path))),
+      optional($.autoinstantiate_keyword),
+      optional(seq(
+        $.within_keyword,
+        alias($.identifier, $.parent_class),
+        optional(seq(
+          $.descriptor_keyword,
+          alias($.string_literal, $.descriptor_type),
+          '=',
+          alias($.string_literal, $.descriptor_value),
+        )),
+      )),
+    ),
+
+    class_type_definition_statement_body: $ => repeat1(choice(
+      $.event_declaration,
+      $.function_prototype,
+      alias($.local_variable_declaration, $.inner_class_variable_declaration),
+    )),
+
+    global_variable_declaration: $ => seq(
+      $.global_keyword,
+      $.type,
+      alias($.identifier, $.variable_name),
+    ),
+
+    forward_declaration_statement_end: $ => seq(
+      $.end_keyword,
+      $.forward_keyword,
+    ),
+
+    shared_variables_section: $ => seq(
+      $.shared_variables_section_statement,
+      optional($.shared_variables_section_body),
+      $.end_variables_section,
+    ),
+
+    shared_variables_section_statement: $ => seq(
+      $.shared_keyword,
+      $.variables_keyword,
+    ),
+
+    shared_variables_section_body: $ => repeat1($.local_variable_declaration),
+
+    end_variables_section: $ => seq(
+      $.end_keyword,
+      $.variables_keyword,
+    ),
+
+    global_variables_section: $ => seq(
+      $.global_variables_section_statement,
+      optional($.global_variables_section_body),
+      $.end_variables_section,
+    ),
+
+    global_variables_section_statement: $ => seq(
+      $.global_keyword,
+      $.variables_keyword,
+    ),
+
+    global_variables_section_body: $ => repeat1($.local_variable_declaration),
+
+    global_var_declaration: $ => seq(
+      $.global_keyword,
+      $.type,
+      alias($.identifier, $.global_variable_name),
+    ),
+
+    external_function_prototypes: $ => seq(
+      $.external_function_prototypes_statement,
+      repeat($.external_function_prototype),
+      $.end_function_prototypes_statement,
+    ),
+
+    external_function_prototypes_statement: $ => seq(
+      $.type_keyword,
+      $.prototypes_keyword,
+    ),
+
+    external_function_prototype: $ => seq(
+      $.function_prototype,
+      $.library_keyword,
+      alias($.string_literal, $.library_name),
+      optional(seq(
+        $.alias_keyword,
+        $.for_keyword,
+        alias($.string_literal, $.alias_name),
+      )),
+    ),
+
+    instance_variables_section: $ => seq(
+      $.instance_variables_section_statement,
+      optional($.instance_variables_section_statement_body),
+      $.end_variables_section,
+    ),
+
+    instance_variables_section_statement: $ => seq(
+      $.type_keyword,
+      $.variables_keyword,
+    ),
+
+    instance_variables_section_statement_body: $ => repeat1(choice(
+      $.access_section,
+      $.instance_variable_declaration,
+    )),
+
+    access_section: $ => seq(
+      $.access_modifier,
+      ':',
+    ),
+
+    instance_variable_declaration: $ => seq(
+      // optional($.constant_keyword), TODO
+      optional($.access_modifier),
+      optional($.readacess_modifier),
+      optional($.writeaccess_modifier),
+      $.local_variable_declaration,
+    ),
+
+    readacess_modifier: $ => choice(
+      $.protectedread_keyword,
+      $.privateread_keyword,
+    ),
+
+    writeaccess_modifier: $ => choice(
+      $.protectedwrite_keyword,
+      $.privatewrite_keyword,
+    ),
+
+    event_definition: $ => seq(
+      $.event_definition_statement,
+      optional(alias($.scriptable_block, $.event_definition_block)),
+      $.event_definition_statement_end,
+    ),
+
+    event_definition_statement: $ => seq(
+      $.event_declaration,
+      $.statement_separation,
+    ),
+
+    event_definition_statement_end: $ => seq(
+      $.end_keyword,
+      $.event_keyword,
+    ),
+
+    on_event_definition: $ => seq(
+      $.on_event_definition_statement,
+      optional(alias($.scriptable_block, $.on_event_definition_block)),
+      $.on_event_definition_statement_end,
+    ),
+
+    on_event_definition_statement: $ => seq(
+      $.on_keyword,
+      alias($.identifier, $.class_name),
+      '.',
+      choice($.create_keyword, $.destroy_keyword),
+    ),
+
+    on_event_definition_statement_end: $ => seq($.end_keyword, $.on_keyword),
+
+    // inner_class_type_definition: $ => seq(
+    //   $.class_type_definition,
+    //   repeat(choice(
+    //     $.event_definition,
+    //     $.on_event_definition,
+    //   )),
+    // ),
+
+    structure_definition: $ => seq(
+      $.structure_definition_statement,
+      optional($.structure_definition_body),
+      $.end_type_declaration_statement,
+    ),
+
+    structure_definition_statement: $ => seq(
+      optional($.global_keyword),
+      $.type_keyword,
+      alias($.identifier, $.structure_name),
+      $.from_keyword,
+      caseInsensitiveAlias('structure'),
+    ),
+
+    structure_definition_body: $ => repeat1($.structure_field),
+
+    structure_field: $ => seq(
+      $.type,
+      alias($.identifier, $.field_name),
+      optional($.array_suffix),
+      optional($.structure_field_comment),
+    ),
+
+    structure_field_comment: $ => seq(
+      $.descriptor_keyword,
+      alias($.string_literal, $.descriptor_type),
+      '=',
+      alias($.string_literal, $.descriptor_value),
+    ),
+
+    function_type_declaration: $ => seq(
+      $.function_type_declaration_statement,
+      $.end_type_declaration_statement,
+    ),
+
+    function_type_declaration_statement: $ => seq(
+      $.global_keyword,
+      $.type_keyword,
+      alias($.identifier, $.function_type_name),
+      $.from_keyword,
+      caseInsensitiveAlias('function_object'),
+    ),
+
+    end_type_declaration_statement: $ => seq($.end_keyword, $.type_keyword),
+
+    forward_function_prototypes: $ => seq(
+      $.forward_function_prototypes_statement,
+      repeat($.function_prototype),
+      $.end_function_prototypes_statement,
+    ),
+
+    forward_function_prototypes_statement: $ => seq($.forward_keyword, $.prototypes_keyword),
+
+    end_function_prototypes_statement: $ => seq($.end_keyword, $.prototypes_keyword),
+
+    event_declaration: $ => seq(
+      $.event_keyword,
+      optional(seq($.type_keyword, alias($.type, $.return_type))),
+      alias($.identifier, $.event_name),
+      optional($.parameter_list),
+      optional($.throws_clause),
+      optional($.event_id),
+    ),
+
+    event_id: $ => /pbm_[a-zA-Z_][a-zA-Z0-9_]*/,
+
+    function_prototype: $ => choice(
+      $._function_prototype,
+      $._subroutine_prototype,
+    ),
+
+    _function_prototype: $ => seq(
+      optional($.global_keyword),
+      optional($.access_modifier),
+      $.function_keyword,
+      alias($.type, $.return_type),
+      alias($.identifier, $.function_name),
+      $.parameter_list,
+      optional($.throws_clause),
+    ),
+
+    _subroutine_prototype: $ => seq(
+      optional($.global_keyword),
+      optional($.access_modifier),
+      $.subroutine_keyword,
+      alias($.identifier, $.subroutine_name),
+      $.parameter_list,
+      optional($.throws_clause),
+    ),
+
+    throws_clause: $ => seq(
+      $.throws_keyword,
+      commaSep1(alias($.identifier, $.throwable_name)),
+    ),
+
+    function_definition: $ => choice(
+      $._function_definition,
+      $._subroutine_definition,
+    ),
+
+    _function_definition: $ => seq(
+      $.function_definition_statement,
+      optional(alias($.scriptable_block, $.function_definition_block)),
+      $.function_definition_statement_end,
+    ),
+
+    function_definition_statement: $ => seq($._function_prototype, $.statement_separation),
+
+    function_definition_statement_end: $ => seq($.end_keyword, $.function_keyword),
+
+    _subroutine_definition: $ => seq(
+      $.subroutine_definition_statement,
+      optional(alias($.scriptable_block, $.subroutine_definition_block)),
+      $.subroutine_definition_statement_end,
+    ),
+
+    subroutine_definition_statement: $ => seq($._subroutine_prototype, $.statement_separation),
+
+    subroutine_definition_statement_end: $ => seq($.end_keyword, $.subroutine_keyword),
+
+    parameter_list: $ => seq($.open_parenthesis, commaSep($.parameter), $.close_parenthesis),
+
+    parameter: $ => seq(
+      optional(alias(choice(
+        $.ref_keyword,
+        $.readonly_keyword,
+      ), $.parameter_pass_by_type)),
+      $.type,
+      alias($.identifier, $.parameter_name),
+      optional($.array_parameter_declaration_suffix),
+    ),
+
+    local_variable_declaration: $ => seq(
+      optional($.constant_keyword),
+      alias($.type, $.variable_type),
+      optional($.variable_precision),
+      $.variable_declaration_list,
+    ),
+
+    variable_precision: $ => seq($.open_curly_brackets, $.integer_literal, $.close_curly_brackets),
+
+    variable_declaration_list: $ => commaSep1($.variable_declaration),
+
+    variable_declaration: $ => seq(
+      alias($.identifier, $.variable_name),
+      optional($.array_suffix),
+      optional(seq('=', alias($.r_value_expression, $.initial_value))),
+    ),
+
+    array_suffix: $ => seq(
+      $.open_brackets,
+      choice(
+        commaSep($.r_value_expression),
+        commaSep(seq($.r_value_expression, $.to_keyword, $.r_value_expression)),
+      ),
+      $.close_brackets,
+    ),
+
+    array_parameter_declaration_suffix: $ => seq($.open_brackets, $.close_brackets),
+
+    access_modifier: $ => choice(
+      $.public_keyword,
+      $.private_keyword,
+      $.protected_keyword,
+    ),
+
+    scriptable_block: $ => repeat1($.statement),
+
+    statement: $ => choice(
+      $.conditional_compilation_statement,
+      $.choose_statement,
+      $.do_loop,
+      $.for_loop,
+      $.goto_label,
+      $.if_statement,
+      $.inline_if_statement,
+      $.local_variable_declaration_statement,
+      $.try_catch_statement,
+      $.while_loop,
+      seq($.inline_statement, optional($.statement_separation)),
+      $.sql_statement,
+    ),
+
+    conditional_compilation_statement: $ => seq(
+      '#',
+      $.if_keyword,
+      optional($.not_keyword),
+      caseInsensitiveAlias('defined'),
+      alias($.identifier, $.predefined_symbol),
+      $.then_keyword,
+      optional(alias($.scriptable_block, $.conditional_compilation_if_block)),
+      optional(seq(
+        '#',
+        $.elseif_keyword,
+        optional($.not_keyword),
+        caseInsensitiveAlias('defined'),
+        alias($.identifier, $.predefined_symbol),
+        $.then_keyword,
+        optional(alias($.scriptable_block, $.conditional_compilation_elseif_block)),
+      )),
+      optional(seq(
+        '#',
+        $.else_keyword,
+        optional(alias($.scriptable_block, $.conditional_compilation_else_block)),
+      )),
+      '#',
+      $.end_keyword,
+      $.if_keyword,
+    ),
+
+    choose_statement: $ => seq(
+      $.choose_case_statement,
+      seq(
+        repeat1($.choose_case_clause),
+        optional($.choose_case_else_clause),
+      ),
+      $.choose_statement_end,
+    ),
+
+    choose_case_statement: $ => seq(
+      $.choose_keyword,
+      $.case_keyword,
+      alias($.r_value_expression, $.test_expression),
+      optional($.statement_separation),
+    ),
+
+    choose_case_clause: $ => seq(
+      $.case_keyword,
+      alias(choice(
+        $.choose_case_to_expression,
+        $.choose_case_is_relational_expression,
+        $.choose_case_condition_expression,
+      ), $.choose_case_clause_condition),
+      optional($.statement_separation),
+      optional(alias($.scriptable_block, $.choose_case_block)),
+    ),
+
+    choose_case_to_expression: $ => seq($.r_value_expression, $.to_keyword, $.r_value_expression),
+
+    choose_case_is_relational_expression: $ => seq($.is_keyword, $.relational_operator, $.r_value_expression),
+
+    choose_case_condition_expression: $ => commaSep1($.r_value_expression),
+
+    choose_case_else_clause: $ => seq(
+      $.case_keyword,
+      $.else_keyword,
+      optional($.statement_separation),
+      optional(alias($.scriptable_block, $.choose_case_else_block)),
+    ),
+
+    choose_statement_end: $ => seq(
+      $.end_keyword,
+      $.choose_keyword,
+      optional($.statement_separation),
+    ),
+
+    relational_operator: _ => choice('>', '<', '>=', '<='),
+
+    do_loop: $ => seq(
+      $.do_keyword,
+      optional($.statement_separation),
+      alias(optional($.scriptable_block), $.do_loop_block),
+      $.do_loop_end,
+    ),
+
+    do_loop_end: $ => seq(
+      $.loop_keyword,
+      choice($.until_keyword, $.while_keyword),
+      alias($.r_value_expression, $.condition),
+      optional($.statement_separation),
+    ),
+
+    for_loop: $ => seq(
+      $.for_loop_statement,
+      optional(alias($.scriptable_block, $.for_loop_block)),
+      $.next_keyword,
+      optional($.statement_separation),
+    ),
+
+    for_loop_statement: $ => seq(
+      $.for_keyword,
+      alias($.l_value_expression, $.iterator_counter),
+      '=',
+      alias($.r_value_expression, $.initial_value),
+      $.to_keyword,
+      alias($.r_value_expression, $.final_value),
+      optional(seq($.step_keyword, alias($.r_value_expression, $.increment_value))),
+      optional($.statement_separation),
+    ),
+
+    goto_label: $ => seq(alias($.identifier, $.label), ':', optional($.statement_separation)),
+
+    if_statement: $ => seq(
+      $.if_then_statement,
+      optional(alias($.scriptable_block, $.if_block)),
+      repeat($.elseif_clause),
+      optional($.else_clause),
+      $.if_then_statement_end,
+    ),
+
+    if_then_statement: $ => seq(
+      $.if_keyword,
+      alias($.r_value_expression, $.condition),
+      $.then_keyword,
+      optional($.statement_separation),
+    ),
+
+    if_then_statement_end: $ => seq(
+      $.end_keyword,
+      $.if_keyword,
+      optional($.statement_separation),
+    ),
+
+    elseif_clause: $ => seq(
+      $.elseif_keyword,
+      alias($.r_value_expression, $.condition),
+      $.then_keyword,
+      optional($.statement_separation),
+      optional(alias($.scriptable_block, $.elseif_block)),
+    ),
+
+    else_clause: $ => seq(
+      $.else_keyword,
+      optional($.statement_separation),
+      optional(alias($.scriptable_block, $.else_block)),
+    ),
+
+    inline_if_statement: $ => prec.left(seq(
+      $.if_keyword,
+      alias($.r_value_expression, $.condition),
+      $.then_keyword,
+      alias($.inline_statement, $.if_case_statement),
+      optional(seq($.else_keyword, alias($.inline_statement, $.else_case_statement))),
+      optional($.statement_separation),
+    )),
+
+    local_variable_declaration_statement: $ => seq(
+      $.local_variable_declaration,
+      optional($.statement_separation),
+    ),
+
+    try_catch_statement: $ => seq(
+      $.try_keyword,
+      optional($.statement_separation),
+      optional(alias($.scriptable_block, $.try_block)),
+      repeat($.catch_clause),
+      optional($.finally_clause),
+      $.try_catch_statement_end,
+    ),
+
+    try_catch_statement_end: $ => seq(
+      $.end_keyword,
+      $.try_keyword,
+      optional($.statement_separation),
+    ),
+
+    catch_clause: $ => seq(
+      $.catch_clause_statement,
+      optional(alias($.scriptable_block, $.catch_block)),
+    ),
+
+    catch_clause_statement: $ => seq(
+      $.catch_keyword,
+      $.open_parenthesis,
+      alias($.type, $.throwable_type),
+      alias($.identifier, $.throwable_name),
+      $.close_parenthesis,
+      optional($.statement_separation),
+    ),
+
+    finally_clause: $ => seq(
+      $.finally_keyword,
+      optional($.statement_separation),
+      optional(alias($.scriptable_block, $.finally_block)),
+    ),
+
+    while_loop: $ => seq(
+      $.while_loop_statement,
+      optional(alias($.scriptable_block, $.while_loop_block)),
+      $.loop_keyword,
+      optional($.statement_separation),
+    ),
+
+    while_loop_statement: $ => seq(
+      $.do_keyword,
+      choice($.until_keyword, $.while_keyword),
+      alias($.r_value_expression, $.condition),
+      optional($.statement_separation),
+    ),
+
+    inline_statement: $ => choice(
+      $.assignment_statement,
+      $.call_statement,
+      $.continue_statement,
+      $.create_statement,
+      $.destroy_statement,
+      $.exit_statement,
+      $.goto_statement,
+      $.halt_statement,
+      $.return_statement,
+      $.throw_statement,
+      $.expression_statement,
+    ),
+
+    assignment_statement: $ => seq(
+      alias($.l_value_expression, $.l_value),
+      alias(choice('=', '+=', '-=', '*=', '/=', '^='), $.operator),
+      alias($.r_value_expression, $.r_value),
+    ),
+
+    call_statement: $ => seq(
+      $.call_keyword,
+      alias($.r_value_expression, $.ancestor_name),
+      optional(seq('`', alias($.identifier, $.control_name))),
+      '::',
+      alias($.identifier, $.event_name),
+    ),
+
+    continue_statement: $ => $.continue_keyword,
+
+    create_statement: $ => choice(
+      seq(
+        alias($.l_value_expression, $.l_value),
+        '=',
+        $.create_keyword,
+        $.type,
+      ),
+      seq(
+        alias($.l_value_expression, $.l_value),
+        '=',
+        $.create_keyword,
+        $.using_keyword,
+        alias($.r_value_expression, $.dynamic_type),
+      ),
+    ),
+
+    destroy_statement: $ => choice(
+      seq($.destroy_keyword, $.open_parenthesis, alias($.r_value_expression, $.variable_name), $.close_parenthesis),
+      seq($.destroy_keyword, alias($.r_value_expression, $.variable_name)),
+    ),
+
+    exit_statement: $ => $.exit_keyword,
+
+    goto_statement: $ => seq($.goto_keyword, alias($.identifier, $.label)),
+
+    halt_statement: $ => seq($.halt_keyword, optional($.close_keyword)),
+
+    return_statement: $ => seq(
+      $.return_keyword,
+      optional(alias($.r_value_expression, $.return_value)),
+    ),
+
+    throw_statement: $ => seq(
+      $.throw_keyword,
+      choice(
+        seq($.create_keyword, $.type),
+        $.r_value_expression,
+      ),
+    ),
+
+    expression_statement: $ => seq(
+      choice(
+        $.method_invocation,
+        $.update_expression,
+      ),
+    ),
+
+    method_invocation: $ => prec(PREC.METHOD_INVOCATION, seq(
+      optional(seq(
+        alias(choice($.r_value_expression), $.method_object),
+        alias(choice('.', '::'), $.operator)),
+      ),
+      optional(alias(choice($.function_keyword, $.event_keyword), $.method_type)),
+      optional(alias(choice($.static_keyword, $.dynamic_keyword), $.call_type)),
+      optional(alias(choice($.trigger_keyword, $.post_keyword), $.when_type)),
+      alias($.identifier, $.method_name),
+      $.argument_list,
+    )),
+
+    argument_list: $ => seq(
+      $.open_parenthesis,
+      commaSep(seq(optional($.ref_keyword), $.r_value_expression)),
+      $.close_parenthesis,
+    ),
+
+    update_expression: $ => {
+      const argument = alias($.l_value_expression, $.argument);
+      const operator = alias(choice('--', '++'), $.operator);
+      return prec.right(PREC.UPDATE_UNARY, seq(argument, operator));
+    },
+
+    l_value_expression: $ => choice(
+      $.identifier_expression,
+      $.field_access,
+      $.array_access,
+    ),
+
+    r_value_expression: $ => choice(
+      $.l_value_expression,
+
+      $.binary_expression,
+      $.unary_expression,
+
+      $._literal,
+      $.array_literal,
+      $.this_keyword,
+      $.parent_keyword,
+      $.super_keyword,
+      $.enumetation_datatype,
+      $.method_invocation,
+      $.parenthesized_expression,
+    ),
+
+    binary_expression: $ => {
+      const table = [
+        { operator: '+', precedence: PREC.ADDITIVE },
+        { operator: '-', precedence: PREC.ADDITIVE },
+        { operator: '*', precedence: PREC.MULTIPLICATIVE },
+        { operator: '/', precedence: PREC.MULTIPLICATIVE },
+        { operator: '^', precedence: PREC.EXPONENTIATION },
+        { operator: $.or_keyword, precedence: PREC.OR },
+        { operator: $.and_keyword, precedence: PREC.AND },
+        { operator: '=', precedence: PREC.EQUALITY },
+        { operator: '<>', precedence: PREC.EQUALITY },
+        { operator: '>', precedence: PREC.RELATIONAL },
+        { operator: '<', precedence: PREC.RELATIONAL },
+        { operator: '>=', precedence: PREC.RELATIONAL },
+        { operator: '<=', precedence: PREC.RELATIONAL },
+      ];
+
+      return choice(...table.map(({ operator, precedence }) => {
+        return prec.left(precedence, seq(
+          alias($.r_value_expression, $.left_expression),
+          alias(operator, $.operator),
+          alias($.r_value_expression, $.right_expression),
+        ));
+      }));
+    },
+
+    unary_expression: $ => prec.left(PREC.UNARY, seq(
+      alias(choice($.not_keyword, '-', '+'), $.operator),
+      field('argument', $.r_value_expression),
+    )),
+
+    array_literal: $ => seq(
+      $.open_curly_brackets,
+      commaSep1($.r_value_expression),
+      $.close_curly_brackets,
+    ),
+
+    array_access: $ => seq(
+      alias($.r_value_expression, $.array_name),
+      $.open_brackets,
+      alias($.r_value_expression, $.array_index),
+      $.close_brackets,
+    ),
+
+    enumetation_datatype: $ => seq(alias($.identifier, $.enum_name), '!'),
+
+    field_access: $ => prec(PREC.FIELD_ACCESS, seq(
+      alias(choice($.r_value_expression), $.object),
+      '.',
+      alias($.identifier, $.field_name),
+      optional($.array_suffix_ref),
+    )),
+
+    array_suffix_ref: _ => /\[[ \t]*\]/,
+
+    identifier_expression: $ => prec(PREC.IDENTIFIER_EXPRESSION, seq($.identifier, optional($.array_suffix_ref))),
+
+    parenthesized_expression: $ => seq($.open_parenthesis, $.r_value_expression, $.close_parenthesis),
+
+    type: $ => choice(
+      $.primitive_type,
+      alias($.identifier, $.custom_type),
+    ),
+
+    _literal: $ => choice(
+      $.integer_literal,
+      $.decimal_literal,
+      $.real_literal,
+      $.string_literal,
+      $.date_literal,
+      $.time_literal,
+      $.boolean_literal,
+    ),
+
+    integer_literal: _ => /\d+/,
+    decimal_literal: _ => /\d*\.\d+/,
+    real_literal: _ => /(?:[0-9]+(?:\.[0-9]*)?|\.[0-9]+)[Ee][+-]?[0-9]+/,
+    date_literal: _ => /(?:\d{4}-\d{2}-\d{2})/,
+    time_literal: $ => /(?:[01][0-9]|2[0-3]):[0-5][0-9]:[0-5][0-9](?:\.[0-9]{1,6})?/,
+
+    string_literal: $ => choice(
+      seq($.double_quote, alias(repeat(token.immediate(prec(1, choice(/[^"\\]/, /\\./, /~"/)))), $.string_content), $.double_quote),
+      seq($.single_quote, alias(repeat(token.immediate(prec(1, choice(/[^'\\]/, /\\./, /~'/)))), $.string_content), $.single_quote),
+    ),
+
+    boolean_literal: $ => choice(
+      $.true_keyword,
+      $.false_keyword,
+    ),
+
+    primitive_type: _ => choice(
+      caseInsensitiveAlias('blob'),
+      caseInsensitiveAlias('boolean'),
+      caseInsensitiveAlias('byte'),
+      caseInsensitiveAlias('char'),
+      caseInsensitiveAlias('character'),
+      caseInsensitiveAlias('date'),
+      caseInsensitiveAlias('datetime'),
+      caseInsensitiveAlias('decimal'),
+      caseInsensitiveAlias('dec'),
+      caseInsensitiveAlias('double'),
+      caseInsensitiveAlias('integer'),
+      caseInsensitiveAlias('int'),
+      caseInsensitiveAlias('longlong'),
+      caseInsensitiveAlias('long'),
+      caseInsensitiveAlias('real'),
+      caseInsensitiveAlias('string'),
+      caseInsensitiveAlias('time'),
+      caseInsensitiveAlias('unsignedinteger'),
+      caseInsensitiveAlias('unsignedint'),
+      caseInsensitiveAlias('uint'),
+      caseInsensitiveAlias('unsignedlong'),
+      caseInsensitiveAlias('ulong'),
+      caseInsensitiveAlias('any'),
+    ),
+
+    open_parenthesis: _ => '(',
+    close_parenthesis: _ => ')',
+    open_brackets: _ => '[',
+    close_brackets: _ => ']',
+    open_curly_brackets: _ => '{',
+    close_curly_brackets: _ => '}',
+    single_quote: _ => '\'',
+    double_quote: _ => '"',
+    statement_separation: _ => ';',
+
+    public_keyword: _ => reservedWord('public'),
+    private_keyword: _ => reservedWord('private'),
+    protected_keyword: _ => reservedWord('protected'),
+    alias_keyword: _ => reservedWord('alias'),
+    and_keyword: _ => reservedWord('and'),
+    autoinstantiate_keyword: _ => reservedWord('autoinstantiate'),
+    call_keyword: _ => reservedWord('call'),
+    case_keyword: _ => reservedWord('case'),
+    catch_keyword: _ => reservedWord('catch'),
+    choose_keyword: _ => reservedWord('choose'),
+    close_keyword: _ => reservedWord('close'),
+    commit_keyword: _ => reservedWord('commit'),
+    connect_keyword: _ => reservedWord('connect'),
+    constant_keyword: _ => reservedWord('constant'),
+    continue_keyword: _ => reservedWord('continue'),
+    create_keyword: _ => reservedWord('create'),
+    cursor_keyword: _ => reservedWord('cursor'),
+    declare_keyword: _ => reservedWord('declare'),
+    delete_keyword: _ => reservedWord('delete'),
+    describe_keyword: _ => reservedWord('describe'),
+    descriptor_keyword: _ => reservedWord('descriptor'),
+    destroy_keyword: _ => reservedWord('destroy'),
+    disconnect_keyword: _ => reservedWord('disconnect'),
+    do_keyword: _ => reservedWord('do'),
+    dynamic_keyword: _ => reservedWord('dynamic'),
+    else_keyword: _ => reservedWord('else'),
+    elseif_keyword: _ => reservedWord('elseif'),
+    end_keyword: _ => reservedWord('end'),
+    enumerated_keyword: _ => reservedWord('enumerated'),
+    event_keyword: _ => reservedWord('event'),
+    execute_keyword: _ => reservedWord('execute'),
+    exit_keyword: _ => reservedWord('exit'),
+    external_keyword: _ => reservedWord('external'),
+    false_keyword: _ => reservedWord('false'),
+    fetch_keyword: _ => reservedWord('fetch'),
+    finally_keyword: _ => reservedWord('finally'),
+    first_keyword: _ => reservedWord('first'),
+    for_keyword: _ => reservedWord('for'),
+    forward_keyword: _ => reservedWord('forward'),
+    from_keyword: _ => reservedWord('from'),
+    function_keyword: _ => reservedWord('function'),
+    global_keyword: _ => reservedWord('global'),
+    goto_keyword: _ => reservedWord('goto'),
+    halt_keyword: _ => reservedWord('halt'),
+    if_keyword: _ => reservedWord('if'),
+    immediate_keyword: _ => reservedWord('immediate'),
+    indirect_keyword: _ => reservedWord('indirect'),
+    insert_keyword: _ => reservedWord('insert'),
+    into_keyword: _ => reservedWord('into'),
+    intrinsic_keyword: _ => reservedWord('intrinsic'),
+    is_keyword: _ => reservedWord('is'),
+    last_keyword: _ => reservedWord('last'),
+    library_keyword: _ => reservedWord('library'),
+    loop_keyword: _ => reservedWord('loop'),
+    native_keyword: _ => reservedWord('native'),
+    next_keyword: _ => reservedWord('next'),
+    not_keyword: _ => reservedWord('not'),
+    of_keyword: _ => reservedWord('of'),
+    on_keyword: _ => reservedWord('on'),
+    open_keyword: _ => reservedWord('open'),
+    or_keyword: _ => reservedWord('or'),
+    parent_keyword: _ => reservedWord('parent'),
+    post_keyword: _ => reservedWord('post'),
+    prepare_keyword: _ => reservedWord('prepare'),
+    prior_keyword: _ => reservedWord('prior'),
+    privateread_keyword: _ => reservedWord('privateread'),
+    privatewrite_keyword: _ => reservedWord('privatewrite'),
+    procedure_keyword: _ => reservedWord('procedure'),
+    protectedread_keyword: _ => reservedWord('protectedread'),
+    protectedwrite_keyword: _ => reservedWord('protectedwrite'),
+    prototypes_keyword: _ => reservedWord('prototypes'),
+    readonly_keyword: _ => reservedWord('readonly'),
+    ref_keyword: _ => reservedWord('ref'),
+    return_keyword: _ => reservedWord('return'),
+    rollback_keyword: _ => reservedWord('rollback'),
+    rpcfunc_keyword: _ => reservedWord('rpcfunc'),
+    select_keyword: _ => reservedWord('select'),
+    selectblob_keyword: _ => reservedWord('selectblob'),
+    shared_keyword: _ => reservedWord('shared'),
+    static_keyword: _ => reservedWord('static'),
+    step_keyword: _ => reservedWord('step'),
+    subroutine_keyword: _ => reservedWord('subroutine'),
+    super_keyword: _ => reservedWord('super'),
+    system_keyword: _ => reservedWord('system'),
+    systemread_keyword: _ => reservedWord('systemread'),
+    systemwrite_keyword: _ => reservedWord('systemwrite'),
+    then_keyword: _ => reservedWord('then'),
+    this_keyword: _ => reservedWord('this'),
+    throw_keyword: _ => reservedWord('throw'),
+    throws_keyword: _ => reservedWord('throws'),
+    to_keyword: _ => reservedWord('to'),
+    trigger_keyword: _ => reservedWord('trigger'),
+    true_keyword: _ => reservedWord('true'),
+    try_keyword: _ => reservedWord('try'),
+    type_keyword: _ => reservedWord('type'),
+    until_keyword: _ => reservedWord('until'),
+    update_keyword: _ => reservedWord('update'),
+    updateblob_keyword: _ => reservedWord('updateblob'),
+    using_keyword: _ => reservedWord('using'),
+    variables_keyword: _ => reservedWord('variables'),
+    while_keyword: _ => reservedWord('while'),
+    with_keyword: _ => reservedWord('with'),
+    within_keyword: _ => reservedWord('within'),
+    debug_keyword: _ => reservedWord('_debug'),
+    where_keyword: _ => reservedWord('where'),
+    current_keyword: _ => reservedWord('current'),
+
+    export_header: $ => seq(
+      $.export_header_identifier,
+      optional($.export_header_comments),
+    ),
+
+    export_header_identifier: $ => seq(
+      alias(/(HA)?\$PBExportHeader\$/, $.export_header_identifier_text),
+      $.export_header_identifier_content,
+    ),
+
+    export_header_identifier_content: $ => seq(alias($.identifier, $.file_name), '.', $.file_extension),
+
+    export_header_comments: $ => seq(
+      alias('$PBExportComments$', $.export_header_comments_text),
+      alias(/[^\r\n]*/, $.export_header_comments_content),
+    ),
+
+    file_extension: $ => choice(
+      alias('sra', $.application_file_extension),
+      alias('sru', $.user_object_file_extension),
+      alias('srw', $.window_file_extension),
+      alias('srm', $.menu_file_extension),
+      alias('srs', $.structure_file_extension),
+      alias('srf', $.function_file_extension),
+    ),
+
+    identifier: _ => /[a-zA-Z_][a-zA-Z0-9\-_$#%]*/,
+
+    line_comment: _ => seq('//', token.immediate(prec(1, /.*/))),
+    block_comment: _ => token(seq('/*', /[^*]*\*+([^/*][^*]*\*+)*/, '/')),
+    line_continuation: _ => '&',
+
+
+    sql_statement: $ => choice(
+      $.connect_statement,
+      $.disconnect_statement,
+      $.commit_statement,
+      $.rollback_statement,
+      $.fetch_statement,
+      $.open_cursor_statement,
+      $.close_cursor_procedure_statement,
+      $.execute_statement,
+
+      $.delete_statement,
+      $.insert_statement,
+      $.select_statement,
+      $.update_statement,
+
+      $.declare_cursor_statement,
+      $.declare_procedure_statement,
+      $.declare_dynamic_statement,
+      $.describe_sql_statement,
+
+
+      $.prepare_sql_statement,
+
+      /*
+
+      */
+    ),
+
+    close_cursor_procedure_statement: $ => seq(
+      $.close_keyword,
+      alias($.identifier, $.cursor_procedure_name),
+      $.statement_separation,
+    ),
+
+    using_transaction_statement: $ => seq(
+      $.using_keyword,
+      alias($.identifier, $.transaction_name),
+    ),
+
+    commit_statement: $ => seq(
+      $.commit_keyword,
+      optional($.using_transaction_statement),
+      $.statement_separation,
+    ),
+
+    connect_statement: $ => seq(
+      $.connect_keyword,
+      optional($.using_transaction_statement),
+      $.statement_separation,
+    ),
+
+    declare_cursor_statement: $ => seq(
+      $.declare_keyword,
+      alias($.identifier, $.cursor_name),
+      $.cursor_keyword,
+      $.for_keyword,
+      $.select_statement,
+    ),
+
+    declare_procedure_statement: $ => seq(
+      $.declare_keyword,
+      alias($.identifier, $.procedure_name),
+      $.procedure_keyword,
+      $.for_keyword,
+      alias($.identifier, $.store_procedure_name),
+      optional($.stored_procedure_param_list),
+      optional($.using_transaction_statement),
+      $.statement_separation,
+    ),
+
+    declare_dynamic_statement: $ => seq(
+      $.declare_keyword,
+      alias($.identifier, $.cursor_procedure_name),
+      $.dynamic_keyword,
+      choice($.cursor_keyword, $.procedure_keyword),
+      $.for_keyword,
+      alias($.identifier, $.dynamic_stage_area),
+      $.statement_separation,
+    ),
+
+    describe_sql_statement: $ => seq(
+      $.describe_keyword,
+      alias($.identifier, $.dynamic_stage_area),
+      $.into_keyword,
+      alias($.identifier, $.dynamic_description_area),
+      $.statement_separation,
+    ),
+
+    stored_procedure_param_list: $ => choice(
+      commaSep1($.stored_procedure_param_ase),
+      seq($.open_parenthesis, commaSep1($.stored_procedure_param_oracle), $.close_parenthesis),
+    ),
+
+    stored_procedure_param_ase: $ => seq(
+      '@',
+      alias($.identifier, $.param_name),
+      '=',
+      optional(':'),
+      alias($.r_value_expression, $.variable_name),
+    ),
+
+    stored_procedure_param_oracle: $ => seq(
+      optional(':'),
+      alias($.r_value_expression, $.variable_name),
+    ),
+
+    delete_statement: $ => choice(
+      seq(
+        $.delete_keyword,
+        $.from_keyword,
+        alias($.identifier, $.table_name),
+        $.where_keyword,
+        $.where_criteria,
+        $.rest_of_sql,
+        $.statement_separation,
+      ),
+      seq(
+        $.delete_keyword,
+        $.from_keyword,
+        alias($.identifier, $.table_name),
+        $.where_keyword,
+        $.current_keyword,
+        $.of_keyword,
+        alias($.identifier, $.cursor_name),
+        $.statement_separation,
+      ),
+    ),
+
+    disconnect_statement: $ => seq(
+      $.disconnect_keyword,
+      optional($.using_transaction_statement),
+      $.statement_separation,
+    ),
+
+    execute_statement: $ => choice(
+      seq($.execute_keyword, alias($.identifier, $.procedure_name), $.statement_separation),
+      $.execute_statement_immediate_case,
+      seq(
+        $.execute_keyword,
+        alias($.identifier, $.dynamic_stage_area),
+        $.using_keyword,
+        commaSep1($.stored_procedure_param_oracle),
+        $.statement_separation,
+      ),
+      seq(
+        $.execute_keyword,
+        $.dynamic_keyword,
+        alias($.identifier, $.procedure_name),
+        optional(seq(
+          $.using_keyword,
+          commaSep1($.stored_procedure_param_oracle),
+        )),
+        $.statement_separation,
+      ),
+      seq(
+        $.execute_keyword,
+        $.dynamic_keyword,
+        alias($.identifier, $.procedure_name),
+        $.using_keyword,
+        $.descriptor_keyword,
+        alias($.identifier, $.dynamic_description_area),
+        $.statement_separation),
+    ),
+
+    execute_statement_immediate_case: $ => prec(PREC.IMMEDIATE_CASE, seq(
+      $.execute_keyword,
+      $.immediate_keyword,
+      choice($.stored_procedure_param_oracle, $.string_literal),
+      optional($.using_transaction_statement),
+      $.statement_separation,
+    )),
+
+    fetch_statement: $ => choice(
+      seq(
+        $.fetch_keyword,
+        alias($.identifier, $.cursor_procedure_name),
+        $.into_keyword,
+        $.fetch_variable_list,
+        $.statement_separation,
+      ),
+      seq(
+        $.fetch_keyword,
+        alias($.identifier, $.cursor_procedure_name),
+        $.using_keyword,
+        $.descriptor_keyword,
+        alias($.identifier, $.dynamic_stage_area),
+        $.statement_separation,
+      ),
+    ),
+
+    fetch_variable_list: $ => commaSep1(seq(
+      ':',
+      alias($.identifier, $.variable_name),
+      optional(seq(
+        ':',
+        alias($.identifier, $.indicator_var),
+      )),
+    )),
+
+    insert_statement: $ => seq(
+      $.insert_keyword,
+      $.rest_of_sql,
+      $.statement_separation,
+    ),
+
+    open_cursor_statement: $ => choice(
+      seq(
+        $.open_keyword,
+        alias($.identifier, $.cursor_name),
+        $.statement_separation,
+      ),
+      seq(
+        $.open_keyword,
+        $.dynamic_keyword,
+        alias($.identifier, $.cursor_name),
+        optional(seq(
+          $.using_keyword,
+          commaSep1($.stored_procedure_param_oracle),
+        )),
+        $.statement_separation,
+      ),
+      seq(
+        $.open_keyword,
+        $.dynamic_keyword,
+        alias($.identifier, $.cursor_name),
+        $.using_keyword,
+        $.descriptor_keyword,
+        alias($.identifier, $.dynamic_staging_area),
+        $.statement_separation,
+      ),
+    ),
+
+    rollback_statement: $ => seq(
+      $.rollback_keyword,
+      optional($.using_transaction_statement),
+      $.statement_separation,
+    ),
+
+    select_statement: $ => seq(
+      choice($.select_keyword, $.selectblob_keyword),
+      $.rest_of_sql,
+      $.statement_separation,
+    ),
+
+    update_statement: $ => seq(
+      choice($.update_keyword, $.updateblob_keyword),
+      alias($.identifier, $.table_name),
+      $.rest_of_sql,
+      $.statement_separation,
+    ),
+
+    prepare_sql_statement: $ => seq(
+      $.prepare_keyword,
+      alias($.identifier, $.dynamic_staging_area),
+      $.from_keyword,
+      choice(
+        alias($.string_literal, $.sql_statement),
+        seq(':', alias($.r_value_expression, $.sql_statement)),
+      ),
+      $.statement_separation,
+    ),
+
+    rest_of_sql: $ => token(/[^;]*/),
+
+    where_criteria: $ => $.rest_of_sql,
+
+  },
+});
+
+/**
+ * Creates a reserved word
+ *
+ * @param {string} word
+ *
+ * @returns {AliasRule}
+ */
+function reservedWord(word) {
+  return alias(reserved(caseInsensitiveRegExp(word)), word);
+}
+
+/**
+ * Creates a reserved word regex
+ *
+ * @param {RegExp} regex
+ *
+ * @returns {TokenRule}
+ */
+function reserved(regex) {
+  return token(prec(PREC.KEYWORD, regex));
+}
+
+/**
+ * Creates a case insensitive word
+ *
+ * @param {string} word
+ *
+ * @returns {RegExp}
+ */
+function caseInsensitiveRegExp(word) {
+  return new RegExp(word.split('')
+    .map(letter => `[${letter}${letter.toUpperCase()}]`)
+    .join(''),
+  );
+}
+
+/**
+ * Creates a case insensitive alias rule
+ *
+ * @param {string} word
+ *
+ * @returns {AliasRule}
+ */
+function caseInsensitiveAlias(word) {
+  return alias(caseInsensitiveRegExp(word), word);
+}
+
+/**
+ * Creates a rule to optionally match one or more of the rules separated by a comma
+ *
+ * @param {Rule} rule
+ *
+ * @returns {ChoiceRule}
+ */
+function commaSep(rule) {
+  return optional(commaSep1(rule));
+}
+
+/**
+ * Creates a rule to match one or more of the rules separated by a comma
+ *
+ * @param {Rule} rule
+ *
+ * @returns {SeqRule}
+ */
+function commaSep1(rule) {
+  return seq(rule, repeat(seq(',', rule)));
+}