How to use and build a makefile to link scip to C? - c

Question

I am very new in C. I just need to use one of the functions in scip. I made a make file as below:
SCIPDIR=$/Users/amin/Documents/cProgram/scipoptsuite-6.0.2/scip
include $(SCIPDIR)/make/make.project
%.o: %.c
$(CC) $(FLAGS) $(OFLAGS) $(BINOFLAGS) $(CFLAGS) -c $<
all: cmain
cmain: cmain.o
$(LINKCXX) cmain.o $(LINKCXXSCIPALL) $(LDFLAGS) $(LINKCXX_o) cmain
my cmain.c file is like this:
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* */
/* This file is part of the program and library */
/* SCIP --- Solving Constraint Integer Programs */
/* */
/* Copyright (C) 2002-2019 Konrad-Zuse-Zentrum */
/* fuer Informationstechnik Berlin */
/* */
/* SCIP is distributed under the terms of the ZIB Academic License. */
/* */
/* You should have received a copy of the ZIB Academic License */
/* along with SCIP; see the file COPYING. If not visit scip.zib.de. */
/* */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/**#file GMI/src/cmain.c
* #brief main file for GMI cut example
* #author Marc Pfetsch
*/
/*--+----1----+----2----+----3----+----4----+----5----+----6----+----7----+----8----+----9----+----0----+----1----+----2*/
#include <scip/scip.h>
#include <scip/scipdefplugins.h>
/** reads parameters */
static
SCIP_RETCODE readParams(
SCIP* scip, /**< SCIP data structure */
const char* filename /**< parameter file name, or NULL */
)
{
if ( filename != NULL )
{
if ( SCIPfileExists(filename) )
{
SCIPinfoMessage(scip, NULL, "reading parameter file <%s> ...\n", filename);
SCIP_CALL( SCIPreadParams(scip, filename) );
}
else
SCIPinfoMessage(scip, NULL, "parameter file <%s> not found - using default parameters.\n", filename);
}
else if ( SCIPfileExists("scipgmi.set") )
{
SCIPinfoMessage(scip, NULL, "reading parameter file <scipgmi.set> ...\n");
SCIP_CALL( SCIPreadParams(scip, "scipgmi.set") );
}
return SCIP_OKAY;
}
/** starts SCIP */
static
SCIP_RETCODE fromCommandLine(
SCIP* scip, /**< SCIP data structure */
const char* filename /**< input file name */
)
{
/********************
* Problem Creation *
********************/
SCIPinfoMessage(scip, NULL, "read problem <%s> ...\n\n", filename);
SCIP_CALL( SCIPreadProb(scip, filename, NULL) );
/*******************
* Problem Solving *
*******************/
/* solve problem */
SCIPinfoMessage(scip, NULL, "solve problem ...\n\n");
SCIP_CALL( SCIPsolve(scip) );
SCIPinfoMessage(scip, NULL, "primal solution:\n");
SCIP_CALL( SCIPprintBestSol(scip, NULL, FALSE) );
/**************
* Statistics *
**************/
SCIPinfoMessage(scip, NULL, "Statistics:\n");
SCIP_CALL( SCIPprintStatistics(scip, NULL) );
return SCIP_OKAY;
}
/** starts user interactive mode */
static
SCIP_RETCODE interactive(
SCIP* scip /**< SCIP data structure */
)
{
SCIP_CALL( SCIPstartInteraction(scip) );
return SCIP_OKAY;
}
/** creates a SCIP instance with default plugins, evaluates command line parameters, runs SCIP appropriately,
* and frees the SCIP instance
*/
static
SCIP_RETCODE runSCIP(
int argc, /**< number of shell parameters */
char** argv /**< array with shell parameters */
)
{
SCIP* scip = NULL;
/*********
* Setup *
*********/
/* initialize SCIP */
SCIP_CALL( SCIPcreate(&scip) );
/* we explicitly enable the use of a debug solution for this main SCIP instance */
SCIPenableDebugSol(scip);
/***********************
* Version information *
***********************/
SCIPprintVersion(scip, NULL);
SCIPinfoMessage(scip, NULL, "\n");
/* include default SCIP plugins */
SCIP_CALL( SCIPincludeDefaultPlugins(scip) );
/**************
* Parameters *
**************/
if ( argc >= 3 )
{
SCIP_CALL( readParams(scip, argv[2]) );
}
else
{
SCIP_CALL( readParams(scip, NULL) );
}
/**************
* Start SCIP *
**************/
if ( argc >= 2 )
{
SCIP_CALL( fromCommandLine(scip, argv[1]) );
}
else
{
SCIPinfoMessage(scip, NULL, "\n");
SCIP_CALL( interactive(scip) );
}
/********************
* Deinitialization *
********************/
SCIP_CALL( SCIPfree(&scip) );
BMScheckEmptyMemory();
return SCIP_OKAY;
}
/** main method starting SCIP */
int main(
int argc, /**< number of arguments from the shell */
char** argv /**< array of shell arguments */
)
{
SCIP_RETCODE retcode;
retcode = runSCIP(argc, argv);
if ( retcode != SCIP_OKAY )
{
SCIPprintError(retcode);
return -1;
}
return 0;
}
Now in the directory that I have these 2 file, I run Make but it doesn't work I get error: No such file or directory
make: *** No rule to make target `Users/amin/Documents/cProgram/scipoptsuite-6.0.2/scip/make/make.project'. Stop.
I just tried to follow a instruction that someone suggested. Please help me if you can. what I have to do?

Answer 1

You are going about this incorrectly.
First without target the first recipe is the one called, so the all target should go first.
second: don't include that other file and delete just about everything but the directory variable and the all target
you simply need to add to the LD_FLAGS variable and the automatic rules will link for you. unless the scip project is bringing in a bunch of variables that you need I don't know why you would need to include its make file information here.
Also of note is that the current path you loaded into a variable had an incorrect leading $ sign in the assignment, and for this to link we will need to make sure its full path to libscip.so ( or libscip.a )
i.e. LD_FLAGS+=-L${DIR_containing_libscip.so} -lscip
you might also need to point to the header/include files:
CPP_FLAGS+=-I${DIR_before_includes_of_scip}/include ( if they are included as <scip/foo>. or without the /include and going up further if they are to be included just as <foo>; this depends upon the projects style. Most projects use the /include/projname pattern so as to keep the project effectively in a namespace of its own for include files to avoid collisions.
that should be it assuming everything else is built and in place and there is nothing particularly special about scip that I need to know about...

Answer 2

You want to separate two things
Building SCIP
Building and Linking your program.
Building SCIP
Usually one would go about and install this library using a package manager on most UNIX-like systems, or do make install to copy it into the system. Then, header files etc. will automatically be found. If you don't want to do that but rather "bundle" SCIP with your program, you usually distribute a copy or link a copy of that version for your program (copy of the code in your sourcetree under eg. "external" or using git submodules, ...). In any case though, you don't want the path to SCIP to be absolute. As an example, use this layout:
./
-- external/SCIP
-- cmain.c
-- Makefile
In the Makefile you can then set SCIPDIR like this for later use:
SCIPDIR := "./external/SCIP"
First, however, you should understand how to build manually. For that, you enter "./external/SCIP" and build the library as instructed in the Readme (often by doing something like ./configure && make && make install). If you want to automate this, you can do this from your main file. For that you can add a "phony" target (ie. a target that will not exactly create one output but build all dependencies) that we will call dep:
dep:
cd $(SCIPDIR); ./configure
$(MAKE) -C $(SCIPDIR)
.PHONY: dep
(thanks to #UpAndAdam for pointing out that you have to change the CWD before running the configure script)
For that we recursively call make for our subproject. We don't want to system-wide install the files, so we just build the library.
Building your program
We now add two pattern-rules that specify how to build and link C programs. GNU/Make (the one you're using) already has built-in suffix rules s.t. it already by default knows how to build C programs, but suffix rules are hard to deal with and you already use other GNU/Make features, so we can also use pattern-rules that are roughly equivalent and disable the built-in rules:
%.o: %.c
$(CC) $(CPPFLAGS) $(CFLAGS) -c -o $# $<
%: %.o
$(CC) $(LDFLAGS) $(CFLAGS) -o $# $^ $(LDLIBS)
.SUFFIXES:
A small note here: We compile one object file from one c file by pattern matching. I used the standard variables, CPPFLAGS (C preprocessor, not C++!), CFLAGS (C compiler & Feature flags) and listed all options before the non-option argument $< which will hold the (first) dependency listed, eg. "cmain.c". Not all C compilers allow mixing options and arguments.
For linking I do the same, but I list the libraries that we want to link with last. This is important, a classic C compiler will discard any libraries listed there if there wasn't any object earlier in the list that depends on that variable.
Now that we know how to build a generic C program, we actually want to first build SCIP, then your program and link it. For that, we'll create a new PHONY dependency, called "all", that will do exactly that:
all: dep cmain
.PHONY: dep all
However, if we now execute make all it will fail as we haven't yet specified the include path etc. For that, we set the variables that we've used before to the needed values (I guessed the specific path, as I'm on mobile):
CPPFLAGS += -I$(SCIPDIR)/include
LDFLAGS += -L$(SCIPDIR)
LDLIBS += -lscip
Putting it all together
Now this should work, more or less. One thing though is, that it's common to have all as the default target, that is, the first target listed in the Makefile. So we write:
CPPFLAGS += -I$(SCIPDIR)/include
LDFLAGS += -L$(SCIPDIR)
LDLIBS += -lscip
all: dep cmain
%.o: %.c
$(CC) $(CPPFLAGS) $(CFLAGS) -c -o $# $<
%: %.o
$(CC) $(LDFLAGS) $(CFLAGS) -o $# $^ $(LDLIBS)
dep:
cd $(SCIPDIR); ./configure.sh
$(MAKE) -C $(SCIPDIR)
.PHONY: dep all
.SUFFIXES:
Note: I'm on mobile, so I couldn't test and don't know the exact paths, but this should guide you along. Also my code here used spaces instead of tabs in the Makefile for the same reason. Be sure to replace them.