def analyze_errorr_card_list(module):
    card_iter = env.get_card_iterator(module)
    card_1, ngout = analyze_errorr_card_1(env.next(card_iter), module)
    card_2, ign = analyze_errorr_card_2(env.next(card_iter), module)
    # Card 3 should only be defined for ngout = 0.
    if ngout == 0:
        analyze_errorr_card_3(env.next(card_iter), module)

def analyze_groupr_card_10(card, module):
    rule.card_must_be_defined('card_10', card, module, None)
    stmt_iter = env.get_statement_iterator(card)
    order_map = groupr_settings.card_10_order_map
    rule.analyze_statement(order_map.get(0), env.next(stmt_iter), card, module)
    rule.no_statement_allowed(env.next(stmt_iter), card, module)
    return card

def organize_card_list(card_list, module):
    card_iter = env.get_card_iterator(module)
    organize_card_1(env.next(card_iter), module)
    # Number of card_2's denotes the number of materials to process. Each
    # card_2 is assumed to have an accompanying card_3 and card_4 which
    # defines the temperatures and sigma zero values, respectively.
    number_of_card_2 = len(env.get_cards('card_2', module))
    # The last card 2 should not be considered as a next material to process,
    # since it is expected to terminate the execution of purr.
    # Therefore, 'number_of_card_2-1' is used to create the range to iterate
    # over.
    for c2 in range(number_of_card_2-1):
        card_2, ntemp, nsigz = organize_card_2(env.next(card_iter), module)
        # XXX: Assuming card 3 is only defined when there actually are temps
        # that should be defined.
        if ntemp > 0:
            organize_card_3(ntemp, env.next(card_iter), module)
        # XXX: Assuming card 4 is only defined when there actually are sigz
        # that should be defined.
        if nsigz > 0:
            organize_card_4(nsigz, env.next(card_iter), module)
    # The last card is expected to be a card 2 with matd = 0, to indicate
    # termination of purr.
    organize_card_2_stop(env.next(card_iter), module)
    return module

def analyze_moder_card_list(module):
    card_iter = env.get_card_iterator(module)
    card_1, nin = analyze_moder_card_1(env.next(card_iter), module)
    # Card 2 and 3 should only be defined if abs(nin) is in the range [1,19].
    if abs(nin) in range(1,20):
        analyze_moder_card_2(env.next(card_iter), module)
        # The number of card 3's cannot be predicted, need to count 'em.
        number_of_card_3 = len(env.get_cards('card_3', module))
        # Need at least two card 3's? One to indicate the next material and
        # one to terminate the moder run.
        if number_of_card_3 < 2:
            rule.too_few_cards_defined(number_of_card_3, 2, 'card_3', module)
        # The last card 3 should not be considered as a next material to
        # process, since it is expected to terminate the execution of moder.
        # Therefore, 'number_of_card_3-1' is used to create the range to
        # iterate over.
        for c3 in range(number_of_card_3-1):
            analyze_moder_card_3(env.next(card_iter), module)
        # The last card is expected to be a card 3 with nin = 0, to indicate
        # termination of moder.
        analyze_moder_card_3_stop(env.next(card_iter), module)
    # No more cards are allowed. The next card returned by env.next(card_iter)
    # should be 'None'.
    rule.no_card_allowed(env.next(card_iter), module)
    return module

def analyze_thermr_card_list(module):
    card_iter = env.get_card_iterator(module)
    analyze_thermr_card_1(env.next(card_iter), module)
    card_2, ntemp = analyze_thermr_card_2(env.next(card_iter), module)
    analyze_thermr_card_3(ntemp, env.next(card_iter), module)
    analyze_thermr_card_4(env.next(card_iter), module)
    rule.no_card_allowed(env.next(card_iter), module)
    return module

def analyze_card_1(card, module):
    rule.card_must_be_defined('card_1', card, module, None)
    stmt_iter = env.get_statement_iterator(card)
    order_map = unresr_settings.card_1_order_map
    for i in range(len(order_map)):
        rule.analyze_statement(order_map.get(i), env.next(stmt_iter), card, module)
    rule.no_statement_allowed(env.next(stmt_iter), card, module)
    return card

def analyze_card_7(card, module):
    rule.card_must_be_defined('card_7', card, module, None)
    stmt_iter = env.get_statement_iterator(card)
    order_map = gaminr_settings.card_7_order_map
    rule.analyze_statement(order_map.get(0), env.next(stmt_iter), card, module)
    rule.no_statement_allowed(env.next(stmt_iter), card, module)
    matd = env.get_identifier_value('matd', order_map, card)
    return card, matd

def analyze_plotr_card_1(card, module):
    rule.card_must_be_defined('card_1', card, module, None)
    stmt_iter = env.get_statement_iterator(card)
    order_map = plotr_settings.card_1_order_map
    for i in range(len(order_map)):
        rule.analyze_statement(order_map.get(i), env.next(stmt_iter), card, module)
    rule.no_statement_allowed(env.next(stmt_iter), card, module)
    lori = env.get_identifier_value('lori', order_map, card)
    return card, lori

def analyze_reconr_card_4(card, module):
    msg = ('\'card_4\' must be defined for each material desired (card 3)')
    rule.card_must_be_defined('card_4', card, module, msg)
    stmt_iter = env.get_statement_iterator(card)
    order_map = reconr_settings.card_4_order_map
    for i in range(len(order_map)):
        rule.analyze_statement(order_map.get(i), env.next(stmt_iter), card, module)
    rule.no_statement_allowed(env.next(stmt_iter), card, module)
    return card

def analyze_errorr_card_2(card, module):
    rule.card_must_be_defined('card_2', card, module, None)
    stmt_iter = env.get_statement_iterator(card)
    order_map = errorr_settings.card_2_order_map
    for i in range(len(order_map)):
        rule.analyze_statement(order_map.get(i), env.next(stmt_iter), card, module)
    rule.no_statement_allowed(env.next(stmt_iter), card, module)
    ign = env.get_identifier_value('ign', order_map, card)
    return card, ign

def analyze_covr_card_3c(card, module):
    msg = ('expected \'card_3c\' since nout > 0 in \'card_1\'.')
    rule.card_must_be_defined('card_3c', card, module, msg)
    stmt_iter = env.get_statement_iterator(card)
    order_map = covr_settings.card_3c_order_map
    for i in range(len(order_map)):
        rule.analyze_statement(order_map.get(i), env.next(stmt_iter), card, module)
    rule.no_statement_allowed(env.next(stmt_iter), card, module)
    return card

def analyze_plotr_card_10(card, module):
    # XXX: Provide a descriptive message of why card 10 should be supplied.
    rule.card_must_be_defined('card_10', card, module, None)
    stmt_iter = env.get_statement_iterator(card)
    order_map = plotr_settings.card_10_order_map
    for i in range(len(order_map)):
        rule.analyze_statement(order_map.get(i), env.next(stmt_iter), card, module)
    rule.no_statement_allowed(env.next(stmt_iter), card, module)
    return card

def analyze_reconr_card_3(card, module):
    rule.card_must_be_defined('card_3', card, module, None)
    stmt_iter = env.get_statement_iterator(card)
    order_map = reconr_settings.card_3_order_map
    for i in range(len(order_map)):
        rule.analyze_statement(order_map.get(i), env.next(stmt_iter), card, module)
    rule.no_statement_allowed(env.next(stmt_iter), card, module)
    ncards = env.get_identifier_value('ncards', order_map, card)
    ngrid = env.get_identifier_value('ngrid', order_map, card)
    return card, ncards, ngrid

def analyze_reconr_card_6(ngrid, card, module):
    msg = ('expected ' + str(ngrid) + ' \'card_6\'s, since ' +
           'ngrid = ' + str(ngrid) + ' in the current \'card_3\'.')
    rule.card_must_be_defined('card_6', card, module, msg)
    stmt_iter = env.get_statement_iterator(card)
    order_map = reconr_settings.card_6_order_map
    for i in range(len(order_map)):
        rule.analyze_statement(order_map.get(i), env.next(stmt_iter), card, module)
    rule.no_statement_allowed(env.next(stmt_iter), card, module)
    return card

def analyze_moder_card_3(card, module):
    msg = ('expected \'card_3\' since the absolute value of the input unit ' +
           '(\'nin\') is in the range [1,19] in \'card_1\'.')
    rule.card_must_be_defined('card_3', card, module, msg)
    stmt_iter = env.get_statement_iterator(card)
    order_map = moder_settings.card_3_order_map
    for i in range(len(order_map)):
        rule.analyze_statement(order_map.get(i), env.next(stmt_iter), card, module)
    rule.no_statement_allowed(env.next(stmt_iter), card, module)
    return card

def analyze_covr_card_3a(card, module):
    msg = ('expected \'card_3a\' since nout <= 0 in \'card_1\'.')
    rule.card_must_be_defined('card_3a', card, module, msg)
    stmt_iter = env.get_statement_iterator(card)
    order_map = covr_settings.card_3a_order_map
    for i in range(len(order_map)):
        rule.analyze_statement(order_map.get(i), env.next(stmt_iter), card, module)
    rule.no_statement_allowed(env.next(stmt_iter), card, module)
    ncase = env.get_identifier_value('ncase', order_map, card)
    return card, ncase

def analyze_card_2(card, module):
    rule.card_must_be_defined('card_2', card, module, None)
    stmt_iter = env.get_statement_iterator(card)
    order_map = unresr_settings.card_2_order_map
    for i in range(len(order_map)):
        rule.analyze_statement(order_map.get(i), env.next(stmt_iter), card, module)
    rule.no_statement_allowed(env.next(stmt_iter), card, module)
    ntemp = env.get_identifier_value('ntemp', order_map, card)
    nsigz = env.get_identifier_value('nsigz', order_map, card)
    return card, ntemp, nsigz

def analyze_plotr_card_6a(card, module):
    msg = ('expected \'card_6a\' since the plot index (\'iplot\') is 1 or ' +
           '-1 in \'card_2\'.')
    rule.card_must_be_defined('card_6a', card, module, msg)
    stmt_iter = env.get_statement_iterator(card)
    order_map = plotr_settings.card_6a_order_map
    for i in range(len(order_map)):
        rule.analyze_statement(order_map.get(i), env.next(stmt_iter), card, module)
    rule.no_statement_allowed(env.next(stmt_iter), card, module)
    return card

def analyze_groupr_card_8d(card, module):
    # Note that card 8d should only be defined if iwt = 0 in card_2, check if
    # it is before calling this function.
    msg = ('expected \'card_8d\' since iwt = 0 in \'card_2\'')
    rule.card_must_be_defined('card_8d', card, module, msg)
    stmt_iter = env.get_statement_iterator(card)
    order_map = groupr_settings.card_8d_order_map
    for i in range(len(order_map)):
        rule.analyze_statement(order_map.get(i), env.next(stmt_iter), card, module)
    rule.no_statement_allowed(env.next(stmt_iter), card, module)
    return card

def analyze_plotr_card_12(card, module):
    msg = ('expected \'card_12\' since the ENDF version (\'iverf\') is 0 ' +
           'in \'card_8\'.')
    rule.card_must_be_defined('card_12', card, module, msg)
    stmt_iter = env.get_statement_iterator(card)
    order_map = plotr_settings.card_12_order_map
    for i in range(len(order_map)):
        rule.analyze_statement(order_map.get(i), env.next(stmt_iter), card, module)
    rule.no_statement_allowed(env.next(stmt_iter), card, module)
    nform = env.get_identifier_value('nform', order_map, card)
    return card, nform