basic.h

basic.c */ /**//* Project:NeuroBasic, basic package*//**/ /* Survey:This is a simple Basic b-code

/****************************************************************/
/*								*/
/* Name:	basic.h						*/
/*								*/
/* Project:	NeuroBasic, basic package			*/
/*								*/
/* Survey:	Contains definitions for the basic interpreter	*/
/*								*/
/* Author:	Urs Mueller					*/
/*		Electronics Laboratory, ETH Zuerich		*/
/*		Switzerland					*/
/*								*/
/* Created:	July 21, 1994					*/
/* Modified:	August 2, 1995 (um)				*/
/*								*/
/****************************************************************/


#ifndef __basic_h__
#define __basic_h__


#include <stdio.h>
#include "common.h"




/* macro definitions */
/*********************/

#define PROMPT		"Ok "
#define INDENT		"   "
#define LIST_MAX	20		/* number of lines listed */
#define WHITE_SPACE	" \f\n\r\t\v"
#define PRINTQ_MAX	40		/* size of printer queue */
#define NULLSTRING      ""
#define PRG_MAX		10000		/* largest program-line number */
#define LINE_BEGIN	10		/* first prog. line number */
#define LINE_INCREMENT  10 		/* increment for prog. lines */
#define STACK_MAX	512		/* b-code stacksize */
#define STR_SPACE	4096		/* space for b-code strings */
#define RELOC_MAX	1024		/* size of relocation table */
#define VAR_MAX		5000		/* # global variables */
#define ARR_MAX		256		/* # arrays */
#define LOCVAR_MAX	128		/* # local variables */
#define FCT_MAX		128		/* number of basic functions */
#define CMD_MAX		512		/* max. length of a command */
#define FNAME_MAX	32		/* max. length of function names */
#define LABEL_MAX	512		/* max. numbers of labels */

#define VAR_EMPTY	0
#define VAR_SET		1

#ifndef MINT
#define MINT long
#endif
#ifndef MFLOAT
#define MFLOAT float
#endif


#ifndef TRUE
#define TRUE 1
#endif
#ifndef FALSE
#define FALSE 0
#endif

#ifndef EXIT_SUCCESS
#define EXIT_SUCCESS	0
#endif
#ifndef EXIT_FAILURE
#define EXIT_FAILURE	-1
#endif

#ifndef UNUSED
#define UNUSED	0
#endif
#ifndef USED
#define USED	1
#endif



/* b-code macros */
/*****************/

typedef enum
{
  B_USER_FCT,		/* call user-function		*/
  B_USER_FCT2,		/* user-fct can return < 0	*/
  B_BUILTIN_FCT,	/* built-in basic function	*/
  B_CHS,		/* change sign (+/-)		*/
  B_POW,		/* power of (** or ^)		*/
  B_MPY,		/* multiply			*/
  B_DIV,		/* divide			*/
  B_IDIV,		/* integer divide		*/
  B_MOD,		/* modulo			*/
  B_ADD,		/* add				*/
  B_SUB,		/* subtract			*/
  B_LEQ,		/* less or equal		*/
  B_GEQ,		/* greater or equal		*/
  B_LTH,		/* less than			*/
  B_GTH,		/* greater than			*/
  B_EQU,		/* equal			*/
  B_NEQ,		/* not equal			*/
  B_OR,			/* logical OR			*/
  B_EXOR,		/* logical exclusive OR		*/
  B_AND,		/* logical AND			*/
  B_NOT,		/* negation (logical NOT)	*/
  B_NOP,		/* no operation			*/
  B_EXIST,		/* test variable if defined	*/
  B_PUSHC,		/* push constant		*/
  B_PUSHV,		/* push global variable		*/
  B_PUSHLOCV,		/* push local variable		*/
  B_PULL,		/* kill top of stack		*/
  B_ASSIGN,		/* assign to global variable	*/
  B_LOCASSIGN,		/* assign to local variable	*/
  B_ASSIGN_STR,		/* assign to string variable 	*/
  B_JUMPA,		/* jump always			*/
  B_JUMPC,		/* jump conditional		*/
  B_NEXT,		/* next	(in for-next loop)	*/
  B_LOCNEXT,		/* next (with local variable)	*/
  B_INPUT,		/* input from user to variable	*/
  B_LOCINPUT,		/* input from user to local v.	*/
  B_PRINT,		/* print out the queue		*/
  B_PRINTTAB,		/* print a tab			*/
  B_PRINTNL,		/* new line			*/
  B_PRINTS,		/* print a string		*/
  B_PRINTF,		/* print a floatingpoint value	*/
  B_DIM,		/* create an array		*/
  B_ASSIGN_ARR,		/* assign to array variable	*/
  B_ARRAY,		/* variable is an array		*/
  B_MKFRAMEP,		/* make frame pointer		*/
  B_RETURNFN,		/* return from function		*/
  B_OPENFILE,           /* open print file              */
  B_CLOSEFILE,          /* close print file             */
  B_STR_ADD,		/* concatenate two string var.  */
  B_STR_DEL_STACK,	/* delete string stack	 	*/
  B_END			/* end program			*/
} b_opcode_t;





/* type definitions */
/********************/


typedef union
{
  MINT		i;
  MFLOAT	f;
  void		*p;
} b_stack_t;  

typedef union
{
  MINT		i;
  MFLOAT	f;
  void		(*p)(b_stack_t **b_sp);
} b_code_t;

typedef b_stack_t printq_t[PRINTQ_MAX];

typedef struct
{
  unsigned int	char0 : 8;
  unsigned int	char1 : 8;
  unsigned int	char2 : 8;
  unsigned int	char3 : 8;
} PACKED_CHARS_T;		/* used for string conversion */

typedef void (*neuro_fct_t)(b_stack_t **pb_sp);

typedef void (*host_fct_t)(message_t msg);

typedef struct
{
  const char	*fct_name;
  neuro_fct_t	fct_pointer;
  MINT		fct_nargs;
} FUNCTION_PTR_ARR_T;

typedef struct
{
  MINT	*mft_func_ptr;
  MINT	*mft_nargs;
  MINT	*mft_fct_names;
  MINT	mft_nitems;
} MFCT_TAB_T;

typedef struct
{
  char	*name;
  char	*str;
  MINT	used;
} str_ve_t;

typedef enum
{
  PR_NORMAL, PR_SINGLELINE
} pr_t;

typedef struct
{
  MFLOAT	v;		/* value */
  MINT		f;		/* flags */
} var_t;

typedef struct
{
  MFLOAT	*arr;		/* values */
  MINT		size;
} arr_t;

typedef struct
{
  char		*cname;
  MFLOAT	cvalue;
} bconst_t;




/* common variables */
/********************/

extern const char *b_error_strings[];
extern bconst_t bconst[];
extern host_fct_t host_fcts[];
extern long prg_line;
extern char cmdbuf[CMD_MAX+1];
extern MFCT_TAB_T mfct_tab;
extern long nfunctions;
extern char *bsrc[PRG_MAX];




/* function prototypes */
/***********************/

MINT b_interpreter(MINT prg_length, MINT entry_point);
MINT m_get_fct_ptrs(void);
MINT init_musicside(void);
MINT clear_mvars(void);
MINT store_string(const char *name, char *pstr, int search);
int kwcmp(const char *cmd, const char *kw);
char *idend(char *s);
MINT get_label(char *name);
void turn_byte_order(MINT *ptr, MINT nwords);

int basic(int nfiles, char *file_list[]);
void prg_version(void);


/* prototypes for compiler.c */
/*****************************/
int bc_compile_line(const char *source_line);
int bc_compile_program(char *bsource[]);
size_t bc_get_codelength(void);
b_code_t *bc_get_codeadr(void);
int bc_get_error(void);
void bc_reset(void);
void bc_clrvars(void);
MINT bc_srcline(MINT b_pos);
void bc_print_varerror(MINT b_pos, MINT var_nr);
void bc_print_error(int type, MINT varnr, MINT index, MINT b_pos);
char *bc_str_get(MINT index, MINT b_pos, int *eflag);
void bc_str_dup(MINT dest, MINT src, MINT b_pos, int *eflag);
MINT bc_str_add(MINT s1, MINT s2, MINT b_pos, int *eflag);
MINT bc_str_new(char *str, MINT b_pos, int *eflag);
void bc_str_delstack(void);

#endif