Lines Matching full:it
70 .\" Ix is an indexing macro similar to .IX but I've disabled it for now
82 .\" is numeric, it is taken as the depth for numbering (as for .NH), else
113 .\" that says NOTE in it. Unfortunately, it does cause a break, but
184 purpose. It is provided "as is" without express or implied warranty.
190 can think of for it to do. The basic idea behind PMake is that, for
191 any given system, be it a program or a document or whatever, there
194 must specify, and uses them to build whatever it is you want it to
200 considerably faster. It also has a great deal more functionality than
203 cause a makefile to fail if you don't do something about it), or is
204 simply important, it will be flagged with a little sign in the left
227 (in that order) in the current directory if you don't tell it
237 A makefile has four different types of lines in it:
249 Any line may be continued over multiple lines by ending it with a
291 out-of-date if it has no sources. These operations are represented by
308 if it is found to be out-of-date by using these two rules.
328 If the target is out-of-date according to these rules, it will be re-created.
361 cannot be made by linking together .c files \*- it must be
364 it isn't the .c files that need to be re-created, it's the .o files.
426 for example means all characters between a and z), or both. It matches
435 actually `re-created,' as he likes to spell it?''
443 doesn't actually check to see if the target was created. It just
444 assumes it's there).
453 Each target has associated with it a shell script made up of
538 an error to have occurred if one of the shells it invokes returns a non-zero
539 status. When it detects an error, PMake's usual action is to abort
540 whatever it's doing and exit with a non-zero status itself (any other
563 flag (it stands for backwards-compatible) that forces each command to
564 be given to a separate shell. It also does several other things, all
586 PMake, like Make before it, has the ability to save text in variables
668 Unlike Make, PMake will not expand a variable unless it knows
677 To keep PMake from substituting for a variable it knows, precede the
809 in the makefile will have no effect, because once it
888 are given by PMake to each shell it invokes. They are expanded like
895 etc., it should always use. This variable is examined before the
928 will treat it as a comment, too). If, for some reason, you need to use the `#'
929 in a variable or on a dependency line, put a backslash in front of it.
950 that some makefiles (and programs) are written in such a way that it is
958 There is no way to change it. Thus you cannot run two of them at once
1021 When faced with the writing of a makefile, it is usually best to start
1060 You remember about local variables? Good, so it should come
1067 expressions too (which, of course, requires a name change or two), it
1093 want it to without unnecessary compilations or excessive typing on
1094 your part. There are two things wrong with it, however (aside from it
1138 you could write it like this:
1160 flag lets you do is see what PMake would do without it actually doing
1165 question that comes to mind (after ``What time is it, anyway?'') is
1172 The first causes PMake to tell you as it examines each target in the
1173 makefile and indicate why it is deciding whatever it is deciding. You
1177 flag makes PMake print out its internal state when it is done,
1199 will effectively fall off the edge of the universe, making it
1204 involved in any cycle it looked at (i.e. if you have two cycles in the
1207 make the other to find the second cycle). When run as Make, it will
1223 figure out why PMake is doing what it's doing, you might try using
1229 remember where this table is and come back to it as you read on.
1242 The making of each target: what target is being examined; when it was
1243 last modified; whether it is out-of-date; etc.
1263 is the final argument or the argument from which it would get these
1284 Prints out a summary of the various flags PMake accepts. It can also
1296 by any of its shells. It's like placing a `\-' before all the commands
1302 in that it allows PMake to continue when it sees an error, but unlike
1306 causes it to recognize the error and only continue work on those
1308 depending on something that depends on it), whose creation returned the error.
1314 people executing it in the same directory (by means of a file called
1315 ``LOCK.make'' that it creates and checks for in the directory). This
1321 will turn it off, and vice versa. Note that this locking will not
1323 you own the lock file, PMake will warn you about it but continue to execute.
1337 the commands it would have executed and exit. This is particularly
1339 what you expect it to, it's a good chance the makefile is wrong.
1346 is a bitwise-or of 1 and 2 where 1 means it should print the input
1347 before doing any processing and 2 says it should print it after
1350 would print it twice\*-once before processing and once after (you
1352 useful to me, but you may find it informative in some bizarre circumstances.
1355 If you give PMake this flag, it will not try to re-create anything. It
1359 When PMake starts up, it reads a default makefile that tells it what
1360 sort of system it's on and gives it some idea of what to do if you
1361 don't tell it anything. I'll tell you about it in chapter 3. If you
1365 This causes PMake to not print commands before they're executed. It
1370 Rather than try to re-create a target, PMake will simply ``touch'' it
1371 so as to make it appear up-to-date. If the target didn't exist before,
1372 it will when PMake finishes, but if the target did exist, it will
1377 version of Make. It is the same as giving
1382 in parallel, however. This is the mode PMake will enter if it is
1389 This tells PMake it's ok to export jobs to other machines, if they're
1390 available. It is used when running in Make mode, as exporting in this
1416 is encountered. It is useful mostly in a makefile that you wrote for PMake
1419 or has things set in the environment that tell it to be compatible.
1459 one is not available when it is started.
1464 with Make. It still allows you to use all but a few of the features of
1465 PMake, but it is non-parallel. This is the mode PMake enters if you
1466 call it
1480 output and transferring it to the screen all at once when the job
1482 its children) and buffering it until an entire line is received, then
1484 the output. Since I prefer this second method, it is the one used by
1493 substituting the empty string for any variable it doesn't know.
1497 only a warning, i.e. it can continue to work in spite of your having
1500 and would like PMake to stop bothering you. This flag tells it to shut
1548 or errors from it to be ignored (if
1618 don't forget to compile something. Good. That's just what it is.
1672 into an object file, you compile it using
1679 to it for more examples (type
1681 to find out where it is).
1741 files \*- it's not mentioned anywhere in the new makefile. This is
1742 because it isn't needed: one of the effects of applying a
1744 source. That's why it's called the implied
1762 will do the right thing, it's much more informative to type
1764 This will show you what PMake is up to as it processes the files. In
1771 trying a.c...got it
1774 trying b.c...got it
1799 The transformations it tries are, naturally
1806 line \*- the earlier a suffix appears, the earlier it is checked as
1863 trying jive.l...got it
1872 and looks for things it can transform to a
1874 file. In this case, it only finds
1876 so it looks for the file
1878 It fails to find it, so it looks for transformations into a
1880 file. Again it has only one choice:
1882 So it looks for
1884 and, as you know, fails to find it. At this point it has two choices:
1895 line, it checks for
1897 first, but can't find it, so it looks for
1899 and, lo and behold, there it is.
1900 At this point, it has defined a transformation path as follows:
1935 no known suffix? PMake simply pretends it actually has a known suffix
1937 The suffix it chooses is the source for the
1946 free and welcome to change it to a suffix of your own choosing.
1953 Just as for programs, it is often useful to extract certain parts of a
1954 makefile into another file and just include it in other makefiles
2024 into which it stuffs information for the linker to use. Two of them
2068 them. Others you'll have to find uses for yourself. Think of it as ``an
2071 attribute.'' That's just the way I phrase it, so you know.
2083 how to create it, it will ignore this fact and assume the file isn't
2084 really needed or actually exists and PMake just can't find it. This may prove
2087 attempting to touch the target if it is given the
2095 effect on targets that depend on it. This makes the target into a sort
2145 has been made, thus they depend on it.
2152 your system administrator if it is necessary.
2178 create the other, so it must exist before the other is created. You
2195 rule couldn't be applied. This is not as useful as it should be, and
2202 while permitting everything else to be done so. Specifically it
2207 variable and all the local variables of any target that depends on it,
2215 that I mentioned earlier, only this time it's more severe: you
2217 will need those libraries before it can be re-created. You can do
2249 In case you're wondering, it's called
2251 because it joins together different threads of the ``input graph'' at
2253 Another aspect of the .JOIN attribute is it keeps the target from
2273 and have it descend the directory tree (if your makefiles are set up
2274 correctly), printing what it would have executed if you hadn't
2283 the creation is so simple, it is pointless to send it to another
2286 attribute, it will be run locally, even if you've given PMake the
2309 When PMake is interrupted (you type control-C at the keyboard), it
2313 attribute, however, PMake will leave it alone. An additional side
2326 By giving a target this attribute, you turn it into PMake's equivalent
2337 target to which it is applied (as stored in the
2376 meaning to PMake. When you use one on a dependency line, it is the
2390 is done. You can use it for any initialization that needs doing.
2394 source) that PMake can't figure out any other way to create. It's only
2408 in that commands attached to it are executed once everything has been
2409 re-created (so long as no errors occurred). It also serves the extra
2424 attribute. If you don't give it any sources, then it is like
2470 it will execute the commands in the script for this target, if it
2492 PMake, it will take the sources of this target as the targets to
2510 if, in fact, it has no known suffix. Only one suffix may be so
2516 directories in which to search for files it cannot find in the current
2517 directory. If you give no sources, it will clear out any directories
2519 very complex, I'll leave it til chapter four to give you a complete
2525 but it does it only for files with the given suffix. The suffix must
2549 attribute to all its sources. It does nothing if you don't give it any sources.
2553 the commands you put in the makefile. You can tell it some other shell
2565 as a target, it applies the
2568 dependency line, then it is as if you gave PMake the
2577 suffixes it knew (this also nukes the null suffix).
2578 For those targets that need to have suffixes defined, this is how you do it.
2594 modifiers that may be applied to a variable's value before it is
2595 expanded. You apply a modifier by placing it after the variable name
2636 flags that would be passed to the C compiler. This allows it to
2643 except it substitutes all words that don't match the given pattern.
2686 unless it is preceded by a backslash.
2689 delimiter character may be placed in either string by preceding it
2760 To top it all off, the final executables
2824 exists. Only if it cannot be found there are the directories in the
2829 pattern has a recognizable suffix on it, the path for that suffix will
2851 it will be found using transformation rules if it isn't given. This is because
2861 you have a large system spread over many directories, it would behoove
2866 \&\*- when it is first encountered \*- so any changes to the
2897 PMake solves the problem with archives by allowing you to tell it to
2928 file doesn't exist, but it is in the archive, the modification time
2963 targets that depend on it is taken by the value of its
3036 Like the C compiler before it, PMake allows you to configure the makefile,
3135 process to stop once it has read the makefile. If you want to check
3203 flag, or you can use another target (call it
3206 this for you. I have also made it so defining the variable
3243 to specify a different shell for it to use when executing these
3251 PMake needs to know where the shell actually resides, so it can
3252 execute it. If you specify this and nothing else, PMake will use the
3253 last component of the path and look in its table of the shells it
3254 knows and use the specification it finds, if any. Use this if you just
3258 This is the name by which the shell is to be known. It is a single
3265 will do it).
3271 keyword is the command used to turn echoing off. Once it is turned
3276 Many shells will echo the echo-off command when it is given. This
3279 output, it will delete it and any following whitespace, up to and
3285 PMake wants to start the shell running with echoing on. To do this, it
3300 the shell check for errors. It also serves another purpose if the
3302 in a minute. Again, once error checking has been turned on, it is
3303 expected to remain on until it is turned off again.
3305 This is the command PMake uses to turn error checking off. It has
3333 execute the command to be executed and ignore any error it returns.
3347 way that each command is printed as it is executed. That is, if more
3355 # the commands just before executing them, rather than when it reads
3375 as PMake can figure that out for itself (it's the last component of
3438 the last command it executed).
3453 As noted before, PMake will not expand a variable unless it knows of a
3454 value for it. This can cause problems for makefiles that expect to
3500 the install, leaving the main shell in the directory in which it started.
3509 the compatibility mode for you. It is entered either by giving PMake
3566 When PMake reads the makefile, it parses sources and targets into
3569 parents and children (the nodes that depend on it and those on which
3576 After PMake has parsed the makefile, it begins with the nodes the user
3577 has told it to make (either on the command line, or via a
3582 attribute) placed in a queue. It continues to take the node off the
3583 front of the queue, mark it as something that needs to be made, pass
3600 If the node has no children, it is placed at the end of
3605 queue. PMake removes the node at the head of the queue and sees if it
3606 is out-of-date. If it is, it is passed to a function that will execute
3613 instructed it to create. When the examination queue is empty and no
3633 etc.). Now, PMake's idea of a suffix is more like English's: it's the
3655 and transform it into an invocation of the variable at which it
3669 it), since, as it says in the hint, PMake does no further substitution
3685 A property given to a target that causes PMake to treat it differently.
3705 is much like `:', save it creates multiple instances of a target each
3708 This refers to a source that has a local variable invocation in it. It
3738 A file that describes how a system is built. If you don't know what it
3761 A target that causes PMake to do special things when it's encountered.
3771 is) both a target and a source (what it is depends on how PMake is
3772 looking at it at the time \*- sort of like the wave/particle duality