VBoxCPP.cpp@ 41766

Last change on this file since 41766 was 41359, checked in by vboxsync, 13 years ago
VBoxCPP: Empty macro detection bug spotted by MSC & Vitali.
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 178.9 KB

Line
1	/* $Id: VBoxCPP.cpp 41359 2012-05-21 08:32:15Z vboxsync $ */
2	/** @file
3	* VBox Build Tool - A mini C Preprocessor.
4	*
5	* Purposes to which this preprocessor will be put:
6	* - Preprocessig vm.h into dtrace/lib/vm.d so we can access the VM
7	* structure (as well as substructures) from DTrace without having
8	* to handcraft it all.
9	* - Removing \#ifdefs relating to a new feature that has become
10	* stable and no longer needs \#ifdef'ing.
11	* - Pretty printing preprocessor directives. This will be used by
12	* SCM.
13	*/
14
15	/*
16	* Copyright (C) 2012 Oracle Corporation
17	*
18	* This file is part of VirtualBox Open Source Edition (OSE), as
19	* available from http://www.virtualbox.org. This file is free software;
20	* you can redistribute it and/or modify it under the terms of the GNU
21	* General Public License (GPL) as published by the Free Software
22	* Foundation, in version 2 as it comes in the "COPYING" file of the
23	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
24	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
25	*/
26
27
28	/*******************************************************************************
29	* Header Files *
30	*******************************************************************************/
31	#include <VBox/VBoxTpG.h>
32
33	#include <iprt/alloca.h>
34	#include <iprt/assert.h>
35	#include <iprt/asm.h>
36	#include <iprt/ctype.h>
37	#include <iprt/err.h>
38	#include <iprt/file.h>
39	#include <iprt/getopt.h>
40	#include <iprt/initterm.h>
41	#include <iprt/list.h>
42	#include <iprt/mem.h>
43	#include <iprt/message.h>
44	#include <iprt/path.h>
45	#include <iprt/stream.h>
46	#include <iprt/string.h>
47
48	#include "scmstream.h"
49
50
51	/*******************************************************************************
52	* Defined Constants And Macros *
53	*******************************************************************************/
54	/** The bitmap type. */
55	#define VBCPP_BITMAP_TYPE uint64_t
56	/** The bitmap size as a multiple of VBCPP_BITMAP_TYPE. */
57	#define VBCPP_BITMAP_SIZE (128 / 64)
58	/** Checks if a bit is set. */
59	#define VBCPP_BITMAP_IS_SET(a_bm, a_ch) ASMBitTest(a_bm, (a_ch) & 0x7f)
60	/** Sets a bit. */
61	#define VBCPP_BITMAP_SET(a_bm, a_ch) ASMBitSet(a_bm, (a_ch) & 0x7f)
62	/** Empties the bitmap. */
63	#define VBCPP_BITMAP_EMPTY(a_bm) do { (a_bm)[0] = 0; (a_bm)[1] = 0; } while (0)
64	/** Joins to bitmaps by OR'ing their values.. */
65	#define VBCPP_BITMAP_OR(a_bm1, a_bm2) do { (a_bm1)[0] \|= (a_bm2)[0]; (a_bm1)[1] \|= (a_bm2)[1]; } while (0)
66
67
68	/*******************************************************************************
69	* Structures and Typedefs *
70	*******************************************************************************/
71	/** Pointer to the C preprocessor instance data. */
72	typedef struct VBCPP *PVBCPP;
73
74
75	/**
76	* Variable string buffer (very simple version of SCMSTREAM).
77	*/
78	typedef struct VBCPPSTRBUF
79	{
80	/** The preprocessor instance (for error reporting). */
81	struct VBCPP *pThis;
82	/** The length of the string in the buffer. */
83	size_t cchBuf;
84	/** The string storage. */
85	char *pszBuf;
86	/** Allocated buffer space. */
87	size_t cbBufAllocated;
88	} VBCPPSTRBUF;
89	/** Pointer to a variable string buffer. */
90	typedef VBCPPSTRBUF *PVBCPPSTRBUF;
91
92
93	/**
94	* The preprocessor mode.
95	*/
96	typedef enum VBCPPMODE
97	{
98	kVBCppMode_Invalid = 0,
99	kVBCppMode_Standard,
100	kVBCppMode_Selective,
101	kVBCppMode_SelectiveD,
102	kVBCppMode_End
103	} VBCPPMODE;
104
105
106	/**
107	* A macro (aka define).
108	*/
109	typedef struct VBCPPMACRO
110	{
111	/** The string space core. */
112	RTSTRSPACECORE Core;
113	#if 0
114	/** For linking macros that have the fExpanding flag set. */
115	struct VBCPPMACRO *pUpExpanding;
116	#endif
117	/** Whether it's a function. */
118	bool fFunction;
119	/** Variable argument count. */
120	bool fVarArg;
121	/** Set if originating on the command line. */
122	bool fCmdLine;
123	/** Set if this macro is currently being expanded and should not be
124	* recursively applied. */
125	bool fExpanding;
126	/** The number of known arguments. */
127	uint32_t cArgs;
128	/** Pointer to a list of argument names. */
129	const char **papszArgs;
130	/** Lead character bitmap for the argument names. */
131	VBCPP_BITMAP_TYPE bmArgs[VBCPP_BITMAP_SIZE];
132	/** The value length. */
133	size_t cchValue;
134	/** The define value. (This is followed by the name and arguments.) */
135	char szValue[1];
136	} VBCPPMACRO;
137	/** Pointer to a macro. */
138	typedef VBCPPMACRO *PVBCPPMACRO;
139
140
141	/**
142	* Macro expansion data.
143	*/
144	typedef struct VBCPPMACROEXP
145	{
146	/** The expansion buffer. */
147	VBCPPSTRBUF StrBuf;
148	#if 0
149	/** List of expanding macros (Stack). */
150	PVBCPPMACRO pMacroStack;
151	#endif
152	/** The input stream (in case we want to look for parameter lists). */
153	PSCMSTREAM pStrmInput;
154	/** Array of argument values. Used when expanding function style macros. */
155	char **papszArgs;
156	/** The number of argument values current in papszArgs. */
157	size_t cArgs;
158	/** The number of argument values papszArgs can currently hold */
159	size_t cArgsAlloced;
160	} VBCPPMACROEXP;
161	/** Pointer to macro expansion data. */
162	typedef VBCPPMACROEXP *PVBCPPMACROEXP;
163
164
165	/**
166	* The vbcppMacroExpandReScan mode of operation.
167	*/
168	typedef enum VBCPPMACRORESCANMODE
169	{
170	/** Invalid mode. */
171	kMacroReScanMode_Invalid = 0,
172	/** Normal expansion mode. */
173	kMacroReScanMode_Normal,
174	/** Replaces known macros and heeds the 'defined' operator. */
175	kMacroReScanMode_Expression,
176	/** End of valid modes. */
177	kMacroReScanMode_End
178	} VBCPPMACRORESCANMODE;
179
180
181	/**
182	* Expression node type.
183	*/
184	typedef enum VBCPPEXPRKIND
185	{
186	kVBCppExprKind_Invalid = 0,
187	kVBCppExprKind_Unary,
188	kVBCppExprKind_Binary,
189	kVBCppExprKind_Ternary,
190	kVBCppExprKind_SignedValue,
191	kVBCppExprKind_UnsignedValue,
192	kVBCppExprKind_End
193	} VBCPPEXPRKIND;
194
195
196	/** Macro used for the precedence field. */
197	#define VBCPPOP_PRECEDENCE(a_iPrecedence) ((a_iPrecedence) << 8)
198	/** Mask for getting the precedence field value. */
199	#define VBCPPOP_PRECEDENCE_MASK 0xff00
200	/** Operator associativity - Left to right. */
201	#define VBCPPOP_L2R (1 << 16)
202	/** Operator associativity - Right to left. */
203	#define VBCPPOP_R2L (2 << 16)
204
205	/**
206	* Unary operators.
207	*/
208	typedef enum VBCPPUNARYOP
209	{
210	kVBCppUnaryOp_Invalid = 0,
211	kVBCppUnaryOp_Pluss = VBCPPOP_R2L \| VBCPPOP_PRECEDENCE( 3) \| 5,
212	kVBCppUnaryOp_Minus = VBCPPOP_R2L \| VBCPPOP_PRECEDENCE( 3) \| 6,
213	kVBCppUnaryOp_LogicalNot = VBCPPOP_R2L \| VBCPPOP_PRECEDENCE( 3) \| 7,
214	kVBCppUnaryOp_BitwiseNot = VBCPPOP_R2L \| VBCPPOP_PRECEDENCE( 3) \| 8,
215	kVBCppUnaryOp_Parenthesis = VBCPPOP_R2L \| VBCPPOP_PRECEDENCE(15) \| 9,
216	kVBCppUnaryOp_End
217	} VBCPPUNARYOP;
218
219	/**
220	* Binary operators.
221	*/
222	typedef enum VBCPPBINARYOP
223	{
224	kVBCppBinary_Invalid = 0,
225	kVBCppBinary_Multiplication = VBCPPOP_L2R \| VBCPPOP_PRECEDENCE( 5) \| 2,
226	kVBCppBinary_Division = VBCPPOP_L2R \| VBCPPOP_PRECEDENCE( 5) \| 4,
227	kVBCppBinary_Modulo = VBCPPOP_L2R \| VBCPPOP_PRECEDENCE( 5) \| 5,
228	kVBCppBinary_Addition = VBCPPOP_L2R \| VBCPPOP_PRECEDENCE( 6) \| 6,
229	kVBCppBinary_Subtraction = VBCPPOP_L2R \| VBCPPOP_PRECEDENCE( 6) \| 7,
230	kVBCppBinary_LeftShift = VBCPPOP_L2R \| VBCPPOP_PRECEDENCE( 7) \| 8,
231	kVBCppBinary_RightShift = VBCPPOP_L2R \| VBCPPOP_PRECEDENCE( 7) \| 9,
232	kVBCppBinary_LessThan = VBCPPOP_L2R \| VBCPPOP_PRECEDENCE( 8) \| 10,
233	kVBCppBinary_LessThanOrEqual = VBCPPOP_L2R \| VBCPPOP_PRECEDENCE( 8) \| 11,
234	kVBCppBinary_GreaterThan = VBCPPOP_L2R \| VBCPPOP_PRECEDENCE( 8) \| 12,
235	kVBCppBinary_GreaterThanOrEqual = VBCPPOP_L2R \| VBCPPOP_PRECEDENCE( 8) \| 13,
236	kVBCppBinary_EqualTo = VBCPPOP_L2R \| VBCPPOP_PRECEDENCE( 9) \| 14,
237	kVBCppBinary_NotEqualTo = VBCPPOP_L2R \| VBCPPOP_PRECEDENCE( 9) \| 15,
238	kVBCppBinary_BitwiseAnd = VBCPPOP_L2R \| VBCPPOP_PRECEDENCE(10) \| 16,
239	kVBCppBinary_BitwiseXor = VBCPPOP_L2R \| VBCPPOP_PRECEDENCE(11) \| 17,
240	kVBCppBinary_BitwiseOr = VBCPPOP_L2R \| VBCPPOP_PRECEDENCE(12) \| 18,
241	kVBCppBinary_LogicalAnd = VBCPPOP_L2R \| VBCPPOP_PRECEDENCE(13) \| 19,
242	kVBCppBinary_LogicalOr = VBCPPOP_L2R \| VBCPPOP_PRECEDENCE(14) \| 20,
243	kVBCppBinary_End
244	} VBCPPBINARYOP;
245
246	/** The precedence of the ternary operator (expr ? true : false). */
247	#define VBCPPTERNAROP_PRECEDENCE VBCPPOP_PRECEDENCE(16)
248
249
250	/** Pointer to an expression parsing node. */
251	typedef struct VBCPPEXPR *PVBCPPEXPR;
252	/**
253	* Expression parsing node.
254	*/
255	typedef struct VBCPPEXPR
256	{
257	/** Parent expression. */
258	PVBCPPEXPR pParent;
259	/** Whether the expression is complete or not. */
260	bool fComplete;
261	/** The kind of expression. */
262	VBCPPEXPRKIND enmKind;
263	/** Kind specific content. */
264	union
265	{
266	/** kVBCppExprKind_Unary */
267	struct
268	{
269	VBCPPUNARYOP enmOperator;
270	PVBCPPEXPR pArg;
271	} Unary;
272
273	/** kVBCppExprKind_Binary */
274	struct
275	{
276	VBCPPBINARYOP enmOperator;
277	PVBCPPEXPR pLeft;
278	PVBCPPEXPR pRight;
279	} Binary;
280
281	/** kVBCppExprKind_Ternary */
282	struct
283	{
284	PVBCPPEXPR pExpr;
285	PVBCPPEXPR pTrue;
286	PVBCPPEXPR pFalse;
287	} Ternary;
288
289	/** kVBCppExprKind_SignedValue */
290	struct
291	{
292	int64_t s64;
293	} SignedValue;
294
295	/** kVBCppExprKind_UnsignedValue */
296	struct
297	{
298	uint64_t u64;
299	} UnsignedValue;
300	} u;
301	} VBCPPEXPR;
302
303
304	/**
305	* Operator return statuses.
306	*/
307	typedef enum VBCPPEXPRRET
308	{
309	kExprRet_Error = -1,
310	kExprRet_Ok = 0,
311	kExprRet_UnaryOperator,
312	kExprRet_Value,
313	kExprRet_EndOfExpr,
314	kExprRet_End
315	} VBCPPEXPRRET;
316
317	/**
318	* Expression parser context.
319	*/
320	typedef struct VBCPPEXPRPARSER
321	{
322	/** The current expression posistion. */
323	const char *pszCur;
324	/** The root node. */
325	PVBCPPEXPR pRoot;
326	/** The current expression node. */
327	PVBCPPEXPR pCur;
328	/** Where to insert the next expression. */
329	PVBCPPEXPR *ppCur;
330	/** The expression. */
331	const char *pszExpr;
332	/** The number of undefined macros we've encountered while parsing. */
333	size_t cUndefined;
334	/** Pointer to the C preprocessor instance. */
335	PVBCPP pThis;
336	} VBCPPEXPRPARSER;
337	/** Pointer to an expression parser context. */
338	typedef VBCPPEXPRPARSER *PVBCPPEXPRPARSER;
339
340
341	/**
342	* Evaluation result.
343	*/
344	typedef enum VBCPPEVAL
345	{
346	kVBCppEval_Invalid = 0,
347	kVBCppEval_True,
348	kVBCppEval_False,
349	kVBCppEval_Undecided,
350	kVBCppEval_End
351	} VBCPPEVAL;
352
353
354	/**
355	* The condition kind.
356	*/
357	typedef enum VBCPPCONDKIND
358	{
359	kVBCppCondKind_Invalid = 0,
360	/** \#if expr */
361	kVBCppCondKind_If,
362	/** \#ifdef define */
363	kVBCppCondKind_IfDef,
364	/** \#ifndef define */
365	kVBCppCondKind_IfNDef,
366	/** \#elif expr */
367	kVBCppCondKind_ElIf,
368	/** The end of valid values. */
369	kVBCppCondKind_End
370	} VBCPPCONDKIND;
371
372
373	/**
374	* Conditional stack entry.
375	*/
376	typedef struct VBCPPCOND
377	{
378	/** The next conditional on the stack. */
379	struct VBCPPCOND *pUp;
380	/** The kind of conditional. This changes on encountering \#elif. */
381	VBCPPCONDKIND enmKind;
382	/** Evaluation result. */
383	VBCPPEVAL enmResult;
384	/** The evaluation result of the whole stack. */
385	VBCPPEVAL enmStackResult;
386
387	/** Whether we've seen the last else. */
388	bool fSeenElse;
389	/** Set if we have an else if which has already been decided. */
390	bool fElIfDecided;
391	/** The nesting level of this condition. */
392	uint16_t iLevel;
393	/** The nesting level of this condition wrt the ones we keep. */
394	uint16_t iKeepLevel;
395
396	/** The condition string. (Points within the stream buffer.) */
397	const char *pchCond;
398	/** The condition length. */
399	size_t cchCond;
400	} VBCPPCOND;
401	/** Pointer to a conditional stack entry. */
402	typedef VBCPPCOND *PVBCPPCOND;
403
404
405	/**
406	* Input buffer stack entry.
407	*/
408	typedef struct VBCPPINPUT
409	{
410	/** Pointer to the next input on the stack. */
411	struct VBCPPINPUT *pUp;
412	/** The input stream. */
413	SCMSTREAM StrmInput;
414	/** Pointer into szName to the part which was specified. */
415	const char *pszSpecified;
416	/** The input file name with include path. */
417	char szName[1];
418	} VBCPPINPUT;
419	/** Pointer to a input buffer stack entry */
420	typedef VBCPPINPUT *PVBCPPINPUT;
421
422
423	/**
424	* The action to take with \#include.
425	*/
426	typedef enum VBCPPINCLUDEACTION
427	{
428	kVBCppIncludeAction_Invalid = 0,
429	kVBCppIncludeAction_Include,
430	kVBCppIncludeAction_PassThru,
431	kVBCppIncludeAction_Drop,
432	kVBCppIncludeAction_End
433	} VBCPPINCLUDEACTION;
434
435
436	/**
437	* C Preprocessor instance data.
438	*/
439	typedef struct VBCPP
440	{
441	/** @name Options
442	* @{ */
443	/** The preprocessing mode. */
444	VBCPPMODE enmMode;
445	/** Whether to keep comments. */
446	bool fKeepComments;
447	/** Whether to respect source defines. */
448	bool fRespectSourceDefines;
449	/** Whether to let source defines overrides the ones on the command
450	* line. */
451	bool fAllowRedefiningCmdLineDefines;
452	/** Whether to pass thru defines. */
453	bool fPassThruDefines;
454	/** Whether to allow undecided conditionals. */
455	bool fUndecidedConditionals;
456	/** Whether to pass thru D pragmas. */
457	bool fPassThruPragmaD;
458	/** Whether to pass thru STD pragmas. */
459	bool fPassThruPragmaSTD;
460	/** Whether to pass thru other pragmas. */
461	bool fPassThruPragmaOther;
462	/** Whether to remove dropped lines from the output. */
463	bool fRemoveDroppedLines;
464	/** Whether to preforme line splicing.
465	* @todo implement line splicing */
466	bool fLineSplicing;
467	/** What to do about include files. */
468	VBCPPINCLUDEACTION enmIncludeAction;
469
470	/** The number of include directories. */
471	uint32_t cIncludes;
472	/** Array of directories to search for include files. */
473	char **papszIncludes;
474
475	/** The name of the input file. */
476	const char *pszInput;
477	/** The name of the output file. NULL if stdout. */
478	const char *pszOutput;
479	/** @} */
480
481	/** The define string space. */
482	RTSTRSPACE StrSpace;
483	/** The string space holding explicitly undefined macros for selective
484	* preprocessing runs. */
485	RTSTRSPACE UndefStrSpace;
486	/** Indicates whether a C-word might need expansion.
487	* The bitmap is indexed by C-word lead character. Bits that are set
488	* indicates that the lead character is used in a \#define that we know and
489	* should expand. */
490	VBCPP_BITMAP_TYPE bmDefined[VBCPP_BITMAP_SIZE];
491
492	/** The current depth of the conditional stack. */
493	uint32_t cCondStackDepth;
494	/** Conditional stack. */
495	PVBCPPCOND pCondStack;
496	/** The current condition evaluates to kVBCppEval_False, don't output. */
497	bool fIf0Mode;
498	/** Just dropped a line and should maybe drop the current line. */
499	bool fJustDroppedLine;
500
501	/** Whether the current line could be a preprocessor line.
502	* This is set when EOL is encountered and cleared again when a
503	* non-comment-or-space character is encountered. See vbcppPreprocess. */
504	bool fMaybePreprocessorLine;
505
506	/** The input stack depth */
507	uint32_t cInputStackDepth;
508	/** The input buffer stack. */
509	PVBCPPINPUT pInputStack;
510
511	/** The output stream. */
512	SCMSTREAM StrmOutput;
513
514	/** The status of the whole job, as far as we know. */
515	RTEXITCODE rcExit;
516	/** Whether StrmOutput is valid (for vbcppTerm). */
517	bool fStrmOutputValid;
518	} VBCPP;
519
520
521	/*******************************************************************************
522	* Internal Functions *
523	*******************************************************************************/
524	static PVBCPPMACRO vbcppMacroLookup(PVBCPP pThis, const char *pszDefine, size_t cchDefine);
525	static RTEXITCODE vbcppMacroExpandIt(PVBCPP pThis, PVBCPPMACROEXP pExp, size_t offMacro, PVBCPPMACRO pMacro, size_t offParameters);
526	static RTEXITCODE vbcppMacroExpandReScan(PVBCPP pThis, PVBCPPMACROEXP pExp, VBCPPMACRORESCANMODE enmMode, size_t *pcReplacements);
527	static void vbcppMacroExpandCleanup(PVBCPPMACROEXP pExp);
528
529
530
531	/*
532	*
533	*
534	* Message Handling.
535	* Message Handling.
536	* Message Handling.
537	* Message Handling.
538	* Message Handling.
539	*
540	*
541	*/
542
543
544	/**
545	* Displays an error message.
546	*
547	* @returns RTEXITCODE_FAILURE
548	* @param pThis The C preprocessor instance.
549	* @param pszMsg The message.
550	* @param va Message arguments.
551	*/
552	static RTEXITCODE vbcppErrorV(PVBCPP pThis, const char *pszMsg, va_list va)
553	{
554	NOREF(pThis);
555	if (pThis->pInputStack)
556	{
557	PSCMSTREAM pStrm = &pThis->pInputStack->StrmInput;
558
559	size_t const off = ScmStreamTell(pStrm);
560	size_t const iLine = ScmStreamTellLine(pStrm);
561	ScmStreamSeekByLine(pStrm, iLine);
562	size_t const offLine = ScmStreamTell(pStrm);
563
564	RTPrintf("%s:%d:%zd: error: %N.\n", pThis->pInputStack->szName, iLine + 1, off - offLine + 1, pszMsg, va);
565
566	size_t cchLine;
567	SCMEOL enmEof;
568	const char *pszLine = ScmStreamGetLineByNo(pStrm, iLine, &cchLine, &enmEof);
569	if (pszLine)
570	RTPrintf(" %.*s\n"
571	" %*s^\n",
572	cchLine, pszLine, off - offLine, "");
573
574	ScmStreamSeekAbsolute(pStrm, off);
575	}
576	else
577	RTMsgErrorV(pszMsg, va);
578	return pThis->rcExit = RTEXITCODE_FAILURE;
579	}
580
581
582	/**
583	* Displays an error message.
584	*
585	* @returns RTEXITCODE_FAILURE
586	* @param pThis The C preprocessor instance.
587	* @param pszMsg The message.
588	* @param ... Message arguments.
589	*/
590	static RTEXITCODE vbcppError(PVBCPP pThis, const char *pszMsg, ...)
591	{
592	va_list va;
593	va_start(va, pszMsg);
594	RTEXITCODE rcExit = vbcppErrorV(pThis, pszMsg, va);
595	va_end(va);
596	return rcExit;
597	}
598
599
600	/**
601	* Displays an error message.
602	*
603	* @returns RTEXITCODE_FAILURE
604	* @param pThis The C preprocessor instance.
605	* @param pszPos Pointer to the offending character.
606	* @param pszMsg The message.
607	* @param ... Message arguments.
608	*/
609	static RTEXITCODE vbcppErrorPos(PVBCPP pThis, const char pszPos, const char pszMsg, ...)
610	{
611	NOREF(pszPos); NOREF(pThis);
612	va_list va;
613	va_start(va, pszMsg);
614	RTMsgErrorV(pszMsg, va);
615	va_end(va);
616	return pThis->rcExit = RTEXITCODE_FAILURE;
617	}
618
619
620
621
622
623
624
625	/*
626	*
627	*
628	* Variable String Buffers.
629	* Variable String Buffers.
630	* Variable String Buffers.
631	* Variable String Buffers.
632	* Variable String Buffers.
633	*
634	*
635	*/
636
637
638	/**
639	* Initializes a string buffer.
640	*
641	* @param pStrBuf The buffer structure to initialize.
642	* @param pThis The C preprocessor instance.
643	*/
644	static void vbcppStrBufInit(PVBCPPSTRBUF pStrBuf, PVBCPP pThis)
645	{
646	pStrBuf->pThis = pThis;
647	pStrBuf->cchBuf = 0;
648	pStrBuf->cbBufAllocated = 0;
649	pStrBuf->pszBuf = NULL;
650	}
651
652
653	/**
654	* Deletes a string buffer.
655	*
656	* @param pStrBuf Pointer to the string buffer.
657	*/
658	static void vbcppStrBufDelete(PVBCPPSTRBUF pStrBuf)
659	{
660	RTMemFree(pStrBuf->pszBuf);
661	pStrBuf->pszBuf = NULL;
662	}
663
664
665	/**
666	* Ensures that sufficient bufferspace is available, growing the buffer if
667	* necessary.
668	*
669	* @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
670	* @param pStrBuf Pointer to the string buffer.
671	* @param cbMin The minimum buffer size.
672	*/
673	static RTEXITCODE vbcppStrBufGrow(PVBCPPSTRBUF pStrBuf, size_t cbMin)
674	{
675	if (pStrBuf->cbBufAllocated >= cbMin)
676	return RTEXITCODE_SUCCESS;
677
678	size_t cbNew = pStrBuf->cbBufAllocated * 2;
679	if (cbNew < cbMin)
680	cbNew = RT_ALIGN_Z(cbMin, _1K);
681	void *pv = RTMemRealloc(pStrBuf->pszBuf, cbNew);
682	if (!pv)
683	return vbcppError(pStrBuf->pThis, "out of memory (%zu bytes)", cbNew);
684
685	pStrBuf->pszBuf = (char *)pv;
686	pStrBuf->cbBufAllocated = cbNew;
687	return RTEXITCODE_SUCCESS;
688	}
689
690
691	/**
692	* Appends a substring.
693	*
694	* @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
695	* @param pStrBuf Pointer to the string buffer.
696	* @param pchSrc Pointer to the first character in the substring.
697	* @param cchSrc The length of the substring.
698	*/
699	static RTEXITCODE vbcppStrBufAppendN(PVBCPPSTRBUF pStrBuf, const char *pchSrc, size_t cchSrc)
700	{
701	size_t cchBuf = pStrBuf->cchBuf;
702	if (cchBuf + cchSrc + 1 > pStrBuf->cbBufAllocated)
703	{
704	RTEXITCODE rcExit = vbcppStrBufGrow(pStrBuf, cchBuf + cchSrc + 1);
705	if (rcExit != RTEXITCODE_SUCCESS)
706	return rcExit;
707	}
708
709	memcpy(&pStrBuf->pszBuf[cchBuf], pchSrc, cchSrc);
710	cchBuf += cchSrc;
711	pStrBuf->pszBuf[cchBuf] = '\0';
712	pStrBuf->cchBuf = cchBuf;
713
714	return RTEXITCODE_SUCCESS;
715	}
716
717
718	/**
719	* Appends a character.
720	*
721	* @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
722	* @param pStrBuf Pointer to the string buffer.
723	* @param ch The charater to append.
724	*/
725	static RTEXITCODE vbcppStrBufAppendCh(PVBCPPSTRBUF pStrBuf, char ch)
726	{
727	size_t cchBuf = pStrBuf->cchBuf;
728	if (cchBuf + 2 > pStrBuf->cbBufAllocated)
729	{
730	RTEXITCODE rcExit = vbcppStrBufGrow(pStrBuf, cchBuf + 2);
731	if (rcExit != RTEXITCODE_SUCCESS)
732	return rcExit;
733	}
734
735	pStrBuf->pszBuf[cchBuf++] = ch;
736	pStrBuf->pszBuf[cchBuf] = '\0';
737	pStrBuf->cchBuf = cchBuf;
738
739	return RTEXITCODE_SUCCESS;
740	}
741
742
743	/**
744	* Appends a string to the buffer.
745	*
746	* @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
747	* @param pStrBuf Pointer to the string buffer.
748	* @param psz The string to append.
749	*/
750	static RTEXITCODE vbcppStrBufAppend(PVBCPPSTRBUF pStrBuf, const char *psz)
751	{
752	return vbcppStrBufAppendN(pStrBuf, psz, strlen(psz));
753	}
754
755
756	/**
757	* Gets the last char in the buffer.
758	*
759	* @returns Last character, 0 if empty.
760	* @param pStrBuf Pointer to the string buffer.
761	*/
762	static char vbcppStrBufLastCh(PVBCPPSTRBUF pStrBuf)
763	{
764	if (!pStrBuf->cchBuf)
765	return '\0';
766	return pStrBuf->pszBuf[pStrBuf->cchBuf - 1];
767	}
768
769
770
771
772
773
774
775	/*
776	*
777	*
778	* C Identifier/Word Parsing.
779	* C Identifier/Word Parsing.
780	* C Identifier/Word Parsing.
781	* C Identifier/Word Parsing.
782	* C Identifier/Word Parsing.
783	*
784	*
785	*/
786
787
788	/**
789	* Checks if the given character is a valid C identifier lead character.
790	*
791	* @returns true / false.
792	* @param ch The character to inspect.
793	*/
794	DECLINLINE(bool) vbcppIsCIdentifierLeadChar(char ch)
795	{
796	return RT_C_IS_ALPHA(ch)
797	\|\| ch == '_';
798	}
799
800
801	/**
802	* Checks if the given character is a valid C identifier character.
803	*
804	* @returns true / false.
805	* @param ch The character to inspect.
806	*/
807	DECLINLINE(bool) vbcppIsCIdentifierChar(char ch)
808	{
809	return RT_C_IS_ALNUM(ch)
810	\|\| ch == '_';
811	}
812
813
814
815	/**
816	*
817	* @returns @c true if valid, @c false if not. Error message already displayed
818	* on failure.
819	* @param pThis The C preprocessor instance.
820	* @param pchIdentifier The start of the identifier to validate.
821	* @param cchIdentifier The length of the identifier. RTSTR_MAX if not
822	* known.
823	*/
824	static bool vbcppValidateCIdentifier(PVBCPP pThis, const char *pchIdentifier, size_t cchIdentifier)
825	{
826	if (cchIdentifier == RTSTR_MAX)
827	cchIdentifier = strlen(pchIdentifier);
828
829	if (cchIdentifier == 0)
830	{
831	vbcppErrorPos(pThis, pchIdentifier, "Zero length identifier");
832	return false;
833	}
834
835	if (!vbcppIsCIdentifierLeadChar(*pchIdentifier))
836	{
837	vbcppErrorPos(pThis, pchIdentifier, "Bad lead chararacter in identifier: '%.*s'", cchIdentifier, pchIdentifier);
838	return false;
839	}
840
841	for (size_t off = 1; off < cchIdentifier; off++)
842	{
843	if (!vbcppIsCIdentifierChar(pchIdentifier[off]))
844	{
845	vbcppErrorPos(pThis, pchIdentifier + off, "Illegal chararacter in identifier: '%.*s' (#%zu)", cchIdentifier, pchIdentifier, off + 1);
846	return false;
847	}
848	}
849
850	return true;
851	}
852
853	#if 0
854
855	/**
856	* Checks if the given character is valid C punctuation.
857	*
858	* @returns true / false.
859	* @param ch The character to inspect.
860	*/
861	DECLINLINE(bool) vbcppIsCPunctuationLeadChar(char ch)
862	{
863	switch (ch)
864	{
865	case '!':
866	case '#':
867	case '%':
868	case '&':
869	case '(':
870	case ')':
871	case '*':
872	case '+':
873	case ',':
874	case '-':
875	case '.':
876	case '/':
877	case ':':
878	case ';':
879	case '<':
880	case '=':
881	case '>':
882	case '?':
883	case '[':
884	case ']':
885	case '^':
886	case '{':
887	case '\|':
888	case '}':
889	case '~':
890	return true;
891	default:
892	return false;
893	}
894	}
895
896
897	/**
898	* Checks if the given string start with valid C punctuation.
899	*
900	* @returns 0 if not, otherwise the length of the punctuation.
901	* @param pch The which start we should evaluate.
902	* @param cchMax The maximum string length.
903	*/
904	static size_t vbcppIsCPunctuationLeadChar(const char *psz, size_t cchMax)
905	{
906	if (!cchMax)
907	return 0;
908
909	switch (psz[0])
910	{
911	case '!':
912	case '*':
913	case '/':
914	case '=':
915	case '^':
916	if (cchMax >= 2 && psz[1] == '=')
917	return 2;
918	return 1;
919
920	case '#':
921	if (cchMax >= 2 && psz[1] == '#')
922	return 2;
923	return 1;
924
925	case '%':
926	if (cchMax >= 2 && (psz[1] == '=' \|\| psz[1] == '>'))
927	return 2;
928	if (cchMax >= 2 && psz[1] == ':')
929	{
930	if (cchMax >= 4 && psz[2] == '%' && psz[3] == ':')
931	return 4;
932	return 2;
933	}
934	return 1;
935
936	case '&':
937	if (cchMax >= 2 && (psz[1] == '=' \|\| psz[1] == '&'))
938	return 2;
939	return 1;
940
941	case '(':
942	case ')':
943	case ',':
944	case '?':
945	case '[':
946	case ']':
947	case '{':
948	case '}':
949	return 1;
950
951	case '+':
952	if (cchMax >= 2 && (psz[1] == '=' \|\| psz[1] == '+'))
953	return 2;
954	return 1;
955
956	case '-':
957	if (cchMax >= 2 && (psz[1] == '=' \|\| psz[1] == '-' \|\| psz[1] == '>'))
958	return 2;
959	return 1;
960
961	case ':':
962	if (cchMax >= 2 && psz[1] == '>')
963	return 2;
964	return 1;
965
966	case ';':
967	return 1;
968
969	case '<':
970	if (cchMax >= 2 && psz[1] == '<')
971	{
972	if (cchMax >= 3 && psz[2] == '=')
973	return 3;
974	return 2;
975	}
976	if (cchMax >= 2 && (psz[1] == '=' \|\| psz[1] == ':' \|\| psz[1] == '%'))
977	return 2;
978	return 1;
979
980	case '.':
981	if (cchMax >= 3 && psz[1] == '.' && psz[2] == '.')
982	return 3;
983	return 1;
984
985	case '>':
986	if (cchMax >= 2 && psz[1] == '>')
987	{
988	if (cchMax >= 3 && psz[2] == '=')
989	return 3;
990	return 2;
991	}
992	if (cchMax >= 2 && psz[1] == '=')
993	return 2;
994	return 1;
995
996	case '\|':
997	if (cchMax >= 2 && (psz[1] == '=' \|\| psz[1] == '\|'))
998	return 2;
999	return 1;
1000
1001	case '~':
1002	return 1;
1003
1004	default:
1005	return 0;
1006	}
1007	}
1008
1009	#endif
1010
1011
1012
1013
1014
1015	/*
1016	*
1017	*
1018	* Output
1019	* Output
1020	* Output
1021	* Output
1022	* Output
1023	*
1024	*
1025	*/
1026
1027
1028	/**
1029	* Outputs a character.
1030	*
1031	* @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
1032	* @param pThis The C preprocessor instance.
1033	* @param ch The character to output.
1034	*/
1035	static RTEXITCODE vbcppOutputCh(PVBCPP pThis, char ch)
1036	{
1037	int rc = ScmStreamPutCh(&pThis->StrmOutput, ch);
1038	if (RT_SUCCESS(rc))
1039	return RTEXITCODE_SUCCESS;
1040	return vbcppError(pThis, "Output error: %Rrc", rc);
1041	}
1042
1043
1044	/**
1045	* Outputs a string.
1046	*
1047	* @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
1048	* @param pThis The C preprocessor instance.
1049	* @param pch The string.
1050	* @param cch The number of characters to write.
1051	*/
1052	static RTEXITCODE vbcppOutputWrite(PVBCPP pThis, const char *pch, size_t cch)
1053	{
1054	int rc = ScmStreamWrite(&pThis->StrmOutput, pch, cch);
1055	if (RT_SUCCESS(rc))
1056	return RTEXITCODE_SUCCESS;
1057	return vbcppError(pThis, "Output error: %Rrc", rc);
1058	}
1059
1060
1061	static RTEXITCODE vbcppOutputComment(PVBCPP pThis, PSCMSTREAM pStrmInput, size_t offStart, size_t cchOutputted,
1062	size_t cchMinIndent)
1063	{
1064	size_t offCur = ScmStreamTell(pStrmInput);
1065	if (offStart < offCur)
1066	{
1067	int rc = ScmStreamSeekAbsolute(pStrmInput, offStart);
1068	AssertRCReturn(rc, vbcppError(pThis, "Input seek error: %Rrc", rc));
1069
1070	/*
1071	* Use the same indent, if possible.
1072	*/
1073	size_t cchIndent = offStart - ScmStreamTellOffsetOfLine(pStrmInput, ScmStreamTellLine(pStrmInput));
1074	if (cchOutputted < cchIndent)
1075	rc = ScmStreamPrintf(&pThis->StrmOutput, "%*s", cchIndent - cchOutputted, "");
1076	else
1077	rc = ScmStreamPutCh(&pThis->StrmOutput, ' ');
1078	if (RT_FAILURE(rc))
1079	return vbcppError(pThis, "Output error: %Rrc", rc);
1080
1081	/*
1082	* Copy the bytes.
1083	*/
1084	while (ScmStreamTell(pStrmInput) < offCur)
1085	{
1086	unsigned ch = ScmStreamGetCh(pStrmInput);
1087	if (ch == ~(unsigned)0)
1088	return vbcppError(pThis, "Input error: %Rrc", rc);
1089	rc = ScmStreamPutCh(&pThis->StrmOutput, ch);
1090	if (RT_FAILURE(rc))
1091	return vbcppError(pThis, "Output error: %Rrc", rc);
1092	}
1093	}
1094
1095	return RTEXITCODE_SUCCESS;
1096	}
1097
1098
1099
1100
1101
1102	/*
1103	*
1104	*
1105	* Input
1106	* Input
1107	* Input
1108	* Input
1109	* Input
1110	*
1111	*
1112	*/
1113
1114
1115	/**
1116	* Skips white spaces, including escaped new-lines.
1117	*
1118	* @param pStrmInput The input stream.
1119	*/
1120	static void vbcppProcessSkipWhiteAndEscapedEol(PSCMSTREAM pStrmInput)
1121	{
1122	unsigned chPrev = ~(unsigned)0;
1123	unsigned ch;
1124	while ((ch = ScmStreamPeekCh(pStrmInput)) != ~(unsigned)0)
1125	{
1126	if (ch == '\r' \|\| ch == '\n')
1127	{
1128	if (chPrev != '\\')
1129	break;
1130	chPrev = ch;
1131	ScmStreamSeekByLine(pStrmInput, ScmStreamTellLine(pStrmInput) + 1);
1132	}
1133	else if (RT_C_IS_SPACE(ch))
1134	{
1135	ch = chPrev;
1136	ch = ScmStreamGetCh(pStrmInput);
1137	Assert(ch == chPrev);
1138	}
1139	else
1140	break;
1141	}
1142	}
1143
1144
1145	/**
1146	* Skips white spaces, escaped new-lines and multi line comments.
1147	*
1148	* @param pThis The C preprocessor instance.
1149	* @param pStrmInput The input stream.
1150	*/
1151	static RTEXITCODE vbcppProcessSkipWhiteEscapedEolAndComments(PVBCPP pThis, PSCMSTREAM pStrmInput)
1152	{
1153	unsigned chPrev = ~(unsigned)0;
1154	unsigned ch;
1155	while ((ch = ScmStreamPeekCh(pStrmInput)) != ~(unsigned)0)
1156	{
1157	if (!RT_C_IS_SPACE(ch))
1158	{
1159	/* Multi-line Comment? */
1160	if (ch != '/')
1161	break; /* most definitely, not. */
1162
1163	size_t offSaved = ScmStreamTell(pStrmInput);
1164	ScmStreamGetCh(pStrmInput);
1165	if (ScmStreamPeekCh(pStrmInput) != '*')
1166	{
1167	ScmStreamSeekAbsolute(pStrmInput, offSaved);
1168	break; /* no */
1169	}
1170
1171	/* Skip to the end of the comment. */
1172	while ((ch = ScmStreamGetCh(pStrmInput)) != ~(unsigned)0)
1173	{
1174	if (ch == '*')
1175	{
1176	ch = ScmStreamGetCh(pStrmInput);
1177	if (ch == '/')
1178	break;
1179	if (ch == ~(unsigned)0)
1180	break;
1181	}
1182	}
1183	if (ch == ~(unsigned)0)
1184	return vbcppError(pThis, "unterminated multi-line comment");
1185	chPrev = '/';
1186	}
1187	/* New line (also matched by RT_C_IS_SPACE). */
1188	else if (ch == '\r' \|\| ch == '\n')
1189	{
1190	/* Stop if not escaped. */
1191	if (chPrev != '\\')
1192	break;
1193	chPrev = ch;
1194	ScmStreamSeekByLine(pStrmInput, ScmStreamTellLine(pStrmInput) + 1);
1195	}
1196	/* Real space char. */
1197	else
1198	{
1199	chPrev = ch;
1200	ch = ScmStreamGetCh(pStrmInput);
1201	Assert(ch == chPrev);
1202	}
1203	}
1204	return RTEXITCODE_SUCCESS;
1205	}
1206
1207
1208	/**
1209	* Skips white spaces, escaped new-lines, and multi line comments, then checking
1210	* that we're at the end of a line.
1211	*
1212	* @param pThis The C preprocessor instance.
1213	* @param pStrmInput The input stream.
1214	*/
1215	static RTEXITCODE vbcppProcessSkipWhiteEscapedEolAndCommentsCheckEol(PVBCPP pThis, PSCMSTREAM pStrmInput)
1216	{
1217	RTEXITCODE rcExit = vbcppProcessSkipWhiteEscapedEolAndComments(pThis, pStrmInput);
1218	if (rcExit == RTEXITCODE_SUCCESS)
1219	{
1220	unsigned ch = ScmStreamPeekCh(pStrmInput);
1221	if ( ch != ~(unsigned)0
1222	&& ch != '\r'
1223	&& ch != '\n')
1224	rcExit = vbcppError(pThis, "Did not expected anything more on this line");
1225	}
1226	return rcExit;
1227	}
1228
1229
1230	/**
1231	* Skips white spaces.
1232	*
1233	* @returns The current location upon return.
1234	* @param pStrmInput The input stream.
1235	*/
1236	static size_t vbcppProcessSkipWhite(PSCMSTREAM pStrmInput)
1237	{
1238	unsigned ch;
1239	while ((ch = ScmStreamPeekCh(pStrmInput)) != ~(unsigned)0)
1240	{
1241	if (!RT_C_IS_SPACE(ch) \|\| ch == '\r' \|\| ch == '\n')
1242	break;
1243	unsigned chCheck = ScmStreamGetCh(pStrmInput);
1244	AssertBreak(chCheck == ch);
1245	}
1246	return ScmStreamTell(pStrmInput);
1247	}
1248
1249
1250	/**
1251	* Looks for a left parenthesis in the input stream.
1252	*
1253	* Used during macro expansion. Will ignore comments, newlines and other
1254	* whitespace.
1255	*
1256	* @retval true if found. The stream position at opening parenthesis.
1257	* @retval false if not found. The stream position is unchanged.
1258	*
1259	* @param pThis The C preprocessor instance.
1260	* @param pStrmInput The input stream.
1261	*/
1262	static bool vbcppInputLookForLeftParenthesis(PVBCPP pThis, PSCMSTREAM pStrmInput)
1263	{
1264	size_t offSaved = ScmStreamTell(pStrmInput);
1265	RTEXITCODE rcExit = vbcppProcessSkipWhiteEscapedEolAndComments(pThis, pStrmInput);
1266	unsigned ch = ScmStreamPeekCh(pStrmInput);
1267	if (ch == '(')
1268	return true;
1269
1270	int rc = ScmStreamSeekAbsolute(pStrmInput, offSaved);
1271	AssertFatalRC(rc);
1272	return false;
1273	}
1274
1275
1276	/**
1277	* Skips input until the real end of the current directive line has been
1278	* reached.
1279	*
1280	* This includes multiline comments starting on the same line
1281	*
1282	* @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
1283	* @param pThis The C preprocessor instance.
1284	* @param pStrmInput The input stream.
1285	* @param poffComment Where to note down the position of the final
1286	* comment. Optional.
1287	*/
1288	static RTEXITCODE vbcppInputSkipToEndOfDirectiveLine(PVBCPP pThis, PSCMSTREAM pStrmInput, size_t *poffComment)
1289	{
1290	if (poffComment)
1291	*poffComment = ~(size_t)0;
1292
1293	RTEXITCODE rcExit = RTEXITCODE_SUCCESS;
1294	bool fInComment = false;
1295	unsigned chPrev = 0;
1296	unsigned ch;
1297	while ((ch = ScmStreamPeekCh(pStrmInput)) != ~(unsigned)0)
1298	{
1299	if (ch == '\r' \|\| ch == '\n')
1300	{
1301	if (chPrev == '\\')
1302	{
1303	ScmStreamSeekByLine(pStrmInput, ScmStreamTellLine(pStrmInput) + 1);
1304	continue;
1305	}
1306	if (!fInComment)
1307	break;
1308	/* The expression continues after multi-line comments. Cool. :-) */
1309	}
1310	else if (!fInComment)
1311	{
1312	if (chPrev == '/' && ch == '*' )
1313	{
1314	fInComment = true;
1315	if (poffComment)
1316	*poffComment = ScmStreamTell(pStrmInput) - 1;
1317	}
1318	else if (chPrev == '/' && ch == '/')
1319	{
1320	if (poffComment)
1321	*poffComment = ScmStreamTell(pStrmInput) - 1;
1322	rcExit = vbcppProcessSkipWhiteEscapedEolAndComments(pThis, pStrmInput);
1323	break; /* done */
1324	}
1325	}
1326	else if (ch == '/' && chPrev == '*')
1327	fInComment = false;
1328
1329	/* advance */
1330	chPrev = ch;
1331	ch = ScmStreamGetCh(pStrmInput); Assert(ch == chPrev);
1332	}
1333	return rcExit;
1334	}
1335
1336
1337	/**
1338	* Processes a multi-line comment.
1339	*
1340	* Must either string the comment or keep it. If the latter, we must refrain
1341	* from replacing C-words in it.
1342	*
1343	* @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
1344	* @param pThis The C preprocessor instance.
1345	* @param pStrmInput The input stream.
1346	*/
1347	static RTEXITCODE vbcppProcessMultiLineComment(PVBCPP pThis, PSCMSTREAM pStrmInput)
1348	{
1349	/* The open comment sequence. */
1350	ScmStreamGetCh(pStrmInput); /* '' /
1351	RTEXITCODE rcExit = RTEXITCODE_SUCCESS;
1352	if ( pThis->fKeepComments
1353	&& !pThis->fIf0Mode)
1354	rcExit = vbcppOutputWrite(pThis, "/*", 2);
1355
1356	/* The comment.*/
1357	unsigned ch;
1358	while ( rcExit == RTEXITCODE_SUCCESS
1359	&& (ch = ScmStreamGetCh(pStrmInput)) != ~(unsigned)0 )
1360	{
1361	if (ch == '*')
1362	{
1363	/* Closing sequence? */
1364	unsigned ch2 = ScmStreamPeekCh(pStrmInput);
1365	if (ch2 == '/')
1366	{
1367	ScmStreamGetCh(pStrmInput);
1368	if ( pThis->fKeepComments
1369	&& !pThis->fIf0Mode)
1370	rcExit = vbcppOutputWrite(pThis, "*/", 2);
1371	break;
1372	}
1373	}
1374
1375	if (ch == '\r' \|\| ch == '\n')
1376	{
1377	if ( ( pThis->fKeepComments
1378	&& !pThis->fIf0Mode)
1379	\|\| !pThis->fRemoveDroppedLines
1380	\|\| !ScmStreamIsAtStartOfLine(&pThis->StrmOutput))
1381	rcExit = vbcppOutputCh(pThis, ch);
1382	pThis->fJustDroppedLine = false;
1383	pThis->fMaybePreprocessorLine = true;
1384	}
1385	else if ( pThis->fKeepComments
1386	&& !pThis->fIf0Mode)
1387	rcExit = vbcppOutputCh(pThis, ch);
1388
1389	if (rcExit != RTEXITCODE_SUCCESS)
1390	break;
1391	}
1392	return rcExit;
1393	}
1394
1395
1396	/**
1397	* Processes a single line comment.
1398	*
1399	* Must either string the comment or keep it. If the latter, we must refrain
1400	* from replacing C-words in it.
1401	*
1402	* @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
1403	* @param pThis The C preprocessor instance.
1404	* @param pStrmInput The input stream.
1405	*/
1406	static RTEXITCODE vbcppProcessOneLineComment(PVBCPP pThis, PSCMSTREAM pStrmInput)
1407	{
1408	RTEXITCODE rcExit = RTEXITCODE_SUCCESS;
1409	SCMEOL enmEol;
1410	size_t cchLine;
1411	const char *pszLine = ScmStreamGetLine(pStrmInput, &cchLine, &enmEol); Assert(pszLine);
1412	pszLine--; cchLine++; /* unfetching the first slash. */
1413	for (;;)
1414	{
1415	if ( pThis->fKeepComments
1416	&& !pThis->fIf0Mode)
1417	rcExit = vbcppOutputWrite(pThis, pszLine, cchLine + enmEol);
1418	else if ( !pThis->fIf0Mode
1419	\|\| !pThis->fRemoveDroppedLines
1420	\|\| !ScmStreamIsAtStartOfLine(&pThis->StrmOutput) )
1421	rcExit = vbcppOutputWrite(pThis, pszLine + cchLine, enmEol);
1422	if (rcExit != RTEXITCODE_SUCCESS)
1423	break;
1424	if ( cchLine == 0
1425	\|\| pszLine[cchLine - 1] != '\\')
1426	break;
1427
1428	pszLine = ScmStreamGetLine(pStrmInput, &cchLine, &enmEol);
1429	if (!pszLine)
1430	break;
1431	}
1432	pThis->fJustDroppedLine = false;
1433	pThis->fMaybePreprocessorLine = true;
1434	return rcExit;
1435	}
1436
1437
1438	/**
1439	* Processes a double quoted string.
1440	*
1441	* Must not replace any C-words in strings.
1442	*
1443	* @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
1444	* @param pThis The C preprocessor instance.
1445	* @param pStrmInput The input stream.
1446	*/
1447	static RTEXITCODE vbcppProcessStringLitteral(PVBCPP pThis, PSCMSTREAM pStrmInput)
1448	{
1449	RTEXITCODE rcExit = vbcppOutputCh(pThis, '"');
1450	if (rcExit == RTEXITCODE_SUCCESS)
1451	{
1452	bool fEscaped = false;
1453	for (;;)
1454	{
1455	unsigned ch = ScmStreamGetCh(pStrmInput);
1456	if (ch == ~(unsigned)0)
1457	{
1458	rcExit = vbcppError(pThis, "Unterminated double quoted string");
1459	break;
1460	}
1461
1462	rcExit = vbcppOutputCh(pThis, ch);
1463	if (rcExit != RTEXITCODE_SUCCESS)
1464	break;
1465
1466	if (ch == '"' && !fEscaped)
1467	break;
1468	fEscaped = !fEscaped && ch == '\\';
1469	}
1470	}
1471	return rcExit;
1472	}
1473
1474
1475	/**
1476	* Processes a single quoted constant.
1477	*
1478	* Must not replace any C-words in character constants.
1479	*
1480	* @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
1481	* @param pThis The C preprocessor instance.
1482	* @param pStrmInput The input stream.
1483	*/
1484	static RTEXITCODE vbcppProcessCharacterConstant(PVBCPP pThis, PSCMSTREAM pStrmInput)
1485	{
1486	RTEXITCODE rcExit = vbcppOutputCh(pThis, '\'');
1487	if (rcExit == RTEXITCODE_SUCCESS)
1488	{
1489	bool fEscaped = false;
1490	for (;;)
1491	{
1492	unsigned ch = ScmStreamGetCh(pStrmInput);
1493	if (ch == ~(unsigned)0)
1494	{
1495	rcExit = vbcppError(pThis, "Unterminated singled quoted string");
1496	break;
1497	}
1498
1499	rcExit = vbcppOutputCh(pThis, ch);
1500	if (rcExit != RTEXITCODE_SUCCESS)
1501	break;
1502
1503	if (ch == '\'' && !fEscaped)
1504	break;
1505	fEscaped = !fEscaped && ch == '\\';
1506	}
1507	}
1508	return rcExit;
1509	}
1510
1511
1512	/**
1513	* Processes a integer or floating point number constant.
1514	*
1515	* Must not replace the type suffix.
1516	*
1517	* @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
1518	* @param pThis The C preprocessor instance.
1519	* @param pStrmInput The input stream.
1520	* @param chFirst The first character.
1521	*/
1522	static RTEXITCODE vbcppProcessNumber(PVBCPP pThis, PSCMSTREAM pStrmInput, char chFirst)
1523	{
1524	RTEXITCODE rcExit = vbcppOutputCh(pThis, chFirst);
1525
1526	unsigned ch;
1527	while ( rcExit == RTEXITCODE_SUCCESS
1528	&& (ch = ScmStreamPeekCh(pStrmInput)) != ~(unsigned)0)
1529	{
1530	if ( !vbcppIsCIdentifierChar(ch)
1531	&& ch != '.')
1532	break;
1533
1534	unsigned ch2 = ScmStreamGetCh(pStrmInput);
1535	AssertBreakStmt(ch2 == ch, rcExit = vbcppError(pThis, "internal error"));
1536	rcExit = vbcppOutputCh(pThis, ch);
1537	}
1538
1539	return rcExit;
1540	}
1541
1542
1543	/**
1544	* Processes a identifier, possibly replacing it with a definition.
1545	*
1546	* @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
1547	* @param pThis The C preprocessor instance.
1548	* @param pStrmInput The input stream.
1549	* @param ch The first character.
1550	*/
1551	static RTEXITCODE vbcppProcessIdentifier(PVBCPP pThis, PSCMSTREAM pStrmInput, char ch)
1552	{
1553	RTEXITCODE rcExit;
1554	size_t cchDefine;
1555	const char *pchDefine = ScmStreamCGetWordM1(pStrmInput, &cchDefine);
1556	AssertReturn(pchDefine, vbcppError(pThis, "Internal error in ScmStreamCGetWordM1"));
1557
1558	/*
1559	* Does this look like a define we know?
1560	*/
1561	PVBCPPMACRO pMacro = vbcppMacroLookup(pThis, pchDefine, cchDefine);
1562	if ( pMacro
1563	&& ( !pMacro->fFunction
1564	\|\| vbcppInputLookForLeftParenthesis(pThis, pStrmInput)) )
1565	{
1566	/*
1567	* Expand it.
1568	*/
1569	VBCPPMACROEXP ExpCtx;
1570	#if 0
1571	ExpCtx.pMacroStack = NULL;
1572	#endif
1573	ExpCtx.pStrmInput = pStrmInput;
1574	ExpCtx.papszArgs = NULL;
1575	ExpCtx.cArgs = 0;
1576	ExpCtx.cArgsAlloced = 0;
1577	vbcppStrBufInit(&ExpCtx.StrBuf, pThis);
1578	rcExit = vbcppStrBufAppendN(&ExpCtx.StrBuf, pchDefine, cchDefine);
1579	if (rcExit == RTEXITCODE_SUCCESS)
1580	rcExit = vbcppMacroExpandIt(pThis, &ExpCtx, 0 /* offset */, pMacro, cchDefine);
1581	if (rcExit == RTEXITCODE_SUCCESS)
1582	rcExit = vbcppMacroExpandReScan(pThis, &ExpCtx, kMacroReScanMode_Normal, NULL);
1583	if (rcExit == RTEXITCODE_SUCCESS)
1584	{
1585	/*
1586	* Insert it into the output stream. Make sure there is a
1587	* whitespace following it.
1588	*/
1589	int rc = ScmStreamWrite(&pThis->StrmOutput, ExpCtx.StrBuf.pszBuf, ExpCtx.StrBuf.cchBuf);
1590	if (RT_SUCCESS(rc))
1591	{
1592	unsigned chAfter = ScmStreamPeekCh(pStrmInput);
1593	if (chAfter != ~(unsigned)0 && !RT_C_IS_SPACE(chAfter))
1594	rcExit = vbcppOutputCh(pThis, ' ');
1595	}
1596	else
1597	rcExit = vbcppError(pThis, "Output error: %Rrc", rc);
1598	}
1599	vbcppMacroExpandCleanup(&ExpCtx);
1600	}
1601	else
1602	{
1603	/*
1604	* Not a macro or a function-macro name match but no invocation, just
1605	* output the text unchanged.
1606	*/
1607	int rc = ScmStreamWrite(&pThis->StrmOutput, pchDefine, cchDefine);
1608	if (RT_SUCCESS(rc))
1609	rcExit = RTEXITCODE_SUCCESS;
1610	else
1611	rcExit = vbcppError(pThis, "Output error: %Rrc", rc);
1612	}
1613	return rcExit;
1614	}
1615
1616
1617
1618
1619
1620
1621
1622	/*
1623	*
1624	*
1625	* D E F I N E S / M A C R O S
1626	* D E F I N E S / M A C R O S
1627	* D E F I N E S / M A C R O S
1628	* D E F I N E S / M A C R O S
1629	* D E F I N E S / M A C R O S
1630	*
1631	*
1632	*/
1633
1634
1635	/**
1636	* Checks if a define exists.
1637	*
1638	* @returns true or false.
1639	* @param pThis The C preprocessor instance.
1640	* @param pszDefine The define name and optionally the argument
1641	* list.
1642	* @param cchDefine The length of the name. RTSTR_MAX is ok.
1643	*/
1644	static bool vbcppMacroExists(PVBCPP pThis, const char *pszDefine, size_t cchDefine)
1645	{
1646	return cchDefine > 0
1647	&& VBCPP_BITMAP_IS_SET(pThis->bmDefined, *pszDefine)
1648	&& RTStrSpaceGetN(&pThis->StrSpace, pszDefine, cchDefine) != NULL;
1649	}
1650
1651
1652	/**
1653	* Looks up a define.
1654	*
1655	* @returns Pointer to the define if found, NULL if not.
1656	* @param pThis The C preprocessor instance.
1657	* @param pszDefine The define name and optionally the argument
1658	* list.
1659	* @param cchDefine The length of the name. RTSTR_MAX is ok.
1660	*/
1661	static PVBCPPMACRO vbcppMacroLookup(PVBCPP pThis, const char *pszDefine, size_t cchDefine)
1662	{
1663	if (!cchDefine)
1664	return NULL;
1665	if (!VBCPP_BITMAP_IS_SET(pThis->bmDefined, *pszDefine))
1666	return NULL;
1667	return (PVBCPPMACRO)RTStrSpaceGetN(&pThis->StrSpace, pszDefine, cchDefine);
1668	}
1669
1670
1671	static uint32_t vbcppMacroLookupArg(PVBCPPMACRO pMacro, const char *pchName, size_t cchName)
1672	{
1673	Assert(cchName > 0);
1674
1675	char const ch = *pchName;
1676	for (uint32_t i = 0; i < pMacro->cArgs; i++)
1677	if ( pMacro->papszArgs[i][0] == ch
1678	&& !strncmp(pMacro->papszArgs[i], pchName, cchName)
1679	&& pMacro->papszArgs[i][cchName] == '\0')
1680	return i;
1681
1682	if ( pMacro->fVarArg
1683	&& cchName == sizeof("__VA_ARGS__") - 1
1684	&& !strncmp(pchName, "__VA_ARGS__", sizeof("__VA_ARGS__") - 1) )
1685	return pMacro->cArgs;
1686
1687	return UINT32_MAX;
1688	}
1689
1690
1691	static RTEXITCODE vbcppMacroExpandReplace(PVBCPP pThis, PVBCPPMACROEXP pExp, size_t off, size_t cchToReplace,
1692	const char *pchReplacement, size_t cchReplacement)
1693	{
1694	/*
1695	* Figure how much space we actually need.
1696	* (Hope this whitespace stuff is correct...)
1697	*/
1698	bool const fLeadingSpace = off > 0
1699	&& !RT_C_IS_SPACE(pExp->StrBuf.pszBuf[off - 1]);
1700	bool const fTrailingSpace = off + cchToReplace < pExp->StrBuf.cchBuf
1701	&& !RT_C_IS_SPACE(pExp->StrBuf.pszBuf[off + cchToReplace]);
1702	size_t const cchActualReplacement = fLeadingSpace + cchReplacement + fTrailingSpace;
1703
1704	/*
1705	* Adjust the buffer size and contents.
1706	*/
1707	if (cchActualReplacement > cchToReplace)
1708	{
1709	size_t const offMore = cchActualReplacement - cchToReplace;
1710
1711	/* Ensure enough buffer space. */
1712	size_t cbMinBuf = offMore + pExp->StrBuf.cchBuf + 1;
1713	RTEXITCODE rcExit = vbcppStrBufGrow(&pExp->StrBuf, cbMinBuf);
1714	if (rcExit != RTEXITCODE_SUCCESS)
1715	return rcExit;
1716
1717	/* Push the chars following the replacement area down to make room. */
1718	memmove(&pExp->StrBuf.pszBuf[off + cchToReplace + offMore],
1719	&pExp->StrBuf.pszBuf[off + cchToReplace],
1720	pExp->StrBuf.cchBuf - off - cchToReplace + 1);
1721	pExp->StrBuf.cchBuf += offMore;
1722
1723	}
1724	else if (cchActualReplacement < cchToReplace)
1725	{
1726	size_t const offLess = cchToReplace - cchActualReplacement;
1727
1728	/* Pull the chars following the replacement area up. */
1729	memmove(&pExp->StrBuf.pszBuf[off + cchToReplace - offLess],
1730	&pExp->StrBuf.pszBuf[off + cchToReplace],
1731	pExp->StrBuf.cchBuf - off - cchToReplace + 1);
1732	pExp->StrBuf.cchBuf -= offLess;
1733	}
1734
1735	/*
1736	* Insert the replacement string.
1737	*/
1738	char *pszCur = &pExp->StrBuf.pszBuf[off];
1739	if (fLeadingSpace)
1740	*pszCur++ = ' ';
1741	memcpy(pszCur, pchReplacement, cchReplacement);
1742	if (fTrailingSpace)
1743	*pszCur++ = ' ';
1744
1745	Assert(strlen(pExp->StrBuf.pszBuf) == pExp->StrBuf.cchBuf);
1746
1747	return RTEXITCODE_SUCCESS;
1748	}
1749
1750
1751	static unsigned vbcppMacroExpandPeekCh(PVBCPPMACROEXP pExp, size_t *poff)
1752	{
1753	size_t off = *poff;
1754	if (off >= pExp->StrBuf.cchBuf)
1755	return pExp->pStrmInput ? ScmStreamPeekCh(pExp->pStrmInput) : ~(unsigned)0;
1756	return pExp->StrBuf.pszBuf[off];
1757	}
1758
1759
1760	static unsigned vbcppMacroExpandGetCh(PVBCPPMACROEXP pExp, size_t *poff)
1761	{
1762	size_t off = *poff;
1763	if (off >= pExp->StrBuf.cchBuf)
1764	return pExp->pStrmInput ? ScmStreamGetCh(pExp->pStrmInput) : ~(unsigned)0;
1765	*poff = off + 1;
1766	return pExp->StrBuf.pszBuf[off];
1767	}
1768
1769
1770	static RTEXITCODE vbcppMacroExpandSkipEolEx(PVBCPP pThis, PVBCPPMACROEXP pExp, size_t *poff, unsigned chFirst)
1771	{
1772	if (chFirst == '\r')
1773	{
1774	unsigned ch2 = vbcppMacroExpandPeekCh(pExp, poff);
1775	if (ch2 == '\n')
1776	{
1777	ch2 = ScmStreamGetCh(pExp->pStrmInput);
1778	AssertReturn(ch2 == '\n', vbcppError(pThis, "internal error"));
1779	}
1780	}
1781	return RTEXITCODE_SUCCESS;
1782	}
1783
1784
1785	static RTEXITCODE vbcppMacroExpandSkipEol(PVBCPP pThis, PVBCPPMACROEXP pExp, size_t *poff)
1786	{
1787	unsigned ch = vbcppMacroExpandGetCh(pExp, poff);
1788	AssertReturn(ch == '\r' \|\| ch == '\n', vbcppError(pThis, "internal error"));
1789	return vbcppMacroExpandSkipEolEx(pThis, pExp, poff, ch);
1790	}
1791
1792
1793	static RTEXITCODE vbcppMacroExpandSkipCommentLine(PVBCPP pThis, PVBCPPMACROEXP pExp, size_t *poff)
1794	{
1795	unsigned ch = vbcppMacroExpandGetCh(pExp, poff);
1796	AssertReturn(ch == '/', vbcppError(pThis, "Internal error - expected '/' got '%c'", ch));
1797
1798	unsigned chPrev = 0;
1799	while ((ch = vbcppMacroExpandGetCh(pExp, poff)) != ~(unsigned)0)
1800	{
1801	if (ch == '\r' \|\| ch == '\n')
1802	{
1803	RTEXITCODE rcExit = vbcppMacroExpandSkipEolEx(pThis, pExp, poff, ch);
1804	if (rcExit != RTEXITCODE_SUCCESS)
1805	return rcExit;
1806	if (chPrev != '\\')
1807	break;
1808	}
1809
1810	chPrev = ch;
1811	}
1812	return RTEXITCODE_SUCCESS;
1813	}
1814
1815
1816	static RTEXITCODE vbcppMacroExpandSkipComment(PVBCPP pThis, PVBCPPMACROEXP pExp, size_t *poff)
1817	{
1818	unsigned ch = vbcppMacroExpandGetCh(pExp, poff);
1819	AssertReturn(ch == '', vbcppError(pThis, "Internal error - expected '' got '%c'", ch));
1820
1821	unsigned chPrev2 = 0;
1822	unsigned chPrev = 0;
1823	while ((ch = vbcppMacroExpandGetCh(pExp, poff)) != ~(unsigned)0)
1824	{
1825	if (ch == '/' && chPrev == '*')
1826	break;
1827
1828	if (ch == '\r' \|\| ch == '\n')
1829	{
1830	RTEXITCODE rcExit = vbcppMacroExpandSkipEolEx(pThis, pExp, poff, ch);
1831	if (rcExit != RTEXITCODE_SUCCESS)
1832	return rcExit;
1833	if (chPrev == '\\')
1834	{
1835	chPrev = chPrev2; /* for line splicing */
1836	continue;
1837	}
1838	}
1839
1840	chPrev2 = chPrev;
1841	chPrev = ch;
1842	}
1843	return RTEXITCODE_SUCCESS;
1844	}
1845
1846
1847	static RTEXITCODE vbcppMacroExpandGrowArgArray(PVBCPP pThis, PVBCPPMACROEXP pExp, uint32_t cMinArgs)
1848	{
1849	if (cMinArgs > pExp->cArgsAlloced)
1850	{
1851	void pv = RTMemRealloc(pExp->papszArgs, cMinArgs sizeof(char *));
1852	if (!pv)
1853	return vbcppError(pThis, "out of memory");
1854	pExp->papszArgs = (char **)pv;
1855	pExp->cArgsAlloced = cMinArgs;
1856	}
1857	return RTEXITCODE_SUCCESS;
1858	}
1859
1860
1861	static RTEXITCODE vbcppMacroExpandAddEmptyParameter(PVBCPP pThis, PVBCPPMACROEXP pExp)
1862	{
1863	RTEXITCODE rcExit = vbcppMacroExpandGrowArgArray(pThis, pExp, pExp->cArgs + 1);
1864	if (rcExit == RTEXITCODE_SUCCESS)
1865	{
1866	char pszArg = (char )RTMemAllocZ(1);
1867	if (pszArg)
1868	pExp->papszArgs[pExp->cArgs++] = pszArg;
1869	else
1870	rcExit = vbcppError(pThis, "out of memory");
1871	}
1872	return rcExit;
1873	}
1874
1875
1876	static RTEXITCODE vbcppMacroExpandGatherParameters(PVBCPP pThis, PVBCPPMACROEXP pExp, size_t *poff, uint32_t cArgsHint)
1877	{
1878	RTEXITCODE rcExit = RTEXITCODE_SUCCESS;
1879
1880	/*
1881	* Free previous argument values.
1882	*/
1883	while (pExp->cArgs > 0)
1884	{
1885	RTMemFree(pExp->papszArgs[--pExp->cArgs]);
1886	pExp->papszArgs[pExp->cArgs] = NULL;
1887	}
1888
1889	/*
1890	* The current character should be an opening parenthsis.
1891	*/
1892	unsigned ch = vbcppMacroExpandGetCh(pExp, poff);
1893	if (ch != '(')
1894	return vbcppError(pThis, "Internal error - expected '(', found '%c' (#x)", ch, ch);
1895
1896	/*
1897	* Parse the argument list.
1898	*/
1899	char chQuote = 0;
1900	size_t cbArgAlloc = 0;
1901	size_t cchArg = 0;
1902	char *pszArg = NULL;
1903	size_t cParentheses = 1;
1904	unsigned chPrev = 0;
1905	while ((ch = vbcppMacroExpandGetCh(pExp, poff)) != ~(unsigned)0)
1906	{
1907	/** @todo check for '#directives'! */
1908	if (ch == ')' && !chQuote)
1909	{
1910	Assert(cParentheses >= 1);
1911	cParentheses--;
1912
1913	/* The end? */
1914	if (!cParentheses)
1915	{
1916	if (cchArg)
1917	while (cchArg > 0 && RT_C_IS_SPACE(pszArg[cchArg - 1]))
1918	pszArg[--cchArg] = '\0';
1919	else if (pExp->cArgs \|\| cArgsHint > 0)
1920	rcExit = vbcppMacroExpandAddEmptyParameter(pThis, pExp);
1921	break;
1922	}
1923	}
1924	else if (ch == '(' && !chQuote)
1925	cParentheses++;
1926	else if (ch == ',' && cParentheses == 1 && !chQuote)
1927	{
1928	/* End of one argument, start of the next. */
1929	if (cchArg)
1930	while (cchArg > 0 && RT_C_IS_SPACE(pszArg[cchArg - 1]))
1931	pszArg[--cchArg] = '\0';
1932	else
1933	{
1934	rcExit = vbcppMacroExpandAddEmptyParameter(pThis, pExp);
1935	if (rcExit != RTEXITCODE_SUCCESS)
1936	break;
1937	}
1938
1939	cbArgAlloc = 0;
1940	cchArg = 0;
1941	pszArg = NULL;
1942	continue;
1943	}
1944	else if (ch == '/' && !chQuote)
1945	{
1946	/* Comment? */
1947	unsigned ch2 = vbcppMacroExpandPeekCh(pExp, poff);
1948	/** @todo This ain't right wrt line splicing. */
1949	if (ch2 == '/' \|\| ch == '*')
1950	{
1951	if (ch2 == '/')
1952	rcExit = vbcppMacroExpandSkipCommentLine(pThis, pExp, poff);
1953	else
1954	rcExit = vbcppMacroExpandSkipComment(pThis, pExp, poff);
1955	if (rcExit != RTEXITCODE_SUCCESS)
1956	break;
1957	continue;
1958	}
1959	}
1960	else if (ch == '"')
1961	{
1962	if (!chQuote)
1963	chQuote = '"';
1964	else if (chPrev != '\\')
1965	chQuote = 0;
1966	}
1967	else if (ch == '\'')
1968	{
1969	if (!chQuote)
1970	chQuote = '\'';
1971	else if (chPrev != '\\')
1972	chQuote = 0;
1973	}
1974	else if (ch == '\\')
1975	{
1976	/* Splice lines? */
1977	unsigned ch2 = vbcppMacroExpandPeekCh(pExp, poff);
1978	if (ch2 == '\r' \|\| ch2 == '\n')
1979	{
1980	rcExit = vbcppMacroExpandSkipEol(pThis, pExp, poff);
1981	if (rcExit != RTEXITCODE_SUCCESS)
1982	break;
1983	continue;
1984	}
1985	}
1986	else if (cchArg == 0 && RT_C_IS_SPACE(ch))
1987	continue; /* ignore spaces leading up to an argument value */
1988
1989	/* Append the character to the argument value, adding the argument
1990	to the output array if it's first character in it. */
1991	if (cchArg + 1 >= cbArgAlloc)
1992	{
1993	/* Add argument to the vector. */
1994	if (!cchArg)
1995	{
1996	rcExit = vbcppMacroExpandGrowArgArray(pThis, pExp, RT_MAX(pExp->cArgs + 1, cArgsHint));
1997	if (rcExit != RTEXITCODE_SUCCESS)
1998	break;
1999	pExp->papszArgs[pExp->cArgs++] = pszArg;
2000	}
2001
2002	/* Resize the argument value buffer. */
2003	cbArgAlloc = cbArgAlloc ? cbArgAlloc * 2 : 16;
2004	pszArg = (char *)RTMemRealloc(pszArg, cbArgAlloc);
2005	if (!pszArg)
2006	{
2007	rcExit = vbcppError(pThis, "out of memory");
2008	break;
2009	}
2010	pExp->papszArgs[pExp->cArgs - 1] = pszArg;
2011	}
2012
2013	pszArg[cchArg++] = ch;
2014	pszArg[cchArg] = '\0';
2015	}
2016
2017	/*
2018	* Check that we're leaving on good terms.
2019	*/
2020	if (rcExit == RTEXITCODE_SUCCESS)
2021	{
2022	if (cParentheses)
2023	rcExit = vbcppError(pThis, "Missing ')'");
2024	}
2025
2026	return rcExit;
2027	}
2028
2029
2030	/**
2031	* Expands the arguments referenced in the macro value.
2032	*
2033	* @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE + msg.
2034	* @param pThis The C preprocessor instance.
2035	* @param pExp The expansion context.
2036	* @param pMacro The macro. Must be a function macro.
2037	* @param pStrBuf String buffer containing the result. The caller
2038	* should initialize and destroy this!
2039	*/
2040	static RTEXITCODE vbcppMacroExpandValueWithArguments(PVBCPP pThis, PVBCPPMACROEXP pExp, PVBCPPMACRO pMacro,
2041	PVBCPPSTRBUF pStrBuf)
2042	{
2043	Assert(pMacro->fFunction);
2044
2045	/*
2046	* Empty?
2047	*/
2048	if ( !pMacro->cchValue
2049	\|\| (pMacro->cchValue == 1 && pMacro->szValue[0] == '#'))
2050	return RTEXITCODE_SUCCESS;
2051
2052	/*
2053	* Parse the value.
2054	*/
2055	RTEXITCODE rcExit = RTEXITCODE_SUCCESS;
2056	const char *pszSrc = pMacro->szValue;
2057	const char *pszSrcSeq;
2058	char ch;
2059	while ((ch = *pszSrc++) != '\0')
2060	{
2061	Assert(ch != '\r'); Assert(ch != '\n'); /* probably not true atm. */
2062	if (ch == '#')
2063	{
2064	if (*pszSrc == '#')
2065	{
2066	/* Concatenate operator. */
2067	rcExit = vbcppError(pThis, "The '##' operatore is not yet implemented");
2068	}
2069	else
2070	{
2071	/* Stringify macro argument. */
2072	rcExit = vbcppError(pThis, "The '#' operatore is not yet implemented");
2073	}
2074	return rcExit;
2075	}
2076	else if (ch == '"')
2077	{
2078	/* String litteral. */
2079	pszSrcSeq = pszSrc - 1;
2080	while ((ch = *pszSrc++) != '"')
2081	{
2082	if (ch == '\\')
2083	ch = *pszSrc++;
2084	if (ch == '\0')
2085	{
2086	rcExit = vbcppError(pThis, "String litteral is missing closing quote (\").");
2087	break;
2088	}
2089	}
2090	rcExit = vbcppStrBufAppendN(pStrBuf, pszSrcSeq, pszSrc - pszSrcSeq);
2091	}
2092	else if (ch == '\'')
2093	{
2094	/* Character constant. */
2095	pszSrcSeq = pszSrc - 1;
2096	while ((ch = *pszSrc++) != '\'')
2097	{
2098	if (ch == '\\')
2099	ch = *pszSrc++;
2100	if (ch == '\0')
2101	{
2102	rcExit = vbcppError(pThis, "Character constant is missing closing quote (').");
2103	break;
2104	}
2105	}
2106	rcExit = vbcppStrBufAppendN(pStrBuf, pszSrcSeq, pszSrc - pszSrcSeq);
2107	}
2108	else if (RT_C_IS_DIGIT(ch))
2109	{
2110	/* Process numerical constants correctly (i.e. don't mess with the suffix). */
2111	pszSrcSeq = pszSrc - 1;
2112	while ( (ch = *pszSrc) != '\0'
2113	&& ( vbcppIsCIdentifierChar(ch)
2114	\|\| ch == '.') )
2115	pszSrc++;
2116	rcExit = vbcppStrBufAppendN(pStrBuf, pszSrcSeq, pszSrc - pszSrcSeq);
2117	}
2118	else if (RT_C_IS_SPACE(ch))
2119	{
2120	/* join spaces */
2121	if (RT_C_IS_SPACE(vbcppStrBufLastCh(pStrBuf)))
2122	continue;
2123	rcExit = vbcppStrBufAppendCh(pStrBuf, ch);
2124	}
2125	else if (vbcppIsCIdentifierLeadChar(ch))
2126	{
2127	/* Something we should replace? */
2128	pszSrcSeq = pszSrc - 1;
2129	while ( (ch = *pszSrc) != '\0'
2130	&& vbcppIsCIdentifierChar(ch))
2131	pszSrc++;
2132	size_t cchDefine = pszSrc - pszSrcSeq;
2133	uint32_t iArg;
2134	if ( VBCPP_BITMAP_IS_SET(pMacro->bmArgs, *pszSrcSeq)
2135	&& (iArg = vbcppMacroLookupArg(pMacro, pszSrcSeq, cchDefine)) != UINT32_MAX)
2136	{
2137	/** @todo check out spaces here! */
2138	if (iArg < pMacro->cArgs)
2139	{
2140	Assert(iArg < pExp->cArgs);
2141	rcExit = vbcppStrBufAppend(pStrBuf, pExp->papszArgs[iArg]);
2142	if (*pExp->papszArgs[iArg] != '\0' && rcExit == RTEXITCODE_SUCCESS)
2143	rcExit = vbcppStrBufAppendCh(pStrBuf, ' ');
2144	}
2145	else
2146	{
2147	/* __VA_ARGS__ */
2148	if (iArg < pExp->cArgs)
2149	{
2150	for (;;)
2151	{
2152	rcExit = vbcppStrBufAppend(pStrBuf, pExp->papszArgs[iArg]);
2153	if (rcExit != RTEXITCODE_SUCCESS)
2154	break;
2155	iArg++;
2156	if (iArg >= pExp->cArgs)
2157	break;
2158	rcExit = vbcppStrBufAppendCh(pStrBuf, ',');
2159	if (rcExit != RTEXITCODE_SUCCESS)
2160	break;
2161	}
2162	}
2163	if (rcExit == RTEXITCODE_SUCCESS)
2164	rcExit = vbcppStrBufAppendCh(pStrBuf, ' ');
2165	}
2166	}
2167	/* Not an argument needing replacing. */
2168	else
2169	rcExit = vbcppStrBufAppendN(pStrBuf, pszSrcSeq, cchDefine);
2170	}
2171	else
2172	{
2173	rcExit = vbcppStrBufAppendCh(pStrBuf, ch);
2174	}
2175	}
2176
2177	return rcExit;
2178	}
2179
2180
2181
2182	/**
2183	* Expands the given macro.
2184	*
2185	* Caller already checked if a function macro should be expanded, i.e. whether
2186	* there is a parameter list.
2187	*
2188	* @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE + msg.
2189	* @param pThis The C preprocessor instance.
2190	* @param pExp The expansion context.
2191	* @param offMacro Offset into the expansion buffer of the macro
2192	* invocation.
2193	* @param pMacro The macro.
2194	* @param offParameters The start of the parameter list if applicable.
2195	* Ignored if not function macro. If the
2196	* parameter list starts at the current stream
2197	* position shall be at the end of the expansion
2198	* buffer.
2199	*/
2200	static RTEXITCODE vbcppMacroExpandIt(PVBCPP pThis, PVBCPPMACROEXP pExp, size_t offMacro, PVBCPPMACRO pMacro,
2201	size_t offParameters)
2202	{
2203	RTEXITCODE rcExit;
2204	Assert(offMacro + pMacro->Core.cchString <= pExp->StrBuf.cchBuf);
2205	Assert(!pMacro->fExpanding);
2206
2207	/*
2208	* Function macros are kind of difficult...
2209	*/
2210	if (pMacro->fFunction)
2211	{
2212	rcExit = vbcppMacroExpandGatherParameters(pThis, pExp, &offParameters, pMacro->cArgs + pMacro->fVarArg);
2213	if (rcExit == RTEXITCODE_SUCCESS)
2214	{
2215	if (pExp->cArgs > pMacro->cArgs && !pMacro->fVarArg)
2216	rcExit = vbcppError(pThis, "Too many arguments to macro '%s' - found %u, expected %u",
2217	pMacro->Core.pszString, pExp->cArgs, pMacro->cArgs);
2218	else if (pExp->cArgs < pMacro->cArgs)
2219	rcExit = vbcppError(pThis, "Too few arguments to macro '%s' - found %u, expected %u",
2220	pMacro->Core.pszString, pExp->cArgs, pMacro->cArgs);
2221	}
2222	if (rcExit == RTEXITCODE_SUCCESS)
2223	{
2224	VBCPPSTRBUF ValueBuf;
2225	vbcppStrBufInit(&ValueBuf, pThis);
2226	rcExit = vbcppMacroExpandValueWithArguments(pThis, pExp, pMacro, &ValueBuf);
2227	if (rcExit == RTEXITCODE_SUCCESS)
2228	rcExit = vbcppMacroExpandReplace(pThis, pExp, offMacro, offParameters - offMacro,
2229	ValueBuf.pszBuf, ValueBuf.cchBuf);
2230	vbcppStrBufDelete(&ValueBuf);
2231	}
2232	}
2233	/*
2234	* Object-like macros are easy. :-)
2235	*/
2236	else
2237	rcExit = vbcppMacroExpandReplace(pThis, pExp, offMacro, pMacro->Core.cchString, pMacro->szValue, pMacro->cchValue);
2238	if (rcExit == RTEXITCODE_SUCCESS)
2239	{
2240	#if 0 /* wrong */
2241	/*
2242	* Push the macro onto the stack.
2243	*/
2244	pMacro->fExpanding = true;
2245	pMacro->pUpExpanding = pExp->pMacroStack;
2246	pExp->pMacroStack = pMacro;
2247	#endif
2248	}
2249
2250	return rcExit;
2251	}
2252
2253
2254	/**
2255	* Looks for a left parenthesis in the macro expansion buffer and the input
2256	* stream.
2257	*
2258	* @retval true if found. The stream position at opening parenthesis.
2259	* @retval false if not found. The stream position is unchanged.
2260	*
2261	* @param pThis The C preprocessor instance.
2262	* @param pExp The expansion context.
2263	* @param poff The current offset in the expansion context.
2264	* Will be updated on success.
2265	*
2266	* @sa vbcppInputLookForLeftParenthesis
2267	*/
2268	static bool vbcppMacroExpandLookForLeftParenthesis(PVBCPP pThis, PVBCPPMACROEXP pExp, size_t *poff)
2269	{
2270	/*
2271	* Search the buffer first. (No comments there.)
2272	*/
2273	size_t off = *poff;
2274	while (off < pExp->StrBuf.cchBuf)
2275	{
2276	char ch = pExp->StrBuf.pszBuf[off];
2277	if (!RT_C_IS_SPACE(ch))
2278	{
2279	if (ch == '(')
2280	{
2281	*poff = off;
2282	return true;
2283	}
2284	return false;
2285	}
2286	off++;
2287	}
2288
2289	/*
2290	* Reached the end of the buffer, continue searching in the stream.
2291	*/
2292	PSCMSTREAM pStrmInput = pExp->pStrmInput;
2293	size_t offSaved = ScmStreamTell(pStrmInput);
2294	RTEXITCODE rcExit = vbcppProcessSkipWhiteEscapedEolAndComments(pThis, pStrmInput);
2295	unsigned ch = ScmStreamPeekCh(pStrmInput);
2296	if (ch == '(')
2297	{
2298	*poff = pExp->StrBuf.cchBuf;
2299	return true;
2300	}
2301
2302	int rc = ScmStreamSeekAbsolute(pStrmInput, offSaved);
2303	AssertFatalRC(rc);
2304	return false;
2305	}
2306
2307
2308	/**
2309	* Implements the 'defined' unary operator for \#if and \#elif expressions.
2310	*
2311	* @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE + msg.
2312	* @param pThis The C preprocessor instance.
2313	* @param pExp The expansion context.
2314	* @param offStart The expansion buffer offset where the 'defined'
2315	* occurs.
2316	* @param poff Where to store the offset at which the re-scan
2317	* shall resume upon return.
2318	*/
2319	static RTEXITCODE vbcppMacroExpandDefinedOperator(PVBCPP pThis, PVBCPPMACROEXP pExp, size_t offStart, size_t *poff)
2320	{
2321	Assert(!pExp->pStrmInput); /* offset usage below. */
2322
2323	/*
2324	* Skip white space.
2325	*/
2326	unsigned ch;
2327	while ((ch = vbcppMacroExpandGetCh(pExp, poff)) != ~(unsigned)0)
2328	if (!RT_C_IS_SPACE(ch))
2329	break;
2330	bool const fWithParenthesis = ch == '(';
2331	if (fWithParenthesis)
2332	while ((ch = vbcppMacroExpandGetCh(pExp, poff)) != ~(unsigned)0)
2333	if (!RT_C_IS_SPACE(ch))
2334	break;
2335
2336	/*
2337	* Macro identifier.
2338	*/
2339	if (!vbcppIsCIdentifierLeadChar(ch))
2340	return vbcppError(pThis, "Expected macro name after 'defined' operator");
2341
2342	size_t const offDefine = *poff - 1;
2343	while ((ch = vbcppMacroExpandGetCh(pExp, poff)) != ~(unsigned)0)
2344	if (!vbcppIsCIdentifierChar(ch))
2345	break;
2346	size_t const cchDefine = *poff - offDefine;
2347
2348	/*
2349	* Check for closing parenthesis.
2350	*/
2351	if (fWithParenthesis)
2352	{
2353	while (RT_C_IS_SPACE(ch))
2354	ch = vbcppMacroExpandGetCh(pExp, poff);
2355	if (ch != ')')
2356	return vbcppError(pThis, "Expected closing parenthesis after macro name");
2357	}
2358
2359	/*
2360	* Do the job.
2361	*/
2362	const char *pszResult = vbcppMacroExists(pThis, &pExp->StrBuf.pszBuf[offDefine], cchDefine)
2363	? "1" : "0";
2364	RTEXITCODE rcExit = vbcppMacroExpandReplace(pThis, pExp, offStart, *poff - offStart, pszResult, 1);
2365	*poff = offStart + 1;
2366	return rcExit;
2367	}
2368
2369
2370	/**
2371	* Re-scan the expanded macro.
2372	*
2373	* @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE + msg.
2374	* @param pThis The C preprocessor instance.
2375	* @param pExp The expansion context.
2376	* @param enmMode The re-scan mode.
2377	* @param pcReplacements Where to return the number of replacements
2378	* performed. Optional.
2379	*/
2380	static RTEXITCODE vbcppMacroExpandReScan(PVBCPP pThis, PVBCPPMACROEXP pExp, VBCPPMACRORESCANMODE enmMode, size_t *pcReplacements)
2381	{
2382	RTEXITCODE rcExit = RTEXITCODE_SUCCESS;
2383	size_t cReplacements = 0;
2384	size_t off = 0;
2385	unsigned ch;
2386	while ( off < pExp->StrBuf.cchBuf
2387	&& (ch = vbcppMacroExpandGetCh(pExp, &off)) != ~(unsigned)0)
2388	{
2389	/*
2390	* String litteral or character constant.
2391	*/
2392	if (ch == '\'' \|\| ch == '"')
2393	{
2394	unsigned const chEndQuote = ch;
2395	while ( off < pExp->StrBuf.cchBuf
2396	&& (ch = vbcppMacroExpandGetCh(pExp, &off)) != ~(unsigned)0)
2397	{
2398	if (ch == '\\')
2399	{
2400	ch = vbcppMacroExpandGetCh(pExp, &off);
2401	if (ch == ~(unsigned)0)
2402	break;
2403	}
2404	else if (ch == chEndQuote)
2405	break;
2406	}
2407	if (ch == ~(unsigned)0)
2408	return vbcppError(pThis, "Missing end quote (%c)", chEndQuote);
2409	}
2410	/*
2411	* Number constant.
2412	*/
2413	else if ( RT_C_IS_DIGIT(ch)
2414	\|\| ( ch == '.'
2415	&& off + 1 < pExp->StrBuf.cchBuf
2416	&& RT_C_IS_DIGIT(vbcppMacroExpandPeekCh(pExp, &off))
2417	)
2418	)
2419	{
2420	while ( off < pExp->StrBuf.cchBuf
2421	&& (ch = vbcppMacroExpandPeekCh(pExp, &off)) != ~(unsigned)0
2422	&& vbcppIsCIdentifierChar(ch) )
2423	vbcppMacroExpandGetCh(pExp, &off);
2424	}
2425	/*
2426	* Something that can be replaced?
2427	*/
2428	else if (vbcppIsCIdentifierLeadChar(ch))
2429	{
2430	size_t offDefine = off - 1;
2431	while ( off < pExp->StrBuf.cchBuf
2432	&& (ch = vbcppMacroExpandPeekCh(pExp, &off)) != ~(unsigned)0
2433	&& vbcppIsCIdentifierChar(ch) )
2434	vbcppMacroExpandGetCh(pExp, &off);
2435	size_t cchDefine = off - offDefine;
2436
2437	PVBCPPMACRO pMacro = vbcppMacroLookup(pThis, &pExp->StrBuf.pszBuf[offDefine], cchDefine);
2438	if ( pMacro
2439	&& ( !pMacro->fFunction
2440	\|\| vbcppMacroExpandLookForLeftParenthesis(pThis, pExp, &off)) )
2441	{
2442	rcExit = vbcppMacroExpandIt(pThis, pExp, offDefine, pMacro, off);
2443	off = offDefine;
2444	}
2445	else
2446	{
2447	if ( !pMacro
2448	&& enmMode == kMacroReScanMode_Expression
2449	&& cchDefine == sizeof("defined") - 1
2450	&& !strncmp(&pExp->StrBuf.pszBuf[offDefine], "defined", cchDefine))
2451	rcExit = vbcppMacroExpandDefinedOperator(pThis, pExp, offDefine, &off);
2452	else
2453	off = offDefine + cchDefine;
2454	}
2455	}
2456	else
2457	{
2458	Assert(RT_C_IS_SPACE(ch) \|\| RT_C_IS_PUNCT(ch));
2459	Assert(ch != '\r' && ch != '\n');
2460	}
2461	}
2462
2463	return rcExit;
2464	}
2465
2466
2467	/**
2468	* Cleans up the expansion context.
2469	*
2470	* This involves clearing VBCPPMACRO::fExpanding and VBCPPMACRO::pUpExpanding,
2471	* and freeing the memory resources associated with the expansion context.
2472	*
2473	* @param pExp The expansion context.
2474	*/
2475	static void vbcppMacroExpandCleanup(PVBCPPMACROEXP pExp)
2476	{
2477	#if 0
2478	while (pExp->pMacroStack)
2479	{
2480	PVBCPPMACRO pMacro = pExp->pMacroStack;
2481	pExp->pMacroStack = pMacro->pUpExpanding;
2482
2483	pMacro->fExpanding = false;
2484	pMacro->pUpExpanding = NULL;
2485	}
2486	#endif
2487
2488	while (pExp->cArgs > 0)
2489	{
2490	RTMemFree(pExp->papszArgs[--pExp->cArgs]);
2491	pExp->papszArgs[pExp->cArgs] = NULL;
2492	}
2493
2494	RTMemFree(pExp->papszArgs);
2495	pExp->papszArgs = NULL;
2496
2497	vbcppStrBufDelete(&pExp->StrBuf);
2498	}
2499
2500
2501
2502	/**
2503	* Frees a define.
2504	*
2505	* @returns VINF_SUCCESS (used when called by RTStrSpaceDestroy)
2506	* @param pStr Pointer to the VBCPPMACRO::Core member.
2507	* @param pvUser Unused.
2508	*/
2509	static DECLCALLBACK(int) vbcppMacroFree(PRTSTRSPACECORE pStr, void *pvUser)
2510	{
2511	RTMemFree(pStr);
2512	NOREF(pvUser);
2513	return VINF_SUCCESS;
2514	}
2515
2516
2517	/**
2518	* Removes a define.
2519	*
2520	* @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE + msg.
2521	* @param pThis The C preprocessor instance.
2522	* @param pszDefine The define name, no argument list or anything.
2523	* @param cchDefine The length of the name. RTSTR_MAX is ok.
2524	* @param fExplicitUndef Explicit undefinition, that is, in a selective
2525	* preprocessing run it will evaluate to undefined.
2526	*/
2527	static RTEXITCODE vbcppMacroUndef(PVBCPP pThis, const char *pszDefine, size_t cchDefine, bool fExplicitUndef)
2528	{
2529	PRTSTRSPACECORE pHit = RTStrSpaceGetN(&pThis->StrSpace, pszDefine, cchDefine);
2530	if (pHit)
2531	{
2532	RTStrSpaceRemove(&pThis->StrSpace, pHit->pszString);
2533	vbcppMacroFree(pHit, NULL);
2534	}
2535
2536	if (fExplicitUndef)
2537	{
2538	if (cchDefine == RTSTR_MAX)
2539	cchDefine = strlen(pszDefine);
2540
2541	PRTSTRSPACECORE pStr = (PRTSTRSPACECORE)RTMemAlloc(sizeof(*pStr) + cchDefine + 1);
2542	if (!pStr)
2543	return vbcppError(pThis, "out of memory");
2544	char pszDst = (char )(pStr + 1);
2545	pStr->pszString = pszDst;
2546	memcpy(pszDst, pszDefine, cchDefine);
2547	pszDst[cchDefine] = '\0';
2548	if (!RTStrSpaceInsert(&pThis->UndefStrSpace, pStr))
2549	RTMemFree(pStr);
2550	}
2551
2552	return RTEXITCODE_SUCCESS;
2553	}
2554
2555
2556	/**
2557	* Inserts a define (rejecting and freeing it in some case).
2558	*
2559	* @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE + msg.
2560	* @param pThis The C preprocessor instance.
2561	* @param pMacro The define to insert.
2562	*/
2563	static RTEXITCODE vbcppMacroInsert(PVBCPP pThis, PVBCPPMACRO pMacro)
2564	{
2565	/*
2566	* Reject illegal macro names.
2567	*/
2568	if (!strcmp(pMacro->Core.pszString, "defined"))
2569	{
2570	RTEXITCODE rcExit = vbcppError(pThis, "Cannot use '%s' as a macro name", pMacro->Core.pszString);
2571	vbcppMacroFree(&pMacro->Core, NULL);
2572	return rcExit;
2573	}
2574
2575	/*
2576	* Ignore in source-file defines when doing selective preprocessing.
2577	*/
2578	if ( !pThis->fRespectSourceDefines
2579	&& !pMacro->fCmdLine)
2580	{
2581	/* Ignore*/
2582	vbcppMacroFree(&pMacro->Core, NULL);
2583	return RTEXITCODE_SUCCESS;
2584	}
2585
2586	/*
2587	* Insert it and update the lead character hint bitmap.
2588	*/
2589	if (RTStrSpaceInsert(&pThis->StrSpace, &pMacro->Core))
2590	VBCPP_BITMAP_SET(pThis->bmDefined, *pMacro->Core.pszString);
2591	else
2592	{
2593	/*
2594	* Duplicate. When doing selective D preprocessing, let the command
2595	* line take precendece.
2596	*/
2597	PVBCPPMACRO pOld = (PVBCPPMACRO)RTStrSpaceGet(&pThis->StrSpace, pMacro->Core.pszString); Assert(pOld);
2598	if ( pThis->fAllowRedefiningCmdLineDefines
2599	\|\| pMacro->fCmdLine == pOld->fCmdLine)
2600	{
2601	if (pMacro->fCmdLine)
2602	RTMsgWarning("Redefining '%s'", pMacro->Core.pszString);
2603
2604	RTStrSpaceRemove(&pThis->StrSpace, pOld->Core.pszString);
2605	vbcppMacroFree(&pOld->Core, NULL);
2606
2607	bool fRc = RTStrSpaceInsert(&pThis->StrSpace, &pMacro->Core);
2608	Assert(fRc);
2609	}
2610	else
2611	{
2612	RTMsgWarning("Ignoring redefinition of '%s'", pMacro->Core.pszString);
2613	vbcppMacroFree(&pMacro->Core, NULL);
2614	}
2615	}
2616
2617	return RTEXITCODE_SUCCESS;
2618	}
2619
2620
2621	/**
2622	* Adds a define.
2623	*
2624	* @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE + msg.
2625	* @param pThis The C preprocessor instance.
2626	* @param pszDefine The define name, no parameter list.
2627	* @param cchDefine The length of the name.
2628	* @param pszParams The parameter list.
2629	* @param cchParams The length of the parameter list.
2630	* @param pszValue The value.
2631	* @param cchDefine The length of the value.
2632	* @param fCmdLine Set if originating on the command line.
2633	*/
2634	static RTEXITCODE vbcppMacroAddFn(PVBCPP pThis, const char *pszDefine, size_t cchDefine,
2635	const char *pszParams, size_t cchParams,
2636	const char *pszValue, size_t cchValue,
2637	bool fCmdLine)
2638
2639	{
2640	Assert(RTStrNLen(pszDefine, cchDefine) == cchDefine);
2641	Assert(RTStrNLen(pszParams, cchParams) == cchParams);
2642	Assert(RTStrNLen(pszValue, cchValue) == cchValue);
2643
2644	/*
2645	* Determin the number of arguments and how much space their names
2646	* requires. Performing syntax validation while parsing.
2647	*/
2648	uint32_t cchArgNames = 0;
2649	uint32_t cArgs = 0;
2650	for (size_t off = 0; off < cchParams; off++)
2651	{
2652	/* Skip blanks and maybe one comma. */
2653	bool fIgnoreComma = cArgs != 0;
2654	while (off < cchParams)
2655	{
2656	if (!RT_C_IS_SPACE(pszParams[off]))
2657	{
2658	if (pszParams[off] != ',' \|\| !fIgnoreComma)
2659	{
2660	if (vbcppIsCIdentifierLeadChar(pszParams[off]))
2661	break;
2662	/** @todo variadic macros. */
2663	return vbcppErrorPos(pThis, &pszParams[off], "Unexpected character");
2664	}
2665	fIgnoreComma = false;
2666	}
2667	off++;
2668	}
2669	if (off >= cchParams)
2670	break;
2671
2672	/* Found and argument. First character is already validated. */
2673	cArgs++;
2674	cchArgNames += 2;
2675	off++;
2676	while ( off < cchParams
2677	&& vbcppIsCIdentifierChar(pszParams[off]))
2678	off++, cchArgNames++;
2679	}
2680
2681	/*
2682	* Allocate a structure.
2683	*/
2684	size_t cbDef = RT_OFFSETOF(VBCPPMACRO, szValue[cchValue + 1 + cchDefine + 1 + cchArgNames])
2685	+ sizeof(const char ) cArgs;
2686	cbDef = RT_ALIGN_Z(cbDef, sizeof(const char *));
2687	PVBCPPMACRO pMacro = (PVBCPPMACRO)RTMemAlloc(cbDef);
2688	if (!pMacro)
2689	return RTMsgErrorExit(RTEXITCODE_FAILURE, "out of memory");
2690
2691	char *pszDst = &pMacro->szValue[cchValue + 1];
2692	pMacro->Core.pszString = pszDst;
2693	memcpy(pszDst, pszDefine, cchDefine);
2694	pszDst += cchDefine;
2695	*pszDst++ = '\0';
2696	pMacro->fFunction = true;
2697	pMacro->fVarArg = false;
2698	pMacro->fCmdLine = fCmdLine;
2699	pMacro->fExpanding = false;
2700	pMacro->cArgs = cArgs;
2701	pMacro->papszArgs = (const char *)((uintptr_t)pMacro + cbDef - sizeof(const char ) * cArgs);
2702	VBCPP_BITMAP_EMPTY(pMacro->bmArgs);
2703	pMacro->cchValue = cchValue;
2704	memcpy(pMacro->szValue, pszValue, cchValue);
2705	pMacro->szValue[cchValue] = '\0';
2706
2707	/*
2708	* Set up the arguments.
2709	*/
2710	uint32_t iArg = 0;
2711	for (size_t off = 0; off < cchParams; off++)
2712	{
2713	/* Skip blanks and maybe one comma. */
2714	bool fIgnoreComma = cArgs != 0;
2715	while (off < cchParams)
2716	{
2717	if (!RT_C_IS_SPACE(pszParams[off]))
2718	{
2719	if (pszParams[off] != ',' \|\| !fIgnoreComma)
2720	break;
2721	fIgnoreComma = false;
2722	}
2723	off++;
2724	}
2725	if (off >= cchParams)
2726	break;
2727
2728	/* Found and argument. First character is already validated. */
2729	VBCPP_BITMAP_SET(pMacro->bmArgs, pszParams[off]);
2730	pMacro->papszArgs[iArg] = pszDst;
2731	do
2732	{
2733	*pszDst++ = pszParams[off++];
2734	} while ( off < cchParams
2735	&& vbcppIsCIdentifierChar(pszParams[off]));
2736	*pszDst++ = '\0';
2737	iArg++;
2738	}
2739	Assert((uintptr_t)pszDst <= (uintptr_t)pMacro->papszArgs);
2740
2741	return vbcppMacroInsert(pThis, pMacro);
2742	}
2743
2744
2745	/**
2746	* Adds a define.
2747	*
2748	* @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE + msg.
2749	* @param pThis The C preprocessor instance.
2750	* @param pszDefine The define name and optionally the argument
2751	* list.
2752	* @param cchDefine The length of the name. RTSTR_MAX is ok.
2753	* @param pszValue The value.
2754	* @param cchDefine The length of the value. RTSTR_MAX is ok.
2755	* @param fCmdLine Set if originating on the command line.
2756	*/
2757	static RTEXITCODE vbcppMacroAdd(PVBCPP pThis, const char *pszDefine, size_t cchDefine,
2758	const char *pszValue, size_t cchValue, bool fCmdLine)
2759	{
2760	/*
2761	* We need the lengths. Trim the input.
2762	*/
2763	if (cchDefine == RTSTR_MAX)
2764	cchDefine = strlen(pszDefine);
2765	while (cchDefine > 0 && RT_C_IS_SPACE(*pszDefine))
2766	pszDefine++, cchDefine--;
2767	while (cchDefine > 0 && RT_C_IS_SPACE(pszDefine[cchDefine - 1]))
2768	cchDefine--;
2769	if (!cchDefine)
2770	return vbcppErrorPos(pThis, pszDefine, "The define has no name");
2771
2772	if (cchValue == RTSTR_MAX)
2773	cchValue = strlen(pszValue);
2774	while (cchValue > 0 && RT_C_IS_SPACE(*pszValue))
2775	pszValue++, cchValue--;
2776	while (cchValue > 0 && RT_C_IS_SPACE(pszValue[cchValue - 1]))
2777	cchValue--;
2778
2779	/*
2780	* Arguments make the job a bit more annoying. Handle that elsewhere
2781	*/
2782	const char pszParams = (const char )memchr(pszDefine, '(', cchDefine);
2783	if (pszParams)
2784	{
2785	size_t cchParams = pszDefine + cchDefine - pszParams;
2786	cchDefine -= cchParams;
2787	if (!vbcppValidateCIdentifier(pThis, pszDefine, cchDefine))
2788	return RTEXITCODE_FAILURE;
2789	if (pszParams[cchParams - 1] != ')')
2790	return vbcppErrorPos(pThis, pszParams + cchParams - 1, "Missing closing parenthesis");
2791	pszParams++;
2792	cchParams -= 2;
2793	return vbcppMacroAddFn(pThis, pszDefine, cchDefine, pszParams, cchParams, pszValue, cchValue, fCmdLine);
2794	}
2795
2796	/*
2797	* Simple define, no arguments.
2798	*/
2799	if (!vbcppValidateCIdentifier(pThis, pszDefine, cchDefine))
2800	return RTEXITCODE_FAILURE;
2801
2802	PVBCPPMACRO pMacro = (PVBCPPMACRO)RTMemAlloc(RT_OFFSETOF(VBCPPMACRO, szValue[cchValue + 1 + cchDefine + 1]));
2803	if (!pMacro)
2804	return RTMsgErrorExit(RTEXITCODE_FAILURE, "out of memory");
2805
2806	pMacro->Core.pszString = &pMacro->szValue[cchValue + 1];
2807	memcpy((char *)pMacro->Core.pszString, pszDefine, cchDefine);
2808	((char *)pMacro->Core.pszString)[cchDefine] = '\0';
2809	pMacro->fFunction = false;
2810	pMacro->fVarArg = false;
2811	pMacro->fCmdLine = fCmdLine;
2812	pMacro->fExpanding = false;
2813	pMacro->cArgs = 0;
2814	pMacro->papszArgs = NULL;
2815	VBCPP_BITMAP_EMPTY(pMacro->bmArgs);
2816	pMacro->cchValue = cchValue;
2817	memcpy(pMacro->szValue, pszValue, cchValue);
2818	pMacro->szValue[cchValue] = '\0';
2819
2820	return vbcppMacroInsert(pThis, pMacro);
2821	}
2822
2823
2824	/**
2825	* Tries to convert a define into an inline D constant.
2826	*
2827	* @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
2828	* @param pThis The C preprocessor instance.
2829	* @param pMacro The macro.
2830	*/
2831	static RTEXITCODE vbcppMacroTryConvertToInlineD(PVBCPP pThis, PVBCPPMACRO pMacro)
2832	{
2833	AssertReturn(pMacro, vbcppError(pThis, "Internal error"));
2834	if (pMacro->fFunction)
2835	return RTEXITCODE_SUCCESS;
2836
2837	/*
2838	* Do some simple macro resolving. (Mostly to make x86.h work.)
2839	*/
2840	const char *pszDefine = pMacro->Core.pszString;
2841	const char *pszValue = pMacro->szValue;
2842	size_t cchValue = pMacro->cchValue;
2843
2844	unsigned i = 0;
2845	PVBCPPMACRO pMacro2;
2846	while ( i < 10
2847	&& cchValue > 0
2848	&& vbcppIsCIdentifierLeadChar(*pszValue)
2849	&& (pMacro2 = vbcppMacroLookup(pThis, pszValue, cchValue)) != NULL
2850	&& !pMacro2->fFunction )
2851	{
2852	pszValue = pMacro2->szValue;
2853	cchValue = pMacro2->cchValue;
2854	i++;
2855	}
2856
2857	if (!pMacro->cchValue)
2858	return RTEXITCODE_SUCCESS;
2859
2860
2861	/*
2862	* A lone value?
2863	*/
2864	ssize_t cch = 0;
2865	uint64_t u64;
2866	char *pszNext;
2867	int rc = RTStrToUInt64Ex(pszValue, &pszNext, 0, &u64);
2868	if (RT_SUCCESS(rc))
2869	{
2870	if ( rc == VWRN_TRAILING_SPACES
2871	\|\| rc == VWRN_NEGATIVE_UNSIGNED
2872	\|\| rc == VWRN_NUMBER_TOO_BIG)
2873	return RTEXITCODE_SUCCESS;
2874	const char *pszType;
2875	if (rc == VWRN_TRAILING_CHARS)
2876	{
2877	if (!strcmp(pszNext, "u") \|\| !strcmp(pszNext, "U"))
2878	pszType = "uint32_t";
2879	else if (!strcmp(pszNext, "ul") \|\| !strcmp(pszNext, "UL"))
2880	pszType = "uintptr_t";
2881	else if (!strcmp(pszNext, "ull") \|\| !strcmp(pszNext, "ULL"))
2882	pszType = "uint64_t";
2883	else
2884	pszType = NULL;
2885	}
2886	else if (u64 <= UINT8_MAX)
2887	pszType = "uint8_t";
2888	else if (u64 <= UINT16_MAX)
2889	pszType = "uint16_t";
2890	else if (u64 <= UINT32_MAX)
2891	pszType = "uint32_t";
2892	else
2893	pszType = "uint64_t";
2894	if (!pszType)
2895	return RTEXITCODE_SUCCESS;
2896	cch = ScmStreamPrintf(&pThis->StrmOutput, "inline %s %s = %.*s;\n",
2897	pszType, pszDefine, pszNext - pszValue, pszValue);
2898	}
2899	/*
2900	* A value wrapped in a constant macro?
2901	*/
2902	else if ( (pszNext = (char *)strchr(pszValue, '(')) != NULL
2903	&& pszValue[cchValue - 1] == ')' )
2904	{
2905	size_t cchPrefix = pszNext - pszValue;
2906	size_t cchInnerValue = cchValue - cchPrefix - 2;
2907	const char *pchInnerValue = &pszValue[cchPrefix + 1];
2908	while (cchInnerValue > 0 && RT_C_IS_SPACE(*pchInnerValue))
2909	cchInnerValue--, pchInnerValue++;
2910	while (cchInnerValue > 0 && RT_C_IS_SPACE(pchInnerValue[cchInnerValue - 1]))
2911	cchInnerValue--;
2912	if (!cchInnerValue \|\| !RT_C_IS_XDIGIT(*pchInnerValue))
2913	return RTEXITCODE_SUCCESS;
2914
2915	rc = RTStrToUInt64Ex(pchInnerValue, &pszNext, 0, &u64);
2916	if ( RT_FAILURE(rc)
2917	\|\| rc == VWRN_TRAILING_SPACES
2918	\|\| rc == VWRN_NEGATIVE_UNSIGNED
2919	\|\| rc == VWRN_NUMBER_TOO_BIG)
2920	return RTEXITCODE_SUCCESS;
2921
2922	const char *pszType;
2923	#define MY_MATCH_STR(a_sz) (sizeof(a_sz) - 1 == cchPrefix && !strncmp(pszValue, a_sz, sizeof(a_sz) - 1))
2924	if (MY_MATCH_STR("UINT8_C"))
2925	pszType = "uint8_t";
2926	else if (MY_MATCH_STR("UINT16_C"))
2927	pszType = "uint16_t";
2928	else if (MY_MATCH_STR("UINT32_C"))
2929	pszType = "uint32_t";
2930	else if (MY_MATCH_STR("UINT64_C"))
2931	pszType = "uint64_t";
2932	else
2933	pszType = NULL;
2934	if (pszType)
2935	cch = ScmStreamPrintf(&pThis->StrmOutput, "inline %s %s = %.*s;\n",
2936	pszType, pszDefine, cchInnerValue, pchInnerValue);
2937	else if (MY_MATCH_STR("RT_BIT") \|\| MY_MATCH_STR("RT_BIT_32"))
2938	cch = ScmStreamPrintf(&pThis->StrmOutput, "inline uint32_t %s = 1U << %llu;\n",
2939	pszDefine, u64);
2940	else if (MY_MATCH_STR("RT_BIT_64"))
2941	cch = ScmStreamPrintf(&pThis->StrmOutput, "inline uint64_t %s = 1ULL << %llu;\n",
2942	pszDefine, u64);
2943	else
2944	return RTEXITCODE_SUCCESS;
2945	#undef MY_MATCH_STR
2946	}
2947	/* Dunno what this is... */
2948	else
2949	return RTEXITCODE_SUCCESS;
2950
2951	/*
2952	* Check for output error and clear the output suppression indicator.
2953	*/
2954	if (cch < 0)
2955	return vbcppError(pThis, "Output error");
2956
2957	pThis->fJustDroppedLine = false;
2958	return RTEXITCODE_SUCCESS;
2959	}
2960
2961
2962
2963	/**
2964	* Processes a abbreviated line number directive.
2965	*
2966	* @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
2967	* @param pThis The C preprocessor instance.
2968	* @param pStrmInput The input stream.
2969	* @param offStart The stream position where the directive
2970	* started (for pass thru).
2971	*/
2972	static RTEXITCODE vbcppDirectiveDefine(PVBCPP pThis, PSCMSTREAM pStrmInput, size_t offStart)
2973	{
2974	/*
2975	* Parse it.
2976	*/
2977	RTEXITCODE rcExit = vbcppProcessSkipWhiteEscapedEolAndComments(pThis, pStrmInput);
2978	if (rcExit == RTEXITCODE_SUCCESS)
2979	{
2980	size_t cchDefine;
2981	const char *pchDefine = ScmStreamCGetWord(pStrmInput, &cchDefine);
2982	if (pchDefine)
2983	{
2984	/* If it's a function style define, parse out the parameter list. */
2985	size_t cchParams = 0;
2986	const char *pchParams = NULL;
2987	unsigned ch = ScmStreamPeekCh(pStrmInput);
2988	if (ch == '(')
2989	{
2990	ScmStreamGetCh(pStrmInput);
2991	pchParams = ScmStreamGetCur(pStrmInput);
2992
2993	unsigned chPrev = ch;
2994	while ((ch = ScmStreamPeekCh(pStrmInput)) != ~(unsigned)0)
2995	{
2996	if (ch == '\r' \|\| ch == '\n')
2997	{
2998	if (chPrev != '\\')
2999	{
3000	rcExit = vbcppError(pThis, "Missing ')'");
3001	break;
3002	}
3003	ScmStreamSeekByLine(pStrmInput, ScmStreamTellLine(pStrmInput) + 1);
3004	}
3005	if (ch == ')')
3006	{
3007	cchParams = ScmStreamGetCur(pStrmInput) - pchParams;
3008	ScmStreamGetCh(pStrmInput);
3009	break;
3010	}
3011	ScmStreamGetCh(pStrmInput);
3012	}
3013	}
3014	/* The simple kind. */
3015	else if (!RT_C_IS_SPACE(ch) && ch != ~(unsigned)0)
3016	rcExit = vbcppError(pThis, "Expected whitespace after macro name");
3017
3018	/* Parse out the value. */
3019	if (rcExit == RTEXITCODE_SUCCESS)
3020	rcExit = vbcppProcessSkipWhiteEscapedEolAndComments(pThis, pStrmInput);
3021	if (rcExit == RTEXITCODE_SUCCESS)
3022	{
3023	size_t offValue = ScmStreamTell(pStrmInput);
3024	const char *pchValue = ScmStreamGetCur(pStrmInput);
3025	unsigned chPrev = ch;
3026	while ((ch = ScmStreamPeekCh(pStrmInput)) != ~(unsigned)0)
3027	{
3028	if (ch == '\r' \|\| ch == '\n')
3029	{
3030	if (chPrev != '\\')
3031	break;
3032	ScmStreamSeekByLine(pStrmInput, ScmStreamTellLine(pStrmInput) + 1);
3033	}
3034	chPrev = ScmStreamGetCh(pStrmInput);
3035	}
3036	size_t cchValue = ScmStreamGetCur(pStrmInput) - pchValue;
3037
3038	/*
3039	* Execute.
3040	*/
3041	if (pchParams)
3042	rcExit = vbcppMacroAddFn(pThis, pchDefine, cchDefine, pchParams, cchParams, pchValue, cchValue, false);
3043	else
3044	rcExit = vbcppMacroAdd(pThis, pchDefine, cchDefine, pchValue, cchValue, false);
3045
3046	/*
3047	* Pass thru?
3048	*/
3049	if ( rcExit == RTEXITCODE_SUCCESS
3050	&& pThis->fPassThruDefines)
3051	{
3052	unsigned cchIndent = pThis->pCondStack ? pThis->pCondStack->iKeepLevel : 0;
3053	ssize_t cch;
3054	if (pchParams)
3055	cch = ScmStreamPrintf(&pThis->StrmOutput, "#%sdefine %.s(%.*s)",
3056	cchIndent, "", cchDefine, pchDefine, cchParams, pchParams);
3057	else
3058	cch = ScmStreamPrintf(&pThis->StrmOutput, "#%sdefine %.s",
3059	cchIndent, "", cchDefine, pchDefine);
3060	if (cch > 0)
3061	vbcppOutputComment(pThis, pStrmInput, offValue, cch, 1);
3062	else
3063	rcExit = vbcppError(pThis, "output error");
3064	}
3065	else if ( rcExit == RTEXITCODE_SUCCESS
3066	&& pThis->enmMode == kVBCppMode_SelectiveD)
3067	rcExit = vbcppMacroTryConvertToInlineD(pThis, vbcppMacroLookup(pThis, pchDefine, cchDefine));
3068	else
3069	pThis->fJustDroppedLine = true;
3070	}
3071	}
3072	}
3073	return rcExit;
3074	}
3075
3076
3077	/**
3078	* Processes a abbreviated line number directive.
3079	*
3080	* @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
3081	* @param pThis The C preprocessor instance.
3082	* @param pStrmInput The input stream.
3083	* @param offStart The stream position where the directive
3084	* started (for pass thru).
3085	*/
3086	static RTEXITCODE vbcppDirectiveUndef(PVBCPP pThis, PSCMSTREAM pStrmInput, size_t offStart)
3087	{
3088	/*
3089	* Parse it.
3090	*/
3091	RTEXITCODE rcExit = vbcppProcessSkipWhiteEscapedEolAndComments(pThis, pStrmInput);
3092	if (rcExit == RTEXITCODE_SUCCESS)
3093	{
3094	size_t cchDefine;
3095	const char *pchDefine = ScmStreamCGetWord(pStrmInput, &cchDefine);
3096	if (pchDefine)
3097	{
3098	size_t offMaybeComment = vbcppProcessSkipWhite(pStrmInput);
3099	rcExit = vbcppProcessSkipWhiteEscapedEolAndCommentsCheckEol(pThis, pStrmInput);
3100	if (rcExit == RTEXITCODE_SUCCESS)
3101	{
3102	/*
3103	* Take action.
3104	*/
3105	PVBCPPMACRO pMacro = vbcppMacroLookup(pThis, pchDefine, cchDefine);
3106	if ( pMacro
3107	&& pThis->fRespectSourceDefines
3108	&& ( !pMacro->fCmdLine
3109	\|\| pThis->fAllowRedefiningCmdLineDefines ) )
3110	{
3111	RTStrSpaceRemove(&pThis->StrSpace, pMacro->Core.pszString);
3112	vbcppMacroFree(&pMacro->Core, NULL);
3113	}
3114
3115	/*
3116	* Pass thru.
3117	*/
3118	if ( rcExit == RTEXITCODE_SUCCESS
3119	&& pThis->fPassThruDefines)
3120	{
3121	unsigned cchIndent = pThis->pCondStack ? pThis->pCondStack->iKeepLevel : 0;
3122	ssize_t cch = ScmStreamPrintf(&pThis->StrmOutput, "#%sundef %.s",
3123	cchIndent, "", cchDefine, pchDefine);
3124	if (cch > 0)
3125	vbcppOutputComment(pThis, pStrmInput, offMaybeComment, cch, 1);
3126	else
3127	rcExit = vbcppError(pThis, "output error");
3128	}
3129
3130	}
3131	}
3132	else
3133	rcExit = vbcppError(pThis, "Malformed #ifndef");
3134	}
3135	return rcExit;
3136
3137	}
3138
3139
3140
3141
3142
3143	/*
3144	*
3145	*
3146	* C O N D I T I O N A L S
3147	* C O N D I T I O N A L S
3148	* C O N D I T I O N A L S
3149	* C O N D I T I O N A L S
3150	* C O N D I T I O N A L S
3151	*
3152	*
3153	*/
3154
3155
3156	/**
3157	* Combines current stack result with the one being pushed.
3158	*
3159	* @returns Combined result.
3160	* @param enmEvalPush The result of the condition being pushed.
3161	* @param enmEvalStack The current stack result.
3162	*/
3163	static VBCPPEVAL vbcppCondCombine(VBCPPEVAL enmEvalPush, VBCPPEVAL enmEvalStack)
3164	{
3165	if (enmEvalStack == kVBCppEval_False)
3166	return kVBCppEval_False;
3167	return enmEvalPush;
3168	}
3169
3170
3171	/**
3172	* Pushes an conditional onto the stack.
3173	*
3174	* @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
3175	* @param pThis The C preprocessor instance.
3176	* @param pStrmInput The current input stream.
3177	* @param offStart Not currently used, using @a pchCondition and
3178	* @a cchCondition instead.
3179	* @param enmKind The kind of conditional.
3180	* @param enmResult The result of the evaluation.
3181	* @param pchCondition The raw condition.
3182	* @param cchCondition The length of @a pchCondition.
3183	*/
3184	static RTEXITCODE vbcppCondPush(PVBCPP pThis, PSCMSTREAM pStrmInput, size_t offStart,
3185	VBCPPCONDKIND enmKind, VBCPPEVAL enmResult,
3186	const char *pchCondition, size_t cchCondition)
3187	{
3188	if (pThis->cCondStackDepth >= _64K)
3189	return vbcppError(pThis, "Too many nested #if/#ifdef/#ifndef statements");
3190
3191	/*
3192	* Allocate a new entry and push it.
3193	*/
3194	PVBCPPCOND pCond = (PVBCPPCOND)RTMemAlloc(sizeof(*pCond));
3195	if (!pCond)
3196	return vbcppError(pThis, "out of memory");
3197
3198	PVBCPPCOND pUp = pThis->pCondStack;
3199	pCond->enmKind = enmKind;
3200	pCond->enmResult = enmResult;
3201	pCond->enmStackResult = pUp ? vbcppCondCombine(enmResult, pUp->enmStackResult) : enmResult;
3202	pCond->fSeenElse = false;
3203	pCond->fElIfDecided = enmResult == kVBCppEval_True;
3204	pCond->iLevel = pThis->cCondStackDepth;
3205	pCond->iKeepLevel = (pUp ? pUp->iKeepLevel : 0) + enmResult == kVBCppEval_Undecided;
3206	pCond->pchCond = pchCondition;
3207	pCond->cchCond = cchCondition;
3208
3209	pCond->pUp = pThis->pCondStack;
3210	pThis->pCondStack = pCond;
3211	pThis->fIf0Mode = pCond->enmStackResult == kVBCppEval_False;
3212
3213	/*
3214	* Do pass thru.
3215	*/
3216	if ( !pThis->fIf0Mode
3217	&& enmResult == kVBCppEval_Undecided)
3218	{
3219	/** @todo this is stripping comments of \#ifdef and \#ifndef atm. */
3220	const char *pszDirective;
3221	switch (enmKind)
3222	{
3223	case kVBCppCondKind_If: pszDirective = "if"; break;
3224	case kVBCppCondKind_IfDef: pszDirective = "ifdef"; break;
3225	case kVBCppCondKind_IfNDef: pszDirective = "ifndef"; break;
3226	case kVBCppCondKind_ElIf: pszDirective = "elif"; break;
3227	default: AssertFailedReturn(RTEXITCODE_FAILURE);
3228	}
3229	ssize_t cch = ScmStreamPrintf(&pThis->StrmOutput, "#%s%s %.s",
3230	pCond->iKeepLevel - 1, "", pszDirective, cchCondition, pchCondition);
3231	if (cch < 0)
3232	return vbcppError(pThis, "Output error %Rrc", (int)cch);
3233	}
3234	else
3235	pThis->fJustDroppedLine = true;
3236
3237	return RTEXITCODE_SUCCESS;
3238	}
3239
3240
3241	/**
3242	* Recursively destroys the expression tree.
3243	*
3244	* @param pExpr The root of the expression tree to destroy.
3245	*/
3246	static void vbcppExprDestoryTree(PVBCPPEXPR pExpr)
3247	{
3248	if (!pExpr)
3249	return;
3250
3251	switch (pExpr->enmKind)
3252	{
3253	case kVBCppExprKind_Unary:
3254	vbcppExprDestoryTree(pExpr->u.Unary.pArg);
3255	break;
3256	case kVBCppExprKind_Binary:
3257	vbcppExprDestoryTree(pExpr->u.Binary.pLeft);
3258	vbcppExprDestoryTree(pExpr->u.Binary.pRight);
3259	break;
3260	case kVBCppExprKind_Ternary:
3261	vbcppExprDestoryTree(pExpr->u.Ternary.pExpr);
3262	vbcppExprDestoryTree(pExpr->u.Ternary.pExpr);
3263	vbcppExprDestoryTree(pExpr->u.Ternary.pFalse);
3264	break;
3265	case kVBCppExprKind_SignedValue:
3266	case kVBCppExprKind_UnsignedValue:
3267	break;
3268	default:
3269	AssertFailed();
3270	return;
3271	}
3272	RTMemFree(pExpr);
3273	}
3274
3275
3276	/**
3277	* Report error during expression parsing.
3278	*
3279	* @returns kExprRet_Error
3280	* @param pParser The parser instance.
3281	* @param pszMsg The error message.
3282	* @param ... Format arguments.
3283	*/
3284	static VBCPPEXPRRET vbcppExprParseError(PVBCPPEXPRPARSER pParser, const char *pszMsg, ...)
3285	{
3286	va_list va;
3287	va_start(va, pszMsg);
3288	vbcppErrorV(pParser->pThis, pszMsg, va);
3289	va_end(va);
3290	return kExprRet_Error;
3291	}
3292
3293
3294	/**
3295	* Skip white space.
3296	*
3297	* @param pParser The parser instance.
3298	*/
3299	static void vbcppExprParseSkipWhiteSpace(PVBCPPEXPRPARSER pParser)
3300	{
3301	while (RT_C_IS_SPACE(*pParser->pszCur))
3302	pParser->pszCur++;
3303	}
3304
3305
3306	/**
3307	* Allocate a new
3308	*
3309	* @returns Pointer to the node. NULL+msg on failure.
3310	* @param pParser The parser instance.
3311	*/
3312	static PVBCPPEXPR vbcppExprParseAllocNode(PVBCPPEXPRPARSER pParser)
3313	{
3314	PVBCPPEXPR pExpr = (PVBCPPEXPR)RTMemAllocZ(sizeof(*pExpr));
3315	if (!pExpr)
3316	vbcppExprParseError(pParser, "out of memory (expression node)");
3317	return pExpr;
3318	}
3319
3320
3321	/**
3322	* Looks for right parentheses and/or end of expression.
3323	*
3324	* @returns Expression status.
3325	* @retval kExprRet_Ok
3326	* @retval kExprRet_Error with msg.
3327	* @retval kExprRet_EndOfExpr
3328	* @param pParser The parser instance.
3329	*/
3330	static VBCPPEXPRRET vbcppExprParseMaybeRParenOrEoe(PVBCPPEXPRPARSER pParser)
3331	{
3332	Assert(!pParser->ppCur);
3333	for (;;)
3334	{
3335	vbcppExprParseSkipWhiteSpace(pParser);
3336	char ch = *pParser->pszCur;
3337	if (ch == '\0')
3338	return kExprRet_EndOfExpr;
3339	if (ch != ')')
3340	break;
3341	pParser->pszCur++;
3342
3343	PVBCPPEXPR pCur = pParser->pCur;
3344	while ( pCur
3345	&& ( pCur->enmKind != kVBCppExprKind_Unary
3346	\|\| pCur->u.Unary.enmOperator != kVBCppUnaryOp_Parenthesis))
3347	{
3348	switch (pCur->enmKind)
3349	{
3350	case kVBCppExprKind_SignedValue:
3351	case kVBCppExprKind_UnsignedValue:
3352	Assert(pCur->fComplete);
3353	break;
3354	case kVBCppExprKind_Unary:
3355	AssertReturn(pCur->u.Unary.pArg, vbcppExprParseError(pParser, "internal error"));
3356	pCur->fComplete = true;
3357	break;
3358	case kVBCppExprKind_Binary:
3359	AssertReturn(pCur->u.Binary.pLeft, vbcppExprParseError(pParser, "internal error"));
3360	AssertReturn(pCur->u.Binary.pRight, vbcppExprParseError(pParser, "internal error"));
3361	pCur->fComplete = true;
3362	break;
3363	case kVBCppExprKind_Ternary:
3364	#if 1 /** @todo Check out the ternary operator implementation. */
3365	return vbcppExprParseError(pParser, "The ternary operator is not implemented");
3366	#else
3367	Assert(pCur->u.Ternary.pExpr);
3368	if (!pCur->u.Ternary.pTrue)
3369	return vbcppExprParseError(pParser, "?!?!?");
3370	if (!pCur->u.Ternary.pFalse)
3371	return vbcppExprParseError(pParser, "?!?!?!?");
3372	pCur->fComplete = true;
3373	#endif
3374	break;
3375	default:
3376	return vbcppExprParseError(pParser, "Internal error (enmKind=%d)", pCur->enmKind);
3377	}
3378	pCur = pCur->pParent;
3379	}
3380	if (!pCur)
3381	return vbcppExprParseError(pParser, "Right parenthesis without a left one");
3382	pCur->fComplete = true;
3383
3384	while ( pCur->enmKind == kVBCppExprKind_Unary
3385	&& pCur->u.Unary.enmOperator != kVBCppUnaryOp_Parenthesis
3386	&& pCur->pParent)
3387	{
3388	AssertReturn(pCur->u.Unary.pArg, vbcppExprParseError(pParser, "internal error"));
3389	pCur->fComplete = true;
3390	pCur = pCur->pParent;
3391	}
3392	}
3393
3394	return kExprRet_Ok;
3395	}
3396
3397
3398	/**
3399	* Parses an binary operator.
3400	*
3401	* @returns Expression status.
3402	* @retval kExprRet_Ok
3403	* @retval kExprRet_Error with msg.
3404	* @param pParser The parser instance.
3405	*/
3406	static VBCPPEXPRRET vbcppExprParseBinaryOperator(PVBCPPEXPRPARSER pParser)
3407	{
3408	/*
3409	* Binary or ternary operator should follow now.
3410	*/
3411	VBCPPBINARYOP enmOp;
3412	char ch = *pParser->pszCur;
3413	switch (ch)
3414	{
3415	case '*':
3416	if (pParser->pszCur[1] == '=')
3417	return vbcppExprParseError(pParser, "The assignment by product operator is not valid in a preprocessor expression");
3418	enmOp = kVBCppBinary_Multiplication;
3419	break;
3420	case '/':
3421	if (pParser->pszCur[1] == '=')
3422	return vbcppExprParseError(pParser, "The assignment by quotient operator is not valid in a preprocessor expression");
3423	enmOp = kVBCppBinary_Division;
3424	break;
3425	case '%':
3426	if (pParser->pszCur[1] == '=')
3427	return vbcppExprParseError(pParser, "The assignment by remainder operator is not valid in a preprocessor expression");
3428	enmOp = kVBCppBinary_Modulo;
3429	break;
3430	case '+':
3431	if (pParser->pszCur[1] == '=')
3432	return vbcppExprParseError(pParser, "The assignment by sum operator is not valid in a preprocessor expression");
3433	enmOp = kVBCppBinary_Addition;
3434	break;
3435	case '-':
3436	if (pParser->pszCur[1] == '=')
3437	return vbcppExprParseError(pParser, "The assignment by difference operator is not valid in a preprocessor expression");
3438	enmOp = kVBCppBinary_Subtraction;
3439	break;
3440	case '<':
3441	enmOp = kVBCppBinary_LessThan;
3442	if (pParser->pszCur[1] == '=')
3443	{
3444	pParser->pszCur++;
3445	enmOp = kVBCppBinary_LessThanOrEqual;
3446	}
3447	else if (pParser->pszCur[1] == '<')
3448	{
3449	pParser->pszCur++;
3450	if (pParser->pszCur[1] == '=')
3451	return vbcppExprParseError(pParser, "The assignment by bitwise left shift operator is not valid in a preprocessor expression");
3452	enmOp = kVBCppBinary_LeftShift;
3453	}
3454	break;
3455	case '>':
3456	enmOp = kVBCppBinary_GreaterThan; break;
3457	if (pParser->pszCur[1] == '=')
3458	{
3459	pParser->pszCur++;
3460	enmOp = kVBCppBinary_GreaterThanOrEqual;
3461	}
3462	else if (pParser->pszCur[1] == '<')
3463	{
3464	pParser->pszCur++;
3465	if (pParser->pszCur[1] == '=')
3466	return vbcppExprParseError(pParser, "The assignment by bitwise right shift operator is not valid in a preprocessor expression");
3467	enmOp = kVBCppBinary_LeftShift;
3468	}
3469	break;
3470	case '=':
3471	if (pParser->pszCur[1] != '=')
3472	return vbcppExprParseError(pParser, "The assignment operator is not valid in a preprocessor expression");
3473	pParser->pszCur++;
3474	enmOp = kVBCppBinary_EqualTo;
3475	break;
3476
3477	case '!':
3478	if (pParser->pszCur[1] != '=')
3479	return vbcppExprParseError(pParser, "Expected binary operator, found the unary operator logical NOT");
3480	pParser->pszCur++;
3481	enmOp = kVBCppBinary_NotEqualTo;
3482	break;
3483
3484	case '&':
3485	if (pParser->pszCur[1] == '=')
3486	return vbcppExprParseError(pParser, "The assignment by bitwise AND operator is not valid in a preprocessor expression");
3487	if (pParser->pszCur[1] == '&')
3488	{
3489	pParser->pszCur++;
3490	enmOp = kVBCppBinary_LogicalAnd;
3491	}
3492	else
3493	enmOp = kVBCppBinary_BitwiseAnd;
3494	break;
3495	case '^':
3496	if (pParser->pszCur[1] == '=')
3497	return vbcppExprParseError(pParser, "The assignment by bitwise XOR operator is not valid in a preprocessor expression");
3498	enmOp = kVBCppBinary_BitwiseXor;
3499	break;
3500	case '\|':
3501	if (pParser->pszCur[1] == '=')
3502	return vbcppExprParseError(pParser, "The assignment by bitwise AND operator is not valid in a preprocessor expression");
3503	if (pParser->pszCur[1] == '\|')
3504	{
3505	pParser->pszCur++;
3506	enmOp = kVBCppBinary_LogicalOr;
3507	}
3508	else
3509	enmOp = kVBCppBinary_BitwiseOr;
3510	break;
3511	case '~':
3512	return vbcppExprParseError(pParser, "Expected binary operator, found the unary operator bitwise NOT");
3513
3514	case ':':
3515	case '?':
3516	return vbcppExprParseError(pParser, "The ternary operator is not yet implemented");
3517
3518	default:
3519	return vbcppExprParseError(pParser, "Expected binary operator, found '%.20s'", pParser->pszCur);
3520	}
3521	pParser->pszCur++;
3522
3523	/*
3524	* Create a binary operator node.
3525	*/
3526	PVBCPPEXPR pExpr = vbcppExprParseAllocNode(pParser);
3527	if (!pExpr)
3528	return kExprRet_Error;
3529	pExpr->fComplete = true;
3530	pExpr->enmKind = kVBCppExprKind_Binary;
3531	pExpr->u.Binary.enmOperator = enmOp;
3532	pExpr->u.Binary.pLeft = NULL;
3533	pExpr->u.Binary.pRight = NULL;
3534
3535	/*
3536	* Back up the tree until we find our spot.
3537	*/
3538	PVBCPPEXPR *ppPlace = NULL;
3539	PVBCPPEXPR pChild = NULL;
3540	PVBCPPEXPR pParent = pParser->pCur;
3541	while (pParent)
3542	{
3543	if (pParent->enmKind == kVBCppExprKind_Unary)
3544	{
3545	if (pParent->u.Unary.enmOperator == kVBCppUnaryOp_Parenthesis)
3546	{
3547	ppPlace = &pParent->u.Unary.pArg;
3548	break;
3549	}
3550	AssertReturn(pParent->u.Unary.pArg, vbcppExprParseError(pParser, "internal error"));
3551	pParent->fComplete = true;
3552	}
3553	else if (pParent->enmKind == kVBCppExprKind_Binary)
3554	{
3555	AssertReturn(pParent->u.Binary.pLeft, vbcppExprParseError(pParser, "internal error"));
3556	AssertReturn(pParent->u.Binary.pRight, vbcppExprParseError(pParser, "internal error"));
3557	if ((pParent->u.Binary.enmOperator & VBCPPOP_PRECEDENCE_MASK) >= (enmOp & VBCPPOP_PRECEDENCE_MASK))
3558	{
3559	AssertReturn(pChild, vbcppExprParseError(pParser, "internal error"));
3560
3561	if (pParent->u.Binary.pRight == pChild)
3562	ppPlace = &pParent->u.Binary.pRight;
3563	else
3564	ppPlace = &pParent->u.Binary.pLeft;
3565	AssertReturn(*ppPlace == pChild, vbcppExprParseError(pParser, "internal error"));
3566	break;
3567	}
3568	pParent->fComplete = true;
3569	}
3570	else if (pParent->enmKind == kVBCppExprKind_Ternary)
3571	{
3572	return vbcppExprParseError(pParser, "The ternary operator is not implemented");
3573	}
3574	else
3575	AssertReturn( pParent->enmKind == kVBCppExprKind_SignedValue
3576	\|\| pParent->enmKind == kVBCppExprKind_UnsignedValue,
3577	vbcppExprParseError(pParser, "internal error"));
3578
3579	/* Up on level */
3580	pChild = pParent;
3581	pParent = pParent->pParent;
3582	}
3583
3584	/*
3585	* Do the rotation.
3586	*/
3587	Assert(pChild);
3588	Assert(pChild->pParent == pParent);
3589	pChild->pParent = pExpr;
3590
3591	pExpr->u.Binary.pLeft = pChild;
3592	pExpr->pParent = pParent;
3593
3594	if (!pParent)
3595	pParser->pRoot = pExpr;
3596	else
3597	*ppPlace = pExpr;
3598
3599	pParser->ppCur = &pExpr->u.Binary.pRight;
3600	pParser->pCur = pExpr;
3601
3602	return kExprRet_Ok;
3603	}
3604
3605
3606	/**
3607	* Deals with right paretheses or/and end of expression, looks for binary
3608	* operators.
3609	*
3610	* @returns Expression status.
3611	* @retval kExprRet_Ok if binary operator was found processed.
3612	* @retval kExprRet_Error with msg.
3613	* @retval kExprRet_EndOfExpr
3614	* @param pParser The parser instance.
3615	*/
3616	static VBCPPEXPRRET vbcppExprParseBinaryOrEoeOrRparen(PVBCPPEXPRPARSER pParser)
3617	{
3618	VBCPPEXPRRET enmRet = vbcppExprParseMaybeRParenOrEoe(pParser);
3619	if (enmRet != kExprRet_Ok)
3620	return enmRet;
3621	return vbcppExprParseBinaryOperator(pParser);
3622	}
3623
3624
3625	/**
3626	* Parses an identifier in the expression, replacing it by 0.
3627	*
3628	* All known identifiers has already been replaced by their macro values, so
3629	* what's left are unknown macros. These are replaced by 0.
3630	*
3631	* @returns Expression status.
3632	* @retval kExprRet_Value
3633	* @retval kExprRet_Error with msg.
3634	* @param pParser The parser instance.
3635	*/
3636	static VBCPPEXPRRET vbcppExprParseIdentifier(PVBCPPEXPRPARSER pParser)
3637	{
3638	/** @todo don't increment if it's an actively undefined macro. Need to revise
3639	* the expression related code wrt selective preprocessing. */
3640	pParser->cUndefined++;
3641
3642	/* Find the end. */
3643	const char *pszMacro = pParser->pszCur;
3644	const char *pszNext = pszMacro + 1;
3645	while (vbcppIsCIdentifierChar(*pszNext))
3646	pszNext++;
3647	size_t cchMacro = pszNext - pszMacro;
3648
3649	/* Create a signed value node. */
3650	PVBCPPEXPR pExpr = vbcppExprParseAllocNode(pParser);
3651	if (!pExpr)
3652	return kExprRet_Error;
3653	pExpr->fComplete = true;
3654	pExpr->enmKind = kVBCppExprKind_UnsignedValue;
3655	pExpr->u.UnsignedValue.u64 = 0;
3656
3657	/* Link it. */
3658	pExpr->pParent = pParser->pCur;
3659	pParser->pCur = pExpr;
3660	*pParser->ppCur = pExpr;
3661	pParser->ppCur = NULL;
3662
3663	/* Skip spaces and check for parenthesis. */
3664	pParser->pszCur = pszNext;
3665	vbcppExprParseSkipWhiteSpace(pParser);
3666	if (*pParser->pszCur == '(')
3667	return vbcppExprParseError(pParser, "Unknown unary operator '%.*s'", cchMacro, pszMacro);
3668
3669	return kExprRet_Value;
3670	}
3671
3672
3673	/**
3674	* Parses an numeric constant in the expression.
3675	*
3676	* @returns Expression status.
3677	* @retval kExprRet_Value
3678	* @retval kExprRet_Error with msg.
3679	* @param pParser The parser instance.
3680	*/
3681	static VBCPPEXPRRET vbcppExprParseNumber(PVBCPPEXPRPARSER pParser)
3682	{
3683	bool fSigned;
3684	char *pszNext;
3685	uint64_t u64;
3686	char ch = *pParser->pszCur++;
3687	char ch2 = *pParser->pszCur;
3688	if ( ch == '0'
3689	&& (ch == 'x' \|\| ch == 'X'))
3690	{
3691	ch2 = *++pParser->pszCur;
3692	if (!RT_C_IS_XDIGIT(ch2))
3693	return vbcppExprParseError(pParser, "Expected hex digit following '0x'");
3694	int rc = RTStrToUInt64Ex(pParser->pszCur, &pszNext, 16, &u64);
3695	if ( RT_FAILURE(rc)
3696	\|\| rc == VWRN_NUMBER_TOO_BIG)
3697	return vbcppExprParseError(pParser, "Invalid hex value '%.20s...' (%Rrc)", pParser->pszCur, rc);
3698	fSigned = false;
3699	}
3700	else if (ch == '0')
3701	{
3702	int rc = RTStrToUInt64Ex(pParser->pszCur - 1, &pszNext, 8, &u64);
3703	if ( RT_FAILURE(rc)
3704	\|\| rc == VWRN_NUMBER_TOO_BIG)
3705	return vbcppExprParseError(pParser, "Invalid octal value '%.20s...' (%Rrc)", pParser->pszCur, rc);
3706	fSigned = u64 > (uint64_t)INT64_MAX ? false : true;
3707	}
3708	else
3709	{
3710	int rc = RTStrToUInt64Ex(pParser->pszCur - 1, &pszNext, 10, &u64);
3711	if ( RT_FAILURE(rc)
3712	\|\| rc == VWRN_NUMBER_TOO_BIG)
3713	return vbcppExprParseError(pParser, "Invalid decimal value '%.20s...' (%Rrc)", pParser->pszCur, rc);
3714	fSigned = u64 > (uint64_t)INT64_MAX ? false : true;
3715	}
3716
3717	/* suffix. */
3718	if (vbcppIsCIdentifierLeadChar(*pszNext))
3719	{
3720	size_t cchSuffix = 1;
3721	while (vbcppIsCIdentifierLeadChar(pszNext[cchSuffix]))
3722	cchSuffix++;
3723
3724	if (cchSuffix == '1' && (pszNext == 'u' \|\| pszNext == 'U'))
3725	fSigned = false;
3726	else if ( cchSuffix == '1'
3727	&& (pszNext == 'l' \|\| pszNext == 'L'))
3728	fSigned = true;
3729	else if ( cchSuffix == '2'
3730	&& (!strncmp(pszNext, "ul", 2) \|\| !strncmp(pszNext, "UL", 2)))
3731	fSigned = false;
3732	else if ( cchSuffix == '2'
3733	&& (!strncmp(pszNext, "ll", 2) \|\| !strncmp(pszNext, "LL", 2)))
3734	fSigned = true;
3735	else if ( cchSuffix == '3'
3736	&& (!strncmp(pszNext, "ull", 3) \|\| !strncmp(pszNext, "ULL", 3)))
3737	fSigned = false;
3738	else
3739	return vbcppExprParseError(pParser, "Invalid number suffix '%.*s'", cchSuffix, pszNext);
3740
3741	pszNext += cchSuffix;
3742	}
3743	pParser->pszCur = pszNext;
3744
3745	/* Create a signed value node. */
3746	PVBCPPEXPR pExpr = vbcppExprParseAllocNode(pParser);
3747	if (!pExpr)
3748	return kExprRet_Error;
3749	pExpr->fComplete = true;
3750	if (fSigned)
3751	{
3752	pExpr->enmKind = kVBCppExprKind_SignedValue;
3753	pExpr->u.SignedValue.s64 = (int64_t)u64;
3754	}
3755	else
3756	{
3757	pExpr->enmKind = kVBCppExprKind_UnsignedValue;
3758	pExpr->u.UnsignedValue.u64 = u64;
3759	}
3760
3761	/* Link it. */
3762	pExpr->pParent = pParser->pCur;
3763	pParser->pCur = pExpr;
3764	*pParser->ppCur = pExpr;
3765	pParser->ppCur = NULL;
3766
3767	return kExprRet_Value;
3768	}
3769
3770
3771	/**
3772	* Parses an character constant in the expression.
3773	*
3774	* @returns Expression status.
3775	* @retval kExprRet_Value
3776	* @retval kExprRet_Error with msg.
3777	* @param pParser The parser instance.
3778	*/
3779	static VBCPPEXPRRET vbcppExprParseCharacterConstant(PVBCPPEXPRPARSER pParser)
3780	{
3781	char ch = *pParser->pszCur++;
3782	char ch2 = *pParser->pszCur++;
3783	if (ch2 == '\'')
3784	return vbcppExprParseError(pParser, "Empty character constant");
3785	int64_t s64;
3786	if (ch2 == '\\')
3787	{
3788	ch2 = *pParser->pszCur++;
3789	switch (ch2)
3790	{
3791	case '0': s64 = 0x00; break;
3792	case 'n': s64 = 0x0d; break;
3793	case 'r': s64 = 0x0a; break;
3794	case 't': s64 = 0x09; break;
3795	default:
3796	return vbcppExprParseError(pParser, "Escape character '%c' is not implemented", ch2);
3797	}
3798	}
3799	else
3800	s64 = ch2;
3801	if (*pParser->pszCur != '\'')
3802	return vbcppExprParseError(pParser, "Character constant contains more than one character");
3803
3804	/* Create a signed value node. */
3805	PVBCPPEXPR pExpr = vbcppExprParseAllocNode(pParser);
3806	if (!pExpr)
3807	return kExprRet_Error;
3808	pExpr->fComplete = true;
3809	pExpr->enmKind = kVBCppExprKind_SignedValue;
3810	pExpr->u.SignedValue.s64 = s64;
3811
3812	/* Link it. */
3813	pExpr->pParent = pParser->pCur;
3814	pParser->pCur = pExpr;
3815	*pParser->ppCur = pExpr;
3816	pParser->ppCur = NULL;
3817
3818	return kExprRet_Value;
3819	}
3820
3821
3822	/**
3823	* Parses a unary operator or a value.
3824	*
3825	* @returns Expression status.
3826	* @retval kExprRet_Value if value was found and processed.
3827	* @retval kExprRet_UnaryOperator if an unary operator was found and processed.
3828	* @retval kExprRet_Error with msg.
3829	* @param pParser The parser instance.
3830	*/
3831	static VBCPPEXPRRET vbcppExprParseUnaryOrValue(PVBCPPEXPRPARSER pParser)
3832	{
3833	vbcppExprParseSkipWhiteSpace(pParser);
3834	char ch = *pParser->pszCur;
3835	if (ch == '\0')
3836	return vbcppExprParseError(pParser, "Premature end of expression");
3837
3838	/*
3839	* Value?
3840	*/
3841	if (ch == '\'')
3842	return vbcppExprParseCharacterConstant(pParser);
3843	if (RT_C_IS_DIGIT(ch))
3844	return vbcppExprParseNumber(pParser);
3845	if (ch == '"')
3846	return vbcppExprParseError(pParser, "String litteral");
3847	if (vbcppIsCIdentifierLeadChar(ch))
3848	return vbcppExprParseIdentifier(pParser);
3849
3850	/*
3851	* Operator?
3852	*/
3853	VBCPPUNARYOP enmOperator;
3854	if (ch == '+')
3855	{
3856	enmOperator = kVBCppUnaryOp_Pluss;
3857	if (pParser->pszCur[1] == '+')
3858	return vbcppExprParseError(pParser, "The prefix increment operator is not valid in a preprocessor expression");
3859	}
3860	else if (ch == '-')
3861	{
3862	enmOperator = kVBCppUnaryOp_Minus;
3863	if (pParser->pszCur[1] == '-')
3864	return vbcppExprParseError(pParser, "The prefix decrement operator is not valid in a preprocessor expression");
3865	}
3866	else if (ch == '!')
3867	enmOperator = kVBCppUnaryOp_LogicalNot;
3868	else if (ch == '~')
3869	enmOperator = kVBCppUnaryOp_BitwiseNot;
3870	else if (ch == '(')
3871	enmOperator = kVBCppUnaryOp_Parenthesis;
3872	else
3873	return vbcppExprParseError(pParser, "Unknown token '%.*s'", 32, pParser->pszCur - 1);
3874	pParser->pszCur++;
3875
3876	/* Create an operator node. */
3877	PVBCPPEXPR pExpr = vbcppExprParseAllocNode(pParser);
3878	if (!pExpr)
3879	return kExprRet_Error;
3880	pExpr->fComplete = false;
3881	pExpr->enmKind = kVBCppExprKind_Unary;
3882	pExpr->u.Unary.enmOperator = enmOperator;
3883	pExpr->u.Unary.pArg = NULL;
3884
3885	/* Link it into the tree. */
3886	pExpr->pParent = pParser->pCur;
3887	pParser->pCur = pExpr;
3888	*pParser->ppCur = pExpr;
3889	pParser->ppCur = &pExpr->u.Unary.pArg;
3890
3891	return kExprRet_UnaryOperator;
3892	}
3893
3894
3895	/**
3896	* Parses an expanded preprocessor expression.
3897	*
3898	* @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
3899	* @param pThis The C preprocessor instance.
3900	* @param pszExpr The expression to parse.
3901	* @param cchExpr The length of the expression in case we need it.
3902	* @param ppExprTree Where to return the parse tree.
3903	* @param pcUndefined Where to return the number of unknown undefined
3904	* macros. Optional.
3905	*/
3906	static RTEXITCODE vbcppExprParse(PVBCPP pThis, char pszExpr, size_t cchExpr, PVBCPPEXPR ppExprTree, size_t *pcUndefined)
3907	{
3908	RTEXITCODE rcExit = RTEXITCODE_FAILURE;
3909	NOREF(cchExpr);
3910
3911	/*
3912	* Initialize the parser context structure.
3913	*/
3914	VBCPPEXPRPARSER Parser;
3915	Parser.pszCur = pszExpr;
3916	Parser.pRoot = NULL;
3917	Parser.pCur = NULL;
3918	Parser.ppCur = &Parser.pRoot;
3919	Parser.pszExpr = pszExpr;
3920	Parser.cUndefined = 0;
3921	Parser.pThis = pThis;
3922
3923	/*
3924	* Do the parsing.
3925	*/
3926	VBCPPEXPRRET enmRet;
3927	for (;;)
3928	{
3929	/*
3930	* Eat unary operators until we hit a value.
3931	*/
3932	do
3933	enmRet = vbcppExprParseUnaryOrValue(&Parser);
3934	while (enmRet == kExprRet_UnaryOperator);
3935	if (enmRet == kExprRet_Error)
3936	break;
3937	AssertBreakStmt(enmRet == kExprRet_Value, enmRet = vbcppExprParseError(&Parser, "Expected value (enmRet=%d)", enmRet));
3938
3939	/*
3940	* Non-unary operator, right parenthesis or end of expression is up next.
3941	*/
3942	enmRet = vbcppExprParseBinaryOrEoeOrRparen(&Parser);
3943	if (enmRet == kExprRet_Error)
3944	break;
3945	if (enmRet == kExprRet_EndOfExpr)
3946	{
3947	/** @todo check if there are any open parentheses. */
3948	rcExit = RTEXITCODE_SUCCESS;
3949	break;
3950	}
3951	AssertBreakStmt(enmRet == kExprRet_Ok, enmRet = vbcppExprParseError(&Parser, "Expected value (enmRet=%d)", enmRet));
3952	}
3953
3954	if (rcExit != RTEXITCODE_SUCCESS)
3955	{
3956	vbcppExprDestoryTree(Parser.pRoot);
3957	return rcExit;
3958	}
3959
3960	if (pcUndefined)
3961	*pcUndefined = Parser.cUndefined;
3962	*ppExprTree = Parser.pRoot;
3963	return rcExit;
3964	}
3965
3966
3967	/**
3968	* Checks if an expression value value is evaluates to @c true or @c false.
3969	*
3970	* @returns @c true or @c false.
3971	* @param pExpr The value expression.
3972	*/
3973	static bool vbcppExprIsExprTrue(PVBCPPEXPR pExpr)
3974	{
3975	Assert(pExpr->enmKind == kVBCppExprKind_SignedValue \|\| pExpr->enmKind == kVBCppExprKind_UnsignedValue);
3976
3977	return pExpr->enmKind == kVBCppExprKind_SignedValue
3978	? pExpr->u.SignedValue.s64 != 0
3979	: pExpr->u.UnsignedValue.u64 != 0;
3980	}
3981
3982
3983	/**
3984	* Evalutes a parse (sub-)tree.
3985	*
3986	* @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
3987	* @param pThis The C preprocessor instance.
3988	* @param pRoot The root of the parse (sub-)tree.
3989	* @param pResult Where to store the result value.
3990	*/
3991	static RTEXITCODE vbcppExprEvaluteTree(PVBCPP pThis, PVBCPPEXPR pRoot, PVBCPPEXPR pResult)
3992	{
3993	RTEXITCODE rcExit;
3994	switch (pRoot->enmKind)
3995	{
3996	case kVBCppExprKind_SignedValue:
3997	pResult->enmKind = kVBCppExprKind_SignedValue;
3998	pResult->u.SignedValue.s64 = pRoot->u.SignedValue.s64;
3999	return RTEXITCODE_SUCCESS;
4000
4001	case kVBCppExprKind_UnsignedValue:
4002	pResult->enmKind = kVBCppExprKind_UnsignedValue;
4003	pResult->u.UnsignedValue.u64 = pRoot->u.UnsignedValue.u64;
4004	return RTEXITCODE_SUCCESS;
4005
4006	case kVBCppExprKind_Unary:
4007	rcExit = vbcppExprEvaluteTree(pThis, pRoot->u.Unary.pArg, pResult);
4008	if (rcExit != RTEXITCODE_SUCCESS)
4009	return rcExit;
4010
4011	/* Apply the unary operator to the value */
4012	switch (pRoot->u.Unary.enmOperator)
4013	{
4014	case kVBCppUnaryOp_Minus:
4015	if (pResult->enmKind == kVBCppExprKind_SignedValue)
4016	pResult->u.SignedValue.s64 = -pResult->u.SignedValue.s64;
4017	else
4018	pResult->u.UnsignedValue.u64 = (uint64_t)-(int64_t)pResult->u.UnsignedValue.u64;
4019	break;
4020
4021	case kVBCppUnaryOp_LogicalNot:
4022	if (pResult->enmKind == kVBCppExprKind_SignedValue)
4023	pResult->u.SignedValue.s64 = !pResult->u.SignedValue.s64;
4024	else
4025	pResult->u.UnsignedValue.u64 = !pResult->u.UnsignedValue.u64;
4026	break;
4027
4028	case kVBCppUnaryOp_BitwiseNot:
4029	if (pResult->enmKind == kVBCppExprKind_SignedValue)
4030	pResult->u.SignedValue.s64 = ~pResult->u.SignedValue.s64;
4031	else
4032	pResult->u.UnsignedValue.u64 = ~pResult->u.UnsignedValue.u64;
4033	break;
4034
4035	case kVBCppUnaryOp_Pluss:
4036	case kVBCppUnaryOp_Parenthesis:
4037	/* do nothing. */
4038	break;
4039
4040	default:
4041	return vbcppError(pThis, "Internal error: u.Unary.enmOperator=%d", pRoot->u.Unary.enmOperator);
4042	}
4043	return RTEXITCODE_SUCCESS;
4044
4045	case kVBCppExprKind_Binary:
4046	{
4047	/* Always evalute the left side. */
4048	rcExit = vbcppExprEvaluteTree(pThis, pRoot->u.Binary.pLeft, pResult);
4049	if (rcExit != RTEXITCODE_SUCCESS)
4050	return rcExit;
4051
4052	/* If logical AND or OR we can sometimes skip evaluting the right side. */
4053	if ( pRoot->u.Binary.enmOperator == kVBCppBinary_LogicalAnd
4054	&& !vbcppExprIsExprTrue(pResult))
4055	return RTEXITCODE_SUCCESS;
4056
4057	if ( pRoot->u.Binary.enmOperator == kVBCppBinary_LogicalOr
4058	&& vbcppExprIsExprTrue(pResult))
4059	return RTEXITCODE_SUCCESS;
4060
4061	/* Evalute the right side. */
4062	VBCPPEXPR Result2;
4063	rcExit = vbcppExprEvaluteTree(pThis, pRoot->u.Binary.pRight, &Result2);
4064	if (rcExit != RTEXITCODE_SUCCESS)
4065	return rcExit;
4066
4067	/* If one of them is unsigned, promote the other to unsigned as well. */
4068	if ( pResult->enmKind == kVBCppExprKind_UnsignedValue
4069	&& Result2.enmKind == kVBCppExprKind_SignedValue)
4070	{
4071	Result2.enmKind = kVBCppExprKind_UnsignedValue;
4072	Result2.u.UnsignedValue.u64 = Result2.u.SignedValue.s64;
4073	}
4074	else if ( pResult->enmKind == kVBCppExprKind_SignedValue
4075	&& Result2.enmKind == kVBCppExprKind_UnsignedValue)
4076	{
4077	pResult->enmKind = kVBCppExprKind_UnsignedValue;
4078	pResult->u.UnsignedValue.u64 = pResult->u.SignedValue.s64;
4079	}
4080
4081	/* Perform the operation. */
4082	if (pResult->enmKind == kVBCppExprKind_UnsignedValue)
4083	{
4084	switch (pRoot->u.Binary.enmOperator)
4085	{
4086	case kVBCppBinary_Multiplication:
4087	pResult->u.UnsignedValue.u64 *= Result2.u.UnsignedValue.u64;
4088	break;
4089	case kVBCppBinary_Division:
4090	if (!Result2.u.UnsignedValue.u64)
4091	return vbcppError(pThis, "Divide by zero");
4092	pResult->u.UnsignedValue.u64 /= Result2.u.UnsignedValue.u64;
4093	break;
4094	case kVBCppBinary_Modulo:
4095	if (!Result2.u.UnsignedValue.u64)
4096	return vbcppError(pThis, "Divide by zero");
4097	pResult->u.UnsignedValue.u64 %= Result2.u.UnsignedValue.u64;
4098	break;
4099	case kVBCppBinary_Addition:
4100	pResult->u.UnsignedValue.u64 += Result2.u.UnsignedValue.u64;
4101	break;
4102	case kVBCppBinary_Subtraction:
4103	pResult->u.UnsignedValue.u64 -= Result2.u.UnsignedValue.u64;
4104	break;
4105	case kVBCppBinary_LeftShift:
4106	pResult->u.UnsignedValue.u64 <<= Result2.u.UnsignedValue.u64;
4107	break;
4108	case kVBCppBinary_RightShift:
4109	pResult->u.UnsignedValue.u64 >>= Result2.u.UnsignedValue.u64;
4110	break;
4111	case kVBCppBinary_LessThan:
4112	pResult->u.UnsignedValue.u64 = pResult->u.UnsignedValue.u64 < Result2.u.UnsignedValue.u64;
4113	break;
4114	case kVBCppBinary_LessThanOrEqual:
4115	pResult->u.UnsignedValue.u64 = pResult->u.UnsignedValue.u64 <= Result2.u.UnsignedValue.u64;
4116	break;
4117	case kVBCppBinary_GreaterThan:
4118	pResult->u.UnsignedValue.u64 = pResult->u.UnsignedValue.u64 > Result2.u.UnsignedValue.u64;
4119	break;
4120	case kVBCppBinary_GreaterThanOrEqual:
4121	pResult->u.UnsignedValue.u64 = pResult->u.UnsignedValue.u64 >= Result2.u.UnsignedValue.u64;
4122	break;
4123	case kVBCppBinary_EqualTo:
4124	pResult->u.UnsignedValue.u64 = pResult->u.UnsignedValue.u64 == Result2.u.UnsignedValue.u64;
4125	break;
4126	case kVBCppBinary_NotEqualTo:
4127	pResult->u.UnsignedValue.u64 = pResult->u.UnsignedValue.u64 != Result2.u.UnsignedValue.u64;
4128	break;
4129	case kVBCppBinary_BitwiseAnd:
4130	pResult->u.UnsignedValue.u64 &= Result2.u.UnsignedValue.u64;
4131	break;
4132	case kVBCppBinary_BitwiseXor:
4133	pResult->u.UnsignedValue.u64 ^= Result2.u.UnsignedValue.u64;
4134	break;
4135	case kVBCppBinary_BitwiseOr:
4136	pResult->u.UnsignedValue.u64 \|= Result2.u.UnsignedValue.u64;
4137	break;
4138	case kVBCppBinary_LogicalAnd:
4139	pResult->u.UnsignedValue.u64 = pResult->u.UnsignedValue.u64 && Result2.u.UnsignedValue.u64;
4140	break;
4141	case kVBCppBinary_LogicalOr:
4142	pResult->u.UnsignedValue.u64 = pResult->u.UnsignedValue.u64 \|\| Result2.u.UnsignedValue.u64;
4143	break;
4144	default:
4145	return vbcppError(pThis, "Internal error: u.Binary.enmOperator=%d", pRoot->u.Binary.enmOperator);
4146	}
4147	}
4148	else
4149	{
4150	switch (pRoot->u.Binary.enmOperator)
4151	{
4152	case kVBCppBinary_Multiplication:
4153	pResult->u.SignedValue.s64 *= Result2.u.SignedValue.s64;
4154	break;
4155	case kVBCppBinary_Division:
4156	if (!Result2.u.SignedValue.s64)
4157	return vbcppError(pThis, "Divide by zero");
4158	pResult->u.SignedValue.s64 /= Result2.u.SignedValue.s64;
4159	break;
4160	case kVBCppBinary_Modulo:
4161	if (!Result2.u.SignedValue.s64)
4162	return vbcppError(pThis, "Divide by zero");
4163	pResult->u.SignedValue.s64 %= Result2.u.SignedValue.s64;
4164	break;
4165	case kVBCppBinary_Addition:
4166	pResult->u.SignedValue.s64 += Result2.u.SignedValue.s64;
4167	break;
4168	case kVBCppBinary_Subtraction:
4169	pResult->u.SignedValue.s64 -= Result2.u.SignedValue.s64;
4170	break;
4171	case kVBCppBinary_LeftShift:
4172	pResult->u.SignedValue.s64 <<= Result2.u.SignedValue.s64;
4173	break;
4174	case kVBCppBinary_RightShift:
4175	pResult->u.SignedValue.s64 >>= Result2.u.SignedValue.s64;
4176	break;
4177	case kVBCppBinary_LessThan:
4178	pResult->u.SignedValue.s64 = pResult->u.SignedValue.s64 < Result2.u.SignedValue.s64;
4179	break;
4180	case kVBCppBinary_LessThanOrEqual:
4181	pResult->u.SignedValue.s64 = pResult->u.SignedValue.s64 <= Result2.u.SignedValue.s64;
4182	break;
4183	case kVBCppBinary_GreaterThan:
4184	pResult->u.SignedValue.s64 = pResult->u.SignedValue.s64 > Result2.u.SignedValue.s64;
4185	break;
4186	case kVBCppBinary_GreaterThanOrEqual:
4187	pResult->u.SignedValue.s64 = pResult->u.SignedValue.s64 >= Result2.u.SignedValue.s64;
4188	break;
4189	case kVBCppBinary_EqualTo:
4190	pResult->u.SignedValue.s64 = pResult->u.SignedValue.s64 == Result2.u.SignedValue.s64;
4191	break;
4192	case kVBCppBinary_NotEqualTo:
4193	pResult->u.SignedValue.s64 = pResult->u.SignedValue.s64 != Result2.u.SignedValue.s64;
4194	break;
4195	case kVBCppBinary_BitwiseAnd:
4196	pResult->u.SignedValue.s64 &= Result2.u.SignedValue.s64;
4197	break;
4198	case kVBCppBinary_BitwiseXor:
4199	pResult->u.SignedValue.s64 ^= Result2.u.SignedValue.s64;
4200	break;
4201	case kVBCppBinary_BitwiseOr:
4202	pResult->u.SignedValue.s64 \|= Result2.u.SignedValue.s64;
4203	break;
4204	case kVBCppBinary_LogicalAnd:
4205	pResult->u.SignedValue.s64 = pResult->u.SignedValue.s64 && Result2.u.SignedValue.s64;
4206	break;
4207	case kVBCppBinary_LogicalOr:
4208	pResult->u.SignedValue.s64 = pResult->u.SignedValue.s64 \|\| Result2.u.SignedValue.s64;
4209	break;
4210	default:
4211	return vbcppError(pThis, "Internal error: u.Binary.enmOperator=%d", pRoot->u.Binary.enmOperator);
4212	}
4213	}
4214	return rcExit;
4215	}
4216
4217	case kVBCppExprKind_Ternary:
4218	rcExit = vbcppExprEvaluteTree(pThis, pRoot->u.Ternary.pExpr, pResult);
4219	if (rcExit != RTEXITCODE_SUCCESS)
4220	return rcExit;
4221	if (vbcppExprIsExprTrue(pResult))
4222	return vbcppExprEvaluteTree(pThis, pRoot->u.Ternary.pTrue, pResult);
4223	return vbcppExprEvaluteTree(pThis, pRoot->u.Ternary.pFalse, pResult);
4224
4225	default:
4226	return vbcppError(pThis, "Internal error: enmKind=%d", pRoot->enmKind);
4227	}
4228	}
4229
4230
4231	/**
4232	* Evalutes the expression.
4233	*
4234	* @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
4235	* @param pThis The C preprocessor instance.
4236	* @param pszExpr The expression.
4237	* @param cchExpr The length of the expression.
4238	* @param penmResult Where to store the result.
4239	*/
4240	static RTEXITCODE vbcppExprEval(PVBCPP pThis, char pszExpr, size_t cchExpr, size_t cReplacements, VBCPPEVAL penmResult)
4241	{
4242	Assert(strlen(pszExpr) == cchExpr);
4243	size_t cUndefined;
4244	PVBCPPEXPR pExprTree;
4245	RTEXITCODE rcExit = vbcppExprParse(pThis, pszExpr, cchExpr, &pExprTree, &cUndefined);
4246	if (rcExit == RTEXITCODE_SUCCESS)
4247	{
4248	if ( !cUndefined
4249	\|\| pThis->enmMode == kVBCppMode_SelectiveD
4250	\|\| pThis->enmMode == kVBCppMode_Standard)
4251	{
4252	VBCPPEXPR Result;
4253	rcExit = vbcppExprEvaluteTree(pThis, pExprTree, &Result);
4254	if (rcExit == RTEXITCODE_SUCCESS)
4255	{
4256	if (vbcppExprIsExprTrue(&Result))
4257	*penmResult = kVBCppEval_True;
4258	else
4259	*penmResult = kVBCppEval_False;
4260	}
4261	}
4262	else
4263	*penmResult = kVBCppEval_Undecided;
4264	}
4265	return rcExit;
4266	}
4267
4268
4269	static RTEXITCODE vbcppExtractSkipCommentLine(PVBCPP pThis, PSCMSTREAM pStrmInput)
4270	{
4271	unsigned chPrev = ScmStreamGetCh(pStrmInput); Assert(chPrev == '/');
4272	unsigned ch;
4273	while ((ch = ScmStreamPeekCh(pStrmInput)) != ~(unsigned)0)
4274	{
4275	if (ch == '\r' \|\| ch == '\n')
4276	{
4277	if (chPrev != '\\')
4278	break;
4279	ScmStreamSeekByLine(pStrmInput, ScmStreamTellLine(pStrmInput) + 1);
4280	chPrev = ch;
4281	}
4282	else
4283	{
4284	chPrev = ScmStreamGetCh(pStrmInput);
4285	Assert(chPrev == ch);
4286	}
4287	}
4288	return RTEXITCODE_SUCCESS;
4289	}
4290
4291
4292	static RTEXITCODE vbcppExtractSkipComment(PVBCPP pThis, PSCMSTREAM pStrmInput)
4293	{
4294	unsigned ch = ScmStreamGetCh(pStrmInput); Assert(ch == '*');
4295	while ((ch = ScmStreamGetCh(pStrmInput)) != ~(unsigned)0)
4296	{
4297	if (ch == '*')
4298	{
4299	ch = ScmStreamGetCh(pStrmInput);
4300	if (ch == '/')
4301	return RTEXITCODE_SUCCESS;
4302	}
4303	}
4304	return vbcppError(pThis, "Expected '*/'");
4305	}
4306
4307
4308	static RTEXITCODE vbcppExtractQuotedString(PVBCPP pThis, PSCMSTREAM pStrmInput, PVBCPPSTRBUF pStrBuf,
4309	char chOpen, char chClose)
4310	{
4311	unsigned ch = ScmStreamGetCh(pStrmInput);
4312	Assert(ch == (unsigned)chOpen);
4313
4314	RTEXITCODE rcExit = vbcppStrBufAppendCh(pStrBuf, chOpen);
4315	if (rcExit != RTEXITCODE_SUCCESS)
4316	return rcExit;
4317
4318	for (;;)
4319	{
4320	ch = ScmStreamGetCh(pStrmInput);
4321	if (ch == '\\')
4322	{
4323	ch = ScmStreamGetCh(pStrmInput);
4324	if (ch == ~(unsigned)0)
4325	break;
4326	rcExit = vbcppStrBufAppendCh(pStrBuf, '\\');
4327	if (rcExit == RTEXITCODE_SUCCESS)
4328	rcExit = vbcppStrBufAppendCh(pStrBuf, ch);
4329	if (rcExit != RTEXITCODE_SUCCESS)
4330	return rcExit;
4331	}
4332	else if (ch != ~(unsigned)0)
4333	{
4334	rcExit = vbcppStrBufAppendCh(pStrBuf, ch);
4335	if (rcExit != RTEXITCODE_SUCCESS)
4336	return rcExit;
4337	if (ch == (unsigned)chClose)
4338	return RTEXITCODE_SUCCESS;
4339	}
4340	else
4341	break;
4342	}
4343
4344	return vbcppError(pThis, "File ended with an open character constant");
4345	}
4346
4347
4348	/**
4349	* Extracts a line from the stream, stripping it for comments and maybe
4350	* optimzing some of the whitespace.
4351	*
4352	* @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
4353	* @param pThis The C preprocessor instance.
4354	* @param pStrmInput The input stream.
4355	* @param pStrBuf Where to store the extracted line. Caller must
4356	* initialize this prior to the call an delete it
4357	* after use (even on failure).
4358	* @param poffComment Where to note down the position of the final
4359	* comment. Optional.
4360	*/
4361	static RTEXITCODE vbcppExtractDirectiveLine(PVBCPP pThis, PSCMSTREAM pStrmInput, PVBCPPSTRBUF pStrBuf, size_t *poffComment)
4362	{
4363	size_t offComment = ~(size_t)0;
4364	unsigned ch;
4365	while ((ch = ScmStreamPeekCh(pStrmInput)) != ~(unsigned)0)
4366	{
4367	RTEXITCODE rcExit;
4368	if (ch == '/')
4369	{
4370	/* Comment? */
4371	unsigned ch2 = ScmStreamGetCh(pStrmInput); Assert(ch == ch2);
4372	ch = ScmStreamPeekCh(pStrmInput);
4373	if (ch == '*')
4374	{
4375	offComment = ScmStreamTell(pStrmInput) - 1;
4376	rcExit = vbcppExtractSkipComment(pThis, pStrmInput);
4377	}
4378	else if (ch == '/')
4379	{
4380	offComment = ScmStreamTell(pStrmInput) - 1;
4381	rcExit = vbcppExtractSkipCommentLine(pThis, pStrmInput);
4382	}
4383	else
4384	rcExit = vbcppStrBufAppendCh(pStrBuf, '/');
4385	}
4386	else if (ch == '\'')
4387	{
4388	offComment = ~(size_t)0;
4389	rcExit = vbcppExtractQuotedString(pThis, pStrmInput, pStrBuf, '\'', '\'');
4390	}
4391	else if (ch == '"')
4392	{
4393	offComment = ~(size_t)0;
4394	rcExit = vbcppExtractQuotedString(pThis, pStrmInput, pStrBuf, '"', '"');
4395	}
4396	else if (ch == '\r' \|\| ch == '\n')
4397	break; /* done */
4398	else if ( RT_C_IS_SPACE(ch)
4399	&& ( RT_C_IS_SPACE(vbcppStrBufLastCh(pStrBuf))
4400	\|\| vbcppStrBufLastCh(pStrBuf) == '\0') )
4401	{
4402	unsigned ch2 = ScmStreamGetCh(pStrmInput);
4403	Assert(ch == ch2);
4404	rcExit = RTEXITCODE_SUCCESS;
4405	}
4406	else
4407	{
4408	unsigned ch2 = ScmStreamGetCh(pStrmInput); Assert(ch == ch2);
4409
4410	/* Escaped newline? */
4411	if ( ch == '\\'
4412	&& ( (ch2 = ScmStreamPeekCh(pStrmInput)) == '\r'
4413	\|\| ch2 == '\n'))
4414	{
4415	ScmStreamSeekByLine(pStrmInput, ScmStreamTellLine(pStrmInput) + 1);
4416	rcExit = RTEXITCODE_SUCCESS;
4417	}
4418	else
4419	{
4420	offComment = ~(size_t)0;
4421	rcExit = vbcppStrBufAppendCh(pStrBuf, ch);
4422	}
4423	}
4424	if (rcExit != RTEXITCODE_SUCCESS)
4425	return rcExit;
4426	}
4427
4428	if (poffComment)
4429	*poffComment = offComment;
4430	return RTEXITCODE_SUCCESS;
4431	}
4432
4433
4434	/**
4435	* Processes a abbreviated line number directive.
4436	*
4437	* @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
4438	* @param pThis The C preprocessor instance.
4439	* @param pStrmInput The input stream.
4440	* @param offStart The stream position where the directive
4441	* started (for pass thru).
4442	* @param enmKind The kind of directive we're processing.
4443	*/
4444	static RTEXITCODE vbcppDirectiveIfOrElif(PVBCPP pThis, PSCMSTREAM pStrmInput, size_t offStart,
4445	VBCPPCONDKIND enmKind)
4446	{
4447	/*
4448	* Check for missing #if if #elif.
4449	*/
4450	if ( enmKind == kVBCppCondKind_ElIf
4451	&& !pThis->pCondStack )
4452	return vbcppError(pThis, "#elif without #if");
4453
4454	/*
4455	* Extract the expression string.
4456	*/
4457	const char *pchCondition = ScmStreamGetCur(pStrmInput);
4458	size_t offComment;
4459	VBCPPMACROEXP ExpCtx;
4460	#if 0
4461	ExpCtx.pMacroStack = NULL;
4462	#endif
4463	ExpCtx.pStrmInput = NULL;
4464	ExpCtx.papszArgs = NULL;
4465	ExpCtx.cArgs = 0;
4466	ExpCtx.cArgsAlloced = 0;
4467	vbcppStrBufInit(&ExpCtx.StrBuf, pThis);
4468	RTEXITCODE rcExit = vbcppExtractDirectiveLine(pThis, pStrmInput, &ExpCtx.StrBuf, &offComment);
4469	if (rcExit == RTEXITCODE_SUCCESS)
4470	{
4471	size_t const cchCondition = ScmStreamGetCur(pStrmInput) - pchCondition;
4472
4473	/*
4474	* Expand known macros in it.
4475	*/
4476	size_t cReplacements;
4477	rcExit = vbcppMacroExpandReScan(pThis, &ExpCtx, kMacroReScanMode_Expression, &cReplacements);
4478	if (rcExit == RTEXITCODE_SUCCESS)
4479	{
4480	/*
4481	* Strip it and check that it's not empty.
4482	*/
4483	char *pszExpr = ExpCtx.StrBuf.pszBuf;
4484	size_t cchExpr = ExpCtx.StrBuf.cchBuf;
4485	while (cchExpr > 0 && RT_C_IS_SPACE(*pszExpr))
4486	pszExpr++, cchExpr--;
4487
4488	while (cchExpr > 0 && RT_C_IS_SPACE(pszExpr[cchExpr - 1]))
4489	{
4490	pszExpr[--cchExpr] = '\0';
4491	ExpCtx.StrBuf.cchBuf--;
4492	}
4493	if (cchExpr)
4494	{
4495	/*
4496	* Now, evalute the expression.
4497	*/
4498	VBCPPEVAL enmResult;
4499	rcExit = vbcppExprEval(pThis, pszExpr, cchExpr, cReplacements, &enmResult);
4500	if (rcExit == RTEXITCODE_SUCCESS)
4501	{
4502	/*
4503	* Take action.
4504	*/
4505	if (enmKind != kVBCppCondKind_ElIf)
4506	rcExit = vbcppCondPush(pThis, pStrmInput, offComment, enmKind, enmResult,
4507	pchCondition, cchCondition);
4508	else
4509	{
4510	PVBCPPCOND pCond = pThis->pCondStack;
4511	if ( pCond->enmResult != kVBCppEval_Undecided
4512	&& ( !pCond->pUp
4513	\|\| pCond->pUp->enmStackResult == kVBCppEval_True))
4514	{
4515	Assert(enmResult == kVBCppEval_True \|\| enmResult == kVBCppEval_False);
4516	if ( pCond->enmResult == kVBCppEval_False
4517	&& enmResult == kVBCppEval_True
4518	&& !pCond->fElIfDecided)
4519	{
4520	pCond->enmStackResult = kVBCppEval_True;
4521	pCond->fElIfDecided = true;
4522	}
4523	else
4524	pCond->enmStackResult = kVBCppEval_False;
4525	pThis->fIf0Mode = pCond->enmStackResult == kVBCppEval_False;
4526	}
4527	pCond->enmKind = kVBCppCondKind_ElIf;
4528	pCond->enmResult = enmResult;
4529	pCond->pchCond = pchCondition;
4530	pCond->cchCond = cchCondition;
4531
4532	/*
4533	* Do #elif pass thru.
4534	*/
4535	if ( !pThis->fIf0Mode
4536	&& pCond->enmResult == kVBCppEval_Undecided)
4537	{
4538	ssize_t cch = ScmStreamPrintf(&pThis->StrmOutput, "#%*selif", pCond->iKeepLevel - 1, "");
4539	if (cch > 0)
4540	rcExit = vbcppOutputComment(pThis, pStrmInput, offStart, cch, 2);
4541	else
4542	rcExit = vbcppError(pThis, "Output error %Rrc", (int)cch);
4543	}
4544	else
4545	pThis->fJustDroppedLine = true;
4546	}
4547	}
4548	}
4549	else
4550	rcExit = vbcppError(pThis, "Empty #if expression");
4551	}
4552	}
4553	vbcppMacroExpandCleanup(&ExpCtx);
4554	return rcExit;
4555	}
4556
4557
4558	/**
4559	* Processes a abbreviated line number directive.
4560	*
4561	* @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
4562	* @param pThis The C preprocessor instance.
4563	* @param pStrmInput The input stream.
4564	* @param offStart The stream position where the directive
4565	* started (for pass thru).
4566	*/
4567	static RTEXITCODE vbcppDirectiveIfDef(PVBCPP pThis, PSCMSTREAM pStrmInput, size_t offStart)
4568	{
4569	/*
4570	* Parse it.
4571	*/
4572	RTEXITCODE rcExit = vbcppProcessSkipWhiteEscapedEolAndComments(pThis, pStrmInput);
4573	if (rcExit == RTEXITCODE_SUCCESS)
4574	{
4575	size_t cchDefine;
4576	const char *pchDefine = ScmStreamCGetWord(pStrmInput, &cchDefine);
4577	if (pchDefine)
4578	{
4579	rcExit = vbcppProcessSkipWhiteEscapedEolAndCommentsCheckEol(pThis, pStrmInput);
4580	if (rcExit == RTEXITCODE_SUCCESS)
4581	{
4582	/*
4583	* Evaluate it.
4584	*/
4585	VBCPPEVAL enmEval;
4586	if (vbcppMacroExists(pThis, pchDefine, cchDefine))
4587	enmEval = kVBCppEval_True;
4588	else if ( !pThis->fUndecidedConditionals
4589	\|\| RTStrSpaceGetN(&pThis->UndefStrSpace, pchDefine, cchDefine) != NULL)
4590	enmEval = kVBCppEval_False;
4591	else
4592	enmEval = kVBCppEval_Undecided;
4593	rcExit = vbcppCondPush(pThis, pStrmInput, offStart, kVBCppCondKind_IfDef, enmEval,
4594	pchDefine, cchDefine);
4595	}
4596	}
4597	else
4598	rcExit = vbcppError(pThis, "Malformed #ifdef");
4599	}
4600	return rcExit;
4601	}
4602
4603
4604	/**
4605	* Processes a abbreviated line number directive.
4606	*
4607	* @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
4608	* @param pThis The C preprocessor instance.
4609	* @param pStrmInput The input stream.
4610	* @param offStart The stream position where the directive
4611	* started (for pass thru).
4612	*/
4613	static RTEXITCODE vbcppDirectiveIfNDef(PVBCPP pThis, PSCMSTREAM pStrmInput, size_t offStart)
4614	{
4615	/*
4616	* Parse it.
4617	*/
4618	RTEXITCODE rcExit = vbcppProcessSkipWhiteEscapedEolAndComments(pThis, pStrmInput);
4619	if (rcExit == RTEXITCODE_SUCCESS)
4620	{
4621	size_t cchDefine;
4622	const char *pchDefine = ScmStreamCGetWord(pStrmInput, &cchDefine);
4623	if (pchDefine)
4624	{
4625	rcExit = vbcppProcessSkipWhiteEscapedEolAndCommentsCheckEol(pThis, pStrmInput);
4626	if (rcExit == RTEXITCODE_SUCCESS)
4627	{
4628	/*
4629	* Evaluate it.
4630	*/
4631	VBCPPEVAL enmEval;
4632	if (vbcppMacroExists(pThis, pchDefine, cchDefine))
4633	enmEval = kVBCppEval_False;
4634	else if ( !pThis->fUndecidedConditionals
4635	\|\| RTStrSpaceGetN(&pThis->UndefStrSpace, pchDefine, cchDefine) != NULL)
4636	enmEval = kVBCppEval_True;
4637	else
4638	enmEval = kVBCppEval_Undecided;
4639	rcExit = vbcppCondPush(pThis, pStrmInput, offStart, kVBCppCondKind_IfNDef, enmEval,
4640	pchDefine, cchDefine);
4641	}
4642	}
4643	else
4644	rcExit = vbcppError(pThis, "Malformed #ifndef");
4645	}
4646	return rcExit;
4647	}
4648
4649
4650	/**
4651	* Processes a abbreviated line number directive.
4652	*
4653	* @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
4654	* @param pThis The C preprocessor instance.
4655	* @param pStrmInput The input stream.
4656	* @param offStart The stream position where the directive
4657	* started (for pass thru).
4658	*/
4659	static RTEXITCODE vbcppDirectiveElse(PVBCPP pThis, PSCMSTREAM pStrmInput, size_t offStart)
4660	{
4661	/*
4662	* Nothing to parse, just comment positions to find and note down.
4663	*/
4664	offStart = vbcppProcessSkipWhite(pStrmInput);
4665	RTEXITCODE rcExit = vbcppProcessSkipWhiteEscapedEolAndCommentsCheckEol(pThis, pStrmInput);
4666	if (rcExit == RTEXITCODE_SUCCESS)
4667	{
4668	/*
4669	* Execute.
4670	*/
4671	PVBCPPCOND pCond = pThis->pCondStack;
4672	if (pCond)
4673	{
4674	if (!pCond->fSeenElse)
4675	{
4676	pCond->fSeenElse = true;
4677	if ( pCond->enmResult != kVBCppEval_Undecided
4678	&& ( !pCond->pUp
4679	\|\| pCond->pUp->enmStackResult == kVBCppEval_True))
4680	{
4681	if ( pCond->enmResult == kVBCppEval_True
4682	\|\| pCond->fElIfDecided)
4683
4684	pCond->enmStackResult = kVBCppEval_False;
4685	else
4686	pCond->enmStackResult = kVBCppEval_True;
4687	pThis->fIf0Mode = pCond->enmStackResult == kVBCppEval_False;
4688	}
4689
4690	/*
4691	* Do pass thru.
4692	*/
4693	if ( !pThis->fIf0Mode
4694	&& pCond->enmResult == kVBCppEval_Undecided)
4695	{
4696	ssize_t cch = ScmStreamPrintf(&pThis->StrmOutput, "#%*selse", pCond->iKeepLevel - 1, "");
4697	if (cch > 0)
4698	rcExit = vbcppOutputComment(pThis, pStrmInput, offStart, cch, 2);
4699	else
4700	rcExit = vbcppError(pThis, "Output error %Rrc", (int)cch);
4701	}
4702	else
4703	pThis->fJustDroppedLine = true;
4704	}
4705	else
4706	rcExit = vbcppError(pThis, "Double #else or/and missing #endif");
4707	}
4708	else
4709	rcExit = vbcppError(pThis, "#else without #if");
4710	}
4711	return rcExit;
4712	}
4713
4714
4715	/**
4716	* Processes a abbreviated line number directive.
4717	*
4718	* @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
4719	* @param pThis The C preprocessor instance.
4720	* @param pStrmInput The input stream.
4721	* @param offStart The stream position where the directive
4722	* started (for pass thru).
4723	*/
4724	static RTEXITCODE vbcppDirectiveEndif(PVBCPP pThis, PSCMSTREAM pStrmInput, size_t offStart)
4725	{
4726	/*
4727	* Nothing to parse, just comment positions to find and note down.
4728	*/
4729	offStart = vbcppProcessSkipWhite(pStrmInput);
4730	RTEXITCODE rcExit = vbcppProcessSkipWhiteEscapedEolAndCommentsCheckEol(pThis, pStrmInput);
4731	if (rcExit == RTEXITCODE_SUCCESS)
4732	{
4733	/*
4734	* Execute.
4735	*/
4736	PVBCPPCOND pCond = pThis->pCondStack;
4737	if (pCond)
4738	{
4739	pThis->pCondStack = pCond->pUp;
4740	pThis->fIf0Mode = pCond->pUp && pCond->pUp->enmStackResult == kVBCppEval_False;
4741
4742	/*
4743	* Do pass thru.
4744	*/
4745	if ( !pThis->fIf0Mode
4746	&& pCond->enmResult == kVBCppEval_Undecided)
4747	{
4748	ssize_t cch = ScmStreamPrintf(&pThis->StrmOutput, "#%*sendif", pCond->iKeepLevel - 1, "");
4749	if (cch > 0)
4750	rcExit = vbcppOutputComment(pThis, pStrmInput, offStart, cch, 1);
4751	else
4752	rcExit = vbcppError(pThis, "Output error %Rrc", (int)cch);
4753	}
4754	else
4755	pThis->fJustDroppedLine = true;
4756	}
4757	else
4758	rcExit = vbcppError(pThis, "#endif without #if");
4759	}
4760	return rcExit;
4761	}
4762
4763
4764
4765
4766
4767	/*
4768	*
4769	*
4770	* Misc Directives
4771	* Misc Directives
4772	* Misc Directives
4773	* Misc Directives
4774	*
4775	*
4776	*/
4777
4778
4779	/**
4780	* Adds an include directory.
4781	*
4782	* @returns Program exit code, with error message on failure.
4783	* @param pThis The C preprocessor instance.
4784	* @param pszDir The directory to add.
4785	*/
4786	static RTEXITCODE vbcppAddInclude(PVBCPP pThis, const char *pszDir)
4787	{
4788	uint32_t cIncludes = pThis->cIncludes;
4789	if (cIncludes >= _64K)
4790	return vbcppError(pThis, "Too many include directories");
4791
4792	void pv = RTMemRealloc(pThis->papszIncludes, (cIncludes + 1) sizeof(char **));
4793	if (!pv)
4794	return vbcppError(pThis, "No memory for include directories");
4795	pThis->papszIncludes = (char **)pv;
4796
4797	int rc = RTStrDupEx(&pThis->papszIncludes[cIncludes], pszDir);
4798	if (RT_FAILURE(rc))
4799	return vbcppError(pThis, "No string memory for include directories");
4800
4801	pThis->cIncludes = cIncludes + 1;
4802	return RTEXITCODE_SUCCESS;
4803	}
4804
4805
4806	/**
4807	* Processes a abbreviated line number directive.
4808	*
4809	* @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
4810	* @param pThis The C preprocessor instance.
4811	* @param pStrmInput The input stream.
4812	* @param offStart The stream position where the directive
4813	* started (for pass thru).
4814	*/
4815	static RTEXITCODE vbcppDirectiveInclude(PVBCPP pThis, PSCMSTREAM pStrmInput, size_t offStart)
4816	{
4817	/*
4818	* Parse it.
4819	*/
4820	RTEXITCODE rcExit = vbcppProcessSkipWhiteEscapedEolAndComments(pThis, pStrmInput);
4821	if (rcExit == RTEXITCODE_SUCCESS)
4822	{
4823	size_t cchFileSpec = 0;
4824	const char *pchFileSpec = NULL;
4825	size_t cchFilename = 0;
4826	const char *pchFilename = NULL;
4827
4828	unsigned ch = ScmStreamPeekCh(pStrmInput);
4829	unsigned chType = ch;
4830	if (ch == '"' \|\| ch == '<')
4831	{
4832	ScmStreamGetCh(pStrmInput);
4833	pchFileSpec = pchFilename = ScmStreamGetCur(pStrmInput);
4834	unsigned chEnd = chType == '<' ? '>' : '"';
4835	unsigned chPrev = ch;
4836	while ( (ch = ScmStreamGetCh(pStrmInput)) != ~(unsigned)0
4837	&& ch != chEnd)
4838	{
4839	if (ch == '\r' \|\| ch == '\n')
4840	{
4841	rcExit = vbcppError(pThis, "Multi-line include file specfications are not supported");
4842	break;
4843	}
4844	}
4845
4846	if (rcExit == RTEXITCODE_SUCCESS)
4847	{
4848	if (ch != ~(unsigned)0)
4849	cchFileSpec = cchFilename = ScmStreamGetCur(pStrmInput) - pchFilename - 1;
4850	else
4851	rcExit = vbcppError(pThis, "Expected '%c'", chType);
4852	}
4853	}
4854	else if (vbcppIsCIdentifierLeadChar(ch))
4855	{
4856	//pchFileSpec = ScmStreamCGetWord(pStrmInput, &cchFileSpec);
4857	rcExit = vbcppError(pThis, "Including via a define is not implemented yet");
4858	}
4859	else
4860	rcExit = vbcppError(pThis, "Malformed include directive");
4861
4862	/*
4863	* Take down the location of the next non-white space, in case we need
4864	* to pass thru the directive further down. Then skip to the end of the
4865	* line.
4866	*/
4867	size_t const offIncEnd = vbcppProcessSkipWhite(pStrmInput);
4868	if (rcExit == RTEXITCODE_SUCCESS)
4869	rcExit = vbcppProcessSkipWhiteEscapedEolAndCommentsCheckEol(pThis, pStrmInput);
4870
4871	if (rcExit == RTEXITCODE_SUCCESS)
4872	{
4873	/*
4874	* Execute it.
4875	*/
4876	if (pThis->enmIncludeAction == kVBCppIncludeAction_Include)
4877	{
4878	/** @todo Search for the include file and push it onto the input stack.
4879	* Not difficult, just unnecessary rigth now. */
4880	rcExit = vbcppError(pThis, "Includes are fully implemented");
4881	}
4882	else if (pThis->enmIncludeAction == kVBCppIncludeAction_PassThru)
4883	{
4884	/* Pretty print the passthru. */
4885	unsigned cchIndent = pThis->pCondStack ? pThis->pCondStack->iKeepLevel : 0;
4886	ssize_t cch;
4887	if (chType == '<')
4888	cch = ScmStreamPrintf(&pThis->StrmOutput, "#%sinclude <%.s>",
4889	cchIndent, "", cchFileSpec, pchFileSpec);
4890	else if (chType == '"')
4891	cch = ScmStreamPrintf(&pThis->StrmOutput, "#%sinclude \"%.s\"",
4892	cchIndent, "", cchFileSpec, pchFileSpec);
4893	else
4894	cch = ScmStreamPrintf(&pThis->StrmOutput, "#%sinclude %.s",
4895	cchIndent, "", cchFileSpec, pchFileSpec);
4896	if (cch > 0)
4897	rcExit = vbcppOutputComment(pThis, pStrmInput, offIncEnd, cch, 1);
4898	else
4899	rcExit = vbcppError(pThis, "Output error %Rrc", (int)cch);
4900
4901	}
4902	else
4903	{
4904	Assert(pThis->enmIncludeAction == kVBCppIncludeAction_Drop);
4905	pThis->fJustDroppedLine = true;
4906	}
4907	}
4908	}
4909	return rcExit;
4910	}
4911
4912
4913	/**
4914	* Processes a abbreviated line number directive.
4915	*
4916	* @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
4917	* @param pThis The C preprocessor instance.
4918	* @param pStrmInput The input stream.
4919	* @param offStart The stream position where the directive
4920	* started (for pass thru).
4921	*/
4922	static RTEXITCODE vbcppDirectivePragma(PVBCPP pThis, PSCMSTREAM pStrmInput, size_t offStart)
4923	{
4924	/*
4925	* Parse out the first word.
4926	*/
4927	RTEXITCODE rcExit = vbcppProcessSkipWhiteEscapedEolAndComments(pThis, pStrmInput);
4928	if (rcExit == RTEXITCODE_SUCCESS)
4929	{
4930	size_t cchPragma;
4931	const char *pchPragma = ScmStreamCGetWord(pStrmInput, &cchPragma);
4932	if (pchPragma)
4933	{
4934	size_t const off2nd = vbcppProcessSkipWhite(pStrmInput);
4935	size_t offComment;
4936	rcExit = vbcppInputSkipToEndOfDirectiveLine(pThis, pStrmInput, &offComment);
4937	if (rcExit == RTEXITCODE_SUCCESS)
4938	{
4939	/*
4940	* What to do about this
4941	*/
4942	bool fPassThru = false;
4943	if ( cchPragma == 1
4944	&& *pchPragma == 'D')
4945	fPassThru = pThis->fPassThruPragmaD;
4946	else if ( cchPragma == 3
4947	&& !strncmp(pchPragma, "STD", 3))
4948	fPassThru = pThis->fPassThruPragmaSTD;
4949	else
4950	fPassThru = pThis->fPassThruPragmaOther;
4951	if (fPassThru)
4952	{
4953	unsigned cchIndent = pThis->pCondStack ? pThis->pCondStack->iKeepLevel : 0;
4954	ssize_t cch = ScmStreamPrintf(&pThis->StrmOutput, "#%spragma %.s",
4955	cchIndent, "", cchPragma, pchPragma);
4956	if (cch > 0)
4957	rcExit = vbcppOutputComment(pThis, pStrmInput, off2nd, cch, 1);
4958	else
4959	rcExit = vbcppError(pThis, "output error");
4960	}
4961	else
4962	pThis->fJustDroppedLine = true;
4963	}
4964	}
4965	else
4966	rcExit = vbcppError(pThis, "Malformed #pragma");
4967	}
4968
4969	return rcExit;
4970	}
4971
4972
4973	/**
4974	* Processes an error directive.
4975	*
4976	* @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
4977	* @param pThis The C preprocessor instance.
4978	* @param pStrmInput The input stream.
4979	* @param offStart The stream position where the directive
4980	* started (for pass thru).
4981	*/
4982	static RTEXITCODE vbcppDirectiveError(PVBCPP pThis, PSCMSTREAM pStrmInput, size_t offStart)
4983	{
4984	return vbcppError(pThis, "Hit an #error");
4985	}
4986
4987
4988	/**
4989	* Processes a abbreviated line number directive.
4990	*
4991	* @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
4992	* @param pThis The C preprocessor instance.
4993	* @param pStrmInput The input stream.
4994	* @param offStart The stream position where the directive
4995	* started (for pass thru).
4996	*/
4997	static RTEXITCODE vbcppDirectiveLineNo(PVBCPP pThis, PSCMSTREAM pStrmInput, size_t offStart)
4998	{
4999	return vbcppError(pThis, "Not implemented: %s", __FUNCTION__);
5000	}
5001
5002
5003	/**
5004	* Processes a abbreviated line number directive.
5005	*
5006	* @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
5007	* @param pThis The C preprocessor instance.
5008	* @param pStrmInput The input stream.
5009	*/
5010	static RTEXITCODE vbcppDirectiveLineNoShort(PVBCPP pThis, PSCMSTREAM pStrmInput)
5011	{
5012	return vbcppError(pThis, "Not implemented: %s", __FUNCTION__);
5013	}
5014
5015
5016	/**
5017	* Handles a preprocessor directive.
5018	*
5019	* @returns RTEXITCODE_SUCCESS or RTEXITCODE_FAILURE+msg.
5020	* @param pThis The C preprocessor instance.
5021	* @param pStrmInput The input stream.
5022	*/
5023	static RTEXITCODE vbcppProcessDirective(PVBCPP pThis, PSCMSTREAM pStrmInput)
5024	{
5025	/*
5026	* Get the directive and do a string switch on it.
5027	*/
5028	RTEXITCODE rcExit = vbcppProcessSkipWhiteEscapedEolAndComments(pThis, pStrmInput);
5029	if (rcExit != RTEXITCODE_SUCCESS)
5030	return rcExit;
5031	size_t cchDirective;
5032	const char *pchDirective = ScmStreamCGetWord(pStrmInput, &cchDirective);
5033	if (pchDirective)
5034	{
5035	size_t const offStart = ScmStreamTell(pStrmInput);
5036	#define IS_DIRECTIVE(a_sz) ( sizeof(a_sz) - 1 == cchDirective && strncmp(pchDirective, a_sz, sizeof(a_sz) - 1) == 0)
5037	if (IS_DIRECTIVE("if"))
5038	rcExit = vbcppDirectiveIfOrElif(pThis, pStrmInput, offStart, kVBCppCondKind_If);
5039	else if (IS_DIRECTIVE("elif"))
5040	rcExit = vbcppDirectiveIfOrElif(pThis, pStrmInput, offStart, kVBCppCondKind_ElIf);
5041	else if (IS_DIRECTIVE("ifdef"))
5042	rcExit = vbcppDirectiveIfDef(pThis, pStrmInput, offStart);
5043	else if (IS_DIRECTIVE("ifndef"))
5044	rcExit = vbcppDirectiveIfNDef(pThis, pStrmInput, offStart);
5045	else if (IS_DIRECTIVE("else"))
5046	rcExit = vbcppDirectiveElse(pThis, pStrmInput, offStart);
5047	else if (IS_DIRECTIVE("endif"))
5048	rcExit = vbcppDirectiveEndif(pThis, pStrmInput, offStart);
5049	else if (!pThis->fIf0Mode)
5050	{
5051	if (IS_DIRECTIVE("include"))
5052	rcExit = vbcppDirectiveInclude(pThis, pStrmInput, offStart);
5053	else if (IS_DIRECTIVE("define"))
5054	rcExit = vbcppDirectiveDefine(pThis, pStrmInput, offStart);
5055	else if (IS_DIRECTIVE("undef"))
5056	rcExit = vbcppDirectiveUndef(pThis, pStrmInput, offStart);
5057	else if (IS_DIRECTIVE("pragma"))
5058	rcExit = vbcppDirectivePragma(pThis, pStrmInput, offStart);
5059	else if (IS_DIRECTIVE("error"))
5060	rcExit = vbcppDirectiveError(pThis, pStrmInput, offStart);
5061	else if (IS_DIRECTIVE("line"))
5062	rcExit = vbcppDirectiveLineNo(pThis, pStrmInput, offStart);
5063	else
5064	rcExit = vbcppError(pThis, "Unknown preprocessor directive '#%.*s'", cchDirective, pchDirective);
5065	}
5066	#undef IS_DIRECTIVE
5067	}
5068	else if (!pThis->fIf0Mode)
5069	{
5070	/* Could it be a # <num> "file" directive? */
5071	unsigned ch = ScmStreamPeekCh(pStrmInput);
5072	if (RT_C_IS_DIGIT(ch))
5073	rcExit = vbcppDirectiveLineNoShort(pThis, pStrmInput);
5074	else
5075	rcExit = vbcppError(pThis, "Malformed preprocessor directive");
5076	}
5077	return rcExit;
5078	}
5079
5080
5081	/*
5082	*
5083	*
5084	* M a i n b o d y.
5085	* M a i n b o d y.
5086	* M a i n b o d y.
5087	* M a i n b o d y.
5088	* M a i n b o d y.
5089	*
5090	*
5091	*/
5092
5093
5094	/**
5095	* Does the actually preprocessing of the input file.
5096	*
5097	* @returns Exit code.
5098	* @param pThis The C preprocessor instance.
5099	*/
5100	static RTEXITCODE vbcppPreprocess(PVBCPP pThis)
5101	{
5102	RTEXITCODE rcExit = RTEXITCODE_SUCCESS;
5103
5104	/*
5105	* Parse.
5106	*/
5107	while (pThis->pInputStack)
5108	{
5109	pThis->fMaybePreprocessorLine = true;
5110
5111	PSCMSTREAM pStrmInput = &pThis->pInputStack->StrmInput;
5112	unsigned ch;
5113	while ((ch = ScmStreamGetCh(pStrmInput)) != ~(unsigned)0)
5114	{
5115	if (ch == '/')
5116	{
5117	ch = ScmStreamPeekCh(pStrmInput);
5118	if (ch == '*')
5119	rcExit = vbcppProcessMultiLineComment(pThis, pStrmInput);
5120	else if (ch == '/')
5121	rcExit = vbcppProcessOneLineComment(pThis, pStrmInput);
5122	else
5123	{
5124	pThis->fMaybePreprocessorLine = false;
5125	if (!pThis->fIf0Mode)
5126	rcExit = vbcppOutputCh(pThis, '/');
5127	}
5128	}
5129	else if (ch == '#' && pThis->fMaybePreprocessorLine)
5130	{
5131	rcExit = vbcppProcessDirective(pThis, pStrmInput);
5132	pStrmInput = &pThis->pInputStack->StrmInput;
5133	}
5134	else if (ch == '\r' \|\| ch == '\n')
5135	{
5136	if ( ( !pThis->fIf0Mode
5137	&& !pThis->fJustDroppedLine)
5138	\|\| !pThis->fRemoveDroppedLines
5139	\|\| !ScmStreamIsAtStartOfLine(&pThis->StrmOutput))
5140	rcExit = vbcppOutputCh(pThis, ch);
5141	pThis->fJustDroppedLine = false;
5142	pThis->fMaybePreprocessorLine = true;
5143	}
5144	else if (RT_C_IS_SPACE(ch))
5145	{
5146	if (!pThis->fIf0Mode)
5147	rcExit = vbcppOutputCh(pThis, ch);
5148	}
5149	else
5150	{
5151	pThis->fMaybePreprocessorLine = false;
5152	if (!pThis->fIf0Mode)
5153	{
5154	if (ch == '"')
5155	rcExit = vbcppProcessStringLitteral(pThis, pStrmInput);
5156	else if (ch == '\'')
5157	rcExit = vbcppProcessCharacterConstant(pThis, pStrmInput);
5158	else if (vbcppIsCIdentifierLeadChar(ch))
5159	rcExit = vbcppProcessIdentifier(pThis, pStrmInput, ch);
5160	else if (RT_C_IS_DIGIT(ch))
5161	rcExit = vbcppProcessNumber(pThis, pStrmInput, ch);
5162	else
5163	rcExit = vbcppOutputCh(pThis, ch);
5164	}
5165	}
5166	if (rcExit != RTEXITCODE_SUCCESS)
5167	break;
5168	}
5169
5170	/*
5171	* Check for errors.
5172	*/
5173	if (rcExit != RTEXITCODE_SUCCESS)
5174	break;
5175
5176	/*
5177	* Pop the input stack.
5178	*/
5179	PVBCPPINPUT pPopped = pThis->pInputStack;
5180	pThis->pInputStack = pPopped->pUp;
5181	RTMemFree(pPopped);
5182	}
5183
5184	return rcExit;
5185	}
5186
5187
5188	/**
5189	* Opens the input and output streams.
5190	*
5191	* @returns Exit code.
5192	* @param pThis The C preprocessor instance.
5193	*/
5194	static RTEXITCODE vbcppOpenStreams(PVBCPP pThis)
5195	{
5196	if (!pThis->pszInput)
5197	return vbcppError(pThis, "Preprocessing the standard input stream is currently not supported");
5198
5199	size_t cchName = strlen(pThis->pszInput);
5200	PVBCPPINPUT pInput = (PVBCPPINPUT)RTMemAlloc(RT_OFFSETOF(VBCPPINPUT, szName[cchName + 1]));
5201	if (!pInput)
5202	return vbcppError(pThis, "out of memory");
5203	pInput->pUp = pThis->pInputStack;
5204	pInput->pszSpecified = pInput->szName;
5205	memcpy(pInput->szName, pThis->pszInput, cchName + 1);
5206	pThis->pInputStack = pInput;
5207	int rc = ScmStreamInitForReading(&pInput->StrmInput, pThis->pszInput);
5208	if (RT_FAILURE(rc))
5209	return vbcppError(pThis, "ScmStreamInitForReading returned %Rrc when opening input file (%s)",
5210	rc, pThis->pszInput);
5211
5212	rc = ScmStreamInitForWriting(&pThis->StrmOutput, &pInput->StrmInput);
5213	if (RT_FAILURE(rc))
5214	return vbcppError(pThis, "ScmStreamInitForWriting returned %Rrc", rc);
5215
5216	pThis->fStrmOutputValid = true;
5217	return RTEXITCODE_SUCCESS;
5218	}
5219
5220
5221	/**
5222	* Changes the preprocessing mode.
5223	*
5224	* @param pThis The C preprocessor instance.
5225	* @param enmMode The new mode.
5226	*/
5227	static void vbcppSetMode(PVBCPP pThis, VBCPPMODE enmMode)
5228	{
5229	switch (enmMode)
5230	{
5231	case kVBCppMode_Standard:
5232	pThis->fKeepComments = false;
5233	pThis->fRespectSourceDefines = true;
5234	pThis->fAllowRedefiningCmdLineDefines = true;
5235	pThis->fPassThruDefines = false;
5236	pThis->fUndecidedConditionals = false;
5237	pThis->fPassThruPragmaD = false;
5238	pThis->fPassThruPragmaSTD = true;
5239	pThis->fPassThruPragmaOther = true;
5240	pThis->fRemoveDroppedLines = false;
5241	pThis->fLineSplicing = true;
5242	pThis->enmIncludeAction = kVBCppIncludeAction_Include;
5243	break;
5244
5245	case kVBCppMode_Selective:
5246	pThis->fKeepComments = true;
5247	pThis->fRespectSourceDefines = false;
5248	pThis->fAllowRedefiningCmdLineDefines = false;
5249	pThis->fPassThruDefines = true;
5250	pThis->fUndecidedConditionals = true;
5251	pThis->fPassThruPragmaD = true;
5252	pThis->fPassThruPragmaSTD = true;
5253	pThis->fPassThruPragmaOther = true;
5254	pThis->fRemoveDroppedLines = true;
5255	pThis->fLineSplicing = false;
5256	pThis->enmIncludeAction = kVBCppIncludeAction_PassThru;
5257	break;
5258
5259	case kVBCppMode_SelectiveD:
5260	pThis->fKeepComments = true;
5261	pThis->fRespectSourceDefines = true;
5262	pThis->fAllowRedefiningCmdLineDefines = false;
5263	pThis->fPassThruDefines = false;
5264	pThis->fUndecidedConditionals = false;
5265	pThis->fPassThruPragmaD = true;
5266	pThis->fPassThruPragmaSTD = false;
5267	pThis->fPassThruPragmaOther = false;
5268	pThis->fRemoveDroppedLines = true;
5269	pThis->fLineSplicing = false;
5270	pThis->enmIncludeAction = kVBCppIncludeAction_Drop;
5271	break;
5272
5273	default:
5274	AssertFailedReturnVoid();
5275	}
5276	pThis->enmMode = enmMode;
5277	}
5278
5279
5280	/**
5281	* Parses the command line options.
5282	*
5283	* @returns Program exit code. Exit on non-success or if *pfExit is set.
5284	* @param pThis The C preprocessor instance.
5285	* @param argc The argument count.
5286	* @param argv The argument vector.
5287	* @param pfExit Pointer to the exit indicator.
5288	*/
5289	static RTEXITCODE vbcppParseOptions(PVBCPP pThis, int argc, char *argv, bool pfExit)
5290	{
5291	RTEXITCODE rcExit;
5292
5293	*pfExit = false;
5294
5295	/*
5296	* Option config.
5297	*/
5298	static RTGETOPTDEF const s_aOpts[] =
5299	{
5300	{ "--define", 'D', RTGETOPT_REQ_STRING },
5301	{ "--include-dir", 'I', RTGETOPT_REQ_STRING },
5302	{ "--undefine", 'U', RTGETOPT_REQ_STRING },
5303	{ "--keep-comments", 'C', RTGETOPT_REQ_NOTHING },
5304	{ "--strip-comments", 'c', RTGETOPT_REQ_NOTHING },
5305	{ "--D-strip", 'd', RTGETOPT_REQ_NOTHING },
5306	};
5307
5308	RTGETOPTUNION ValueUnion;
5309	RTGETOPTSTATE GetOptState;
5310	int rc = RTGetOptInit(&GetOptState, argc, argv, &s_aOpts[0], RT_ELEMENTS(s_aOpts), 1, RTGETOPTINIT_FLAGS_OPTS_FIRST);
5311	AssertReleaseRCReturn(rc, RTEXITCODE_FAILURE);
5312
5313	/*
5314	* Process the options.
5315	*/
5316	while ((rc = RTGetOpt(&GetOptState, &ValueUnion)) != 0)
5317	{
5318	switch (rc)
5319	{
5320	case 'c':
5321	pThis->fKeepComments = false;
5322	break;
5323
5324	case 'C':
5325	pThis->fKeepComments = false;
5326	break;
5327
5328	case 'd':
5329	vbcppSetMode(pThis, kVBCppMode_SelectiveD);
5330	break;
5331
5332	case 'D':
5333	{
5334	const char *pszEqual = strchr(ValueUnion.psz, '=');
5335	if (pszEqual)
5336	rcExit = vbcppMacroAdd(pThis, ValueUnion.psz, pszEqual - ValueUnion.psz, pszEqual + 1, RTSTR_MAX, true);
5337	else
5338	rcExit = vbcppMacroAdd(pThis, ValueUnion.psz, RTSTR_MAX, "1", 1, true);
5339	if (rcExit != RTEXITCODE_SUCCESS)
5340	return rcExit;
5341	break;
5342	}
5343
5344	case 'I':
5345	rcExit = vbcppAddInclude(pThis, ValueUnion.psz);
5346	if (rcExit != RTEXITCODE_SUCCESS)
5347	return rcExit;
5348	break;
5349
5350	case 'U':
5351	rcExit = vbcppMacroUndef(pThis, ValueUnion.psz, RTSTR_MAX, true);
5352	break;
5353
5354	case 'h':
5355	RTPrintf("No help yet, sorry\n");
5356	*pfExit = true;
5357	return RTEXITCODE_SUCCESS;
5358
5359	case 'V':
5360	{
5361	/* The following is assuming that svn does it's job here. */
5362	static const char s_szRev[] = "$Revision: 41359 $";
5363	const char *psz = RTStrStripL(strchr(s_szRev, ' '));
5364	RTPrintf("r%.*s\n", strchr(psz, ' ') - psz, psz);
5365	*pfExit = true;
5366	return RTEXITCODE_SUCCESS;
5367	}
5368
5369	case VINF_GETOPT_NOT_OPTION:
5370	if (!pThis->pszInput)
5371	pThis->pszInput = ValueUnion.psz;
5372	else if (!pThis->pszOutput)
5373	pThis->pszOutput = ValueUnion.psz;
5374	else
5375	return RTMsgErrorExit(RTEXITCODE_SYNTAX, "too many file arguments");
5376	break;
5377
5378
5379	/*
5380	* Errors and bugs.
5381	*/
5382	default:
5383	return RTGetOptPrintError(rc, &ValueUnion);
5384	}
5385	}
5386
5387	return RTEXITCODE_SUCCESS;
5388	}
5389
5390
5391	/**
5392	* Terminates the preprocessor.
5393	*
5394	* This may return failure if an error was delayed.
5395	*
5396	* @returns Exit code.
5397	* @param pThis The C preprocessor instance.
5398	*/
5399	static RTEXITCODE vbcppTerm(PVBCPP pThis)
5400	{
5401	/*
5402	* Flush the output first.
5403	*/
5404	if (pThis->fStrmOutputValid)
5405	{
5406	if (pThis->pszOutput)
5407	{
5408	int rc = ScmStreamWriteToFile(&pThis->StrmOutput, "%s", pThis->pszOutput);
5409	if (RT_FAILURE(rc))
5410	vbcppError(pThis, "ScmStreamWriteToFile failed with %Rrc when writing '%s'", rc, pThis->pszOutput);
5411	}
5412	else
5413	{
5414	int rc = ScmStreamWriteToStdOut(&pThis->StrmOutput);
5415	if (RT_FAILURE(rc))
5416	vbcppError(pThis, "ScmStreamWriteToStdOut failed with %Rrc", rc);
5417	}
5418	}
5419
5420	/*
5421	* Cleanup.
5422	*/
5423	while (pThis->pInputStack)
5424	{
5425	ScmStreamDelete(&pThis->pInputStack->StrmInput);
5426	void *pvFree = pThis->pInputStack;
5427	pThis->pInputStack = pThis->pInputStack->pUp;
5428	RTMemFree(pvFree);
5429	}
5430
5431	ScmStreamDelete(&pThis->StrmOutput);
5432
5433	RTStrSpaceDestroy(&pThis->StrSpace, vbcppMacroFree, NULL);
5434	pThis->StrSpace = NULL;
5435
5436	uint32_t i = pThis->cIncludes;
5437	while (i-- > 0)
5438	RTStrFree(pThis->papszIncludes[i]);
5439	RTMemFree(pThis->papszIncludes);
5440	pThis->papszIncludes = NULL;
5441
5442	return pThis->rcExit;
5443	}
5444
5445
5446	/**
5447	* Initializes the C preprocessor instance data.
5448	*
5449	* @param pThis The C preprocessor instance data.
5450	*/
5451	static void vbcppInit(PVBCPP pThis)
5452	{
5453	vbcppSetMode(pThis, kVBCppMode_Selective);
5454	pThis->cIncludes = 0;
5455	pThis->papszIncludes = NULL;
5456	pThis->pszInput = NULL;
5457	pThis->pszOutput = NULL;
5458	pThis->StrSpace = NULL;
5459	pThis->UndefStrSpace = NULL;
5460	pThis->cCondStackDepth = 0;
5461	pThis->pCondStack = NULL;
5462	pThis->fIf0Mode = false;
5463	pThis->fJustDroppedLine = false;
5464	pThis->fMaybePreprocessorLine = true;
5465	VBCPP_BITMAP_EMPTY(pThis->bmDefined);
5466	pThis->cCondStackDepth = 0;
5467	pThis->pInputStack = NULL;
5468	RT_ZERO(pThis->StrmOutput);
5469	pThis->rcExit = RTEXITCODE_SUCCESS;
5470	pThis->fStrmOutputValid = false;
5471	}
5472
5473
5474
5475	int main(int argc, char **argv)
5476	{
5477	int rc = RTR3InitExe(argc, &argv, 0);
5478	if (RT_FAILURE(rc))
5479	return RTMsgInitFailure(rc);
5480
5481	/*
5482	* Do the job. The code says it all.
5483	*/
5484	VBCPP This;
5485	vbcppInit(&This);
5486	bool fExit;
5487	RTEXITCODE rcExit = vbcppParseOptions(&This, argc, argv, &fExit);
5488	if (!fExit && rcExit == RTEXITCODE_SUCCESS)
5489	{
5490	rcExit = vbcppOpenStreams(&This);
5491	if (rcExit == RTEXITCODE_SUCCESS)
5492	rcExit = vbcppPreprocess(&This);
5493	}
5494
5495	if (rcExit == RTEXITCODE_SUCCESS)
5496	rcExit = vbcppTerm(&This);
5497	else
5498	vbcppTerm(&This);
5499	return rcExit;
5500	}
5501

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

source: vbox/trunk/src/bldprogs/VBoxCPP.cpp@ 41766

Download in other formats: