PASCAL MACRO COMPILER
Decimal String Comparison Macros

The following macros generate comparisons between integers that are represented as strings of decimal digits. For example, the integer 123 would be represented as a string of 3 decimal digits, namely '123'. Signs and leading zeroes are not allowed.

The ordinary string comparisons in Pascal cannot be used for directly comparing integers in string form, because the comparison goes left to right. Thus a Pascal string comparison would consider the string '25' to be greater than the string '190'. Since 190 is greater than 25 the decimal string comparisons should consider '190' to be greater than '25'.

The macros can handle unsigned integers of up to 255 decimal digits. They can also handle binary or hexadecimal numbers represented as strings, such as '777FFFFFF000C' provided that a single case is used consistently for hex digits greater than 9. That is, the digits A-F should not be written in lowercase in some places and uppercase in other places in the same program.

These macros generate comparisons that can be used in If, While and Until statements. For example,
if DecLE(counter,limit)
then xxx else yyy;

while DecLT(time,'1000')
do xxx;

repeat
xxx
until DecGT(errorcode,warning);
The decimal comparison macros generate in-line code. This is faster than calling Pascal procedures to compare the strings. They use only comparisons, so that they are much faster than converting the strings to integers and then comparing the integers.

Comparisons for Equal and Not Equal are not included, since these can be written directly in Pascal, for example
if value='9999999999'
then exit;
The macro headers, or prologues, describe how the comparison macros are used.

{Generate comparisons between unsigned decimal numbers}
{that are represented as strings of decimal digits.	}
{For example, the number 123 would be represented as	}
{the string '123'.  The strings may not have leading  }
{zeroes.  Thus 123 could be '123' but not '0123'.     }

{The generated comparisons may be used in IF, WHILE	}
{and UNTIL conditions, for example			}
{   if  DecLE(counter,limit)				}
{	  then xxx else yyy;				}
{   while  DecLT(time,'1000')                         }
{	do xxx; 					}
{   repeat						}
{	xxx						}
{   until  DecGT(errorcode,warning);			}
{These comparisons produce inline code, which is much }
{faster than calling comparison functions.		}

{DecGE  Greater than or equal 			}
{DecGT  Greater than					}
{DecLE  Less than or equal				}
{DecLT  Less than					}

{   It is not necessary to use macros to generate	}
{Equal and Not Equal comparisons for decimal strings, }
{as these may be done directly in Pascal, for example }
{   if  SerialNumber = LastNumber			}
{	  then	CloseOut;				}

{Test whether one decimal string is numerically}
{Greater than or Equal to another.		 }
{Example:  DecGE('100','99') gives True.      }
%Function  DecGE (st1,st2: code): string;
%Var
compare: code;
%Begin	{DecGE}
%compare :=(length(st1) > length(st2)) or
((length(st1) = length(st2)) and (st1 >= st2))%;
%DecGe := %code compare;
%End;	{DecGE}

{Test whether one decimal string is numerically}
{Greater Than another.			 }
{Example:  DecGT('100','99') gives True.       }
%Function  DecGT (st1,st2: code): string;
%Var
compare: code;
%Begin	{DecGT}
%compare :=(length(st1) > length(st2)) or
((length(st1) = length(st2)) and (st1 > st2))%;
%DecGT := %code compare;
%End;	{DecGT}

{Test whether one decimal string is numerically}
{Less than or Equal to another.		 }
{Example:  DecLE('100','99') gives False       }
%Function  DecLE (st1,st2: code): string;
%Var
compare: code;
%Begin	{DecLE}
%compare :=(length(st1) < length(st2)) or
((length(st1) = length(st2)) and (st1 <= st2))%;
%DecLe := %code compare;
%End;	{DecLE}

{Test whether one decimal string is numerically}
{Less Than another.				 }
{Example:  DecLT('100','99') gives False.      }
%Function  DecLT (st1,st2: code): string;
%Var
compare: code;
%Begin	{DecLT}
%compare :=(length(st1) < length(st2)) or
((length(st1) = length(st2)) and (st1 < st2))%;
%DecLT := %code compare;
%End;	{DecLT}