Lines Matching full:it
37 .\" is numeric, it is taken as the depth for numbering (as for .NH), else
69 .\" that says NOTE in it. Unfortunately, it does cause a break, but
130 purpose. It is provided "as is" without express or implied warranty.
136 can think of for it to do. The basic idea behind PMake is that, for
137 any given system, be it a program or a document or whatever, there
140 must specify, and uses them to build whatever it is you want it to
146 considerably faster. It also has a great deal more functionality than
149 cause a makefile to fail if you don't do something about it), or is
150 simply important, it will be flagged with a little sign in the left
173 (in that order) in the current directory if you don't tell it
183 A makefile has four different types of lines in it:
195 Any line may be continued over multiple lines by ending it with a
237 out-of-date if it has no sources. These operations are represented by
254 if it is found to be out-of-date by using these two rules.
274 If the target is out-of-date according to these rules, it will be re-created.
307 cannot be made by linking together .c files \*- it must be
310 it isn't the .c files that need to be re-created, it's the .o files.
372 for example means all characters between a and z), or both. It matches
381 actually `re-created,' as he likes to spell it?''
389 doesn't actually check to see if the target was created. It just
390 assumes it's there).
399 Each target has associated with it a shell script made up of
484 an error to have occurred if one of the shells it invokes returns a non-zero
485 status. When it detects an error, PMake's usual action is to abort
486 whatever it's doing and exit with a non-zero status itself (any other
509 flag (it stands for backwards-compatible) that forces each command to
510 be given to a separate shell. It also does several other things, all
532 PMake, like Make before it, has the ability to save text in variables
614 Unlike Make, PMake will not expand a variable unless it knows
623 To keep PMake from substituting for a variable it knows, precede the
755 in the makefile will have no effect, because once it
834 are given by PMake to each shell it invokes. They are expanded like
841 etc., it should always use. This variable is examined before the
874 will treat it as a comment, too). If, for some reason, you need to use the `#'
875 in a variable or on a dependency line, put a backslash in front of it.
896 that some makefiles (and programs) are written in such a way that it is
904 There is no way to change it. Thus you cannot run two of them at once
967 When faced with the writing of a makefile, it is usually best to start
1006 You remember about local variables? Good, so it should come
1013 expressions too (which, of course, requires a name change or two), it
1039 want it to without unnecessary compilations or excessive typing on
1040 your part. There are two things wrong with it, however (aside from it
1084 you could write it like this:
1106 flag lets you do is see what PMake would do without it actually doing
1111 question that comes to mind (after ``What time is it, anyway?'') is
1118 The first causes PMake to tell you as it examines each target in the
1119 makefile and indicate why it is deciding whatever it is deciding. You
1123 flag makes PMake print out its internal state when it is done,
1145 will effectively fall off the edge of the universe, making it
1150 involved in any cycle it looked at (i.e. if you have two cycles in the
1153 make the other to find the second cycle). When run as Make, it will
1169 figure out why PMake is doing what it's doing, you might try using
1175 remember where this table is and come back to it as you read on.
1188 The making of each target: what target is being examined; when it was
1189 last modified; whether it is out-of-date; etc.
1209 is the final argument or the argument from which it would get these
1230 Prints out a summary of the various flags PMake accepts. It can also
1242 by any of its shells. It's like placing a `\-' before all the commands
1248 in that it allows PMake to continue when it sees an error, but unlike
1252 causes it to recognize the error and only continue work on those
1254 depending on something that depends on it), whose creation returned the error.
1260 people executing it in the same directory (by means of a file called
1261 ``LOCK.make'' that it creates and checks for in the directory). This
1267 will turn it off, and vice versa. Note that this locking will not
1269 you own the lock file, PMake will warn you about it but continue to execute.
1283 the commands it would have executed and exit. This is particularly
1285 what you expect it to, it's a good chance the makefile is wrong.
1292 is a bitwise-or of 1 and 2 where 1 means it should print the input
1293 before doing any processing and 2 says it should print it after
1296 would print it twice\*-once before processing and once after (you
1298 useful to me, but you may find it informative in some bizarre circumstances.
1301 If you give PMake this flag, it will not try to re-create anything. It
1305 When PMake starts up, it reads a default makefile that tells it what
1306 sort of system it's on and gives it some idea of what to do if you
1307 don't tell it anything. I'll tell you about it in chapter 3. If you
1311 This causes PMake to not print commands before they're executed. It
1316 Rather than try to re-create a target, PMake will simply ``touch'' it
1317 so as to make it appear up-to-date. If the target didn't exist before,
1318 it will when PMake finishes, but if the target did exist, it will
1323 version of Make. It is the same as giving
1328 in parallel, however. This is the mode PMake will enter if it is
1335 This tells PMake it's ok to export jobs to other machines, if they're
1336 available. It is used when running in Make mode, as exporting in this
1362 is encountered. It is useful mostly in a makefile that you wrote for PMake
1365 or has things set in the environment that tell it to be compatible.
1405 one is not available when it is started.
1410 with Make. It still allows you to use all but a few of the features of
1411 PMake, but it is non-parallel. This is the mode PMake enters if you
1412 call it
1426 output and transferring it to the screen all at once when the job
1428 its children) and buffering it until an entire line is received, then
1430 the output. Since I prefer this second method, it is the one used by
1439 substituting the empty string for any variable it doesn't know.
1443 only a warning, i.e. it can continue to work in spite of your having
1446 and would like PMake to stop bothering you. This flag tells it to shut
1494 or errors from it to be ignored (if
1564 don't forget to compile something. Good. That's just what it is.
1618 into an object file, you compile it using
1625 to it for more examples (type
1627 to find out where it is).
1687 files \*- it's not mentioned anywhere in the new makefile. This is
1688 because it isn't needed: one of the effects of applying a
1690 source. That's why it's called the implied
1708 will do the right thing, it's much more informative to type
1710 This will show you what PMake is up to as it processes the files. In
1717 trying a.c...got it
1720 trying b.c...got it
1745 The transformations it tries are, naturally
1752 line \*- the earlier a suffix appears, the earlier it is checked as
1809 trying jive.l...got it
1818 and looks for things it can transform to a
1820 file. In this case, it only finds
1822 so it looks for the file
1824 It fails to find it, so it looks for transformations into a
1826 file. Again it has only one choice:
1828 So it looks for
1830 and, as you know, fails to find it. At this point it has two choices:
1841 line, it checks for
1843 first, but can't find it, so it looks for
1845 and, lo and behold, there it is.
1846 At this point, it has defined a transformation path as follows:
1881 no known suffix? PMake simply pretends it actually has a known suffix
1883 The suffix it chooses is the source for the
1892 free and welcome to change it to a suffix of your own choosing.
1899 Just as for programs, it is often useful to extract certain parts of a
1900 makefile into another file and just include it in other makefiles
1970 into which it stuffs information for the linker to use. Two of them
2014 them. Others you'll have to find uses for yourself. Think of it as ``an
2017 attribute.'' That's just the way I phrase it, so you know.
2029 how to create it, it will ignore this fact and assume the file isn't
2030 really needed or actually exists and PMake just can't find it. This may prove
2033 attempting to touch the target if it is given the
2041 effect on targets that depend on it. This makes the target into a sort
2091 has been made, thus they depend on it.
2098 your system administrator if it is necessary.
2124 create the other, so it must exist before the other is created. You
2141 rule couldn't be applied. This is not as useful as it should be, and
2148 while permitting everything else to be done so. Specifically it
2153 variable and all the local variables of any target that depends on it,
2161 that I mentioned earlier, only this time it's more severe: you
2163 will need those libraries before it can be re-created. You can do
2195 In case you're wondering, it's called
2197 because it joins together different threads of the ``input graph'' at
2199 Another aspect of the .JOIN attribute is it keeps the target from
2219 and have it descend the directory tree (if your makefiles are set up
2220 correctly), printing what it would have executed if you hadn't
2229 the creation is so simple, it is pointless to send it to another
2232 attribute, it will be run locally, even if you've given PMake the
2255 When PMake is interrupted (you type control-C at the keyboard), it
2259 attribute, however, PMake will leave it alone. An additional side
2272 By giving a target this attribute, you turn it into PMake's equivalent
2283 target to which it is applied (as stored in the
2322 meaning to PMake. When you use one on a dependency line, it is the
2336 is done. You can use it for any initialization that needs doing.
2340 source) that PMake can't figure out any other way to create. It's only
2354 in that commands attached to it are executed once everything has been
2355 re-created (so long as no errors occurred). It also serves the extra
2370 attribute. If you don't give it any sources, then it is like
2416 it will execute the commands in the script for this target, if it
2438 PMake, it will take the sources of this target as the targets to
2456 if, in fact, it has no known suffix. Only one suffix may be so
2462 directories in which to search for files it cannot find in the current
2463 directory. If you give no sources, it will clear out any directories
2465 very complex, I'll leave it til chapter four to give you a complete
2471 but it does it only for files with the given suffix. The suffix must
2495 attribute to all its sources. It does nothing if you don't give it any sources.
2499 the commands you put in the makefile. You can tell it some other shell
2511 as a target, it applies the
2514 dependency line, then it is as if you gave PMake the
2523 suffixes it knew (this also nukes the null suffix).
2524 For those targets that need to have suffixes defined, this is how you do it.
2540 modifiers that may be applied to a variable's value before it is
2541 expanded. You apply a modifier by placing it after the variable name
2582 flags that would be passed to the C compiler. This allows it to
2589 except it substitutes all words that don't match the given pattern.
2632 unless it is preceded by a backslash.
2635 delimiter character may be placed in either string by preceding it
2706 To top it all off, the final executables
2770 exists. Only if it cannot be found there are the directories in the
2775 pattern has a recognizable suffix on it, the path for that suffix will
2797 it will be found using transformation rules if it isn't given. This is because
2807 you have a large system spread over many directories, it would behoove
2812 \&\*- when it is first encountered \*- so any changes to the
2843 PMake solves the problem with archives by allowing you to tell it to
2874 file doesn't exist, but it is in the archive, the modification time
2909 targets that depend on it is taken by the value of its
2982 Like the C compiler before it, PMake allows you to configure the makefile,
3081 process to stop once it has read the makefile. If you want to check
3149 flag, or you can use another target (call it
3152 this for you. I have also made it so defining the variable
3189 to specify a different shell for it to use when executing these
3197 PMake needs to know where the shell actually resides, so it can
3198 execute it. If you specify this and nothing else, PMake will use the
3199 last component of the path and look in its table of the shells it
3200 knows and use the specification it finds, if any. Use this if you just
3204 This is the name by which the shell is to be known. It is a single
3211 will do it).
3217 keyword is the command used to turn echoing off. Once it is turned
3222 Many shells will echo the echo-off command when it is given. This
3225 output, it will delete it and any following whitespace, up to and
3231 PMake wants to start the shell running with echoing on. To do this, it
3246 the shell check for errors. It also serves another purpose if the
3248 in a minute. Again, once error checking has been turned on, it is
3249 expected to remain on until it is turned off again.
3251 This is the command PMake uses to turn error checking off. It has
3279 execute the command to be executed and ignore any error it returns.
3293 way that each command is printed as it is executed. That is, if more
3301 # the commands just before executing them, rather than when it reads
3321 as PMake can figure that out for itself (it's the last component of
3384 the last command it executed).
3399 As noted before, PMake will not expand a variable unless it knows of a
3400 value for it. This can cause problems for makefiles that expect to
3446 the install, leaving the main shell in the directory in which it started.
3455 the compatibility mode for you. It is entered either by giving PMake
3512 When PMake reads the makefile, it parses sources and targets into
3515 parents and children (the nodes that depend on it and those on which
3522 After PMake has parsed the makefile, it begins with the nodes the user
3523 has told it to make (either on the command line, or via a
3528 attribute) placed in a queue. It continues to take the node off the
3529 front of the queue, mark it as something that needs to be made, pass
3546 If the node has no children, it is placed at the end of
3551 queue. PMake removes the node at the head of the queue and sees if it
3552 is out-of-date. If it is, it is passed to a function that will execute
3559 instructed it to create. When the examination queue is empty and no
3579 etc.). Now, PMake's idea of a suffix is more like English's: it's the
3601 and transform it into an invocation of the variable at which it
3615 it), since, as it says in the hint, PMake does no further substitution
3631 A property given to a target that causes PMake to treat it differently.
3651 is much like `:', save it creates multiple instances of a target each
3654 This refers to a source that has a local variable invocation in it. It
3684 A file that describes how a system is built. If you don't know what it
3707 A target that causes PMake to do special things when it's encountered.
3717 is) both a target and a source (what it is depends on how PMake is
3718 looking at it at the time \*- sort of like the wave/particle duality