Some crypto applications are now being built on Unix, so they should on VMS as...

$!  It was re-written so it would try to determine what "C" compiler to use 

$!  or you can specify which "C" compiler to use.

$!

$!  Specify RSAREF as P1 to compile with the RSAREF library instead of

$!  Specify the following as P1 to build just that part or ALL to just

$!  build everything.

$!

$!    		LIBRARY    To just compile the [.xxx.EXE.CRYPTO]LIBCRYPTO.OLB Library.

$!    		APPS       To just compile the [.xxx.EXE.CRYPTO]*.EXE

$!		ALL	   To do both LIBRARY and APPS

$!

$!  Specify RSAREF as P2 to compile with the RSAREF library instead of

$!  the regular one.  If you specify NORSAREF it will compile with the

$!  regular RSAREF routines.  (Note: If you are in the United States

$!  you MUST compile with RSAREF unless you have a license from RSA).

$!        into the [.RSAREF] directory under the root directory as that

$!        is where the scripts will look for the files.

$!

$!  Specify DEBUG or NODEBUG as P2 to compile with or without debugger

$!  Specify DEBUG or NODEBUG as P3 to compile with or without debugger

$!  information.

$!

$!  Specify which compiler at P3 to try to compile under.

$!  Specify which compiler at P4 to try to compile under.

$!

$!	   VAXC	 For VAX C.

$!	   DECC	 For DEC C.

$!  If you don't speficy a compiler, it will try to determine which

$!  "C" compiler to use.

$!

$!  P4, if defined, sets a TCP/IP library to use, through one of the following

$!  P5, if defined, sets a TCP/IP library to use, through one of the following

$!  keywords:

$!

$!	UCX		for UCX

$!	SOCKETSHR	for SOCKETSHR+NETLIB

$!

$!  P5, if defined, sets a compiler thread NOT needed on OpenVMS 7.1 (and up)

$!  P6, if defined, sets a compiler thread NOT needed on OpenVMS 7.1 (and up)

$!

$!  P6, if defined, sets a choice of crypto methods to compile.

$!  P7, if defined, sets a choice of crypto methods to compile.

$!  WARNING: this should only be done to recompile some part of an already

$!  fully compiled library.

$!

		  "BUFFER,BIO,STACK,LHASH,RAND,ERR,OBJECTS,"+ -

		  "EVP,EVP_2,ASN1,ASN1_2,PEM,X509,X509V3,"+ -

		  "CONF,TXT_DB,PKCS7,PKCS12,COMP"

$ ENCRYPT_PROGRAMS = "DES,PKCS7"

$!

$! Check To Make Sure We Have Valid Command Line Parameters.

$!

$!

$ LIB_NAME := 'EXE_DIR'LIBCRYPTO.OLB

$!

$! Define The CRYPTO-LIB We Are To Use.

$!

$ CRYPTO_LIB := 'EXE_DIR'LIBCRYPTO.OLB

$!

$! Define The RSAREF-LIB We Are To Use.

$!

$ RSAREF_LIB := SYS$DISK:[-.'ARCH'.EXE.RSAREF]LIBRSAGLUE.OLB

$!

$! Check To See If We Already Have A "[.xxx.EXE.CRYPTO]LIBCRYPTO.OLB" Library...

$!

$ IF (F$SEARCH(LIB_NAME).EQS."")

$!

$ ENDIF

$!

$! Build our options file for the application

$!

$ GOSUB CHECK_OPT_FILE

$!

$! Define The Different Encryption "library" Strings.

$!

$ APPS_DES = "DES/DES,CBC3_ENC"

$ APPS_PKCS7 = "ENC/ENC;DEC/DEC;SIGN/SIGN;VERIFY/VERIFY,EXAMPLE"

$

$ LIB_ = "cryptlib,mem,cversion,ex_data,tmdiff,cpt_err"

$ LIB_MD2 = "md2_dgst,md2_one"

$ LIB_MD5 = "md5_dgst,md5_one"

	"bn_gcd,bn_prime,bn_err,bn_sqr,"+LIB_BN_ASM+",bn_recp,bn_mont,"+ -

	"bn_mpi,bn_exp2"

$ LIB_RSA = "rsa_eay,rsa_gen,rsa_lib,rsa_sign,rsa_saos,rsa_err,"+ -

	"rsa_pk1,rsa_ssl,rsa_none,rsa_oaep,rsa_chk"

$ LIB_DSA = "dsa_gen,dsa_key,dsa_lib,dsa_asn1,dsa_vrf,dsa_sign,dsa_err"

	"rsa_pk1,rsa_ssl,rsa_none,rsa_oaep,rsa_chk,rsa_null"

$ LIB_DSA = "dsa_gen,dsa_key,dsa_lib,dsa_asn1,dsa_vrf,dsa_sign,dsa_err,dsa_ossl"

$ LIB_DH = "dh_gen,dh_key,dh_lib,dh_check,dh_err"

$ LIB_BUFFER = "buffer,buf_err"

$ LIB_BIO = "bio_lib,bio_cb,bio_err,"+ -

	"c_all,evp_lib,bio_ok,evp_pkey,evp_pbe,p5_crpt,p5_crpt2"

$ LIB_ASN1 = "a_object,a_bitstr,a_utctm,a_gentm,a_time,a_int,a_octet,"+ -

	"a_print,a_type,a_set,a_dup,a_d2i_fp,a_i2d_fp,a_bmp,"+ -

	"a_enum,a_vis,a_utf8,a_sign,a_digest,a_verify,"+ -

	"a_enum,a_vis,a_utf8,a_sign,a_digest,a_verify,a_mbstr,"+ -

	"x_algor,x_val,x_pubkey,x_sig,x_req,x_attrib,"+ -

	"x_name,x_cinf,x_x509,x_crl,x_info,x_spki,nsseq,"+ -

	"d2i_r_pr,i2d_r_pr,d2i_r_pu,i2d_r_pu,"+ -

	"d2i_s_pr,i2d_s_pr,d2i_s_pu,i2d_s_pu,"+ -

	"d2i_pu,d2i_pr,i2d_pu,i2d_pr"

$ LIB_ASN1_2 = "t_req,t_x509,t_crl,t_pkey,"+ -

$ LIB_ASN1_2 = "t_req,t_x509,t_crl,t_pkey,t_spki,"+ -

	"p7_i_s,p7_signi,p7_signd,p7_recip,p7_enc_c,p7_evp,"+ -

	"p7_dgst,p7_s_e,p7_enc,p7_lib,"+ -

	"f_int,f_string,i2d_dhp,i2d_dsap,d2i_dhp,d2i_dsap,n_pkey,"+ -

	"f_enum,a_hdr,x_pkey,a_bool,x_exten,"+ -

	"asn1_par,asn1_lib,asn1_err,a_meth,a_bytes,"+ -

	"asn1_par,asn1_lib,asn1_err,a_meth,a_bytes,a_strnid,"+ -

	"evp_asn1,asn_pack,p5_pbe,p5_pbev2,p8_pkey"

$ LIB_PEM = "pem_sign,pem_seal,pem_info,pem_lib,pem_all,pem_err"

$ LIB_X509 = "x509_def,x509_d2,x509_r2x,x509_cmp,"+ -

	"x509_obj,x509_req,x509_vfy,"+ -

	"x509_obj,x509_req,x509spki,x509_vfy,"+ -

	"x509_set,x509rset,x509_err,"+ -

	"x509name,x509_v3,x509_ext,"+ -

	"x509type,x509_lu,x_all,x509_txt,"+ -

	"by_file,by_dir"

$ LIB_X509V3 = "v3_bcons,v3_bitst,v3_conf,v3_extku,v3_ia5,v3_lib,"+ -

	"v3_prn,v3_utl,v3err,v3_genn,v3_alt,v3_skey,v3_akey,v3_pku,"+ -

	"v3_int,v3_enum,v3_sxnet,v3_cpols,v3_crld"

	"v3_int,v3_enum,v3_sxnet,v3_cpols,v3_crld,v3_purp"

$ LIB_CONF = "conf,conf_err"

$ LIB_TXT_DB = "txt_db"

$ LIB_PKCS7 = "pk7_lib,pkcs7err,pk7_doit"

$!

$! Check To See If We Are Going To Use RSAREF.

$!

$ IF (RSAREF.EQS."TRUE" .AND. ENCRYPT_TYPES - "RSA".NES.ENCRYPT_TYPES)

$ IF (RSAREF.EQS."TRUE" .AND. ENCRYPT_TYPES - "RSA".NES.ENCRYPT_TYPES -

      .AND. (BUILDALL .EQS. "TRUE" .OR. BUILDALL .EQS. "LIBRARY"))

$ THEN

$!

$!  Check To See If The File [-.RSAREF]RSAREF.C Is Actually There.

$! Extract The Module Name From The Encryption List.

$!

$ MODULE_NAME = F$ELEMENT(MODULE_COUNTER,",",ENCRYPT_TYPES)

$ MODULE_NAME1 = MODULE_NAME

$!

$! Check To See If We Are At The End Of The Module List.

$!

$!

$ MODULE_COUNTER = MODULE_COUNTER + 1

$!

$! Tell The User What Module We Are Building.

$!

$ IF (MODULE_NAME.NES."") 

$ THEN

$   WRITE SYS$OUTPUT "Compiling The ",MODULE_NAME," Files."

$ ENDIF

$!

$!  Define A File Counter And Set It To "0".

$!

$ FILE_COUNTER = 0

$!

$! Create The Library Module Name.

$! Create The Library and Apps Module Names.

$!

$ LIB_MODULE = "LIB_" + MODULE_NAME

$ APPS_MODULE = "APPS_" + MODULE_NAME

$ IF (MODULE_NAME.EQS."ASN1_2")

$ THEN

$   MODULE_NAME = "ASN1"

$   MODULE_NAME = "EVP"

$ ENDIF

$!

$! Set state (can be LIB and APPS)

$!

$ STATE = "LIB"

$ IF BUILDALL .EQS. "APPS" THEN STATE = "APPS"

$!

$! Check if the library module name actually is defined

$!

$ IF F$TYPE('LIB_MODULE') .EQS. ""

$   GOTO MODULE_NEXT

$ ENDIF

$!

$! Top Of The Module Loop.

$!

$ MODULE_AGAIN:

$!

$! Tell The User What Module We Are Building.

$!

$ IF (MODULE_NAME1.NES."") 

$ THEN

$   IF STATE .EQS. "LIB"

$   THEN

$     WRITE SYS$OUTPUT "Compiling The ",MODULE_NAME1," Library Files. (",BUILDALL,",",STATE,")"

$   ELSE IF F$TYPE('APPS_MODULE') .NES. ""

$     THEN

$       WRITE SYS$OUTPUT "Compiling The ",MODULE_NAME1," Applications. (",BUILDALL,",",STATE,")"

$     ENDIF

$   ENDIF

$ ENDIF

$!

$!  Define A File Counter And Set It To "0".

$!

$ FILE_COUNTER = 0

$ APPLICATION = ""

$ APPLICATION_COUNTER = 0

$!

$! Top Of The File Loop.

$!

$ NEXT_FILE:

$!

$! Look in the LIB_MODULE is we're in state LIB

$!

$ IF STATE .EQS. "LIB"

$ THEN

$!

$!   O.K, Extract The File Name From The File List.

$!

$   FILE_NAME = F$ELEMENT(FILE_COUNTER,",",'LIB_MODULE')

$!

$!   else

$!

$ ELSE

$   FILE_NAME = ","

$!

$   IF F$TYPE('APPS_MODULE') .NES. ""

$   THEN

$!

$!     Extract The File Name From The File List.

$!     This part is a bit more complicated.

$!

$     IF APPLICATION .EQS. ""

$     THEN

$       APPLICATION = F$ELEMENT(APPLICATION_COUNTER,";",'APPS_MODULE')

$       APPLICATION_COUNTER = APPLICATION_COUNTER + 1

$       APPLICATION_OBJECTS = F$ELEMENT(1,"/",APPLICATION)

$       APPLICATION = F$ELEMENT(0,"/",APPLICATION)

$       FILE_COUNTER = 0

$     ENDIF

$

$!     WRITE SYS$OUTPUT "DEBUG: SHOW SYMBOL APPLICATION*"

$!     SHOW SYMBOL APPLICATION*

$!

$     IF APPLICATION .NES. ";"

$     THEN

$       FILE_NAME = F$ELEMENT(FILE_COUNTER,",",APPLICATION_OBJECTS)

$       IF FILE_NAME .EQS. ","

$       THEN

$         APPLICATION = ""

$         GOTO NEXT_FILE

$       ENDIF

$     ENDIF

$   ENDIF

$ ENDIF

$!

$! Check To See If We Are At The End Of The File List.

$!

$ IF (FILE_NAME.EQS.",") 

$ THEN 

$!

$!  We Are At The End Of The File List, Goto FILE_DONE.

$!  We Are At The End Of The File List, Change State Or Goto FILE_DONE.

$!

$   IF STATE .EQS. "LIB" .AND. BUILDALL .NES. "LIBRARY"

$   THEN

$     STATE = "APPS"

$     GOTO MODULE_AGAIN

$   ELSE

$     GOTO FILE_DONE

$   ENDIF

$!

$! End The File List Check.

$!

$!

$ IF (MODULE_NAME.EQS."")

$ THEN

     WRITE SYS$OUTPUT "Compiling The ",FILE_NAME," File."

$   WRITE SYS$OUTPUT "Compiling The ",FILE_NAME," File.  (",BUILDALL,",",STATE,")"

$ ENDIF

$ IF (MODULE_NAME.NES."")

$ THEN 

$     ENDIF

$   ENDIF

$ ENDIF

$ IF STATE .EQS. "LIB"

$ THEN 

$!

$!   Add It To The Library.

$!

$!   Time To Clean Up The Object File.

$!

$   DELETE 'OBJECT_FILE';*

$ ENDIF

$!

$! Go Back And Do It Again.

$!

$!

$ FILE_DONE:

$!

$! Time To Build Some Applications

$!

$ IF F$TYPE('APPS_MODULE') .NES. "" .AND. BUILDALL .NES. "LIBRARY"

$ THEN

$   APPLICATION_COUNTER = 0

$ NEXT_APPLICATION:

$   APPLICATION = F$ELEMENT(APPLICATION_COUNTER,";",'APPS_MODULE')

$   IF APPLICATION .EQS. ";" THEN GOTO APPLICATION_DONE

$

$   APPLICATION_COUNTER = APPLICATION_COUNTER + 1

$   APPLICATION_OBJECTS = F$ELEMENT(1,"/",APPLICATION)

$   APPLICATION = F$ELEMENT(0,"/",APPLICATION)

$

$!   WRITE SYS$OUTPUT "DEBUG: SHOW SYMBOL APPLICATION*"

$!   SHOW SYMBOL APPLICATION*

$!

$! Tell the user what happens

$!

$   WRITE SYS$OUTPUT "	",APPLICATION,".exe"

$!

$! Link The Program, Check To See If We Need To Link With RSAREF Or Not.

$!

$   IF (RSAREF.EQS."TRUE")

$   THEN

$!

$!  Check To See If We Are To Link With A Specific TCP/IP Library.

$!

$     IF (TCPIP_LIB.NES."")

$     THEN

$!

$!    Link With The RSAREF Library And A Specific TCP/IP Library.

$!

$       LINK/'DEBUGGER'/'TRACEBACK'/EXE='EXE_DIR''APPLICATION'.EXE -

            'OBJ_DIR''APPLICATION_OBJECTS', -

	    'CRYPTO_LIB'/LIBRARY,'RSAREF_LIB'/LIBRARY, -

	    'TCPIP_LIB','OPT_FILE'/OPTION

$!

$!    Else...

$!

$     ELSE

$!

$!      Link With The RSAREF Library And NO TCP/IP Library.

$!

$       LINK/'DEBUGGER'/'TRACEBACK'/EXE='EXE_DIR''APPLICATION'.EXE -

            'OBJ_DIR''APPLICATION_OBJECTS', -

	    'CRYPTO_LIB'/LIBRARY,'RSAREF_LIB'/LIBRARY, -

	    'OPT_FILE'/OPTION

$!

$!    End The TCP/IP Library Check.

$!

$     ENDIF

$!

$!   Else...

$!

$   ELSE

$!

$!    Don't Link With The RSAREF Routines.

$!

$!

$!    Check To See If We Are To Link With A Specific TCP/IP Library.

$!

$     IF (TCPIP_LIB.NES."")

$     THEN

$!

$!      Don't Link With The RSAREF Routines And TCP/IP Library.

$!

$       LINK/'DEBUGGER'/'TRACEBACK'/EXE='EXE_DIR''APPLICATION'.EXE -

            'OBJ_DIR''APPLICATION_OBJECTS', -

	    'CRYPTO_LIB'/LIBRARY, -

            'TCPIP_LIB','OPT_FILE'/OPTION

$!

$!    Else...

$!

$     ELSE

$!

$!      Don't Link With The RSAREF Routines And Link With A TCP/IP Library.

$!

$       LINK/'DEBUGGER'/'TRACEBACK'/EXE='EXE_DIR''APPLICATION'.EXE -

            'OBJ_DIR''APPLICATION_OBJECTS',-

	    'CRYPTO_LIB'/LIBRARY, -

            'OPT_FILE'/OPTION

$!

$!    End The TCP/IP Library Check.

$!

$     ENDIF

$!

$!   End The RSAREF Link Check.

$!

$   ENDIF

$   GOTO NEXT_APPLICATION

$  APPLICATION_DONE:

$ ENDIF

$!

$! Go Back And Get The Next Module.

$!

$ GOTO MODULE_NEXT

$!

$ RETURN

$!

$! Check To See If P1 Is Blank.

$!

$ IF (P1.EQS."ALL")

$ THEN

$!

$!   P1 Is Blank, So Build Everything.

$!

$    BUILDALL = "TRUE"

$!

$! Else...

$!

$ ELSE

$!

$!  Else, Check To See If P1 Has A Valid Arguement.

$!

$   IF (P1.EQS."LIBRARY").OR.(P1.EQS."APPS")

$   THEN

$!

$!    A Valid Arguement.

$!

$     BUILDALL = P1

$!

$!  Else...

$!

$   ELSE

$!

$!    Tell The User We Don't Know What They Want.

$!

$     WRITE SYS$OUTPUT ""

$     WRITE SYS$OUTPUT "The Option ",P1," Is Invalid.  The Valid Options Are:"

$     WRITE SYS$OUTPUT ""

$     WRITE SYS$OUTPUT "    ALL      :  Just Build Everything."

$     WRITE SYS$OUTPUT "    LIBRARY  :  To Compile Just The [.xxx.EXE.SSL]LIBCRYPTO.OLB Library."

$     WRITE SYS$OUTPUT "    APPS     :  To Compile Just The [.xxx.EXE.SSL]*.EXE Programs."

$     WRITE SYS$OUTPUT ""

$     WRITE SYS$OUTPUT " Where 'xxx' Stands For:"

$     WRITE SYS$OUTPUT ""

$     WRITE SYS$OUTPUT "        AXP  :  Alpha Architecture."

$     WRITE SYS$OUTPUT "        VAX  :  VAX Architecture."

$     WRITE SYS$OUTPUT ""

$!

$!    Time To EXIT.

$!

$     EXIT

$!

$!  End The Valid Arguement Check.

$!

$   ENDIF

$!

$! End The P1 Check.

$!

$ ENDIF

$!

$! Check The User's Options.

$!

$ CHECK_OPTIONS:

$!

$! Check To See If P1 Is Blank.

$! Check To See If P2 Is Blank.

$!

$ IF (P1.EQS."NORSAREF")

$ IF (P2.EQS."NORSAREF")

$ THEN

$!

$!   P1 Is NORSAREF, So Compile With The Regular RSA Libraries.

$!   P2 Is NORSAREF, So Compile With The Regular RSA Libraries.

$!

$    RSAREF = "FALSE"

$ ELSE

$!

$!  Check To See If We Are To Use The RSAREF Library.

$!

$   IF (P1.EQS."RSAREF")

$   IF (P2.EQS."RSAREF")

$   THEN

$!

$!    Check To Make Sure We Have The RSAREF Source Code Directory.

$!    They Entered An Invalid Option..

$!

$     WRITE SYS$OUTPUT ""

$     WRITE SYS$OUTPUT "The Option ",P1," Is Invalid.  The Valid Options Are:"

$     WRITE SYS$OUTPUT "The Option ",P2," Is Invalid.  The Valid Options Are:"

$     WRITE SYS$OUTPUT ""

$     WRITE SYS$OUTPUT "     RSAREF   :  Compile With The RSAREF Library."

$     WRITE SYS$OUTPUT "     NORSAREF :  Compile With The Regular RSA Library."

$!

$   ENDIF

$!

$! End The P1 Check.

$! End The P2 Check.

$!

$ ENDIF

$!

$! Check To See If P2 Is Blank.

$! Check To See If P3 Is Blank.

$!

$ IF (P2.EQS."NODEBUG")

$ IF (P3.EQS."NODEBUG")

$ THEN

$!

$!   P2 Is NODEBUG, So Compile Without The Debugger Information.

$!   P3 Is NODEBUG, So Compile Without The Debugger Information.

$!

$    DEBUGGER = "NODEBUG"

$    TRACEBACK = "NOTRACEBACK" 

$!

$!  Check To See If We Are To Compile With Debugger Information.

$!

$   IF (P2.EQS."DEBUG")

$   IF (P3.EQS."DEBUG")

$   THEN

$!

$!    Compile With Debugger Information.

$!    They Entered An Invalid Option..

$!

$     WRITE SYS$OUTPUT ""

$     WRITE SYS$OUTPUT "The Option ",P2," Is Invalid.  The Valid Options Are:"

$     WRITE SYS$OUTPUT "The Option ",P3," Is Invalid.  The Valid Options Are:"

$     WRITE SYS$OUTPUT ""

$     WRITE SYS$OUTPUT "     DEBUG   :  Compile With The Debugger Information."

$     WRITE SYS$OUTPUT "     NODEBUG :  Compile Without The Debugger Information."

$!

$   ENDIF

$!

$! End The P2 Check.

$! End The P3 Check.

$!

$ ENDIF

$!

$!              richard@levitte.org

$!

$!

$! Check To See If We Have A Option For P5.

$! Check To See If We Have A Option For P6.

$!

$ IF (P5.EQS."")

$ IF (P6.EQS."")

$ THEN

$!

$!  Get The Version Of VMS We Are Using.

$!

$   ENDIF

$!

$! End The P5 Check.

$! End The P6 Check.

$!

$ ENDIF

$!

$! Check To See If P3 Is Blank.

$! Check To See If P4 Is Blank.

$!

$ IF (P3.EQS."")

$ IF (P4.EQS."")

$ THEN

$!

$!  O.K., The User Didn't Specify A Compiler, Let's Try To

$!

$!    Looks Like GNUC, Set To Use GNUC.

$!

$     P3 = "GNUC"

$     P4 = "GNUC"

$!

$!  Else...

$!

$!

$!      Looks Like DECC, Set To Use DECC.

$!

$       P3 = "DECC"

$       P4 = "DECC"

$!

$!    Else...

$!

$!

$!      Looks Like VAXC, Set To Use VAXC.

$!

$       P3 = "VAXC"

$       P4 = "VAXC"

$!

$!    End The VAXC Compiler Check.

$!

$!

$ ENDIF

$!

$! Check To See If We Have A Option For P4.

$! Check To See If We Have A Option For P5.

$!

$ IF (P4.EQS."")

$ IF (P5.EQS."")

$ THEN

$!

$!  Find out what socket library we have available

$!

$!    We have SOCKETSHR, and it is my opinion that it's the best to use.

$!

$     P4 = "SOCKETSHR"

$     P5 = "SOCKETSHR"

$!

$!    Tell the user

$!

$!

$!	Last resort: a UCX or UCX-compatible library

$!

$	P4 = "UCX"

$	P5 = "UCX"

$!

$!      Tell the user

$!

$!

$! Set Up Initial CC Definitions, Possibly With User Ones

$!

$ CCDEFS = "VMS=1,TCPIP_TYPE_''P4'"

$ CCDEFS = "VMS=1,TCPIP_TYPE_''P5'"

$ IF F$TYPE(USER_CCDEFS) .NES. "" THEN CCDEFS = CCDEFS + "," + USER_CCDEFS

$ CCEXTRAFLAGS = ""

$ IF F$TYPE(USER_CCFLAGS) .NES. "" THEN CCEXTRAFLAGS = USER_CCFLAGS

$!

$!  Check To See If The User Entered A Valid Paramter.

$!

$ IF (P3.EQS."VAXC").OR.(P3.EQS."DECC").OR.(P3.EQS."GNUC")

$ IF (P4.EQS."VAXC").OR.(P4.EQS."DECC").OR.(P4.EQS."GNUC")

$ THEN

$!

$!    Check To See If The User Wanted DECC.

$!

$   IF (P3.EQS."DECC")

$   IF (P4.EQS."DECC")

$   THEN

$!

$!    Looks Like DECC, Set To Use DECC.

$!

$!  Check To See If We Are To Use VAXC.

$!

$   IF (P3.EQS."VAXC")

$   IF (P4.EQS."VAXC")

$   THEN

$!

$!    Looks Like VAXC, Set To Use VAXC.

$!

$!  Check To See If We Are To Use GNU C.

$!

$   IF (P3.EQS."GNUC")

$   IF (P4.EQS."GNUC")

$   THEN

$!

$!    Looks Like GNUC, Set To Use GNUC.

$   ENDIF

$   CC3 = CC + "/DEFINE=(" + CCDEFS + ISSEVEN + ")" + CCDISABLEWARNINGS

$   CC = CC + "/DEFINE=(" + CCDEFS + ")" + CCDISABLEWARNINGS

$   IF ARCH .EQS. "VAX" .AND. COMPILER .EQS. "DECC" .AND. P2 .NES. "DEBUG"

$   IF ARCH .EQS. "VAX" .AND. COMPILER .EQS. "DECC" .AND. P3 .NES. "DEBUG"

$   THEN

$     CC5 = CC + "/OPTIMIZE=NODISJOINT"

$   ELSE

$!  Tell The User We Don't Know What They Want.

$!

$   WRITE SYS$OUTPUT ""

$   WRITE SYS$OUTPUT "The Option ",P3," Is Invalid.  The Valid Options Are:"

$   WRITE SYS$OUTPUT "The Option ",P4," Is Invalid.  The Valid Options Are:"

$   WRITE SYS$OUTPUT ""

$   WRITE SYS$OUTPUT "    VAXC  :  To Compile With VAX C."

$   WRITE SYS$OUTPUT "    DECC  :  To Compile With DEC C."

$!

$! Time to check the contents, and to make sure we get the correct library.

$!

$ IF P4.EQS."SOCKETSHR" .OR. P4.EQS."MULTINET" .OR. P4.EQS."UCX"

$ IF P5.EQS."SOCKETSHR" .OR. P5.EQS."MULTINET" .OR. P5.EQS."UCX"

$ THEN

$!

$!  Check to see if SOCKETSHR was chosen

$!

$   IF P4.EQS."SOCKETSHR"

$   IF P5.EQS."SOCKETSHR"

$   THEN

$!

$!    Set the library to use SOCKETSHR

$!

$!  Check to see if MULTINET was chosen

$!

$   IF P4.EQS."MULTINET"

$   IF P5.EQS."MULTINET"

$   THEN

$!

$!    Set the library to use UCX emulation.

$!

$     P4 = "UCX"

$     P5 = "UCX"

$!

$!    Done with MULTINET

$!

$!

$!  Check to see if UCX was chosen

$!

$   IF P4.EQS."UCX"

$   IF P5.EQS."UCX"

$   THEN

$!

$!    Set the library to use UCX.

$!  Tell The User We Don't Know What They Want.

$!

$   WRITE SYS$OUTPUT ""

$   WRITE SYS$OUTPUT "The Option ",P4," Is Invalid.  The Valid Options Are:"

$   WRITE SYS$OUTPUT "The Option ",P5," Is Invalid.  The Valid Options Are:"

$   WRITE SYS$OUTPUT ""

$   WRITE SYS$OUTPUT "    SOCKETSHR  :  To link with SOCKETSHR TCP/IP library."

$   WRITE SYS$OUTPUT "    UCX        :  To link with UCX TCP/IP library."

$! Check if the user wanted to compile just a subset of all the encryption

$! methods.

$!

$ IF P6 .NES. ""

$ IF P7 .NES. ""

$ THEN

$   ENCRYPT_TYPES = P6

$   ENCRYPT_TYPES = P7

$ ENDIF

$!

$!  Time To RETURN...

$!

$! Build The [.xxx.EXE.CRYPTO]LIBCRYPTO.OLB Library.

$!  

$ @CRYPTO-LIB 'RSAREF' 'DEBUGGER' "''COMPILER'" "''TCPIP_TYPE'" 'ISSEVEN'

$ @CRYPTO-LIB LIBRARY 'RSAREF' 'DEBUGGER' "''COMPILER'" "''TCPIP_TYPE'" 'ISSEVEN'

$!

$! Go Back To The Main Directory.

$!