new_contents: #!/usr/bin/env python3
  
  import json
  import random
  import math
  
  # Generate a complete coverage test case based on core/res/encodings.json
  
  def construct(opname, regs, gen_list):
      output = []
      # Recurse downward until there is just one field in gen_list. Use that to generate a base
      # encoding, and then step out. Now a 2nd field in gen_list will apply all of its encodings
      # to the array, in addition to adding many more entries.
      partial = [] if len(gen_list) == 1 else construct(opname, regs, gen_list[0:-1])
  
      hi = gen_list[-1]['hi']
      lo = gen_list[-1]['lo']
      values = gen_list[-1]['values']
      is_reg = gen_list[-1]['is_reg']
      display = gen_list[-1]['display']
  
      for value in values:
          bits = (value & ((1 << (hi - lo + 1)) - 1)) << lo
          if len(gen_list) == 1:
              encoded = bits
              decoded = opname
              output.append((encoded, decoded))
          else:
              for part in partial:
                  encoded = part[0] | bits
                  decoded = part[1]
                  if display: decoded += ' ' + (regs[value] if is_reg else '%d' % value)
                  output.append((encoded, decoded))
  
      return output
  
  def main():
      with open('../core/res/encodings.json') as config_file:
          config = json.load(config_file)
  
      # Find the instructions and register listing
      regs = list(filter(lambda x: x['type'] == 'REGS', config))[0]['data']['reglist']
      insts = filter(lambda x: x['type'] == 'INST', config)
  
      with open('comprehensive_test.asm', 'w') as output:
          # Instruction permutations are independent of other instructions
          for inst in insts:
              opname = inst['data']['label']
              enc_parts = inst['data']['enc']
              # gen_list contains the target values for each of the fields in the instruction.
              # For example, for a register add instruction, the core of the gen_list array would look like:
              #    [{display: True , hi: 11, lo: 9 , pos: 0 , is_reg: True , values: [0, 1, ..., 7]},
              #     {display: True , hi: 8 , lo: 6 , pos: 1 , is_reg: True , values: [0, 1, ..., 7]},
              #     {display: True , hi: 2 , lo: 0 , pos: 2 , is_reg: True , values: [0, 1, ..., 7]},
              #     {display: False, hi: 15, lo: 12, pos: -1, is_reg: False, values: [1]},
              #     {display: False, hi: 5 , lo: 3 , pos: -1, is_reg: False, values: [0]}]
              #
              # Once the target values have been generated, the construct function generates all permutations
              # of the values to get complete coverage of the instruction.
              gen_list = []
  
              # Go through the encoding parts
              for enc_part in inst['data']['enc']:
                  # Check if the field is predetermined (OPCODE and FIXED types) or not
                  if enc_part['type'] != 'OPCODE' and enc_part['type'] != 'FIXED':
                      size = enc_part['hi'] - enc_part['lo'] + 1
                      is_reg = enc_part['type'] == 'REG'
                      pos = enc_part['data']['pos']
                      values = []
  
                      # Iterate over all possible values of the field and append them to a list
                      # This assumes all immediates can be signed
                      for i in range(0, 1 << size):
                          values.append(i - (1 << (size - 1)))
                      gen_list.append({'display': True, 'hi': enc_part['hi'], 'lo': enc_part['lo'], 'pos': pos, 'is_reg': is_reg, 'values': values})
                  else:
                      gen_list.append({'display': False, 'hi': enc_part['hi'], 'lo': enc_part['lo'], 'pos': -1, 'is_reg': False, 'values': [int(enc_part['data']['value'], 2)]})
              gen_list.sort(key=lambda x: x['pos'])
              instructions = construct(opname, regs, gen_list)
              for (encoded, decoded) in instructions:
                  output.write('0x%04x %s\n' % (encoded, decoded))
  
  if __name__ == '__main__':
      main()
  
subject: Add asm test generator