kDepObj.c

Last change on this file was 3364, checked in by bird, 5 years ago
kDepObj: -W4 warning fixes.
Property svn:eol-style set to `native` Property svn:keywords set to `Id`
File size: 42.9 KB

Line
1	/* $Id: kDepObj.c 3364 2020-06-08 19:29:42Z bird $ */
2	/** @file
3	* kDepObj - Extract dependency information from an object file.
4	*/
5
6	/*
7	* Copyright (c) 2007-2010 knut st. osmundsen <[email protected]>
8	*
9	* This file is part of kBuild.
10	*
11	* kBuild is free software; you can redistribute it and/or modify
12	* it under the terms of the GNU General Public License as published by
13	* the Free Software Foundation; either version 3 of the License, or
14	* (at your option) any later version.
15	*
16	* kBuild is distributed in the hope that it will be useful,
17	* but WITHOUT ANY WARRANTY; without even the implied warranty of
18	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19	* GNU General Public License for more details.
20	*
21	* You should have received a copy of the GNU General Public License
22	* along with kBuild. If not, see <http://www.gnu.org/licenses/>
23	*
24	*/
25
26	/*******************************************************************************
27	* Header Files *
28	*******************************************************************************/
29	#define MSCFAKES_NO_WINDOWS_H
30	#include <stdio.h>
31	#include <stdlib.h>
32	#include <stddef.h>
33	#include <string.h>
34	#include <errno.h>
35	#include <ctype.h>
36	#include <stdarg.h>
37	#if !defined(_MSC_VER)
38	# include <unistd.h>
39	#else
40	# include <io.h>
41	typedef intptr_t ssize_t;
42	#endif
43	#include "k/kDefs.h"
44	#include "k/kTypes.h"
45	#include "k/kLdrFmts/pe.h"
46	#ifdef HAVE_CONFIG_H
47	# include "config.h"
48	#endif
49	#include "kDep.h"
50	#include "err.h"
51	#include "kmkbuiltin.h"
52
53
54	/*******************************************************************************
55	* Defined Constants And Macros *
56	*******************************************************************************/
57	#if 0
58	# define dprintf(a) printf a
59	# define dump(pb, cb, offBase) depHexDump(pb,cb,offBase)
60	# define WITH_DPRINTF
61	#else
62	# define dprintf(a) do {} while (0)
63	# define dump(pb, cb, offBase) do {} while (0)
64	# undef WITH_DPRINTF
65	#endif
66
67	/** @name OMF defines
68	* @{ */
69	#define KDEPOMF_THEADR 0x80
70	#define KDEPOMF_LHEADR 0x82
71	#define KDEPOMF_COMENT 0x88
72	#define KDEPOMF_CMTCLS_DEPENDENCY 0xe9
73	#define KDEPOMF_CMTCLS_DBGTYPE 0xa1
74	#define KDEPOMF_LINNUM 0x94
75	#define KDEPOMF_LINNUM32 0x95
76	/** @} */
77
78
79	/*******************************************************************************
80	* Structures and Typedefs *
81	*******************************************************************************/
82	/** @name OMF Structures
83	* @{ */
84	#pragma pack(1)
85	/** OMF record header. */
86	typedef struct KDEPOMFHDR
87	{
88	/** The record type. */
89	KU8 bType;
90	/** The size of the record, excluding this header. */
91	KU16 cbRec;
92	} KDEPOMFHDR;
93	typedef KDEPOMFHDR *PKDEPOMFHDR;
94	typedef const KDEPOMFHDR *PCKDEPOMFHDR;
95
96	/** OMF string. */
97	typedef struct KDEPOMFSTR
98	{
99	KU8 cch;
100	char ach[1];
101	} KDEPOMFSTR;
102	typedef KDEPOMFSTR *PKDEPOMFSTR;
103	typedef const KDEPOMFSTR *PCKDEPOMFSTR;
104
105	/** THEADR/LHEADR. */
106	typedef struct KDEPOMFTHEADR
107	{
108	KDEPOMFHDR Hdr;
109	KDEPOMFSTR Name;
110	} KDEPOMFTHEADR;
111	typedef KDEPOMFTHEADR *PKDEPOMFTHEADR;
112	typedef const KDEPOMFTHEADR *PCKDEPOMFTHEADR;
113
114	/** Dependency File. */
115	typedef struct KDEPOMFDEPFILE
116	{
117	KDEPOMFHDR Hdr;
118	KU8 fType;
119	KU8 bClass;
120	KU16 wDosTime;
121	KU16 wDosDate;
122	KDEPOMFSTR Name;
123	} KDEPOMFDEPFILE;
124	typedef KDEPOMFDEPFILE *PKDEPOMFDEPFILE;
125	typedef const KDEPOMFDEPFILE *PCKDEPOMFDEPFILE;
126
127	#pragma pack()
128	/** @} */
129
130
131	/** @name COFF Structures
132	* @{ */
133	#pragma pack(1)
134
135	typedef struct KDEPCVSYMHDR
136	{
137	/** The record size minus the size field. */
138	KU16 cb;
139	/** The record type. */
140	KU16 uType;
141	} KDEPCVSYMHDR;
142	typedef KDEPCVSYMHDR *PKDEPCVSYMHDR;
143	typedef const KDEPCVSYMHDR *PCKDEPCVSYMHDR;
144
145	/** @name Selection of KDEPCVSYMHDR::uType values.
146	* @{ */
147	#define K_CV8_S_MSTOOL KU16_C(0x1116)
148	/** @} */
149
150	typedef struct KDEPCV8SYMHDR
151	{
152	/** The record type. */
153	KU32 uType;
154	/** The record size minus the size field. */
155	KU32 cb;
156	} KDEPCV8SYMHDR;
157	typedef KDEPCV8SYMHDR *PKDEPCV8SYMHDR;
158	typedef const KDEPCV8SYMHDR *PCKDEPCV8SYMHDR;
159
160	/** @name Known KDEPCV8SYMHDR::uType Values.
161	* @{ */
162	#define K_CV8_SYMBOL_INFO KU32_C(0x000000f1)
163	#define K_CV8_LINE_NUMBERS KU32_C(0x000000f2)
164	#define K_CV8_STRING_TABLE KU32_C(0x000000f3)
165	#define K_CV8_SOURCE_FILES KU32_C(0x000000f4)
166	#define K_CV8_COMDAT_XXXXX KU32_C(0x000000f5) /*< no idea about the format... /
167	/** @} */
168
169	#pragma pack()
170	/** @} */
171
172	/**
173	* Globals.
174	*/
175	typedef struct KDEPOBJGLOBALS
176	{
177	/** The command execution context. */
178	PKMKBUILTINCTX pCtx;
179	/** Core instance. */
180	DEPGLOBALS Core;
181	/** The file. */
182	const char *pszFile;
183	} KDEPOBJGLOBALS;
184	/** Pointer to kDepObj globals. */
185	typedef KDEPOBJGLOBALS *PKDEPOBJGLOBALS;
186
187
188
189	/**
190	* Prints an error message.
191	*
192	* @returns rc.
193	* @param pThis kObjDep instance data.
194	* @param rc The return code, for making one line return statements.
195	* @param pszFormat The message format string.
196	* @param ... Format arguments.
197	* @todo Promote this to kDep.c.
198	*/
199	static int kDepErr(PKDEPOBJGLOBALS pThis, int rc, const char *pszFormat, ...)
200	{
201	char szMsg[2048];
202	va_list va;
203	va_start(va, pszFormat);
204	vsnprintf(szMsg, sizeof(szMsg) - 1, pszFormat, va);
205	va_end(va);
206	szMsg[sizeof(szMsg) - 1] = '\0';
207
208	if (pThis->pszFile)
209	warnx(pThis->pCtx, "%s: error: %s", pThis->pszFile, szMsg);
210	else
211	errx(pThis->pCtx, rc, "%s", szMsg);
212	return rc;
213	}
214
215
216	/**
217	* Gets an index from the data.
218	*
219	* @returns The index, KU16_MAX on buffer underflow.
220	* @param puData The current data stream position (in/out).
221	* @param pcbLeft Number of bytes left (in/out).
222	*/
223	static KU16 kDepObjOMFGetIndex(KPCUINT puData, KU16 pcbLeft)
224	{
225	KU16 u16;
226
227	if (pcbLeft >= 1 && pcbLeft != KU16_MAX)
228	{
229	*pcbLeft -= 1;
230	u16 = *puData->pb++;
231	if (u16 & KU16_C(0x80))
232	{
233	if (*pcbLeft >= 1)
234	{
235	*pcbLeft -= 1;
236	u16 = ((u16 & KU16_C(0x7f)) << 8) \| *puData->pb++;
237	}
238	else
239	u16 = KU16_MAX;
240	}
241	}
242	else
243	u16 = KU16_MAX;
244	return u16;
245	}
246
247
248	/**
249	* Parses the OMF file.
250	*
251	* @returns 0 on success, 1 on failure, 2 if no dependencies was found.
252	* @param pThis The kDepObj instance data.
253	* @param pbFile The start of the file.
254	* @param cbFile The file size.
255	*/
256	int kDepObjOMFParse(PKDEPOBJGLOBALS pThis, const KU8 *pbFile, KSIZE cbFile)
257	{
258	PCKDEPOMFHDR pHdr = (PCKDEPOMFHDR)pbFile;
259	KSIZE cbLeft = cbFile;
260	char uDbgType = 0; /* H or C */
261	KU8 uDbgVer = KU8_MAX;
262	KU32 iSrc = 0;
263	KU32 iMaybeSrc = 0;
264	KU8 uLinNumType = KU8_MAX;
265	KU16 cLinNums = 0;
266	KU32 cLinFiles = 0;
267	KU32 iLinFile = 0;
268
269	/*
270	* Iterate thru the records until we hit the end or an invalid one.
271	*/
272	while ( cbLeft >= sizeof(*pHdr)
273	&& cbLeft >= pHdr->cbRec + sizeof(*pHdr))
274	{
275	KPCUINT uData;
276	uData.pv = pHdr + 1;
277
278	/* process selected record types. */
279	dprintf(("%#07" KUPTR_PRI ": %#04x %#05x\n", (const KU8*)pHdr - pbFile, pHdr->bType, pHdr->cbRec));
280	switch (pHdr->bType)
281	{
282	/*
283	* The T/L Header contains the source name. When emitting CodeView 4
284	* and earlier (like masm and watcom does), all includes used by the
285	* line number tables have their own THEADR record.
286	*/
287	case KDEPOMF_THEADR:
288	case KDEPOMF_LHEADR:
289	{
290	PCKDEPOMFTHEADR pTHeadr = (PCKDEPOMFTHEADR)pHdr;
291	if (1 + pTHeadr->Name.cch + 1 != pHdr->cbRec)
292	return kDepErr(pThis, 1, "%#07x - Bad %cHEADR record, length mismatch.",
293	(const KU8*)pHdr - pbFile, pHdr->bType == KDEPOMF_THEADR ? 'T' : 'L');
294	if ( ( pTHeadr->Name.cch > 2
295	&& pTHeadr->Name.ach[pTHeadr->Name.cch - 2] == '.'
296	&& ( pTHeadr->Name.ach[pTHeadr->Name.cch - 1] == 'o'
297	\|\| pTHeadr->Name.ach[pTHeadr->Name.cch - 1] == 'O'))
298	\|\| ( pTHeadr->Name.cch > 4
299	&& pTHeadr->Name.ach[pTHeadr->Name.cch - 4] == '.'
300	&& ( pTHeadr->Name.ach[pTHeadr->Name.cch - 3] == 'o'
301	\|\| pTHeadr->Name.ach[pTHeadr->Name.cch - 3] == 'O')
302	&& ( pTHeadr->Name.ach[pTHeadr->Name.cch - 2] == 'b'
303	\|\| pTHeadr->Name.ach[pTHeadr->Name.cch - 2] == 'B')
304	&& ( pTHeadr->Name.ach[pTHeadr->Name.cch - 1] == 'j'
305	\|\| pTHeadr->Name.ach[pTHeadr->Name.cch - 1] == 'J'))
306	)
307	dprintf(("%cHEADR: %.*s [ignored]\n", pHdr->bType == KDEPOMF_THEADR ? 'T' : 'L', pTHeadr->Name.cch, pTHeadr->Name.ach));
308	else
309	{
310	dprintf(("%cHEADR: %.*s\n", pHdr->bType == KDEPOMF_THEADR ? 'T' : 'L', pTHeadr->Name.cch, pTHeadr->Name.ach));
311	depAdd(&pThis->Core, pTHeadr->Name.ach, pTHeadr->Name.cch);
312	iMaybeSrc++;
313	}
314	uLinNumType = KU8_MAX;
315	break;
316	}
317
318	case KDEPOMF_COMENT:
319	{
320	KU8 uClass;
321
322	if (pHdr->cbRec < 2 + 1)
323	return kDepErr(pThis, 1, "%#07x - Bad COMMENT record, too small.", (const KU8*)pHdr - pbFile);
324	if (uData.pb[0] & 0x3f)
325	return kDepErr(pThis, 1, "%#07x - Bad COMMENT record, reserved flags set.", (const KU8*)pHdr - pbFile);
326	uClass = uData.pb[1];
327	uData.pb += 2;
328	switch (uClass)
329	{
330	/*
331	* Borland dependency file comment (famously used by wmake and Watcom).
332	*/
333	case KDEPOMF_CMTCLS_DEPENDENCY:
334	{
335	PCKDEPOMFDEPFILE pDep = (PCKDEPOMFDEPFILE)pHdr;
336	if (K_OFFSETOF(KDEPOMFDEPFILE, Name.ach[pDep->Name.cch]) + 1 != pHdr->cbRec + sizeof(*pHdr))
337	{
338	/* Empty record indicates the end of the dependency files,
339	no need to go on. */
340	if (pHdr->cbRec == 2 + 1)
341	return 0;
342	return kDepErr(pThis, 1, "%#07lx - Bad DEPENDENCY FILE record, length mismatch. (%u/%u)",
343	(long)((const KU8 *)pHdr - pbFile),
344	K_OFFSETOF(KDEPOMFDEPFILE, Name.ach[pDep->Name.cch]) + 1,
345	(unsigned)(pHdr->cbRec + sizeof(*pHdr)));
346	}
347	depAdd(&pThis->Core, pDep->Name.ach, pDep->Name.cch);
348	iSrc++;
349	break;
350	}
351
352	/*
353	* Pick up the debug type so we can parse the LINNUM records.
354	*/
355	case KDEPOMF_CMTCLS_DBGTYPE:
356	if (pHdr->cbRec < 2 + 3 + 1)
357	break; /* ignore, Borland used this for something else apparently. */
358	if ( !(uData.pb[1] == 'C' && uData.pb[2] == 'V')
359	&& !(uData.pb[1] == 'H' && uData.pb[2] == 'L'))
360	{
361	dprintf(("Unknown debug type: %c%c (%u)\n", uData.pb[1], uData.pb[2], uData.pb[0]));
362	break;
363	}
364	uDbgType = uData.pb[1];
365	uDbgVer = uData.pb[0];
366	dprintf(("Debug Type %s ver %u\n", uDbgType == 'H' ? "HLL" : "CodeView", uDbgVer));
367	break;
368
369	}
370	break; /* COMENT */
371	}
372
373	/*
374	* LINNUM + THEADR == sigar.
375	*/
376	case KDEPOMF_LINNUM:
377	if (uDbgType == 'C')
378	iMaybeSrc \|= KU32_C(0x80000000);
379	dprintf(("LINNUM:\n"));
380	break;
381
382	/*
383	* The HLL v4 and v6 file names table will include all files when present, which
384	* is perfect for generating dependencies.
385	*/
386	case KDEPOMF_LINNUM32:
387	if ( uDbgType == 'H'
388	&& uDbgVer >= 3
389	&& uDbgVer <= 6)
390	{
391	/* skip two indexes (group & segment) */
392	KU16 cbRecLeft = pHdr->cbRec - 1;
393	KU16 uGrp = kDepObjOMFGetIndex(&uData, &cbRecLeft);
394	KU16 uSeg = kDepObjOMFGetIndex(&uData, &cbRecLeft);
395	if (uSeg == KU16_MAX)
396	return kDepErr(pThis, 1, "%#07lx - Bad LINNUM32 record", (long)((const KU8 *)pHdr - pbFile));
397	K_NOREF(uGrp);
398
399	if (uLinNumType == KU8_MAX)
400	{
401	#ifdef WITH_DPRINTF
402	static const char * const s_apsz[5] =
403	{
404	"source file", "listing file", "source & listing file", "file names table", "path table"
405	};
406	#endif
407	KU16 uLine;
408	KU8 uReserved;
409	KU16 uSeg2;
410	KU32 cbLinNames;
411
412	if (cbRecLeft < 2+1+1+2+2+4)
413	return kDepErr(pThis, 1, "%#07lx - Bad LINNUM32 record, too short", (long)((const KU8 *)pHdr - pbFile));
414	cbRecLeft -= 2+1+1+2+2+4;
415	uLine = *uData.pu16++;
416	uLinNumType = *uData.pu8++;
417	uReserved = *uData.pu8++; K_NOREF(uReserved);
418	cLinNums = *uData.pu16++; K_NOREF(cLinNums);
419	uSeg2 = *uData.pu16++; K_NOREF(uSeg2);
420	cbLinNames = *uData.pu32++; K_NOREF(cbLinNames);
421
422	dprintf(("LINNUM32: uGrp=%#x uSeg=%#x uSeg2=%#x uLine=%#x (MBZ) uReserved=%#x\n",
423	uGrp, uSeg, uSeg2, uLine, uReserved));
424	dprintf(("LINNUM32: cLinNums=%#x (%u) cbLinNames=%#x (%u) uLinNumType=%#x (%s)\n",
425	cLinNums, cLinNums, cbLinNames, cbLinNames, uLinNumType,
426	uLinNumType < K_ELEMENTS(s_apsz) ? s_apsz[uLinNumType] : "??"));
427
428	if (uLine != 0)
429	return kDepErr(pThis, 1, "%#07lx - Bad LINNUM32 record, line %#x (MBZ)", (long)((const KU8 *)pHdr - pbFile), uLine);
430	cLinFiles = iLinFile = KU32_MAX;
431	if ( uLinNumType == 3 /* file names table */
432	\|\| uLinNumType == 4 /* path table */)
433	cLinNums = 0; /* no line numbers */
434	else if (uLinNumType > 4)
435	return kDepErr(pThis, 1, "%#07lx - Bad LINNUM32 record, type %#x unknown", (long)((const KU8 *)pHdr - pbFile), uLinNumType);
436	}
437	else
438	dprintf(("LINNUM32: uGrp=%#x uSeg=%#x\n", uGrp, uSeg));
439
440
441	/* Skip file numbers (we parse them to follow the stream correctly). */
442	if (uLinNumType != 3 && uLinNumType != 4)
443	{
444	static const KU16 s_acbTypes[3] = { 2+2+4, 4+4+4, 2+2+4+4+4 };
445	KU16 cbEntry = s_acbTypes[uLinNumType];
446
447	while (cLinNums && cbRecLeft)
448	{
449	if (cbRecLeft < cbEntry)
450	return kDepErr(pThis, 1, "%#07lx - Bad LINNUM32 record, incomplete line entry", (long)((const KU8 *)pHdr - pbFile));
451
452	switch (uLinNumType)
453	{
454	case 0: /* source file */
455	dprintf((" Line %6" KU16_PRI " of file %2" KU16_PRI " at %#010" KX32_PRI "\n",
456	uData.pu16[0], uData.pu16[1], uData.pu32[1]));
457	break;
458	case 1: /* listing file */
459	dprintf((" Line %6" KU32_PRI ", statement %6" KU32_PRI " at %#010" KX32_PRI "\n",
460	uData.pu32[0], uData.pu32[1], uData.pu32[2]));
461	break;
462	case 2: /* source & listing file */
463	dprintf((" Line %6" KU16_PRI " of file %2" KU16_PRI ", listning line %6" KU32_PRI ", statement %6" KU32_PRI " at %#010" KX32_PRI "\n",
464	uData.pu16[0], uData.pu16[1], uData.pu32[1], uData.pu32[2], uData.pu32[3]));
465	break;
466	}
467	uData.pb += cbEntry;
468	cbRecLeft -= cbEntry;
469	cLinNums--;
470	}
471
472	/* If at end of the announced line number entiries, we may find a file names table
473	here (who is actually emitting this?). */
474	if (!cLinNums)
475	{
476	uLinNumType = cbRecLeft > 0 ? 3 : KU8_MAX;
477	dprintf(("End-of-line-numbers; uLinNumType=%u cbRecLeft=%#x\n", uLinNumType, cbRecLeft));
478	}
479	}
480
481	if (uLinNumType == 3 \|\| uLinNumType == 4)
482	{
483	/* Read the file/path table header (first time only). */
484	if (cLinFiles == KU32_MAX && iLinFile == KU32_MAX)
485	{
486	KU32 iFirstCol;
487	KU32 cCols;
488
489	if (cbRecLeft < 4+4+4)
490	return kDepErr(pThis, 1, "%#07lx - Bad LINNUM32 record, incomplete file/path table header", (long)((const KU8 *)pHdr - pbFile));
491	cbRecLeft -= 4+4+4;
492
493	iFirstCol = *uData.pu32++; K_NOREF(iFirstCol);
494	cCols = *uData.pu32++; K_NOREF(cCols);
495	cLinFiles = *uData.pu32++;
496	dprintf(("%s table header: cLinFiles=%#" KX32_PRI " (%" KU32_PRI ") iFirstCol=%" KU32_PRI " cCols=%" KU32_PRI"\n",
497	uLinNumType == 3 ? "file names" : "path", cLinFiles, cLinFiles, iFirstCol, cCols));
498	if (cLinFiles == KU32_MAX)
499	return kDepErr(pThis, 1, "%#07lx - Bad LINNUM32 record, too many file/path table entries.", (long)((const KU8 *)pHdr - pbFile));
500	iLinFile = 0;
501	}
502
503	/* Parse the file names / path table. */
504	while (iLinFile < cLinFiles && cbRecLeft)
505	{
506	KU16 cbName = *uData.pb++;
507	if (cbRecLeft < 1 + cbName)
508	return kDepErr(pThis, 1, "%#07lx - Bad LINNUM32 record, file/path table entry too long.", (long)((const KU8 *)pHdr - pbFile));
509	iLinFile++;
510	dprintf(("#%" KU32_PRI": %.*s\n", iLinFile, cbName, uData.pch));
511	if (uLinNumType == 3)
512	{
513	depAdd(&pThis->Core, uData.pch, cbName);
514	iSrc++;
515	}
516	cbRecLeft -= 1 + cbName;
517	uData.pb += cbName;
518	}
519
520	/* The end? */
521	if (iLinFile == cLinFiles)
522	{
523	uLinNumType = KU8_MAX;
524	dprintf(("End-of-file/path-table; cbRecLeft=%#x\n", cbRecLeft));
525	}
526	}
527	}
528	else
529	dprintf(("LINNUM32: Unknown or unsupported format\n"));
530	break;
531
532	}
533
534	/* advance */
535	cbLeft -= pHdr->cbRec + sizeof(*pHdr);
536	pHdr = (PCKDEPOMFHDR)((const KU8 *)(pHdr + 1) + pHdr->cbRec);
537	}
538
539	if (cbLeft)
540	return kDepErr(pThis, 1, "%#07x - Unexpected EOF. cbLeft=%#x", (const KU8*)pHdr - pbFile, cbLeft);
541
542	if (iSrc == 0 && iMaybeSrc <= 1)
543	{
544	dprintf(("kDepObjOMFParse: No cylindrical smoking thing: iSrc=0 iMaybeSrc=%#" KX32_PRI"\n", iMaybeSrc));
545	return 2;
546	}
547	dprintf(("kDepObjOMFParse: iSrc=%" KU32_PRI " iMaybeSrc=%#" KX32_PRI "\n", iSrc, iMaybeSrc));
548	return 0;
549	}
550
551
552	/**
553	* Checks if this file is an OMF file or not.
554	*
555	* @returns K_TRUE if it's OMF, K_FALSE otherwise.
556	*
557	* @param pb The start of the file.
558	* @param cb The file size.
559	*/
560	KBOOL kDepObjOMFTest(const KU8 *pbFile, KSIZE cbFile)
561	{
562	PCKDEPOMFTHEADR pHdr = (PCKDEPOMFTHEADR)pbFile;
563
564	if (cbFile <= sizeof(*pHdr))
565	return K_FALSE;
566	if ( pHdr->Hdr.bType != KDEPOMF_THEADR
567	&& pHdr->Hdr.bType != KDEPOMF_LHEADR)
568	return K_FALSE;
569	if (pHdr->Hdr.cbRec + sizeof(pHdr->Hdr) >= cbFile)
570	return K_FALSE;
571	if (pHdr->Hdr.cbRec != 1 + pHdr->Name.cch + 1)
572	return K_FALSE;
573
574	return K_TRUE;
575	}
576
577
578	/**
579	* Parses a CodeView 8 symbol section.
580	*
581	* @returns 0 on success, 1 on failure, 2 if no dependencies was found.
582	* @param pThis The kDepObj instance data.
583	* @param pbSyms Pointer to the start of the symbol section.
584	* @param cbSyms Size of the symbol section.
585	*/
586	int kDepObjCOFFParseCV8SymbolSection(PKDEPOBJGLOBALS pThis, const KU8 *pbSyms, KU32 cbSyms)
587	{
588	char const * pchStrTab = NULL;
589	KU32 cbStrTab = 0;
590	KPCUINT uSrcFiles = {0};
591	KU32 cbSrcFiles = 0;
592	KU32 off = 4;
593	KU32 iSrc = 0;
594
595	if (cbSyms < 16)
596	return 1;
597
598	/*
599	* The parsing loop.
600	*/
601	while (off < cbSyms)
602	{
603	PCKDEPCV8SYMHDR pHdr = (PCKDEPCV8SYMHDR)(pbSyms + off);
604	KPCUINT uData;
605	KU32 cbData;
606	uData.pv = pHdr + 1;
607
608	if (off + sizeof(*pHdr) >= cbSyms)
609	{
610	kDepErr(pThis, 1, "CV symbol table entry at %08" KX32_PRI " is too long; cbSyms=%#" KX32_PRI "",
611	off, cbSyms);
612	return 1; /* FIXME */
613	}
614
615	cbData = pHdr->cb;
616	if (off + cbData + sizeof(*pHdr) > cbSyms)
617	{
618	kDepErr(pThis, 1, "CV symbol table entry at %08" KX32_PRI " is too long; cbData=%#" KX32_PRI " cbSyms=%#" KX32_PRI,
619	off, cbData, cbSyms);
620	return 1; /* FIXME */
621	}
622
623	/* If the size is 0, assume it covers the rest of the section. VC++ 2003 has
624	been observed doing thing. */
625	if (!cbData)
626	cbData = cbSyms - off;
627
628	switch (pHdr->uType)
629	{
630	case K_CV8_SYMBOL_INFO:
631	dprintf(("%06" KX32_PRI " %06" KX32_PRI ": Symbol Info\n", off, cbData));
632	/dump(uData.pb, cbData, 0);/
633	break;
634
635	case K_CV8_LINE_NUMBERS:
636	dprintf(("%06" KX32_PRI " %06" KX32_PRI ": Line numbers\n", off, cbData));
637	/dump(uData.pb, cbData, 0);/
638	break;
639
640	case K_CV8_STRING_TABLE:
641	dprintf(("%06" KX32_PRI " %06" KX32_PRI ": String table\n", off, cbData));
642	if (pchStrTab)
643	warnx(pThis->pCtx, "%s: warning: Found yet another string table!", pThis->pszFile);
644	pchStrTab = uData.pch;
645	cbStrTab = cbData;
646	/dump(uData.pb, cbData, 0);/
647	break;
648
649	case K_CV8_SOURCE_FILES:
650	dprintf(("%06" KX32_PRI " %06" KX32_PRI ": Source files\n", off, cbData));
651	if (uSrcFiles.pb)
652	warnx(pThis->pCtx, "%s: warning: Found yet another source files table!", pThis->pszFile);
653	uSrcFiles = uData;
654	cbSrcFiles = cbData;
655	/dump(uData.pb, cbData, 0);/
656	break;
657
658	case K_CV8_COMDAT_XXXXX:
659	dprintf(("%06" KX32_PRI " %06" KX32_PRI ": 0xf5 Unknown COMDAT stuff\n", off, cbData));
660	/dump(uData.pb, cbData, 0);/
661	break;
662
663	default:
664	dprintf(("%06" KX32_PRI " %06" KX32_PRI ": Unknown type %#" KX32_PRI "\n",
665	off, cbData, pHdr->uType));
666	dump(uData.pb, cbData, 0);
667	break;
668	}
669
670	/* next */
671	cbData = (cbData + 3) & ~KU32_C(3);
672	off += cbData + sizeof(*pHdr);
673	}
674
675	/*
676	* Did we find any source files and strings?
677	*/
678	if (!pchStrTab \|\| !uSrcFiles.pv)
679	{
680	dprintf(("kDepObjCOFFParseCV8SymbolSection: No cylindrical smoking thing: pchStrTab=%p uSrcFiles.pv=%p\n", pchStrTab, uSrcFiles.pv));
681	return 2;
682	}
683
684	/*
685	* Iterate the source file table.
686	*/
687	off = 0;
688	while (off < cbSrcFiles)
689	{
690	KU32 offFile;
691	const char *pszFile;
692	KSIZE cchFile;
693	KU16 u16Type;
694	KPCUINT uSrc;
695	KU32 cbSrc;
696
697	/*
698	* Validate and parse the entry (variable length record are fun).
699	*/
700	if (off + 8 > cbSrcFiles)
701	return kDepErr(pThis, 1, "CV source file entry at %08" KX32_PRI " is too long; cbSrcFiles=%#" KX32_PRI,
702	off, cbSrcFiles);
703	uSrc.pb = uSrcFiles.pb + off;
704	u16Type = uSrc.pu16[2];
705	switch (u16Type)
706	{
707	case 0x0110: cbSrc = 6 + 16 + 2; break; /* MD5 */
708	case 0x0214: cbSrc = 6 + 20 + 2; break; /* SHA1 / /* @todo check this */
709	case 0x0320: cbSrc = 6 + 32 + 2; break; /* SHA-256 */
710	default: cbSrc = 6 + 0 + 2; break;
711	}
712	if (off + cbSrc > cbSrcFiles)
713	return kDepErr(pThis, 1, "CV source file entry at %08" KX32_PRI " is too long; cbSrc=%#" KX32_PRI " cbSrcFiles=%#" KX32_PRI,
714	off, cbSrc, cbSrcFiles);
715
716	offFile = *uSrc.pu32;
717	if (offFile > cbStrTab)
718	return kDepErr(pThis, 1, "CV source file entry at %08" KX32_PRI " is out side the string table; offFile=%#" KX32_PRI " cbStrTab=%#" KX32_PRI,
719	off, offFile, cbStrTab);
720	pszFile = pchStrTab + offFile;
721	cchFile = strlen(pszFile);
722	if (cchFile == 0)
723	return kDepErr(pThis, 1, "CV source file entry at %08" KX32_PRI " has an empty file name; offFile=%#x" KX32_PRI,
724	off, offFile);
725
726	/*
727	* Display the result and add it to the dependency database.
728	*/
729	depAdd(&pThis->Core, pszFile, cchFile);
730	#ifdef WITH_DPRINTF
731	dprintf(("#%03" KU32_PRI ": ", iSrc));
732	{
733	KU32 off = 6;
734	for (;off < cbSrc - 2; off++)
735	dprintf(("%02" KX8_PRI, uSrc.pb[off]));
736	if (cbSrc == 6)
737	dprintf(("type=%#06" KX16_PRI, u16Type));
738	dprintf((" '%s'\n", pszFile));
739	}
740	#endif
741
742
743	/* next */
744	iSrc++;
745	off += cbSrc;
746	}
747
748	if (iSrc == 0)
749	{
750	dprintf(("kDepObjCOFFParseCV8SymbolSection: No cylindrical smoking thing: iSrc=0\n"));
751	return 2;
752	}
753	dprintf(("kDepObjCOFFParseCV8SymbolSection: iSrc=%" KU32_PRI "\n", iSrc));
754	return 0;
755	}
756
757
758	/**
759	* Parses the OMF file.
760	*
761	* @returns 0 on success, 1 on failure, 2 if no dependencies was found.
762	* @param pThis The kDepObj instance data.
763	* @param pbFile The start of the file.
764	* @param cbFile The file size.
765	*/
766	int kDepObjCOFFParse(PKDEPOBJGLOBALS pThis, const KU8 *pbFile, KSIZE cbFile)
767	{
768	IMAGE_FILE_HEADER const pFileHdr = (IMAGE_FILE_HEADER const )pbFile;
769	ANON_OBJECT_HEADER_BIGOBJ const pBigObjHdr = (ANON_OBJECT_HEADER_BIGOBJ const )pbFile;
770	IMAGE_SECTION_HEADER const *paSHdrs;
771	KU32 cSHdrs;
772	unsigned iSHdr;
773	KPCUINT u;
774	KBOOL fDebugS = K_FALSE;
775	int rcRet = 2;
776	int rc;
777
778	if ( pBigObjHdr->Sig1 == 0
779	&& pBigObjHdr->Sig2 == KU16_MAX)
780	{
781	paSHdrs = (IMAGE_SECTION_HEADER const *)(pBigObjHdr + 1);
782	cSHdrs = pBigObjHdr->NumberOfSections;
783	}
784	else
785	{
786	paSHdrs = (IMAGE_SECTION_HEADER const )((KU8 const )(pFileHdr + 1) + pFileHdr->SizeOfOptionalHeader);
787	cSHdrs = pFileHdr->NumberOfSections;
788	}
789
790
791	dprintf(("COFF file!\n"));
792
793	for (iSHdr = 0; iSHdr < cSHdrs; iSHdr++)
794	{
795	if ( !memcmp(paSHdrs[iSHdr].Name, ".debug$S", sizeof(".debug$S") - 1)
796	&& paSHdrs[iSHdr].SizeOfRawData > 4)
797	{
798	u.pb = pbFile + paSHdrs[iSHdr].PointerToRawData;
799	dprintf(("CV symbol table: version=%x\n", *u.pu32));
800	if (*u.pu32 == 0x000000004)
801	rc = kDepObjCOFFParseCV8SymbolSection(pThis, u.pb, paSHdrs[iSHdr].SizeOfRawData);
802	else
803	rc = 2;
804	dprintf(("rc=%d\n", rc));
805	if (rcRet == 2)
806	rcRet = rc;
807	if (rcRet != 2)
808	return rc;
809	fDebugS = K_TRUE;
810	}
811	dprintf(("#%d: %.8s\n", iSHdr, paSHdrs[iSHdr].Name));
812	}
813
814	/* If we found no dependencies but did find a .debug$S section, check if
815	this is a case where the compile didn't emit any because there is no
816	code in this compilation unit. */
817	if (rcRet == 2)
818	{
819	if (fDebugS)
820	{
821	for (iSHdr = 0; iSHdr < cSHdrs; iSHdr++)
822	if (!memcmp(paSHdrs[iSHdr].Name, ".text", sizeof(".text") - 1))
823	return kDepErr(pThis, 2, "%s: no dependencies (has text).", pThis->pszFile);
824	warnx(pThis->pCtx, "%s: no dependencies, but also no text, so probably (mostly) harmless.", pThis->pszFile);
825	return 0;
826	}
827	kDepErr(pThis, 2, "%s: no dependencies.", pThis->pszFile);
828	}
829
830	return rcRet;
831	}
832
833
834	/**
835	* Checks if this file is a COFF file or not.
836	*
837	* @returns K_TRUE if it's COFF, K_FALSE otherwise.
838	*
839	* @param pThis The kDepObj instance data.
840	* @param pb The start of the file.
841	* @param cb The file size.
842	*/
843	KBOOL kDepObjCOFFTest(PKDEPOBJGLOBALS pThis, const KU8 *pbFile, KSIZE cbFile)
844	{
845	IMAGE_FILE_HEADER const pFileHdr = (IMAGE_FILE_HEADER const )pbFile;
846	ANON_OBJECT_HEADER_BIGOBJ const pBigObjHdr = (ANON_OBJECT_HEADER_BIGOBJ const )pbFile;
847	IMAGE_SECTION_HEADER const *paSHdrs;
848	KU32 cSHdrs;
849	KU32 iSHdr;
850	KSIZE cbHdrs;
851
852	if (cbFile <= sizeof(*pFileHdr))
853	return K_FALSE;
854
855	/*
856	* Deal with -bigobj output first.
857	*/
858	if ( pBigObjHdr->Sig1 == 0
859	&& pBigObjHdr->Sig2 == KU16_MAX)
860	{
861	static const KU8 s_abClsId[16] = { ANON_OBJECT_HEADER_BIGOBJ_CLS_ID_BYTES };
862
863	paSHdrs = (IMAGE_SECTION_HEADER const *)(pBigObjHdr + 1);
864	cSHdrs = pBigObjHdr->NumberOfSections;
865	cbHdrs = sizeof(IMAGE_SECTION_HEADER) * cSHdrs;
866
867	if (cbFile <= sizeof(*pBigObjHdr))
868	return K_FALSE;
869
870	if (pBigObjHdr->Version != 2)
871	return K_FALSE;
872	if (memcmp(&pBigObjHdr->ClassID[0], s_abClsId, sizeof(pBigObjHdr->ClassID)) != 0)
873	return K_FALSE;
874
875	if ( pBigObjHdr->Machine != IMAGE_FILE_MACHINE_I386
876	&& pBigObjHdr->Machine != IMAGE_FILE_MACHINE_AMD64
877	&& pBigObjHdr->Machine != IMAGE_FILE_MACHINE_ARM
878	&& pBigObjHdr->Machine != IMAGE_FILE_MACHINE_ARMNT
879	&& pBigObjHdr->Machine != IMAGE_FILE_MACHINE_ARM64
880	&& pBigObjHdr->Machine != IMAGE_FILE_MACHINE_EBC)
881	{
882	kDepErr(pThis, 1, "bigobj Machine not supported: %#x", pBigObjHdr->Machine);
883	return K_FALSE;
884	}
885	if (pBigObjHdr->Flags != 0)
886	{
887	kDepErr(pThis, 1, "bigobj Flags field is non-zero: %#x", pBigObjHdr->Flags);
888	return K_FALSE;
889	}
890	if (pBigObjHdr->SizeOfData != 0)
891	{
892	kDepErr(pThis, 1, "bigobj SizeOfData field is non-zero: %#x", pBigObjHdr->SizeOfData);
893	return K_FALSE;
894	}
895
896	if ( pBigObjHdr->PointerToSymbolTable != 0
897	&& ( pBigObjHdr->PointerToSymbolTable < cbHdrs
898	\|\| pBigObjHdr->PointerToSymbolTable > cbFile))
899	return K_FALSE;
900	if ( pBigObjHdr->PointerToSymbolTable == 0
901	&& pBigObjHdr->NumberOfSymbols != 0)
902	return K_FALSE;
903	}
904	/*
905	* Look for normal COFF object.
906	*/
907	else
908	{
909	paSHdrs = (IMAGE_SECTION_HEADER const )((KU8 const )(pFileHdr + 1) + pFileHdr->SizeOfOptionalHeader);
910	cSHdrs = pFileHdr->NumberOfSections;
911	cbHdrs = (const KU8 )&paSHdrs[cSHdrs] - (const KU8 )pbFile;
912
913	if ( pFileHdr->Machine != IMAGE_FILE_MACHINE_I386
914	&& pFileHdr->Machine != IMAGE_FILE_MACHINE_AMD64
915	&& pFileHdr->Machine != IMAGE_FILE_MACHINE_ARM
916	&& pFileHdr->Machine != IMAGE_FILE_MACHINE_ARMNT
917	&& pFileHdr->Machine != IMAGE_FILE_MACHINE_ARM64
918	&& pFileHdr->Machine != IMAGE_FILE_MACHINE_EBC)
919	return K_FALSE;
920
921	if (pFileHdr->SizeOfOptionalHeader != 0)
922	return K_FALSE; /* COFF files doesn't have an optional header */
923
924	if ( pFileHdr->PointerToSymbolTable != 0
925	&& ( pFileHdr->PointerToSymbolTable < cbHdrs
926	\|\| pFileHdr->PointerToSymbolTable > cbFile))
927	return K_FALSE;
928	if ( pFileHdr->PointerToSymbolTable == 0
929	&& pFileHdr->NumberOfSymbols != 0)
930	return K_FALSE;
931	if ( pFileHdr->Characteristics
932	& ( IMAGE_FILE_DLL
933	\| IMAGE_FILE_SYSTEM
934	\| IMAGE_FILE_UP_SYSTEM_ONLY
935	\| IMAGE_FILE_NET_RUN_FROM_SWAP
936	\| IMAGE_FILE_REMOVABLE_RUN_FROM_SWAP
937	\| IMAGE_FILE_EXECUTABLE_IMAGE
938	\| IMAGE_FILE_RELOCS_STRIPPED))
939	return K_FALSE;
940	}
941	if ( cSHdrs <= 1
942	\|\| cSHdrs > cbFile)
943	return K_FALSE;
944	if (cbHdrs >= cbFile)
945	return K_FALSE;
946
947	/*
948	* Check the section headers.
949	*/
950	for (iSHdr = 0; iSHdr < cSHdrs; iSHdr++)
951	{
952	if ( paSHdrs[iSHdr].PointerToRawData != 0
953	&& ( paSHdrs[iSHdr].PointerToRawData < cbHdrs
954	\|\| paSHdrs[iSHdr].PointerToRawData >= cbFile
955	\|\| paSHdrs[iSHdr].PointerToRawData + paSHdrs[iSHdr].SizeOfRawData > cbFile))
956	return K_FALSE;
957	if ( paSHdrs[iSHdr].PointerToRelocations != 0
958	&& ( paSHdrs[iSHdr].PointerToRelocations < cbHdrs
959	\|\| paSHdrs[iSHdr].PointerToRelocations >= cbFile
960	\|\| paSHdrs[iSHdr].PointerToRelocations + paSHdrs[iSHdr].NumberOfRelocations * 10 > cbFile)) /* IMAGE_RELOCATION */
961	return K_FALSE;
962	if ( paSHdrs[iSHdr].PointerToLinenumbers != 0
963	&& ( paSHdrs[iSHdr].PointerToLinenumbers < cbHdrs
964	\|\| paSHdrs[iSHdr].PointerToLinenumbers >= cbFile
965	\|\| paSHdrs[iSHdr].PointerToLinenumbers + paSHdrs[iSHdr].NumberOfLinenumbers * 6 > cbFile)) /* IMAGE_LINENUMBER */
966	return K_FALSE;
967	}
968
969	return K_TRUE;
970	}
971
972
973	/**
974	* Read the file into memory and parse it.
975	*/
976	static int kDepObjProcessFile(PKDEPOBJGLOBALS pThis, FILE *pInput)
977	{
978	size_t cbFile;
979	KU8 *pbFile;
980	void *pvOpaque;
981	int rc = 0;
982
983	/*
984	* Read the file into memory.
985	*/
986	pbFile = (KU8 *)depReadFileIntoMemory(pInput, &cbFile, &pvOpaque);
987	if (!pbFile)
988	return 1;
989
990	/*
991	* See if it's an OMF file, then process it.
992	*/
993	if (kDepObjOMFTest(pbFile, cbFile))
994	rc = kDepObjOMFParse(pThis, pbFile, cbFile);
995	else if (kDepObjCOFFTest(pThis, pbFile, cbFile))
996	rc = kDepObjCOFFParse(pThis, pbFile, cbFile);
997	else
998	rc = kDepErr(pThis, 1, "Doesn't recognize the header of the OMF/COFF file.");
999
1000	depFreeFileMemory(pbFile, pvOpaque);
1001	return rc;
1002	}
1003
1004
1005	static void kDebObjUsage(PKMKBUILTINCTX pCtx, int fIsErr)
1006	{
1007	kmk_builtin_ctx_printf(pCtx, fIsErr,
1008	"usage: %s -o <output> -t <target> [-fqs] [-e <ignore-ext>] <OMF or COFF file>\n"
1009	" or: %s --help\n"
1010	" or: %s --version\n",
1011	pCtx->pszProgName, pCtx->pszProgName, pCtx->pszProgName);
1012	}
1013
1014
1015	int kmk_builtin_kDepObj(int argc, char argv, char envp, PKMKBUILTINCTX pCtx)
1016	{
1017	int i;
1018	KDEPOBJGLOBALS This;
1019
1020	/* Arguments. */
1021	FILE *pOutput = NULL;
1022	const char *pszOutput = NULL;
1023	FILE *pInput = NULL;
1024	const char *pszTarget = NULL;
1025	int fStubs = 0;
1026	int fFixCase = 0;
1027	const char *pszIgnoreExt = NULL;
1028	/* Argument parsing. */
1029	int fInput = 0; /* set when we've found input argument. */
1030	int fQuiet = 0;
1031
1032	/* Init instance data. */
1033	This.pCtx = pCtx;
1034	This.pszFile = NULL;
1035
1036	/*
1037	* Parse arguments.
1038	*/
1039	if (argc <= 1)
1040	{
1041	kDebObjUsage(pCtx, 0);
1042	return 1;
1043	}
1044	for (i = 1; i < argc; i++)
1045	{
1046	if (argv[i][0] == '-')
1047	{
1048	const char *pszValue;
1049	const char *psz = &argv[i][1];
1050	char chOpt;
1051	chOpt = *psz++;
1052	if (chOpt == '-')
1053	{
1054	/* Convert long to short option. */
1055	if (!strcmp(psz, "quiet"))
1056	chOpt = 'q';
1057	else if (!strcmp(psz, "help"))
1058	chOpt = '?';
1059	else if (!strcmp(psz, "version"))
1060	chOpt = 'V';
1061	else
1062	{
1063	errx(pCtx, 2, "Invalid argument '%s'.", argv[i]);
1064	kDebObjUsage(pCtx, 1);
1065	return 2;
1066	}
1067	psz = "";
1068	}
1069
1070	/*
1071	* Requires value?
1072	*/
1073	switch (chOpt)
1074	{
1075	case 'o':
1076	case 't':
1077	case 'e':
1078	if (*psz)
1079	pszValue = psz;
1080	else if (++i < argc)
1081	pszValue = argv[i];
1082	else
1083	return errx(pCtx, 2, "The '-%c' option takes a value.", chOpt);
1084	break;
1085
1086	default:
1087	pszValue = NULL;
1088	break;
1089	}
1090
1091
1092	switch (chOpt)
1093	{
1094	/*
1095	* Output file.
1096	*/
1097	case 'o':
1098	{
1099	if (pOutput)
1100	return errx(pCtx, 2, "only one output file!");
1101	pszOutput = pszValue;
1102	if (pszOutput[0] == '-' && !pszOutput[1])
1103	pOutput = stdout;
1104	else
1105	pOutput = fopen(pszOutput, "w" KMK_FOPEN_NO_INHERIT_MODE);
1106	if (!pOutput)
1107	return err(pCtx, 1, "Failed to create output file '%s'", pszOutput);
1108	break;
1109	}
1110
1111	/*
1112	* Target name.
1113	*/
1114	case 't':
1115	{
1116	if (pszTarget)
1117	return errx(pCtx, 2, "only one target!");
1118	pszTarget = pszValue;
1119	break;
1120	}
1121
1122	/*
1123	* Fix case.
1124	*/
1125	case 'f':
1126	{
1127	fFixCase = 1;
1128	break;
1129	}
1130
1131	/*
1132	* Quiet.
1133	*/
1134	case 'q':
1135	{
1136	fQuiet = 1;
1137	break;
1138	}
1139
1140	/*
1141	* Generate stubs.
1142	*/
1143	case 's':
1144	{
1145	fStubs = 1;
1146	break;
1147	}
1148
1149	/*
1150	* Extension to ignore.
1151	*/
1152	case 'e':
1153	{
1154	if (pszIgnoreExt)
1155	return errx(pCtx, 2, "The '-e' option can only be used once!");
1156	pszIgnoreExt = pszValue;
1157	break;
1158	}
1159
1160	/*
1161	* The mandatory version & help.
1162	*/
1163	case '?':
1164	kDebObjUsage(pCtx, 0);
1165	return 0;
1166	case 'V':
1167	case 'v':
1168	return kbuild_version(argv[0]);
1169
1170	/*
1171	* Invalid argument.
1172	*/
1173	default:
1174	errx(pCtx, 2, "Invalid argument '%s'.", argv[i]);
1175	kDebObjUsage(pCtx, 1);
1176	return 2;
1177	}
1178	}
1179	else
1180	{
1181	pInput = fopen(argv[i], "rb" KMK_FOPEN_NO_INHERIT_MODE);
1182	if (!pInput)
1183	return err(pCtx, 1, "Failed to open input file '%s'", argv[i]);
1184	This.pszFile = argv[i];
1185	fInput = 1;
1186	}
1187
1188	/*
1189	* End of the line?
1190	*/
1191	if (fInput)
1192	{
1193	if (++i < argc)
1194	return errx(pCtx, 2, "No arguments shall follow the input spec.");
1195	break;
1196	}
1197	}
1198
1199	/*
1200	* Got all we require?
1201	*/
1202	if (!pInput)
1203	return errx(pCtx, 2, "No input!");
1204	if (!pOutput)
1205	return errx(pCtx, 2, "No output!");
1206	if (!pszTarget)
1207	return errx(pCtx, 2, "No target!");
1208
1209	/*
1210	* Do the parsing.
1211	*/
1212	depInit(&This.Core);
1213	i = kDepObjProcessFile(&This, pInput);
1214	fclose(pInput);
1215
1216	/*
1217	* Write the dependecy file.
1218	*/
1219	if (!i)
1220	{
1221	depOptimize(&This.Core, fFixCase, fQuiet, pszIgnoreExt);
1222	depPrintTargetWithDeps(&This.Core, pOutput, pszTarget, 1 /fEscapeTarget/);
1223	if (fStubs)
1224	depPrintStubs(&This.Core, pOutput);
1225	}
1226
1227	/*
1228	* Close the output, delete output on failure.
1229	*/
1230	if (!i && ferror(pOutput))
1231	i = errx(pCtx, 1, "Error writing to '%s'", pszOutput);
1232	fclose(pOutput);
1233	if (i)
1234	{
1235	if (unlink(pszOutput))
1236	warn(pCtx, "warning: failed to remove output file '%s' on failure.", pszOutput);
1237	}
1238
1239	depCleanup(&This.Core);
1240	return i;
1241	}
1242
1243	#ifdef KMK_BUILTIN_STANDALONE
1244	int main(int argc, char argv, char envp)
1245	{
1246	KMKBUILTINCTX Ctx = { "kDepObj", NULL };
1247	return kmk_builtin_kDepObj(argc, argv, envp, &Ctx);
1248	}
1249	#endif
1250

Note: See TracBrowser for help on using the repository browser.

source: kBuild/trunk/src/kmk/kmkbuiltin/kDepObj.c

Download in other formats: