| abx_inherent_3a/3* | ABX Instruction. |
| accumulator_offset_from_r_a_accumulator/4* | Uses Register R which is encoded in the post-byte. |
| accumulator_offset_from_r_a_accumulator_address_only/4* | Uses Register R which is encoded in the post-byte. |
| accumulator_offset_from_r_b_accumulator/4* | Uses Register R which is encoded in the post-byte. |
| accumulator_offset_from_r_b_accumulator_address_only/4* | Uses Register R which is encoded in the post-byte. |
| accumulator_offset_from_r_d_accumulator/4* | Uses Register R which is encoded in the post-byte. |
| accumulator_offset_from_r_d_accumulator_address_only/4* | Uses Register R which is encoded in the post-byte. |
| accumulator_offset_from_r_e_accumulator/4* | Uses Register R which is encoded in the post-byte. |
| accumulator_offset_from_r_e_accumulator_address_only/4* | Uses Register R which is encoded in the post-byte. |
| accumulator_offset_from_r_f_accumulator/4* | Uses Register R which is encoded in the post-byte. |
| accumulator_offset_from_r_f_accumulator_address_only/4* | Uses Register R which is encoded in the post-byte. |
| accumulator_offset_from_r_w_accumulator/4* | Uses Register R which is encoded in the post-byte. |
| accumulator_offset_from_r_w_accumulator_address_only/4* | Uses Register R which is encoded in the post-byte. |
| adc_generic_part/7* | ADC Instruction (8 Bit). |
| adca_direct_99/3* | ADC(A). |
| adca_extended_b9/3* | ADC(A). |
| adca_immediate_89/3* | ADC(A). |
| adca_indexed_a9/3* | ADC(A). |
| adcb_direct_d9/3* | ADC(B). |
| adcb_extended_f9/3* | ADC(B). |
| adcb_immediate_c9/3* | ADC(B). |
| adcb_indexed_e9/3* | ADC(B). |
| adcd_direct_1099/3* | ADCD (6309 ONLY). |
| adcd_extended_10b9/3* | ADCD (6309 ONLY). |
| adcd_generic_part/5* | |
| adcd_immediate_1089/3* | ADCD (6309 ONLY). |
| adcd_indexed_10a9/3* | ADCD (6309 ONLY). |
| adcr_immediate_1031/3* | ADCR (6309 ONLY). |
| add_generic_part/7* | ADD Generic Part (8 and 16 Bit). |
| adda_direct_9b/3* | ADD (8-bit). |
| adda_extended_bb/3* | ADD (8-bit). |
| adda_immediate_8b/3* | ADD (8-bit). |
| adda_indexed_ab/3* | ADD (8-bit). |
| addb_direct_db/3* | ADD (8-bit). |
| addb_extended_fb/3* | ADD (8-bit). |
| addb_immediate_cb/3* | ADD (8-bit). |
| addb_indexed_eb/3* | ADD (8-bit). |
| addd_direct_d3/3* | ADD (16-bit). |
| addd_extended_f3/3* | ADD (16-bit). |
| addd_immediate_c3/3* | ADD (16-bit). |
| addd_indexed_e3/3* | ADD (16-bit). |
| adde_direct_119b/3* | ADD (8-bit). |
| adde_extended_11bb/3* | ADD (8-bit). |
| adde_immediate_118b/3* | ADD (8-bit). |
| adde_indexed_11ab/3* | ADD (8-bit). |
| addf_direct_11db/3* | ADD (8-bit). |
| addf_extended_11fb/3* | ADD (8-bit). |
| addf_immediate_11cb/3* | ADD (8-bit). |
| addf_indexed_11eb/3* | ADD (8-bit). |
| addr_immediate_1030/3* | ADDR (6309 ONLY). |
| addw_direct_109b/3* | ADD (16-bit). |
| addw_extended_10bb/3* | ADD (16-bit). |
| addw_immediate_108b/3* | ADD (16-bit). |
| addw_indexed_10ab/3* | ADD (16-bit). |
| aim_direct_02/3* | AIM (6309 Only). |
| aim_extended_72/3* | AIM (6309 Only). |
| aim_generic_part/7* | AIM (6309 Only). |
| aim_indexed_62/3* | AIM (6309 Only). |
| and_generic_part/7* | AND (8-BIT). |
| anda_direct_94/3* | AND (8-BIT). |
| anda_extended_b4/3* | AND (8-BIT). |
| anda_immediate_84/3* | AND (8-BIT). |
| anda_indexed_a4/3* | AND (8-BIT). |
| andb_direct_d4/3* | AND (8-BIT). |
| andb_extended_f4/3* | AND (8-BIT). |
| andb_immediate_c4/3* | AND (8-BIT). |
| andb_indexed_e4/3* | AND (8-BIT). |
| andcc_immediate_1c/3* | ANDCC. |
| andd_direct_1094/3* | ANDD (6309). |
| andd_extended_10b4/3* | ANDD (6309). |
| andd_generic_part/5* | ANDD (6309). |
| andd_immediate_1084/3* | ANDD (6309). |
| andd_indexed_10a4/3* | ANDD (6309). |
| andr_immediate_1034/3* | ANDR (6309). |
| asl_direct_08/3* | |
| asl_extended_78/3* | |
| asl_generic_part/6* | |
| asl_indexed_68/3* | |
| asla_inherent_48/3* | |
| aslb_inherent_58/3* | |
| asld_inherent_1048/3* | |
| asr_direct_07/3* | |
| asr_extended_77/3* | |
| asr_generic_part/6* | |
| asr_indexed_67/3* | |
| asra_inherent_47/3* | |
| asrb_inherent_57/3* | |
| asrd_inherent_1047/3* | |
| auto_decrement_of_r_pre_decrement_by_1/4* | Uses Register R which is encoded in the post-byte. |
| auto_decrement_of_r_pre_decrement_by_1_address_only/4* | Uses Register R which is encoded in the post-byte. |
| auto_decrement_of_r_pre_decrement_by_2/4* | Uses Register R which is encoded in the post-byte. |
| auto_decrement_of_r_pre_decrement_by_2_address_only/4* | Uses Register R which is encoded in the post-byte. |
| auto_decrement_of_w_pre_decrement_by_2/4* | Uses Register W. |
| auto_decrement_of_w_pre_decrement_by_2_address_only/4* | Uses Register W. |
| auto_increment_of_r_post_increment_by_1/4* | Uses Register R which is encoded in the post-byte. |
| auto_increment_of_r_post_increment_by_1_address_only/4* | Uses Register R which is encoded in the post-byte. |
| auto_increment_of_r_post_increment_by_2/4* | Uses Register R which is encoded in the post-byte. |
| auto_increment_of_r_post_increment_by_2_address_only/4* | Uses Register R which is encoded in the post-byte. |
| auto_increment_of_w_post_increment_by_2/4* | Uses Register W. |
| auto_increment_of_w_post_increment_by_2_address_only/4* | Uses Register W. |
| band_direct_1130/3* | |
| band_reg_name_decode/1* | |
| bcc_relative_24/3* | |
| bcs_relative_25/3* | |
| beor_direct_1134/3* | |
| beq_relative_27/3* | |
| bge_relative_2c/3* | |
| bgt_relative_2e/3* | |
| bhi_relative_22/3* | |
| bhs_relative_24/3* | |
| biand_direct_1131/3* | |
| bieor_direct_1135/3* | |
| bior_direct_1133/3* | |
| bit_generic_part/6* | |
| bita_direct_95/3* | |
| bita_extended_b5/3* | |
| bita_immediate_85/3* | |
| bita_indexed_a5/3* | |
| bitb_direct_d5/3* | |
| bitb_extended_f5/3* | |
| bitb_immediate_c5/3* | |
| bitb_indexed_e5/3* | |
| bitd_direct_1095/3* | |
| bitd_extended_10b5/3* | |
| bitd_immediate_1085/3* | |
| bitd_indexed_10a5/3* | |
| bitmd_immediate_113c/3* | |
| ble_relative_2f/3* | |
| blo_relative_25/3* | |
| bls_relative_23/3* | |
| blt_relative_2d/3* | |
| bmi_relative_2b/3* | |
| bne_relative_26/3* | |
| bor_direct_1132/3* | |
| bpl_relative_2a/3* | |
| bra_relative_20/3* | |
| brn_relative_21/3* | |
| bsr_relative_8d/3* | |
| bvc_relative_28/3* | |
| bvs_relative_29/3* | |
| check_cc_status_update/4* | Checks if Key (atom) is in the Map. |
| clr_direct_0f/3* | |
| clr_extended_7f/3* | |
| clr_generic_part/5* | |
| clr_indexed_6f/3* | |
| clra_inherent_4f/3* | |
| clrb_inherent_5f/3* | |
| clrd_inherent_104f/3* | |
| clre_inherent_114f/3* | |
| clrf_inherent_115f/3* | |
| clrw_inherent_105f/3* | |
| cmp_generic_part/6* | |
| cmpa_direct_91/3* | |
| cmpa_extended_b1/3* | |
| cmpa_immediate_81/3* | |
| cmpa_indexed_a1/3* | |
| cmpb_direct_d1/3* | |
| cmpb_extended_f1/3* | |
| cmpb_immediate_c1/3* | |
| cmpb_indexed_e1/3* | |
| cmpd_direct_0093/3* | |
| cmpd_extended_00b3/3* | |
| cmpd_immediate_0083/3* | |
| cmpd_indexed_00a3/3* | |
| cmpe_direct_1191/3* | |
| cmpe_extended_11b1/3* | |
| cmpe_immediate_1181/3* | |
| cmpe_indexed_11a1/3* | |
| cmpf_direct_11d1/3* | |
| cmpf_extended_11f1/3* | |
| cmpf_immediate_11c1/3* | |
| cmpf_indexed_11e1/3* | |
| cmpr_immediate_1037/3* | |
| cmps_direct_019C/3* | |
| cmps_extended_01bc/3* | |
| cmps_immediate_018C/3* | |
| cmps_indexed_01ac/3* | |
| cmpu_direct_0193/3* | |
| cmpu_extended_01b3/3* | |
| cmpu_immediate_0183/3* | |
| cmpu_indexed_01a3/3* | |
| cmpw_direct_0091/3* | |
| cmpw_extended_00b1/3* | |
| cmpw_immediate_0081/3* | |
| cmpw_indexed_00a1/3* | |
| cmpx_direct_9c/3* | |
| cmpx_extended_bc/3* | |
| cmpx_immediate_8c/3* | |
| cmpx_indexed_ac/3* | |
| cmpy_direct_009c/3* | |
| cmpy_extended_00bc/3* | |
| cmpy_immediate_008c/3* | |
| cmpy_indexed_00ac/3* | |
| com_generic_part/6* | |
| constant_offset_from_pc_16_bit_offset/4* | Uses Register PC. |
| constant_offset_from_pc_16_bit_offset_address_only/4* | Uses Register PC. |
| constant_offset_from_pc_8_bit_offset/4* | Uses Register PC. |
| constant_offset_from_pc_8_bit_offset_address_only/4* | Uses Register PC. |
| constant_offset_from_r_16_bit_offset/4* | Uses Register R which is encoded in the post-byte. |
| constant_offset_from_r_16_bit_offset_address_only/4* | Uses Register R which is encoded in the post-byte. |
| constant_offset_from_r_5_bit_offset_direct/4* | Uses Register R which is encoded in the post-byte. |
| constant_offset_from_r_5_bit_offset_direct_address_only/4* | Uses Register R which is encoded in the post-byte. |
| constant_offset_from_r_8_bit_offset/4* | Uses Register R which is encoded in the post-byte. |
| constant_offset_from_r_8_bit_offset_address_only/4* | Uses Register R which is encoded in the post-byte. |
| constant_offset_from_r_no_offset/4* | Uses Register R which is encoded in the post-byte. |
| constant_offset_from_r_no_offset_address_only/4* | Uses Register R which is encoded in the post-byte. |
| constant_offset_from_w_16_bit_offset/4* | Uses Register W. |
| constant_offset_from_w_16_bit_offset_address_only/4* | Uses Register W. |
| constant_offset_from_w_no_offset/4* | Uses Register W. |
| constant_offset_from_w_no_offset_address_only/4* | Uses Register W. |
| cpu_clear/0* | |
| cpu_get_a/1* | Gets the A Register bits from CPU_Data. |
| cpu_get_b/1* | Gets the B Register bits from CPU_Data. |
| cpu_get_cc/1* | Gets the CC Register bits from CPU_Data. |
| cpu_get_cc_c/1* | Gets the CC Register C bit from CPU_Data. |
| cpu_get_cc_e/1* | Gets the CC Register E bit from CPU_Data. |
| cpu_get_cc_f/1* | Gets the CC Register F bit from CPU_Data. |
| cpu_get_cc_h/1* | Gets the CC Register H bit from CPU_Data. |
| cpu_get_cc_i/1* | Gets the CC Register I bit from CPU_Data. |
| cpu_get_cc_n/1* | Gets the CC Register N bit from CPU_Data. |
| cpu_get_cc_v/1* | Gets the CC Register V bit from CPU_Data. |
| cpu_get_cc_z/1* | Gets the CC Register Z bit from CPU_Data. |
| cpu_get_d/1* | Gets the D Register bits from CPU_Data. |
| cpu_get_dp/1* | Gets the DP Register bits from CPU_Data. |
| cpu_get_e/1* | Gets the E Register bits from CPU_Data. |
| cpu_get_f/1* | Gets the F Register bits from CPU_Data. |
| cpu_get_firq/1* | Gets the FIRQ bit from CPU_Data. |
| cpu_get_halt/1* | Gets the HALT bit from CPU_Data. |
| cpu_get_irq/1* | Gets the IRQ bit from CPU_Data. |
| cpu_get_md/1* | Gets the MD Register bits from CPU_Data. |
| cpu_get_md_div0/1* | Gets the MD Register DIV0 bit from CPU_Data. |
| cpu_get_md_fm/1* | Gets the MD Register FM bit from CPU_Data. |
| cpu_get_md_il/1* | Gets the MD Register IL bit from CPU_Data. |
| cpu_get_md_nm/1* | Gets the MD Register NM bit from CPU_Data. |
| cpu_get_nmi/1* | Gets the NMI bit from CPU_Data. |
| cpu_get_pc/1* | Gets the PC Register bits from CPU_Data. |
| cpu_get_q/1* | Gets the Q Register bits from CPU_Data. |
| cpu_get_reserved/1* | Gets the RESERVED bit from CPU_Data. |
| cpu_get_reset/1* | Gets the RESET bit from CPU_Data. |
| cpu_get_s/1* | Gets the S Register bits from CPU_Data. |
| cpu_get_swi/1* | Gets the SWI bit from CPU_Data. |
| cpu_get_swi2/1* | Gets the SWI2 bit from CPU_Data. |
| cpu_get_swi3/1* | Gets the SWI3 bit from CPU_Data. |
| cpu_get_u/1* | Gets the U Register bits from CPU_Data. |
| cpu_get_v/1* | Gets the V Register bits from CPU_Data. |
| cpu_get_w/1* | Gets the W Register bits from CPU_Data. |
| cpu_get_x/1* | Gets the X Register bits from CPU_Data. |
| cpu_get_y/1* | Gets the Y Register bits from CPU_Data. |
| cpu_get_zero/1* | Gets the Zero Register bits from CPU_Data. |
| cpu_perform_actions/1* | Performs a list of actions on the CPU. |
| cpu_perform_actions/2* | |
| cpu_set_a/2* | Sets the A Register in CPU_Data. |
| cpu_set_b/2* | Sets the B Register in CPU_Data. |
| cpu_set_cc/2* | Sets the CC Register in CPU_Data. |
| cpu_set_cc_c/2* | Sets the CC Register C Bit in CPU_Data. |
| cpu_set_cc_e/2* | Sets the CC Register E Bit in CPU_Data. |
| cpu_set_cc_f/2* | Sets the CC Register F Bit in CPU_Data. |
| cpu_set_cc_h/2* | Sets the CC Register H Bit in CPU_Data. |
| cpu_set_cc_i/2* | Sets the CC Register I Bit in CPU_Data. |
| cpu_set_cc_n/2* | Sets the CC Register N Bit in CPU_Data. |
| cpu_set_cc_v/2* | Sets the CC Register V Bit in CPU_Data. |
| cpu_set_cc_z/2* | Sets the CC Register Z Bit in CPU_Data. |
| cpu_set_d/2* | Sets the D Register in CPU_Data. |
| cpu_set_dp/2* | Sets the DP Register in CPU_Data. |
| cpu_set_e/2* | Sets the E Register in CPU_Data. |
| cpu_set_f/2* | Sets the F Register in CPU_Data. |
| cpu_set_firq/2* | Sets the FIRQ bit in CPU_Data. |
| cpu_set_halt/2* | Sets the HALT bit in CPU_Data. |
| cpu_set_irq/2* | Sets the IRQ bit in CPU_Data. |
| cpu_set_md/2* | Sets the MD Register in CPU_Data. |
| cpu_set_md_div0/2* | Sets the MD Register DIV0 Bit in CPU_Data. |
| cpu_set_md_fm/2* | Sets the MD Register FM Bit in CPU_Data. |
| cpu_set_md_il/2* | Sets the MD Register IL Bit in CPU_Data. |
| cpu_set_md_nm/2* | Sets the MD Register NM Bit in CPU_Data. |
| cpu_set_nmi/2* | Sets the NMI bit in CPU_Data. |
| cpu_set_pc/2* | Sets the PC Register in CPU_Data. |
| cpu_set_q/2* | Sets the Q Register in CPU_Data. |
| cpu_set_reserved/2* | Sets the RESERVED bit in CPU_Data. |
| cpu_set_reset/2* | Sets the Reset bit in CPU_Data. |
| cpu_set_s/2* | Sets the S Register in CPU_Data. |
| cpu_set_swi/2* | Sets the SWI bit in CPU_Data. |
| cpu_set_swi2/2* | Sets the SWI2 bit in CPU_Data. |
| cpu_set_swi3/2* | Sets the SWI3 bit in CPU_Data. |
| cpu_set_u/2* | Sets the U Register in CPU_Data. |
| cpu_set_v/2* | Sets the V Register in CPU_Data. |
| cpu_set_w/2* | Sets the W Register in CPU_Data. |
| cpu_set_x/2* | Sets the X Register in CPU_Data. |
| cpu_set_y/2* | Sets the Y Register in CPU_Data. |
| cpu_set_zero/2* | Sets the ZERO Register in CPU_Data. |
| decode_inter_register_actual_source/3* | Decodes the Inter Register actual source value. |
| decode_inter_register_bits/1* | Decode an Inter Register Bit encoding to the corresponding register name (atom). |
| decode_inter_register_post_byte/1* | Decodes the inter register names from a post byte. |
| direct_1_address/3* | Get the value (8-bit) from a direct request. |
| direct_1_address_address_only/3* | Get the address only from a direct request. |
| direct_2_address/3* | Get the value (16-bit) from a direct request. |
| direct_2_address_address_only/3* | Get the address only from a direct request. |
| dont_care/0* | |
| execution/2* | |
| extended_indirect_16_bit_address/4* | Used 16-bit address value from after the post-byte. |
| extended_indirect_16_bit_address_address_only/4* | Used 16-bit address value from after the post-byte. |
| generate_n_z_flags_map/1* | Get the flag map of the value for n and z flags. |
| get_byte_pos/2* | |
| get_lower_8_reg_16/1* | Extracts the lower 8 bytes of a 16 bit register. |
| get_n_flag_of_value/1* | Get the Negative Flag from a value. |
| get_register_from_name/2* | Gets the Register based on name (atom). |
| get_size_of_register/1* | Get the bit size of a register (atom). |
| get_z_flag_of_value/1* | Get the Zero Flag from a value. |
| immediate_1_address/3* | Get the immediate data (8-bit) at pos from the Data. |
| immediate_2_address/3* | Get the immediate data (16-bit) at pos from the Data. |
| index_reg_set_value/3* | Set a value to a register determined by RR encoding. |
| index_reg_value/2* | Extracts the value of the encode Register RR from the provided CPU_Data. |
| indexed_1_address/3* | |
| indexed_1_address_address_only/3* | |
| indexed_2_address/3* | |
| indexed_2_address_address_only/3* | |
| indexed_address/4* | |
| indexed_address_address_only/4* | |
| pc_1_inc/1* | Takes a CPU_Data and increases the PC value by 1. |
| pc_2_inc/1* | Takes a CPU_Data and increases the PC value by 2. |
| pos_inc/1* | Increase the POS Address by one. |
| pos_inc2/1* | Increase the POS Address by two. |
| pos_inc_n/2* | Increase the POS Address by N. |
| post_byte_16_offset_pc_direct/1* | Generates a Post-Byte for Indexed 16-bit Offset from PC Direct Addressing. |
| post_byte_16_offset_pc_indirect/1* | Generates a Post-Byte for Indexed 16-bit Offset from PC Indirect Addressing. |
| post_byte_8_offset_pc_direct/1* | Generates a Post-Byte for Indexed 8-bit Offset from PC Direct Addressing. |
| post_byte_8_offset_pc_indirect/1* | Generates a Post-Byte for Indexed 8-bit Offset from PC Indirect Addressing. |
| post_byte_extended_16_address_indirect/1* | Generates a Post-Byte for Extended 16-bit Offset Indirect Addressing. |
| post_byte_indexed_16_offset_r_direct/2* | Generates a Post-Byte for Indexed 16-bit Offset from R Direct Addressing. |
| post_byte_indexed_16_offset_r_indirect/2* | Generates a Post-Byte for Indexed 16-bit Offset from R Indirect Addressing. |
| post_byte_indexed_16_offset_w_direct/1* | Generates a Post-Byte for Indexed 16-bit Offset from W Direct Addressing. |
| post_byte_indexed_16_offset_w_indirect/1* | Generates a Post-Byte for Indexed 16-bit Offset from W Indirect Addressing. |
| post_byte_indexed_5_offset_r_direct/2* | Generates a Post-Byte for Indexed 5-bit Offset from R Direct Addressing. |
| post_byte_indexed_8_offset_r_direct/2* | Generates a Post-Byte for Indexed 8-bit Offset from R Direct Addressing. |
| post_byte_indexed_8_offset_r_indirect/2* | Generates a Post-Byte for Indexed 8-bit Offset from R Indirect Addressing. |
| post_byte_indexed_a_offset_r_direct/1* | Generates a Post-Byte for Register A Offset from R Direct Addressing. |
| post_byte_indexed_a_offset_r_indirect/1* | Generates a Post-Byte for Register A Offset from R Indirect Addressing. |
| post_byte_indexed_b_offset_r_direct/1* | Generates a Post-Byte for Register B Offset from R Direct Addressing. |
| post_byte_indexed_b_offset_r_indirect/1* | Generates a Post-Byte for Register B Offset from R Indirect Addressing. |
| post_byte_indexed_d_offset_r_direct/1* | Generates a Post-Byte for Register D Offset from R Direct Addressing. |
| post_byte_indexed_d_offset_r_indirect/1* | Generates a Post-Byte for Register D Offset from R Indirect Addressing. |
| post_byte_indexed_e_offset_r_direct/1* | Generates a Post-Byte for Register E Offset from R Direct Addressing. |
| post_byte_indexed_e_offset_r_indirect/1* | Generates a Post-Byte for Register E Offset from R Indirect Addressing. |
| post_byte_indexed_f_offset_r_direct/1* | Generates a Post-Byte for Register F Offset from R Direct Addressing. |
| post_byte_indexed_f_offset_r_indirect/1* | Generates a Post-Byte for Register F Offset from R Indirect Addressing. |
| post_byte_indexed_no_offset_r_direct/1* | Generates a Post-Byte for Indexed No Offset from R Direct Addressing. |
| post_byte_indexed_no_offset_r_indirect/1* | Generates a Post-Byte for Indexed No Offset from R Indirect Addressing. |
| post_byte_indexed_no_offset_w_direct/0* | Generates a Post-Byte for Indexed No Offset from W Direct Addressing. |
| post_byte_indexed_no_offset_w_indirect/0* | Generates a Post-Byte for Indexed No Offset from W Indirect Addressing. |
| post_byte_indexed_w_offset_r_direct/1* | Generates a Post-Byte for Register W Offset from R Direct Addressing. |
| post_byte_indexed_w_offset_r_indirect/1* | Generates a Post-Byte for Register W Offset from R Indirect Addressing. |
| post_byte_post_increment_1_r_direct/1* | Generates a Post-Byte for Post Increment 1 of R Direct Addressing. |
| post_byte_post_increment_2_r_direct/1* | Generates a Post-Byte for Post Increment 2 of R Direct Addressing. |
| post_byte_post_increment_2_r_indirect/1* | Generates a Post-Byte for Post Increment 2 of R Indirect Addressing. |
| post_byte_post_increment_2_w_direct/0* | Generates a Post-Byte for Post Increment 2 of W Direct Addressing. |
| post_byte_post_increment_2_w_indirect/0* | Generates a Post-Byte for Post Increment 2 of W Indirect Addressing. |
| post_byte_pre_decrement_1_r_direct/1* | Generates a Post-Byte for Pre Decrement 1 of R Direct Addressing. |
| post_byte_pre_decrement_2_r_direct/1* | Generates a Post-Byte for Pre Decrement 2 of R Direct Addressing. |
| post_byte_pre_decrement_2_r_indirect/1* | Generates a Post-Byte for Pre Decrement 2 of R Indirect Addressing. |
| post_byte_pre_decrement_2_w_direct/0* | Generates a Post-Byte for Pre Decrement 2 of W Direct Addressing. |
| post_byte_pre_decrement_2_w_indirect/0* | Generates a Post-Byte for Pre Decrement 2 of W Indirect Addressing. |
| pretty_print/1* | |
| rr_from_r/1* | Generates RR Register encoding from register name (atom). |
| set_register_from_name/3* | Set the Register based on name (atom) with value. |
| update_condition_codes_from_map/2* | Updates the conditions codes via the Map. |
abx_inherent_3a(Pos::binary(), Data::binary(), CPU_Data::binary()) -> {binary(), binary()}
ABX Instruction
Add Accumulator B to Index Register X
X' = X + ACCB
The ABX instruction performs an unsigned addition of the contents of Accumulator B
with the contents of Index Register X. The 16-bit result is placed into Index Register
X. None of the Condition Code flags are affected
---- Unit-Tested ----
accumulator_offset_from_r_a_accumulator(Pos::binary(), Data::binary(), CPU_Data::binary(), Number_Of_Bytes::non_neg_integer()) -> {binary(), binary(), binary()}
Uses Register R which is encoded in the post-byte
and an 8-bit signed value from register A
Direct mode the effective address is the value in R + 8-bit value
Indirect mode the effective address is determine by
first getting an address from the value of R + 8-bit value, and then getting
an another address from that memory location
Returns: {value, CPU_Data, New_Position}
---- Unit-Tested ----
accumulator_offset_from_r_a_accumulator_address_only(Pos::binary(), Data::binary(), CPU_Data::binary(), Number_Of_Bytes::non_neg_integer()) -> {binary(), binary(), binary()}
Uses Register R which is encoded in the post-byte
and an 8-bit signed value from register A
Direct mode the effective address is the value in R + 8-bit value
Indirect mode the effective address is determine by
first getting an address from the value of R + 8-bit value, and then getting
an another address from that memory location
Returns: {address, CPU_Data, New_Position}
---- Unit-Tested ----
accumulator_offset_from_r_b_accumulator(Pos::binary(), Data::binary(), CPU_Data::binary(), Number_Of_Bytes::non_neg_integer()) -> {binary(), binary(), binary()}
Uses Register R which is encoded in the post-byte
and an 8-bit signed value from register B
Direct mode the effective address is the value in R + 8-bit value
Indirect mode the effective address is determine by
first getting an address from the value of R + 8-bit value, and then getting
an another address from that memory location
Returns: {value, CPU_Data, New_Position}
---- Unit-Tested ----
accumulator_offset_from_r_b_accumulator_address_only(Pos::binary(), Data::binary(), CPU_Data::binary(), Number_Of_Bytes::non_neg_integer()) -> {binary(), binary(), binary()}
Uses Register R which is encoded in the post-byte
and an 8-bit signed value from register B
Direct mode the effective address is the value in R + 8-bit value
Indirect mode the effective address is determine by
first getting an address from the value of R + 8-bit value, and then getting
an another address from that memory location
Returns: {address, CPU_Data, New_Position}
---- Unit-Tested ----
accumulator_offset_from_r_d_accumulator(Pos::binary(), Data::binary(), CPU_Data::binary(), Number_Of_Bytes::non_neg_integer()) -> {binary(), binary(), binary()}
Uses Register R which is encoded in the post-byte
and an 16-bit signed value from register D
Direct mode the effective address is the value in R + 16-bit value
Indirect mode the effective address is determine by
first getting an address from the value of R + 16-bit value, and then getting
an another address from that memory location
Returns: {value, CPU_Data, New_Position}
---- Unit-Tested ----
accumulator_offset_from_r_d_accumulator_address_only(Pos::binary(), Data::binary(), CPU_Data::binary(), _Number_Of_Bytes::non_neg_integer()) -> {binary(), binary(), binary()}
Uses Register R which is encoded in the post-byte
and an 16-bit signed value from register D
Direct mode the effective address is the value in R + 16-bit value
Indirect mode the effective address is determine by
first getting an address from the value of R + 16-bit value, and then getting
an another address from that memory location
Returns: {address, CPU_Data, New_Position}
---- Unit-Tested ----
accumulator_offset_from_r_e_accumulator(Pos::binary(), Data::binary(), CPU_Data::binary(), Number_Of_Bytes::non_neg_integer()) -> {binary(), binary(), binary()}
Uses Register R which is encoded in the post-byte
and an 8-bit signed value from register E
Direct mode the effective address is the value in R + 8-bit value
Indirect mode the effective address is determine by
first getting an address from the value of R + 8-bit value, and then getting
an another address from that memory location
Returns: {value, CPU_Data, New_Position}
---- Unit-Tested ----
accumulator_offset_from_r_e_accumulator_address_only(Pos::binary(), Data::binary(), CPU_Data::binary(), Number_Of_Bytes::non_neg_integer()) -> {binary(), binary(), binary()}
Uses Register R which is encoded in the post-byte
and an 8-bit signed value from register E
Direct mode the effective address is the value in R + 8-bit value
Indirect mode the effective address is determine by
first getting an address from the value of R + 8-bit value, and then getting
an another address from that memory location
Returns: {address, CPU_Data, New_Position}
---- Unit-Tested ----
accumulator_offset_from_r_f_accumulator(Pos::binary(), Data::binary(), CPU_Data::binary(), Number_Of_Bytes::non_neg_integer()) -> {binary(), binary(), binary()}
Uses Register R which is encoded in the post-byte
and an 8-bit signed value from register F
Direct mode the effective address is the value in R + 8-bit value
Indirect mode the effective address is determine by
first getting an address from the value of R + 8-bit value, and then getting
an another address from that memory location
Returns: {value, CPU_Data, New_Position}
---- Unit-Tested ----
accumulator_offset_from_r_f_accumulator_address_only(Pos::binary(), Data::binary(), CPU_Data::binary(), Number_Of_Bytes::non_neg_integer()) -> {binary(), binary(), binary()}
Uses Register R which is encoded in the post-byte
and an 8-bit signed value from register F
Direct mode the effective address is the value in R + 8-bit value
Indirect mode the effective address is determine by
first getting an address from the value of R + 8-bit value, and then getting
an another address from that memory location
Returns: {address, CPU_Data, New_Position}
---- Unit-Tested ----
accumulator_offset_from_r_w_accumulator(Pos::binary(), Data::binary(), CPU_Data::binary(), Number_Of_Bytes::non_neg_integer()) -> {binary(), binary(), binary()}
Uses Register R which is encoded in the post-byte
and an 16-bit signed value from register W
Direct mode the effective address is the value in R + 16-bit value
Indirect mode the effective address is determine by
first getting an address from the value of R + 16-bit value, and then getting
an another address from that memory location
Returns: {value, CPU_Data, New_Position}
---- Unit-Tested ----
accumulator_offset_from_r_w_accumulator_address_only(Pos::binary(), Data::binary(), CPU_Data::binary(), Number_Of_Bytes::non_neg_integer()) -> {binary(), binary(), binary()}
Uses Register R which is encoded in the post-byte
and an 16-bit signed value from register W
Direct mode the effective address is the value in R + 16-bit value
Indirect mode the effective address is determine by
first getting an address from the value of R + 16-bit value, and then getting
an another address from that memory location
Returns: {address, CPU_Data, New_Position}
---- Unit-Tested ----
adc_generic_part(_Pos::binary(), Data::binary(), New_CPU_Data::binary(), Memory_Data::binary(), Get_Reg_Fun::function(), Set_Reg_Fun::function(), New_Pos::binary()) -> {binary(), binary()}
ADC Instruction (8 Bit)
Add Memory Byte plus Carry with Accumulator A or B
r' = r + (M) + C
These instructions add the contents of a byte in memory plus the contents of the Carry
flag with either Accumulator A or B. The 8-bit result is placed back into the specified
accumulator.
H The Half-Carry flag is set if a carry into bit 4 occurred; cleared otherwise.
N The Negative flag is set equal to the new value of bit 7 of the accumulator
Z The Zero flag is set if the new accumulator value is zero; cleared otherwise.
V The Overflow flag is set if an overflow occurred; cleared otherwise.
C The Carry flag is set if a carry out of bit 7 occured; cleared otherwise.
---- Unit-Tested ----
adca_direct_99(Pos::binary(), Data::binary(), CPU_Data::binary()) -> {binary(), binary()}
ADC(A)
See Generic Part for details
---- Unit-Tested ----
adca_extended_b9(Pos::binary(), Data::binary(), CPU_Data::binary()) -> {binary(), binary()}
ADC(A)
See Generic Part for details
---- Unit-Tested ----
adca_immediate_89(Pos::binary(), Data::binary(), CPU_Data::binary()) -> {binary(), binary()}
ADC(A)
See Generic Part for details
---- Unit-Tested ----
adca_indexed_a9(Pos::binary(), Data::binary(), CPU_Data::binary()) -> {binary(), binary()}
ADC(A)
See Generic Part for details
---- Unit-Tested ----
adcb_direct_d9(Pos::binary(), Data::binary(), CPU_Data::binary()) -> {binary(), binary()}
ADC(B)
See Generic Part for details
---- Unit-Tested ----
adcb_extended_f9(Pos::binary(), Data::binary(), CPU_Data::binary()) -> {binary(), binary()}
ADC(B)
See Generic Part for details
---- Unit-Tested ----
adcb_immediate_c9(Pos::binary(), Data::binary(), CPU_Data::binary()) -> {binary(), binary()}
ADC(B)
See Generic Part for details
---- Unit-Tested ----
adcb_indexed_e9(Pos::binary(), Data::binary(), CPU_Data::binary()) -> {binary(), binary()}
ADC(B)
See Generic Part for details
---- Unit-Tested ----
adcd_direct_1099(Pos::binary(), Data::binary(), CPU_Data::binary()) -> {binary(), binary()}
ADCD (6309 ONLY)
See Generic Part for details
---- Unit-Tested ----
adcd_extended_10b9(Pos::binary(), Data::binary(), CPU_Data::binary()) -> {binary(), binary()}
ADCD (6309 ONLY)
See Generic Part for details
---- Unit-Tested ----
adcd_generic_part(Pos, Data, New_CPU_Data, Memory_Data, New_Pos) -> any()
adcd_immediate_1089(Pos::binary(), Data::binary(), CPU_Data::binary()) -> {binary(), binary()}
ADCD (6309 ONLY)
See Generic Part for details
---- Unit-Tested ----
adcd_indexed_10a9(Pos::binary(), Data::binary(), CPU_Data::binary()) -> {binary(), binary()}
ADCD (6309 ONLY)
See Generic Part for details
---- Unit-Tested ----
adcr_immediate_1031(Pos::binary(), Data::binary(), CPU_Data::binary()) -> {binary(), binary()}
ADCR (6309 ONLY)
Add Source Register plus Carry to Destination Register
r1' = r1 + r0 + c
The ADCR instruction adds the contents of a source register plus the contents of the
Carry flag with the contents of a destination register. The result is placed into the
destination register
H The Half-Carry flag is not affected by the ADCR instruction
N The Negative flag is set equal to the value of the result's high-order bit
Z The Zero flag is set if the new value of the destination register is zero; cleared otherwise
V The Overflow flag is set if an overflow occurred; cleared otherwise.
C The Carry flag is set if a carry out of the high-order bit occured; cleared otherwise.
---- Unit-Tested ----
add_generic_part(_Pos::binary(), Data::binary(), New_CPU_Data::binary(), Memory_Data::binary(), Get_Reg_Fun::function(), Set_Reg_Fun::function(), New_Pos::binary()) -> {binary(), binary()}
ADD Generic Part (8 and 16 Bit)
----------------------------------------------------------------------------------------
ADD Instruction (8 Bit)
r' = r + (M)
These instructions add the content of a byte in memory with one of the 8-bit
accumulators (A,B,E,F). The 8-bit result is placed back into the specified accumulator
H The Half-Carry flag is set if a carry into bit 4 occurred; cleared otherwise.
N The Negative flag is set equal to the new value of bit 7 of the accumulator
Z The Zero flag is set if the new accumulator value is zero; cleared otherwise.
V The Overflow flag is set if an overflow occurred; cleared otherwise.
C The Carry flag is set if a carry out of bit 7 occured; cleared otherwise.
The 8-bit ADD instructions are used for single-byte addition, and for addition of the
least-significant byte in multi-byte additions. Since the 6x09 also provides a 16-bit ADD
instructions, it is not necessary to use the 8-bit ADD and ADC instructions for performing
16-bit addition.
----------------------------------------------------------------------------------------
ADD (16 Bit)
Add Memory Word to 16-Bit Accumulator
r' = r + (M:M+1)
These instructions add the content of a double-byte value in memory with one of the 16-bit
accumulators (D,W). The 16-bit result is placed back into the specified accumulator.
H The Half-Carry flag is not affected by these instructions.
N The Negative flag is set equal to the new value of bit 15 of the accumulator.
Z The Zero flag is set if the new accumulator value is zero; cleared otherwise.
V The Overflow flag is set if an overflow occured; cleared otherwise.
C The Carry flag is set if a carry out of bit 15 occured; cleared otherwise.
The 16-bit ADD instructions are used for double-byte addition, and for addition of the
least-significant word of multi-byte additions. See the description of the ADCD
instruction for an example of how 32-bit addition can be performed on a 6309 processor.
---- Unit-Tested ----
=======================================================================================
adda_direct_9b(Pos::binary(), Data::binary(), CPU_Data::binary()) -> {binary(), binary()}
ADD (8-bit)
See Generic Part for details
---- Unit-Tested ----
adda_extended_bb(Pos::binary(), Data::binary(), CPU_Data::binary()) -> {binary(), binary()}
ADD (8-bit)
See Generic Part for details
---- Unit-Tested ----
adda_immediate_8b(Pos::binary(), Data::binary(), CPU_Data::binary()) -> {binary(), binary()}
ADD (8-bit)
See Generic Part for details
---- Unit-Tested ----
adda_indexed_ab(Pos::binary(), Data::binary(), CPU_Data::binary()) -> {binary(), binary()}
ADD (8-bit)
See Generic Part for details
---- Unit-Tested ----
addb_direct_db(Pos::binary(), Data::binary(), CPU_Data::binary()) -> {binary(), binary()}
ADD (8-bit)
See Generic Part for details
---- Unit-Tested ----
addb_extended_fb(Pos::binary(), Data::binary(), CPU_Data::binary()) -> {binary(), binary()}
ADD (8-bit)
See Generic Part for details
---- Unit-Tested ----
addb_immediate_cb(Pos::binary(), Data::binary(), CPU_Data::binary()) -> {binary(), binary()}
ADD (8-bit)
See Generic Part for details
---- Unit-Tested ----
addb_indexed_eb(Pos::binary(), Data::binary(), CPU_Data::binary()) -> {binary(), binary()}
ADD (8-bit)
See Generic Part for details
---- Unit-Tested ----
addd_direct_d3(Pos::binary(), Data::binary(), CPU_Data::binary()) -> {binary(), binary()}
ADD (16-bit)
See Generic Part for details
---- Unit-Tested ----
addd_extended_f3(Pos::binary(), Data::binary(), CPU_Data::binary()) -> {binary(), binary()}
ADD (16-bit)
See Generic Part for details
---- Unit-Tested ----
addd_immediate_c3(Pos::binary(), Data::binary(), CPU_Data::binary()) -> {binary(), binary()}
ADD (16-bit)
See Generic Part for details
---- Unit-Tested ----
addd_indexed_e3(Pos::binary(), Data::binary(), CPU_Data::binary()) -> {binary(), binary()}
ADD (16-bit)
See Generic Part for details
---- Unit-Tested ----
adde_direct_119b(Pos::binary(), Data::binary(), CPU_Data::binary()) -> {binary(), binary()}
ADD (8-bit)
See Generic Part for details
---- Unit-Tested ----
adde_extended_11bb(Pos::binary(), Data::binary(), CPU_Data::binary()) -> {binary(), binary()}
ADD (8-bit)
See Generic Part for details
---- Unit-Tested ----
adde_immediate_118b(Pos::binary(), Data::binary(), CPU_Data::binary()) -> {binary(), binary()}
ADD (8-bit)
See Generic Part for details
---- Unit-Tested ----
adde_indexed_11ab(Pos::binary(), Data::binary(), CPU_Data::binary()) -> {binary(), binary()}
ADD (8-bit)
See Generic Part for details
---- Unit-Tested ----
addf_direct_11db(Pos::binary(), Data::binary(), CPU_Data::binary()) -> {binary(), binary()}
ADD (8-bit)
See Generic Part for details
---- Unit-Tested ----
addf_extended_11fb(Pos::binary(), Data::binary(), CPU_Data::binary()) -> {binary(), binary()}
ADD (8-bit)
See Generic Part for details
---- Unit-Tested ----
addf_immediate_11cb(Pos::binary(), Data::binary(), CPU_Data::binary()) -> {binary(), binary()}
ADD (8-bit)
See Generic Part for details
---- Unit-Tested ----
addf_indexed_11eb(Pos::binary(), Data::binary(), CPU_Data::binary()) -> {binary(), binary()}
ADD (8-bit)
See Generic Part for details
---- Unit-Tested ----
addr_immediate_1030(Pos::binary(), Data::binary(), CPU_Data::binary()) -> {binary(), binary()}
ADDR (6309 ONLY)
Add Source Register to Destination Register
r1' = r1 + r0
The ADDR instruction adds the contents of a source register plus the contents of the
destination register. The result is placed into the destination register
H The Half-Carry flag is not affected by the ADDR instruction
N The Negative flag is set equal to the value of the result's high-order bit
Z The Zero flag is set if the new value of the destination register is zero; cleared otherwise
V The Overflow flag is set if an overflow occurred; cleared otherwise.
C The Carry flag is set if a carry out of the high-order bit occured; cleared otherwise.
---- Unit-Tested ----
addw_direct_109b(Pos::binary(), Data::binary(), CPU_Data::binary()) -> {binary(), binary()}
ADD (16-bit)
See Generic Part for details
---- Unit-Tested ----
addw_extended_10bb(Pos::binary(), Data::binary(), CPU_Data::binary()) -> {binary(), binary()}
ADD (16-bit)
See Generic Part for details
---- Unit-Tested ----
addw_immediate_108b(Pos::binary(), Data::binary(), CPU_Data::binary()) -> {binary(), binary()}
ADD (16-bit)
See Generic Part for details
---- Unit-Tested ----
addw_indexed_10ab(Pos::binary(), Data::binary(), CPU_Data::binary()) -> {binary(), binary()}
ADD (16-bit)
See Generic Part for details
---- Unit-Tested ----
aim_direct_02(Pos::binary(), Data::binary(), CPU_Data::binary()) -> {binary(), binary()}
AIM (6309 Only)
See Generic Part for details
---- Unit-Tested ----
aim_extended_72(Pos::binary(), Data::binary(), CPU_Data::binary()) -> {binary(), binary()}
AIM (6309 Only)
See Generic Part for details
---- Unit-Tested ----
aim_generic_part(_Pos::binary(), Data::binary(), New_CPU_Data::binary(), Memory_Data::binary(), Immediate_Byte::binary(), Designated_Memory_Location::binary(), New_Pos::binary()) -> {binary(), binary()}
AIM (6309 Only)
Logical AND of Immediate Value with Memory Byte
M' = (M) AND IMM
The AIM instruction logically ANDs the contents of a byte in memory with an 8-bit
immediate value, The resulting value is placed back into the designated memory location.
N The Negative flag is set equal to the new value of bit 7 of the memory byte.
Z The Zero flag is set if the new value of the memory byte is zero; cleared otherwise.
V The Overflow flag is cleared by this instruction.
C The Carry flag is not affected by this instruction.
AIM is one of the more useful additions to the 6309 instruction set. It takes three separate
instructions to perform the same operation on a 6809.
---- Unit-Tested ----
aim_indexed_62(Pos::binary(), Data::binary(), CPU_Data::binary()) -> {binary(), binary()}
AIM (6309 Only)
See Generic Part for details
---- Unit-Tested ----
and_generic_part(_Pos::binary(), Data::binary(), New_CPU_Data::binary(), Memory_Data::binary(), Get_Reg_Fun::function(), Set_Reg_Fun::function(), New_Pos::binary()) -> {binary(), binary()}
AND (8-BIT)
Logically AND Memory Byte with Accumulator A or B
R' = R AND (M)
These instructions logically AND the contents of a byte in memory with either
Accumulator A or B. The 8-bit result is then placed in the specified accumulator.
N The Negative flag is set equal to the new value of bit 7 of the accumulator.
Z The Zero flag is set if the new value of the accumulator is zero; cleared otherwise.
V The Overflow flas is cleared by this instruction.
C The Carry flag is not affected by this instruction.
The AND instructions are commonly used for clearing bits and for testing bits.
---- Unit-Tested ----
anda_direct_94(Pos::binary(), Data::binary(), CPU_Data::binary()) -> {binary(), binary()}
AND (8-BIT)
See Generic Part for details
---- Unit-Tested ----
anda_extended_b4(Pos::binary(), Data::binary(), CPU_Data::binary()) -> {binary(), binary()}
AND (8-BIT)
See Generic Part for details
---- Unit-Tested ----
anda_immediate_84(Pos::binary(), Data::binary(), CPU_Data::binary()) -> {binary(), binary()}
AND (8-BIT)
See Generic Part for details
---- Unit-Tested ----
anda_indexed_a4(Pos::binary(), Data::binary(), CPU_Data::binary()) -> {binary(), binary()}
AND (8-BIT)
See Generic Part for details
---- Unit-Tested ----
andb_direct_d4(Pos::binary(), Data::binary(), CPU_Data::binary()) -> {binary(), binary()}
AND (8-BIT)
See Generic Part for details
---- Unit-Tested ----
andb_extended_f4(Pos::binary(), Data::binary(), CPU_Data::binary()) -> {binary(), binary()}
AND (8-BIT)
See Generic Part for details
---- Unit-Tested ----
andb_immediate_c4(Pos::binary(), Data::binary(), CPU_Data::binary()) -> {binary(), binary()}
AND (8-BIT)
See Generic Part for details
---- Unit-Tested ----
andb_indexed_e4(Pos::binary(), Data::binary(), CPU_Data::binary()) -> {binary(), binary()}
AND (8-BIT)
See Generic Part for details
---- Unit-Tested ----
andcc_immediate_1c(Pos::binary(), Data::binary(), CPU_Data::binary()) -> {binary(), binary()}
ANDCC
Logically AND Immediate Value with the CC Register
CC' = CC AND IMM
This instruction logically ANDs the contents of the Condition Codes register with the
immediate byte specified in the instruction. The result is placed back in the Condition
Codes register.
The ANDCC instruction provides a method to clear specific flags in the Condition Codes
register. All flags that correspond to "0" bits in the immediate operand are cleared, while
those corresponding with "1"s are left unchanged.
The bit numbers for each flag are shown below:
|7|6|5|4|3|2|1|0|
|E|F|H|I|N|Z|V|C|
---- Unit-Tested ----
andd_direct_1094(Pos::binary(), Data::binary(), CPU_Data::binary()) -> {binary(), binary()}
ANDD (6309)
See Generic Part for details
---- Unit-Tested ----
andd_extended_10b4(Pos::binary(), Data::binary(), CPU_Data::binary()) -> {binary(), binary()}
ANDD (6309)
See Generic Part for details
---- Unit-Tested ----
andd_generic_part(_Pos::binary(), Data::binary(), New_CPU_Data::binary(), Memory_Data::binary(), New_Pos::binary()) -> {binary(), binary()}
ANDD (6309)
Logically AND Memory Word with Accumulator D
ACCD' = ACCD AND (M:M+1)
The ANDD instruction logically ANDs the contents of a double-byte value in memory
with the contents of Accumulator D. The 16-bit result is placed back into Accumulator D.
N The Negative flag is set equal to the new value of bit 15 of Accumulator D.
Z The Zero flag is set if the new value of the Accumulator D is zero; cleared otherwise.
V The Overflow flag is cleared by this instruction.
C The Carry flag is not affected by this instruction.
One use for the ANDD instruction is to truncate bits of an address value.
---- Unit-Tested ----
andd_immediate_1084(Pos::binary(), Data::binary(), CPU_Data::binary()) -> {binary(), binary()}
ANDD (6309)
See Generic Part for details
---- Unit-Tested ----
andd_indexed_10a4(Pos::binary(), Data::binary(), CPU_Data::binary()) -> {binary(), binary()}
ANDD (6309)
See Generic Part for details
---- Unit-Tested ----
andr_immediate_1034(Pos::binary(), Data::binary(), CPU_Data::binary()) -> {binary(), binary()}
ANDR (6309)
Logically AND Source Register with Destination Register
R1' = R1 AND R0
The ANDR instruction logically ANDs the contents of a source register with the contents
of a destination register. The result is placed into the destination register.
N The Negative flag is set equal to the value of the result's high-order bit.
Z The Zero flag is set if the new value of the destination register is zero; cleared otherwise.
V The Overflow flag is cleared by this instruction.
C The Carry flag is not affected by this instruction.
---- Unit-Tested ----
asl_direct_08(Pos, Data, CPU_Data) -> any()
asl_extended_78(Pos, Data, CPU_Data) -> any()
asl_generic_part(Pos, Data, New_CPU_Data, Memory_Data, Designated_Memory_Location, New_Pos) -> any()
asl_indexed_68(Pos, Data, CPU_Data) -> any()
asla_inherent_48(Pos, Data, CPU_Data) -> any()
aslb_inherent_58(Pos, Data, CPU_Data) -> any()
asld_inherent_1048(Pos, Data, CPU_Data) -> any()
asr_direct_07(Pos, Data, CPU_Data) -> any()
asr_extended_77(Pos, Data, CPU_Data) -> any()
asr_generic_part(Pos, Data, New_CPU_Data, Memory_Data, Designated_Memory_Location, New_Pos) -> any()
asr_indexed_67(Pos, Data, CPU_Data) -> any()
asra_inherent_47(Pos, Data, CPU_Data) -> any()
asrb_inherent_57(Pos, Data, CPU_Data) -> any()
asrd_inherent_1047(Pos, Data, CPU_Data) -> any()
auto_decrement_of_r_pre_decrement_by_1(Pos::binary(), Data::binary(), CPU_Data::binary(), Number_Of_Bytes::non_neg_integer()) -> {binary(), binary(), binary()}
Uses Register R which is encoded in the post-byte
First the value of R is decreased by 1 automatically
Direct mode the effective address is the value in R
Indirect mode the effective address is determine by
first getting an address from the value of R, and then getting
an another address from that memory location
Returns: {value, CPU_Data, New_Position}
---- Unit-Tested ----
auto_decrement_of_r_pre_decrement_by_1_address_only(Pos::binary(), Data::binary(), CPU_Data::binary(), Number_Of_Bytes::non_neg_integer()) -> {binary(), binary(), binary()}
Uses Register R which is encoded in the post-byte
First the value of R is decreased by 1 automatically
Direct mode the effective address is the value in R
Indirect mode the effective address is determine by
first getting an address from the value of R, and then getting
an another address from that memory location
Returns: {address, CPU_Data, New_Position}
---- Unit-Tested ----
auto_decrement_of_r_pre_decrement_by_2(Pos::binary(), Data::binary(), CPU_Data::binary(), Number_Of_Bytes::non_neg_integer()) -> {binary(), binary(), binary()}
Uses Register R which is encoded in the post-byte
First the value of R is decreased by 2 automatically
Direct mode the effective address is the value in R
Indirect mode the effective address is determine by
first getting an address from the value of R, and then getting
an another address from that memory location
Returns: {value, CPU_Data, New_Position}
---- Unit-Tested ----
auto_decrement_of_r_pre_decrement_by_2_address_only(Pos::binary(), Data::binary(), CPU_Data::binary(), Number_Of_Bytes::non_neg_integer()) -> {binary(), binary(), binary()}
Uses Register R which is encoded in the post-byte
First the value of R is decreased by 2 automatically
Direct mode the effective address is the value in R
Indirect mode the effective address is determine by
first getting an address from the value of R, and then getting
an another address from that memory location
Returns: {address, CPU_Data, New_Position}
---- Unit-Tested ----
auto_decrement_of_w_pre_decrement_by_2(Pos::binary(), Data::binary(), CPU_Data::binary(), Number_Of_Bytes::non_neg_integer()) -> {binary(), binary(), binary()}
Uses Register W
First the value of W is decreased by 2 automatically
Direct mode the effective address is the value in W
Indirect mode the effective address is determine by
first getting an address from the value of W, and then getting
an another address from that memory location
Returns: {value, CPU_Data, New_Position}
---- Unit-Tested ----
auto_decrement_of_w_pre_decrement_by_2_address_only(Pos::binary(), Data::binary(), CPU_Data::binary(), Number_Of_Bytes::non_neg_integer()) -> {binary(), binary(), binary()}
Uses Register W
First the value of W is decreased by 2 automatically
Direct mode the effective address is the value in W
Indirect mode the effective address is determine by
first getting an address from the value of W, and then getting
an another address from that memory location
Returns: {address, CPU_Data, New_Position}
---- Unit-Tested ----
auto_increment_of_r_post_increment_by_1(Pos::binary(), Data::binary(), CPU_Data::binary(), Number_Of_Bytes::non_neg_integer()) -> {binary(), binary(), binary()}
Uses Register R which is encoded in the post-byte
Direct mode the effective address is the value in R
Indirect mode the effective address is determine by
first getting an address from the value of R, and then getting
an another address from that memory location
After this the value of R is increased by 1 automatically
Returns: {value, CPU_Data, New_Position}
---- Unit-Tested ----
auto_increment_of_r_post_increment_by_1_address_only(Pos::binary(), Data::binary(), CPU_Data::binary(), Number_Of_Bytes::non_neg_integer()) -> {binary(), binary(), binary()}
Uses Register R which is encoded in the post-byte
Direct mode the effective address is the value in R
Indirect mode the effective address is determine by
first getting an address from the value of R, and then getting
an another address from that memory location
After this the value of R is increased by 1 automatically
Returns: {address, CPU_Data, New_Position}
---- Unit-Tested ----
auto_increment_of_r_post_increment_by_2(Pos::binary(), Data::binary(), CPU_Data::binary(), Number_Of_Bytes::non_neg_integer()) -> {binary(), binary(), binary()}
Uses Register R which is encoded in the post-byte
Direct mode the effective address is the value in R
Indirect mode the effective address is determine by
first getting an address from the value of R, and then getting
an another address from that memory location
After this the value of R is increased by 2 automatically
Returns: {value, CPU_Data, New_Position}
---- Unit-Tested ----
auto_increment_of_r_post_increment_by_2_address_only(Pos::binary(), Data::binary(), CPU_Data::binary(), Number_Of_Bytes::non_neg_integer()) -> {binary(), binary(), binary()}
Uses Register R which is encoded in the post-byte
Direct mode the effective address is the value in R
Indirect mode the effective address is determine by
first getting an address from the value of R, and then getting
an another address from that memory location
After this the value of R is increased by 2 automatically
Returns: {address, CPU_Data, New_Position}
---- Unit-Tested ----
auto_increment_of_w_post_increment_by_2(Pos::binary(), Data::binary(), CPU_Data::binary(), Number_Of_Bytes::non_neg_integer()) -> {binary(), binary(), binary()}
Uses Register W
Direct mode the effective address is the value in W
Indirect mode the effective address is determine by
first getting an address from the value of W, and then getting
an another address from that memory location
After this the value of W is increased by 2 automatically
Returns: {value, CPU_Data, New_Position}
---- Unit-Tested ----
auto_increment_of_w_post_increment_by_2_address_only(Pos::binary(), Data::binary(), CPU_Data::binary(), Number_Of_Bytes::non_neg_integer()) -> {binary(), binary(), binary()}
Uses Register W
Direct mode the effective address is the value in W
Indirect mode the effective address is determine by
first getting an address from the value of W, and then getting
an another address from that memory location
After this the value of W is increased by 2 automatically
Returns: {address, CPU_Data, New_Position}
---- Unit-Tested ----
band_direct_1130(Pos, Data, CPU_Data) -> any()
band_reg_name_decode(RR::non_neg_integer()) -> atom()
bcc_relative_24(Pos, Data, CPU_Data) -> any()
bcs_relative_25(Pos, Data, CPU_Data) -> any()
beor_direct_1134(Pos, Data, CPU_Data) -> any()
beq_relative_27(Pos, Data, CPU_Data) -> any()
bge_relative_2c(Pos, Data, CPU_Data) -> any()
bgt_relative_2e(Pos, Data, CPU_Data) -> any()
bhi_relative_22(Pos, Data, CPU_Data) -> any()
bhs_relative_24(Pos, Data, CPU_Data) -> any()
biand_direct_1131(Pos, Data, CPU_Data) -> any()
bieor_direct_1135(Pos, Data, CPU_Data) -> any()
bior_direct_1133(Pos, Data, CPU_Data) -> any()
bit_generic_part(Pos, Data, New_CPU_Data, Memory_Data, Get_Reg_Fun, New_Pos) -> any()
bita_direct_95(Pos, Data, CPU_Data) -> any()
bita_extended_b5(Pos, Data, CPU_Data) -> any()
bita_immediate_85(Pos, Data, CPU_Data) -> any()
bita_indexed_a5(Pos, Data, CPU_Data) -> any()
bitb_direct_d5(Pos, Data, CPU_Data) -> any()
bitb_extended_f5(Pos, Data, CPU_Data) -> any()
bitb_immediate_c5(Pos, Data, CPU_Data) -> any()
bitb_indexed_e5(Pos, Data, CPU_Data) -> any()
bitd_direct_1095(Pos, Data, CPU_Data) -> any()
bitd_extended_10b5(Pos, Data, CPU_Data) -> any()
bitd_immediate_1085(Pos, Data, CPU_Data) -> any()
bitd_indexed_10a5(Pos, Data, CPU_Data) -> any()
bitmd_immediate_113c(Pos, Data, CPU_Data) -> any()
ble_relative_2f(Pos, Data, CPU_Data) -> any()
blo_relative_25(Pos, Data, CPU_Data) -> any()
bls_relative_23(Pos, Data, CPU_Data) -> any()
blt_relative_2d(Pos, Data, CPU_Data) -> any()
bmi_relative_2b(Pos, Data, CPU_Data) -> any()
bne_relative_26(Pos, Data, CPU_Data) -> any()
bor_direct_1132(Pos, Data, CPU_Data) -> any()
bpl_relative_2a(Pos, Data, CPU_Data) -> any()
bra_relative_20(Pos, Data, CPU_Data) -> any()
brn_relative_21(Pos, Data, CPU_Data) -> any()
bsr_relative_8d(Pos, Data, CPU_Data) -> any()
bvc_relative_28(Pos, Data, CPU_Data) -> any()
bvs_relative_29(Pos, Data, CPU_Data) -> any()
check_cc_status_update(Map::#{}, CPU_Data::binary(), Key::atom(), Fun::function()) -> binary()
Checks if Key (atom) is in the Map
If it is extract its value from the Map and update the condition code for that key
Returns the updated CPU representation
---- Unit-Tested ----
clr_direct_0f(Pos, Data, CPU_Data) -> any()
clr_extended_7f(Pos, Data, CPU_Data) -> any()
clr_generic_part(Pos, Data, New_CPU_Data, Designated_Memory_Location, New_Pos) -> any()
clr_indexed_6f(Pos, Data, CPU_Data) -> any()
clra_inherent_4f(Pos, Data, CPU_Data) -> any()
clrb_inherent_5f(Pos, Data, CPU_Data) -> any()
clrd_inherent_104f(Pos, Data, CPU_Data) -> any()
clre_inherent_114f(Pos, Data, CPU_Data) -> any()
clrf_inherent_115f(Pos, Data, CPU_Data) -> any()
clrw_inherent_105f(Pos, Data, CPU_Data) -> any()
cmp_generic_part(Pos, Data, New_CPU_Data, Memory_Data, Get_Reg_Fun, New_Pos) -> any()
cmpa_direct_91(Pos, Data, CPU_Data) -> any()
cmpa_extended_b1(Pos, Data, CPU_Data) -> any()
cmpa_immediate_81(Pos, Data, CPU_Data) -> any()
cmpa_indexed_a1(Pos, Data, CPU_Data) -> any()
cmpb_direct_d1(Pos, Data, CPU_Data) -> any()
cmpb_extended_f1(Pos, Data, CPU_Data) -> any()
cmpb_immediate_c1(Pos, Data, CPU_Data) -> any()
cmpb_indexed_e1(Pos, Data, CPU_Data) -> any()
cmpd_direct_0093(Pos, Data, CPU_Data) -> any()
cmpd_extended_00b3(Pos, Data, CPU_Data) -> any()
cmpd_immediate_0083(Pos, Data, CPU_Data) -> any()
cmpd_indexed_00a3(Pos, Data, CPU_Data) -> any()
cmpe_direct_1191(Pos, Data, CPU_Data) -> any()
cmpe_extended_11b1(Pos, Data, CPU_Data) -> any()
cmpe_immediate_1181(Pos, Data, CPU_Data) -> any()
cmpe_indexed_11a1(Pos, Data, CPU_Data) -> any()
cmpf_direct_11d1(Pos, Data, CPU_Data) -> any()
cmpf_extended_11f1(Pos, Data, CPU_Data) -> any()
cmpf_immediate_11c1(Pos, Data, CPU_Data) -> any()
cmpf_indexed_11e1(Pos, Data, CPU_Data) -> any()
cmpr_immediate_1037(Pos, Data, CPU_Data) -> any()
cmps_direct_019C(Pos, Data, CPU_Data) -> any()
cmps_extended_01bc(Pos, Data, CPU_Data) -> any()
cmps_immediate_018C(Pos, Data, CPU_Data) -> any()
cmps_indexed_01ac(Pos, Data, CPU_Data) -> any()
cmpu_direct_0193(Pos, Data, CPU_Data) -> any()
cmpu_extended_01b3(Pos, Data, CPU_Data) -> any()
cmpu_immediate_0183(Pos, Data, CPU_Data) -> any()
cmpu_indexed_01a3(Pos, Data, CPU_Data) -> any()
cmpw_direct_0091(Pos, Data, CPU_Data) -> any()
cmpw_extended_00b1(Pos, Data, CPU_Data) -> any()
cmpw_immediate_0081(Pos, Data, CPU_Data) -> any()
cmpw_indexed_00a1(Pos, Data, CPU_Data) -> any()
cmpx_direct_9c(Pos, Data, CPU_Data) -> any()
cmpx_extended_bc(Pos, Data, CPU_Data) -> any()
cmpx_immediate_8c(Pos, Data, CPU_Data) -> any()
cmpx_indexed_ac(Pos, Data, CPU_Data) -> any()
cmpy_direct_009c(Pos, Data, CPU_Data) -> any()
cmpy_extended_00bc(Pos, Data, CPU_Data) -> any()
cmpy_immediate_008c(Pos, Data, CPU_Data) -> any()
cmpy_indexed_00ac(Pos, Data, CPU_Data) -> any()
com_generic_part(Pos, Data, New_CPU_Data, Get_Reg_Fun, Set_Reg_Fun, New_Pos) -> any()
constant_offset_from_pc_16_bit_offset(Pos::binary(), Data::binary(), CPU_Data::binary(), Number_Of_Bytes::non_neg_integer()) -> {binary(), binary(), binary()}
Uses Register PC
and an 16-bit signed value from after the post-byte
Direct mode the effective address is the value in PC + 16-bit value
Indirect mode the effective address is determine by
first getting an address from the value of PC + 16-bit value, and then getting
an another address from that memory location
Returns: {value, CPU_Data, New_Position}
---- Unit-Tested ----
constant_offset_from_pc_16_bit_offset_address_only(Pos::binary(), Data::binary(), CPU_Data::binary(), _Number_Of_Bytes::non_neg_integer()) -> {binary(), binary(), binary()}
Uses Register PC
and an 16-bit signed value from after the post-byte
Direct mode the effective address is the value in PC + 16-bit value
Indirect mode the effective address is determine by
first getting an address from the value of PC + 16-bit value, and then getting
an another address from that memory location
Returns: {address, CPU_Data, New_Position}
---- Unit-Tested ----
constant_offset_from_pc_8_bit_offset(Pos::binary(), Data::binary(), CPU_Data::binary(), Number_Of_Bytes::non_neg_integer()) -> {binary(), binary(), binary()}
Uses Register PC
and an 8-bit signed value from after the post-byte
Direct mode the effective address is the value in PC + 8-bit value
Indirect mode the effective address is determine by
first getting an address from the value of PC + 8-bit value, and then getting
an another address from that memory location
Returns: {value, CPU_Data, New_Position}
---- Unit-Tested ----
constant_offset_from_pc_8_bit_offset_address_only(Pos::binary(), Data::binary(), CPU_Data::binary(), Number_Of_Bytes::non_neg_integer()) -> {binary(), binary(), binary()}
Uses Register PC
and an 8-bit signed value from after the post-byte
Direct mode the effective address is the value in PC + 8-bit value
Indirect mode the effective address is determine by
first getting an address from the value of PC + 8-bit value, and then getting
an another address from that memory location
Returns: {address, CPU_Data, New_Position}
---- Unit-Tested ----
constant_offset_from_r_16_bit_offset(Pos::binary(), Data::binary(), CPU_Data::binary(), Number_Of_Bytes::non_neg_integer()) -> {binary(), binary(), binary()}
Uses Register R which is encoded in the post-byte
and an 16-bit value encode after the post-byte
Direct mode the effective address is the value in R + 16-bit value
Indirect mode the effective address is determine by
first getting an address from the value of R + 16-bit value, and then getting
an another address from that memory location
Returns: {value, CPU_Data, New_Position}
---- Unit-Tested ----
constant_offset_from_r_16_bit_offset_address_only(Pos::binary(), Data::binary(), CPU_Data::binary(), Number_Of_Bytes::non_neg_integer()) -> {binary(), binary(), binary()}
Uses Register R which is encoded in the post-byte
and an 16-bit value encode after the post-byte
Direct mode the effective address is the value in R + 16-bit value
Indirect mode the effective address is determine by
first getting an address from the value of R + 16-bit value, and then getting
an another address from that memory location
Returns: {address, CPU_Data, New_Position}
---- Unit-Tested ----
constant_offset_from_r_5_bit_offset_direct(Pos::binary(), Data::binary(), CPU_Data::binary(), Number_Of_Bytes::non_neg_integer()) -> {binary(), binary(), binary()}
Uses Register R which is encoded in the post-byte
and a signed 5-bit offset which is also encoded in the post-byte
The effective address is calculated by R + 5-bit offset
This address mode supports direct addressing only
Returns: {value, CPU_Data, New_Position}
---- Unit-Tested ----
constant_offset_from_r_5_bit_offset_direct_address_only(Pos::binary(), Data::binary(), CPU_Data::binary(), Number_Of_Bytes::non_neg_integer()) -> {binary(), binary(), binary()}
Uses Register R which is encoded in the post-byte
and a signed 5-bit offset which is also encoded in the post-byte
The effective address is calculated by R + 5-bit offset
This address mode supports direct addressing only
Returns: {address, CPU_Data, New_Position}
---- Unit-Tested ----
constant_offset_from_r_8_bit_offset(Pos::binary(), Data::binary(), CPU_Data::binary(), Number_Of_Bytes::non_neg_integer()) -> {binary(), binary(), binary()}
Uses Register R which is encoded in the post-byte
and an 8-bit value encode after the post-byte
Direct mode the effective address is the value in R + 8-bit value
Indirect mode the effective address is determine by
first getting an address from the value of R + 8-bit value, and then getting
an another address from that memory location
Returns: {value, CPU_Data, New_Position}
---- Unit-Tested ----
constant_offset_from_r_8_bit_offset_address_only(Pos::binary(), Data::binary(), CPU_Data::binary(), Number_Of_Bytes::non_neg_integer()) -> {binary(), binary(), binary()}
Uses Register R which is encoded in the post-byte
and an 8-bit value encode after the post-byte
Direct mode the effective address is the value in R + 8-bit value
Indirect mode the effective address is determine by
first getting an address from the value of R + 8-bit value, and then getting
an another address from that memory location
Returns: {address, CPU_Data, New_Position}
---- Unit-Tested ----
constant_offset_from_r_no_offset(Pos::binary(), Data::binary(), CPU_Data::binary(), Number_Of_Bytes::non_neg_integer()) -> {binary(), binary(), binary()}
Uses Register R which is encoded in the post-byte
Direct mode the effective address is the value in R
Indirect mode the effective address is determine by
first getting an address from the value of R, and then getting
an another address from that memory location
Returns: {value, CPU_Data, New_Position}
---- Unit-Tested ----
constant_offset_from_r_no_offset_address_only(Pos::binary(), Data::binary(), CPU_Data::binary(), Number_Of_Bytes::non_neg_integer()) -> {binary(), binary(), binary()}
Uses Register R which is encoded in the post-byte
Direct mode the effective address is the value in R
Indirect mode the effective address is determine by
first getting an address from the value of R, and then getting
an another address from that memory location
Returns: {address, CPU_Data, New_Position}
---- Unit-Tested ----
constant_offset_from_w_16_bit_offset(Pos::binary(), Data::binary(), CPU_Data::binary(), Number_Of_Bytes::non_neg_integer()) -> {binary(), binary(), binary()}
Uses Register W
and an 16-bit value encode after the post-byte
Direct mode the effective address is the value in W + 16-bit value
Indirect mode the effective address is determine by
first getting an address from the value of W + 16-bit value, and then getting
an another address from that memory location
Returns: {value, CPU_Data, New_Position}
---- Unit-Tested ----
constant_offset_from_w_16_bit_offset_address_only(Pos::binary(), Data::binary(), CPU_Data::binary(), Number_Of_Bytes::non_neg_integer()) -> {binary(), binary(), binary()}
Uses Register W
and an 16-bit value encode after the post-byte
Direct mode the effective address is the value in W + 16-bit value
Indirect mode the effective address is determine by
first getting an address from the value of W + 16-bit value, and then getting
an another address from that memory location
Returns: {address, CPU_Data, New_Position}
---- Unit-Tested ----
constant_offset_from_w_no_offset(Pos::binary(), Data::binary(), CPU_Data::binary(), Number_Of_Bytes::non_neg_integer()) -> {binary(), binary(), binary()}
Uses Register W
Direct mode the effective address is the value in W
Indirect mode the effective address is determine by
first getting an address from the value of W, and then getting
an another address from that memory location
Returns: {value, CPU_Data, New_Position}
---- Unit-Tested ----
constant_offset_from_w_no_offset_address_only(Pos::binary(), Data::binary(), CPU_Data::binary(), Number_Of_Bytes::non_neg_integer()) -> {binary(), binary(), binary()}
Uses Register W
Direct mode the effective address is the value in W
Indirect mode the effective address is determine by
first getting an address from the value of W, and then getting
an another address from that memory location
Returns: {address, CPU_Data, New_Position}
---- Unit-Tested ----
cpu_clear() -> any()
cpu_get_a(CPU_Data::binary()) -> binary()
Gets the A Register bits from CPU_Data
Returns: 8 bit binary
---- Unit-Tested ----
cpu_get_b(CPU_Data::binary()) -> binary()
Gets the B Register bits from CPU_Data
Returns: 8 bit binary
---- Unit-Tested ----
cpu_get_cc(CPU_Data::binary()) -> binary()
Gets the CC Register bits from CPU_Data
Returns: 8 bit binary
---- Unit-Tested ----
cpu_get_cc_c(CPU_Data::binary()) -> binary()
Gets the CC Register C bit from CPU_Data
Returns: 1 bit binary
---- Unit-Tested ----
cpu_get_cc_e(CPU_Data::binary()) -> binary()
Gets the CC Register E bit from CPU_Data
Returns: 1 bit binary
---- Unit-Tested ----
cpu_get_cc_f(CPU_Data::binary()) -> binary()
Gets the CC Register F bit from CPU_Data
Returns: 1 bit binary
---- Unit-Tested ----
cpu_get_cc_h(CPU_Data::binary()) -> binary()
Gets the CC Register H bit from CPU_Data
Returns: 1 bit binary
---- Unit-Tested ----
cpu_get_cc_i(CPU_Data::binary()) -> binary()
Gets the CC Register I bit from CPU_Data
Returns: 1 bit binary
---- Unit-Tested ----
cpu_get_cc_n(CPU_Data::binary()) -> binary()
Gets the CC Register N bit from CPU_Data
Returns: 1 bit binary
---- Unit-Tested ----
cpu_get_cc_v(CPU_Data::binary()) -> binary()
Gets the CC Register V bit from CPU_Data
Returns: 1 bit binary
---- Unit-Tested ----
cpu_get_cc_z(CPU_Data::binary()) -> binary()
Gets the CC Register Z bit from CPU_Data
Returns: 1 bit binary
---- Unit-Tested ----
cpu_get_d(CPU_Data::binary()) -> binary()
Gets the D Register bits from CPU_Data
Returns: 16 bit binary
---- Unit-Tested ----
cpu_get_dp(CPU_Data::binary()) -> binary()
Gets the DP Register bits from CPU_Data
Returns: 8 bit binary
---- Unit-Tested ----
cpu_get_e(CPU_Data::binary()) -> binary()
Gets the E Register bits from CPU_Data
Returns: 8 bit binary
---- Unit-Tested ----
cpu_get_f(CPU_Data::binary()) -> binary()
Gets the F Register bits from CPU_Data
Returns: 8 bit binary
---- Unit-Tested ----
cpu_get_firq(CPU_Data::binary()) -> binary()
Gets the FIRQ bit from CPU_Data
Returns: 1 bit binary
---- Unit-Tested ----
cpu_get_halt(CPU_Data::binary()) -> binary()
Gets the HALT bit from CPU_Data
Returns: 1 bit binary
---- Unit-Tested ----
cpu_get_irq(CPU_Data::binary()) -> binary()
Gets the IRQ bit from CPU_Data
Returns: 1 bit binary
---- Unit-Tested ----
cpu_get_md(CPU_Data::binary()) -> binary()
Gets the MD Register bits from CPU_Data
Returns: 8 bit binary
---- Unit-Tested ----
cpu_get_md_div0(CPU_Data::binary()) -> binary()
Gets the MD Register DIV0 bit from CPU_Data
Returns: 1 bit binary
---- Unit-Tested ----
cpu_get_md_fm(CPU_Data::binary()) -> binary()
Gets the MD Register FM bit from CPU_Data
Returns: 1 bit binary
---- Unit-Tested ----
cpu_get_md_il(CPU_Data::binary()) -> binary()
Gets the MD Register IL bit from CPU_Data
Returns: 1 bit binary
---- Unit-Tested ----
cpu_get_md_nm(CPU_Data::binary()) -> binary()
Gets the MD Register NM bit from CPU_Data
Returns: 1 bit binary
---- Unit-Tested ----
cpu_get_nmi(CPU_Data::binary()) -> binary()
Gets the NMI bit from CPU_Data
Returns: 1 bit binary
---- Unit-Tested ----
cpu_get_pc(CPU_Data::binary()) -> binary()
Gets the PC Register bits from CPU_Data
Returns: 16 bit binary
---- Unit-Tested ----
cpu_get_q(CPU_Data::binary()) -> binary()
Gets the Q Register bits from CPU_Data
Returns: 32 bit binary
---- Unit-Tested ----
cpu_get_reserved(CPU_Data::binary()) -> binary()
Gets the RESERVED bit from CPU_Data
Returns: 1 bit binary
---- Unit-Tested ----
cpu_get_reset(CPU_Data::binary()) -> binary()
Gets the RESET bit from CPU_Data
Returns: 1 bit binary
---- Unit-Tested ----
cpu_get_s(CPU_Data::binary()) -> binary()
Gets the S Register bits from CPU_Data
Returns: 16 bit binary
---- Unit-Tested ----
cpu_get_swi(CPU_Data::binary()) -> binary()
Gets the SWI bit from CPU_Data
Returns: 1 bit binary
---- Unit-Tested ----
cpu_get_swi2(CPU_Data::binary()) -> binary()
Gets the SWI2 bit from CPU_Data
Returns: 1 bit binary
---- Unit-Tested ----
cpu_get_swi3(CPU_Data::binary()) -> binary()
Gets the SWI3 bit from CPU_Data
Returns: 1 bit binary
---- Unit-Tested ----
cpu_get_u(CPU_Data::binary()) -> binary()
Gets the U Register bits from CPU_Data
Returns: 16 bit binary
---- Unit-Tested ----
cpu_get_v(CPU_Data::binary()) -> binary()
Gets the V Register bits from CPU_Data
Returns: 16 bit binary
---- Unit-Tested ----
cpu_get_w(CPU_Data::binary()) -> binary()
Gets the W Register bits from CPU_Data
Returns: 16 bit binary
---- Unit-Tested ----
cpu_get_x(CPU_Data::binary()) -> binary()
Gets the X Register bits from CPU_Data
Returns: 16 bit binary
---- Unit-Tested ----
cpu_get_y(CPU_Data::binary()) -> binary()
Gets the Y Register bits from CPU_Data
Returns: 16 bit binary
---- Unit-Tested ----
cpu_get_zero(CPU_Data::binary()) -> binary()
Gets the Zero Register bits from CPU_Data
Returns: 16 bit binary
---- Unit-Tested ----
cpu_perform_actions(Fun_List::[function()]) -> binary()
Performs a list of actions on the CPU
Returns: Updated CPU Data
---- Unit-Tested ----
cpu_perform_actions(Funs, CPU_Data) -> any()
cpu_set_a(A::binary(), CPU_Data::binary()) -> binary()
Sets the A Register in CPU_Data
Returns: Updated CPU Data
---- Unit-Tested ----
cpu_set_b(B::binary(), CPU_Data::binary()) -> binary()
Sets the B Register in CPU_Data
Returns: Updated CPU Data
---- Unit-Tested ----
cpu_set_cc(CC::binary(), CPU_Data::binary()) -> binary()
Sets the CC Register in CPU_Data
Returns: Updated CPU Data
---- Unit-Tested ----
cpu_set_cc_c(CC_C::binary(), CPU_Data::binary()) -> binary()
Sets the CC Register C Bit in CPU_Data
Returns: Updated CPU Data
---- Unit-Tested ----
cpu_set_cc_e(CC_E::binary(), CPU_Data::binary()) -> binary()
Sets the CC Register E Bit in CPU_Data
Returns: Updated CPU Data
---- Unit-Tested ----
cpu_set_cc_f(CC_F::binary(), CPU_Data::binary()) -> binary()
Sets the CC Register F Bit in CPU_Data
Returns: Updated CPU Data
---- Unit-Tested ----
cpu_set_cc_h(CC_H::binary(), CPU_Data::binary()) -> binary()
Sets the CC Register H Bit in CPU_Data
Returns: Updated CPU Data
---- Unit-Tested ----
cpu_set_cc_i(CC_I::binary(), CPU_Data::binary()) -> binary()
Sets the CC Register I Bit in CPU_Data
Returns: Updated CPU Data
---- Unit-Tested ----
cpu_set_cc_n(CC_N::binary(), CPU_Data::binary()) -> binary()
Sets the CC Register N Bit in CPU_Data
Returns: Updated CPU Data
---- Unit-Tested ----
cpu_set_cc_v(CC_V::binary(), CPU_Data::binary()) -> binary()
Sets the CC Register V Bit in CPU_Data
Returns: Updated CPU Data
---- Unit-Tested ----
cpu_set_cc_z(CC_Z::binary(), CPU_Data::binary()) -> binary()
Sets the CC Register Z Bit in CPU_Data
Returns: Updated CPU Data
---- Unit-Tested ----
cpu_set_d(D::binary(), CPU_Data::binary()) -> binary()
Sets the D Register in CPU_Data
Returns: Updated CPU Data
---- Unit-Tested ----
cpu_set_dp(DP::binary(), CPU_Data::binary()) -> binary()
Sets the DP Register in CPU_Data
Returns: Updated CPU Data
---- Unit-Tested ----
cpu_set_e(E::binary(), CPU_Data::binary()) -> binary()
Sets the E Register in CPU_Data
Returns: Updated CPU Data
---- Unit-Tested ----
cpu_set_f(F::binary(), CPU_Data::binary()) -> binary()
Sets the F Register in CPU_Data
Returns: Updated CPU Data
---- Unit-Tested ----
cpu_set_firq(FIRQ::binary(), CPU_Data::binary()) -> binary()
Sets the FIRQ bit in CPU_Data
Returns: Updated CPU Data
---- Unit-Tested ----
cpu_set_halt(Halt::binary(), CPU_Data::binary()) -> binary()
Sets the HALT bit in CPU_Data
Returns: Updated CPU Data
---- Unit-Tested ----
cpu_set_irq(IRQ::binary(), CPU_Data::binary()) -> binary()
Sets the IRQ bit in CPU_Data
Returns: Updated CPU Data
---- Unit-Tested ----
cpu_set_md(MD::binary(), CPU_Data::binary()) -> binary()
Sets the MD Register in CPU_Data
Returns: Updated CPU Data
---- Unit-Tested ----
cpu_set_md_div0(MD_Div0::binary(), CPU_Data::binary()) -> binary()
Sets the MD Register DIV0 Bit in CPU_Data
Returns: Updated CPU Data
---- Unit-Tested ----
cpu_set_md_fm(MD_FM::binary(), CPU_Data::binary()) -> binary()
Sets the MD Register FM Bit in CPU_Data
Returns: Updated CPU Data
---- Unit-Tested ----
cpu_set_md_il(MD_IL::binary(), CPU_Data::binary()) -> binary()
Sets the MD Register IL Bit in CPU_Data
Returns: Updated CPU Data
---- Unit-Tested ----
cpu_set_md_nm(MD_NM::binary(), CPU_Data::binary()) -> binary()
Sets the MD Register NM Bit in CPU_Data
Returns: Updated CPU Data
---- Unit-Tested ----
cpu_set_nmi(NMI::binary(), CPU_Data::binary()) -> binary()
Sets the NMI bit in CPU_Data
Returns: Updated CPU Data
---- Unit-Tested ----
cpu_set_pc(PC::binary(), CPU_Data::binary()) -> binary()
Sets the PC Register in CPU_Data
Returns: Updated CPU Data
---- Unit-Tested ----
cpu_set_q(Q::binary(), CPU_Data::binary()) -> binary()
Sets the Q Register in CPU_Data
Returns: Updated CPU Data
---- Unit-Tested ----
cpu_set_reserved(Reserved::binary(), CPU_Data::binary()) -> binary()
Sets the RESERVED bit in CPU_Data
Returns: Updated CPU Data
---- Unit-Tested ----
cpu_set_reset(Reset::binary(), CPU_Data::binary()) -> binary()
Sets the Reset bit in CPU_Data
Returns: Updated CPU Data
---- Unit-Tested ----
cpu_set_s(S::binary(), CPU_Data::binary()) -> binary()
Sets the S Register in CPU_Data
Returns: Updated CPU Data
---- Unit-Tested ----
cpu_set_swi(SWI::binary(), CPU_Data::binary()) -> binary()
Sets the SWI bit in CPU_Data
Returns: Updated CPU Data
---- Unit-Tested ----
cpu_set_swi2(SWI2::binary(), CPU_Data::binary()) -> binary()
Sets the SWI2 bit in CPU_Data
Returns: Updated CPU Data
---- Unit-Tested ----
cpu_set_swi3(SWI3::binary(), CPU_Data::binary()) -> binary()
Sets the SWI3 bit in CPU_Data
Returns: Updated CPU Data
---- Unit-Tested ----
cpu_set_u(U::binary(), CPU_Data::binary()) -> binary()
Sets the U Register in CPU_Data
Returns: Updated CPU Data
---- Unit-Tested ----
cpu_set_v(V::binary(), CPU_Data::binary()) -> binary()
Sets the V Register in CPU_Data
Returns: Updated CPU Data
---- Unit-Tested ----
cpu_set_w(W::binary(), CPU_Data::binary()) -> binary()
Sets the W Register in CPU_Data
Returns: Updated CPU Data
---- Unit-Tested ----
cpu_set_x(X::binary(), CPU_Data::binary()) -> binary()
Sets the X Register in CPU_Data
Returns: Updated CPU Data
---- Unit-Tested ----
cpu_set_y(Y::binary(), CPU_Data::binary()) -> binary()
Sets the Y Register in CPU_Data
Returns: Updated CPU Data
---- Unit-Tested ----
cpu_set_zero(Zero::binary(), CPU_Data::binary()) -> binary()
Sets the ZERO Register in CPU_Data
Returns: Updated CPU Data
---- Unit-Tested ----
decode_inter_register_actual_source(Source_Reg::atom(), Destination_Size::non_neg_integer(), CPU::binary()) -> binary()
Decodes the Inter Register actual source value
Based on the destination size and source register
---- Unit-Tested ----
decode_inter_register_bits(Bits::binary()) -> atom()
Decode an Inter Register Bit encoding to the corresponding register name (atom)
---- Unit-Tested ----
decode_inter_register_post_byte(Post_Byte::binary()) -> {atom(), atom()}
Decodes the inter register names from a post byte
Returns: a tuple with the register names as atoms
E.g. {d,a}
---- Unit-Tested ----
direct_1_address(Pos::binary(), Data::binary(), CPU_Data::binary()) -> {binary(), binary(), binary()}
Get the value (8-bit) from a direct request
Returns: {value, CPU_Data, New_Position}
---- Unit-Tested ----
direct_1_address_address_only(Pos::binary(), Data::binary(), CPU_Data::binary()) -> {binary(), binary(), binary()}
Get the address only from a direct request
Returns: {address, CPU_Data, New_Position}
---- Unit-Tested ----
direct_2_address(Pos::binary(), Data::binary(), CPU_Data::binary()) -> {binary(), binary(), binary()}
Get the value (16-bit) from a direct request
Returns: {value, CPU_Data, New_Position}
---- Unit-Tested ----
direct_2_address_address_only(Pos::binary(), Data::binary(), CPU_Data::binary()) -> {binary(), binary(), binary()}
Get the address only from a direct request
Returns: {address, CPU_Data, New_Position}
---- Unit-Tested ----
dont_care() -> any()
execution(Data, CPU_Data) -> any()
extended_indirect_16_bit_address(Pos::binary(), Data::binary(), CPU_Data::binary(), Number_Of_Bytes::non_neg_integer()) -> {binary(), binary(), binary()}
Used 16-bit address value from after the post-byte
Indirect mode only in which the effective address is determined by
first getting an address from the value of the 16-bits, and then getting
an another address from that memory location
Returns: {value, CPU_Data, New_Position}
---- Unit-Tested ----
extended_indirect_16_bit_address_address_only(Pos::binary(), Data::binary(), CPU_Data::binary(), Number_Of_Bytes::non_neg_integer()) -> {binary(), binary(), binary()}
Used 16-bit address value from after the post-byte
Indirect mode only in which the effective address is determined by
first getting an address from the value of the 16-bits, and then getting
an another address from that memory location
Returns: {address, CPU_Data, New_Position}
---- Unit-Tested ----
generate_n_z_flags_map(Value::binary()) -> #{}
Get the flag map of the value for n and z flags
---- Unit-Tested ----
get_byte_pos(Data, Pos) -> any()
get_lower_8_reg_16(Reg_16_Binary::binary()) -> binary()
Extracts the lower 8 bytes of a 16 bit register
---- Unit-Tested ----
get_n_flag_of_value(Value::binary()) -> binary()
Get the Negative Flag from a value
---- Unit-Tested ----
get_register_from_name(Reg_Name::atom(), CPU::binary()) -> binary()
Gets the Register based on name (atom)
---- Unit-Tested ----
get_size_of_register(Reg::atom()) -> non_neg_integer()
Get the bit size of a register (atom)
---- Unit-Tested ----
get_z_flag_of_value(Value::binary()) -> binary()
Get the Zero Flag from a value
---- Unit-Tested ----
immediate_1_address(Pos::binary(), Data::binary(), CPU_Data::binary()) -> {binary(), binary(), binary()}
Get the immediate data (8-bit) at pos from the Data
Returns: {immediate_data_8, CPU_Data, New_Position}
---- Unit-Tested ----
immediate_2_address(Pos::binary(), Data::binary(), CPU_Data::binary()) -> {binary(), binary(), binary()}
Get the immediate data (16-bit) at pos from the Data
Returns: {immediate_data_16, CPU_Data, New_Position}
---- Unit-Tested ----
index_reg_set_value(RR::non_neg_integer(), CPU_Data::binary(), Value::integer()) -> binary()
Set a value to a register determined by RR encoding
Returns: updated CPU_Data
---- Unit-Tested ----
index_reg_value(RR::non_neg_integer(), CPU_Data::binary()) -> integer()
Extracts the value of the encode Register RR from the provided CPU_Data
Returns: Integer Value not binary value
---- Unit-Tested ----
indexed_1_address(Pos, Data, CPU_Data) -> any()
indexed_1_address_address_only(Pos, Data, CPU_Data) -> any()
indexed_2_address(Pos, Data, CPU_Data) -> any()
indexed_2_address_address_only(Pos, Data, CPU_Data) -> any()
indexed_address(Pos, Data, CPU_Data, Number_Of_Bytes) -> any()
indexed_address_address_only(Pos, Data, CPU_Data, Number_Of_Bytes) -> any()
pc_1_inc(CPU_Data::binary()) -> binary()
Takes a CPU_Data and increases the PC value by 1
Returns: updated CPU_Data
---- Unit-Tested ----
pc_2_inc(CPU_Data::binary()) -> binary()
Takes a CPU_Data and increases the PC value by 2
Returns: updated CPU_Data
---- Unit-Tested ----
pos_inc(Pos::binary()) -> binary()
Increase the POS Address by one
---- Unit-Tested ----
pos_inc2(Pos::binary()) -> binary()
Increase the POS Address by two
---- Unit-Tested ----
pos_inc_n(Pos::binary(), N::integer()) -> binary()
Increase the POS Address by N
---- Unit-Tested ----
post_byte_16_offset_pc_direct(Offset::integer()) -> binary()
Generates a Post-Byte for Indexed 16-bit Offset from PC Direct Addressing
Returns: Post_Byte size 3
---- Unit-Tested ----
post_byte_16_offset_pc_indirect(Offset::integer()) -> binary()
Generates a Post-Byte for Indexed 16-bit Offset from PC Indirect Addressing
Returns: Post_Byte size 3
---- Unit-Tested ----
post_byte_8_offset_pc_direct(Offset::integer()) -> binary()
Generates a Post-Byte for Indexed 8-bit Offset from PC Direct Addressing
Returns: Post_Byte size 2
---- Unit-Tested ----
post_byte_8_offset_pc_indirect(Offset::integer()) -> binary()
Generates a Post-Byte for Indexed 8-bit Offset from PC Indirect Addressing
Returns: Post_Byte size 2
---- Unit-Tested ----
post_byte_extended_16_address_indirect(Address::binary()) -> binary()
Generates a Post-Byte for Extended 16-bit Offset Indirect Addressing
Returns: Post_Byte size 3
---- Unit-Tested ----
post_byte_indexed_16_offset_r_direct(R::atom(), Offset::integer()) -> binary()
Generates a Post-Byte for Indexed 16-bit Offset from R Direct Addressing
Returns: Post_Byte size 3
---- Unit-Tested ----
post_byte_indexed_16_offset_r_indirect(R::atom(), Offset::integer()) -> binary()
Generates a Post-Byte for Indexed 16-bit Offset from R Indirect Addressing
Returns: Post_Byte size 3
---- Unit-Tested ----
post_byte_indexed_16_offset_w_direct(Offset::integer()) -> binary()
Generates a Post-Byte for Indexed 16-bit Offset from W Direct Addressing
Returns: Post_Byte size 3
---- Unit-Tested ----
post_byte_indexed_16_offset_w_indirect(Offset::integer()) -> binary()
Generates a Post-Byte for Indexed 16-bit Offset from W Indirect Addressing
Returns: Post_Byte size 3
---- Unit-Tested ----
post_byte_indexed_5_offset_r_direct(R::atom(), Offset::integer()) -> binary()
Generates a Post-Byte for Indexed 5-bit Offset from R Direct Addressing
Returns: Post_Byte size 1
---- Unit-Tested ----
post_byte_indexed_8_offset_r_direct(R::atom(), Offset::integer()) -> binary()
Generates a Post-Byte for Indexed 8-bit Offset from R Direct Addressing
Returns: Post_Byte size 2
---- Unit-Tested ----
post_byte_indexed_8_offset_r_indirect(R::atom(), Offset::integer()) -> binary()
Generates a Post-Byte for Indexed 8-bit Offset from R Indirect Addressing
Returns: Post_Byte size 2
---- Unit-Tested ----
post_byte_indexed_a_offset_r_direct(R::atom()) -> binary()
Generates a Post-Byte for Register A Offset from R Direct Addressing
Returns: Post_Byte size 1
---- Unit-Tested ----
post_byte_indexed_a_offset_r_indirect(R::atom()) -> binary()
Generates a Post-Byte for Register A Offset from R Indirect Addressing
Returns: Post_Byte size 1
---- Unit-Tested ----
post_byte_indexed_b_offset_r_direct(R::atom()) -> binary()
Generates a Post-Byte for Register B Offset from R Direct Addressing
Returns: Post_Byte size 1
---- Unit-Tested ----
post_byte_indexed_b_offset_r_indirect(R::atom()) -> binary()
Generates a Post-Byte for Register B Offset from R Indirect Addressing
Returns: Post_Byte size 1
---- Unit-Tested ----
post_byte_indexed_d_offset_r_direct(R::atom()) -> binary()
Generates a Post-Byte for Register D Offset from R Direct Addressing
Returns: Post_Byte size 1
---- Unit-Tested ----
post_byte_indexed_d_offset_r_indirect(R::atom()) -> binary()
Generates a Post-Byte for Register D Offset from R Indirect Addressing
Returns: Post_Byte size 1
---- Unit-Tested ----
post_byte_indexed_e_offset_r_direct(R::atom()) -> binary()
Generates a Post-Byte for Register E Offset from R Direct Addressing
Returns: Post_Byte size 1
---- Unit-Tested ----
post_byte_indexed_e_offset_r_indirect(R::atom()) -> binary()
Generates a Post-Byte for Register E Offset from R Indirect Addressing
Returns: Post_Byte size 1
---- Unit-Tested ----
post_byte_indexed_f_offset_r_direct(R::atom()) -> binary()
Generates a Post-Byte for Register F Offset from R Direct Addressing
Returns: Post_Byte size 1
---- Unit-Tested ----
post_byte_indexed_f_offset_r_indirect(R::atom()) -> binary()
Generates a Post-Byte for Register F Offset from R Indirect Addressing
Returns: Post_Byte size 1
---- Unit-Tested ----
post_byte_indexed_no_offset_r_direct(R::atom()) -> binary()
Generates a Post-Byte for Indexed No Offset from R Direct Addressing
Returns: Post_Byte size 1
---- Unit-Tested ----
post_byte_indexed_no_offset_r_indirect(R::atom()) -> binary()
Generates a Post-Byte for Indexed No Offset from R Indirect Addressing
Returns: Post_Byte size 1
---- Unit-Tested ----
post_byte_indexed_no_offset_w_direct() -> binary()
Generates a Post-Byte for Indexed No Offset from W Direct Addressing
Returns: Post_Byte size 1
---- Unit-Tested ----
post_byte_indexed_no_offset_w_indirect() -> binary()
Generates a Post-Byte for Indexed No Offset from W Indirect Addressing
Returns: Post_Byte size 1
---- Unit-Tested ----
post_byte_indexed_w_offset_r_direct(R::atom()) -> binary()
Generates a Post-Byte for Register W Offset from R Direct Addressing
Returns: Post_Byte size 1
---- Unit-Tested ----
post_byte_indexed_w_offset_r_indirect(R::atom()) -> binary()
Generates a Post-Byte for Register W Offset from R Indirect Addressing
Returns: Post_Byte size 1
---- Unit-Tested ----
post_byte_post_increment_1_r_direct(R::atom()) -> binary()
Generates a Post-Byte for Post Increment 1 of R Direct Addressing
Returns: Post_Byte size 1
---- Unit-Tested ----
post_byte_post_increment_2_r_direct(R::atom()) -> binary()
Generates a Post-Byte for Post Increment 2 of R Direct Addressing
Returns: Post_Byte size 1
---- Unit-Tested ----
post_byte_post_increment_2_r_indirect(R::atom()) -> binary()
Generates a Post-Byte for Post Increment 2 of R Indirect Addressing
Returns: Post_Byte size 1
---- Unit-Tested ----
post_byte_post_increment_2_w_direct() -> binary()
Generates a Post-Byte for Post Increment 2 of W Direct Addressing
Returns: Post_Byte size 1
---- Unit-Tested ----
post_byte_post_increment_2_w_indirect() -> binary()
Generates a Post-Byte for Post Increment 2 of W Indirect Addressing
Returns: Post_Byte size 1
---- Unit-Tested ----
post_byte_pre_decrement_1_r_direct(R::atom()) -> binary()
Generates a Post-Byte for Pre Decrement 1 of R Direct Addressing
Returns: Post_Byte size 1
---- Unit-Tested ----
post_byte_pre_decrement_2_r_direct(R::atom()) -> binary()
Generates a Post-Byte for Pre Decrement 2 of R Direct Addressing
Returns: Post_Byte size 1
---- Unit-Tested ----
post_byte_pre_decrement_2_r_indirect(R::atom()) -> binary()
Generates a Post-Byte for Pre Decrement 2 of R Indirect Addressing
Returns: Post_Byte size 1
---- Unit-Tested ----
post_byte_pre_decrement_2_w_direct() -> binary()
Generates a Post-Byte for Pre Decrement 2 of W Direct Addressing
Returns: Post_Byte size 1
---- Unit-Tested ----
post_byte_pre_decrement_2_w_indirect() -> binary()
Generates a Post-Byte for Pre Decrement 2 of W Indirect Addressing
Returns: Post_Byte size 1
---- Unit-Tested ----
pretty_print(CPU) -> any()
rr_from_r(R::atom()) -> binary()
Generates RR Register encoding from register name (atom)
---- Unit-Tested ----
set_register_from_name(Reg_Name::atom(), Value::binary(), CPU::binary()) -> binary()
Set the Register based on name (atom) with value
---- Unit-Tested ----
update_condition_codes_from_map(Map::#{}, CPU_Data::binary()) -> binary()
Updates the conditions codes via the Map
Returns the updated CPU representation
---- Unit-Tested ----
Generated by EDoc, Jan 2 2017, 10:30:46.


rails new "project_name"- Start local server for current project on port 3000:
rails server- Start local server for current project on a specified port:
rails server -p "port"- Open console to interact with application from command-line:
rails console- Check current version of rails:
rails --version


Love Stinks (R) ** 1/2 Starring French Stewart, Bridgette Wilson Directed by Jeff Franklin A Review by Frankie Paiva
Attending Love Stinks more than a month before it actually opens, I am actually here with my first movie review (imagine me, 12, and seeing a special screening!) before a movie opens. Luckily, I saw Love Stinks, a film that reminds us just how funny well-used bathroom humor can be.
Seth Winnick (Stewart, Harry from 3rd Rock From the Sun) is a writer for a new sitcom called Jesse & Rebecca. He meets Chelsea (Wilson) at his fellow writer's wedding. Instantly overcome with love he brings to the planetarium to dance under the stars, and their romance begins. She redecorates his apartment and makes him get allergy shots to live with her beloved cat, but she soon becomes more and more controlling.
But what Chelsea is really after is someone to marry. On Valentine's Day Seth says he might marry her in a year, and she settles for it. But when I comes around that time next year, he doesn't propose.  Throwing her cat off a pier (could that be a inspiration from There's Something About Mary popping up again?) and inviting over the sexy bimbo she asked him not to cast on his show.
Yes, the film contains a lot of bathroom humor. However, (I am ashamed to say) that most of it is pretty darn funny. Another nice thing about Love Stinks is the way that the story is told in flashbacks. Stewart gives a fine performance, although his character seems very Harry-ized (read 2nd paragraph) and I wonder if he can do any other types of acting. Also performing well is Tyra Banks, in her movie debut, she adds a different touch to some of the scenes.
Looking for an intelligent and witty sophisticated film? Not one ounce is to be found here, but if your just looking to laugh regularly in a darkened theater for 90 minutes or so, see Love Stinks which gets ** 1/2 stars.
A Review by Frankie Paiva The 12 Year-Old Movie Reviewer E-Mail me at<EMAIL_ADDRESS>The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


#include "gim_geometry.h"
#include "gim_radixsort.h"
#include "gim_array.h"
Go to the source code of this file.
Classes | |
| class | GIM_CONTACT |
Defines | |
| #define | NORMAL_CONTACT_AVERAGE 1 |
Definition in file gim_contact.h.
| #define NORMAL_CONTACT_AVERAGE 1 |
Configuration var for applying interpolation of contact normals
Definition at line 44 of file gim_contact.h.


This is a demo of progressively enhancing an HTML5 form. We'll use native HTML5 features when they are available, and JavaScript fallbacks when they are not. This is using Modernizr for feature detection, Yepnope (built together with Modernizr into a single script) to load scripts and CSS as needed, and jQuery for funzies.


|
Uran
|
Public Member Functions | |
| FunctionFactory () | |
| FunctionFactory (int cap) | |
| FunctionFactory (int cap, float load) | |
| Constant | createConstant (String name, Type type) |
| Function | createFunction (String name, Type...args) |
| Constant | conLookup (String name) |
| Function | funLookup (String name) |
| int | size () |
| void | remove (String name) |
| List< Function > | getAllFunctions () |
| void | updateValue (String name, Value value) |
| Value | getValue (String name) |
| NegFormula | negConstants () |
| String | toString () |
Factory for creating functions and constants, only these functions and constants created by factory are translated to SMT2.
Definition at line 39 of file FunctionFactory.java.
|
inline |
Create a factory with default ini capacity and load factor
Definition at line 47 of file FunctionFactory.java.
|
inline |
Specify an ini capacity.
Definition at line 53 of file FunctionFactory.java.
|
inline |
Specify an ini capacity and load factor
| cap | the initial capacity |
| load | the load factor |
Definition at line 63 of file FunctionFactory.java.
|
inline |
Retrieve an existing constant from the factory
| name | the name of a constant |
an exisitng constant saved in the factory otherwise returns a null value.
otherwise it must be a constant
Definition at line 107 of file FunctionFactory.java.
Create a new constant, and save it into the hash map. No duplicated constant is allowed in the hashmap.
| name | the name of a constant |
| type |
|
a new constant
| NullableFormulaException |
|
| DuplicatedDeclaration |
|
Definition at line 76 of file FunctionFactory.java.
|
inline |
Create a new function with a list of arguments, and save it into the hash map. No duplicated constant is allowed in the hashmap.
| name | the name of a function |
| args |
|
a new function
| NullableFormulaException |
|
| DuplicatedDeclaration |
|
Definition at line 92 of file FunctionFactory.java.
|
inline |
Retrieve an existing function from the factory
| name | the name of a function |
an exisitng function saved in the factory otherwise returns a null value.
Definition at line 120 of file FunctionFactory.java.
|
inline |
Return a list of functions that are perserved in the factory.
Definition at line 147 of file FunctionFactory.java.
|
inline |
Get the specific value for a function from our symbol table If no such function is found, a null value is returned.
Definition at line 174 of file FunctionFactory.java.
|
inline |
Definition at line 183 of file FunctionFactory.java.
|
inline |
Remove a function.
Definition at line 139 of file FunctionFactory.java.
|
inline |
Return the number of functions perserved by the factory
Definition at line 133 of file FunctionFactory.java.
|
inline |
Return a string representation of all functions.
Definition at line 208 of file FunctionFactory.java.
|
inline |
Update a specific function with an assignment returned by the SMT solver.
Definition at line 158 of file FunctionFactory.java.


This service does have its own web API. I'm not sure why you would you use it in your app, but, maybe for entertainment purposes, it will be cool to use it.
package require http package require tls package require base64 http::register https 443 tls::socket ;# use TLS set url "https://catlanguage.herokuapp.com/do-cat" set token [http::geturl $url -query {Hey}] set status [http::status $token] set answer [http::data $token] http::cleanup $token http::unregister https if {$status == {ok}} { puts $answer }Output (if everything goes ok):
meoow meoow, meew, mow meew


AbstractAggregator
Aggregate
AggregateBuilder
AggregateBuilder.PerClause
Aggregator
Chart
ChartFactory
ConnectionString
ConnectionString.EmbeddedConnectionString
ConnectionString.RemoteConnectionString
Database
Datasets
DataType
DataTypes
DbFactories
DbFactory
DerbyFactory
Diagram
DiagramFactory
DiagramFactory.DiagramImpl
ExcelWriter
Filter
Filters
GnuPlotContext
GnuPlotWriter
GnuPlotWriter.GnuPlotFiles
Order
Orders
Pattern
PlotStyle
Record
Records
ReportBuilder
Schema
SQLRuntimeException
StringUtils
Timestamps
|


The DOM (Document Object Model) is a cross-platform API that treats HTML and XML documents as a tree structure consisting of nodes. These nodes (such as elements and text nodes) are objects that can be programmatically manipulated and any visible changes made to them are reflected live in the document. In a browser, this API is available to JavaScript where DOM nodes can be manipulated to change their styles, contents, placement in the document, or interacted with through event listeners.
<head>
with a defer
attribute, or inside a DOMContentLoaded
event listener. Scripts that manipulate DOM nodes should be run after the DOM has been constructed to avoid errors.document.getElementById()
and document.querySelector()
are common functions for selecting DOM nodes.innerHTML
property to a new value runs the string through the HTML parser, offering an easy way to append dynamic HTML content to a node.


Mitchell reveals he turned down Super Rugby coaching gig
Cape Town - England defence coach John Mitchell has revealed that he turned down a coaching opportunity at Super Rugby outfit the Chiefs.
In an interview with the New Zealand Herald, Mitchell said he was offered the assistant coach role at the Hamilton-based franchise.
He would have worked alongside head coach Warren Gatland, who recently returned to his home country after coaching Wales.
Mitchell said the job had the added incentive of stepping into the head coaching role while Gatland takes a sabbatical in 2021 to coach the British and Irish Lions on their tour to South Africa.
"Emotionally it felt really good but sitting down with family and looking through it I've made the right decision at this time in my career," Mitchell said.
Mitchell became England defence coach in September last year after ending his tenure at the Bulls, where he was executive of rugby.
He accepted two-year contract extension prior to the Rugby World Cup to stay on as England defence coach under Eddie Jones.
Mitchell and Jones recently masterminded a 19-7 demolition of the All Blacks in the Rugby World Cup semi-finals, before their team lost 32-12 in the final to the Springboks.
- Compiled by Herman Mostert


Type something in the input field to search the table for resource no, names or links

| Resource No | Resource Name | Resource Desription | Unit of Competency | Resource Location |
|---|---|---|---|---|
| VR Room 1 | Clinic | Sample description | employability skills 1 | https://rmit.instructure.com/courses/64236/pages/virutal-wp-test |
| VR Room 2 | Laboratory | Sample description | employability skills 2 | https://rmit.instructure.com/courses/64236/pages/virutal-wp-test |
| VR Room 3 | Nurses station | Sample description | employability skills 3 | https://rmit.instructure.com/courses/64236/pages/virutal-wp-test |
| VR Room 4 | Reception | Sample description | employability skills 4 | https://rmit.instructure.com/courses/64236/pages/virutal-wp-test |
| VR Room 5 | Nurses station | Sample description | employability skills 5 | https://rmit.instructure.com/courses/64236/pages/virutal-wp-test |
| VR Room 6 | Intranet Simulation | Sample description | employability skills 6 | https://rmit.instructure.com/courses/64236/pages/virutal-wp-test |
| VR Room 7 | Incident Management | Sample description | employability skills 7 | https://rmit.instructure.com/courses/64236/pages/virutal-wp-test |
| VR Room 8 | Knowledge Base | Sample description | employability skills 8 | https://rmit.instructure.com/courses/64236/pages/virutal-wp-test |
| VR Room 9 | Home page | Sample description | employability skills 9 | https://rmit.instructure.com/courses/64236/pages/virutal-wp-test |
| VR Room 10 | Document repo | Sample description | employability skills 10 | https://rmit.instructure.com/courses/64236/pages/virutal-wp-test |
Note: These resources are only available to teachers