Binary coded decimal: Difference between revisions

The 6502 is a bit different in that it has a special operating mode where all addition and subtraction is handled as binary-coded decimal. Like the 68000, this must be invoked ahead of time, rather than using the Intel method of doing the math normally and then correcting it after the fact. (This special operating mode won't work on the aforementioned Ricoh 2A03, which performs math in "normal" mode even if the decimal flag is set.)

 

lda #$19

clc

=={{header|68000 Assembly}}==

The 68000 has special mathematics commands for binary-coded decimal. However, they only work at byte length, and cannot use immediate operands. Even adding by 1 this way requires you to load 1 into a register first.

MOVEQ #1,D1

MOVEQ #0,D2

=={{header|ALGOL 68}}==

Algol 68 does not have BCD as standard. This sample implements 2-digit unsigned packed decimal numbers, similar to the [[#PL/M|PL/M]] sample. The 2-digit numbers are then used to provide addition/subtraction of larger numbers.

INT x99 = ( 9 * 16 ) + 9; # maximum unsigned 2-digit BCD value #

# structure to hold BCD values #

023456790012 - 011111111111 = 012345678901

</pre>

=={{header|ALGOL W}}==

{{Trans|ALGOL 68}}

integer X99; % maximum unsigned 2-digit BCD value %

% structure to hold BCD values %

023456790012 - 011111111111 = 012345678901

</pre>

=={{header|Forth}}==

This code implements direct BCD arithmetic using notes from Douglas Jones from the University of Iowa: https://homepage.cs.uiowa.edu/~jones/bcd/bcd.html#packed

\ add two 15 digit bcd numbers

\

99 1 bcd+ . 100 ok

</pre>

=={{header|J}}==

 

Here, we represent hexadecimal numbers using J's constant notation, and to demonstrate bcd we generate results in that representation:

 

16b19 +bcd 1

16b20

For reference, here are decimal and binary representations of the above numbers:

 

25 2b11001

(":,_16{.' '-.~'2b',":@#:) 16b20

25

NB. ...</syntaxhighlight>

=={{header|Julia}}==

Handles negative and floating point numbers (but avoid BigFloats due to very long decimal places from binary to decimal conversion).

 

"""

BCD 99 (UInt8[0x99]) + BCD 1 ((UInt8[0x01], 1)[1]) = BCD 100 ((UInt8[0x01, 0x00], 1))

</pre>

=={{header|Pascal}}==

==={{header|Free Pascal}}===

There exist a special unit for BCD, even with fractions.Obvious for Delphi compatibility.

// See https://wiki.freepascal.org/BcdUnit

{$IFDEF FPC} {$MODE objFPC}{$ELSE} {$APPTYPE CONSOLE} {$ENDIF}

99*99 =9801

</pre>

=={{header|Phix}}==

=== using fbld and fbstp ===

The FPU maths is all as normal (decimal), it is only the load and store that convert from/to BCD.<br>

While I supply everything in decimal, you could easily return and pass around the likes of acc and res.

<span style="color: #008080;">without</span> <span style="color: #008080;">javascript_semantics</span> <span style="color: #000080;font-style:italic;">-- (not a chance!)</span>

<span style="color: #7060A8;">requires</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"1.0.2"</span><span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- #ilASM{fbld, fbstp} added</span>

The aaa, aas, aam, and aad instructions are also available.

Same output as above, of course

<span style="color: #008080;">without</span> <span style="color: #008080;">javascript_semantics</span> <span style="color: #000080;font-style:italic;">-- (not a chance!)</span>

<span style="color: #7060A8;">requires</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"1.0.2"</span><span style="color: #0000FF;">)</span> <span style="color: #000080;font-style:italic;">-- #ilASM{aaa, etc} added</span>

With routines to convert between decimal and bcd, same output as above, of course.

No attempt has been made to support fractions or negative numbers...

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span> <span style="color: #000080;font-style:italic;">-- (no requires() needed here)</span>

<span style="color: #008080;">function</span> <span style="color: #000000;">bcd_decode</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">bcd</span><span style="color: #0000FF;">)</span>

<span style="color: #000000;">test3</span><span style="color: #0000FF;">(</span><span style="color: #000000;">99</span><span style="color: #0000FF;">,</span><span style="color: #008000;">'+'</span><span style="color: #0000FF;">)</span>

<!--</syntaxhighlight>-->

=={{header|PL/M}}==

{{works with|8080 PL/M Compiler}} ... under CP/M (or an emulator)

The 8080 PL/M compiler supports packed BCD by wrapping the 8080/Z80 DAA instruction with the DEC built in function, demonstrated here. Unfortunately, I couldn't get the first use of DEC to yeild the correct result without first doing a shift operation. Not sure if this is a bug in the program, the compiler or the 8080 emulator or that I'm misunderstanding something...

This is basically {{Trans|Z80 Assembly}}

 

BDOS: PROCEDURE( FN, ARG ); /* CP/M BDOS SYSTEM CALL */

 

A more complex example, showing how the DEC function can be used to perform unsigned BCD addition and subtraction on arbitrary length BCD numbers.

 

BDOS: PROCEDURE( FN, ARG ); /* CP/M BDOS SYSTEM CALL */

023456790012 - 011111111111 = 012345678901

</pre>

=={{header|Rust}}==

Based on the Forth implementation re: how to implement BCD arithmetic in software. Uses operator overloading for new BCD type.

#[derive(Copy, Clone)]

pub struct Bcd64 {

test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s

</pre>

=={{header|Wren}}==

{{libheader|Wren-check}}

 

In what follows, the hex prefix '0x' is simply a way of representing BCD literals and has nothing to do with hexadecimal as such.

import "./math" for Int

import "./str" for Str

0x99 + 1 = 0x100 or, in unpacked BCD, 100100001001 + 1 = 10000000000000000

</pre>

=={{header|Z80 Assembly}}==

The <code>DAA</code> function will convert an 8-bit hexadecimal value to BCD after an addition or subtraction is performed. The algorithm used is actually quite complex, but the Z80's dedicated hardware for it makes it all happen in 4 clock cycles, tied with the fastest instructions the CPU can perform.

 

PrintChar equ &BB5A ;Amstrad CPC kernel's print routine

org &1000