module dmd.backend.Util;

import dmd.Array;
import dmd.Loc;

import dmd.backend.elem;
import dmd.backend.Symbol;
import dmd.backend.TYPE;
import dmd.backend.SC;
import dmd.backend.dt_t;
import dmd.backend.LIST;
import dmd.backend.block;
import dmd.backend.targ_types;
import dmd.backend.SYMIDX;
import dmd.backend.PARAM;
import dmd.backend.Blockx;
import dmd.backend.struct_t;
import dmd.backend.BC;
import dmd.backend.code;

import std.string;

alias ubyte mangle_t;

alias SC enum_SC;
alias uint SYMFLGS;

version (MARS) {
	enum SYM_PREDEF_SZ = 35;
} else {
	enum SYM_PREDEF_SZ = 22;
}

//extern (C++) extern {
	elem* eictor;
	Symbol* ictorlocalgot;
	elem* ector;
	Array ectorgates;
	elem* edtor;
	elem* etest;
	int dtorcount;
	Symbol* localgot;
//}

static this()
{
	ectorgates = new Array();
}

alias uint tym_t;		// data type big enough for type masks
alias elem* elem_p;		// data type big enough for type masks

void el_setLoc(elem* e, Loc loc) {
	e.Esrcpos.Sfilename = cast(char*)toStringz(loc.filename);
	e.Esrcpos.Slinnum = loc.linnum;
}

void elem_setLoc(elem* e, Loc loc) {
	return el_setLoc(e, loc);
}

struct_t* struct_calloc() {
	return cast(struct_t *) mem_fcalloc(struct_t.sizeof);
}
///#define struct_free(st)	((void)(st))

extern (C++) {
	void* mem_fcalloc(uint numbytes);
	void obj_initfile(const(char)* filename, const(char)* csegname, const(char)* modname);
	Symbol* symbol_calloc(const(char)* id);
	type* type_fake(tym_t);
	dt_t** dtnzeros(dt_t** pdtend, targ_size_t size);
	void outdata(Symbol* s);
	int reftoident(int seg, targ_size_t offset, Symbol* s, targ_size_t val, int flags);
	dt_t ** dtnbytes(dt_t** pdtend, targ_size_t size, const(char)* ptr);
	type* type_alloc(tym_t ty);
	elem_p el_params(elem_p, ...);
	elem_p el_ptr(Symbol*);
	elem_p el_long(tym_t, targ_long);
	elem_p el_bin(uint, tym_t, elem_p, elem_p);
	elem_p el_var(Symbol*);
	elem_p el_combine(elem_p, elem_p);
	block* block_calloc();
	void writefunc(Symbol* sfunc);
	void obj_termfile();
	int objextdef(const(char)* name);
	void obj_includelib(const(char)* name);
	SYMIDX symbol_add(Symbol* s);
	elem* el_param(elem* e1, elem* e2);
	elem* el_una(uint op, tym_t ty, elem* e1);
	Symbol* symbol_name(const(char)* name, int sclass, type* t);
	type* type_setcv(type** pt, tym_t cv);
	int type_jparam(type* t);
	void obj_export(Symbol* s, uint argsize);
	void obj_startaddress(Symbol* s);
	void symbol_func(Symbol* s);
	type* type_allocn(tym_t, type* tn);
	param_t* param_append_type(param_t** pp, type* t);
	void block_appendexp(block* b, elem* e);
	void block_next(Blockx* bctx, BC bc, block* bn);
	dt_t** dtxoff(dt_t** pdtend, Symbol* s,targ_size_t offset, tym_t ty);
	dt_t** dtdword(dt_t** pdtend, int value);
	dt_t** dtabytes(dt_t** pdtend, tym_t ty, targ_size_t offset, targ_size_t size, const(char)* ptr);
	void obj_moduleinfo(Symbol* scc);
	Symbol* symbol_genauto(TYPE* t);
	elem* el_same(elem**);
	void el_free(elem*);
	Symbol* symbol_generate(int sclass, type* t);
	elem* el_calloc();
	void dt_optimize(dt_t* dt);
	type* type_setty(type**, int);
	type* type_setmangle(type** pt, mangle_t mangle);
	list_t list_append(list_t* plist, void* ptr);
	dt_t** dtcat(dt_t** pdtend, dt_t* dt);
	elem_p el_copytree(elem_p);
	elem_p el_pair(tym_t, elem_p, elem_p);
	int el_allbits(elem *e, int bit);
	block* block_goto(Blockx* bctx, BC bc, block* bn);
	block* block_calloc(Blockx* blx);
	targ_size_t type_paramsize_i(type* t);
	int os_critsecsize();
	void el_setVolatile(elem* e);
	elem* exp2_copytotemp(elem* e);
	elem* el_const(tym_t, eve*);
	elem *el_params(void** args, int length);
	
	void cod3_thunk(Symbol* sthunk, Symbol* sfunc, uint p, tym_t thisty, targ_size_t d, int i, targ_size_t d2);
	
	version (SEH) {
		void nteh_declarvars(Blockx* bx);
		elem* nteh_setScopeTableIndex(Blockx* blx, int scope_index);
	}
}