IMPLEMENTATION MODULE DecodeArg ;
(*
        Title:          PANOS Argument decoding module.
        Author:         Keith Rautenbach
        History:
           20-Jul-1984 Initial Version.
*)

FROM SYSTEM IMPORT WORD , ADR , CALLEXTPROC , CALLEXTFUNC ;

TYPE
   DecodedInformation         = WORD ;

(* ----------------------------------------------------------------------------
   DecodeInit(STRING:KeyString,
              STRING:ArgumentString);INTEGER:Result,
                                     ADDRESS:DecodedArguments
*)
PROCEDURE DecodeInit( VAR DecodedArguments : DecodedInformation ;
                      KeyString : ARRAY OF CHAR ;
                      ArgumentString : ARRAY OF CHAR ) : INTEGER ;
BEGIN
   RETURN INTEGER( CALLEXTFUNC( "DecodeInit" ,
                                ADR( DecodedArguments ) ,
                                ADR( KeyString[ 0 ] ) ,
                                   HIGH( KeyString ) ,
                                ADR( ArgumentString[ 0 ] ) ,
                                   HIGH( ArgumentString ) ) ) ;
END DecodeInit ;

(* ----------------------------------------------------------------------------
   GetStringArg(STRING  :Argumentname,
                CARDINAL:Index,
                ADDRESS :DecodedArguments);INTEGER:ResultCode,
                                           STRING:Arg
*)
PROCEDURE GetStringArg( VAR Arg : ARRAY OF CHAR ;
                        VAR ArgLength : CARDINAL ;
                        ArgumentName : ARRAY OF CHAR ;
                        Index : CARDINAL ;
                        DecodedArguments : DecodedInformation ) : INTEGER ;
BEGIN
   RETURN INTEGER( CALLEXTFUNC( "GetStringArg" ,
                                ADR( Arg[ 0 ] ) ,
                                   HIGH( Arg ) ,
                                ADR( ArgLength ) ,
                                ADR( ArgumentName[ 0 ] ) ,
                                   HIGH( ArgumentName ) ,
                                Index ,
                                DecodedArguments ) ) ;
END GetStringArg ;

(* ----------------------------------------------------------------------------
   GetStateArg(STRING  :Argumentname,
               ADDRESS :DecodedArguments);INTEGER:ResultCode,
                                          BOOLEAN:Arg
*)
PROCEDURE GetStateArg( VAR Arg : BOOLEAN ;
                       ArgumentName : ARRAY OF CHAR ;
                       DecodedArguments : DecodedInformation ) : INTEGER ;
BEGIN
   RETURN INTEGER( CALLEXTFUNC( "GetStateArg" ,
                                ADR( Arg ) ,
                                ADR( ArgumentName[ 0 ] ) ,
                                   HIGH( ArgumentName ) ,
                                DecodedArguments ) ) ;
END GetStateArg ;

(* ----------------------------------------------------------------------------
   GetIntegerArg(STRING  :Argumentname,
                 CARDINAL:Index,
                 ADDRESS :DecodedArguments);INTEGER:ResultCode,
                                            INTEGER:Arg
*)
PROCEDURE GetIntegerArg( VAR Arg : INTEGER ;
                         ArgumentName : ARRAY OF CHAR ;
                         Index : CARDINAL ;
                         DecodedArguments : DecodedInformation ) : INTEGER ;
BEGIN
   RETURN INTEGER( CALLEXTFUNC( "GetIntegerArg" ,
                                ADR( Arg ) ,
                                ADR( ArgumentName[ 0 ] ) ,
                                   HIGH( ArgumentName ) ,
                                Index ,
                                DecodedArguments ) ) ;
END GetIntegerArg ;

(* ----------------------------------------------------------------------------
   GetCardinalArg(STRING  :Argumentname,
                  CARDINAL:Index,
                  ADDRESS :DecodedArguments);INTEGER:ResultCode,
                                             CARDINAL:Arg
*)
PROCEDURE GetCardinalArg( VAR Arg : CARDINAL ;
                          ArgumentName : ARRAY OF CHAR ;
                          Index : CARDINAL ;
                          DecodedArguments : DecodedInformation ) : INTEGER ;
BEGIN
   RETURN INTEGER( CALLEXTFUNC( "GetCardinalArg" ,
                                ADR( Arg ) ,
                                ADR( ArgumentName[ 0 ] ) ,
                                   HIGH( ArgumentName ) ,
                                Index ,
                                DecodedArguments ) ) ;
END GetCardinalArg ;

(* ----------------------------------------------------------------------------
   GetNumberOfValues(STRING  :Argumentname,
                     ADDRESS :DecodedArguments);INTEGER:ResultCode,
                                                CARDINAL:Number
*)
PROCEDURE GetNumberOfValues( VAR Number : CARDINAL ;
                             ArgumentName : ARRAY OF CHAR ;
                             DecodedArguments : DecodedInformation ): INTEGER ;
BEGIN
   RETURN INTEGER( CALLEXTFUNC( "GetNumberOfValues" ,
                                ADR( Number ) ,
                                ADR( ArgumentName[ 0 ] ) ,
                                   HIGH( ArgumentName ) ,
                                DecodedArguments ) ) ;
END GetNumberOfValues ;

(* ----------------------------------------------------------------------------
   Substitute(STRING:String, HIDDEN:DecodedInformation);
              INTEGER:ResultCode, STRING:SubstitutedString
*)
PROCEDURE Substitute( VAR ResultString : ARRAY OF CHAR ;
                      VAR ResultLength : CARDINAL ;
                      String : ARRAY OF CHAR ;
                      DecodedArguments : DecodedInformation ) : INTEGER ;
BEGIN
   RETURN INTEGER( CALLEXTFUNC( "Substitute" ,
                                ADR( ResultString[ 0 ] ) ,
                                   HIGH( ResultString ) ,
                                ADR( ResultLength ) ,
                                ADR( String[ 0 ] ) ,
                                   HIGH( String ) ,
                                DecodedArguments ) ) ;
END Substitute ;

(* ----------------------------------------------------------------------------
   DecodeEnd(ADDRESS :DecodedArguments);INTEGER:ResultCode
*)
PROCEDURE DecodeEnd( DecodedArguments : DecodedInformation ) : INTEGER ;
BEGIN
   RETURN INTEGER( CALLEXTFUNC( "DecodeEnd" , DecodedArguments ) ) ;
END DecodeEnd ;

(* ========================================================================= *)

(*   Xprocedure forms of the above .... *)

(* ----------------------------------------------------------------------------
   XDecodeInit(STRING:KeyString,
               STRING:ArgumentString);ADDRESS:DecodedArguments
*)
PROCEDURE XDecodeInit( KeyString : ARRAY OF CHAR ;
                       ArgumentString : ARRAY OF CHAR ) : DecodedInformation ;

BEGIN
   RETURN DecodedInformation( CALLEXTFUNC( "XDecodeInit" ,
                                           ADR( KeyString[ 0 ] ) ,
                                              HIGH( KeyString ) ,
                                           ADR( ArgumentString[ 0 ] ) ,
                                              HIGH( ArgumentString ) ) ) ;
END XDecodeInit ;

(* ----------------------------------------------------------------------------
   XGetStringArg(STRING  :Argumentname,
                 CARDINAL:Index,
                 ADDRESS :DecodedArguments);STRING:Arg
*)
PROCEDURE XGetStringArg( VAR Arg : ARRAY OF CHAR ;
                         ArgumentName : ARRAY OF CHAR ;
                         Index : CARDINAL ;
                         DecodedArguments : DecodedInformation ) : CARDINAL ;
BEGIN
   RETURN CARDINAL( CALLEXTFUNC( "XGetStringArg" ,
                                 ADR( Arg ) ,
                                    HIGH( Arg ) ,
                                 ADR( ArgumentName ) ,
                                    HIGH( ArgumentName ) ,
                                 Index ,
                                 DecodedArguments ) ) ;
END XGetStringArg ;

(* ----------------------------------------------------------------------------
   XGetStateArg(STRING  :Argumentname,
                ADDRESS :DecodedArguments);BOOLEAN:Arg
*)
PROCEDURE XGetStateArg( ArgumentName : ARRAY OF CHAR ;
                        DecodedArguments : DecodedInformation ) : BOOLEAN ;
BEGIN
   RETURN BOOLEAN( CALLEXTFUNC( "XGetStateArg" ,
                                ADR( ArgumentName ) ,
                                   HIGH( ArgumentName ) ,
                                DecodedArguments ) ) ;
END XGetStateArg ;

(* ----------------------------------------------------------------------------
   XGetIntegerArg(STRING  :Argumentname,
                  CARDINAL:Index,
                  ADDRESS :DecodedArguments);INTEGER:Arg
*)
PROCEDURE XGetIntegerArg( ArgumentName : ARRAY OF CHAR ;
                          Index : CARDINAL ;
                          DecodedArguments : DecodedInformation ) : INTEGER ;
BEGIN
   RETURN INTEGER( CALLEXTFUNC( "XGetIntegerArg" ,
                                ADR( ArgumentName ) ,
                                   HIGH( ArgumentName ) ,
                                Index ,
                                DecodedArguments ) ) ;
END XGetIntegerArg ;

(* ----------------------------------------------------------------------------
   XGetCardinalArg(STRING  :Argumentname,
                   CARDINAL:Index,
                   ADDRESS :DecodedArguments);CARDINAL:Arg
*)
PROCEDURE XGetCardinalArg( ArgumentName : ARRAY OF CHAR ;
                           Index : CARDINAL ;
                           DecodedArguments : DecodedInformation ) : CARDINAL ;
BEGIN
   RETURN CARDINAL( CALLEXTFUNC( "XGetCardinalArg" ,
                                 ADR( ArgumentName ) ,
                                    HIGH( ArgumentName ) ,
                                 Index ,
                                 DecodedArguments ) ) ;
END XGetCardinalArg ;

(* ----------------------------------------------------------------------------
   XGetNumberOfValues(STRING  :Argumentname,
                      ADDRESS :DecodedArguments);CARDINAL:Number
*)
PROCEDURE XGetNumberOfValues( ArgumentName : ARRAY OF CHAR ;
                              DecodedArguments : DecodedInformation ):CARDINAL;
BEGIN
   RETURN CARDINAL( CALLEXTFUNC( "XGetNumberOfValues" ,
                                 ADR( ArgumentName ) ,
                                    HIGH( ArgumentName ) ,
                                 DecodedArguments ) ) ;
END XGetNumberOfValues ;

(* ----------------------------------------------------------------------------
   XSubstitute(STRING:String, HIDDEN:DecodedInformation);
               STRING:SubstitutedString
*)
PROCEDURE XSubstitute( VAR ResultString : ARRAY OF CHAR ;
                       VAR ResultLength : CARDINAL ;
                       String : ARRAY OF CHAR ;
                       DecodedArguments : DecodedInformation ) ;
BEGIN
   CALLEXTPROC( "XSubstitute" ,
                ADR( ResultString[ 0 ] ) ,
                   HIGH( ResultString ) ,
                ADR( ResultLength ) ,
                ADR( String[ 0 ] ) ,
                   HIGH( String ) ,
                DecodedArguments ) ;
END XSubstitute ;
(* ----------------------------------------------------------------------------
   XDecodeEnd(ADDRESS :DecodedArguments)
*)
PROCEDURE XDecodeEnd( DecodedArguments : DecodedInformation ) ;
BEGIN
   CALLEXTPROC( "XDecodeEnd" ,
                DecodedArguments ) ;
END XDecodeEnd ;


END DecodeArg.