#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>

/*
 * macros
 */

#define SUCCESS 0

#define ROWS(a) a->rows
#define COLS(a) a->cols
#define STR(a)  a->u.str
#define MAT(a)  a->u.ptr
#define VAL(a)  a->u.val
#define NAME(a) (a->name ? a->name : NONAME)

#define OFFSET(a) a->rows	/* for local variables */

#define NARG(a)  a->rows	/* for FUNCTIONS and PROCEDURES */
#define SIZE(a)  a->cols

#define SCALAR(a) (a->type == NUMBER)

#define A(i,j) MAT(a)[i][j]
#define B(i,j) MAT(b)[i][j]
#define C(i,j) MAT(c)[i][j]
#define D(i,j) MAT(d)[i][j]
#define R(i,j) MAT(r)[i][j]
#define V(i,j) MAT(v)[i][j]

typedef void (*Inst)( void);	/* machine instruction */
typedef Inst *Instptr;		/* pointer to machine instruction */

/*
 * symbol table structure
 *
 *   type:	UNDEF, NUMBER, MATRIX, STRING, FN, PROC, FUNCTION, PROCEDURE,
 *		or a keyword (see init.h for list of keywords)
 *
 *		<---- VAR's, func's ---->  <-- constants -->
 *   class:	NEW, EXTERN, AUTO, STATIC, CONST, DEFN, LOOP
 *		<- named ->  <---------- unnamed ---------->
 */

typedef struct symbol {
    char *name;
    short type;
    short class;
    int rows, cols;
    union {
	Inst fn;			/* if FN or PROC */
	Instptr fptr;			/* if FUNCTION or PROCEDURE */
	double val;			/* if NUMBER */
	double **ptr;			/* if MATRIX */
	char *str;			/* if STRING */
    } u;
    struct symbol *next;
} Symbol;

typedef Symbol *Symbolptr;

/*
 * global variables
 */

extern int line_number;				/* from io.c */

extern Symbol eps, tol, num, format, IO, rowend;/* from util.c */
extern Symbol CLEAN;
extern Symbol LTsym, GTsym, GTGTsym;
extern char *NONAME;

extern FILE *fin, *fdiary;			/* from main.c */
extern int diary, batch;
#ifdef DEBUG
    extern int stack_debug;
    extern int prog_debug;
    extern int trace;
    extern int stack_dump;
    extern int exe;
#endif

extern int inmat, inloop, instmt, insw, indef;	/* from m.y */
extern int echo;
#if YYDEBUG
    extern int yydebug;
#endif

extern Inst prog[];				/* from code.c */
extern Instptr pp, pc;

extern Symbolptr stack[];			/* from stack.c */
extern Symbolptr *sp;
extern Symbolptr *frame[];
extern Symbolptr **fp;

extern int got_return, got_break, got_continue;	/* from execute.c */

#ifndef YACC
# include "y_tab.h"	/* token defs, etc. */
#endif

/*
 * global functions
 */

void version( void);		/* version.c */

void error( char *, char *);	/* main.c */
void yyerror( char *);
void prompt( void);

void push( Symbolptr);		/* stack.c */
void matpop( void);
Symbolptr pop( void);
void npop( int);
void swap( void);
void local_push( void);
void sympush( void);
void fpush( void);
void fpop( void);
Symbolptr *ftop( void);
#ifdef DEBUG
    void s_dump( void);
#endif

Symbolptr lookup( char *name);	 /* symbol.c */
Symbolptr install( char * name, int type, int class, int rows, int cols);
void init( void);
void who( void);
void what( void);
void display( Symbolptr p, char *msg);
void dump( void);
void clear( Symbolptr p);
void cleanup( int all);
void clear_all( void);
void save( FILE *fout, Symbolptr a, int binary);
void save_all( FILE *fout, int binary);
void readfile( char *fname);

Symbolptr new( void);		/* new.c */
void dispose( Symbolptr p);

double urand( void);		/* rand.c */
double erand( void);
double grand( void);
int irand( int);
void randomize( void);

void addfile( char *name);	/* file.c */
FILE *nextfile( void);

void history( int nlines, FILE *fout);	/* io.c */
int m_getc( void);
void m_ungetc( int c);
int m_scanf( double *x);
void m_gets( void);
void fn_start( void);
char *defn( void);
void dprint( char *fmt, ...);

void dputchar( int c);
void derror( void);

#include "mat.h"	/* mat.c, svd.c */

void initcode( void);	/* code.c */
Inst d2i( void *v);
void *i2d( Inst i);
Instptr code( Inst f);
Instptr code2( Inst f1, Inst f2);
Instptr code3( Inst f1, Inst f2, Inst f3);
Instptr code4( Inst f1, Inst f2, Inst f3, Inst f4);
void define( Symbolptr a, int narg);
Instptr varpush( Symbolptr a);
void mklocal( Symbolptr a, int class, Instptr init);
void fnarg( int type, Symbolptr a);

void execute( Instptr p);	/* execute.c */
void fn( void);
void m_while( void);
void m_do( void);
void m_if( void);
void m_for( void);
void m_break( void);
void m_continue( void);
void proc_ret( void);
void func_ret( void);
void m_and( void);
void m_or( void);
void m_cond( void);
void m_switch( void);
void m_case( void);
void m_default( void);
void call( void);
void call2( Symbolptr f, int narg);
#ifdef DEBUG
    void disasm( Instptr p, Instptr pp);
#endif

void m_diary( void);		/* m_cmd.c */
void m_cd( void);
void m_pwd( void);
void m_history( void);
void m_echo( void);
void m_what( void);
void m_who( void);
void m_help( void);
void m_clear( void);
void m_quit( void);
void m_list( void);
void m_save( void);
void m_read( void);
#ifdef DEBUG
    void m_disasm( void);
#endif

void m_abs( void);	/* m_fn.c: functions from <math.h> */
void m_acos( void);
void m_asin( void);
void m_atan( void);
void m_atan2( void);
void m_ceil( void);
void m_cos( void);
void m_cosh( void);
void m_erf( void);
void m_erfc( void);
void m_exp( void);
void m_floor( void);
void m_log( void);
void m_log10( void);
void m_sin( void);
void m_sinh( void);
void m_sqrt( void);
void m_sum( void);
void m_prod( void);
void m_tan( void);
void m_tanh( void);

void m_IO( void);	/* m_fn.c: other functions */
void m_sort( void);
void m_all( void);
void m_any( void);
void m_cleanup( void);
void m_cols( void);
void m_diag( void);
void m_eps( void);
void m_eye( void);
void m_find( void);
void m_format( void);
void m_max( void);
void m_min( void);
void m_norm( void);
void m_null( void);
void m_ones( void);
void m_rand( void);
void m_reshape( void);
void m_trunc( void);
void m_trunc2( void);
void m_round( void);
void m_round2( void);
void m_rows( void);
void m_sizeof( void);
void m_svd( void);
void m_tol( void);
void m_num( void);
void m_undef( void);
void m_zeros( void);

void m_feval( void);

void m_srand( void);		/* m_proc.c */
void m_qr( void);
void m_exit( void);
void m_dump( void);
void m_load( void);
void m_write( void);
void m_printfn( void);
void m_printf( void);
void mplot( void (*plotfn)( char *, double *, double *, int) );
void m_plot2d( void);
void m_plot( void);
void m_hplot( void);
#ifdef DEBUG
    void m_debug( void);
#endif

void m_print( void);		/* m_mat.c */
void m_copy( void);
void m_colon( void);
void m_assign( void);
void m_assign1( void);
void m_assign2( void);
void m_string( void);
void m_matrix( void);
void m_transpose( void);
void m_index( void);
void m_index1( void);
void m_index2( void);
void m_pp( void);
void m_pp2( void);
void m_reduce( void);
void m_mul( void);
void m_unary( void);
void m_dyadic( void);
void m_pbs( void);
void m_tbs( void);
void m_install( void);
void m_uninstall( void);

void m_init( void);		/* util.c */
char *str_type( int type);
char *str_class( int class);
void check( Symbolptr a);
void c_check( Symbolptr a, char *name);
void m_check( Symbolptr a, char *name);
void n_check( Symbolptr a, char *name);
void s_check( Symbolptr a, char *name);
void print( Symbolptr s);
void arg_check( int narg, char *name);
void unary_check( int narg, char *name);
Symbolptr m_create( int m, int n);
Symbolptr s_create( int n);
Symbolptr m_new( Symbolptr a, int m, int n);
double sdyadic( double x, double y, int op);
void matsdyadic( double *x[], double *y[], double s, int m, int n, int op);
void smatdyadic( double *x[], double s, double *y[], int m, int n, int op);
void matdyadic( double *x[], double *y[], double *z[], int m, int n, int op);
Symbolptr unary( Symbolptr a, int op);
Symbolptr reduce( Symbolptr a, int op);
Symbolptr dyadic( Symbolptr v1, Symbolptr v2, int op);
Symbolptr copy( Symbolptr a, Symbolptr b);
Symbolptr diag( Symbolptr a);
double round1( double x, double s);
double trunc1( double x, double s);
double round2( double x, double s);
double trunc2( double x, double s);

void hplot(  char *title, double x[], double y[], int n);	/* plot.c */
void plot(   char *title, double x[], double y[], int n);
void plot2d( char *title, double x[], double y[], int n);

Symbolptr sort( Symbolptr a);	/* sort.c */

/*
 * unary function codes
 */

#define ABS	1000
#define ACOS	1001
#define ASIN	1002
#define ATAN	1003
#define CEIL	1004
#define COS	1005
#define COSH	1006
#define ERF	1007
#define ERFC	1008
#define EXP	1009
#define FLOOR	1010
#define LOG	1011
#define LOG10	1012
#define SIN	1013
#define SINH	1014
#define SQRT	1015
#define TAN	1016
#define TANH	1017

/*
 * dyadic function codes
 */

#define ATAN2	1500
#define MAX	1501
#define MIN	1502
#define ROUND	1503
#define ROUND2	1504
#define TRUNC	1505
#define TRUNC2	1506

/*
 * miscellaneous codes
 */

#define DEFN	2000
#define LOOP	2001
#define MATRIX	2002
#define NEW	2003
#define UNDEF	2004
#define VECTOR	2005