statement method

Parser<StatementNode> statement()

Implementation

Parser<StatementNode> statement() =>
    seq2(
      ref0(statementLabel).optional(),
      [
        ref0(statementAssign),
        ref0(statementCall),
        ref0(statementBlock),
        ref0(statementIf),
        ref0(statementRepeat),
        ref0(statementWhile),
        ref0(statementFor),
        ref0(statementCase),
        ref0(statementWith),
        ref0(statementGoto),
        ref0(statementExit),
      ].toChoiceParser().optional(),
    ).optional().map((values) {
      if (values == null) return const EmptyStatementNode();
      final (label, stmt) = values;
      if (stmt == null) return EmptyStatementNode(label: label);
      if (label != null) {
        return switch (stmt) {
          final CompoundStatementNode cs => CompoundStatementNode(
            label: label,
            statements: cs.statements,
          ),
          final AssignmentStatementNode a => AssignmentStatementNode(
            label: label,
            variable: a.variable,
            value: a.value,
          ),
          final ProcedureStatementNode p => ProcedureStatementNode(
            label: label,
            name: p.name,
            arguments: p.arguments,
          ),
          final IfStatementNode i => IfStatementNode(
            label: label,
            condition: i.condition,
            thenStatement: i.thenStatement,
            elseStatement: i.elseStatement,
          ),
          final CaseStatementNode c => CaseStatementNode(
            label: label,
            expression: c.expression,
            cases: c.cases,
          ),
          final WhileStatementNode w => WhileStatementNode(
            label: label,
            condition: w.condition,
            statement: w.statement,
          ),
          final RepeatStatementNode r => RepeatStatementNode(
            label: label,
            statements: r.statements,
            condition: r.condition,
          ),
          final ForStatementNode f => ForStatementNode(
            label: label,
            variable: f.variable,
            initialValue: f.initialValue,
            isDownTo: f.isDownTo,
            finalValue: f.finalValue,
            statement: f.statement,
          ),
          final WithStatementNode wt => WithStatementNode(
            label: label,
            records: wt.records,
            statement: wt.statement,
          ),
          final GotoStatementNode g => GotoStatementNode(
            label: label,
            targetLabel: g.targetLabel,
          ),
          EmptyStatementNode _ => EmptyStatementNode(label: label),
        };
      }
      return stmt;
    });