694 lines
17 KiB
Java
694 lines
17 KiB
Java
|
//tabstop=4
|
||
|
|
//*****************************************************************************/
|
||
|
|
// Project: jpl
|
||
|
|
//
|
||
|
|
// File: $Id$
|
||
|
|
// Date: $Date$
|
||
|
|
// Author: Fred Dushin <fadushin@syr.edu>
|
||
|
|
//
|
||
|
|
//
|
||
|
|
// Description:
|
||
|
|
//
|
||
|
|
//
|
||
|
|
// -------------------------------------------------------------------------
|
||
|
|
// Copyright (c) 1998 Fred Dushin
|
||
|
|
// All rights reserved.
|
||
|
|
//
|
||
|
|
// This library is free software; you can redistribute it and/or
|
||
|
|
// modify it under the terms of the GNU Library Public License
|
||
|
|
// as published by the Free Software Foundation; either version 2
|
||
|
|
// of the License, or (at your option) any later version.
|
||
|
|
//
|
||
|
|
// This library is distributed in the hope that it will be useful,
|
||
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||
|
|
// GNU Library Public License for more details.
|
||
|
|
//*****************************************************************************/
|
||
|
|
package jpl;
|
||
|
|
|
||
|
|
import java.util.Hashtable;
|
||
|
|
import jpl.fli.*;
|
||
|
|
|
||
|
|
//----------------------------------------------------------------------/
|
||
|
|
// Compound
|
||
|
|
/**
|
||
|
|
* A Compound is a base class for all of the compound class types
|
||
|
|
* (e.g., List, Tuple, etc.), but it can also be instantiated to
|
||
|
|
* produce, for example, any functional expression. For example, to
|
||
|
|
* produce the term f(a), one might write:
|
||
|
|
* <pre>
|
||
|
|
* Term[] arg = { new Atom( "a" ) };
|
||
|
|
* Compound f = new Compound( new Atom( "f" ), arg );
|
||
|
|
* </pre>
|
||
|
|
*
|
||
|
|
* See the List and Tuple classes for common extensions of this class.
|
||
|
|
*
|
||
|
|
* <hr><i>
|
||
|
|
* Copyright (C) 1998 Fred Dushin<p>
|
||
|
|
*
|
||
|
|
* This library is free software; you can redistribute it and/or
|
||
|
|
* modify it under the terms of the GNU Library Public License
|
||
|
|
* as published by the Free Software Foundation; either version 2
|
||
|
|
* of the License, or (at your option) any later version.<p>
|
||
|
|
*
|
||
|
|
* This library is distributed in the hope that it will be useful,
|
||
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||
|
|
* GNU Library Public License for more details.<p>
|
||
|
|
* </i><hr>
|
||
|
|
* @author Fred Dushin <fadushin@syr.edu>
|
||
|
|
* @version $Revision$
|
||
|
|
* @see jpl.Term
|
||
|
|
* @see jpl.List
|
||
|
|
* @see jpl.Tuple
|
||
|
|
*/
|
||
|
|
// Implementation notes:
|
||
|
|
//
|
||
|
|
//----------------------------------------------------------------------/
|
||
|
|
public class Compound
|
||
|
|
extends Term
|
||
|
|
{
|
||
|
|
//==================================================================/
|
||
|
|
// Attributes
|
||
|
|
//==================================================================/
|
||
|
|
|
||
|
|
/**
|
||
|
|
* the atom in this Compound
|
||
|
|
*/
|
||
|
|
protected Atom atom_ = null;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* the arguments in this Compound
|
||
|
|
*/
|
||
|
|
protected Term[] args_ = null;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @return the atom in this Compound
|
||
|
|
*/
|
||
|
|
public final Atom
|
||
|
|
atom()
|
||
|
|
{
|
||
|
|
return atom_;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @return the arguments in this Compound
|
||
|
|
*/
|
||
|
|
public final Term[]
|
||
|
|
args()
|
||
|
|
{
|
||
|
|
return args_;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @return the ith argument in this Compound
|
||
|
|
*/
|
||
|
|
public final Term
|
||
|
|
ith( int i)
|
||
|
|
{
|
||
|
|
return args_[i];
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//==================================================================/
|
||
|
|
// Contructors and Initialization
|
||
|
|
//==================================================================/
|
||
|
|
|
||
|
|
|
||
|
|
//------------------------------------------------------------------/
|
||
|
|
// Compound
|
||
|
|
/**
|
||
|
|
* Creates a Comound with an Atom and an array of arguments. The
|
||
|
|
* length of the array determines the arity of the Compound.
|
||
|
|
*
|
||
|
|
* @param atom the Atom in this Compound
|
||
|
|
* @param args the arguments in this Compound
|
||
|
|
*/
|
||
|
|
// Implementation notes:
|
||
|
|
//
|
||
|
|
//------------------------------------------------------------------/
|
||
|
|
public
|
||
|
|
Compound( Atom atom, Term args[] )
|
||
|
|
{
|
||
|
|
this.atom_ = atom;
|
||
|
|
this.args_ = args;
|
||
|
|
}
|
||
|
|
|
||
|
|
//------------------------------------------------------------------/
|
||
|
|
// Compound
|
||
|
|
/**
|
||
|
|
* This constructor is short for
|
||
|
|
* <pre>
|
||
|
|
* new Compound( new Atom( name ), arg )
|
||
|
|
* </pre>
|
||
|
|
*
|
||
|
|
* @param name the name for the Atom in this Compound
|
||
|
|
* @param args the arguments in this Compound
|
||
|
|
*/
|
||
|
|
// Implementation notes:
|
||
|
|
//
|
||
|
|
//------------------------------------------------------------------/
|
||
|
|
public
|
||
|
|
Compound( java.lang.String name, Term args[] )
|
||
|
|
{
|
||
|
|
this( new Atom( name ), args );
|
||
|
|
}
|
||
|
|
|
||
|
|
//------------------------------------------------------------------/
|
||
|
|
// Compound
|
||
|
|
/**
|
||
|
|
* This constructor is shorthand for
|
||
|
|
* <pre>
|
||
|
|
* new Compound(
|
||
|
|
* new Atom( name ),
|
||
|
|
* Util.toTermArray( t0 ) )
|
||
|
|
* </pre>
|
||
|
|
*
|
||
|
|
* @param name the name of the functor in this Compound
|
||
|
|
* @param t0 a jpl.Term
|
||
|
|
*/
|
||
|
|
// Implementation notes:
|
||
|
|
//
|
||
|
|
//------------------------------------------------------------------/
|
||
|
|
public
|
||
|
|
Compound(
|
||
|
|
java.lang.String name,
|
||
|
|
Term t0 )
|
||
|
|
{
|
||
|
|
this(
|
||
|
|
new Atom( name ),
|
||
|
|
Util.toTermArray( t0 ) );
|
||
|
|
}
|
||
|
|
|
||
|
|
//------------------------------------------------------------------/
|
||
|
|
// Compound
|
||
|
|
/**
|
||
|
|
* This constructor is shorthand for
|
||
|
|
* <pre>
|
||
|
|
* new Compound(
|
||
|
|
* new Atom( name ),
|
||
|
|
* Util.toTermArray( t0, t1 ) )
|
||
|
|
* </pre>
|
||
|
|
*
|
||
|
|
* @param name the name of the functor in this Compound
|
||
|
|
* @param t0 a jpl.Term
|
||
|
|
* @param t1 a jpl.Term
|
||
|
|
*/
|
||
|
|
// Implementation notes:
|
||
|
|
//
|
||
|
|
//------------------------------------------------------------------/
|
||
|
|
public
|
||
|
|
Compound(
|
||
|
|
java.lang.String name,
|
||
|
|
Term t0,
|
||
|
|
Term t1 )
|
||
|
|
{
|
||
|
|
this(
|
||
|
|
new Atom( name ),
|
||
|
|
Util.toTermArray( t0, t1 ) );
|
||
|
|
}
|
||
|
|
|
||
|
|
//------------------------------------------------------------------/
|
||
|
|
// Compound
|
||
|
|
/**
|
||
|
|
* This constructor is shorthand for
|
||
|
|
* <pre>
|
||
|
|
* new Compound(
|
||
|
|
* new Atom( name ),
|
||
|
|
* Util.toTermArray( t0, t1, t2 ) )
|
||
|
|
* </pre>
|
||
|
|
*
|
||
|
|
* @param name the name of the functor in this Compound
|
||
|
|
* @param t0 a jpl.Term
|
||
|
|
* @param t1 a jpl.Term
|
||
|
|
* @param t2 a jpl.Term
|
||
|
|
*/
|
||
|
|
// Implementation notes:
|
||
|
|
//
|
||
|
|
//------------------------------------------------------------------/
|
||
|
|
public
|
||
|
|
Compound(
|
||
|
|
java.lang.String name,
|
||
|
|
Term t0,
|
||
|
|
Term t1,
|
||
|
|
Term t2 )
|
||
|
|
{
|
||
|
|
this(
|
||
|
|
new Atom( name ),
|
||
|
|
Util.toTermArray( t0, t1, t2 ) );
|
||
|
|
}
|
||
|
|
|
||
|
|
//------------------------------------------------------------------/
|
||
|
|
// Compound
|
||
|
|
/**
|
||
|
|
* This constructor is shorthand for
|
||
|
|
* <pre>
|
||
|
|
* new Compound(
|
||
|
|
* new Atom( name ),
|
||
|
|
* Util.toTermArray( t0, t1, t2, t3 ) )
|
||
|
|
* </pre>
|
||
|
|
*
|
||
|
|
* @param name the name of the functor in this Compound
|
||
|
|
* @param t0 a jpl.Term
|
||
|
|
* @param t1 a jpl.Term
|
||
|
|
* @param t2 a jpl.Term
|
||
|
|
* @param t3 a jpl.Term
|
||
|
|
*/
|
||
|
|
// Implementation notes:
|
||
|
|
//
|
||
|
|
//------------------------------------------------------------------/
|
||
|
|
public
|
||
|
|
Compound(
|
||
|
|
java.lang.String name,
|
||
|
|
Term t0,
|
||
|
|
Term t1,
|
||
|
|
Term t2,
|
||
|
|
Term t3 )
|
||
|
|
{
|
||
|
|
this(
|
||
|
|
new Atom( name ),
|
||
|
|
Util.toTermArray( t0, t1, t2, t3 ) );
|
||
|
|
}
|
||
|
|
|
||
|
|
//------------------------------------------------------------------/
|
||
|
|
// Compound
|
||
|
|
/**
|
||
|
|
* This constructor is shorthand for
|
||
|
|
* <pre>
|
||
|
|
* new Compound(
|
||
|
|
* new Atom( name ),
|
||
|
|
* Util.toTermArray( t0, t1, t2, t3, t4 ) )
|
||
|
|
* </pre>
|
||
|
|
*
|
||
|
|
* @param name the name of the functor in this Compound
|
||
|
|
* @param t0 a jpl.Term
|
||
|
|
* @param t1 a jpl.Term
|
||
|
|
* @param t2 a jpl.Term
|
||
|
|
* @param t3 a jpl.Term
|
||
|
|
* @param t4 a jpl.Term
|
||
|
|
*/
|
||
|
|
// Implementation notes:
|
||
|
|
//
|
||
|
|
//------------------------------------------------------------------/
|
||
|
|
public
|
||
|
|
Compound(
|
||
|
|
java.lang.String name,
|
||
|
|
Term t0,
|
||
|
|
Term t1,
|
||
|
|
Term t2,
|
||
|
|
Term t3,
|
||
|
|
Term t4 )
|
||
|
|
{
|
||
|
|
this(
|
||
|
|
new Atom( name ),
|
||
|
|
Util.toTermArray( t0, t1, t2, t3, t4 ) );
|
||
|
|
}
|
||
|
|
|
||
|
|
//------------------------------------------------------------------/
|
||
|
|
// Compound
|
||
|
|
/**
|
||
|
|
* This constructor is shorthand for
|
||
|
|
* <pre>
|
||
|
|
* new Compound(
|
||
|
|
* new Atom( name ),
|
||
|
|
* Util.toTermArray( t0, t1, t2, t3, t4,
|
||
|
|
* t5 ) )
|
||
|
|
* </pre>
|
||
|
|
*
|
||
|
|
* @param name the name of the functor in this Compound
|
||
|
|
* @param t0 a jpl.Term
|
||
|
|
* @param t1 a jpl.Term
|
||
|
|
* @param t2 a jpl.Term
|
||
|
|
* @param t3 a jpl.Term
|
||
|
|
* @param t4 a jpl.Term
|
||
|
|
* @param t5 a jpl.Term
|
||
|
|
*/
|
||
|
|
// Implementation notes:
|
||
|
|
//
|
||
|
|
//------------------------------------------------------------------/
|
||
|
|
public
|
||
|
|
Compound(
|
||
|
|
java.lang.String name,
|
||
|
|
Term t0,
|
||
|
|
Term t1,
|
||
|
|
Term t2,
|
||
|
|
Term t3,
|
||
|
|
Term t4,
|
||
|
|
Term t5 )
|
||
|
|
{
|
||
|
|
this(
|
||
|
|
new Atom( name ),
|
||
|
|
Util.toTermArray( t0, t1, t2, t3, t4,
|
||
|
|
t5 ) );
|
||
|
|
}
|
||
|
|
|
||
|
|
//------------------------------------------------------------------/
|
||
|
|
// Compound
|
||
|
|
/**
|
||
|
|
* This constructor is shorthand for
|
||
|
|
* <pre>
|
||
|
|
* new Compound(
|
||
|
|
* new Atom( name ),
|
||
|
|
* Util.toTermArray( t0, t1, t2, t3, t4,
|
||
|
|
* t5, t6 ) )
|
||
|
|
* </pre>
|
||
|
|
*
|
||
|
|
* @param name the name of the functor in this Compound
|
||
|
|
* @param t0 a jpl.Term
|
||
|
|
* @param t1 a jpl.Term
|
||
|
|
* @param t2 a jpl.Term
|
||
|
|
* @param t3 a jpl.Term
|
||
|
|
* @param t4 a jpl.Term
|
||
|
|
* @param t5 a jpl.Term
|
||
|
|
* @param t6 a jpl.Term
|
||
|
|
*/
|
||
|
|
// Implementation notes:
|
||
|
|
//
|
||
|
|
//------------------------------------------------------------------/
|
||
|
|
public
|
||
|
|
Compound(
|
||
|
|
java.lang.String name,
|
||
|
|
Term t0,
|
||
|
|
Term t1,
|
||
|
|
Term t2,
|
||
|
|
Term t3,
|
||
|
|
Term t4,
|
||
|
|
Term t5,
|
||
|
|
Term t6 )
|
||
|
|
{
|
||
|
|
this(
|
||
|
|
new Atom( name ),
|
||
|
|
Util.toTermArray( t0, t1, t2, t3, t4,
|
||
|
|
t5, t6 ) );
|
||
|
|
}
|
||
|
|
|
||
|
|
//------------------------------------------------------------------/
|
||
|
|
// Compound
|
||
|
|
/**
|
||
|
|
* This constructor is shorthand for
|
||
|
|
* <pre>
|
||
|
|
* new Compound(
|
||
|
|
* new Atom( name ),
|
||
|
|
* Util.toTermArray( t0, t1, t2, t3, t4,
|
||
|
|
* t5, t6, t7 ) )
|
||
|
|
* </pre>
|
||
|
|
*
|
||
|
|
* @param name the name of the functor in this Compound
|
||
|
|
* @param t0 a jpl.Term
|
||
|
|
* @param t1 a jpl.Term
|
||
|
|
* @param t2 a jpl.Term
|
||
|
|
* @param t3 a jpl.Term
|
||
|
|
* @param t4 a jpl.Term
|
||
|
|
* @param t5 a jpl.Term
|
||
|
|
* @param t6 a jpl.Term
|
||
|
|
* @param t7 a jpl.Term
|
||
|
|
*/
|
||
|
|
// Implementation notes:
|
||
|
|
//
|
||
|
|
//------------------------------------------------------------------/
|
||
|
|
public
|
||
|
|
Compound(
|
||
|
|
java.lang.String name,
|
||
|
|
Term t0,
|
||
|
|
Term t1,
|
||
|
|
Term t2,
|
||
|
|
Term t3,
|
||
|
|
Term t4,
|
||
|
|
Term t5,
|
||
|
|
Term t6,
|
||
|
|
Term t7 )
|
||
|
|
{
|
||
|
|
this(
|
||
|
|
new Atom( name ),
|
||
|
|
Util.toTermArray( t0, t1, t2, t3, t4,
|
||
|
|
t5, t6, t7 ) );
|
||
|
|
}
|
||
|
|
|
||
|
|
//------------------------------------------------------------------/
|
||
|
|
// Compound
|
||
|
|
/**
|
||
|
|
* This constructor is shorthand for
|
||
|
|
* <pre>
|
||
|
|
* new Compound(
|
||
|
|
* new Atom( name ),
|
||
|
|
* Util.toTermArray( t0, t1, t2, t3, t4,
|
||
|
|
* t5, t6, t7, t8 ) )
|
||
|
|
* </pre>
|
||
|
|
*
|
||
|
|
* @param name the name of the functor in this Compound
|
||
|
|
* @param t0 a jpl.Term
|
||
|
|
* @param t1 a jpl.Term
|
||
|
|
* @param t2 a jpl.Term
|
||
|
|
* @param t3 a jpl.Term
|
||
|
|
* @param t4 a jpl.Term
|
||
|
|
* @param t5 a jpl.Term
|
||
|
|
* @param t6 a jpl.Term
|
||
|
|
* @param t7 a jpl.Term
|
||
|
|
* @param t8 a jpl.Term
|
||
|
|
*/
|
||
|
|
// Implementation notes:
|
||
|
|
//
|
||
|
|
//------------------------------------------------------------------/
|
||
|
|
public
|
||
|
|
Compound(
|
||
|
|
java.lang.String name,
|
||
|
|
Term t0,
|
||
|
|
Term t1,
|
||
|
|
Term t2,
|
||
|
|
Term t3,
|
||
|
|
Term t4,
|
||
|
|
Term t5,
|
||
|
|
Term t6,
|
||
|
|
Term t7,
|
||
|
|
Term t8 )
|
||
|
|
{
|
||
|
|
this(
|
||
|
|
new Atom( name ),
|
||
|
|
Util.toTermArray( t0, t1, t2, t3, t4,
|
||
|
|
t5, t6, t7, t8 ) );
|
||
|
|
}
|
||
|
|
|
||
|
|
//------------------------------------------------------------------/
|
||
|
|
// Compound
|
||
|
|
/**
|
||
|
|
* This constructor is shorthand for
|
||
|
|
* <pre>
|
||
|
|
* new Compound(
|
||
|
|
* new Atom( name ),
|
||
|
|
* Util.toTermArray( t0, t1, t2, t3, t4,
|
||
|
|
* t5, t6, t7, t8, t9 ) )
|
||
|
|
* </pre>
|
||
|
|
*
|
||
|
|
* @param name the name of the functor in this Compound
|
||
|
|
* @param t0 a jpl.Term
|
||
|
|
* @param t1 a jpl.Term
|
||
|
|
* @param t2 a jpl.Term
|
||
|
|
* @param t3 a jpl.Term
|
||
|
|
* @param t4 a jpl.Term
|
||
|
|
* @param t5 a jpl.Term
|
||
|
|
* @param t6 a jpl.Term
|
||
|
|
* @param t7 a jpl.Term
|
||
|
|
* @param t8 a jpl.Term
|
||
|
|
* @param t9 a jpl.Term
|
||
|
|
*/
|
||
|
|
// Implementation notes:
|
||
|
|
//
|
||
|
|
//------------------------------------------------------------------/
|
||
|
|
public
|
||
|
|
Compound(
|
||
|
|
java.lang.String name,
|
||
|
|
Term t0,
|
||
|
|
Term t1,
|
||
|
|
Term t2,
|
||
|
|
Term t3,
|
||
|
|
Term t4,
|
||
|
|
Term t5,
|
||
|
|
Term t6,
|
||
|
|
Term t7,
|
||
|
|
Term t8,
|
||
|
|
Term t9 )
|
||
|
|
{
|
||
|
|
this(
|
||
|
|
new Atom( name ),
|
||
|
|
Util.toTermArray( t0, t1, t2, t3, t4,
|
||
|
|
t5, t6, t7, t8, t9 ) );
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
//==================================================================/
|
||
|
|
// Converting Terms to term_ts
|
||
|
|
//==================================================================/
|
||
|
|
|
||
|
|
//------------------------------------------------------------------/
|
||
|
|
// put
|
||
|
|
/**
|
||
|
|
* To put an Compound in a term, we create a sequence of term_t
|
||
|
|
* references from the Term terms_to_term_t method, and then
|
||
|
|
* use the Prolog cons_functor_v method to create a Prolog compound.
|
||
|
|
*
|
||
|
|
* @param var_table A Hashtable containing term_t's that are
|
||
|
|
* bound to (have packed in) Prolog variables as elements. The
|
||
|
|
* Elements are keyed by jpl.Variable instances. Cf. the put()
|
||
|
|
* implementation in the Variable class.
|
||
|
|
* @param term A (previously created) term_t which is to be
|
||
|
|
* packed with a Prolog term-type appropriate to the Term type
|
||
|
|
* (e.g., Atom, Variable, Compound, etc.) on which the method is
|
||
|
|
* invoked.)
|
||
|
|
*/
|
||
|
|
// Implementation notes: This method is over-ridden in each of
|
||
|
|
// the Term's subclasses, but it is always called from them, as well.
|
||
|
|
//------------------------------------------------------------------/
|
||
|
|
protected final void
|
||
|
|
put( Hashtable var_table, term_t term )
|
||
|
|
{
|
||
|
|
term_t term0 = Term.terms_to_term_ts( var_table, args_ );
|
||
|
|
|
||
|
|
Prolog.cons_functor_v(
|
||
|
|
term,
|
||
|
|
Prolog.new_functor(
|
||
|
|
Prolog.new_atom( atom_.name_ ),
|
||
|
|
args_.length ),
|
||
|
|
term0 );
|
||
|
|
}
|
||
|
|
|
||
|
|
//==================================================================/
|
||
|
|
// Converting term_ts to Terms
|
||
|
|
//==================================================================/
|
||
|
|
|
||
|
|
//------------------------------------------------------------------/
|
||
|
|
// from_term_t
|
||
|
|
/**
|
||
|
|
* Converts a term_t to a Compound. In this case, we create
|
||
|
|
* an Atom and a list of Terms by calling from_term_t for each
|
||
|
|
* term_t reference we get from Prolog.get_arg (Not sure why
|
||
|
|
* we couldn't get a sequence from there, but...).<p>
|
||
|
|
*
|
||
|
|
* We have to do a bit of type analysis to create Java objects
|
||
|
|
* of the right type. For example, we don't want to create just
|
||
|
|
* a Compound if the term_t is a list or a tuple; we want to
|
||
|
|
* create a List or a Tuple, accordingly.
|
||
|
|
*
|
||
|
|
* @param term The term_t to convert
|
||
|
|
* @return A new Atom
|
||
|
|
*/
|
||
|
|
// Implementation notes:
|
||
|
|
//
|
||
|
|
//------------------------------------------------------------------/
|
||
|
|
protected static Term
|
||
|
|
from_term_t( Hashtable vars, term_t term )
|
||
|
|
{
|
||
|
|
atom_t atom = new atom_t();
|
||
|
|
IntHolder arity_holder = new IntHolder();
|
||
|
|
|
||
|
|
Prolog.get_name_arity( term, atom, arity_holder );
|
||
|
|
java.lang.String atom_name = Prolog.atom_chars( atom );
|
||
|
|
|
||
|
|
Term arg[] = new Term[arity_holder.value];
|
||
|
|
|
||
|
|
for ( int i = 1; i <= arity_holder.value; ++i ){
|
||
|
|
term_t termi = Prolog.new_term_ref();
|
||
|
|
|
||
|
|
Prolog.get_arg( i, term, termi );
|
||
|
|
arg[i-1] = Term.from_term_t( vars, termi );
|
||
|
|
}
|
||
|
|
|
||
|
|
if ( atom_name.equals( "." ) ){
|
||
|
|
return
|
||
|
|
new List(
|
||
|
|
arg[0], arg[1] );
|
||
|
|
} else if ( atom_name.equals( "," ) ) {
|
||
|
|
if ( arg.length == 2 ){
|
||
|
|
return
|
||
|
|
new Tuple.Pair( arg[0], arg[1] );
|
||
|
|
} else {
|
||
|
|
return
|
||
|
|
new Tuple( arg );
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
return
|
||
|
|
new Compound(
|
||
|
|
new Atom( atom_name ),
|
||
|
|
arg );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
//==================================================================/
|
||
|
|
// Computing Substitutions
|
||
|
|
//==================================================================/
|
||
|
|
|
||
|
|
|
||
|
|
//------------------------------------------------------------------/
|
||
|
|
// computeSubstitution
|
||
|
|
/**
|
||
|
|
* Nothing needs to be done except to pass the buck to the args.
|
||
|
|
*
|
||
|
|
* @param table table holding Term substitutions, keyed on
|
||
|
|
* Variables.
|
||
|
|
*/
|
||
|
|
// Implementation notes:
|
||
|
|
//
|
||
|
|
//------------------------------------------------------------------/
|
||
|
|
protected final void
|
||
|
|
computeSubstitution( Hashtable bindings, Hashtable vars )
|
||
|
|
{
|
||
|
|
Term.computeSubstitutions( bindings, vars, args_ );
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//------------------------------------------------------------------/
|
||
|
|
// toString
|
||
|
|
/**
|
||
|
|
* Converts a Compound to its String form, atom( arg_1, ..., arg_n )
|
||
|
|
*
|
||
|
|
* @return string representation of an Compound
|
||
|
|
*/
|
||
|
|
// Implementation notes:
|
||
|
|
//
|
||
|
|
//------------------------------------------------------------------/
|
||
|
|
public java.lang.String
|
||
|
|
toString()
|
||
|
|
{
|
||
|
|
return atom_.toString() + "( " + Term.toString( args_ ) + " )";
|
||
|
|
}
|
||
|
|
|
||
|
|
public java.lang.String
|
||
|
|
debugString()
|
||
|
|
{
|
||
|
|
return
|
||
|
|
"(Compound " +
|
||
|
|
atom_.debugString() + " " +
|
||
|
|
Term.debugString( args_ ) + ")";
|
||
|
|
}
|
||
|
|
|
||
|
|
//------------------------------------------------------------------/
|
||
|
|
// equals
|
||
|
|
/**
|
||
|
|
* Two Compounds are equal if their atoms are equal and their
|
||
|
|
* term arguments are equal.
|
||
|
|
*
|
||
|
|
* @param obj the Object to compare
|
||
|
|
* @return true if the Object satisfies the above condition
|
||
|
|
*/
|
||
|
|
// Implementation notes:
|
||
|
|
//
|
||
|
|
//------------------------------------------------------------------/
|
||
|
|
public final boolean
|
||
|
|
equals( Object obj )
|
||
|
|
{
|
||
|
|
if ( this == obj ){
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
if ( ! (obj instanceof Compound) ){
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
return
|
||
|
|
atom_.equals( ((Compound)obj).atom_ ) &&
|
||
|
|
Term.terms_equals( args_, ((Compound)obj).args_ );
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
//345678901234567890123456789012346578901234567890123456789012345678901234567890
|