Garbage collect the intern symbol table

Symbols created by the compiler, or that are hard-coded as class
constants now use SymbolTerm.intern() to cache the SymbolTerm and
try to reuse the same instance across all locations that use it.
Strings are interned using the Java interning system, ensuring at
most 1 copy of the String object exists in the heap.

Symbols created dynamically on the fly by builtin predicates are
allocated directly and not stored in the cache. This slows down
any evaluation, as the symbol must be compared one character at
a time, however String.equals() should be faster here than doing
the HashMap lookup on each wrapping of a String into a SymbolTerm.

To reduce the risk of leaks, the symbol table now uses WeakReferences
to hold onto the cached SymbolTerm and SymbolTerm.gc() is invoked
cleaning out any dead references whenever the interpreter stops
goal evaluation.

50 files changed, 356 insertions, 249 deletions

diff --git a/src/builtin/PRED_$call_2.java b/src/builtin/PRED_$call_2.java
index b9ace54..d036dae 100644
--- a/src/builtin/PRED_$call_2.java
+++ b/src/builtin/PRED_$call_2.java
@@ -8,8 +8,8 @@ import java.lang.reflect.*;
  * @version 1.0
  */
 class PRED_$call_2 extends Predicate.P2 {
-    private static final SymbolTerm SYM_SLASH_2 = SymbolTerm.makeSymbol("/", 2);
-    private static final SymbolTerm SYM_COLON_2 = SymbolTerm.makeSymbol(":", 2);
+    private static final SymbolTerm SYM_SLASH_2 = SymbolTerm.intern("/", 2);
+    private static final SymbolTerm SYM_COLON_2 = SymbolTerm.intern(":", 2);
 
     public PRED_$call_2(Term a1, Term a2, Operation cont) {
 	arg1 = a1;
@@ -56,7 +56,7 @@ class PRED_$call_2 extends Predicate.P2 {
 		    Term what = new StructureTerm(SYM_COLON_2,
 		       a1,
 		       new StructureTerm(SYM_SLASH_2,
-		         SymbolTerm.makeSymbol(functor),
+		         SymbolTerm.create(functor),
 		         new IntegerTerm(arity)));
 		    ExistenceException err = new ExistenceException(this, 0, "procedure", what, e.getMessage());
 		    err.initCause(e);
diff --git a/src/builtin/PRED_$get_instances_2.java b/src/builtin/PRED_$get_instances_2.java
index 2873e9b..9a5f8ee 100644
--- a/src/builtin/PRED_$get_instances_2.java
+++ b/src/builtin/PRED_$get_instances_2.java
@@ -7,7 +7,7 @@ import com.googlecode.prolog_cafe.lang.*;
    @version 1.1
 */
 class PRED_$get_instances_2 extends Predicate.P2 {
-    private static final SymbolTerm COMMA = SymbolTerm.makeSymbol(",", 2);
+    private static final SymbolTerm COMMA = SymbolTerm.intern(",", 2);
 
     public PRED_$get_instances_2(Term a1, Term a2, Operation cont) {
         arg1 = a1;
diff --git a/src/builtin/PRED_$get_prolog_impl_flag_2.java b/src/builtin/PRED_$get_prolog_impl_flag_2.java
index 81d90ec..f8306f2 100644
--- a/src/builtin/PRED_$get_prolog_impl_flag_2.java
+++ b/src/builtin/PRED_$get_prolog_impl_flag_2.java
@@ -7,18 +7,18 @@ import com.googlecode.prolog_cafe.lang.*;
    @version 1.0
 */
 class PRED_$get_prolog_impl_flag_2 extends Predicate.P2 {
-    private static final SymbolTerm TRUE                      = SymbolTerm.makeSymbol("true");
-    private static final SymbolTerm FALSE                     = SymbolTerm.makeSymbol("false");
-    private static final SymbolTerm BOUNDED                   = SymbolTerm.makeSymbol("bounded");
-    private static final SymbolTerm MAX_INTEGER               = SymbolTerm.makeSymbol("max_integer");
-    private static final SymbolTerm MIN_INTEGER               = SymbolTerm.makeSymbol("min_integer");
-    private static final SymbolTerm INTEGER_ROUNDING_FUNCTION = SymbolTerm.makeSymbol("integer_rounding_function");
-    private static final SymbolTerm CHAR_CONVERSION           = SymbolTerm.makeSymbol("char_conversion");
-    private static final SymbolTerm DEBUG                     = SymbolTerm.makeSymbol("debug");
-    private static final SymbolTerm MAX_ARITY                 = SymbolTerm.makeSymbol("max_arity");
-    private static final SymbolTerm UNKNOWN                   = SymbolTerm.makeSymbol("unknown");
-    private static final SymbolTerm DOUBLE_QUOTES             = SymbolTerm.makeSymbol("double_quotes");
-    private static final SymbolTerm PRINT_STACK_TRACE         = SymbolTerm.makeSymbol("print_stack_trace");
+    private static final SymbolTerm TRUE                      = SymbolTerm.intern("true");
+    private static final SymbolTerm FALSE                     = SymbolTerm.intern("false");
+    private static final SymbolTerm BOUNDED                   = SymbolTerm.intern("bounded");
+    private static final SymbolTerm MAX_INTEGER               = SymbolTerm.intern("max_integer");
+    private static final SymbolTerm MIN_INTEGER               = SymbolTerm.intern("min_integer");
+    private static final SymbolTerm INTEGER_ROUNDING_FUNCTION = SymbolTerm.intern("integer_rounding_function");
+    private static final SymbolTerm CHAR_CONVERSION           = SymbolTerm.intern("char_conversion");
+    private static final SymbolTerm DEBUG                     = SymbolTerm.intern("debug");
+    private static final SymbolTerm MAX_ARITY                 = SymbolTerm.intern("max_arity");
+    private static final SymbolTerm UNKNOWN                   = SymbolTerm.intern("unknown");
+    private static final SymbolTerm DOUBLE_QUOTES             = SymbolTerm.intern("double_quotes");
+    private static final SymbolTerm PRINT_STACK_TRACE         = SymbolTerm.intern("print_stack_trace");
 
     public PRED_$get_prolog_impl_flag_2(Term a1, Term a2, Operation cont) {
         arg1 = a1;
@@ -49,25 +49,25 @@ class PRED_$get_prolog_impl_flag_2 extends Predicate.P2 {
 	    if (! a2.unify(new IntegerTerm(engine.getMinInteger()), engine.trail))
 		return engine.fail();
 	} else if (a1.equals(INTEGER_ROUNDING_FUNCTION)) {
-	    if (! a2.unify(SymbolTerm.makeSymbol(engine.getIntegerRoundingFunction()), engine.trail))
+	    if (! a2.unify(SymbolTerm.intern(engine.getIntegerRoundingFunction()), engine.trail))
 		return engine.fail();
 	} else if (a1.equals(CHAR_CONVERSION)) {
-	    if (! a2.unify(SymbolTerm.makeSymbol(engine.getCharConversion()), engine.trail))
+	    if (! a2.unify(SymbolTerm.intern(engine.getCharConversion()), engine.trail))
 		return engine.fail();
 	} else if (a1.equals(DEBUG)) {
-	    if (! a2.unify(SymbolTerm.makeSymbol(engine.getDebug()), engine.trail))
+	    if (! a2.unify(SymbolTerm.intern(engine.getDebug()), engine.trail))
 		return engine.fail();
 	} else if (a1.equals(MAX_ARITY)) {
 	    if (! a2.unify(new IntegerTerm(engine.getMaxArity()), engine.trail))
 		return engine.fail();
 	} else if (a1.equals(UNKNOWN)) {
-	    if (! a2.unify(SymbolTerm.makeSymbol(engine.getUnknown()), engine.trail))
+	    if (! a2.unify(SymbolTerm.intern(engine.getUnknown()), engine.trail))
 		return engine.fail();
 	} else if (a1.equals(DOUBLE_QUOTES)) {
-	    if (! a2.unify(SymbolTerm.makeSymbol(engine.getDoubleQuotes()), engine.trail))
+	    if (! a2.unify(SymbolTerm.intern(engine.getDoubleQuotes()), engine.trail))
 		return engine.fail();
 	} else if (a1.equals(PRINT_STACK_TRACE)) {
-	    if (! a2.unify(SymbolTerm.makeSymbol(engine.getPrintStackTrace()), engine.trail))
+	    if (! a2.unify(SymbolTerm.intern(engine.getPrintStackTrace()), engine.trail))
 		return engine.fail();
 	} else {
 	    return engine.fail();
diff --git a/src/builtin/PRED_$hash_adda_3.java b/src/builtin/PRED_$hash_adda_3.java
index 9104e7c..94fea66 100644
--- a/src/builtin/PRED_$hash_adda_3.java
+++ b/src/builtin/PRED_$hash_adda_3.java
@@ -8,7 +8,7 @@ import java.util.Hashtable;
    @version 1.0
 */
 class PRED_$hash_adda_3 extends Predicate.P3 {
-    private static final SymbolTerm SYM_NIL = SymbolTerm.makeSymbol("[]");
+    private static final SymbolTerm SYM_NIL = Prolog.Nil;
 
     public PRED_$hash_adda_3(Term a1, Term a2, Term a3, Operation cont) {
         arg1 = a1;
diff --git a/src/builtin/PRED_$hash_addz_3.java b/src/builtin/PRED_$hash_addz_3.java
index ff9fe3f..ae89ca1 100644
--- a/src/builtin/PRED_$hash_addz_3.java
+++ b/src/builtin/PRED_$hash_addz_3.java
@@ -8,7 +8,7 @@ import java.util.Hashtable;
    @version 1.0
 */
 class PRED_$hash_addz_3 extends Predicate.P3 {
-    private static final SymbolTerm SYM_NIL = SymbolTerm.makeSymbol("[]");
+    private static final SymbolTerm SYM_NIL = Prolog.Nil;
 
     public PRED_$hash_addz_3(Term a1, Term a2, Term a3, Operation cont) {
         arg1 = a1;
diff --git a/src/builtin/PRED_$hash_remove_first_3.java b/src/builtin/PRED_$hash_remove_first_3.java
index 44b477d..4639899 100644
--- a/src/builtin/PRED_$hash_remove_first_3.java
+++ b/src/builtin/PRED_$hash_remove_first_3.java
@@ -8,7 +8,7 @@ import java.util.Hashtable;
    @version 1.0
 */
 class PRED_$hash_remove_first_3 extends Predicate.P3 {
-    private static final SymbolTerm SYM_NIL = SymbolTerm.makeSymbol("[]");
+    private static final SymbolTerm SYM_NIL = Prolog.Nil;
 
     public PRED_$hash_remove_first_3(Term a1, Term a2, Term a3, Operation cont) {
         arg1 = a1;
diff --git a/src/builtin/PRED_$read_token0_3.java b/src/builtin/PRED_$read_token0_3.java
index 6e2cd81..9e4c8bc 100644
--- a/src/builtin/PRED_$read_token0_3.java
+++ b/src/builtin/PRED_$read_token0_3.java
@@ -64,7 +64,7 @@ class PRED_$read_token0_3 extends Predicate.P3 {
 		}
 		break;
 	    default :
-		token = SymbolTerm.makeSymbol(s.toString());
+		token = SymbolTerm.create(s.toString());
 		break;
 	    }
 	} catch (Exception e) {
diff --git a/src/builtin/PRED_$set_prolog_impl_flag_2.java b/src/builtin/PRED_$set_prolog_impl_flag_2.java
index e8ad2bc..b7994b1 100644
--- a/src/builtin/PRED_$set_prolog_impl_flag_2.java
+++ b/src/builtin/PRED_$set_prolog_impl_flag_2.java
@@ -7,11 +7,11 @@ import com.googlecode.prolog_cafe.lang.*;
    @version 1.0
 */
 class PRED_$set_prolog_impl_flag_2 extends Predicate.P2 {
-    private static final SymbolTerm CHAR_CONVERSION   = SymbolTerm.makeSymbol("char_conversion");
-    private static final SymbolTerm DEBUG             = SymbolTerm.makeSymbol("debug");
-    private static final SymbolTerm UNKNOWN           = SymbolTerm.makeSymbol("unknown");
-    private static final SymbolTerm DOUBLE_QUOTES     = SymbolTerm.makeSymbol("double_quotes");
-    private static final SymbolTerm PRINT_STACK_TRACE = SymbolTerm.makeSymbol("print_stack_trace");
+    private static final SymbolTerm CHAR_CONVERSION   = SymbolTerm.intern("char_conversion");
+    private static final SymbolTerm DEBUG             = SymbolTerm.intern("debug");
+    private static final SymbolTerm UNKNOWN           = SymbolTerm.intern("unknown");
+    private static final SymbolTerm DOUBLE_QUOTES     = SymbolTerm.intern("double_quotes");
+    private static final SymbolTerm PRINT_STACK_TRACE = SymbolTerm.intern("print_stack_trace");
 
     public PRED_$set_prolog_impl_flag_2(Term a1, Term a2, Operation cont) {
         arg1 = a1;
diff --git a/src/builtin/PRED_$statistics_2.java b/src/builtin/PRED_$statistics_2.java
index 25443fc..a0753ac 100644
--- a/src/builtin/PRED_$statistics_2.java
+++ b/src/builtin/PRED_$statistics_2.java
@@ -7,10 +7,10 @@ import  com.googlecode.prolog_cafe.lang.*;
    @version 1.0
 */
 class PRED_$statistics_2 extends Predicate.P2 {
-    private static final SymbolTerm Nil         = SymbolTerm.makeSymbol("[]");
-    private static final SymbolTerm SYM_RUNTIME = SymbolTerm.makeSymbol("runtime");
-    private static final SymbolTerm SYM_TRAIL   = SymbolTerm.makeSymbol("trail");
-    private static final SymbolTerm SYM_CHOICE  = SymbolTerm.makeSymbol("choice");
+    private static final SymbolTerm Nil         = Prolog.Nil;
+    private static final SymbolTerm SYM_RUNTIME = SymbolTerm.intern("runtime");
+    private static final SymbolTerm SYM_TRAIL   = SymbolTerm.intern("trail");
+    private static final SymbolTerm SYM_CHOICE  = SymbolTerm.intern("choice");
 
     public PRED_$statistics_2(Term a1, Term a2, Operation cont){
 	arg1 = a1;
diff --git a/src/builtin/PRED_$univ_2.java b/src/builtin/PRED_$univ_2.java
index c878dcf..4483e95 100644
--- a/src/builtin/PRED_$univ_2.java
+++ b/src/builtin/PRED_$univ_2.java
@@ -7,8 +7,8 @@ import com.googlecode.prolog_cafe.lang.*;
    @version 1.0
 */
 public class PRED_$univ_2 extends Predicate.P2 {
-    private static final SymbolTerm SYM_DOT = SymbolTerm.makeSymbol(".");
-    private static final SymbolTerm SYM_NIL = SymbolTerm.makeSymbol("[]");
+    private static final SymbolTerm SYM_DOT = SymbolTerm.intern(".");
+    private static final SymbolTerm SYM_NIL = Prolog.Nil;
 
     public PRED_$univ_2(Term a1, Term a2, Operation cont) {
         arg1 = a1;
@@ -37,7 +37,7 @@ public class PRED_$univ_2 extends Predicate.P2 {
 	    if (! a2.unify(t, engine.trail))
 		return engine.fail();
 	} else if (a1.isStructure()) {
-	    SymbolTerm sym = SymbolTerm.makeSymbol(((StructureTerm)a1).functor().name());
+	    SymbolTerm sym = SymbolTerm.create(((StructureTerm)a1).functor().name());
 	    Term[] args = ((StructureTerm)a1).args();
 	    Term t = SYM_NIL;
 	    for (int i=args.length; i>0; i--)
@@ -76,7 +76,7 @@ public class PRED_$univ_2 extends Predicate.P2 {
 		x = ((ListTerm)x).cdr().dereference();
 	    }
 	    int n = ((ListTerm)a2).length() - 1;
-	    SymbolTerm sym = SymbolTerm.makeSymbol(((SymbolTerm)head).name(), n);
+	    SymbolTerm sym = SymbolTerm.create(((SymbolTerm)head).name(), n);
 	    Term[] args = new Term[n];
 	    for(int i=0; i<n; i++) {
 		args[i] = ((ListTerm)tail).car().dereference();
diff --git a/src/builtin/PRED_atom_chars_2.java b/src/builtin/PRED_atom_chars_2.java
index 3d408ff..240bde6 100644
--- a/src/builtin/PRED_atom_chars_2.java
+++ b/src/builtin/PRED_atom_chars_2.java
@@ -7,8 +7,6 @@ import  com.googlecode.prolog_cafe.lang.*;
  * @version 1.1
  */
 public class PRED_atom_chars_2 extends Predicate.P2 {
-    private static final SymbolTerm Nil = SymbolTerm.makeSymbol("[]");
-
     public PRED_atom_chars_2(Term a1, Term a2, Operation cont) {
 	arg1 = a1;
 	arg2 = a2;
@@ -25,7 +23,7 @@ public class PRED_atom_chars_2 extends Predicate.P2 {
 	a2 = a2.dereference();
 	if (a1.isVariable()) { // atom_chars(-Atom, +CharList)
 	    if (a2.isNil()) {
-		if (! a1.unify(SymbolTerm.makeSymbol(""), engine.trail))
+		if (! a1.unify(SymbolTerm.intern(""), engine.trail))
 		    return engine.fail();
 		return cont;
 	    } else if (a2.isVariable()) {
@@ -48,16 +46,16 @@ public class PRED_atom_chars_2 extends Predicate.P2 {
 		sb.append(((SymbolTerm)car).name());
 		x = ((ListTerm)x).cdr().dereference();
 	    }
-	    if (! a1.unify(SymbolTerm.makeSymbol(sb.toString()), engine.trail))
+	    if (! a1.unify(SymbolTerm.create(sb.toString()), engine.trail))
 		return engine.fail();
 	    return cont;
 	} else if (a2.isNil() || a2.isVariable() || a2.isList()) { // atom_chars(+Atom, ?CharList)
 	    if (! a1.isSymbol())
 		throw new IllegalTypeException(this, 1, "atom", a1);
 	    String s = ((SymbolTerm)a1).name();
-	    Term x = Nil;
+	    Term x = Prolog.Nil;
 	    for (int i=s.length(); i>0; i--) {
-		x = new ListTerm(SymbolTerm.makeSymbol(s.substring(i-1,i)), x);
+		x = new ListTerm(SymbolTerm.create(s.substring(i-1,i)), x);
 	    }
 	    if(! a2.unify(x, engine.trail)) 
 		return engine.fail();
diff --git a/src/builtin/PRED_atom_codes_2.java b/src/builtin/PRED_atom_codes_2.java
index cde5641..19cd473 100644
--- a/src/builtin/PRED_atom_codes_2.java
+++ b/src/builtin/PRED_atom_codes_2.java
@@ -7,8 +7,6 @@ import  com.googlecode.prolog_cafe.lang.*;
  * @version 1.1
  */
 public class PRED_atom_codes_2 extends Predicate.P2 {
-    private static final SymbolTerm Nil = SymbolTerm.makeSymbol("[]");
-
     public PRED_atom_codes_2(Term a1, Term a2, Operation cont) {
 	arg1 = a1;
 	arg2 = a2;
@@ -43,14 +41,14 @@ public class PRED_atom_codes_2 extends Predicate.P2 {
 		sb.append((char)i);
 		x = ((ListTerm)x).cdr().dereference();
 	    }
-	    if (! a1.unify(SymbolTerm.makeSymbol(sb.toString()), engine.trail))
+	    if (! a1.unify(SymbolTerm.create(sb.toString()), engine.trail))
 		return engine.fail();
 	    return cont;
 	} else { // atom_codes(+Atom, ?CharCodeList)
 	    if (! a1.isSymbol())
 		throw new IllegalTypeException(this, 1, "atom", a1);
 	    char[] chars = ((SymbolTerm)a1).name().toCharArray();
-	    Term x = Nil;
+	    Term x = Prolog.Nil;
 	    for (int i=chars.length; i>0; i--) {
 		x = new ListTerm(new IntegerTerm((int)chars[i-1]), x);
 	    }
diff --git a/src/builtin/PRED_atom_concat_3.java b/src/builtin/PRED_atom_concat_3.java
index 77e4dec..a12d54a 100644
--- a/src/builtin/PRED_atom_concat_3.java
+++ b/src/builtin/PRED_atom_concat_3.java
@@ -7,7 +7,7 @@ import com.googlecode.prolog_cafe.lang.*;
  * @version 1.0
 */
 public class PRED_atom_concat_3 extends Predicate.P3 {
-    private static final SymbolTerm AC_2 = SymbolTerm.makeSymbol("ac", 2);
+    private static final SymbolTerm AC_2 = SymbolTerm.intern("ac", 2);
 
     public PRED_atom_concat_3(Term a1, Term a2, Term a3, Operation cont) {
         arg1 = a1;
@@ -29,8 +29,8 @@ public class PRED_atom_concat_3 extends Predicate.P3 {
 	    int endIndex = str3.length();
 	    Term t = Prolog.Nil;
 	    for (int i=0; i<=endIndex; i++) {
-		Term[] args = {SymbolTerm.makeSymbol(str3.substring(0, i)),
-			       SymbolTerm.makeSymbol(str3.substring(i, endIndex))};
+		Term[] args = {SymbolTerm.create(str3.substring(0, i)),
+			       SymbolTerm.create(str3.substring(i, endIndex))};
 		t = new ListTerm(new StructureTerm(AC_2, args), t);
 	    }
 	    return new PRED_$member_in_reverse_2(new StructureTerm(AC_2, a1, a2), t, cont);
@@ -49,7 +49,7 @@ public class PRED_atom_concat_3 extends Predicate.P3 {
 	if (! a2.isSymbol())
 	    throw new IllegalTypeException(this, 2, "integer", a2);
 	String str3 = ((SymbolTerm) a1).name().concat(((SymbolTerm) a2).name());
-	if (! a3.unify(SymbolTerm.makeSymbol(str3), engine.trail))
+	if (! a3.unify(SymbolTerm.create(str3), engine.trail))
 	    return engine.fail();
         return cont;
     }
diff --git a/src/builtin/PRED_char_code_2.java b/src/builtin/PRED_char_code_2.java
index 159dca6..5762d2b 100644
--- a/src/builtin/PRED_char_code_2.java
+++ b/src/builtin/PRED_char_code_2.java
@@ -30,7 +30,7 @@ public class PRED_char_code_2 extends Predicate.P2 {
 	    int i = ((IntegerTerm)a2).intValue();
 	    if (! Character.isDefined(i))
 		throw new RepresentationException(this, 2, "character_code");
-	    if (! a1.unify(SymbolTerm.makeSymbol(String.valueOf((char)i)), engine.trail))
+	    if (! a1.unify(SymbolTerm.create((char)i), engine.trail))
 		return engine.fail();
 	} else if (a1.isSymbol()) { // char_code(+Char, ?CharCode)
 	    String s = ((SymbolTerm)a1).name();
diff --git a/src/builtin/PRED_close_2.java b/src/builtin/PRED_close_2.java
index e028100..9d9ddbb 100644
--- a/src/builtin/PRED_close_2.java
+++ b/src/builtin/PRED_close_2.java
@@ -8,10 +8,10 @@ import java.io.*;
  * @version 1.0
 */
 public class PRED_close_2 extends Predicate.P2 {
-    private static final SymbolTerm SYM_ALIAS_1 = SymbolTerm.makeSymbol("alias", 1);
-    private static final SymbolTerm SYM_FORCE_1 = SymbolTerm.makeSymbol("force", 1);
-    private static final SymbolTerm SYM_TRUE    = SymbolTerm.makeSymbol("true");
-    private static final SymbolTerm SYM_FALSE   = SymbolTerm.makeSymbol("false");
+    private static final SymbolTerm SYM_ALIAS_1 = SymbolTerm.intern("alias", 1);
+    private static final SymbolTerm SYM_FORCE_1 = SymbolTerm.intern("force", 1);
+    private static final SymbolTerm SYM_TRUE    = SymbolTerm.intern("true");
+    private static final SymbolTerm SYM_FALSE   = SymbolTerm.intern("false");
 
     public PRED_close_2(Term a1, Term a2, Operation cont) {
         arg1 = a1;
diff --git a/src/builtin/PRED_file_directory_name_2.java b/src/builtin/PRED_file_directory_name_2.java
index 739c223..94d7c0a 100644
--- a/src/builtin/PRED_file_directory_name_2.java
+++ b/src/builtin/PRED_file_directory_name_2.java
@@ -34,7 +34,7 @@ public class PRED_file_directory_name_2 extends Predicate.P2 {
     if (dir == null) throw new IllegalDomainException(this, 1, "file", a1);
 
     Term a2 = arg2.dereference();
-    if (a2.unify(SymbolTerm.makeSymbol(dir.getPath()), engine.trail))
+    if (a2.unify(SymbolTerm.create(dir.getPath()), engine.trail))
       return cont;
     else
       return engine.fail();
diff --git a/src/builtin/PRED_functor_3.java b/src/builtin/PRED_functor_3.java
index 83f27bd..d9b1466 100644
--- a/src/builtin/PRED_functor_3.java
+++ b/src/builtin/PRED_functor_3.java
@@ -7,7 +7,7 @@ import  com.googlecode.prolog_cafe.lang.*;
  * @version 1.0
  */
 public class PRED_functor_3 extends Predicate.P3 {
-    private static final SymbolTerm SYM_DOT = SymbolTerm.makeSymbol(".");
+    private static final SymbolTerm SYM_DOT = SymbolTerm.intern(".");
 
     public PRED_functor_3(Term a1, Term a2, Term a3, Operation cont) {
 	arg1 = a1;
@@ -55,7 +55,7 @@ public class PRED_functor_3 extends Predicate.P3 {
 	    Term[] args = new Term[n];
 	    for(int i=0; i<n; i++)
 		args[i] = new VariableTerm(engine);
-	    SymbolTerm sym = SymbolTerm.makeSymbol(((SymbolTerm)a2).name(), n);
+	    SymbolTerm sym = SymbolTerm.create(((SymbolTerm)a2).name(), n);
 	    if(! a1.unify(new StructureTerm(sym, args), engine.trail))
 		return engine.fail();
 	    return cont;
@@ -70,7 +70,7 @@ public class PRED_functor_3 extends Predicate.P3 {
 	    functor = SYM_DOT;
 	    arity   = new IntegerTerm(2);
 	} else if (a1.isStructure()) {
-	    functor = SymbolTerm.makeSymbol(((StructureTerm)a1).name());
+	    functor = SymbolTerm.create(((StructureTerm)a1).name());
 	    arity   = new IntegerTerm(((StructureTerm)a1).arity());
 	} else {
 	    return engine.fail();
diff --git a/src/builtin/PRED_get_char_2.java b/src/builtin/PRED_get_char_2.java
index 0804c7e..c6509df 100644
--- a/src/builtin/PRED_get_char_2.java
+++ b/src/builtin/PRED_get_char_2.java
@@ -8,7 +8,7 @@ import java.io.*;
  * @version 1.0
 */
 public class PRED_get_char_2 extends Predicate.P2 {
-    private static final SymbolTerm SYM_EOF = SymbolTerm.makeSymbol("end_of_file");
+    private static final SymbolTerm SYM_EOF = SymbolTerm.intern("end_of_file");
 
     public PRED_get_char_2(Term a1, Term a2, Operation cont) {
         arg1 = a1;
@@ -60,7 +60,7 @@ public class PRED_get_char_2 extends Predicate.P2 {
 	    } 
 	    if (! Character.isDefined(c))
 		throw new RepresentationException(this, 0, "character");
-	    if (! a2.unify(SymbolTerm.makeSymbol(String.valueOf((char)c)), engine.trail))
+	    if (! a2.unify(SymbolTerm.create((char)c), engine.trail))
 		return engine.fail();
 	    return cont;
 	} catch (IOException e) {
diff --git a/src/builtin/PRED_hash_get_3.java b/src/builtin/PRED_hash_get_3.java
index e2354c1..ecbfa88 100644
--- a/src/builtin/PRED_hash_get_3.java
+++ b/src/builtin/PRED_hash_get_3.java
@@ -8,8 +8,6 @@ import java.util.Hashtable;
    @version 1.0
 */
 public class PRED_hash_get_3 extends Predicate.P3 {
-    private static final SymbolTerm SYM_NIL = SymbolTerm.makeSymbol("[]");
-
     public PRED_hash_get_3(Term a1, Term a2, Term a3, Operation cont) {
         arg1 = a1;
         arg2 = a2;
@@ -43,7 +41,7 @@ public class PRED_hash_get_3 extends Predicate.P3 {
 	a2 = a2.dereference();
 	Term elem = ((HashtableOfTerm) hash).get(a2);
 	if (elem == null)
-	    elem = SYM_NIL;
+	    elem = Prolog.Nil;
 	if (! a3.unify(elem, engine.trail))
 	    return engine.fail();
         return cont;
diff --git a/src/builtin/PRED_hash_keys_2.java b/src/builtin/PRED_hash_keys_2.java
index 3dd6085..7d365b7 100644
--- a/src/builtin/PRED_hash_keys_2.java
+++ b/src/builtin/PRED_hash_keys_2.java
@@ -9,8 +9,6 @@ import java.util.Enumeration;
    @version 1.0
 */
 public class PRED_hash_keys_2 extends Predicate.P2 {
-    private static final SymbolTerm SYM_NIL = SymbolTerm.makeSymbol("[]");
-
     public PRED_hash_keys_2(Term a1, Term a2, Operation cont) {
         arg1 = a1;
         arg2 = a2;
@@ -39,7 +37,7 @@ public class PRED_hash_keys_2 extends Predicate.P2 {
 	}
 	if (! (hash instanceof HashtableOfTerm))
 	    throw new InternalException(this + ": Hash is not HashtableOfTerm");
-	Term keys = SYM_NIL;
+	Term keys = Prolog.Nil;
 	for (Term t : ((HashtableOfTerm) hash).keySet())
 	    keys = new ListTerm(t, keys);
 	if (! a2.unify(keys, engine.trail))
diff --git a/src/builtin/PRED_java_conversion_2.java b/src/builtin/PRED_java_conversion_2.java
index 22d2fcf..329fcc2 100644
--- a/src/builtin/PRED_java_conversion_2.java
+++ b/src/builtin/PRED_java_conversion_2.java
@@ -1,6 +1,6 @@
 package com.googlecode.prolog_cafe.builtin;
 import com.googlecode.prolog_cafe.lang.*;
-import java.util.Vector;
+import java.util.List;
 /**
  * <code>java_conversion/2</code>
  * @author Mutsunori Banbara (banbara@kobe-u.ac.jp)
@@ -53,12 +53,12 @@ public class PRED_java_conversion_2 extends Predicate.P2 {
 		   o instanceof Double) {
 	    return new DoubleTerm(((Number)o).doubleValue());
 	} else if (o instanceof String) {
-	    return SymbolTerm.makeSymbol((String) o);
-	} else if (o instanceof Vector) {
-	    Vector v = (Vector) o;
+	    return SymbolTerm.create((String) o);
+	} else if (o instanceof List) {
+	    List v = (List) o;
 	    Term t = Prolog.Nil;
 	    for(int i= v.size(); i>0; i--) {
-		t = new ListTerm(inverseConversion(v.elementAt(i-1)), t);
+		t = new ListTerm(inverseConversion(v.get(i-1)), t);
 	    }
 	    return t;
 	}
diff --git a/src/builtin/PRED_keysort_2.java b/src/builtin/PRED_keysort_2.java
index f61196d..abef82f 100644
--- a/src/builtin/PRED_keysort_2.java
+++ b/src/builtin/PRED_keysort_2.java
@@ -8,8 +8,7 @@ import java.util.Arrays;
  * @version 1.1
  */
 public class PRED_keysort_2 extends Predicate.P2 {
-    private static final SymbolTerm SYM_HYPHEN_2 = SymbolTerm.makeSymbol("-", 2);
-    private static final SymbolTerm Nil = SymbolTerm.makeSymbol("[]");
+    private static final SymbolTerm SYM_HYPHEN_2 = SymbolTerm.intern("-", 2);
 
     public PRED_keysort_2(Term a1, Term a2, Operation cont) {
 	arg1 = a1;
@@ -29,8 +28,8 @@ public class PRED_keysort_2 extends Predicate.P2 {
 	a1 = a1.dereference();
 	if (a1.isVariable()) {
 	    throw new PInstantiationException(this, 1);
-	} else if (a1.equals(Nil)) {
-	    if (! a2.unify(Nil, engine.trail))
+	} else if (a1.equals(Prolog.Nil)) {
+	    if (! a2.unify(Prolog.Nil, engine.trail))
 		return engine.fail();
 	    return cont;
 	} else if (! a1.isList()) {
@@ -51,7 +50,7 @@ public class PRED_keysort_2 extends Predicate.P2 {
 		throw new IllegalTypeException(this, 1, "key_value_pair", a1);
 	    tmp = ((ListTerm)tmp).cdr().dereference();
 	}
-	if (! tmp.equals(Nil))
+	if (! tmp.equals(Prolog.Nil))
 	    throw new PInstantiationException(this, 1);
 	try {
 	    Arrays.sort(list, new KeySortComparator());
@@ -60,7 +59,7 @@ public class PRED_keysort_2 extends Predicate.P2 {
 	} catch (ClassCastException e1) {
 	    throw new JavaException(this, 1, e1);
 	}
-	tmp = Nil;
+	tmp = Prolog.Nil;
 	for (int i=list.length-1; i>=0; i--) {
 	    tmp = new ListTerm(list[i], tmp);
 	}
diff --git a/src/builtin/PRED_new_hash_2.java b/src/builtin/PRED_new_hash_2.java
index f3264cc..8fbbdb3 100644
--- a/src/builtin/PRED_new_hash_2.java
+++ b/src/builtin/PRED_new_hash_2.java
@@ -7,8 +7,7 @@ import com.googlecode.prolog_cafe.lang.*;
    @version 1.0
 */
 public class PRED_new_hash_2 extends Predicate.P2 {
-    private static final SymbolTerm SYM_NIL     = SymbolTerm.makeSymbol("[]");
-    private static final SymbolTerm SYM_ALIAS_1 = SymbolTerm.makeSymbol("alias", 1);
+    private static final SymbolTerm SYM_ALIAS_1 = SymbolTerm.intern("alias", 1);
 
     public PRED_new_hash_2(Term a1, Term a2, Operation cont) {
         arg1 = a1;
diff --git a/src/builtin/PRED_number_chars_2.java b/src/builtin/PRED_number_chars_2.java
index ce27be3..75899c4 100644
--- a/src/builtin/PRED_number_chars_2.java
+++ b/src/builtin/PRED_number_chars_2.java
@@ -7,8 +7,6 @@ import  com.googlecode.prolog_cafe.lang.*;
  * @version 1.0
  */
 public class PRED_number_chars_2 extends Predicate.P2 {
-    private static final SymbolTerm Nil = SymbolTerm.makeSymbol("[]");
-
     public PRED_number_chars_2(Term a1, Term a2, Operation cont) {
 	arg1 = a1;
 	arg2 = a2;
@@ -60,9 +58,9 @@ public class PRED_number_chars_2 extends Predicate.P2 {
 	    }
 	} else if (a1.isNumber()) { // number_chars(+Number, ?CharList)
 	    String s = a1.toString();
-	    Term y = Nil;
+	    Term y = Prolog.Nil;
 	    for (int i=s.length(); i>0; i--) {
-		y = new ListTerm(SymbolTerm.makeSymbol(s.substring(i-1,i)), y);
+		y = new ListTerm(SymbolTerm.create(s.substring(i-1,i)), y);
 	    }
 	    if (! a2.unify(y, engine.trail) ) 
 		return engine.fail();
diff --git a/src/builtin/PRED_number_codes_2.java b/src/builtin/PRED_number_codes_2.java
index c83f7f9..0c6437e 100644
--- a/src/builtin/PRED_number_codes_2.java
+++ b/src/builtin/PRED_number_codes_2.java
@@ -7,8 +7,6 @@ import  com.googlecode.prolog_cafe.lang.*;
  * @version 1.1
  */
 public class PRED_number_codes_2 extends Predicate.P2 {
-    private static final SymbolTerm Nil = SymbolTerm.makeSymbol("[]");
-
     public PRED_number_codes_2(Term a1, Term a2, Operation cont) {
 	arg1 = a1;
 	arg2 = a2;
@@ -59,7 +57,7 @@ public class PRED_number_codes_2 extends Predicate.P2 {
 	    }
 	} else if (a1.isNumber()) { // number_codes(+Number, ?CharCodeList)
 	    char[] chars = a1.toString().toCharArray();
-	    Term y = Nil;
+	    Term y = Prolog.Nil;
 	    for (int i=chars.length; i>0; i--) {
 		y = new ListTerm(new IntegerTerm((int)chars[i-1]), y);
 	    }
diff --git a/src/builtin/PRED_open_4.java b/src/builtin/PRED_open_4.java
index 438df3c..8f3f6ec 100644
--- a/src/builtin/PRED_open_4.java
+++ b/src/builtin/PRED_open_4.java
@@ -8,17 +8,16 @@ import java.io.*;
    @version 1.0
 */
 public class PRED_open_4 extends Predicate.P4 {
-    private static final SymbolTerm SYM_NIL         = SymbolTerm.makeSymbol("[]");
-    private static final SymbolTerm SYM_TEXT        = SymbolTerm.makeSymbol("text");
-    private static final SymbolTerm SYM_READ        = SymbolTerm.makeSymbol("read");
-    private static final SymbolTerm SYM_WRITE       = SymbolTerm.makeSymbol("write");
-    private static final SymbolTerm SYM_APPEND      = SymbolTerm.makeSymbol("append");
-    private static final SymbolTerm SYM_INPUT       = SymbolTerm.makeSymbol("input");
-    private static final SymbolTerm SYM_OUTPUT      = SymbolTerm.makeSymbol("output");
-    private static final SymbolTerm SYM_ALIAS_1     = SymbolTerm.makeSymbol("alias", 1);
-    private static final SymbolTerm SYM_MODE_1      = SymbolTerm.makeSymbol("mode", 1);
-    private static final SymbolTerm SYM_TYPE_1      = SymbolTerm.makeSymbol("type", 1);
-    private static final SymbolTerm SYM_FILE_NAME_1 = SymbolTerm.makeSymbol("file_name", 1);
+    private static final SymbolTerm SYM_TEXT        = SymbolTerm.intern("text");
+    private static final SymbolTerm SYM_READ        = SymbolTerm.intern("read");
+    private static final SymbolTerm SYM_WRITE       = SymbolTerm.intern("write");
+    private static final SymbolTerm SYM_APPEND      = SymbolTerm.intern("append");
+    private static final SymbolTerm SYM_INPUT       = SymbolTerm.intern("input");
+    private static final SymbolTerm SYM_OUTPUT      = SymbolTerm.intern("output");
+    private static final SymbolTerm SYM_ALIAS_1     = SymbolTerm.intern("alias", 1);
+    private static final SymbolTerm SYM_MODE_1      = SymbolTerm.intern("mode", 1);
+    private static final SymbolTerm SYM_TYPE_1      = SymbolTerm.intern("type", 1);
+    private static final SymbolTerm SYM_FILE_NAME_1 = SymbolTerm.intern("file_name", 1);
 
     public PRED_open_4(Term a1, Term a2, Term a3, Term a4, Operation cont) {
         arg1 = a1;
@@ -33,7 +32,7 @@ public class PRED_open_4 extends Predicate.P4 {
         engine.setB0();
 	File file;
 	Term alias = null;
-	Term opts = SYM_NIL;
+	Term opts = Prolog.Nil;
 	JavaObjectTerm streamObject;
         Term a1, a2, a3, a4;
         a1 = arg1;
@@ -114,7 +113,7 @@ public class PRED_open_4 extends Predicate.P4 {
 	}
 	opts = new ListTerm(new StructureTerm(SYM_TYPE_1, SYM_TEXT), opts);
 	opts = new ListTerm(new StructureTerm(SYM_MODE_1, a2), opts);
-	opts = new ListTerm(new StructureTerm(SYM_FILE_NAME_1, SymbolTerm.makeSymbol(file.getAbsolutePath())), opts);
+	opts = new ListTerm(new StructureTerm(SYM_FILE_NAME_1, SymbolTerm.create(file.getAbsolutePath())), opts);
 	if (alias != null) {
 	    engine.getStreamManager().put(alias, streamObject);
 	    opts = new ListTerm(new StructureTerm(SYM_ALIAS_1, alias), opts);
diff --git a/src/builtin/PRED_peek_char_2.java b/src/builtin/PRED_peek_char_2.java
index 05b2008..cb7330c 100644
--- a/src/builtin/PRED_peek_char_2.java
+++ b/src/builtin/PRED_peek_char_2.java
@@ -8,7 +8,7 @@ import java.io.*;
    @version 1.0
 */
 public class PRED_peek_char_2 extends Predicate.P2 {
-    private static final SymbolTerm SYM_EOF = SymbolTerm.makeSymbol("end_of_file");
+    private static final SymbolTerm SYM_EOF = SymbolTerm.intern("end_of_file");
 
     public PRED_peek_char_2(Term a1, Term a2, Operation cont) {
         arg1 = a1;
@@ -61,7 +61,7 @@ public class PRED_peek_char_2 extends Predicate.P2 {
 	    if (! Character.isDefined(c))
 		throw new RepresentationException(this, 0, "character");
 	    ((PushbackReader)stream).unread(c);
-	    if (! a2.unify(SymbolTerm.makeSymbol(String.valueOf((char)c)), engine.trail))
+	    if (! a2.unify(SymbolTerm.create((char)c), engine.trail))
 		return engine.fail();
 	    return cont;
 	} catch (IOException e) {
diff --git a/src/builtin/PRED_sort_2.java b/src/builtin/PRED_sort_2.java
index fd6eddd..162f79f 100644
--- a/src/builtin/PRED_sort_2.java
+++ b/src/builtin/PRED_sort_2.java
@@ -8,8 +8,6 @@ import java.util.Arrays;
  * @version 1.1
  */
 public class PRED_sort_2 extends Predicate.P2 {
-    private static final SymbolTerm Nil = SymbolTerm.makeSymbol("[]");
-
     public PRED_sort_2(Term a1, Term a2, Operation cont) {
 	arg1 = a1;
 	arg2 = a2;
@@ -28,8 +26,8 @@ public class PRED_sort_2 extends Predicate.P2 {
 	a1 = a1.dereference();
 	if (a1.isVariable()) {
 	    throw new PInstantiationException(this, 1);
-	} else if (a1.equals(Nil)) {
-	    if (! a2.unify(Nil, engine.trail))
+	} else if (a1.equals(Prolog.Nil)) {
+	    if (! a2.unify(Prolog.Nil, engine.trail))
 		return engine.fail();
 	    return cont;
 	} else if (! a1.isList()) {
@@ -44,14 +42,14 @@ public class PRED_sort_2 extends Predicate.P2 {
 	    list[i] = ((ListTerm)tmp).car().dereference();
 	    tmp = ((ListTerm)tmp).cdr().dereference();
 	}
-	if (! tmp.equals(Nil))
+	if (! tmp.equals(Prolog.Nil))
 	    throw new PInstantiationException(this, 1);
 	try {
 	    Arrays.sort(list);
 	} catch (ClassCastException e) {
 	    throw new JavaException(this, 1, e);
 	}
-	tmp = Nil;
+	tmp = Prolog.Nil;
 	tmp2 = null;
 	for (int i=list.length-1; i>=0; i--) {
 	    if (! list[i].equals(tmp2))
diff --git a/src/compiler/Compiler.java b/src/compiler/Compiler.java
index bfd3b9d..ed57398 100644
--- a/src/compiler/Compiler.java
+++ b/src/compiler/Compiler.java
@@ -85,7 +85,7 @@ public class Compiler {
       final boolean onByDefault;
 
       Option(String symbol, boolean onByDefault) {
-        this.symbol = SymbolTerm.makeSymbol(symbol);
+        this.symbol = SymbolTerm.intern(symbol);
         this.onByDefault = onByDefault;
       }
     }
@@ -112,8 +112,8 @@ public class Compiler {
 		  throw new CompileException(new FileNotFoundException(_prolog));
 
 	    // Create arguments
-	    Term prolog = SymbolTerm.makeSymbol(_prolog);
-	    Term wam    = SymbolTerm.makeSymbol(_wam);
+	    Term prolog = SymbolTerm.create(_prolog);
+	    Term wam    = SymbolTerm.create(_wam);
 	    Term op     = Prolog.Nil;
 	    for (Option opt : options)
 	      op = new ListTerm(opt.symbol, op);
@@ -141,8 +141,8 @@ public class Compiler {
          throw new CompileException(new FileNotFoundException(_dir));
 
 	    // Create arguments
-	    Term wam    = SymbolTerm.makeSymbol(_wam);
-	    Term dir    = SymbolTerm.makeSymbol(_dir);
+	    Term wam    = SymbolTerm.create(_wam);
+	    Term dir    = SymbolTerm.create(_dir);
 	    ListTerm args = new ListTerm(wam, new ListTerm(dir, Prolog.Nil));
 	    try {
 	      if (!pcl.execute("com.googlecode.prolog_cafe.compiler.am2j", "am2j", args))
diff --git a/src/compiler/am2j.pl b/src/compiler/am2j.pl
index bf11804..96354be 100644
--- a/src/compiler/am2j.pl
+++ b/src/compiler/am2j.pl
@@ -271,7 +271,7 @@ write_java0(put_con(C,X), _, Out) :- !,
 	tab(Out, 4),
 	write(Out, 'static final SymbolTerm '),
 	write_reg(X, Out),
-	write(Out, ' = SymbolTerm.makeSymbol("'),
+	write(Out, ' = SymbolTerm.intern("'),
 	(C = F/A -> 
 	    write_constant(F, Out), write(Out, '", '), write(Out, A), write(Out, ');')
 	    ;
@@ -727,7 +727,7 @@ write_inline0(atomic(X), _, Out) :- !,
 	write_if_fail(op('&&',op('!',@('isSymbol'(X))), op('!',@('isNumber'(X)))), [X], 8, Out).
 write_inline0(java(X,Y), _, Out) :- !, 
 	write_if_fail(op('!', @('isJavaObject'(X))), [X], 8, Out),
-	EXP = #('SymbolTerm.makeSymbol'(@(getName(@(getClass(@(object(cast('JavaObjectTerm',X))))))))),
+	EXP = #('SymbolTerm.create'(@(getName(@(getClass(@(object(cast('JavaObjectTerm',X))))))))),
 	write_if_fail(op('!', unify(Y,EXP)), [], 8, Out).
 write_inline0(ground(X), _, Out) :- !, write_if_fail(op('!', @('isGround'(X))), [X], 8, Out).
 % Term comparison
diff --git a/src/lang/Arithmetic.java b/src/lang/Arithmetic.java
index 6494a46..f74591e 100644
--- a/src/lang/Arithmetic.java
+++ b/src/lang/Arithmetic.java
@@ -9,48 +9,48 @@ package com.googlecode.prolog_cafe.lang;
  * @version 1.0
  */
 public class Arithmetic {
-    static final SymbolTerm SYM_RANDOM       = SymbolTerm.makeSymbol("random");
-    static final SymbolTerm SYM_PI           = SymbolTerm.makeSymbol("pi");
-    static final SymbolTerm SYM_E            = SymbolTerm.makeSymbol("e");
-    static final SymbolTerm SYM_ADD_1        = SymbolTerm.makeSymbol("+", 1);
-    static final SymbolTerm SYM_NEGATE_1     = SymbolTerm.makeSymbol("-", 1);
-    static final SymbolTerm SYM_ADD_2        = SymbolTerm.makeSymbol("+", 2);
-    static final SymbolTerm SYM_SUBTRACT_2   = SymbolTerm.makeSymbol("-", 2);
-    static final SymbolTerm SYM_MULTIPLY_2   = SymbolTerm.makeSymbol("*", 2);
-    static final SymbolTerm SYM_DIVIDE_2     = SymbolTerm.makeSymbol("/", 2);
-    static final SymbolTerm SYM_INTDIVIDE_2  = SymbolTerm.makeSymbol("//", 2);
-    static final SymbolTerm SYM_MOD_2        = SymbolTerm.makeSymbol("mod", 2);
-    static final SymbolTerm SYM_SHIFTLEFT_2  = SymbolTerm.makeSymbol("<<", 2);
-    static final SymbolTerm SYM_SHIFTRIGHT_2 = SymbolTerm.makeSymbol(">>", 2);
-    static final SymbolTerm SYM_NOT_1        = SymbolTerm.makeSymbol("\\", 1);
-    static final SymbolTerm SYM_AND_2        = SymbolTerm.makeSymbol("/\\", 2);
-    static final SymbolTerm SYM_OR_2         = SymbolTerm.makeSymbol("\\/", 2);
-    static final SymbolTerm SYM_XOR_2        = SymbolTerm.makeSymbol("#", 2);
-    static final SymbolTerm SYM_POW_2        = SymbolTerm.makeSymbol("**", 2);
-    static final SymbolTerm SYM_ABS_1        = SymbolTerm.makeSymbol("abs", 1);
-    static final SymbolTerm SYM_ACOS_1       = SymbolTerm.makeSymbol("acos", 1);
-    static final SymbolTerm SYM_ASIN_1       = SymbolTerm.makeSymbol("asin", 1);
-    static final SymbolTerm SYM_ATAN_1       = SymbolTerm.makeSymbol("atan", 1);
-    static final SymbolTerm SYM_CEIL_1       = SymbolTerm.makeSymbol("ceiling", 1);
-    static final SymbolTerm SYM_COS_1        = SymbolTerm.makeSymbol("cos", 1);
-    static final SymbolTerm SYM_DEGREES_1    = SymbolTerm.makeSymbol("degrees", 1);
-    static final SymbolTerm SYM_EXP_1        = SymbolTerm.makeSymbol("exp", 1);
-    static final SymbolTerm SYM_FLOOR_1      = SymbolTerm.makeSymbol("floor", 1);
-    static final SymbolTerm SYM_LOG_1        = SymbolTerm.makeSymbol("log", 1);
-    static final SymbolTerm SYM_MAX_2        = SymbolTerm.makeSymbol("max", 2);
-    static final SymbolTerm SYM_MIN_2        = SymbolTerm.makeSymbol("min", 2);
-    static final SymbolTerm SYM_RADIANS_1    = SymbolTerm.makeSymbol("radians", 1);
-    static final SymbolTerm SYM_RINT_1       = SymbolTerm.makeSymbol("rint", 1);
-    static final SymbolTerm SYM_ROUND_1      = SymbolTerm.makeSymbol("round", 1);
-    static final SymbolTerm SYM_SIN_1        = SymbolTerm.makeSymbol("sin", 1);
-    static final SymbolTerm SYM_SQRT_1       = SymbolTerm.makeSymbol("sqrt", 1);
-    static final SymbolTerm SYM_TAN_1        = SymbolTerm.makeSymbol("tan", 1);
-    static final SymbolTerm SYM_REM_2        = SymbolTerm.makeSymbol("rem", 2);
-    static final SymbolTerm SYM_SIGN_1       = SymbolTerm.makeSymbol("sign", 1);
-    static final SymbolTerm SYM_FLOAT_1      = SymbolTerm.makeSymbol("float", 1);
-    static final SymbolTerm SYM_INTPART_1    = SymbolTerm.makeSymbol("float_integer_part", 1);
-    static final SymbolTerm SYM_FRACTPART_1  = SymbolTerm.makeSymbol("float_fractional_part", 1);
-    static final SymbolTerm SYM_TRUNCATE_1   = SymbolTerm.makeSymbol("truncate", 1);
+    static final SymbolTerm SYM_RANDOM       = SymbolTerm.intern("random");
+    static final SymbolTerm SYM_PI           = SymbolTerm.intern("pi");
+    static final SymbolTerm SYM_E            = SymbolTerm.intern("e");
+    static final SymbolTerm SYM_ADD_1        = SymbolTerm.intern("+", 1);
+    static final SymbolTerm SYM_NEGATE_1     = SymbolTerm.intern("-", 1);
+    static final SymbolTerm SYM_ADD_2        = SymbolTerm.intern("+", 2);
+    static final SymbolTerm SYM_SUBTRACT_2   = SymbolTerm.intern("-", 2);
+    static final SymbolTerm SYM_MULTIPLY_2   = SymbolTerm.intern("*", 2);
+    static final SymbolTerm SYM_DIVIDE_2     = SymbolTerm.intern("/", 2);
+    static final SymbolTerm SYM_INTDIVIDE_2  = SymbolTerm.intern("//", 2);
+    static final SymbolTerm SYM_MOD_2        = SymbolTerm.intern("mod", 2);
+    static final SymbolTerm SYM_SHIFTLEFT_2  = SymbolTerm.intern("<<", 2);
+    static final SymbolTerm SYM_SHIFTRIGHT_2 = SymbolTerm.intern(">>", 2);
+    static final SymbolTerm SYM_NOT_1        = SymbolTerm.intern("\\", 1);
+    static final SymbolTerm SYM_AND_2        = SymbolTerm.intern("/\\", 2);
+    static final SymbolTerm SYM_OR_2         = SymbolTerm.intern("\\/", 2);
+    static final SymbolTerm SYM_XOR_2        = SymbolTerm.intern("#", 2);
+    static final SymbolTerm SYM_POW_2        = SymbolTerm.intern("**", 2);
+    static final SymbolTerm SYM_ABS_1        = SymbolTerm.intern("abs", 1);
+    static final SymbolTerm SYM_ACOS_1       = SymbolTerm.intern("acos", 1);
+    static final SymbolTerm SYM_ASIN_1       = SymbolTerm.intern("asin", 1);
+    static final SymbolTerm SYM_ATAN_1       = SymbolTerm.intern("atan", 1);
+    static final SymbolTerm SYM_CEIL_1       = SymbolTerm.intern("ceiling", 1);
+    static final SymbolTerm SYM_COS_1        = SymbolTerm.intern("cos", 1);
+    static final SymbolTerm SYM_DEGREES_1    = SymbolTerm.intern("degrees", 1);
+    static final SymbolTerm SYM_EXP_1        = SymbolTerm.intern("exp", 1);
+    static final SymbolTerm SYM_FLOOR_1      = SymbolTerm.intern("floor", 1);
+    static final SymbolTerm SYM_LOG_1        = SymbolTerm.intern("log", 1);
+    static final SymbolTerm SYM_MAX_2        = SymbolTerm.intern("max", 2);
+    static final SymbolTerm SYM_MIN_2        = SymbolTerm.intern("min", 2);
+    static final SymbolTerm SYM_RADIANS_1    = SymbolTerm.intern("radians", 1);
+    static final SymbolTerm SYM_RINT_1       = SymbolTerm.intern("rint", 1);
+    static final SymbolTerm SYM_ROUND_1      = SymbolTerm.intern("round", 1);
+    static final SymbolTerm SYM_SIN_1        = SymbolTerm.intern("sin", 1);
+    static final SymbolTerm SYM_SQRT_1       = SymbolTerm.intern("sqrt", 1);
+    static final SymbolTerm SYM_TAN_1        = SymbolTerm.intern("tan", 1);
+    static final SymbolTerm SYM_REM_2        = SymbolTerm.intern("rem", 2);
+    static final SymbolTerm SYM_SIGN_1       = SymbolTerm.intern("sign", 1);
+    static final SymbolTerm SYM_FLOAT_1      = SymbolTerm.intern("float", 1);
+    static final SymbolTerm SYM_INTPART_1    = SymbolTerm.intern("float_integer_part", 1);
+    static final SymbolTerm SYM_FRACTPART_1  = SymbolTerm.intern("float_fractional_part", 1);
+    static final SymbolTerm SYM_TRUNCATE_1   = SymbolTerm.intern("truncate", 1);
 
     /**
      * Evaluates <code>_t</code> as an arithmetic expression, 
diff --git a/src/lang/BufferingPrologControl.java b/src/lang/BufferingPrologControl.java
index 9a4a04b..c66ca00 100644
--- a/src/lang/BufferingPrologControl.java
+++ b/src/lang/BufferingPrologControl.java
@@ -23,10 +23,10 @@ public class BufferingPrologControl extends PrologControl {
    * @return true if initialization was successful.
    */
   public boolean initialize(String... pkgs) {
-    Term goal = SymbolTerm.makeSymbol("true");
+    Term goal = SymbolTerm.intern("true");
     Term head = Prolog.Nil;
     for (int i = pkgs.length - 1; 0 <= i; i--)
-      head = new ListTerm(SymbolTerm.makeSymbol(pkgs[i]), head);
+      head = new ListTerm(SymbolTerm.intern(pkgs[i]), head);
     return execute(Prolog.BUILTIN, "initialization", head, goal);
   }
 
diff --git a/src/lang/EvaluationException.java b/src/lang/EvaluationException.java
index 2aca56a..f3d8bda 100644
--- a/src/lang/EvaluationException.java
+++ b/src/lang/EvaluationException.java
@@ -11,7 +11,7 @@ package com.googlecode.prolog_cafe.lang;
  */
 public class EvaluationException extends BuiltinException {
     /** A functor symbol of <code>evaluation_error/3</code>. */
-    public static final SymbolTerm EVALUATION_ERROR = SymbolTerm.makeSymbol("evaluation_error", 3);
+    public static final SymbolTerm EVALUATION_ERROR = SymbolTerm.intern("evaluation_error", 3);
 
     /* errorType ::= float_overflow | int_overflow | undefined | underflow | zero_devisor */
     /** Holds a string representation of error type. */
@@ -36,7 +36,7 @@ public class EvaluationException extends BuiltinException {
 	Term[] args = {
 	    new JavaObjectTerm(goal), 
 	    new IntegerTerm(argNo), 
-	    SymbolTerm.makeSymbol(errorType)};
+	    SymbolTerm.create(errorType)};
 	return new StructureTerm(EVALUATION_ERROR, args);
     }
 
diff --git a/src/lang/ExistenceException.java b/src/lang/ExistenceException.java
index 99a702e..6a7a672 100644
--- a/src/lang/ExistenceException.java
+++ b/src/lang/ExistenceException.java
@@ -10,7 +10,7 @@ package com.googlecode.prolog_cafe.lang;
  */
 public class ExistenceException extends BuiltinException {
     /** A functor symbol of <code>existence_error/5</code>. */
-    public static final SymbolTerm EXISTENCE_ERROR = SymbolTerm.makeSymbol("existence_error", 5);
+    public static final SymbolTerm EXISTENCE_ERROR = SymbolTerm.intern("existence_error", 5);
 
     /* objType ::= procedure | source_sink | stream | hash */
     /** Holds a string representation of object type. */
@@ -47,9 +47,9 @@ public class ExistenceException extends BuiltinException {
 	Term[] args = {
 	    new JavaObjectTerm(goal), 
 	    new IntegerTerm(argNo),
-	    SymbolTerm.makeSymbol(objType),
+	    SymbolTerm.create(objType),
 	    culprit,
-	    SymbolTerm.makeSymbol(message)};
+	    SymbolTerm.create(message)};
 	return new StructureTerm(EXISTENCE_ERROR, args);
     }
 
diff --git a/src/lang/IllegalDomainException.java b/src/lang/IllegalDomainException.java
index ccbbb90..7edd75d 100644
--- a/src/lang/IllegalDomainException.java
+++ b/src/lang/IllegalDomainException.java
@@ -11,7 +11,7 @@ package com.googlecode.prolog_cafe.lang;
  */
 public class IllegalDomainException extends BuiltinException {
     /** A functor symbol of <code>domain_error/4</code>. */
-    public static final SymbolTerm DOMAIN_ERROR = SymbolTerm.makeSymbol("domain_error", 4);
+    public static final SymbolTerm DOMAIN_ERROR = SymbolTerm.intern("domain_error", 4);
 
     /*
       domain ::= character_code_list | close_option | flag_value | io_mode | 
@@ -50,7 +50,7 @@ public class IllegalDomainException extends BuiltinException {
 	Term[] args = {
 	    new JavaObjectTerm(goal), 
 	    new IntegerTerm(argNo), 
-	    SymbolTerm.makeSymbol(domain),
+	    SymbolTerm.create(domain),
 	    culprit};
 	return new StructureTerm(DOMAIN_ERROR, args);
     }
diff --git a/src/lang/IllegalTypeException.java b/src/lang/IllegalTypeException.java
index ee05494..d6fff68 100644
--- a/src/lang/IllegalTypeException.java
+++ b/src/lang/IllegalTypeException.java
@@ -10,7 +10,7 @@ package com.googlecode.prolog_cafe.lang;
  */
 public class IllegalTypeException extends BuiltinException {
     /** A functor symbol of <code>type_error/4</code>. */
-    public static final SymbolTerm TYPE_ERROR = SymbolTerm.makeSymbol("type_error", 4);
+    public static final SymbolTerm TYPE_ERROR = SymbolTerm.intern("type_error", 4);
 
     /*
       type ::= atom | atomic | byte | callable | character | compound | evaluable |
@@ -47,7 +47,7 @@ public class IllegalTypeException extends BuiltinException {
 	Term[] args = {
 	    new JavaObjectTerm(goal), 
 	    new IntegerTerm(argNo), 
-	    SymbolTerm.makeSymbol(type),
+	    SymbolTerm.create(type),
 	    culprit};
 	return new StructureTerm(TYPE_ERROR, args);
     }
diff --git a/src/lang/InternalException.java b/src/lang/InternalException.java
index e953b41..ab08b0b 100644
--- a/src/lang/InternalException.java
+++ b/src/lang/InternalException.java
@@ -8,7 +8,7 @@ package com.googlecode.prolog_cafe.lang;
  */
 public class InternalException extends PrologException {
     /** A functor symbol of <code>internal_error/1</code>. */
-    public static final SymbolTerm INTERNAL_ERROR = SymbolTerm.makeSymbol("internal_error", 1);
+    public static final SymbolTerm INTERNAL_ERROR = SymbolTerm.intern("internal_error", 1);
 
     /** Holds a message. */
     public String message;
@@ -22,7 +22,7 @@ public class InternalException extends PrologException {
      * <code>internal_error(message)</code>.
      */
     public Term getMessageTerm() {
-	Term[] args = {SymbolTerm.makeSymbol(message)};
+	Term[] args = {SymbolTerm.create(message)};
 	return new StructureTerm(INTERNAL_ERROR, args);
     }
 
diff --git a/src/lang/JavaException.java b/src/lang/JavaException.java
index 8065e61..a0f1e2e 100644
--- a/src/lang/JavaException.java
+++ b/src/lang/JavaException.java
@@ -11,7 +11,7 @@ package com.googlecode.prolog_cafe.lang;
  */
 public class JavaException extends BuiltinException {
     /** A functor symbol of <code>java_error/3</code>. */
-    public static final SymbolTerm JAVA_ERROR = SymbolTerm.makeSymbol("java_error", 3);
+    public static final SymbolTerm JAVA_ERROR = SymbolTerm.intern("java_error", 3);
 
     /** Holds a Java exception. */
     public Exception e;
diff --git a/src/lang/ListTerm.java b/src/lang/ListTerm.java
index a585308..942df5d 100644
--- a/src/lang/ListTerm.java
+++ b/src/lang/ListTerm.java
@@ -33,7 +33,7 @@ import java.util.List;
  */
 public class ListTerm extends Term {
     /** A functor <code>'.' /2</code>. */
-    protected static final SymbolTerm SYM_DOT = SymbolTerm.makeSymbol(".", 2);
+    protected static final SymbolTerm SYM_DOT = SymbolTerm.intern(".", 2);
 
     /** Holds the first element of this <code>ListTerm</code>. */
     protected Term car;
diff --git a/src/lang/PInstantiationException.java b/src/lang/PInstantiationException.java
index fb42f97..203d1b3 100644
--- a/src/lang/PInstantiationException.java
+++ b/src/lang/PInstantiationException.java
@@ -11,7 +11,7 @@ package com.googlecode.prolog_cafe.lang;
  */
 public class PInstantiationException extends BuiltinException {
     /** A functor symbol of <code>instantiation/2</code>. */
-    public static final SymbolTerm INSTANTIATION_ERROR = SymbolTerm.makeSymbol("instantiation_error", 2);
+    public static final SymbolTerm INSTANTIATION_ERROR = SymbolTerm.intern("instantiation_error", 2);
 
     /** Constructs a new <code>PInstantiationException</code>. */
     public PInstantiationException(){}
diff --git a/src/lang/PermissionException.java b/src/lang/PermissionException.java
index 0de6fbb..c053386 100644
--- a/src/lang/PermissionException.java
+++ b/src/lang/PermissionException.java
@@ -10,7 +10,7 @@ package com.googlecode.prolog_cafe.lang;
  */
 public class PermissionException extends BuiltinException {
     /** A functor symbol of <code>permission_error/5</code>. */
-    public static final SymbolTerm PERMISSION_ERROR = SymbolTerm.makeSymbol("permission_error", 5);
+    public static final SymbolTerm PERMISSION_ERROR = SymbolTerm.intern("permission_error", 5);
 
     /* operation ::= access | create | input | modify | open | output | reposition | new */
     /** Holds a string representation of operation. */
@@ -50,10 +50,10 @@ public class PermissionException extends BuiltinException {
     public Term getMessageTerm() {
 	Term[] args = {
 	    new JavaObjectTerm(goal), 
-	    SymbolTerm.makeSymbol(operation),
-	    SymbolTerm.makeSymbol(permissionType),
+	    SymbolTerm.create(operation),
+	    SymbolTerm.create(permissionType),
 	    culprit,
-	    SymbolTerm.makeSymbol(message)};
+	    SymbolTerm.create(message)};
 	return new StructureTerm(PERMISSION_ERROR, args);
     }
 
diff --git a/src/lang/Prolog.java b/src/lang/Prolog.java
index 1418d22..a890026 100644
--- a/src/lang/Prolog.java
+++ b/src/lang/Prolog.java
@@ -103,20 +103,20 @@ public final class Prolog {
     public static final String BUILTIN = "com.googlecode.prolog_cafe.builtin";
 
     /** Holds an atom <code>[]<code> (empty list). */
-    public static final SymbolTerm Nil     = SymbolTerm.makeSymbol("[]");
+    public static final SymbolTerm Nil     = SymbolTerm.intern("[]");
 
     /* Some symbols for stream options */
-    static final SymbolTerm SYM_MODE_1     = SymbolTerm.makeSymbol("mode", 1);
-    static final SymbolTerm SYM_ALIAS_1    = SymbolTerm.makeSymbol("alias", 1);
-    static final SymbolTerm SYM_TYPE_1     = SymbolTerm.makeSymbol("type", 1);
-    static final SymbolTerm SYM_READ       = SymbolTerm.makeSymbol("read");
-    static final SymbolTerm SYM_APPEND     = SymbolTerm.makeSymbol("append");
-    static final SymbolTerm SYM_INPUT      = SymbolTerm.makeSymbol("input");
-    static final SymbolTerm SYM_OUTPUT     = SymbolTerm.makeSymbol("output");
-    static final SymbolTerm SYM_TEXT       = SymbolTerm.makeSymbol("text");
-    static final SymbolTerm SYM_USERINPUT  = SymbolTerm.makeSymbol("user_input");
-    static final SymbolTerm SYM_USEROUTPUT = SymbolTerm.makeSymbol("user_output");
-    static final SymbolTerm SYM_USERERROR  = SymbolTerm.makeSymbol("user_error");
+    static final SymbolTerm SYM_MODE_1     = SymbolTerm.intern("mode", 1);
+    static final SymbolTerm SYM_ALIAS_1    = SymbolTerm.intern("alias", 1);
+    static final SymbolTerm SYM_TYPE_1     = SymbolTerm.intern("type", 1);
+    static final SymbolTerm SYM_READ       = SymbolTerm.intern("read");
+    static final SymbolTerm SYM_APPEND     = SymbolTerm.intern("append");
+    static final SymbolTerm SYM_INPUT      = SymbolTerm.intern("input");
+    static final SymbolTerm SYM_OUTPUT     = SymbolTerm.intern("output");
+    static final SymbolTerm SYM_TEXT       = SymbolTerm.intern("text");
+    static final SymbolTerm SYM_USERINPUT  = SymbolTerm.intern("user_input");
+    static final SymbolTerm SYM_USEROUTPUT = SymbolTerm.intern("user_output");
+    static final SymbolTerm SYM_USERERROR  = SymbolTerm.intern("user_error");
 
     public static enum Feature {
       /** Enable the {@code java_*} predicates, supporting reflection in Prolog. */
@@ -228,7 +228,7 @@ public final class Prolog {
 	doubleQuotes    = "codes";
 	printStackTrace = "off";
 
-	exception       = SymbolTerm.makeSymbol("$none");
+	exception       = SymbolTerm.intern("$none");
 	startRuntime    = System.currentTimeMillis();
 	previousRuntime = 0;
 
diff --git a/src/lang/PrologClassLoader.java b/src/lang/PrologClassLoader.java
index f0b1db6..6f407a9 100644
--- a/src/lang/PrologClassLoader.java
+++ b/src/lang/PrologClassLoader.java
@@ -68,6 +68,9 @@ public class PrologClassLoader extends ClassLoader implements Serializable {
     return predicate(pkg, functor, Success.SUCCESS, args);
   }
 
+  private static final SymbolTerm colon2 = SymbolTerm.intern(":", 2);
+  private static final SymbolTerm slash2 = SymbolTerm.intern("/", 2);
+
   /**
    * Allocate a predicate and configure it with the specified arguments.
    *
@@ -97,10 +100,8 @@ public class PrologClassLoader extends ClassLoader implements Serializable {
       cons.setAccessible(true);
       return cons.newInstance(a);
     } catch (Exception err) {
-      SymbolTerm colon2 = SymbolTerm.makeSymbol(":", 2);
-      SymbolTerm slash2 = SymbolTerm.makeSymbol("/", 2);
-      Term[] fa = {SymbolTerm.makeSymbol(functor), new IntegerTerm(arity)};
-      Term[] r = {SymbolTerm.makeSymbol(pkg), new StructureTerm(slash2, fa)};
+      Term[] fa = {SymbolTerm.create(functor), new IntegerTerm(arity)};
+      Term[] r = {SymbolTerm.create(pkg), new StructureTerm(slash2, fa)};
       Term what = new StructureTerm(colon2, r);
 
       ExistenceException e2 = new ExistenceException("procedure", new StructureTerm(slash2, fa), err.toString());
diff --git a/src/lang/PrologControl.java b/src/lang/PrologControl.java
index cb4d5b0..e0d9312 100644
--- a/src/lang/PrologControl.java
+++ b/src/lang/PrologControl.java
@@ -145,6 +145,7 @@ public abstract class PrologControl {
 			break main_loop;
 		    code = code.exec(engine);
 		}
+		SymbolTerm.gc();
 		switch (engine.exceptionRaised) {
 		case 1:  // halt/0
 		    break main_loop;
diff --git a/src/lang/PrologMain.java b/src/lang/PrologMain.java
index bb0229d..7ab9b05 100644
--- a/src/lang/PrologMain.java
+++ b/src/lang/PrologMain.java
@@ -40,8 +40,8 @@ public class PrologMain {
 		System.exit(999);
 	    } 
 	    Term arg1 = Prolog.Nil;
-	    arg1 = new ListTerm(SymbolTerm.makeSymbol("user"), arg1);
-	    arg1 = new ListTerm(SymbolTerm.makeSymbol(Prolog.BUILTIN), arg1);
+	    arg1 = new ListTerm(SymbolTerm.intern("user"), arg1);
+	    arg1 = new ListTerm(SymbolTerm.intern(Prolog.BUILTIN), arg1);
 	    Term arg2 = parseAtomicGoal(argv[0]);
 	    if (arg2  == null) {
 		usage();
@@ -67,13 +67,13 @@ public class PrologMain {
 	StringTokenizer st = new StringTokenizer(s, ":");
 	int i = st.countTokens();
 	if (i == 1) {
-	    Term[] args = {SymbolTerm.makeSymbol("user"), 
-			   SymbolTerm.makeSymbol(st.nextToken())};
-	    return new StructureTerm(SymbolTerm.makeSymbol(":", 2), args);
+	    Term[] args = {SymbolTerm.intern("user"), 
+			   SymbolTerm.create(st.nextToken())};
+	    return new StructureTerm(SymbolTerm.intern(":", 2), args);
 	} else if (i == 2) {
-	    Term[] args = {SymbolTerm.makeSymbol(st.nextToken()), 
-			   SymbolTerm.makeSymbol(st.nextToken())};
-	    return new StructureTerm(SymbolTerm.makeSymbol(":", 2), args);
+	    Term[] args = {SymbolTerm.create(st.nextToken()), 
+			   SymbolTerm.create(st.nextToken())};
+	    return new StructureTerm(SymbolTerm.intern(":", 2), args);
 	} else {
 	    return null;
 	}
@@ -90,15 +90,5 @@ public class PrologMain {
 	s += "    predicate:      predicate name (only atom)";
 	System.out.println(s);
     }
-
-    /*
-    public static Term makeList(int n){
-	Term t = SymbolTerm.makeSymbol("[]");
-	for (int i=n; i>0; i--){
-	    t = new ListTerm(new IntegerTerm(i), t);
-	}
-	return t;
-    }
-    */
 }
 
diff --git a/src/lang/RepresentationException.java b/src/lang/RepresentationException.java
index b6fa85e..9f513d6 100644
--- a/src/lang/RepresentationException.java
+++ b/src/lang/RepresentationException.java
@@ -10,7 +10,7 @@ package com.googlecode.prolog_cafe.lang;
  */
 public class RepresentationException extends BuiltinException {
     /** A functor symbol of <code>representation_error/3</code>. */
-    public static final SymbolTerm REPRESENTATION_ERROR = SymbolTerm.makeSymbol("representation_error", 3);
+    public static final SymbolTerm REPRESENTATION_ERROR = SymbolTerm.intern("representation_error", 3);
 
     /*
       flag ::= character | character_code | in_character_code | 
@@ -38,7 +38,7 @@ public class RepresentationException extends BuiltinException {
 	Term[] args = {
 	    new JavaObjectTerm(goal), 
 	    new IntegerTerm(argNo), 
-	    SymbolTerm.makeSymbol(flag)};
+	    SymbolTerm.create(flag)};
 	return new StructureTerm(REPRESENTATION_ERROR, args);
     }
 
diff --git a/src/lang/StructureTerm.java b/src/lang/StructureTerm.java
index c2388e5..85a91a6 100644
--- a/src/lang/StructureTerm.java
+++ b/src/lang/StructureTerm.java
@@ -33,7 +33,7 @@ public class StructureTerm extends Term {
      * <code>args</code> is the argument terms respectively.
      */
     public StructureTerm(String name, Term... args){
-	this(SymbolTerm.makeSymbol(name, args.length), args);
+	this(SymbolTerm.create(name, args.length), args);
     }
 
     /**
diff --git a/src/lang/SymbolTerm.java b/src/lang/SymbolTerm.java
index 02b920d..9a25b34 100644
--- a/src/lang/SymbolTerm.java
+++ b/src/lang/SymbolTerm.java
@@ -1,4 +1,7 @@
 package com.googlecode.prolog_cafe.lang;
+import java.lang.ref.Reference;
+import java.lang.ref.ReferenceQueue;
+import java.lang.ref.WeakReference;
 import java.util.concurrent.ConcurrentHashMap;
 /**
  * Atom.<br>
@@ -13,40 +16,149 @@ import java.util.concurrent.ConcurrentHashMap;
  * @author Naoyuki Tamura (tamura@kobe-u.ac.jp)
  * @version 1.0
  */
-public class SymbolTerm extends Term {
+public abstract class SymbolTerm extends Term {
     /** Symbol table. */
-    protected static final ConcurrentHashMap<String,SymbolTerm> SYMBOL_TABLE = new ConcurrentHashMap<String,SymbolTerm>();
+    private static final ConcurrentHashMap<Key, InternRef> SYMBOL_TABLE =
+      new ConcurrentHashMap<Key, InternRef>();
 
-    private static final SymbolTerm colon2 = makeSymbol(":", 2);
+    private static final ReferenceQueue<Interned> DEAD = new ReferenceQueue<Interned>();
 
-    /** Holds a string representation of this <code>SymbolTerm</code>. */
-    protected String name;
+    private static final class Key {
+      final String name;
+      final int arity;
 
-    /** Holds the arity of this <code>SymbolTerm</code>. */
-    protected int arity;
+      Key(String n, int a) {
+        name = n;
+        arity = a;
+      }
+
+      @Override
+      public int hashCode() {
+        return name.hashCode();
+      }
+
+      @Override
+      public boolean equals(Object other) {
+        Key k = (Key) other;
+        return arity == k.arity && name.equals(k.name);
+      }
+    }
+
+    private static final class InternRef extends WeakReference<Interned> {
+      final Key key;
+
+      InternRef(Key key, Interned sym) {
+        super(sym, DEAD);
+        this.key = key;
+      }
+    }
+
+    private static final class Dynamic extends SymbolTerm {
+      Dynamic(String name, int arity) {
+        super(name, arity);
+      }
+    }
+
+    private static final class Interned extends SymbolTerm {
+      Interned(String name, int arity) {
+        super(name, arity);
+      }
+    }
+
+    private static final SymbolTerm colon2 = intern(":", 2);
+
+    /** Returns a Prolog atom for the given character. */
+    public static SymbolTerm create(char c) {
+      if (0 <= c && c <= 127)
+        return intern(Character.toString(c), 0);
+      else
+        return create(Character.toString(c));
+    }
 
     /** Returns a Prolog atom for the given name. */
-    public static SymbolTerm makeSymbol(String _name) {
-	return makeSymbol(_name, 0);
+    public static SymbolTerm create(String _name) {
+      return new Dynamic(_name, 0);
+    }
+
+    /** Returns a Prolog atom for the given name. */
+    public static SymbolTerm create(String _name, int arity) {
+      // For a non-zero arity try to reuse the term, its probable this is a
+      // structure term and those are more commonly declared in code
+      // to be a type of object the code manipulates, therefore also very
+      // likely to already be in the cache.
+      if (arity != 0)
+        return softReuse(_name, arity);
+
+      return new Dynamic(_name, 0);
     }
 
     /** Returns a Prolog functor for the given name and arity. */
-    public static StructureTerm makeSymbol(String pkg, String name, int arity) {
-      return new StructureTerm(colon2, makeSymbol(pkg), makeSymbol(name, arity));
+    public static StructureTerm create(String pkg, String name, int arity) {
+      // This is likely a specific function that exists in code, so try to reuse
+      // the symbols that are involved in the term.
+      return new StructureTerm(colon2, softReuse(pkg, 0), softReuse(name, arity));
+    }
+
+    /** Returns a Prolog atom for the given name. */
+    public static SymbolTerm intern(String _name) {
+      return intern(_name, 0);
     }
 
     /** Returns a Prolog functor for the given name and arity. */
-    public static SymbolTerm makeSymbol(String _name, int _arity) {
-	String key = _name + "/" + _arity;
-	SymbolTerm sym = SYMBOL_TABLE.get(key);
-	if (sym != null)
-	  return sym;
+    public static SymbolTerm intern(String _name, int _arity) {
+      _name = _name.intern();
+      Key key = new Key(_name, _arity);
+
+      Reference<? extends Interned> ref = SYMBOL_TABLE.get(key);
+      if (ref != null) {
+        Interned sym = ref.get();
+        if (sym != null)
+          return sym;
+        SYMBOL_TABLE.remove(key, ref);
+        ref.enqueue();
+      }
+
+      gc();
+
+      Interned sym = new Interned(_name, _arity);
+      InternRef nref = new InternRef(key, sym);
+      InternRef oref = SYMBOL_TABLE.putIfAbsent(key, nref);
+      if (oref != null) {
+        SymbolTerm osym = oref.get();
+        if (osym != null)
+          return osym;
+      }
+      return sym;
+    }
 
-	sym = new SymbolTerm(_name, _arity);
-	SymbolTerm old = SYMBOL_TABLE.putIfAbsent(key, sym);
-	return old != null ? old : sym;
+    static void gc() {
+      Reference<? extends Interned> ref;
+      while ((ref = DEAD.poll()) != null) {
+        SYMBOL_TABLE.remove(((InternRef) ref).key, ref);
+      }
     }
 
+    private static SymbolTerm softReuse(String _name, int _arity) {
+      Key key = new Key(_name, _arity);
+      Reference<? extends Interned> ref = SYMBOL_TABLE.get(key);
+      if (ref != null) {
+        Interned sym = ref.get();
+        if (sym != null)
+          return sym;
+        SYMBOL_TABLE.remove(key, ref);
+        ref.enqueue();
+      }
+
+      // If reuse wasn't possible, construct the term dynamically.
+      return new Dynamic(_name, _arity);
+    }
+
+    /** Holds a string representation of this <code>SymbolTerm</code>. */
+    protected final String name;
+
+    /** Holds the arity of this <code>SymbolTerm</code>. */
+    protected final int arity;
+
     /** Constructs a new Prolog atom (or functor) with the given symbol name and arity. */
     protected SymbolTerm(String _name, int _arity) {
 	name  = _name;
@@ -67,13 +179,33 @@ public class SymbolTerm extends Term {
 
     /* Term */
     public boolean unify(Term t, Trail trail) {
-	t = t.dereference();
-	if (t.isVariable()) {
-	    ((VariableTerm) t).bind(this, trail);
-	    return true;
-	}
-	return this == t;
-	//	return name.equals(((SymbolTerm)t).name());
+      t = t.dereference();
+      if (t.isVariable()) {
+        ((VariableTerm) t).bind(this, trail);
+        return true;
+      }
+      return eq(this, t);
+    }
+
+    @Override
+    public int hashCode() {
+      return name.hashCode();
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+      return obj instanceof Term && eq(this, (Term) obj);
+    }
+
+    private static boolean eq(SymbolTerm a, Term b0) {
+      if (a == b0) {
+        return true;
+      } else if (b0 instanceof SymbolTerm && (a instanceof Dynamic || b0 instanceof Dynamic)) {
+        SymbolTerm b = (SymbolTerm) b0;
+        return a.arity == b.arity && a.name.equals(b.name);
+      } else {
+        return false;
+      }
     }
 
     /**
diff --git a/src/lang/SyntaxException.java b/src/lang/SyntaxException.java
index 2802e96..2d22ce3 100644
--- a/src/lang/SyntaxException.java
+++ b/src/lang/SyntaxException.java
@@ -10,7 +10,7 @@ package com.googlecode.prolog_cafe.lang;
  */
 public class SyntaxException extends BuiltinException {
     /** A functor symbol of <code>syntax_error/5</code>. */
-    public static final SymbolTerm SYNTAX_ERROR = SymbolTerm.makeSymbol("syntax_error", 5);
+    public static final SymbolTerm SYNTAX_ERROR = SymbolTerm.intern("syntax_error", 5);
 
     /** Holds a string representation of valid type. */
     public String type;
@@ -45,9 +45,9 @@ public class SyntaxException extends BuiltinException {
 	Term[] args = {
 	    new JavaObjectTerm(goal), 
 	    new IntegerTerm(argNo), 
-	    SymbolTerm.makeSymbol(type),
+	    SymbolTerm.create(type),
 	    culprit,
-	    SymbolTerm.makeSymbol(message) };
+	    SymbolTerm.create(message) };
 	return new StructureTerm(SYNTAX_ERROR, args);
     }
 
diff --git a/src/lang/SystemException.java b/src/lang/SystemException.java
index 5613aea..788b2db 100644
--- a/src/lang/SystemException.java
+++ b/src/lang/SystemException.java
@@ -8,7 +8,7 @@ package com.googlecode.prolog_cafe.lang;
  */
 public class SystemException extends PrologException {
     /** A functor symbol of <code>system_error/1</code>. */
-    public static final SymbolTerm SYSTEM_ERROR = SymbolTerm.makeSymbol("system_error", 1);
+    public static final SymbolTerm SYSTEM_ERROR = SymbolTerm.intern("system_error", 1);
 
     /** Holds a message. */
     public String message;
@@ -22,7 +22,7 @@ public class SystemException extends PrologException {
      * <code>system_error(message)</code>.
      */
     public Term getMessageTerm() {
-	Term[] args = {SymbolTerm.makeSymbol(message)};
+	Term[] args = {SymbolTerm.create(message)};
 	return new StructureTerm(SYSTEM_ERROR, args);
     }