From 8b4befd4fcfb38dcf9e3d62089155658ba2e9093 Mon Sep 17 00:00:00 2001
From: steve <steve>
Date: Tue, 1 May 2001 01:09:39 +0000
Subject: [PATCH]  Add support for memory objects. (Stephan Boettcher)

---
 vvp/Makefile.in   |   4 +-
 vvp/README.txt    |  73 +++++++-
 vvp/codes.h       |  13 +-
 vvp/compile.cc    | 108 +++++++++++-
 vvp/compile.h     |  19 ++-
 vvp/lexor.lex     |   9 +-
 vvp/memory.cc     | 422 ++++++++++++++++++++++++++++++++++++++++++++++
 vvp/memory.h      |  57 +++++++
 vvp/parse.y       |  47 +++++-
 vvp/parse_misc.cc |  12 +-
 vvp/parse_misc.h  |  14 +-
 vvp/schedule.cc   |  65 ++++++-
 vvp/schedule.h    |  19 ++-
 vvp/vthread.cc    |  57 ++++++-
 14 files changed, 894 insertions(+), 25 deletions(-)
 create mode 100644 vvp/memory.cc
 create mode 100644 vvp/memory.h

diff --git a/vvp/Makefile.in b/vvp/Makefile.in
index 243340d9d..4d91b9d1d 100644
--- a/vvp/Makefile.in
+++ b/vvp/Makefile.in
@@ -16,7 +16,7 @@
 #    59 Temple Place - Suite 330
 #    Boston, MA 02111-1307, USA
 #
-#ident "$Id: Makefile.in,v 1.14 2001/04/24 02:23:59 steve Exp $"
+#ident "$Id: Makefile.in,v 1.15 2001/05/01 01:09:39 steve Exp $"
 #
 #
 SHELL = /bin/sh
@@ -61,7 +61,7 @@ V = vpi_modules.o vpi_const.o vpi_iter.o vpi_mcd.o vpi_priv.o \
 vpi_scope.o vpi_signal.o vpi_tasks.o vpi_time.o
 
 O = main.o parse.o parse_misc.o lexor.o compile.o functor.o symbols.o \
-codes.o vthread.o schedule.o tables.o udp.o $V
+codes.o vthread.o schedule.o tables.o udp.o memory.o $V
 
 vvp: $O
 	$(CXX) $(rdynamic) $(CXXFLAGS) $(LDFLAGS) -o vvp $O $(dllib)
diff --git a/vvp/README.txt b/vvp/README.txt
index c49fa7723..d91fdc5df 100644
--- a/vvp/README.txt
+++ b/vvp/README.txt
@@ -1,7 +1,7 @@
 /*
  * Copyright (c) 2001 Stephen Williams (steve@icarus.com)
  *
- *  $Id: README.txt,v 1.20 2001/04/30 04:51:27 steve Exp $
+ *  $Id: README.txt,v 1.21 2001/05/01 01:09:39 steve Exp $
  */
 
 VVP SIMULATION ENGINE
@@ -281,6 +281,77 @@ This prevents any real functor being created and connected, and
 instead leaves the input unconnected and initializes the wire with the
 specified value, instead of the default z.
 
+MEMORY STATEMENTS:
+
+Three types of memory stetement perform (1) creation of a memory, (2)
+connecting a read port to an existing memory, and (3) initializing the
+memory's contents.
+
+       <label> .mem "name", <msb>,<lsb>, <last>,<first> ... ;
+
+The pair of numbers <msb>,<lsb> defines the data port width.  The pair
+<last>,<first> defines the address range.  Multiple address ranges are
+allowed for multidimensional indexing.  
+
+Procedural access to the memory references the memory as single array
+of bits.  For this purpose, the number of bits in a memory word is
+rounded up to the next multiple of four.  That is, for an 18 bit wide
+data bus, bit 0 is the lsb of the first word, bit 20 is the lsb of the
+second word.
+
+Structural read access is implemented in terms of address and data
+ports.  An address port is the concatinations of the smallest number of
+address bits required to express each address range.  The addresses
+applied to the address port are expected to be withing the ranges
+specified. 
+
+An port is a vector of functors that is wide enough to accept all
+address bits and at least as wide as the requested subset of the data
+port.
+
+	<label> .mem/port <memid>, <msb>,<lsb>, <symbols_list> ;
+
+<label> identifies the vector of output functors, to allow connections
+to the data output.  <memid> is the label of the memory. <msb>,<lsb>
+select a part of the data width.  These are not relative to the data
+port range defined for the memory.  The LSB of the data word if here
+referred to as 0, regardless to the range specified in the memory
+definition.  The <symbols_list> connects to the address inputs of this
+port. 
+
+Any address change, or any change in the addressed memory contents is
+imediately propagated to the port outputs.
+
+To initialize a memory, use:
+
+	        .mem/init <memid>[<start>],
+			val val val ...
+			;
+
+<memid> is the lavbel of the memory.  [<start>] is optional,
+identifying the bits locattion where the first value is loaded.
+<start> must be a multiple of four, and defaults to zero, if omitted.
+
+The values are decimal or hex numbers (0x prefix), which may be
+optionally separated by commata ','.  Each number in the range 0..256
+initializes four memory bits.  Two bits form each byte for each memory
+bit, in the ususal encoding.
+
+Procedural access to the memory employs an index register to address a
+bit location in the mememory, via the commands:
+
+	%load/mem   <bit>, <memid>[<ix>] ;
+	%set/mem    <memid>[<ix>], <bit> ;
+	%assign/mem <memid>[<ix>], <delay>, <bit> ;
+
+???  is "/mem" required, or shall functors and memories share a
+namespace? ???
+
+<ix> identifies one of the four index registers of the current
+thread.  The value of register <ix> is the index in the memories bit
+space, where each data word occupies a multiple of four bits.
+
+
 EVENT STATEMENTS
 
 Threads need to interact with the functors of a netlist synchronously,
diff --git a/vvp/codes.h b/vvp/codes.h
index d0ee75830..4d1c9db20 100644
--- a/vvp/codes.h
+++ b/vvp/codes.h
@@ -19,11 +19,12 @@
  *    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
  */
 #if !defined(WINNT)
-#ident "$Id: codes.h,v 1.20 2001/04/18 04:21:23 steve Exp $"
+#ident "$Id: codes.h,v 1.21 2001/05/01 01:09:39 steve Exp $"
 #endif
 
 
 # include  "pointers.h"
+# include  "memory.h"
 # include  "vthread.h"
 # include  <stdio.h>
 
@@ -38,6 +39,7 @@ typedef bool (*vvp_code_fun)(vthread_t thr, vvp_code_t code);
 extern bool of_ADD(vthread_t thr, vvp_code_t code);
 extern bool of_AND(vthread_t thr, vvp_code_t code);
 extern bool of_ASSIGN(vthread_t thr, vvp_code_t code);
+extern bool of_ASSIGN_MEM(vthread_t thr, vvp_code_t code);
 extern bool of_CMPS(vthread_t thr, vvp_code_t code);
 extern bool of_CMPU(vthread_t thr, vvp_code_t code);
 extern bool of_CMPX(vthread_t thr, vvp_code_t code);
@@ -47,17 +49,22 @@ extern bool of_DISABLE(vthread_t thr, vvp_code_t code);
 extern bool of_END(vthread_t thr, vvp_code_t code);
 extern bool of_FORK(vthread_t thr, vvp_code_t code);
 extern bool of_INV(vthread_t thr, vvp_code_t code);
+extern bool of_IX_ADD(vthread_t thr, vvp_code_t code);
+extern bool of_IX_LOAD(vthread_t thr, vvp_code_t code);
+extern bool of_IX_MUL(vthread_t thr, vvp_code_t code);
 extern bool of_JMP(vthread_t thr, vvp_code_t code);
 extern bool of_JMP0(vthread_t thr, vvp_code_t code);
 extern bool of_JMP0XZ(vthread_t thr, vvp_code_t code);
 extern bool of_JMP1(vthread_t thr, vvp_code_t code);
 extern bool of_JOIN(vthread_t thr, vvp_code_t code);
 extern bool of_LOAD(vthread_t thr, vvp_code_t code);
+extern bool of_LOAD_MEM(vthread_t thr, vvp_code_t code);
 extern bool of_MOV(vthread_t thr, vvp_code_t code);
 extern bool of_NOOP(vthread_t thr, vvp_code_t code);
 extern bool of_NORR(vthread_t thr, vvp_code_t code);
 extern bool of_OR(vthread_t thr, vvp_code_t code);
 extern bool of_SET(vthread_t thr, vvp_code_t code);
+extern bool of_SET_MEM(vthread_t thr, vvp_code_t code);
 extern bool of_VPI_CALL(vthread_t thr, vvp_code_t code);
 extern bool of_WAIT(vthread_t thr, vvp_code_t code);
 extern bool of_XNOR(vthread_t thr, vvp_code_t code);
@@ -75,6 +82,7 @@ struct vvp_code_s {
 	    unsigned number;
 	    vvp_ipoint_t iptr;
 	    vvp_cpoint_t cptr;
+	    vvp_memory_t mem;
 	    struct __vpiHandle*handle;
 	    struct fork_extend*fork;
       };
@@ -117,6 +125,9 @@ extern void codespace_dump(FILE*fd);
 
 /*
  * $Log: codes.h,v $
+ * Revision 1.21  2001/05/01 01:09:39  steve
+ *  Add support for memory objects. (Stephan Boettcher)
+ *
  * Revision 1.20  2001/04/18 04:21:23  steve
  *  Put threads into scopes.
  *
diff --git a/vvp/compile.cc b/vvp/compile.cc
index c536b2ee6..a03405c4f 100644
--- a/vvp/compile.cc
+++ b/vvp/compile.cc
@@ -17,12 +17,13 @@
  *    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
  */
 #if !defined(WINNT)
-#ident "$Id: compile.cc,v 1.47 2001/04/30 03:53:19 steve Exp $"
+#ident "$Id: compile.cc,v 1.48 2001/05/01 01:09:39 steve Exp $"
 #endif
 
 # include  "compile.h"
 # include  "functor.h"
 # include  "udp.h" 
+# include  "memory.h" 
 # include  "symbols.h"
 # include  "codes.h"
 # include  "schedule.h"
@@ -54,7 +55,10 @@ enum operand_e {
 	/* The operand is a pointer to code space */
       OA_CODE_PTR,
 	/* The operand is a variable or net pointer */
-      OA_FUNC_PTR
+      OA_FUNC_PTR,
+        /* The operand is a memory, with index ... */
+      OA_MEM_X3, /* ... hardwired index register 3  */
+      OA_MEM_I1  /* ... index register in bit1      */
 };
 
 struct opcode_table_s {
@@ -69,6 +73,7 @@ const static struct opcode_table_s opcode_table[] = {
       { "%add",    of_ADD,    3,  {OA_BIT1,     OA_BIT2,     OA_NUMBER} },
       { "%and",    of_AND,    3,  {OA_BIT1,     OA_BIT2,     OA_NUMBER} },
       { "%assign", of_ASSIGN, 3,  {OA_FUNC_PTR, OA_BIT1,     OA_BIT2} },
+      { "%assign/m",of_ASSIGN_MEM,3,{OA_MEM_X3, OA_BIT1,     OA_BIT2} },
       { "%cmp/s",  of_CMPS,   3,  {OA_BIT1,     OA_BIT2,     OA_NUMBER} },
       { "%cmp/u",  of_CMPU,   3,  {OA_BIT1,     OA_BIT2,     OA_NUMBER} },
       { "%cmp/x",  of_CMPX,   3,  {OA_BIT1,     OA_BIT2,     OA_NUMBER} },
@@ -76,17 +81,22 @@ const static struct opcode_table_s opcode_table[] = {
       { "%delay",  of_DELAY,  1,  {OA_NUMBER,   OA_NONE,     OA_NONE} },
       { "%end",    of_END,    0,  {OA_NONE,     OA_NONE,     OA_NONE} },
       { "%inv",    of_INV,    2,  {OA_BIT1,     OA_BIT2,     OA_NONE} },
+      { "%ix/add", of_IX_ADD, 2,  {OA_BIT1,     OA_NUMBER,   OA_NONE} },
+      { "%ix/load",of_IX_LOAD,3,  {OA_BIT1,     OA_BIT2,     OA_NUMBER} },
+      { "%ix/mul", of_IX_MUL, 2,  {OA_BIT1,     OA_NUMBER,   OA_NONE} },
       { "%jmp",    of_JMP,    1,  {OA_CODE_PTR, OA_NONE,     OA_NONE} },
       { "%jmp/0",  of_JMP0,   2,  {OA_CODE_PTR, OA_BIT1,     OA_NONE} },
       { "%jmp/0xz",of_JMP0XZ, 2,  {OA_CODE_PTR, OA_BIT1,     OA_NONE} },
       { "%jmp/1",  of_JMP1,   2,  {OA_CODE_PTR, OA_BIT1,     OA_NONE} },
       { "%join",   of_JOIN,   0,  {OA_NONE,     OA_NONE,     OA_NONE} },
       { "%load",   of_LOAD,   2,  {OA_BIT1,     OA_FUNC_PTR, OA_NONE} },
+      { "%load/m", of_LOAD_MEM,2, {OA_BIT2,     OA_MEM_I1,   OA_NONE} },
       { "%mov",    of_MOV,    3,  {OA_BIT1,     OA_BIT2,     OA_NUMBER} },
       { "%noop",   of_NOOP,   0,  {OA_NONE,     OA_NONE,     OA_NONE} },
       { "%nor/r",  of_NORR,   3,  {OA_BIT1,     OA_BIT2,     OA_NUMBER} },
       { "%or",     of_OR,     3,  {OA_BIT1,     OA_BIT2,     OA_NUMBER} },
       { "%set",    of_SET,    2,  {OA_FUNC_PTR, OA_BIT1,     OA_NONE} },
+      { "%set/m",  of_SET_MEM,2,  {OA_MEM_I1,   OA_BIT1,     OA_NONE} },
       { "%wait",   of_WAIT,   1,  {OA_FUNC_PTR, OA_NONE,     OA_NONE} },
       { "%xnor",   of_XNOR,   3,  {OA_BIT1,     OA_BIT2,     OA_NUMBER} },
       { "%xor",    of_XOR,    3,  {OA_BIT1,     OA_BIT2,     OA_NUMBER} },
@@ -94,6 +104,9 @@ const static struct opcode_table_s opcode_table[] = {
 };
 
 static unsigned opcode_count = 0;
+//static const unsigned opcode_count 
+//                  = sizeof(opcode_table)/sizeof(*opcode_table) - 1; 
+// No?
 
 static int opcode_compare(const void*k, const void*r)
 {
@@ -406,6 +419,60 @@ void compile_udp_functor(char*label, char*type,
 }
 
 
+void compile_memory(char *label, char *name, int msb, int lsb,
+		    unsigned idxs, long *idx)
+{
+  vvp_memory_t mem = memory_create(label);
+  free(label);
+  memory_new(mem, name, lsb, msb, idxs, idx);
+}
+
+void compile_memory_port(char *label, char *memid, 
+			 unsigned msb, unsigned lsb,
+			 unsigned argc, struct symb_s *argv)
+{
+  vvp_memory_t mem = memory_find(memid);
+  free(memid);
+  assert(mem);
+
+  // These is not a Verilog bit range. 
+  // These is a data port bit range. 
+  assert (lsb >= 0  &&  lsb<=msb);
+  assert (msb < memory_data_width(mem));
+  unsigned nbits = msb-lsb+1;
+
+  unsigned awidth = memory_addr_width(mem);
+  unsigned nfun = (awidth + 3)/4;
+  if (nfun < nbits)
+    nfun = nbits;
+      
+  vvp_ipoint_t ix = functor_allocate(nfun);
+
+  assert(argc == awidth);
+  define_functor_symbol(label, ix);
+  free(label);
+
+  inputs_connect(ix, argc, argv);
+
+  memory_port_new(mem, ix, nbits, lsb);
+}
+
+void compile_memory_init(char *memid, unsigned i, unsigned char val)
+{
+  static vvp_memory_t mem = 0x0;
+  static unsigned idx;
+  if (memid)
+    {
+      mem = memory_find(memid);
+      free(memid);
+      idx = i/4;
+    }
+  assert(mem);
+  memory_init_nibble(mem, idx, val);
+  idx++;
+}
+
+
 void compile_event(char*label, char*type,
 		   unsigned argc, struct symb_s*argv)
 {
@@ -625,6 +692,40 @@ void compile_code(char*label, char*mnem, comp_operands_t opa)
 		  code->number = opa->argv[idx].numb;
 		  break;
 
+        	case OA_MEM_I1:
+	        case OA_MEM_X3:
+		  if (opa->argv[idx].ltype != L_SYMB) {
+			yyerror("operand format");
+			break;
+		  }
+
+		  code->mem = memory_find(opa->argv[idx].symb.text);
+		  if (code->mem == 0) {
+			yyerror("functor undefined");
+			break;
+		  }
+
+		  if (opa->argv[idx].symb.idx >= 4) {
+		        yyerror("index operand out of range (0..3)");
+		        break;
+		  }
+
+		  switch(op->argt[idx]) {
+		      case OA_MEM_I1:
+		        code->bit_idx1 = (unsigned short) 
+			  opa->argv[idx].symb.idx;
+		        break;
+		      case OA_MEM_X3:
+		        if (opa->argv[idx].symb.idx != 3)
+			      yyerror("index operand must be 3");
+			break;
+		      default:
+			break;
+		  }
+
+		  free(opa->argv[idx].symb.text);
+		  break;
+
 	    }
       }
 
@@ -963,6 +1064,9 @@ void compile_dump(FILE*fd)
 
 /*
  * $Log: compile.cc,v $
+ * Revision 1.48  2001/05/01 01:09:39  steve
+ *  Add support for memory objects. (Stephan Boettcher)
+ *
  * Revision 1.47  2001/04/30 03:53:19  steve
  *  Fix up functor inputs to support C<?> values.
  *
diff --git a/vvp/compile.h b/vvp/compile.h
index 8cf97d5de..326475f71 100644
--- a/vvp/compile.h
+++ b/vvp/compile.h
@@ -19,7 +19,7 @@
  *    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
  */
 #if !defined(WINNT)
-#ident "$Id: compile.h,v 1.18 2001/04/25 04:35:05 steve Exp $"
+#ident "$Id: compile.h,v 1.19 2001/05/01 01:09:39 steve Exp $"
 #endif
 
 # include  <stdio.h>
@@ -83,6 +83,20 @@ extern void compile_udp_functor(char*label, char*type,
 
 extern char **compile_udp_table(char **table, char *row);
 
+/*
+ * Memory Instances, Ports, and Initialization
+ */
+
+extern void compile_memory(char *label, char *name, int lsb, int msb,
+			   unsigned idxs, long *idx);
+
+extern void compile_memory_port(char *label, char *memid, 
+				unsigned lsb, unsigned msb,
+				unsigned argc, struct symb_s *argv);
+
+extern void compile_memory_init(char *memid, unsigned idx, unsigned char val);
+
+
 /*
  * The compile_event function takes the parts of the event statement
  * and makes the various objects needed to simulate it. This includes
@@ -160,6 +174,9 @@ extern void compile_dump(FILE*fd);
 
 /*
  * $Log: compile.h,v $
+ * Revision 1.19  2001/05/01 01:09:39  steve
+ *  Add support for memory objects. (Stephan Boettcher)
+ *
  * Revision 1.18  2001/04/25 04:35:05  steve
  *  Document the UDP implementation.
  *
diff --git a/vvp/lexor.lex b/vvp/lexor.lex
index 4091118a5..594c39efd 100644
--- a/vvp/lexor.lex
+++ b/vvp/lexor.lex
@@ -19,7 +19,7 @@
  *    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
  */
 #if !defined(WINNT)
-#ident "$Id: lexor.lex,v 1.14 2001/04/24 02:23:59 steve Exp $"
+#ident "$Id: lexor.lex,v 1.15 2001/05/01 01:09:39 steve Exp $"
 #endif
 
 # include  "parse_misc.h"
@@ -77,7 +77,9 @@
 ".udp"         { return K_UDP; }
 ".udp/c"(omb)? { return K_UDP_C; }
 ".udp/s"(equ)? { return K_UDP_S; }
-
+".mem" 	       { return K_MEM; }
+".mem/p"(ort)? { return K_MEM_P; }
+".mem/i"(nit)? { return K_MEM_I; }
 
   /* instructions start with a % character. The compiler decides what
      kind of instruction this really is. The few exceptions (that have
@@ -130,6 +132,9 @@ int yywrap()
 
 /*
  * $Log: lexor.lex,v $
+ * Revision 1.15  2001/05/01 01:09:39  steve
+ *  Add support for memory objects. (Stephan Boettcher)
+ *
  * Revision 1.14  2001/04/24 02:23:59  steve
  *  Support for UDP devices in VVP (Stephen Boettcher)
  *
diff --git a/vvp/memory.cc b/vvp/memory.cc
new file mode 100644
index 000000000..14462f703
--- /dev/null
+++ b/vvp/memory.cc
@@ -0,0 +1,422 @@
+/*
+ * Copyright (c) 2000 Stephen Williams (steve@icarus.com)
+ * Copyright (c) 2001 Stephan Boettcher <stephan@nevis.columbia.edu>
+ *
+ *    This source code is free software; you can redistribute it
+ *    and/or modify it in source code form under the terms of the GNU
+ *    General Public License as published by the Free Software
+ *    Foundation; either version 2 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
+ *    MERCHANTABILITY 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; if not, write to the Free Software
+ *    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
+ */
+#if !defined(WINNT)
+#ident "$Id: memory.cc,v 1.1 2001/05/01 01:09:39 steve Exp $"
+#endif
+
+#include "memory.h"
+#include "symbols.h"
+#include "schedule.h"
+#include <assert.h>
+#include <malloc.h>
+#include <string.h>
+
+
+typedef struct vvp_memory_port_s *vvp_memory_port_t;
+
+struct vvp_memory_s
+{
+  char *name;                     // VPI scope.name
+
+  // Address port properties:
+  unsigned size;                  // total number of data words
+  unsigned awidth;                // total number of address bits
+  unsigned a_idxs;                // number of address indices
+  vvp_memory_index_t a_idx;       // vector of address indices
+
+  // Data port properties:
+  unsigned width;                 // number of data bits
+  unsigned fwidth;                // number of bytes (4bits) per data word
+  int msb, lsb;                   // Most/Least Significant data bit (VPI)
+
+  vvp_memory_bits_t bits;         // Array of bits
+  vvp_memory_port_t addr_root;    // Port list root;
+};
+
+unsigned memory_data_width(vvp_memory_t mem)
+{
+  return mem->width;
+}
+
+unsigned memory_addr_width(vvp_memory_t mem)
+{
+  return mem->awidth;
+}
+
+#define VVP_MEMORY_NO_ADDR ((int)0x80000000)
+
+struct vvp_memory_index_s
+{
+  int first;       // first memory address
+  unsigned size;   // number of valid addresses
+  unsigned awidth; // width of address port
+};
+
+struct vvp_memory_port_s : public vvp_fobj_s
+{
+  vvp_memory_t mem;
+  vvp_ipoint_t ix;
+  vvp_memory_port_t next;
+  int cur_addr;
+  vvp_memory_bits_t cur_bits;
+  int bitoff;
+  int nbits;
+};
+
+// Compilation
+
+static symbol_table_t memory_table;
+
+vvp_memory_t memory_find(char *label)
+{
+  symbol_value_t v = sym_get_value(memory_table, label);
+  return (vvp_memory_t)v.ptr;
+}
+
+vvp_memory_t memory_create(char *label)
+{
+  if (!memory_table)
+    memory_table = new_symbol_table();
+  
+  assert(!memory_find(label));
+
+  vvp_memory_t mem = new struct vvp_memory_s;
+  
+  symbol_value_t v;
+  v.ptr = mem;
+  sym_set_value(memory_table, label, v);
+
+  return mem;
+}
+
+void memory_new(vvp_memory_t mem, char *name, int msb, int lsb,
+		unsigned idxs, long *idx)
+{
+  mem->width = msb > lsb ? msb-lsb+1 : lsb-msb+1;
+  mem->msb = msb;
+  mem->lsb = lsb;
+  mem->fwidth = (mem->width+3)/4;
+
+  assert((idxs&1) == 0);
+  mem->a_idxs = idxs/2;
+  mem->a_idx = (vvp_memory_index_t)
+    malloc(mem->a_idxs*sizeof(struct vvp_memory_index_s));
+  assert(mem->a_idxs);
+
+  mem->size = 1;
+  mem->awidth = 0;
+  for (unsigned i=0; i < mem->a_idxs; i++)
+    {
+      vvp_memory_index_t x = mem->a_idx + i;
+      int msw = *(idx++);
+      int lsw = *(idx++);
+      x->size  = msw - lsw + 1;
+      x->first = lsw;
+      int m = lsw ^ msw;
+      x->awidth = 0;
+      if (m < 0)
+	{
+	  if (lsw < 0)
+	    m = ~lsw | msw;
+	  else
+	    m = lsw | ~msw;
+	  x->awidth++;
+	}
+      for (int c=1; c<m; c<<=1) 
+	x->awidth ++;
+      mem->awidth += x->awidth;
+      mem->size *= x->size;
+    }
+
+  mem->bits  = (vvp_memory_bits_t) malloc(mem->size * mem->fwidth);
+  assert(mem->bits);
+  memset(mem->bits, 0xaa, mem->size * mem->fwidth);
+
+  mem->addr_root = 0x0;
+  mem->name = name;
+}
+
+static void port_functor_set(vvp_ipoint_t i, functor_t f, bool push);
+
+void memory_port_new(vvp_memory_t mem, vvp_ipoint_t ix, 
+		     unsigned nbits, unsigned bitoff)
+{
+  vvp_memory_port_t a = new struct vvp_memory_port_s;
+  a->set = port_functor_set;  
+  a->get = 0x0;
+  
+  a->mem = mem;
+  a->ix = ix;
+  a->nbits = nbits;
+  a->bitoff = bitoff;
+  
+  a->next = mem->addr_root;
+  a->mem->addr_root = a;
+  
+  unsigned nfun = (a->mem->awidth+3)/4;
+  if (nfun < nbits)
+    nfun = nbits;
+
+  for (unsigned idx = 0;  idx < nfun;  idx ++) 
+    {
+      vvp_ipoint_t ifdx = ipoint_index(ix, idx);
+      functor_t iobj = functor_index(ifdx);
+	  
+      iobj->ival = 0xaa;
+      iobj->oval = 0x02;
+      iobj->mode = M42;
+      iobj->out = 0;
+      iobj->obj = a;
+    }
+
+  a->cur_addr = VVP_MEMORY_NO_ADDR;
+  a->cur_bits = 0x0;
+}
+
+void memory_init_nibble(vvp_memory_t mem, unsigned idx, unsigned char val)
+{
+  assert(idx < mem->size*mem->fwidth);
+  mem->bits[idx] = val;
+}
+
+// Utilities
+
+inline static 
+vvp_memory_bits_t get_word(vvp_memory_t mem, int addr)
+{
+  if (addr == VVP_MEMORY_NO_ADDR)
+    return 0x0;
+
+  // Compute the word index into the bits array.
+  unsigned waddr = 0;
+  for (unsigned i = 0; i<mem->a_idxs; i++)
+    {
+      vvp_memory_index_t x = mem->a_idx + i;
+      unsigned iwaddr = (addr - x->first) & ((1<<x->awidth) - 1);
+      waddr *= x->size;
+      // This fails for negative 
+      if (iwaddr >= x->size)
+	return 0x0;
+      waddr += iwaddr;
+      addr >>= x->awidth;
+    }
+
+  assert(waddr < mem->size);
+
+  return mem->bits + waddr*mem->fwidth;
+}
+
+inline static
+bool set_bit(vvp_memory_bits_t bits, int bit, unsigned char val)
+{
+  int ix =    bit/4;
+  int ip = 2*(bit%4);
+  bool r = ((bits[ix] >> ip) & 3) != val;
+  bits[ix] = (bits[ix] &~ (3<<ip)) | ((val&3) << ip);
+  return r;
+}
+
+inline static
+unsigned char get_nibble(vvp_memory_bits_t bits, int bit)
+{
+  if (!bits)
+    return 0xaa;
+  int ix = bit/4;
+  return bits[ix];
+}
+
+inline static
+unsigned char get_bit(vvp_memory_bits_t bits, int bit)
+{
+  return (get_nibble(bits, bit) >> (2*(bit&3))) & 3;
+}
+
+inline static 
+unsigned char functor_get_inputs(vvp_ipoint_t ip)
+{
+  functor_t fp = functor_index(ip);
+  assert(fp);
+  return fp->ival;
+}
+
+inline static 
+unsigned char functor_get_input(vvp_ipoint_t ip)
+{
+  unsigned char bits = functor_get_inputs(ip);
+  return (bits >> (2*ipoint_port(ip))) & 3;
+}
+
+static void update_addr(vvp_memory_port_t addr);
+
+static 
+bool update_addr_bit(vvp_memory_port_t addr, vvp_ipoint_t ip)
+{
+  unsigned abit = ip - addr->ix;
+
+  assert(abit >= 0  &&  abit < addr->mem->awidth);
+
+  int old = addr->cur_addr;
+
+  int abval = functor_get_input(ip);
+  if (abval>1)
+    addr->cur_addr = VVP_MEMORY_NO_ADDR;
+  else if (addr->cur_addr == VVP_MEMORY_NO_ADDR)
+    update_addr(addr);
+  else if (abval)
+    addr->cur_addr |=  (1<<abit);
+  else
+    addr->cur_addr &=~ (1<<abit);
+
+  bool r = addr->cur_addr != old;
+  if (r)
+    addr->cur_bits = get_word(addr->mem, addr->cur_addr);
+
+  return r;
+}
+
+static
+void update_addr(vvp_memory_port_t addr)
+{
+  addr->cur_addr = 2;
+  for (unsigned i=0; i < addr->mem->awidth; i++)
+    {
+      update_addr_bit(addr, addr->ix+i);
+      if (addr->cur_addr == VVP_MEMORY_NO_ADDR)
+	break;
+    }
+}
+
+inline static
+void update_data(vvp_memory_port_t data, 
+		 vvp_memory_bits_t bits)
+{
+  assert(data);
+  for (int i=0; i < data->nbits; i++)
+    {
+      vvp_ipoint_t dx = ipoint_index(data->ix, i);
+      functor_t df = functor_index(dx);
+      unsigned char out = get_bit(bits, i + data->bitoff);
+      if (out != df->oval)
+	{
+	  df->oval = out;
+	  functor_propagate(dx);
+	}
+    }
+}
+
+static
+void port_functor_set(vvp_ipoint_t i, functor_t f, bool push)
+{
+  vvp_memory_port_t addr = (vvp_memory_port_t)f->obj;
+  if (update_addr_bit(addr, i))
+    update_data(addr, addr->cur_bits);
+  return;
+}
+
+static
+void update_data_ports(vvp_memory_t mem, int addr, int bit, 
+		       unsigned char val)
+{
+  vvp_memory_port_t a = mem->addr_root;
+  while (a)
+    {
+      if (addr == a->cur_addr)
+	{
+	  vvp_memory_port_t d = a; // historic
+	  int i = bit - d->bitoff;
+	  if (i >= 0  &&  i < d->nbits)
+	    {
+	      vvp_ipoint_t ix = ipoint_index(d->ix, i);
+	      functor_t df = functor_index(ix);
+	      if (df->oval != val)
+		{
+		  df->oval = val;
+		  functor_propagate(ix);
+		}
+	    }
+	}
+      a = a->next;
+    }
+}
+
+
+// %set/mem
+
+void memory_set(vvp_memory_t mem, unsigned idx, unsigned char val)
+{
+  if (!set_bit(mem->bits, idx, val))
+    return;
+
+  update_data_ports(mem, idx/(4*mem->fwidth), idx%(4*mem->fwidth), val);
+}
+
+// %load/mem
+
+unsigned memory_get(vvp_memory_t mem, unsigned idx)
+{
+  return get_bit(mem->bits, idx);
+}
+
+// %assign/mem event scheduling
+
+struct mem_assign_s: public vvp_gen_event_s
+{
+  union 
+  {
+    vvp_memory_t mem;
+    struct mem_assign_s *next;
+  };
+  unsigned long idx;
+};
+
+static struct mem_assign_s* ma_free_list = 0;
+
+inline static struct mem_assign_s* ma_alloc()
+{
+  struct mem_assign_s* cur = ma_free_list;
+  if (!cur)
+    cur = (struct mem_assign_s*) malloc(sizeof(struct mem_assign_s));
+  else
+    ma_free_list = cur->next;
+  return cur;
+}
+
+inline static void ma_free(struct mem_assign_s* cur)
+{
+  cur->next = ma_free_list;
+  ma_free_list = cur;
+}
+
+static void run_mem_assign(vvp_gen_event_t obj, unsigned char val)
+{
+  struct mem_assign_s *e = (struct mem_assign_s *) obj;
+  memory_set(e->mem, e->idx, val);
+  ma_free(e);
+}
+
+void schedule_memory(vvp_memory_t mem, unsigned idx, 
+		     unsigned char val, unsigned delay)
+{
+  struct mem_assign_s *e = ma_alloc();
+  e->run = run_mem_assign;
+  e->mem = mem;
+  e->idx = idx;
+  schedule_generic(e, val, delay);
+}
diff --git a/vvp/memory.h b/vvp/memory.h
new file mode 100644
index 000000000..ddf872efa
--- /dev/null
+++ b/vvp/memory.h
@@ -0,0 +1,57 @@
+#ifndef __memory_H                                      // -*- c++ -*- 
+#define __memory_H
+/*
+ * Copyright (c) 2001 Stephen Williams (steve@icarus.com)
+ * Copyright (c) 2001 Stephan Boettcher <stephan@nevis.columbia.edu>
+ *
+ *    This source code is free software; you can redistribute it
+ *    and/or modify it in source code form under the terms of the GNU
+ *    General Public License as published by the Free Software
+ *    Foundation; either version 2 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
+ *    MERCHANTABILITY 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; if not, write to the Free Software
+ *    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
+ */
+#if !defined(WINNT)
+#ident "$Id: memory.h,v 1.1 2001/05/01 01:09:39 steve Exp $"
+#endif
+
+#include "pointers.h"
+#include "functor.h"
+
+typedef struct vvp_memory_s *vvp_memory_t;
+typedef unsigned char *vvp_memory_bits_t;
+typedef struct vvp_memory_index_s *vvp_memory_index_t;
+
+void memory_new(vvp_memory_t mem, char *name, int lsb, int msb,
+		unsigned idxs, long *idx);
+void memory_port_new(vvp_memory_t mem, vvp_ipoint_t ix, 
+		     unsigned nbits, unsigned bitoff);
+void memory_init_nibble(vvp_memory_t mem, unsigned idx, unsigned char val);
+
+void memory_set(vvp_memory_t mem, unsigned idx, unsigned char val);
+unsigned memory_get(vvp_memory_t mem, unsigned idx);
+void schedule_memory(vvp_memory_t mem, unsigned idx, 
+		     unsigned char val, unsigned delay);
+
+unsigned memory_addr_width(vvp_memory_t mem);
+unsigned memory_data_width(vvp_memory_t mem);
+
+vvp_memory_t memory_find(char *label);
+vvp_memory_t memory_create(char *label);
+
+/*
+ * $Log: memory.h,v $
+ * Revision 1.1  2001/05/01 01:09:39  steve
+ *  Add support for memory objects. (Stephan Boettcher)
+ *
+ */
+
+#endif
diff --git a/vvp/parse.y b/vvp/parse.y
index fceed9d36..d42c1f297 100644
--- a/vvp/parse.y
+++ b/vvp/parse.y
@@ -19,7 +19,7 @@
  *    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
  */
 #if !defined(WINNT)
-#ident "$Id: parse.y,v 1.22 2001/04/24 02:23:59 steve Exp $"
+#ident "$Id: parse.y,v 1.23 2001/05/01 01:09:39 steve Exp $"
 #endif
 
 # include  "parse_misc.h"
@@ -54,6 +54,7 @@ extern FILE*yyin;
 
 %token K_EVENT K_EVENT_OR K_FUNCTOR K_NET K_NET_S K_SCOPE K_THREAD
 %token K_UDP K_UDP_C K_UDP_S
+%token K_MEM K_MEM_P K_MEM_I
 %token K_VAR K_VAR_S K_vpi_call K_disable K_fork
 %token K_vpi_module
 
@@ -65,7 +66,7 @@ extern FILE*yyin;
 %token <vect> T_VECTOR
 
 %type <symb>  symbol symbol_opt
-%type <symbv> symbols symbols_net
+%type <symbv> symbols symbols_net numbers
 %type <text> label_opt
 %type <opa>  operand operands operands_opt
 %type <table> udp_table
@@ -128,6 +129,17 @@ statement
 		{ compile_udp_functor($1, $3, $5.cnt, $5.vect); }
 
 
+  /* Memory.  Definition, port, initialization */
+
+        | T_LABEL K_MEM T_STRING ',' T_NUMBER ',' T_NUMBER ',' numbers ';'
+		{ compile_memory($1, $3, $5, $7, $9.cnt, $9.nvec); }
+
+        | T_LABEL K_MEM_P T_SYMBOL ',' T_NUMBER ',' T_NUMBER ',' symbols ';'
+		{ compile_memory_port($1, $3, $5, $7, $9.cnt, $9.vect); }
+
+	| mem_init_stmt
+
+
   /* Event statements take a label, a type (the first T_SYMBOL) and a
      list of inputs. If the type is instead a string, then we have a
      named event instead. */
@@ -323,6 +335,21 @@ symbols
 	;
 
 
+numbers
+	: T_NUMBER
+		{ struct numbv_s obj;
+		  numbv_init(&obj);
+		  numbv_add(&obj, $1);
+		  $$ = obj;
+		}
+	| numbers ',' T_NUMBER
+		{ struct numbv_s obj = $1;
+		  numbv_add(&obj, $3);
+		  $$ = obj;
+		}
+	;
+
+
 symbols_net
 	: symbol_opt
 		{ struct symbv_s obj;
@@ -358,6 +385,7 @@ symbol_opt
 		{ $$.text = 0;
 		  $$.idx = 0;
 		}
+	;
 
 udp_table
 	: T_STRING
@@ -366,6 +394,18 @@ udp_table
 		{ $$ = compile_udp_table($1,  $3); }
 	;
 
+mem_init_stmt
+	: K_MEM_I symbol ',' T_NUMBER o_komma 
+		{ compile_memory_init($2.text, $2.idx, $4); }
+        | mem_init_stmt T_NUMBER o_komma 
+		{ compile_memory_init(0x0,     0,      $2); }
+	;
+
+o_komma
+	: /* empty */
+	| ','
+	;
+
 %%
 
 int compile_design(const char*path)
@@ -385,6 +425,9 @@ int compile_design(const char*path)
 
 /*
  * $Log: parse.y,v $
+ * Revision 1.23  2001/05/01 01:09:39  steve
+ *  Add support for memory objects. (Stephan Boettcher)
+ *
  * Revision 1.22  2001/04/24 02:23:59  steve
  *  Support for UDP devices in VVP (Stephen Boettcher)
  *
diff --git a/vvp/parse_misc.cc b/vvp/parse_misc.cc
index 5198e18f9..dcc6ffd82 100644
--- a/vvp/parse_misc.cc
+++ b/vvp/parse_misc.cc
@@ -17,7 +17,7 @@
  *    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
  */
 #if !defined(WINNT)
-#ident "$Id: parse_misc.cc,v 1.3 2001/03/20 06:16:24 steve Exp $"
+#ident "$Id: parse_misc.cc,v 1.4 2001/05/01 01:09:39 steve Exp $"
 #endif
 
 # include  "parse_misc.h"
@@ -46,6 +46,13 @@ void symbv_add(struct symbv_s*obj, struct symb_s item)
       obj->cnt += 1;
 }
 
+void numbv_add(struct numbv_s*obj, long item)
+{
+      obj->nvec = (long*) realloc(obj->nvec, (obj->cnt+1) * sizeof(long));
+      obj->nvec[obj->cnt] = item;
+      obj->cnt += 1;
+}
+
 void argv_init(struct argv_s*obj)
 {
       obj->argc = 0;
@@ -62,6 +69,9 @@ void argv_add(struct argv_s*obj, vpiHandle item)
 
 /*
  * $Log: parse_misc.cc,v $
+ * Revision 1.4  2001/05/01 01:09:39  steve
+ *  Add support for memory objects. (Stephan Boettcher)
+ *
  * Revision 1.3  2001/03/20 06:16:24  steve
  *  Add support for variable vectors.
  *
diff --git a/vvp/parse_misc.h b/vvp/parse_misc.h
index 1cdc528a1..bfac815aa 100644
--- a/vvp/parse_misc.h
+++ b/vvp/parse_misc.h
@@ -19,7 +19,7 @@
  *    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
  */
 #if !defined(WINNT)
-#ident "$Id: parse_misc.h,v 1.3 2001/03/20 06:16:24 steve Exp $"
+#ident "$Id: parse_misc.h,v 1.4 2001/05/01 01:09:39 steve Exp $"
 #endif
 
 
@@ -50,12 +50,19 @@ struct symb_s {
 
 struct symbv_s {
       unsigned cnt;
-      struct symb_s*vect;
+      union {
+            struct symb_s*vect;
+	    long*nvec;
+      };
 };
 
 extern void symbv_init(struct symbv_s*obj);
 extern void symbv_add(struct symbv_s*obj, struct symb_s item);
 
+#define numbv_s    symbv_s
+#define numbv_init symbv_init
+extern void numbv_add(struct numbv_s*obj, long item);
+
 
 
 struct argv_s {
@@ -68,6 +75,9 @@ extern void argv_add(struct argv_s*obj, vpiHandle);
 
 /*
  * $Log: parse_misc.h,v $
+ * Revision 1.4  2001/05/01 01:09:39  steve
+ *  Add support for memory objects. (Stephan Boettcher)
+ *
  * Revision 1.3  2001/03/20 06:16:24  steve
  *  Add support for variable vectors.
  *
diff --git a/vvp/schedule.cc b/vvp/schedule.cc
index 2aaff90d5..74586812d 100644
--- a/vvp/schedule.cc
+++ b/vvp/schedule.cc
@@ -17,11 +17,12 @@
  *    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
  */
 #if !defined(WINNT)
-#ident "$Id: schedule.cc,v 1.6 2001/04/21 00:34:39 steve Exp $"
+#ident "$Id: schedule.cc,v 1.7 2001/05/01 01:09:39 steve Exp $"
 #endif
 
 # include  "schedule.h"
 # include  "functor.h"
+# include  "memory.h"
 # include  "vthread.h"
 # include  <malloc.h>
 # include  <assert.h>
@@ -32,6 +33,7 @@ struct event_s {
       union {
 	    vthread_t thr;
 	    vvp_ipoint_t fun;
+            vvp_gen_event_t obj;
       };
       unsigned val  :2;
       unsigned type :2;
@@ -39,11 +41,40 @@ struct event_s {
       struct event_s*next;
       struct event_s*last;
 };
-const unsigned TYPE_NOOP   = 0;
+const unsigned TYPE_GEN    = 0;
 const unsigned TYPE_THREAD = 1;
 const unsigned TYPE_PROP   = 2;
 const unsigned TYPE_ASSIGN = 3;
 
+/*
+** These event_s will be required a lot, at high frequency.
+** Once allocated, we never free them, but stash them away for next time. 
+*/
+
+static struct event_s* free_list = 0;
+
+inline static struct event_s* e_alloc()
+{
+  struct event_s* cur = free_list;
+  if (!cur)
+    {
+      cur = (struct event_s*) malloc(sizeof(struct event_s));
+      // cur = (struct event_s*) calloc(1, sizeof(struct event_s));
+    }
+  else
+    {
+      free_list = cur->next;
+      // memset(cur, 0, sizeof(struct event_s));
+    }
+  return cur;
+}
+
+inline static void e_free(struct event_s* cur)
+{
+  cur->next = free_list;
+  free_list = cur;
+}
+
 /*
  * This is the head of the list of pending events.
  */
@@ -114,8 +145,7 @@ static void schedule_event_(struct event_s*cur)
 
 void schedule_vthread(vthread_t thr, unsigned delay)
 {
-      struct event_s*cur = (struct event_s*)
-	    calloc(1, sizeof(struct event_s));
+      struct event_s*cur = e_alloc();
 
       cur->delay = delay;
       cur->thr = thr;
@@ -127,8 +157,7 @@ void schedule_vthread(vthread_t thr, unsigned delay)
 
 void schedule_functor(vvp_ipoint_t fun, unsigned delay)
 {
-      struct event_s*cur = (struct event_s*)
-	    calloc(1, sizeof(struct event_s));
+      struct event_s*cur = e_alloc();
 
       cur->delay = delay;
       cur->fun = fun;
@@ -139,8 +168,7 @@ void schedule_functor(vvp_ipoint_t fun, unsigned delay)
 
 void schedule_assign(vvp_ipoint_t fun, unsigned char val, unsigned delay)
 {
-      struct event_s*cur = (struct event_s*)
-	    calloc(1, sizeof(struct event_s));
+      struct event_s*cur = e_alloc();
 
       cur->delay = delay;
       cur->fun = fun;
@@ -148,7 +176,18 @@ void schedule_assign(vvp_ipoint_t fun, unsigned char val, unsigned delay)
       cur->type= TYPE_ASSIGN;
 
       schedule_event_(cur);
+}
 
+void schedule_generic(vvp_gen_event_t obj, unsigned char val, unsigned delay)
+{
+      struct event_s*cur = e_alloc();
+
+      cur->delay = delay;
+      cur->obj = obj;
+      cur->val = val;
+      cur->type= TYPE_GEN;
+
+      schedule_event_(cur);
 }
 
 static unsigned long schedule_time;
@@ -188,14 +227,22 @@ void schedule_simulate(void)
 		  functor_set(cur->fun, cur->val);
 		  break;
 
+		case TYPE_GEN:
+		  if (cur->obj && cur->obj->run)
+		    cur->obj->run(cur->obj, cur->val);
+		  break;
+
 	    }
 
-	    free(cur);
+	    e_free(cur);
       }
 }
 
 /*
  * $Log: schedule.cc,v $
+ * Revision 1.7  2001/05/01 01:09:39  steve
+ *  Add support for memory objects. (Stephan Boettcher)
+ *
  * Revision 1.6  2001/04/21 00:34:39  steve
  *  Working %disable and reap handling references from scheduler.
  *
diff --git a/vvp/schedule.h b/vvp/schedule.h
index 065ca847f..43ca23fa6 100644
--- a/vvp/schedule.h
+++ b/vvp/schedule.h
@@ -19,7 +19,7 @@
  *    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
  */
 #if !defined(WINNT)
-#ident "$Id: schedule.h,v 1.4 2001/03/31 19:00:43 steve Exp $"
+#ident "$Id: schedule.h,v 1.5 2001/05/01 01:09:39 steve Exp $"
 #endif
 
 # include  "vthread.h"
@@ -46,6 +46,20 @@ extern void schedule_functor(vvp_ipoint_t fun, unsigned delay);
 extern void schedule_assign(vvp_ipoint_t fun, unsigned char val,
 			    unsigned delay);
 
+/*
+ * Create an abstract event.
+ */
+
+typedef struct vvp_gen_event_s *vvp_gen_event_t;
+
+extern void schedule_generic(vvp_gen_event_t obj, unsigned char val,
+			     unsigned delay);
+
+struct vvp_gen_event_s
+{
+  void (*run)(vvp_gen_event_t obj, unsigned char val);
+};
+
 /*
  * This runs the simulator. It runs until all the functors run out or
  * the simulation is otherwise finished.
@@ -74,6 +88,9 @@ extern bool schedule_finished(void);
 
 /*
  * $Log: schedule.h,v $
+ * Revision 1.5  2001/05/01 01:09:39  steve
+ *  Add support for memory objects. (Stephan Boettcher)
+ *
  * Revision 1.4  2001/03/31 19:00:43  steve
  *  Add VPI support for the simulation time.
  *
diff --git a/vvp/vthread.cc b/vvp/vthread.cc
index ca430e439..85fd5d419 100644
--- a/vvp/vthread.cc
+++ b/vvp/vthread.cc
@@ -17,7 +17,7 @@
  *    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
  */
 #if !defined(WINNT)
-#ident "$Id: vthread.cc,v 1.29 2001/04/21 00:34:39 steve Exp $"
+#ident "$Id: vthread.cc,v 1.30 2001/05/01 01:09:39 steve Exp $"
 #endif
 
 # include  "vthread.h"
@@ -82,6 +82,7 @@ struct vthread_s {
       unsigned long pc;
 	/* These hold the private thread bits. */
       unsigned char *bits;
+      long index[4];
       unsigned nbits :16;
 	/* My parent sets this when it wants me to wake it up. */
       unsigned schedule_parent_on_end :1;
@@ -328,6 +329,13 @@ bool of_ASSIGN(vthread_t thr, vvp_code_t cp)
       return true;
 }
 
+bool of_ASSIGN_MEM(vthread_t thr, vvp_code_t cp)
+{
+      unsigned char bit_val = thr_get_bit(thr, cp->bit_idx2);
+      schedule_memory(cp->mem, thr->index[3], bit_val, cp->bit_idx1);
+      return true;
+}
+
 bool of_CMPS(vthread_t thr, vvp_code_t cp)
 {
       unsigned eq = 1;
@@ -615,6 +623,32 @@ bool of_INV(vthread_t thr, vvp_code_t cp)
       return true;
 }
 
+
+/*
+** Index registers, signed arithmetic.
+*/
+
+bool of_IX_ADD(vthread_t thr, vvp_code_t cp)
+{
+  int number = (int)cp->number; // signed
+  thr->index[cp->bit_idx1 & 3] += number;
+  return true;
+}
+
+bool of_IX_MUL(vthread_t thr, vvp_code_t cp)
+{
+  int number = (int)cp->number; // signed
+  thr->index[cp->bit_idx1 & 3] *= number;
+  return true;
+}
+
+bool of_IX_LOAD(vthread_t thr, vvp_code_t cp)
+{
+  // TODO
+  return true;
+}
+
+
 /*
  * The various JMP instruction work simply by pulling the new program
  * counter from the instruction and resuming. If the jump is
@@ -676,6 +710,15 @@ bool of_LOAD(vthread_t thr, vvp_code_t cp)
       return true;
 }
 
+bool of_LOAD_MEM(vthread_t thr, vvp_code_t cp)
+{
+      assert(cp->bit_idx1 >= 4);
+      assert(cp->bit_idx2 < 4);
+      unsigned char val = memory_get(cp->mem, thr->index[cp->bit_idx1]);
+      thr_put_bit(thr, cp->bit_idx2, val);
+      return true;
+}
+
 bool of_MOV(vthread_t thr, vvp_code_t cp)
 {
       assert(cp->bit_idx1 >= 4);
@@ -763,6 +806,15 @@ bool of_SET(vthread_t thr, vvp_code_t cp)
       return true;
 }
 
+bool of_SET_MEM(vthread_t thr, vvp_code_t cp)
+{
+      assert(cp->bit_idx2 < 4);
+      unsigned char val = thr_get_bit(thr, cp->bit_idx2);
+      memory_set(cp->mem, thr->index[cp->bit_idx1], val);
+
+      return true;
+}
+
 bool of_VPI_CALL(vthread_t thr, vvp_code_t cp)
 {
 	// printf("thread %p: %%vpi_call\n", thr);
@@ -873,6 +925,9 @@ bool of_ZOMBIE(vthread_t thr, vvp_code_t)
 
 /*
  * $Log: vthread.cc,v $
+ * Revision 1.30  2001/05/01 01:09:39  steve
+ *  Add support for memory objects. (Stephan Boettcher)
+ *
  * Revision 1.29  2001/04/21 00:34:39  steve
  *  Working %disable and reap handling references from scheduler.
  *