1 #ifndef _MKSH_DEFS_H
2 #define _MKSH_DEFS_H
3 /*
4 * CDDL HEADER START
5 *
6 * The contents of this file are subject to the terms of the
7 * Common Development and Distribution License (the "License").
8 * You may not use this file except in compliance with the License.
9 *
10 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
11 * or http://www.opensolaris.org/os/licensing.
12 * See the License for the specific language governing permissions
13 * and limitations under the License.
14 *
15 * When distributing Covered Code, include this CDDL HEADER in each
16 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
17 * If applicable, add the following below this CDDL HEADER, with the
18 * fields enclosed by brackets "[]" replaced with your own identifying
19 * information: Portions Copyright [yyyy] [name of copyright owner]
20 *
21 * CDDL HEADER END
22 */
23 /*
24 * Copyright 2004 Sun Microsystems, Inc. All rights reserved.
25 * Use is subject to license terms.
26 */
27
28 #include <limits.h> /* MB_LEN_MAX */
29 #include <stdio.h>
30 #include <stdlib.h> /* wchar_t */
31 #include <string.h> /* strcmp() */
32 #include <sys/param.h> /* MAXPATHLEN */
33 #include <sys/types.h> /* time_t, caddr_t */
34 #include <vroot/vroot.h> /* pathpt */
35 #include <sys/time.h> /* timestruc_t */
36 #include <errno.h> /* errno */
37
38 #include <wctype.h>
39
40 /*
41 * A type and some utilities for boolean values
42 */
43
44 #define false BOOLEAN_false
45 #define true BOOLEAN_true
46
47 typedef enum {
48 false = 0,
49 true = 1,
50 failed = 0,
51 succeeded = 1
52 } Boolean;
53 #define BOOLEAN(expr) ((expr) ? true : false)
54
55 /*
56 * Some random constants (in an enum so dbx knows their values)
57 */
58 enum {
59 update_delay = 30, /* time between rstat checks */
60 ar_member_name_len = 1024,
61 hashsize = 2048 /* size of hash table */
62 };
63
64
65 /*
66 * Symbols that defines all the different char constants make uses
67 */
68 enum {
69 ampersand_char = '&',
70 asterisk_char = '*',
71 at_char = '@',
72 backquote_char = '`',
73 backslash_char = '\\',
74 bar_char = '|',
75 braceleft_char = '{',
76 braceright_char = '}',
77 bracketleft_char = '[',
78 bracketright_char = ']',
79 colon_char = ':',
80 comma_char = ',',
81 dollar_char = '$',
82 doublequote_char = '"',
83 equal_char = '=',
84 exclam_char = '!',
85 greater_char = '>',
86 hat_char = '^',
87 hyphen_char = '-',
88 less_char = '<',
89 newline_char = '\n',
90 nul_char = '\0',
91 numbersign_char = '#',
92 parenleft_char = '(',
93 parenright_char = ')',
94 percent_char = '%',
95 period_char = '.',
96 plus_char = '+',
97 question_char = '?',
98 quote_char = '\'',
99 semicolon_char = ';',
100 slash_char = '/',
101 space_char = ' ',
102 tab_char = '\t',
103 tilde_char = '~'
104 };
105
106 /*
107 * For make i18n. Codeset independent.
108 * Setup character semantics by identifying all the special characters
109 * of make, and assigning each an entry in the char_semantics[] vector.
110 */
111 enum {
112 ampersand_char_entry = 0, /* 0 */
113 asterisk_char_entry, /* 1 */
114 at_char_entry, /* 2 */
115 backquote_char_entry, /* 3 */
116 backslash_char_entry, /* 4 */
117 bar_char_entry, /* 5 */
118 bracketleft_char_entry, /* 6 */
119 bracketright_char_entry, /* 7 */
120 colon_char_entry, /* 8 */
121 dollar_char_entry, /* 9 */
122 doublequote_char_entry, /* 10 */
123 equal_char_entry, /* 11 */
124 exclam_char_entry, /* 12 */
125 greater_char_entry, /* 13 */
126 hat_char_entry, /* 14 */
127 hyphen_char_entry, /* 15 */
128 less_char_entry, /* 16 */
129 newline_char_entry, /* 17 */
130 numbersign_char_entry, /* 18 */
131 parenleft_char_entry, /* 19 */
132 parenright_char_entry, /* 20 */
133 percent_char_entry, /* 21 */
134 plus_char_entry, /* 22 */
135 question_char_entry, /* 23 */
136 quote_char_entry, /* 24 */
137 semicolon_char_entry, /* 25 */
138 no_semantics_entry /* 26 */
139 };
140
141 /*
142 * CHAR_SEMANTICS_ENTRIES should be the number of entries above.
143 * The last entry in char_semantics[] should be blank.
144 */
145 #define CHAR_SEMANTICS_ENTRIES 27
146 /*
147 #define CHAR_SEMANTICS_STRING "&*@`\\|[]:$=!>-\n#()%+?;^<'\""
148 */
149
150 /*
151 * Some utility macros
152 */
153 #define ALLOC(x) ((struct _##x *)getmem(sizeof (struct _##x)))
154 #define ALLOC_WC(x) ((wchar_t *)getmem((x) * SIZEOFWCHAR_T))
155 #define FIND_LENGTH -1
156 #define GETNAME(a,b) getname_fn((a), (b), false)
157 #define IS_EQUAL(a,b) (!strcmp((a), (b)))
158 #define IS_EQUALN(a,b,n) (!strncmp((a), (b), (n)))
159 #define IS_WEQUAL(a,b) (!wcscmp((a), (b)))
160 #define IS_WEQUALN(a,b,n) (!wcsncmp((a), (b), (n)))
161 #define MBLEN(a) mblen((a), MB_LEN_MAX)
162 #define MBSTOWCS(a,b) (void) mbstowcs_with_check((a), (b), MAXPATHLEN)
163 #define MBTOWC(a,b) mbtowc((a), (b), MB_LEN_MAX)
164 #define SIZEOFWCHAR_T (sizeof (wchar_t))
165 #define VSIZEOF(v) (sizeof (v) / sizeof ((v)[0]))
166 #define WCSTOMBS(a,b) (void) wcstombs((a), (b), (MAXPATHLEN * MB_LEN_MAX))
167 #define WCTOMB(a,b) (void) wctomb((a), (b))
168 #define HASH(v, c) (v = (v)*31 + (unsigned int)(c))
169
170 extern void mbstowcs_with_check(wchar_t *pwcs, const char *s, size_t n);
171
172 /*
173 * Bits stored in funny vector to classify chars
174 */
175 enum {
176 dollar_sem = 0001,
177 meta_sem = 0002,
178 percent_sem = 0004,
179 wildcard_sem = 0010,
180 command_prefix_sem = 0020,
181 special_macro_sem = 0040,
182 colon_sem = 0100,
183 parenleft_sem = 0200
184 };
185
186 /*
187 * Type returned from doname class functions
188 */
189 typedef enum {
190 build_dont_know = 0,
191 build_failed,
192 build_ok,
193 build_in_progress,
194 build_running, /* PARALLEL & DISTRIBUTED */
195 build_pending, /* PARALLEL & DISTRIBUTED */
196 build_serial, /* PARALLEL & DISTRIBUTED */
197 build_subtree /* PARALLEL & DISTRIBUTED */
198 } Doname;
199
200 /*
201 * The String struct defines a string with the following layout
202 * "xxxxxxxxxxxxxxxCxxxxxxxxxxxxxxx________"
203 * ^ ^ ^ ^
204 * | | | |
205 * buffer.start text.p text.end buffer.end
206 * text.p points to the next char to read/write.
207 */
208 struct _String {
209 struct Text {
210 wchar_t *p; /* Read/Write pointer */
211 wchar_t *end; /* Read limit pointer */
212 } text;
213 struct Physical_buffer {
214 wchar_t *start; /* Points to start of buffer */
215 wchar_t *end; /* End of physical buffer */
216 } buffer;
217 Boolean free_after_use:1;
218 };
219
220 #define STRING_BUFFER_LENGTH 1024
221 #define INIT_STRING_FROM_STACK(str, buf) { \
222 str.buffer.start = (buf); \
223 str.text.p = (buf); \
224 str.text.end = NULL; \
225 str.buffer.end = (buf) \
226 + (sizeof (buf)/SIZEOFWCHAR_T); \
227 str.free_after_use = false; \
228 }
229
230 #define APPEND_NAME(np, dest, len) append_string((np)->string_mb, (dest), (len));
231
232 class Wstring {
233 public:
234 struct _String string;
235 wchar_t string_buf[STRING_BUFFER_LENGTH];
236
237 public:
238 Wstring();
239 Wstring(struct _Name * name);
240 ~Wstring();
241
242 void init(struct _Name * name);
243 void init(wchar_t * name, unsigned length);
244 unsigned length() {
245 return wcslen(string.buffer.start);
246 };
247 void append_to_str(struct _String * str, unsigned off, unsigned length);
248
249 wchar_t * get_string() {
250 return string.buffer.start;
251 };
252
253 wchar_t * get_string(unsigned off) {
254 return string.buffer.start + off;
255 };
256
257 Boolean equaln(wchar_t * str, unsigned length);
258 Boolean equal(wchar_t * str);
259 Boolean equal(wchar_t * str, unsigned off);
260 Boolean equal(wchar_t * str, unsigned off, unsigned length);
261
262 Boolean equaln(Wstring * str, unsigned length);
263 Boolean equal(Wstring * str);
264 Boolean equal(Wstring * str, unsigned off);
265 Boolean equal(Wstring * str, unsigned off, unsigned length);
266 };
267
268
269 /*
270 * Used for storing the $? list and also for the "target + target:"
271 * construct.
272 */
273 struct _Chain {
274 struct _Chain *next;
275 struct _Name *name;
276 struct _Percent *percent_member;
277 };
278
279 /*
280 * Stores one command line for a rule
281 */
282 struct _Cmd_line {
283 struct _Cmd_line *next;
284 struct _Name *command_line;
285 Boolean make_refd:1; /* $(MAKE) referenced? */
286 /*
287 * Remember any command line prefixes given
288 */
289 Boolean ignore_command_dependency:1; /* `?' */
290 Boolean assign:1; /* `=' */
291 Boolean ignore_error:1; /* `-' */
292 Boolean silent:1; /* `@' */
293 Boolean always_exec:1; /* `+' */
294 };
295
296 /*
297 * Linked list of targets/files
298 */
299 struct _Dependency {
300 struct _Dependency *next;
301 struct _Name *name;
302 Boolean automatic:1;
303 Boolean stale:1;
304 Boolean built:1;
305 };
306
307 /*
308 * The specials are markers for targets that the reader should special case
309 */
310 typedef enum {
311 no_special,
312 built_last_make_run_special,
313 default_special,
314 get_posix_special,
315 get_special,
316 ignore_special,
317 keep_state_file_special,
318 keep_state_special,
319 make_version_special,
320 no_parallel_special,
321 parallel_special,
322 posix_special,
323 precious_special,
324 sccs_get_posix_special,
325 sccs_get_special,
326 silent_special,
327 suffixes_special,
328 svr4_special,
329 localhost_special
330 } Special;
331
332 typedef enum {
333 no_colon,
334 one_colon,
335 two_colon,
336 equal_seen,
337 conditional_seen,
338 none_seen
339 } Separator;
340
341 /*
342 * Magic values for the timestamp stored with each name object
343 */
344
345
346 extern const timestruc_t file_no_time;
347 extern const timestruc_t file_doesnt_exist;
348 extern const timestruc_t file_is_dir;
349 extern const timestruc_t file_min_time;
350 extern const timestruc_t file_max_time;
351
352 /*
353 * Each Name has a list of properties
354 * The properties are used to store information that only
355 * a subset of the Names need
356 */
357 typedef enum {
358 no_prop,
359 conditional_prop,
360 line_prop,
361 macro_prop,
362 makefile_prop,
363 member_prop,
364 recursive_prop,
365 sccs_prop,
366 suffix_prop,
367 target_prop,
368 time_prop,
369 vpath_alias_prop,
370 long_member_name_prop,
371 macro_append_prop,
372 env_mem_prop
373 } Property_id;
374
375 typedef enum {
376 no_daemon = 0,
377 chain_daemon
378 } Daemon;
379
380 struct _Env_mem {
381 char *value;
382 };
383
384 struct _Macro_appendix {
385 struct _Name *value;
386 struct _Name *value_to_append;
387 };
388
389 struct _Macro {
390 /*
391 * For "ABC = xyz" constructs
392 * Name "ABC" get one macro prop
393 */
394 struct _Name *value;
395 Boolean exported:1;
396 Boolean read_only:1;
397 /*
398 * This macro is defined conditionally
399 */
400 Boolean is_conditional:1;
401 /*
402 * The list for $? is stored as a structured list that
403 * is translated into a string iff it is referenced.
404 * This is why some macro values need a daemon.
405 */
406 Daemon daemon:2;
407 };
408
409 struct _Macro_list {
410 struct _Macro_list *next;
411 char *macro_name;
412 char *value;
413 };
414
415 enum sccs_stat {
416 DONT_KNOW_SCCS = 0,
417 NO_SCCS,
418 HAS_SCCS
419 };
420
421 struct _Name {
422 struct _Property *prop; /* List of properties */
423 char *string_mb; /* Multi-byte name string */
424 struct {
425 unsigned int length;
426 } hash;
427 struct {
428 timestruc_t time; /* Modification */
429 int stat_errno; /* error from "stat" */
430 off_t size; /* Of file */
431 mode_t mode; /* Of file */
432 Boolean is_file:1;
433 Boolean is_dir:1;
434 Boolean is_sym_link:1;
435 Boolean is_precious:1;
436 enum sccs_stat has_sccs:2;
437 } stat;
438 /*
439 * Count instances of :: definitions for this target
440 */
441 short colon_splits;
442 /*
443 * We only clear the automatic depes once per target per report
444 */
445 short temp_file_number;
446 /*
447 * Count how many conditional macros this target has defined
448 */
449 short conditional_cnt;
450 /*
451 * A conditional macro was used when building this target
452 */
453 Boolean depends_on_conditional:1;
454 /*
455 * Pointer to list of conditional macros which were used to build
456 * this target
457 */
458 struct _Macro_list *conditional_macro_list;
459 Boolean has_member_depe:1;
460 Boolean is_member:1;
461 /*
462 * This target is a directory that has been read
463 */
464 Boolean has_read_dir:1;
465 /*
466 * This name is a macro that is now being expanded
467 */
468 Boolean being_expanded:1;
469 /*
470 * This name is a magic name that the reader must know about
471 */
472 Special special_reader:5;
473 Doname state:3;
474 Separator colons:3;
475 Boolean has_depe_list_expanded:1;
476 Boolean suffix_scan_done:1;
477 Boolean has_complained:1; /* For sccs */
478 /*
479 * This target has been built during this make run
480 */
481 Boolean ran_command:1;
482 Boolean with_squiggle:1; /* for .SUFFIXES */
483 Boolean without_squiggle:1; /* for .SUFFIXES */
484 Boolean has_read_suffixes:1; /* Suffix list cached*/
485 Boolean has_suffixes:1;
486 Boolean has_target_prop:1;
487 Boolean has_vpath_alias_prop:1;
488 Boolean dependency_printed:1; /* For dump_make_state() */
489 Boolean dollar:1; /* In namestring */
490 Boolean meta:1; /* In namestring */
491 Boolean percent:1; /* In namestring */
492 Boolean wildcard:1; /* In namestring */
493 Boolean has_parent:1;
494 Boolean is_target:1;
495 Boolean has_built:1;
496 Boolean colon:1; /* In namestring */
497 Boolean parenleft:1; /* In namestring */
498 Boolean has_recursive_dependency:1;
499 Boolean has_regular_dependency:1;
500 Boolean is_double_colon:1;
501 Boolean is_double_colon_parent:1;
502 Boolean has_long_member_name:1;
503 /*
504 * allowed to run in parallel
505 */
506 Boolean parallel:1;
507 /*
508 * not allowed to run in parallel
509 */
510 Boolean no_parallel:1;
511 /*
512 * used in dependency_conflict
513 */
514 Boolean checking_subtree:1;
515 Boolean added_pattern_conditionals:1;
516 /*
517 * rechecking target for possible rebuild
518 */
519 Boolean rechecking_target:1;
520 /*
521 * build this target in silent mode
522 */
523 Boolean silent_mode:1;
524 /*
525 * build this target in ignore error mode
526 */
527 Boolean ignore_error_mode:1;
528 Boolean dont_activate_cond_values:1;
529 /*
530 * allowed to run serially on local host
531 */
532 Boolean localhost:1;
533 };
534
535 /*
536 * Stores the % matched default rules
537 */
538 struct _Percent {
539 struct _Percent *next;
540 struct _Name **patterns;
541 struct _Name *name;
542 struct _Percent *dependencies;
543 struct _Cmd_line *command_template;
544 struct _Chain *target_group;
545 int patterns_total;
546 Boolean being_expanded;
547 };
548
549 struct Conditional {
550 /*
551 * For "foo := ABC [+]= xyz" constructs
552 * Name "foo" gets one conditional prop
553 */
554 struct _Name *target;
555 struct _Name *name;
556 struct _Name *value;
557 int sequence;
558 Boolean append:1;
559 };
560
561 struct Line {
562 /*
563 * For "target : dependencies" constructs
564 * Name "target" gets one line prop
565 */
566 struct _Cmd_line *command_template;
567 struct _Cmd_line *command_used;
568 struct _Dependency *dependencies;
569 timestruc_t dependency_time;
570 struct _Chain *target_group;
571 Boolean is_out_of_date:1;
572 Boolean sccs_command:1;
573 Boolean command_template_redefined:1;
574 Boolean dont_rebuild_command_used:1;
575 /*
576 * Values for the dynamic macros
577 */
578 struct _Name *target;
579 struct _Name *star;
580 struct _Name *less;
581 struct _Name *percent;
582 struct _Chain *query;
583 };
584
585 struct Makefile {
586 /*
587 * Names that reference makefiles gets one prop
588 */
589 wchar_t *contents;
590 off_t size;
591 };
592
593 struct Member {
594 /*
595 * For "lib(member)" and "lib((entry))" constructs
596 * Name "lib(member)" gets one member prop
597 * Name "lib((entry))" gets one member prop
598 * The member field is filled in when the prop is refd
599 */
600 struct _Name *library;
601 struct _Name *entry;
602 struct _Name *member;
603 };
604
605 struct Recursive {
606 /*
607 * For "target: .RECURSIVE dir makefiles" constructs
608 * Used to keep track of recursive calls to make
609 * Name "target" gets one recursive prop
610 */
611 struct _Name *directory;
612 struct _Name *target;
613 struct _Dependency *makefiles;
614 Boolean has_built;
615 Boolean in_depinfo;
616 };
617
618 struct Sccs {
619 /*
620 * Each file that has a SCCS s. file gets one prop
621 */
622 struct _Name *file;
623 };
624
625 struct Suffix {
626 /*
627 * Cached list of suffixes that can build this target
628 * suffix is built from .SUFFIXES
629 */
630 struct _Name *suffix;
631 struct _Cmd_line *command_template;
632 };
633
634 struct Target {
635 /*
636 * For "target:: dependencies" constructs
637 * The "::" construct is handled by converting it to
638 * "foo: 1@foo" + "1@foo: dependecies"
639 * "1@foo" gets one target prop
640 * This target prop cause $@ to be bound to "foo"
641 * not "1@foo" when the rule is evaluated
642 */
643 struct _Name *target;
644 };
645
646 struct STime {
647 /*
648 * Save the original time for :: targets
649 */
650 timestruc_t time;
651 };
652
653 struct Vpath_alias {
654 /*
655 * If a file was found using the VPATH it gets
656 * a vpath_alias prop
657 */
658 struct _Name *alias;
659 };
660
661 struct Long_member_name {
662 /*
663 * Targets with a truncated member name carries
664 * the full lib(member) name for the state file
665 */
666 struct _Name *member_name;
667 };
668
669 union Body {
670 struct _Macro macro;
671 struct Conditional conditional;
672 struct Line line;
673 struct Makefile makefile;
674 struct Member member;
675 struct Recursive recursive;
676 struct Sccs sccs;
677 struct Suffix suffix;
678 struct Target target;
679 struct STime time;
680 struct Vpath_alias vpath_alias;
681 struct Long_member_name long_member_name;
682 struct _Macro_appendix macro_appendix;
683 struct _Env_mem env_mem;
684 };
685
686 #define PROPERTY_HEAD_SIZE (sizeof (struct _Property)-sizeof (union Body))
687 struct _Property {
688 struct _Property *next;
689 Property_id type:4;
690 union Body body;
691 };
692
693 /* Structure for dynamic "ascii" arrays */
694 struct ASCII_Dyn_Array {
695 char *start;
696 size_t size;
697 };
698
699 struct _Envvar {
700 struct _Name *name;
701 struct _Name *value;
702 struct _Envvar *next;
703 char *env_string;
704 Boolean already_put:1;
705 };
706
707 /*
708 * Macros for the reader
709 */
710 #define GOTO_STATE(new_state) { \
711 SET_STATE(new_state); \
712 goto enter_state; \
713 }
714 #define SET_STATE(new_state) state = (new_state)
715
716 #define UNCACHE_SOURCE() if (source != NULL) { \
717 source->string.text.p = source_p; \
718 }
719 #define CACHE_SOURCE(comp) if (source != NULL) { \
720 source_p = source->string.text.p - \
721 (comp); \
722 source_end = source->string.text.end; \
723 }
724 #define GET_NEXT_BLOCK_NOCHK(source) { UNCACHE_SOURCE(); \
725 source = get_next_block_fn(source); \
726 CACHE_SOURCE(0) \
727 }
728 #define GET_NEXT_BLOCK(source) { GET_NEXT_BLOCK_NOCHK(source); \
729 if (source != NULL && source->error_converting) { \
730 GOTO_STATE(illegal_bytes_state); \
731 } \
732 }
733 #define GET_CHAR() ((source == NULL) || \
734 (source_p >= source_end) ? 0 : *source_p)
735
736 struct _Source {
737 struct _String string;
738 struct _Source *previous;
739 off_t bytes_left_in_file;
740 short fd;
741 Boolean already_expanded:1;
742 Boolean error_converting:1;
743 char *inp_buf;
744 char *inp_buf_end;
745 char *inp_buf_ptr;
746 };
747
748 typedef enum {
749 reading_nothing,
750 reading_makefile,
751 reading_statefile,
752 rereading_statefile,
753 reading_cpp_file
754 } Makefile_type;
755
756 /*
757 * Typedefs for all structs
758 */
759 typedef struct _Chain *Chain, Chain_rec;
760 typedef struct _Envvar *Envvar, Envvar_rec;
761 typedef struct _Macro_list *Macro_list, Macro_list_rec;
762 typedef struct _Name *Name, Name_rec;
763 typedef struct _Property *Property, Property_rec;
764 typedef struct _Source *Source, Source_rec;
765 typedef struct _String *String, String_rec;
766
767 /*
768 * name records hash table.
769 */
770 struct Name_set {
771 private:
772 // single node in a tree
773 struct entry {
774 entry(Name name_, entry *parent_) :
775 name(name_),
776 parent(parent_),
777 left(0),
778 right(0),
779 depth(1)
780 {}
781
782 Name name;
783
784 entry *parent;
785 entry *left;
786 entry *right;
787 unsigned depth;
788
789 void setup_depth() {
790 unsigned rdepth = (right != 0) ? right->depth : 0;
791 unsigned ldepth = (left != 0) ? left->depth : 0;
792 depth = 1 + ((ldepth > rdepth) ? ldepth : rdepth);
793 }
794 };
795
796 public:
797 // make iterator a friend of Name_set to have access to struct entry
798 struct iterator;
799 friend struct Name_set::iterator;
800
801 // iterator over tree nodes
802 struct iterator {
803 public:
804 // constructors
805 iterator() : node(0) {}
806 iterator(entry *node_) : node(node_) {}
807
808 // dereference operator
809 Name operator->() const { return node->name; }
810
811 // conversion operator
812 operator Name() { return node->name; }
813
814 // assignment operator
815 iterator& operator=(const iterator &o) { node = o.node; return *this; }
816
817 // equality/inequality operators
818 int operator==(const iterator &o) const { return (node == o.node); }
819 int operator!=(const iterator &o) const { return (node != o.node); }
820
821 // pre/post increment operators
822 iterator& operator++();
823 iterator operator++(int) { iterator it = *this; ++*this; return it; }
824
825 private:
826 // the node iterator points to
827 entry *node;
828 };
829
830 public:
831 // constructor
832 Name_set() : root(0) {}
833
834 // lookup, insert and remove operations
835 Name lookup(const char *key);
836 Name insert(const char *key, Boolean &found);
837 void insert(Name name);
838
839 // begin/end iterators
840 iterator begin() const;
841 iterator end() const { return iterator(); }
842
843 private:
844 // rebalance given node
845 void rebalance(entry *node);
846
847 private:
848 // tree root
849 entry *root;
850 };
851
852 /*
853 * extern declarations for all global variables.
854 * The actual declarations are in globals.cc
855 */
856 extern char char_semantics[];
857 extern wchar_t char_semantics_char[];
858 extern Macro_list cond_macro_list;
859 extern Boolean conditional_macro_used;
860 extern Boolean do_not_exec_rule; /* `-n' */
861 extern Boolean dollarget_seen;
862 extern Boolean dollarless_flag;
863 extern Name dollarless_value;
864 extern char **environ;
865 extern Envvar envvar;
866 extern int exit_status;
867 extern wchar_t *file_being_read;
868 /* Variable gnu_style=true if env. var. SUN_MAKE_COMPAT_MODE=GNU (RFE 4866328) */
869 extern Boolean gnu_style;
870 extern Name_set hashtab;
871 extern Name host_arch;
872 extern Name host_mach;
873 extern int line_number;
874 extern char *make_state_lockfile;
875 extern Boolean make_word_mentioned;
876 extern Makefile_type makefile_type;
877 extern char mbs_buffer[];
878 extern Name path_name;
879 extern Boolean posix;
880 extern Name query;
881 extern Boolean query_mentioned;
882 extern Name hat;
883 extern Boolean reading_environment;
884 extern Name shell_name;
885 extern Boolean svr4;
886 extern Name target_arch;
887 extern Name target_mach;
888 extern Boolean tilde_rule;
889 extern wchar_t wcs_buffer[];
890 extern Boolean working_on_targets;
891 extern Name virtual_root;
892 extern Boolean vpath_defined;
893 extern Name vpath_name;
894 extern Boolean make_state_locked;
895 extern Boolean out_err_same;
896 extern pid_t childPid;
897
898 /*
899 * RFE 1257407: make does not use fine granularity time info available from stat.
900 * High resolution time comparison.
901 */
902
903 inline int
904 operator==(const timestruc_t &t1, const timestruc_t &t2) {
905 return ((t1.tv_sec == t2.tv_sec) && (t1.tv_nsec == t2.tv_nsec));
906 }
907
908 inline int
909 operator!=(const timestruc_t &t1, const timestruc_t &t2) {
910 return ((t1.tv_sec != t2.tv_sec) || (t1.tv_nsec != t2.tv_nsec));
911 }
912
913 inline int
914 operator>(const timestruc_t &t1, const timestruc_t &t2) {
915 if (t1.tv_sec == t2.tv_sec) {
916 return (t1.tv_nsec > t2.tv_nsec);
917 }
918 return (t1.tv_sec > t2.tv_sec);
919 }
920
921 inline int
922 operator>=(const timestruc_t &t1, const timestruc_t &t2) {
923 if (t1.tv_sec == t2.tv_sec) {
924 return (t1.tv_nsec >= t2.tv_nsec);
925 }
926 return (t1.tv_sec > t2.tv_sec);
927 }
928
929 inline int
930 operator<(const timestruc_t &t1, const timestruc_t &t2) {
931 if (t1.tv_sec == t2.tv_sec) {
932 return (t1.tv_nsec < t2.tv_nsec);
933 }
934 return (t1.tv_sec < t2.tv_sec);
935 }
936
937 inline int
938 operator<=(const timestruc_t &t1, const timestruc_t &t2) {
939 if (t1.tv_sec == t2.tv_sec) {
940 return (t1.tv_nsec <= t2.tv_nsec);
941 }
942 return (t1.tv_sec < t2.tv_sec);
943 }
944
945 #endif