https://www.cnblogs.com/tinywan/p/7230039.html

https://www.sohu.com/a/191735643_505857

https://blog.csdn.net/icycode/article/details/49340151

########################################################################

These are typical uses GNU Of AUTOCONF and AUTOMAKE The installation steps of the generated program

One 、 essential information

1、./configure It is used to detect the target features of your installation platform . For example, it will check whether you have CC or GCC, It's not necessary CC or GCC, It is a shell Script .

2、make  It's for compiling , It is from Makefile Read instructions in , Then compile .

3、make install It's for installation , It also comes from Makefile Read instructions in , Install to specified location .

Be careful :AUTOMAKE and AUTOCONF It's very useful for publishing C Program stuff .

Two 、 Explain in detail

1、configure command

This step is generally used to generate Makefile, Prepare for the next compilation step , You can use the configure Add parameters to control the installation , For example code :./configure –prefix=/usr It means to install the software in /usr below , The executable will be installed in /usr/bin ( Not the default /usr/local/bin), The resource file will be installed in /usr/share( Not the default /usr/local/share). At the same time, you can specify the configuration file of some software –sys-config= Parameter setting . Some software can be added –with、–enable、–without、–disable And other parameters control compilation , You can pass the permission ./configure –help See detailed instructions help .

2、make

This step is compiling , Most source code packages are compiled through this step ( Of course there are perl or python The software needs to call perl or python To compile ). If stay make In the process error , You have to write down the error code ( Note that it's not just the last line ), Then you can submit bugreport( Generally in INSTALL There's a submission address ), Or your system is less dependent on the library and so on , These need to study the error code carefully .

Possible mistakes :make *** There's no target and it can't be found makefile. stop it . The question is clear , No, Makefile, What do I do , It turns out that first ./configure once , Again make.

3、make insatll

This command to install ( Of course, some software needs to be run first make check or make test To do some testing ), This step generally requires you to have root jurisdiction ( Because to write files to the system ).

3、 ... and 、 Extended description

Linux Users of may know , stay Linux Next time you install an application , Generally, run the script first configure, And then use make To compile the source program , Running make install, Last run make clean Delete some temporary files . Use the above three automatic tools , You can generate configure Script . function configure Script , You can generate Makefile file , Then you can run make、make install and make clean.

configure It's a shell Script , It can automatically set the source program to fit on a variety of different platforms Unix The characteristics of the system , And according to the system parameters and environment to generate the appropriate Makefile Documents or C The header file (header file), So that the source program can be easily compiled and connected on these different platforms .

At this time , You can run configure The script , function configure Script , Then we can produce a product that conforms to GNU canonical Makefile The file : $ ./configure

By this time , Can run make Compile , Running make install To install , Last run make clean Delete temporary files .

$ make
$ make install ( notes : You have to have sufficient permissions to run this )
$ make clean

utilize configure Produced by Makefile The file has several preset targets to use , A few of the important ones are outlined below :

make all: Generate the goals we set , The executable file in this example . Only fight make It's fine too , The encoding and decoding of the source code will begin , And then connect , And generate executable files .

make clean: Clear the executable file and target file produced by compilation (object file,*.o).

make distclean: In addition to clearing executable and target files , hold configure Produced by Makefile And get rid of it .

make install: Install the program into the system . If the source code is compiled correctly , And the execution result is correct , You can install the program to the default executable file storage path of the system . If you use bin_PROGRAMS Hong's words , The program will be installed to /usr/local/bin This directory .

make dist: Package the program and related files into a compressed file for distribution . After execution, it will generate a file in the directory with PACKAGE-VERSION.tar.gz Name the file . PACKAGE and VERSION These two variables are based on configure.in In file AM_INIT_AUTOMAKE(PACKAGE,VERSION) The definition of . In this example test-1.0.tar.gz Files of .

make distcheck: and make dist similar , But check whether the packed compressed file is normal . The goal is to package programs and related documents into tar.gz The documents , It will also automatically unpack this compressed file , perform configure, And carry out make all The action of , After confirming that the compilation is correct , It will show this tar.gz The document is available for release . This check is very useful , Check the pass bag , Basically, you can give anyone who has GNU development environment - To recompile .

#######################################################################

stay Linux You often need to install and deploy some software packages or tools , Take a look after you get the installation package , Simple ,configure,make, make install That's it .

Sometimes I just think , This configure,make ,make install What does that mean ,configure It's testing the characteristics that exist , then make Start compilation ,make install Generate the corresponding executable file . But a tool just remembers the spelling parts or basic concepts , But little is known about the principle , It also needs to be supplemented .

Several build compile hidden commands

Let's start with the compilation and installation process , Use command aclocal Will generate m4 file ,aclocal It's essentially a perl Script . First of all m4, m4 It's a kind of macro processor , It is POSIX Part of the standard . Why call m4 Well , The full name is macro,m In the back 4 Letters , It is said that , ha-ha . Excerpt a paragraph for m4 Description of : From the perspective of Turing m4, The input stream and the output stream can be connected to form an infinitely extended paper tape ,m4 It's the reading and writing head of this tape , therefore m4 It's a Turing machine .m4 It's the same computing power as any programming language , The difference is only reflected in the programming efficiency and the running efficiency of the program .

And then there was autoconf, Is to generate configure Of documents ,configure It's a script , It can set the source program to adapt to a variety of different operating system platforms , And according to different systems to produce the appropriate Makefile, So that your source code can be compiled on different operating system platforms .

And finally automake Used to generate Makefile.in file

Just to summarize , This compilation process involves several command tools , The general function points are as follows .

aclocal # produce aclocal.m4

autoconf # according to configure.in Generate configure

automake --add-missing # according to Makefile.am Generate Makefile.in

I found a wonderful picture on the Internet , It's comprehensive .

Build process environment preparation

Let's write a simple one Hello world Let's take a look at the whole process .

I wrote a very simple paragraph c Program , Just make do with it . File for main.c

#include <stdio.h>

int main(int argc, const char *argv[])

{

printf("Hello world ,a new testn");

return 0;

}

It can be seen that , The output of the program is Hello world,a new test

Let's look at building GNU How to simulate this process according to the specification in the program

We create a file configure.ac, Inside are some macros , It's the next two autoconf To deal with the needs of , And then to automake To deal with it , Finally complete this inspection .

AC_INIT([helloworld],[0.1],[xxx@xxx.com])

AM_INIT_AUTOMAKE

AC_PROG_CC

AC_CONFIG_FILES([Makefile])

AC_OUTPUT

such as AC_INIT([helloworld],[0.1],[xxx@xxx.com]) The meaning is autoconf The name of the generated package , edition ( This can be defined by itself ), Feedback email ,

AM_INIT_AUTOMAKE It's inspection automake Try Makefile It's a tool for you ,AC_PROG_CC It's compiler detection ,AC_CONFIG_FILES yes automake Build something like .in The file of .

Then is Makefile The file of , We set the name to Makefile.am, The content of this part is closely related to the above configuration .

[root@oel64 tmp]# cat Makefile.am

AUTOMAKE_OPTIONS=foreign

bin_PROGRAMS = helloworld

helloworld_SOURCES = main.c

automake Provides 3 Two software levels :foreign、gnu and gnits. The default level is gnu. here AUTOMAKE_OPTIONS It uses foreign, Only necessary files are detected .

bin_PROGRAMS Defines the name of the executable file to be generated , Here we define it as helloworld

file_SOURCES Definition file The dependency file for this executable program , among “file_SOURCES” The first part of “file” To rewrite to an executable name , I.e bin_PROGRAMS The name of the definition is consistent , Here is helloworld 了 . If there are multiple executables , Then we need to define the corresponding file_SOURCES.

Build process practice

up to now , We created 3 File main.c,configure.ac,Makefile.am

[root@oel64 c]# ll

-rwxr-xr-x. 1 root root 108 Sep 13 12:13 configure.ac

-rw-r--r--. 1 root root 105 Sep 13 12:13 main.c

-rw-r--r--. 1 root root 79 Sep 13 12:13 Makefile.am

use first aclocal To get m4 file . It's generated here 2 File , One is aclocal.m4, The other is cache file autom4te.cache

[root@oel64 c]# aclocal

[root@oel64 c]# ll

total 56

-rw-r--r--. 1 root root 34611 Sep 13 12:14 aclocal.m4

drwxr-xr-x. 2 root root 4096 Sep 13 12:14 autom4te.cache

-rwxr-xr-x. 1 root root 108 Sep 13 12:13 configure.ac

-rw-r--r--. 1 root root 105 Sep 13 12:13 main.c

-rw-r--r--. 1 root root 79 Sep 13 12:13 Makefile.am

And then use autoconf obtain configure file

[root@oel64 c]# autoconf

[root@oel64 c]# ll

-rw-r--r--. 1 root root 34611 Sep 13 12:14 aclocal.m4

drwxr-xr-x. 2 root root 4096 Sep 13 12:14 autom4te.cache

-rwxr-xr-x. 1 root root 135288 Sep 13 12:14 configure

-rwxr-xr-x. 1 root root 108 Sep 13 12:13 configure.ac

-rw-r--r--. 1 root root 105 Sep 13 12:13 main.c

-rw-r--r--. 1 root root 79 Sep 13 12:13 Makefile.am

And then use automake To build modules

[root@oel64 c]# automake --add-missing

configure.ac:2: installing `./install-sh'

configure.ac:2: installing `./missing'

Makefile.am: installing `./depcomp'

After the whole process , That's what we usually do .

perform configure The results are as follows :

[root@oel64 c]# ./configure

checking for a BSD-compatible install... /usr/bin/install -c

checking whether build environment is sane... yes

checking for a thread-safe mkdir -p... /bin/mkdir -p

checking for gawk... gawk

checking whether make sets $(MAKE)... yes

checking for gcc... gcc

checking for C compiler default output file name... a.out

checking whether the C compiler works... yes

checking whether we are cross compiling... no

checking for suffix of executables...

checking for suffix of object files... o

checking whether we are using the GNU C compiler... yes

checking whether gcc accepts -g... yes

checking for gcc option to accept ISO C89... none needed

checking for style of include used by make... GNU

checking dependency style of gcc... gcc3

configure: creating ./config.status

config.status: creating Makefile

config.status: executing depfiles commands

[root@oel64 c]#

And then there was make, This process you can see clearly gcc Start compilation .

[root@oel64 c]# make

gcc -DPACKAGE_NAME="helloworld" -DPACKAGE_TARNAME="helloworld" -DPACKAGE_VERSION="0.1" -DPACKAGE_STRING="helloworld 0.1" -DPACKAGE_BUGREPORT="xxx@xxx.com" -DPACKAGE="helloworld" -DVERSION="0.1" -I. -g -O2 -MT main.o -MD -MP -MF .deps/main.Tpo -c -o main.o main.c

mv -f .deps/main.Tpo .deps/main.Po

gcc -g -O2 -o helloworld main.o

And finally make install, With executable program files .

[root@oel64 c]# make install

make[1]: Entering directory `/root/c'

test -z "/usr/local/bin" || /bin/mkdir -p "/usr/local/bin"

/usr/bin/install -c helloworld '/usr/local/bin'

make[1]: Nothing to be done for `install-data-am'.

make[1]: Leaving directory `/root/c'

Like compiled main.o, If you use strings To view the content is the result of execution .

[root@oel64 c]# strings main.o

Hello world ,a new test

If you look at the executable helloworld The content of , There is a corresponding stack in it .

[root@oel64 c]# strings helloworld

/lib64/ld-linux-x86-64.so.2

__gmon_start__

libc.so.6

puts

__libc_start_main

GLIBC_2.2.5

fff.

Do it by hand .

[root@oel64 c]# ./helloworld

Hello world ,a new test

####################################################

// The steps in the following sections seem to be more in line with the process in the figure above

This article briefly introduces linux Next autoscan, aclocal, autoconf, automake as well as Makefile.am, Configure.in And so on .

autoscan # Generate according to the path configure.scan and autoscan.log
aclocal # produce aclocal.m4
autoconf # according to configure.in Generate configure
automake --add-missing # according to Makefile.am Generate Makefile.in

Example : stay /hello/ Create one in the directory hello.c file , And compile and run it :

#cd /hello/

(1) Write source file hello.c:

  1. #include <stdio.h>
  2. int main(int argc, char** argv)
  3. {
  4. printf("Hello, GNU!n");
  5. return 0;
  6. }

(2) #autoscan

-> Generate configure.scan and autoscan.log

(3) take configure.scan It is amended as follows configure.in:

And modify it configure.in The contents are as follows

# Process this file with autoconf to produce a configure script.
AC_INIT(hello.c)
AM_INIT_AUTOMAKE(hello, 1.0)
# Checks for programs.
AC_PROG_CC
# Checks for library functions.
AC_OUTPUT(Makefile)

(4) #aclocal

-> Generate aclocal.m4 and autom4te.cache ( Generate aclocal.m4 The process involves configure.in)

(5) #autoconf
-> Generate configure ( according to configure.in, and aclocal.m4)

(6) To write Makefile.am:

AUTOMAKE_OPTIONS= foreign
bin_PROGRAMS= hello
hello_SOURCES= hello.c

(7) #automake --add-missing
-> Generate Makefile.in, depcomp, install-sh, and missing ( according to Makefile.am, and aclocal.m4)

(8) #./configure
-> Generate Makefile, config.log, and config.status

(9) stay configure Specify the external header file and library to be linked to when
     Be careful export
 export LDFLAGS="-L/home/songwei/double-conversion/" CPPFLAGS="-I/home/songwei/double-conversion/src/" CFLAGS="-I/home/songwei/double-conversion/src/" LIBS="-ldouble_conversion -ldouble_conversion_pic"
./configure --prefix=/usr/local/folly ########################################################## The next one is clearer

One 、 Generate Makefile flow chart

Two 、 Specific examples

Order of execution :autoscan; aclocal; autoconf; autoheader; automake --add-missing; ./configure; make; ./helloworld;

1、 Create a directory

Create one in your work directory helloworld Catalog , For storage helloworld Procedures and related documents , If in /home/my/build Next :

$ mkdir helloword
$ cd helloworld

2、 helloworld.c

Edit the file , Save exit when finished . Now in helloworld There should be one in the directory that you wrote yourself helloworld.c 了 .

 int main(int argc, char** argv)
{
printf("Hello, Linux World! ");
return 0;
}

3、 Generate configure

 $ autoscan
$ ls
configure.scan helloworld.c

After implementation hellowrold A file will be generated in the directory :configure.scan, You can use it as configure.ac My blueprint .

 

4、 Generate configure.ac

  You will now configure.scan Renamed as configure.ac, And edit it , Modify as follows , Remove irrelevant statements :
 # -*- Autoconf -*-
# Process this file with autoconf to produce a configure script. AC_PREREQ([2.69])
#AC_INIT([FULL-PACKAGE-NAME], [VERSION], [BUG-REPORT-ADDRESS])
AC_INIT(HelloWorld, 1.0, jiangtengfei007@163.com)
AM_INIT_AUTOMAKE(HelloWorld, 1.0) # This sentence is very important , Otherwise, below aclocal error
AC_CONFIG_SRCDIR([HelloWorld.c])
AC_CONFIG_HEADERS([config.h]) # Checks for programs.
AC_PROG_CC # Checks for libraries. # Checks for header files. # Checks for typedefs, structures, and compiler characteristics. # Checks for library functions. AC_CONFIG_FILES([Makefile])
AC_OUTPUT

5、 perform aclocal and autoconf

And then execute the command aclocal and autoconf, The difference will produce aclocal.m4 And configure Two documents :

 $ aclocal
$ls
aclocal.m4 configure.ac helloworld.c
$ autoconf
$ ls
aclocal.m4 autom4te.cache configure configure.ac helloworld.c

You can see configure.ac The content is some macro definitions , These great classics autoconf After processing, it will become to check the characteristics of the system 、 environment variable 、 The software must have the parameters of shell Script .

autoconf  Is used to generate auto configuration software source code script (configure) Tools for .configure Scripts can be independent of autoconf function , And in the process of running , No user intervention is required .

To generate configure file , You have to tell autoconf How to find the macro you use . The way is to use aclocal Program to generate your aclocal.m4.

aclocal according to configure.ac The content of the document , Automatic generation aclocal.m4 file .aclocal It's a perl  Script program , It's defined as :“aclocal - create aclocal.m4 by scanning configure.ac”.

autoconf from configure.ac This list is created in the template file of various parameters needed to compile the software configure.

autoconf need GNU m4 Macro processor to handle aclocal.m4, Generate configure Script .

m4 It's a macro processor . Copy input to output , Expand the macro at the same time . Macros can be embedded , It can also be user-defined . In addition to being able to expand macros ,m4 There are also some built-in functions , Used to reference files , Carry out orders , Integer operation , Text operation , Cycle, etc .m4 It can be used as the front end of compiler , It can also be used as a macro processor alone .

 
 

6、 perform autoheader

In execution automake --add-missing Before execution autoheade,  Generate config.h.in
 
 

7、 newly build Makefile.am

AUTOMAKE_OPTIONS=foreign
bin_PROGRAMS=helloworld
helloworld_SOURCES=helloworld.c 

automake According to what you wrote Makefile.am To automatically generate Makefile.in.Makefile.am Macro and target defined in , Will guide automake Generate the specified code . for example , macro bin_PROGRAMS Will cause the target of compilation and connection to be generated .

 

8、 function automake

* AutoConf_ automake --add-missing
configure.ac:7: warning: AM_INIT_AUTOMAKE: two- and three-arguments forms are deprecated. For more info, see:
configure.ac:7: http://www.gnu.org/software/automake/manual/automake.html#Modernize-AM_005fINIT_005fAUTOMAKE-invocation
configure.ac:12: installing './compile'
configure.ac:7: installing './install-sh'
configure.ac:7: installing './missing'
Makefile.am: installing './depcomp'

automake Will be based on Makefile.am Files produce some files , Including the most important Makefile.in.

9、 perform configure Generate Makefile

* ./configure
checking for a BSD-compatible install... /usr/bin/install -c
checking whether build environment is sane... yes
checking for a thread-safe mkdir -p... ./install-sh -c -d
checking for gawk... no
checking for mawk... no
checking for nawk... no
checking for awk... awk
checking whether make sets $(MAKE)... yes
checking whether make supports nested variables... yes
checking for gcc... gcc
checking whether the C compiler works... yes
checking for C compiler default output file name... a.out
checking for suffix of executables...
checking whether we are cross compiling... no
checking for suffix of object files... o
checking whether we are using the GNU C compiler... yes
checking whether gcc accepts -g... yes
checking for gcc option to accept ISO C89... none needed
checking whether gcc understands -c and -o together... yes
checking for style of include used by make... GNU
checking dependency style of gcc... gcc3
checking that generated files are newer than configure... done
configure: creating ./config.status
config.status: creating Makefile
config.status: creating config.h
config.status: executing depfiles commands
* ls -l Makefile
-rw-rw-r-- 1 yutao yutao 15035 Oct 15 10:40 Makefile 

You can see , here Makefile It has been produced .

10、 Use Makefile Compile code

* make
/Applications/Xcode.app/Contents/Developer/usr/bin/make all-am
gcc -DHAVE_CONFIG_H -I. -g -O2 -MT helloworld.o -MD -MP -MF .deps/helloworld.Tpo -c -o helloworld.o helloworld.c
mv -f .deps/helloworld.Tpo .deps/helloworld.Po
gcc -g -O2 -o helloworld helloworld.o

11、 function helloworld

* ./helloworld
Hello World!!!!

such helloworld It's compiled , If you follow the steps above , It should also be easy to compile the correct helloworld file . You can also try to use some other make command , Such as make clean,make install,make dist, See what they're going to do for you . How do you feel ? I can write such a professional Makefile, The boss will look at you with new eyes .

3、 ... and 、 Detailed command  

1、 autoscan

autoscan Is used to scan the source code directory to generate configure.scan Of documents .autoscan You can use the directory name as a parameter , But if you don't use parameters , that autoscan It will be assumed that the current directory is being used .autoscan Will scan the source files in the directory you specify , And create configure.scan file .

2、 configure.scan

configure.scan Contains basic options for system configuration , It's full of macro definitions . We need to change it to configure.ac

3、 aclocal

aclocal It's a perl  Script program .aclocal according to configure.ac The content of the document , Automatic generation aclocal.m4 file .aclocal Is defined as :“aclocal
- create aclocal.m4 by scanning configure.ac”.

4、 autoconf

Use autoconf, according to configure.in and aclocal.m4 To produce configure file .configure It's a script , It can set the source program to adapt to a variety of different operating system platforms , And according to different systems to produce the appropriate Makefile, So that your source code can be compiled on different operating system platforms .

configure.ac The contents of the file are some macros , These macros go through autoconf  After processing, it will become to check the characteristics of the system 、 environment variable 、 The software must have the parameters of shell Script .configure.ac The order of the macros in the file is not specified , But you have to add... To the front and back of all macros AC_INIT The macro and AC_OUTPUT macro .

stay configure.ini in :

 # A sign means a comment , The content behind this macro will be ignored .
AC_INIT(FILE) // This macro is used to check the path of the source code .
AM_INIT_AUTOMAKE(PACKAGE, VERSION) // This macro is required , It describes the name of the package we are going to build and its version number :PACKAGE It's the name of the package ,VERSION It's the version number . When you use make dist On command , It will give you a similar helloworld-1.0.tar.gz Software distribution package for , There is the name and version number of the corresponding software package .
AC_PROG_CC // This macro will check the C compiler .
AC_OUTPUT(FILE) // This macro is what we want to output Makefile Name .

We are using automake when , In fact, you need to use some other macros , But we can use aclocal To help us automatically generate . perform aclocal And then we'll get aclocal.m4 file . Produced configure.ac and aclocal.m4 After two macro files , We can use autoconf To produce configure The file .

5、 Makefile.am

Makefile.am Is used to generate Makefile.in Of , You need to write by hand .Makefile.am There are some things defined in :

 AUTOMAKE_OPTIONS // In execution automake when , It checks if there are standards in the directory GNU All kinds of files that should be included in the software package , for example AUTHORS、ChangeLog、NEWS Wait for the documents . We set it to foreign when ,automake Will use the standard of general software package to check .
bin_PROGRAMS // This is to specify the file name of the executable file we want to generate . If you want to generate multiple executables , Then separate the names with spaces .
helloworld_SOURCES // This is designated generation “helloworld” The source code needed for . If it uses multiple source files , So please use the space symbol to separate them . Such as the need to helloworld.h,helloworld.c So please write helloworld_SOURCES= helloworld.h helloworld.c.

If you are in the bin_PROGRAMS Multiple executable files are defined , Corresponding to each executable file, the relative filename_SOURCES.

6、 automake

Use automake, according to configure.in and Makefile.am To produce Makefile.in.

 --add-missing // Is defined as “add missing standard files to package”, It will make automake Some files necessary to add a standard software package .

use automake Produced by Makefile.in The document is in line with GNU Makefile Conventional , Next we just need to execute configure This shell  Scripts can produce the right  Makefile  The file .

7、 Makefile

In conformity with GNU Makefiel Conventional Makefile in , Contains some basic predefined operations :

 make // according to Makefile Compiled source code , Connect , Generate target file , Executable file .
make clean // Clear the last time make The command produces object file ( The suffix is “.o” The file of ) And executable files .
make install // Install the compiled executable file into the system directory , It's usually /usr/local/bin Catalog .
make list // Generate and publish package files ( namely distribution package). This command will package the executable and related files into one tar.gz Compressed files are used as packages for publishing software . It will generate a name similar to “PACKAGE-VERSION.tar.gz” The file of .PACKAGE and VERSION, Are we in configure.ac As defined in AM_INIT_AUTOMAKE(PACKAGE, VERSION).
make distcheck // Generate the release package and test it , To determine the correctness of the release package . This operation will automatically unpack the compressed package file , And then execute configure command , And perform make, To make sure there are no errors in the compilation , Finally, it reminds you that the package is ready , It's ready to release .
make distclean // similar make clean, But it will also configure Delete all generated files , Include Makefile.
 

Linux configure,make,make install More articles about

  1. Linux ./configure &amp;&amp; make &amp;&amp; make install Compile, install and uninstall

    Normal compilation and installation / uninstall : The installation of source code is usually done by 3 Step composition : To configure (configure). compile (make). install (make install).   configure A file is an executable script file , It has many options , ...

  2. [linux note ] clarify linux The setup program uses (configure, make, make install)

    As a teacher, I often work with linux Programmers who deal with , Each time the linux Installation software can be used ——apt-get,yum,brew Wait for the application manager to install , Sometimes things don't work out as they wish , You can only compile and install by yourself -wtf, Good beautiful world ? ...

  3. Linux Medium configure,make,make install What are you doing

    stay Linux You often need to install and deploy some software packages or tools , Take a look after you get the installation package , Simple ,configure,make, make install That's it . Sometimes I just think , This configure,make ,mak ...

  4. ./configure &amp;&amp; make &amp;&amp; make install Compile, install and uninstall (Linux)

    ./configure && make && make install Compile, install and uninstall (Linux) Normal compilation and installation / uninstall :   The installation of source code is usually done by 3 Step composition : To configure ( ...

  5. Linux Under the source code compiler installation program (configure/make/make install The role of , And then in /etc/profile Modification in the document PATH environment variable )

    One . Components of the program Linux The following procedures are mostly composed of the following parts : Binary : That is, program files that can be run The library files : That's what we usually see lib A file in a directory The configuration file : There's no need to say more about this , We all know Help document : Usually we are in ...

  6. Linux Compile and install source code package software configure ,make, make install, make test/check, make clean

    http://www.360doc7.net/wxarticlenew/541275971.html One . What is source code package software ? seeing the name of a thing one thinks of its function , Source code package is the visible package of source code , be based on Linux and BSD The software of the system ...

  7. Win or Linux Command analysis of compiling and installing software in : configure; make; make install

    Original address :http://www.cnblogs.com/Jerry-Chou/archive/2010/12/18/1909843.html Translate an article , I was the first to learn from this article why Linux platform ...

  8. Linux Compile and install source code package software configure ,make, make install, make test/check, make clean False target

    http://www.360doc7.net/wxarticlenew/541275971.html One . Components of the program Linux The following procedures are mostly composed of the following parts : Binary : That is, program files that can be run ...

  9. [ turn ]./configure,make,make install The role of

    ./configure,make,make install The role of ( turn ) These are typical uses GNU Of AUTOCONF and AUTOMAKE The installation steps of the generated program . ./configure It's used to test your installation platform ...

Random recommendation

  1. [ practice ] Android5.1.1 Source code - Let someone APP To explain the execution mode running

    [ practice ] Android5.1.1 Source code - Let someone APP To explain the execution mode running   author : Seeking Yu @ Ali gather security Preface The practice of this paper has modified Android5.1.1 Source code . This article simply talks about the principle . stay “ practice ” section ...

  2. WPF textblock Join hyperlink

    <TextBlock Grid.Row=" Margin="75,0,0,0"> <Hyperlink Name="BlogHl" ...

  3. [Bug] The solution is transparency Activity stay Android 6.0 The background is opaque

    How to reproduce Start two in a row Activity , among Activity 1 by Opaque Of Activity Activity 2 by transparent Of Activity It's usually used for bootstrap pages , for example : Pea clip lock screen guide ...

  4. EF INNER JOIN,LEFT JOIN,GROUP JOIN

    IQueryable<TOuter> The extension method of provides  INNER JOIN,GROUP JOIN But it didn't provide LEFT JOIN GROUP JOIN For one to many scenarios , If it's connected GROU ...

  5. JAVA Data compression simple test

    This code is just a simple test , See if it works , Just take notes here . Suitable for application , Like databases , Data caching . There must be resource consumption in compression and decompression ! When the data is less than 500byte There's no need to compress when it's done @Test public void ...

  6. OAuth2.0 Detailed explanation

    1. Use scenarios A The system stores order information B The system needs to query A Order information in the system , But you have to A After the system is verified , To query . here , We have two ways of verification : 1) Have A System accounts / password The disadvantage is that A system , Direct accounts / ...

  7. Make Windows Of ico Icon

    I don't know if this method is the best , When you have time to look at other methods First design the icon ,png The format is just . Using a piece of software IconWorkshop Download a trial version , Improvisation is enough The production steps are as follows : 1. open png picture 2. ...

  8. hdu 4669 simulation

    Ideas : The main thing is to simulate these operations , Time out with a linked list . Just switch to stack emulation #include<map> #include<set> #include<stack> #incl ...

  9. MOOC linux Learning notes ( One )centOS Installation

    stay VMware8 Installation on centos6.3 Prepared documents New virtual machine Select Create a new empty virtual machine choice linux and centos Distribute 20G Hard disk space for ' Modify the configuration Adjust memory space The bridge : Communication between virtual machine and real machine ...

  10. SystemTray The color of the text

    Today I want to give SystemTray Of ForegroundColor Set to white , But the simulator is right , The real machine is still black . After some tossing , It turns out that Microsoft has made restrictions , What color is the background ,ForegroundColor I can't tell you why the color . ...