linux 注释 续行_linux 行注释 - CSDN
  • 目录   第一天 linux简介, 安装, 目录管理命令 第一章 linux简介 X-SHELL 软件的常用快捷键: ctrl+c 强制终止 ...光标移动到尾 LAMP: linux+apache+mysql+php php和asp都各有


    目录


     

    第一天 linux简介, 安装, 目录管理命令


    第一章 linux简介


    X-SHELL 软件的常用快捷键:

    ctrl+c 强制终止

    ctrl+l 清屏

    ctrl+u 从光标所在删除到行首

    ctrl+a 光标移动到行首

    ctrl+e 光标移动到行尾


    LAMP: linux+apache+mysql+php php和asp都各有特点, mysql不如SQLServer

    但linux的稳定性和安全性比WIDOWS高

    Windwos: Windows+IIS+SQLServer+ASP    


    常见Unix

    AIX IBM

    HP-UX HP

    solaris SUN


    常见的Linux


    1、fedora、RedHat、CentOS、SUSE、gentoo、红旗、Mandriva、turbolinux

    RHEL enterprise


    Redhat:

    个人版:fedora

    企业版;RHEL


    Windows:

    个人版: win7 8 10 xp 阉割

    企业版: winNT 2000 2003 2008

    CentOS  5.5 2.6.18 www.kernel.org 3.1。14


    2、Debian、Ubuntu


    Linux特点


    特点:开源 免费

    稳定

    安全

    缺点: 易用性差

    厂商支持性差


    第二章 Linux安装


    一  虚拟机使用

    VMware主要特点:

    1、不需要分区或重新开机就能在同一台PC上使用两种以上的操作系统

    2、本机系统可以与虚拟机系统网络通信

    3、可以设定并且随时修改虚拟机操作系统的硬件环境


    安装方式

    图形安装 :直接回车

    字符安装:linux text  回车

    耗费资源少,安装速度快。显卡不能识别


    分区表: MBR 主引导记录 64B 16B


    IDE: 133MB/s

    SCSI: 200MB/s

    SATA: 500MB/s




    分区


    linux分区表示


    分区类型:

    主分区:最多只能分四个

    扩展分区: 扩展分区最多1个,扩展不能格式化,也不能写入数据。只能包含逻辑分区。扩展分区加主分区最多有4个。

    逻辑分区:


    文件系统:

    Windows: fat16 fat32 ntfs

    Linux: ext2 ext3 ext4

    Inode i节点


    1) 注意事项

    注意: linux下所有内容都是文件,包括硬件

    linux严格区分大小写

    linux下不以扩展名区分文件类型,而是靠权限.

    但是有特列,如压缩文件,rpm软件包文件

    所有的可存储设备,都必须挂载使用。包括硬盘


    2) Linux分区表示

    /dev/hda1 hd:IDE硬盘 sd:SCSI,SATA硬盘

    a:第一块硬盘 1:第一个分区

    /dev/sda1

    /dev/sdc5 第三块scsi硬盘的,第1个逻辑分区


    3)挂载过程

    windows中: 盘符

    C:\

    D:\

    E:\

    Linux中:


    硬盘文件名----------指定挂载目录(盘符) 挂载

    /dev/sda1-----------/boot


    2 linux分区

    1)必须分区

    / 根分区必须单独分。 越大越好 C:分区

    swap分区 交换分区 2倍 不要大于2GB

    2)常用分区

    /boot 启动分区 100MB /dev/sda1 D:分区

    /home E:分区

    /www F:分区


    3 密码原则:

    复杂性,容易记忆性,时效性


    linux管理员: root

    wmzxdlxx

    wm2xd_LXX


    flzx_3QC


    root


    撞库:就是去小的网站,去安全性低的网站把账号密码弄到,然后再用这个账号密码去别的网站试试.


    4 安装完成基本

    关闭防火墙

    关闭SELinux 增强安全组件

    修改IP地址:

    安装时修改

    setup----- service  network restart


    5 远程管理工具


    6 远程文件传输工具


    第三章 Linux常用命令


    linux命令的格式


    1、命令  [选项]  [参数]


    ls list 显示目录下内容


    命令名称:ls

    命令英文原意:list

    命令所在路径:/bin/ls

    执行权限:所有用户

    功能描述:显示目录文件


    ls 名直接回车,显示目录下内容


    ls  -l 长格式显示

    (缩略选项用一个减号,完整选项用两个减号)

    如: ls -a  和 ls --all 是同样的效果. 



    -rw-------    1   root    root    1190    08-10 23:37     anaconda-ks.cfg

    第一项: 权限位

    第二项:  1 引用计数

    第三项:  root 所有者

    第四项:  root   初始组

    第五项:  大小

    第六项 最后一次修改时间

    第七项 文件名


    ls  -a  显示所有文件(包含隐藏文件) all

    ls  -al

    ls  -h 文件大小显示为常见大小单位 B KB MB human-readable:人性化显示

    ls  -d 显示目录本身,而不是里面的子文件 directory

    ls  -l 使用详细格式列表 list



    示符:

    [root@localhost src]#


    [当前登录用户@主机名 当前所在目录]#


    # 超级用户

    $ 普通用户


    当前所在目录: ~ 用户家目录

    管理员 /root

    普通用户 /home/用户名


    目录操作命令


    1) cd 切换所在目录


    命令名称:cd

    命令英文原意:change directory

    命令所在路径:shell内置命令

    执行权限:所有用户



    ②cd  /usr/local/src

      

    相对路径:参照当前所在目录,进行查找。一定要先确定当前所在目录。    root]#cd  ../usr/local/src

    绝对路径:cd  /usr/local/src 从根目录开始指定,一级一级递归查找。 在任何目录下,都能进入指定位置


    cd  ~ 进入当前用户的家目录 /root /home/aa/

    cd 进入当前用户的家目录 /root /home/aa/

    cd  - 进入上次目录

    cd  .. 进入上一级目录

    cd  . 进入当前目录


    2) pwd 显示当前所在目录

    命令名称:pwd

    命令英文原意:print working directory

    命令所在路径:/bin/pwd

    执行权限:所有用户


    3) linux常见目录

    / 根目录

    /bin 命令保存目录(普通用户就可以读取的命令) binary

    /boot 启动目录,启动相关文件

    /dev 设备文件保存目录 device

    /etc 配置文件保存目录  edit text config

    /home 普通用户的家目录 

    /lib 系统库保存目录

    /mnt 系统挂载目录 mount

    /media 挂载目录

    /root 超级用户的家目录

    /tmp 临时目录

    /sbin 命令保存目录(超级用户才能使用的目录)

    /proc 直接写入内存的

    /sys system

    /usr 系统软件资源目录   unix system resource

    /usr/bin/ 系统命令(普通用户)

    /usr/sbin/ 系统命令(超级用户)

    /var 系统相关文档内容

    /var/log/ 系统日志位置

    /var/spool/mail/ 系统默认邮箱位置

    /var/lib/mysql/ 默认安装的mysql的库文件目录

    4) 建立目录

    mkdir  目录名

    命令名称:mkdir

    命令英文原意:make directories

    命令所在路径:/bin/mkdir

    执行权限:所有用户


    mkdir  -p  11/22/33/44

    p :parents:若所要建立目录的上层目录目前尚未建立

    则会一并建立上层目录

    5) 删除目录

    rmdir  目录 只能删除空目录

    命令名称:rmdir

    命令英文原意:remove empty directories

    命令所在路径:/bin/rmdir

    执行权限:所有用户


    rm  文件名 删除文件


    rm  -rf   目录 删除文件和目录 force:强制删除目录或文件

    -r  递归,删除目录 recursive:递归处理,将指定目录下的所 有子文件及子目录一并处理.

    -f  强制 force


    6)  tree  目录名 显示指定目录下所有内容的目录树

    命令名称:tree

    命令所在路径:/usr/bin/tree

    执行权限:所有用户





    作业:

    1、安装Linux(Vmware、Linux系统、远程工具)

    2、课堂练习

    2、预习-Linux常用命令















    第二天 linux常用命令


    文件操作命令


    1)创建空文件或修改文件时间


    touch  文件名

    命令名称:touch

    命令所在路径:/bin/touch

    执行权限:所有用户

    touch a 如果文件a不存在,则建立空文件,文件名是a, 如果a文 件存在, 则更改a文件的最后修改时间.

    touch a b c d 一次创建多个空文件



    2)删除


    rm  -rf  文件名

    -r  删除目录

    -f 强制

    命令名称:rm

    命令英文原意:remove

    命令所在路径:/bin/rm

    执行权限:所有用户

    rm a 删除文件a

    rm a b c  删除多个文件a b c ,但是会询问是否要删除,按y或者n

    rm -f a b c d 强制删除多个文件a b c d ,不会询问,直接删除

    rm -r 删除目录



             3)cat  文件名 查看文件内容。从头到尾

    命令名称:cat

    命令所在路径:/bin/cat

    执行权限:所有用户

                 tac 文件名 查看文件内容,从尾到头


    -n 列出行号 n : number


    4)more  文件名 分屏显示文件内容

    命令名称:more

    命令所在路径:/bin/more

    执行权限:所有用户

    less 文件名 与 more 类似, 按 pgup 和 pgdn 翻页


    空格向下翻页 b   向上翻页 q  退出


    6) head  文件名 显示文件头

    命令名称:head

    命令所在路径:/usr/bin/head

    执行权限:所有用户

    head  -n  行数   文件名 指定显示文件头几行

    head  -n  20  文件名

    head  -20  文件名


    7) tail 文件名  显示文件末尾

    与head命令类似, 但显示的是尾页


    8) 链接文件

    命令名称:ln

    命令英文原意:link

    命令所在路径:/bin/ln

    执行权限:所有用户


    快捷方式

    新建的链接,占用不同的硬盘位置

    修改一个文件,两都改变

    删除源文件,软连接打不开


    ln  -s  源文件  目标文件 s: symbolic 对文件建立符号链接,而非硬链

    文件名都必须写绝对路径


    文件和目录都能操作的命令


    1)rm 删除文件或目录


    2)复制

    命令名称:cp

    命令英文原意:copy

    命令所在路径:/bin/cp

    执行权限:所有用户



    cp  源文件  目标位置               


    -r  复制目录

    -p 连带文件属性复制 preserve :保留  保留源文件或目录的属性, 

      修改日期也是源文件的日期

    -d 若源文件是链接文件,则复制链接属性

    -d或--no-dereference  当复制符号连接时,把目标文件或目录 也建立为符号连接,并指向与源文件或目录连接的原始文件或目录

    -a 相当于  -pdr   -archive 此参数的效果和同时指定"-dpR"参数相同。 


    cp  aa  /tmp/ 原名复制

    cp  aa  /tmp/bb 改名复制



    3)剪切或改名

    命令名称:mv

    命令英文原意:move

    命令所在路径:/bin/mv

    执行权限:所有用户


    mv  源文件  目标位置

    mv  /root/aa  /tmp/ 剪切

    mv  aa  bb 改名



    权限管理


    1 权限位

    -rw-r--r--   1   root root     0 08-11 01:45 aa


     


    权限位是十位

    第1位: 代表文件类型

    - 普通文件

    d 目录文件

    l 链接文件


    第2-4位: 属主权限u  user  

    第5-7位: 属组权限g     group

    第8-10位: 其他人权限o other


    r 4

    w 2

    x 执行 1

    目录要么不给权限,要么就给5,

    2 修改权限

    chmod

    命令名称:chmod

    命令英文原意:change the permissions mode of a file

    命令所在路径:/bin/chmod

    执行权限:所有用户


    chmod  u+x  aa aa文件的属主加上执行权限

    chmod  u-x  aa

    chmod  g+w,o+w  aa

    chmod  u=rwx  aa

    chmod  755  aa

    chmod  644  aa

    3 权限意义:

    1)权限对文件的含义

    r:读取文件内容 cat  more  head  tail

    w:编辑、新增、修改文件内容 vi  echo

      但是不包含删除文件

    x:可执行

     

    2)权限对目录的含义

    r:可以查询目录下文件名 ls

    w:具有修改目录结构的权限。如新建文件和目录,删除此目录下文件和目录, 重命名此目录下文件和目录,剪切 touch  rm  mv  cp

    x:可以进入目录 cd

    目录要么不给权限,要么就给5, 也就是只给 rx- 的权限. 


    4 属主和属组命令

    chown

    命令名称:chown

    命令英文原意:change file ownership

    命令所在路径:/bin/chown

    执行权限:所有用户


    chown  用户名  文件名 改变文件属主


    chown  user1  aa user1必须存在


    chown  user1:user1  aa 改变属主同时改变属组


    useradd  用户名 添加用户

    passwd 用户名 设定用户密码


    帮助命令

    1 man  命令名 查看命令的帮助

    命令名称:man

    命令英文原意:manual

    命令所在路径:/usr/bin/man

    执行权限:所有用户

    2 命令  --help 查看命令的常见选项

    是在命令的后面输入--help

    查找命令


    通配符:

    * 匹配任意内容

    匹配任意一个内容

    []



    1 whereis  命令名 查找命令的命令,同时看到帮助文档位置,只是查找命令的

    命令名称:whereis

    命令所在路径:/usr/bin/whereis

    执行权限:所有用户


    2 find 搜索命令

    命令名称:find

    命令所在路径:/usr/bin/find

    执行权限:所有用户

    find  查找位置   -name  文件名

    按照文件名查找


    find  /  -name  aabbcc 按照文件名查找



    按照用户

    -user  用户名 按照属主用户名查找文件

    -group  组名 按照属组组名查找文件

    -nouser 找没有属主的文件


    /proc 内核

    /sys 内核

    /mnt/cdrom/ 光盘 除了这三个目录

    find  /  -nouser


    按照文件权限

    -name 按照文件名

    -size 按照文件大小。+50k:大于50k,-50k:小于50k,50k:等于50k k M 注意:k是小写,M是大写

    find  /  -size  +50k


    -type 类型 按照文件类型查找 f:普通 d:目录 l:链接


    find  /root  -perm  644 按照权限查找


    -iname 按照文件名查找,不区分大小写


    -inum 按照i节点查找

    find . -inum 2739078


    在查找出的结果中,直接进行命令操作

    find  /var/log/  -mtime  +10  -exec  rm -rf  {} \;

    -mtime<24小时数>  查找在指定时间曾被更改过的文件或目录,单位以24小时计算

    注意:{}空格\;   没有这个空格报错.


    find /root -inum  1140247  -exec  ls -l {} \;


    3 grep “字符串”  文件名 查找符合条件的字串行。

    命令名称:grep

    命令所在路径:/bin/grep

    执行权限:所有用户


    grep  -i  “root”  /etc/passwd   -i或--ignore-case   忽略字符大小写的差别。

    -v 反向选择 -v或--revert-match   反转查找。

    -i 忽略大小写


    Find: 在系统当中搜索符合条件的文件名,如果需要匹配,使用通配符匹配。

    通配符是完全匹配。

    Grep: 在文件当中搜索符合条件的字符串,如果需要匹配,使用正则表达式匹配.

    正则表达式是包含匹配


    4 管道符

    命令1  |  命令2 命令1的执行结果,作为命令2的执行条件

    netstat -an | grep ESTABLISHED | wc -l

    统计正在连接的网络连接数量

      established adj. 确定的;已制定的,已建立的

    wc 计算字数 -l或--lines   只显示列数。

    cat  文件名  |  grep  “字串”     提取含有字符串的行

    grep  “字符串”  文件名

    ls  -l  /etc  |  more 分屏显示ls内容


    补充命令:

    netstat  查看网络状态的命令, 查看端口. netstat -tlun

    -t 查看tcp端口 -t或--tcp   显示TCP传输协议的连线状况。

    -u 查看udp端口 --u或--udp   显示UDP传输协议的连线状况。

    -l 监听 -l或--listening   显示监控中的服务器的Socket。

    -n 以IP和端口号显示,不用域名和服务名显示

    -n或--numeric   直接使用IP地址,而不通过域名服务器。

    -a 查询所有连接 -a或--all   显示所有连线中的Socket


    目录要么不给权限,要么就给5,




    压缩和解压缩

    .gz .bz2 linux可以识别的常见压缩格式

    .tar.gz .tar.bz2 常见的压缩和打包命令


    压缩同时打包

    tar  -zcvf  压缩文件名  源文件

    tar  -zcvf  aa.tar.gz  aa

    tar  -zcvf  aa.tar.gz  aa  bb  cc

    同时压缩3个文件,分别是aa bb cc ,不同文件用空格分隔.

    -z  识别.gz格式 -z或--gzip或--ungzip   

    通过gzip指令处理备份文件

    -c: 压缩 -c或--create   建立新的备份文件。

    -v:显示压缩过程 -v或--verbose   显示指令执行过程

    -f:指定压缩包名 -f<备份文件>或--file=<备份文件>   

    指定备份文件。

     -x或--extract或--get  从备份文件中还原文件

    tar  -zxvf  压缩文件名 解压缩同时解打包   是解压到当前的目录下

    tar -jxvf root.tar.bz2 -C /tmp/ 指定解压缩位置 -C 指定解压缩位置

    tar  -jcvf  压缩文件名  源文件 压缩同时打包

    tar  -jcvf  aa.tar.bz2  aa

    tar  -jxvf  aa.tar.bz2 解打包同时解压缩


    查看不解包

    tar  -ztvf  aa.tar.gz 查看不解包

    tar  -jtvf  aa.tar.bz2

    -t  只查看,不解压 -t或--list   列出备份文件的内容





    关闭和重启命令

    1)shutdown  -h  now 没有特殊情况,使用此命令

    -h 关机 halt 发音: [浩t]  停止

    -r 重启


    shutdown  -r  now

    远程服务器不允许关机,只能重启.


    命令名称:shutdown

    命令所在路径:/sbin/shutdown

    执行权限:root

    2)reboot

    命令名称:reboot

    命令所在路径:/sbin/reboot

    执行权限:root


    logout 退出

    exit 




    挂载命令

    linux所有存储设备都必须挂载使用,包括硬盘

    命令名称:mount

    命令所在路径:/bin/mount

    执行权限:所有用户


    光盘挂载


    /dev/sda1 第一个scsi硬盘的第一分区

    /dev/cdrom 光盘

    /dev/hdc 光盘 centos  5.5

    /dev/sr0 光盘 centos 6.x

    mount  -t  文件系统  设备描述文件  挂载点(已经存在的空目录)

    mount  -t  iso9660  /dev/cdrom  /mnt/cdrom

    mount /dev/cdrom /mnt/cdrom 如果没有/mnt/cdrom  要先创建一个

    mount 查看已经挂载的设备

    cd /mnt/cdrom 进入cdrom

    ls 查看里面的内容


    光盘卸载

    umount  /dev/cdrom 

    umount  /mnt/cdrom 强调:退出挂载目录,才能卸载


    fdisk  -l

    mount  -t  vfat  /dev/sdb1  /mnt/usb



    网络命令

    1 ping 测试网络连通性

    命令名称:ping

    命令所在路径:/bin/ping

    执行权限:所有用户


    ping  -c  次数  ip 探测网络通畅  

    -c<完成次数>   设置完成要求回应的次数。

    ping IP 一直ping,按CTRL+C退出


    2 ifconfig  查询本机网络信息

    命令名称:ifconfig

    命令英文原意:interface configure

    命令所在路径:/sbin/ifconfig

    执行权限:root




    [root@localhost ~]# ifconfig

    eth0      Link encap:Ethernet  HWaddr 00:0C:29:30:C8:AF  

    当前的网络是以太网,网卡的max地址

              inet addr:192.168.106.27  Bcast:192.168.106.255  Mask:255.255.255.0

    IP, 广播, 子网掩码

              inet6 addr: fe80::20c:29ff:fe30:c8af/64 Scope:Link IPV6的地址

              UP BROADCAST RUNNING MULTICAST  MTU:1500  Metric:1

    网络传输的参数

              RX packets:485759 errors:1 dropped:35 overruns:0 frame:0

    到现在为止, 接收了多少包

              TX packets:23836 errors:0 dropped:0 overruns:0 carrier:0

    到现在为止, 发送了多少包

              collisions:0 txqueuelen:1000 

              RX bytes:66662290 (63.5 MiB)  TX bytes:12826461 (12.2 MiB)

    到现在为止, 接收包的总大小, 发送包的总大小

              Interrupt:19 Base address:0x2000 

    当前网卡在内存中的地址


    lo        Link encap:Local Loopback  

    本地回环网卡,任何的电脑都有

              inet addr:127.0.0.1  Mask:255.0.0.0

    每个电脑都有这个IP,不接网线也能ping,代表网络协议安装好了

              inet6 addr: ::1/128 Scope:Host

              UP LOOPBACK RUNNING  MTU:16436  Metric:1

              RX packets:0 errors:0 dropped:0 overruns:0 frame:0

              TX packets:0 errors:0 dropped:0 overruns:0 carrier:0

              collisions:0 txqueuelen:0 

              RX bytes:0 (0.0 b)  TX bytes:0 (0.0 b)


    [root@localhost ~]# 




    作业

    1、整理笔记

    2、课堂练习

    3、作业题

    4、预习:vi和软件安装



    复习:

    判断题:

    查看某文件权限为rwxr-xr-- ,则其所属组权限为只读。


    对一个目录有w权限,表示可以修改目录下文件内容。


    3、.tar.gz格式的压缩包可以使用tar -xjf解压缩


    mv剪切目录时不需加-r选项。


    5、/sbin目录下的命令只有root可以使用。


    6、find根据文件大小查找使用选项为-size ,默认单位为KB 。


    7、grep查找时反向查找可以使用-i 。


    8、改变文件的所有者可以使用命令chgrp 。


    第三天 vi编辑器


    vi编辑器简介

    vim 全屏幕纯文本编辑器 是vi的升级版,是linux系统中编程最好的文本编辑器.


    vi  /root/.bashrc 环境变量配置文件

    alias  vi=’vim’ alias: 别名    仅限于此次生效.重启后不生效

    vi ~/.bashrc 进入别名的文件,加进去,以后就一直有效了,只限于本用户 bash : base shell的意思      rc : resource 的意思

    vim使用

    1 vi模式 

    vi  文件名



     

    命令模式 其他模式,按ESC进入命令模式

    输入模式 在命令模式,按i , a , o 都可以进入输入模式

    末行模式 输入:就进入了末行模式

    在任何模式,按Esc都可以进入到命令模式(插入模式需要按:q退出后)




    命令----》输入  a:追加 add, 在原始的光标后面出现输入的字符  

    i:插入 input, 在原始的光标前面出现输入的字符  

    o:打开 open, 另起一行,显示输入的字符

    命令----》末行   :w  保存  write 只保存不退出  

    :q  不保存退出  quit 不保存退出 

    :wq 保存退出

    !   强制  

    :q! 强制不保存退出(任何用户都可以使用,)   

    用于:用户修改了文件,但是想不保存,直接退出.就要用强 制!.修改就消失了 默认:q退不出去.

    :wq!(只有root用户可用,)

    用于:对没有写权限的文件做修改,是只读文件,root用户可 以修改,但是退出的时候,会提示”在修改一个只读文件”,所以 需要强制.

    输入----末行


    2 命令模式操作


    1)光标移动

    hjkl 代替方向键, h: 左 j: 下 k:上 l:右


    :n 移动到第几行 :3移动到第3行,光标位于行首


    gg 移动文件头 光标移动到第一行,位于行首

    G 移动到文件尾 光标移动到最后一行,位于行首


    3)删除字母

    x 删除单个字母 删除光标位置的一个字符

    nx 删除n个字母 删除光标后面的n个字符. 

    如: 3x 就是删除光标位置开始,后面的3个字符.


    4)删除整行 剪切

    dd 删除单行 删除光标位置所在的行

    注意:是删除整行的内容,而不是显示出来的一行

    ndd 删除多行 光标位置所在的行开始,向下删除n行,如: 3dd   

    p 粘贴 是粘贴在光标位置的下一行

    P(大) 粘贴到光标前 是粘贴在光标位置的上一行


    dG 从光标所在行删除到文件尾

    要想删除整个文件,可以按gg把光标移动到文件头,然后按dG


    5)复制

    yy 复制光标所在行的内容

    Nyy 赋值光标所在向下N行的内容


    6)撤销

    u 撤销

    ctrl+r 反撤销


    7)显示行号

    :set  nu nu 是number的缩写

    :set  nonu nonu 是no number的缩写


    8)颜色开关

    :syntax  off syntax 是”语法”的意思

    :syntax  on


    vim配置文件

    ~/.vimrc 手工建立的,vi配置文件

    想要的功能是,以后每次进入vim都显示行号

    cd    返回家目录,目的是只有现在的这个用户更改了配置文件

    vi .vimrc 进入配置文件,里面默认是空的.想要什么功能自己直接写

    i 进入插入模式

    set nu 设置显示行号. 注意: 行首没有冒号:

    Esc 返回命令模式

    :wq 保存退出



    9)查找 掌握

    /查找内容 向下查找 被查找的内容以黄色背景显示

    n 下一个

    N 上一个


    10)替换

    :1,10s/old/new/g 替换1到10行的所有old为new

    g: 把找到的所有内容都替换,不加g, 只替换找到的第一个.

    :%s/old/new/g 替换整个文件的old为new

    g 范围内所有old换为new


    :1,5s/^/#/g 注释1到5行 ^是正则中的起始符

    :1,5s/^#//g 取消注释


    :1,5s/^/\/\//g 文件头加入// \的共是转义/

    :1,10s/^\/\///g


    编译: 就是把高级语言转换为机器码(二进制)的过程


    软件包安装


    软件包分类: 两类, 1:源码包 2:脚本安装包


    源码包 优点: 特点 开源 自由定制

    能看到源码, 所以是开源的,执行效率要比RPM包的效率高5%

    如果是一个大的商城,如淘宝,京东,这个是就很大的问题.

    缺点: 编译时间长,一旦报错,很难解决

    需要编译,编译很占资源,很费时间,一个mysql安装包,23M,解压后130M

    I7电脑需要15分钟,编译是不可逆转的.

    脚本安装包:


    二进制包:rpm包

    特点:安装速度快 简易

    缺点:自定义性差 依赖性 依赖性特差,需要安装很多的依赖包


    选择安装包的原则:

    如果这个软件是给系统自用的,用RPM包

    如果软件是给客户端提供服务器,用源码包


    a---->b---->c 树形依赖 解决方案:先安装c 再装b  再装a

    a---b----c---a 环形依赖 解决方法:a b c 一起装,用一条命令安装

    库文件依赖 www.rpmfind.net

    (rpm -ivh /mnt/CentOS/mysql-connector-odbc-3.51.26r1127-1.el5.i386.rpm )


    libodbcinst.so.1


    rpm安装


     手工RPM命令安装


    1 包命名

    包名-版本号-发布次数-适合linux系统-硬件平台.rpm

    openaislib-devel-1.1.1-7.el6.i686.rpm

    包名:  openaislib-devel

    版本号:  1.1.1

    发布次数:7

    适合linux系统:el6

    硬件平台: i686

    rpm: rpm包


    包全名:操作没有安装的软件包,软件包使用包全名

    包名:操作的是已经安装的软件包,软件包使用包名


    2 依赖性


    3 安装


    service  httpd  start 启动apache

    netstat -tlun 查看端口,看看apache是否启动了,apache是80的端口

    -t或--tcp   显示TCP传输协议的连线状况

    -l或--listening   显示监控中的服务器的Socket

    -u或--udp   显示UDP传输协议的连线状况

    -n或--numeric   直接使用IP地址,而不通过域名服务器

    Aphache rpm包的网页目录. 

    vi  /var/www/html/index.html


    setup  进入之后可以配置IP,防火墙...



    rpm  -ivh  包全名(绝对路径)

    只有安装和升级才用到包全名,剩下的都是包名就可以

    -i  install 安装 -v 显示详细信息 -h 显示进度


    rpm  -Uvh  包全名

    -U  升级


    4 卸载

    rpm  -e  包名

    --nodeps 不检查依赖性

    no depends 强烈不推线这么做,因为会卸载掉系统的依赖包.


    5 查询

    1)查询软件包是否安装

    rpm  -q  包名 查询包是否安装

    因为rpm包已经安装,所以包名不用写全称.是精确查询

    rpm  -qa  | grep  httpd 显示所有安装包

    是包含匹配,能查到文件名是httpd的

    2)查询包信息

    rpm  -qi  包名 查询包的信息 包的一些信息,包名, 版本, 网站, 简介等等

    -i information


    3)查看包中文件安装位置

    安装位置是作者认为装哪里,就装哪里.一般不需要指定安装位置.

    rpm  -ql  包名 查询包中文件的安装位置

    能看到安装的内容,一般包括配置文件,库,执行命令等等.

    -l list

    4)查询系统文件属于哪个包

    通过包装出来的文件才能查询.如: touch出来的文件就查不到

    rpm  -qf  系统文件名 查询系统文件属于哪个包

    注意:是系统文件,是包经过安装后的文件.


    (7) 启动httpd服务

    service  httpd  restart|start|stop|status


    /etc/rc.d/init.d/httpd  start

    服务的绝对路径可以查看服务.

    /etc/rc.d/init.d/


    (二 )  yum 仅仅是rpm在线的一种安装方法,没有yum包. 

    Redhat的yum在线安装是售后服务,收费,而CentOS免费.

    安装和卸载都可以用yum执行,但是查询不能.查询是用于已经安装的文 件.而yum是用于安装新的文件和卸载已经安装的文件.


    yum  -y  install  包名 安装 -y  自动回答yes

    注意:只需要写包名就可以了.不用谢包全名. 

    如果没有-y 那么,每装一个包都会询问是否安装.

    yum  -y  remove  包名 当它不存在

    有可能把系统的依赖包都给卸载掉.所以不用.

    yum  -y  update  包名

    yum  list 查询所有可以安装的包

    查询的是yum源里有哪些包可以用.


    光盘作为yum源:

     1. 让默认的网站yum源不生效.

    cd  /etc/yum.repos.d/

    yum源的相关文件是保存在这个目录中的,默认有4个安装文件.

    其中,生效的是Base.repo,其他的都不起作用. 

    mv  CentOS-Base.repo  CentOS-BS.repo.bak

    把名字改掉,目的是让他失效.这样它就不是默认的生效yum源.

    如:

     13 [base] yum源的名字

     14 name=CentOS-$releasever - Base 说明

     15 mirrorlist=http://mirrorlist.centos.org/?release=$releasever&arch=$basearch&repo=os 地址

     16 #baseurl=http://mirror.centos.org/centos/$releasever/os/$basearch/

     17 gpgcheck=1 是否进行安全级的校验

    虽然没写,但是默认就是enabled=1.默认是yum源生效.

     18 gpgkey=file:///etc/pki/rpm-gpg/RPM-GPG-KEY-CentOS-6


    2. 挂载光盘

    mount /dev/hdc  /mnt/cdrom


    3. 修改光盘安装文件,让其生效.

    vi  /etc/yum.repos.d/CentOS-Media.repo

    进入这个文件,修改以下内容

    baseurl=file:///mnt/cdrom/ 指定yum源位置

    多余的注释掉

    enabled=1 yum源文件生效 enabled=0就是关闭

    gpgcheck=1 rpm验证生效 关掉会降低安全性


    pkill -9 yum-updatesd 如果yum报错正在升级,执行此命令,强制杀死升级进程


    yum  -y  install  gcc (gcc是c语言编译器,不装gcc,源码包不能安装)



    源码包安装


    1 远程传输工具winscp传输apache到linux.

    httpd


    2 安装

    1)解压


    2) cd  解压目录

    3)  查看安装文档


    INSTALL README


    4)编译前准备

    ./configure  --prefix=/usr/local/apache2


    功能:

    1 检测系统环境,生成Makefile

    2 定义软件选项


    5)编译 make  clean

    make


    6)编译安装

    make  install


    报错判断:

    第一:安装过程是否停止

    第二:注意error  warning  no  等错误报警

    3 启动

    /usr/local/apache2/bin/apachectl  start


    4 删除

    直接删除安装目录



    补充:

    date 查看系统时间

    date  -s  20130220 设定日期

    date  -s  09:30:00 设定时间


    du  -sh  目录名

    du(disk usage) 统计目录下所有子文件的大小,最终会统计总大小.

    一般所有统计目录大小的命令都支持 -h

    -s -s或--summarize   仅显示总计。

    -h 习惯单位 -h或--human-readable   以K,M,G为单位,提高信息的可读性


    df  -h df(disk free)  查看分区大小.

    du统计的文件大小是准确的 没有统计缓存等空间.

    df统计的剩余空间是准确的 因为除了文件占用,缓存等也占用.

    所以,剩余空间是准确的.

    服务器应该定时重启, 高负载服务器一周重启一次, 低负载服务器最少一月重启一次


    作业:

    笔记整理

    课堂练习

    课后练习题

    预习:用户管理,服务管理




    IP地址配置:

    1setup 进入配置选项


    2vi /etc/sysconfig/network-scripts/ifcfg-eth0 设置网卡启动

    ONBOOT=no 改为 ONBOOT=yes


    3service  network   restart 重启网络服务


    4、修改虚拟机为桥接(以下步骤,只对虚拟机生效)


    5、虚拟机桥接到有线网卡

    编辑----虚拟网络编辑器----桥接到有线网卡(没有wireless的网卡)


    6、修改UUID冲突(此步骤,只针对复制镜像生效)

    1vi /etc/sysconfig/network-scripts/ifcfg-eth0

    删除MAC地址行

    2rm  -rf  /etc/udev/rules.d/70-persistent-net.rules

    删除网卡和MAC地址绑定文件

    3)重启动系统


    7service  network   restart



    软件安装:

    RPM

    手工命令安装

    安装: rpm -ivh 包全名 -i<套件档>--install<套件档>  安装指定的套件档。

    升级: rpm -Uvh 包全名 -h--hash  套件安装时列出标记 -U<套件档>--upgrade<套件档>   升级指定的套件档

    卸载: rpm -e 包名 -e<套件档>--erase<套件档>  删除指定的套件

    查询:

    查询包是否安装: rpm -qa | grep 包名

    查询包信息: rpm  -qi 包名

    查询包中文件的安装位置: rpm -ql 包名

    查询系统文件属于那个包: rpm -qf 系统文件名


    Yum在线安装

    安装: yum -y install 包名

    升级: yum -y update 包名

    卸载: yum -y remove 包名

    查询 yum list


    源码包:

    安装之前的一些事情

    源码包哪里来? ---官方网站下载的

    在同一个系统中,是否可以安装RPMapache,再装源码包apache?

    可以,安装位置不同(rpm包装在系统默认位置,源码包装在指定位置,一般是/usr/local/目录下,但是只能启动一个.原因是端口都是80)

    如何把软件考进linux系统中. 可以用WinSCP

    安装步骤

    只有3个步骤, 1: 指定安装目录. 2: 编译. 3: 编译安装.

    . 解压缩

    drwxr-xr-x. 11  501 games 4.0K 6月  11 2008 httpd-2.2.9

    -rw-r--r--.  1 root root  6.2M 5月  21 17:27 httpd-2.2.9.tar.gz

    问题:为什么压缩后的文件只有4.0K.

    是分区的问题.目录的BLOCK保存的是文件名.

    4.0K是一级子目录的文件名加起来是4K. Ll命令只能统计文件 大小,不能统计目录大小.统计目录的大小,du命令.

    . 进入压缩目录


    . 查看说明.

    一般都有一个安装说明INSTALL README. 都是大写.

    安装说明里有安装方法和步骤

    .

    . 编译前准备

    ./configure  --prefix=/usr/loacl/apache2

    定义安装选项, 这个是定义安装的位置. 一般的源码包都安装在/usr/local/目录下.

     其他的安装选选项可以输入 ./configure  --help查询

    此步作用:

    检测系统环境. 比如说:如果没有安装gcc, 安装就不能进行了.

    定义安装选项, 写入Makefile文件

    ./configure  --prefix=/usr/loacl/apache2

    ( ./configure  不是linux自带的命令,是包自带的命令. 一般的包都有

    定义了安装的位置. 执行完这条命令, 才会有Makefile文件

    . 确定是否报错, 或安装成功

    报错:

    安装停止

    检测是否出现  no  error  warning  等关键字.

    . 编译

    make 是真正意义上的编译步骤. 可能会慢.

    . 编译安装

    make install

    . 如何确定安装成功.

    进入安装的位置, 然后ls命令显示出文件. 就安装成功了.

    . 如何卸载

    直接删除安装目录






    启动源码包apache.


    rpmapache 如何启动

    serveice  httpd  start

    /etc/rc.d/init.d/httpd  start

    网页位置: /var/www/html/


    源码包apache如何启动

    /usr/local/apache2/bin/apachectl start

    在安装目录下有INSTALL安装说明. 在里面就能看到

     10      $ ./configure --prefix=PREFIX

     11      $ make

     12      $ make install

     13      $ PREFIX/bin/apachectl start        这里就是启动说明, 这里的 PREFIX 代表的是安装的根目录下. 与第一行结合起来看, 第一行是安装目录


    网页位置: /usr/local/apache2/htdocs/




    复习:

    判断题

    1、在vim命令模式中输入:q!是强制不保存退出,只有root可以使用

    2、在vim命令模式中ndd是复制多行

    3、在vim命令模式中:%s/old/new/g会把文件中所有的old替换为new

    4、rpm –ql 包全名 命令是查找包中文件的安装位置

    5、RPM包安装的服务的启动方式是/usr/local/apache2/bin/apachectl start

    6、yum –y install 包全名 命令是yum安装命令

    7、源码包删除方式是直接删除安装目录







    第五天: 用户和用户组管理



    用户管理命令


    用户信息文件: /etc/passwd

    这个命令很重要,可以判断系统中有多少个用户,查看用户的基本信息.

    aa:x:501:501::/home/aa:/bin/bash

    第一列:用户名

    第二列:密码位 x: 表示有密码, 密码在/etc/shadow 文件里

    第三列:UID 用户ID

    0: 管理员 root

    1-499: 伪用户(系统用户)

     系统用户不能删掉,删掉系统就崩了,

    功能是: 每次开机启动服务,一个服务就一个用户.

    >=500 普通用户 也有特殊的, 是大于500的

    第四列:GID 初始组ID 下面红色字

    第五列:用户说明

    自己添加的用户没有说明,

    系统用户一般有说明, 这个说明就是一个注释.

    第六列:家目录

    第七列:用户登录之后的权限

    普通用户一般是 /bin/bash  

    系统用户一般是 /sbin/nologin  

    想让用户不能登录, 就可以改这个, 

    /bin/bash 改成 /sbin/nologin


    影子文件: /etc/shadow

    保存用户加密后的密码的文件, /etc/passwd 里面有的用户. 

    这里面都有.是一个非常重要的文件. 通过权限就能看出来. 权限是000

    里面的内容都是如下格式:

    root:$6$ng3IcE9941zrBQfy$t/ttp8Bkg0viB8Md4uX1V2JhoeknqEJfcJox2wsb5cy5axzLXKOyevf1QmmlFL/WzAQftf0XhR9Imr5VcT0uO/:16573:0:99999:7:::

    其中,共有9列,

    第一列: 用户名

    第二列: 加密后的密码

    第三列: 最近更动密码的日期:这个字段记录了『更动密码的那一天』的日期, 不过,很奇怪呀! 在我的例子中怎么会是 12959 呢?呵呵,这个是因为计算 Linux 日期的时间是以 1970 年 1 月 1 日, 作为 1 ,而 1971 年 1 月 1 日则为 366 啦! 所以这个日期是累加的呢! 得注意一下这个资料

    呦!那么最近的 2005 年 1 月 1 日就是 12784 啦

    第四列: 0, 是密码有效期的宽限期, 0代表没有宽限期, 到有效期了就禁止登陆. 

    如果是3, 就代表有3天的宽限期, 即共计有有效期加宽限期的时间更改密码,不该 就禁止登陆, 这个是超哥讲的. 


    资料上是: 

    密码不可被更动的天数: 第四个字段记录了这个账号的密码需要经过几天才可以被变更!如果是

    0 的话, 表示密码随时可以更动的意思。这的限制是为了怕密码被某些人一改再改而设计的!如

    果设定为 20 天的话,那么当你设定了密码之后, 20 天之内都无法改变这个密码呦!

    第五列: 99999代表密码的有效期是99999天.大概是273年, 可以改这个数据, 让用户更改密码

    第六咧: 7, 代表有效期的前7天开始提示用户更改密码.

    第七列: 账号失效日期:这个日期跟第三个字段一样,都是使用 1970 年以来的总日数设定。这个 字段表示: 这个账号在此字段规定的日期之后,将无法再使用。 这个字段会被使用通常 应该是在『收费服务』的系统中, 你可以规定一个日期让该账号不能再使用啦!




    组信息文件: /etc/group

    mail:x:12:mail,postfix

    sc:x:500: 里面内容的格式都是这样的

    组名:组密码位:组ID:组中附加用户

    组名对应的初始用户是看不到的,只能看到组中的附加用户.


    1 添加用户

    useradd  用户名 这个命令不加选项是合理, 加选项就容易乱 


    useradd  选项  用户名

    选项:

    -g  组名 指定初始组 不要手工指定

    -G  组名 指定附加组,把用户加入组,使用附加组

    -c  说明 添加说明 说明用””包含

    -d  目录 手工指定家目录,目录不需要事先建立

    -s  /bin/bash 手工指定用户登录之后的权限



    useradd  -g  aa  bb 添加bb用户,同时指定初始组为aa

    useradd  -G  user1  aa 添加用户aa,指定附加组为user1

    gpasswd  -a  用户名  组名

    useradd  -g  组名  用户名


    初始组:每个用户初始组只能有一个,初始组只能有一个

    一般都是和用户名相同的组作为初始组

    强烈推荐不更改初始组, 就用默认的和用户名相同的组名.改后容易乱

    不同的用户可以有同一个初始组,但是每个用户只能有一个初始组.

    怎么查用户的初始组,只有一个方法:

    用vi /etc/passwd  命令查看初始组的ID ( GID )

    用vi /etc/group  命令查看刚才的GID, 行头就是初始组的名字.

    附加组:每个用户可以属于多个附加组。要把用户加入组,都是加入附加组


    2 设定密码

    passwd   用户名

    passwd 改变当前用户密码 自己改自己密码,需要输入3便密码

    passwd  root 改变root密码


    3 删除用户

    userdel  -r  用户名

    -r  连带家目录一起删除

    如果只用userdel删除用户, 还会存在目录, 所以,要userdel -r一起用


    4 添加组

    groupadd  组名


    5 删除组

    groupdel  组名 注意:组中没有初始用户

    如果这个组是一个用户的初始组, 就不能被删除


    6 把已经存在的用户加入组

    gpasswd  -a  用户名  组名 用户加入组

    注意: 和 useradd  -g  指定的初始组  添加的用户   操作的是用户  

    而 gpasswd 操作的是组. 这两个是反的.

    gpasswd  -d  用户名  组名 把用户从组中删除 


    用户相关命令

    1 id  用户名 显示用户的UID,初始组,和附加组

    [root@localhost home]# id sc

    uid=500(sc) gid=500(sc) groups=500(sc),0(root)


    2 su  -  用户名 切换用户身份

    su ( super user )   su root 是切换超级用户,需要密码    

    超级用户切换其他用户, 不需要密码

    - 连带环境变量一起切换


    ACL权限

    access control list 访问控制表   用来解决用户身份不足的现象.


    举例: /www

    sc-root

    61-fgroup

    o

    770


    [root@localhost ~]# mkdir /www

    [root@localhost ~]# chmod 770 /www/

    [root@localhost ~]# groupadd fgroup

    [root@localhost ~]# gpasswd -a sc fgroup

    正在将用户“sc”加入到“fgroup”组中

    [root@localhost ~]# gpasswd -a aa fgroup

    正在将用户“aa”加入到“fgroup”组中

    [root@localhost ~]# chown root:fgroup  /www

    [root@localhost ~]# ll -d  /www/

    drwxrwx--- 2 root fgroup 4096 04-25 14:56 /www/


    1 getfacl  文件名 查询文件的acl权限 get file acl

    文件名只能是相对路径. 


    2 setfacl  选项  文件名 设定acl权限 set file acl 

    -m 设定权限

    -b 删除权限


    setfacl  -m  u:用户名:权限   文件名 m: modify 修改

    setfacl  -m  g:组名:权限   文件名


    setfacl  -m u:aa:rwx  /test 给test目录赋予用户aa读写执行的acl权限


    setfacl -m u:cc:rx -R soft/ 赋予递归acl权限,只能赋予目录

    -R  递归 权限溢出


    setfacl  -b  /test 删除acl权限


    3 setfacl  -m d:u:aa:rwx -R /test acl默认权限    注意:默认权限只能赋予 d: default 默认权限

    注意:如果给目录赋予acl权限,两条命令都要输入

    -R 递归

    -m  u:用户名:-R 权限 只对已经存在的文件生效

    -m  d:u:用户名:-R 权限 只对未来要新建的文件生效


    输出重定向和多命令顺序执行


    1 输出重定向

    把应该输出到屏幕的输出,重定向到文件。  只要有输出, 都能记录到文件里.


    > 覆盖

    >> 追加


    ls  >  aa 覆盖到aa

    ls  >>  aa 追加到aa


    ls  gdlslga  2>>aa 错误信息输出到aa 强调:错误输出,不能有空格

    2 错误信息



    掌握

    ls  >>  aa  2>&1 错误和正确都输入到aa,可以追加 输入到同一个文件

    2>&1 把标准错误重定向到标准正确输出


    ls  >>  aa  2>>/tmp/bb 正确信息输入aa,错误信息输入bb   输入到不同的文件




    服务和进程管理


    进程管理三个主要任务:

    判断服务器健康状态

    查看所有正在运行的进程

    强制终止进程


    进程查看


    1 ps  aux 查看当前系统所有运行的进程

    ps ( process status )   

    注意: ps aux  中间没有减号-  ,加减号了会报错的

    -a 显示前台所有进程

    -u 显示用户名

    -x 显示后台进程


    user: 用户名

    pid: 进程id。PID 1  init  系统启动的第一个进程

    %CPU cpu占用百分比

    %MEM 内存占用百分比

    VSZ 虚拟内存占用量 KB

    RSS 固定内存占有量

    tty 登录终端

    tty1-7 本地终端 1-6 字符  7图形

    pts/0-255 0-255个远程终端, 其实支持的比这个多, 但是习惯默认就这么多

    ? 是由内核直接调用

    stat 状态

    S:睡眠 D:不可唤醒 R:运行  

    T:停止  Z:僵死  W:进入内存交换 X:死掉的进程 

    <:高优先级 N:低优先级 L:被锁进内存

    s:含子进程 +:位于后台 l:多线程

    start 进程触发时间

    time 占用cpu时间 越高越占资源

    command 进程本身

    /sbin/init 是所有进程的父进程.  


    vi /etc/inittab   这个就是init的配置文件. 是选择default runlevel的

    id:3:initdefault:   这个就是进入配置文件最底部的内容, 3代表开机默认进入的是命令行界面. 改这个就能修改开机默认的界面. 5是图形界面, 但是必须得安装图形界面. 后面有详细的解释 . 


    2 pstree 查看进程树

    pstree ( process status tree ) 

    会把同类进程合并起来, 用pstree  -p     

    p 的意思是pid, 显示 pid ,这样进程就展开了. 


    3 top 用来判断健康. 每隔3秒刷新一次


    第一行: 系统当前时间 系统持续时间 登录用户数 1,5,15分钟之前的平均负载

    第二行:进程总数

    第三行:CPU占用率 %id 空闲百分比

    第四行:内存使用: 总共 使用 空闲 缓存

    第五航:swap使用


    操作命令 M 内存排序

    P CPU排序

    q 退出




    4 进程管理 终止进程 有真确的关闭方法, 就不要用KILL, 除非关不掉了.

    kill  信号  PID 结束单个进程

    kill -l 查看支持的信号   kill 信号 后面跟的是PID. 不是进程名

    -9  强制


    killall  -9  进程名 结束一类进程

    pkill  -9  进程名 等价于killall



    w 判断登录用户 w: who  命令是查看当前登陆了多少用户

    pkill  -9  -t  终端号 把某个终端登录的用户踢出

    是按照终端号踢出用户的 .TTY

    pkill  -9  -t tty1 把本地登录终端1登录用户踢出



    linux服务管理

    Windows 的服务分为:自动 手动 禁用 

    手动的意思是:开机不启动,需要的时候,不经过用户同意, 直接就启动. 

    Linux 的服务没有手动服务, 只有自动和禁用

    1 分类

    1)系统默认安装的服务 rpm包

    ①独立的服务

    绝大多数的服务都是独立的

    独立的意思是: 服务直接就放到内存里, 需要的话, 服务就直接用. 好处是响应速度快. 缺点是:每一个服务都需要占用一定的内存 

    ②基于xinetd的服务,xinetd是系统超级守护进程

    意思是: 服务都需要经过xinetd中转,xinet本身是独立的. 

    他管理着一些后台, 后台要使用,要经过他的调用

    好处是, 只占用一个服务. 缺点是: 响应速度慢. 

    基于xinet的服务越来越少, 要查看基于xinnet的服务, 需要先在yum源 安装 xinet , 然后用 chkconfig --list 就能看到了. 

    service 搜索的目录是/etc/rc.d/init.d

    源码包是安装在作者指定的目录的, 不是在/etc/ 目录里.

    所以 , 类似于这样的服务命令, 都不支持源码包


    2)源码包安装的服务


    (一)系统默认安装的服务

    1 确定服务分类

    chkconfig  --list 查看RPM包安装服务的自启动状态

    chkconfig ( check config ) 检查,设置系统的各种服务


    运行级别:0-6

    0 关机

    1 单用户模式

    就类似于windows中的安全模式. 启动最基本的服务, 用于安全修复. 

    2 不完全多用户,不包含NFS服务

    3 完全多用户 字符界面

    4 未分配

    5 图形界面

    6 重启


    init 0 关机

    init 5  转到图形界面

    init 3 转到文本界面

    init 6 重启


    runlevel 查询系统当前运行级别

    输出: N 3    N的意思是: NULL, 空, 

    是在进入命令行界面之前, 上一个级别是什么. 

    这里开机直接进入了命令界面,所以是空

    可以用 init 5 来转换到图形界面, 前提是必须安装了图形界面. 

    vi  /etc/inittab

    /sbin/init 是所有进程的父进程.  

    vi /etc/inittab   这个就是init的配置文件. 

    id:3:initdefault:   这个就是进入配置文件最底部的内容, 

    3代表开机默认进入的是命令行界面. 

    改这个就能修改开机默认的界面.

    id:3:initdefault: 定义系统默认运行级别


    2 独立的服务器管理


    1)启动 启动的意思就是可以马上停止, 启动

    方法一

    /etc/rc.d/init.d/服务名   start|stop|restart|status

    是通用的方法, 就用这个. 


    方法二

    service   服务名   start|stop|restart|status

    只能管理rpm包的服务

    service 是RedHat的独有命令.


    2)自启动 自启动的意思就是, 需要下次开机才能启动

    方法一

    chkconfig  --level  2345  服务名  on|off

    只能管理rpm包的服务. 


    方法二 推荐

    vi  /etc/rc.local---->/etc/rc.d/rc.local  

    这个2个命令写哪个都可以. 

    在这个文件里写入的任何命令 , linux 在启动的时候都会读取一遍. 

    前面的是后面的软连接

    /etc/rc.d/init.d/httpd  start

    在这个文件里加入这条命令, 

    那么, linux 下次在开机的时候就会自动启动apache了

    如果自启动的两个方法都使用了, 那么服务就会启动两次,

    第二次启动的时候就会报错了, 所以, 要二选一. 

    下次开机, 自启动生效后, 查看的方法有2个, 

    一个是: 查看进程, 一个是:查看端口. 


    3 ntsysv

    所有系统默认安装服务都可以使用ntsysv命令进行自启动管理

    所有用rpm安装的服务, 都在这个图形界面找到. 

     这个是控制开机自启动的. 是redhat专有. 

    service, chkconfig , ntsysv  都只能管理rpm包安装的服务. 

    而不能管理源码包安装的服务. 

    Service, setup , ntsysv 是 redhat 专有的命令. 


    (二)源码包安装的服务

    1源码包安装的服务


    1)绝对路径启动

    /usr/local/apache2/bin/apachectl  start

    每一个源码包的启动方式是不一样的. 因为路径不同. 


    2)自启动

    vi /etc/rc.local

    /usr/local/apache2/bin/apachectl  start


    服务管理:

    RPM包安装的服务

    独立的服务

    启动:

    1)/etc/rc.d/init.d/服务名  start

    2) service  服务名   start

    自启动:

    1) chkconfig  --level  2345  服务名  on|off

    2)vi  /etc/rc.local

    /etc/rc.d/init.d/httpd  start


    基于xinetd的服务


    源码包安装的服务

    启动:

    /usr/local/apache2/bin/apachectl  start

    自启动:

    vi  /etc/rc.local

    /usr/local/apache2/bin/apachectl  start


    date -s 20150521 就是改系统的日期. 

    date -s 04:20:13 就是改系统的时间. 



    计划任务


    echo  11  >>  /root/aa 在aa文件中追加11.一会定时任务验证用

    前提: crond 这个服务运行, 才能用计划任务, 默认是开启的. 


    循环定时任务

    crontab  -e

    编辑定时任务 用这个命令做定时任务, e 是 edit , 进去是空的. 

    写入 0 5 * * * /root/bak_etc.sh   就会定时的执行这个脚本. 

    * * * * *  命令



    10  *  31  *  *  命令

    10  *  *  *  *  命令

    5  4  *  5-10  *  命令 意思是: 5到10月  

    */10  *  *  *  *  命令 意思是: 每隔10分钟

    5 4  1,15  *  *  命令 每个月的第一天和第15天

    日期和星期不要同时指定,会超出预期

    5 4 10 * 5 命令

    */20 4 * 5 2 命令


    第一个*:一小时中第几分钟 0-59

    第二个:一天中第几个小时 0-23

    第三个:一个月中第几天 1-31

    第四个:一年第几个月 1-12

    第五个:一周中星期几 0-6 0 和 7 都代表星期日


    注意: 没有年和秒



    crontab  -l 查看系统定时任务

    crontab  -r  删除定时任务

    直接删掉, 输入这个命令就删掉 了计划任务. 


    注意事项:

    选项都不能为空,必须填入,不知道的值使用通配符*表示任何时间 

    每个时间字段都可以指定多个值,不连续的值用,间隔连续的值用-间隔

    间隔固定时间执行书写为*/n格式 

    命令应该给出绝对路径 

    星期几何第几天不能同时出现

    最小时间范围是分钟,最大时间范围是


    系统运行级别

    1 dmesg 查看系统启动信息

    查看linux开机的自检信息. 信息很多. display message


    cat  /var/log/dmesg 系统启动信息日志

    dmesg | grep eth0 查看eth0信息

    查看网卡的型号. 用这样的命令判断linux开机自检出来的硬件信息. 

    dmesg | grep CPU 查看cpu信息

    查看cpu的硬件情况


    2 系统运行级别 

    0 关机

    1 单用户

    2 不完全多用户,不含NFS

    3 完全多用户

    4 保留

    5 图形界面

    6 重启


    runlevel  查询系统运行级别


    init  运行级别 改变运行级别 init 0     init  6



    修改系统默认运行级别

    vi  /etc/inittab init配置文件

    id:3:initdefault: 系统默认运行级别



    作业:

    笔记整理

    课堂练习

    课后练习题

    预习:网络配置和文件服务器



    复习:

    判断题:

    1、useradd  -G test group 会添加用户test,并把用户加入到group组中

    2、gpasswd  -G  test  group 会把已经存在的用户test添加入用户组group中

    3、setfacl  -m d:u:aa:rwx -R /test 会给/test目录和目录下所有文件设定用户aa拥有rwx权限

    4、ls  >>  aa  2>&1 会把ls命令的正确与错误输出都追加到文件aa中

    5、/etc/rc.d/init.d/httpd  start 会启动RPM安装的apache并把apache设定为自启动

    6、*/10 5 10 * * 命令 命令会在每年10月的早上5点,每10分钟执行一次

    7、3运行级别是字符界面、可以修改vi  /etc/inittab配置文件,改id:3:initdefault:这句话,变为开机直接进入字符界面




    网络基础知识:


    IP地址: Ipv4 2*32

    255.255.255.255

    是有32为的二进制组成的. 每八位分开,

    就这样的格式 1111111.1111111.1111111.1111111.


    10.0.0.0 - 10.255.255.255 这个是私有网络, 就是内网. 

    172.16.0.0 - 172.31.255.255

    192.168.0.0 - 192.168.255.255


    端口: tcp  有216个端口, 是6W多个端口 就是三次握手

    Udp 有216个端口, 是6W多个端口 就是不握手, 直接把数据包扔给你.

    0到10000以内的端口. 是服务器的常规端口. 一般系统服务会占用. 

    10000以上的端口, 是给用户用的. 


    常见网络端口:

    20  21 ftp服务 文件共享

    22 ssh服务 安全远程网络管理

    传送的数据是加密的. 

    23 telnet服务

    也是远程管理. 用telnet传送的数据, 都是明文.

    服务器不允许开启这个服务. 但客户端是常规命令.

    25 smtp:简单邮件传输协议 发信

    110 pop3:邮局协议 收信

    80 www 网页服务

    3306 mysql端口

    53 DNS端口

    /etc/services

    Linux系统下的所有常见端口文件. 可以用vi /etc/services 查看. 


    端口数量 tcp  65535 udp  65535


    telnet  ip  端口 测试端口是否可以正常连接

    ctrl+]  -----------  quit 退出方式


    netstat  -tlun  查看本机所有监听端口

    -t  tcp  -u udp   -l  监听  -n  以IP和端口号显示


    网关的功能: 1). 接收局域网内不能处理的数据包. 

    2). 实现NAT功能, 从内网到外网的转换. 

    发送的数据包不能处理, 都交给网关. 

    经过网关的转换, 就可以发送给公网了,

    网关就是实现内网和外网链接的一个桥梁



    DNS: Domain  Name  System

    负责IP和域名之间的转换, 没有设置DNS, 不影响局域网之间的通讯, 

    但是没有DNS, 会不能访问互联网的网页. 

    例如 QQ 可以聊天, 但是不能打开网页, 一般就是DNS没设置好


    域名 --> IP 正向解析

    IP ——》 域名 反向解析


    北京网通: 202.106.0.20

    这个DNS比较稳定. 还有8.8.8.8      114.114.114.114




    网络配置 


    IP地址配置的方法:


    1 setup redhat的专有功能

    service network  restart   

    设置好setup之后要重启网络服务.


    2 ifconfig  eth0  ip  netmask  掩码

    临时生效, 重启之后就回复原来的IP设置. 


    3 网卡配置文件

    是最标准的配置IP方法. 分为3个步骤. 


    1)/etc/sysconfig/network-scripts/ifcfg-eth0 网卡信息文件

    用vi进入,内容如下:


    左侧的都是大写. 右侧的都是小写

    DEVICE=eth0 网卡设备名

    如果有2块网卡, 那么就是eth1. 

    但是, 网卡信息文件名和网卡设备名必须一致. 就是:黄色背景的,必须一致. 

    BOOTPROTO=none 是否自动获取IP     none:不生效 static:手动 dhcp:动态获取IP, 自动获取IP. 

    要想自动获取IP, 就要在局域网内拥有dhcp服务器. 就会有人给分配IP, 

    就不许要设置这么多的内容. 只需要设置浅蓝色的4个设置

    BROADCAST=192.168.140.255 广播地址

    HWADDR=00:0c:29:21:80:48 mac地址

    IPADDR=192.168.140.253 IP地址

    IPV6INIT=yes IPv6开启

    IPV6_AUTOCONF=yes IPv6获取

    NETMASK=255.255.255.0 掩码

    NETWORK=192.168.140.0 网段

    ONBOOT=yes 网卡开机启动

    TYPE=Ethernet 以太网  

    运行在双胶网线(普通的网线,8跟线的)上的网络, 都是以太网. 

    GATEWAY=192.168.140.1 网关


    2)/etc/sysconfig/network 主机名配置文件, 设置后永久生效,但是要重启 用vi进入, 内容如下:

    HOSTNAME=localhost.localdomain 主机名

    如果是在WINDOWS系统下, 同意局域网内, 主机名一样是不能访问的. Linux的可以. 

    修改后需要重启才能生效, 不想重启, 可以用 hostname=主机名 

    这个命令. 是临时生效. 同时设置就达到效果

    重新登陆一次. 远程终端工具(X-shell)就起效果了. 

    hostname  主机名 临时设定主机名

    hostname 查看主机名


    3)/etc/resolv.conf DNS配置文件 用vi进入. 内容如下:

    nameserver  202.106.0.20


    网络命令


    1 ifconfig 查看网卡信息

    看不到网关. 能看到IP地址, 子网掩码. MAX地址. 


    2 ifup  eth0 ifdown  eth0 快速开启和关闭网卡 

    就相当于windows中的禁用和开启网络邻居里的网卡, 临时的. 


    3 netstat  -an 查看所有网络连接

    netstat  -tlun 查看tcp和udp协议监听端口

    netstat  -rn 查看路由 default:默认路由(网关) 查看网关.  


    4 route 查看路由

    route -n 查看网关

    route  add   default  gw  192.168.140.1 手工设定网关,临时生效

    route del default gw 192.168.190.6 删除网关


    5 ping  ip 探测网络通畅



    7 traceroute  ip或域名 探测到底目的地址的路径(linux命令)

    就是路由追踪命令

    在命令行输入: traceroute www.xdlit.cn  

    如果不通, 就会显示经过了哪些节点. 到哪个节点不通. 


    tracert  ip windows下命令


    89开启


    tcpdump -i eth0 -nnX port 21


    VSFTP服务

    在linux系统, 叫vsftp, 是明文传递的. 网络协议是https的是加密的. 

    tcpdump -i eth0 -nnX port 21 监听端口21 抓包 -nn 拆开包  X 十六进制

    文件服务器简介


    ftp:在内网和公网使用。 服务器:windows,linux 客户端:windows,linux


    1 ftp软件


    linux: wu-ftp 早期,不太安全  淘汰了

    proftp 增强ftp工具

    vsftp 安全,强大  是redhat绑定的


    windows IIS windows下网页搭建服务,可以搭建ftp服务

    Serv-U 专用ftp服务器


    2 原理

    ftp主要使用下面这2个端口

    开启 21  命令传输端口 是监听端口

    20 数据传输端口 只有数据传递的时候才需要


    3 ftp的用户

    1)ftp允许登录用户 就是系统用户 使用密码也是系统密码

    上传位置:/home/家目录


    2)匿名用户 anonymous 密码:  空   或者  邮箱地址   11@aa   

    匿名用户需要输入用户名,  用户名是: anonymous   密码是空

    上传位置:/var/ftp/



    安装


    rpm  -ivh  vsftpd...........

    是需要服务器的. 一般是给内部人员使用的. 

    一般外人不是免费使用的. 一般访问量不大, 用rpm也能接受

    yum  install  vsftpd  -y


    相关文件


    /etc/vsftpd/vsftpd.conf 配置文件


    /etc/vsftpd/ftpusers

    用户访问控制文件 写入此文件的用户都不能访问ftp服务器

    就是黑名单. root也是黑名单. 是正确的. 


    /etc/vsftpd/chroot_list 需要手工建立 定义是否把用户限制在家目录


    配置文件配置


    /etc/vsftpd/vsftpd.conf 用 vi 打开 


    1 主机相关配置

    listen_port=21 监听端口

    这句话在配置文件里找不到.

    默认设置就是这个, 找不到就是默认设置. 需要改就添加进去. 

    connect_from_port_20=YES 数据传输端口

    ftpd_banner= 欢迎信息

    每次进入的信息. 默认是没开启. 是注释掉的. 



    2 匿名用户登录 在linux下识别为  ftp  用户


    anonymous_enable=YES 允许匿名用户登录

    不需要, 因为是给内部人用的. 一般都关掉


    3 本地用户

    local_enable=YES 允许系统用户登录

    write_enable=YES 允许上传

    local_umask=022 默认上传权限

    local_max_rate=300 上传限速 单位是 字节/秒


    4 限制用户访问目录

    chroot_local_user=YES 只有此句,所有用户限制在家目录下. 

    如果不写这几句, 任何的普通用户, 通过ftp都可以访问任何目录. 


    如有三句话,只有文件chroot_list中的用户可以访问任何目录,其他用户限制在家目录

    chroot_local_user=YES

    chroot_list_enable=YES

    chroot_list_file=/etc/vsftpd/chroot_list


    在windows cmd 下, ftp IP , 会login failed , 连接失败. 报错. 

    这个不是ftp的原因. 

    在linux中有这样一个命令: selinux    

    用vi 打开它的配置文件.  vi /etc/selinux/config  , 进去让它失效. 把 SELINUX=enforcing  改成   SELINUX=disabled  就失效了, 其中, enforcing 的意思是强制生效. 

    因为它是由内核编译的. 所以改完之后必须重启Linux. 

    selinux就是Linux的安全防护. 是美国国家安全局开发的. 是为了限制root的权限

    这样, 就不会报错了. 


    ftp客户端使用


    使用命令登录

    ftp  ip windows cmd下, 输入完之后, 需要输入用户名和密码. 


    get  文件名 下载 下载的文件放在了当前目录下. 不能断点续传. 

    put  文件名 上传 不能上传和下载目录


    使用windows窗口

    ftp://用户名@IP 不支持断点续传. 是图形界面. 



    使用第三方工具登录

    flashFXP. winSCP 



    ssh安全登录 22端口


    联机加密工具

    非对称钥匙对加密


    安装 默认安装 openssh  默认都装了.如果没装, 就装这个包


    启动 默认开机自启动 service  sshd  restart


    配置文件 /etc/ssh/sshd_config



    ssh远程安全联机 掌握


    ssh   用户名@ip

    linux 和 linux 互联, 第一次需要输入YES, 目的是传送公匙, 然后输入用户 名和密码就可以登录了. 


    scp 网络复制,网络文件传输 掌握


    1 下载


    scp   用户名@ip:路径   本地路径


    scp  root@192.168.140.93:/root/abc  /root


    scp  -r  root@192.168.140.93:/root/11  /root 下载目录


    2 上传

    scp  本地文件或目录  用户名@ip:路径


    scp  -r  /root/11  root@192.168.140.93:/root 上传目录


    总结: 

    传输数据的工具: 

    Windows 和 windows : 用什么都可以, 如QQ, 网盘

    Windows 和 linux   : winSCP

    Linux   和 Linux   : SCP



    课后作业:

    笔记整理

    课堂练习

    网络设置练习题

    预习 lamp环境搭建





    第六天 搭建LAMP环境



    一、准备工作


    1、安装编译工具gcc、gcc-c++

    注意解决依赖关系,推荐使用yum安装,若不能联网可使用安装光盘做为yum源——

    1)编辑yum配置文件:

    # mount /dev/cdrom /mnt/cdrom

    # vi /etc/yum.repos.d/CentOS-Media.repo 

    [c5-media] 

    name=CentOS-$releasever - Media

    baseurl=file:///mnt/cdrom   * 修改为光盘挂载点

           file:///media/cdrom/

           file:///media/cdrecorder/

    gpgcheck=1

    enabled=1  * 改为1意为启用

    gpgkey=file:///etc/pki/rpm-gpg/RPM-GPG-KEY-CentOS-5

    2)剪切/etc/yum.repos.d/CentOS-Base.repo

    # mv /etc/yum.repos.d/CentOS-Base.repo //etc/yum.repos.d/CentOS-Base.repo.bak

    3)依次安装gcc、gcc-c++

    # yum -y install gcc

    # yum -y install gcc-c++


    2、关闭系统RPM安装包的Apache、MySQL的服务

    关闭启动的服务httpd、mysqld

    # service httpd stop

    # service mysqld stop


    确定rpm包安装的httpd和mysqld不能开机自启动

    chkconfig  --level  2345  httpd(mysqld)  off


    3、关闭SELinux,允许防火墙80端口访问

    使用setup

    关闭防火墙和SElinux


    1)关闭SELinux

    # vi /etc/selinux/config

    SELINUX=disabled   * 若安装时没有禁用SELinux ,将enforcing改为disabled

    修改后需重新启动Linux方可生效!

    2)关闭防火墙Netfilter/iptables

    因尚未做防火墙讲解,直接简单的关闭所有防火墙设置:

    # iptables  -F     * 如果没有禁用防火墙,默认80端口禁止访问

    iptables -Z

    iptables  -X

    Iptables -L 查看防火墙 


    4、关闭不必要自启动服务

    # ntsysv

    以下列出服务可保持自启动,未列出的服务都可以关闭:

    atd    

    crond        # atd、crond计划任务

    irqbalance

    microcode_ctl   # 系统irq端口调用,系统服务

    network    #网络设置

    sendmail   #邮件

    sshd      #远程管理

    syslog    #系统日志


    5、拷贝源码包,解包解压缩

     建议将LAMP环境安装源码包统一存放在一个目录下,如/lamp

     可编写个批量处理脚本,一次性把所有.tar.gz的安装包解包解压缩

     # vi tar.sh

    #!/bin/bash

      cd /lamp

    ls *.tar.gz > ls.list

    ls *.tgz >> ls.list

      for i in `cat ls.list`

     do

    /bin/tar -zxvf $i

     done

    rm -rf ls.log


    6、查看确认磁盘空间未满

    df -h

      * 若/分区已满,可以移动安装包到其他分区或删除其他无用文件



    如何确定报错:

    1)安装过程停止

    2)停止后,一页界面中出现error或者warning


    如何确定安装成功:

    进入安装目录,确认安装程序出现,就是成功


    二、编译安装


     * 每个源码包配置编译安装完成后,确认安装目录下是否生成安装文件

    make  clean

     # 安装libxml2

    Libxml2 是一个xml c语言版的解析器,本来是为Gnome项目开发的工具,是一个基于MIT License的免费开源软件。它除了支持c语言版以外,还支持c++、PHP、Pascal、Ruby、Tcl等语言的绑定,能在Windows、Linux、Solaris、MacOsX等平台上运行。功能还是相当强大的,相信满足一般用户需求没有任何问题。

    libxml是一个用来解析XML文档的函数库。它用C语言写成, 并且能为多种语言所调用,例如C语言C++XSHC#PythonKylix/DelphiRuby,和PHP等。Perl中也可以使用XML::LibXML模块。它最初是为GNOME开发的项目,但现在可以用在各种各样的方面。libXML 代码可移植性非常好,因为它基于标准的ANSI C库, 并采用MIT许可证。


    #yum  install  -y  libxml2-devel 如果报错,安装此包后再尝试安装


    yum -y install python-devel 必须有


     cd /lamp/libxml2-2.9.1

     ./configure --prefix=/usr/local/libxml2/

     make 

     make install


     # 安装libmcrypt

    libmcrypt是加密算法扩展库。支持DES, 3DES, RIJNDAEL, Twofish, IDEA, GOST, CAST-256, ARCFOUR, SERPENT, SAFER+等算法。

     cd /lamp/libmcrypt-2.5.8

     ./configure --prefix=/usr/local/libmcrypt/

     make 

     make install

     * 需调用gcc-c++编译器,未安装会报错


    # 安装libltdl,也在libmcrypt源码目录中,非新软件

     cd /lamp/libmcrypt-2.5.8/libltdl

     ./configure --enable-ltdl-install

     make

     make install



    # 安装mhash

    Mhash是基于离散数学原理的不可逆向的php加密方式扩展库,其在默认情况下不开启。mhash的可以用于创建校验数值,消息摘要,消息认证码,以及无需原文的关键信息保存(如密码)等。

    cd /lamp/mhash-0.9.9.9

    ./configure 

    make

    make install




    # 安装mcrypt

    mcrypt 是 php 里面重要的加密支持扩展库。Mcrypt库支持20多种加密算法和8种加密模式

    cd /lamp/mcrypt-2.6.8

    LD_LIBRARY_PATH=/usr/local/libmcrypt/lib:/usr/local/lib  ./configure --with-libmcrypt-prefix=/usr/local/libmcrypt

    #以上为一条命令。LD_LIBRARY_PATH用于指定libmcrypt和mhash的库的位置。

    --with-libmcrypt-prefix用于指定libmcrypt软件位置

    make

    make install

    #mcrypt没有安装完成,这是php的模块,需要等php安装完成之后,再继续安装


     # 安装zlib

    zlib是提供数据压缩用的函式库,由Jean-loup Gailly与Mark Adler所开发,初版0.9版在1995年5月1日发表。zlib使用DEFLATE算法,最初是为libpng函式库所写的,后来普遍为许多软件所使用。此函式库为自由软件,使用zlib授权

     cd /lamp/zlib-1.2.3

    ./configure

     make

     make install  >>  /root/zlib.log

     * zlib指定安装目录可能造成libpng安装失败,故不指定,为卸载方便,建议make install执行结果输出到安装日志文件,便于日后卸载


    # 安装libpng

    libpng 软件包包含 libpng 库.这些库被其他程式用于解码png图片

     cd /lamp/libpng-1.2.31

     ./configure --prefix=/usr/local/libpng

     make

     make install


     # 安装jpeg6

    用于解码.jpg和.jpeg图片

    mkdir /usr/local/jpeg6

     mkdir /usr/local/jpeg6/bin

     mkdir /usr/local/jpeg6/lib

     mkdir /usr/local/jpeg6/include

     mkdir -p /usr/local/jpeg6/man/man1

    #目录必须手工建立

     cd /lamp/jpeg-6b

     ./configure --prefix=/usr/local/jpeg6/ --enable-shared --enable-static

     make

     make install

     * --enable-shared与--enable-static参数分别为建立共享库和静态库使用的libtool


     # 安装freetype

    FreeType库是一个完全免费(开源)的、高质量的且可移植的字体引擎,它提供统一的接口来访问多种字体格式文件,包括TrueType, OpenType, Type1, CID, CFF, Windows FON/FNT, X11 PCF等。支持单色位图反走样位图的渲染。FreeType库是高度模块化的程序库,虽然它是使用ANSI C开发,但是采用面向对象的思想,因此,FreeType的用户可以灵活地对它进行裁剪。

     cd /lamp/freetype-2.3.5

    ./configure --prefix=/usr/local/freetype/

     make

     make install



    # 安装GD库

    GD库,是php处理图形的扩展库,GD库提供了一系列用来处理图片的API,使用GD库可以处理图片,或者生成图片。 在网站上GD库通常用来生成缩略图,或者用来对图片加水印,或者用来生成汉字验证码,或者对网站数据生成报表等。

    mkdir /usr/local/gd2

     cd /lamp/gd-2.0.35

    * png错误,修改方法:

    vi gd_png.c

    把 #include “png.h” 替换为 #include "/usr/local/libpng/include/png.h"

     ./configure --prefix=/usr/local/gd2/ --with-jpeg=/usr/local/jpeg6/ --with-freetype=/usr/local/freetype/ --with-png=/usr/local/libpng/

     make 

     make install

     * 若前面配置zlib时没有指定安装目录,gd配置时不要添加--with-zlib=/usr/local/zlib/参数


    # 安装Apache

    configure: error: Bundled APR requested but not found at ./srclib/. Download and unpack the corresponding apr and apr-util packages to ./srclib/.

    #如果报错,则:

    tar  zxvf  apr-1.4.6.tar.gz

    tar  zxvf  apr-util-1.4.1.tar.gz

    cp  -r  /test/apr-1.4.6  /test/httpd-2.4.7/srclib/apr

    cp  -r  /test/apr-util-1.4.1  /test/httpd-2.4.7/srclib/apr-util

    #解压apr和apr-util,复制并取消版本号


    configure: error: pcre-config for libpcre not found. PCRE is required and available from

    #如果报错,则:

    tar zxvf pcre-8.34.tar.gz

    cd pcre-8.34  

    ./configure && make && make install


    checking whether to enable mod_ssl... configure: error: mod_ssl has been requested but can not be built due to prerequisite failures

    #如果报错,则:

    yum install openssl-devel


    安装apache

     cd /test/httpd-2.4.7

     ./configure --prefix=/usr/local/apache2/ --sysconfdir=/usr/local/apache2/etc/ --with-included-apr --enable-so --enable-deflate=shared --enable-expires=shared --enable-rewrite=shared

     make

     make install

      * 若前面配置zlib时没有指定安装目录,Apache配置时不要添加--with-z=/usr/local/zlib/参数


     启动Apache测试:

    /usr/local/apache2/bin/apachectl start

    ps –aux | grep httpd

    netstat –tlun | grep :80

    * 若启动时提示/usr/local/apache2/modules/mod_deflate.so无权限,可关闭SELinux或者执行命令chcon -t texrel_shlib_t /usr/local/apache2/modules/mod_deflate.so ,类似此类.so文件不能载入或没有权限的问题,都是SELinux问题,使用命令:“chcon -t texrel_shlib_t 文件名”即可解决,MySQL和Apache也可能有类似问题。

    通过浏览器输入地址访问:http://Apache服务器地址,若显示“It works”即表明Apache正常工作


    设置Apache系统引导时启动:

    echo "/usr/local/apache2/bin/apachectl start" >> /etc/rc.d/rc.local


    # 安装ncurses

    Ncurses 提供字符终端处理库,包括面板和菜单。它提供了一套控制光标,建立窗口,改变前景背景颜色以及处理鼠标操作的函数。使用户在字符终端下编写应用程序时绕过了那些恼人的底层机制。简而言之,他是一个可以使应用程序直接控制终端屏幕显示的函数库。

    1、方法一:

    yum -y install ncurses-devel

    注:如果报错,包找不到,是*通配符没有识别,给文件名加双引号  “ncurses*”

    2、方法二:

    源代码编译:

    cd /lamp/ncurses-5.9

    ./configure --with-shared --without-debug --without-ada --enable-overwrite

    make 

    make install

    * 若不安装ncurses编译MySQL时会报错

    * --without-ada参数为设定不编译为ada绑定,因进入chroot环境不能使用ada ;--enable-overwrite参数为定义把头文件安装到/tools/include下而不是/tools/include/ncurses目录

    * --with-shared 生成共享库


    # 安装cmake和bison

    mysql在5.5以后,不再使用./configure工具,进行编译安装。而使用cmake工具替代了./configure工具。cmake的具体用法参考文档cmake说明。

    bison是一个自由软件,用于自动生成语法分析器程序,可用于所有常见的操作系统

    yum -y install cmake

    yum -y install bison


     # 安装MySQL

     groupadd mysql

     useradd -g mysql mysql

    * 添加用户组mysql ,将mysql用户默认组设置为mysql用户组


    cd /test/mysql-5.5.23

    cmake  -DCMAKE_INSTALL_PREFIX=/usr/local/mysql    -DMYSQL_UNIX_ADDR=/tmp/mysql.sock  -DEXTRA_CHARSETS=all   -DDEFAULT_CHARSET=utf8    -DDEFAULT_COLLATION=utf8_general_ci    -DWITH_MYISAM_STORAGE_ENGINE=1   -DWITH_INNOBASE_STORAGE_ENGINE=1    -DWITH_MEMORY_STORAGE_ENGINE=1  -DWITH_READLINE=1    -DENABLED_LOCAL_INFILE=1   -DMYSQL_USER=mysql  -DMYSQL_TCP_PORT=3306


    -DCMAKE_INSTALL_PREFIX=/usr/local/mysql 安装位置

    -DMYSQL_UNIX_ADDR=/tmp/mysql.sock 指定socket(套接字)文件位置

    -DEXTRA_CHARSETS=all 扩展字符支持

    -DDEFAULT_CHARSET=utf8    默认字符集

    -DDEFAULT_COLLATION=utf8_general_ci    默认字符校对

    -DWITH_MYISAM_STORAGE_ENGINE=1   安装myisam存储引擎

    -DWITH_INNOBASE_STORAGE_ENGINE=1    安装innodb存储引擎

    -DWITH_MEMORY_STORAGE_ENGINE=1  安装memory存储引擎

    -DWITH_READLINE=1    支持readline库

    -DENABLED_LOCAL_INFILE=1   启用加载本地数据

    -DMYSQL_USER=mysql  指定mysql运行用户

    -DMYSQL_TCP_PORT=3306 指定mysql端口



     make

     make install


    make clean 

    rm CMakeCache.txt

    #如果报错,清除缓存,请使用以上命令


    cd /usr/local/mysql/

    chown -R mysql .

    chgrp -R mysql .

    #修改mysql目录权限

    /usr/local/mysql/scripts/mysql_install_db --user=mysql

    #创建数据库授权表,初始化数据库

    chown -R root .

    chown -R mysql data

    #修改mysql目录权限


    cp support-files/my-medium.cnf /etc/my.cnf

    #复制mysql配置文件


    启动MySQL服务:

    1.用原本源代码的方式去使用和启动mysql

    /usr/local/mysql/bin/mysqld_safe --user=mysql &

    2.重启以后还要生效:

    vi /etc/rc.local

    /usr/local/mysql/bin/mysqld_safe --user=mysql &

    3.设定mysql密码

    /usr/local/mysql/bin/mysqladmin -u root password 123

    清空历史命令 history  -c

    * 给mysql用户root加密码123

    * 注意密码不能写成 “123”

     /usr/local/mysql/bin/mysql -u root -p 

    mysql>show databases;

    mysql>use test;

    mysql>show tables;

    mysql>\s #查看字 符集是否改为utf8

    * 进入mysql以后用set来改密码

     mysql> exit

     * 登录MySQL客户端控制台设置指定root密码

     

     # 安装PHP

    编译前确保系统已经安装了libtool和libtool-ltdl软件包,安装:

    yum -y install “libtool*”

    yum -y install “libtool-ltdl*”


    vi /usr/local/gd2/include/gd_io.h

    typedef struct gdIOCtx

    {

    ……

    void (*data);

    #加入此句

    }

    #php 5.4 的bug,检测gd库有问题,需要手工修改


    cd /test/php-5.4.25

    ./configure --prefix=/usr/local/php/ --with-config-file-path=/usr/local/php/etc/ --with-apxs2=/usr/local/apache2/bin/apxs --with-mysql=/usr/local/mysql/ --with-libxml-dir=/usr/local/libxml2/ --with-jpeg-dir=/usr/local/jpeg6/ --with-png-dir=/usr/local/libpng/ --with-freetype-dir=/usr/local/freetype/ --with-gd=/usr/local/gd2/ --with-mcrypt=/usr/local/libmcrypt/ --with-mysqli=/usr/local/mysql/bin/mysql_config --enable-soap --enable-mbstring=all --enable-sockets  --with-pdo-mysql=/usr/local/mysql --without-pear

    若前面配置zlib时没有指定安装目录,PHP配置时不要添加--with-zlib-dir=/usr/local/zlib/参数

    选项:

    --with-config-file-path=/usr/local/php/etc/ 指定配置文件目录

    --with-apxs2=/usr/local/apache2/bin/apxs 指定apache动态模块位置

    --with-mysql=/usr/local/mysql/ 指定mysql位置

    --with-libxml-dir=/usr/local/libxml2/ 指定libxml位置

    --with-jpeg-dir=/usr/local/jpeg6/ 指定jpeg位置

    --with-png-dir=/usr/local/libpng/ 指定libpng位置

    --with-freetype-dir=/usr/local/freetype/ 指定freetype位置

    --with-gd=/usr/local/gd2/ 指定gd位置

    --with-mcrypt=/usr/local/libmcrypt/ 指定libmcrypt位置

    --with-mysqli=/usr/local/mysql/bin/mysql_config 指定mysqli位置

    --enable-soap 支持soap服务

    --enable-mbstring=all 支持多字节,字符串

    --enable-sockets 支持套接字

    --with-pdo-mysql=/usr/local/mysql 启用mysql的pdo模块支持

    --without-pear 不安装pear(安装pear需要连接互联网。 PEAR是PHP扩展与应用库)

    make

     make install


    生成php.ini

    cp /test/php-5.4.25/php.ini-production /usr/local/php/etc/php.ini


    测试Apache与PHP的连通性,看Apache是否能解析php文件

    vi /usr/local/apache2/etc/httpd.conf

     AddType application/x-httpd-php .php .phtml .phps 

    (注意大小写)

     * .phtml为将.phps做为PHP源文件进行语法高亮显示

     重启Apache服务:/usr/local/apache2/bin/apachectl stop

      /usr/local/apache2/bin/apachectl start


    * Apache无法启动,提示cannot restore segment prot after reloc: Permission denied错误,为SELinux问题,可关闭SELinux或者执行命令chcon -t texrel_shlib_t /usr/local/apache2/modules/libphp5.so   

    测试:vi /usr/local/apache2/htdocs/test.php    

      <?php

    phpinfo();

     ?>

    通过浏览器输入地址访问:http://Apache服务器地址/test.php 

    Rpm包安装的网页默认目录 /var/www/html/

    * 有时第一次浏览器测试会失败,关闭浏览器重启再尝试即可,非编译错误


    # 编译安装memcache

    Memcache是一个高性能的分布式的内存对象缓存系统,通过在内存里维护一个统一的巨大的hash表,它能够用来存储各种格式的数据,包括图像视频文件以及数据库检索的结果等。简单的说就是将数据调用到内存中,然后从内存中读取,从而大大提高读取速度。


    yum -y install zlib-devel

    cd memcache-3.0.8 

    /usr/local/php/bin/phpize

    ./configure --with-php-config=/usr/local/php/bin/php-config

    make && make install



    # 编译安装mcrypt

    cd /test/php-5.4.25/ext/mcrypt/

    /usr/local/php/bin/phpize

    ./configure --with-php-config=/usr/local/php/bin/php-config --with-mcrypt=/usr/local/libmcrypt/


    make

    make install

    #php安装完成后,通过这些命令安装mcrypt模块




    修改/usr/local/php/etc/php.ini

    extension_dir = "/usr/local/php/lib/php/extensions/no-debug-zts-20100525/"

    #打开注释,并修改

    extension="memcache.so";

    extension="mcrypt.so";

    #添加

    #重启apache,在phpinfo中可以找到这两个模块



    # 安装memcache源代码

    首先安装依赖包libevent

    yum -y install “libevent*”

    #在CentOS 6.3第二张光盘中,请换盘


    cd /test/memcached-1.4.17

    ./configure --prefix=/usr/local/memcache

    make && make install


    useradd memcache

    #添加memcache用户,此用户不用登录,不设置密码

    /usr/local/memcache/bin/memcached -umemcache &    

    netstat an | grep :11211

    telnet 192.168.10.1 11211

    stats

    写入自启动:

    vi /etc/rc.d/rc.local

    /usr/local/memcache/bin/memcached -umemcache &


    # 安装phpMyAdmin

    cp -r phpMyAdmin-4.1.4-all-languages /usr/local/apache2/htdocs/phpmyadmin

    cd /usr/local/apache2/htdocs/phpmyadmin

    cp config.sample.inc.php config.inc.php

    vi config.inc.php

    $cfg['Servers'][$i]['auth_type'] = 'cookie';

    $cfg['Servers'][$i]['auth_type'] = 'http';

    * 设置auth_type为http ,即设置为HTTP身份认证模式

    通过浏览器输入地址访问:http://Apache服务器地址/phpmyadmin/index.php

    用户名为root ,密码为MySQL设置时指定的root密码(lampbrother)



    安装过程中大多错误其实为输入错误,可以通过history命令查看历史记录检查。


    GRANT ALL PRIVILEGES ON *.* TO 'root'@'%' IDENTIFIED BY '123' WITH GRANT OPTION;

    sql语句,不是linux命令





    第七天  Aphache服务器


    简介


    1 www:world  wide  web 万维网


    http 协议: 超文本传输协议


    HTML语言: 超文本标识语言


    2 URL:统一资源定位 协议+域名:端口+网页文件名

    http://www.sina.com.cn:80/11/index.html

    www.sina.com.cn


    3 搭建www的服务器的方法

    windows  IIS + asp + SQLserver

    Internet  Information  server

    Linux apache + mysql + php 同步   并发量开到2048为合适. 

    再大就需要观察调试,. 

    nginx + mysql + php 异步 并发量可以开到5W. 

    并发连接数量:可以简单的看成是同时访问网站的数量.


    安装

    1、lamp源码安装 Lamp因为是给客户端用的服务器环境. 所以一定要用源码包. 

    2、rpm包安装 现实中根本不用rpm包. 

    httpd

    mysql

    mysql-server

    php

    php-devel

    php-mysql


    相关文件


    apache配置文件

    源码包安装: /usr/lcoal/apache2/etc/httpd.conf 主配置文件. 

      /usr/local/apache/etc/extra/*.conf 扩展配置文件. 

    源码包有主配置文件和扩展配置文件. 

      

    rpm包安装: /etc/httpd/conf/httpd.conf


    默认网页保存位置:

    源码包: /usr/local/apache2/htdocs/

    rpm包安装: /var/www/html/


    日志保存位置

    源码包: /usr/local/apache2/logs/

    rpm包: /var/log/httpd/


    配置文件

    输入 vi /usr/lcoal/apache2/etc/httpd.conf 进入主配置文件. 

    很多注释. (行首带#). 下面这些绿色的文字是不带注释的. 都是起作用的语句. 

    注意:apache配置文件严格区分大小写


    1 针对主机环境的基本配置


    ServerRoot apache主目录

    ServerRoot "/usr/local/apache2/"

    服务器的主目录. 其他扩展配置文件的路径都 是相对于这个路径的. 

    不要改这个路径, 因为改的话, 还需要改很多的路径. 


    Listen 监听端口

    Listen 80

    默认开的就是这个80端口. 

    最好不要改这个端口, 如果改了, 输入网站的时候, 在IP后面还要加 上:端口号. 做网站的目的就失去了意义.


    LoadModule 加载的相关模块

    LoadModule authn_file_module modules/mod_authn_file.so

    php安装完之后, 就相当于模块. 


    User 伪用户

    Group 用户和组

    User daemon

    Group daemon

    如果对目录的权限不足, 就需要给目录加写目录, 不能用chmod 777, 

    要用这个, 把拥有者换成 daemon . 例如有个目录 cc. 要给这个cc目 录写权限. 用这个命令. chmown daemon cc

    所有通过浏览器可以访问的目录, 都要设置daemon权限. 


    ServerAdmin 管理员邮箱

    ServerAdmin  you@example.com

    Apache出现任何问题. 都会发到这个邮箱里, 问题是, 都是英文. 


    ServerName 服务器名(没有域名解析时,使用临时解析。不开启)


    ErrorLog "logs/error_log 错误日志

    ErrorLog "logs/error_log"


    LogLevel warn 日志等级

    日志等级分为:

    debug, info, notice, warn, error, crit,alert, emerg.

    Debug最低, emerg 最高. 等级越低越详细. 默认是 warn. 


    CustomLog "logs/access_log" common 正确访问日志


    DirectoryIndex index.html index.php 默认网页文件名,优先级顺序

    <IfModule dir_module>    

     DirectoryIndex index.html

    </IfModule>

    默认的网页文件. 如果有多个, 如:还有一个 index.php 也想加进去. 可以放到后面, 用空格分开. 但是是有优先级的. 前面的优先级高


    Include  etc/extra/httpd-vhosts.conf 子配置文件中内容也会加载生效


    2 主页目录及权限


    DocumentRoot "/usr/local/apache2//htdocs"

    主页目录

    放网页文件的目录. 可以改, 但是要和下面的一起改. 

    <Directory "/usr/local/apache2//htdocs">

    #Directory关键字定义目录权限


    Options Indexes FollowSymLinks

    #options 

    None:没有任何额外权限

    All:所有权限

    Indexes:浏览权限(当此目录下没有默认网页文件时,显示目录内容)

    FollowSymLinks:准许软连接到其他目录

    AllowOverride None

    #定义是否允许目录下.htaccess文件中的权限生效

    是隐藏文件, 要放在主页目录中, 即DocumentRoot目录中.

    None:.htaccess中权限不生效

    All:文件中所有权限都生效

    AuthConfig:文件中,只有网页认证的权限生效。


    Require all granted 访问控制列表

    可以理解为简单的防火墙. 防火墙的功能是数据包过滤. 

    例子4 和 例子5 是拒绝和允许所有IP, 不需要封装, 

    但是, 如果拒绝或者允许某个IP, 需要封装. (标签对).

    现实中, 一般不用它. 是用防火墙. 

    这个可以封IP, 在没有防火墙的情况下, 可以用这个. 


        </Directory>


    #定义此目录的允许访问权限

    例1: 仅允许IP为192.168.1.1的主机访问

    <RequireAll> 

          Require all  granted 

          Require ip 192.168.1.1 

    </RequireAll> 


    例子2.仅允许192.168.0.0/24网络的主机访问

    <RequireAll>  

          Require all  granted  

          Require ip 192.168.1.0/24 

    代表一个网段. 24的意思是:11111111,11111111,11111111,00000000

    也就是255.255.255.0     

    192.168.1.0/24的意思就是: 192.168.1.0 到 255.255.255.0之前的IP. 

    </RequireAll>  


    例子3.禁止192.168.1.2的主机访问,其他的都允许访问,

    <RequireAll> 

          Require all  granted 

          Require not ip 192.168.1.2 

    </RequireAll> 


    例子4.允许所有访问,

    Require all  granted

    #可以不写在<RequireAll>。。。</RequireAll>中


    例子5.拒绝所有访问,

    Require all  denied

    #可以不写在<RequireAll>。。。</RequireAll>中



    3 目录别名


    子配置文件名 etc/extra/httpd-autoindex.conf

    需要在主配置文件中找到 #Include etc//extra/httpd-autoindex.conf

    把前面的#去掉,就是去掉注释, 就起作用了

    目录别名的作用: 让网页文件不用必须放到网页目录下, 而是可以放到任意的 目录当中. 


    所有通过浏览器可以访问的目录, 都要daemon权限.


    Alias /icons/ "/usr/local/apache2//icons/"

        apache以为在这里 实际目录位置

    定义别名  /icons/----

    http://192.168.1.253/icons/


    <Directory "/usr/local/apache2//icons">

        Options Indexes MultiViews MultiViews多编码支持

        AllowOverride None

        Require all granted 

    </Directory>


    4 用户认证

    限制特定目录,只有指定用户可以访问。

    需要的用户都是由root通过linux命令加进去的. 而且不能注册, 适合公司内部用. 


    1) 建立需要保护的目录


    ①在/usr/local/apache2/htdocs/11下建立目录,然后保护


    ②使用别名,在系统位置建立目录,然后保护


    mkdir  -p  /share/soft


    2)修改配置文件,允许权限文件生效

    vi  /usr/local/apache2/etc/httpd.conf

    Alias /soft/ "/share/soft/"


    <Directory "/share/soft">

        Options Indexes 

        AllowOverride All #开启权限认证文件.htaccess

        Require all granted 

    </Directory>


    重启apache


    3)在指定目录建立权限文件 默认是不存在的, 需要手工建立. 

    cd  /share/soft


    vi  .htaccess #不区分大小写

    AuthName "50 docs"

    #提示信息 在输入账号和密码的时候会出现提示信息. 

    AuthType basic

    #加密类型   能用的加密方式就这一种: basic

    AuthUserFile /share/apache.passwd

    #密码文件,文件名自定义。

    require valid-user

    #允许密码文件中所有用户访问


    4)建立密码文件,加入允许访问的用户。用户和系统用户无关

    /usr/local/apache2/bin/htpasswd  -c  /share/apache.passwd  test1

    -c  建立密码文件,只有添加第一个用户时,才能-c

    回车后要求输入密码

    /usr/local/apache2/bin/htpasswd  -m  /share/apache.passwd  test2

    -m  再添加更多用户时,


    5 虚拟主机


    xeon  *2


    开启了虚拟主机, 默认的网页目录就不能访问了. 因为虚拟主机的优先级更高. 

    是给虚拟主机分了目录, 和网页目录是平级的. 

    1)分类

    基于IP的虚拟主机: 一台服务器,多个IP,搭建多个网站

    基于端口的虚拟主机 一台服务器,一个ip,搭建多个网站,每个网络使用不同端 口访问

    基于名字的虚拟主机 一台服务器,一个ip,搭建多个网站,每个网站使用不同域 名访问


    2)步骤:

    解析试验域名

    www.sina.com

    www.sohu.com

    C:\WINDOWS\system32\drivers\etc\hosts windows

    /etc/hosts Linux



    规划网站主目录

    /share/sina--------------www.sina.com

    /share/sohu ------------ www.sohu.com


    修改配置文件

    vi  /usr/local/apache2/etc/httpd.conf

    进入主配置文件, 找到下面这句话.

    Include etc//extra/httpd-vhosts.conf

    #打开虚拟主机配置文件

    把前面的#去掉, 就是取消注释. 默认是带#.

    vi /usr/local/apache2/etc/extra/httpd-vhosts.conf

    进入扩展配置文件. 

     


    <Directory "/usr/local/apache2/htdocs/sina"> 给目录设置权限. 

        Options Indexes

        AllowOverride None

    Require all granted 

    </Directory>


    <Directory "/usr/local/apache2/htdocs/sohu"> 给目录设置权限. 

        Options Indexes

        AllowOverride None

        Require all granted 

    </Directory>


    <VirtualHost 192.168.150.253>

    #注意,只能写ip

        ServerAdmin webmaster@sina.com

    #管理员邮箱

        DocumentRoot "/usr/local/apache2/htdocs/sina"

    #网站主目录

        ServerName www.sina.com

    #完整域名

        ErrorLog "logs/sina-error_log"

    #错误日志

        CustomLog "logs/sina-access_log" common

    #访问日志

    </VirtualHost>


    <VirtualHost 192.168.150.253>

        ServerAdmin webmaster@sohu.com

        DocumentRoot "/usr/local/apache2/htdocs/sohu"

        ServerName www.sohu.com

        ErrorLog "logs/sohu.com-error_log"

        CustomLog "logs/sohu.com-access_log" common

    </VirtualHost>


    6 rewrite 重写功能


    在URL中输入一个地址,会自动跳转为另一个


    1)域名跳转 www.sina.com  ------>  www.sohu.com


    开启虚拟主机,并正常访问 


    vi /usr/local/apache2/etc/httpd.conf

    进入主配置文件. 找到下面这句话. 

    LoadModule rewrite_module modules/mod_rewrite.so

    #打开重写模块,记得重启apache

    默认前面是有#, 是注释, 把#删掉. 


    修改配置文件,使sina目录的。htaccess文件生效


    [root@localhost etc]# vi extra/httpd-vhosts.conf


    <Directory "/usr/local/apache2/htdocs/sina">

        Options Indexes FollowSymLinks 代表新浪同意跳转. 

        AllowOverride All

    Require all granted 

    </Directory>


    vi  /usr/local/apache2/htdocs/sina/.htaccess

    RewriteEngine on

    #开启rewrite功能

    RewriteCond %{HTTP_HOST} www.sina.com

    把以www.sina.com 开头的内容赋值给HTTP_HOST变量

    只有开启域名跳转的时候需要这句话, 文件跳转不需要. 

    RewriteRule  .*   http://www.sohu.com

    .*  输入任何地址,都跳转到http://www.sohu.com



    静态网页向动态网页跳转

    文件跳转, 在URL中是看不到变化的. 

    修改配置文件

    <Directory "/usr/local/apache2/htdocs/sohu">

        Options Indexes FollowSymLinks

        AllowOverride All

        Require all granted 

    </Directory>



    vi  /usr/local/apache2/htdocs/sohu/.htaccess

    RewriteEngine on


    RewriteRule index(\d+).html index.php?id=$1

    # 输入index(数值).html时,跳转到index.php文件,同时把数值当成变量传入index.php




    7 常用子配置文件

    所有的扩展配置文件都需要在主配置文件中开启. 默认都是不关闭的. 


    httpd-autoindex.conf apache系统别名


    httpd-default.conf 线程控制 *

    Timeout 60 超时时间. 

    KeepAlive On 意思是: 一个用户在打开网页是, 右打开了一个新的连接, 

    就会占用2个进程. 开启这个, 就会只占用一个进程. 另一个用子进程打开, 就是线程打开


    httpd-info.conf 状态统计网页


    httpd-languages.conf 语言编码 *

    打开这个配置文件, 就是多语言支持. 但是还需要装字典. 编码等. 


    httpd-manual.conf apache帮助文档


    httpd-mpm.conf 最大连接数 *

    MaxRequestWorkers      250 (默认worker MPM模块生效)

    就是最大的并发数量. 


    httpd-multilang-errordoc.conf 错页面 *

    这个有BUG. 不能用. 


    httpd-ssl.conf ssl安全套接字访问


    httpd-userdir.conf 用户主目录配置


    httpd-vhosts.conf 虚拟主机


    浏览器报错: 403是权限拒绝

    404是文件不存在





    常用文件名和配置文件目录



    系统运行级别文件 /etc/inittab (init的配置文件)

    环境变量配置文件 ~/.bashrc

    开机自启动配置文件 /etc/rc.local(软连接---/etc/rc.d/rc.local)

    vim配置文件 ~/.vimrc (需要手动创建)

    用户信息文件 /etc/passwd

    影子文件 /etc/shadow

    组信息文件 /etc/group

    通过RPM包安装的服务所在目录 一般在/etc/rc.d/init.d

    通过源码包安装的apache服务 /usr/local/apache2/bin/apachectl

    系统启动日志文件 /var/log/dmesg  

    网卡信息文件 /etc/sysconfig/network-scripts/ifcfg-eth0

    主机名配置文件 /etc/sysconfig/network

    DNS配置文件 /etc/resolv.conf

    ftp普通用户上传位置 /home/用户名

    ftp匿名用户上传位置 /var/ftp/

    ftp配置文件 /etc/vsftpd/vsftpd.conf

    用户访问控制文件(访问黑名单) /etc/vsftpd/ftpusers

    可以跳出家目录文件(目录文件白名单) /etc/vsftpd/chroot_list

    SSH配置文件 /etc/ssh/sshd_config

    服务的绝对路径 /etc/rc.d/init.d/

    所有系统常见端口 /etc/services/

    完整防护配置文件(限制root权限) /etc/selinux/config

    rpm网页位置 /var/www/html

    源码包的网页位置 /usr/local/apache2/htdocs

    系统日志位置 /var/log

    系统默认邮箱位置 /var/spool/mail/

    默认安装的mysql的库文件目录 /var/lib/mysql/





    查询命令:

    w

    [root@localhost yum]# w

     06:04:48 up  2:19,  1 user,  load average: 0.00, 0.00, 0.00

    USER   TTY      FROM        LOGIN@  IDLE    JCPU   PCPU WHAT

    root    pts/0    192.168.106.26   03:46    0.00s  0.17s  0.01s w


    who

    [root@localhost yum]# who

    root     pts/0        2015-05-28 03:46 (192.168.106.26)


    whoami

    [root@localhost yum]# whoami

    root


    runlevel 查询系统运行级别

    [root@localhost ~]# runlevel

    N 3


    /etc/services linux的所有端口文件. 可以用cat  vi  more  等查看. 






    关机命令:

    shutdown -h now

    init 0


    重启命令:

    reboot

    init 6



    service, chkconfig , ntsysv  都只能管理rpm包安装的服务. 

    而不能管理源码包安装的服务. 

    Service, setup , ntsysv 是 redhat 专有的命令. 

    展开全文
  • linux/Makefile 代码注释

    2009-05-25 12:41:00
    1 #2 # if you want the ram-disk device, define this to be the # 如果你要使用RAM 盘设备的话,就3 # size in blocks. # 定义块的大小。4 #5 RAMDISK = #-DRAMDISK=51267 AS86 =as86 -0 -a # 8086 汇编编译器和...

    1 #
    2 # if you want the ram-disk device, define this to be the # 如果你要使用RAM 盘设备的话,就
    3 # size in blocks. # 定义块的大小。
    4 #
    5 RAMDISK = #-DRAMDISK=512
    6
    7 AS86 =as86 -0 -a # 8086 汇编编译器和连接器,见列表后的介绍。后带的参数含义分别
    8 LD86 =ld86 -0 # 是:-0 生成8086 目标程序;-a 生成与gas 和gld 部分兼容的代码。
    9
    10 AS =gas # GNU 汇编编译器和连接器,见列表后的介绍。
    11 LD =gld
    12 LDFLAGS =-s -x -M # GNU 连接器gld 运行时用到的选项。含义是:-s 输出文件中省略所
    # 有的符号信息;-x 删除所有局部符号;-M 表示需要在标准输出设备
    # (显示器)上打印连接映象(link map),是指由连接程序产生的一种
    # 内存地址映象,其中列出了程序段装入到内存中的位置信息。具体
    # 来讲有如下信息:
    # • 目标文件及符号信息映射到内存中的位置;
    # • 公共符号如何放置;
    # • 连接中包含的所有文件成员及其引用的符号。

    13 CC =gcc $(RAMDISK) # gcc 是GNU C 程序编译器。对于UNIX 类的脚本(script)程序而言,
    # 在引用定义的标识符时,需在前面加上$符号并用括号括住标识符。
    14 CFLAGS =-Wall -O -fstrength-reduce -fomit-frame-pointer /
    15 -fcombine-regs -mstring-insns # gcc 的选项。前一行最后的'/'符号表示下一行是续行。
    # 选项含义为:-Wall 打印所有警告信息;-O 对代码进行优化;
    # -fstrength-reduce 优化循环语句;-mstring-insns 是
    # Linus 自己为gcc 增加的选项,可以去掉。
    16 CPP =cpp -nostdinc -Iinclude # cpp 是gcc 的前(预)处理程序。-nostdinc -Iinclude 的含
    # 义是不要搜索标准的头文件目录中的文件,而是使用-I
    # 选项指定的目录或者是在当前目录里搜索头文件。
    17
    18 #
    19 # ROOT_DEV specifies the default root-device when making the image.
    20 # This can be either FLOPPY, /dev/xxxx or empty, in which case the
    21 # default of /dev/hd6 is used by 'build'.
    22 #
    23 ROOT_DEV=/dev/hd6 # ROOT_DEV 指定在创建内核映像(image)文件时所使用的默认根文件系统所
    # 在的设备,这可以是软盘(FLOPPY)、/dev/xxxx 或者干脆空着,空着时
    # build 程序(在tools/目录中)就使用默认值/dev/hd6。
    24
    25 ARCHIVES=kernel/kernel.o mm/mm.o fs/fs.o # kernel 目录、mm 目录和fs 目录所产生的目标代
    # 码文件。为了方便引用在这里将它们用
    # ARCHIVES(归档文件)标识符表示。
    26 DRIVERS =kernel/blk_drv/blk_drv.a kernel/chr_drv/chr_drv.a # 块和字符设备库文件。.a 表
    # 示该文件是个归档文件,也即包含有许多可执行二进制代码子程
    # 序集合的库文件,通常是用GNU 的ar 程序生成。ar 是GNU 的二进制
    # 文件处理程序,用于创建、修改以及从归档文件中抽取文件。
    27 MATH =kernel/math/math.a # 数学运算库文件。
    28 LIBS =lib/lib.a # 由lib/目录中的文件所编译生成的通用库文件。
    29
    30 .c.s: # make 老式的隐式后缀规则。该行指示make 利用下面的命令将所有的
    # .c 文件编译生成.s 汇编程序。':'表示下面是该规则的命令。
    31 $(CC) $(CFLAGS) /
    32 -nostdinc -Iinclude -S -o $*.s $< # 指使gcc 采用前面CFLAGS 所指定的选项以及
    # 仅使用include/目录中的头文件,在适当地编译后不进行汇编就
    # 停止(-S),从而产生与输入的各个C 文件对应的汇编语言形式的
    # 代码文件。默认情况下所产生的汇编程序文件是原C 文件名去掉.c
    # 而加上.s 后缀。-o 表示其后是输出文件的形式。其中$*.s(或$@)
    # 是自动目标变量,$<代表第一个先决条件,这里即是符合条件
    # *.c 的文件。
    33 .s.o: # 表示将所有.s 汇编程序文件编译成.o 目标文件。下一条是实
    # 现该操作的具体命令。
    34 $(AS) -c -o $*.o $< # 使用gas 编译器将汇编程序编译成.o 目标文件。-c 表示只编译
    # 或汇编,但不进行连接操作。
    35 .c.o: # 类似上面,*.c 文件-

    展开全文
  • 版权声明:著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处,@清风蓝。 ...// 代码实例: #define LED_RGBOFF \ LED1_ON;\ LED2_O...

    版权声明:著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处,@清风蓝。 https://blog.csdn.net/qq_38405680/article/details/81565592

    // 代码实例:

     #define LED_RGBOFF \
                            LED1_ON;\
                            LED2_ON\
                            LED3_OFF
    

    代码中的“\”是 C 语言中的续行符语法,表示续行符的下一行与续行符所在的代码是
    同一行。代码中因为宏定义关键字“#define”只是对当前行有效,所以我们使用续行符来
    连接起来,以下的代码是等效的:
    #define LED_RGBOFF LED1_ON; LED2_ON; LED3_OFF
    应用续行符的时候要注意,在“\”后面不能有任何字符(包括注释、空格),只能直接
    回车。

    展开全文
  • Linux内核完全注释Linux内核体系结构()2.6 Linux 内核对内存的使用方法2.8 Linux 内核源代码的目录结构2.9 内核系统与用户程序的关系2.10 linux/Makefile 文件小结 2.6 Linux 内核对内存的使用方法 在Linux ...

    2.6 Linux 内核对内存的使用方法

    在Linux 0.11 内核中,为了有效地使用机器中的物理内存,内存被划分成几个功能区域,见下图 2-9 所示。
    在这里插入图片描述其中,Linux 内核程序占据在物理内存的开始部分,接下来是用于供硬盘或软盘等块设备使用的高速缓冲区部分。当一个进程需要读取块设备中的数据时,系统会首先将数据读到高速缓冲区中;当有数据需要写到块设备上去时,系统也是先将数据放到高速缓冲区中,然后由块设备驱动程序写到设备上。 后部分是供所有程序可以随时申请使用的主内存区部分。内核程序在使用主内存区时,也同样要首先向内核的内存管理模块提出申请,在申请成功后方能使用。对于含有 RAM 虚拟盘的系统,主内存区头 部还要划去一部分,供虚拟盘存放数据。
    在 Linux 0.11 内核中,在进行地址映射时,我们需要首先分清 3 种地址以及它们之间的变换概念:a. 程序(进程)的逻辑地址;b. CPU 的线性地址;c. 实际物理内存地址。
    逻辑地址(Logical Address)是指有程序产生的与段相关的偏移地址部分。在 Intel 保护模式下即是指程序执行代码段限长内的偏移地址(假定代码段、数据段完全一样)。应用程序员仅需与逻辑地址打交道,而分段和分页机制对他来说是完全透明的,仅由系统编程人员涉及。
    线性地址(Linear Address)是逻辑地址到物理地址变换之间的中间层。程序代码会产生逻辑地址,或者说是段中的偏移地址,加上相应段的基地址就生成了一个线性地址。如果启用了分页机制,那么线性地址可以再经变换以产生一个物理地址。若没有启用分页机制,那么线性地址直接就是物理地址。Intel 80386的线性地址空间容量为4G。
    物理地址(Physical Address)是指出现在CPU外部地址总线上的寻址物理内存的地址信号,是地址变换的终结果地址。如果启用了分页机制,那么线性地址会使用页目录和页表中的项变换成物理地址。如果没有启用分页机制,那么线性地址就直接成为物理地址了。
    有时我们也把逻辑地址称为虚拟地址。因为与虚拟内存空间的概念类似,逻辑地址也是与实际物理内存容量无关的。
    在内存分段系统中,一个程序的逻辑地址是通过分段机制自动地映射(变换)到中间层的线性地址上。每次对内存的引用都是对内存段中内存的引用。当一个程序引用一个内存地址时,通过把相应的段 基址加到程序员看得见的逻辑地址上就形成了一个对应的线性地址。此时若没有启用分页机制,则该线性地址就被送到 CPU 的外部地址总线上,用于直接寻址对应的物理内存。
    若采用了分页机制,则此时线性地址只是一个中间结果,还需要使用分页机制进行变换,再终映射到实际物理内存地址上。与分段机制类似,分页机制允许我们重新定向(变换)每次内存引用,以适应我们的特殊要求。使用分页机制普遍的场合是当系统内存实际上被分成很多凌乱的块时,它可以建立一个大而连续的内存空间的映象,好让程序不用操心和管理这些分散的内存块。分页机制增强了分段机制 的性能。页地址变换是建立在段变换基础之上的。任何分页机制的保护措施并不会取代段变换的保护措施而只是进行更进一步的检查操 作。
    Intel CPU 使用段(Segment)的概念来对程序进行寻址。每个段定义了内存中的某个区域以及访问 的优先级等信息。而每个程序都可有若干个内存段组成。程序的逻辑地址(或称为虚拟地址)即是用于 寻址这些段和段中具体地址位置。在 Linux 0.11 中,程序逻辑地址到线性地址的变换过程使用了 CPU 的全局段描述符表GDT和局部段描述符表LDT。由 LDT 映射的地址空间称为全局地址空间,由LDT映射的地址空间则称为局部地址空间,而这两者构成了虚拟地址的空间。具体的使用方式见图 2-10 所示。
    在这里插入图片描述

    2.8 Linux 内核源代码的目录结构

    当我们使用 tar 命令将 linux-0.11.tar.gz 解开时,内核源代码文件被放到了 linux/目录中。其中的目录结构见图 2-15 所示:
    在这里插入图片描述

    2.9 内核系统与用户程序的关系

    在 Linux 系统中,内核为应用程序提供了两方面的接口。其一是系统调用接口(在第 5 章中说明), 也即中断调用 int 0x80;另一方面是通过内核库函数(在第 12 章中说明)与内核进行信息交流。内核库 函数是基本C函数库libc的组成部分。许多系统调用是作为基本 C 语言函数库的一部分实现的。系统调用主要是提供给系统软件直接使用或用于库函数的实现。而一般用户开发的程序则是通过调用象libc等库中的函数来访问内核资源。通过调用这些库中的程序,应用程序代码能够完成各种常用工作,例如,打开和关闭对文件或设备的访问、进行科学计算、出错处理以及访问组和用户标识号ID等系统信息。

    2.10 linux/Makefile 文件

    Makefile 文件相当于程序编译过程中的批处理文件。是工具程序 make 运行时的输入数据文件。只 要在含有 Makefile 的当前目录中键入 make 命令,它就会依据 Makefile 文件中的设置对源程序或目标代 码文件进行编译、连接或进行安装等活动。
    make工具程序能自动地确定一个大程序系统中那些程序文件需要被重新编译,并发出命令对这些程 序文件进行编译。在使用make之前,需要编写 Makefile 信息文件,该文件描述了整个程序包中各程序之间的关系,并针对每个需要更新的文件给出具体的控制命令。通常,执行程序是根据其目标文件进行更新的,而这些目标文件则是由编译程序创建的。一旦编写好一个合适的 Makefile 文件,那么在你每次修改过程序系统中的某些源代码文件后,执行 make 命令就能进行所有必要的重新编译工作。
    Makefile 文件的主要作用是指示make程序终使用独立编译连接成的 tools/目录中的 build 执 行程序将所有内核编译代码连接和合并成一个可运行的内核映像文件 image。具体是对 boot/中的bootsect.s、setup.s使用8086汇编器进行编译,分别生成各自的执行模块。再对源代码中的其它所有程序 使用 GNU 的编译器 gcc/gas进行编译,并连接成模块 system。再用 build工具将这三块组合成一个内核映象文件image. 基本编译连接/组合结构如图 2-20 所示。
    在这里插入图片描述make 的执行过程分为两个不同的阶段。在第一个阶段,它读取所有的 makefile 文件以及包含的 makefile 文件等,记录所有的变量及其值、隐式的或显式的规则,并构造出所有目标对象及其先决条件的一幅全景图。在第二阶段期间,make 就使用这些内部结构来确定哪个目标对象需要被重建,并且使用 相应的规则来操作。
    当 make 重新编译程序时,每个修改过的 C 代码文件必须被重新编译。如果一个头文件被修改过了, 那么为了确保正确,每一个包含该头文件的 C 代码程序都将被重新编译。每次编译操作都产生一个与源程序对应的目标文件(object file)。如果任何源代码文件被编译过了,那么所有的目标文件不管是 刚编译完的还是以前就编译好的必须连接在一起以生成新的可执行文件。
    简单的 makefile 文件含有一些规则,这些规则具有如下的形式:
    在这里插入图片描述其中’目标’对象通常是程序生成的一个文件的名称;例如是一个可执行文件或目标文件。目标也可以 是所要采取活动的名字,比如’清除’(‘clean’)。'先决条件’是一个或多个文件名,是用作产生目标的输入条 件。通常一个目标依赖几个文件。而’命令’是 make 需要执行的操作。一个规则可以有多个命令,每一个命令自成一行。

    小结

    本章概述了Linux 早期操作系统的内核模式和体系结构。给出了 Linux 0.11 内核源代码的目录结构形式,并详细地介绍了各个子目录中代码文件的基本功能和层次关系。后从 Linux 内核主目录下的 makefile 文件着手,开始对内核源代码进行注释。

    展开全文
  • 什么是makefile?或许很多Winodws的程序员都不知道这个东西,因为那些Windows的IDE都 为你做了这个工作,但我觉得要作一个好的和 professional的程序员,makefile还是要懂 。... ...特别在Unix下的软件编译,你就不能不...

    什么是makefile?或许很多Winodws的程序员都不知道这个东西,因为那些Windows的IDE都
    为你做了这个工作,但我觉得要作一个好的和 professional的程序员,makefile还是要懂
    。这就好像现在有这么多的HTML的编辑器,但如果你想成为一个专业人士,你还是要了解
    HTML的标识的含义。特别在Unix下的软件编译,你就不能不自己写makefile了,会不会写
    makefile,从一个侧面说明了一个人是否具备完成大型工程的能力。

    因为,makefile关系到了整个工程的编译规则。一个工程中的源文件不计数,其按类型、
    功能、模块分别放在若干个目录中,makefile定义了一系列的规则来指定,哪些文件需要
    先编译,哪些文件需要后编译,哪些文件需要重新编译,甚至于进行更复杂的功能操作,
    因为 makefile就像一个Shell脚本一样,其中也可以执行操作系统的命令。

    makefile带来的好处就是——“自动化编译”,一旦写好,只需要一个make命令,整个工
    程完全自动编译,极大的提高了软件开发的效率。make是一个命令工具,是一个解释make
    file中指令的命令工具,一般来说,大多数的IDE都有这个命令,比如:Delphi的make,V
    isual C++的nmake,Linux下GNU的make。可见,makefile都成为了一种在工程方面的编译
    方法。

    现在讲述如何写 makefile的文章比较少,这是我想写这篇文章的原因。当然,不同厂商的
    make各不相同,也有不同的语法,但其本质都是在“文件依赖性”上做文章,这里,我仅
    对GNU的make进行讲述,我的环境是RedHat Linux 8.0,make的版本是3.80。必竟,这个m
    ake是应用最为广泛的,也是用得最多的。而且其还是最遵循于IEEE 1003.2-1992 标准的
    (POSIX.2)。

    在这篇文档中,将以C/C++的源码作为我们基础,所以必然涉及一些关于C/C++的编译的知
    识,相关于这方面的内容,还请各位查看相关的编译器的文档。这里所默认的编译器是UN
    IX下的GCC和CC。



    关于程序的编译和链接
    ——————————

    在此,我想多说关于程序编译的一些规范和方法,一般来说,无论是C、C++、还是pas,首
    先要把源文件编译成中间代码文件在Windows下也就是 .obj 文件,UNIX下是 .o 文件
    即 Object File,这个动作叫做编译(compile)。然后再把大量的Object File合成执行
    文件,这个动作叫作链接(link)。

    编译时,编译器需要的是语法的正确,函数与变量的声明的正确。对于后者,通常是你需
    要告诉编译器头文件的所在位置(头文件中应该只是声明,而定义应该放在C/C++文件中)
    ,只要所有的语法正确,编译器就可以编译出中间目标文件。一般来说,每个源文件都应
    该对应于一个中间目标文件(O文件或是OBJ文件)。

    链接时,主要是链接函数和全局变量,所以,我们可以使用这些中间目标文件(O文件或是
    OBJ文件)来链接我们的应用程序。链接器并不管函数所在的源文件,只管函数的中间目标
    文件(Object File),在大多数时候,由于源文件太多,编译生成的中间目标文件太多,
    而在链接时需要明显地指出中间目标文件名,这对于编译很不方便,所以,我们要给中间
    目标文件打个包,在Windows下这种包叫“库文件”(Library File),也就是 .lib 文件
    ,在UNIX下,是Archive File,也就是 .a 文件

    总结一下,源文件首先会生成中间目标文件,再由中间目标文件生成执行文件。在编译时
    ,编译器只检测程序语法,和函数、变量是否被声明。如果函数未被声明,编译器会给出
    一个警告,但可以生成Object File。而在链接程序时,链接器会在所有的Object File中
    找寻函数的实现,如果找不到,那到就会报链接错误码(Linker Error),在VC下,这种
    错误一般是:Link 2001错误,意思说是说,链接器未能找到函数的实现。你需要指定函数
    的Object File.

    好,言归正传,GNU的make有许多的内容,闲言少叙,还是让我们开始吧。



    Makefile 介绍
    ———————

    make命令执行时,需要一个 Makefile(一般首字母大写) 文件,以告诉make命令需要怎么样的去编译和链接
    程序

    首先,我们用一个示例来说明Makefile的书写规则。以便给大家一个感兴认识。这个示例
    来源于GNU的make使用手册,在这个示例中,我们的工程有8个C文件,和3个头文件,我们
    要写一个Makefile来告诉make命令如何编译和链接这几个文件。我们的规则是:
    1)如果这个工程没有编译过,那么我们的所有C文件都要编译并被链接。
    2)如果这个工程的某几个C文件被修改,那么我们只编译被修改的C文件,并链接目标程序

    3)如果这个工程的头文件被改变了,那么我们需要编译引用了这个头文件的所有C文件,并
    链接目标程序。

    只要我们的Makefile写得够好,所有的这一切,我们只用一个make命令就可以完成,make
    命令会自动智能地根据当前的文件修改的情况来确定哪些文件需要重编译,从而自己编译
    所需要的文件和链接目标程序。


    一、Makefile的规则

    在讲述这个Makefile之前,还是让我们先来粗略地看一看Makefile的规则。

    target ... : prerequisites ...
    command
    ...
    ...

    target也就是一个目标文件,可以是Object File,也可以是执行文件。还可以是一个标签
    (Label),对于标签这种特性,在后续的“伪目标”章节中会有叙述。

    prerequisites就是,要生成那个target所需要的文件或是目标。

    command也就是make需要执行的命令。(任意的Shell命令

    这是一个文件的依赖关系,也就是说,target这一个或多个的目标文件依赖于prerequisi
    tes中的文件,其生成规则定义在command中。说白一点就是说,prerequisites中如果有一
    个以上的文件比target文件要新的话,command所定义的命令就会被执行
    。这就是 Makefi
    le的规则。也就是Makefile中最核心的内容。

    说到底,Makefile的东西就是这样一点,好像我的这篇文档也该结束了。呵呵。还不尽然
    ,这是Makefile的主线和核心,但要写好一个Makefile还不够,我会以后面一点一点地结
    合我的工作经验给你慢慢到来。内容还多着呢。:)


    二、一个示例

    正如前面所说的,如果一个工程有3个头文件,和8个C文件,我们为了完成前面所述的那三
    个规则,我们的Makefile应该是下面的这个样子的。

    edit : main.o kbd.o command.o display.o \
    insert.o search.o files.o utils.o
      cc -o edit main.o kbd.o command.o display.o \
    insert.o search.o files.o utils.o

    main.o : main.c defs.h
      cc -c main.c
    kbd.o : kbd.c defs.h command.h
      cc -c kbd.c
    command.o : command.c defs.h command.h
      cc -c command.c
    display.o : display.c defs.h buffer.h
      cc -c display.c
    insert.o : insert.c defs.h buffer.h
      cc -c insert.c
    search.o : search.c defs.h buffer.h
      cc -c search.c
    files.o : files.c defs.h buffer.h command.h
      cc -c files.c
    utils.o : utils.c defs.h
      cc -c utils.c
    clean :
      rm edit main.o kbd.o command.o display.o \
    insert.o search.o files.o utils.o

    反斜杠(\)是换行符的意思。这样比较便于Makefile的易读。我们可以把这个内容保存在
    文件为“Makefile”或“makefile”的文件中,然后在该目录下直接输入命令“make”就
    可以生成执行文件edit。如果要删除执行文件和所有的中间目标文件,那么,只要简单地
    执行一下“make clean”就可以了

    在这个makefile中,目标文件(target)包含:执行文件edit和中间目标文件(*.o),依
    赖文件(prerequisites)就是冒号后面的那些 .c 文件和 .h文件。每一个 .o 文件都有
    一组依赖文件,而这些 .o 文件又是执行文件 edit 的依赖文件。依赖关系的实质上就是
    说明了目标文件是由哪些文件生成的,换言之,目标文件是哪些文件更新的

    在定义好依赖关系后,后续的那一行定义了如何生成目标文件的操作系统命令,一定要以
    一个Tab键作为开头。记住,make并不管命令是怎么工作的,他只管执行所定义的命令。m
    ake会比较targets文件和prerequisites文件的修改日期,如果prerequisites文件的日期
    要比targets文件的日期要新,或者target不存在的话,那么,make就会执行后续定义的命
    令。

    这里要说明一点的是,clean不是一个文件,它只不过是一个动作名字,有点像C语言中的
    lable一样,其冒号后什么也没有,那么,make就不会自动去找文件的依赖性,也就不会自
    动执行其后所定义的命令。要执行其后的命令,就要在make命令后明显得指出这个lable的
    名字。这样的方法非常有用,我们可以在一个makefile中定义不用的编译或是和编译无关
    的命令,比如程序的打包,程序的备份,等等。



    三、make是如何工作的

    在默认的方式下,也就是我们只输入make命令。那么,

    1、make会在当前目录下找名字叫“Makefile”或“makefile”的文件。
    2、如果找到,它会找文件中的第一个目标文件(target),在上面的例子中,他会找到“
    edit”这个文件,并把这个文件作为最终的目标文件。
    3、如果edit文件不存在,或是edit所依赖的后面的 .o 文件的文件修改时间要比edit这个
    文件新,那么,他就会执行后面所定义的命令来生成edit这个文件。
    4、如果edit所依赖的.o文件也不存在,那么make会在当前文件中找目标为.o文件的依赖性
    ,如果找到则再根据那一个规则生成.o文件。(这有点像一个堆栈的过程)
    5、当然,你的C文件和H文件是存在的啦,于是make会生成 .o 文件,然后再用 .o 文件生
    命make的终极任务,也就是执行文件edit了。

    这就是整个make的依赖性,make会一层又一层地去找文件的依赖关系,直到最终编译出第
    一个目标文件。在找寻的过程中,如果出现错误,比如最后被依赖的文件找不到,那么ma
    ke就会直接退出,并报错,而对于所定义的命令的错误,或是编译不成功,make根本不理
    。make只管文件的依赖性,即,如果在我找了依赖关系之后,冒号后面的文件还是不在,
    那么对不起,我就不工作啦。

    通过上述分析,我们知道,像clean这种,没有被第一个目标文件直接或间接关联,那么它
    后面所定义的命令将不会被自动执行,不过,我们可以显示要make执行。即命令——“ma
    ke clean”,以此来清除所有的目标文件,以便重编译

    于是在我们编程中,如果这个工程已被编译过了,当我们修改了其中一个源文件,比如fi
    le.c,那么根据我们的依赖性,我们的目标file.o会被重编译(也就是在这个依性关系后
    面所定义的命令),于是file.o的文件也是最新的啦,于是file.o的文件修改时间要比ed
    it要新,所以edit也会被重新链接了(详见edit目标文件后定义的命令)。

    而如果我们改变了“command.h”,那么,kdb.o、command.o和files.o都会被重编译,并
    且,edit会被重链接。


    四、makefile中使用变量

    在上面的例子中,先让我们看看edit的规则:

    edit : main.o kbd.o command.o display.o \
    insert.o search.o files.o utils.o
      cc -o edit main.o kbd.o command.o display.o \
    insert.o search.o files.o utils.o

    我们可以看到[.o]文件的字符串被重复了两次,如果我们的工程需要加入一个新的[.o]文
    件,那么我们需要在两个地方加(应该是三个地方,还有一个地方在 clean中)。当然,
    我们的makefile并不复杂,所以在两个地方加也不累,但如果makefile变得复杂,那么我
    们就有可能会忘掉一个需要加入的地方,而导致编译失败。所以,为了makefile的易维护
    在makefile中我们可以使用变量。makefile的变量也就是一个字符串,理解成 C语言中
    的宏可能会更好

    比如,我们声明一个变量,叫objects, OBJECTS, objs, OBJS, obj, 或是 OBJ,反正不管
    什么啦,只要能够表示obj文件就行了。我们在makefile一开始就这样定义:

    objects = main.o kbd.o command.o display.o \
    insert.o search.o files.o utils.o

    于是,我们就可以很方便地在我们的makefile中以“$(objects)”的方式来使用这个变量
    了,于是我们的改良版makefile就变成下面这个样子:

    objects = main.o kbd.o command.o display.o \
    insert.o search.o files.o utils.o

    edit : $(objects)
      cc -o edit $(objects)
    main.o : main.c defs.h
      cc -c main.c
    kbd.o : kbd.c defs.h command.h
      cc -c kbd.c
    command.o : command.c defs.h command.h
      cc -c command.c
    display.o : display.c defs.h buffer.h
      cc -c display.c
    insert.o : insert.c defs.h buffer.h
      cc -c insert.c
    search.o : search.c defs.h buffer.h
      cc -c search.c
    files.o : files.c defs.h buffer.h command.h
      cc -c files.c
    utils.o : utils.c defs.h
    c  c -c utils.c
    clean :
      rm edit $(objects)


    于是如果有新的 .o 文件加入,我们只需简单地修改一下 objects 变量就可以了。

    关于变量更多的话题,我会在后续给你一一道来。


    五、让make自动推导

    GNU的make很强大,它可以自动推导文件以及文件依赖关系后面的命令,于是我们就没必要
    去在每一个[.o]文件后都写上类似的命令,因为,我们的make会自动识别,并自己推导命
    令。

    只要make看到一个[.o]文件,它就会自动的把[.c]文件加在依赖关系中,如果make找到一
    个whatever.o,那么whatever.c,就会是whatever.o的依赖文件。并且 cc -c whatever.
    c 也会被推导出来,于是,我们的makefile再也不用写得这么复杂。我们的是新的makefi
    le又出炉了。


    objects = main.o kbd.o command.o display.o \
    insert.o search.o files.o utils.o

    edit : $(objects)
      cc -o edit $(objects)

    main.o : defs.h
    kbd.o : defs.h command.h
    command.o : defs.h command.h
    display.o : defs.h buffer.h
    insert.o : defs.h buffer.h
    search.o : defs.h buffer.h
    files.o : defs.h buffer.h command.h
    utils.o : defs.h

    .PHONY : clean
    clean :
      rm edit $(objects)

    这种方法,也就是make的“隐晦规则”。上面文件内容中,“.PHONY”表示,clean是个伪
    目标文件

    关于更为详细的“隐晦规则”和“伪目标文件”,我会在后续给你一一道来。


    六、另类风格的makefile(同感,不推荐)

    即然我们的make可以自动推导命令,那么我看到那堆[.o]和[.h]的依赖就有点不爽,那么
    多的重复的[.h],能不能把其收拢起来,好吧,没有问题,这个对于make来说很容易,谁
    叫它提供了自动推导命令和文件的功能呢?来看看最新风格的makefile吧。

    objects = main.o kbd.o command.o display.o \
    insert.o search.o files.o utils.o

    edit : $(objects)
      cc -o edit $(objects)

    $(objects) : defs.h
    kbd.o command.o files.o : command.h
    display.o insert.o search.o files.o : buffer.h

    .PHONY : clean
    clean :
      rm edit $(objects)

    这种风格,让我们的makefile变得很简单,但我们的文件依赖关系就显得有点凌乱了。鱼
    和熊掌不可兼得。还看你的喜好了。我是不喜欢这种风格的,一是文件的依赖关系看不清
    楚,二是如果文件一多,要加入几个新的.o文件,那就理不清楚了。

    七、清空目标文件的规则

    每个Makefile中都应该写一个清空目标文件(.o和执行文件)的规则,这不仅便于重编译
    ,也很利于保持文件的清洁。这是一个“修养”(呵呵,还记得我的《编程修养》吗)。
    一般的风格都是:

    clean:
      rm edit $(objects)

    更为稳健的做法是:

    .PHONY : clean
    clean :
      -rm edit $(objects)

    前面说过,.PHONY意思表示clean是一个“伪目标”,。而在rm命令前面加了一个小减号的
    意思就是,也许某些文件出现问题,但不要管,继续做后面的事。当然,clean的规则不要
    放在文件的开头,不然,这就会变成make的默认目标,相信谁也不愿意这样。不成文的规
    矩是——“clean从来都是放在文件的最后”。


    上面就是一个makefile的概貌,也是makefile的基础,下面还有很多makefile的相关细节
    ,准备好了吗?准备好了就来。

    Makefile 总述
    ———————

    一、Makefile里有什么?

    Makefile里主要包含了五个东西:显式规则、隐晦规则、变量定义、文件指示和注释。


    1、显式规则。显式规则说明了,如何生成一个或多的的目标文件。这是由Makefile的书写
    者明显指出,要生成的文件,文件的依赖文件,生成的命令。

    2、隐晦规则。由于我们的make有自动推导的功能,所以隐晦的规则可以让我们比较粗糙地
    简略地书写Makefile,这是由make所支持的。

    3、变量的定义。在Makefile中我们要定义一系列的变量,变量一般都是字符串,这个有点
    你C语言中的宏,当Makefile被执行时,其中的变量都会被扩展到相应的引用位置上。

    4、文件指示。其包括了三个部分,一个是在一个Makefile中引用另一个Makefile,就像C
    语言中的include一样;另一个是指根据某些情况指定Makefile中的有效部分,就像C语言
    中的预编译#if一样;还有就是定义一个多行的命令。有关这一部分的内容,我会在后续的
    部分中讲述。

    5、注释。Makefile中只有行注释,和UNIX的Shell脚本一样,其注释是用“#”字符,这个
    就像C/C++中的“//”一样。如果你要在你的Makefile中使用“#”字符,可以用反斜框进
    行转义,如:“\#”。

    最后,还值得一提的是,在Makefile中的命令,必须要以[Tab]键开始


    二、Makefile的文件名

    默认的情况下,make命令会在当前目录下按顺序找寻文件名为“GNUmakefile”、“makef
    ile”、“Makefile”的文件,找到了解释这个文件。在这三个文件名中,最好使用“Mak
    efile”这个文件名,因为,这个文件名第一个字符为大写,这样有一种显目的感觉。最好
    不要用 “GNUmakefile”,这个文件是GNU的make识别的。有另外一些make只对全小写的“
    makefile”文件名敏感,但是基本上来说,大多数的make都支持“makefile”和“Makefi
    le”这两种默认文件名。

    当然,你可以使用别的文件名来书写Makefile,比如:“Make.Linux”,“Make.Solaris
    ”,“Make.AIX”等,如果要指定特定的Makefile,你可以使用make的“- f”和“--fil
    e”参数,如:make -f Make.Linux或make --file Make.AIX


    三、引用其它的Makefile

    在Makefile使用include关键字可以把别的Makefile包含进来,这很像C语言的#include,
    被包含的文件会原模原样的放在当前文件的包含位置。include的语法是:

    include

    filename可以是当前操作系统Shell的文件模式(可以保含路径和通配符)

    在 include前面可以有一些空字符,但是绝不能是[Tab]键开始。include和可
    以用一个或多个空格隔开。举个例子,你有这样几个Makefile:a.mk、b.mk、c.mk,还有
    一个文件叫foo.make,以及一个变量$(bar),其包含了e.mk和 f.mk,那么,下面的语句:


    include foo.make *.mk $(bar)

    等价于:

    include foo.make a.mk b.mk c.mk e.mk f.mk

    make 命令开始时,会把找寻include所指出的其它Makefile,并把其内容安置在当前的位
    置。就好像C/C++的#include指令一样。如果文件都没有指定绝对路径或是相对路径的话,
    make会在当前目录下首先寻找,如果当前目录下没有找到,那么,make还会在下面的几个
    目录下找:

    1、如果make执行时,有“-I”或“--include-dir”参数,那么make就会在这个参数所指
    定的目录下去寻找。
    2、如果目录/include(一般是:/usr/local/bin或/usr/include)存在的话,m
    ake也会去找。

    如果有文件没有找到的话,make会生成一条警告信息,但不会马上出现致命错误。它会继
    续载入其它的文件,一旦完成makefile的读取,make会再重试这些没有找到,或是不能读
    取的文件,如果还是不行,make才会出现一条致命信息。如果你想让make不理那些无法读
    取的文件,而继续执行,你可以在 include前加一个减号“-”。如:

    -include
    其表示,无论include过程中出现什么错误,都不要报错继续执行。和其它版本make兼容的
    相关命令是sinclude,其作用和这一个是一样的。


    四、环境变量 MAKEFILES

    如果你的当前环境中定义了环境变量MAKEFILES,那么,make会把这个变量中的值做一个类
    似于include的动作。这个变量中的值是其它的 Makefile,用空格分隔。只是,它和incl
    ude不同的是,从这个环境变中引入的Makefile的“目标”不会起作用,如果环境变量中定
    义的文件发现错误,make也会不理。

    但是在这里我还是建议不要使用这个环境变量,因为只要这个变量一被定义,那么当你使
    用make时,所有的 Makefile都会受到它的影响,这绝不是你想看到的。在这里提这个事,
    只是为了告诉大家,也许有时候你的Makefile出现了怪事,那么你可以看看当前环境中有
    没有定义这个变量。


    五、make的工作方式

    GNU的make工作时的执行步骤入下:(想来其它的make也是类似)

    1、读入所有的Makefile。
    2、读入被include的其它Makefile。
    3、初始化文件中的变量。
    4、推导隐晦规则,并分析所有规则。
    5、为所有的目标文件创建依赖关系链。
    6、根据依赖关系,决定哪些目标要重新生成。
    7、执行生成命令。


    1-5 步为第一个阶段,6-7为第二个阶段。第一个阶段中,如果定义的变量被使用了,那么
    ,make会把其展开在使用的位置。但make并不会完全马上展开,make使用的是拖延战术,
    如果变量出现在依赖关系的规则中,那么仅当这条依赖被决定要使用了,变量才会在其内
    部展开。

    当然,这个工作方式你不一定要清楚,但是知道这个方式你也会对make更为熟悉。有了这
    个基础,后续部分也就容易看懂了。



    书写规则
    ————

    规则包含两个部分,一个是依赖关系,一个是生成目标的方法

    在 Makefile中,规则的顺序是很重要的,因为,Makefile中只应该有一个最终目标,其它
    的目标都是被这个目标所连带出来的,所以一定要让 make知道你的最终目标是什么。一般
    来说,定义在Makefile中的目标可能会有很多,但是第一条规则中的目标将被确立为最终
    的目标。如果第一条规则中的目标有很多个,那么,第一个目标会成为最终的目标。make
    所完成的也就是这个目标。

    好了,还是让我们来看一看如何书写规则。


    一、规则举例

    foo.o : foo.c defs.h # foo模块
      cc -c -g foo.c

    看到这个例子,各位应该不是很陌生了,前面也已说过,foo.o是我们的目标,foo.c和de
    fs.h是目标所依赖的源文件,而只有一个命令“cc -c -g foo.c”(以Tab键开头)。这个
    规则告诉我们两件事:

    1、文件的依赖关系,foo.o依赖于foo.c和defs.h的文件,如果foo.c和defs.h的文件日期
    要比foo.o文件日期要新,或是foo.o不存在,那么依赖关系发生。
    2、如果生成(或更新)foo.o文件。也就是那个cc命令,其说明了,如何生成foo.o这个文
    件。(当然foo.c文件include了defs.h文件)


    二、规则的语法

    targets : prerequisites
    command
    ...

    或是这样:

    targets : prerequisites ; command
    command
    ...

    targets是文件名,以空格分开,可以使用通配符。一般来说,我们的目标基本上是一个文
    件,但也有可能是多个文件。

    command是命令行,如果其不与“target吐舌rerequisites”在一行,那么,必须以[Tab键
    ]开头,如果和prerequisites在一行,那么可以用分号做为分隔。(见上)

    prerequisites也就是目标所依赖的文件(或依赖目标)。如果其中的某个文件要比目标文
    件要新,那么,目标就被认为是“过时的”,被认为是需要重生成的。这个在前面已经讲
    过了。

    如果命令太长,你可以使用反斜框(‘\’)作为换行符。make对一行上有多少个字符没有
    限制。规则告诉make两件事,文件的依赖关系和如何成成目标文件。

    一般来说,make会以UNIX的标准Shell,也就是/bin/sh来执行命令。


    三、在规则中使用通配符

    如果我们想定义一系列比较类似的文件,我们很自然地就想起使用通配符。make支持三各
    通配符:“*”,“?”和“[...]”。这是和Unix的B-Shell是相同的

    波浪号(“~”)字符在文件名中也有比较特殊的用途。如果是“~/test”,这就表示当前
    用户的$HOME目录下的test目录。而“~hchen /test”则表示用户hchen的宿主目录下的te
    st目录。(这些都是Unix下的小知识了,make也支持)而在Windows或是MS-DOS 下,用户
    没有宿主目录,那么波浪号所指的目录则根据环境变量“HOME”而定。

    通配符代替了你一系列的文件,如“*.c”表示所以后缀为c的文件。一个需要我们注意的
    是,如果我们的文件名中有通配符,如:“*”,那么可以用转义字符“\”,如“\*”来
    表示真实的“*”字符,而不是任意长度的字符串。

    好吧,还是先来看几个例子吧:

    clean:
      rm -f *.o

    上面这个例子我不不多说了,这是操作系统Shell所支持的通配符。这是在命令中的通配符


    print: *.c
    lpr -p $?
    touch print

    上面这个例子说明了通配符也可以在我们的规则中,目标print依赖于所有的[.c]文件。其
    中的“$?”是一个自动化变量,我会在后面给你讲述。

    objects = *.o

    上面这个例子,表示了,通符同样可以用在变量中。并不是说[*.o]会展开,不!objects
    的值就是“*.o”。Makefile中的变量其实就是 C/C++中的宏。如果你要让通配符在变量中
    展开,也就是让objects的值是所有[.o]的文件名的集合,那么,你可以这样:

    objects := $(wildcard *.o)

    这种用法由关键字“wildcard”指出,关于Makefile的关键字,我们将在后面讨论。


    四、文件搜寻

    在一些大的工程中,有大量的源文件,我们通常的做法是把这许多的源文件分类,并存放
    在不同的目录中。所以,当make需要去找寻文件的依赖关系时,你可以在文件前加上路径
    ,但最好的方法是把一个路径告诉make,让make在自动去找。

    Makefile文件中的特殊变量“VPATH”就是完成这个功能的,如果没有指明这个变量,mak
    e只会在当前的目录中去找寻依赖文件和目标文件。如果定义了这个变量,那么,make就会
    在当当前目录找不到的情况下,到所指定的目录中去找寻文件了。

    VPATH = src:../headers

    上面的的定义指定两个目录,“src”和“../headers”,make会按照这个顺序进行搜索。
    目录由“冒号”分隔。(当然,当前目录永远是最高优先搜索的地方

    另一个设置文件搜索路径的方法是使用make的“vpath”关键字(注意,它是全小写的),
    这不是变量,这是一个make的关键字,这和上面提到的那个 VPATH变量很类似,但是它更
    为灵活。它可以指定不同的文件在不同的搜索目录中。这是一个很灵活的功能。它的使用
    方法有三种:

    1、vpath

    为符合模式的文件指定搜索目录。

    2、vpath

    清除符合模式的文件的搜索目录。

    3、vpath

    清除所有已被设置好了的文件搜索目录。

    vapth 使用方法中的需要包含“%”字符。“%”的意思是匹配零或若干字符,例
    如,“%.h”表示所有以“.h”结尾的文件。指定了要搜索的文件集,而
    tories>则指定了的文件集的搜索的目录。例如:

    vpath %.h ../headers

    该语句表示,要求make在“../headers”目录下搜索所有以“.h”结尾的文件。(如果某
    文件在当前目录没有找到的话)

    我们可以连续地使用vpath语句,以指定不同搜索策略。如果连续的vpath语句中出现了相
    同的,或是被重复了的,那么,make会按照vpath语句的先后顺序来执
    行搜索。如:

    vpath %.c foo
    vpath % blish
    vpath %.c bar


    其表示“.c”结尾的文件,先在“foo”目录,然后是“blish”,最后是“bar”目录。


    vpath %.c foo:bar
    vpath % blish


    而上面的语句则表示“.c”结尾的文件,先在“foo”目录,然后是“bar”目录,最后才
    是“blish”目录。


    五、伪目标

    最早先的一个例子中,我们提到过一个“clean”的目标,这是一个“伪目标”,

    clean:
      rm *.o temp

    正像我们前面例子中的“clean”一样,即然我们生成了许多文件编译文件,我们也应该提
    供一个清除它们的“目标”以备完整地重编译而用。 (以“make clean”来使用该目标)


    因为,我们并不生成“clean”这个文件。“伪目标”并不是一个文件,只是一个标签,由
    于“伪目标”不是文件,所以make无法生成它的依赖关系和决定它是否要执行。我们只有
    通过显示地指明这个“目标”才能让其生效。当然,“伪目标”的取名不能和文件名重名
    ,不然其就失去了“伪目标”的意义了

    当然,为了避免和文件重名的这种情况,我们可以使用一个特殊的标记“.PHONY”来显示
    地指明一个目标是“伪目标”,向make说明,不管是否有这个文件,这个目标就是“伪目
    标”。

    .PHONY : clean

    只要有这个声明,不管是否有“clean”文件,要运行“clean”这个目标,只有“make c
    lean”这样。于是整个过程可以这样写:

    .PHONY: clean
    clean:
      rm *.o temp

    伪目标一般没有依赖的文件。但是,我们也可以为伪目标指定所依赖的文件。伪目标同样
    可以作为“默认目标”,只要将其放在第一个。一个示例就是,如果你的 Makefile需要一
    口气生成若干个可执行文件,但你只想简单地敲一个make完事,并且,所有的目标文件都
    写在一个Makefile中,那么你可以使用“伪目标”这个特性

    all : prog1 prog2 prog3
    .PHONY : all

    prog1 : prog1.o utils.o
    cc -o prog1 prog1.o utils.o

    prog2 : prog2.o
    cc -o prog2 prog2.o

    prog3 : prog3.o sort.o utils.o
    cc -o prog3 prog3.o sort.o utils.o

    我们知道,Makefile中的第一个目标会被作为其默认目标。我们声明了一个“all”的伪目
    标,其依赖于其它三个目标。由于伪目标的特性是,总是被执行的,所以其依赖的那三个
    目标就总是不如“all”这个目标新。所以,其它三个目标的规则总是会被决议。也就达到
    了我们一口气生成多个目标的目的。 “.PHONY : all”声明了“all”这个目标为“伪目
    标”。

    随便提一句,从上面的例子我们可以看出,目标也可以成为依赖。所以,伪目标同样也可
    成为依赖。看下面的例子:

    .PHONY: cleanall cleanobj cleandiff

    cleanall : cleanobj cleandiff
    rm program

    cleanobj :
    rm *.o

    cleandiff :
    rm *.diff

    “make clean”将清除所有要被清除的文件。“cleanobj”和“cleandiff”这两个伪目标
    有点像“子程序”的意思。我们可以输入“make cleanall”和“make cleanobj”和“ma
    ke cleandiff”命令来达到清除不同种类文件的目的

    六、多目标

    Makefile 的规则中的目标可以不止一个,其支持多目标,有可能我们的多个目标同时依赖
    于一个文件,并且其生成的命令大体类似。于是我们就能把其合并起来。当然,多个目标
    的生成规则的执行命令是同一个,这可能会可我们带来麻烦,不过好在我们的可以使用一
    自动化变量“$@”(关于自动化变量,将在后面讲述),这个变量表示着目前规则中所
    有的目标的集合,这样说可能很抽象,还是看一个例子吧。

    bigoutput littleoutput : text.g
    generate text.g -$(subst output,,$@) > $@

    上述规则等价于:

    bigoutput : text.g
    generate text.g -big > bigoutput
    littleoutput : text.g
    generate text.g -little > littleoutput

    其中,-$(subst output,,$@)中的“$”表示执行一个Makefile的函数,函数名为subst,
    后面的为参数。关于函数,将在后面讲述。这里的这个函数是截取字符串的意思,“$@”
    表示目标的集合,就像一个数组,“$@”依次取出目标,并执于命令。


    七、静态模式

    静态模式可以更加容易地定义多目标的规则,可以让我们的规则变得更加的有弹性和灵活
    。我们还是先来看一下语法:

    : :

    ...


    targets定义了一系列的目标文件,可以有通配符。是目标的一个集合。

    target-parrtern是指明了targets的模式,也就是的目标集模式。

    prereq-parrterns是目标的依赖模式,它对target-parrtern形成的模式再进行一次依赖目
    标的定义。


    这样描述这三个东西,可能还是没有说清楚,还是举个例子来说明一下吧。如果我们的
    arget-parrtern>定义成“%.o”,意思是我们的集合中都是以“.o”结尾的,而
    如果我们的定义成“%.c”,意思是对所形成的目
    标集进行二次定义,其计算方法是,取模式中的“%”(也就是去掉了
    [.o]这个结尾),并为其加上[.c]这个结尾,形成的新集合。

    所以,我们的“目标模式”或是“依赖模式”中都应该有“%”这个字符,如果你的文件名
    中有“%”那么你可以使用反斜杠“\”进行转义,来标明真实的“%”字符。

    看一个例子:

    objects = foo.o bar.o

    all: $(objects)

    $(objects): %.o: %.c
    $(CC) -c $(CFLAGS) $< -o $@


    上面的例子中,指明了我们的目标从$object中获取,“%.o”表明要所有以“.o”结尾的
    目标,也就是“foo.o bar.o”,也就是变量$object集合的模式,而依赖模式“%.c”则取
    模式“%.o”的“%”,也就是“foo bar”,并为其加下“.c”的后缀,于是,我们的依赖
    目标就是“foo.c bar.c”。而命令中的“$<”和“$@”则是自动化变量,“$<”表示所有
    的依赖目标集(也就是“foo.c bar.c”),“$@”表示目标集(也就是“foo.o bar.o”
    )。于是,上面的规则展开后等价于下面的规则:

    foo.o : foo.c
    $(CC) -c $(CFLAGS) foo.c -o foo.o
    bar.o : bar.c
    $(CC) -c $(CFLAGS) bar.c -o bar.o

    试想,如果我们的“%.o”有几百个,那种我们只要用这种很简单的“静态模式规则”就可
    以写完一堆规则,实在是太有效率了。“静态模式规则”的用法很灵活,如果用得好,那
    会一个很强大的功能。再看一个例子:


    files = foo.elc bar.o lose.o

    $(filter %.o,$(files)): %.o: %.c
    $(CC) -c $(CFLAGS) $< -o $@
    $(filter %.elc,$(files)): %.elc: %.el
    emacs -f batch-byte-compile $<</span>


    $(filter %.o,$(files))表示调用Makefile的filter函数,过滤“$filter”集,只要其中
    模式为“%.o”的内容。其的它内容,我就不用多说了吧。这个例字展示了Makefile中更大
    的弹性。


    八、自动生成依赖性

    在Makefile中,我们的依赖关系可能会需要包含一系列的头文件,比如,如果我们的main
    .c中有一句“#include "defs.h"”,那么我们的依赖关系应该是:

    main.o : main.c defs.h

    但是,如果是一个比较大型的工程,你必需清楚哪些C文件包含了哪些头文件,并且,你在
    加入或删除头文件时,也需要小心地修改Makefile,这是一个很没有维护性的工作。为了
    避免这种繁重而又容易出错的事情,我们可以使用C/C++编译的一个功能。大多数的C/C++
    编译器都支持一个“-M”的选项,即自动找寻源文件中包含的头文件,并生成一个依赖关
    。例如,如果我们执行下面的命令:

    cc -M main.c

    其输出是:

    main.o : main.c defs.h

    于是由编译器自动生成的依赖关系,这样一来,你就不必再手动书写若干文件的依赖关系
    ,而由编译器自动生成了。需要提醒一句的是,如果你使用GNU的C/C++编译器,你得用“
    -MM”参数,不然,“-M”参数会把一些标准库的头文件也包含进来

    gcc -M main.c的输出是:

    main.o: main.c defs.h /usr/include/stdio.h /usr/include/features.h \
    /usr/include/sys/cdefs.h /usr/include/gnu/stubs.h \
    /usr/lib/gcc-lib/i486-suse-linux/2.95.3/include/stddef.h \
    /usr/include/bits/types.h /usr/include/bits/pthreadtypes.h \
    /usr/include/bits/sched.h /usr/include/libio.h \
    /usr/include/_G_config.h /usr/include/wchar.h \
    /usr/include/bits/wchar.h /usr/include/gconv.h \
    /usr/lib/gcc-lib/i486-suse-linux/2.95.3/include/stdarg.h \
    /usr/include/bits/stdio_lim.h


    gcc -MM main.c的输出则是:

    main.o: main.c defs.h

    那么,编译器的这个功能如何与我们的Makefile联系在一起呢。因为这样一来,我们的Ma
    kefile也要根据这些源文件重新生成,让Makefile 自已依赖于源文件?这个功能并不现实
    ,不过我们可以有其它手段来迂回地实现这一功能。GNU组织建议把编译器为每一个源文件
    的自动生成的依赖关系放到一个文件中,为每一个“name.c”的文件都生成一个“name.d
    ”的Makefile文件,[.d]文件中就存放对应[.c]文件的依赖关系

    于是,我们可以写出[.c]文件和[.d]文件的依赖关系,并让make自动更新或自成[.d]文件
    ,并把其包含在我们的主Makefile中,这样,我们就可以自动化地生成每个文件的依赖关
    系了。

    这里,我们给出了一个模式规则来产生[.d]文件:

    %.d: %.c
    @set -e; rm -f $@; \
    $(CC) -M $(CPPFLAGS) $< > $@.$$$$; \
    sed 's,\($*\)\.o[ :]*,\1.o $@ : ,g' < $@.$$$$ > $@; \
    rm -f $@.$$$$


    这个规则的意思是,所有的[.d]文件依赖于[.c]文件,“rm -f $@”的意思是删除所有的
    目标,也就是[.d]文件,第二行的意思是,为每个依赖文件“$<”,也就是[.c]文件生成
    依赖文件,“$@”表示模式 “%.d”文件,如果有一个C文件是name.c,那么“%”就是“
    name”,“$$$$”意为一个随机编号,第二行生成的文件有可能是 “name.d.12345”,第
    三行使用sed命令做了一个替换,关于sed命令的用法请参看相关的使用文档。第四行就是
    删除临时文件。

    总而言之,这个模式要做的事就是在编译器生成的依赖关系中加入[.d]文件的依赖,即把
    依赖关系:

    main.o : main.c defs.h

    转成:

    main.o main.d : main.c defs.h

    于是,我们的[.d]文件也会自动更新了,并会自动生成了,当然,你还可以在这个[.d]文
    件中加入的不只是依赖关系,包括生成的命令也可一并加入,让每个 [.d]文件都包含一个
    完赖的规则。一旦我们完成这个工作,接下来,我们就要把这些自动生成的规则放进我们
    的主Makefile中。我们可以使用 Makefile的“include”命令,来引入别的Makefile文件
    (前面讲过),例如:

    sources = foo.c bar.c

    include $(sources:.c=.d)

    上述语句中的“$(sources:.c=.d)”中的“.c=.d”的意思是做一个替换,把变量$(sourc
    es)所有[.c]的字串都替换成 [.d],关于这个“替换”的内容,在后面我会有更为详细的
    讲述。当然,你得注意次序,因为include是按次来载入文件,最先载入的[.d]文件中的目
    标会成为默认目标。



    书写命令
    ————

    每条规则中的命令和操作系统Shell的命令行是一致的。make会一按顺序一条一条的执行命
    令,每条命令的开头必须以[Tab]键开头,除非,命令是紧跟在依赖规则后面的分号后的。
    在命令行之间中的空格或是空行会被忽略,但是如果该空格或空行是以Tab键开头的,那么
    make会认为其是一个空命令。

    我们在UNIX下可能会使用不同的Shell,但是make的命令默认是被“/bin/sh”——UNIX的
    标准Shell解释执行的。除非你特别指定一个其它的Shell。Makefile中,“#”是注释符,
    很像C/C++中的“//”,其后的本行字符都被注释。

    一、显示命令

    通常,make会把其要执行的命令行在命令执行前输出到屏幕上。当我们用“@”字符在命令
    行前,那么,这个命令将不被make显示出来,最具代表性的例子是,我们用这个功能来像
    屏幕显示一些信息。如:

    @echo 正在编译XXX模块......

    当make执行时,会输出“正在编译XXX模块......”字串,但不会输出命令,如果没有“@
    ”,那么,make将输出:

    echo 正在编译XXX模块......
    正在编译XXX模块......

    如果make执行时,带入make参数“-n”或“--just-print”,那么其只是显示命令,但不
    会执行命令,这个功能很有利于我们调试我们的Makefile,看看我们书写的命令是执行起
    来是什么样子的或是什么顺序的。

    make参数“-s”或“--slient”则是全面禁止命令的显示



    二、命令执行

    当依赖目标新于目标时,也就是当规则的目标需要被更新时,make会一条一条的执行其后
    的命令。需要注意的是,如果你要让上一条命令的结果应用在下一条命令时,你应该使用
    分号分隔这两条命令。比如你的第一条命令是cd命令,你希望第二条命令得在cd之后的基
    础上运行,那么你就不能把这两条命令写在两行上,而应该把这两条命令写在一行上,用
    分号分隔。如:

    示例一:
    exec:
    cd /home/hchen
    pwd

    示例二:
    exec:
    cd /home/hchen; pwd

    当我们执行“make exec”时,第一个例子中的cd没有作用,pwd会打印出当前的Makefile
    目录,而第二个例子中,cd就起作用了,pwd会打印出“/home/hchen”。

    make 一般是使用环境变量SHELL中所定义的系统Shell来执行命令,默认情况下使用UNIX的
    标准Shell——/bin/sh来执行命令。但在MS- DOS下有点特殊,因为MS-DOS下没有SHELL环
    境变量,当然你也可以指定。如果你指定了UNIX风格的目录形式,首先,make会在SHELL所
    指定的路径中找寻命令解释器,如果找不到,其会在当前盘符中的当前目录中寻找,如果
    再找不到,其会在PATH环境变量中所定义的所有路径中寻找。MS- DOS中,如果你定义的命
    令解释器没有找到,其会给你的命令解释器加上诸如“.exe”、“.com”、“.bat”、“
    .sh”等后缀。



    三、命令出错

    每当命令运行完后,make会检测每个命令的返回码,如果命令返回成功,那么make会执行
    下一条命令,当规则中所有的命令成功返回后,这个规则就算是成功完成了。如果一个规
    则中的某个命令出错了(命令退出码非零),那么make就会终止执行当前规则,这将有可
    能终止所有规则的执行。

    有些时候,命令的出错并不表示就是错误的。例如mkdir命令,我们一定需要建立一个目录
    ,如果目录不存在,那么mkdir就成功执行,万事大吉,如果目录存在,那么就出错了。我
    们之所以使用mkdir的意思就是一定要有这样的一个目录,于是我们就不希望mkdir出错而
    终止规则的运行。

    为了做到这一点,忽略命令的出错,我们可以在Makefile的命令行前加一个减号“-”(在
    Tab键之后),标记为不管命令出不出错都认为是成功的。如:

    clean:
    -rm -f *.o

    还有一个全局的办法是,给make加上“-i”或是“--ignore-errors”参数,那么,Makef
    ile中所有命令都会忽略错误。而如果一个规则是以“.IGNORE”作为目标的,那么这个规
    则中的所有命令将会忽略错误。这些是不同级别的防止命令出错的方法,你可以根据你的
    不同喜欢设置。

    还有一个要提一下的make的参数的是“-k”或是“--keep-going”,这个参数的意思是,
    如果某规则中的命令出错了,那么就终目该规则的执行,但继续执行其它规则。



    四、嵌套执行make

    在一些大的工程中,我们会把我们不同模块或是不同功能的源文件放在不同的目录中,我
    们可以在每个目录中都书写一个该目录的Makefile,这有利于让我们的Makefile变得更加
    地简洁,而不至于把所有的东西全部写在一个Makefile中,这样会很难维护我们的Makefi
    le,这个技术对于我们模块编译和分段编译有着非常大的好处。

    例如,我们有一个子目录叫subdir,这个目录下有个Makefile文件,来指明了这个目录下
    文件的编译规则。那么我们总控的Makefile可以这样书写:

    subsystem:
    cd subdir && $(MAKE)

    其等价于:

    subsystem:
    $(MAKE) -C subdir

    定义$(MAKE)宏变量的意思是,也许我们的make需要一些参数,所以定义成一个变量比较利
    于维护。这两个例子的意思都是先进入“subdir”目录,然后执行make命令

    我们把这个Makefile叫做“总控Makefile”,总控Makefile的变量可以传递到下级的Make
    file中(如果你显示的声明),但是不会覆盖下层的Makefile中所定义的变量,除非指定
    了“-e”参数。

    如果你要传递变量到下级Makefile中,那么你可以使用这样的声明:

    export

    如果你不想让某些变量传递到下级Makefile中,那么你可以这样声明:

    unexport

    如:

    示例一:

    export variable = value

    其等价于:

    variable = value
    export variable

    其等价于:

    export variable := value

    其等价于:

    variable := value
    export variable

    示例二:

    export variable += value

    其等价于:

    variable += value
    export variable

    如果你要传递所有的变量,那么,只要一个export就行了。后面什么也不用跟,表示传递
    所有的变量。

    需要注意的是,有两个变量,一个是SHELL,一个是MAKEFLAGS,这两个变量不管你是否ex
    port,其总是要传递到下层Makefile中,特别是MAKEFILES变量,其中包含了make的参数信
    息,如果我们执行“总控Makefile”时有make参数或是在上层Makefile中定义了这个变量
    ,那么MAKEFILES变量将会是这些参数,并会传递到下层Makefile中,这是一个系统级的环
    境变量。

    但是make命令中的有几个参数并不往下传递,它们是“-C”,“-f”,“-h”“-o”和“-W
    ”(有关Makefile参数的细节将在后面说明),如果你不想往下层传递参数,那么,你可
    以这样来:

    subsystem:
    cd subdir && $(MAKE) MAKEFLAGS=

    如果你定义了环境变量MAKEFLAGS,那么你得确信其中的选项是大家都会用到的,如果其中
    有“-t”,“-n”,和“-q”参数,那么将会有让你意想不到的结果,或许会让你异常地恐
    慌。

    还有一个在“嵌套执行”中比较有用的参数,“-w”或是“--print-directory”会在mak
    e的过程中输出一些信息,让你看到目前的工作目录。比如,如果我们的下级make目录是“
    /home/hchen/gnu/make”,如果我们使用“make -w”来执行,那么当进入该目录时,我们
    会看到:

    make: Entering directory `/home/hchen/gnu/make'.

    而在完成下层make后离开目录时,我们会看到:

    make: Leaving directory `/home/hchen/gnu/make'

    当你使用“-C”参数来指定make下层Makefile时,“-w”会被自动打开的。如果参数中有
    “-s”(“--slient”)或是“--no-print-directory”,那么,“-w”总是失效的。




    五、定义命令包

    如果Makefile中出现一些相同命令序列,那么我们可以为这些相同的命令序列定义一个变
    量。定义这种命令序列的语法以“define”开始,以“endef”结束,如:

    define run-yacc
    yacc $(firstword $^)
    mv y.tab.c $@
    endef

    这里,“run-yacc”是这个命令包的名字,其不要和Makefile中的变量重名。在“define
    ”和“endef”中的两行就是命令序列。这个命令包中的第一个命令是运行Yacc程序,因为
    Yacc程序总是生成“y.tab.c”的文件,所以第二行的命令就是把这个文件改改名字。还是
    把这个命令包放到一个示例中来看看吧。

    foo.c : foo.y
    $(run-yacc)

    我们可以看见,要使用这个命令包,我们就好像使用变量一样。在这个命令包的使用中,
    命令包“run-yacc”中的“$^”就是“foo.y”,“$@”就是“foo.c”(有关这种以 “$
    ”开头的特殊变量,我们会在后面介绍),make在执行命令包时,命令包中的每个命令会
    被依次独立执行。

    使用变量
    ————

    在 Makefile中的定义的变量,就像是C/C++语言中的宏一样,他代表了一个文本字串,在
    Makefile中执行的时候其会自动原模原样地展开在所使用的地方。其与C/C++所不同的是,
    你可以在Makefile中改变其值。在Makefile中,变量可以使用在“目标”,“依赖目标”
    ,“命令”或是 Makefile的其它部分中。

    变量的命名字可以包含字符、数字,下划线(可以是数字开头),但不应该含有“:”、“
    #”、“=”或是空字符(空格、回车等)。变量是大小写敏感的,“foo”、“Foo”和“
    FOO”是三个不同的变量名。传统的Makefile的变量名是全大写的命名方式,但我推荐使用
    大小写搭配的变量名,如:MakeFlags。这样可以避免和系统的变量冲突,而发生意外的事
    情。

    有一些变量是很奇怪字串,如“$<”、“$@”等,这些是自动化变量,我会在后面介绍。


    一、变量的基础

    变量在声明时需要给予初值,而在使用时,需要给在变量名前加上“$”符号,但最好用小
    括号“()”或是大括号“{}”把变量给包括起来。如果你要使用真实的“$”字符,那么
    你需要用“$$”来表示。

    变量可以使用在许多地方,如规则中的“目标”、“依赖”、“命令”以及新的变量中。
    先看一个例子:

    objects = program.o foo.o utils.o
    program : $(objects)
    cc -o program $(objects)

    $(objects) : defs.h

    变量会在使用它的地方精确地展开,就像C/C++中的宏一样,例如:

    foo = c
    prog.o : prog.$(foo)
    $(foo)$(foo) -$(foo) prog.$(foo)

    展开后得到:

    prog.o : prog.c
    cc -c prog.c

    当然,千万不要在你的Makefile中这样干,这里只是举个例子来表明Makefile中的变量在
    使用处展开的真实样子。可见其就是一个“替代”的原理。

    另外,给变量加上括号完全是为了更加安全地使用这个变量,在上面的例子中,如果你不
    想给变量加上括号,那也可以,但我还是强烈建议你给变量加上括号。


    二、变量中的变量

    在定义变量的值时,我们可以使用其它变量来构造变量的值,在Makefile中有两种方式来
    在用变量定义变量的值。

    先看第一种方式,也就是简单的使用“=”号,在“=”左侧是变量,右侧是变量的值,右
    侧变量的值可以定义在文件的任何一处,也就是说,右侧中的变量不一定非要是已定义好
    的值,其也可以使用后面定义的值。如:

    foo = $(bar)
    bar = $(ugh)
    ugh = Huh?

    all:
    echo $(foo)

    我们执行“make all”将会打出变量$(foo)的值是“Huh?”( $(foo)的值是$(bar),$(b
    ar)的值是$(ugh),$(ugh)的值是“Huh?”)可见,变量是可以使用后面的变量来定义的。


    这个功能有好的地方,也有不好的地方,好的地方是,我们可以把变量的真实值推到后面
    来定义,如:

    CFLAGS = $(include_dirs) -O
    include_dirs = -Ifoo -Ibar

    当“CFLAGS”在命令中被展开时,会是“-Ifoo -Ibar -O”。但这种形式也有不好的地方
    ,那就是递归定义,如:

    CFLAGS = $(CFLAGS) -O

    或:

    A = $(B)
    B = $(A)

    这会让make陷入无限的变量展开过程中去,当然,我们的make是有能力检测这样的定义,
    并会报错。还有就是如果在变量中使用函数,那么,这种方式会让我们的make运行时非常
    慢,更糟糕的是,他会使用得两个make的函数“wildcard”和“shell”发生不可预知的错
    误。因为你不会知道这两个函数会被调用多少次。

    为了避免上面的这种方法,我们可以使用make中的另一种用变量来定义变量的方法。这种
    方法使用的是“:=”操作符,如:


    x := foo
    y := $(x) bar
    x := later

    其等价于:

    y := foo bar
    x := later

    值得一提的是,这种方法,前面的变量不能使用后面的变量,只能使用前面已定义好了的
    变量。如果是这样:

    y := $(x) bar
    x := foo

    那么,y的值是“bar”,而不是“foo bar”。

    上面都是一些比较简单的变量使用了,让我们来看一个复杂的例子,其中包括了make的函
    数、条件表达式和一个系统变量“MAKELEVEL”的使用:

    ifeq (0,${MAKELEVEL})
    cur-dir := $(shell pwd)
    whoami := $(shell whoami)
    host-type := $(shell arch)
    MAKE := ${MAKE} host-type=${host-type} whoami=${whoami}
    endif

    关于条件表达式和函数,我们在后面再说,对于系统变量“MAKELEVEL”,其意思是,如果
    我们的make有一个嵌套执行的动作(参见前面的“嵌套使用make”),那么,这个变量会
    记录了我们的当前Makefile的调用层数。

    下面再介绍两个定义变量时我们需要知道的,请先看一个例子,如果我们要定义一个变量
    ,其值是一个空格,那么我们可以这样来:

    nullstring :=
    space := $(nullstring) # end of the line

    nullstring 是一个Empty变量,其中什么也没有,而我们的space的值是一个空格。因为在
    操作符的右边是很难描述一个空格的,这里采用的技术很管用,先用一个 Empty变量来标
    明变量的值开始了,而后面采用“#”注释符来表示变量定义的终止,这样,我们可以定义
    出其值是一个空格的变量。请注意这里关于“#”的使用,注释符“#”的这种特性值得我
    们注意,如果我们这样定义一个变量:

    dir := /foo/bar # directory to put the frobs in

    dir这个变量的值是“/foo/bar”,后面还跟了4个空格,如果我们这样使用这样变量来指
    定别的目录——“$(dir)/file”那么就完蛋了。

    还有一个比较有用的操作符是“?=”,先看示例:

    FOO ?= bar

    其含义是,如果FOO没有被定义过,那么变量FOO的值就是“bar”,如果FOO先前被定义过
    ,那么这条语将什么也不做,其等价于:

    ifeq ($(origin FOO), undefined)
    FOO = bar
    endif


    三、变量高级用法

    这里介绍两种变量的高级使用方法,第一种是变量值的替换。

    我们可以替换变量中的共有的部分,其格式是“$(var:a=b)”或是“${var:a=b}”,其意
    思是,把变量“var”中所有以“a”字串“结尾”的“a”替换成“b”字串。这里的“结
    尾”意思是“空格”或是“结束符”。

    还是看一个示例吧:

    foo := a.o b.o c.o
    bar := $(foo:.o=.c)

    这个示例中,我们先定义了一个“$(foo)”变量,而第二行的意思是把“$(foo)”中所有
    以“.o”字串“结尾”全部替换成“.c”,所以我们的“$(bar)”的值就是“a.c b.c c.
    c”。

    另外一种变量替换的技术是以“静态模式”(参见前面章节)定义的,如:

    foo := a.o b.o c.o
    bar := $(foo:%.o=%.c)

    这依赖于被替换字串中的有相同的模式,模式中必须包含一个“%”字符,这个例子同样让
    $(bar)变量的值为“a.c b.c c.c”。

    第二种高级用法是——“把变量的值再当成变量”。先看一个例子:

    x = y
    y = z
    a := $($(x))

    在这个例子中,$(x)的值是“y”,所以$($(x))就是$(y),于是$(a)的值就是“z”。(注
    意,是“x=y”,而不是“x=$(y)”)

    我们还可以使用更多的层次:

    x = y
    y = z
    z = u
    a := $($($(x)))

    这里的$(a)的值是“u”,相关的推导留给读者自己去做吧。

    让我们再复杂一点,使用上“在变量定义中使用变量”的第一个方式,来看一个例子:


    x = $(y)
    y = z
    z = Hello
    a := $($(x))

    这里的$($(x))被替换成了$($(y)),因为$(y)值是“z”,所以,最终结果是:a:=$(z),
    也就是“Hello”。

    再复杂一点,我们再加上函数:

    x = variable1
    variable2 := Hello
    y = $(subst 1,2,$(x))
    z = y
    a := $($($(z)))

    这个例子中,“$($($(z)))”扩展为“$($(y))”,而其再次被扩展为“$($(subst 1,2,$
    (x)))”。$(x)的值是“variable1”,subst函数把“variable1”中的所有“1”字串替换
    成“2”字串,于是,“variable1”变成“variable2”,再取其值,所以,最终,$(a)的
    值就是$(variable2)的值—— “Hello”。(喔,好不容易)

    在这种方式中,或要可以使用多个变量来组成一个变量的名字,然后再取其值:

    first_second = Hello
    a = first
    b = second
    all = $($a_$b)

    这里的“$a_$b”组成了“first_second”,于是,$(all)的值就是“Hello”。

    再来看看结合第一种技术的例子:

    a_objects := a.o b.o c.o
    1_objects := 1.o 2.o 3.o

    sources := $($(a1)_objects:.o=.c)

    这个例子中,如果$(a1)的值是“a”的话,那么,$(sources)的值就是“a.c b.c c.c”;
    如果$(a1)的值是“1”,那么$(sources)的值是“1.c 2.c 3.c”。

    再来看一个这种技术和“函数”与“条件语句”一同使用的例子:

    ifdef do_sort
    func := sort
    else
    func := strip
    endif

    bar := a d b g q c

    foo := $($(func) $(bar))

    这个示例中,如果定义了“do_sort”,那么:foo := $(sort a d b g q c),于是$(foo
    )的值就是“a b c d g q”,而如果没有定义“do_sort”,那么:foo := $(sort a d b
    g q c),调用的就是strip函数。

    当然,“把变量的值再当成变量”这种技术,同样可以用在操作符的左边:

    dir = foo
    $(dir)_sources := $(wildcard $(dir)/*.c)
    define $(dir)_print
    lpr $($(dir)_sources)
    endef

    这个例子中定义了三个变量:“dir”,“foo_sources”和“foo_print”。


    四、追加变量值

    我们可以使用“+=”操作符给变量追加值,如:

    objects = main.o foo.o bar.o utils.o
    objects += another.o

    于是,我们的$(objects)值变成:“main.o foo.o bar.o utils.o another.o”(anothe
    r.o被追加进去了)

    使用“+=”操作符,可以模拟为下面的这种例子:

    objects = main.o foo.o bar.o utils.o
    objects := $(objects) another.o

    所不同的是,用“+=”更为简洁。

    如果变量之前没有定义过,那么,“+=”会自动变成“=”,如果前面有变量定义,那么“
    +=”会继承于前次操作的赋值符。如果前一次的是“:=”,那么“+=”会以“:=”作为其
    赋值符,如:

    variable := value
    variable += more

    等价于:

    variable := value
    variable := $(variable) more

    但如果是这种情况:

    variable = value
    variable += more

    由于前次的赋值符是“=”,所以“+=”也会以“=”来做为赋值,那么岂不会发生变量的
    递补归定义,这是很不好的,所以make会自动为我们解决这个问题,我们不必担心这个问
    题。


    五、override 指示符

    如果有变量是通常make的命令行参数设置的,那么Makefile中对这个变量的赋值会被忽略
    。如果你想在Makefile中设置这类参数的值,那么,你可以使用“override”指示符。其
    语法是:

    override =

    override :=

    当然,你还可以追加:

    override +=

    对于多行的变量定义,我们用define指示符,在define指示符前,也同样可以使用ovveri
    de指示符,如:

    override define foo
    bar
    endef

    六、多行变量

    还有一种设置变量值的方法是使用define关键字。使用define关键字设置变量的值可以有
    换行,这有利于定义一系列的命令(前面我们讲过“命令包”的技术就是利用这个关键字
    )。

    define 指示符后面跟的是变量的名字,而重起一行定义变量的值,定义是以endef关键字
    结束。其工作方式和“=”操作符一样。变量的值可以包含函数、命令、文字,或是其它变
    量。因为命令需要以[Tab]键开头,所以如果你用define定义的命令变量中没有以[Tab]键
    开头,那么make就不会把其认为是命令。

    下面的这个示例展示了define的用法:

    define two-lines
    echo foo
    echo $(bar)
    endef


    七、环境变量

    make 运行时的系统环境变量可以在make开始运行时被载入到Makefile文件中,但是如果M
    akefile中已定义了这个变量,或是这个变量由make命令行带入,那么系统的环境变量的值
    将被覆盖。(如果make指定了“-e”参数,那么,系统环境变量将覆盖Makefile中定义的
    变量)

    因此,如果我们在环境变量中设置了“CFLAGS”环境变量,那么我们就可以在所有的Make
    file中使用这个变量了。这对于我们使用统一的编译参数有比较大的好处。如果Makefile
    中定义了CFLAGS,那么则会使用Makefile中的这个变量,如果没有定义则使用系统环境变
    量的值,一个共性和个性的统一,很像“全局变量”和“局部变量”的特性。

    当make嵌套调用时(参见前面的“嵌套调用”章节),上层Makefile中定义的变量会以系
    统环境变量的方式传递到下层的Makefile中。当然,默认情况下,只有通过命令行设置的
    变量会被传递。而定义在文件中的变量,如果要向下层 Makefile传递,则需要使用expro
    t关键字来声明。(参见前面章节)

    当然,我并不推荐把许多的变量都定义在系统环境中,这样,在我们执行不用的Makefile
    时,拥有的是同一套系统变量,这可能会带来更多的麻烦。


    八、目标变量

    前面我们所讲的在Makefile中定义的变量都是“全局变量”,在整个文件,我们都可以访
    问这些变量。当然,“自动化变量”除外,如“$<”等这种类量的自动化变量就属于“规
    则型变量”,这种变量的值依赖于规则的目标和依赖目标的定义。

    当然,我样同样可以为某个目标设置局部变量,这种变量被称为“Target-specific Vari
    able”,它可以和“全局变量”同名,因为它的作用范围只在这条规则以及连带规则中,
    所以其值也只在作用范围内有效。而不会影响规则链以外的全局变量的值。

    其语法是:

    :

    : overide

    可以是前面讲过的各种赋值表达式,如“=”、“:=”、“+=”或
    是“?=”。第二个语法是针对于make命令行带入的变量,或是系统环境变量。

    这个特性非常的有用,当我们设置了这样一个变量,这个变量会作用到由这个目标所引发
    的所有的规则中去。如:

    prog : CFLAGS = -g
    prog : prog.o foo.o bar.o
    $(CC) $(CFLAGS) prog.o foo.o bar.o

    prog.o : prog.c
    $(CC) $(CFLAGS) prog.c

    foo.o : foo.c
    $(CC) $(CFLAGS) foo.c

    bar.o : bar.c
    $(CC) $(CFLAGS) bar.c

    在这个示例中,不管全局的$(CFLAGS)的值是什么,在prog目标,以及其所引发的所有规则
    中(prog.o foo.o bar.o的规则),$(CFLAGS)的值都是“-g”


    九、模式变量

    在GNU的make中,还支持模式变量(Pattern-specific Variable),通过上面的目标变量
    中,我们知道,变量可以定义在某个目标上。模式变量的好处就是,我们可以给定一种“
    模式”,可以把变量定义在符合这种模式的所有目标上。

    我们知道,make的“模式”一般是至少含有一个“%”的,所以,我们可以以如下方式给所
    有以[.o]结尾的目标定义目标变量:

    %.o : CFLAGS = -O

    同样,模式变量的语法和“目标变量”一样:

    :

    : override

    override同样是针对于系统环境传入的变量,或是make命令行指定的变量。

    使用条件判断
    ——————

    使用条件判断,可以让make根据运行时的不同情况选择不同的执行分支。条件表达式可以
    是比较变量的值,或是比较变量和常量的值。

    一、示例

    下面的例子,判断$(CC)变量是否“gcc”,如果是的话,则使用GNU函数编译目标。

    libs_for_gcc = -lgnu
    normal_libs =

    foo: $(objects)
    ifeq ($(CC),gcc)
    $(CC) -o foo $(objects) $(libs_for_gcc)
    else
    $(CC) -o foo $(objects) $(normal_libs)
    endif

    可见,在上面示例的这个规则中,目标“foo”可以根据变量“$(CC)”值来选取不同的函
    数库来编译程序。

    我们可以从上面的示例中看到三个关键字:ifeq、else和endif。ifeq的意思表示条件语句
    的开始,并指定一个条件表达式,表达式包含两个参数,以逗号分隔,表达式以圆括号括
    起。else表示条件表达式为假的情况。endif表示一个条件语句的结束,任何一个条件表达
    式都应该以endif结束。

    当我们的变量$(CC)值是“gcc”时,目标foo的规则是:

    foo: $(objects)
    $(CC) -o foo $(objects) $(libs_for_gcc)

    而当我们的变量$(CC)值不是“gcc”时(比如“cc”),目标foo的规则是:

    foo: $(objects)
    $(CC) -o foo $(objects) $(normal_libs)

    当然,我们还可以把上面的那个例子写得更简洁一些:

    libs_for_gcc = -lgnu
    normal_libs =

    ifeq ($(CC),gcc)
    libs=$(libs_for_gcc)
    else
    libs=$(normal_libs)
    endif

    foo: $(objects)
    $(CC) -o foo $(objects) $(libs)


    二、语法

    条件表达式的语法为:



    endif

    以及:



    else

    endif

    其中表示条件关键字,如“ifeq”。这个关键字有四个。

    第一个是我们前面所见过的“ifeq”

    ifeq (, )
    ifeq '' ''
    ifeq "" ""
    ifeq "" ''
    ifeq '' ""

    比较参数“arg1”和“arg2”的值是否相同。当然,参数中我们还可以使用make的函数。
    如:

    ifeq ($(strip $(foo)),)

    endif

    这个示例中使用了“strip”函数,如果这个函数的返回值是空(Empty),那么
    -empty>就生效。

    第二个条件关键字是“ifneq”。语法是:

    ifneq (, )
    ifneq '' ''
    ifneq "" ""
    ifneq "" ''
    ifneq '' ""

    其比较参数“arg1”和“arg2”的值是否相同,如果不同,则为真。和“ifeq”类似。


    第三个条件关键字是“ifdef”。语法是:

    ifdef

    如果变量的值非空,那到表达式为真。否则,表达式为假。当然,
    able-name>同样可以是一个函数的返回值。注意,ifdef只是测试一个变量是否有值,其并
    不会把变量扩展到当前位置。还是来看两个例子:

    示例一:
    bar =
    foo = $(bar)
    ifdef foo
    frobozz = yes
    else
    frobozz = no
    endif

    示例二:
    foo =
    ifdef foo
    frobozz = yes
    else
    frobozz = no
    endif

    第一个例子中,“$(frobozz)”值是“yes”,第二个则是“no”。

    第四个条件关键字是“ifndef”。其语法是:

    ifndef

    这个我就不多说了,和“ifdef”是相反的意思。

    在这一行上,多余的空格是被允许的,但是不能以[Tab]键做为
    开始(不然就被认为是命令)。而注释符“#”同样也是安全的。“else”和“endif”也
    一样,只要不是以[Tab]键开始就行了。

    特别注意的是,make是在读取Makefile时就计算条件表达式的值,并根据条件表达式的值
    来选择语句,所以,你最好不要把自动化变量(如“$@”等)放入条件表达式中,因为自
    动化变量是在运行时才有的。

    而且,为了避免混乱,make不允许把整个条件语句分成两部分放在不同的文件中。



    使用函数
    ————

    在Makefile中可以使用函数来处理变量,从而让我们的命令或是规则更为的灵活和具有智
    能。make所支持的函数也不算很多,不过已经足够我们的操作了。函数调用后,函数的返
    回值可以当做变量来使用。


    一、函数的调用语法

    函数调用,很像变量的使用,也是以“$”来标识的,其语法如下:

    $( )

    或是

    ${ }

    这里,就是函数名,make支持的函数不多。是函数的参数,参数间
    以逗号“,”分隔,而函数名和参数之间以“空格”分隔。函数调用以“$”开头,以圆括
    号或花括号把函数名和参数括起。感觉很像一个变量,是不是?函数中的参数可以使用变
    量,为了风格的统一,函数和变量的括号最好一样,如使用“$(subst a,b,$(x))”这样的
    形式,而不是“$(subst a,b,${x})”的形式。因为统一会更清楚,也会减少一些不必要的
    麻烦。

    还是来看一个示例:

    comma:= ,
    empty:=
    space:= $(empty) $(empty)
    foo:= a b c
    bar:= $(subst $(space),$(comma),$(foo))

    在这个示例中,$(comma)的值是一个逗号。$(space)使用了$(empty)定义了一个空格,$(
    foo)的值是“a b c”,$(bar)的定义用,调用了函数“subst”,这是一个替换函数,这
    个函数有三个参数,第一个参数是被替换字串,第二个参数是替换字串,第三个参数是替
    换操作作用的字串。这个函数也就是把$(foo)中的空格替换成逗号,所以$(bar)的值是“
    a,b,c”。


    二、字符串处理函数

    $(subst ,, )

    名称:字符串替换函数——subst。
    功能:把字串中的字符串替换成。
    返回:函数返回被替换过后的字符串。

    示例:

    $(subst ee,EE,feet on the street),

    把“feet on the street”中的“ee”替换成“EE”,返回结果是“fEEt on the strEEt
    ”。


    $(patsubst ,, )

    名称:模式字符串替换函数——patsubst。
    功能:查找中的单词(单词以“空格”、“Tab”或“回车”“换行”分隔)是否符
    合模式,如果匹配的话,则以替换。这里,可以包括通
    配符“%”,表示任意长度的字串。如果中也包含“%”,那么,
    ent>中的这个“%”将是中的那个“%”所代表的字串。(可以用“\”来转义,
    以“\%”来表示真实含义的“%”字符)
    返回:函数返回被替换过后的字符串。

    示例:

    $(patsubst %.c,%.o,x.c.c bar.c)

    把字串“x.c.c bar.c”符合模式[%.c]的单词替换成[%.o],返回结果是“x.c.o bar.o”


    备注:

    这和我们前面“变量章节”说过的相关知识有点相似。如:

    “$(var:= )”
    相当于
    “$(patsubst ,,$(var))”,

    而“$(var: = )”
    则相当于
    “$(patsubst %,%,$(var))”。

    例如有:objects = foo.o bar.o baz.o,
    那么,“$(objects:.o=.c)”和“$(patsubst %.o,%.c,$(objects))”是一样的。

    $(strip )

    名称:去空格函数——strip。
    功能:去掉字串中开头和结尾的空字符。
    返回:返回被去掉空格的字符串值。
    示例:

    $(strip a b c )

    把字串“a b c ”去到开头和结尾的空格,结果是“a b c”。

    $(findstring , )

    名称:查找字符串函数——findstring。
    功能:在字串中查找字串。
    返回:如果找到,那么返回,否则返回空字符串。
    示例:

    $(findstring a,a b c)
    $(findstring a,b c)

    第一个函数返回“a”字符串,第二个返回“”字符串(空字符串)

    $(filter , )

    名称:过滤函数——filter。
    功能:以模式过滤字符串中的单词,保留符合模式的单词。可
    以有多个模式。
    返回:返回符合模式的字串。
    示例:

    sources := foo.c bar.c baz.s ugh.h
    foo: $(sources)
    cc $(filter %.c %.s,$(sources)) -o foo

    $(filter %.c %.s,$(sources))返回的值是“foo.c bar.c baz.s”。

    $(filter-out , )

    名称:反过滤函数——filter-out。
    功能:以模式过滤字符串中的单词,去除符合模式的单词。可
    以有多个模式。
    返回:返回不符合模式的字串。
    示例:

    objects=main1.o foo.o main2.o bar.o
    mains=main1.o main2.o

    $(filter-out $(mains),$(objects)) 返回值是“foo.o bar.o”。

    $(sort )

    名称:排序函数——sort。
    功能:给字符串中的单词排序(升序)。
    返回:返回排序后的字符串。
    示例:$(sort foo bar lose)返回“bar foo lose” 。
    备注:sort函数会去掉中相同的单词。

    $(word , )

    名称:取单词函数——word。
    功能:取字符串中第个单词。(从一开始)
    返回:返回字符串中第个单词。如果比中的单词数要大,那么返回空
    字符串。
    示例:$(word 2, foo bar baz)返回值是“bar”。

    $(wordlist ,, )

    名称:取单词串函数——wordlist。
    功能:从字符串中取从开始到的单词串。和是一个数字。
    返回:返回字符串中从到的单词字串。如果比中的单词数要大,那
    么返回空字符串。如果大于的单词数,那么返回从开始,到结束的单
    词串。
    示例: $(wordlist 2, 3, foo bar baz)返回值是“bar baz”。

    $(words )

    名称:单词个数统计函数——words。
    功能:统计中字符串中的单词个数。
    返回:返回中的单词数。
    示例:$(words, foo bar baz)返回值是“3”。
    备注:如果我们要取中最后的一个单词,我们可以这样:$(word $(words  
    ), )。

    $(firstword )

    名称:首单词函数——firstword。
    功能:取字符串中的第一个单词。
    返回:返回字符串的第一个单词。
    示例:$(firstword foo bar)返回值是“foo”。
    备注:这个函数可以用word函数来实现:$(word 1, )。

    以上,是所有的字符串操作函数,如果搭配混合使用,可以完成比较复杂的功能。这里,
    举一个现实中应用的例子。我们知道,make使用“VPATH”变量来指定“依赖文件”的搜索
    路径。于是,我们可以利用这个搜索路径来指定编译器对头文件的搜索路径参数CFLAGS,
    如:

    override CFLAGS += $(patsubst %,-I%,$(subst :, ,$(VPATH)))

    如果我们的“$(VPATH)”值是“src:../headers”,那么“$(patsubst %,-I%,$(subst :
    , ,$(VPATH)))”将返回“-Isrc -I../headers”,这正是cc或gcc搜索头文件路径的参数



    三、文件名操作函数

    下面我们要介绍的函数主要是处理文件名的。每个函数的参数字符串都会被当做一个或是
    一系列的文件名来对待。

    $(dir )

    名称:取目录函数——dir。
    功能:从文件名序列中取出目录部分。目录部分是指最后一个反斜杠(“/”)之
    前的部分。如果没有反斜杠,那么返回“./”。
    返回:返回文件名序列的目录部分。
    示例: $(dir src/foo.c hacks)返回值是“src/ ./”。

    $(notdir )

    名称:取文件函数——notdir。
    功能:从文件名序列中取出非目录部分。非目录部分是指最后一个反斜杠(“/”
    )之后的部分。
    返回:返回文件名序列的非目录部分。
    示例: $(notdir src/foo.c hacks)返回值是“foo.c hacks”。

    $(suffix )

    名称:取后缀函数——suffix。
    功能:从文件名序列中取出各个文件名的后缀。
    返回:返回文件名序列的后缀序列,如果文件没有后缀,则返回空字串。
    示例:$(suffix src/foo.c src-1.0/bar.c hacks)返回值是“.c .c”。

    $(basename )

    名称:取前缀函数——basename。
    功能:从文件名序列中取出各个文件名的前缀部分。
    返回:返回文件名序列的前缀序列,如果文件没有前缀,则返回空字串。
    示例:$(basename src/foo.c src-1.0/bar.c hacks)返回值是“src/foo src-1.0/bar h
    acks”。

    $(addsuffix , )

    名称:加后缀函数——addsuffix。
    功能:把后缀加到中的每个单词后面。
    返回:返回加过后缀的文件名序列。
    示例:$(addsuffix .c,foo bar)返回值是“foo.c bar.c”。

    $(addprefix , )

    名称:加前缀函数——addprefix。
    功能:把前缀加到中的每个单词后面。
    返回:返回加过前缀的文件名序列。
    示例:$(addprefix src/,foo bar)返回值是“src/foo src/bar”。

    $(join , )

    名称:连接函数——join。
    功能:把中的单词对应地加到的单词后面。如果的单词个数要比<</span>
    list2>的多,那么,中的多出来的单词将保持原样。如果的单词个数要比
    多,那么,多出来的单词将被复制到中。
    返回:返回连接过后的字符串。
    示例:$(join aaa bbb , 111 222 333)返回值是“aaa111 bbb222 333”。



    四、foreach 函数


    foreach 函数和别的函数非常的不一样。因为这个函数是用来做循环用的,Makefile中的
    foreach函数几乎是仿照于Unix标准Shell(/bin /sh)中的for语句,或是C-Shell(/bin
    /csh)中的foreach语句而构建的。它的语法是:



    $(foreach ,, )



    这个函数的意思是,把参数中的单词逐一取出放到参数所指定的变量中,然后
    再执行所包含的表达式。每一次会返回一个字符串,循环过程中,的
    所返回的每个字符串会以空格分隔,最后当整个循环结束时,所返回的每个字符串
    所组成的整个字符串(以空格分隔)将会是foreach函数的返回值。



    所以,最好是一个变量名,可以是一个表达式,而中一般会使用
    这个参数来依次枚举中的单词。举个例子:



    names := a b c d

    files := $(foreach n,$(names),$(n).o)



    上面的例子中,$(name)中的单词会被挨个取出,并存到变量“n”中,“$(n).o”每次根
    据“$(n)”计算出一个值,这些值以空格分隔,最后作为foreach函数的返回,所以,$(f
    iles)的值是“a.o b.o c.o d.o”。



    注意,foreach中的参数是一个临时的局部变量,foreach函数执行完后,参数
    的变量将不在作用,其作用域只在foreach函数当中。





    五、if 函数


    if函数很像GNU的make所支持的条件语句——ifeq(参见前面所述的章节),if函数的语法
    是:



    $(if , )



    或是



    $(if ,, )



    可见,if函数可以包含“else”部分,或是不含。即if函数的参数可以是两个,也可以是
    三个。参数是if的表达式,如果其返回的为非空字符串,那么这个表达式就相
    当于返回真,于是,会被计算,否则 会被计算。



    而if函数的返回值是,如果为真(非空字符串),那个会是整个
    函数的返回值,如果为假(空字符串),那么会是整个函数的返
    回值,此时如果没有被定义,那么,整个函数返回空字串。



    所以,和只会有一个被计算。





    六、call函数


    call函数是唯一一个可以用来创建新的参数化的函数。你可以写一个非常复杂的表达式,
    这个表达式中,你可以定义许多参数,然后你可以用call函数来向这个表达式传递参数。
    其语法是:



    $(call ,,,...)



    当 make执行这个函数时,参数中的变量,如$(1),$(2),$(3)等,会被参数
    ,,依次取代。而的返回值就是 call函数的返回值
    。例如:

    reverse = $(1) $(2)

    foo = $(call reverse,a,b)



    那么,foo的值就是“a b”。当然,参数的次序是可以自定义的,不一定是顺序的,如:




    reverse = $(2) $(1)

    foo = $(call reverse,a,b)



    此时的foo的值就是“b a”。





    七、origin函数
    origin函数不像其它的函数,他并不操作变量的值,他只是告诉你你的这个变量是哪里来
    的?其语法是:



    $(origin )



    注意,是变量的名字,不应该是引用。所以你最好不要在中使用“
    $”字符。Origin函数会以其返回值来告诉你这个变量的“出生情况”,下面,是origin函
    数的返回值:



    “undefined”

    如果从来没有定义过,origin函数返回这个值“undefined”。



    “default”

    如果是一个默认的定义,比如“CC”这个变量,这种变量我们将在后面讲述。




    “environment”

    如果是一个环境变量,并且当Makefile被执行时,“-e”参数没有被打开。




    “file”

    如果这个变量被定义在Makefile中。



    “command line”

    如果这个变量是被命令行定义的。



    “override”

    如果是被override指示符重新定义的。



    “automatic”

    如果是一个命令运行中的自动化变量。关于自动化变量将在后面讲述。



    这些信息对于我们编写Makefile是非常有用的,例如,假设我们有一个Makefile其包了一
    个定义文件Make.def,在Make.def中定义了一个变量“bletch”,而我们的环境中也有一
    个环境变量“bletch”,此时,我们想判断一下,如果变量来源于环境,那么我们就把之
    重定义了,如果来源于Make.def或是命令行等非环境的,那么我们就不重新定义它。于是
    ,在我们的Makefile中,我们可以这样写:



    ifdef bletch

    ifeq "$(origin bletch)" "environment"

    bletch = barf, gag, etc.

    endif

    endif



    当然,你也许会说,使用override关键字不就可以重新定义环境中的变量了吗?为什么需
    要使用这样的步骤?是的,我们用override是可以达到这样的效果,可是override过于粗
    暴,它同时会把从命令行定义的变量也覆盖了,而我们只想重新定义环境传来的,而不想
    重新定义命令行传来的。





    八、shell函数


    shell 函数也不像其它的函数。顾名思义,它的参数应该就是操作系统Shell的命令。它和
    反引号“`”是相同的功能。这就是说,shell函数把执行操作系统命令后的输出作为函数
    返回。于是,我们可以用操作系统命令以及字符串处理命令awk,sed等等命令来生成一个
    变量,如:



    contents := $(shell cat foo)



    files := $(shell echo *.c)



    注意,这个函数会新生成一个Shell程序来执行命令,所以你要注意其运行性能,如果你的
    Makefile中有一些比较复杂的规则,并大量使用了这个函数,那么对于你的系统性能是有
    害的。特别是Makefile的隐晦的规则可能会让你的shell函数执行的次数比你想像的多得多






    九、控制make的函数


    make提供了一些函数来控制make的运行。通常,你需要检测一些运行Makefile时的运行时
    信息,并且根据这些信息来决定,你是让make继续执行,还是停止。



    $(error )



    产生一个致命的错误,是错误信息。注意,error函数不会在一被使用就会产生
    错误信息,所以如果你把其定义在某个变量中,并在后续的脚本中使用这个变量,那么也
    是可以的。例如:



    示例一:

    ifdef ERROR_001

    $(error error is $(ERROR_001))

    endif



    示例二:

    ERR = $(error found an error!)

    .PHONY: err

    err: ; $(ERR)



    示例一会在变量ERROR_001定义了后执行时产生error调用,而示例二则在目录err被执行时
    才发生error调用。



    $(warning )



    这个函数很像error函数,只是它并不会让make退出,只是输出一段警告信息,而make继续
    执行。

    make 的运行
    ——————

    一般来说,最简单的就是直接在命令行下输入make命令,make命令会找当前目录的makefi
    le来执行,一切都是自动的。但也有时你也许只想让 make重编译某些文件,而不是整个工
    程,而又有的时候你有几套编译规则,你想在不同的时候使用不同的编译规则,等等。本
    章节就是讲述如何使用make命令的。

    一、make的退出码

    make命令执行后有三个退出码:

    0 —— 表示成功执行。
    1 —— 如果make运行时出现任何错误,其返回1。
    2 —— 如果你使用了make的“-q”选项,并且make使得一些目标不需要更新,那么返回2


    Make的相关参数我们会在后续章节中讲述。


    二、指定Makefile

    前面我们说过,GNU make找寻默认的Makefile的规则是在当前目录下依次找三个文件——
    “GNUmakefile”、“makefile”和“Makefile”。其按顺序找这三个文件,一旦找到,就
    开始读取这个文件并执行。

    当前,我们也可以给make命令指定一个特殊名字的Makefile。要达到这个功能,我们要使
    用make的“-f”或是“--file”参数(“-- makefile”参数也行)。例如,我们有个mak
    efile的名字是“hchen.mk”,那么,我们可以这样来让make来执行这个文件:

    make –f hchen.mk

    如果在make的命令行是,你不只一次地使用了“-f”参数,那么,所有指定的makefile将
    会被连在一起传递给make执行。


    三、指定目标

    一般来说,make的最终目标是makefile中的第一个目标,而其它目标一般是由这个目标连
    带出来的。这是make的默认行为。当然,一般来说,你的 makefile中的第一个目标是由许
    多个目标组成,你可以指示make,让其完成你所指定的目标。要达到这一目的很简单,需
    在make命令后直接跟目标的名字就可以完成(如前面提到的“make clean”形式)

    任何在makefile中的目标都可以被指定成终极目标,但是除了以“- ”打头,或是包含了
    “=”的目标,因为有这些字符的目标,会被解析成命令行参数或是变量。甚至没有被我们
    明确写出来的目标也可以成为make的终极目标,也就是说,只要make可以找到其隐含规则
    推导规则,那么这个隐含目标同样可以被指定成终极目标。

    有一个make的环境变量叫“MAKECMDGOALS”,这个变量中会存放你所指定的终极目标的列
    表,如果在命令行上,你没有指定目标,那么,这个变量是空值。这个变量可以让你使用
    在一些比较特殊的情形下。比如下面的例子:

    sources = foo.c bar.c
    ifneq ( $(MAKECMDGOALS),clean)
    include $(sources:.c=.d)
    endif

    基于上面的这个例子,只要我们输入的命令不是“make clean”,那么makefile会自动包
    含“foo.d”和“bar.d”这两个makefile。

    使用指定终极目标的方法可以很方便地让我们编译我们的程序,例如下面这个例子:

    .PHONY: all
    all: prog1 prog2 prog3 prog4

    从这个例子中,我们可以看到,这个makefile中有四个需要编译的程序——“prog1”, 
    “prog2”, “prog3”和 “prog4”,我们可以使用“make all”命令来编译所有的目标
    (如果把all置成第一个目标,那么只需执行“make”),我们也可以使用“make prog2”
    来单独编译目标“prog2”。

    即然make可以指定所有makefile中的目标,那么也包括“伪目标”,于是我们可以根据这
    种性质来让我们的makefile根据指定的不同的目标来完成不同的事。在Unix世界中,软件
    发布时,特别是GNU这种开源软件的发布时,其 makefile都包含了编译、安装、打包等功
    能。我们可以参照这种规则来书写我们的makefile中的目标。

    “all”
    这个伪目标是所有目标的目标,其功能一般是编译所有的目标。
    “clean”
    这个伪目标功能是删除所有被make创建的文件。
    “install”
    这个伪目标功能是安装已编译好的程序,其实就是把目标执行文件拷贝到指定的目标中去

    “print”
    这个伪目标的功能是例出改变过的源文件。
    “tar”
    这个伪目标功能是把源程序打包备份。也就是一个tar文件。
    “dist”
    这个伪目标功能是创建一个压缩文件,一般是把tar文件压成Z文件。或是gz文件。
    “TAGS”
    这个伪目标功能是更新所有的目标,以备完整地重编译使用。
    “check”和“test”
    这两个伪目标一般用来测试makefile的流程。


    当然一个项目的makefile中也不一定要书写这样的目标,这些东西都是GNU的东西,但是我
    想,GNU搞出这些东西一定有其可取之处(等你的UNIX下的程序文件一多时你就会发现这些
    功能很有用了),这里只不过是说明了,如果你要书写这种功能,最好使用这种名字命名
    你的目标,这样规范一些,规范的好处就是——不用解释,大家都明白。而且如果你的ma
    kefile中有这些功能,一是很实用,二是可以显得你的makefile很专业(不是那种初学者
    的作品)。


    四、检查规则

    有时候,我们不想让我们的makefile中的规则执行起来,我们只想检查一下我们的命令,
    或是执行的序列。于是我们可以使用make命令的下述参数:

    “-n”
    “--just-print”
    “--dry-run”
    “--recon”

    不执行参数,这些参数只是打印命令,不管目标是否更新,把规则和连带规则下的命令打
    印出来,但不执行,这些参数对于我们调试makefile很有用处。

    “-t”
    “--touch”
    这个参数的意思就是把目标文件的时间更新,但不更改目标文件。也就是说,make假装编
    译目标,但不是真正的编译目标,只是把目标变成已编译过的状态。

    “-q”
    “--question”
    这个参数的行为是找目标的意思,也就是说,如果目标存在,那么其什么也不会输出,当
    然也不会执行编译,如果目标不存在,其会打印出一条出错信息。

    “-W ”
    “--what-if=”
    “--assume-new=”
    “--new-file=”
    这个参数需要指定一个文件。一般是是源文件(或依赖文件),Make会根据规则推导来运
    行依赖于这个文件的命令,一般来说,可以和“-n”参数一同使用,来查看这个依赖文件
    所发生的规则命令。

    另外一个很有意思的用法是结合“-p”和“-v”来输出makefile被执行时的信息(这个将
    在后面讲述)。


    五、make的参数

    下面列举了所有GNU make 3.80版的参数定义。其它版本和产商的make大同小异,不过其它
    产商的make的具体参数还是请参考各自的产品文档。

    “-b”
    “-m”
    这两个参数的作用是忽略和其它版本make的兼容性。

    “-B”
    “--always-make”
    认为所有的目标都需要更新(重编译)。

    “-C


    “--directory=

    指定读取makefile的目录。如果有多个“-C”参数,make的解释是后面的路径以前面的作
    为相对路径,并以最后的目录作为被指定目录。如:“make –C ~hchen/test –C prog”
    等价于“make –C ~hchen/test/prog”。

    “—debug[=]”
    输出make的调试信息。它有几种不同的级别可供选择,如果没有参数,那就是输出最简单
    的调试信息。下面是的取值:
    a —— 也就是all,输出所有的调试信息。(会非常的多)
    b —— 也就是basic,只输出简单的调试信息。即输出不需要重编译的目标。
    v —— 也就是verbose,在b选项的级别之上。输出的信息包括哪个makefile被解析,不需
    要被重编译的依赖文件(或是依赖目标)等。
    i —— 也就是implicit,输出所以的隐含规则。
    j —— 也就是jobs,输出执行规则中命令的详细信息,如命令的PID、返回码等。
    m —— 也就是makefile,输出make读取makefile,更新makefile,执行makefile的信息。


    “-d”
    相当于“--debug=a”。

    “-e”
    “--environment-overrides”
    指明环境变量的值覆盖makefile中定义的变量的值。

    “-f=”
    “--file=”
    “--makefile=”
    指定需要执行的makefile。

    “-h”
    “--help”
    显示帮助信息。

    “-i”
    “--ignore-errors”
    在执行时忽略所有的错误。

    “-I

    “--include-dir=

    指定一个被包含makefile的搜索目标。可以使用多个“-I”参数来指定多个目录。

    “-j []”
    “--jobs[=]”
    指同时运行命令的个数。如果没有这个参数,make运行命令时能运行多少就运行多少。如
    果有一个以上的“-j”参数,那么仅最后一个“-j”才是有效的。(注意这个参数在MS-D
    OS中是无用的)

    “-k”
    “--keep-going”
    出错也不停止运行。如果生成一个目标失败了,那么依赖于其上的目标就不会被执行了。


    “-l ”
    “--load-average[=
    “—max-load[=]”
    指定make运行命令的负载。

    “-n”
    “--just-print”
    “--dry-run”
    “--recon”
    仅输出执行过程中的命令序列,但并不执行。

    “-o ”
    “--old-file=”
    “--assume-old=”
    不重新生成的指定的,即使这个目标的依赖文件新于它。

    “-p”
    “--print-data-base”
    输出makefile中的所有数据,包括所有的规则和变量。这个参数会让一个简单的makefile
    都会输出一堆信息。如果你只是想输出信息而不想执行 makefile,你可以使用“make -q
    p”命令。如果你想查看执行makefile前的预设变量和规则,你可以使用“make –p –f 
    /dev/null”。这个参数输出的信息会包含着你的makefile文件的文件名和行号,所以,用
    这个参数来调试你的makefile会是很有用的,特别是当你的环境变量很复杂的时候。

    “-q”
    “--question”
    不运行命令,也不输出。仅仅是检查所指定的目标是否需要更新。如果是0则说明要更新,
    如果是2则说明有错误发生。

    “-r”
    “--no-builtin-rules”
    禁止make使用任何隐含规则。

    “-R”
    “--no-builtin-variabes”
    禁止make使用任何作用于变量上的隐含规则。

    “-s”
    “--silent”
    “--quiet”
    在命令运行时不输出命令的输出。

    “-S”
    “--no-keep-going”
    “--stop”
    取消“-k”选项的作用。因为有些时候,make的选项是从环境变量“MAKEFLAGS”中继承下
    来的。所以你可以在命令行中使用这个参数来让环境变量中的“-k”选项失效。

    “-t”
    “--touch”
    相当于UNIX的touch命令,只是把目标的修改日期变成最新的,也就是阻止生成目标的命令
    运行。

    “-v”
    “--version”
    输出make程序的版本、版权等关于make的信息。

    “-w”
    “--print-directory”
    输出运行makefile之前和之后的信息。这个参数对于跟踪嵌套式调用make时很有用。

    “--no-print-directory”
    禁止“-w”选项。

    “-W ”
    “--what-if=”
    “--new-file=”
    “--assume-file=”
    假定目标需要更新,如果和“-n”选项使用,那么这个参数会输出该目标更新时的
    运行动作。如果没有“-n”那么就像运行UNIX的“touch”命令一样,使得的修改时
    间为当前时间。

    “--warn-undefined-variables”
    只要make发现有未定义的变量,那么就输出警告信息。

    隐含规则
    ————

    在我们使用Makefile时,有一些我们会经常使用,而且使用频率非常高的东西,比如,我
    们编译C/C++的源程序为中间目标文件(Unix下是[.o] 文件,Windows下是[.obj]文件)。
    本章讲述的就是一些在Makefile中的“隐含的”,早先约定了的,不需要我们再写出来的
    规则。

    “隐含规则”也就是一种惯例,make会按照这种“惯例”心照不喧地来运行,那怕我们的
    Makefile中没有书写这样的规则。例如,把[.c]文件编译成[.o]文件这一规则,你根本就
    不用写出来,make会自动推导出这种规则,并生成我们需要的[.o]文件。

    “隐含规则”会使用一些我们系统变量,我们可以改变这些系统变量的值来定制隐含规则
    的运行时的参数。如系统变量“CFLAGS”可以控制编译时的编译器参数。

    我们还可以通过“模式规则”的方式写下自己的隐含规则。用“后缀规则”来定义隐含规
    则会有许多的限制。使用“模式规则”会更回得智能和清楚,但“后缀规则”可以用来保
    证我们Makefile的兼容性。
    我们了解了“隐含规则”,可以让其为我们更好的服务,也会让我们知道一些“约定俗成
    ”了的东西,而不至于使得我们在运行Makefile时出现一些我们觉得莫名其妙的东西。当
    然,任何事物都是矛盾的,水能载舟,亦可覆舟,所以,有时候“隐含规则”也会给我们
    造成不小的麻烦。只有了解了它,我们才能更好地使用它。


    一、使用隐含规则

    如果要使用隐含规则生成你需要的目标,你所需要做的就是不要写出这个目标的规则。那
    么,make会试图去自动推导产生这个目标的规则和命令,如果make可以自动推导生成这个
    目标的规则和命令,那么这个行为就是隐含规则的自动推导。当然,隐含规则是make事先
    约定好的一些东西。例如,我们有下面的一个Makefile:

    foo : foo.o bar.o
    cc –o foo foo.o bar.o $(CFLAGS) $(LDFLAGS)

    我们可以注意到,这个Makefile中并没有写下如何生成foo.o和bar.o这两目标的规则和命
    令。因为make的“隐含规则”功能会自动为我们自动去推导这两个目标的依赖目标和生成
    命令。

    make 会在自己的“隐含规则”库中寻找可以用的规则,如果找到,那么就会使用。如果找
    不到,那么就会报错。在上面的那个例子中,make调用的隐含规则是,把 [.o]的目标的依
    赖文件置成[.c],并使用C的编译命令“cc –c $(CFLAGS) [.c]”来生成[.o]的目标。也
    就是说,我们完全没有必要写下下面的两条规则:

    foo.o : foo.c
    cc –c foo.c $(CFLAGS)
    bar.o : bar.c
    cc –c bar.c $(CFLAGS)


    因为,这已经是“约定”好了的事了,make和我们约定好了用C编译器“cc”生成[.o]文件
    的规则,这就是隐含规则。

    当然,如果我们为[.o]文件书写了自己的规则,那么make就不会自动推导并调用隐含规则
    ,它会按照我们写好的规则忠实地执行。

    还有,在make的“隐含规则库”中,每一条隐含规则都在库中有其顺序,越靠前的则是越
    被经常使用的,所以,这会导致我们有些时候即使我们显示地指定了目标依赖,make也不
    会管。如下面这条规则(没有命令):

    foo.o : foo.p

    依赖文件“foo.p”(Pascal程序的源文件)有可能变得没有意义。如果目录下存在了“f
    oo.c”文件,那么我们的隐含规则一样会生效,并会通过 “foo.c”调用C的编译器生成f
    oo.o文件。因为,在隐含规则中,Pascal的规则出现在C的规则之后,所以,make找到可以
    生成foo.o的 C的规则就不再寻找下一条规则了。如果你确实不希望任何隐含规则推导,那
    么,你就不要只写出“依赖规则”,而不写命令。


    二、隐含规则一览

    这里我们将讲述所有预先设置(也就是make内建)的隐含规则,如果我们不明确地写下规
    则,那么,make就会在这些规则中寻找所需要规则和命令。当然,我们也可以使用make的
    参数“-r”或“--no-builtin-rules”选项来取消所有的预设置的隐含规则。

    当然,即使是我们指定了“-r”参数,某些隐含规则还是会生效,因为有许多的隐含规则
    都是使用了“后缀规则”来定义的,所以,只要隐含规则中有“后缀列表 ”(也就一系统
    定义在目标.SUFFIXES的依赖目标),那么隐含规则就会生效。默认的后缀列表是:.out,
    .a, .ln, .o, .c, .cc, .C, .p, .f, .F, .r, .y, .l, .s, .S, .mod, .sym, .def, .
    h, .info, .dvi, .tex, .texinfo, .texi, .txinfo, .w, .ch .web, .sh, .elc, .el。
    具体的细节,我们会在后面讲述。

    还是先来看一看常用的隐含规则吧。

    1、编译C程序的隐含规则。
    “.o”的目标的依赖目标会自动推导为“.c”,并且其生成命令是“$(CC) –c $(
    CPPFLAGS) $(CFLAGS)”

    2、编译C++程序的隐含规则。
    “.o” 的目标的依赖目标会自动推导为“.cc”或是“.C”,并且其生成命令是
    “$(CXX) –c $(CPPFLAGS) $(CFLAGS)”。(建议使用“.cc”作为C++源文件的后缀,而
    不是“.C”

    3、编译Pascal程序的隐含规则。
    “.o”的目标的依赖目标会自动推导为“.p”,并且其生成命令是“$(PC) –c $(
    PFLAGS)”。

    4、编译Fortran/Ratfor程序的隐含规则。
    “.o”的目标的依赖目标会自动推导为“.r”或“.F”或“.f”,并且其生
    成命令是:
    “.f” “$(FC) –c $(FFLAGS)”
    “.F” “$(FC) –c $(FFLAGS) $(CPPFLAGS)”
    “.f” “$(FC) –c $(FFLAGS) $(RFLAGS)”

    5、预处理Fortran/Ratfor程序的隐含规则。
    “.f”的目标的依赖目标会自动推导为“.r”或“.F”。这个规则只是转换Rat
    for或有预处理的Fortran程序到一个标准的Fortran程序。其使用的命令是:
    “.F” “$(FC) –F $(CPPFLAGS) $(FFLAGS)”
    “.r” “$(FC) –F $(FFLAGS) $(RFLAGS)”

    6、编译Modula-2程序的隐含规则。
    “.sym” 的目标的依赖目标会自动推导为“.def”,并且其生成命令是:“$(M2C
    ) $(M2FLAGS) $(DEFFLAGS)”。“” 的目标的依赖目标会自动推导为“.mod”,
    并且其生成命令是:“$(M2C) $(M2FLAGS) $(MODFLAGS)”。

    7、汇编和汇编预处理的隐含规则。
    “.o” 的目标的依赖目标会自动推导为“.s”,默认使用编译品“as”,并且其生
    成命令是:“$(AS) $(ASFLAGS)”。“.s” 的目标的依赖目标会自动推导为“.S”
    ,默认使用C预编译器“cpp”,并且其生成命令是:“$(AS) $(ASFLAGS)”。

    8、链接Object文件的隐含规则。
    “” 目标依赖于“.o”,通过运行C的编译器来运行链接程序生成(一般是“ld”
    ),其生成命令是:“$(CC) $(LDFLAGS) .o $(LOADLIBES) $(LDLIBS)”。这个规则对
    于只有一个源文件的工程有效,同时也对多个Object文件(由不同的源文件生成)的也有
    效。例如如下规则:

    x : y.o z.o

    并且“x.c”、“y.c”和“z.c”都存在时,隐含规则将执行如下命令:

    cc -c x.c -o x.o
    cc -c y.c -o y.o
    cc -c z.c -o z.o
    cc x.o y.o z.o -o x
    rm -f x.o
    rm -f y.o
    rm -f z.o

    如果没有一个源文件(如上例中的x.c)和你的目标名字(如上例中的x)相关联,那么,
    你最好写出自己的生成规则,不然,隐含规则会报错的。

    9、Yacc C程序时的隐含规则。
    “.c”的依赖文件被自动推导为“n.y”(Yacc生成的文件),其生成命令是:“$(YA
    CC) $(YFALGS)”。(“Yacc”是一个语法分析器,关于其细节请查看相关资料)

    10、Lex C程序时的隐含规则。
    “.c”的依赖文件被自动推导为“n.l”(Lex生成的文件),其生成命令是:“$(LEX
    ) $(LFALGS)”。(关于“Lex”的细节请查看相关资料)

    11、Lex Ratfor程序时的隐含规则。
    “.r”的依赖文件被自动推导为“n.l”(Lex生成的文件),其生成命令是:“$(LEX
    ) $(LFALGS)”。

    12、从C程序、Yacc文件或Lex文件创建Lint库的隐含规则。
    “.ln” (lint生成的文件)的依赖文件被自动推导为“n.c”,其生成命令是:“$(
    LINT) $(LINTFALGS) $(CPPFLAGS) -i”。对于“.y”和“.l”也是同样的规则。



    三、隐含规则使用的变量

    在隐含规则中的命令中,基本上都是使用了一些预先设置的变量。你可以在你的makefile
    中改变这些变量的值,或是在make的命令行中传入这些值,或是在你的环境变量中设置这
    些值,无论怎么样,只要设置了这些特定的变量,那么其就会对隐含规则起作用。当然,
    你也可以利用make的“-R”或“--no– builtin-variables”参数来取消你所定义的变量
    对隐含规则的作用。

    例如,第一条隐含规则——编译C程序的隐含规则的命令是“$(CC) –c $(CFLAGS) $(CPP
    FLAGS)”。Make默认的编译命令是“cc”,如果你把变量“$(CC)”重定义成“gcc”,把
    变量“$(CFLAGS)”重定义成 “-g”,那么,隐含规则中的命令全部会以“gcc –c -g $
    (CPPFLAGS)”的样子来执行了。

    我们可以把隐含规则中使用的变量分成两种:一种是命令相关的,如“CC”;一种是参数
    相的关,如“CFLAGS”。下面是所有隐含规则中会用到的变量:


    1、关于命令的变量。

    AR
    函数库打包程序。默认命令是“ar”。
    AS
    汇编语言编译程序。默认命令是“as”。
    CC
    C语言编译程序。默认命令是“cc”。
    CXX
    C++语言编译程序。默认命令是“g++”。
    CO
    从 RCS文件中扩展文件程序。默认命令是“co”。
    CPP
    C程序的预处理器(输出是标准输出设备)。默认命令是“$(CC) –E”。
    FC
    Fortran 和 Ratfor 的编译器和预处理程序。默认命令是“f77”。
    GET
    从SCCS文件中扩展文件的程序。默认命令是“get”。
    LEX
    Lex方法分析器程序(针对于C或Ratfor)。默认命令是“lex”。
    PC
    Pascal语言编译程序。默认命令是“pc”。
    YACC
    Yacc文法分析器(针对于C程序)。默认命令是“yacc”。
    YACCR
    Yacc文法分析器(针对于Ratfor程序)。默认命令是“yacc –r”。
    MAKEINFO
    转换Texinfo源文件(.texi)到Info文件程序。默认命令是“makeinfo”。
    TEX
    从TeX源文件创建TeX DVI文件的程序。默认命令是“tex”。
    TEXI2DVI
    从Texinfo源文件创建军TeX DVI 文件的程序。默认命令是“texi2dvi”。
    WEAVE
    转换Web到TeX的程序。默认命令是“weave”。
    CWEAVE
    转换C Web 到 TeX的程序。默认命令是“cweave”。
    TANGLE
    转换Web到Pascal语言的程序。默认命令是“tangle”。
    CTANGLE
    转换C Web 到 C。默认命令是“ctangle”。
    RM
    删除文件命令。默认命令是“rm –f”。

    2、关于命令参数的变量

    下面的这些变量都是相关上面的命令的参数。如果没有指明其默认值,那么其默认值都是
    空。

    ARFLAGS
    函数库打包程序AR命令的参数。默认值是“rv”。
    ASFLAGS
    汇编语言编译器参数。(当明显地调用“.s”或“.S”文件时)。
    CFLAGS
    C语言编译器参数。
    CXXFLAGS
    C++语言编译器参数。
    COFLAGS
    RCS命令参数。
    CPPFLAGS
    C预处理器参数。( C 和 Fortran 编译器也会用到)。
    FFLAGS
    Fortran语言编译器参数。
    GFLAGS
    SCCS “get”程序参数。
    LDFLAGS
    链接器参数。(如:“ld”)
    LFLAGS
    Lex文法分析器参数。
    PFLAGS
    Pascal语言编译器参数。
    RFLAGS
    Ratfor 程序的Fortran 编译器参数。
    YFLAGS
    Yacc文法分析器参数。


    四、隐含规则链

    有些时候,一个目标可能被一系列的隐含规则所作用。例如,一个[.o]的文件生成,可能
    会是先被Yacc的[.y]文件先成[.c],然后再被C的编译器生成。我们把这一系列的隐含规则
    叫做“隐含规则链”。

    在上面的例子中,如果文件[.c]存在,那么就直接调用C的编译器的隐含规则,如果没有[
    .c]文件,但有一个[.y]文件,那么Yacc的隐含规则会被调用,生成[.c]文件,然后,再调
    用C编译的隐含规则最终由[.c]生成[.o]文件,达到目标。

    我们把这种[.c]的文件(或是目标),叫做中间目标。不管怎么样,make会努力自动推导
    生成目标的一切方法,不管中间目标有多少,其都会执着地把所有的隐含规则和你书写的
    规则全部合起来分析,努力达到目标,所以,有些时候,可能会让你觉得奇怪,怎么我的
    目标会这样生成?怎么我的makefile发疯了?

    在默认情况下,对于中间目标,它和一般的目标有两个地方所不同:第一个不同是除非中
    间的目标不存在,才会引发中间规则。第二个不同的是,只要目标成功产生,那么,产生
    最终目标过程中,所产生的中间目标文件会被以“rm -f”删除。

    通常,一个被makefile指定成目标或是依赖目标的文件不能被当作中介。然而,你可以明
    显地说明一个文件或是目标是中介目标,你可以使用伪目标“.INTERMEDIATE”来强制声明
    。(如:.INTERMEDIATE : mid )

    你也可以阻止make自动删除中间目标,要做到这一点,你可以使用伪目标“.SECONDARY”
    来强制声明(如:.SECONDARY : sec)。你还可以把你的目标,以模式的方式来指定(如
    :%.o)成伪目标“.PRECIOUS”的依赖目标,以保存被隐含规则所生成的中间文件。

    在“隐含规则链”中,禁止同一个目标出现两次或两次以上,这样一来,就可防止在make
    自动推导时出现无限递归的情况。

    Make 会优化一些特殊的隐含规则,而不生成中间文件。如,从文件“foo.c”生成目标程
    序“foo”,按道理,make会编译生成中间文件“foo.o”,然后链接成“foo”,但在实际
    情况下,这一动作可以被一条“cc”的命令完成(cc –o foo foo.c),于是优化过的规
    则就不会生成中间文件。



    五、定义模式规则

    你可以使用模式规则来定义一个隐含规则。一个模式规则就好像一个一般的规则,只是在
    规则中,目标的定义需要有"%"字符。"%"的意思是表示一个或多个任意字符。在依赖目标
    中同样可以使用"%",只是依赖目标中的"%"的取值,取决于其目标。

    有一点需要注意的是,"%"的展开发生在变量和函数的展开之后,变量和函数的展开发生在
    make载入Makefile时,而模式规则中的"%"则发生在运行时。


    1、模式规则介绍

    模式规则中,至少在规则的目标定义中要包含"%",否则,就是一般的规则。目标中的"%"
    定义表示对文件名的匹配,"%"表示长度任意的非空字符串。例如:"%.c"表示以".c"结尾
    的文件名(文件名的长度至少为3),而"s.%.c"则表示以"s."开头,".c"结尾的文件名(
    文件名的长度至少为 5)。


    如果"%"定义在目标中,那么,目标中的"%"的值决定了依赖目标中的"%"的值,也就是说,
    目标中的模式的"%"决定了依赖目标中"%"的样子。例如有一个模式规则如下:

    %.o : %.c ;

    其含义是,指出了怎么从所有的[.c]文件生成相应的[.o]文件的规则。如果要生成的目标
    是"a.o b.o",那么"%c"就是"a.c b.c"。

    一旦依赖目标中的"%"模式被确定,那么,make会被要求去匹配当前目录下所有的文件名,
    一旦找到,make就会规则下的命令,所以,在模式规则中,目标可能会是多个的,如果有
    模式匹配出多个目标,make就会产生所有的模式目标,此时,make关心的是依赖的文件名
    和生成目标的命令这两件事。


    2、模式规则示例

    下面这个例子表示了,把所有的[.c]文件都编译成[.o]文件.

    %.o : %.c
    $(CC) -c $(CFLAGS) $(CPPFLAGS) $< -o $@

    其中,"$@"表示所有的目标的挨个值,"$<"表示了所有依赖目标的挨个值。这些奇怪的变
    量我们叫"自动化变量",后面会详细讲述。

    下面的这个例子中有两个目标是模式的:

    %.tab.c %.tab.h: %.y
    bison -d $<</span>

    这条规则告诉make把所有的[.y]文件都以"bison -d .y"执行,然后生成".tab.c"和
    ".tab.h"文件。(其中,"" 表示一个任意字符串)。如果我们的执行程序"foo"依
    赖于文件"parse.tab.o"和"scan.o",并且文件"scan.o"依赖于文件"parse.tab.h",如果
    "parse.y"文件被更新了,那么根据上述的规则,"bison -d parse.y"就会被执行一次,于
    是,"parse.tab.o"和"scan.o"的依赖文件就齐了。(假设,"parse.tab.o" 由"parse.ta
    b.c"生成,和"scan.o"由"scan.c"生成,而"foo"由"parse.tab.o"和"scan.o"链接生成,
    而且foo和其[.o]文件的依赖关系也写好,那么,所有的目标都会得到满足)


    3、自动化变量

    在上述的模式规则中,目标和依赖文件都是一系例的文件,那么我们如何书写一个命令来
    完成从不同的依赖文件生成相应的目标?因为在每一次的对模式规则的解析时,都会是不
    同的目标和依赖文件。

    自动化变量就是完成这个功能的。在前面,我们已经对自动化变量有所提涉,相信你看到
    这里已对它有一个感性认识了。所谓自动化变量,就是这种变量会把模式中所定义的一系
    列的文件自动地挨个取出,直至所有的符合模式的文件都取完了。这种自动化变量只应出
    现在规则的命令中。

    下面是所有的自动化变量及其说明:

    $@
    表示规则中的目标文件集。在模式规则中,如果有多个目标,那么,"$@"就是匹配于目标
    中模式定义的集合。


    $%
    仅当目标是函数库文件中,表示规则中的目标成员名。例如,如果一个目标是"foo.a(bar
    .o)",那么,"$%"就是"bar.o","$@"就是"foo.a"。如果目标不是函数库文件(Unix下是
    [.a],Windows下是[.lib]),那么,其值为空。

    $<</span>
    依赖目标中的第一个目标名字。如果依赖目标是以模式(即"%")定义的,那么"$<"将是符
    合模式的一系列的文件集。注意,其是一个一个取出来的。

    $?
    所有比目标新的依赖目标的集合。以空格分隔。

    $^
    所有的依赖目标的集合。以空格分隔。如果在依赖目标中有多个重复的,那个这个变量会
    去除重复的依赖目标,只保留一份。

    $+
    这个变量很像"$^",也是所有依赖目标的集合。只是它不去除重复的依赖目标。

    $*
    这个变量表示目标模式中"%"及其之前的部分。如果目标是"dir/a.foo.b",并且目标的模
    式是"a.%.b",那么,"$*"的值就是"dir /a.foo"。这个变量对于构造有关联的文件名是比
    较有较。如果目标中没有模式的定义,那么"$*"也就不能被推导出,但是,如果目标文件
    的后缀是 make所识别的,那么"$*"就是除了后缀的那一部分。例如:如果目标是"foo.c"
    ,因为".c"是make所能识别的后缀名,所以,"$*"的值就是"foo"。这个特性是GNU make的
    ,很有可能不兼容于其它版本的make,所以,你应该尽量避免使用"$*",除非是在隐含规
    则或是静态模式中。如果目标中的后缀是make所不能识别的,那么"$*"就是空值。

    当你希望只对更新过的依赖文件进行操作时,"$?"在显式规则中很有用,例如,假设有一
    个函数库文件叫"lib",其由其它几个object文件更新。那么把object文件打包的比较有效
    率的Makefile规则是:

    lib : foo.o bar.o lose.o win.o
    ar r lib $?

    在上述所列出来的自动量变量中。四个变量($@、$<、$%、$*)在扩展时只会有一个文件
    ,而另三个的值是一个文件列表。这七个自动化变量还可以取得文件的目录名或是在当前
    目录下的符合模式的文件名,只需要搭配上"D"或"F"字样。这是GNU make中老版本的特性
    ,在新版本中,我们使用函数"dir"或"notdir"就可以做到了。"D"的含义就是Directory,
    就是目录,"F"的含义就是File,就是文件。

    下面是对于上面的七个变量分别加上"D"或是"F"的含义:

    $(@D)
    表示"$@"的目录部分(不以斜杠作为结尾),如果"$@"值是"dir/foo.o",那么"$(@D)"就
    是"dir",而如果"$@"中没有包含斜杠的话,其值就是"."(当前目录)。

    $(@F)
    表示"$@"的文件部分,如果"$@"值是"dir/foo.o",那么"$(@F)"就是"foo.o","$(@F)"相
    当于函数"$(notdir $@)"。

    "$(*D)"
    "$(*F)"
    和上面所述的同理,也是取文件的目录部分和文件部分。对于上面的那个例子,"$(*D)"返
    回"dir",而"$(*F)"返回"foo"

    "$(%D)"
    "$(%F)"
    分别表示了函数包文件成员的目录部分和文件部分。这对于形同"archive(member)"形式的
    目标中的"member"中包含了不同的目录很有用。

    "$(
    "$(
    分别表示依赖文件的目录部分和文件部分。

    "$(^D)"
    "$(^F)"
    分别表示所有依赖文件的目录部分和文件部分。(无相同的)

    "$(+D)"
    "$(+F)"
    分别表示所有依赖文件的目录部分和文件部分。(可以有相同的)

    "$(?D)"
    "$(?F)"

    分别表示被更新的依赖文件的目录部分和文件部分。

    最后想提醒一下的是,对于"$<",为了避免产生不必要的麻烦,我们最好给$后面的那个特
    定字符都加上圆括号,比如,"$(< )"就要比"$<"要好一些。

    还得要注意的是,这些变量只使用在规则的命令中,而且一般都是"显式规则"和"静态模式
    规则"(参见前面"书写规则"一章)。其在隐含规则中并没有意义。

    4、模式的匹配

    一般来说,一个目标的模式有一个有前缀或是后缀的"%",或是没有前后缀,直接就是一个
    "%"。因为"%"代表一个或多个字符,所以在定义好了的模式中,我们把"%"所匹配的内容叫
    做"茎",例如"%.c"所匹配的文件"test.c"中"test"就是"茎"。因为在目标和依赖目标中同
    时有"%"时,依赖目标的"茎"会传给目标,当做目标中的"茎"。

    当一个模式匹配包含有斜杠(实际也不经常包含)的文件时,那么在进行模式匹配时,目
    录部分会首先被移开,然后进行匹配,成功后,再把目录加回去。在进行"茎"的传递时,
    我们需要知道这个步骤。例如有一个模式"e%t",文件"src/eat" 匹配于该模式,于是"sr
    c/a"就是其"茎",如果这个模式定义在依赖目标中,而被依赖于这个模式的目标中又有个
    模式"c%r",那么,目标就是"src/car"。("茎"被传递)


    5、重载内建隐含规则

    你可以重载内建的隐含规则(或是定义一个全新的),例如你可以重新构造和内建隐含规
    则不同的命令,如:

    %.o : %.c
    $(CC) -c $(CPPFLAGS) $(CFLAGS) -D$(date)

    你可以取消内建的隐含规则,只要不在后面写命令就行。如:

    %.o : %.s

    同样,你也可以重新定义一个全新的隐含规则,其在隐含规则中的位置取决于你在哪里写
    下这个规则。朝前的位置就靠前。


    六、老式风格的"后缀规则"

    后缀规则是一个比较老式的定义隐含规则的方法。后缀规则会被模式规则逐步地取代。因
    为模式规则更强更清晰。为了和老版本的Makefile兼容,GNU make同样兼容于这些东西。
    后缀规则有两种方式:"双后缀"和"单后缀"。

    双后缀规则定义了一对后缀:目标文件的后缀和依赖目标(源文件)的后缀。如".c.o"相
    当于"%o : %c"。单后缀规则只定义一个后缀,也就是源文件的后缀。如".c"相当于"% : 
    %.c"。

    后缀规则中所定义的后缀应该是make所认识的,如果一个后缀是make所认识的,那么这个
    规则就是单后缀规则,而如果两个连在一起的后缀都被make所认识,那就是双后缀规则。
    例如:".c"和".o"都是make所知道。因而,如果你定义了一个规则是".c.o"那么其就是双
    后缀规则,意义就是".c" 是源文件的后缀,".o"是目标文件的后缀。如下示例:

    .c.o:
    $(CC) -c $(CFLAGS) $(CPPFLAGS) -o $@ $<</span>

    后缀规则不允许任何的依赖文件,如果有依赖文件的话,那就不是后缀规则,那些后缀统
    统被认为是文件名,如:

    .c.o: foo.h
    $(CC) -c $(CFLAGS) $(CPPFLAGS) -o $@ $<</span>

    这个例子,就是说,文件".c.o"依赖于文件"foo.h",而不是我们想要的这样:

    %.o: %.c foo.h
    $(CC) -c $(CFLAGS) $(CPPFLAGS) -o $@ $<</span>

    后缀规则中,如果没有命令,那是毫无意义的。因为他也不会移去内建的隐含规则。

    而要让make知道一些特定的后缀,我们可以使用伪目标".SUFFIXES"来定义或是删除,如:


    .SUFFIXES: .hack .win

    把后缀.hack和.win加入后缀列表中的末尾。

    .SUFFIXES: # 删除默认的后缀
    .SUFFIXES: .c .o .h # 定义自己的后缀

    先清楚默认后缀,后定义自己的后缀列表。

    make的参数"-r"或"-no-builtin-rules"也会使用得默认的后缀列表为空。而变量"SUFFIX
    E"被用来定义默认的后缀列表,你可以用".SUFFIXES"来改变后缀列表,但请不要改变变量
    "SUFFIXE"的值。


    七、隐含规则搜索算法

    比如我们有一个目标叫 T。下面是搜索目标T的规则的算法。请注意,在下面,我们没有提
    到后缀规则,原因是,所有的后缀规则在Makefile被载入内存时,会被转换成模式规则。
    如果目标是"archive(member)"的函数库文件模式,那么这个算法会被运行两次,第一次是
    找目标T,如果没有找到的话,那么进入第二次,第二次会把"member"当作T来搜索。

    1、把T的目录部分分离出来。叫D,而剩余部分叫N。(如:如果T是"src/foo.o",那么,
    D就是"src/",N就是"foo.o")

    2、创建所有匹配于T或是N的模式规则列表。

    3、如果在模式规则列表中有匹配所有文件的模式,如"%",那么从列表中移除其它的模式


    4、移除列表中没有命令的规则。

    5、对于第一个在列表中的模式规则:
    1)推导其"茎"S,S应该是T或是N匹配于模式中"%"非空的部分。
    2)计算依赖文件。把依赖文件中的"%"都替换成"茎"S。如果目标模式中没有包含斜框字符
    ,而把D加在第一个依赖文件的开头。
    3)测试是否所有的依赖文件都存在或是理当存在。(如果有一个文件被定义成另外一个规
    则的目标文件,或者是一个显式规则的依赖文件,那么这个文件就叫"理当存在")
    4)如果所有的依赖文件存在或是理当存在,或是就没有依赖文件。那么这条规则将被采用
    ,退出该算法。

    6、如果经过第5步,没有模式规则被找到,那么就做更进一步的搜索。对于存在于列表中
    的第一个模式规则:
    1)如果规则是终止规则,那就忽略它,继续下一条模式规则。
    2)计算依赖文件。(同第5步)
    3)测试所有的依赖文件是否存在或是理当存在。
    4)对于不存在的依赖文件,递归调用这个算法查找他是否可以被隐含规则找到。
    5)如果所有的依赖文件存在或是理当存在,或是就根本没有依赖文件。那么这条规则被采
    用,退出该算法。

    7、如果没有隐含规则可以使用,查看".DEFAULT"规则,如果有,采用,把".DEFAULT"的命
    令给T使用。

    一旦规则被找到,就会执行其相当的命令,而此时,我们的自动化变量的值才会生成。



    使用make更新函数库文件
    ———————————

    函数库文件也就是对Object文件(程序编译的中间文件)的打包文件。在Unix下,一般是
    由命令"ar"来完成打包工作。

    一、函数库文件的成员

    一个函数库文件由多个文件组成。你可以以如下格式指定函数库文件及其组成:

    archive(member)

    这个不是一个命令,而一个目标和依赖的定义。一般来说,这种用法基本上就是为了"ar"
    命令来服务的。如:

    foolib(hack.o) : hack.o
    ar cr foolib hack.o

    如果要指定多个member,那就以空格分开,如:

    foolib(hack.o kludge.o)

    其等价于:

    foolib(hack.o) foolib(kludge.o)

    你还可以使用Shell的文件通配符来定义,如:

    foolib(*.o)


    二、函数库成员的隐含规则

    当 make搜索一个目标的隐含规则时,一个特殊的特性是,如果这个目标是"a(m)"形式的,
    其会把目标变成"(m)"。于是,如果我们的成员是"%.o" 的模式定义,并且如果我们使用"
    make foo.a(bar.o)"的形式调用Makefile时,隐含规则会去找"bar.o"的规则,如果没有定
    义bar.o的规则,那么内建隐含规则生效,make会去找bar.c文件来生成bar.o,如果找得到
    的话,make执行的命令大致如下:

    cc -c bar.c -o bar.o
    ar r foo.a bar.o
    rm -f bar.o

    还有一个变量要注意的是"$%",这是专属函数库文件的自动化变量,有关其说明请参见"自
    动化变量"一节。


    三、函数库文件的后缀规则

    你可以使用"后缀规则"和"隐含规则"来生成函数库打包文件,如:

    .c.a:
    $(CC) $(CFLAGS) $(CPPFLAGS) -c $< -o $*.o
    $(AR) r $@ $*.o
    $(RM) $*.o

    其等效于:

    (%.o) : %.c
    $(CC) $(CFLAGS) $(CPPFLAGS) -c $< -o $*.o
    $(AR) r $@ $*.o
    $(RM) $*.o


    四、注意事项

    在进行函数库打包文件生成时,请小心使用make的并行机制("-j"参数)。如果多个ar命
    令在同一时间运行在同一个函数库打包文件上,就很有可以损坏这个函数库文件。所以,
    在make未来的版本中,应该提供一种机制来避免并行操作发生在函数打包文件上。

    但就目前而言,你还是应该不要尽量不要使用"-j"参数。



    后序
    ——

    终于到写结束语的时候了,以上基本上就是GNU make的Makefile的所有细节了。其它的产
    商的make基本上也就是这样的,无论什么样的make,都是以文件的依赖性为基础的,其基
    本是都是遵循一个标准的。这篇文档中80%的技术细节都适用于任何的make,我猜测"函数
    "那一章的内容可能不是其它make所支持的,而隐含规则方面,我想不同的make会有不同的
    实现,我没有精力来查看GNU的make和VC的nmake、BCB的make,或是别的UNIX下的make有些
    什么样的差别,一是时间精力不够,二是因为我基本上都是在Unix下使用make,以前在SC
    O Unix和IBM的AIX,现在在Linux、Solaris、HP-UX、AIX和Alpha下使用,Linux和Solari
    s下更多一点。不过,我可以肯定的是,在Unix下的make,无论是哪种平台,几乎都使用了
    Richard Stallman开发的make和cc/gcc的编译器,而且,基本上都是GNU的make(公司里所
    有的UNIX机器上都被装上了GNU的东西,所以,使用GNU的程序也就多了一些)。GNU的东西
    还是很不错的,特别是使用得深了以后,越来越觉得GNU的软件的强大,也越来越觉得GNU
    的在操作系统中(主要是Unix,甚至Windows)"杀伤力"。

    对于上述所有的make的细节,我们不但可以利用make这个工具来编译我们的程序,还可以
    利用make来完成其它的工作,因为规则中的命令可以是任何Shell之下的命令,所以,在U
    nix下,你不一定只是使用程序语言的编译器,你还可以在Makefile中书写其它的命令,如
    :tar、awk、mail、sed、cvs、compress、ls、rm、yacc、rpm、 ftp……等等,等等,来
    完成诸如"程序打包"、"程序备份"、"制作程序安装包"、"提交代码"、"使用程序模板"、
    "合并文件"等等五花八门的功能,文件操作,文件管理,编程开发设计,或是其它一些异
    想天开的东西。比如,以前在书写银行交易程序时,由于银行的交易程序基本一样,就见
    到有人书写了一些交易的通用程序模板,在该模板中把一些网络通讯、数据库操作的、业
    务操作共性的东西写在一个文件中,在这些文件中用些诸如"@@@N、###N"奇怪字串标注一
    些位置,然后书写交易时,只需按照一种特定的规则书写特定的处理,最后在make时,使
    用awk和sed,把模板中的"@@@N、###N"等字串替代成特定的程序,形成C文件,然后再编译
    。这个动作很像数据库的"扩展C"语言(即在C语言中用"EXEC SQL"的样子执行SQL语句,
    在用 cc/gcc编译之前,需要使用"扩展C"的翻译程序,如cpre,把其翻译成标准C)。如果
    你在使用make时有一些更为绝妙的方法,请记得告诉我啊。

    回头看看整篇文档,不觉记起几年前刚刚开始在Unix下做开发的时候,有人问我会不会写
    Makefile时,我两眼发直,根本不知道在说什么。一开始看到别人在vi中写完程序后输入
    "!make"时,还以为是vi的功能,后来才知道有一个Makefile在作怪,于是上网查啊查,那
    时又不愿意看英文,发现就根本没有中文的文档介绍Makefile,只得看别人写的Makefile
    ,自己瞎碰瞎搞才积累了一点知识,但在很多地方完全是知其然不知所以然。后来开始从
    事UNIX下产品软件的开发,看到一个400人年,近200万行代码的大工程,发现要编译这样
    一个庞然大物,如果没有Makefile,那会是多么恐怖的一样事啊。于是横下心来,狠命地
    读了一堆英文文档,才觉得对其掌握了。但发现目前网上对Makefile介绍的文章还是少得
    那么的可怜,所以想写这样一篇文章,共享给大家,希望能对各位有所帮助。

    现在我终于写完了,看了看文件的创建时间,这篇技术文档也写了两个多月了。发现,自
    己知道是一回事,要写下来,跟别人讲述又是另外一回事,而且,现在越来越没有时间专
    研技术细节,所以在写作时,发现在阐述一些细节问题时很难做到严谨和精练,而且对先
    讲什么后讲什么不是很清楚,所以,还是参考了一些国外站点上的资料和题纲,以及一些
    技术书籍的语言风格,才得以完成。整篇文档的提纲是基于GNU的 Makefile技术手册的提
    纲来书写的,并结合了自己的工作经验,以及自己的学习历程。因为从来没有写过这么长
    ,这么细的文档,所以一定会有很多地方存在表达问题,语言歧义或是错误。因些,我迫
    切地得等待各位给我指证和建议,以及任何的反馈。

    最后,还是利用这个后序,介绍一下自己。我目前从事于所有Unix平台下的软件研发,主
    要是做分布式计算/网格计算方面的系统产品软件,并且我对于下一代的计算机革命——网
    格计算非常地感兴趣,对于分布式计算、P2P、Web Service、J2EE技术方向也很感兴趣,
    同时,对于项目实施、团队管理、项目管理也小有心得,希望同样和我战斗在“技术和管
    理并重”的阵线上的年轻一代,能够和我多多地交流。我的MSN是:haoel@hotmail.com(
    常用),QQ是:753640(不常用)。(注:请勿给我MSN的邮箱发信,由于hotmail的垃圾
    邮件导致我拒收这个邮箱的所有来信)

    我欢迎任何形式的交流,无论是讨论技术还是管理,或是其它海阔天空的东西。除了政治
    和娱乐新闻我不关心,其它只要积极向上的东西我都欢迎!

    最最后,我还想介绍一下make程序的设计开发者。

    首当其冲的是: Richard Stallman

    开源软件的领袖和先驱,从来没有领过一天工资,从来没有使用过Windows操作系统。对于
    他的事迹和他的软件以及他的思想,我无需说过多的话,相信大家对这个人并不比我陌生
    ,这是他的主页:http://www.stallman.org/ 



    第二位是:Roland McGrath

    个人主页是:http://www.frob.com/~roland/ ,下面是他的一些事迹:

    1) 合作编写了并维护GNU make。

    2) 和Thomas Bushnell一同编写了GNU Hurd。

    3) 编写并维护着GNU C library。

    4) 合作编写并维护着部分的GNU Emacs。



    在此,向这两位开源项目的斗士致以最真切的敬意。
    展开全文
  • 有时候一个语句太长,一写不下,或者显得不美观,为了便于阅读,可以将较长的语句拆分成两甚至多行,除了最后一之外,在每一个分行后面加一个反斜杠“\”,这样编译的时候,系统会自动将这几个分行读成一个...
  • linux MINIX 文件系统 理解文件系统中的加锁、睡眠等原因也是重要关键的点。 super.c inode.c bitmap.c namei.c truncate.c stat.c open.c read_write.c fcntl.c pipe.c file_dev.c block_dev.c char_...
  • 上篇博客Linux内核完全注释:第三章 内核引导启动程序-setup.s讲解 功能描述 源码解析
  • 1.解释下什么是GPL,GNU,自由软件? GPL:(通用公共许可证):一种授权,任何人有权取得、修改、重新发布自由软件的权力。 GNU:(革奴计划):目标是创建一套...2.如何选择Linux操作系统版本? 一般来讲,桌面用
  • Linux下的光盘刻录

    2012-04-13 16:51:52
    随着Linux用户的不断增多,许多用户都在Linux中保存了大量信息,于是如何把这些信息刻录到光盘中就成了大家关心的问题。因为在windows下有许多工具可用,也很方便!其实linux也不例外。不管是在哪个平台,刻录都有...
  • 上一篇 bootsect.s讲解
  • [1] 粗略阅读linux0.11引导程序。 [2] 粗略阅读linux0.11由实模式进入保护模式的程序 。 [3] 粗略阅读linux0.11护模式初始化程序。 [4] 粗略阅读linux0.11主存管理程序。 [5] 粗略阅读linux0.11中断/异常机制...
  • java到python的入门

    2019-09-25 08:55:20
    注释续行符 python使用#开始注释Linux的一样 如果一行语句很长 要分成多行 则需要使用\在每行最后续行 当多行之间有括号等连接时 则不需要使用续行符 python使用换行结束一条语句 同一行要写多个语句 则使用;...
  • Linux实用教程(第三版)

    2020-03-20 13:28:43
    第一章 Linux系统初步了解 本章内容 1.1 Linux系统简介 1.2 Linux系统的特点和组成 1.3 Linux版本介绍 1.4 Red Hat Linux系统概述 1.1 Linux系统简介 1.1.1 什么是Linux 1.1.2 Linux系统的产生 1.1.3 Linux...
  • Python3 基础语法 编码 默认情况下,Python 3源码文件以 UTF-8 编码,所有字符串都是 unicode 字符串。 当然你也可以为源码文件指定不同的编码: # -*- coding: cp-1252 -*- ...第一个字符必须是字母表中字母或...
  • Linux Shell脚本教程

    2019-07-05 08:40:24
    Linux Shell脚本教程 一.... 单纯的PHP也可以实现断点传下载,但单纯的PHP实现代码会比较复杂,而且没有多线程下载,速度会比较慢。...没有多行注释,只能每一加一个#号。但可以通过其它变通的方法实行多行注释...
  • 上一篇,我们介绍了一个脚本,该脚本可以实现将命令及其依赖的库一并复制到我们的小linux上,这里,我们先用该脚本将下面的所有命令复制到我们的小linux上,待会我们会用到,如果还需要复制某些命令,我们可以直接...
  • linux平常的常用命令

    2017-06-20 18:14:23
    平常经常使用linux进行开发,软件安装,环境部署等,会用到一些常用的命令,下面是我平时使用到linux下的常用命令:   type command 查看一条命令是外部命令还是内部命令 [root@upl test]# type cd cd is a shell ...
  • TimeWait,收集了一下Linux网络参数的优化技巧,红帽官网有相关说明。 收集了一下,挺多的。注释很详细了: # 对于一个新建连接,内核要发送多少个SYN连接请求才决定放弃。<=255,默认值是5,对应于180秒...
  • Linux命令大全完整版 目 录I 1. linux系统管理命令1  adduser1 chfn(change finger information)1 chsh(change shell)1 date2 exit3 finger4 free5 fwhois5 gitps(gnu interactive tools process ...
1 2 3 4 5 ... 20
收藏数 5,929
精华内容 2,371
关键字:

linux 注释 续行