Quick Search:

View

Revision:
Expand:  
Changeset: MAIN:plunky:20121022090322

Diff

Diff from 1.5 to:

Annotations

Annotate by Age | Author | Mixed | None
/fisheye/browse/pcc/pcc/cc/cxxcom/pass1.h

Annotated File View

plunky
1.5
1 /*      $Id: pass1.h,v 1.5 2012/10/22 09:03:22 plunky Exp $     */
ragge
1.1
2 /*
3  * Copyright(C) Caldera International Inc. 2001-2002. All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  *
9  * Redistributions of source code and documentation must retain the above
10  * copyright notice, this list of conditions and the following disclaimer.
11  * Redistributions in binary form must reproduce the above copyright
12  * notice, this list of conditionsand the following disclaimer in the
13  * documentation and/or other materials provided with the distribution.
14  * All advertising materials mentioning features or use of this software
15  * must display the following acknowledgement:
16  *      This product includes software developed or owned by Caldera
17  *      International, Inc.
18  * Neither the name of Caldera International, Inc. nor the names of other
19  * contributors may be used to endorse or promote products derived from
20  * this software without specific prior written permission.
21  *
22  * USE OF THE SOFTWARE PROVIDED FOR UNDER THIS LICENSE BY CALDERA
23  * INTERNATIONAL, INC. AND CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR
24  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
25  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
26  * DISCLAIMED.  IN NO EVENT SHALL CALDERA INTERNATIONAL, INC. BE LIABLE
27  * FOR ANY DIRECT, INDIRECT INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
29  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
30  * HOWEVER CAUSED AND ON ANY THEORY OFLIABILITY, WHETHER IN CONTRACT,
31  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
32  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
33  * POSSIBILITY OF SUCH DAMAGE.
34  */
35
36 #include "config.h"
37
38 #include <sys/types.h>
39 #include <stdarg.h>
40 #include <string.h>
41 #ifdef HAVE_STDINT_H
42 #include <stdint.h>
43 #endif
44
45 #ifndef MKEXT
46 #include "external.h"
47 #else
48 typedef unsigned int bittype/* XXX - for basicblock */
49 #endif
50 #include "manifest.h"
51
52 /*
53  * Storage classes
54  */
55 #define SNULL           0
56 #define AUTO            1
57 #define EXTERN          2
58 #define STATIC          3
59 #define REGISTER        4
60 #define EXTDEF          5
61 /* #define LABEL        6*/
62 /* #define ULABEL       7*/
63 #define MOS             8
64 #define PARAM           9
65 #define STNAME          10
66 #define MOU             11
67 #define UNAME           12
68 #define TYPEDEF         13
69 /* #define FORTRAN              14 */
70 #define ENAME           15
71 #define MOE             16
72 /* #define UFORTRAN     17 */
73 #define USTATIC         18
74 #define MAXSTCL         20
75
76         /* field size is ORed in */
77 #define FIELD           0200
78 #define FLDSIZ          0177
79 extern  char *scnames(int);
80
81 /*
82  * Symbol table flags
83  */
84 #define SNORMAL         0
85 #define STAGNAME        01
86 #define SLBLNAME        02
87 #define SMOSNAME        03
88 #define SSTRING         04
89 #define NSTYPES         05
90 #define SMASK           07
91
92 #define STLS            00010   /* Thread Local Support variable */
93 /* #define SREF         00020 */
94 #define SNOCREAT        00040   /* don't create a symbol in lookup() */
95 #define STEMP           00100   /* Allocate symtab from temp or perm mem */
96 #define SDYNARRAY       00200   /* symbol is dynamic array on stack */
97 #define SINLINE         00400   /* function is of type inline */
98 #define STNODE          01000   /* symbol shall be a temporary node */
ragge
1.3
99 #define SBUILTIN        02000   /* this is a builtin function */
ragge
1.1
100 #define SASG            04000   /* symbol is assigned to already */
101 #define SLOCAL1         010000
102 #define SLOCAL2         020000
103 #define SLOCAL3         040000
104
105         /* alignment of initialized quantities */
106 #ifndef AL_INIT
107 #define AL_INIT ALINT
108 #endif
109
110 struct rstack;
111 struct symtab;
112 union arglist;
113 #ifdef GCC_COMPAT
114 struct gcc_attr_pack;
115 #endif
116
117 struct namespace;
118
119 /*
120  * Dimension/prototype information.
121  *      ddim > 0 holds the dimension of an array.
122  *      ddim < 0 is a dynamic array and refers to a tempnode.
123  *      ...unless:
124  *              ddim == NOOFFSET, an array without dimenston, "[]"
125  *              ddim == -1, dynamic array while building before defid.
126  */
127 union dimfun {
128         int     ddim;           /* Dimension of an array */
129         union arglist *dfun;    /* Prototype index */
130 };
131
132 /*
133  * Argument list member info when storing prototypes.
134  */
135 union arglist {
136         TWORD type;
137         union dimfun *df;
138         struct attr *sap;
139 };
140 #define TNULL           INCREF(FARG) /* pointer to FARG -- impossible type */
141 #define TELLIPSIS       INCREF(INCREF(FARG))
142
143 /*
144  * Symbol table definition.
145  */
146 struct  symtab {
147         struct  symtab *snext;  /* link to other symbols in the same scope */
148         struct  symtab *sdown;  /* link to parent class */
149         struct  symtab *sup;    /* link to child class */
150         int     soffset;        /* offset or value */
151         char    sclass;         /* storage class */
152         char    slevel;         /* scope level */
153         short   sflags;         /* flags, see below */
154         char    *sname;         /* Symbol name */
155         char    *soname;        /* Written-out name */
156         TWORD   stype;          /* type word */
157         TWORD   squal;          /* qualifier word */
158         union   dimfun *sdf;    /* ptr to the dimension/prototype array */
159         struct  attr *sap;      /* the base type attribute list */
160 };
161
162 #define ISSOU(ty)   ((ty) == STRTY || (ty) == UNIONTY)
163
164 /*
165  * External definitions
166  */
167 struct swents {                 /* switch table */
168         struct swents *next;    /* Next struct in linked list */
169         CONSZ   sval;           /* case value */
170         int     slab;           /* associated label */
171 };
172 int mygenswitch(intTWORDstruct swents **, int);
173
174 extern  int blevel;
175 extern  int oldstyle;
176
177 extern  int linenonerrors;
178
179 extern  char *ftitle;
180 extern  struct symtab *cftnsp;
plunky
1.4
181 extern  int autooffmaxautooffargoff;
ragge
1.1
182
183 extern  OFFSZ inoff;
184
185 extern  int reached;
186 extern  int isinlining;
187 extern  int xinlinexgnu89xgnu99;
plunky
1.2
188 extern  int bdebugddebugedebugidebugndebug;
189 extern  int odebugpdebugsdebugtdebugxdebug;
ragge
1.1
190
191 /* various labels */
192 extern  int brklab;
193 extern  int contlab;
194 extern  int flostat;
195 extern  int retlab;
196 extern  int doing_initstatinit;
197 extern  short sztable[];
198 extern  char *astypnames[];
199
200 /* pragma globals */
201 extern int pragma_allpackedpragma_packedpragma_aligned;
202 extern char *pragma_renamed;
203
204 /*
205  * Flags used in the (elementary) flow analysis ...
206  */
207 #define FBRK            02
208 #define FCONT           04
209 #define FDEF            010
210 #define FLOOP           020
211
212 /*
213  * Location counters
214  */
215 #define NOSEG           -1
216 #define PROG            0               /* (ro) program segment */
217 #define DATA            1               /* (rw) data segment */
218 #define RDATA           2               /* (ro) data segment */
219 #define LDATA           3               /* (rw) local data */
220 #define UDATA           4               /* (rw) uninitialized data */
221 #define STRNG           5               /* (ro) string segment */
222 #define PICDATA         6               /* (rw) relocatable data segment */
223 #define PICRDATA        7               /* (ro) relocatable data segment */
224 #define PICLDATA        8               /* (rw) local relocatable data */
225 #define TLSDATA         9               /* (rw) TLS data segment */
226 #define TLSUDATA        10              /* (rw) TLS uninitialized segment */
227 #define CTORS           11              /* constructor */
228 #define DTORS           12              /* destructor */
229 #define NMSEG           13              /* other (named) segment */
230
plunky
1.5
231 extern int lastloc;
ragge
1.1
232 void locctr(int typestruct symtab *sp);
233 void setseg(int typechar *name);
234 void defalign(int al);
235 void symdirec(struct symtab *sp);
236
237 /*      mark an offset which is undefined */
238
239 #define NOOFFSET        (-10201)
240
241 /* declarations of various functions */
242 extern  NODE
243         *buildtree(intNODE *, NODE *r),
244         *mkty(unsignedunion dimfun *, struct attr *),
245         *rstruct(char *, int),
246         *dclstruct(struct rstack *),
247         *strend(int gtypechar *),
248         *tymerge(NODE *, NODE *),
249         *stref(NODE *),
250 #ifdef WORD_ADDRESSED
251         *offcon(OFFSZTWORDunion dimfun *, struct attr *),
252 #endif
253         *bcon(int),
254         *xbcon(CONSZstruct symtab *, TWORD),
255         *bpsize(NODE *),
256         *convert(NODE *, int),
257         *pconvert(NODE *),
258         *oconvert(NODE *),
259         *ptmatch(NODE *),
260         *makety(NODE *, TWORDTWORDunion dimfun *, struct attr *),
261         *block(intNODE *, NODE *, TWORDunion dimfun *, struct attr *),
262         *doszof(NODE *),
263         *talloc(void),
264         *optim(NODE *),
265         *clocal(NODE *),
266         *ccopy(NODE *),
267         *tempnode(intTWORDunion dimfun *, struct attr *),
268         *eve(NODE *),
269         *doacall(struct symtab *, NODE *, NODE *, int);
270 NODE    *intprom(NODE *);
271 OFFSZ   tsize(TWORDunion dimfun *, struct attr *),
272         psize(NODE *);
273 NODE *  typenode(NODE *new);
274 void    spalloc(NODE *, NODE *, OFFSZ);
275 char    *exname(char *);
276 NODE    *floatcon(char *);
277 NODE    *fhexcon(char *);
278 NODE    *bdty(int op, ...);
279 extern struct rstack *rpole;
280
281 int oalloc(struct symtab *, int *);
282 void deflabel(char *, NODE *);
283 void gotolabel(char *);
284 unsigned int esccon(char **);
285 void inline_start(struct symtab *);
286 void inline_end(void);
287 void inline_addarg(struct interpass *);
288 void inline_ref(struct symtab *);
289 void inline_prtout(void);
290 void inline_args(struct symtab **, int);
291 NODE *inlinetree(struct symtab *, NODE *, NODE *);
292 void ftnarg(NODE *);
293 struct rstack *bstruct(char *, intNODE *);
294 void moedef(char *);
295 void beginit(struct symtab *);
296 void simpleinit(struct symtab *, NODE *);
297 struct symtab *lookup(char *, int);
298 struct symtab *getsymtab(char *, int);
299 char *addstring(char *);
300 char *addname(char *);
301 void symclear(int);
302 struct symtab *hide(struct symtab *);
303 void soumemb(NODE *, char *, int);
304 int talign(unsigned intstruct attr *);
305 void bfcode(struct symtab **, int);
306 int chkftn(union arglist *, union arglist *);
307 void branch(int);
308 void cbranch(NODE *, NODE *);
309 void extdec(struct symtab *);
310 void defzero(struct symtab *);
311 int falloc(struct symtab *, intNODE *);
312 TWORD ctype(TWORD);  
313 void inval(CONSZintNODE *);
314 int ninval(CONSZintNODE *);
315 void infld(CONSZintCONSZ);
316 void zbits(CONSZint);
317 void instring(struct symtab *);
318 void inwstring(struct symtab *);
319 void plabel(int);
320 void bjobcode(void);
321 void ejobcode(int);
322 void calldec(NODE *, NODE *);
323 int cisreg(TWORD);
324 char *tmpsprintf(char *, ...);
325 char *tmpvsprintf(char *, va_list);
326 void asginit(NODE *);
327 void desinit(NODE *);
328 void endinit(int);
329 void endictx(void);
330 void sspinit(void);
331 void sspstart(void);
332 void sspend(void);
333 void ilbrace(void);
334 void irbrace(void);
335 CONSZ scalinit(NODE *);
336 void p1print(char *, ...);
337 char *copst(int);
338 int cdope(int);
339 void myp2tree(NODE *);
340 void lcommprint(void);
341 void lcommdel(struct symtab *);
342 NODE *funcode(NODE *);
343 struct symtab *enumhd(char *);
344 NODE *enumdcl(struct symtab *);
345 NODE *enumref(char *);
346 CONSZ icons(NODE *);
347 CONSZ valcast(CONSZ vTWORD t);
348 int mypragma(char *);
349 char *pragtok(char *);
350 int eat(int);
351 void fixdef(struct symtab *);
352 int cqual(TWORDTWORD);
353 void defloc(struct symtab *);
354 int fldchk(int);
355 int nncon(NODE *);
356 void cunput(char);
357 NODE *nametree(struct symtab *sp);
358 void *inlalloc(int size);
359 void *blkalloc(int size);
360 void pass1_lastchance(struct interpass *);
361 void fldty(struct symtab *p);
362 int getlab(void);
363 struct suedef *sueget(struct suedef *p);
364 void complinit(void);
365 NODE *structref(NODE *pint fchar *name);
366 NODE *cxop(int opNODE *lNODE *r);
367 NODE *imop(int opNODE *lNODE *r);
368 NODE *cxelem(int opNODE *p);
369 NODE *cxconj(NODE *p);
370 NODE *cxret(NODE *pNODE *q);
371 NODE *cast(NODE *pTWORD tTWORD q);
372 NODE *ccast(NODE *pTWORD tTWORD uunion dimfun *dfstruct attr *sue);
373 int andable(NODE *);
374 int conval(NODE *, intNODE *);
375 int ispow2(CONSZ);
376 void defid(NODE *qint class);
377 void efcode(void);
378 void ecomp(NODE *p);
379 int upoff(int sizeint alignmentint *poff);
380 void nidcl(NODE *pint class);
381 void eprint(NODE *, intint *, int *);
382 int uclass(int class);
383 int notlval(NODE *);
384 void ecode(NODE *p);
385 void ftnend(void);
386 void dclargs(void);
387 int suemeq(struct attr *s1struct attr *s2);
388 struct symtab *strmemb(struct attr *ap);
389 int yylex(void);
390 void yyerror(char *);
391 int pragmas_gcc(char *t);
392 NODE *cstknode(TWORD tunion dimfun *dfstruct attr *ap);
393 int concast(NODE *pTWORD t);
394 NODE *rmpconv(NODE *);
395 NODE *nlabel(int label);
396 int isbuiltin(char *n);
397
398 #ifdef SOFTFLOAT
399 typedef struct softfloat SF;
400 SF soft_neg(SF);
401 SF soft_cast(CONSZ vTWORD);
402 SF soft_plus(SFSF);
403 SF soft_minus(SFSF);
404 SF soft_mul(SFSF);
405 SF soft_div(SFSF);
406 int soft_cmp_eq(SFSF);
407 int soft_cmp_ne(SFSF);
408 int soft_cmp_ge(SFSF);
409 int soft_cmp_gt(SFSF);
410 int soft_cmp_le(SFSF);
411 int soft_cmp_lt(SFSF);
412 int soft_isz(SF);
413 CONSZ soft_val(SF);
414 #define FLOAT_NEG(sf)           soft_neg(sf)
415 #define FLOAT_CAST(v,t)         soft_cast(v, t)
416 #define FLOAT_PLUS(x1,x2)       soft_plus(x1, x2)
417 #define FLOAT_MINUS(x1,x2)      soft_minus(x1, x2)
418 #define FLOAT_MUL(x1,x2)        soft_mul(x1, x2)
419 #define FLOAT_DIV(x1,x2)        soft_div(x1, x2)
420 #define FLOAT_ISZERO(sf)        soft_isz(sf)
421 #define FLOAT_VAL(sf)           soft_val(sf)
422 #define FLOAT_EQ(x1,x2)         soft_cmp_eq(x1, x2)
423 #define FLOAT_NE(x1,x2)         soft_cmp_ne(x1, x2)
424 #define FLOAT_GE(x1,x2)         soft_cmp_ge(x1, x2)
425 #define FLOAT_GT(x1,x2)         soft_cmp_gt(x1, x2)
426 #define FLOAT_LE(x1,x2)         soft_cmp_le(x1, x2)
427 #define FLOAT_LT(x1,x2)         soft_cmp_lt(x1, x2)
428 #else
429 #define FLOAT_NEG(p)            -(p)
430 #define FLOAT_CAST(p,v)         (ISUNSIGNED(v) ? \
431                 (long double)(U_CONSZ)(p) : (long double)(CONSZ)(p))
432 #define FLOAT_PLUS(x1,x2)       (x1) + (x2)
433 #define FLOAT_MINUS(x1,x2)      (x1) - (x2)
434 #define FLOAT_MUL(x1,x2)        (x1) * (x2)
435 #define FLOAT_DIV(x1,x2)        (x1) / (x2)
436 #define FLOAT_ISZERO(p)         (p) == 0.0
437 #define FLOAT_VAL(p)            (CONSZ)(p)
438 #define FLOAT_EQ(x1,x2)         (x1) == (x2)
439 #define FLOAT_NE(x1,x2)         (x1) != (x2)
440 #define FLOAT_GE(x1,x2)         (x1) >= (x2)
441 #define FLOAT_GT(x1,x2)         (x1) > (x2)
442 #define FLOAT_LE(x1,x2)         (x1) <= (x2)
443 #define FLOAT_LT(x1,x2)         (x1) < (x2)
444 #endif
445
446 enum {  ATTR_NONE,
447
448         /* PCC used attributes */
449         ATTR_COMPLEX,   /* Internal definition of complex */
450         xxxATTR_BASETYP,        /* Internal; see below */
451         ATTR_QUALTYP,   /* Internal; const/volatile, see below */
452         ATTR_STRUCT,    /* Internal; element list */
453 #define ATTR_MAX ATTR_STRUCT
454
455 #ifdef GCC_COMPAT
456         /* type attributes */
457         GCC_ATYP_ALIGNED,
458         GCC_ATYP_PACKED,
459         GCC_ATYP_SECTION,
460         GCC_ATYP_TRANSP_UNION,
461         GCC_ATYP_UNUSED,
462         GCC_ATYP_DEPRECATED,
463         GCC_ATYP_MAYALIAS,
464
465         /* variable attributes */
466         GCC_ATYP_MODE,
467
468         /* function attributes */
469         GCC_ATYP_NORETURN,
470         GCC_ATYP_FORMAT,
471         GCC_ATYP_NONNULL,
472         GCC_ATYP_SENTINEL,
473         GCC_ATYP_WEAK,
474         GCC_ATYP_FORMATARG,
475         GCC_ATYP_GNU_INLINE,
476         GCC_ATYP_MALLOC,
477         GCC_ATYP_NOTHROW,
478         GCC_ATYP_CONST,
479         GCC_ATYP_PURE,
480         GCC_ATYP_CONSTRUCTOR,
481         GCC_ATYP_DESTRUCTOR,
482         GCC_ATYP_VISIBILITY,
483         GCC_ATYP_STDCALL,
484         GCC_ATYP_CDECL,
485         GCC_ATYP_WARN_UNUSED_RESULT,
486         GCC_ATYP_USED,
487         GCC_ATYP_NO_INSTR_FUN,
488         GCC_ATYP_NOINLINE,
489         GCC_ATYP_ALIAS,
490         GCC_ATYP_WEAKREF,
491         GCC_ATYP_ALLOCSZ,
492         GCC_ATYP_ALW_INL,
493         GCC_ATYP_TLSMODEL,
494         GCC_ATYP_ALIASWEAK,
495
496         /* other stuff */
497         GCC_ATYP_BOUNDED,       /* OpenBSD extra boundary checks */
498
499         GCC_ATYP_MAX
500 #endif
501 };
502
503
504 /*
505 #ifdef notdef
506  * ATTR_BASETYP has the following layout:
507  * aa[0].iarg has size
508  * aa[1].iarg has alignment
509 #endif
510  * ATTR_QUALTYP has the following layout:
511  * aa[0].iarg has CON/VOL + FUN/ARY/PTR
512  * Not defined yet...
513  * aa[3].iarg is dimension for arrays (XXX future)
514  * aa[3].varg is function defs for functions.
515  */
516 #ifdef notdef
517 #define atypsz  aa[0].iarg
518 #define aalign  aa[1].iarg
519 #endif
520
521 /*
522  * ATTR_STRUCT member list.
523  */
524 #define amlist  aa[0].varg
525 #define amsize  aa[1].iarg
526 #define strattr(x)      (attr_find(x, ATTR_STRUCT))
527
528 #define iarg(x) aa[x].iarg
529 #define sarg(x) aa[x].sarg
530 #define varg(x) aa[x].varg
531
532 void gcc_init(void);
533 int gcc_keyword(char *, NODE **);
534 struct attr *gcc_attr_parse(NODE *);
535 void gcc_tcattrfix(NODE *);
536 struct gcc_attrib *gcc_get_attr(struct suedef *, int);
537 void dump_attr(struct attr *gap);
538
539 struct attr *attr_add(struct attr *origstruct attr *new);
540 struct attr *attr_new(intint);
541 struct attr *attr_find(struct attr *, int);
542 struct attr *attr_copy(struct attr *srcstruct attr *dstint nelem);
543 struct attr *attr_dup(struct attr *apint n);
544
ragge
1.3
545 #ifndef NO_C_BUILTINS
546 struct bitable {
547         char *name;
548         NODE *(*fun)(const struct bitable *, NODE *a);
549         short flags;
550 #define BTNOPROTO       001
551 #define BTNORVAL        002
552 #define BTNOEVE         004
553         short narg;
554         TWORD *tp;
555         TWORD rt;
556 };
557
558 NODE *builtin_check(struct symtab *, NODE *a);
559 void builtin_init(void);
560 #endif
561
562
ragge
1.1
563 #ifdef STABS
564 void stabs_init(void);
565 void stabs_file(char *);
566 void stabs_efile(char *);
567 void stabs_line(int);
568 void stabs_rbrac(int);
569 void stabs_lbrac(int);
570 void stabs_func(struct symtab *);
571 void stabs_newsym(struct symtab *);
572 void stabs_chgsym(struct symtab *);
573 void stabs_struct(struct symtab *, struct attr *);
574 #endif
575
576 #ifndef CHARCAST
577 /* to make character constants into character connstants */
578 /* this is a macro to defend against cross-compilers, etc. */
579 #define CHARCAST(x) (char)(x)
580 #endif
581
582 /* sometimes int is smaller than pointers */
583 #if SZPOINT(CHAR) <= SZINT
584 #define INTPTR  INT
585 #elif SZPOINT(CHAR) <= SZLONG
586 #define INTPTR  LONG
587 #elif SZPOINT(CHAR) <= SZLONGLONG
588 #define INTPTR  LONGLONG
589 #else
590 #error int size unknown
591 #endif
592
593 /* Generate a bitmask from a given type size */
594 #define SZMASK(y) ((((1LL << ((y)-1))-1) << 1) | 1)
595
596 /*
597  * C compiler first pass extra defines.
598  */
599 #define QUALIFIER       (MAXOP+1)
600 #define CLASS           (MAXOP+2)
601 #define RB              (MAXOP+3)
602 #define DOT             (MAXOP+4)
603 #define ELLIPSIS        (MAXOP+5)
604 #define TYPE            (MAXOP+6)
605 #define LB              (MAXOP+7)
606 #define COMOP           (MAXOP+8)
607 #define QUEST           (MAXOP+9)
608 #define COLON           (MAXOP+10)
609 #define ANDAND          (MAXOP+11)
610 #define OROR            (MAXOP+12)
611 #define NOT             (MAXOP+13)
612 #define CAST            (MAXOP+14)
613 #define STRING          (MAXOP+15)
614
615 /* The following must be in the same order as their NOASG counterparts */
616 #define PLUSEQ          (MAXOP+16)
617 #define MINUSEQ         (MAXOP+17)
618 #define DIVEQ           (MAXOP+18)
619 #define MODEQ           (MAXOP+19)
620 #define MULEQ           (MAXOP+20)
621 #define ANDEQ           (MAXOP+21)
622 #define OREQ            (MAXOP+22)
623 #define EREQ            (MAXOP+23)
624 #define LSEQ            (MAXOP+24)
625 #define RSEQ            (MAXOP+25)
626
627 #define UNASG           (-(PLUSEQ-PLUS))+
628
629 #define INCR            (MAXOP+26)
630 #define DECR            (MAXOP+27)
631 #define SZOF            (MAXOP+28)
632 #define CLOP            (MAXOP+29)
633 #define ATTRIB          (MAXOP+30)
634 #define XREAL           (MAXOP+31)
635 #define XIMAG           (MAXOP+32)
636 #define TYMERGE         (MAXOP+33)
637 #define LABEL           (MAXOP+34)
638
639 /*
640  * The following types are only used in pass1.
641  */
642 #define SIGNED          (MAXTYPES+1)
643 #define FARG            (MAXTYPES+2)
644 #define FIMAG           (MAXTYPES+3)
645 #define IMAG            (MAXTYPES+4)
646 #define LIMAG           (MAXTYPES+5)
647 #define FCOMPLEX        (MAXTYPES+6)
648 #define COMPLEX         (MAXTYPES+7)
649 #define LCOMPLEX        (MAXTYPES+8)
650 #define ENUMTY          (MAXTYPES+9)
651
652 #define ISFTY(x)        ((x) >= FLOAT && (x) <= LDOUBLE)
653 #define ISCTY(x)        ((x) >= FCOMPLEX && (x) <= LCOMPLEX)
654 #define ISITY(x)        ((x) >= FIMAG && (x) <= LIMAG)
655 #define ANYCX(p) (p->n_type == STRTY && attr_find(p->n_ap, ATTR_COMPLEX))
656
657 #define coptype(o)      (cdope(o)&TYFLG)
658 #define clogop(o)       (cdope(o)&LOGFLG)
659 #define casgop(o)       (cdope(o)&ASGFLG)
660
661 #include <cxxdefs.h>
662
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-27 13:57 +0100