Integer overflow: Difference between revisions

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

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

8080 PL/M does not check for overflow, incrementing the largest integer values wraps around to 0 (numbers are insigned in 8080 PL/M).

<lang pli>100H: /* SHOW INTEGER OVERFLOW */

/* CP/M SYSTEM CALL */

BDOS: PROCEDURE( FN, ARG ); DECLARE FN BYTE, ARG ADDRESS; GOTO 5; END;

/* CONSOLE I/O ROUTINES */

PRCHAR: PROCEDURE( C ); DECLARE C BYTE; CALL BDOS( 2, C ); END;

PRSTRING: PROCEDURE( S ); DECLARE S ADDRESS; CALL BDOS( 9, S ); END;

PRNL: PROCEDURE; CALL PRCHAR( 0DH ); CALL PRCHAR( 0AH ); END;

PRNUMBER: PROCEDURE( N );

DECLARE N ADDRESS;

DECLARE V ADDRESS, N$STR( 6 ) BYTE, W BYTE;

N$STR( W := LAST( N$STR ) ) = '$';

N$STR( W := W - 1 ) = '0' + ( ( V := N ) MOD 10 );

DO WHILE( ( V := V / 10 ) > 0 );

N$STR( W := W - 1 ) = '0' + ( V MOD 10 );

END;

CALL PRSTRING( .N$STR( W ) );

END PRNUMBER;

/* TASK */

/* THE ONLY TYPES SUPPORTED BY THE ORIGINAL PL/M COMPILER ARE */

/* UNSIGED, BYTE IS 8 BITS AND ADDRESS IS 16 BITS */

DECLARE SV BYTE, LV ADDRESS;

SV = 255; /* MAXIMUM BYTE VALUE */

LV = 65535; /* MAXIMUM ADDRESS VALUE */

CALL PRSTRING( .'8-BIT: $' );

CALL PRNUMBER( SV );

CALL PRSTRING( .' INCREMENTS TO: $' );

SV = SV + 1;

CALL PRNUMBER( SV );

CALL PRNL;

CALL PRSTRING( .'16-BIT: $' );

CALL PRNUMBER( LV );

CALL PRSTRING( .' INCREMENTS TO: $' );

LV = LV + 1;

CALL PRNUMBER( LV );

CALL PRNL;

EOF</lang>

{{out}}

<pre>

8-BIT: 255 INCREMENTS TO: 0

16-BIT: 65535 INCREMENTS TO: 0

</pre>