Initial stacker checkin

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@10178 91177308-0d34-0410-b5e6-96231b3b80d8

6 files changed, 2417 insertions, 0 deletions

diff --git a/projects/Stacker/lib/compiler/Lexer.l b/projects/Stacker/lib/compiler/Lexer.l
new file mode 100644
index 0000000000..6087f883e5
--- /dev/null
+++ b/projects/Stacker/lib/compiler/Lexer.l
@@ -0,0 +1,234 @@
+/*===-- Lexer.l - Scanner for Stacker language -----------------*- C++ -*--===//
+// 
+//                     The LLVM Compiler Infrastructure
+//
+// This file was developed by Reid Spencer and donated to the LLVM research 
+// group and is distributed under the University of Illinois Open Source 
+// License. See LICENSE.TXT for details.
+// 
+//===----------------------------------------------------------------------===//
+//
+//  This file implements the flex scanner for Stacker languages files.
+//
+//===----------------------------------------------------------------------===*/
+
+%option prefix="Stacker"
+%option yylineno
+%option nostdinit
+%option never-interactive
+%option batch
+%option noyywrap
+%option nodefault
+%option 8bit
+%option outfile="Lexer.cpp"
+%option ecs
+%option noreject
+%option noyymore
+
+%{
+
+#include "StackerCompiler.h"
+#include "StackerParser.h"
+
+/* Conversion of text ints to binary */
+static uint64_t IntToVal(const char *Buffer) {
+  uint64_t Result = 0;
+  for (; *Buffer; Buffer++) {
+    uint64_t OldRes = Result;
+    Result *= 10;
+    Result += *Buffer-'0';
+    if (Result < OldRes)   // Uh, oh, overflow detected!!!
+      StackerCompiler::ThrowException("constant bigger than 64 bits detected!");
+  }
+  return Result;
+}
+
+/* Conversion of text hexadecimal ints to binary */
+static uint64_t HexIntToVal(const char *Buffer) {
+  uint64_t Result = 0;
+  for (; *Buffer; ++Buffer) {
+    uint64_t OldRes = Result;
+    Result *= 16;
+    char C = *Buffer;
+    if (C >= '0' && C <= '9')
+      Result += C-'0';
+    else if (C >= 'A' && C <= 'F')
+      Result += C-'A'+10;
+    else if (C >= 'a' && C <= 'f')
+      Result += C-'a'+10;
+
+    if (Result < OldRes)   // Uh, oh, overflow detected!!!
+      StackerCompiler::ThrowException("constant bigger than 64 bits detected!");
+  }
+  return Result;
+}
+
+#define YY_NEVER_INTERACTIVE 1
+%}
+
+/* Comments start with a ; and go till end of line */
+Comment1	[#].*$
+/* You can also embed them in ( ... ) */
+Comment2	\(.*\)
+/* We ignore white space */
+White		[ \t\n]
+
+/* jdentifiers start with a % sign */
+Identifier  	[A-Za-z][-A-Za-z0-9_]*
+
+/* Strings can contain any character except " and \ */
+String		\"[^\"]*\"
+
+/* Positive and negative integer constants*/
+PInteger	[+]?[0-9]+
+NInteger	-[0-9]+
+HexInteger 	0x[0-9A-Fa-f]+
+
+/* Special Characters - name them to avoid flex confusion */
+Semi 		[;]
+Colon 		[:]
+Less		\<
+More		\>
+LessEq		\<\=
+MoreEq		\>\=
+NotEq		\<\>
+Equal		\=
+Plus		\+
+Minus		\-
+Incr		\+\+
+Decr		\-\-
+Mult		\*
+Div		\/
+StarSlash	\*\/
+LShift		\<\<
+RShift		\>\>
+InStr		\<s
+InNum		\<d
+InChar		\<c
+OutStr		\>s
+OutNum		\>d
+OutChar		\>c
+
+%%
+
+{Comment1}	{ /* Ignore comments */ }
+{Comment2}	{ /* Ignore comments */ }
+
+{Colon}		{ return COLON; }
+{Semi}		{ return SEMI; }
+
+TRUE		{ return TRUE; }
+FALSE		{ return FALSE; }
+ON		{ return TRUE; }
+OFF		{ return FALSE; }
+{Less}		{ return LESS; }
+LT		{ return LESS; }
+{More}		{ return MORE; }
+GT		{ return MORE; }
+{LessEq}	{ return LESS_EQUAL; }
+LE		{ return LESS_EQUAL; }
+{MoreEq}	{ return MORE_EQUAL; }
+GE		{ return MORE_EQUAL; }
+{NotEq}		{ return NOT_EQUAL; }
+NE		{ return NOT_EQUAL; }
+{Equal}		{ return EQUAL; }
+EQ		{ return EQUAL; }
+
+{Plus}		{ return PLUS; }
+{Minus}		{ return MINUS; }
+{Incr}		{ return INCR; }
+{Decr}		{ return DECR; }
+{Mult}		{ return MULT; }
+{Div}		{ return DIV; }
+MOD		{ return MODULUS; }
+NEG		{ return NEGATE; }
+ABS		{ return ABS; }
+MIN		{ return MIN; }
+MAX		{ return MAX; }
+{StarSlash}	{ return STAR_SLASH; }
+
+AND		{ return AND; }
+OR		{ return OR; }
+XOR		{ return XOR; }
+{LShift}	{ return LSHIFT; }
+{RShift}	{ return RSHIFT; }
+
+DROP		{ return DROP; }
+NIP		{ return NIP; }
+DUP		{ return DUP; }
+SWAP		{ return SWAP; }
+OVER		{ return OVER; }
+PICK		{ return PICK; }
+SELECT		{ return SELECT; }
+ROT		{ return ROT; }
+RROT		{ return RROT; }
+ROLL		{ return ROLL; }
+TUCK		{ return TUCK; }
+DROP2		{ return DROP2; }
+NIP2		{ return NIP2; }
+DUP2		{ return DUP2; }
+SWAP2		{ return SWAP2; }
+OVER2		{ return OVER2; }
+TUCK2		{ return TUCK2; }
+ROT2		{ return ROT2; }
+RROT2		{ return RROT2; }
+
+MALLOC		{ return MALLOC; }
+FREE		{ return FREE; }
+GET		{ return GET; }
+PUT		{ return PUT; }
+
+IF		{ return IF; }
+ELSE		{ return ELSE; }
+ENDIF		{ return ENDIF; }
+WHILE		{ return WHILE; }
+END		{ return END; }
+
+RECURSE		{ return RECURSE; }
+RETURN		{ return RETURN; }
+EXIT		{ return EXIT; }
+FORWARD		{ return FORWARD; }
+TAB		{ return TAB; }
+SPACE		{ return SPACE; }
+CR		{ return CR; }
+
+{InStr}		{ return IN_STR; }
+{InNum}		{ return IN_NUM; }
+{InChar} 	{ return IN_CHAR; }
+
+{OutStr}	{ return OUT_STR; }
+{OutNum}	{ return OUT_NUM; }
+{OutChar} 	{ return OUT_CHAR; }
+
+MAIN		{ return MAIN; }
+
+DUMP		{ return DUMP; }
+
+!=		{ StackerCompiler::ThrowException(
+		  "You probably meant to use a <> instead of !=" ); }
+
+==		{ StackerCompiler::ThrowException(
+		  "You probably meant to use a single = .. this isn't C"); }
+
+{PInteger}      { Stackerlval.IntegerVal = IntToVal(yytext); return INTEGER; }
+{NInteger}      { uint64_t Val = IntToVal(yytext+1);
+		  // +1:  we have bigger negative range
+		  if (Val > (uint64_t)INT64_MAX+1)
+		    StackerCompiler::ThrowException(
+		    "Constant too large for signed 64 bits!");
+                  Stackerlval.IntegerVal = -Val; 
+		  return INTEGER; 
+                }
+{HexInteger} 	{ Stackerlval.IntegerVal = HexIntToVal(yytext+3); 
+                   return INTEGER;
+                }
+
+{String} 	{ yytext[strlen(yytext)-1] = 0;           // nuke end quote
+		  Stackerlval.StringVal = strdup(yytext+1);  // Nuke start quote
+		  return STRING;
+                }
+
+{Identifier}    { Stackerlval.StringVal = strdup(yytext); return IDENTIFIER; }
+
+{White}         { /* Ignore whitespace */ }
+%%
diff --git a/projects/Stacker/lib/compiler/Makefile b/projects/Stacker/lib/compiler/Makefile
new file mode 100644
index 0000000000..4c89ca8468
--- /dev/null
+++ b/projects/Stacker/lib/compiler/Makefile
@@ -0,0 +1,21 @@
+##===- projects/sample/lib/sample/Makefile -----------------*- Makefile -*-===##
+
+#
+# Indicate where we are relative to the top of the source tree.
+#
+LEVEL=../../../..
+
+#
+# Give the name of a library.  This will build a dynamic version.
+#
+SHARED_LIBRARY=1
+LIBRARYNAME=stkr_compiler
+
+#
+# Include Makefile.common so we know what to do.
+#
+include $(LEVEL)/Makefile.common
+
+ifdef PARSE_DEBUG
+INCLUDES += -DPARSE_DEBUG
+endif
diff --git a/projects/Stacker/lib/compiler/README b/projects/Stacker/lib/compiler/README
new file mode 100644
index 0000000000..5f13cbb52f
--- /dev/null
+++ b/projects/Stacker/lib/compiler/README
@@ -0,0 +1,20 @@
+This directory contains a sample language front end for LLVM.
+
+It is a *very* simple/crude implementation of FORTH. It has many
+deficiencies but provides enough basics to give you an idea of 
+what programming a new language front end for LLVM  looks like.
+
+To keep things simple, Stacker has the following limitations:
+1. Only a single, global stack is manipulated.
+2. There is no interpretation, everything is compiled.
+3. There's no type/bounds checking .. you're on your own.
+4. There's no floating point support.
+5. Only stdin can be read. Only stdout can be written. No other 
+   file I/O is supported.
+
+As such, this isn't a very useful language for anything other than
+the most trivial of programs. It is, however, a good learning tool
+(for both the author and the student).
+
+Reid Spencer
+16 November 2003
diff --git a/projects/Stacker/lib/compiler/StackerCompiler.cpp b/projects/Stacker/lib/compiler/StackerCompiler.cpp
new file mode 100644
index 0000000000..6ebcae9b36
--- /dev/null
+++ b/projects/Stacker/lib/compiler/StackerCompiler.cpp
@@ -0,0 +1,1728 @@
+//===-- StackerCompiler.cpp - Parser for llvm assembly files ----*- C++ -*-===//
+// 
+//                     The LLVM Compiler Infrastructure
+//
+// This file was developed by Reid Spencer and donated to the LLVM research 
+// group and is distributed under the University of Illinois Open Source 
+// License. See LICENSE.TXT for details.
+// 
+//===----------------------------------------------------------------------===//
+//
+//  This file implements the compiler for the "Stacker" language.
+//
+//===----------------------------------------------------------------------===//
+
+//===----------------------------------------------------------------------===//
+//            Globasl - Global variables we use 
+//===----------------------------------------------------------------------===//
+
+#include <llvm/Analysis/Verifier.h>
+#include <llvm/iMemory.h>
+#include <llvm/iOperators.h>
+#include <llvm/iOther.h>
+#include <llvm/iTerminators.h>
+#include <Support/Statistic.h>
+#include "StackerCompiler.h"
+#include "StackerParser.h"
+#include <string>
+
+// Lexer/Parser defined variables and functions
+extern std::FILE *Stackerin;
+extern int Stackerlineno;
+extern char* Stackertext;
+extern int Stackerleng;
+extern int Stackerparse();
+
+StackerCompiler* StackerCompiler::TheInstance = 0;
+
+static Statistic<> NumDefinitions(
+	"numdefs","The # of definitions encoutered while compiling Stacker");
+
+StackerCompiler::StackerCompiler()
+    : CurFilename("")
+    , TheModule(0)
+    , TheFunction(0)
+    , DefinitionType(0)
+    , TheStack(0)
+    , TheIndex(0)
+    , TheScanf(0)
+    , ThePrintf(0)
+    , TheExit(0)
+    , StrFormat(0)
+    , NumFormat(0)
+    , ChrFormat(0)
+    , InStrFormat(0)
+    , InNumFormat(0)
+    , InChrFormat(0)
+    , Zero(0)
+    , One(0)
+    , Two(0)
+    , Three(0)
+    , Four(0)
+    , Five(0)
+    , IZero(0)
+    , IOne(0)
+    , ITwo(0)
+    , no_arguments()
+    , echo(false)
+    , stack_size(256)
+    , stack_type(0)
+{
+}
+
+StackerCompiler::~StackerCompiler()
+{
+    // delete TheModule; << don't do this! 
+    // TheModule is passed to caller of the compile() method .. its their 
+    // problem.  Likewise for the other allocated objects (which become part 
+    // of TheModule.
+    TheModule = 0;
+    DefinitionType = 0;
+    TheStack = 0;
+    TheIndex = 0;
+}
+
+Module*
+StackerCompiler::compile(
+    const std::string& filename,
+    bool should_echo,
+    size_t the_stack_size
+)
+{
+    // TODO: Provide a global lock to protect the singled-threaded compiler
+    // and its global variables. Should be in guard object on the stack so
+    // that its destructor causes lock to be released (multiple exits from
+    // this function).
+
+    // Assign parameters
+    CurFilename = filename;
+    echo = should_echo;
+    stack_size = the_stack_size;
+
+    /// Default the file to read
+    FILE *F = stdin;
+
+    ///
+    if (filename != "-") 
+    {
+	F = fopen(filename.c_str(), "r");
+
+	if (F == 0)
+	{
+	    throw ParseException(filename, 
+		"Could not open file '" + filename + "'");
+	}
+    }
+
+    Module *Result;
+    try 
+    {
+	// Create the module we'll return
+	TheModule = new Module( CurFilename );
+
+	// Create a type to represent the stack. This is the same as the LLVM 
+	// Assembly type [ 256 x int ]
+	stack_type = ArrayType::get( Type::IntTy, stack_size );
+
+	// Create a global variable for the stack. Note the use of appending 
+	// linkage linkage so that multiple modules will make the stack larger. 
+	// Also note that the last argument causes the global to be inserted 
+	// automatically into the module.
+	TheStack = new GlobalVariable( 
+	    /*type=*/ stack_type, 
+	    /*isConstant=*/ false, 
+	    /*Linkage=*/ GlobalValue::AppendingLinkage, 
+	    /*initializer=*/0, 
+	    /*name=*/ "_stack_",
+	    /*parent=*/ TheModule 
+	);
+
+	// Create a global variable for indexing into the stack. Note the use 
+	// of LinkOnce linkage. Only one copy of _index_ will be retained 
+	// after linking
+	TheIndex = new GlobalVariable( 
+	    /*type=*/Type::LongTy, 
+	    /*isConstant=*/false,
+	    /*Linkage=*/GlobalValue::LinkOnceLinkage, 
+	    /*initializer=*/0, 
+	    /*name=*/"_index_",
+	    /*parent=*/TheModule
+	);
+
+	// Create a function prototype for definitions. No parameters, no 
+	// result.  This is used below any time a function is created.
+	std::vector<const Type*> params; // No parameters
+	DefinitionType = FunctionType::get( Type::VoidTy, params, false );
+
+	// Create a function for printf(3)
+	params.push_back( PointerType::get( Type::SByteTy ) );
+	FunctionType* printf_type = 
+	    FunctionType::get( Type::IntTy, params, true );
+	ThePrintf = new Function( 
+	    printf_type, GlobalValue::ExternalLinkage, "printf", TheModule);
+
+	// Create a function for scanf(3)
+	TheScanf = new Function( 
+	    printf_type, GlobalValue::ExternalLinkage, "scanf", TheModule);
+
+	// Create a function for exit(3)
+	params.clear();
+	params.push_back( Type::IntTy );
+	FunctionType* exit_type = 
+	    FunctionType::get( Type::VoidTy, params, false );
+	TheExit = new Function( 
+	    exit_type, GlobalValue::ExternalLinkage, "exit", TheModule);
+
+	ConstantArray* str_format = ConstantArray::get("%s");
+	StrFormat = new GlobalVariable( 
+	    /*type=*/ArrayType::get( Type::SByteTy,  3 ),
+	    /*isConstant=*/true,
+	    /*Linkage=*/GlobalValue::LinkOnceLinkage, 
+	    /*initializer=*/str_format, 
+	    /*name=*/"_str_format_",
+	    /*parent=*/TheModule
+	);
+
+	ConstantArray* in_str_format = ConstantArray::get(" %as");
+	InStrFormat = new GlobalVariable( 
+	    /*type=*/ArrayType::get( Type::SByteTy,  5 ),
+	    /*isConstant=*/true,
+	    /*Linkage=*/GlobalValue::LinkOnceLinkage, 
+	    /*initializer=*/in_str_format, 
+	    /*name=*/"_in_str_format_",
+	    /*parent=*/TheModule
+	);
+
+	ConstantArray* num_format = ConstantArray::get("%d");
+	NumFormat = new GlobalVariable( 
+	    /*type=*/ArrayType::get( Type::SByteTy,  3 ),
+	    /*isConstant=*/true,
+	    /*Linkage=*/GlobalValue::LinkOnceLinkage, 
+	    /*initializer=*/num_format, 
+	    /*name=*/"_num_format_",
+	    /*parent=*/TheModule
+	);
+
+	ConstantArray* in_num_format = ConstantArray::get(" %d");
+	InNumFormat = new GlobalVariable( 
+	    /*type=*/ArrayType::get( Type::SByteTy,  4 ),
+	    /*isConstant=*/true,
+	    /*Linkage=*/GlobalValue::LinkOnceLinkage, 
+	    /*initializer=*/in_num_format, 
+	    /*name=*/"_in_num_format_",
+	    /*parent=*/TheModule
+	);
+
+	ConstantArray* chr_format = ConstantArray::get("%c");
+	ChrFormat = new GlobalVariable( 
+	    /*type=*/ArrayType::get( Type::SByteTy,  3 ),
+	    /*isConstant=*/true,
+	    /*Linkage=*/GlobalValue::LinkOnceLinkage, 
+	    /*initializer=*/chr_format, 
+	    /*name=*/"_chr_format_",
+	    /*parent=*/TheModule
+	);
+
+	ConstantArray* in_chr_format = ConstantArray::get(" %c");
+	InChrFormat = new GlobalVariable( 
+	    /*type=*/ArrayType::get( Type::SByteTy,  4 ),
+	    /*isConstant=*/true,
+	    /*Linkage=*/GlobalValue::LinkOnceLinkage, 
+	    /*initializer=*/in_chr_format, 
+	    /*name=*/"_in_chr_format_",
+	    /*parent=*/TheModule
+	);
+
+	// Get some constants so we aren't always creating them
+	Zero = ConstantInt::get( Type::LongTy, 0 );
+	One = ConstantInt::get( Type::LongTy, 1 );
+	Two = ConstantInt::get( Type::LongTy, 2 );
+	Three = ConstantInt::get( Type::LongTy, 3 );
+	Four = ConstantInt::get( Type::LongTy, 4 );
+	Five = ConstantInt::get( Type::LongTy, 5 );
+	IZero = ConstantInt::get( Type::IntTy, 0 );
+	IOne = ConstantInt::get( Type::IntTy, 1 );
+	ITwo = ConstantInt::get( Type::IntTy, 2 );
+
+	// Reset the current line number
+	Stackerlineno = 1;    
+
+	// Reset the parser's input to F
+	Stackerin = F;		// Set the input file.
+
+	// Let the parse know about this instance
+	TheInstance = this;
+
+	// Parse the file. The parser (see StackParser.y) will call back to 
+	// the StackCompiler via the "handle*" methods 
+	Stackerparse(); 
+
+	// Avoid potential illegal use (TheInstance might be on the stack)
+	TheInstance = 0;
+
+    } catch (...) {
+	if (F != stdin) fclose(F);      // Make sure to close file descriptor 
+	throw;                          // if an exception is thrown
+    }
+
+    // Close the file
+    if (F != stdin) fclose(F);
+    
+    // Return the compiled module to the caller
+    return TheModule;
+}
+
+//===----------------------------------------------------------------------===//
+//            Internal Functions, used by handleXXX below.
+//            These represent the basic stack operations.
+//===----------------------------------------------------------------------===//
+
+Instruction*
+StackerCompiler::incr_stack_index( BasicBlock* bb, Value* ival = 0 )
+{
+    // Load the value from the TheIndex
+    LoadInst* loadop = new LoadInst( TheIndex );
+    bb->getInstList().push_back( loadop );
+
+    // Increment the loaded index value
+    if ( ival == 0 ) ival = One;
+    CastInst* caster = new CastInst( ival, Type::LongTy );
+    bb->getInstList().push_back( caster );
+    BinaryOperator* addop = BinaryOperator::create( Instruction::Add, 
+	    loadop, caster);
+    bb->getInstList().push_back( addop );
+
+    // Store the incremented value
+    StoreInst* storeop = new StoreInst( addop, TheIndex );
+    bb->getInstList().push_back( storeop );
+    return storeop;
+}
+
+Instruction*
+StackerCompiler::decr_stack_index( BasicBlock* bb, Value* ival = 0 )
+{
+    // Load the value from the TheIndex
+    LoadInst* loadop = new LoadInst( TheIndex );
+    bb->getInstList().push_back( loadop );
+
+    // Decrement the loaded index value
+    if ( ival == 0 ) ival = One;
+    CastInst* caster = new CastInst( ival, Type::LongTy );
+    bb->getInstList().push_back( caster );
+    BinaryOperator* subop = BinaryOperator::create( Instruction::Sub, 
+	    loadop, caster);
+    bb->getInstList().push_back( subop );
+
+    // Store the incremented value
+    StoreInst* storeop = new StoreInst( subop, TheIndex );
+    bb->getInstList().push_back( storeop );
+
+    return storeop;
+}
+
+Instruction*
+StackerCompiler::get_stack_pointer( BasicBlock* bb, Value* index = 0 )
+{
+    // Load the value of the Stack Index 
+    LoadInst* loadop = new LoadInst( TheIndex );
+    bb->getInstList().push_back( loadop );
+
+    // Index into the stack to get its address. NOTE the use of two
+    // elements in this vector. The first de-references the pointer that
+    // "TheStack" represents. The second indexes into the pointed to array.
+    // Think of the first index as getting the address of the 0th element
+    // of the array.
+    std::vector<Value*> indexVec;
+    indexVec.push_back( Zero );
+
+    if ( index == 0 )
+    {
+	indexVec.push_back(loadop);	
+    }
+    else
+    {
+	CastInst* caster = new CastInst( index, Type::LongTy );
+	bb->getInstList().push_back( caster );
+	BinaryOperator* subop = BinaryOperator::create( 
+	    Instruction::Sub, loadop, caster );
+	bb->getInstList().push_back( subop );
+	indexVec.push_back(subop);
+    }
+
+    // Get the address of the indexed stack element
+    GetElementPtrInst* gep = new GetElementPtrInst( TheStack, indexVec );
+    bb->getInstList().push_back( gep );		// Put GEP in Block
+
+    return gep;
+}
+
+Instruction*
+StackerCompiler::push_value( BasicBlock* bb, Value* val )
+{
+    // Get location of 
+    incr_stack_index(bb);
+
+    // Get the stack pointer
+    GetElementPtrInst* gep = cast<GetElementPtrInst>( 
+	    get_stack_pointer( bb ) );
+
+    // Cast the value to an integer .. hopefully it works
+    CastInst* cast_inst = new CastInst( val, Type::IntTy );
+    bb->getInstList().push_back( cast_inst );
+
+    // Store the value
+    StoreInst* storeop = new StoreInst( cast_inst, gep );
+    bb->getInstList().push_back( storeop );
+
+    return storeop;
+}
+
+Instruction*
+StackerCompiler::push_integer(BasicBlock* bb, int32_t value )
+{
+    // Just push a constant integer value
+    return push_value( bb, ConstantSInt::get( Type::IntTy, value ) );
+}
+
+Instruction*
+StackerCompiler::pop_integer( BasicBlock*bb )
+{
+    // Get the stack pointer
+    GetElementPtrInst* gep = cast<GetElementPtrInst>(
+	get_stack_pointer( bb ));
+
+    // Load the value
+    LoadInst* load_inst = new LoadInst( gep );
+    bb->getInstList().push_back( load_inst );
+
+    // Decrement the stack index
+    decr_stack_index( bb );
+
+    // Return the value
+    return load_inst;
+}
+
+Instruction*
+StackerCompiler::push_string( BasicBlock* bb, const char* value )
+{
+    // Get length of the string
+    size_t len = strlen( value );
+
+    // Create a type for the string constant. Length is +1 for 
+    // the terminating 0.
+    ArrayType* char_array = ArrayType::get( Type::SByteTy, len + 1 );
+
+    // Create an initializer for the value
+    ConstantArray* initVal = ConstantArray::get( value );
+
+    // Create an internal linkage global variable to hold the constant.
+    GlobalVariable* strconst = new GlobalVariable( 
+	char_array, 
+	/*isConstant=*/true, 
+	GlobalValue::InternalLinkage, 
+	/*initializer=*/initVal,
+	"",
+	TheModule
+    );
+
+    // Push the casted value
+    return push_value( bb, strconst );
+}
+
+Instruction*
+StackerCompiler::pop_string( BasicBlock* bb )
+{
+    // Get location of stack pointer
+    GetElementPtrInst* gep = cast<GetElementPtrInst>(
+	get_stack_pointer( bb ));
+
+    // Load the value from the stack
+    LoadInst* loader = new LoadInst( gep );
+    bb->getInstList().push_back( loader );
+
+    // Cast the integer to a sbyte*
+    CastInst* caster = new CastInst( loader, PointerType::get(Type::SByteTy) );
+    bb->getInstList().push_back( caster );
+
+    // Decrement stack index
+    decr_stack_index( bb );
+
+    // Return the value
+    return caster;
+}
+
+Instruction*
+StackerCompiler::replace_top( BasicBlock* bb, Value* new_top, Value* index = 0 )
+{
+    // Get the stack pointer
+    GetElementPtrInst* gep = cast<GetElementPtrInst>(
+	    get_stack_pointer( bb, index ));
+    
+    // Store the value there
+    StoreInst* store_inst = new StoreInst( new_top, gep );
+    bb->getInstList().push_back( store_inst );
+
+    // Return the value
+    return store_inst;
+}
+
+Instruction*
+StackerCompiler::stack_top( BasicBlock* bb, Value* index = 0 )
+{
+    // Get the stack pointer
+    GetElementPtrInst* gep = cast<GetElementPtrInst>(
+	get_stack_pointer( bb, index ));
+
+    // Load the value
+    LoadInst* load_inst = new LoadInst( gep );
+    bb->getInstList().push_back( load_inst );
+
+    // Return the value
+    return load_inst;
+}
+
+Instruction*
+StackerCompiler::stack_top_string( BasicBlock* bb, Value* index = 0 )
+{
+    // Get location of stack pointer
+    GetElementPtrInst* gep = cast<GetElementPtrInst>(
+	get_stack_pointer( bb, index ));
+
+    // Load the value from the stack
+    LoadInst* loader = new LoadInst( gep );
+    bb->getInstList().push_back( loader );
+
+    // Cast the integer to a sbyte*
+    CastInst* caster = new CastInst( loader, PointerType::get(Type::SByteTy) );
+    bb->getInstList().push_back( caster );
+
+    // Return the value
+    return caster;
+}
+
+static void
+add_block( Function*f, BasicBlock* bb )
+{
+    if ( ! f->empty() && f->back().getTerminator() == 0 )
+    {
+	BranchInst* branch = new BranchInst(bb);
+	f->back().getInstList().push_back( branch );
+    }
+    f->getBasicBlockList().push_back( bb );
+}
+
+
+//===----------------------------------------------------------------------===//
+//            handleXXX - Handle semantics of parser productions
+//===----------------------------------------------------------------------===//
+
+Module*
+StackerCompiler::handle_module_start( )
+{
+    // Return the newly created module
+    return TheModule;
+}
+
+Module* 
+StackerCompiler::handle_module_end( Module* mod )
+{
+    // Return the module.
+    return mod;
+}
+
+Module*
+StackerCompiler::handle_definition_list_start()
+{
+    return TheModule;
+}
+
+Module* 
+StackerCompiler::handle_definition_list_end( Module* mod, Function* definition )
+{
+    if ( ! definition->empty() )
+    {
+	BasicBlock& last_block = definition->back();
+	if ( last_block.getTerminator() == 0 )
+	{
+	    last_block.getInstList().push_back( new ReturnInst() );
+	}
+    }
+    // Insert the definition into the module
+    mod->getFunctionList().push_back( definition );
+
+    // Bump our (sample) statistic.
+    ++NumDefinitions;
+    return mod;
+}
+
+Function*
+StackerCompiler::handle_main_definition( Function* func )
+{
+    // Set the name of the function defined as the Stacker main
+    func->setName( "_MAIN_");
+
+    // Create the actual main for the runtime system.
+    //std::vector<const Type*> params; // No parameters
+    //FunctionType* main_type = FunctionType::get( Type::IntTy, params, false );
+    Function* SystemMain = new Function(
+	DefinitionType, 
+	GlobalValue::ExternalLinkage,
+	"main", TheModule);
+
+    // Create a basic block that just calls the STACKERMAIN function. Note
+    // that the basic block is automatically inserted into the end of SystemMain
+    BasicBlock* bb = new BasicBlock( (echo?"main":"a"), SystemMain ) ;
+    bb->getInstList().push_back( new CallInst( func, no_arguments) );
+    bb->getInstList().push_back( new ReturnInst() ); 
+
+    // Turn "_stack_" into an initialized variable since this is the main
+    // module. This causes it to not be "external" but defined in this module.
+    TheStack->setInitializer( Constant::getNullValue(stack_type) );
+
+    // Turn "_index_" into an intialized variable for the same reason.
+    TheIndex->setInitializer( Constant::getNullValue(Type::LongTy) );
+    return func;
+}
+
+Function* 
+StackerCompiler::handle_forward( char * name )
+{
+    // Just create a placeholder function
+    Function* the_function = new Function ( 
+	DefinitionType, 
+	GlobalValue::ExternalLinkage, 
+	name ); 
+    assert( the_function->isExternal() );
+
+    free( name );
+    return the_function;
+}
+
+Function* 
+StackerCompiler::handle_definition( char * name, Function* f )
+{
+    // Look up the function name in the module to see if it was forward
+    // declared.
+    Function* existing_function = TheModule->getNamedFunction( name );
+
+#if 0
+    // If the function already exists...
+    if ( existing_function )
+    {
+	// Just get rid of the placeholder
+	existing_function->dropAllReferences();
+	delete existing_function;
+    }
+#endif
+
+    // Just set the name of the function now that we know what it is.
+    f->setName( name );
+
+    free( name );
+
+    return f;
+}
+
+Function*
+StackerCompiler::handle_word_list_start()
+{
+    TheFunction = new Function(DefinitionType, GlobalValue::ExternalLinkage);
+    return TheFunction;
+}
+
+Function*
+StackerCompiler::handle_word_list_end( Function* f, BasicBlock* bb )
+{
+    add_block( f, bb );
+    return f;
+}
+
+BasicBlock* 
+StackerCompiler::handle_if( char* ifTrue, char* ifFalse )
+{
+    // Create a basic block for the preamble
+    BasicBlock* bb = new BasicBlock((echo?"if":""));
+
+    // Get the condition value
+    LoadInst* cond = cast<LoadInst>( pop_integer(bb) );
+
+    // Compare the condition against 0 
+    SetCondInst* cond_inst = new SetCondInst( Instruction::SetNE, cond, 
+	ConstantSInt::get( Type::IntTy, 0) );
+    bb->getInstList().push_back( cond_inst );
+
+    // Create an exit block
+    BasicBlock* exit_bb = new BasicBlock((echo?"endif":""));
+
+    // Create the true_block
+    BasicBlock* true_bb = new BasicBlock((echo?"then":""));
+
+    // Create the false_block
+    BasicBlock* false_bb = 0;
+    if ( ifFalse ) false_bb = new BasicBlock((echo?"else":""));
+
+    // Create a branch on the SetCond
+    BranchInst* br_inst = new BranchInst( true_bb, 
+	( ifFalse ? false_bb : exit_bb ), cond_inst );
+    bb->getInstList().push_back( br_inst );
+
+    // Fill the true block 
+    std::vector<Value*> args;
+    if ( Function* true_func = TheModule->getNamedFunction(ifTrue) )
+    {
+	true_bb->getInstList().push_back( 
+		new CallInst( true_func, args ) );
+	true_bb->getInstList().push_back( 
+		new BranchInst( exit_bb ) );
+    }
+    else
+    {
+	ThrowException(std::string("Function '") + ifTrue + 
+	    "' must be declared first.'");
+    }
+
+    free( ifTrue );
+
+    // Fill the false block
+    if ( false_bb )
+    {
+	if ( Function* false_func = TheModule->getNamedFunction(ifFalse) )
+	{
+	    false_bb->getInstList().push_back( 
+		    new CallInst( false_func, args ) );
+	    false_bb->getInstList().push_back( 
+		    new BranchInst( exit_bb ) );
+	}
+	else
+	{
+	    ThrowException(std::string("Function '") + ifFalse + 
+		    "' must be declared first.'");
+	}
+	free( ifFalse );
+    }
+
+    // Add the blocks to the function
+    add_block( TheFunction, bb );
+    add_block( TheFunction, true_bb );
+    if ( false_bb ) add_block( TheFunction, false_bb );
+
+    return exit_bb;
+}
+
+BasicBlock* 
+StackerCompiler::handle_while( char* todo )
+{
+
+    // Create a basic block for the loop test
+    BasicBlock* test = new BasicBlock((echo?"while":""));
+
+    // Create an exit block
+    BasicBlock* exit = new BasicBlock((echo?"end":""));
+
+    // Create a loop body block
+    BasicBlock* body = new BasicBlock((echo?"do":""));
+
+    // Create a root node
+    BasicBlock* bb = new BasicBlock((echo?"root":""));
+    BranchInst* root_br_inst = new BranchInst( test );
+    bb->getInstList().push_back( root_br_inst );
+
+    // Pop the condition value
+    LoadInst* cond = cast<LoadInst>( stack_top(test) );
+
+    // Compare the condition against 0 
+    SetCondInst* cond_inst = new SetCondInst( 
+	Instruction::SetNE, cond, ConstantSInt::get( Type::IntTy, 0) );
+    test->getInstList().push_back( cond_inst );
+
+    // Add the branch instruction
+    BranchInst* br_inst = new BranchInst( body, exit, cond_inst );
+    test->getInstList().push_back( br_inst );
+
+    // Fill in the body
+    std::vector<Value*> args;
+    if ( Function* body_func = TheModule->getNamedFunction(todo) )
+    {
+	body->getInstList().push_back( new CallInst( body_func, args ) );
+	body->getInstList().push_back( new BranchInst( test ) );
+    }
+    else
+    {
+	ThrowException(std::string("Function '") + todo + 
+	    "' must be declared first.'");
+    }
+
+    free( todo );
+
+    // Add the blocks
+    add_block( TheFunction, bb );
+    add_block( TheFunction, test );
+    add_block( TheFunction, body );
+
+    return exit;
+}
+
+BasicBlock* 
+StackerCompiler::handle_identifier( char * name )
+{
+    Function* func = TheModule->getNamedFunction( name );
+    BasicBlock* bb = new BasicBlock((echo?"call":""));
+    if ( func )
+    {
+	CallInst* call_def = new CallInst( func , no_arguments );
+	bb->getInstList().push_back( call_def );
+    }
+    else
+    {
+	ThrowException(std::string("Definition '") + name + 
+	    "' must be defined before it can be used.");
+    }
+
+    free( name );
+    return bb;
+}
+
+BasicBlock* 
+StackerCompiler::handle_string( char * value )
+{
+    // Create a new basic block for the push operation
+    BasicBlock* bb = new BasicBlock((echo?"string":""));
+
+    // Push the string onto the stack
+    push_string(bb, value);
+
+    // Free the strdup'd string
+    free( value );
+
+    return bb;
+}
+
+BasicBlock* 
+StackerCompiler::handle_integer( const int32_t value )
+{
+    // Create a new basic block for the push operation
+    BasicBlock* bb = new BasicBlock((echo?"int":""));
+
+    // Push the integer onto the stack
+    push_integer(bb, value );
+
+    return bb;
+}
+
+BasicBlock* 
+StackerCompiler::handle_word( int tkn )
+{
+    // Create a new basic block to hold the instruction(s)
+    BasicBlock* bb = new BasicBlock();
+
+    /* Fill the basic block with