Subversion Repositories zipcpu

////////////////////////////////////////////////////////////////////////////////
//
// Filename: 	asmdata.h
//
// Project:	Zip CPU -- a small, lightweight, RISC CPU core
//
// Purpose:	Data structures for the assembler.  In particular, this file
//		declares: Abstract Syntax Trees (ASTs) to store operations for
//		later calculation, ASMLINEs or assembled lines (which may or
//		may not be defined, depending upon symbol table status),
//		symbol table access and the final output object file together
//		with its necessary relocations.  Yes, linking is done, but as
//		part of the assembler and not part of a separate linker.
//
// Creator:	Dan Gisselquist, Ph.D.
//		Gisselquist Technology, LLC
//
////////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2015, Gisselquist Technology, LLC
//
// This program is free software (firmware): you can redistribute it and/or
// modify it under the terms of  the GNU General Public License as published
// by the Free Software Foundation, either version 3 of the License, or (at
// your option) any later version.
//
// This program is distributed in the hope that it will be useful, but WITHOUT
// ANY WARRANTY; without even the implied warranty of MERCHANTIBILITY or
// FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
// for more details.
//
// You should have received a copy of the GNU General Public License along
// with this program.  (It's in the $(ROOT)/doc directory, run make with no
// target there if the PDF file isn't present.)  If not, see
// <http://www.gnu.org/licenses/> for a copy.
//
// License:	GPL, v3, as defined and found on www.gnu.org,
//		http://www.gnu.org/licenses/gpl.html
//
//
////////////////////////////////////////////////////////////////////////////////
#ifndef	ASMDATA_H
#define	ASMDATA_H
 
#include <stdio.h>
#include <string>
#include <list>
#include "zopcodes.h"
#include "zparser.h"
 
extern	"C" char	*linecp;
extern	int	yylineno;
 
typedef enum {
//	TST	OPCND
	// Dual operand instructions that take conditions
	OP_CMP, OP_TST, OP_MOV, OP_LDIHI, OP_LDILO, OP_MPYU, OP_MPYS, OP_ROL,
		OP_SUB, OP_AND, OP_ADD, OP_OR, OP_XOR,
		OP_LSL, OP_ASR, OP_LSR,
	// New bit-wise operations
	OP_BREV, OP_POPC,
	// New divide instruction
	OP_DIVU, OP_DIVS,
	// New floating point instructions
	OP_FPADD, OP_FPSUB, OP_FPMUL, OP_FPDIV, OP_FPCVT, OP_FPINT,
	// Memory operands/operators
	OP_LOD, OP_STO,
	// Dual operand instructions that do not take conditions
	OP_LDI,
	// Single operand instructions that can take conditions
	OP_CLRF, OP_JMP, OP_LJMP, OP_NOT,
	// Branch operands
	OP_BRA, OP_BLT, OP_BZ, OP_BNZ, OP_BGT, OP_BGE, OP_BRC, OP_BRV,
	// Single operand instructions that have no explicit conditions
	OP_CLR, OP_TRAP, OP_NEG,
	// BAREOPs that can have conditions
	OP_HALT,  OP_RTU, OP_BUSY, OP_RETN,
	// BAREOPs without conditions
	OP_BREAK, OP_NOOP, OP_LOCK,
	// Error condition--undefined operand
	OP_NONE
} LEXOPCODE;
 
#define	DEFAULT_LINE	0x76000000
 
class	ASMLINE	{
public:
	char	m_state;
	int	m_lineno;
	virtual	bool	isdefined(void) { return true; };
	virtual	~ASMLINE(void) {};
	virtual	int	nlines(void) { return 0; }
	virtual	unsigned int	eval(const int lno) { return DEFAULT_LINE; }
	virtual	void	dump(FILE *fp) = 0;
};
 
class	AST { // The actual expression tree
public:
	// node type is one of:
	// 'B' a branch with two sides
	// 'N' a number
	// 'I' an identifier
	// 'A' ?? an address ?? would we need this?
	virtual	~AST(void) {}
	char	m_node_type;
	virtual	bool	isdefined(void) = 0;
	virtual	int	eval(void) = 0;
	virtual	void	reduce(void) = 0;
	virtual void	dump(FILE *fp) = 0;
};
 
/*
class	ULINE : public ASMLINE	{ // Unprocessed line of assembly
public:
	std::string	m_file, m_text;
	int		m_lineno;
	ULINE(const int line, const std::string file,
		const std::string text) : m_file(file), m_text(text),
					m_lineno(line) { m_state = 'U'; }
	class TLINE	*eval(void);
	int		nlines(void) { return 0; };
	virtual	bool	isdefined(void) { return false; };
};
*/
 
class	ILINE : public ASMLINE { // Instruction line
public:
	ZIPI	m_in;
	ILINE(const ZIPI in) : m_in(in) { m_state = 'I'; m_lineno = yylineno; };
	virtual	bool	isdefined(void) { return true; };
	virtual	int	nlines(void) { return 1; }
	virtual	unsigned int	eval(const int lno);
	void	dump(FILE *fp) { fprintf(fp, "IN: %08x\n", m_in); }
};
 
class	VLINE : public ASMLINE { // Void line
public:
	VLINE(void) { m_state = 'V'; m_lineno = yylineno; };
	virtual	bool	isdefined(void) { return true; };
	virtual	int	nlines(void) { return 0; }
	virtual	unsigned int	eval(const int lno);
	void	dump(FILE *fp) { fprintf(fp, "void\n"); }
};
 
class	DLINE : public ASMLINE { // Data line
public:
	ZIPI	m_data;
	DLINE(const ZIPI dat) : m_data(dat) { m_state = 'D'; m_lineno = yylineno; };
	virtual	bool	isdefined(void) { return true; };
	virtual	int	nlines(void) { return 1; }
	virtual	unsigned int	eval(const int lno);
	void	dump(FILE *fp) { fprintf(fp, "\tWORD\t%08d\n", m_data); }
};
 
class	LLINE : public ASMLINE { // List line -- one line that has turned into
		// many
public:
	int	m_nlines;
	ASMLINE	**m_lines;
	LLINE(void) : m_nlines(0), m_lines(NULL) { m_state = 'L'; m_lineno = yylineno; };
	void addline(ASMLINE *line) ;
	virtual	bool	isdefined(void);
	~LLINE(void);
	virtual	int	nlines(void) { return m_nlines; }
	virtual	unsigned int	eval(const int lno);
	void	dump(FILE *fp) { 
		for(int i=0; i<m_nlines; i++)
			m_lines[i]->dump(fp);
	}
};
 
class	TLINE : public ASMLINE { // Expression tree
public:
	LEXOPCODE		m_opcode;
	ZPARSER::ZIPCOND	m_cond;
	AST			*m_imm;
	ZPARSER::ZIPREG		m_opb, m_opa;
 
	TLINE(void) : m_opcode(OP_NONE), m_cond(ZPARSER::ZIPC_ALWAYS),
			m_imm(NULL), m_opa(ZPARSER::ZIP_Rnone), m_opb(ZPARSER::ZIP_Rnone)
			{ m_state = 'T'; m_lineno = yylineno; };
	virtual	bool	isdefined(void) {
		if (m_imm != NULL) {
			bool answer = m_imm->isdefined();
			return answer;
		} else return true;
	}
	ASMLINE *eval(void);
	~TLINE(void) { if (m_imm) delete m_imm; }
	virtual	int	nlines(void); //  { return 1; }
	virtual	unsigned int	eval(const int lno);
	void	dump(FILE *fp);
};
 
class	AST_BRANCH : public AST { // The actual expression tree
public:
	int	m_op; // An operator
	AST	*m_left, *m_right;
 
	AST_BRANCH(int op, AST *l, AST *r)
		: m_op(op), m_left(l), m_right(r) { m_node_type = 'B';
		}
	~AST_BRANCH(void) {
		if (m_left)
			delete	m_left;
		if (m_right)
			delete	m_right;
	}
 
	bool	isdefined(void) {
		return ((m_left)&&(m_right)
				&&(m_left->isdefined())
				&&(m_right->isdefined()));
	}
 
	int	eval(void);
	void	reduce(void);
	void	dump(FILE *fp) {
		fprintf(fp, "(");
		m_left->dump(fp);
		fprintf(fp, ") %c (", m_node_type);
		m_right->dump(fp);
		fprintf(fp, ")");
	}
};
 
class	AST_NUMBER : public AST { // A number at the base of the tree
public:
	int	m_val;
	AST_NUMBER(int val) : m_val(val) { m_node_type = 'N'; }
	bool	isdefined(void) { return true; }
	int	eval(void);
	void	reduce(void);
	void	dump(FILE *fp) { fprintf(fp, "%d", m_val); }
};
 
class	AST_IDENTIFIER : public AST { // An identifier within the expression tree
public:
	std::string	m_id;
	AST_IDENTIFIER(const char *id) : m_id(id) { m_node_type = 'I'; }
	AST_IDENTIFIER(AST *ida, const char *idb);
	bool	isdefined(void);
	int	eval(void);
	void	reduce(void);
	void	dump(FILE *fp) { fprintf(fp, "%s", m_id.c_str()); }
};
 
class	AST_LABEL : public AST { // An address label within the expression tree
	// This is special, because it cannot be evaluated without knowing
	// the PC value at this address
public:
	std::string	m_label;
	AST_LABEL(const char *id) : m_label(id) { m_node_type = 'L'; }
	bool	isdefined(void);
	int	eval(void);
	void	reduce(void);
	void	dump(FILE *fp) { fprintf(fp, "%s", m_label.c_str()); }
};
 
class	SAVED_ASMLINE {
public:
	unsigned int	m_pc;
	ASMLINE		*m_ln;
	SAVED_ASMLINE(const unsigned int pc, ASMLINE *ln) : m_pc(pc), m_ln(ln)
		{}
};
 
class	OBJFILE {
	typedef	std::list<SAVED_ASMLINE> SVDTBL;
 
	SVDTBL		m_tbl;
	unsigned int	m_pc;
	FILE		*m_fp;
 
public:
	OBJFILE(void) { m_fp = NULL; m_pc = 0; }
	void open(const char *fname);
	void close(void) { fclose(m_fp); };
	unsigned int pc(void) { return m_pc; }
	void	operator+=(ASMLINE *ln);
	bool	reduce(void);
};
 
// The file we are building
extern	OBJFILE	objcode;
 
// Functions for accessing and defining elements in our symbol table
extern	bool	stb_isdefined(const char *key);
extern	int	stb_value(const char *key);
extern	void	stb_define(const char *key, AST *value);
extern	void	gbl_define(const char *key, AST *value);
extern	bool	stb_isdefined(const std::string &key); //  { return stb_isdefined(key.c_str()); }
extern	int	stb_value(const std::string &key); //  { return stb_value(key.c_str()); }
extern	void	stb_define(const std::string &key, AST *value); //  { return stb_define(key.c_str(), value); }
extern	void	gbl_define(const std::string &key, AST *value); //  { return stb_define(key.c_str(), value); }
extern	void	create_new_context(void); // Create a new symbol table context
 
 
#endif // ASMDATA_H