Print this page
make: translate using gettext, rather than the unmaintainable catgets
| Split |
Close |
| Expand all |
| Collapse all |
--- old/usr/src/cmd/make/bin/pmake.cc
+++ new/usr/src/cmd/make/bin/pmake.cc
1 1 /*
2 2 * CDDL HEADER START
3 3 *
4 4 * The contents of this file are subject to the terms of the
5 5 * Common Development and Distribution License (the "License").
6 6 * You may not use this file except in compliance with the License.
7 7 *
8 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 9 * or http://www.opensolaris.org/os/licensing.
10 10 * See the License for the specific language governing permissions
11 11 * and limitations under the License.
12 12 *
13 13 * When distributing Covered Code, include this CDDL HEADER in each
14 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 15 * If applicable, add the following below this CDDL HEADER, with the
16 16 * fields enclosed by brackets "[]" replaced with your own identifying
17 17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 18 *
19 19 * CDDL HEADER END
20 20 */
21 21 /*
22 22 * Copyright 2004 Sun Microsystems, Inc. All rights reserved.
23 23 * Use is subject to license terms.
24 24 */
25 25
26 26
27 27 /*
28 28 * Included files
29 29 */
|
↓ open down ↓ |
29 lines elided |
↑ open up ↑ |
30 30 #include <arpa/inet.h>
31 31 #include <mk/defs.h>
32 32 #include <mksh/misc.h>
33 33 #include <netdb.h>
34 34 #include <netinet/in.h>
35 35 #include <sys/socket.h>
36 36 #include <sys/stat.h>
37 37 #include <sys/types.h>
38 38 #include <sys/utsname.h>
39 39 #include <rpc/rpc.h> /* host2netname(), netname2host() */
40 +#include <libintl.h>
40 41
41 42 /*
42 43 * Defined macros
43 44 */
44 45
45 46 /*
46 47 * typedefs & structs
47 48 */
48 49
49 50 /*
50 51 * Static variables
51 52 */
52 53
53 54 /*
54 55 * File table of contents
55 56 */
56 57 static int get_max(wchar_t **ms_address, wchar_t *hostname);
57 58 static Boolean pskip_comment(wchar_t **cp_address);
58 59 static void pskip_till_next_word(wchar_t **cp);
59 60 static Boolean pskip_white_space(wchar_t **cp_address);
60 61
61 62
62 63 /*
63 64 * read_make_machines(Name make_machines_name)
64 65 *
65 66 * For backwards compatibility w/ PMake 1.x, when DMake 2.x is
66 67 * being run in parallel mode, DMake should parse the PMake startup
67 68 * file $(HOME)/.make.machines to get the PMake max jobs.
68 69 *
69 70 * Return value:
70 71 * int of PMake max jobs
71 72 *
72 73 * Parameters:
73 74 * make_machines_name Name of .make.machines file
74 75 *
75 76 */
76 77 int
77 78 read_make_machines(Name make_machines_name)
78 79 {
79 80 wchar_t c;
80 81 Boolean default_make_machines;
81 82 struct hostent *hp;
82 83 wchar_t local_host[MAX_HOSTNAMELEN + 1];
83 84 char local_host_mb[MAX_HOSTNAMELEN + 1] = "";
84 85 int local_host_wslen;
85 86 wchar_t full_host[MAXNETNAMELEN + 1];
86 87 int full_host_wslen = 0;
87 88 char *homedir;
88 89 Name MAKE_MACHINES;
89 90 struct stat make_machines_buf;
90 91 FILE *make_machines_file;
|
↓ open down ↓ |
41 lines elided |
↑ open up ↑ |
91 92 wchar_t *make_machines_list = NULL;
92 93 char *make_machines_list_mb = NULL;
93 94 wchar_t make_machines_path[MAXPATHLEN];
94 95 char mb_make_machines_path[MAXPATHLEN];
95 96 wchar_t *mp;
96 97 wchar_t *ms;
97 98 int pmake_max_jobs = 0;
98 99 struct utsname uts_info;
99 100
100 101
101 - MBSTOWCS(wcs_buffer, NOCATGETS("MAKE_MACHINES"));
102 + MBSTOWCS(wcs_buffer, "MAKE_MACHINES");
102 103 MAKE_MACHINES = GETNAME(wcs_buffer, FIND_LENGTH);
103 104 /* Did the user specify a .make.machines file on the command line? */
104 105 default_make_machines = false;
105 106 if (make_machines_name == NULL) {
106 107 /* Try reading the default .make.machines file, in $(HOME). */
107 - homedir = getenv(NOCATGETS("HOME"));
108 + homedir = getenv("HOME");
108 109 if ((homedir != NULL) && (strlen(homedir) < (sizeof(mb_make_machines_path) - 16))) {
109 110 sprintf(mb_make_machines_path,
110 - NOCATGETS("%s/.make.machines"), homedir);
111 + "%s/.make.machines", homedir);
111 112 MBSTOWCS(make_machines_path, mb_make_machines_path);
112 113 make_machines_name = GETNAME(make_machines_path, FIND_LENGTH);
113 114 default_make_machines = true;
114 115 }
115 116 if (make_machines_name == NULL) {
116 117 /*
117 118 * No $(HOME)/.make.machines file.
118 119 * Return 0 for PMake max jobs.
119 120 */
120 121 return(0);
121 122 }
122 123 }
123 124 /*
124 125 make_machines_list_mb = getenv(MAKE_MACHINES->string_mb);
125 126 */
126 127 /* Open the .make.machines file. */
127 128 if ((make_machines_file = fopen(make_machines_name->string_mb, "r")) == NULL) {
128 129 if (!default_make_machines) {
129 130 /* Error opening .make.machines file. */
130 - fatal(catgets(catd, 1, 314, "Open of %s failed: %s"),
131 + fatal(gettext("Open of %s failed: %s"),
131 132 make_machines_name->string_mb,
132 133 errmsg(errno));
133 134 } else {
134 135 /*
135 136 * No $(HOME)/.make.machines file.
136 137 * Return 0 for PMake max jobs.
137 138 */
138 139 return(0);
139 140 }
140 141 /* Stat the .make.machines file to get the size of the file. */
141 142 } else if (fstat(fileno(make_machines_file), &make_machines_buf) < 0) {
142 143 /* Error stat'ing .make.machines file. */
143 - fatal(catgets(catd, 1, 315, "Stat of %s failed: %s"),
144 + fatal(gettext("Stat of %s failed: %s"),
144 145 make_machines_name->string_mb,
145 146 errmsg(errno));
146 147 } else {
147 148 /* Allocate memory for "MAKE_MACHINES=<contents of .m.m>" */
148 149 make_machines_list_mb =
149 150 (char *) getmem((int) (strlen(MAKE_MACHINES->string_mb) +
150 151 2 +
151 152 make_machines_buf.st_size));
152 153 sprintf(make_machines_list_mb,
153 154 "%s=",
154 155 MAKE_MACHINES->string_mb);
155 156 /* Read in the .make.machines file. */
156 157 if (fread(make_machines_list_mb + strlen(MAKE_MACHINES->string_mb) + 1,
157 158 sizeof(char),
158 159 (int) make_machines_buf.st_size,
159 160 make_machines_file) != make_machines_buf.st_size) {
160 161 /*
161 162 * Error reading .make.machines file.
162 163 * Return 0 for PMake max jobs.
163 164 */
164 - warning(catgets(catd, 1, 316, "Unable to read %s"),
165 + warning(gettext("Unable to read %s"),
165 166 make_machines_name->string_mb);
166 167 (void) fclose(make_machines_file);
167 168 retmem_mb((caddr_t) make_machines_list_mb);
168 169 return(0);
169 170 } else {
170 171 (void) fclose(make_machines_file);
171 172 /* putenv "MAKE_MACHINES=<contents of .m.m>" */
172 173 *(make_machines_list_mb +
173 174 strlen(MAKE_MACHINES->string_mb) +
174 175 1 +
175 176 make_machines_buf.st_size) = (int) nul_char;
176 177 if (putenv(make_machines_list_mb) != 0) {
177 - warning(catgets(catd, 1, 317, "Couldn't put contents of %s in environment"),
178 + warning(gettext("Couldn't put contents of %s in environment"),
178 179 make_machines_name->string_mb);
179 180 } else {
180 181 make_machines_list_mb += strlen(MAKE_MACHINES->string_mb) + 1;
181 182 make_machines_list = ALLOC_WC(strlen(make_machines_list_mb) + 1);
182 183 (void) mbstowcs(make_machines_list,
183 184 make_machines_list_mb,
184 185 (strlen(make_machines_list_mb) + 1));
185 186 }
186 187 }
187 188 }
188 189
189 190 uname(&uts_info);
190 191 strcpy(local_host_mb, &uts_info.nodename[0]);
191 192 MBSTOWCS(local_host, local_host_mb);
192 193 local_host_wslen = wslen(local_host);
193 194
194 195 // There is no getdomainname() function on Solaris.
195 196 // And netname2host() function does not work on Linux.
196 197 // So we have to use different APIs.
197 198 if (host2netname(mbs_buffer, NULL, NULL) &&
198 199 netname2host(mbs_buffer, mbs_buffer2, MAXNETNAMELEN+1)) {
199 200 MBSTOWCS(full_host, mbs_buffer2);
200 201 full_host_wslen = wslen(full_host);
201 202 }
202 203
203 204 for (ms = make_machines_list;
204 205 (ms) && (*ms );
205 206 ) {
206 207 /*
207 208 * Skip white space and comments till you reach
208 209 * a machine name.
209 210 */
210 211 pskip_till_next_word(&ms);
211 212
212 213 /*
213 214 * If we haven't reached the end of file, process the
214 215 * machine name.
215 216 */
216 217 if (*ms) {
217 218 /*
218 219 * If invalid machine name decrement counter
219 220 * and skip line.
220 221 */
221 222 mp = ms;
222 223 SKIPWORD(ms);
223 224 c = *ms;
224 225 *ms++ = '\0'; /* Append null to machine name. */
225 226 /*
226 227 * If this was the beginning of a comment
227 228 * (we overwrote a # sign) and it's not
228 229 * end of line yet, shift the # sign.
229 230 */
230 231 if ((c == '#') && (*ms != '\n') && (*ms)) {
|
↓ open down ↓ |
43 lines elided |
↑ open up ↑ |
231 232 *ms = '#';
232 233 }
233 234 WCSTOMBS(mbs_buffer, mp);
234 235 /*
235 236 * Print "Ignoring unknown host" if:
236 237 * 1) hostname is longer than MAX_HOSTNAMELEN, or
237 238 * 2) hostname is unknown
238 239 */
239 240 if ((wslen(mp) > MAX_HOSTNAMELEN) ||
240 241 ((hp = gethostbyname(mbs_buffer)) == NULL)) {
241 - warning(catgets(catd, 1, 318, "Ignoring unknown host %s"),
242 + warning(gettext("Ignoring unknown host %s"),
242 243 mbs_buffer);
243 244 SKIPTOEND(ms);
244 245 /* Increment ptr if not end of file. */
245 246 if (*ms) {
246 247 ms++;
247 248 }
248 249 } else {
249 250 /* Compare current hostname with local_host. */
250 251 if (wslen(mp) == local_host_wslen &&
251 252 IS_WEQUALN(mp, local_host, local_host_wslen)) {
252 253 /*
253 254 * Bingo, local_host is in .make.machines.
254 255 * Continue reading.
255 256 */
256 257 pmake_max_jobs = PMAKE_DEF_MAX_JOBS;
257 258 /* Compare current hostname with full_host. */
258 259 } else if (wslen(mp) == full_host_wslen &&
259 260 IS_WEQUALN(mp, full_host, full_host_wslen)) {
260 261 /*
261 262 * Bingo, full_host is in .make.machines.
262 263 * Continue reading.
263 264 */
264 265 pmake_max_jobs = PMAKE_DEF_MAX_JOBS;
265 266 } else {
266 267 if (c != '\n') {
|
↓ open down ↓ |
15 lines elided |
↑ open up ↑ |
267 268 SKIPTOEND(ms);
268 269 if (*ms) {
269 270 ms++;
270 271 }
271 272 }
272 273 continue;
273 274 }
274 275 /* If we get here, local_host is in .make.machines. */
275 276 if (c != '\n') {
276 277 /* Now look for keyword 'max'. */
277 - MBSTOWCS(wcs_buffer, NOCATGETS("max"));
278 + MBSTOWCS(wcs_buffer, "max");
278 279 SKIPSPACE(ms);
279 280 while ((*ms != '\n') && (*ms)) {
280 281 if (*ms == '#') {
281 282 pskip_comment(&ms);
282 283 } else if (IS_WEQUALN(ms, wcs_buffer, 3)) {
283 284 /* Skip "max". */
284 285 ms += 3;
285 286 pmake_max_jobs = get_max(&ms, mp);
286 287 SKIPSPACE(ms);
287 288 } else {
288 - warning(catgets(catd, 1, 322, "unknown option for host %s"), mbs_buffer);
289 + warning(gettext("unknown option for host %s"), mbs_buffer);
289 290 SKIPTOEND(ms);
290 291 break;
291 292 }
292 293 }
293 294 }
294 295 break; /* out of outermost for() loop. */
295 296 }
296 297 }
297 298 }
298 299 retmem(make_machines_list);
299 300 return(pmake_max_jobs);
300 301 }
301 302
302 303 /*
303 304 * pskip_till_next_word(cp)
304 305 *
305 306 * Parameters:
306 307 * cp the address of the string pointer.
307 308 *
308 309 * On return:
309 310 * cp points to beginning of machine name.
310 311 *
311 312 */
312 313 static void
313 314 pskip_till_next_word(wchar_t **cp)
314 315 {
315 316 /*
316 317 * Keep recursing until all combinations of white spaces
317 318 * and comments have been skipped.
318 319 */
319 320 if (pskip_white_space(cp) || pskip_comment(cp)) {
320 321 pskip_till_next_word(cp);
321 322 }
322 323 }
323 324
324 325 /*
325 326 * pskip_white_space(cp_address)
326 327 *
327 328 * Advances the string pointer so that it points to the first
328 329 * non white character (space/tab/linefeed).
329 330 *
330 331 * Parameters:
331 332 * cp_address the address of the string pointer.
332 333 *
333 334 * Return Value:
334 335 * True if the pointer was changed.
335 336 *
336 337 */
337 338 static Boolean
338 339 pskip_white_space(wchar_t **cp_address)
339 340 {
340 341 wchar_t *cp = *cp_address;
341 342
342 343 while (*cp && iswspace(*cp)) {
343 344 cp++;
344 345 }
345 346 /* Have we skipped any characters? */
346 347 if (cp != *cp_address) {
347 348 *cp_address = cp;
348 349 return(true);
349 350 } else {
350 351 return(false);
351 352 }
352 353 }
353 354
354 355 /*
355 356 * pskip_comment(cp_address)
356 357 *
357 358 * If cp_address is pointing to '#' (the beginning of a comment),
358 359 * increment the pointer till you reach end of line.
359 360 *
360 361 * Parameters:
361 362 * cp_address the address of the string pointer.
362 363 *
363 364 * Return Value:
364 365 * True if the pointer was changed.
365 366 *
366 367 */
367 368 static Boolean
368 369 pskip_comment(wchar_t **cp_address)
369 370 {
370 371 wchar_t *cp = *cp_address;
371 372
372 373 /* Is this the beginning of a comment? Skip till end of line. */
373 374 if (*cp == '#') {
374 375 SKIPTOEND(cp);
375 376 }
376 377 /* Have we skipped a comment line? */
377 378 if (cp != *cp_address) {
378 379 *cp_address = cp;
379 380 return(true);
380 381 } else {
381 382 return(false);
382 383 }
383 384 }
384 385
385 386 static int
|
↓ open down ↓ |
87 lines elided |
↑ open up ↑ |
386 387 get_max(wchar_t **ms_address, wchar_t *hostname)
387 388 {
388 389 wchar_t *ms = *ms_address;
389 390 int limit = PMAKE_DEF_MAX_JOBS; /* Default setting. */
390 391
391 392 WCSTOMBS(mbs_buffer, hostname);
392 393 /* Look for `='. */
393 394 SKIPSPACE(ms);
394 395 if ((!*ms) || (*ms == '\n') || (*ms != '=')) {
395 396 SKIPTOEND(ms);
396 - warning(catgets(catd, 1, 319, "expected `=' after max, ignoring rest of line for host %s"),
397 + warning(gettext("expected `=' after max, ignoring rest of line for host %s"),
397 398 mbs_buffer);
398 399 *ms_address = ms;
399 400 return((int) limit);
400 401 } else {
401 402 ms++;
402 403 SKIPSPACE(ms);
403 404 if ((*ms != '\n') && (*ms != '\0')) {
404 405 /* We've found, hopefully, a valid "max" value. */
405 406 limit = (int) wcstol(ms, &ms, 10);
406 407 if (limit < 1) {
407 408 limit = PMAKE_DEF_MAX_JOBS;
408 - warning(catgets(catd, 1, 320, "max value cannot be less than or equal to zero for host %s"), mbs_buffer);
409 + warning(gettext("max value cannot be less than or equal to zero for host %s"), mbs_buffer);
409 410 }
410 411 } else {
411 412 /* No "max" value after "max=". */
412 - warning(catgets(catd, 1, 321, "no max value specified for host %s"), mbs_buffer);
413 + warning(gettext("no max value specified for host %s"), mbs_buffer);
413 414 }
414 415 *ms_address = ms;
415 416 return(limit);
416 417 }
417 418 }
418 419
419 420
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX