// Auto-generated file, do not edit!

#ifndef PROTOS_H_
#define PROTOS_H_

enum OptionModes;
enum e_am;
enum e_bt;
enum e_node;
enum e_op;
enum e_sc;
enum e_sym;
struct _regsimg;
struct _stackimg;
struct amode;
struct bcd;
struct blk;
struct cse;
struct enode;
struct hstab;
struct ocode;
struct snode;
struct stab;
struct sym;
struct typ;

struct typ *shiftop(struct enode **node);
void local_clean(void);	/* remove local symbols from alsyms -- to be called just before rel_local */
void g_label(unsigned int labno);
struct snode *casestmt(void);
void compile(void);
void dump_endnode();
int blk_free(struct blk *bp1);
int complexity(struct enode *ep);
void check_table(struct hstab *table);
struct typ *nameref(struct enode **node);
int en_dir_cost(struct enode *ep);
void extscan(unsigned char *ext);
void genstorage(struct sym *sp, int align);
void freeregs(struct _regsimg *img);	/* used by g_fcall */
struct amode *mk_immed(long i);
char *litlate(char *s);
struct snode *forstmt(void);
struct amode *g_xmul(struct enode *node, int flags, enum(e_op) op);
struct enode *mk_icon(long i);
void getsym();
struct typ *equalops(struct enode **node);
void genfunc(struct snode *stmt);
struct typ *copy_type(struct typ *s);
void repcse(struct snode *block);
int internal(char *s);
void genbyte(int val);
struct typ *bitor(struct enode **node);
void fill(int n);
void scan(struct snode *block);
struct snode *retstmt(void);
void out_init();
void _scr_main();
void add_code(enum(e_op) op, int len, struct amode *ap1, struct amode *ap2, int line);
char *create_ti_file(int calc,int tigl_type,char *name,char *folder,char *content,unsigned long content_size,unsigned long *ti_file_size);
long intexpr();
int bitwise_reduction(unsigned long x,int *size);
void double2bcd(double d,struct bcd *bcd);
struct amode *g_aslogic(struct enode *node, int flags, enum(e_op) op);
long auto_init(long offs,struct typ *typ,struct typ **tpp,int brace_level,int offmod,int stroff);
void initstack();
void falsejp(struct enode *node, unsigned int lab);
int getch();
int doif(int x,int c);
void temp_inv(void);
long inittype(struct typ *tp,struct typ **tpp);
void do_warning(char *s, ...);
struct typ *forcefit(struct enode **node1, struct typ *tp1, struct enode **node2, struct typ *tp2);
void collect(int g);
int movem(short x);
void g_code(enum(e_op) op, int len, struct amode *ap1, struct amode *ap2);
struct enode *parmlist(struct sym *f);
int isbyte(struct enode *node);
void clean_up();
void getrawid();
struct typ *deref(struct enode **node, struct typ *tp);
long strip_icon(long i, enum(e_bt) type);
void genword(int val);
int getid(int c);
void d_snode(struct snode **node);
struct snode *exprstmt(void);
struct typ *relation(struct enode **node);
int integral(struct typ *tp);
void g_bitmancode(enum(e_op) op,int size,struct amode *ap1,struct amode *ap2);
struct amode *g_offset(struct amode *ap, int off);
struct amode *as_fcall(struct enode *node, int flags, char *libname);
struct snode *contstmt(void);
int vcg_init();
long push_param(struct enode *ep);
int label(char *s);
struct amode *get_asmparam();
struct amode *g_fderef(struct enode *node, struct amode *ap0, int flags);
int req_all_aregs(struct enode *plist,int rp_dn,int rp_an);
void genstmt(struct snode *stmt);
int vcg_cost();
void useregs(struct _regsimg *img);	/* used by g_fcall */
char *strend(char *s);
TI_SHORT process_attr();
void dump_genfunc(struct snode *stmt);
void getidstr();
int stringlit(char *s, int len);
void ds_free(void);
void scope_init(void);
void verbose_print_include(char *filename);
void tmp_use();
struct sym *symremove(char *na, struct hstab *tab);
struct sym *search(char *na, int crc, struct hstab *tab);
void add_label(int lab);
void dump_startline();
struct typ *cond_deref(struct enode **node, struct typ *tp);
struct amode *temp_addr(void);
struct amode *g_cast2(struct enode *ep, enum(e_bt) typ2, int flags);
void get_offset(struct amode *ap);
void scanexpr(struct enode *node, int duse);
void progr_initforcurfile();
void move_pos(long diff);	/* caution : only works in overwrite mode */
void dump_newnode(char *name);
void fatal(char *message);
int arsearch(int r,struct ocode *ip);
void usestack(struct _stackimg *img);	/* used by g_expr::en_compound */
struct typ *bitand(struct enode **node);
FILE *xfopen(char *f,char *m,int sys);
int tst_const(struct enode *node);
long mod_mask(long i);
struct amode *mk_strlab(char *s);
void concat(struct stab *dest,struct stab *src);
struct amode *temp_data(void);
void rel_dualstack(void);
int pwrof2(long i);
void hashinit(struct hstab *t);
int eq_type(struct typ *tp1, struct typ *tp2);
void dodecl(enum(e_sc) defclass);
struct snode *gotostmt(void);
void g_coder(enum(e_op) op, int len, struct amode *ap1, struct amode *ap2);
struct typ *expression(struct enode **node);
struct snode *breakstmt(void);
int has_autocon(struct enode *ep);
struct snode *dostmt(void);
char *strsave(char *s);
void opt_compare(struct enode *node);
struct amode *g_asmod(struct enode *node, int flags);
int hexatoi(char *s);
struct ocode *new_code(int s);
void d_amode(struct amode **node);
int getline(int listflag);
void call_library(char *lib_name);
unsigned long _w2ul(TI_LONG *x);
int asm_isreserved();
void dooper(struct enode **node);
short count_dn_an(struct enode *plist,int rp_dn,int rp_an);
struct amode *g_compound(struct snode *st, int flags);
void repexpr(struct enode *node);
void initpch();
void genfloat(double val);
void asm_searchkw();
struct amode *g_deref(struct enode *node, enum(e_bt) type, int flags, long size);
int free_data(void);
int indir_num(struct typ *tp);
int _getline(int listflag,char *base);
struct typ *asnop(struct enode **node);
struct amode *g_fcall(struct enode *node, int flags);
void warn_usr(char *s,...);
int tst_ushort(struct enode *node);
void scope_flush(void);
void rewrite(long size);
struct amode *g_aincdec(struct enode *node, int flags, enum(e_op) op);
void funcbottom(void);
struct typ *bitxor(struct enode **node);
struct amode *g_addsub(struct enode *node, int flags, enum(e_op) op);
struct snode *statement(void);
void searchkw(void);
void opt0(struct enode **node);
void decl(struct hstab *table);		/* table is used only for enum members */
struct amode *g_index(struct enode *node);
void g_strlab(char *s);
struct enode *copynode(struct enode *node);
void expand_do(char *q,int len,char *in,char *inbound,int need_ds_update);
unsigned int getconst(enum(e_sym) s,enum(e_sym) e);
void opt1(struct snode *block);
long intexpr_notemp();
int getasm_main();
unsigned short _w2us(TI_SHORT *x);
struct amode *g_div(struct enode *node, int flags);
struct amode *mk_offset(struct enode *node);
unsigned long desire(struct cse *csp);
int equalnode(struct enode *node1, struct enode *node2);
void funcbody(struct sym *sp, char *names[], int nparms);
struct amode *g_commute(void *func,struct enode *node,int flags,enum(e_op) op,int dummy/*void *reversal*/);
void add_peep(struct ocode *new_ocode);
struct snode *ifstmt(void);
void locate(void);
void allocate(void);
size_t option_parse(size_t listc,char **listv,enum(OptionModes) ex_mode);
void opt3(void);
long auto_pad(long offs,int len,int offmod);
struct amode *g_asxor(struct enode *node, int flags);
void truejp(struct enode *node, unsigned int lab);
void opt4(struct enode **node);
void macro_expansion(char *in,char *inbound,int need_ds_update);
void insert(struct sym *sp,struct hstab *table);
void dumplits();
struct amode *g_asdiv(struct enode *node, int flags);
struct amode *g_mod(struct enode *node, int flags);
struct amode *copy_addr(struct amode *ap);
int equal_address(struct amode *ap1, struct amode *ap2);
void gendouble(double val);
struct typ *commaop(struct enode **node);
void swap_nodes(struct enode *node);
int preprocess();
void dump_addstr(char *name,char *v);
struct amode *g_alloca(struct enode *node);
struct snode *whilestmt(void);
struct amode *mk_rmask(unsigned int mask);
struct amode *mk_reg(int r);
void do_compile();
void bitwise_optimize(struct enode *ep,long mode);
void out_close();
unsigned int getconst2(enum(e_sym) e);
struct amode *func_result(int flags, long bytes);
struct amode *g_cast(struct amode *ap, enum(e_bt) typ1, enum(e_bt) typ2, int flags);
struct amode *g_asmul(struct enode *node, int flags);
int start_block(int m);	// used in block() (func.c)
void error(int n);
void ds_allocatleast(unsigned int size);
struct typ *forceft2(struct enode **node1, struct typ *tp1, struct enode **node2, struct typ *tp2);
char *type_str(struct typ *tp);
struct amode *mk_label(unsigned int lab);
struct snode *loopstmt(void);
void asm_getsym();
void d_ocodes(void);
void extload(unsigned char *ext);
void initsym();
struct amode *g_shift(struct enode *node, int flags, enum(e_op) op);
void block(struct sym *sp); /* CAUTION : always requires a compound_done() after call */
struct amode *g_ybin(struct enode *node, int flags, enum(e_op) op);
struct sym *gsearch(char *na,int crc);
int cast_ok(struct typ *tp1, struct typ *tp2, int need_physically_compatible);
void needpunc(enum(e_sym) p);
struct amode *mk_scratch(long size);
void dump_genstmt(struct snode *stmt);
void d_enode(struct enode **node);
int ap_hasbeenpushed(struct amode *ap);
struct amode *g_unary(struct enode *node, int flags, enum(e_op) op);
void append(struct sym **ptr_sp, struct hstab *table);
void checkstack(void);
void rel_global();
void option_parse_all(enum(OptionModes) ex_mode);
int pchload(char *name,char *data,unsigned int flags,unsigned char *tabp, unsigned char *p0,TI_SHORT *extTab);
void my_fclose(FILE *f);
struct typ *andop(struct enode **node);
struct amode *g_expr(struct enode *node, int flags);
struct amode *g_assign(struct enode *node, int flags);
void rel_local();
struct sym *mk_int(char *name);
struct snode *asmstmt(void);
unsigned long double2ffp(double d);
void decl1(void);
struct typ *orop(struct enode **node);
int alignment(struct typ *tp);
struct amode *g_asshift(struct enode *node, int flags, enum(e_op) op);
void closepch();
void castback(long offset, struct typ *tp1, struct typ *tp2);
void dump_addreg(char *name,int v);
double floatexpr();
void freeop(struct amode *ap);
void err_usr(int m,...);
struct typ *cast_op(struct enode **ep, struct typ *tp1, struct typ *tp2);
struct amode *g_asadd(struct enode *node, int flags, enum(e_op) op);
int tst_short(struct enode *node);
struct typ *mk_type(enum(e_bt) bt, int siz);
struct enode *mk_node(enum(e_node) nt, struct enode *v1, struct enode *v2);
void _repexpr(struct enode **ep);
struct typ *binlog(struct enode **node, struct typ *(*xfunc)(), enum(e_node) nt, enum(e_sym) sy);
struct amode *func_result2(int flags, long bytes, int reg);
struct typ *force_cast_op(struct enode **ep, struct typ *tp1, struct typ *tp2);
void _exit(int code);
struct amode *g_mul(struct enode *node, int flags);
void tmp_free();
struct snode *switchstmt(void);
void g_pop(int reg, enum(e_am) rmode, int number);
struct snode *compound(int no_init);
int isshort(struct enode *node);
void flush_peep();
void put_label(int lab);
int not_lvalue(struct enode *node);
struct amode *mk_smask(unsigned int mask);
int datalit(char *s, int len);
void verbose_print_searchdirs();
void structassign(struct amode *ap1, struct amode *ap2, long size, int mode);
int pchsearch(char *id,int mode);	/* returns 0 if not PCH, 1 if PCH/def, -1 if PCH/init */
struct snode *labelstmt(void);
int getsch(int flag);
struct amode *g_xbin(struct enode *node, int flags, enum(e_op) op);
void genfuncbegin(void);
int crcN(char *na);
struct typ *binop(struct enode **node, struct typ *(*xfunc)(), enum(e_node) nt, enum (e_sym) sy);
void bsort(struct cse **list);
int macro_expand(char *id,int crc/* may equal -1 */,char *in,char *oldin,char *inbound,int need_ds_update);
void g_push(int reg, enum(e_am) rmode, int number);
int checkcases(struct snode *head);
struct amode *g_hook(struct enode *node, int flags);
void insert_macros(char *p);
struct typ *exprnc(struct enode **node);
void genptr(struct enode *node);
int *_xalloc(int siz);
int castbegin(enum(e_sym) st);
void skipspace();
int ppquit();
void dump_addint(char *name,int v);
void validate(struct amode *ap);
int radix36(char c);
struct amode *mk_legal(struct amode *ap, int flags, long size);
struct typ *copy_type_global(struct typ *tp);
void freestack(struct _stackimg *img);	/* used by g_expr::en_compound */
char *fill_calcvar(char *buffer, char *input);
int getcache(enum(e_sym) f);
int vcg_done();
void put_align2(void);
int dodefine(int mode);	// 1: #define, -1 : #macro, 0 : #undef
int drsearch(int r,struct ocode *ip);
struct typ *conditional(struct enode **node);
void doinit(struct sym *sp, int align);

#endif
