Unverified Commit c603390a authored by gepirdtu's avatar gepirdtu Committed by GitHub
Browse files

Merge pull request #30 from DTUWindEnergy/linuxcompil

Updated and simplified Linux compilation
parents cadf5cbd df3a2a86
*.mod
*.o
*.so
.*.swp
......@@ -8,16 +8,15 @@ The controller features both partial and full load operation capabilities as wel
Blade pitch servo and generator models are not included in this controller. They can be found in the project [ServoAndUtilities](https://github.com/DTUWindEnergy/ServosAndUtilities).
## Compatibility
The repository includes Visual Studio project (for Windows) and Makefiles (for Windows and Linux) to create DLLs to interface the controller to HAWC2 and Bladed.
The repository includes Visual Studio project (for Windows) and Makefiles (for Linux) to create DLLs to interface the controller to HAWC2 and Bladed.
The controller is written in Fortran and it is compatible with Intel and GFortran compilers. It can be compiled both on Windows and Linux.
## Compilation
- For compilation using Visual Studio open the Visual Studio Solution or Projec files (*.sln, *.vfproj)
- For compilation using Makefile, read the instructions in src/Makefile.README.txt
- For compilation in Windows (as a dll), use the Visual Studio Solution or Project files provided (*.sln, *.vfproj)
- For compilation in Unix (as a so file), go to the /src subfolder and type `make FC=compiler`. Where 'compiler' should be replaced by an already installed compiler (e.g. ifort, mpif90).
## Documentation
......@@ -32,14 +31,6 @@ The documentations requires the [Fortran Sphynx](https://github.com/VACUMM/sphin
$ pip install sphinx-fortran
## Tests
For users that compiled using the shipped makefiles a set of tests are present in the folder "src/_tests".
- Rudimentary matlab and fortran tests are present in this folder to dynamically load the compiled dlls and perform a simple call.
- Running `make` within this folder will perform the Fortran tests using different "Fortran" method to load a dll (i.e. cray-pointer or C-integer handles).
## License
The Basic DTU Wind Energy controller is distributed under the [GNU General Public License v3.0](http://en.wikipedia.org/wiki/GNU_General_Public_License).
......
# --------------------------------------------------------------------------------
# --- INFO
# --------------------------------------------------------------------------------
# This makefile can perform the following:
# - loops over the directories and execute the common rules: all, clean, purge
# - perform a batch compilation for different CONFIG (e.g. compilers, DEBUG)
# --------------------------------------------------------------------------------
# --- Detection of possible configs
# --------------------------------------------------------------------------------
# --- Detection of OS
include _mkf/MakefileOS.mk
# ---- Detection of Compilers
include _mkf/MakefileFortran_ifort_Checks.mk
include _mkf/MakefileFortran_gfortran_Checks.mk
include _mkf/MakefileFortran_compaq_Checks.mk
# --------------------------------------------------------------------------------
# --- Subdirectories
# --------------------------------------------------------------------------------
# Defining dependencies between sub-directories
SUBDIRS = dtu_we_controller dtu_we_controller_bladed
.PHONY: all
# Creating rules by adding suffixes to directories
SUBCLEAN = $(addsuffix .clean,$(SUBDIRS))
SUBALL = $(addsuffix .all,$(SUBDIRS))
SUBPURGE = $(addsuffix .purge,$(SUBDIRS))
all: dtu_we_controller dtu_we_controller_bladed flap_controller_cyclic flap_controller_individual_aep_u_f
# --------------------------------------------------------------------------------
# --- General rules
# --------------------------------------------------------------------------------
.PHONY: clean all
.PHONY: dtu_we_controller
all: $(SUBALL)
@echo "[ OK ] make all in subfolders"
@echo ""
dtu_we_controller:
make -C dtu_we_controller
clean: $(SUBCLEAN)
@echo "[ OK ] make clean in subfolders"
@echo ""
.PHONY: dtu_we_controller_bladed
purge: $(SUBPURGE)
@$(MKDIR) DUMMY
@$(RMDIR) DUMMY $(wildcard _lib*) $(ERR_TO_NULL)
@echo "[ OK ] make purge in subfolders"
@echo ""
dtu_we_controller_bladed:
make -C dtu_we_controller_bladed
# --------------------------------------------------------------------------------
# --- Subdirectories rules
# --------------------------------------------------------------------------------
$(SUBALL): %.all:
@$(MAKE) -C $* all
$(SUBCLEAN):%.clean:
@$(MAKE) -C $* clean
$(SUBPURGE):%.purge:
@$(MAKE) -C $* purge
.PHONY: flap_controller_cyclic
flap_controller_cyclic:
make -C flap_controller_cyclic
.PHONY: flap_controller_individual_aep_u_f
flap_controller_individual_aep_u_f:
make -C flap_controller_individual_aep_u_f
.PHONY: clean
# --------------------------------------------------------------------------------
# --- Batch compilation
# --------------------------------------------------------------------------------
batch:
ifeq ($(IFORT_STATUS),1)
make FCOMPILER=1 RELEASE=1
endif
ifeq ($(GFORTRAN_STATUS),1)
make FCOMPILER=0 RELEASE=1
endif
@echo "[ OK ] Batch compilation"
# --------------------------------------------------------------------------------
# --- Automatic generation of def files based on bind(c)
# --------------------------------------------------------------------------------
def:
python ./simple-fortran-parser/fortran_signature_def_gen.py dtu_we_controller$(SLASH)dtu_we_controller.f90
python ./simple-fortran-parser/fortran_signature_def_gen.py dtu_we_controller_bladed$(SLASH)dtu_we_controller_bladed.f90
# --------------------------------------------------------------------------------
# --- Automatic generation of header files
# --------------------------------------------------------------------------------
headers:
python ./simple-fortran-parser/fortran_signature_gen.py dtu_we_controller$(SLASH)dtu_we_controller.f90
python ./simple-fortran-parser/fortran_signature_gen.py dtu_we_controller_bladed$(SLASH)dtu_we_controller_bladed.f90
# --------------------------------------------------------------------------------
# --- SIMPLE RULES
# --------------------------------------------------------------------------------
include _mkf/MakefileSimpleRules.mk
clean:
make -C dtu_we_controller clean
make -C dtu_we_controller_bladed clean
make -C flap_controller_cyclic clean
make -C flap_controller_individual_aep_u_f clean
\ No newline at end of file
# --------------------------------------------------------------------------------
# --- Quick start
# --------------------------------------------------------------------------------
- Install make (search the web)
For windows: http://gnuwin32.sourceforge.net/downlinks/make.php
For linux : apt-get install make (or the like)
- Open a command window from the current directory
For windows: you can choose to double click on one of the open-cmd*.bat files provided
- Simply type "make" and press Enter. The dlls should compile and be placed in a folder "_lib*"
The makefile detects whether intel fortran or gfortran is present and uses the first one it finds.
If it doesnt work, or if you want more info about how to setup your compiler, read the following.
# --------------------------------------------------------------------------------
# --- General information
# --------------------------------------------------------------------------------
The current directory and the sub-directories contain Makefiles.
The makefile in the current directory simply loops over the sub-directories and run make in these directories using the same rule as the one it was called with.
All Makefiles contain the rules "all", "clean", "purge" and "flags".
The Makefile in the current directory also contain the rules "batch", "def" and "headers"
The Makefiles include common Makefile code placed in the directory "_mkf".
The files from the "_mkf" directory comes from: https://github.com/elmanuelito/_mkf.git
# --------------------------------------------------------------------------------
# --- Makefile rules
# --------------------------------------------------------------------------------
all: default rule, triggers the compilation (creates a _build* folder)
clean: remove objects, modules files and build folders
purge: remove the libraries and dlls
flags: displays the flags and compiler used for compilation
For the Makefile in the current directory,
batch: performs compilation for several compilers and/or release/debug version
(advanced) The rules below require the simple-fortran-parser tool from https://github.com/elmanuelito/simple-fortran-parser.git.
def: (advanded) automatically generate the ".def" file containing the dll export definitions
headers: (advanded) automatically generate the ".h" file containing the headers for the dll
# --------------------------------------------------------------------------------
# --- Main Makefile options / redefining Makefile variables
# --------------------------------------------------------------------------------
- Choice of Fortran Compiler
By default the compiler looks for the intel fortran compiler (ifort) or the gnu fortran compiler (gfortran). Intel has the priority. This step is performed in the included file "_mkf/MakefileDllInit".
The choice of compiler can be overriden by adding FCOMPILER=... to the makefile call.
The different compilers are defined in "_mkf/MakefileFortran.mk" where the following convention is used:
FCOMPILER=0 : gfortran
FCOMPILER=1 : ifort
FCOMPILER=2 : sun
FCOMPILER=3 : compaq
For instance, if both intel and gfortran are present, the compilation using gfortran can be forced by typing "make FCOMPILER=0"
- Release vs Debug
The Makefile compiles a release version by default. To compile debug versions simply type "make RELEASE=0"
- Choice of Target architecture
The target architecure is automatically detected based on the compiler (using for instance the "--version" flags of a compiler) and stored in the Makefile variable "FC_ARCHI". These detections are handled by the files "_mkf/MakefileFortran_*_Checks.mk". The target architecture can be different than the OS architecture, detected by "_mkf/MakefileOS.mk" and stored in "OS_ARCHI". To setup intel compiler for different architecture see the next section.
# --------------------------------------------------------------------------------
# --- Setting up your environment such that your compilers are accessible
# --------------------------------------------------------------------------------
- Generalities: The commands available within a command line correponds to binaries located in the different folders defined in the environment variable "PATH" ("echo $PATH ", or "echo %PATH%")
If you type a command and get a "command not found" message it needs you need to setup your PATH to access this command.
To have the compiler available you will have to setup your PATH.
For windows users, the free software Eveditor is convenient to edit the environment variable like PATH.
Remember that after setting your PATH, you need to open a new terminal window.
- make: Usually make is available since its "bin" folder is added to the PATH at install. Otherwise find it and add-it.
- gfortran: Usually gfortran is available since its "bin" folder is added to the PATH at install. Otherwise find it and add-it.
- Intel: The ifort compiler comes with tools to automatically setup your PATH. This tool is called "ifortvars.bat" or "compilervars.bat". Look for the folder containing this tool (For example:"C:\Program Files (x86)\Intel\Composer\bin" or /opt/intel/composer/bin). Add this folder to your PATH (or run the script in your current terminal).
- For linux users running "ifortvars.bat intel64" should make the "ifort" command available in your current terminal session. The basic C-compilation tools (gcc ld) are likely present on your system.
- For windows users, the basic C-compilation tools are not available by default. You can use the one from Visual Studio (2010 here assumed). Like Intel, Visual Studio comes with a bat script to configure the path. This script is called "vcvars.bat" (e.g. "C:\Program Files (x86)\Microsoft Visual Studio 10.0\VC"). Find it, and add the containing folder to your PATH.
To setup intel fortran you need to first setup the C visual studio toolkit. The commands are as follows for 32bit and 64 bit respectively (assuming the two bat scripts above are in your path and available).
vcvarsall.bat x86
ifortvars.bat ia32 vs2010
vcvarsall.bat amd64
ifortvars.bat intel64 vs2010
For convenience, the open-cmd*.bat are shipped with the current repository to automatically performs these commands in a terminal sessin.
$(OBJ_DIR)/%.$(o): %.for
@echo "($(CONFIG)):" $<
@$(FC) $(DEFS) $(INCS) $(FFLAGS) -c $< $(FOUT_OBJ)$(OBJ_DIR)$(SLASH)$*.$(o)
$(OBJ_DIR)/%.$(o): %.F90
@echo "($(CONFIG)):" $<
@$(FC) $(DEFS) $(INCS) $(FFFREE) $(FFLAGS) -c $< $(FOUT_OBJ)$(OBJ_DIR)$(SLASH)$*.$(o)
$(OBJ_DIR)/%.$(o): %.$(f)
@echo "($(CONFIG)):" $<
@$(FC) $(DEFS) $(INCS) $(FFFREE) $(FFLAGS) -c $< $(FOUT_OBJ)$(OBJ_DIR)$(SLASH)$*.$(o)
# --------------------------------------------------------------------------------
# --- Setup Fortran Compiler
# --------------------------------------------------------------------------------
include ../_mkf/MakefileFortran.mk
# Note: This is a default makefile to compile a library
# --------------------------------------------------------------------------------
# --- Defining a configuration string (e.g. windows-amd64-ifort-debug)
# --------------------------------------------------------------------------------
CONFIG=$(strip $(OS_NAME))-$(strip $(FC_ARCHI))-$(strip $(FC_NAME))
ifeq ($(RELEASE),0)
CONFIG:=$(CONFIG)-debug
endif
# --------------------------------------------------------------------------------
# --- Defining variables based on OS and fortran
# --------------------------------------------------------------------------------
LIB_DIR=$(LIB_DIR_BASE)-$(CONFIG)
INC_DIR=$(LIB_DIR)$(SLASH)$(INC_DIR_BASE)
OBJ_DIR=$(OBJ_DIR_BASE)-$(CONFIG)
LIB_NAME= $(LIB_NAME_BASE)
ifeq ($(OS_NAME),linux)
LIB_NAME=lib$(LIB_NAME_BASE)
endif
ifeq ($(MAKE_STATIC),1)
RULES+= $(LIB_DIR)$(SLASH)$(LIB_NAME).$(lib)
endif
ifeq ($(MAKE_DLL),1)
RULES+= $(LIB_DIR)$(SLASH)$(LIB_NAME).$(dll)
endif
# --------------------------------------------------------------------------------
# --- INCLUDES
# --------------------------------------------------------------------------------
# We add obj_dir to include path (for old compilers)
INCS=-I$(OBJ_DIR) -I$(INC_DIR)
INCS+=$(INC_EXTRA)
# --------------------------------------------------------------------------------
# --- DEFINITIONS
# --------------------------------------------------------------------------------
DEFS=$(OS_DEF) -D__MAKEFILE__
DEFS+=$(DEFS_EXTRA)
# --------------------------------------------------------------------------------
# --- LIBS
# --------------------------------------------------------------------------------
LIBS=
LIBS+=$(LIBS_EXTRA)
# --------------------------------------------------------------------------------
# --- Compiler Flags
# --------------------------------------------------------------------------------
FFLAGS = $(FF_NOLOGO) $(FF_MODINC)$(OBJ_DIR)
FFLAGS += $(FF_DLL)
ifeq ($(RELEASE),0)
FFLAGS += $(FF_DEBUGINFO) $(FF_DEBUG) $(FF_PE) $(FF_WARN) $(FF_WARNEXTRA) $(FF_OPT0)
#FFLAGS += $(FF_WARNERROR)
FFLAGS += $(FF_TRACE)
BUILD=debug
else
FFLAGS += $(FF_OPTO5)
BUILD=release
endif
FFLAGS += $(FFLAGS_EXTRA)
#
# --------------------------------------------------------------------------------
# --- ARCHIVER flags
# --------------------------------------------------------------------------------
ifeq ($(AR),Lib)
ARFLAGS=$(FFNOLOGO)
else
# v: verbose
# r: insert with replacement
# c: create
# q: quickly append without checking for replacements
#ARFLAGS=-cq
ARFLAGS=-r
endif
ARFLAGS+= $(ARFLAGS_EXTRA)
# --------------------------------------------------------------------------------
# --- Linker flags
# --------------------------------------------------------------------------------
ifeq ($(OS_NAME),windows)
ifeq ($(LD),ld)
# We erase LD
LD=$(FC) -shared $(LIB_NAME).def
# LDFLAGS=-Wl,--enable-runtime-pseudo-reloc,-no-undefined
else
# WINDOWS - IFORT
LDFLAGS=$(LD_DLL) /def:$(LIB_NAME).def
endif
endif
LDFLAGS+= $(LDFLAGS_EXTRA)
# --------------------------------------------------------------------------------
# --- Defining Objects based on SRC
# --------------------------------------------------------------------------------
# Setting up objects
OBJ:= $(patsubst %.f90,%.$(o),$(SRC))
OBJ:= $(patsubst %.F90,%.$(o),$(OBJ))
OBJ:= $(patsubst %.for,%.$(o),$(OBJ))
OBJ:= $(patsubst %,$(OBJ_DIR)/%,$(OBJ))
vpath %.f90
vpath %.F90
vpath %.for
# --------------------------------------------------------------------------------
# --- Main rules
# --------------------------------------------------------------------------------
.PHONY: lib all clean flags
all: $(RULES)
clean:OBJ_DIRS:=$(wildcard $(OBJ_DIR_BASE)*)
clean:
@$(MKDIR) DUMMY
@$(RMDIR) DUMMY $(OBJ_DIRS) $(ERR_TO_NULL)
@echo "[ OK ] $(LIB_NAME_BASE) lib cleaned"
@echo ""
purge: clean $(LIB_DIR)
@$(RM) $(LIB_DIR)$(SLASH)$(LIB_NAME)* $(ERR_TO_NULL)
@echo "[ OK ] $(LIB_NAME_BASE) lib purged"
@echo ""
# --------------------------------------------------------------------------------
# --- Static library
# --------------------------------------------------------------------------------
$(LIB_DIR)$(SLASH)$(LIB_NAME).$(lib): $(LIB_DIR) $(INC_DIR) $(OBJ_DIR) $(OBJ)
@echo "----------------------------------------------------------------------"
@echo "- Compiling static library: " $(LIB_DIR)$(SLASH)$(LIB_NAME).$(lib)
@echo "----------------------------------------------------------------------"
$(AR) $(ARFLAGS) $(AR_OUT)$(LIB_DIR)$(SLASH)$(LIB_NAME).$(lib) $(OBJ)
@$(TOUCH) $(OBJ_DIR)$(SLASH)dummy.mod
@$(CP) $(OBJ_DIR)$(SLASH)*.mod $(INC_DIR)
@$(RM) $(OBJ_DIR)$(SLASH)dummy.mod
@$(RM) $(INC_DIR)$(SLASH)dummy.mod
@echo "[ OK ] Compilation of static library $(LIB_NAME)"
@echo ""
# --------------------------------------------------------------------------------
# --- DLL library
# --------------------------------------------------------------------------------
$(LIB_DIR)$(SLASH)$(LIB_NAME).$(dll): $(LIB_DIR) $(INC_DIR) $(OBJ_DIR) $(OBJ)
@echo "----------------------------------------------------------------------"
@echo "- Compiling dynamic library: " $(LIB_DIR)$(SLASH)$(LIB_NAME).$(dll)
@echo "----------------------------------------------------------------------"
ifeq ($(OS_NAME),windows)
$(LD) $(LDFLAGS) $(LD_OUT)"$(LIB_DIR)$(SLASH)$(LIB_NAME).$(dll)" $(OBJ_DIR)$(SLASH)*.$(o) $(LIBS)
# dlltool -z $(LIB_NAME).def --export-all-symbols $(OBJ_DIR)$(SLASH)\*.$(o) -e exports.o
# gcc dll.o exports.o -o dll.dll
else
# $(FC) $(DEFS) $(INCS) -shared $(LDFLAGS) -Wl,-soname,$(LIB_NAME).$(dll).1 $(OBJ_DIR)$(SLASH)*.$(o) $(LIBS) $(LD_OUT)$(LIB_DIR)$(SLASH)$(LIB_NAME).$(dll)
$(FC) $(DEFS) $(INCS) -shared $(LD_OUT)$(LIB_DIR)$(SLASH)$(LIB_NAME).$(dll) $(LDFLAGS) -Wl,-soname,$(LIB_NAME).$(dll).1 $ $(OBJ_DIR)$(SLASH)*.$(o) $(LIBS)
endif
@echo "[ OK ] Compilation of dynamic library $(LIB_NAME)"
@echo ""
# --------------------------------------------------------------------------------
# --- Low-level Compilation rules
# --------------------------------------------------------------------------------
include ../_mkf/MakefileDefaultCompile.mk
# --------------------------------------------------------------------------------
# --- DEPENDENCIES
# --------------------------------------------------------------------------------
# Creating build directory
$(OBJ_DIR):
@make --no-print-directory flags
@$(MKDIR) $(OBJ_DIR)
$(LIB_DIR):
@$(MKDIR) $(LIB_DIR)
$(INC_DIR):
@$(MKDIR) $(INC_DIR)
# --------------------------------------------------------------------------------
# --- SIMPLE RULES
# --------------------------------------------------------------------------------
include ../_mkf/MakefileSimpleRules.mk
# --------------------------------------------------------------------------------
# --- Defining OS and Archi
# --------------------------------------------------------------------------------
include ../_mkf/MakefileOS.mk
# ---- Detection of Compilers
include ../_mkf/MakefileFortran_ifort_Checks.mk
include ../_mkf/MakefileFortran_gfortran_Checks.mk
# --------------------------------------------------------------------------------
# --- Main Makefile variables
# --------------------------------------------------------------------------------
# Release or debug
ifeq ($(RELEASE),)
RELEASE=1
endif
# FORTRAN COMPILER. If not defined, we look at the available ones
ifeq ($(FCOMPILER),)
ifeq ($(GFORTRAN_STATUS),1)
FCOMPILER=0
endif
ifeq ($(IFORT_STATUS),1)
FCOMPILER=1
endif
endif
OBJ_DIR_BASE=_build
LIB_DIR_BASE=..$(SLASH)_lib
INC_DIR_BASE=_inc
MAKE_DLL=1
MAKE_STATIC=1
f=f90
FC =NOT_SET
FC_NAME =NOT_SET
FC_DEF =NOT_SET
FC_ARCHI=NOT_SET
# mkfile_path := $(abspath $(lastword $(MAKEFILE_LIST)))
# current_dir := $(notdir $(patsubst %/,%,$(dir $(mkfile_path))))
SELF_DIR := $(dir $(lastword $(MAKEFILE_LIST)))
# --------------------------------------------------------------------------------
# --- Setup of compiler variables FC_* and flags FF_*
# --------------------------------------------------------------------------------
# GFORTRAN COMPILER
ifeq ($(FCOMPILER),0)
include $(SELF_DIR)MakefileFortran_gfortran.mk
endif
# INTEL FORTRAN COMPILER
ifeq ($(FCOMPILER),1)
include $(SELF_DIR)MakefileFortran_ifort.mk
endif
# SUN COMPILER
ifeq ($(FCOMPILER),2)
include $(SELF_DIR)MakefileFortran_sun.mk
endif
# COMPAQ COMPILER
ifeq ($(FCOMPILER),3)
include $(SELF_DIR)MakefileFortran_compaq.mk
endif
# --------------------------------------------------------------------------------
# --- USER OVERRIDE
# --------------------------------------------------------------------------------
ifneq ($(CUSTOM_FC),)
FC=$(CUSTOM_FC)
endif
# --------------------------------------------------------------------------------
# --- MKL LIBRARY
# --------------------------------------------------------------------------------
# include MakefileMKL.mk
# --------------------------------------------------------------------------------
# --- MPI (NASTY FOR NOW)
# --------------------------------------------------------------------------------
MPIFC = mpif90
MPIRUN = mpirun -n $(PPN)
RUN = mpirun
ifeq ($(strip $(HOSTNAME)),jess.dtu.dk)
MPIFC = mpiifort
MPIRUN = mpirun -n $(PPN)
RUN = mpirun
endif
ifeq ($(strip $(PBS_O_HOST)),jess.dtu.dk)
MPIFC = mpiifort
MPIRUN = mpirun -n $(PPN)
RUN = mpirun
endif
ifeq ($(strip $(HOSTNAME)),g-000.risoe.dk)
MPIFC = mpiifort
MPIRUN = mpirun -n $(PPN)
RUN = mpirun
endif
ifeq ($(strip $(HOSTNAME)),work)
ifeq ($(FCOMPILER),0)
MPIFC = mpif90.openmpi
MPIRUN = mpirun.openmpi -n $(PPN)
RUN = mpirun.openmpi
endif
endif
ifeq ($(strip $(HOSTNAME)),olympe)
ifeq ($(FCOMPILER),0)
MPIFC = mpif90.openmpi
MPIRUN = mpirun.openmpi -n $(PPN)
RUN = mpirun.openmpi
endif
endif
# Compaq Compiler
FC =f90
FC_NAME =compaq
FC_DEF =-D_DF_VERSION_ -DCOMPAQ
# Output flags
FOUT_EXE = /exe:
FOUT_OBJ = /obj:
FOUT_DLL = /out:
# Usual flags
FF_FREE = -free
FF_OPT0 = /Optimize=0
FF_OPT = /Optimize=3
FF_OPTO3 = /Optimize=3
FF_OPTO5 = /Optimize=3
FF_DLL = /libs:dll
FF_FPP = -fpp
FF_BYTERECL = -assume byterecl
FF_MODINC = /module=
FF_OPENMP = -openmp
# Warnings and debug options
FF_TRACE = -traceback
FF_DEBUGINFO=
FF_WARN = -warn:all
FF_WARNERROR=
FF_WARNEXTRA=
FF_DEBUG = -check:bounds -check:format -check:output_conversion -check:pointers -check:uninit -debug:full -gen-interface
FF_DEBUGARG = -check arg_temp_created
# Advanced flags
FF_PE = -fpe0
FF_AUTOPAR = -parallel -par-report1
FF_ACC = #-offload-build #-no-offload
FF_SAVE = /Qsave
FF_NOLOGO = -nologo
# Checking that compiler is present
#ifeq ($(COMPAQ_STATUS),)
# include MakefileFortran_compaq_Checks.mk
#endif
#ifeq ($(COMPAQ_STATUS),0)
# $(error " $(FC) not in current shell, load ifort using ifortvars <arch> <vs>")
#endif
# Variable defined in _Checks
FC_ARCHI=ia32
\ No newline at end of file
# --------------------------------------------------------------------------------
# --- Description
# --------------------------------------------------------------------------------
# This Makefile perform checks for the compaq compiler :
# - If the compiler is available, the variable STATUS is set to 1
# - The architecture the compiler will use to compile is set in ARCHI
# - The variable FC_AVAILABLE is incremented
#
# This makefile requires MakefileOS
# --------------------------------------------------------------------------------
# --- Requirements
# --------------------------------------------------------------------------------
ifeq ($(ERR_TO_STD),)
$(warning 'MakefileFortran_compaq_Checks needs MakefileOS' )
ERR_TO_STD=2>&1
GREP=grep
endif