"parse error, unexpected T_NEW"

[Edward_Sandstig]

Well, I'm maintaining someone else's code and I'm trying to get the app to run again. Unfortunately, I keep running into the above-mentioned error message. My understanding is that this has to do with classes. I've posted the code below. Can anyone find anything wrong? Thanks!

    class SqlWhere 
    {
        var $classname = 'SqlWhere';
		var $clauses = new OrClauses;

    function SqlWhere ($conjunction = 'or') 
    { 
        $conjunction = strtolower ($conjunction);

        switch ((string) $conjunction)
        {
            case 'or':
                $this->clauses = new OrClauses (); break;
            case 'and':
                $this->clauses = new AndClauses (); break;
            default:
                printf ("%s %d: SqlWhere; unrecognised conjunction<br>",
                        __FILE__,
                        __LINE__);
                break;
        }

    }    // function::SqlWhere
}

class OrClauses extends BoolClauseCombiner
{
    var $conjunction = "OR";

    function OrClauses { ; }

}    // class::OrClauses

[steved]

instead of:
switch ((string) $conjunction)

shouldn't it be:
switch ($conjunction)

[Edward_Sandstig]

I get the same error even when I edit it. Here are the contents of ClauseCombiner.inc:

<?



if (!isset ($ClauseCombiner_File))
{
    $ClauseCombiner_File = sprintf ("%s", __FILE__);

// ==================================================
// class ClauseCombiner
//
// Base class provided to combine clauses with the appropriate 
// conjunction.  A clause is added to the field '$clauses', using the 
// 'addClause' method.
//
// All clauses can be retrieved FIFO as a single string, each seperated
// by field '$conjunction', using the 'combine' method.
//
// Author                  : MAS.
// First Created           : Wednesday Mar 10 1999.
// Modification History    : Tuesday Aug 3 1999.
//                           addClause method can now take an array 
//                           argument.
//
// ==================================================



class ClauseCombiner 
{
    var $conjunction = " ";
    var $clauses = array ();
    var $classname = 'ClauseCombiner';

    function ClauseCombiner ($conj = " ")
    {
        $this->setConjunction ($conj);
    }

    /*
     * function ClauseCombiner::setConjunction
     *
     * Sets the conjunction for the object.
     *
     */

    function setConjunction ($conj = " ") { $this->conjunction = $conj; }

    /*
     * function ClauseCombiner::getNumClauses
     *
     * Returns the number of clauses to be combined.
     *
     */


    function getNumClauses () { return sizeof ($this->clauses); }

    /*
     * function ClauseCombiner::combine
     * 
     * Returns the clauses held in the field '$clauses', seperated by the
     * appropriate conjunction.
     *
     */

    function combine ()
    {
        $str = ""; 
        $size = sizeof ($this->clauses);   
        if ($size > 0)
           $str = implode ($this->clauses, $this->conjunction);

        return $str;
    }


    /*
     * function ClauseCombiner::addClause
     * 
     * Adds a clause to the field '$clauses'.  Note that the clause is
     * not added if it is an empty string.  Note that the clauses parameter
     * may be an array.
     *
     */

    function addClause ($clause) 
    {
         $clauses = (array) $clause;

         while (list ($k, $v) = each ($clauses))
         {
             if ('' != $v)
                 $this->clauses [] = $v;
         }
    }


    /*
     * function getClauses
     *
     * Returns a copy of the field '$this->clauses'.
     *
     */


     function getClauses () { return $this->clauses; }

}    // class::ClauseCombiner

// ==================================================
// class::UniqueClauseCombiner extends ClauseCombiner
//
// Only unique clauses are pushed onto the queue, no repeats are allowed.
// This is achieved by calculating the md5 hash of the clause, and using
// this as the key.  When it is desired to add a new clause to the queue,
// the md5 hash of the clause is calculated, and compared against those
// keys already present in the class variable '$clauses'.
//
// Author                  : MAS.
// First Created           : Wednesday Mar 10 1999.
// Modification History    : Tuesday Aug 3 1999.
//                           addClause method can now take an array 
//                           argument.
//
// ==================================================



class UniqueClauseCombiner extends ClauseCombiner
{
    var $classname = 'UniqueClauseCombiner';

    function UniqueClauseCombiner ($conjunction = " ")
    {
        $this->conjunction = $conjunction;
    }



    /*
     * function UniqueClauseCombiner::addClause
     * 
     * Adds a clause to the field '$clauses', if not already seen.
     * Returns true if the clause is added, and false if it is not.
     * Clauses consisting only of empty strings are not added to the 
     * queue.  This is the same behaviour as the method in the overridden
     * (ClauseCombiner) class.
     *
     * Note that the parameter '$clause' can now be an array of clauses,
     * in which case the return value is the success, or otherwise of
     * the last attempted addition.
     *
     */


    function addClause ($clause)
    {
        $retVal = false;
        $clauses = (array) $clause;

        while (list ($k, $v) = each ($clauses))
        {
            if ('' == $v) continue;
            $hash = md5 ($v);

            if (!isset ($this->clauses[$hash]))
            {
                $this->clauses [$hash] = $v;
                $retVal = true;
            }
        }
        return $retVal;
    }    // function::addClause
}    // class::UniqueClauseCombiner



// ==================================================
// class SetCombiner
//
// Extends UniqueClauseCombiner.
//
// Invoking the SetCombiner::combine method produces a depiction of a set
// (all members distinct) using the standard mathematical representation:
//
// '(x1, x2, x3)'
//
// where x1, x2, x3 are members of the set.  If there are no members of 
// the set, then an empty/null string is returned.
//
// ==================================================

class SetCombiner extends UniqueClauseCombiner
{
    var $classname = 'SetCombiner';

    function SetCombiner () { $this->conjunction = ', '; }

    function combine ()
    {
        $retVal = '';
        $size = sizeof ($this->clauses);
        if ($size > 0)
            $retVal =  sprintf ("(%s)", 
                           implode ($this->clauses, $this->conjunction));
        return $retVal;
    }

}     // class::SetCombiner


// ==================================================
// class BoolClauseCombiner
//
// Extends ClauseCombiner 
// 
// Author                  : MAS.
// First Created           : Wednesday Mar 10 1999.
// Modification History    : none.
//           
// Overrides the combine method of class ClauseCombiner, in that each 
// clause is correctly bracketed to ensure precedence. This is useful for
// mathematical or SQL statements.
//
// ==================================================


class BoolClauseCombiner extends ClauseCombiner
{

    function BoolClauseCombiner ($conjunction = '') 
    { 
        $this->conjunction = $conjunction; 
    }


    function combine ()
    {
        $str = "";

        $size = sizeof ($this->clauses);

        $str = implode ($this->clauses, " $this->conjunction ");

        if ($size > 1)

            $str = sprintf ("(%s)", $str);

        return $str;

    }    // function::combine

}    // class::BoolClauseCombiner



// ==================================================
// class AndClauses extends BoolClauseCombiner
//
// Extends BoolClauseCombiner - conjunction is set equal to 'AND'.
//
// Author                  : MAS.
// First Created           : Wednesday Mar 10 1999.
// Modification History    : none.
//
// ==================================================


class AndClauses extends BoolClauseCombiner
{
    var $conjunction = "AND";

    function AndClauses () { ; }
}    // class::AndClauses



// ==================================================
// class OrClauses extends BoolClauseCombiner
//
// Extends BoolClauseCombiner - conjunction is set equal to 'OR'.
//
// Author                  : MAS.
// First Created           : Wednesday Mar 10 1999.
// Modification History    : <none>
//
// ==================================================



class OrClauses extends BoolClauseCombiner
{

    var $conjunction = "OR";

    function OrClauses { ; }
}    // class::OrClauses


}

[steved]

There are a couple of places where there is a statement like:

$clauses = (array) $clause;

That to me doesn't look right. Since I'm not sure what they are trying to do, I can't tell you what it should be.

$clauses = array(); ? ? ?

$clauses = array($clause); ? ? ?

[sijis]

i also don't have a clue what the code is suppose to do.
but i think steved is in the right direction.

in the code, i think the stuff that is between parenthesis are just comments, so the programmer knew what kind of string type to expect.

so code like this:
$clauses = (array) $clause;

I assume, means that $clauses is an array.
it should had probably been coded like this:
$clauses = array(); // array

once you sort that out in the code, where are you geting your errors? what line and what are the lines above & below that error line?

[ghormley]

The code looks as if it was written by a Java programmer accustomed to casting variables. That would explain the values in parentheses ahead of the variables. While no one does it in PHP, doesn't PHP support casting?

John Ghormley
Bedford, Texas

[Edward_Sandstig]

I could post the rest of the code, but the size of posts here is a little limited. I'll try posting the code on a standard HTML page somewhere.

I wonder if this could be a PHP3 to PHP4 migration issue or if I have to turn register_globals on or somethings...

[Zontar]

The code looks as if it was written by a Java programmer accustomed to casting variables. That would explain the values in parentheses ahead of the variables. While no one does it in PHP, doesn't PHP support casting?

Agreed regarding the Java-esque quality of the code. However, I must disagree with your statement that "no-one does it [casting] in PHP". Just as you don't have to make everything a class in PHP to write good and useful code (and I would argue that what Edward's trying to deal with here is an example of overkill), neither do you have to worry about data types a lot of the time -- but sometimes it's very useful indeed, even necessary.

At any rate, casting to arrays is possible PHP, but about the only time it's of any real use is with objects.

Zontar the Mindless -- Brisbane, Australia.