Obfuscation in ABL

Hi All,

A little PROGRESS gem we could all learn a great deal from.

One of our colleagues has written a little gem. See below.

PS: It runs and only displays a message!!

Regards

Jonny

/* Author: Dayne May */

/* Date: 20/Dec/2006 */

DEFINE VARIABLE ALERT-BOX AS CHARACTER NO-UNDO.

DEFINE VARIABLE ORDINAL AS INTEGER NO-UNDO EXTENT 25.

DEFINE VARIABLE CHARACTER AS INTEGER NO-UNDO.

DEFINE VARIABLE COMBO-BOX AS DECIMAL NO-UNDO.

RUN SUB-MENU. RUN MODULO.

DEFINE VARIABLE STRING AS INTEGER NO-UNDO.

DEFINE VARIABLE ABSOLUTE LIKE STRING NO-UNDO.

DEFINE VARIABLE PROCEDURE LIKE ABSOLUTE NO-UNDO.

DEFINE VARIABLE FUNCTION LIKE CHARACTER NO-UNDO.

DEFINE VARIABLE MODULO LIKE PROCEDURE.

PROCEDURE MODULO. MESSAGE ALERT-BOX. END PROCEDURE.

DEFINE VARIABLE MAXIMUM LIKE FUNCTION NO-UNDO.

DEFINE VARIABLE DECIMAL LIKE ORDINAL NO-UNDO.

DEFINE VARIABLE MINIMUM LIKE MAXIMUM NO-UNDO.

DEFINE VARIABLE COM-HANDLE LIKE CHARACTER NO-UNDO.

/**********************/

/* PROCEDURE Sub-Menu */

/**********************/

PROCEDURE SUB-MENU.

ASSIGN

CHARACTER = NO-LOCK MODULO ( EXCLUSIVE-LOCK - NO-WAIT ) COM-HANDLE = ( EXCLUSIVE-LOCK

- NO-WAIT ) MOD CHARACTER FUNCTION = ABSOLUTE ( CHARACTER ) * MINIMUM (

COM-HANDLE, CHARACTER ) MAXIMUM = ( FUNCTION + CHARACTER ) MODULO COM-HANDLE

ABSOLUTE = MAXIMUM - (FUNCTION MODULO MAXIMUM ) STRING = MAXIMUM - ABSOLUTE

( ABSOLUTE ( MINIMUM ( ABSOLUTE, MAXIMUM ) ) ) MINIMUM = ABSOLUTE ( ABSOLUTE

( ABSOLUTE + ABSOLUTE ( ABSOLUTE ) ) ) DECIMAL = FUNCTION *

ABSOLUTE + ( FUNCTION / ( COM-HANDLE * ABSOLUTE ) ) DECIMAL =

MAXIMUM * FUNCTION - ( CHARACTER * ABSOLUTE ) DECIMAL = DECIMAL

+ STRING DECIMAL [ INTEGER ( FUNCTION / ( COM-HANDLE * ABSOLUTE

) ) ] = EXCLUSIVE-LOCK - ( NO-WAIT + ABSOLUTE ) DECIMAL =

ABSOLUTE ( CHARACTER ) * ( ABSOLUTE ( ABSOLUTE + ABSOLUTE ) ) DECIMAL [

COM-HANDLE + STRING ] = DECIMAL DECIMAL [ MINIMUM + ABSOLUTE

+ STRING ] = DECIMAL DECIMAL = DECIMAL [ MAXIMUM (

COM-HANDLE, MAXIMUM , MINIMUM ) ] DECIMAL = DECIMAL [

ABSOLUTE ( MINIMUM ) ] DECIMAL = INTEGER ( STRING (

STRING ) + STRING ( STRING ) + STRING ( STRING ) ) DECIMAL [ INTEGER ( STRING

( STRING ) + STRING ( STRING ) ) ] = MAXIMUM * FUNCTION - INTEGER ( STRING (

STRING ) + STRING ( STRING ) ) DECIMAL = DECIMAL [

CHARACTER + MAXIMUM ] - CHARACTER DECIMAL = DECIMAL

DECIMAL = MAXIMUM * MAXIMUM

( FUNCTION, MAXIMUM ) - STRING * STRING DECIMAL =

DECIMAL DECIMAL [ ABSOLUTE * ABSOLUTE

( MINIMUM * ABSOLUTE ) ] = ( FUNCTION - COM-HANDLE ) * MAXIMUM DECIMAL [

CHARACTER * ABSOLUTE + STRING ] = COM-HANDLE * CHARACTER * MAXIMUM - MAXIMUM

• ABSOLUTE DECIMAL [ MAXIMUM ( MAXIMUM, MAXIMUM ) * MAXIMUM * ABSOLUTE (

ABSOLUTE ) ] = MINIMUM ( COM-HANDLE * MINIMUM * COM-HANDLE, FUNCTION *

FUNCTION ) DECIMAL [ INTEGER ( ABSOLUTE ( FUNCTION / ABSOLUTE ) ) - MINIMUM

( STRING, MINIMUM ) ] = DECIMAL DECIMAL [ INTEGER

( FUNCTION / ABSOLUTE ) ] = DECIMAL DECIMAL [ MAXIMUM * (

COM-HANDLE + ABSOLUTE ) ] = DECIMAL - STRING DECIMAL [ ABSOLUTE

• INTEGER ( STRING ( STRING ) + STRING ( STRING ) ) ] = DECIMAL

DECIMAL = MAXIMUM

• FUNCTION - MINIMUM DECIMAL =

INTEGER ( STRING ( MAXIMUM ) + STRING ( MAXIMUM ) ). DO WHILE

/*************************/

/* PROCEDURE Com-handle */

/*************************/

PROCEDURE < COM-HANDLE * COM-HANDLE:

PROCEDURE = PROCEDURE + ABSOLUTE ( MINIMUM (

STRING, MAXIMUM ) ). ALERT-BOX =

ALERT-BOX + CHR ( DECIMAL [

PROCEDURE ] ).

END. /* PROCEDURE */

END.