/* ---------------------------------------------------------------------- */
/*                   Copyright (C) 1991 by Natrlich!                     */
/*                      This file is copyrighted!                         */
/*                Refer to the documentation for details.                 */
/* ---------------------------------------------------------------------- */
#ifndef _LABELS_
#define _LABELS_

#if LINKER || LIBRARIAN
#define SEP  31
#else
#define SEP  30
#endif

/* number of different symbol tables */

#define L_NORMAL     0x0            /* Like FOO = $4000 */
#define L_ZERO       0x1            /* Like FOO = $40   */
#define L_EQU        0x2            /* Like FOO .= $4   */
#define L_SPECIAL    0x8            /* LIKE __RUN       */
#define L_LINKZERO   0x10           /* Like FOO == $40  */
#define L_REF        0x40
#define L_PC         0x8000         /* is label PC-relative ?? */
#define L_MASK1      (L_PC  | L_LINKZERO)
#define L_MASK2      (L_EQU | L_SPECIAL)
#define q_pcrel( p)  ((sword)((p)->type) < 0)
#define dumpable( x) (((x)->type & L_MASK1) && ! ((x)->type & L_MASK2))

#define FIX_WCODE    0x1       /* Fix 6502 word */
#define FIX_ZCODE    0x2       /* Fix 6502 byte */
#define FIX_SZCODE   0x3       /* Fix ATARI screen character */
#define FIX_BRANCH   0x4       /* Fix a 6502 branch byte */
#define FIX_DCODE    0x5       /* Fix 68000 word */
#define FIX_NOTHING  0x6       /* Fix nothing (for copexpr f.i.) */
#define FIX_LABEL    0x10      /* Fix a label */
#define FIX_NOTYET   0x20      /* For linker (obsolete) */

#define unvalued( x)   ((x)->l || (x)->label)      /* for expressions */
#define valued( x)     (! unvalued( x))
#define e_pcrel( p)    ((signed char)((p)->op) < 0)
#define is_msb( p)     (((p)->op & O_BITS) == O_MSB)  
/* ----------------------------------------------------- */
/*      Search for a label that fits the description     */
/* ----------------------------------------------------- */
#define found( p, x)  (p && p->hash == x)

#define einlinker( head, tail, last, used, p)            \
   if( last)                                             \
   {                                                     \
      MESS("last was there");                            \
      if( last->before)                                  \
      {                                                  \
         MESS("last->before exists");                    \
         last->before->next = p;                         \
         p->before = last->before;                       \
         p->next   = last;                               \
      }                                                  \
      else                                               \
      {                                                  \
         MESS("last->before does not exist");            \
         p->before = 0;                                  \
         p->next   = head[used];                         \
         head[ used] = p;                                \
      }                                                  \
      p->next->before = p;                               \
   }                                                     \
   else                                                  \
      if( tail[used])                                    \
      {                                                  \
         MESS("tail exists");                            \
         tail[used]->next = p;                           \
         p->before  = tail[used];                        \
         p->next    = 0;                                 \
         tail[used] = p;                                 \
      }                                                  \
      else                                               \
      {                                                  \
         MESS("head & tail created");                    \
         head[used] = tail[used] = p;                    \
         p->next = p->before = 0;                        \
      }

#define auslinker( head, tail, last, used, p)            \
   if( head[ used] == p)                                 \
   {                                                     \
      if( head[ used] = p->next)                         \
         p->next->before = 0;                            \
   }                                                     \
   else                                                  \
      p->before->next = p->next;                         \
   if( tail[ used] == p)                                 \
   {                                                     \
      if( tail[ used] = p->before)                       \
         tail[ used]->next = 0;                          \
   }                                                     \
   else                                                  \
      p->next->before = p->before

#endif