Quick Search:

View

Revision:
Expand:  
Changeset: MAIN:plunky:20121020200836

Diff

Diff from 1.4 to:

Annotations

Annotate by Age | Author | Mixed | None
/fisheye/browse/pcc/pcc/cc/cxxcom/cxxcode.c

Annotated File View

plunky
1.4
1 /*      $Id: cxxcode.c,v 1.4 2012/10/20 20:08:37 plunky Exp $   */
ragge
1.1
2 /*
3  * Copyright (c) 2011 Anders Magnusson (ragge@ludd.luth.se).
4  * All rights reserved.
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions
8  * are met:
9  * 1. Redistributions of source code must retain the above copyright
10  *    notice, this list of conditions and the following disclaimer.
11  * 2. Redistributions in binary form must reproduce the above copyright
12  *    notice, this list of conditions and the following disclaimer in the
13  *    documentation and/or other materials provided with the distribution.
14  *
15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
16  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
18  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
19  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
20  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
21  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
22  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
24  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25  */
26
27 # include "pass1.h"
28
29
30 struct symtab spole0 = { 0000000"base""base", };
31 struct symtab *spole = &spole0;
32 struct symtab *nscur = &spole0;
33 int elnknsptr;
34
35 static struct symtab *sfind(char *nstruct symtab *sp);
36 /*
37  * Declare a namespace.
38  */
39 void
40 dclns(NODE *attrchar *n)
41 {
42         struct symtab *sp;
43         struct attr *ap = gcc_attr_parse(attr);
44
45         if (cppdebug)printf("declaring namespace %s\n"n);
46         n = addname(n);
47
48         sp = sfind(nnscur->sup);
49         while (sp != NULL) {
50                 if (sp->sname == n && sp->sclass == NSPACE)
51                         break;
52                 sp = sfind(nsp->snext);
53         }
54         if (sp == NULL) {
55                 /* New namespace */
56                 sp = getsymtab(n0);
57                 sp->sclass = NSPACE;
58                 INSSYM(sp);
59         }
60         nscur = sp;
61         if (cppdebug)printf("declaring namespace2 %s\n"nscur->sname);
62         sp->sap = attr_add(sp->sapap); /* XXX check attributes */
63 }
64
65 /*
66  * Generate a call tree to function named n.
67  */
68 static NODE *
69 callftn(char *n, ...)
70 {
71         struct symtab *sp = getsymtab(n0);
72         NODE *p, *a, *b;
73         va_list ap;
74
75         sp->stype = (FTN|VOID) | (PTR << TSHIFT);
76         va_start(apn);
77
78         a = va_arg(apNODE *);
79         if (a != NULL) {
80                 do {
81                         b = va_arg(apNODE *);
82                         if (b != NULL)
83                                 a = buildtree(CMab);
84                 } while (b != NULL);
85         }
86         
87         p = doacall(spnametree(sp), a0);
88         va_end(ap);
89         return p;
90 }
91
92 /*
93  * Sanitycheck "new" keyword.
94  */
95 NODE *
96 cxx_new(NODE *p)
97 {
98         NODE *q = p;
99         NODE *t1 = bcon(1);
100         int nw = NM_NEW;
101
102         while (p->n_op == LB) {
103                 nw = NM_NWA;
104                 t1 = buildtree(MULt1eve(p->n_right));
105                 p->n_right = bcon(0);
106                 p = p->n_left;
107         }
108         if (p->n_op != TYPE)
109                 uerror("new used illegally");
110         t1 = buildtree(MULt1
111             xbcon(tsize(p->n_typep->n_dfp->n_ap)/SZCHARNULLINTPTR));
112         tfree(q);
113         return callftn(decoratename(NULLnw), t1NULL);
114 }
115
116 /*
117  * Handle "delete" keyword.
118  */
119 NODE *
120 cxx_delete(NODE *pint del)
121 {
122         return callftn(decoratename(NULLdel), pNULL);
123 }
124
125 /*
126   <operator-name> ::= nw        # new           
127                   ::= na        # new[]
128                   ::= dl        # delete        
129                   ::= da        # delete[]      
130                   ::= ps        # + (unary)
131                   ::= ng        # - (unary)     
132                   ::= ad        # & (unary)     
133                   ::= de        # * (unary)     
134                   ::= co        # ~             
135                   ::= pl        # +             
136                   ::= mi        # -             
137                   ::= ml        # *             
138                   ::= dv        # /             
139                   ::= rm        # %             
140                   ::= an        # &             
141                   ::= or        # |             
142                   ::= eo        # ^             
143                   ::= aS        # =             
144                   ::= pL        # +=            
145                   ::= mI        # -=            
146                   ::= mL        # *=            
147                   ::= dV        # /=            
148                   ::= rM        # %=            
149                   ::= aN        # &=            
150                   ::= oR        # |=            
151                   ::= eO        # ^=            
152                   ::= ls        # <<            
153                   ::= rs        # >>            
154                   ::= lS        # <<=           
155                   ::= rS        # >>=           
156                   ::= eq        # ==            
157                   ::= ne        # !=            
158                   ::= lt        # <             
159                   ::= gt        # >             
160                   ::= le        # <=            
161                   ::= ge        # >=            
162                   ::= nt        # !             
163                   ::= aa        # &&            
164                   ::= oo        # ||            
165                   ::= pp        # ++ (postfix in <expression> context)
166                   ::= mm        # -- (postfix in <expression> context)           
167                   ::= cm        # ,             
168                   ::= pm        # ->*           
169                   ::= pt        # ->            
170                   ::= cl        # ()            
171                   ::= ix        # []            
172                   ::= qu        # ?             
173                   ::= st        # sizeof (a type)
174                   ::= sz        # sizeof (an expression)
175                   ::= at        # alignof (a type)
176                   ::= az        # alignof (an expression)
177                   ::= cv <type> # (cast)        
178                   ::= v <digit> <source-name>   # vendor extended operator
179 */
180
181 /*
182   <builtin-type> ::= v  # void
183                  ::= w  # wchar_t
184                  ::= b  # bool
185                  ::= c  # char
186                  ::= a  # signed char
187                  ::= h  # unsigned char
188                  ::= s  # short
189                  ::= t  # unsigned short
190                  ::= i  # int
191                  ::= j  # unsigned int
192                  ::= l  # long
193                  ::= m  # unsigned long
194                  ::= x  # long long, __int64
195                  ::= y  # unsigned long long, __int64
196                  ::= n  # __int128
197                  ::= o  # unsigned __int128
198                  ::= f  # float
199                  ::= d  # double
200                  ::= e  # long double, __float80
201                  ::= g  # __float128
202                  ::= z  # ellipsis
203                  ::= Dd # IEEE 754r decimal floating point (64 bits)
204                  ::= De # IEEE 754r decimal floating point (128 bits)
205                  ::= Df # IEEE 754r decimal floating point (32 bits)
206                  ::= Dh # IEEE 754r half-precision floating point (16 bits)
207                  ::= Di # char32_t
208                  ::= Ds # char16_t
209                  ::= Da # auto (in dependent new-expressions)
210                  ::= Dn # std::nullptr_t (i.e., decltype(nullptr))
211                  ::= u <source-name>    # vendor extended type
212 */
213
214 /* matches type numbering in manifest.h */
215 static char chmap[] = { 'v''b''c''h''s''t''i''j''l''m',
216         'x''y''f''d''e' };
217
218 static int
219 typch(int typ)
220 {
221         int c = BTYPE(typ);
222         if (c == VOID)
223                 c = 0;
224         return chmap[c];
225 }
226
227 #define MAXNM   255     /* max length of mangled name */
228 static char nmblk[MAXNM];
229 static int nmptrsubptr;
230
231 /* push character */
232 static void
233 nmch(int c)
234 {
235         if (nmptr >= MAXNM)
236                 cerror("Too long mangled name");
237         nmblk[nmptr++] = c;
238 }
239
240 /* Push length and string */
241 static void
242 pshsln(char *c)
243 {
244         int ijln = strlen(c);
245
246 #define cnt(v,n) for (v = 0; ln >= n; v++, ln -= n)
247         cnt(i,100);
248         cnt(j,10);
249         if (inmch(i+'0');
250         if (j || inmch(j+'0');
251         nmch(ln+'0');
252         for (; *cc++)
253                 nmch(*c);
254 }
255
256 /* Recurse to push namespace names */
257 static void
258 recnpsh(struct symtab *sp)
259 {
260         if (sp == spole)
261                 return;
262         if (sp == sp->sdown)
263                 cerror("sp == sp->sdown");
264         if (sp->sdown)
265                 recnpsh(sp->sdown);
266         pshsln(sp->sname);
267 }
268
269 static void
270 pshargs(union arglist *al)
271 {
272         TWORD t;
273         
274
275         for (; al->type != TNULLal++) {
276                 t = al->type;
277                 if (t == TELLIPSIS) {
278                         nmch('z');
279                         continue;
280                 }
281                 while (t > BTMASK) {
282                         if (ISPTR(t))
283                                 nmch('P');
284                         else
285                                 uerror("pshargs2: %lx\n"t);
286                         t = DECREF(t);
287                 }
288                 if (t > LDOUBLE)
289                         uerror("pshargs: %lx\n"t);
290                 /* XXX - cannot emit const/volatile */
291                 nmch(typch(t));
292         }
293 }
294
295 /*
296  * Do name mangling of a symbol table entry.
297  * The resulting name is saved in soname.
298  */
299 char *
300 decoratename(struct symtab *spint type)
301 {
302         char *n;
303
304 #define QNM(m,s) case m: n = s; break
305         switch (type) {
306         QNM(NM_NEW,"_Znwm");
307         QNM(NM_NWA,"_Znam");
308         QNM(NM_DEL,"_ZdlPv");
309         QNM(NM_DLA,"_ZdaPv");
310         case NM_NORMAL/* Defined in defid() */
311                 break;
312         default:
313                 uerror("missed mangling %d\n"type);
314                 return "";
315         }
316         if (type != NM_NORMAL)
317                 return addname(n);
318
319         /* special non-mangled cases:
320          * "C" linkage
321          * main() function
322          * variables outside namespaces and classes
323          */
324         if (elnk == LINK_C || strcmp(sp->sname"main") == 0 ||
plunky
1.4
325             (sp->sdown == spole && !ISFTN(sp->stype))) {
ragge
1.1
326                 n = exname(sp->sname);
327                 return addname(n);
328         }
329         /* Compute the mangled name for other symbols */
330         nmptr = 0;
331         subptr = 0;
332         nmch('_'); nmch('Z');
333         if (sp->sdown != NULL) {
334                 nmch('N');
335                 recnpsh(sp->sdown);
336         }
337         pshsln(sp->sname);
338         if (sp->sdown != NULL)
339                 nmch('E');
340         if (ISFTN(sp->stype) && sp->sdf->dfun)
341                 pshargs(sp->sdf->dfun);
342         nmch(0);
343         return addname(nmblk);
344 }
345
346 /*
347  * find a symtab entry in the given link.
348  */
349 static struct symtab *
350 sfind(char *nstruct symtab *sp)
351 {
352         while (sp) {
353         if (cppdebug)printf("sfind: checking %s against %s\n"nsp->sname);
354                 if (sp->sname == n)
355                         return sp;
356                 sp = sp->snext;
357         }
358         return NULL;
359 }
360
361 /* class or namespace? */
362 #define CLORNS(sp) (sp->sclass == STNAME || sp->sclass == CLNAME || \
363         sp->sclass == UNAME || sp->sclass == NSPACE)
364
365 /*
366  * find a symtab path entry in the given path.
367  * p is expected to be a link of NMNAMEs.
368  * It is supposed to return a sup value of the last found class.
369  */
370 static struct symtab *
371 pfind(NODE *pstruct symtab *sp)
372 {
373         char *n;
374
375         if (cppdebug)printf("pfind: op %d searching %s\n"p->n_opp->n_op == NAME ?
376 (char *)p->n_sp:(char *)p->n_right->n_sp);
377
378         if (p->n_op == NAME) {
379                 n = (char *)p->n_sp;
380                 if ((sp = sfind(nsp)) == NULL)
381                         return NULL;
382         if (cppdebug)printf("pfind: NAME class %d name %s\n"sp->sclasssp->sname);
383                 while (!CLORNS(sp)) {
384                         if ((sp = sfind(nsp->snext)) == NULL)
385                                 return NULL;
386                 }
387         if (cppdebug)printf("pfind: FOUND %s\n"sp->sname);
388                 sp = sp->sup;
389         } else {
390                 n = (char *)p->n_right->n_sp;
391                 if ((sp = sfind(nsp)) == NULL)
392                         return NULL;
393         if (cppdebug)printf("pfind: NMLIST class %d name %s\n"sp->sclasssp->sname);
394                 while (!CLORNS(sp)) {
395                         if ((sp = sfind(nsp->snext)) == NULL)
396                                 return NULL;
397                 }
398                 sp = pfind(p->n_leftsp->sup);
399         }
400         return sp;
401 }
402
403 /*
ragge
1.3
404  * Declare a variable.
405  */
406 struct symtab *
407 cxxdeclvar(NODE *p)
408 {
409         struct symtab *sp;
410
411         if (blevel && p->n_op == NAME) {
412                 sp = p->n_sp = lookup((char *)p->n_sp0);
413         } else {
414                 sp = cxxlookup(pSNORMAL);
415         }
416         return sp;
417 }
418
419 /*
ragge
1.1
420  * class is MOS if variable is member of a CLASS, NORMAL otherwise.
421  * A CLASS as member of a class has symbol type CLASS.
422  */
423 char *symclass[] = { "NORMAL""CLASS""LABEL""MOS""STRING" };
424
425 /*
426  * Do a name lookup.  p can be either just a NAME or NMLIST.
427  * The first symbol instance on its level is returned, which may or
428  * may not be correct.
429  * If no symbol is found, return a new symtab entry.
430  * p should be a NAME after this with n_sp filled in accordingly.
431  * It's the responsibility of the declaration routine to add it to 
432  * the symbol table.
433  * nfree() will be called on p after this function.
434  */
435 struct symtab *
436 cxxlookup(NODE *pint flags)
437 {
438         struct symtab *sp, *ns;
439         int ftyp = flags & SMASK;
440         NODE *q;
441         char *n, *s;
442
443 #define SPNAME(p) ((char *)(p->n_op == NAME ? p->n_sp : p->n_right->n_sp))
444         if (cppdebug){ printf("cxxlookup %s\n"SPNAME(p)); symtree(); }
445
446         q = p;
447         if (p->n_op == NAME) {
448                 s = (char *)p->n_sp;
449                 if (blevel) {
450                         sp = lookup(sSNOCREAT); /* check if auto var */
451                         if (sp == NULL) {
452                                 /* check if in classes */
453                                 for (ns = nscurns != spolens = ns->sdown)
454                                         if ((sp = sfind(sns->sup)))
455                                                 break;
456                                 if (sp == NULL)
457                                         sp = sfind(sspole->sup);
458                         }
459                         if (sp == NULL)
460                                 sp = lookup(s0); /* fallback */
461                 } else {
462                         ns = nscur;
463                         sp = sfind(sns);
464                         while (sp != NULL) {
465                                 if ((sp->sflags & SMASK) == ftyp)
466                                         break;
467                                 sp = sfind(ssp->snext);
468                         }
469                         if (sp == NULL) {
470                                 sp = getsymtab(sftyp);
471                                 if ((flags & SNOCREAT) == 0) {
472         if (cppdebug)printf("cxxlookup: adding %s %s %s at %s\n"symclass[ftyp], ssp->sonamenscur ? nscur->sname : "base");
473                                         INSSYM(sp);
474                                         cxxsetname(sp);
475                                 }
476                         }
477                 }
478         } else {
479                 /* Search through namespaces/classes for it */
480                 n = SPNAME(p);
481                 ns = pfind(p->n_leftspole->sup);
482                 if (ns == NULL) {
483                         uerror("undeclared class in chain");
484                         return getsymtab(nftyp);
485                 }
486                 if ((sp = sfind(nns)) == NULL) {
487                         sp = getsymtab(nftyp);
488                         if ((flags & SNOCREAT) == 0) {
489                                 sp->snext = ns->snext;
490                                 ns->snext = sp;
491                         }
492                 }
493         }
494         
495         /* make top node a NAME */
496         if (q->n_op != NAME) {
497                 tfree(q->n_left);
498                 p = q->n_right;
499                 *q = *q->n_right;
500                 nfree(p);
501         }
502         q->n_sp = sp;
503         return sp;
504 }
505
506 void
507 cxxsetname(struct symtab *sp)
508 {
509         if (elnk == LINK_C)
510                 return/* leave to target */
511         sp->soname = decoratename(spNM_NORMAL);
512 }
513
514 /*
515  * Create a symbol out of a struct.
516  * We call the symbol "__%THIS" to avoid interference.
517  */
518 struct symtab *
519 cxxstrvar(struct symtab *so)
520 {
521         struct symtab *sp;
522         NODE *p;
523
524         sp = lookup("__%THIS"0);
525         p = block(NAME00INCREF(so->stype), so->sdfso->sap);
526         p->n_sp = sp;
527         defid(pPARAM);
528         nfree(p);
529         return sp;
530 }
531
532 /*
533  * Declare a struct (class) based on its name n.
534  * Assumed that nmcur is correctly pointing to either:
535  * - nothing (class at level 0)
536  * - current namespace
537  * - parent class
538  */
539 struct symtab *
540 cxxdclstr(char *n)
541 {
542         struct symtab *sp;
543
544         sp = sfind(nnscur->sup);
545         while (sp && !CLORNS(sp))
546                 sp = sfind(nsp->snext);
547         if (sp == 0)
548                 sp = getsymtab(nSTAGNAME);
549 //      else
550 //              uerror("class/namespace redefined");
551 //      INSSYM(sp);
552 //      nscur = sp;
553
554 if (cppdebug)printf("declaring2 struct %s %p nscur %s\n"nspnscur->sname);
555         return sp;
556 }
557
558 #ifdef PCC_DEBUG
559 static void
560 symwalk(struct symtab *spint indent)
561 {
562         int i
563
564         while (sp) {
565                 for (i = 0i < indenti++)
566                         printf("  ");
567                 printf("%s (%p) %s\n"sp->snamespscnames(sp->sclass));
568                 if (sp->sup)
569                         symwalk(sp->supindent+1);
570                 sp = sp->snext;
571         }
572 }
573
574 void
575 symtree(void)
576 {
577         symwalk(spole0);
578 }
579 #endif
580
581 /*
582  * Compare a matching prototype for a function.
583  */
584 static int
585 cxxpcmp(struct symtab *spNODE *p)
586 {
587         union arglist *a1, *a2;
588         int i;
589
590         if (!ISFTN(sp->stype) || p->n_df == NULL || sp->sdf == NULL)
591                 return 0/* no dimfun */
ragge
1.2
592         if ((a1 = sp->sdf->dfun) == NULL || (a2 = p->n_df->dfun) == NULL)
ragge
1.1
593                 return 0/* no argument */
594
595         for (i = 0; ; i++) {
596                 if (a1[i].type == TNULL && a2[i].type == TNULL)
597                         return 1/* equal prototypes */
598                 if (a1[i].type != a2[i].type)
599                         return 1/* unequal prototypes */
600         }
601 }
602
603 struct ckstr {
604         int rv;
605         union arglist *al;
606 };
607
608 static void
609 cxxckproto(NODE *pvoid *arg)
610 {
611         struct ckstr *cp = arg;
612
613         if (cp->rv == -1)
614                 return;
615
616         if (cp->al[0].type != p->n_type)
617                 goto fail;
618         if (BTYPE(cp->al[0].type) > LDOUBLE)
619                 uerror("cxxckproto");
620         cp->al++;
621         return;
622 fail:
623         cp->rv = -1;
624 }
625
626 /*
627  * Compare a matching prototype for an argument tree.
628  * Here we can expand to also do inexact matches.
629  * Return 0 if equal, -1 if failed.
630  */
631 static int
632 cxxptreecmp(struct symtab *spNODE *p)
633 {
634         struct ckstr ckstr;
635         union arglist *a1;
636
637         if (!ISFTN(sp->stype) || sp->sdf == NULL ||
638             (a1 = sp->sdf->dfun) == NULL)
639                 return 0/* no dimfun */
640
641         if (p == NULL && a1[0].type == TNULL)
642                 return 1/* arg-less */
643
644         ckstr.rv = 0;
645         ckstr.al = a1;
646         flist(pcxxckproto, &ckstr);
647
648         if (ckstr.al[0].type != TNULL)
649                 return -1/* arg number error */
650         return ckstr.rv;
651 }
652
653 /*
654  * Search for (and declare) a function.
655  */
656 struct symtab *
657 cxxftnfind(NODE *pint flags)
658 {
659         struct symtab *sp, *ns;
660         char *s;
661
662         if (p->n_op == NAME) {
663                 s = (char *)p->n_sp;
664                 /* Search for equally named functions */
665                 sp = sfind(snscur->sup);
666                 while (sp != NULL) {
667                         if (cxxpcmp(spp)) {
668                                 if (sp->sclass != NSPACE ||
669                                     sp->sclass == EXTDEF) {
670                                         uerror("%s redefined"s);
671                                         return sp;
672                                 } else
673                                         break;
674                         }
675                         sp = sfind(ssp->snext);
676                 }
677                 if (sp == NULL) {
678                         sp = getsymtab(sSNORMAL);
679                         sp->stype = p->n_type;
680                         sp->squal = p->n_qual;
681                         sp->sdf = p->n_df;
682                         sp->sap = p->n_ap;
683                         INSSYM(sp);
684                         if (nscur->sclass != NSPACE && nscur != &spole0)
685                                 uerror("inside struct");
686                 }
687                 sp->sclass = EXTDEF;
688                 if (sp->soname == 0)
689                         sp->soname = decoratename(spNM_NORMAL);
690         } else {
691                 /*
692                  * declared outside class, tree-style reference
693                  * Must have been defined already
694                  * This will be an external declaration (not spooled).
695                  */
696                 s = SPNAME(p);
697                 if ((ns = pfind(p->n_leftspole->sup)) == NULL) {
698                         uerror("undeclared class in chain");
699                         goto undecl;
700                 }
701                 /* Search for an EXTERN or EXTDEF declaration within */
702                 /* EXTDEF causes redeclaration. */
703                 sp = sfind(sns);
704                 while (sp != NULL) {
705                         if (sp->sclass == EXTERN || sp->sclass == EXTDEF) {
706                                 if (cxxpcmp(spp->n_right)) {
707                                         if (sp->sclass == EXTDEF)
708                                                 uerror("%s redefined"s);
709                                         break;
710                                 }
711                         }
712                         sp = sfind(ssp->snext);
713                 }
714                 if (sp == NULL) {
715                         uerror("%s undeclared"s);
716                         goto undecl;
717                 }
718                 sp->sclass = EXTDEF;
719         }
720         return sp;
721
722 undecl:
723         return getsymtab(sSNORMAL);
724 }
725
726 /*
727  * Reference to a struct as a :: name.
728  */
729 NODE *
730 cxxrstruct(int soruNODE *attrNODE *tchar *n)
731 {
732         struct symtab *ns, *sp;
733
734         ns = pfind(tspole->sup);
735         if (ns == NULL)
736                 goto undecl;
737
738         tfree(t);
739         sp = sfind(nns);
740         while (sp != NULL) {
741                 if (sp->sclass == soru)
742                         return mkty(sp->stype0sp->sap);
743                 sp = sfind(nsp->snext);
744         }
745 undecl:
746         uerror("%s undeclared"n);
747         return mkty(INT00);
748 }
749
750 /*
751  * Search for correct matching function in a struct depending on 
752  * argument list a.  Return a call node for this function.
753  * Do not touch neither f nor a.
754  * return a name tree suitable for a function call.
755  * We know here that f is a struct reference.
756  */
757 NODE *
758 cxxmatchftn(NODE *fNODE *a)
759 {
760         struct attr *ap;
761         struct symtab *sp;
762         char *n = (char *)f->n_right->n_sp;
763
764         f = f->n_left;
765
766         if ((ap = attr_find(f->n_apATTR_STRUCT)) == NULL) {
767                 uerror("undefined class");
ragge
1.2
768                 sp = getsymtab(n0);
ragge
1.1
769         } else
770                 sp = ap->amlist;
771         sp = sfind(nsp);
772         while (sp != NULL) {
773                 if (ISFTN(sp->stype) && cxxptreecmp(spa) == 0)
774                         break;
775                 sp = sfind(nsp->snext);
776         }
777         if (sp == NULL)
778                 uerror("undefined class member");
779         return nametree(sp);
780 }
781
782 /*
783  * Add hidden argument f first in node list a. Return resulting a.
784  */
785 NODE *
786 cxxaddhidden(NODE *aNODE *f)
787 {
788         NODE *q;
789
790         if (a == NULL)
791                 return f;
792         if (a->n_op != CM)
793                 return block(CMfaINT00);
794         for (q = aq->n_left->n_op == CMq = q->n_left)
795                 ;
796         q->n_left = block(CMfq->n_leftINT00);
797         return a;
798 }
799
800 /*
801  * Watch out for references to static members.
802  */
803 NODE *
804 cxxstructref(NODE *pint fchar *n)
805 {
806         struct symtab *sp = strmemb(p->n_ap);
807
808         if (sp == NULL)
809                 cerror("ref to unknown struct");
810         sp = sfind(nsp);
811         while (sp != NULL) {
plunky
1.4
812                 if (!ISFTN(sp->stype)) {
ragge
1.1
813                         if (sp->sclass == STATIC || sp->sclass == USTATIC) {
814                                 tfree(p);
815                                 return nametree(sp);
816                         }
817                         break;
818                 }
819                 sp = sfind(nsp->snext);
820         }
821         return structref(pfn);
822 }
FishEye: Open Source License registered to PCC.
Atlassian FishEye, CVS analysis. (Version:1.6.3 Build:build-336 2008-11-04) - Administration - Page generated 2014-12-20 14:00 +0100