xref: /aoo41x/main/soltools/cpp/_macro.c (revision cdf0e10c) 
1 #ifdef _MSC_VER
2 #	define _POSIX_
3 #endif
4 #include <stdio.h>
5 #include <stdlib.h>
6 #include <string.h>
7 #ifdef __hpux
8 #	define _HPUX_SOURCE
9 #endif
10 #if defined(__IBMC__) || defined(__EMX__)
11 #   define PATH_MAX _MAX_PATH
12 #endif
13 #include <limits.h>
14 
15 #include "cpp.h"
16 
17 #define NCONCAT 16384
18 
19 /*
20  * do a macro definition.  tp points to the name being defined in the line
21  */
22 void
23     dodefine(Tokenrow * trp)
24 {
25     Token *tp;
26     Nlist *np;
27     Source *s;
28     Tokenrow *def, *args;
29 	static uchar location[(PATH_MAX + 8) * NINC], *cp;
30 
31     tp = trp->tp + 1;
32     if (tp >= trp->lp || tp->type != NAME)
33     {
34         error(ERROR, "#defined token is not a name");
35         return;
36     }
37     np = lookup(tp, 1);
38     if (np->flag & ISUNCHANGE)
39     {
40         error(ERROR, "#defined token %t can't be redefined", tp);
41         return;
42     }
43     /* collect arguments */
44     tp += 1;
45     args = NULL;
46     if (tp < trp->lp && tp->type == LP && tp->wslen == 0)
47     {
48         /* macro with args */
49         int narg = 0;
50 
51         tp += 1;
52         args = new(Tokenrow);
53         maketokenrow(2, args);
54         if (tp->type != RP)
55         {
56             int err = 0;
57 
58             for (;;)
59             {
60                 Token *atp;
61 
62                 if (tp->type != NAME)
63                 {
64                     err++;
65                     break;
66                 }
67                 if (narg >= args->max)
68                     growtokenrow(args);
69                 for (atp = args->bp; atp < args->lp; atp++)
70                     if (atp->len == tp->len
71                         && strncmp((char *) atp->t, (char *) tp->t, tp->len) == 0)
72                         error(ERROR, "Duplicate macro argument");
73                 *args->lp++ = *tp;
74                 narg++;
75                 tp += 1;
76                 if (tp->type == RP)
77                     break;
78                 if (tp->type != COMMA)
79                 {
80                     err++;
81                     break;
82                 }
83                 tp += 1;
84             }
85             if (err)
86             {
87                 error(ERROR, "Syntax error in macro parameters");
88                 return;
89             }
90         }
91         tp += 1;
92     }
93     trp->tp = tp;
94     if (((trp->lp) - 1)->type == NL)
95         trp->lp -= 1;
96     def = normtokenrow(trp);
97     if (np->flag & ISDEFINED)
98     {
99         if (comparetokens(def, np->vp)
100             || (np->ap == NULL) != (args == NULL)
101             || (np->ap && comparetokens(args, np->ap)))
102 		{
103 			if ( np->loc )
104             	error(ERROR,
105 					"Macro redefinition of %t (already defined at %s)",
106 					trp->bp + 2, np->loc);
107 			else
108             	error(ERROR,
109 					"Macro redefinition of %t (already defined at %s)",
110 					trp->bp + 2, "commandline" );
111 		}
112     }
113     if (args)
114     {
115         Tokenrow *tap;
116 
117         tap = normtokenrow(args);
118         dofree(args->bp);
119         args = tap;
120     }
121     np->ap = args;
122     np->vp = def;
123     np->flag |= ISDEFINED;
124 
125 	/* build location string of macro definition */
126     for (cp = location, s = cursource; s; s = s->next)
127         if (*s->filename)
128 		{
129 			if (cp != location)
130 				*cp++ = ' ';
131             sprintf((char *)cp, "%s:%d", s->filename, s->line);
132 			cp += strlen((char *)cp);
133 		}
134 
135 	np->loc = newstring(location, strlen((char *)location), 0);
136 
137 	if (Mflag)
138 	{
139 		if (np->ap)
140 			error(INFO, "Macro definition of %s(%r) [%r]", np->name, np->ap, np->vp);
141 		else
142 			error(INFO, "Macro definition of %s [%r]", np->name, np->vp);
143 	}
144 }
145 
146 /*
147  * Definition received via -D or -U
148  */
149 void
150     doadefine(Tokenrow * trp, int type)
151 {
152     Nlist *np;
153 	static uchar onestr[2] = "1";
154     static Token onetoken[1] = {{NUMBER, 0, 0, 1, onestr, 0}};
155     static Tokenrow onetr = {onetoken, onetoken, onetoken + 1, 1};
156 
157     trp->tp = trp->bp;
158     if (type == 'U')
159     {
160         if (trp->lp - trp->tp != 2 || trp->tp->type != NAME)
161             goto syntax;
162         if ((np = lookup(trp->tp, 0)) == NULL)
163             return;
164         np->flag &= ~ISDEFINED;
165         return;
166     }
167 
168     if (type == 'A')
169     {
170         if (trp->tp >= trp->lp || trp->tp->type != NAME)
171             goto syntax;
172         trp->tp->type = ARCHITECTURE;
173         np = lookup(trp->tp, 1);
174         np->flag |= ISARCHITECTURE;
175         trp->tp += 1;
176         if (trp->tp >= trp->lp || trp->tp->type == END)
177         {
178             np->vp = &onetr;
179             return;
180         }
181         else
182             error(FATAL, "Illegal -A argument %r", trp);
183     }
184 
185     if (trp->tp >= trp->lp || trp->tp->type != NAME)
186         goto syntax;
187     np = lookup(trp->tp, 1);
188     np->flag |= ISDEFINED;
189     trp->tp += 1;
190     if (trp->tp >= trp->lp || trp->tp->type == END)
191     {
192         np->vp = &onetr;
193         return;
194 	}
195 	if (trp->tp->type != ASGN)
196 		goto syntax;
197 	trp->tp += 1;
198 	if ((trp->lp - 1)->type == END)
199 		trp->lp -= 1;
200 	np->vp = normtokenrow(trp);
201 	return;
202 syntax:
203 	error(FATAL, "Illegal -D or -U argument %r", trp);
204 }
205 
206 
207 
208 /*
209  * Do macro expansion in a row of tokens.
210  * Flag is NULL if more input can be gathered.
211  */
212 void
213 	expandrow(Tokenrow * trp, char *flag)
214 {
215 	Token *	tp;
216 	Nlist *	np;
217 
218 	MacroValidatorList 	validators;
219 	mvl_init(&validators);
220     /* Sets all token-identifiers to 0 because tokens may not be initialised (never use C!) */
221 	tokenrow_zeroTokenIdentifiers(trp);
222 
223 	if (flag)
224 		setsource(flag, -1, -1, "", 0);
225 	for (tp = trp->tp; tp < trp->lp;)
226 	{
227 		mvl_check(&validators, tp);
228 
229 		if (tp->type != NAME
230 			|| quicklook(tp->t[0], tp->len > 1 ? tp->t[1] : 0) == 0
231 			|| (np = lookup(tp, 0)) == NULL
232 			|| (np->flag & (ISDEFINED | ISMAC)) == 0
233 			|| (np->flag & ISACTIVE) != 0)
234 		{
235 			tp++;
236 			continue;
237 		}
238 		trp->tp = tp;
239 		if (np->val == KDEFINED)
240 		{
241 			tp->type = DEFINED;
242 			if ((tp + 1) < trp->lp && (tp + 1)->type == NAME)
243 				(tp + 1)->type = NAME1;
244 			else
245 				if ((tp + 3) < trp->lp && (tp + 1)->type == LP
246 					&& (tp + 2)->type == NAME && (tp + 3)->type == RP)
247 					(tp + 2)->type = NAME1;
248 				else
249 					error(ERROR, "Incorrect syntax for `defined'");
250 			tp++;
251 			continue;
252 		}
253 		else
254 			if (np->val == KMACHINE)
255 			{
256 				if (((tp - 1) >= trp->bp) && ((tp - 1)->type == SHARP))
257 				{
258 					tp->type = ARCHITECTURE;
259 					if ((tp + 1) < trp->lp && (tp + 1)->type == NAME)
260 						(tp + 1)->type = NAME2;
261 					else
262 						if ((tp + 3) < trp->lp && (tp + 1)->type == LP
263 							&& (tp + 2)->type == NAME && (tp + 3)->type == RP)
264 							(tp + 2)->type = NAME2;
265 						else
266 							error(ERROR, "Incorrect syntax for `#machine'");
267 				}
268 				tp++;
269 				continue;
270 			}
271 
272 		if (np->flag & ISMAC)
273 			builtin(trp, np->val);
274 		else
275 			expand(trp, np, &validators);
276 		tp = trp->tp;
277 	}	// end for
278 	if (flag)
279 		unsetsource();
280 
281 	mvl_destruct(&validators);
282 }
283 
284 /*
285  * Expand the macro whose name is np, at token trp->tp, in the tokenrow.
286  * Return trp->tp at the first token next to be expanded
287  * (ordinarily the beginning of the expansion)
288  * I.e.: the same position as before!
289  * Only one expansion is performed, then we return to the expandrow()
290  * loop and start at same position.
291  */
292 void
293 	expand(Tokenrow * trp, Nlist * np, MacroValidatorList *	pValidators)
294 {
295 //	Token * pOldNextTp;
296 	Tokenrow ntr;
297 	int ntokc, narg, i;
298 	Tokenrow *atr[NARG + 1];
299 
300 	if (Mflag == 2)
301 	{
302 		if (np->ap)
303 			error(INFO, "Macro expansion of %t with %s(%r)", trp->tp, np->name, np->ap);
304 		else
305 			error(INFO, "Macro expansion of %t with %s", trp->tp, np->name);
306 	}
307 
308 	copytokenrow(&ntr, np->vp);         /* copy macro value */
309 	if (np->ap == NULL)                 /* parameterless */
310 		ntokc = 1;
311 	else
312 	{
313 		ntokc = gatherargs(trp, atr, &narg);
314 		if (narg < 0)
315 		{                               /* not actually a call (no '(') */
316 			trp->tp++;
317 			return;
318 		}
319 		if (narg != rowlen(np->ap))
320 		{
321 			error(ERROR, "Disagreement in number of macro arguments");
322 			trp->tp += ntokc;
323 			return;
324 		}
325 
326 		/** If gatherargs passed a macro validating token, this token
327 			must become valid here.
328 			trp->tp+0 was checked in expandrow(), so we dont need to do it
329 			again here:
330 		*/
331 		for (i = 1; i < ntokc; i++)
332 		{
333 			mvl_check(pValidators,trp->tp+i);
334 		}
335 
336 		substargs(np, &ntr, atr);		/* put args into replacement */
337 		for (i = 0; i < narg; i++)
338 		{
339 			dofree(atr[i]->bp);
340 			dofree(atr[i]);
341 		}
342 	}
343 
344 /* old
345 	np->flag |= ISACTIVE;
346 */
347 
348 /* rh
349 */
350 	doconcat(&ntr);                     /* execute ## operators */
351 	ntr.tp = ntr.bp;
352 	makespace(&ntr, trp->tp);
353 
354 /* old
355 //	expandrow(&ntr, "<expand>");
356 //	insertrow(trp, ntokc, &ntr);
357 //	dofree(ntr.bp);
358 //	np->flag &= ~ISACTIVE;
359 */
360 
361 /* NP
362 		// Replace macro by its value:
363 */
364 //	pOldNextTp = trp->tp+ntokc;
365 	tokenrow_zeroTokenIdentifiers(&ntr);
366 	insertrow(trp, ntokc, &ntr);
367 		/* Reassign old macro validators:
368 		*/
369 //	mvl_move(pValidators, trp->tp - pOldNextTp);
370 
371 		/* add validator for just invalidated macro:
372 		*/
373 	np->flag |= ISACTIVE;
374 	if (trp->tp != trp->lp)
375 	{  	/* tp is a valid pointer: */
376 		mvl_add(pValidators,np,trp->tp);
377 	}
378 	else
379 	{	/* tp is == lp, therefore does not point to valid memory: */
380 		mvl_add(pValidators,np,0);
381 	}
382 		/* reset trp->tp to original position:
383 		*/
384 	trp->tp -= ntr.lp - ntr.bp;			/* so the result will be tested for macros from the same position again */
385 
386 	dofree(ntr.bp);
387 
388 	return;
389 }
390 
391 /*
392  * Gather an arglist, starting in trp with tp pointing at the macro name.
393  * Return total number of tokens passed, stash number of args found.
394  * trp->tp is not changed relative to the tokenrow.
395  */
396 int
397 	gatherargs(Tokenrow * trp, Tokenrow ** atr, int *narg)
398 {
399 	int parens = 1;
400 	int ntok = 0;
401 	Token *bp, *lp;
402 	Tokenrow ttr;
403 	int ntokp;
404 	int needspace;
405 
406 	*narg = -1;                         /* means that there is no macro
407 										 * call */
408 	/* look for the ( */
409 	for (;;)
410 	{
411 		trp->tp++;
412 		ntok++;
413 		if (trp->tp >= trp->lp)
414 		{
415 			gettokens(trp, 0);
416 			if ((trp->lp - 1)->type == END)
417 			{
418 				trp->lp -= 1;
419 				trp->tp -= ntok;
420 				return ntok;
421 			}
422 		}
423 		if (trp->tp->type == LP)
424 			break;
425 		if (trp->tp->type != NL)
426 			return ntok;
427 	}
428 	*narg = 0;
429 	ntok++;
430 	ntokp = ntok;
431 	trp->tp++;
432 	/* search for the terminating ), possibly extending the row */
433 	needspace = 0;
434 	while (parens > 0)
435 	{
436 		if (trp->tp >= trp->lp)
437 			gettokens(trp, 0);
438 		if (needspace)
439 		{
440 			needspace = 0;
441 			/* makespace(trp); [rh] */
442 		}
443 		if (trp->tp->type == END)
444 		{
445 			trp->lp -= 1;
446 			trp->tp -= ntok;
447 			error(ERROR, "EOF in macro arglist");
448 			return ntok;
449 		}
450 		if (trp->tp->type == NL)
451 		{
452 			trp->tp += 1;
453 			adjustrow(trp, -1);
454 			trp->tp -= 1;
455 			/* makespace(trp); [rh] */
456 			needspace = 1;
457 			continue;
458 		}
459 		if (trp->tp->type == LP)
460 			parens++;
461 		else
462 			if (trp->tp->type == RP)
463 				parens--;
464 		trp->tp++;
465 		ntok++;
466 	}
467 	trp->tp -= ntok;
468 	/* Now trp->tp won't move underneath us */
469 	lp = bp = trp->tp + ntokp;
470 	for (; parens >= 0; lp++)
471 	{
472 		if (lp->type == LP)
473 		{
474             parens++;
475             continue;
476         }
477         if (lp->type == RP)
478             parens--;
479         if (lp->type == DSHARP)
480 			lp->type = DSHARP1;         /* ## not special in arg */
481         if ((lp->type == COMMA && parens == 0) ||
482 				( parens < 0 && ((lp - 1)->type != LP)))
483         {
484             if (*narg >= NARG - 1)
485 				error(FATAL, "Sorry, too many macro arguments");
486             ttr.bp = ttr.tp = bp;
487             ttr.lp = lp;
488             atr[(*narg)++] = normtokenrow(&ttr);
489             bp = lp + 1;
490         }
491     }
492     return ntok;
493 }
494 
495 /*
496  * substitute the argument list into the replacement string
497  *  This would be simple except for ## and #
498  */
499 void
500 	substargs(Nlist * np, Tokenrow * rtr, Tokenrow ** atr)
501 {
502 	Tokenrow tatr;
503 	Token *tp;
504 	int ntok, argno;
505 
506 	for (rtr->tp = rtr->bp; rtr->tp < rtr->lp;)
507 	{
508 		if (rtr->tp->type == SHARP)
509 		{                               /* string operator */
510 			tp = rtr->tp;
511 			rtr->tp += 1;
512 			if ((argno = lookuparg(np, rtr->tp)) < 0)
513 			{
514 				error(ERROR, "# not followed by macro parameter");
515 				continue;
516 			}
517 			ntok = 1 + (rtr->tp - tp);
518 			rtr->tp = tp;
519 			insertrow(rtr, ntok, stringify(atr[argno]));
520 			continue;
521 		}
522 		if (rtr->tp->type == NAME
523 			&& (argno = lookuparg(np, rtr->tp)) >= 0)
524 		{
525 			if (((rtr->tp + 1) < rtr->lp && (rtr->tp + 1)->type == DSHARP)
526 				|| (rtr->tp != rtr->bp  && (rtr->tp - 1)->type == DSHARP))
527 			{
528 				copytokenrow(&tatr, atr[argno]);
529 				makespace(&tatr, rtr->tp);
530 				insertrow(rtr, 1, &tatr);
531 				dofree(tatr.bp);
532 			}
533             else
534             {
535                 copytokenrow(&tatr, atr[argno]);
536 				makespace(&tatr, rtr->tp);
537                 expandrow(&tatr, "<macro>");
538                 insertrow(rtr, 1, &tatr);
539                 dofree(tatr.bp);
540             }
541             continue;
542         }
543         rtr->tp++;
544     }
545 }
546 
547 /*
548  * Evaluate the ## operators in a tokenrow
549  */
550 void
551     doconcat(Tokenrow * trp)
552 {
553     Token *ltp, *ntp;
554     Tokenrow ntr;
555     int len;
556 
557     for (trp->tp = trp->bp; trp->tp < trp->lp; trp->tp++)
558     {
559         if (trp->tp->type == DSHARP1)
560             trp->tp->type = DSHARP;
561         else
562             if (trp->tp->type == DSHARP)
563             {
564 				int  i;
565                 char tt[NCONCAT];
566 
567                 ltp = trp->tp - 1;
568 				ntp = trp->tp + 1;
569 
570 				if (ltp < trp->bp || ntp >= trp->lp)
571                 {
572                     error(ERROR, "## occurs at border of replacement");
573                     continue;
574 				}
575 
576 				ntp = ltp;
577 				i   = 1;
578 				len = 0;
579 
580 				do
581 				{
582 					if (len + ntp->len + ntp->wslen > sizeof(tt))
583 					{
584 						error(ERROR, "## string concatination buffer overrun");
585 						break;
586 					}
587 
588 					if (ntp != trp->tp + 1)
589 					{
590 						strncpy((char *) tt + len, (char *) ntp->t - ntp->wslen,
591 							    ntp->len + ntp->wslen);
592 						len += ntp->len + ntp->wslen;
593 					}
594 					else	// Leerzeichen um ## herum entfernen:
595 					{
596 						strncpy((char *) tt + len, (char *) ntp->t, ntp->len);
597 						len += ntp->len;
598 					}
599 
600 					ntp = trp->tp + i;
601 					i++;
602 				}
603 				while (ntp < trp->lp);
604 
605                 tt[len] = '\0';
606 				setsource("<##>", -1, -1, tt, 0);
607                 maketokenrow(3, &ntr);
608                 gettokens(&ntr, 1);
609                 unsetsource();
610 				if (ntr.bp->type == UNCLASS)
611 					error(WARNING, "Bad token %r produced by ##", &ntr);
612 				while ((ntr.lp-1)->len == 0 && ntr.lp != ntr.bp)
613 					ntr.lp--;
614 
615 			    doconcat(&ntr);
616                 trp->tp = ltp;
617 				makespace(&ntr, ltp);
618                 insertrow(trp, ntp - ltp, &ntr);
619                 dofree(ntr.bp);
620                 trp->tp--;
621             }
622     }
623 }
624 
625 /*
626  * tp is a potential parameter name of macro mac;
627  * look it up in mac's arglist, and if found, return the
628  * corresponding index in the argname array.  Return -1 if not found.
629  */
630 int
631     lookuparg(Nlist * mac, Token * tp)
632 {
633     Token *ap;
634 
635     if (tp->type != NAME || mac->ap == NULL)
636         return -1;
637     for (ap = mac->ap->bp; ap < mac->ap->lp; ap++)
638     {
639         if (ap->len == tp->len && strncmp((char *) ap->t, (char *) tp->t, ap->len) == 0)
640             return ap - mac->ap->bp;
641     }
642     return -1;
643 }
644 
645 /*
646  * Return a quoted version of the tokenrow (from # arg)
647  */
648 #define	STRLEN	512
649 Tokenrow *
650     stringify(Tokenrow * vp)
651 {
652     static Token t = {STRING, 0, 0, 0, NULL, 0};
653 	static Tokenrow tr = {&t, &t, &t + 1, 1};
654     Token *tp;
655     uchar s[STRLEN];
656     uchar *sp = s, *cp;
657     int i, instring;
658 
659     *sp++ = '"';
660     for (tp = vp->bp; tp < vp->lp; tp++)
661     {
662         instring = tp->type == STRING || tp->type == CCON;
663         if (sp + 2 * tp->len + tp->wslen  >= &s[STRLEN - 10])
664         {
665             error(ERROR, "Stringified macro arg is too long");
666             break;
667         }
668 
669         // Change by np 31.10.2001, #93725 - begin
670         if ( tp->wslen > 0 )
671         *sp++ = ' ';
672         // change end.
673 
674         for (i = 0, cp = tp->t; (unsigned int)i < tp->len; i++)
675         {
676             if (instring && (*cp == '"' || *cp == '\\'))
677                 *sp++ = '\\';
678             *sp++ = *cp++;
679         }
680     }
681     *sp++ = '"';
682     *sp = '\0';
683 	sp = s;
684     t.len = strlen((char *) sp);
685     t.t = newstring(sp, t.len, 0);
686     return &tr;
687 }
688 
689 /*
690  * expand a builtin name
691  */
692 void
693     builtin(Tokenrow * trp, int biname)
694 {
695     char *op;
696     Token *tp;
697     Source *s;
698 
699     tp = trp->tp;
700     trp->tp++;
701     /* need to find the real source */
702     s = cursource;
703     while (s && s->fd == -1)
704         s = s->next;
705     if (s == NULL)
706         s = cursource;
707 	/* most are strings */
708     tp->type = STRING;
709     if (tp->wslen)
710     {
711         *outptr++ = ' ';
712         tp->wslen = 1;
713     }
714     op = outptr;
715     *op++ = '"';
716     switch (biname)
717     {
718 
719         case KLINENO:
720             tp->type = NUMBER;
721             op = outnum(op - 1, s->line);
722             break;
723 
724         case KFILE:
725             {
726                 char *src = s->filename;
727 
728                 while ((*op++ = *src++) != 0)
729                     if (src[-1] == '\\')
730                         *op++ = '\\';
731                 op--;
732                 break;
733             }
734 
735         case KDATE:
736             strncpy(op, curtime + 4, 7);
737             strncpy(op + 7, curtime + 20, 4);
738             op += 11;
739             break;
740 
741         case KTIME:
742             strncpy(op, curtime + 11, 8);
743             op += 8;
744             break;
745 
746         default:
747             error(ERROR, "cpp botch: unknown internal macro");
748             return;
749     }
750     if (tp->type == STRING)
751         *op++ = '"';
752     tp->t = (uchar *) outptr;
753     tp->len = op - outptr;
754     outptr = op;
755 }
756 
757