/* Micro-C Generic Code Generation Part */

/*
************************************************************************
** Copyright (C) 2006 Shinji Kono
** 連絡先： 琉球大学情報工学科 河野 真治  
** （E-Mail Address: kono@ie.u-ryukyu.ac.jp）
**
**    このソースのいかなる複写，改変，修正も許諾します。ただし、
**    その際には、誰が貢献したを示すこの部分を残すこと。
**    再配布や雑誌の付録などの問い合わせも必要ありません。
**    営利利用も上記に反しない範囲で許可します。
**    バイナリの配布の際にはversion messageを保存することを条件とします。
**    このプログラムについては特に何の保証もしない、悪しからず。
**
**    Everyone is permitted to do anything on this program 
**    including copying, modifying, improving,
**    as long as you don't try to pretend that you wrote it.
**    i.e., the above copyright notice has to appear in all copies.  
**    Binary distribution requires original version messages.
**    You don't have to ask before copying, redistribution or publishing.
**    THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE.
***********************************************************************
 */
#include <stdio.h>
#include "mc.h"
#include "mc-parse.h"
#include "mc-codegen.h"
#include "mc-code.h"
#include "mc-switch.h"
#include "mc-inline.h"
#include "conv/conv.h"

extern Converter *conv;

int use;       /* generated value will be used */
char *init_src;
int size_of_pointer;
int size_of_int;
int size_of_short;
int size_of_float;
int size_of_double;
int size_of_longlong;
int size_of_vector;
int bit_of_byte;
int endian;
int struct_align;

static void assign(int e1);
#if ASM_CODE
static void gen_asm(int asm0,int in,int out,int opt,int e);
#endif
static void compatible(int t1, int t2);
static int contains(int e,int type);
static int contains_in_list(int e,int type);
static int contains_in_list_p(int e,int (*p)(int));
static void iassop(int e1);
static int is_same_type(int e1,int e2);
static void machinop(int e1);
static int register_to_lvar(int e);
static void remove0(int *parent,int e) ;
static void sassign(int e1);
static int gen_decl_data0(int v,int target_type,int init,int offset);

#if FLOAT_CODE

/* floating point */

static void dassop(int e1);
static void dmachinop(int e1,int d);
static void dassign(int e1);

#endif
#if LONGLONG_CODE
static void lassop(int e1);
static void lmachinop(int e1);
static void lassign(int e1);
#endif

#if BIT_FIELD_CODE
static int bit_field_repl(int e1,int e2,int t);
static int bit_field(int e1,int t);
static int bassign(int e1,int e2,int t);
static int bassop(int e1,int e2,int op,int t,int post);
#endif

extern void
codegen_init()
{
    /* called only once */
    code_init();
}

extern void
codegen_reinit()
{
    /* called for each file */
    emit_reinit();
}

extern void
codegen_decl_init()
{
    /* called before each declaration */
    emit_init();
    init_free_lvar_list();
}

/**
    make register argments
    and save it into memory (sigh...)
    we should postpone code_save_argument_register
 */
extern void 
arg_register(NMTBL *fnptr, int in)
{
    code_arg_register(fnptr, in);
}

extern int
gexpr(int e1,int use0)
{
    if (chk==1) return INT;
    gexpr_init();
    use = use0;
    return g_expr0(e1);
}

/* gexpr for value unused */

extern int
g_expr_u(int e1)
{
    int t;
    int suse = use; use=0;
    t=g_expr0(e1);
    use=suse;
    return t;
}

/* gexpr for value used */

extern int
g_expr(int e1)
{
    int t;
    int suse = use; use=1;
    t=g_expr0(e1);
    use=suse;
    return t;
}

/* gexpr for used flag untouched */

extern int
g_expr0(int e1)
{
  int e2,e3,t,d,t1;
  NMTBL *n;

  if (inmode) {
        error(-1);
        // return (parse = list3(ST_COMP,parse,e1));
  }
  if (!e1 ||(!control && !IS_STATEMENT(car(e1)))) return VOID;

  for(;e1;e1=e2) {
    code_gexpr(e1);
    conv->expr_(e1);

    e2 = cadr(e1);
    switch (car(e1)){
    case GVAR:   case STATIC:   
        code_gvar(e1,USE_CREG);
        return ADDRESS;
    case RGVAR: 
        code_rgvar(e1,USE_CREG);
        return INT;
    case URGVAR:
        code_rgvar(e1,USE_CREG);
        return UNSIGNED;
    case CRGVAR:
        code_crgvar(e1,USE_CREG,1,1);
        return CHAR;
    case CURGVAR:
        code_crgvar(e1,USE_CREG,0,1);
        return UCHAR;
    case SRGVAR:
        code_crgvar(e1,USE_CREG,1,size_of_short);
        return CHAR;
    case SURGVAR:
        code_crgvar(e1,USE_CREG,0,size_of_short);
        return UCHAR;
    case LVAR: 
        code_lvar(e2,USE_CREG);
        return ADDRESS;
    case REGISTER:
        code_register(e2,USE_CREG);
        return INT;
#if FLOAT_CODE
    case DREGISTER:
        code_dregister(e2,USE_CREG,1);
        return DOUBLE;
    case FREGISTER:
        code_dregister(e2,USE_CREG,0);
        return FLOAT;
#endif
#if LONGLONG_CODE
    case LREGISTER:
        code_lregister(e2,USE_CREG);
        return LONGLONG;
#endif
    case RLVAR:
        if (lp64) code_crlvar(e2,USE_CREG,1,size_of_int);
        else code_rlvar(e2,USE_CREG);
        return INT;
    case URLVAR:
        if (lp64) code_crlvar(e2,USE_CREG,0,size_of_int);
        else code_rlvar(e2,USE_CREG);
        return UNSIGNED;
    case CRLVAR:
        code_crlvar(e2,USE_CREG,1,1);
        return CHAR;
    case CURLVAR:
        code_crlvar(e2,USE_CREG,0,1);
        return UCHAR;
    case SRLVAR:
        code_crlvar(e2,USE_CREG,1,size_of_short);
        return CHAR;
    case SURLVAR:
        code_crlvar(e2,USE_CREG,0,size_of_short);
        return UCHAR;
#if FLOAT_CODE
    case FRLVAR:
        code_drlvar(e2,0,USE_CREG);
        return FLOAT;
    case FRGVAR:
        code_drgvar(e1,0,USE_CREG);
        return FLOAT;
    case DRLVAR:
        code_drlvar(e2,1,USE_CREG);
        return DOUBLE;
    case DRGVAR:
        code_drgvar(e1,1,USE_CREG);
        return DOUBLE;
#endif
#if LONGLONG_CODE
    case LRLVAR:
        code_lrlvar(e2,USE_CREG);
        return LONGLONG;
    case LRGVAR:
        code_lrgvar(e1,USE_CREG);
        return LONGLONG;
    case LURLVAR:
        code_lrlvar(e2,USE_CREG);
        return ULONGLONG;
    case LURGVAR:
        code_lrgvar(e1,USE_CREG);
        return ULONGLONG;
#endif
    case FNAME:
        code_fname(ncaddr(e1),USE_CREG);
        return ADDRESS;
    case LABEL:
        if (car(e2)!=LVAR) error(-1);
        code_label_value(cadr(e2),USE_CREG);
        return ADDRESS;
    case CONST:  /* 代入する値が0でも特別な処理はしない */
        code_const(e2,USE_CREG);
        return INT;
#if FLOAT_CODE
    case DCONST:
        code_dconst(e1,USE_CREG,1);
        return DOUBLE;
    case FCONST:
        code_dconst(e1,USE_CREG,0);
        return FLOAT;
#endif
#if LONGLONG_CODE
    case LCONST:
        code_lconst(e1,USE_CREG);
        return LONGLONG;
#endif
    case STRINGS:
        code_strings(e2,USE_CREG) ;
        return ADDRESS;
    case STRING:
        code_string(e1,USE_CREG);
        return ADDRESS;
    case FUNCTION:
        if (car(e2)==FNAME&&is_code(ncaddr(e2))) {
            // error(FNERR);
            jump(e1,0);
            return VOID;
        } 
        t = function(e1);
        return t;
    case JUMP:
        if (car(e2)==FNAME&&is_function(ncaddr(e2))) {
            // error(GTERR);
            return function(e1);
        }
        jump(e2,caddr(e1));
        return VOID;
    case ARRAY:
        if (chk==2) { // for generation check (?)
            indop(e1);
            t = type;
            g_expr0(e2);
            g_expr0(caddr(e1));
            code_gexpr(e1);
            return t;
        }
        e1=binop(ADD,e2,caddr(e1),cadddr(e1),caddddr(e1));
        e1 = indop(e1); t = type;
        g_expr0(e1);
        return t;
    case PERIOD:
        nptr = ncadddr(e1);
        type = caddr(e1);
        e1 = strop(e2,0); t = type;
        if (chk) return t;
        g_expr0(e1);
        return t;
    case ARROW:
        nptr = ncadddr(e1);
        type = caddr(e1);
        e1 = strop(e2,1); t = type;
        if (chk) return t;
        g_expr0(e1);
        return t;
    case INLINE:
        return gen_inline(e1,0);
    case INDIRECT:
        return g_expr0(e2);
    case RINDIRECT:  
        code_rindirect(e2,USE_CREG,caddr(e1),1,0); return INT;
    case URINDIRECT:  
        code_rindirect(e2,USE_CREG,caddr(e1),0,0); return UNSIGNED;
    case CRINDIRECT: 
        code_rindirect(e2,USE_CREG,caddr(e1),1,1); return CHAR;
    case CURINDIRECT:
        code_rindirect(e2,USE_CREG,caddr(e1),0,1); return UCHAR;
    case SRINDIRECT: 
        code_rindirect(e2,USE_CREG,caddr(e1),1,size_of_short); return SHORT;
    case SURINDIRECT:
        code_rindirect(e2,USE_CREG,caddr(e1),0,size_of_short); return USHORT;
#if FLOAT_CODE
    case FRINDIRECT:
        return code_drindirect(e2,USE_CREG,caddr(e1),0);
    case DRINDIRECT: 
        return code_drindirect(e2,USE_CREG,caddr(e1),1);
#endif
#if LONGLONG_CODE
    case LRINDIRECT: 
        return code_lrindirect(e2,USE_CREG,caddr(e1),0);
    case LURINDIRECT:
        return code_lrindirect(e2,USE_CREG,caddr(e1),1);
#endif
    case ADDRESS:
        if (car(e2)==REGISTER||car(e2)==DREGISTER||car(e2)==FREGISTER)
            return register_to_lvar(e2); /* too late? */
        else
            return g_expr0(e2);
    case MINUS:  /* レジスタに対し、neglを実行すれば実現可能 */
        g_expr0(e2); code_neg(USE_CREG);
        return INT;
#if LONGLONG_CODE
    case LMINUS: 
        g_expr0(e2); code_lneg(USE_CREG);
        return LONGLONG;
#endif
#if FLOAT_CODE
    case DMINUS: 
        g_expr0(e2); code_dneg(USE_CREG,1);
        return DOUBLE;
    case FMINUS: 
        g_expr0(e2); code_dneg(USE_CREG,0);
        return FLOAT;
#endif
    case CONV: 
        g_expr0(e2); 
        switch(caddr(e1)) {
        case I2C: code_i2c(USE_CREG); return INT;
        case I2S: code_i2s(USE_CREG); return INT;
        case U2UC: code_u2uc(USE_CREG); return UNSIGNED;
        case U2US: code_u2us(USE_CREG); return UNSIGNED;
#if FLOAT_CODE
        case I2D: code_i2d(USE_CREG); return DOUBLE;
        case D2I: code_d2i(USE_CREG); return INT;
        case U2D: code_u2d(USE_CREG); return DOUBLE;
        case F2U: code_f2u(USE_CREG); return UNSIGNED;
        case I2F: code_i2f(USE_CREG); return FLOAT;
        case F2I: code_f2i(USE_CREG); return INT;
        case U2F: code_u2f(USE_CREG); return FLOAT;
        case D2U: code_d2u(USE_CREG); return UNSIGNED;
        case D2F: code_d2f(USE_CREG); return FLOAT;
        case F2D: code_f2d(USE_CREG); return DOUBLE;
#endif
#if LONGLONG_CODE
        case  I2LL: code_i2ll(USE_CREG); return LONGLONG;
        case  I2ULL: code_i2ull(USE_CREG); return ULONGLONG;
        case  U2LL: code_u2ll(USE_CREG); return LONGLONG;
        case  U2ULL: code_u2ull(USE_CREG); return ULONGLONG;
        case  LL2I: code_ll2i(USE_CREG); return INT;
        case  LL2U: code_ll2u(USE_CREG); return UNSIGNED;
        case  ULL2I: code_ull2i(USE_CREG); return INT;
        case  ULL2U: code_ull2u(USE_CREG); return UNSIGNED;
#if FLOAT_CODE
        case  D2LL: code_d2ll(USE_CREG); return LONGLONG;
        case  D2ULL: code_d2ull(USE_CREG); return ULONGLONG;
        case  F2LL: code_f2ll(USE_CREG); return LONGLONG;
        case  F2ULL: code_f2ull(USE_CREG); return ULONGLONG;
        case  LL2D: code_ll2d(USE_CREG); return DOUBLE;
        case  LL2F: code_ll2f(USE_CREG); return FLOAT;
        case  ULL2D: code_ull2d(USE_CREG); return DOUBLE;
        case  ULL2F: code_ull2f(USE_CREG); return FLOAT;
#endif
#endif

        default:
            error(-1); return INT;
        }
    case BNOT:   /* ~ */
        g_expr0(e2); code_not(USE_CREG);
        return INT;
    case LNOT:   /* !  */
        g_expr0(e2); code_lnot(USE_CREG);
        return INT;
    case PREINC:
        code_preinc(e1,e2,caddr(e1),1,cadddr(e1),USE_CREG);
        return INT;
    case UPREINC:
        code_preinc(e1,e2,caddr(e1),0,cadddr(e1),USE_CREG);
        return INT;
    case POSTINC:
        code_postinc(e1,e2,caddr(e1),1,cadddr(e1),USE_CREG);
        return INT;
    case UPOSTINC:
        code_postinc(e1,e2,caddr(e1),0,cadddr(e1),USE_CREG);
        return INT;
#if FLOAT_CODE
    case DPREINC:   /* ++d */
        code_dpreinc(e1,e2,1,USE_CREG);
        return DOUBLE;
    case DPOSTINC:  /* d++ */
        code_dpostinc(e1,e2,1,USE_CREG);
        return DOUBLE;
    case FPREINC:   /* ++f */
        code_dpreinc(e1,e2,0,USE_CREG);
        return FLOAT;
    case FPOSTINC:  /* f++ */
        code_dpostinc(e1,e2,0,USE_CREG);
        return FLOAT;
#endif
#if LONGLONG_CODE
    case LPREINC:   /* ++d */
        code_lpreinc(e1,e2,USE_CREG);
        return LONGLONG;
    case LPOSTINC:  /* d++ */
        code_lpostinc(e1,e2,USE_CREG);
        return LONGLONG;
    case LUPREINC:   /* ++d */
        code_lpreinc(e1,e2,USE_CREG);
        return ULONGLONG;
    case LUPOSTINC:  /* d++ */
        code_lpostinc(e1,e2,USE_CREG);
        return ULONGLONG;
#endif
    case MUL: case UMUL:
    case DIV: case UDIV:           
    case MOD: case UMOD:
    case LSHIFT: case ULSHIFT: case RSHIFT: case URSHIFT:
    case ADD: case SUB: case BAND: case EOR: case BOR: case CMP: case CMPGE:
    case UCMP: case CMPEQ: case CMPNEQ: case UCMPGE:
        machinop(e1);
        return INT;
#if FLOAT_CODE
    case DMUL: case DDIV:
    case DADD: case DSUB:
    case DCMP: case DCMPGE: case DCMPEQ: case DCMPNEQ:
        dmachinop(e1,1);
        return DOUBLE;
    case FMUL: case FDIV:
    case FADD: case FSUB:
    case FCMP: case FCMPGE: case FCMPEQ: case FCMPNEQ:
        dmachinop(e1,0);
        return FLOAT;
#endif
#if LONGLONG_CODE
    case LMUL: case LUMUL:
    case LDIV: case LUDIV:         
    case LMOD: case LUMOD:
    case LLSHIFT: case LULSHIFT: case LRSHIFT: case LURSHIFT:
    case LADD: case LSUB: case LBAND: case LEOR: case LBOR: case LCMP:
        lmachinop(e1);
        return INT;
#endif
    case COND:        /* a?0:1 should consider non-brach instruction */
    case UCOND:
        d = INT; goto cond_case;
    case LUCOND:
    case LCOND:
        d = LONGLONG; goto cond_case;
    case DCOND:
        d = DOUBLE; goto cond_case;
    case FCOND:
        d = FLOAT;
cond_case:
        e2=fwdlabel();
        if (caddr(e1)) {
            b_expr(cadr(e1),0,e2,0);
            g_expr0(caddr(e1));
        } else {  // gcc extenstion  a?:DEF 
            bexpr(cadr(e1),0,e2); // value used
        }
        t = code_get_fixed_creg(USE_CREG,d);
        gen_jmp(e3=fwdlabel());
        fwddef(e2);
        t1=g_expr0(cadddr(e1));
        code_set_fixed_creg(t,1,d);
        fwddef(e3);
        return t1;
    case STASS: 
        sassign(e1);
        return STRUCT;
    case ASS: case CASS: case SASS:
        assign(e1);
        return INT;
    case SASSOP: case SUASSOP:
    case ASSOP: case CASSOP: case CUASSOP:
        iassop(e1);
        return INT;
#if FLOAT_CODE
    case FASS: 
        dassign(e1);
        return FLOAT;
    case DASS: 
        dassign(e1);
        return DOUBLE;
    case FASSOP:
        dassop(e1);
        return FLOAT;
    case DASSOP: 
        dassop(e1);
        return DOUBLE;
#endif
#if LONGLONG_CODE
    case LASS: 
        lassign(e1);
        return LONGLONG;
    case LASSOP: case LUASSOP:
        lassop(e1);
        return LONGLONG ;
#endif
    case ALLOCA:
        code_alloca(e2,USE_CREG);
        return list2(POINTER,CHAR);
    case BUILTINP:
        /* Too late. Should be evaluated in pexpr. */
        code_const(is_const(e2),USE_CREG);
        return INT;
    case BUILTIN_FABSF:
        code_builtin_fabsf(e2);
        return FLOAT;
    case BUILTIN_FABS:
    case BUILTIN_FABSL:
        code_builtin_fabs(e2);
        return DOUBLE;
    case BUILTIN_INFF:
        code_builtin_inff();
        return FLOAT;
    case BUILTIN_INF:
    case BUILTIN_INFL:
        code_builtin_inf();
        return DOUBLE;
    case COMMA:
        g_expr_u(e2);
        return g_expr0(caddr(e1));
    case RETURN:
        n = ncaddr(e1);
        if (retcont==0)
            retcont=fwdlabel();
        code_return(USE_CREG);
        return VOID;
    case ENVIRONMENT:
        code_environment(USE_CREG);
        return ADDRESS;
    case LCALL:
        code_save_stacks();
        gen_jmp(e2);
        fwddef(caddr(e1));
        return VOID;
#if BIT_FIELD_CODE
    case RBIT_FIELD:
        return bit_field(e2,caddr(e1) /* type */);
    case BASS:
        return bassign(e2,caddr(e1),cadr(cadddr(e1))/* type */);
    case BPREINC:
        return bassop(e2,list2(CONST,caddr(e1)),ADD,
                                    cadddr(e1)/* type */,0);
    case BPOSTINC:
        return bassop(e2,list2(CONST,caddr(e1)),ADD,
                                    cadddr(e1)/* type */,1);
    case BASSOP:
        return bassop(e2,caddr(e1),car(cadddr(e1)),/* op */
                                    cadr(cadddr(e1))/* type */,0);
#endif
#if ASM_CODE
    case ASM:
        gen_asm(car(e2),cadr(e2),caddr(e2),cadddr(e2),caddr(e1));
        /*        asm    in (str) out (str) opt(str)   expr */
        return VOID;
#endif
    case CAST:
        error(-1); // correct_type is too late for contains_p
        type = cadddr(e1);
        e2 = correct_type(e2,caddr(e1));
        continue;
    case DECL_DATA:
        e1 =  gen_decl_data(e1,0);
        return e1;
    case ST_DECL:         checkretpening(); st_decl(e1);  break;
    case ST_IF:           checkretpening(); st_if(e1);    break;
    case ST_DO:           checkretpening(); st_do(e1);    break;
    case ST_WHILE:        checkretpening(); st_while(e1); break;
    case ST_FOR:          checkretpening(); st_for(e1);   break;
    case ST_SWITCH:       checkretpening(); st_switch(e1);        break;
    case ST_COMP:         checkretpening();st_comp(e1);  break;
    case ST_BREAK:        st_break(e1); break;
    case ST_CONTINUE:     st_continue(e1);      break;
    case ST_CASE:         st_case(e1);  break;
    case ST_DEFAULT:      st_default(e1);       break;
    case ST_RETURN:       st_return(e1);        break;
    case ST_GOTO:         checkret(); st_goto(e1);  break;
    case ST_ASM:          checkret(); st_asm(e1);   break;
    case ST_LABEL:        st_label(e1); break;
    case ST_COMMENT:      st_comment(e1);       break;
    case ST_OP:
        checkretpening(); 
        e3=caddr(e1);
        e1=binop(e2,car(e1),cadr(e3),caddr(e3),cadddr(e3));
        continue;
    case IVAR:            error(-1);    break;
    case 0:               
        error(-1);
        break; // empty case
    default:
        code_bool(e1,USE_CREG); /* type? */
        return INT;
    }
  }
  return VOID;
}

extern int
rop_dual(int op)
{
    //   x op y => y dual(op) x
    switch(op) {
    case GT: return LT;
    case UGT: return ULT;
    case GE: return LE;
    case UGE: return ULE;
    case LT: return GT;
    case ULT: return UGT;
    case LE: return GE;
    case ULE: return UGE;
    case DOP+GT: return DOP+LT;
    case DOP+GE: return DOP+LE;
    case DOP+LT: return DOP+GT;
    case DOP+LE: return DOP+GE;
    case FOP+GT: return FOP+LT;
    case FOP+GE: return FOP+LE;
    case FOP+LT: return FOP+GT;
    case FOP+LE: return FOP+GE;

    case LOP+GT: return LOP+LT;
    case LOP+GE: return LOP+LE;
    case LOP+LT: return LOP+GT;
    case LOP+LE: return LOP+GE;
    case LOP+UGT: return FOP+ULT;
    case LOP+UGE: return FOP+ULE;
    case LOP+ULT: return FOP+UGT;
    case LOP+ULE: return FOP+UGE;
    }
    return op;
}

/* bexpr for value unused */
/*   l1 ... label for branch */
/*   return 0 if l1 is not used, otherwise return l1 */

static int
bexpr_u(int e1, char cond, int l1)
{
    int op = car(e1);
    conv->expr_(e1);
    if (chk) return l1;

    // is this switch really useful?
    switch(op) {
        case GT: case UGT: case GE: case UGE: case LT: 
        case ULT: case LE: case ULE:  
        case DOP+GT: case DOP+GE: case DOP+LT: case DOP+LE:  
        case FOP+GT: case FOP+GE: case FOP+LT: case FOP+LE:  
        case FOP+EQ: case FOP+NEQ:  
        case EQ: case NEQ: case DOP+EQ: case DOP+NEQ:
        switch(car(cadr(e1))) {
        case CONST: case DCONST: case FCONST: case LCONST:
            return b_expr(list3(rop_dual(op),caddr(e1),cadr(e1)),cond,l1,0);
        }
    }
    return b_expr(e1,cond,l1,0);
}

/* bexpr for value used */

extern int
bexpr(int e1, char cond, int l1)
{
    int uses = use; use=1;
    l1 = bexpr_u(e1, cond, l1);
    use = uses;
    return l1;
}

/* branch expression generator    */
/*    if (cond?e1:!e1) goto  l1   */
/* 1 or 0 is return for code_bool */

extern int
b_expr(int e1, char cond, int l1,int err)
{
    int e2,l2,t;
    code_save_stacks();

    if (!control) return l1;
    l2 = 0;
    e2=cadr(e1);
    switch(car(e1)) {
    case LNOT:
        return b_expr(e2,!cond,l1,0);
    case GT: case GE: case LT: case LE:
    case EQ: case NEQ:
        return rexpr(e1,l1,cond,INT);
        return l1;
    case UGT: case UGE: case ULT: case ULE:
        return rexpr(e1,l1,cond,UNSIGNED);
#if FLOAT_CODE
    case DOP+GT:
    case DOP+GE:
    case DOP+EQ:
    case DOP+NEQ:
    case FOP+GT:
    case FOP+GE:
    case FOP+EQ:
    case FOP+NEQ:
        return drexpr(cadr(e1),caddr(e1),l1,car(e1),cond);
    case FOP+LT:
    case FOP+LE:
    case DOP+LT:
    case DOP+LE:
        return drexpr(caddr(e1),cadr(e1),l1,rop_dual(car(e1)),cond);
#endif
#if LONGLONG_CODE
    case LOP+GT:
    case LOP+GE:
    case LOP+EQ:
    case LOP+NEQ:
    case LOP+UGT:
    case LOP+UGE:
        return lrexpr(cadr(e1),caddr(e1),l1,car(e1),cond);
    case LOP+LT:
    case LOP+LE:
    case LOP+ULT:
    case LOP+ULE:
        return lrexpr(caddr(e1),cadr(e1),l1,rop_dual(car(e1)),cond);
#endif
    case LAND:
        l2=bexpr(e2,0,cond?(l2=fwdlabel()):l1);
        l1=bexpr_u(caddr(e1),cond,l1);
        if(cond) fwddef(l2);
        return l1;
    case LOR:
        l2=bexpr(e2,1,cond?l1:(l2=fwdlabel()));
        l1=bexpr_u(caddr(e1),cond,l1);
        if(!cond) fwddef(l2);
        return l1;
    case CRGVAR: case CURGVAR:
        conv->bool_(e1);
        code_cmp_crgvar(e1,USE_CREG,1,l1,cond);
        return l1;
    case SRGVAR: case SURGVAR:
        conv->bool_(e1);
        code_cmp_crgvar(e1,USE_CREG,size_of_short,l1,cond);
        return l1;
    case CRLVAR: case CURLVAR:
        conv->bool_(e1);
        code_cmp_crlvar(e2,USE_CREG,1,l1,cond);
        return l1;
    case SRLVAR: case SURLVAR:
        conv->bool_(e1);
        code_cmp_crlvar(e2,USE_CREG,size_of_short,l1,cond);
        return l1;
    case RGVAR:
    case URGVAR:
        conv->bool_(e1);
        code_cmp_rgvar(e1,USE_CREG,l1,cond);
        return l1;
    case RLVAR:
    case URLVAR:
        conv->bool_(e1);
        code_cmp_rlvar(e2,USE_CREG,l1,cond);
        return l1;
#if 0 && FLOAT_CODE
    case DRLVAR:
        code_cmp_drlvar(e2,USE_CREG,1,l1,cond);
        return l1;
    case FRLVAR:
        code_cmp_drlvar(e2,USE_CREG,0,l1,cond);
        return l1;
    case DRGVAR:
        code_cmp_drgvar(e2,USE_CREG,1,l1,cond);
        return l1;
    case FRGVAR:
        code_cmp_drgvar(e2,USE_CREG,0,l1,cond);
        return l1;
    case FREGISTER:
        code_cmp_dregister(e2,0,l1,cond);
        return l1;
    case DREGISTER:
        code_cmp_dregister(e2,1,l1,cond);
        return l1;
    case DCONST:
    case FCONST:
        if(control&&((dcadr(e2)!=0.0)^cond)) {
            gen_jmp(l1); return l1;
        } else return 0;
#endif
#if 0 && LONGLONG_CODE
    case LRLVAR:
        code_cmp_lrlvar(e2,USE_CREG,l1,cond);
        return l1;
    case LRGVAR:
        code_cmp_lrgvar(e2,USE_CREG,l1,cond);
        return l1;
    case LREGISTER:
        code_cmp_lregister(e2,l1,cond);
        return l1;
    case LCONST:
        if(control&&((lcadr(e2)!=0)^cond)) {
            gen_jmp(l1); return l1;
        } else return 0;
#endif
    case REGISTER:
        conv->bool_(e1);
        code_cmp_register(e2,l1,cond);
        return l1;
    case CONST:
        if(control&&((cond&&e2)||(!cond&&!e2))) {
            gen_jmp(l1); return l1;
        } else return 0;
    default:
        if(err) {
            error(-1); return l1; /* recursive g_expr/b_expr */
        }
        t=g_expr(e1);
        if (!use) return l1;  // Is this really happen?
        conv->bool_(e1);
        if (0) ;
#if FLOAT_CODE
        else if(t==FLOAT)
            code_cmp_dregister(USE_CREG,0,l1,cond);
        else if(t==DOUBLE)
            code_cmp_dregister(USE_CREG,1,l1,cond);
#endif
#if LONGLONG_CODE
        else if(t==LONGLONG||t==ULONGLONG)
            code_cmp_lregister(USE_CREG,l1,cond);
#endif
        else
            code_cmp_register(USE_CREG,l1,cond);
        return l1;
    }
}

extern int 
is_const(int e)
{
    switch(car(e)) {
        case ADDRESS:
            e = cadr(e);
            return (car(e)==GVAR||car(e)==FNAME||car(e)==LVAR);
        case STRINGS: case STRING: case GVAR: 
        case EXTRN: case EXTRN1: case FNAME:
        case CONST: case LCONST: case FCONST: case DCONST:
        return 1;
    default:
        return 0;
    }
}

extern int 
is_code(NMTBL *fnptr)
{
    int type = type_value(fnptr->ty);
    return (type==CODE|| (type>0 && car(type)==CODE));
}

extern int 
is_function(NMTBL *fnptr)
{
    int type = type_value(fnptr->ty);
    return (type==FUNCTION || (type>0 && car(type)==FUNCTION));
}

extern int 
is_inline(NMTBL *f)
{
    return (f && !attr_value(f,NOINLINE) &&  attr_value(f,INLINE));
}

extern int 
function_type(int e1,int *dots)
{
    int ret_type,t;
    if (e1<0) return INT;
    ret_type = type_value(cadr(e1));
    if (ret_type==CHAR) ret_type=INT;

    /* check argments type is DOTS? */
    t = type_value(caddr(e1));
    if (/* t==0 || */ t==DOTS) *dots = 1;
    else {
        *dots = 0;
        for(;t;t = type_value(cadr(t))) {
            if (car(t)==DOTS) *dots = 1;
        }
    }

    return ret_type;
}

static int
register_to_lvar(int e)
{
    error(REG_ERR);
    return 0;
#if 0
    途中でレジスタからLVARに変更しても、間に合わない。

    NMTBL *n = (NMTBL*)caddr(e);
    int reg = cadr(e);
    int tag = car(e);
    int lvar;
    int t;
    if (!n||n==&null_nptr) error(REG_ERR);
    switch(tag) {
    case REGISTER:
        n->dsp = new_lvar(size_of_int); t = INT; break;
    case DREGISTER:
        n->dsp = new_lvar(size_of_double); t = DOUBLE; break;
    case FREGISTER:
        n->dsp = new_lvar(size_of_float); t = DOUBLE; break;
    case LREGISTER:
        n->dsp = new_lvar(size_of_longlong); t = LONGLONG; break;
    default:
        error(-1);
    }
    n->sc  = LVAR;
    lvar = list3n(LVAR,n->dsp,n);
    g_expr_u(assign_expr0(list3n(LVAR,n->dsp,n),list3n(tag,reg,n),t,t));
    if (tag==REGISTER||tag==DREGISTER||tag==FREGISTER||tag==LREGISTER) {
        free_register(reg);
    return g_expr0(lvar);
#endif
}

// parallel assignment of registers.
//
//  target = list3(target_regnum,next,source_regnum);
//
//  register の大きさはsize_of_int とは限らない。むしろ、
//  get_register_var した方が安全...

extern void
parallel_rassign(int assigns)
{
    int free,tmp,remains,t0=0,t2,src;
    tmp = 0;
    for(;;) {
        remains = 0;
        // find free target
        for(free=assigns;free;free=cadr(free)) {
            if (!caddr(free)) continue;       // already done
            if (car(free)==caddr(free)) {
                caddr(free)=0;
                continue;
            }
            remains++;
            t0 = car(free);                   // target register
            // check target is free
            for(src=assigns;src;src=cadr(src)) {
                if ((t2=caddr(src)) && t0==t2) break;  // target is in source
            }
            if (src==0) {
                break;                      // free is a free target
            } 
        }
        if (remains==0) {
            if (tmp) free_lvar(tmp);
            return;
        }
        if (free) {  // free target
            if (t0!=caddr(free)) {
                if (caddr(free)>=0) {
                    code_assign_register(t0,0,caddr(free));
                } else {
                    code_rlvar(caddr(free),t0);
                }
            }
            caddr(free)=0;       // mark it done
        } else {  // no free target
            for(free=assigns;free;free=cadr(free)) {
                if (caddr(free)) break; // not yet done
            }
            if (!free) error(-1);
            tmp = new_lvar(size_of_int);
            if (tmp>0) error(-1);
            code_assign_lvar(tmp,caddr(free),0);
            caddr(free) = tmp;
        }
    }
}

/* goto arguments list                                      */
/* target         list4(list2(tag,disp),cdr,ty,source_expr) */
/*     source         expr=listn(tag,...)                   */
/*     source (after) list2(tag,disp)                       */
/* source list    list3(e,cdr,sz)                           */

#define DEBUG_PARALLEL_ASSIGN 0

static int is_writable(int);

/* overlap 
      return list of overlapped target
 */

static int
overlap(int t,int sz,int target)
{
    int s,s0,s1;
    int t0=cadr(t);
    int t1=t0+sz;
    int source;
    int result=0;
    if (!is_writable(t)) error(-1);
    for(;target;target=cadr(target)) {
        for(source=caddddr(target);source;source=cadr(source)) {
            s=car(source); s0=cadr(s); 
            switch(car(s)) {
            case REGISTER: case DREGISTER: case FREGISTER: case LREGISTER:
                if (code_register_overlap(s,t)) {
                    result = list2(target,result);
                }
                break;
            default:
                if (is_same_type(s,t)) {
                    s1=s0+caddr(source);
#if DEBUG_PARALLEL_ASSIGN>1 
if (lsrc) printf("## overlap source %d t0 %d t1 %d\n",car(car(t)),t0,t1);
if (lsrc) printf("## overlap target %d s0 %d s1 %d\n",car(car(source)),s0,s1);
if (lsrc) printf("## overlap   equal = %d\n",((t0<=s0&&s0<t1)||(t0<s1&&s1<=t1)));
#endif
                    if((t0<=s0&&s0<t1)||(t0<s1&&s1<=t1))
                        result = list2(target,result);
                }
            }
        }
    }
    return result;
}

static void
remove_target(int *target,int t,int *use)
{
    int use0=*use;
    int reg;
    while(use0) {
        if (car(use0)==t) {
            reg = car(caddr(use0));
            if (reg==REGISTER||reg==FREGISTER||reg==DREGISTER||reg==LREGISTER)
                free_register(cadr(caddr(use0)));
            break;
        }
        use0 = cadr(use0);
    }
    remove0(target,t);
}

static void
save_target(int t,int s,int *target,int *use,int sz,int ty)
{
    int e1 = 0;
    // 使ったら free するべきだよね? code goto の時なら害はないか...
    /*新しいレジスタ(or スタック)を取得する*/
    if (scalar(ty) && sz==size_of_int && (e1=get_register_var(0))!=-1) {
        // e1=list3(REGISTER,e1,0);
        if (code_register_overlap(s,e1)) goto use_lvar;
        *use=list3(t,*use,e1);
        g_expr_u(assign_expr0(e1,s,ty,ty));
        *target = append5(*target,t,ty,e1,list3(e1,0,sz));
#if FLOAT_CODE
    } else if (ty==DOUBLE && sz==size_of_double && (e1=get_dregister_var(0,1))!=-1) {
        if (code_register_overlap(s,e1)) goto use_lvar;
        *use=list3(t,*use,e1);
        g_expr_u(assign_expr0(e1,s,ty,ty));
        *target = append5(*target,t,ty,e1,list3(e1,0,sz));
    } else if (ty==FLOAT && sz==size_of_float && (e1=get_dregister_var(0,0))!=-1) {
        if (code_register_overlap(s,e1)) goto use_lvar;
        *use=list3(t,*use,e1);
        g_expr_u(assign_expr0(e1,s,ty,ty));
        *target = append5(*target,t,ty,e1,list3(e1,0,sz));
#endif
#if LONGLONG_CODE
    } else if ((ty==LONGLONG||ty==ULONGLONG)&&(e1=get_lregister_var(0))!=-1) {
        if (code_register_overlap(s,e1)) goto use_lvar;
        *use=list3(t,*use,e1);
        g_expr_u(assign_expr0(e1,s,ty,ty));
        *target = append5(*target,t,ty,e1,list3(e1,0,sz));
#endif
    } else {
        if (0) {
use_lvar:;
#if DEBUG_PARALLEL_ASSIGN>1
if (lsrc) printf("## register overrap in save_target\n");
#endif
        }
        g_expr_u(assign_expr0((e1=list3n(LVAR,new_lvar(sz),0)),s,ty,ty));
        *target = append5(*target,t,ty,e1,list3(e1,0,sz));
        *use=list3(t,*use,e1);
    }
}

static int
circular_dependency(int t,int clist,int target,int history)
{
    int t1,h,sz,s,clist1,t2;

    for(;clist;clist=cadr(clist)) {          /* conflict list */
loop:
        t1 = car(clist);
        for(h=history;h;h=cadr(h)) {
            if (t1==car(h)) {
#if DEBUG_PARALLEL_ASSIGN
if (lsrc) printf("## circular dependency %d ty %d\n",car(t1),cadr(t1));
#endif
                return t1;
            }
        }
        for(s=caddddr(t1);s;s=cadr(s)) {    /* dependent memory sources */
            sz=caddr(s);
            if ((clist1=overlap(car(s),sz,target))) {
                if (!cadr(t1)&&!cadr(s)) {
                    history = list2(t,history);
                    t = t1;
                    clist = clist1; 
                    goto loop;  // tail recursion
                } else {
                    if ((t2=circular_dependency(t1,
                                clist1,target,list2(t,history)))) {
                        return t2;
                    }
                }
            }
        }
    }
    return 0;
}

// static void remove_a(int source,int s);  // remove all child

static void
parallel_assign(int *target,int *processing,int *use)
{
    int t,s,sz,ty,target0,s1,progress;
    while(*target) {
        progress = 0;
        for(target0=*target;target0; target0=cadr(target0)) {
            t=car(target0); s=cadddr(target0);
            sz=size(ty=caddr(target0)); 
            if(is_same_type(t,s) && cadr(t)==cadr(s)) {
                /*書き込み先が自分自身*/
#if DEBUG_PARALLEL_ASSIGN
if (lsrc) printf("## remove same %d ty %d+%d sz %d\n",car(t),ty,cadr(t),sz);
#endif
                remove_target(target,t,use);
                progress = 1;
            } else if (!(s1=overlap(t,sz,*target)) || 
                    (cadr(s1)==0 && car(car(s1))==t)) {
                /* 重なってないので安心して書き込める */
#if DEBUG_PARALLEL_ASSIGN
if (s1 && cadr(s1)==0) {
if (lsrc) printf("## singleton %d ty %d+%d sz %d\n",car(t),ty,cadr(t),sz);
    // this means singleton struct should be copied safely.
} else
if (lsrc) printf("## normal assign %d ty %d+%d sz %d\n",car(t),ty,cadr(t),sz);
#endif
                g_expr_u(assign_expr0(t,s,ty,ty));
                remove_target(target,t,use);
                progress = 1;
            } else if((t=circular_dependency(target0,s1,*target,0))) {
                remove_target(target,car(t),use);
                sz=size(ty=caddr(t)); 
                save_target(car(t),cadddr(t),target,use,sz,ty);
                progress = 1;
#if DEBUG_PARALLEL_ASSIGN
if (lsrc)    printf("## saving %d ty %d+%d sz %d\n",car(car(t)),ty,cadr(car(t)),sz);
#endif
                break;
            }
        }
        if (!progress) {
            // can't performe parallel assign
            // error(-1);
            target0 = *target;
            t=car(target0); s=cadddr(target0);
            sz=size(ty=caddr(target0)); 
#if DEBUG_PARALLEL_ASSIGN
if (lsrc)printf("## can't progress save any %d ty %d+%d sz %d\n",car(s),ty,cadr(t),sz);
#endif
            remove_target(target,t,use);
            save_target(t,s,target,use,sz,ty);
        }
    }
}

static void 
remove0(int *parent,int e) 
{
    int list;
    while ((list=*parent)) {
        if (car(list)==e) {
            *parent= cadr(list); return;
        } else {
             parent=&cadr(list);
        }
    }
}

/*

static int
remove_1(int source,int e)
{
    int sz;
    if ((sz=is_memory(e))) {
        remove0((int*)source,e);
    }
    return source;
}

static void
remove_a(int source,int s)
{
    contains_p1(source,s,remove_1);
}
*/

// #define SAVE_ALL_NON_MEMORY

#ifdef SAVE_ALL_NON_MEMORY
static int
is_simple(int e1) 
{
    switch(e1) {
        case CONST: case FNAME: case LVAR: case REGISTER: case DREGISTER:
        case FREGISTER: case LREGISTER:
        case GVAR: case RGVAR: case RLVAR: case CRLVAR: case CRGVAR:
        case DRLVAR: case FRLVAR: case LRLVAR:
        case CURLVAR: case SURLVAR: case CURGVAR: case SURGVAR:
        case URGVAR: case URLVAR:
        return 1;
    }
    return 0;
}
#endif

static int
is_same_type(int e1,int e2)
{
    int ce1=car(e1);
    int ce2=car(e2);
    if (ce1==LVAR) {
        switch(ce2) {
            case LRLVAR: case LURLVAR:  return lp64;
            case RLVAR: case CRLVAR: case FRLVAR: case DRLVAR:
            case SRLVAR: case SURLVAR: case CURLVAR: case LVAR:
            case URLVAR:
            return 1;
        }
    } else if (ce2==LVAR) {
        switch(ce1) {
            case LRLVAR: case LURLVAR:  return lp64;
            case RLVAR: case CRLVAR: case FRLVAR: case DRLVAR:
            case SRLVAR: case SURLVAR: case CURLVAR: case LVAR:
            case URLVAR:
            return 1;
        }
    } else if (ce1==GVAR) {
        return 0;
#if 0
        switch(ce2) {
            case RGVAR: case CRGVAR: case FRGVAR: case DRGVAR:
            case SRGVAR: case SURGVAR: case CURGVAR:
            return 1;
        }
#endif
    } else if (ce2==GVAR) {
        return 0;
#if 0
        switch(ce1) {
            case RGVAR: case CRGVAR: case FRGVAR: case DRGVAR:
            case SRGVAR: case SURGVAR: case CURGVAR: case LRGVAR:
            return 1;
        }
#endif
    } else if (ce1==REGISTER) {
        if (lp64 && ce2==LREGISTER) return 1;
    } else if (ce2==REGISTER) {
        if (lp64 && ce1==LREGISTER) return 1;
    }
    return 0;
}

static int
is_writable(int e1)
{
    switch(car(e1)) {
    case GVAR :
    case LVAR :
    case RLVAR :  case LRLVAR: case URLVAR: case LURLVAR:     // this is wrong, but ia32 generates this.
    case REGISTER :
        return size_of_int;
    case FREGISTER :
        return size_of_float;
    case DREGISTER  :
        return size_of_double;
    case LREGISTER:
        return size_of_longlong;
    }
    return 0;
}

extern int
reference(int e1)
{
    switch(car(e1)) {
    case GVAR :
    case CRGVAR  :
    case CURGVAR :
    case DRGVAR  :
    case FRGVAR :
    case LRGVAR :
    case LURGVAR :
    case RGVAR:
    case SRGVAR :
    case SURGVAR:
    case URGVAR:
        return list3n(GVAR,cadr(e1),ncaddr(e1));
    case LVAR :
    case CRLVAR  :
    case CURLVAR  :
    case DRLVAR  :
    case FRLVAR  :
    case LRLVAR:
    case LURLVAR:
    case RLVAR:
    case SRLVAR :
    case SURLVAR :
    case URLVAR:
        return list3n(LVAR,cadr(e1),ncaddr(e1));
    case FREGISTER :
    case REGISTER:
    case LREGISTER:
    case DREGISTER:
        return e1;
        break;
    default: error(-1);
    }
    return e1;
}

static int
is_memory0(int e1,int *global)
{
    *global=0;
    switch(car(e1)) {
    case CRGVAR  :
    case CURGVAR :
        *global=1;
    case CRLVAR  :
    case CURLVAR  :
        return 1;
    case SRGVAR :
    case SURGVAR:
        *global=1;
    case SRLVAR :
    case SURLVAR :
        return size_of_short;
    // case GVAR :
    case RGVAR:
    case URGVAR:
        *global=1;
    // case LVAR :
    case RLVAR:
    case REGISTER :
        return size_of_int;
    case FRGVAR :
        *global=1;
    case FRLVAR  :
    case FREGISTER :
        return size_of_float;
    case DRGVAR  :
        *global=1;
    case DRLVAR  :
    case DREGISTER  :
        return size_of_double;
    case LRGVAR :
    case LURGVAR :
        *global=1;
    case LRLVAR :
    case LURLVAR :
    case LREGISTER:
        return size_of_longlong;
    }
    return 0;
}

extern int
is_memory(int e1)
{
    int global;
    return is_memory0(e1,&global);
}

extern int
is_local_memory(int e1)
{
    int global;
    return is_memory0(e1,&global) && !global;
}

static int
check_source(int source,int e)
{
    int sz;
    if ((sz=is_memory(e))) {
        source = list3(e,source,sz);
    }
    return source;
}

//
// CbC goto statement with environment
//

// maximum size of struct divide (don't make it large)

#define ASSIGN_STRUCT_DIVIDE 40
#define ARG_OFFSET_CODE 1

extern void
jump(int e1, int env)
{
    int e2,e3,e4,sz,arg_size,ty,regs,fregs;
    int t0,s0,r,reg;
    NMTBL *code0 = 0;
    int target = 0;
    int processing = 0;
    int use = 0;
    int envreg = 0;
    int int_type = lp64?LONGLONG:INT;

    /* e1 = list4(FUNCTION,code_segment,arglist,ftype); */

    if (env) {
        error(-1); // not supported
        envreg = get_register_var(0);
        g_expr_u(assign_expr0(envreg,env,int_type,int_type));
    }

    /* まず、サイズを計算しながら、target を決まった形に落す。 */
    /*    list5(target,next,ty,source,source_dependency)       */

    arg_size = 0; regs = 0;
    fregs = 0;
    for (e3 = reverse0(caddr(e1)); e3; e3 = cadr(e3)) { 
        e2 = car(e3); sz = size(ty=caddr(e3)); 
        if (scalar(ty) && (r = get_input_register_var(regs,0,1))) {
            target=list5(r,target,ty,e2,0); regs++;
        } else if (ty==FLOAT  && (r = get_input_dregister_var(fregs,0,1,0))) {
            target=list5(r, target,ty,e2,0); fregs++;
        } else if (ty==DOUBLE && (r = get_input_dregister_var(fregs,0,1,1))) {
            target=list5(r, target,ty,e2,0); fregs++;
        } else if ((ty==LONGLONG||ty==ULONGLONG) && (r = get_input_lregister_var(fregs,0,1))) {
            target=list5(r, target,ty,e2,0); regs+=lp64?1:2;
        } else if (env) {
        /*
            envreg contains frame pointer, we need disp_offset. disp_offset
            for code segment and function should be the same value. 
            If original frame pointer has indeterminate offset, these should
            fixed in code_fix_frame_pointer.
         */
            g_expr_u(assign_expr0(
                list2(INDIRECT,
    lp64?list3(LADD,rvalue_t(envreg,LONGLONG),llist2(LCONST,-arg_size-sz+disp_offset))
         :list3(ADD,rvalue_t(envreg,INT),list2(CONST,-arg_size-sz+disp_offset))
                ),
                e2,ty,ty));
        } else {
            target=list5(list3n(LVAR,0,0), target,ty,e2,0);
        }
        /* keep arg space for register variables */
#if ARG_OFFSET_CODE
        NMTBL n;
        arg_size = code_arg_alignment(arg_size, &n, ty, sz,1);
#else
        arg_size += sz;
#endif
#if DEBUG_PARALLEL_ASSIGN
if (lsrc)printf("## target %d ty %d+%d sz %d\n",car(car(target)),ty,cadr(car(target)),sz);
#endif
    }
    if (env) {
        /* change the frame pointer during parallel assignment */
            target=list5(code_frame_pointer_register(), target,INT,rvalue_t(envreg,INT),0);
    } 


    /* disp を飛び先似合わせて修正 */
    if (is_code(fnptr)) {
        if (-arg_size<disp) disp = -arg_size;
    } else {
        if (disp_offset-arg_size<disp) disp = disp_offset-arg_size;
    }

    /*  複雑な式を前もって計算しておく     */
    /*  必要なら局所変数を用いる。         */
    /*  局所変数へのオフセットを覚えておく */
#if ARG_OFFSET_CODE
    NMTBL n;
    n.dsp = 0;
    int arg_offset = 0;
    target = reverse0(target); 
#endif
    for (e2 = target; e2; e2 = cadr(e2)) {      
        t0=car(e2); s0=cadddr(e2);
        sz=size(ty=caddr(e2));
#if ARG_OFFSET_CODE
        /* ここで、書込先アドレスを決める */
        arg_offset = code_arg_alignment(arg_offset, &n, ty, sz,1);
        if(car(t0)==LVAR) {
            cadr(t0) = n.dsp;
        }
#else
        if(car(t0)==LVAR) {
            cadr(t0)=-arg_size;    // disp_offset?!
        }
        arg_size-=sz;
#endif
#ifdef SAVE_ALL_NON_MEMORY
        if (!is_simple(car(s0))) {
#else
        if (contains_p(s0,not_simple_p)) {   /* } */
#endif
            /* complex case */
            g_expr_u(assign_expr0((e4=list3n(LVAR,new_lvar(sz),0)),s0,ty,ty));
            use=list3(ty,use,e1);
            cadddr(e2)=e4;
            caddddr(e2)=list3(e4,0,sz);
            s0=e4;
        } else if (is_same_type(t0,s0)) {
            if(cadr(t0)==cadr(s0)) {
                if(is_writable(s0)) {
                    caddddr(e2)=list3(s0,0,sz); // これなんだっけ?
                    continue;
                } else
                    error(-1);
            }
        }
        int int_unsigned = lp64?ULONGLONG:UNSIGNED;
        int int_size = lp64?sizeof(long long):sizeof(int);
        if(is_writable(s0)) {
            if (sz>8 && car(s0)==LVAR && car(t0)==LVAR 
                    &&sz<ASSIGN_STRUCT_DIVIDE) {
                /* large struct generate large save/restore */
                /* divide it to avoid large copy */
#if DEBUG_PARALLEL_ASSIGN
if (lsrc)printf("## division sz %d\n",sz);
#endif
                caddr(e2) = int_unsigned;
                caddddr(e2) = list3(
                        cadddr(e2)=list3n(LVAR,cadr(s0),0),
                                0, int_size);
#if DEBUG_PARALLEL_ASSIGN
if (lsrc)printf("## div 0 source %d ty %d+%d sz %d\n",car(s0),ty,cadr(s0),int_size);
#endif
                for(e4=int_size;e4<sz;) {
                    cadr(e2) = list5(car(e2),cadr(e2),
                        caddr(e2),cadddr(e2),caddddr(e2));
                    switch(sz-e4) {
                    case 1: caddr(e2) = UCHAR; r = 1; break;
                    case 2:
                    case 3: caddr(e2) = USHORT; r = size_of_short; break;
                    case 4: if (lp64) { caddr(e2) = UNSIGNED; r = size_of_int; break; }
                    default: caddr(e2) = int_unsigned; r = int_size;
                    }
                    if (e4==int_size) e3=cadr(e2);
                    car(e2) =  list3n(LVAR,cadr(t0)+e4,0);
                    caddddr(e2) = list3(
                        cadddr(e2) = list3n(LVAR,cadr(s0)+e4,0),0, r);
                    e4 += r;
#if DEBUG_PARALLEL_ASSIGN
if (lsrc)printf("## div 1 source %d ty %d+%d sz %d\n",car(s0),ty,cadr(s0),r);
#endif
                }
                e2 = e3;
                continue;
            }
            caddddr(e2)=list3(s0,0,sz);
#if DEBUG_PARALLEL_ASSIGN
if (lsrc)printf("## source %d ty %d+%d sz %d\n",car(s0),ty,cadr(s0),sz);
#endif
        } else {
            /* check used sources in rather complex source */
            /*   more complex sources are compiled before */
            caddddr(e2)=contains_p1(0,s0,check_source);
        }
    }
    /* compute jump address */
    e2 = cadr(e1);
    if (car(e2) == FNAME) {     
        code0=ncaddr(e2);
        // if (!is_code(code0)) { error(TYERR); return; }
    } else {    /* indirect */
        g_expr(e2);
        emit_push();
    }
    if (chk) return;

    /* 並列代入を実行 */
    parallel_assign(&target,&processing,&use);
    while (use) {
        reg = car(caddr(use));
        if (reg==REGISTER||reg==FREGISTER||reg==DREGISTER||reg==LREGISTER)
            free_register(cadr(caddr(use)));
        else if (car(caddr(use))==LVAR)
            free_lvar(cadr(caddr(use)));
        use=cadr(use);
    }
    // if(target) error(-1);
    if(env) {
        if (car(envreg)==REGISTER)
            free_register(cadr(envreg));
        else free_lvar(cadr(envreg));
    }
    code_fix_frame_pointer(env);

    if (car(e2) == FNAME) {     
        code_jmp(code0->nm);
    } else {
        e2 = emit_pop(0);
        code_indirect_jmp(e2);
        emit_pop_free(e2);
    }
}

static void
machinop(int e1)
{
    int e2,e3,op;

    // e3 op e2

    e2 = cadr(e1);
    op = car(e1);
    e3 = caddr(e1);
    if (code_const_op_p(op,e3)) {
        g_expr(e2);
        oprtc(op,USE_CREG,e3);
        return;
    }
    if ((op==CMP||op==UCMP) && car(e3)==REGISTER && car(e2)==REGISTER) {
        if (tosop_operand_safe_p(op)==1) {
            // both operands are safe
            tosop(op,cadr(e2),cadr(e3));
            return;
        }
    }
    if (car(e3)==REGISTER) {
        if (tosop_operand_safe_p(op)) {
            // operand are safe
            g_expr(e2);
            tosop(op,USE_CREG,cadr(e3));
            return;
        }
    }
    g_expr(e3);
    emit_push();
    g_expr(e2);
    tosop(op,USE_CREG,(e2=pop_register()));
    emit_pop_free(e2);
    return;
}

#if FLOAT_CODE
static void
dmachinop(int e1,int d)
{
    int e2,e3,op;

    e2 = cadr(e1);
    op = car(e1);
    e3 = caddr(e1);
    switch (op) {
    case DCMPGE: case DCMPEQ: case DCMPNEQ: case DCMP:
    case FCMPGE: case FCMPEQ: case FCMPNEQ: case FCMP:
        if ((car(e3)==DREGISTER||car(e3)==FREGISTER) && 
           ((car(e2)==DREGISTER||car(e2)==FREGISTER))) { 
            if (tosop_operand_safe_p(op)==1) {
                dtosop(op,cadr(e2),cadr(e3));
                return;
            }
        }
    }
    if (car(e3)==DREGISTER||car(e3)==FREGISTER) {
        if (tosop_operand_safe_p(op)) {
            g_expr(e2);
            dtosop(op,USE_CREG,cadr(e3));
            return;
        }
    }
    g_expr(e3);
    emit_dpush(d);
    g_expr(e2);
    dtosop(car(e1),USE_CREG,(e2=emit_dpop(d)));
    emit_dpop_free(e2,d);
    return;
}
#endif

#if LONGLONG_CODE
static void
lmachinop(int e1)
{
    int e2,e3,op;

    e2 = cadr(e1);
    op = car(e1);
    e3 = caddr(e1);
    if (code_lconst_op_p(op,e3)) {
        g_expr(e2);
        loprtc(op,USE_CREG,e3);
        return;
    }
    if (car(e3)==LREGISTER && tosop_operand_safe_p(op)) {
        g_expr(e2);
        ltosop(op,USE_CREG,cadr(e3));
        return;
    }
    g_expr(e3);
    emit_lpush();
    g_expr(e2);
    ltosop(op,USE_CREG,(e2=emit_lpop()));
    emit_lpop_free(e2);
    return;
}
#endif
static int llvalue_opt(int e0);

static int
lvalue_opt(int e0)
{
    int e,e1;

    if (inmode) return e0;
    if (car(e0)==LADD) return llvalue_opt(e0);
    if (car(e0)!=ADD) return e0;
    if (car(e=caddr(e0))!=CONST) return e0;
    e1 = cadr(e0);
    if(car(e1)==ADDRESS) {
        switch (car(cadr(e1))) {
        case GVAR:
            return(list2(ADDRESS,
                list3n(GVAR,cadr(cadr(e1))+cadr(e),ncaddr(cadr(e1)))));
        case LVAR:
            return(list2(ADDRESS,
                list3n(LVAR,cadr(cadr(e1))+cadr(e),
                        ncaddr(cadr(e1)))));
        // case INDIRECT:
        case PERIOD:
        case ARROW:
            if (lp64) return list3(LADD,e1,llist2(LCONST,cadr(e)));
            return list3(ADD,e1,e);
        default:
            return e0;
        }
    } else if(car(e1)==GVAR) {
        return(list3n(GVAR,cadr(e1)+cadr(e),ncaddr(e1)));
    } else if(car(e1)==LVAR) {
        return(list3n(LVAR,cadr(e1)+cadr(e),ncaddr(e1)));
    }
    return e0;
}

static int
llvalue_opt(int e0)
{
    int e,e1;

    if (inmode) return e0;
    if (car(e0)!=LADD) return e0;
    if (car(e=caddr(e0))!=LCONST) return e0;
    // should we check LCONST is 32bit
    e1 = cadr(e0);
    if(car(e1)==ADDRESS) {
        switch (car(cadr(e1))) {
        case GVAR:
            return(list2(ADDRESS,
                list3n(GVAR,cadr(cadr(e1))+lcadr(e),ncaddr(cadr(e1)))));
        case LVAR:
            return(list2(ADDRESS,
                list3n(LVAR,cadr(cadr(e1))+lcadr(e),
                        ncaddr(cadr(e1)))));
        case INDIRECT:
        case PERIOD:
        case ARROW:
            return list3(LADD,e1,e);
        default:
            return e0;
        }
    } else if(car(e1)==GVAR) {
        return(list3n(GVAR,cadr(e1)+lcadr(e),ncaddr(e1)));
    } else if(car(e1)==LVAR) {
        return(list3n(LVAR,cadr(e1)+lcadr(e),ncaddr(e1)));
    }
    return e0;
}

static void
sassign(int e1)
{
    int e2,e3,e4,sz,xreg,det,offset;

    /* structure assignment */
    e2 = cadr(e1);  /* pointer variable to the struct */
    e3 = cadr(e2);  /* offset of the variable (distination) */
    e4 = caddr(e1); /* right value (source) */
    sz = cadddr(e1);  /* size of struct or union */
    if (is_same_type(e2,e4)) {
        if (cadr(e2)==cadr(e4)) {
            if (use) g_expr(e4);
            return;
        }
    }
    e2 = lvalue_opt(e2);

    if (car(e4)==DECL_DATA && (car(e2)==GVAR || car(e2)==LVAR)) {
        // we can do optimize any other type of destination ...
        // but gen_decl_data0 requires nptr (of course wrong decision)
        int t = caddr(e4);
        int sinit_vars = init_vars; init_vars = 0;
        gen_decl_data0(e2,t,e4,0);
        emit_init_vars();
        init_vars = sinit_vars;
        return;
    }


    g_expr(e4);
    emit_push();
    g_expr(e2);
    xreg = emit_pop(0);
    /* 一般的にはコピーのオーバラップの状況は実行時にしかわからない */
    /* しかし、わかる場合もある */
    if (is_same_type(e2,e4)) {
        if(cadr(e2)>cadr(e4)) { 
            offset = 0;
            if (!(sz==1 || sz==2 || sz==3 || (lp64 && sz==8))) {
                offset=sz; sz=-sz;
            }
        } else offset=0;
        det=1;  
    } else {
        det = 0;  offset=0;
    }
    emit_copy(xreg,USE_CREG,sz,offset,1,det);
    emit_pop_free(xreg);
    return;
}

static void
assign_opt(int e5,int e2,int e4,int byte)
{
    int reg;
    /*    e2=e4 */
    if (e5==REGISTER||e5==LREGISTER) {
        reg = cadr(e4);
        switch(car(e2)) {
        case GVAR: code_assign_gvar(e2,reg,byte); return;
        case LVAR: code_assign_lvar(cadr(e2),reg,byte); return;
        case REGISTER: code_assign_register(cadr(e2),byte,reg); return;
        case LREGISTER: code_lassign_lregister(cadr(e2),reg); return;
        }
        g_expr(e2);
        code_assign(USE_CREG,byte,reg);
        return;
    }
    /* e2 is register now */
    if (car(e2)!=REGISTER && car(e2)!=LREGISTER) error(-1);
    reg = cadr(e2);
    switch(e5) {
    case CRGVAR:  
    case CURGVAR:  code_crgvar(e4,reg,e5==CRGVAR,1); return;
    case SRGVAR:  
    case SURGVAR:  code_crgvar(e4,reg,e5==SRGVAR,size_of_short); return;
    case RGVAR: case URGVAR:   code_rgvar(e4,reg);  return;
    case CRLVAR:  
    case CURLVAR:  code_crlvar(cadr(e4),reg,e5==CRLVAR,1); return;
    case SRLVAR:  
    case SURLVAR:  code_crlvar(cadr(e4),reg,e5==SRLVAR,size_of_short); return;
    case RLVAR: case URLVAR:   code_rlvar(cadr(e4),reg);  return;
    case GVAR:     code_gvar(e4,reg);   return;
    case LVAR:     code_lvar(cadr(e4),reg);   return;
    case CONST:    code_const(cadr(e4),reg); return;
    case ADDRESS: 
        if (car(cadr(e4))==STRING) { code_string(cadr(e4),reg);
        } else if (car(cadr(e4))==STRINGS) {
            code_strings(cadr(e4),reg);
        } else code_gvar(cadr(e4),reg);   
        return;
    case FNAME:    code_fname(ncaddr(e4),reg); return;
    case STRING:   code_string(e4,reg); return;
    case STRINGS:   code_strings(cadr(e4),reg); return;
    default: error(-1);
    }
}

static void
assign(int e1)
{
    int e2,e4,byte,e5;

    byte=(car(e1) == CASS)?1:(car(e1) == SASS)?size_of_short: lp64? size_of_int : 0;
    /*    e2=e4 */
    e2 = cadr(e1);
    e2 = lvalue_opt(e2);
    e4 = caddr(e1);e5=car(e4);
    if (is_same_type(e2,e4)&&cadr(e2)==cadr(e4)) {
        if (use) g_expr(e4);
        return;
    }
    if (!use) {
        if (e5==REGISTER||e5==LREGISTER) {
            assign_opt(e5,e2,e4,byte);
            return;
        } else if (car(e2)==REGISTER||car(e2)==LREGISTER) {
            switch(e5) {
            case ADDRESS:
                if (!((car(cadr(e4))==STRING)|| (car(cadr(e4))==STRINGS) || car(cadr(e4))==GVAR)) 
                    break; 
            case  CRGVAR  : case  CRLVAR  : case  RGVAR  : case  RLVAR :
            case  URGVAR  : case  URLVAR :
            case  CURGVAR  : case  CURLVAR  :
            case  SURGVAR  : case  SURLVAR  :
            case  GVAR  : case  LVAR :
            case  CONST   : case  FNAME  : case  STRING : case STRINGS:
                assign_opt(e5,e2,e4,byte);
                return;
            }
        }
    }
    switch(car(e2)) {
    case GVAR:      /*   i=3 */
            g_expr(e4);
            code_assign_gvar(e2,USE_CREG,byte);
            return;
    case LVAR:
            g_expr(e4);
            code_assign_lvar(cadr(e2),USE_CREG,byte);
            return;
    case REGISTER:
            g_expr(e4);
            code_assign_register(cadr(e2),byte,USE_CREG);
            return;
    case LREGISTER:
            g_expr(e4);
            code_lassign_lregister(cadr(e2),USE_CREG);
            return;
    }
    g_expr(e2);
    emit_push();
    g_expr(e4);
    e2 = emit_pop(0);
    code_assign(e2,byte,USE_CREG);
    emit_pop_free(e2);
    return;
}

#if FLOAT_CODE

static void
dassign_opt(int e5,int e2,int e4,int d)
{
    int reg;
    /*    e2=e4 */
    if (e5==DREGISTER||e5==FREGISTER) {
        reg = cadr(e4);
        switch(car(e2)) {
        case GVAR:      /*   i=3 */
                code_dassign_gvar(e2,reg,d);
                return;
        case LVAR:
                code_dassign_lvar(cadr(e2),reg,d);
                return;
        case DREGISTER:
        case FREGISTER:
                if (reg!=cadr(e2))
                    code_dassign_dregister(cadr(e2),d,reg);
                return;
        default:
            error(-1);
        }
    }
    /* e2 is register now */
    if (car(e2)!=DREGISTER && car(e2)!=FREGISTER) error(-1);
    reg = cadr(e2);
    switch(e5) {
    case FRGVAR:
    case DRGVAR: code_drgvar(e4,d,reg); return;
    case FRLVAR:
    case DRLVAR: code_drlvar(cadr(e4),d,reg); return;
    case FCONST:
    case DCONST: code_dconst(e4,reg,d); return;
    default:
            error(-1);
    }
}

static void
dassign(int e1)
{
    int e2,e3,e4,d=0,e5;

    /*    e2=e4 */
    e2 = cadr(e1);
    e3 = cadr(e2);
    e4 = caddr(e1); e5=car(e4);
    if (is_same_type(e2,e4)&&cadr(e2)==cadr(e4)) {
        if (use) g_expr(e4);
        return;
    }
    if (car(e1)==DASS) d=1;
    else if (car(e1)==FASS) d=0;
    else error(-1); 
    if (!use) {
        switch(e5) {
            case DRGVAR: case DRLVAR: case DCONST:
                if (car(e2)!=DREGISTER) break;
                dassign_opt(e5,e2,e4,d); return;
            case FRGVAR: case FRLVAR: case FCONST:
                if (car(e2)!=FREGISTER) break;
            case DREGISTER: case FREGISTER:
                dassign_opt(e5,e2,e4,d); return;
        }
    }
    switch(car(e2)) {
    case GVAR:
            g_expr(e4);
            code_dassign_gvar(e2,USE_CREG,d);
            return;
    case LVAR:
            g_expr(e4);
            code_dassign_lvar(cadr(e2),USE_CREG,d);
            return;
    case DREGISTER:
    case FREGISTER:
            g_expr(e4);
            code_dassign_dregister(cadr(e2),d,USE_CREG);
            return;
    }
    g_expr(e2);
    emit_push();
    g_expr(e4);
    e2 = emit_pop(0);
    code_dassign(e2,USE_CREG,d);
    emit_pop_free(e2);
    return;
}

#endif

#if LONGLONG_CODE

static void
lassign_opt(int e5,int e2,int e4)
{
    int reg;
    /*    e2=e4 */
    if (e5==LREGISTER||e5==REGISTER) {
        reg = cadr(e4);
        switch(car(e2)) {
        case GVAR:      /*   i=3 */
                code_lassign_gvar(e2,reg);
                return;
        case LVAR:
                code_lassign_lvar(cadr(e2),reg);
                return;
        case LREGISTER:
        case REGISTER:
                if (reg!=cadr(e2))
                    code_lassign_lregister(cadr(e2),reg);
                return;
        default:
            error(-1);
        }
    }
    /* e2 is register now */
    if (!(car(e2)==LREGISTER||car(e2)==REGISTER)) error(-1);
    reg = cadr(e2);
    switch(e5) {
    case LRGVAR: case LURGVAR: code_lrgvar(e4,reg); return;
    case LRLVAR: case LURLVAR: code_lrlvar(cadr(e4),reg); return;
    case LCONST: code_lconst(e4,reg); return;
    default:
            error(-1);
    }
}

static void
lassign(int e1)
{
    int e2,e3,e4,e5;

    /*    e2=e4 */
    e2 = cadr(e1);
    e3 = cadr(e2);
    e4 = caddr(e1); e5=car(e4);
    if (is_same_type(e2,e4)&&cadr(e2)==cadr(e4)) {
        if (use) g_expr(e4);
        return;
    }
    if (!use && (
        ((e5==LREGISTER||e5==REGISTER) &&(car(e2)==GVAR||car(e2)==LVAR||car(e2)==LREGISTER || car(e2)==REGISTER)) ||
            ((car(e2)==LREGISTER||car(e2)==REGISTER)&&
                (e5==LRGVAR||e5==LRLVAR||e5==LURLVAR||e5==LURGVAR||e5==LCONST))
        )) {
        lassign_opt(e5,e2,e4);
        return;
    }
    switch(car(e2)) {
    case GVAR:
            g_expr(e4);
            code_lassign_gvar(e2,USE_CREG);
            return;
    case LVAR:
            g_expr(e4);
            code_lassign_lvar(cadr(e2),USE_CREG);
            return;
    case LREGISTER:
    case REGISTER:
            g_expr(e4);
            code_lassign_lregister(cadr(e2),USE_CREG);
            return;
    }
    g_expr(e2);
    emit_push();
    g_expr(e4);
    e2 = emit_pop(0);
    code_lassign(e2,USE_CREG);
    emit_pop_free(e2);
    return;
}

#endif

/* numerical type conversion */

#if FLOAT_CODE
static int
double_value(int e2)
{
    switch(car(e2)) {
    case LCONST:
#if LONGLONG_CODE
        e2 =  dlist2(DCONST,(double)lcadr(e2)); break;
#endif
    case CONST:
        e2 =  dlist2(DCONST,(double)cadr(e2)); break;
    case FCONST:
        e2 = dlist2(DCONST,dcadr(e2)); break;
    default:
        switch(type_value(type)) {
        case DOUBLE: break;
        case FLOAT: e2 =  list3(CONV,e2,F2D); break;
        case UNSIGNED: e2 =  list3(CONV,e2,U2D); break;
        case LONGLONG: e2 =  list3(CONV,e2,LL2D); break;
        case ULONGLONG: e2 =  list3(CONV,e2,ULL2D); break;
        default:
            if(integral(type)) e2 =  list3(CONV,e2,I2D);
            else { error(TYERR); e2 =  dlist2(DCONST,1.0); }
        }
    }
    type = set_type_with_attr(DOUBLE,type);
    return e2;
}

static int
float_value(int e2)
{
    if (0) ;
#if LONGLONG_CODE
    else if (car(e2)==LCONST)  e2 =  dlist2(FCONST,(double)lcadr(e2));
#endif
    else if (car(e2)==CONST)  e2 = dlist2(FCONST,(double)cadr(e2));
    else if (car(e2)==DCONST)  e2 = dlist2(FCONST,dcadr(e2));
    else {
        switch(type_value(type)) {
        case LONGLONG: e2 = list3(CONV,e2,LL2F); break;
        case ULONGLONG: e2 = list3(CONV,e2,ULL2F); break;
        case FLOAT: break;
        case DOUBLE: e2 =  list3(CONV,e2,D2F); break;
        case UNSIGNED: e2 =  list3(CONV,e2,U2F); break;
        default:
            if(integral(type)) e2 =  list3(CONV,e2,I2F);
            else { error(TYERR); e2 =  dlist2(DCONST,1.0); }
        }
    }
    type = set_type_with_attr(FLOAT,type);
    return e2;
}
#endif

#if LONGLONG_CODE
static int
longlong_value(int e2)
{
    if (0) ;
    else if (car(e2)==CONST)  e2 = llist2(LCONST,(long long)cadr(e2));
    else if (car(e2)==LCONST) ;
#if FLOAT_CODE
    else if (car(e2)==DCONST||car(e2)==FCONST)
        e2 = llist2(LCONST,(long long)dcadr(e2));
#endif
    else {
        switch(type_value(type)) {
        case FLOAT: e2 = list3(CONV,e2,F2LL); break;
        case DOUBLE: e2 = list3(CONV,e2,D2LL); break;
        case UNSIGNED: e2 = list3(CONV,e2,U2LL); break;
        case LONGLONG: break;
        case ULONGLONG: break;
        default:
            if(integral(type)) e2 = list3(CONV,e2,I2LL);
            else if(lp64)
               ;
            // else { error(TYERR); e2 = llist2(LCONST,0LL); }
        }
    }
    type = set_type_with_attr(LONGLONG,type);
    return e2;
}

static int
ulonglong_value(int e2)
{
    if (0);
    else if (car(e2)==CONST)  {
        e2 = llist2(LCONST,(unsigned long long)cadr(e2));
    }
    else if (car(e2)==LCONST)  ;
#if FLOAT_CODE
    else if (car(e2)==DCONST||car(e2)==FCONST) {
        if (dcadr(e2)<0) 
            e2 = llist2(LCONST,0);
        e2 = llist2(LCONST,(unsigned long long)dcadr(e2));
    }
#endif
    else {
        switch(type_value(type)) {
        case FLOAT: e2 = list3(CONV,e2,F2ULL); break;
        case DOUBLE: e2 = list3(CONV,e2,D2ULL); break;
        case UNSIGNED: e2 = list3(CONV,e2,U2ULL); break;
        case LONGLONG: break;
        case ULONGLONG: break;
        default:
            if(integral(type)) e2 = list3(CONV,e2,I2ULL);
            else if(lp64)
              ;
            // else { error(TYERR); e2 = llist2(LCONST,0LL); }
        }
    }
    type = set_type_with_attr(ULONGLONG,type);
    return e2;
}
#endif

static int
int_value(int e2)
{
    int t = type_value(type);
    if (0);
    else if(t>0&&car(t)==ARRAY) return e2;
    else if(scalar(t)) { type = set_type_with_attr(INT,type); return e2; }
#if FLOAT_CODE
    else if (car(e2)==DCONST||car(e2)==FCONST)  e2 = list2(CONST,(int)dcadr(e2));
#endif
#if LONGLONG_CODE
    else if (car(e2)==LCONST)  e2 = list2(CONST,(int)lcadr(e2));
#endif
    else {
        switch(t) {
        case FLOAT: e2 = list3(CONV,e2,F2I); break;
        case DOUBLE: e2 = list3(CONV,e2,D2I); break;
        case LONGLONG: e2 = list3(CONV,e2,LL2I); break;
        case ULONGLONG: e2 = list3(CONV,e2,ULL2I); break;
        default:
            error(TYERR); e2 = list2(CONST,1);
        }
    }
    type = set_type_with_attr(INT,type);
    return e2;
}

static int
char_value(int e2)
{
    int t = type_value(type);
    if (t!=CHAR&&t!=INT) { 
        e2 = list3(CONV,int_value(e2),I2C); 
        type = set_type_with_attr(INT,type);
    }
    return e2;
}

static int
short_value(int e2)
{
    int t = type_value(type);
    if (t!=SHORT&&t!=INT) { 
        e2 = list3(CONV,int_value(e2),I2S); 
        type = set_type_with_attr(INT,type);
    }
    return e2;
}

static int
unsigned_value(int e2)
{
    int t = type_value(type);
    if(t>0&&car(t)==ARRAY) return e2;
    if (0);
    else if(scalar(t)) { type = set_type_with_attr(UNSIGNED,type); return e2; }
#if FLOAT_CODE
    else if (car(e2)==DCONST||car(e2)==FCONST)  {
        if (dcadr(e2)<0)
            return e2 = list2(CONST,0);
        e2 = list2(CONST,(int)dcadr(e2));
    }
#endif
#if LONGLONG_CODE
    else if (car(e2)==LCONST)  {
        if (lcadr(e2)<0)
            e2 = list2(CONST,0);
        e2 = list2(CONST,(unsigned)lcadr(e2));
    }
#endif
    else {
        switch(t) {
        case LONGLONG: e2 = list3(CONV,e2,LL2U); break;
        case ULONGLONG: e2 = list3(CONV,e2,ULL2U); break;
        case FLOAT: e2 = list3(CONV,e2,F2U); break;
        case DOUBLE: e2 = list3(CONV,e2,D2U); break;
        default:
            error(TYERR); 
        }
    }
    type = set_type_with_attr(UNSIGNED,type);
    return e2;
}

static int
uchar_value(int e2)
{
    int t = type_value(type);
    if (t!=UCHAR&&t!=UNSIGNED) { 
        e2 = list3(CONV,unsigned_value(e2),U2UC);
        type = set_type_with_attr(UNSIGNED,type);
    }
    return e2;
}

static int
ushort_value(int e2)
{
    int t = type_value(type);
    if (t!=USHORT&&t!=UNSIGNED) { 
        e2 = list3(CONV,unsigned_value(e2),U2US); 
        type = set_type_with_attr(UNSIGNED,type);
    }
    return e2;
}

/* assign statement */

/* keep type */

extern int
assign_expr0(int e1,int e2,int t,int type0) {
    int stype;
    stype=type;
    type = type0;
    e2 = rvalue(e2);
    e1=assign_expr(e1,e2,t);
    type=stype;
    return e1;
}



/* with conversion (will destroy type global variable) */

extern int
assign_expr(int e1,int e2,int t) {
    /* we should check const / assign violation here */
    t = type_value(t);
    if (t>0) {
        switch(car(type_value(t))) {
        case BIT_FIELD:
            //        type = list4(BIT_FIELD,type,
            //            list3(type /*store type*/,0 /*bit offset*/,bitsize));
            e2 = correct_type(e2,cadr(t)); /* value type */
            return(list4(BASS,e1,e2,list2(BASS,t)));
        case STRUCT:case UNION:
            if (size(t)!=size(type)) error(TYERR);
            type=t;    // dispose attr
            if(car(e2)==FUNCTION) {
                replace_return_struct(e2,e1);
                return e2;
            } else {
                return (list4(STASS,e1,e2,size(t)));
            }
        default:
            if(scalar(t)) {
                if (car(t)!=POINTER) {
                    e2=(type_value(t)==UNSIGNED)?
                        unsigned_value(e2):int_value(e2);
                }
                if (lp64) return(list3(LASS,e1,e2));
                return(list3(ASS,e1,e2));
            }
            error(TYERR); return list3(ASS,e1,e2);
        }
    }
    switch(t) {
    case VOID:
        break;
    case CHAR:case UCHAR: 
        e2=(t==UCHAR)?unsigned_value(e2):int_value(e2);
        return(list3(CASS,e1,e2));
    case SHORT:case USHORT:
        e2=(t==USHORT)?unsigned_value(e2):int_value(e2);
        return(list3(SASS,e1,e2));
    case INT:case UNSIGNED: case ENUM:
        e2=(t==UNSIGNED)?unsigned_value(e2):int_value(e2);
        return(list3(ASS,e1,e2));
#if FLOAT_CODE
    case DOUBLE:
        e2=double_value(e2);
        return(list3(DASS,e1,e2));
    case FLOAT:
        e2=float_value(e2);
        return(list3(FASS,e1,e2));
#endif
#if LONGLONG_CODE
    case LONGLONG:
        e2=longlong_value(e2);
        return(list3(LASS,e1,e2));
    case ULONGLONG:
        e2=ulonglong_value(e2);
        return(list3(LASS,e1,e2));
#endif
    }
    error(TYERR); return list3(ASS,e1,e2);
}

extern int
cond(int t,int e1,int e2,int e3)
{
    int t0 = type_value(t);
    int t1 = type_value(type);
    if(car(e1)==CONST) {
        if(cadr(e1)) {type=set_type_with_attr(t,type);return e2?e2:e1;} else return e3;
    }
#if FLOAT_CODE
    if(car(e1)==DCONST) {
        if(dcadr(e1)) {type=t;return e2?e2:e1;} else return e3;
    }
    if(t1==DOUBLE||t0==DOUBLE) {
        e3=double_value(e3);
        type = t; if (e2) e2=double_value(e2);
        return(list4(DCOND,e1,e2,e3));
    }
    if(t1==FLOAT||t0==FLOAT) {
        e3=float_value(e3);
        type = t; if (e2) e2=float_value(e2);
        return(list4(FCOND,e1,e2,e3));
    }
#endif
#if LONGLONG_CODE
    if(car(e1)==LCONST) {
        if(lcadr(e1)) {type=set_type_with_attr(t,type);return e2?e2:e1;} else return e3;
    }
    if(t1==LONGLONG||t0==LONGLONG) {
        e3=longlong_value(e3);
        type = t; if (e2) e2=longlong_value(e2);
        return(list4(LCOND,e1,e2,e3));
    }
    if(t1==ULONGLONG||t0==ULONGLONG) {
        e3=ulonglong_value(e3);
        type = t; if (e2) e2=ulonglong_value(e2);
        return(list4(LUCOND,e1,e2,e3));
    }
#endif
    if(t1==INT||t0==INT) {
        e3=int_value(e3);
        type = t; if (e2) e2=int_value(e2);
        return(list4(COND,e1,e2,e3));
    }
    e3=unsigned_value(e3);
    type = t; if (e2) e2=unsigned_value(e2);
    /* if (t!=type) error(TYERR); */
    return(list4(UCOND,e1,e2,e3));
}

/*
   assop
      parse tree generation
 */
extern int
assop(int e1,int e2,int op,int t,int no_float)
{
    int ass=0,u = 0;
    int t0 = type_value(type);
    if(!(integral(t0)||t0==FLOAT||t0==DOUBLE||
        t0==LONGLONG||t0==ULONGLONG
            )) error(TYERR);
    switch(t) {
#if FLOAT_CODE
    case FLOAT:
        if (no_float) error(TYERR);
        e2=float_value(e2);
        return(list4(FASSOP,e1,e2,op+FOP));
    case DOUBLE:
        if (no_float) error(TYERR);
        e2=double_value(e2);
        return(list4(DASSOP,e1,e2,op+DOP));
#endif
#if LONGLONG_CODE
    case LONGLONG:
        e2=longlong_value(e2);
        return(list4(LASSOP,e1,e2,op+LOP));
    case ULONGLONG:
        e2=ulonglong_value(e2);
        return(list4(LASSOP,e1,e2,op+LOP+((op==MUL+AS||op==DIV+AS)?US:0)));
#endif
    case CHAR:
        e2=correct_type(e2,INT); ass = CASSOP;  break;
    case SHORT:
        e2=correct_type(e2,INT); ass = SASSOP; break;
    case INT:
        e2=correct_type(e2,INT); ass = ASSOP;  break;
    case UCHAR:
        e2=correct_type(e2,UNSIGNED); ass = CUASSOP; u=1; break;
    case USHORT:
        e2=correct_type(e2,UNSIGNED); ass = SUASSOP; u=1; break;
    case UNSIGNED:
        e2=correct_type(e2,UNSIGNED); ass = ASSOP;  u=1; break;
    default:
        if (t>0 && car(t)==BIT_FIELD) {
            //        type = list4(BIT_FIELD,type,
            //            list3(type /*store type*/,0 /*bit offset*/,symval));
            e2 = correct_type(e2,car(caddr(t))); /* store type */
            type = set_type_with_attr(cadr(t),type); /* value type */
            return(list4(BASSOP,e1,e2,list2(op,t)));
        }
    }
    if (u) {
        if (op==RSHIFT||op==LSHIFT) op=op+US;
        else {
            switch(type) {
            case UCHAR: case USHORT: case UNSIGNED:
                if (op==MUL||op==DIV||op==MOD) op=op+US;
            }
        }
    }
    type = set_type_with_attr(t,type);
    if(integral(t)) return(list4(ass,e1,e2,op));
    /* pointer += ... */
    if((op!=ADD&&op!=SUB)||car(t)!=POINTER) error(TYERR);
    if (lp64) {
        e2=binop(MUL,e2,llist2(LCONST,size(cadr(t))),INT,ULONGLONG);
        type = set_type_with_attr(t,type);
        return list4(LASSOP,e1,e2,op+LOP);
    }
    e2=binop(MUL,e2,list2(CONST,size(cadr(t))),INT,UNSIGNED);
    type = set_type_with_attr(t,type);

    return list4(ASSOP,e1,e2,op);
}


/*
   assop
      code generation
 */

static void
iassop(int e1)
{
    int e2,e3,byte,op,sign,size;
    int t;

    /*   e2 op= e3 */
    switch(car(e1)) {
    case  CUASSOP: byte = 1; sign = 0; size = 1; break;
    case  CASSOP:  byte = 1; sign = 1; size = 1; break;
    case  SUASSOP: byte = size_of_short; sign = 0; size = size_of_short; break;
    case  SASSOP:  byte = size_of_short; sign = 1; size = size_of_short; break;
    default:       byte = lp64?size_of_int:0; sign = 1; size = size_of_int;
    }
    e2 = cadr(e1);
    e3 = caddr(e1);
    op = cadddr(e1);

    if (car(e2)==REGISTER) {
        if (code_const_op_p(op,e3)) {
            oprtc(op,cadr(e2),e3);
        } else {
            g_expr(e3);
            code_register_assop(cadr(e2),USE_CREG,op,byte);
        }
        if (use) {
            code_register(cadr(e2),USE_CREG);
        }
        return;
    }
    if (car(e3)==CONST) {
        /*  e2 = e2 op e3; */
        t = sign?INT:UNSIGNED;
        // oprtc expected
        if (car(e2)==LVAR||car(e2)==GVAR||
                 (car(e2)==INDIRECT&&car(cadr(e2))==REGISTER)) {
            g_expr0(assign_expr0(e2,list3(op,rvalue_t(e2,t),e3),t,t));
            return;
        }
#if 0
        /*  new = &e2 */
        /*  *new = *new op e3 */
        // e2 が複雑な式でないと却ってだめなこともある
        // register が取れれば常に有効か?
        // たぶん、i386 の時には有効だったんだろうなぁ。
        int n = list3n(LVAR,new_lvar(size_of_int),0); // get register var?
        g_expr_u(assign_expr0(n,list2(ADDRESS,e2),INT,INT));
        g_expr0(assign_expr0(rvalue_t(n,INT),
            list3(op,rvalue_t(list2(INDIRECT,rvalue_t(n,INT)),t),e3),t,t));
        free_lvar(cadr(n));
        return;
#endif
    }
    g_expr(e3);
    emit_push();
    g_expr(e2);
    code_assop(op,USE_CREG,byte,sign);
    return;
}

#if FLOAT_CODE

static void
dassop(int e1)
{
    int e2,e3,op,d;

    /*   e2 op= e3 */
    d = (car(e1) == DASSOP);
    e2 = cadr(e1);
    // if (car(e2)==INDIRECT) e2=cadr(e2);
    e3 = caddr(e1);
    op = cadddr(e1);

    if (car(e2)==DREGISTER||car(e2)==FREGISTER) {
        g_expr(e3);
        emit_dpush(d);
        code_register_dassop(cadr(e2),op,d);
        if (use)
            code_dregister(cadr(e2),USE_CREG,d);
        return;
    }
    if (car(e3)==DCONST||car(e3)==FCONST) {
        /*  e2 = e2 op e3; */
        int t = d?DOUBLE:FLOAT;
        // oprtc expected
        if (car(e2)==LVAR||car(e2)==GVAR||
                 (car(e2)==INDIRECT&&car(cadr(e2))==REGISTER)) {
            g_expr0(assign_expr0(e2,list3(op,rvalue_t(e2,t),e3),t,t));
            return;
        }
    }
    g_expr(e3);
    emit_dpush(d);
    g_expr(e2);
    code_dassop(op,USE_CREG,d);
    return;
}

#endif 

#if LONGLONG_CODE

static int
long_sign(int op)
{
    return (op==LUDIV||op==LUMOD||op==LULSHIFT||op==LURSHIFT)?ULONGLONG:LONGLONG;
}

static void
lassop(int e1)
{
    int e2,e3,op;
    int t;

    /*   e2 op= e3 */
    e2 = cadr(e1);
    // if (car(e2)==INDIRECT) e2=cadr(e2);
    e3 = caddr(e1);
    op = cadddr(e1);

    if (car(e2)==LREGISTER) {
        if (code_lconst_op_p(op,e3)) {
            loprtc(op,cadr(e2),e3);
            if (use) {
                code_lregister(cadr(e2),USE_CREG);
            }
            return;
        }
        if (code_lassop_p) {
            g_expr(e3);
            emit_lpush();
            code_register_lassop(cadr(e2),op);
            if (use) {
                code_lregister(cadr(e2),USE_CREG);
            }
            return;
        }
    }
    if (!code_lassop_p||car(e3)==LCONST) {
        /*  e2 = e2 op e3; */
        t = long_sign(op);
        if (car(e2)==LREGISTER||car(e2)==LVAR||car(e2)==GVAR||
                 (car(e2)==INDIRECT&&car(cadr(e2))==REGISTER)) {
            g_expr0(assign_expr0(e2,list3(op,rvalue_t(e2,t),e3),t,t));
            return;
        }
        if (!code_lassop_p) {
            /*  new = &e2 */
            /*  *new = *new op e3 */
            int n = list3n(LVAR,new_lvar(size_of_int),0);
            g_expr_u(assign_expr0(n,list2(ADDRESS,e2),INT,INT));
            g_expr0(assign_expr0(rvalue_t(n,INT),
                list3(op,rvalue_t(list2(INDIRECT,rvalue_t(n,INT)),t),e3),t,t));
            free_lvar(cadr(n));
            return;
        }
    }

    g_expr(e3);
    if (car(e2)==LREGISTER||car(e2)==REGISTER) {
        emit_lpush();
        code_register_lassop(cadr(e2),op);
        if (use)
            code_lregister(cadr(e2),USE_CREG);
        return;
    }
    emit_lpush();
    g_expr(e2);
    code_lassop(op,USE_CREG);
    return;
}

#endif 

extern void 
cmpdimm(int e, int csreg,int label,int cond)
{
    if (!chk) {
        if (car(csreg)==CONST) {
            switch(cond) {
            case 1: case 0: 
            if (cond ^ (cadr(csreg)==e)) gen_jmp(label);
                break;
            case LT:
            if ((cadr(csreg)>e)) gen_jmp(label);
                break;
            }
        } else if (car(csreg)==REGISTER) {
            code_cmpdimm(e, cadr(csreg),label,cond);
        } else error(-1);
    }
}

extern int 
csvalue()
{
    return code_csvalue();
}

extern void
gen_ret()
{
    if (chk) return;
    code_ret();
}

extern void
gen_label_call(int l)
{
    if (chk) return;
    code_label_call(l);
}

extern int
fwdlabel(void)
{       
    return labelno++;
}

extern void
fwddef(int l)
{       
    if (l==0) return;
    checkjmp(l);
    control=1;
    if (!chk)
        code_label(l);
}

extern int
backdef(void)
{       
    checkjmp(0);
    control=1;
    if (!chk)
        code_label(labelno);
    return labelno++;
}

// define case label with default label for switch statement

extern void
df_label(int cslabel, int dlabel)
{
    int fl;

    checkjmp(0);
    fl = 0;
    if (control) {
        gen_jmp(fl=fwdlabel());
    }
    fwddef(cslabel);
    if (dlabel)
        gen_jmp(dlabel);
    if (fl) {
        fwddef(fl);
    }
}

extern void
ret(void)
{       
    if (!is_inline(fnptr))  {
        if (!chk)
            code_set_return_register(1);
    }
    gen_jmp(retlabel); 
}

extern void
opening(char *filename)
{
    emit_init();
    if (!chk)
        code_opening(filename);
}

extern void
closing()
{
    int e;
    NMTBL *n;
    inmode = 0;
    for(e=inline_funcs;e;e=cadr(e)) {
        n = ncaddr(e);
        if (is_code(n)||is_function(n)) {
            if (n->sc!=STATIC || has_attr(n,FNAME)) {
                // global or used as pointer
                // generate possibly called inline function
                pfdecl(n);
            }
        }
    }
    if (!chk)
        code_closing();
    conv->close_();
}

static int
contains_in_list(int e,int type)
{
    while(e) {
        if(contains(car(e),type)) return 1;
        e = cadr(e);
    }
    return 0;
}

static int
contains(int e,int type)
{
    while(e) {
        if (car(e)==type) return 1;
        if (!car(e)) return 0;
        if (LIST_ARGS(car(e))){
        /* list arguments */
            return contains_in_list(caddr(e),type);
        } else if (UNARY_ARGS(car(e))) {
        /* unary operators */
            e = cadr(e);
            continue;
        } else if (BINARY_ARGS(car(e))) {
        /* biary operators */
            if (contains(cadr(e),type)) return 1;
            e = caddr(e);
            continue;
        } else if (TERNARY_ARGS(car(e))) {
        /* tarary operators */
            if (contains(cadr(e), type)) return 1;
            if (contains(caddr(e),type)) return 1;
            e = cadddr(e);
            continue;
        } else if (NULLARY_ARGS(car(e))) {
        /* nullary operators */
            return 0;
        } else if (IS_STATEMENT(car(e))) {
            return 1;  // may contain anything
        } else {
            // if (lsrc)fprintf(stderr,"Unknown Tree ID %d\n",car(e));
            error(-1);
            return 0;
        }
    }
    return 0;
}

static int
contains_in_list_p(int e,int (*p)(int))
{
    while(e) {
        if(contains_p(car(e),p)) return 1;
        e = cadr(e);
    }
    return 0;
}

extern int
contains_p(int e,int (*p)(int))
{
    while(e) {
        int e1 = car(e);
        if (!e1) return 0;
        if (p(e1)) return 1;
        if (LIST_ARGS(e1)){
        /* list arguments */
            return contains_in_list_p(caddr(e),p);
        } else if (UNARY_ARGS(e1)) {
        /* unary operators */
            e = cadr(e);
            continue;
        } else if (BINARY_ARGS(e1)) {
        /* biary operators */
            if (contains_p(cadr(e),p)) return 1;
            e = caddr(e);
            continue;
        } else if (TERNARY_ARGS(e1)) {
        /* tarary operators */
            if (contains_p(cadr(e), p)) return 1;
            if (contains_p(caddr(e),p)) return 1;
            e = cadddr(e);
            continue;
        } else if (NULLARY_ARGS(e1)) {
        /* nullary operators */
            return 0;
        } else if (IS_STATEMENT(e1)) {
            return 1;  // may contain anything
        } else {
            // if (lsrc)fprintf(stderr,"Unknown Tree ID %d\n",car(e));
            error(-1);
            return 0;
        }
    }
    return 0;
}

/* gahter accumurated list in all parse tree */

static int
contains_in_list_p1(int arg,int e,int (*p)(int,int))
{
    while(e) {
        arg=contains_p1(arg,car(e),p);
        e = cadr(e);
    }
    return arg;
}

extern int
contains_p1(int arg,int e,int (*p)(int,int))
{
    while(e) {
        int e1 = car(e);
        if (!e1) return arg;
        if (LIST_ARGS(e1)){
        /* list arguments */
            return contains_in_list_p1(arg,caddr(e),p);
        } else if (UNARY_ARGS(e1)) {
        /* unary operators */
            e = cadr(e);
            continue;
        } else if (BINARY_ARGS(e1)) {
        /* biary operators */
            arg=contains_p1(arg,cadr(e),p);
            e = caddr(e);
            continue;
        } else if (TERNARY_ARGS(e1)) {
        /* tarary operators */
            arg=contains_p1(arg,cadr(e), p);
            arg=contains_p1(arg,caddr(e),p);
            e = cadddr(e);
            continue;
        } else if (NULLARY_ARGS(e1)) {
        /* nullary operators */
            arg=p(arg,e);
            return arg;
        } else if (IS_STATEMENT(e1)) {
            return arg;
        } else {
            // if (lsrc)fprintf(stderr,"Unknown Tree ID %d\n",car(e));
            // error(-1);
            return arg;
        }
    }
    return arg;
}

/* gahter accumurated list in all parse tree for all operator */

static int
contains_in_list_p2(int arg,int e,int (*p)(int,int))
{
    while(e) {
        arg=contains_p2(arg,car(e),p);
        e = cadr(e);
    }
    return arg;
}

extern int
contains_p2(int arg,int e,int (*p)(int,int))
{
    while(e) {
        if (!car(e)) return arg;
        if (LIST_ARGS(car(e))){
        /* list arguments */
            arg=p(arg,e);
            return contains_in_list_p2(arg,caddr(e),p);
        } else if (UNARY_ARGS(car(e))) {
        /* unary operators */
            arg=p(arg,e);
            e = cadr(e);
            continue;
        } else if (BINARY_ARGS(car(e))) {
        /* biary operators */
            arg=p(arg,e);
            arg=contains_p2(arg,cadr(e),p);
            e = caddr(e);
            continue;
        } else if (TERNARY_ARGS(car(e))) {
        /* tarary operators */
            arg=p(arg,e);
            arg=contains_p2(arg,cadr(e), p);
            arg=contains_p2(arg,caddr(e),p);
            e = cadddr(e);
            continue;
        } else if (NULLARY_ARGS(car(e))) {
        /* nullary operators */
            arg=p(arg,e);
            return arg;
        } else if (IS_STATEMENT(car(e))) {
            return arg;
        } else {
            // if (lsrc)fprintf(stderr,"Unknown Tree ID %d\n",car(e));
            // error(-1);
            return arg;
        }
    }
    return arg;
}

//
// globalize parse tree
//

static int
copy_list(int e)
{
    int e1;
    if (!e) return 0;
    e1 = copy_expr(car(e));
    return glist2(e1,copy_list(cadr(e)));
    return 0;
}

extern int
copy_expr(int e)
{
    int smode = mode;  
        if (!e || !car(e)) return 0;
        if (car(e)<0) {
            mode = GDECL;
            switch (car(e)){
            case CONST: e=list2(car(e),cadr(e)); break;
            case FCONST: 
            case DCONST: e=dlist2(car(e),dcadr(e)); break;
            case LCONST: e=llist2(car(e),lcadr(e)); break;
            case STRING: e=list3n(car(e),cadr(e),ncaddr(e)); break;
            case STRINGS: e=list3s(car(e),cadr(e),scaddr(e)); break;
            case STRUCT:  // for udpcl
                e=glist3(car(e),copy_expr(cadr(e)),copy_expr(caddr(e))); break;
            case ARRAY:
                e= glist5(car(e),copy_expr(cadr(e)),
                copy_expr(caddr(e)),cadddr(e),caddddr(e)); 
                break;
            }
            mode = smode;
            return e;
        }
        switch (OP(car(e))){
        // special cases
        case ARROW:
        case PERIOD:
            return glist4(car(e),copy_expr(cadr(e)),caddr(e),cadddr(e));
        case LVAR: case RLVAR:case URLVAR:
        case GVAR: case RGVAR:case URGVAR:
            return (e>gfree)?glist3(car(e),cadr(e),caddr(e)):e;
        case INDIRECT: // case RINDIRECT:
            return glist2(car(e),copy_expr(cadr(e)));
        }
        if (LIST_ARGS(car(e))){
        /* list arguments */
            return copy_list(caddr(e));
        } else if (UNARY_ARGS(car(e))) {
        /* unary operators */
            e = glist2(car(e),copy_expr(cadr(e)));
            return e;
        } else if (BINARY_ARGS(car(e))) {
        /* biary operators */
            e = glist3(car(e),copy_expr(cadr(e)),copy_expr(caddr(e)));
            return e;
        } else if (TERNARY_ARGS(car(e))||car(e)==STRUCT) {
        /* ternary operators */
            e = glist4(car(e),copy_expr(cadr(e)),
                copy_expr(caddr(e)),
                copy_expr(cadddr(e)));
            return e;
        } else if (NULLARY_ARGS(car(e))) {
        /* nullary operators */
            if (e>gfree) { // local
                int smode = mode;
                switch(car(e)%SOP) {
                case GVAR: case RGVAR: case URGVAR:
                case LVAR: case RLVAR: case URLVAR:
                case REGISTER: case FREGISTER:
                case DREGISTER: case LREGISTER:
                case FNAME:
                case IVAR: case RIVAR:
                    e = glist3n(car(e),cadr(e),ncaddr(e)); break;
                case STRING:
                    e = glist3n(car(e),cadr(e),ncaddr(e)); break;
                case STRINGS:
                    e = glist3s(car(e),cadr(e),scaddr(e)); break;
                case CONST: 
                    switch(car(e)) {
                    case CONST:
                        e = glist2(car(e),cadr(e)); break;
                    case DCONST: case FCONST:
                        mode=GDECL;
                        e = dlist2(car(e),dcadr(e)); mode = smode; break;
                    case LCONST: 
                        mode=GDECL;
                        e = llist2(car(e),lcadr(e)); mode = smode; break;
                    }
                    break;
                case LCALL:
                case LABEL:
                    e = glist2(car(e),cadr(e)); break;
                case DECL:
                case COMP:
                    // is this correct?
                    e = glist2(car(e),cadr(e)); break;
                }
            } 
            return e;
        } else if (IS_STATEMENT(car(e))) {
            // already in global heap
            return e;  // may contain anything
        } else {
            // if (lsrc)fprintf(stderr,"Unknown Tree ID %d\n",car(e));
            error(-1);
            return 0;
        }
    return 0;
}

#if ASM_CODE


/*
        __asm__ __volatile__ ("sthbrx %1,0,%2" : "=m" (*addr) : "r" (val), "r" (a
ddr));
   asm string : output constraint parameter : input constraint parameter : opt

     1: asm string     %1,%2 will be replaced by register or value
     2: constraint     gcc constraint sting
        prefix
           =    overwrite by this asm for output
           &    overwrite by this asm and can't be used as input register
           ignored in this compiler
        constraints
           m    value expression is modified (no corresponding register)
                        information for compiler
           r    register for input or output 
                        input register, output register can be shared
           0-9  same operands as outout register in input constraints
      3: opt     "cc", "memory"
           ignored in this compiler
 */

static void
gen_asm(int asm0,int in,int out,int opt,int e)
{
    int i,e1,n;
    int repl = 0;
    int repl0;
    int assign = 0;
    char *p;
    int ty;

    e = reverse0(e);

    for(i=out;i;i=cadr(i)) {
        p = (ncaddr(car(i)))->nm;
        e1 = car(e); e = cadr(e);
        repl = code_asm_operand(p,e1,ASM_OUTPUT,repl,0,0);
        if (!chk && repl) {
            switch(car(car(repl))) {
            case REGISTER: ty = INT; break;
            case LREGISTER: ty = LONGLONG; break;
            case FREGISTER: ty = FLOAT; break;
            case DREGISTER: ty = DOUBLE; break;
            default: continue;
            }
            assign = list2(assign_expr0(e1,car(repl),ty,ty),assign);
        }
    }
    repl0 = repl;
    n = length(repl0);
    for(i=in;i;i=cadr(i)) {
        p = (ncaddr(car(i)))->nm;
        e1 = car(e); e = cadr(e);
        repl = code_asm_operand(p,e1,ASM_INPUT,repl,n,repl0);
        if (!chk && repl) {
            switch(car(car(repl))) {
            case REGISTER: ty = INT; break;
            case LREGISTER: ty = LONGLONG; break;
            case FREGISTER: ty = FLOAT; break;
            case DREGISTER: ty = DOUBLE; break;
            default: continue;
            }
            g_expr_u(assign_expr0(car(repl),e1,ty,ty));
        }
    }

    repl = reverse0(repl);
    p = (ncaddr(asm0))->nm;
    code_asm(p,repl);
    for(i=assign;i;i=cadr(i)) {
        g_expr_u(car(i));
    }
    code_free_asm_operand(repl);
    // no check for opt 
}

#endif

static void
set_ctmode(NMTBL *n,int ctmode)
{
    if (ctmode & KONST_BIT) set_attr(n,KONST,0);
    if (ctmode & VOLATILE_BIT) set_attr(n,VOLATILE,0);
    if (ctmode & RESTRICT_BIT) set_attr(n,RESTRICT,0);
}

static int 
struct_align_offset(int t,int offset)
{
    int strtype=0;
    if (t>0 && (car(t)==STRUCT||car(t)==UNION))
        strtype=1;
    int sz = size(t);
    if (lp64 && (sz%size_of_longlong==0)) {
        offset = align(offset,size_of_longlong);
    } else if (sz%size_of_int==0||strtype) {
        offset = align(offset,struct_align);
    }
    return offset;
}

/*
    define symbol name contents 
      depending on stmode, mode
      define displacement
 */

extern NMTBL *
def(NMTBL *n,int ctmode)
{
    int sz,nsc,ndsp,align0;
    int sbit_f = bit_field_disp;
    int type0 = type_value(type);
    int attr = attribute;
    attribute = 0;

    bit_field_disp = 0;  // default is 0, recover only in bit-field

    if (n==0) {
        n=anonymous_nptr();
        n->nm = "_";
    }
    nsc=ndsp=0;
    if (stmode==EXTRN||mode==GDECL)
        n->ty = type;  /* must be in global table/heap */
    if(type0>0&&(car(type0)==FUNCTION || car(type0)==CODE)) {
        if (mode==GDECL) {
            fcheck(n);
            NMTBL *fsave = fnptr;
            int save = struct_return;
            fnptr = n;
            fdecl_struct(n->ty); /* insert extra argument for struct passing */
            struct_return = save;
            fnptr = fsave;
            set_ctmode(n,ctmode);
            set_attributes(n,attr);
            return n;
            /* function and code segment are defined using fdecl/code_decl */
            /* in decl() */
        }
    }

    // compute size 

    if (mode==GSDECL||mode==LSDECL) {   // struct
        /* Struct fields name lists are in the struct type or tag. */
        /* Only name in the table is used. Do not set n->ty! */
        /* Struct field may volatile... where do I put? list2(VOLATILE,type)? */
        /* disp is pushded and reset in sdecl */
        if (type0>0 && car(type0)==BIT_FIELD) {
            bit_field_disp=sbit_f;   // default is 0, recover only here.
            //        type = list4(BIT_FIELD,value type,
            //            list3(store type,bit offset,bit_width));
#if BIT_FIELD_CODE
            cadr(caddr(type0)) = code_bit_field_disp(
                type,&disp,&bit_field_disp,&sz);
            /* bit_field_disp is next bit posision */
#else
            error(-1);
#endif
        }  else {
            sz = size(type0);
#if STRUCT_ALIGN 
            disp = struct_align_offset(type0,disp);
#endif
            if ((align0=attr_value_in_list(attr,ALIGNED))) {
int hoge = disp;
                if (car(align0)!=CONST) error(-1);
                // align have to be 2^n
                align0 = caddr(align0);
                disp = align(disp,align0);
if (lsrc && hoge!=disp)
printf("# field %s %d->%d (align %d)\n",n->nm,hoge,disp,align0);
            }
        }
        if (n!=&null_nptr)
            fields = list4n(type,fields,disp,n);
        // don't set attribute to n
    } else if (mode==GUDECL||mode==LUDECL) { // union
        /* disp is pushded and reset in sdecl */
        if (type0>0 && car(type0)==BIT_FIELD) {
            cadr(caddr(type0)) = 0; sz = size(cadr(type0));
        }  else {
            sz = size(type0);
        }
        fields = list4n(type,fields,0,n);
    } else {
        if (n->sc!=EMPTY &&  !(n->sc==EXTRN||n->sc==EXTRN1||n->sc==STATIC)) {
          /* redefined case */
          if (mode==ADECL) {  /* K&R arguments case */
            if (n->sc==LVAR && n->ty==INT);
            else if ( n->sc==REGISTER && n->ty==INT);
            else if ( n->sc==TYPE) {
                n = lsearch(n->nm,0);
            } else error(RDERR);
          } else {
            if (mode==GDECL) {
                compatible(n->ty,type);
            } else
                error(RDERR); // on different type
          }
        }
        sz = size(n->ty = type);
    }
    switch(mode) {
    case GDECL:            // global variable
        gen_gdecl(n->nm,gpc);
    case STADECL:          // static variable
        nsc = GVAR;
        ndsp = gpc;
        if (n->dsp!=-1)     /* don't set dsp if initialized static */
            n->dsp = ndsp;  /* emit_data will override this */
        if (stmode==EXTRN)
            nsc = EXTRN;
        else if (stmode==STATIC||stmode==LDECL)
            nsc = STATIC;
        n->sc = nsc;
        if (stmode==LDECL) {
            // this means local static variable
            n = new_static_name(n->nm,'.');
            if (!n->next) {
                n->next = local_static_list; local_static_list = n;
            }
        } else {
            if (!n->next) {
                n->next = global_list; global_list = n;
            }
        }
        gpc +=sz;
        set_ctmode(n,ctmode);
        set_attributes(n,attr);
        return n;
    case GSDECL: case LSDECL:   // struct
        disp += sz;
        return n;
    case GUDECL: case LUDECL:   // union
        /* In union case, disp contains max size of the member */
        if (disp < sz) disp = sz;
        return n;
    case GTDECL:                // typedef
        nsc = TYPE;
        gtypedefed=glist3n(GTDECL,gtypedefed,gnptr);
        set_attributes(n,attr);
        break;
    case LTDECL:                // local typedef
        nsc = TYPE;
        set_attributes(n,attr);
        break;
    case LLDECL:                // label def (gcc extension)
        nsc = FLABEL;
        if (!inmode)
            ndsp = fwdlabel();
        else
            ndsp = --disp;
        // inmode の時は pvartable のoffset を確保する。st_label で
        // nptr が 0 ならば backdef、st_label よりも先に使われたら
        // fwdlabel すれば良い。
        // scope は parse 時に解決される。
        break;
    case ADECL:                 // funcion arguments
        if(type0>0) {
            if (!integral(type0) && (car(type0)==FUNCTION||car(type0)==CODE)) {
                type=list2(POINTER,type); n->ty = type;
                sz = size_of_pointer;
                type0=type;
            } else if (car(type0)==ARRAY) {
                type=list2(POINTER,cadr(type)); n->ty = type;
                sz = size_of_pointer;
                type0=type;
            }
        }
        fnptr->dsp=list4n(type,fnptr->dsp,0,n);
        n->sc = LVAR;
        if(inmode==INLINE) {
            n->dsp = args++;
            n->sc = IVAR;
        } else {
            // this is useless, because we cannot know this function is code or function now
            // we have to fix this later in case of code segment ( in code_arg_register )
            args = code_arg_alignment(args,n,type0,sz, is_code(fnptr));
        }

        caddr(fnptr->dsp)=sz;
        if(type0==VOID) {
        } else {
            n->ty = type;
        }
        // don't set attribute
        set_ctmode(n,ctmode);
        return n;
    case STAT: /* return (struct hoge)f() case? */
    case LDECL:    // local variable
        set_attributes(n,attr);
        if (stmode==REGISTER && !(inmode==INLINE)) {
            if(scalar(type0)) {
                ndsp = get_register_var(n);
#if FLOAT_CODE
            } else if (type0==FLOAT) {
                ndsp = get_dregister_var(n,0);
            } else if (type0==DOUBLE) {
                ndsp = get_dregister_var(n,1);
#endif
#if LONGLONG_CODE
            } else if (type0==LONGLONG||type0==ULONGLONG) {
                ndsp = get_lregister_var(n);
#endif
            } else error(DCERR);
            nsc = car(ndsp);
            ndsp = cadr(ndsp);
        } else if (inmode==INLINE) {
            nsc = IVAR;
            ndsp = --disp;
        } else {
            code_lvar_alignment(disp,n,type0,sz);
            set_ctmode(n,ctmode);
            return n;
        }
        n->sc = nsc;
        n->dsp = ndsp;
        set_ctmode(n,ctmode);
    case SFDINIT:  
        return n;
    default:
        error(DCERR);
    }
    // should be an error?
    n->sc = nsc;
    n->dsp = ndsp;
    set_ctmode(n,ctmode);
    if (stmode==EXTRN)
        n->sc = EXTRN;
    return n;
}

// standard 32bit alignment 


// for function
extern int
code_arg_alignment0(int offset,NMTBL *n, int type0,int sz, int is_code)
{
    if(type0==CHAR||type0==UCHAR) {
        if (n->dsp==0) {
            n->dsp = is_code? -offset-size_of_int:offset;
            if (endian) n->dsp += size_of_int-1;
        }
        offset += size_of_int;
    } else if(type0==SHORT||type0==USHORT) {
        if (n->dsp==0) {
            n->dsp = is_code? -offset-size_of_int: offset;
            if (endian) n->dsp += size_of_int-size_of_short;
        }
        offset += size_of_int;
    } else if(type0>0&&(car(type0)==UNION||car(type0)==STRUCT)) {
        /* alignment in struct in argument */
        /* should be GCD of member alignment */
        /* __attribute(alignment(16)) is ignored in argments */
        int asz = align(sz,size_of_int);
        n->dsp = is_code? -offset-asz:offset;
        offset += asz;
    } else {
        /* if (n->dsp==0) (argument list in ADECL is useless, type
           list can be found in type ) */
        n->dsp = is_code? -offset-size_of_int: offset;
        offset += sz; 
    }
    return offset;
}

// standard 32bit alignment for local variable

extern int
code_lvar_alignment0(int disp0,NMTBL *n,int type0,int sz) {
    int align;

    /* local variable alignment is done by new_lvar */
    if ((align=attr_value(n,ALIGNED))) {
        if (car(align)!=CONST) error(-1);
        n->sc = LVAR;
        n->dsp = new_lvar_align(sz,caddr(align));
    } else {
        n->sc = LVAR;
        n->dsp = new_lvar(sz);
    }
    return disp;
}

// for mc-parse.c
extern int
arg_alignment(int args,NMTBL *n, int type0,int sz, int is_code)
{
    return code_arg_alignment(args,n, type0,sz, is_code);
}

extern char *
nm(NMTBL *n) {
    int e;
    NMTBL *str; 
    if (n->attr) {
        if ((e=attr_value(n,ASM))) {
            if (car(e)==STRINGS) {
                // first element only
                return scaddr(e); // may non terminated
            }
            if (car(e)!=STRING) error(-1);
            str = ncaddr(e);
            return str->nm;
        }
    }
    return n->nm;
}

extern void
emit_init_vars(void)
{
    int e;
    if (!init_vars) return;
    e = reverse0(init_vars); init_vars = 0;
    if (inmode) {
        while(e) {
            parse = list3(ST_COMP,parse,car(e));
            e = cadr(e);
        }
        return;
    }
    while(e) {
        g_expr_u(car(e));
        e = cadr(e);
    }
}

static int
str_init_eq()
{
    // error(-1);  // duplicate struct field value
    return 2;      // allow override keep unique
}

//
// generate constant on global memory
//
static int
emit_name(int e,NMTBL *n, int sz) 
{
        switch(car(e)) {
        case CONST:
            if (lp64 && sz>4) emit_longlong(e); else emit_int(cadr(e));
            return 1;
        case LCONST:
            if (lp64 && sz>4) emit_longlong(e); else emit_int(lcadr(e));
            return 1;
        case ADDRESS:
            if (car(cadr(e))==GVAR)
                emit_address((ncaddr(cadr(e)))->nm,cadr(cadr(e)));
            else error(INERR);
            return 1;
        case FNAME:
            emit_address((ncaddr(e))->nm,0);
            return 1;
        case GVAR:
            emit_address((ncaddr(e))->nm,0);
            return 1;
        case STRING:
            emit_string((ncaddr(e))->nm,n->ty,(ncaddr(e))->dsp);
            return 1;
        case STRINGS:
            emit_strings(ncaddr(e));
            return 1;
        }
    // if (lsrc)fprintf(stderr,"## type= %d\n",t);
        return 0;
}


static void
emit_data(int e, int t, NMTBL *n)
{
    t = type_value(t);
    if(mode!=GDECL && mode!=STADECL)  { 
        error(-1); return;
    }
    if (chk) return;
    if (n->dsp != -1) {
        n->dsp = -1;   /* initialized flag */
        emit_global(n,t,e);
    }
    switch(t) {
    case EMPTY:
        if(car(e)!=CONST) error(-1);
        emit_space(cadr(e));
        return;
    case CHAR: case UCHAR:
        if (car(e)!=CONST) error(INERR);
        emit_char(cadr(e));
        data_alignment++;
        return;
    case SHORT: case USHORT:
        if (car(e)!=CONST) error(INERR);
        emit_short(cadr(e));
        data_alignment++;
        return;
    case DOUBLE:
        if (car(e)!=DCONST&&car(e)!=FCONST) error(INERR);
        emit_double(e);
        return;
    case FLOAT:
        if (car(e)!=DCONST&&car(e)!=FCONST) error(INERR);
        emit_float(e);
        data_alignment++;
        return;
    case LONGLONG: case ULONGLONG:
        if (car(e)==CONST) {
            emit_longlong(llist2(LCONST,cadr(e))); 
            return;
        } else if (car(e)==LCONST) {
            emit_longlong(e); 
            return;
        }
        if (lp64 && emit_name(e,n,size(t))) return;
        break;
    default:
        if (t<0) error(-1);
        if (car(t)==BIT_FIELD) {
            /* not yet supported */
            error(-1);
            return;
        }
        if (car(t)!=POINTER&&car(t)!=ARRAY) error(-1);
    case INT: case UNSIGNED:   /* including address case */
    case ENUM:
        if (emit_name(e,n,size(t))) return;
    }
    error(INERR);
}


extern int
gen_delayed_decl_data(int v,int offset)
{
    int e;
    int t,sz,offset1=0;
    int init = decl_str_init;
    NMTBL *n = ncaddr(v);

    decl_str_init = 0;
    sz = size(n->ty);
    /*
         decl_str_init
            output delayed decl data
         list4(offset,next,expression,list2(type0,type1));
     */
    while (init) {
        offset1= car(init);
        e=caddr(init);
        t=car(cadddr(init));
        if (offset1!=offset) {
            // make space
            assign_data(list2(CONST,offset1-offset),EMPTY,v,offset);
        }
        type=cadr(cadddr(init));
        offset = gen_decl_data0(v,t,e,offset1);
        init = cadr(init);
    }
    if ((sz=(sz-offset))>0)
        assign_data(list2(CONST,sz),EMPTY,v,offset);
    decl_str_init = 0;
    local_nptr = 0;
    return offset;
}

static int
gen_decl_data_array(int v,int init,int target_type,int offset)
{
    int type0 = cadr(target_type);  /* array item type */
    int e;

    for(; init; init = cadr(init)) {
        // unordered data with tag or array offset
        if (car(init)!=DECL_DATA_ARRAY) {
                error(-1);
        }
        e = caddr(init);
        if (!e) continue; // {...,} case
        e = pexpr(e);
        offset = gen_decl_data0(v,type0,e,offset);
    }
    return offset;
}

static int
gen_decl_data_field(int v,int init,int target_type,int offset)
{
    int type0 = target_type;  /* list of fields */
    int e,t,type1,foffset;
    NMTBL *n;

    for(; init; init = cadr(init)) {
        // unordered data with tag or array offset
        if (car(init)!=DECL_DATA_FIELD) {
                error(-1);
        }
        n = ncadddr(init);
        type1 = search_struct_type(type0,n->nm,&foffset);
        e = caddr(init);
        if (car(e)!=DECL_DATA) error(-1);
        t = caddr(e);
        decl_str_init=insert_ascend(decl_str_init,
            glist4(offset+foffset,0,e,glist2(type1,t)),str_init_eq);
    }
    return offset;
}

static int
gen_decl_data_list(int v,int init,int target_type,int offset)
{
    int type0 = caddr(target_type);  /* list of fields */
    int e;

    for(; init; init = cadr(init)) {
        if (car(init)==DECL_DATA) {
            // casted initilizer
            e = cadr(init); // value
            if (!e) continue; // {...,} case
            offset = gen_decl_data0(v,caddr(init),e,offset);
            continue;
        }
        // ordered data
        if (car(init)!=DECL_DATA_LIST) {
                error(-1);
        }
        e = caddr(init);
        if (!e) {  // {...,} case
            int sz = size(target_type);
            zfill(v, offset, sz);
            offset += sz;
            continue;
        }
        offset = gen_decl_data0(v,car(type0),e,offset);
        type0 = cadr(type0);
    }
    return offset;
}


static int
gen_decl_data0(int v,int target_type,int init,int offset)
{
    int e,t;
    if (car(init)==DECL_DATA) {
        switch( car(e=cadr(init))) {
        case DECL_DATA_LIST:
            offset = gen_decl_data_list(v,e,target_type,offset);
            break;
        case DECL_DATA_FIELD:
            offset = gen_decl_data_field(v,e,target_type,offset);
            break;
        case DECL_DATA_ARRAY:
            offset = gen_decl_data_array(v,e,target_type,offset);
            break;
        default:
            type = t  = caddr(init);       // type of source
            // e = rvalue_t(e,t);
            offset=assign_data(e,target_type,v,offset);
        }
    } else {
        offset=assign_data(init,target_type,v,offset);
    }
    if (decl_str_init) {
        offset = gen_delayed_decl_data(v,offset);
    }
    return offset;
}

extern int
gen_decl_data(int e,int v)
{
    NMTBL *nptr0;
    int t = caddr(e);
    int e1,sz;
    int offset = 0;
    int sinit_vars = init_vars;
    init_vars = 0;

    type = t;
    sz = size(type);

    if (v==0) {
        nptr0 = get_nptr(); 
        nptr0->nm = "";
        nptr0->sc = LVAR;
        nptr0->attr = 0;
        nptr0->ty = t;
        nptr0->dsp = new_lvar_align(sz,16); // ?!
        e1 = list3n(nptr0->sc,nptr0->dsp,nptr0);
        v = list3n(nptr0->sc,nptr0->dsp,nptr0);
    } else {
        e1 = 0;
    }

    gen_decl_data0(v,t,e,offset);
    text_mode(0);

    if (init_vars) emit_init_vars();
    if (e1) g_expr0(e1);
    init_vars = sinit_vars;
    return type;
}

//
// local variable initialization
//
extern void
zfill(int var, int offset, int sz)
{
    int fill = sz;
    if (fill>63) {
        // call bzero 
    }
    int ass = list2(CONST,0);
    while(fill>0) {   // should consider alignment
        int t = UCHAR;
        if (fill>=size_of_longlong) t = ULONGLONG;
        else if (fill>=size_of_int) t = UNSIGNED;
        else if (fill>=size_of_short) t = USHORT;
        fill -= size(t);
        int dest =  (offset+fill)?( 
                (car(var)==LVAR) ?  ( lp64? list3n(LVAR,cadr(var)+offset+fill,ncaddr(var)) : list3n(LVAR,cadr(var)+offset+fill,ncaddr(var)) ) :
                                    ( lp64?list3(LADD,var,llist2(LCONST,offset+fill)): list3(ADD,var,list2(CONST,offset+fill)))) :
                var
        ;
        ass = assign_expr0(dest, ass,t,t); 
    }
    init_vars = list2(ass,init_vars);
}


extern int
assign_data(int e, int t, int v,int offset)
{
    int ass,bfd;
    int v0 = car(v);
    NMTBL *n = ncaddr(v);

#if STRUCT_ALIGN
    if (t!=EMPTY) 
        offset = struct_align_offset(t,offset);
#endif
    if (car(e)==ADDRESS||car(e)==GVAR) {
        if (scalar(t)) {
            int t1 = list2(POINTER,VOID); 
            if (size(t)>=size(t1)) t = t1; // fake
        } else {
            error(TYERR);
        }
    }
    switch (mode) {
    case GDECL:
        if (!is_const(e)) error(INERR);
        emit_data(e,t,n);
        break;
    case STADECL:
        if (!is_const(e)) error(INERR);
        else emit_data(e,t,n);
        break;
    case LDECL:
    case STAT:               // inline case
        if (t==EMPTY) {
            /* empty space in partial initialization */
            zfill(v,offset,cadr(e));
            return offset+cadr(e);
        }
        /* If this is a local declared constant, we don't have to assign.
           But some one may take it's address. We have to generate assign.
         */
        ass = assign_expr0(
    (v0==REGISTER||v0==DREGISTER||v0==FREGISTER||v0==LREGISTER)?
                v: (offset? list3n(v0,cadr(v)+offset,ncaddr(v)) : v),
            e,t,type);
        init_vars = list2(ass,init_vars);
        break;
    case SFDINIT:
// if (lsrc)printf("## %d sfdinit c0(e)=%d type=%d t=%d offset=%d\n",lineno,car(e),type,t,offset);
        decl_str_init=insert_ascend(decl_str_init,
                glist4(offset,0,e,glist2(t,type)),str_init_eq);
        break;
    default:
        error(DCERR);
        return offset;
    }
    if (t>0&&car(t)==BIT_FIELD) {
        int sz = 0; 
        bfd = cadr(caddr(t)); /* bit_field_disp */
#if BIT_FIELD_CODE
        code_bit_field_disp(t,&offset,&bfd,&sz);
#endif
        return offset+sz;
    }
    /* constant value field */
    if (offset==0 && (has_attr(n,KONST))) {
        if (is_const(e))
            set_attr(n,KONST,e);
    }
    return offset+((t==EMPTY)?cadr(e):size(t));
}

extern void
data_closing(int e,int type)
{
    if (!chk) {
	if (!inmode && type>0&&(car(type)==STRUCT||car(type)==UNION) && decl_str_init==0) {
	    zfill(e,0,size(type));
	}
        if (decl_str_init) gen_delayed_decl_data(e,0);
        emit_data_closing(ncaddr(e));
    }
}

#define ARG_REORDER_DEBUG 0

/*
     In K&R style, order of argment list and order of argment
     type decl are differnt. Fix them.

     arg      defined in f(a,b,c)
     new_arg  defined in   int b; short a; char c;
 */

extern int
arg_reorder(int arg,int new_arg)
{
    /*  list4(type,fnptr->dsp,(int)n,size); */
    int i,j,sz,arg_types = 0;
    int dsp = 0;
    NMTBL *n,*n1;

    /* f(a,b,c)  int c; short a; char* b; { } case */
#if ARG_REORDER_DEBUG
 if (lsrc)fprintf(stderr,"arg_reorder old:\n");
    for(j=new_arg;j;j=cadr(j)) {
            n=ncadddr(j);
 if (lsrc)fprintf(stderr,"dsp %d %s sz %d type %d\n",n->dsp,n->nm,cadddr(j),car(j));
    }
 if (lsrc)fprintf(stderr,"arg_reorder new:\n");
#endif
    for(j=arg;j;j=cadr(j)) {
        n=ncadddr(j);
        for(i=new_arg;i;i=cadr(i)) {
            n1=ncadddr(i);
            if (!neqname(n1->nm,n->nm)) break;
            // if (n1==n) break;
        }
#if ARG_REORDER_DEBUG
 if (lsrc)fprintf(stderr,"dsp %d %s %s sz %d type %d\n",dsp,n->nm,n1->nm,cadddr(i),car(i));
#endif
        if (!i) {
            /* f(a,b,c) int c; { } case (what?!) */
            i = j;
            n1 = n;
        }
        if(n->sc==LVAR) {
            n->dsp = dsp;
            car(j)=car(i);
            ncadddr(j)=ncadddr(i);
            n1->dsp = n->dsp;
            n->ty =  n1->ty;
            n->sc =  n1->sc;
            n->attr =  n1->attr;
            caddr(j)=sz= caddr(i);
            if (sz==1||sz==size_of_short) sz = size_of_int;
            dsp += sz;
        } else if(n->sc==IVAR) {
            n->dsp = dsp;
            car(j)=car(i);
            ncadddr(j)=ncadddr(i);
            n1->dsp = n->dsp;
            n->ty =  n1->ty;
            n->sc =  n1->sc;
            n->attr =  n1->attr;
            caddr(j)=sz= caddr(i);
            dsp ++;
        }
        arg_types = glist2(n->ty, arg_types);
    }
#if ARG_REORDER_DEBUG
 if (lsrc)fprintf(stderr,"arg_reorder end:\n");
#endif
    caddr(fnptr->ty) = reverse0(arg_types);
    return arg;
}


NMTBL str_ret;

/*
    If function has a structure return value, it has an extra
    argument for where to write the structure. It has to be
    the first argument. We add the argument here and we have 
    to fix all arguments' offset. If this is the last value, 
    we don't have to fix, but gcc has a first argument convention.
 */

extern void
fdecl_struct(int fntype)
{
    int type_save,mode_save,t,sz;
    NMTBL *n;
    int sargs = args;

    t = cadr(fntype);
    if (t>0 && (car(t)==STRUCT||car(t)==UNION)) {
        mode_save = mode;
        mode=ADECL;
        type_save = type;
        /* extra argument for struct return */
        /* This dummy variable is set in the calling sequence */
        str_ret.nm = "str_ret"; str_ret.sc = EMPTY;
        str_ret.dsp = 0; str_ret.ty = 0;
        type=list2(POINTER,t);
        /* fix all argument's offset */
        sz = inmode?1:size_of_pointer;
        for(t=fnptr->dsp;t;t=cadr(t)) {
            n=ncadddr(t);
            n->dsp += inmode?1:sz;
        }
        fnptr->dsp = reverse0(fnptr->dsp);
        if ((sz=size(cadr(fntype)))==-1) error(TYERR);
        else {
            args=0;  // set struct var dsp = 0
            def(&str_ret,0); 
            args = sargs + (inmode?1:size_of_pointer);
            struct_return = inmode
                ?list3(list3n(IVAR,str_ret.dsp,0),sz,type)
                :list3(list3n(LVAR,str_ret.dsp,0),sz,type);
            caddr(fnptr->ty) = glist2(POINTER,caddr(fnptr->ty));
        }
        type = type_save;
        mode = mode_save;
    } else {
        struct_return = 0;
        fnptr->dsp = reverse0(fnptr->dsp);
    }
}

extern void
fcheck(NMTBL *n)
{
    int type0 = type_value(type);
    if(!(mode==GDECL||mode==ADECL)||
             (car(type0)!=FUNCTION&&car(type0)!=CODE)) error(DCERR);
    if (n->sc==EMPTY) {
        n->sc=EXTRN;
        n->ty=type;
    } else if(is_code(n)) {
        // if (car(type0)!=CODE) error(TYERR);
        compatible(cadr(n->ty),cadr(type));
    } else if(is_function(n)) {
        // if (car(type0)!=FUNCTION) error(TYERR);
        compatible(cadr(n->ty),cadr(type));
    } else {
        error(DCERR);
    }
}

extern int
type_compatible(int t1, int t2)
{
    t1 = type_value(t1);
    t2 = type_value(t2);
    if(integral(t1)) {
            if(t1!=t2) return 0;
    }
    else if(t1<0 || t2<0) {
        if(t1!=t2) return 0;
    } else if(car(t1)!=car(t2))
            return 0;
    else if((car(t1)==STRUCT || car(t1)==UNION) && cadr(t1)!=cadr(t2))
            return 0;
    else if(car(t1)==POINTER || car(t1)==ARRAY ||car(t1)==FUNCTION)
            return type_compatible(cadr(t1),cadr(t2));
    return 1;
}

static void
compatible(int t1, int t2)
{
    if (!type_compatible(t1,t2)) error(TYERR);
}

extern int
scalar(int t)
{
    t = type_value(t);
    return(integral(t)
        ||(t>0 && (car(t)==POINTER)));
}

extern int
integral(int t)
{
    t = type_value(t);
    return(t==INT||t==SIGNED||t==CHAR||t==UNSIGNED||
        t==UCHAR||t==SHORT||t==USHORT||t==ENUM || 
                (lp64&&(t==LONGLONG||t==ULONGLONG)));
}

/*
    Delayed jmp code generation. A jump code will be delayed until
    new code generation or new label. If label is equal the jumped
    label, no jump code is necesarry.
 */

extern void
checkjmp(int l)
{
    int p = pending_jmp;
    if (p) {
        pending_jmp = 0;
        if (p!=l) {
            control=0;
            if (!chk)
                jmp(p);
        }
    }
}

/*
    Delayed jmp code to function leaveing part. The lastexp in
    a statement expression is also checked. It also handle the
    first case statement jump in switch statement.
 */

extern void
checkretpening(void)
{
    if (retpending) {
        ret();
        control=0;
        retpending=0;
    }
}

extern void
checkret(void)
{
    int lastexp0;
    if (!inmode) {
        code_save_stacks(); // because of statment expression
        if (cslabel==0) {
            if (!control) error(CSERR); // no execute code in switch
            checkjmp(0);
            control=0;
            jmp(cslabel=fwdlabel());
        } else if (retpending) {
            ret();
            control=0;
            retpending=0;
        }
        if (lastexp) {
            if(!control) error(-1);
            lastexp0 = lastexp;
            lastexp = 0;   // checkret can be nest?
            gexpr(lastexp0,0);
        }
    } else if (lastexp) {
        parse = list3(ST_COMP,parse,lastexp);
        lastexp = 0;
    }
}

/*
    In casading call of struct valued function, an argument for
    return position will be replaced by calling function.
 */

extern void
replace_return_struct(int func,int left) {
    int e = caddr(func);      /* arg lists */
    while(cadr(e)) e=cadr(e); /* find first arg */
    e = car(e);               /* return_struct arg */
    cadr(e) = left;
}


/* indirect right value , get the value of the variable */

static int
indirect(int t,int e1,int type)
{
    int e2,e3,e4,offset;
    e2 = e1;
    offset = 0;
    e3 = cadr(e2);
    if (car(e2)==ADD) {
        e4=caddr(e2);
        if (car(e4)==CONST) {
            offset=cadr(e4);
            e1=e3;
        }
    } else if (car(e2)==LADD) {
        e4=caddr(e2);
        if (car(e4)==CONST) { offset=cadr(e4); e1=e3; }
        else if (car(e4)==LCONST) { offset=lcadr(e4); e1=e3; }
    }
    return list4(t,e1,offset,type);
}

/*
    make right value from original left value.
    type will be changed.
 */
extern int
rvalue(int e)
{
    int op,c;
    NMTBL *n;    
    int type0 = type_value(type);
    int stype;

    if (e==0) error(-1);
    op = 0;
    switch(type0) {
    case INT:           
        break;
    case UNSIGNED:      op=US; type=set_type_with_attr(UNSIGNED,type); break;
    case VOID:          break;
    case CHAR:          op=COP;    type=set_type_with_attr(INT,type); break;
    case UCHAR:         op=COP+US; type=set_type_with_attr(UNSIGNED,type); break;
    case SHORT:         op=SOP;    type=set_type_with_attr(SHORT,type); break;
    case USHORT:        op=SOP+US; type=set_type_with_attr(UNSIGNED,type); break;
    case LONGLONG:      op=LOP; break;
    case ULONGLONG:     op=LOP+US; break;
    case FLOAT:         op=FOP; break;
    case DOUBLE:        op=DOP; break;
    case CODE:  return e;
    case 0:     error(-1); return e;
    default:
        if (integral(type0)) break;
        switch(car(type0)) {
        case ARRAY:
            type=set_type_with_attr(list2(POINTER,cadr(type)),type);
            if(car(e)==INDIRECT) return cadr(e);
            return list2(ADDRESS,e);
        case STRUCT: case UNION:
            if(car(e)==INDIRECT) return cadr(e);
            return e; 
        case FUNCTION:
            type=set_type_with_attr(cadr(type0),type);
            return e;
        case CODE:
            return e;
        case POINTER:
            if (lp64) op=LOP;
            break;
        case BIT_FIELD:
            if (car(e)==BIT_FIELD) {
                e =  list3(RBIT_FIELD,cadr(e),type);
            /*                         byte rvalue,   store type */
            } else {
                e =  list3(RBIT_FIELD,e,type);
            }
            type=set_type_with_attr(cadr(type0),type);/* value type */
            return e;
        default:
            error(TYERR);
        }
    }
    switch(OP(car(e))) {
    case GVAR:
        n = ncaddr(e);
        if (cadr(e)==0 && (c=attr_value(n,KONST))) {
            if (!has_attr(n,VOLATILE))
            return c;
        }
        return(list3n(RGVAR+op,cadr(e),ncaddr(e)));
    case LVAR:
        n = ncaddr(e);
        if (cadr(e)==0 && n && (c=attr_value(n,KONST))) {
            if (!has_attr(n,VOLATILE))
            return c;
        }
        return(list3n(RLVAR+op,cadr(e),ncaddr(e)));
    case INDIRECT:
        return(indirect(RINDIRECT+op,cadr(e),type0)); // cadr(e)?
    case IVAR: case ARRAY: case PERIOD: case ARROW:
        return(indirect(RINDIRECT+op,e,type0));   // RIVAR?
    case BIT_FIELD:
        return list3(RBIT_FIELD,cadr(e),caddr(e));
    case CAST:
        stype = type;
        type = cadddr(e);
        op = rvalue(cadr(e));
        e = list4(CAST,op,caddr(e),cadddr(e));  // should be RCAST?
        type = stype;
    default:return(e); /* idempotent case? */ }
}

/*
    right value with preserving type global variable
 */
extern int
rvalue_t(int e,int type0)
{
    int op,c;
    NMTBL *n;    

    if (e==0) error(-1);
    op = 0;
    switch(type0) {
    case INT:           
        break;
    case UNSIGNED:      op=US;  break;
    case VOID:          break;
    case CHAR:          op=COP;     break;
    case UCHAR:         op=COP+US;  break;
    case SHORT:         op=SOP;     break;
    case USHORT:        op=SOP+US;  break;
    case LONGLONG:      op=LOP; break;
    case ULONGLONG:     op=LOP+US; break;
    case FLOAT:         op=FOP; break;
    case DOUBLE:        op=DOP; break;
    case CODE:  return e;
    case 0:     error(-1); return e;
    default:
        if (type0>0) {
            if (car(type0)==POINTER) {
                if (lp64) op=LOP;
            } else error(-1);
        } else error(-1);
    }
    switch(OP(car(e))) {
    case GVAR:
        n = ncaddr(e);
        if (cadr(e)==0 && (c=attr_value(n,KONST))) {
            if (!has_attr(n,VOLATILE))
            return c;
        }
        return(list3n(RGVAR+op,cadr(e),ncaddr(e)));
    case LVAR:
        n = ncaddr(e);
        if (cadr(e)==0 && n && (c=attr_value(n,KONST))) {
            if (!has_attr(n,VOLATILE))
            return c;
        }
        return(list3n(RLVAR+op,cadr(e),ncaddr(e)));
    case INDIRECT:
        return(indirect(RINDIRECT+op,cadr(e),type0)); // cadr(e)?
    case IVAR: case ARRAY: case PERIOD: case ARROW:
        return(indirect(RINDIRECT+op,e,type0));   // RIVAR?
    case BIT_FIELD:
        return list3(RBIT_FIELD,cadr(e),caddr(e));
    case CAST: 
        op = rvalue_t(cadr(e),cadddr(e));
        e = list4(CAST,op,caddr(e),cadddr(e));  // should be RCAST?
    default:return(e); /* idempotent case? */
    }
}

/*
    left value check. Can we assign a value to it?
 */
extern void
lcheck(int e)
{
    int t;
    int type0 = type_value(type);
    if(scalar(type0)) return;
    switch(type0) {
    case DOUBLE: case FLOAT : case LONGLONG: case ULONGLONG:
        return;
    default:
        switch(car(e)) {
        case GVAR: case LVAR: case INDIRECT  :
        case REGISTER  : case DREGISTER  : case FREGISTER  : case LREGISTER:
        return;
        }
    }
    if ((t=car(type0))<0 && t!=STRUCT && t!=UNION)
        error(LVERR);
}

/*
    Indirect operator.
 */
extern int
indop(int e)
{
    int type0 = type_value(type);
    if(type0!=INT&&type0!=UNSIGNED&&type0!=LONGLONG&&type0!=ULONGLONG) {
        if(car(type0)==POINTER)
            type=set_type_with_attr(cadr(type),type);
        else if(car(type0)==CODE || car(type0)==FUNCTION) {
            // type=type;
        } else error(TYERR);
    } else
        type= set_type_with_attr(CHAR,type);  // ?!
    if(car(e)==ADDRESS)
        return(cadr(e));
    return(list2(INDIRECT,e));
}

/* struct field name search */

    /* type = list4(s,disp,fields,tag_nptr); */

extern int
search_struct_type(int type,char *name,int *dsp)
{
    int t;
    NMTBL *nptr0;
    t = caddr(type_value(type));
    if (t==0) {
        nptr0=ncadddr(type);
        if (!nptr0->ty) { error(TYERR); return 0; }
        t = caddr(type) = caddr(nptr0->ty);
    }
    for(;t;t = cadr(t)) {
        if (neqname(ncadddr(t)->nm,name)==0) {
            *dsp = caddr(t);
            return car(t);
        }
    }
    return 0;
}

/*
    Structure operation 
    a.b, a->b
 */

extern int
strop(int e,int ind)
{
    int dsp = 0;
    int type0;
    int e1 = 0;

    if (inmode || chk) {
        e1 = list4n(ind?ARROW:PERIOD,e,type,nptr);
    }
    if (ind) e = indop(rvalue(e));
    type0 = type_value(type);
    if (integral(type0)||(car(type0)!=STRUCT && car(type0)!=UNION)) {
        e=rvalue(e); type0 = type_value(type);
    }
    if (type<=0 || (car(type0)!=STRUCT && car(type0)!=UNION)) {
        error(TYERR); type=INT; return e; 
    }
    /* type = list4(s,disp,fields,tag_nptr); */
    /* print_fields(caddr(type),"strop"); */
    type = search_struct_type(type,nptr->nm,&dsp);
    if (!type) { error(UFLDERR); type=INT; return e; }
    if (inmode || chk) {
        // bitfield will be checked after parse
        return e1;
    } 
    ind = 0;
    if (car(e)==INDIRECT) {
        e = cadr(e);
        ind = 1;
    }
    if(dsp) {
        switch(OP(car(e))) {
        case GVAR: 
            // e=list2(INDIRECT,list3(ADD,e,list2(CONST,dsp)));
            e=list3n(car(e),cadr(e)+dsp,ncaddr(e));
            break;
        case LVAR: 
            e=list3n(car(e),cadr(e) + dsp,ncaddr(e));  /* may have attribute */
            break;
        case IVAR:
            if (lp64)
                e=list3(LADD,e,llist2(LCONST,dsp));
            else
                e=list3(ADD,e,list2(CONST,dsp));
            break;
        default:
            if (lp64)
                e=list3(LADD,e,llist2(LCONST,dsp));
            else
                e=list3(ADD,e,list2(CONST,dsp));
        }
    }
    if (ind && !parse_mode && !inmode) {
        e = list2(INDIRECT,e);
    }
    type0 = type_value(type);
    if (type>0&&car(type)==BIT_FIELD) {
        // n->ty = list4(BIT_FIELD,type,bit_offset, bit_size);
        e=list3(BIT_FIELD,e,type);  //  ???
    }
    return e;
}

/*

    Binary operator parse tree generation (and optimization)

   I don't know how to handle type attribute (const/volatie) in binop
 */

#if FLOAT_CODE
/* binary floating computation */

#define DTYPE(dop) (dop==DOP?DOUBLE:FLOAT)

static int
fdbinop(int op, int e1, int e2, int t1, int t2, int dop)
{
    double d1,d2,d;
    int b=0,t;

    if (dop==DOP) {
        type=t1; e1=double_value(e1);
        type=t2; e2=double_value(e2);
    } else {
        type=t1; e1=float_value(e1);
        type=t2; e2=float_value(e2);
    }
    if(car(e1)==dop+CONST&&car(e2)==dop+CONST) {
        d1=dcadr(e1);
        d2=dcadr(e2);
        switch(op) {
        case ADD: d=d1+d2; break;
        case SUB: d=d1-d2; break;
        case MUL: d=d1*d2;break;
        case DIV:
            if(!d2) error(EXERR);d=d1/d2;break;
        default:
            switch(op) {
                case GT: b=(d1>d2);break;
                case GE: b=(d1>=d2);break;
                case LT: b=(d1<d2);break;
                case LE: b=(d1<=d2);break;
                case EQ: b=(d1==d2);break;
                case NEQ: b=(d1!=d2);break;
                default: error(EXERR);
            }
            type = INT;
            return list2(CONST,b);
        }
        return dlist2(dop+CONST,d);
    }
    if(car(e1)==dop+CONST) {
        if ((op==SUB||op==ADD)&&dcadr(e1)==0.0) {
            return e2;
        } else if (op==MUL&&dcadr(e1)==1.0) {
            return e2;
        } else if (op==MUL&&-dcadr(e1)==1.0) {
            return list2(dop+MINUS,e2);
        }
    }
    if(car(e2)==dop+CONST) {
        if ((op==SUB||op==ADD)&&dcadr(e2)==0.0) {
            return e1;
        }
        if ((op==DIV||op==MUL)&&dcadr(e2)==1.0) {
            return e1;
        }
        if ((op==DIV||op==MUL)&&-dcadr(e2)==1.0) {
            return list2(DMINUS,e1);
        }
        if (op==SUB) {
            op=ADD; e2 = dlist2(dop+CONST,-dcadr(e2));
            // op=ADD; dcadr(e2) = -dcadr(e2);
        } else if(op==DIV) {
            if(dcadr(e2)==0.0) error(EXERR);
            op=MUL; e2 = dlist2(dop+CONST,1.0/dcadr(e2));
            // op=MUL; dcadr(e2)=1/dcadr(e2);
        }
    }
    if ((op==ADD||op==MUL) && (
            car(e1)==dop+CONST ||
            car(e2)==DRLVAR || car(e2)==DRGVAR ||
            car(e2)==FRLVAR || car(e2)==FRGVAR
        )) {
        return(list3(op+dop,e2,e1));
    }
    if(op==ADD||op==SUB||op==MUL||op==DIV) {
        return(list3(op+dop,e1,e2));
    }
    t = type;
    type=INT;
    if(op==LT) {
        return(list3(GT+dop,e2,e1));
    } else if(op==LE) {
        return(list3(GE+dop,e2,e1));
    } else if(op==GT||op==GE||op==EQ||op==NEQ) {
        return(list3(op+dop,e1,e2));
    } else {
        error(-1);
        return e1;
    }
}

static int
dbinop(int op, int e1, int e2, int t1, int t2)
{
    return fdbinop(op, e1, e2, t1, t2,DOP);
}

static int
fbinop(int op, int e1, int e2, int t1, int t2)
{
    return fdbinop(op, e1, e2, t1, t2,FOP);
}

#endif 

#if LONGLONG_CODE

static int
lintegral(int t)
{
    return (t==LONGLONG||t==ULONGLONG);
}

static int
lbinop(int op, int e1, int e2, int t1, int t2)
{
    int e=0;
    long long le1, le2;
    long long le = 0;
    int us = ((t1==ULONGLONG||t1==UNSIGNED)&&(t2==ULONGLONG||t2==UNSIGNED));

    if (us||(t1==ULONGLONG&&(op==LSHIFT||op==RSHIFT))) {
        type=t1; e1=ulonglong_value(e1);
        type=t2; e2=ulonglong_value(e2);
        t1=t2=ULONGLONG;
    } else {
        if(!(t1>0&&car(t1)==POINTER)) { type=t1; e1=longlong_value(e1); t1 = LONGLONG;}
        if(!(t2>0&&car(t2)==POINTER)) { type=t2; e2=longlong_value(e2); t2 = LONGLONG;}
    }
    if(car(e1)==LCONST&&car(e2)==LCONST) {
        le1=lcadr(e1);
        le2=lcadr(e2);
        switch(op) {
        case BOR:
            le=le1|le2;break;
        case EOR:
            le=le1^le2;break;
        case BAND:
            le=le1&le2;break;
        case ADD:
            if(lintegral(t1)) {
                if(lintegral(t2)) {
                        le=le1+le2;
                } else {
                        if(car(t2)!=POINTER) error(TYERR);
                        le=size(cadr(t2))*le1+le2;
                        type=t2;
                }
            } else {
                if(car(t1)!=POINTER) error(TYERR);
                le=le1+size(cadr(t1))*le2;
                type=t1;
            }
            break;
        case SUB:
            if(lintegral(t1)) {
                le=le1-le2; type=LONGLONG;
            } else {
                if(car(t1)!=POINTER) error(TYERR);
                if(lintegral(t2)) {
                    le=le1-size(cadr(t1))*le2;
                    type=t1;
                } else {
                    le=(le1-le2)/size(cadr(t1));
                    type=LONGLONG;
                }
            }
            break;
        case MUL:
            le=le1*le2;break;
        case DIV:
            if(!le2) error(EXERR);
            if (us) le=(((unsigned long long )le1)/((unsigned long long )le2)); 
            else e=(le1/le2);
        case MOD:
            if(!le2) error(EXERR);
            if (us) le=(((unsigned long long )le1)%((unsigned long long )le2)); 
            else e=(le1%le2);
        case LSHIFT:
            if (t1==ULONGLONG) le=(((unsigned long long)le1)<<le2); else le=le1<<le2;
            break;
        case RSHIFT:
            if (t1==ULONGLONG) le=(((unsigned long long)le1)>>le2); else le=le1>>le2;
            break;
        default:
            switch(op) {
            case EQ:
                e=(le1==le2);break;
            case NEQ:
                e=(le1!=le2);break;
            case LT:
                le=le1;le1=le2;le2=le;
            case GT:
                if (us) e=((unsigned long long)le1>(unsigned long long)le2);
                else e=(le1>le2);
                break;
            case LE:
                le=le1;le1=le2;le2=le;
            case GE:
                if (us) e=((unsigned long long)le1>=(unsigned long long)le2);
                else e=(le1>=le2);
                break;
            default:
                error(-1); return list2(CONST,0);
            }
            type = INT;
            return list2(CONST,e);
        }
        return llist2(LCONST,le);
    }
    if(op==SUB) { us = 0; type=LONGLONG; }
    if(op==SUB&&car(e2)==LCONST) { op=ADD; e2=llist2(LCONST,-lcadr(e2)); }
    if((op==ADD||op==MUL||op==BOR||op==EOR||op==BAND)&&
        (car(e1)!=LCONST) && (
            car(e2)==LRGVAR||car(e2)==LRLVAR||
            car(e2)==LURGVAR||car(e2)==LURLVAR
                )) {
        e=e1;e1=e2;e2=e;e=t1;t1=t2;t2=e;
    }
    if(op==ADD) {
        if(lintegral(t1)) {
            if(lintegral(t2)) {
                // if(t1==INT) type=t2;else type=t1;
                if (us) type=ULONGLONG; else type=LONGLONG;
                return(list3(LADD,e1,e2));
            }
            if(car(t2)!=POINTER) error(TYERR);
            e=lbinop(MUL,e1,llist2(LCONST,size(cadr(t2))),t1,LONGLONG);
            type=t2;
            return(lvalue_opt(list3(LADD,e2,e)));
        }
        if(car(t1)!=POINTER||!lintegral(t2)) error(TYERR);
        e=lbinop(MUL,e2,llist2(LCONST,size(cadr(t1))),t2,LONGLONG);
        type=t1;
        if (car(e)==LCONST && lcadr(e)==0)
            return(e1);
        return(llvalue_opt(list3(LADD,e1,e)));
    }
    if(op==SUB) {
        if(lintegral(t1)) {
            if(!lintegral(t2)) error(TYERR);
            if(t1==LONGLONG) type=t2;else type=t1;
            if (type==ULONGLONG) type=LONGLONG;
            return(list3(LSUB,e1,e2));
        }
        if(car(t1)!=POINTER) error(TYERR);
        if(lintegral(t2)) {
            e=binop(MUL,e2,llist2(LCONST,size(cadr(t1))),t2,LONGLONG);
            type=t1;
            if (car(e)==LCONST) error(-1);
            return(list3(LSUB,e1,e));
        }
        if(car(t2)!=POINTER)
            error(TYERR);
        compatible(t1,t2);
        e=list3(LSUB,e1,e2);
        e=lbinop(DIV,e,llist2(LCONST,size(cadr(t1))),LONGLONG,LONGLONG);
        type= LONGLONG;
        return e;
    }
    if((op==MUL||op==DIV)&&car(e2)==LCONST&&lcadr(e2)==1) return e1;
    if(op==BOR||op==EOR||op==BAND||op==ADD||op==SUB) {
        return(list3(op+LOP,e1,e2));
    }
    if(op==LSHIFT && car(e2)==LCONST) {
        if (lcadr(e2)==0) return e1;
        else if (lcadr(e2)>63) return llist2(LCONST,0);
    }
    if(op==RSHIFT && car(e2)==LCONST) {
        if (lcadr(e2)==0) return e1;
    }
    if(op==LSHIFT||op==RSHIFT) {
        return(list3(op+LOP+(t1==ULONGLONG),e1,e2));
    }
    if (op==DIV||op==MUL||op==ADD||op==SUB||op==MOD) {
        return(list3(op+LOP,e1,e2));
    }

    type = INT;
    if(op==LT) {
        return(list3(GT+LOP+us,e2,e1));
    } else if(op==LE) {
        return(list3(GE+LOP+us,e2,e1));
    } else if(op==EQ||op==NEQ) {   // EQ/NEQ has no unsign
        return(list3(op+LOP,e1,e2));
    } else if(op==GT||op==GE||op==LT||op==LE) {
        return(list3(op+LOP+us,e1,e2));
    } else
        error(-1);
    return 0; /* not reached */
}
#endif

/* binary integer computation */

extern int
binop0(int op, int e1, int e2, int t1, int t2)
{
    int e=0;
    int us = 0;

    // for inmode, destructive modification e1,e2,t1,t2 is not allowed

    if(t1>0&&car(t1)==POINTER) { 
        if (lp64) return lbinop(op,e1,e2,t1,t2);
        if(!(op==SUB && t2>0&&car(t2)==POINTER))  {
            type = t2; e2= int_value(e2); t2=INT; 
        }
    } else if(t2>0&&car(t2)==POINTER) { 
        if (lp64) return lbinop(op,e1,e2,t1,t2);
        type = t1; e1= int_value(e1); t1=INT; 
    }
#if FLOAT_CODE
    else if(t1==DOUBLE||t2==DOUBLE)
        return dbinop(op,e1,e2,t1,t2);
    else if(t1==FLOAT||t2==FLOAT)
        return fbinop(op,e1,e2,t1,t2);
#endif
#if LONGLONG_CODE
    else if(t1==LONGLONG||t2==LONGLONG||t1==ULONGLONG||t2==ULONGLONG)
        return lbinop(op,e1,e2,t1,t2);
#endif
    if (t1==UNSIGNED) {
        if (t2==UNSIGNED || (car(e2)==CONST && cadr(e2)>0)) us = 1;
    }
    if (t2==UNSIGNED) {
        if (t1==UNSIGNED || (car(e1)==CONST && cadr(e1)>0)) us = 1;
    }

    if(car(e1)==CONST&&car(e2)==CONST) {
        e1=cadr(e1);
        e2=cadr(e2);
        type= INT;
        switch(op) {
        case BOR:
            e=e1|e2;break;
        case EOR:
            e=e1^e2;break;
        case BAND:
            e=e1&e2;break;
        case ADD:
            if(integral(t1)) {
                if(integral(t2)) {
                        e=e1+e2;
                } else {
                        if(car(t2)!=POINTER) error(TYERR);
                        e=size(cadr(t2))*e1+e2;
                        type=t2;
                }
            } else {
                if(car(t1)!=POINTER) error(TYERR);
                e=e1+size(cadr(t1))*e2;
                type=t1;
            }
            break;
        case SUB:
            if(integral(t1)) {
                e=e1-e2; type=INT;
            } else {
                if(car(t1)!=POINTER) error(TYERR);
                if(integral(t2)) {
                    e=e1-size(cadr(t1))*e2;
                    type=t1;
                } else {
                    e=(e1-e2)/size(cadr(t1));
                    type=INT;
                }
            }
            break;
        case MUL:
            e=e1*e2;break;
        case DIV:
            if(!e2) error(EXERR);
            if (us) e=(((unsigned)e1)/((unsigned)e2)); else e=e1/e2;
            break;
        case MOD:
            if(!e2) error(EXERR);
            if (us) e=(((unsigned)e1)%((unsigned)e2)); else e=e1%e2;
            break;
        case RSHIFT:
            if (t1==UNSIGNED) e=(((unsigned)e1)>>((unsigned)e2)); else e=e1>>e2;
            break;
        case LSHIFT:
            if (t1==UNSIGNED) e=(((unsigned)e1)<<((unsigned)e2)); else e=e1<<e2;
            break;
        case EQ:
            e=(e1==e2);break;
        case NEQ:
            e=(e1!=e2);break;
        case LT:
            e=e1;e1=e2;e2=e;
        case GT:
            if (us) e=(((unsigned)e1)>((unsigned)e2)); else e=(e1>e2);
            break;
        case LE:
            e=e1;e1=e2;e2=e;
        case GE:
            if (us) e=(((unsigned)e1)>=((unsigned)e2)); else e=(e1>=e2);
            break;
        default: error(-1); return list2(CONST,0);
        }
        return list2(CONST,e);
    }
    if(op==GT||op==GE||op==LT||op==LE) {
        return(car(e1)==CONST?list3(rop_dual(op)+us,e2,e1):list3(op+us,e1,e2));
    } else if(op==EQ||op==NEQ) {
        return(car(e1)==CONST?list3(op,e2,e1):list3(op,e1,e2));
    }
    if(op==SUB&&car(e2)==CONST) { op=ADD; e2=list2(CONST,-cadr(e2)); }
    if((op==ADD||op==MUL||op==BOR||op==EOR||op==BAND)&& (car(e1)!=CONST)) {
        switch(car(e2)) {
            case RGVAR: case RLVAR:
            case URGVAR: case URLVAR:
            case SRGVAR: case SRLVAR:
            case SURGVAR: case SURLVAR:
            case CRGVAR: case CRLVAR:
            case CURGVAR: case CURLVAR:
            e=e1;e1=e2;e2=e;e=t1;t1=t2;t2=e;
        }
    }
    if(op==ADD) {
        if(integral(t1)) {
            if(integral(t2)) {
                // if(t1==INT) type=t2;else type=t1;
                if (us) type=UNSIGNED; else type=INT;
                return(list3(ADD,e1,e2));
            }
            if(car(t2)!=POINTER) error(TYERR);
            e=binop0(MUL,e1,list2(CONST,size(cadr(t2))),t1,INT);
            type=t2;
            return lvalue_opt(list3(ADD,e2,e));
        }
        if(car(t1)!=POINTER||!integral(t2)) error(TYERR);
        e=binop0(MUL,e2,list2(CONST,size(cadr(t1))),t2,INT);
        type=t1;
        if (car(e)==CONST && cadr(e)==0)
            return(e1);
        return(lvalue_opt(list3(ADD,e1,e)));
    }
    if(op==SUB) {
        if(integral(t1)) {
            if(!integral(t2)) error(TYERR);
            if(t1==INT) type=t2;else type=t1;
            if (type==UNSIGNED) type=INT;
            return(list3(SUB,e1,e2));
        }
        if(car(t1)!=POINTER) error(TYERR);
        if(integral(t2)) {
            e=binop0(MUL,e2,list2(CONST,size(cadr(t1))),t2,INT);
            type=t1;
            if (car(e)==CONST) error(-1);
            return(list3(SUB,e1,e));
        }
        if(car(t2)!=POINTER)
            error(TYERR);
        compatible(t1,t2);
        e=list3(SUB,e1,e2);
        e=binop0(DIV,e,list2(CONST,size(cadr(t1))),INT,INT);
        type= INT;
        return e;
    }
    if(!integral(t1)||!integral(t2)) error(TYERR);
    // if(t1==INT) type=t2; else type=t1;  /* ??? */
    if (us) type=UNSIGNED; else type=INT;
    if((op==MUL||op==DIV)&&car(e2)==CONST&&cadr(e2)==1) return e1;
    if(op==BOR||op==EOR||op==BAND) return(list3(op,e1,e2));
    if(op==LSHIFT||op==RSHIFT) return(list3(op+(t1==UNSIGNED?US:0),e1,e2));
    // which ops remain?
    return(list3(op+us,e1,e2));
}

extern int
binop(int op, int e1, int e2, int t1, int t2)
{
    int e = binop0(op,e1,e2,t1,t2);   // we have to execute this to fix type
    if (inmode) return  list3(ST_OP,op,list4(e1,e2,t1,t2));
    return e;
}

/*
       arugment type of binary operator
 */
extern int
type_of_bop(int op)
{
    int us;
    if (op>0) {
        switch(OP(op)) {
            case UMUL: case UDIV: case UMOD:
            case URSHIFT: case ULSHIFT:
            case ULT: case UCMP: case UCMPGE: case UGE: case UGT: case ULE:
                us = 1; break;
            case MUL: case DIV: case MOD: case ADD: case SUB: case CMP:
            case RSHIFT: case LSHIFT:
            case GT: case GE: case LT: case LE: case EQ: case NEQ:
            case BAND: case EOR: case BOR:
            case CMPGE: case CMPEQ: case CMPNEQ:
                us = 0; break;
            default:
                return 0;
        }
        switch(OP_TAG(op) + us) {
        case SOP:    return SHORT;
        case SOP+US: return USHORT;
        case COP:    return CHAR;
        case COP+US: return UCHAR;
        case DOP:    return DOUBLE;
        case FOP:    return FLOAT;
        case LOP:    return LONGLONG;
        case LOP+US: return ULONGLONG;
        case US:     return UNSIGNED;
        case 0:      return INT;
        }
    }
    return 0;
}

/*
    type of result of conversion operator
 */
extern int
type_of_conv(int op)
{
    switch(op) {
        case  LL2D: case  ULL2D: case F2D: case I2D: case U2D: 
            return DOUBLE;
        case  LL2F: case  ULL2F: case D2F: case I2F: case U2F: 
            return FLOAT;
        case  LL2I: case  ULL2I: case D2I: case F2I: 
        case I2C: case I2S: 
            return INT;
        case  D2LL: case  F2LL: case  I2LL: case  U2LL: 
            return LONGLONG;
        case  D2ULL: case  F2ULL: case  I2ULL: case  U2ULL: 
            return ULONGLONG;
        case  LL2U: case  ULL2U: case D2U: case F2U: 
        case U2UC: case U2US: 
            return UNSIGNED;
    }
    return 0;
}

extern int
skip_cast(int e)
{
    int t,t1;
    if (car(e)==CAST) {
        t  = caddr(e);
        t1 = cadddr(e);
        if ( type_compatible(t, t1) ) {
            return cadr(e);
        }
    } 
    return e;
}

/* coarse for function/code segments arguments */

extern int
correct_type(int e,int t0)
{
    int t = type_value(t0),t1;
    // e = rvalue(e); 
#if BIT_FIELD_CODE
    // if (type>0 && car(type)==BIT_FIELD) e = rvalue(e);
#endif
    if (t==DOTS) {
        if (type==FLOAT) t=DOUBLE; 
        else if (type==CHAR) t=INT;
        else if (type==UCHAR) t=UNSIGNED;
        else if (type==SHORT) t=INT;
        else if (type==USHORT) t=UNSIGNED;
    }
    // is this correct?
    if ((t1=type_value(type))>0 && 
            car(type_value(type))==ARRAY && car(e)==GVAR) {
        if (!chk)
            e=list2(ADDRESS,e);
    }
    if (t>0) {
        switch(car(t)) {
        case POINTER:
            if (cadr(t)>0) {
                switch(car(cadr(t))) {
                case FUNCTION: 
                // type でチェックするべきだよね? 本来...
                // compatible(cadr(t),cadr(type));
                // ではあかんの?
                    if (car(e)==FNAME) {
                        NMTBL *n = ncaddr(e);
                        int targ0 = caddr(cadr(t));
                        int targ1 = caddr(n->ty);
                        if (is_function(n)) {
                            // return type
                            compatible(cadr(cadr(t)),cadr(n->ty));
                        }
                        // arguments
                        for (;targ0;targ0=cadr(targ0),targ1=cadr(targ1)) {
                            if (car(targ0)==DOTS) break;
                            compatible(car(targ0),car(targ1));
                        }
                    }
                    break;
                default:
                    if (!(t1>0&&car(t1)==ARRAY) && !scalar(t1)) error(TYERR);
                }
            } else {
                if (!(t1>0&&car(t1)==ARRAY) && !scalar(t1)) error(TYERR);
            }
            break;
        case STRUCT: case UNION:
            if (scalar(t1)) error(TYERR);
            else if(size(t)!=size(type)) error(TYERR);
            break;
        }
    } else {
        switch(t) {
        case DOTS: return e;
        case UNSIGNED:  e = unsigned_value(e);  t = UNSIGNED; break;
        case CHAR:      e = char_value(e); t = INT; break;
        case UCHAR:     e = uchar_value(e); t = UNSIGNED; break;
        case SHORT:     e = short_value(e); t = INT; break;
        case USHORT:    e = ushort_value(e); t = UNSIGNED; break;
#if FLOAT_CODE
        case FLOAT:     e = float_value(e); break;
        case DOUBLE:    e = double_value(e); break;
#endif
#if LONGLONG_CODE
        case LONGLONG:  e = longlong_value(e); break;
        case ULONGLONG: e = ulonglong_value(e); break;
#endif
        default:        
            if (integral(t)) e = int_value(e);
        }
    }
    type = set_type_with_attr(t,t0);
    return e;
}

/*
    Integer Constant expression is required
 */

extern int
cexpr(int e)
{
    if (car(e) == CONV) {
        switch(caddr(e)) {
        case I2C: case I2S: case U2UC: case U2US:
            e=cadr(e); break;
        default: error(-1); // illeagal int constant
        }
    }
    if (car(e) != CONST) error(CNERR);
    return (cadr(e));
}

#define is_long_type(type)  (type==LONGLONG||type==ULONGLONG)

#if BIT_FIELD_CODE

/* 
    bitfield   struct { char a:1; unsigned int b:10; }
    System dependent bit alignment is defined by code_bit_field_disp.
       type of bitfield represents type of the value
       these values are stored in a stored type which can be different from
       value type.
 */

static int
bit_field(int e1,int t)
{
    int reg;
if (car(e1)==BIT_FIELD) {
//    if (lsrc)printf("## bit_field_bug\n");
    e1 = cadr(e1);
}
    g_expr(e1);
    emit_push();
    code_bit_field(t, reg = emit_pop(0), USE_CREG);
    emit_pop_free(reg);
    return cadr(t); /* value type */
}

static int
bit_field_repl(int e1,int e2,int t)
{
    /* e1 = e2 */
    if ((car(e2)==CONST||car(e2)==LCONST)) {
        g_expr(e1);
        code_bit_replace_const(e2,USE_CREG,t);
        return t;
    }
    g_expr(e1);
    emit_push();
    g_expr(e2);
    code_bit_replace(e2=emit_pop(0),USE_CREG,t);
    emit_pop_free(e2);
    return t;
}

static int
bassign(int e2,int e3,int t)
{
    int type  = cadr(t);
    /*  e2 = e3 */
    if (car(e2)==BIT_FIELD) {
        e2 = cadr(e2);
    }
    bit_field_repl(e2,e3,t);
    return type;
}

static int
bassop(int e2,int e3,int op,int t,int post)
{
  /*
        n = bit_field address
        code_bit_field
        if (post) n1 = value
        value op= operand
        n bit-repl value
        if (post) n1;
   */
    /*  e2 = e2 op e3; */
    /*  new = &e2 */
    /*  *new = *new op e3 */
    int suse = use;
    int lo = (type==LONGLONG||type==ULONGLONG);
    int n1=0,n2=0;
    int reg;

    g_expr(list2(ADDRESS,cadr(e2)));
    reg = emit_push();
    code_bit_field(t, reg, USE_CREG);
    use=1;
    if (lo) {
#if LONGLONG_CODE
        if (post) {
            n1 = list3n(LVAR,new_lvar(size_of_longlong),0);
            code_lassign_lvar(cadr(n1),USE_CREG);
        }
        if (!code_lassop_p) {
            n2 = list3n(LVAR,new_lvar(size_of_longlong),0);
            code_lassign_lvar(cadr(n2),USE_CREG);
            lassign(list4(LASSOP,n2,e3,op+LOP));
        } else {
            emit_lpush();
            g_expr(e3);
            code_register_lassop(USE_CREG,op+LOP);
        }
#else
        error(TYERR);
#endif
    } else {
        if (post) {
            n1 = list3n(LVAR,new_lvar(size_of_int),0);
            code_assign_lvar(cadr(n1),USE_CREG,size_of_int);
        }
        emit_push();
        g_expr(e3);
        code_register_assop((e2=emit_pop(0)),USE_CREG,op,size(type));
        if (use) {
            code_register(e2,USE_CREG);
        }
        emit_pop_free(e2);
    }
    use=post?0:suse;
    code_bit_replace(e2=emit_pop(0),USE_CREG,t);
    emit_pop_free(e2);
    use = suse;
    if (post&&use) { g_expr(rvalue_t(n1,type));} 
    if (n1) free_lvar(cadr(n1));
    if (n2) free_lvar(cadr(n2));
    
    return type;
}

#endif

/* temporal local variable free list */

static int lvar_list,lvar_free_list;

extern int
new_lvar0(int sz, int align)
{
    disp-=sz;
    if (align) {
        disp &= ~(align-1);
    } else if (sz>=4 && (disp & (4-1))) { // alignment 4
        disp &= ~(4-1);
    }
    return disp;
}

/*
    Allocate new local variable in flat scope
 */


extern int
new_lvar_align(int size,int align)
{
    int lvar,plvar;

    /* Can we reuse previously freed local variable? */ 
    for (plvar = 0,lvar = lvar_free_list;lvar;lvar = cadr(lvar)) {
        if (caddr(lvar)==size && (~align|| car(lvar)%align==0)) {
            if (plvar) cadr(plvar) = cadr(lvar);
            else lvar_free_list = cadr(lvar);
            break;
        }
        plvar = lvar;
    }
    if (!lvar) {
        lvar_list = glist3((lvar=new_lvar0(size,align)),lvar_list,size);
    } else {
        cadr(lvar) = lvar_list; lvar_list = lvar;
        lvar = car(lvar_list);
    }
    return lvar;
}

extern int
new_lvar(int size) {  // system dependent?
    return new_lvar_align(size,0);
}

/*
    Free the allocated local variable.  It may be reused again.
 */

extern void
free_register_var(int reg_arg_list)
{
    int arg;
    for(;reg_arg_list;reg_arg_list=cadr(reg_arg_list)) {
        arg = car(reg_arg_list);
        if (car(arg)==REGISTER||car(arg)==DREGISTER||car(arg)==FREGISTER
                ||car(arg)==LREGISTER)  {
            free_register(cadr(arg));
        } else if (car(arg)==LVAR&&cadr(arg)<0) free_lvar(cadr(arg));
    }
}


extern void
free_lvar(int disp)
{
    int lvar,plvar;

    for (plvar = 0,lvar = lvar_list;lvar;lvar = cadr(lvar)) {
        if (car(lvar)==disp) {
            if (plvar) cadr(plvar) = cadr(lvar);
            else lvar_list = cadr(lvar);
            break;
        }
        plvar = lvar;
    }
    if (!lvar) error(-1);
    cadr(lvar) = lvar_free_list; lvar_free_list = lvar;
}

extern void
init_free_lvar_list()
{
    int lvar;
    while((lvar=lvar_list)) {
        lvar_list=cadr(lvar_list);
        free_glist3(lvar);
    }
    while((lvar=lvar_free_list)) {
        lvar_free_list=cadr(lvar_free_list);
        free_glist3(lvar); 
    }
}

extern void
gen_comment(char *s)
{
    if (!chk)
        code_comment(s);
}

extern void
gen_code_enter(char *name)
{
    code_enter(name);
}

extern void
gen_code_enter1(int args)
{
    code_enter1(args);
}

extern void
gen_code_leave(char *name)
{
    code_leave(name);
}

extern void
gen_enter(char *name)
{
    enter(name);
}

extern void
gen_enter1()
{
    enter1();
}

extern void
gen_leave(int control, char *name)
{
    leave(control,name);
}

extern void
gen_jmp(int l)
{
    control=0;
    if (!pending_jmp) {
        pending_jmp = l;
    }
}

extern void
gen_indirect_goto(int e1)
{
    g_expr(e1);
    code_indirect_jmp(USE_CREG);
}

/*
    make bit mask
      MSB 1 2 3 4 .... 29 30 31 LSB
 */
extern unsigned 
make_mask(int from,int to)
{
    unsigned mask = 0;
    unsigned bit = 1;
    int i;
    if (from<0||from>31) error(-1);
    for (i=31;from<=i;i--,bit<<=1) {
        if (i<=to) {
            mask |= bit;
        }
    }
    return mask;
}

extern unsigned long long
make_mask_64(int from,int to)
{
    unsigned long long mask = 0;
    unsigned long long bit = 1;
    int i;
    if (from<0||from>63) error(-1);
    for (i=63;from<=i;i--,bit<<=1) {
        if (i<=to) {
            mask |= bit;
        }
    }
    return mask;
}

#define MAX_PTR_CACHE 10

static int ptr_cache=0;
static int ptr_cache_last=0;

/* 
    global name pointer cache
        global pointer needs dynamic loading or table.
        it may used again, put it to a register as a cache.
 */

extern void
init_ptr_cache()
{
    int i;
    for(i=0;i<MAX_PTR_CACHE-1;i++) {
        ptr_cache=glist3n(0,ptr_cache,0);
    }
    ptr_cache_last=ptr_cache;
}

extern void
clear_ptr_cache_reg(int r)
{
    int ptcptr=ptr_cache;
    int prev = 0;
    while(ptcptr!=ptr_cache_last) {
        if(ncaddr(ptcptr)&&car(ptcptr)==r) {
            free_register(r); car(ptcptr)=-1; ncaddr(ptcptr)=0;
            // remove me
            if (prev) cadr(prev) = cadr(ptcptr);
            else ptr_cache = cadr(ptcptr);
            // add me to the next of ptr_cache_last
            cadr(ptcptr) = cadr(ptr_cache_last);
            cadr(ptr_cache_last) = ptcptr;
            return;
        }
        ptcptr=cadr(prev=ptcptr);
    }
}

extern int
last_ptr_cache()
{
    int ptcptr=ptr_cache;
    int r = 0;
    while(ptcptr!=ptr_cache_last) {
        r = car(ptcptr);
        ptcptr=cadr(ptcptr);
    }
    return r;
}


extern void
clear_ptr_cache()
{
    int ptcptr=ptr_cache;
    while(ptcptr!=ptr_cache_last) {
        free_register(car(ptcptr)); car(ptcptr)=-1; ncaddr(ptcptr)=0;
        ptcptr=cadr(ptcptr);
    }
    ptr_cache_last = ptr_cache;
}


extern int
get_ptr_cache(NMTBL *nptr)
{
    int r;
    int ptcptr=ptr_cache;
    NMTBL *g = nptr;
    int prev=0,p;

    // linear search cache 
    while(ptcptr!=ptr_cache_last) {
        if(ncaddr(ptcptr)==g) {
            if (prev) {
                // make this top
                cadr(prev)=cadr(ptcptr);
                cadr(ptcptr) = ptr_cache;
                ptr_cache = ptcptr;
            }
            return car(ptcptr);
        }
        ptcptr=cadr(prev=ptcptr);
    }
    if (!cadr(ptr_cache_last)) {
        // cache is full
        if (prev) {
            // remove oldest cache and it becomes the last
            free_register(car(prev)); car(ptcptr)=-1; ncaddr(ptcptr)=0;
            ptr_cache_last = prev;
        }
        else error(-1);
    }
    r = get_register(0); // some ptr cache may remove by this
    car(p = cadr(ptr_cache_last)) = r;
    ncaddr(p) = g;
    use_ptr_cache(r);

    cadr(ptr_cache_last) = cadr(p);
    cadr(p) = ptr_cache;
    ptr_cache = p;
    code_ptr_cache_def(r,nptr);
    return r;
}

extern int
ilog(int i)
{
    /* number of bit (i-1) is better? */
    switch(i) {
    case 2: return 1;
    case 4: return 2;
    case 8: return 3;
    case 16: return 4;
    case 32: return 5;
    case 64: return 6;
    case 128: return 7;
    case 256: return 8;
    case 512: return 9;
    case 1024: return 10;
    case 2048: return 11;
    case 4096: return 12;
    case 8192: return 13;
    case 16384: return 14;
    case 32768: return 15;
    case 65536: return 16;
    case 131072: return 17;
    case 262144: return 18;
    case 524288: return 19;
    }
    return 0;
}

/* end */