Monday, May 25, 2009

install perl module as non-root

perl Makefile.PL, make, make test, make install

The standard way to install a Perl module on Unix is to change into the directory that was created when you unpacked the .tar.gz file, and then type the following sequence of commands:

  perl Makefile.PL
  make
  make test
  make install


This will create a makefile for you, then compile the module, test it, and put it in the correct location for you. This requires that you are logged in as root, so that you can copy files to the Perl library directory, and various other places on your system where the installation will put files.

If you do not have root permissions on the machine where you want to install the module, such as if you wish to install a module in your home directory, just change one of those commands. Instead of

  perl Makefile.PL

type

  #perl Makefile.PL PREFIX=/path/to/where/you/want/it
  perl Makefile.PL INSTALL_BASE=/path/to/where/you/want/it

 make install

That will put all the files in that directory. In order to use modules that are stored in that location, you will need to add the following like to your Perl programs:

  use lib "/path/to/where/you/want/it/perl5"
and, yes, thanks for the comment, local::lib might be easier to install a new module.
  use local::lib "/path/to/where/you/want/it/perl5"

Saturday, April 25, 2009

encryption

Most of then are concerpted from wikipedia.

and some from cisco

CSS:

Content Scramble System (CSS) is a Digital Rights Management (DRM) scheme used on almost all commercially produced DVD-Video discs. It utilizes a proprietary 40-bit stream cipher algorithm. The system was introduced around 1996 and has subsequently been compromised.

CSS key is a collective term for authentication key, disc keys, player keys, title keys, secured disk key set, and/or encrypted title keys.

Some of the keys are stored on the lead-in area of the disk, which is generally only read by compliant drives. Keys can be passed from a DVD drive to a descrambler over a PC bus using a secure handshake protocol

he purpose of CSS is twofold. First and foremost, it prevents byte-for-byte copies of an MPEG stream from being playable since such copies will not include the keys that are hidden on the lead-in area of the restricted DVD disk. Second, it provides a reason for manufacturers to make compliant devices, since CSS scrambled disks will not play on noncompliant devices. Anyone wishing to build compliant devices must obtain a license, which contains the requirement that the rest of the DRM system be implemented.

In October 1999 the algorithm and DeCSS was released.  Structural flaws in the algorithm reduced the effective key length to only around 16 bits, which could be brute-forced by a 450 MHz processor in less than a minute.

DES

Published as the U.S. Federal Information Processing Standard 46 in 1977, DES is still widely used, despite being proven inadequate for use in many applications. It is a symmetric block cipher (shared secret key), with its block size fixed at 64 bits. There are four defined modes of operation, with the Electronic Code Book (ECB) mode being the most widely used. Additionally, DES has been incorporated into numerous other standards, such as American Bankers Association's Protection of Personal Identification Numbers in Interchange Standard, Management and Use of Personal Identification Numbers Standard, Key Management Standard, and three ANSI standards, Data Encryption Algorithm (DEA), Standard for Personal Identification Number (PIN) Management and Security, and Standard for Financial Institution Message Authentication [3]. In particular, DES is also specified as an approved algorithm in the IP Security Architecture (IPSec) standard [9], which is used in the equipment from many different suppliers.

Key length is one of the two most important security factors of any encryption algorithm—the other one being the design of the algorithm itself. DES uses a 64-bit block for the key; however, 8 of these bits are used for odd parity and are, therefore, not counted in the key length. The effective key length is then calculated as 56 bits, giving 256 possible keys. A true 64-bit key has 256 times as many keys, whereas a 128-bit key is 272 times "better" than a 56-bit key. As if this was not enough, DES also has so-called weak and semi-weak keys. During the encryption process, the key is used to generate two values that are used for separate purposes during the process. These 16 weak and semi-weak keys will produce values that don't appear to be random. They will give outputs of all-ones, all-zeros, or distinguishable patterns of ones and zeros. It is generally recognized that these 16 key values should not be used. The key length was known to be a factor in trusting DES soon after DES was published. For this reason, people started exploring the use of multiple encryption passes and multiple keys. Triple DES (3DES) is a way of using DES encryption three times.

The most common method is to first encrypt the data block with one key. The output of this operation is run through the decryption process with a second key, and the output of that operation is run through the encryption process again with the first key. This process makes the effective key length 112 bits long. Again, the problem with weak and semi-weak keys remains. The disadvantage of Triple DES is that it is about one-third as fast as DES when processing data. This effort just slightly extended the life of DES while a suitable alternative could be found.

Because some internal structures used in DES are not designed to be strong against linear cryptanalysis, it is quite effective when used against DES. To show that the DES is inadequate and should not be used in important systems anymore.

When spoken, "DES" is either spelled out (IPA: /diː iː ɛs/) as an abbreviation or pronounced as a single syllable (IPA: /dɛs/) acronym

AES

Advanced Encryption Standard (AES) is an encryption standard adopted by the U.S. government. The standard comprises three block ciphers, AES-128, AES-192 and AES-256, adopted from a larger collection originally published as Rijndael. 

As of 2009, AES is one of the most popular algorithms used in symmetric key cryptography. AES is the first publicly accessible and open cipher approved by the NSA for top secret information.Unlike its predecessor DES, AES does not use a Feistel network.

AES has a fixed block size of 128 bits and a key size of 128, 192, or 256 bits, whereas Rijndael can be specified with block and key sizes in any multiple of 32 bits, with a minimum of 128 bits and a maximum of 256 bits.
Assuming one byte equals 8 bits, the fixed block size of 128 bits is 128 ÷ 8 = 16 bytes. AES operates on a 4×4 array of bytes, termed the state. he AES cipher is specified as a number of repetitions of transformation rounds that convert the input plain-text into the final output of cipher-text. Each round consists of several processing steps, including one that depends on the encryption key. A set of reverse rounds are applied to transform cipher-text back into the original plain-text using the same encryption key.

High-level description of the algorithm

1. KeyExpansion using Rijndael's key schedule

2.Initial Round
AddRoundKey
Rounds
SubBytes—a non-linear substitution step where each byte is replaced with another according to a lookup table - an 8-bit substitution box, the Rijndael S-box
ShiftRows—a transposition step where each row of the state is shifted cyclically a certain number of steps.
MixColumns—a mixing operation which operates on the columns of the state, combining the four bytes in each column
AddRoundKey—each byte of the state is combined with the round key; each round key is derived from the cipher key using a key schedule.
3.Final Round (no MixColumns)
SubBytes
ShiftRows
AddRoundKey

M6

M6 is a block cipher proposed by Hitachi in 1997 for use in the IEEE 1394 FireWire standard.

The algorithm operates on blocks of 64 bits using a 10-round Feistel network structure. The key size is 40 bits by default, but can be up to 64 bits. Because its round function is based on rotation and addition, M6 was one of the first ciphers attacked by mod n cryptanalysis. Mod 5, about 100 known plaintexts suffice to distinguish the output from a pseudorandom permutation. Due to its simple key schedule, M6 is also vulnerable to a slide attack, which requires more known plaintext but less computation.

C2

The Cryptomeria cipher, commonly referred to as C2, is a proprietary block cipher defined and licensed by the 4C Entity. It is the successor to CSS algorithm (used for DVD-Video) and was designed for the CPRM/CPPM Digital Rights Management scheme which are used by DRM-restricted Secure Digital cards and DVD-Audio discs.

Like DES, it has a key size of 56 bits and a block size of 64 bits. The encryption and decryption algorithms are available for peer review, but implementations require the so-called "secret constant", the values of the substitution boxes, which are only available under a license from the 4C Entity.

SHA

The SHA hash functions are a set of cryptographic hash functions designed by the National Security Agency (NSA).SHA stands for Secure Hash Algorithm. The three SHA algorithms are structured differently and are distinguished as SHA-0, SHA-1, and SHA-2. The SHA-2 family uses an identical algorithm with a variable digest size which is distinguished as SHA-224, SHA-256, SHA-384, and SHA-512.

SHA-1 is the best established of the existing SHA hash functions, and is employed in several widely used security applications and protocols.In 2005, security flaws were identified in SHA-1, namely that a possible mathematical weakness might exist, indicating that a stronger hash function would be desirable. Although no attacks have yet been reported on the SHA-2 variants, they are algorithmically similar to SHA-1 and so efforts are underway to develop improved alternatives.[2][3] A new hash standard, SHA-3, is currently under development.

SHA-1 (as well as SHA-0) produces a 160-bit digest from a message with a maximum length of (264 − 1) bits. SHA-1 is based on principles similar to those used by Ronald L. Rivest of MIT in the design of the MD4 and MD5 message digest algorithms, but has a more conservative design.

NIST published four additional hash functions in the SHA family, named after their digest lengths (in bits): SHA-224, SHA-256, SHA-384, and SHA-512. The algorithms are collectively known as SHA-2.

SHA-256 and SHA-512 are novel hash functions computed with 32- and 64-bit words, respectively. They use different shift amounts and additive constants, but their structures are otherwise virtually identical, differing only in the number of rounds. SHA-224 and SHA-384 are simply truncated versions of the first two, computed with different initial values.

Wednesday, April 8, 2009

ts subsystem

podci: 6-1 mux, stream formating output; and direct muxed output

    suport stream formating, i.e. clock/sync recovery, data s2p, etc

btr:bi-directional transport interface that write/read data to/from mem.

 And STC(System Time Counter) and provide sync check/maintenance

hostif: will be responsible for cicam programming

a pcmcia compatible interface is used, supporting 68k & sram strobe timing

Tuesday, April 7, 2009

Transport stream (TS, TP, MPEG-TS, or M2T) is a communications protocol for audio, video, and data. It is a type of digital container format that encapsulates packetized elementary streams and other data. TS is specified in MPEG-2 Part 1, Systems (ISO/IEC standard 13818-1)

Transport stream offers features for error correction for transportation over unreliable media, and is used in broadcast applications such as DVB and ATSC. It is contrasted with program stream, designed for more reliable media such as DVDs.

A packet is the basic unit of data in a transport stream. It consists of

1. a sync byte, whose value is 0x47,

2.followed by three one-bit flags and a 13-bit Packet Identifier (PID).

3.This is followed by a 4-bit continuity counter.

4.Additional optional transport fields, as signaled in the optional adaptation field, may follow.

5.The rest of the packet consists of payload.

Friday, March 6, 2009

莫尔斯码 (morse code)



ET, I Am Normal Man.
So U R Weird. Don't Keep Going Out.
He's Very Fond of Lazy et. Please Join BoXing Club. Yes, Zealously and Quietly.
E .

T #

I ..
A .#
N #.
M ##

S ...
U ..#
R .#.
W .##
D #..
K #.#
G ##.
O ###

H ....
V ...#
F ..#.
L .#..
P .##.
J .###
B #...
X #..#
C #.#.
Y #.##
Z ##..
Q ##.#

5 .....
4 ....#
3 ...##
2 ..###
1 .####
6 #....
7 ##...
8 ###..
9 ####.
0 #####

.   .#.#.#
,   ..##..

?  ..##..

!   ..##.
:   ###...
" .#..#.
'   .####.
=   #...#
THE QUICK BRMN FOX MJEUMPS OVER TSE LAZY DOG
- /. . . . / .
- -.- / . . - / . / - . - . / - . -
- . . . / . - . / - - - / . - - / - .
. . - . / - - - / - . . -
. - - - / . . - / - - / . - - . / . . .
- - - / . . . - / . / . - .
- / . . . . / .
. - . . / . - / - - . . / - . - -
- . . / - - - / - - .

Tuesday, December 30, 2008

systemverilog wordfile

copied from http://avm-users.googlegroups.com/web/systemverilog.txt?hl=en&gsc=Lb4u6AsAAADWzOiV2TvclJOPyNlia6Gs
/L20"Verilog 1364-2001" Line Comment = // Block Comment On = /* Block Comment Off = */ String Chars = " File Extensions = SV SVL/Delimiters = ~!@%^&*()-+=|\/{}[]:;"<> , .?#/Function String = "%[a-z0-9]+[ ^t]+[a-z_0-9]+[ ^t]+("
/Indent Strings = "begin" "fork" "specify" "config"
/Unindent Strings = "end" "join" "join_any" "join_none" "endspecify" "endconfig"
/C1"Keywords"
alias always always_comb always_ff always_latch and assert assign assume automatic 
before begin bind bins binsof bit break buf bufif0 bufif1 byte
case casex casez cell chandle class clocking cmos config const constraint context continue cover covergroup coverpoint cross
deassign default defparam design disable dist do
edge else end endcase endclass endclocking endconfig endfunction endgenerate endgroup endinterface endmodule endpackage endprimitive endprogram endproperty endspecify endsequence endtable endtask enum event expect export extends extern
final first_match for force foreach forever fork forkjoin function
generate genvar
highz0 highz1
if iff ifnone ignore_bins illegal_bins import incdir include initial inout input inside instance int integer interface intersect join
join_any join_none
large liblist library local localparam logic longint
macromodule matches medium modport module
nand negedge new nmos nor noshowcancelled not notif0 notif1 null
or output
package packed parameter pmos posedge primitive priority program property protected pull0 pull1 pulldown pullup pulsestyle_onevent pulsestyle_ondetect pure
rand randc randcase randsequence rcmos real realtime ref reg release repeat return rnmos rpmos rtran rtranif0 rtranif1
scalared sequence shortint shortreal showcancelled signed small solve specify specparam static string strong0 strong1 struct super supply0 supply1
table tagged task this throughout time timeprecision timeunit tran tranif0 tranif1 tri tri0 tri1 triand trior trireg type typedef
union unique unsigned use
var vectored virtual void
wait wait_order wand weak0 weak1 while wildcard wire with within wor
xnor xor
/C2"System"
** 'b 'B 'o 'O 'd 'D 'h 'H 'sb 'sB 'so 'sO 'sd 'sD 'sh 'sH 'Sb 'SB 'So 'SO 'Sd 'SD 'Sh 'SH
** _
$assertkill $assertoff $asserton $async$and$array $async$nand$array $async$or$array $async$nor$array $async$and$plane $async$nand$plane $async$or$plane $async$nor$plane
$bits $bitstoreal $bitstoshortreal 
$cast $comment $countdrivers $countones
$date $dimensions $display $displayb $displayh $displayo $dist_chi_square $dist_erlang $dist_exponential $dist_normal $dist_poisson $dist_t $dist_uniform $dumpall $dumpflush $dumpfile $dumplimit $dumpoff $dumpon $dumpports $dumpportsall $dumpportsflush $dumpportslimit $dumpportsoff $dumpportson $dumpvars
$enddefinitions $error $exit
$fatal $fdisplay $fdisplayf $fdisplayb $fdisplayh $fdisplayo $fell $feof $ferror $fflush $fgetc $fgets $finish $fopen $fmonitor $fmonitorb $fmonitorf $fmonitorh $fmonitoro $fclose $fread $fscanf $fseek $fsscanf $fstrobe $fstrobeb $fstrobef $fstrobeh $fstrobeo $ftell $fullskew $fwrite $fwriteb $fwritef $fwriteh $fwriteo 
$get_coverage $getpattern
$high $hold $history
$increment $incsave $info $input $isunbounded $isunknown $itor
$key 
$left $list $load_coverage_db $log $low 
$monitor $monitorb $monitorh $monitoro $monitoron $monitoroff 
$nochange $nokey $nolog $onehot $onehot0
$past $period $printtimescale
$q_add $q_exam $q_full $q_initialize $q_remove $q_random
$random $readmemb $readmemh $realtime $realtobits $recovery $recrem $removal $reset $reset_count $reset_value $restart $rewind $right $root $rose $rtoi
$sampled $save $scale $scope $sdf_annotate $set_coverage_db_name $setup $setuphold $sformat $shortrealtobits $showvariables $showscopes $showvars $signed $size $skew $sreadmemb $sreadmemh $sscanf $stable $stime $stop $strobe $strobeb $strobeh $strobeo $swrite $swriteb $swriteh $swriteo $sync$and$array $sync$nand$array $sync$or$array $sync$nor$array $sync$and$plane $sync$nand$plane $sync$or$plane $sync$nor$plane
$test$plusargs $time $timeformat $timescale $timeskew $typename $typeof
$ungetc $unit $unpacked_dimensions $unsigned $upscope $urandom $urandom_range
$value$plusargs $var $vcdclose $version
$warning $width $write $writeb $writeh $writeo $writememb $writememh

/C3"Operators"
->
+:
-:
@
@*
*>
,
;
.*
{
}
+
-
// /
*
**
%
>
>=
>>
>>>
<
<=
<<
<<<
!
!=
!==
&
&&
|
||
=
==
===
^
^~
~
~^
~&
~|
?
:
|->
|=>
/C4"Directives"
** `
`begin_keywords
`accelerate `autoexepand_vectornets
`celldefine
`default_nettype `define `default_decay_time `default_trieg_distributed `default_trireg_strength `delay_mode_distributed `delay_mode_path `delay_mode_unit `delay_mode_zero
`else `elsif `endcelldefine `endif `end_keywords `endprotect `endprotected `expand_vectornets
`file
`ifdef `ifndef `include
`line
`noaccelerate `noexpand_vectornets `noremove_gatenames `noremove_netnames `nounconnected_drive
`pragma `protect `protected
`remove_gatenames `remove_netnames `resetall
`timescale
`unconnected_drive `undef `uselib


/C5"DelaysAndParameters"
#
##

Make script

The oritinal page is http://www.hsrl.rutgers.edu/ug/make_help.html
How to write a Makefile

How to write a Makefile



Introduction


Make is one of the original Unix tools for Software Engineering. By
S.I. Feldman of AT&T Bell Labs circa 1975. But there are public
domain versions (eg. GNU) and versions for other systems
(eg. Vax/VMS).


Related tools are the language compilers (cc, f77, lex, yacc, etc.)
and shell programming tools (eg. awk, sed, cp, rm, etc.). You need to
know how to use these.


Important adjuncts are lint (source code checking for obvious errors)
ctags (locate functions, etc. in source code) and mkdepend. These are
nice, and good programmers use them.


Important, and related tools, are the software revision systems SCCS (Source Code Control System) and RCS (Revision Control System -- the recommended choice)

The idea is to automate and optimize the construction of
programs/files -- ie. to leave enough foot prints so that others can
follow.

Makefile Naming



make is going to look for a file called Makefile, if not found then a
file called makefile. Use the first (so the name stands out in
listings).


You can get away without any Makefile (but shouldn't)! Make has
default rules it knows about.

Makefile Components




  • Comments


    Comments are any text beginning with the pound (#) sign. A
    comment can start anywhere on a line and continue until the end of the
    line. For example:


    # $Id: slides,v 1.2 1992/02/14 21:00:58 reggers Exp $


  • Macros

    Make has a simple macro definition and substitution mechanism. Macros are defined in a Makefile as = pairs. For example:


    MACROS= -me
    PSROFF= groff -Tps
    DITROFF= groff -Tdvi
    CFLAGS= -O -systype bsd43

    There are lots of default macros -- you should honor the existing naming conventions. To find out what rules/macros make is using type:

    % make -p

    NOTE: That your environment variables are exported into the make as macros. They will override the defaults.


    You can set macros on the make command line:


    % make "CFLAGS= -O" "LDFLAGS=-s" printenv
    cc -O printenv.c -s -o printenv


  • Targets

    You make a particular target (eg. make all), in none specified then the first target found:


    paper.dvi: $(SRCS)
    $(DITROFF) $(MACROS) $(SRCS) >paper.dvi

    NOTE: The the line beginning with $(DITROFF) begins with TAB not spaces.

    The target is made if any of the dependent files have changed. The dependent files in this case are represented by the $(SRCS) statement.



  • Continuation of Lines

    Use a back slash (\). This is important for long macros and/or rules.




  • Conventional Macros


    There are lots of default macros (type "make -p" to print out the defaults). Most are pretty obvious from the rules in which they are used:


    AR = ar
    GFLAGS =
    GET = get
    ASFLAGS =
    MAS = mas
    AS = as
    FC = f77
    CFLAGS =
    CC = cc
    LDFLAGS =
    LD = ld
    LFLAGS =
    LEX = lex
    YFLAGS =
    YACC = yacc
    LOADLIBS =
    MAKE = make
    MAKEARGS = 'SHELL=/bin/sh'
    SHELL = /bin/sh
    MAKEFLAGS = b


  • Special Macros


    Before issuing any command in a target rule set there are certain special macros predefined.



    1. $@ is the name of the file to be made.
    2. $? is the names of the changed dependents.


    So, for example, we could use a rule


    printenv: printenv.c
    $(CC) $(CFLAGS) $? $(LDFLAGS) -o $@

    alternatively:

    printenv: printenv.c
    $(CC) $(CFLAGS) $@.c $(LDFLAGS) -o $@

    There are two more special macros used in implicit rules. They are:


    1. $< the name of the related file that caused the action.
    2. $* the prefix shared by target and dependent files.



  • Makefile Target Rules


    The general syntax of a Makefile Target Rule is


    target [target...] : [dependent ....]
    [ command ...]

    Items in brackets are optional, ellipsis means one or more.
    Note the tab to preface each command is required.


    The semantics is pretty simple. When you say "make target"
    make finds the target rule that applies and, if any of the
    dependents are newer than the target, make executes the com-
    mands one at a time (after macro substitution). If any
    dependents have to be made, that happens first (so you have
    a recursion).


    A make will terminate if any command returns a failure sta-
    tus. That's why you see rules like:


    clean:
    -rm *.o *~ core paper

    Make ignores the returned status on command lines that begin
    with a dash. eg. who cares if there is no core file?


    Make will echo the commands, after macro substition to show
    you what's happening as it happens. Sometimes you might want
    to turn that off. For example:


    install:
    @echo You must be root to install



  • Example Target Rules


    For example, to manage sources stored within RCS (sometimes
    you'll need to "check out" a source file):


    SRCS=x.c y.c z.c

    $(SRCS):
    co $@

    To manage sources stored within SCCS (sometimes you'll need
    to "get" a source file):

    $(SRCS):
    sccs get $@

    Alternativley, to manage sources stored within SCCS or RCS
    let's generalize with a macro that we can set as required.

    SRCS=x.c y.c z.c
    # GET= sccs get
    GET= co

    $(SRCS):
    $(GET) $@

    For example, to construct a library of object files

    lib.a: x.o y.o z.o
    ar rvu lib.a x.o y.o z.o
    ranlib lib.a

    Alternatively, to be a bit more fancy you could use:

    OBJ=x.o y.o z.o
    AR=ar

    lib.a: $(OBJ)
    $(AR) rvu $@ $(OBJ)
    ranlib $@

    Since AR is a default macro already assigned to "ar" you can
    get away without defining it (but shouldn't).


    If you get used to using macros you'll be able to make a few
    rules that you can use over and over again.

    For example, to construct a library in some other directory


    INC=../misc
    OTHERS=../misc/lib.a

    $(OTHERS):
    cd $(INC); make lib.a

    Beware:, the following will not work (but you'd think it
    should)

    INC=../misc
    OTHERS=../misc/lib.a

    $(OTHERS):
    cd $(INC)
    make lib.a

    Each command in the target rule is executed in a separate
    shell. This makes for some interesting constructs and long
    continuation lines.


    To generate a tags file


    SRCS=x.c y.c z.c
    CTAGS=ctags -x >tags

    tags: $(SRCS)
    ${CTAGS} $(SRCS)

    On large projects a tags file, that lists all functions and
    their invocations is a handy tool.


    To generate a listing of likely bugs in your problems

    lint:
    lint $(CFLAGS) $(SRCS)

    Lint is a really good tool for finding those obvious
    bugs that slip into programs -- eg. type classes, bad argu-
    ment list, etc.


  • Some Basic Make Rule


    People have come to expect certain targets in Makefiles. You
    should always browse first, but it's reasonable to expect
    that the targets all (or just make), install, and clean will
    be found.



    1. make all -- should compile everything so that you can do local testing before installing things.
    2. make install -- should install things in the right places. But watch out that things are installed in the right place for your system.
    3. make clean -- should clean things up. Get rid of the executables, any temporary files, object files, etc.


    You may encounter other common targets, some have been
    already mentioned (tags and lint).



  • An Example Makefile for printenv



    # make the printenv command
    #
    OWNER=bin
    GROUP=bin
    CTAGS= ctags -x >tags
    CFLAGS= -O
    LDFLAGS= -s
    CC=cc
    GET=co
    SRCS=printenv.c
    OBJS=printenv.o
    SHAR=shar
    MANDIR=/usr/man/manl/printenv.l
    BINDIR=/usr/local/bin
    DEPEND= makedepend $(CFLAGS)
    all: printenv

    # To get things out of the revision control system
    $(SRCS):
    $(GET) $@
    # To make an object from source
    $(CC) $(CFLAGS) -c $*.c

    # To make an executable

    printenv: $(OBJS)
    $(CC) $(LDFLAGS) -o $@ $(OBJS)

    # To install things in the right place
    install: printenv printenv.man
    $(INSTALL) -c -o $(OWNER) -g $(GROUP) -m 755 printenv $(BINDIR)
    $(INSTALL) -c -o $(OWNER) -g $(GROUP) -m 644 printenv.man $(MANDIR)

    # where are functions/procedures?
    tags: $(SRCS)
    $(CTAGS) $(SRCS)

    # what have I done wrong?
    lint: $(SRCS)
    lint $(CFLAGS) $(SRCS)

    # what are the source dependencies
    depend: $(SRCS)
    $(DEPEND) $(SRCS)

    # to make a shar distribution
    shar: clean
    $(SHAR) README Makefile printenv.man $(SRCS) >shar

    # clean out the dross
    clean:
    -rm printenv *~ *.o *.bak core tags shar

    # DO NOT DELETE THIS LINE -- make depend depends on it.
    printenv.o: /usr/include/stdio.h




  • Makefile Implicit Rules


    Consider the rule we used for printenv


    printenv: printenv.c
    $(CC) $(CFLAGS) printenv.c $(LDFLAGS) -o printenv

    We generalized a bit to get

    printenv: printenv.c
    $(CC) $(CFLAGS) $@.c $(LDFLAGS) -o $@

    The command is one that ought to work in all cases where we
    build an executable x out of the source code x.c This can be
    stated as an implicit rule:

    .c:
    $(CC) $(CFLAGS) $@.c $(LDFLAGS) -o $@

    This Implicit rule says how to make x out of x.c -- run cc
    on x.c and call the output x. The rule is implicit because
    no particular target is mentioned. It can be used in all
    cases.


    Another common implicit rule is for the construction of .o
    (object) files out of .c (source files).


    .o.c:
    $(CC) $(CFLAGS) -c $<

    alternatively

    .o.c:
    $(CC) $(CFLAGS) -c $*.c


  • Make Dependencies


    It's pretty common to have source code that uses include
    files. For example:


    % cat program.c

    #include
    #include "defs.h"
    #include "glob.h"
    etc....
    main(argc,argv)
    etc...

    The implicit rule only covers part of the source code depen-
    dency (it only knows that program.o depends on program.c).
    The usual method for handling this is to list the dependen-
    cies separately;

    etc...
    $(CC) $(CFLAGS) -c $*.c
    etc...
    program.o: program.c defs.h glob.h

    Usually an implicit rule and a separate list of dependencies
    is all you need. And it ought to be easy enough to figure
    out what the dependencies are.


    However, there are a number of nice tools around that will
    automatically generate dependency lists for you. For example
    (trivial):


    DEPEND= makedepend $(CFLAGS)
    etc...
    # what are the source dependencies

    depend: $(SRCS)
    $(DEPEND) $(SRCS)

    etc....
    # DO NOT DELETE THIS LINE -- ....

    printenv.o: /usr/include/stdio.h

    These tools (mkdepend, mkmkf, etc.) are very common these
    days and aren't too difficult to use or understand. They're
    just shell scripts that run cpp (or cc -M, or etc.) to find
    out what all the include dependencies are. They then just
    tack the dependency list onto the end of the Makefile.



Based on Make and Makefiles by
Reg Quinton

Computing and Communications Services

The University of Western Ontario

London, Ontario N6A 5B7

Canada




Press here to return to the General Unix Software Menu.