Attachment #38595 for bug #75102

Attachment #38595: To be super-reviewed (diff -u -N) for bug #75102

View | Details | Raw Unified | Return to bug 75102
Collapse All | Expand All





  ../source/xpath/BooleanResult.o \
  ../source/xpath/ElementExpr.o \
  ../source/xpath/ErrorFunctionCall.o \
  ../source/xpath/Expr.o \
  ../source/xpath/ExprLexer.o \
  ../source/xpath/ExprLexerChars.o \
  ../source/xpath/ExprParser.o \
  ../source/xpath/ExtensionFunctionCall.o \
  ../source/xpath/FilterExpr.o \
  ../source/xpath/FunctionCall.o \
  ../source/xpath/IdentityExpr.o \
  ../source/xpath/LocationStep.o \
  ../source/xpath/MultiplicativeExpr.o \
  ../source/xpath/NodeSet.o \

  ../source/xpath/NumberExpr.o \
  ../source/xpath/NumberFunctionCall.o \
  ../source/xpath/NumberResult.o \
  ../source/xpath/ParentExpr.o \
  ../source/xpath/PathExpr.o \
  ../source/xpath/PredicateList.o \
  ../source/xpath/RelationalExpr.o \

  ../source/xpath/StringResult.o \
  ../source/xpath/TextExpr.o \
  ../source/xpath/UnionExpr.o \
  ../source/xpath/UnaryExpr.o \
  ../source/xpath/VariableRefExpr.o \
  ../source/xpath/XPathNames.o \
  ../source/xpath/XPathProcessor.o \





	..\source\xpath\$(OBJDIR)\BooleanResult.obj \
	..\source\xpath\$(OBJDIR)\ElementExpr.obj \
	..\source\xpath\$(OBJDIR)\ErrorFunctionCall.obj \
	..\source\xpath\$(OBJDIR)\Expr.obj \
	..\source\xpath\$(OBJDIR)\ExprLexer.obj \
	..\source\xpath\$(OBJDIR)\ExprLexerChars.obj \
	..\source\xpath\$(OBJDIR)\ExprParser.obj \
	..\source\xpath\$(OBJDIR)\ExtensionFunctionCall.obj \
	..\source\xpath\$(OBJDIR)\FilterExpr.obj \
	..\source\xpath\$(OBJDIR)\FunctionCall.obj \
	..\source\xpath\$(OBJDIR)\IdentityExpr.obj \
	..\source\xpath\$(OBJDIR)\LocationStep.obj \
	..\source\xpath\$(OBJDIR)\MultiplicativeExpr.obj \
	..\source\xpath\$(OBJDIR)\NodeSet.obj \

	..\source\xpath\$(OBJDIR)\NumberExpr.obj \
	..\source\xpath\$(OBJDIR)\NumberFunctionCall.obj \
	..\source\xpath\$(OBJDIR)\NumberResult.obj \
	..\source\xpath\$(OBJDIR)\ParentExpr.obj \
	..\source\xpath\$(OBJDIR)\PathExpr.obj \
	..\source\xpath\$(OBJDIR)\PredicateList.obj \
	..\source\xpath\$(OBJDIR)\RelationalExpr.obj \

	..\source\xpath\$(OBJDIR)\StringResult.obj \
	..\source\xpath\$(OBJDIR)\TextExpr.obj \
	..\source\xpath\$(OBJDIR)\UnionExpr.obj \
	..\source\xpath\$(OBJDIR)\UnaryExpr.obj \
	..\source\xpath\$(OBJDIR)\VariableRefExpr.obj \
	..\source\xpath\$(OBJDIR)\XPathNames.obj \
	..\source\xpath\$(OBJDIR)\XPathProcessor.obj \





  ../xpath/BooleanResult.o \
  ../xpath/ElementExpr.o \
  ../xpath/ErrorFunctionCall.o \
  ../xpath/Expr.o \
  ../xpath/ExprLexer.o \
  ../xpath/ExprLexerChars.o \
  ../xpath/ExprParser.o \
  ../xpath/ExtensionFunctionCall.o \
  ../xpath/FilterExpr.o \
  ../xpath/FunctionCall.o \
  ../xpath/IdentityExpr.o \
  ../xpath/LocationStep.o \
  ../xpath/MultiplicativeExpr.o \
  ../xpath/NodeSet.o \

  ../xpath/NumberExpr.o \
  ../xpath/NumberFunctionCall.o \
  ../xpath/NumberResult.o \
  ../xpath/ParentExpr.o \
  ../xpath/PathExpr.o \
  ../xpath/PredicateList.o \
  ../xpath/RelationalExpr.o \

  ../xpath/StringResult.o \
  ../xpath/TextExpr.o \
  ../xpath/UnionExpr.o \
  ../xpath/UnaryExpr.o \
  ../xpath/VariableRefExpr.o \
  ../xpath/XPathNames.o \
  ../xml/XMLUtils.o \





  ../xpath/$(OBJDIR)/BooleanResult.obj \
  ../xpath/$(OBJDIR)/ElementExpr.obj \
  ../xpath/$(OBJDIR)/ErrorFunctionCall.obj \
  ../xpath/$(OBJDIR)/Expr.obj \
  ../xpath/$(OBJDIR)/ExprLexer.obj \
  ../xpath/$(OBJDIR)/ExprLexerChars.obj \
  ../xpath/$(OBJDIR)/ExprParser.obj \
  ../xpath/$(OBJDIR)/ExtensionFunctionCall.obj \
  ../xpath/$(OBJDIR)/FilterExpr.obj \
  ../xpath/$(OBJDIR)/FunctionCall.obj \
  ../xpath/$(OBJDIR)/IdentityExpr.obj \
  ../xpath/$(OBJDIR)/LocationStep.obj \
  ../xpath/$(OBJDIR)/MultiplicativeExpr.obj \
  ../xpath/$(OBJDIR)/NodeSet.obj \

  ../xpath/$(OBJDIR)/NumberExpr.obj \
  ../xpath/$(OBJDIR)/NumberFunctionCall.obj \
  ../xpath/$(OBJDIR)/NumberResult.obj \
  ../xpath/$(OBJDIR)/ParentExpr.obj \
  ../xpath/$(OBJDIR)/PathExpr.obj \
  ../xpath/$(OBJDIR)/PredicateList.obj \
  ../xpath/$(OBJDIR)/RelationalExpr.obj \

  ../xpath/$(OBJDIR)/StringResult.obj \
  ../xpath/$(OBJDIR)/TextExpr.obj \
  ../xpath/$(OBJDIR)/UnionExpr.obj \
  ../xpath/$(OBJDIR)/UnaryExpr.obj \
  ../xpath/$(OBJDIR)/VariableRefExpr.obj \
  ../xpath/$(OBJDIR)/XPathNames.obj \
  ../xml/$(OBJDIR)/XMLUtils.obj \





**/
BasicNodeExpr::BasicNodeExpr() {
    this->type = NodeExpr::NODE_EXPR;
    nodeNameSet = MB_FALSE;
} //-- BasicNodeExpr

/**

**/
BasicNodeExpr::BasicNodeExpr(NodeExpr::NodeExprType nodeExprType) {
    this->type = nodeExprType;
    nodeNameSet = MB_FALSE;
} //-- BasicNodeExpr

/**

 //- Public Methods -/
//------------------/

void BasicNodeExpr::setNodeName(const String& name) {
    this->nodeName = name;
    nodeNameSet = MB_TRUE;
}

  //-----------------------------/
 //- Methods from NodeExpr.cpp -/
//-----------------------------/

/**
 * Evaluates this Expr based on the given context node and processor state
 * @param context the context node for evaluation of this Expr

    return nodeSet;
} //-- evaluate

  //-----------------------------/
 //- Methods from NodeExpr.cpp -/
//-----------------------------/

/**
 * Returns the default priority of this Expr based on the given Node,
 * context Node, and ContextState.
 * If this pattern does not match the given Node under the current context Node and
 * ContextState then Negative Infinity is returned.
**/
double BasicNodeExpr::getDefaultPriority(Node* node, Node* context, ContextState* cs) {
    if (nodeNameSet) return 0;
    return -0.5;
} //-- getDefaultPriority


        case NodeExpr::COMMENT_EXPR:
            return (MBool) (node->getNodeType() == Node::COMMENT_NODE);
        case NodeExpr::PI_EXPR :
            return (MBool) (node->getNodeType() == Node::PROCESSING_INSTRUCTION_NODE &&
                            !nodeNameSet || nodeName.isEqual(node->getNodeName()));
        default: //-- node()
            if(node->getNodeType() == Node::TEXT_NODE)
                return !cs->isStripSpaceAllowed(node);

            dest.append("comment()");
            break;
        case NodeExpr::PI_EXPR :
            dest.append("processing-instruction(");
            if (nodeNameSet) {
                dest.append('\'');
                dest.append(nodeName);
                dest.append('\'');
            }
            dest.append(')');
            break;
        default: //-- node()
            dest.append("node()");





/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
 * The contents of this file are subject to the Mozilla Public
 * License Version 1.1 (the "License"); you may not use this file
 * except in compliance with the License. You may obtain a copy of
 * the License at http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS
 * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
 * implied. See the License for the specific language governing
 * rights and limitations under the License.
 *
 * The Initial Developer of the Original Code is Jonas Sicking.
 * Portions created by Jonas Sicking are Copyright (C) 2001, Jonas Sicking.
 * All rights reserved.
 *
 * Contributor(s):
 * Jonas Sicking, sicking@bigfoot.com
 *   -- original author.
 */
 
#include "Expr.h"

Expr::~Expr() {
} //-- ~Expr

/**
 * Determines whether this Expr matches the given node within
 * the given context
**/
MBool Expr::matches(Node* node, Node* context, ContextState* cs)
{
    #ifndef TX_EXE
    NS_ASSERTION(0,"Expr::matches() called");
    #endif
    return MB_FALSE;
} //-- matches

/**
 * Returns the default priority of this Expr based on the given Node,
 * context Node, and ContextState.
**/
double Expr::getDefaultPriority(Node* node, Node* context, ContextState* cs)
{
    #ifndef TX_EXE
    NS_ASSERTION(0,"Expr::matches() called");
    #endif
    return 0;
} //-- getDefaultPriority

(-)Expr.h (-636 / +120 lines)

Line	Link Here

Lines 24-29	Link Here

 *   -- 19990806

 *   -- 19990806

 *     - changed constant short declarations in many of the classes

 *     - changed constant short declarations in many of the classes

 *       with enumerations, commented with //--LF

 *       with enumerations, commented with //--LF

 * Jonas Sicking, sicking@bigfoot.com

 *   -- removal of Patterns and some restructuring

 *      in the class set

 * $Id: Expr.h,v 1.13 2001/05/12 09:54:15 nisheeth%netscape.com Exp $

 * $Id: Expr.h,v 1.13 2001/05/12 09:54:15 nisheeth%netscape.com Exp $

*/

*/

Lines 52-57	Link Here

//necessary prototypes

//necessary prototypes

class FunctionCall;

class FunctionCall;

typedef class Expr Pattern;

typedef class Expr PatternExpr;

/**

/**

 * The expression context and state class used when evaluating XPath Expressions.

 * The expression context and state class used when evaluating XPath Expressions.

**/

**/

Lines 115-121	Link Here

115

/**

122

/**

116

     * Virtual destructor, important for subclasses

123

     * Virtual destructor, important for subclasses

117

**/

124

**/

118

    virtual ~Expr() {};

125

    virtual ~Expr();

119

126

120

/**

127

/**

121

     * Evaluates this Expr based on the given context node and processor state

128

     * Evaluates this Expr based on the given context node and processor state

Lines 127-132	Link Here

127

    virtual ExprResult* evaluate(Node* context, ContextState* cs) = 0;

134

    virtual ExprResult* evaluate(Node* context, ContextState* cs) = 0;

128

135

129

/**

136

/**

137

     * Determines whether this Expr matches the given node within

138

     * the given context

139

**/

140

    virtual MBool matches(Node* node, Node* context, ContextState* cs);

141

142

/**

143

     * Returns the default priority of this Expr based on the given Node,

144

     * context Node, and ContextState.

145

**/

146

    virtual double getDefaultPriority(Node* node, Node* context, ContextState* cs);

147

148

/**

130

     * Returns the String representation of this Expr.

149

     * Returns the String representation of this Expr.

131

     * @param dest the String to use when creating the String

150

     * @param dest the String to use when creating the String

132

     * representation. The String representation will be appended to

151

     * representation. The String representation will be appended to

Lines 138-144	Link Here

138

157

139

}; //-- Expr

158

}; //-- Expr

140

159

141

142

/**

160

/**

143

 * This class represents a FunctionCall as defined by the XPath 1.0

161

 * This class represents a FunctionCall as defined by the XPath 1.0

144

 * Recommendation.

162

 * Recommendation.

Lines 149-171	Link Here

149

167

150

    static const String INVALID_PARAM_COUNT;

168

    static const String INVALID_PARAM_COUNT;

151

169

152

153

    virtual ~FunctionCall();

170

    virtual ~FunctionCall();

154

171

155

/**

172

/**

156

     * Adds the given parameter to this FunctionCall's parameter list

173

     * Virtual methods from Expr

157

     * @param expr the Expr to add to this FunctionCall's parameter list

158

**/

174

**/

159

    void addParam(Expr* expr);

175

    virtual ExprResult* evaluate(Node* context, ContextState* cs) = 0;

176

    virtual MBool matches(Node* node, Node* context, ContextState* cs);

177

    virtual double getDefaultPriority(Node* node, Node* context, ContextState* cs);

178

    virtual void toString(String& dest);

160

179

161

/**

180

/**

162

     * Evaluates this Expr based on the given context node and processor state

181

     * Adds the given parameter to this FunctionCall's parameter list

163

     * @param context the context node for evaluation of this Expr

182

     * @param expr the Expr to add to this FunctionCall's parameter list

164

     * @param ps the ContextState containing the stack information needed

165

     * for evaluation

166

     * @return the result of the evaluation

167

**/

183

**/

168

    virtual ExprResult* evaluate(Node* context, ContextState* cs) = 0;

184

    void addParam(Expr* expr);

169

185

170

/**

186

/**

171

     * Returns the name of this FunctionCall

187

     * Returns the name of this FunctionCall

Lines 184-198	Link Here

184

     * @param name the name of this Function

200

     * @param name the name of this Function

185

**/

201

**/

186

    void setName(const String& name);

202

    void setName(const String& name);

187

/**

188

     * Returns the String representation of this Pattern.

189

     * @param dest the String to use when creating the String

190

     * representation. The String representation will be appended to

191

     * any data in the destination String, to allow cascading calls to

192

     * other #toString() methods for Expressions.

193

     * @return the String representation of this Pattern.

194

**/

195

    virtual void toString(String& dest);

196

203

197

204

198

protected:

205

protected:

Lines 221-317	Link Here

221

    String name;

228

    String name;

222

}; //-- FunctionCall

229

}; //-- FunctionCall

223

230

224

/**

225

 * A base Pattern class

226

**/

227

class Pattern {

228

229

public:

230

231

/**

232

     * Virtual destructor, important for subclasses

233

**/

234

    virtual ~Pattern() {};

235

236

/**

237

     * Returns the default priority of this Pattern based on the given Node,

238

     * context Node, and ContextState.

239

     * If this pattern does not match the given Node under the current context Node and

240

     * ContextState then Negative Infinity is returned.

241

**/

242

    virtual double getDefaultPriority(Node* node, Node* context, ContextState* cs) = 0;

243

244

/**

245

     * Determines whether this Pattern matches the given node within

246

     * the given context

247

**/

248

    virtual MBool matches(Node* node, Node* context, ContextState* cs) = 0;

249

250

251

/**

252

     * Returns the String representation of this Pattern.

253

     * @param dest the String to use when creating the String

254

     * representation. The String representation will be appended to

255

     * any data in the destination String, to allow cascading calls to

256

     * other #toString() methods for Expressions.

257

     * @return the String representation of this Pattern.

258

**/

259

    virtual void toString(String& dest) = 0;

260

261

}; //-- Pattern

262

231

263

264

/**

232

/**

265

 * A Base class for all Expressions and Patterns

266

**/

267

class PatternExpr :

268

    public Expr,

269

    public Pattern

270

271

272

public:

273

274

/**

275

     * Virtual destructor, important for subclasses

276

**/

277

    virtual ~PatternExpr() {};

278

279

/**

280

     * Evaluates this Expr based on the given context node and processor state

281

     * @param context the context node for evaluation of this Expr

282

     * @param ps the ContextState containing the stack information needed

283

     * for evaluation

284

     * @return the result of the evaluation

285

**/

286

    virtual ExprResult* evaluate(Node* context, ContextState* cs) = 0;

287

288

/**

289

     * Returns the default priority of this Pattern based on the given Node,

290

     * context Node, and ContextState.

291

     * If this pattern does not match the given Node under the current context Node and

292

     * ContextState then Negative Infinity is returned.

293

**/

294

    virtual double getDefaultPriority(Node* node, Node* context, ContextState* cs) = 0;

295

296

/**

297

     * Determines whether this PatternExpr matches the given node within

298

     * the given context

299

**/

300

    virtual MBool matches(Node* node, Node* context, ContextState* cs) = 0;

301

302

/**

303

     * Returns the String representation of this PatternExpr.

304

     * @param dest the String to use when creating the String

305

     * representation. The String representation will be appended to

306

     * any data in the destination String, to allow cascading calls to

307

     * other #toString() methods for Expressions.

308

     * @return the String representation of this PatternExpr.

309

**/

310

    virtual void toString(String& dest) = 0;

311

312

}; //-- PatternExpr

313

314

/**

315

 * Represents an AttributeValueTemplate

233

 * Represents an AttributeValueTemplate

316

**/

234

**/

317

class AttributeValueTemplate: public Expr {

235

class AttributeValueTemplate: public Expr {

Lines 328-349	Link Here

328

    void addExpr(Expr* expr);

246

    void addExpr(Expr* expr);

329

247

330

/**

248

/**

331

     * Evaluates this Expr based on the given context node and processor state

249

     * Virtual methods from Expr

332

     * @param context the context node for evaluation of this Expr

333

     * @param ps the ContextState containing the stack information needed

334

     * for evaluation

335

     * @return the result of the evaluation

336

**/

250

**/

337

    virtual ExprResult* evaluate(Node* context, ContextState* cs);

251

    virtual ExprResult* evaluate(Node* context, ContextState* cs);

338

339

/**

340

     * Returns the String representation of this Expr.

341

     * @param dest the String to use when creating the String

342

     * representation. The String representation will be appended to

343

     * any data in the destination String, to allow cascading calls to

344

     * other #toString() methods for Expressions.

345

     * @return the String representation of this Expr.

346

**/

347

    virtual void toString(String& str);

252

    virtual void toString(String& str);

348

253

349

private:

254

private:

Lines 355-361	Link Here

355

 * This class represents a NodeTestExpr as defined by the XSL

260

 * This class represents a NodeTestExpr as defined by the XSL

356

 * Working Draft

261

 * Working Draft

357

**/

262

**/

358

class NodeExpr : public PatternExpr {

263

class NodeExpr : public Expr {

359

264

360

public:

265

public:

361

266

Lines 379-411	Link Here

379

    //------------------/

284

    //------------------/

380

285

381

/**

286

/**

382

     * Returns the default priority of this Pattern based on the given Node,

383

     * context Node, and ContextState.

384

     * If this pattern does not match the given Node under the current context Node and

385

     * ContextState then Negative Infinity is returned.

386

**/

387

    virtual double getDefaultPriority(Node* node, Node* context, ContextState* cs) = 0;

388

389

/**

390

     * Returns the type of this NodeExpr

287

     * Returns the type of this NodeExpr

391

     * @return the type of this NodeExpr

288

     * @return the type of this NodeExpr

392

**/

289

**/

393

    virtual short getType() = 0;

290

    virtual short getType() = 0;

394

291

395

/**

292

/**

396

     * Determines whether this NodeExpr matches the given node within

293

     * Virtual methods from Expr

397

     * the given context

398

**/

294

**/

399

    virtual MBool matches(Node* node, Node* context, ContextState* cs) = 0;

295

    virtual MBool matches(Node* node, Node* context, ContextState* cs) = 0;

400

296

    virtual double getDefaultPriority(Node* node, Node* context, ContextState* cs) = 0;

401

/**

402

     * Returns the String representation of this Pattern.

403

     * @param dest the String to use when creating the String

404

     * representation. The String representation will be appended to

405

     * any data in the destination String, to allow cascading calls to

406

     * other #toString() methods for Expressions.

407

     * @return the String representation of this Pattern.

408

**/

409

    virtual void toString(String& dest) = 0;

297

    virtual void toString(String& dest) = 0;

410

298

411

}; //-- NodeExpr

299

}; //-- NodeExpr

Lines 440-486	Link Here

440

**/

328

**/

441

    void setName(const String& name);

329

    void setName(const String& name);

442

330

443

    //-----------------------------------/

444

   //- Method signatures from NodeExpr -/

445

  //-----------------------------------/

446

447

/**

331

/**

448

     * Returns the default priority of this Pattern based on the given Node,

332

     * Virtual methods from NodeExpr

449

     * context Node, and ContextState.

450

     * If this pattern does not match the given Node under the current context Node and

451

     * ContextState then Negative Infinity is returned.

452

**/

333

**/

453

    virtual double getDefaultPriority(Node* node, Node* context, ContextState* cs);

454

455

/**

456

     * Evaluates this Expr based on the given context node and processor state

457

     * @param context the context node for evaluation of this Expr

458

     * @param ps the ContextState containing the stack information needed

459

     * for evaluation

460

     * @return the result of the evaluation

461

**/

462

    virtual ExprResult* evaluate(Node* context, ContextState* cs);

334

    virtual ExprResult* evaluate(Node* context, ContextState* cs);

463

464

/**

465

     * Returns the type of this NodeExpr

466

     * @return the type of this NodeExpr

467

**/

468

    short getType();

335

    short getType();

469

470

/**

471

     * Determines whether this NodeExpr matches the given node within

472

     * the given context

473

**/

474

    virtual MBool matches(Node* node, Node* context, ContextState* cs);

336

    virtual MBool matches(Node* node, Node* context, ContextState* cs);

475

337

    virtual double getDefaultPriority(Node* node, Node* context, ContextState* cs);

476

/**

477

     * Returns the String representation of this NodeExpr.

478

     * @param dest the String to use when creating the String

479

     * representation. The String representation will be appended to

480

     * any data in the destination String, to allow cascading calls to

481

     * other #toString() methods for Expressions.

482

     * @return the String representation of this NodeExpr.

483

**/

484

    virtual void toString(String& dest);

338

    virtual void toString(String& dest);

485

339

486

private:

340

private:

Lines 521-572	Link Here

521

     * Destroys this BasicNodeExpr

375

     * Destroys this BasicNodeExpr

522

**/

376

**/

523

    virtual ~BasicNodeExpr();

377

    virtual ~BasicNodeExpr();

524

378

525

    //-----------------------------------/

526

   //- Method signatures from NodeExpr -/

527

  //-----------------------------------/

528

529

/**

379

/**

530

     * Returns the default priority of this Pattern based on the given Node,

380

     * Sets the name of the node to match. Only availible for pi nodes

531

     * context Node, and ContextState.

532

     * If this pattern does not match the given Node under the current context Node and

533

     * ContextState then Negative Infinity is returned.

534

**/

381

**/

535

    virtual double getDefaultPriority(Node* node, Node* context, ContextState* cs);

382

    void setNodeName(const String& name);

536

383

537

/**

384

/**

538

     * Evaluates this Expr based on the given context node and processor state

385

     * Virtual methods from NodeExpr

539

     * @param context the context node for evaluation of this Expr

540

     * @param ps the ContextState containing the stack information needed

541

     * for evaluation

542

     * @return the result of the evaluation

543

**/

386

**/

544

    virtual ExprResult* evaluate(Node* context, ContextState* cs);

387

    virtual ExprResult* evaluate(Node* context, ContextState* cs);

545

546

/**

547

     * Returns the type of this NodeExpr

548

     * @return the type of this NodeExpr

549

**/

550

    short getType();

388

    short getType();

551

552

/**

553

     * Determines whether this NodeExpr matches the given node within

554

     * the given context

555

**/

556

    virtual MBool matches(Node* node, Node* context, ContextState* cs);

389

    virtual MBool matches(Node* node, Node* context, ContextState* cs);

557

390

    virtual double getDefaultPriority(Node* node, Node* context, ContextState* cs);

558

/**

559

     * Returns the String representation of this NodeExpr.

560

     * @param dest the String to use when creating the String

561

     * representation. The String representation will be appended to

562

     * any data in the destination String, to allow cascading calls to

563

     * other #toString() methods for Expressions.

564

     * @return the String representation of this NodeExpr.

565

**/

566

    virtual void toString(String& dest);

391

    virtual void toString(String& dest);

567

392

568

private:

393

private:

569

    NodeExprType type;

394

    NodeExprType type;

395

    String nodeName;

396

    MBool nodeNameSet;

570

}; //-- BasicNodeExpr

397

}; //-- BasicNodeExpr

571

398

572

/**

399

/**

Lines 597-643	Link Here

597

**/

424

**/

598

    void setName(const String& name);

425

    void setName(const String& name);

599

426

600

    //-----------------------------------/

601

   //- Method signatures from NodeExpr -/

602

  //-----------------------------------/

603

604

/**

427

/**

605

     * Evaluates this Expr based on the given context node and processor state

428

     * Virtual methods from NodeExpr

606

     * @param context the context node for evaluation of this Expr

607

     * @param ps the ContextState containing the stack information needed

608

     * for evaluation

609

     * @return the result of the evaluation

610

**/

429

**/

611

    virtual ExprResult* evaluate(Node* context, ContextState* cs);

430

    virtual ExprResult* evaluate(Node* context, ContextState* cs);

612

613

/**

614

     * Returns the default priority of this Pattern based on the given Node,

615

     * context Node, and ContextState.

616

     * If this pattern does not match the given Node under the current context Node and

617

     * ContextState then Negative Infinity is returned.

618

**/

619

    virtual double getDefaultPriority(Node* node, Node* context, ContextState* cs);

620

621

/**

622

     * Returns the type of this NodeExpr

623

     * @return the type of this NodeExpr

624

**/

625

    short getType();

431

    short getType();

626

432

    virtual double getDefaultPriority(Node* node, Node* context, ContextState* cs);

627

/**

628

     * Determines whether this NodeExpr matches the given node within

629

     * the given context

630

**/

631

    virtual MBool matches(Node* node, Node* context, ContextState* cs);

433

    virtual MBool matches(Node* node, Node* context, ContextState* cs);

632

633

/**

634

     * Returns the String representation of this NodeExpr.

635

     * @param dest the String to use when creating the String

636

     * representation. The String representation will be appended to

637

     * any data in the destination String, to allow cascading calls to

638

     * other #toString() methods for Expressions.

639

     * @return the String representation of this NodeExpr.

640

**/

641

    virtual void toString(String& dest);

434

    virtual void toString(String& dest);

642

435

643

private:

436

private:

Lines 655-775	Link Here

655

}; //-- ElementExpr

448

}; //-- ElementExpr

656

449

657

/**

450

/**

658

 * This class represents a IdentityExpr, which only matches a node

659

 * if it is equal to the context node

660

**/

661

class IdentityExpr : public Expr {

662

663

public:

664

665

      //------------------/

666

     //- Public Methods -/

667

    //------------------/

668

669

/**

670

     * Evaluates this Expr based on the given context node and processor state

671

     * @param context the context node for evaluation of this Expr

672

     * @param ps the ContextState containing the stack information needed

673

     * for evaluation

674

     * @return the result of the evaluation

675

**/

676

    virtual ExprResult* evaluate(Node* context, ContextState* cs);

677

678

/**

679

     * Returns the String representation of this NodeExpr.

680

     * @param dest the String to use when creating the String

681

     * representation. The String representation will be appended to

682

     * any data in the destination String, to allow cascading calls to

683

     * other #toString() methods for Expressions.

684

     * @return the String representation of this NodeExpr.

685

**/

686

    virtual void toString(String& dest);

687

688

}; //-- IdentityExpr

689

690

/**

691

 * This class represents a ParentExpr, which only selects a node

692

 * if it is equal to the context node's parent

693

**/

694

class ParentExpr : public Expr {

695

696

public:

697

698

      //------------------/

699

     //- Public Methods -/

700

    //------------------/

701

702

/**

703

     * Evaluates this Expr based on the given context node and processor state

704

     * @param context the context node for evaluation of this Expr

705

     * @param ps the ContextState containing the stack information needed

706

     * for evaluation

707

     * @return the result of the evaluation

708

**/

709

    virtual ExprResult* evaluate(Node* context, ContextState* cs);

710

711

712

/**

713

     * Returns the String representation of this NodeExpr.

714

     * @param dest the String to use when creating the String

715

     * representation. The String representation will be appended to

716

     * any data in the destination String, to allow cascading calls to

717

     * other #toString() methods for Expressions.

718

     * @return the String representation of this NodeExpr.

719

**/

720

    virtual void toString(String& dest);

721

722

}; //-- ParentExpr

723

724

/**

725

 * This class represents a TextExpr, which only matches any text node

451

 * This class represents a TextExpr, which only matches any text node

726

**/

452

**/

727

class TextExpr : public NodeExpr {

453

class TextExpr : public NodeExpr {

728

454

729

public:

455

public:

730

731

      //------------------/

732

     //- Public Methods -/

733

    //------------------/

734

735

/**

736

     * Evaluates this Expr based on the given context node and processor state

737

     * @param context the context node for evaluation of this Expr

738

     * @param ps the ContextState containing the stack information needed

739

     * for evaluation

740

     * @return the result of the evaluation

741

**/

742

    virtual ExprResult* evaluate(Node* context, ContextState* cs);

743

744

/**

745

     * Returns the default priority of this Pattern based on the given Node,

746

     * context Node, and ContextState.

747

     * If this pattern does not match the given Node under the current context Node and

748

     * ContextState then Negative Infinity is returned.

749

**/

750

    virtual double getDefaultPriority(Node* node, Node* context, ContextState* cs);

751

752

/**

753

     * Returns the type of this NodeExpr

754

     * @return the type of this NodeExpr

755

**/

756

    virtual short getType();

757

758

/**

759

     * Determines whether this NodeExpr matches the given node within

760

     * the given context

761

**/

762

    virtual MBool matches(Node* node, Node* context, ContextState* cs);

763

456

457

      //------------------/

458

     //- Public Methods -/

459

    //------------------/

764

460

765

/**

461

/**

766

     * Returns the String representation of this NodeExpr.

462

     * Virtual methods from NodeExpr

767

     * @param dest the String to use when creating the String

768

     * representation. The String representation will be appended to

769

     * any data in the destination String, to allow cascading calls to

770

     * other #toString() methods for Expressions.

771

     * @return the String representation of this NodeExpr.

772

**/

463

**/

464

    virtual ExprResult* evaluate(Node* context, ContextState* cs);

465

    virtual short getType();

466

    virtual MBool matches(Node* node, Node* context, ContextState* cs);

467

    virtual double getDefaultPriority(Node* node, Node* context, ContextState* cs);

773

    virtual void toString(String& dest);

468

    virtual void toString(String& dest);

774

469

775

}; //-- TextExpr

470

}; //-- TextExpr

Lines 827-833	Link Here

827

    List predicates;

522

    List predicates;

828

}; //-- PredicateList

523

}; //-- PredicateList

829

524

830

class LocationStep : public PredicateList, public PatternExpr {

525

class LocationStep : public PredicateList, public Expr {

831

526

832

public:

527

public:

833

528

Lines 887-933	Link Here

887

**/

582

**/

888

    void setNodeExpr(NodeExpr* nodeExpr);

583

    void setNodeExpr(NodeExpr* nodeExpr);

889

584

890

      //------------------------------------/

891

     //- Virtual methods from PatternExpr -/

892

    //------------------------------------/

893

894

/**

585

/**

895

     * Evaluates this Expr based on the given context node and processor state

586

     * Virtual methods from Expr

896

     * @param context the context node for evaluation of this Expr

897

     * @param ps the ContextState containing the stack information needed

898

     * for evaluation

899

     * @return the result of the evaluation

900

**/

587

**/

901

    virtual ExprResult* evaluate(Node* context, ContextState* cs);

588

    virtual ExprResult* evaluate(Node* context, ContextState* cs);

902

903

/**

904

     * Returns the default priority of this Pattern based on the given Node,

905

     * context Node, and ContextState.

906

     * If this pattern does not match the given Node under the current context Node and

907

     * ContextState then Negative Infinity is returned.

908

**/

909

    virtual double getDefaultPriority(Node* node, Node* context, ContextState* cs);

910

911

/**

912

     * Determines whether this PatternExpr matches the given node within

913

     * the given context

914

**/

915

    virtual MBool matches(Node* node, Node* context, ContextState* cs);

589

    virtual MBool matches(Node* node, Node* context, ContextState* cs);

916

590

    virtual double getDefaultPriority(Node* node, Node* context, ContextState* cs);

917

/**

918

     * Returns the String representation of this PatternExpr.

919

     * @param dest the String to use when creating the String

920

     * representation. The String representation will be appended to

921

     * any data in the destination String, to allow cascading calls to

922

     * other #toString() methods for Expressions.

923

     * @return the String representation of this PatternExpr.

924

**/

925

    virtual void toString(String& dest);

591

    virtual void toString(String& dest);

926

592

927

private:

593

private:

928

594

929

  NodeExpr* nodeExpr;

595

    NodeExpr* nodeExpr;

930

  short     axisIdentifier;

596

    short     axisIdentifier;

931

597

932

    void fromDescendants(Node* context, ContextState* cs, NodeSet* nodes);

598

    void fromDescendants(Node* context, ContextState* cs, NodeSet* nodes);

933

    void fromDescendantsRev(Node* context, ContextState* cs, NodeSet* nodes);

599

    void fromDescendantsRev(Node* context, ContextState* cs, NodeSet* nodes);

Lines 935-941	Link Here

935

}; //-- LocationStep

601

}; //-- LocationStep

936

602

937

603

938

class FilterExpr : public PredicateList, public PatternExpr {

604

class FilterExpr : public PredicateList, public Expr {

939

605

940

public:

606

public:

941

607

Lines 962-1007	Link Here

962

**/

628

**/

963

    void setExpr(Expr* expr);

629

    void setExpr(Expr* expr);

964

630

965

      //------------------------------------/

966

     //- Virtual methods from PatternExpr -/

967

    //------------------------------------/

968

969

/**

631

/**

970

     * Evaluates this Expr based on the given context node and processor state

632

     * Virtual methods from Expr

971

     * @param context the context node for evaluation of this Expr

972

     * @param ps the ContextState containing the stack information needed

973

     * for evaluation

974

     * @return the result of the evaluation

975

**/

633

**/

976

    virtual ExprResult* evaluate(Node* context, ContextState* cs);

634

    virtual ExprResult* evaluate(Node* context, ContextState* cs);

977

978

/**

979

     * Returns the default priority of this Pattern based on the given Node,

980

     * context Node, and ContextState.

981

     * If this pattern does not match the given Node under the current context Node and

982

     * ContextState then Negative Infinity is returned.

983

**/

984

    virtual double getDefaultPriority(Node* node, Node* context, ContextState* cs);

985

986

/**

987

     * Determines whether this PatternExpr matches the given node within

988

     * the given context

989

**/

990

    virtual MBool matches(Node* node, Node* context, ContextState* cs);

635

    virtual MBool matches(Node* node, Node* context, ContextState* cs);

991

636

    virtual double getDefaultPriority(Node* node, Node* context, ContextState* cs);

992

/**

993

     * Returns the String representation of this PatternExpr.

994

     * @param dest the String to use when creating the String

995

     * representation. The String representation will be appended to

996

     * any data in the destination String, to allow cascading calls to

997

     * other #toString() methods for Expressions.

998

     * @return the String representation of this PatternExpr.

999

**/

1000

    virtual void toString(String& dest);

637

    virtual void toString(String& dest);

1001

638

1002

private:

639

private:

1003

640

1004

  Expr*     expr;

641

    Expr* expr;

1005

642

1006

}; //-- FilterExpr

643

}; //-- FilterExpr

1007

644

Lines 1015-1036	Link Here

1015

    ~NumberExpr();

652

    ~NumberExpr();

1016

653

1017

/**

654

/**

1018

     * Evaluates this Expr based on the given context node and processor state

655

     * Virtual methods from Expr

1019

     * @param context the context node for evaluation of this Expr

1020

     * @param ps the ContextState containing the stack information needed

1021

     * for evaluation

1022

     * @return the result of the evaluation

1023

**/

656

**/

1024

    virtual ExprResult* evaluate(Node* context, ContextState* cs);

657

    virtual ExprResult* evaluate(Node* context, ContextState* cs);

1025

1026

/**

1027

     * Returns the String representation of this Expr.

1028

     * @param dest the String to use when creating the String

1029

     * representation. The String representation will be appended to

1030

     * any data in the destination String, to allow cascading calls to

1031

     * other #toString() methods for Expressions.

1032

     * @return the String representation of this Expr.

1033

**/

1034

    virtual void toString(String& str);

658

    virtual void toString(String& str);

1035

659

1036

private:

660

private:

Lines 1052-1073	Link Here

1052

    ~StringExpr();

676

    ~StringExpr();

1053

677

1054

/**

678

/**

1055

     * Evaluates this Expr based on the given context node and processor state

679

     * Virtual methods from Expr

1056

     * @param context the context node for evaluation of this Expr

1057

     * @param ps the ContextState containing the stack information needed

1058

     * for evaluation

1059

     * @return the result of the evaluation

1060

**/

680

**/

1061

    virtual ExprResult* evaluate(Node* context, ContextState* cs);

681

    virtual ExprResult* evaluate(Node* context, ContextState* cs);

1062

1063

/**

1064

     * Returns the String representation of this Expr.

1065

     * @param dest the String to use when creating the String

1066

     * representation. The String representation will be appended to

1067

     * any data in the destination String, to allow cascading calls to

1068

     * other #toString() methods for Expressions.

1069

     * @return the String representation of this Expr.

1070

**/

1071

    virtual void toString(String& str);

682

    virtual void toString(String& str);

1072

683

1073

private:

684

private:

Lines 1106-1127	Link Here

1106

717

1107

718

1108

/**

719

/**

1109

     * Evaluates this Expr based on the given context node and processor state

720

     * Virtual methods from Expr

1110

     * @param context the context node for evaluation of this Expr

1111

     * @param ps the ContextState containing the stack information needed

1112

     * for evaluation

1113

     * @return the result of the evaluation

1114

**/

721

**/

1115

    virtual ExprResult* evaluate(Node* context, ContextState* cs);

722

    virtual ExprResult* evaluate(Node* context, ContextState* cs);

1116

1117

/**

1118

     * Returns the String representation of this Expr.

1119

     * @param dest the String to use when creating the String

1120

     * representation. The String representation will be appended to

1121

     * any data in the destination String, to allow cascading calls to

1122

     * other #toString() methods for Expressions.

1123

     * @return the String representation of this Expr.

1124

**/

1125

    virtual void toString(String& str);

723

    virtual void toString(String& str);

1126

724

1127

725

Lines 1133-1138	Link Here

1133

}; //-- AdditiveExpr

731

}; //-- AdditiveExpr

1134

732

1135

/**

733

/**

734

 * Represents an UnaryExpr. Returns the negative value of it's expr.

735

**/

736

class UnaryExpr : public Expr {

737

738

public:

739

740

     UnaryExpr();

741

     UnaryExpr(Expr* expr);

742

     ~UnaryExpr();

743

744

/**

745

     * Sets the expression to negate

746

**/

747

    void setExpr(Expr* expr);

748

749

/**

750

     * Virtual methods from Expr

751

**/

752

    virtual ExprResult* evaluate(Node* context, ContextState* cs);

753

    virtual void toString(String& str);

754

755

private:

756

    Expr* expr;

757

}; //-- UnaryExpr

758

759

/**

1136

 * Represents a BooleanExpr, a binary expression that

760

 * Represents a BooleanExpr, a binary expression that

1137

 * performs a boolean operation between it's lvalue and rvalue:<BR/>

761

 * performs a boolean operation between it's lvalue and rvalue:<BR/>

1138

**/

762

**/

Lines 1148-1180	Link Here

1148

     ~BooleanExpr();

772

     ~BooleanExpr();

1149

773

1150

/**

774

/**

1151

     * Sets the left side of this AdditiveExpr

775

     * Sets the left side of this BooleanExpr

1152

**/

776

**/

1153

    void setLeftExpr(Expr* leftExpr);

777

    void setLeftExpr(Expr* leftExpr);

1154

778

1155

/**

779

/**

1156

     * Sets the right side of this AdditiveExpr

780

     * Sets the right side of this BooleanExpr

1157

**/

781

**/

1158

    void setRightExpr(Expr* rightExpr);

782

    void setRightExpr(Expr* rightExpr);

1159

783

1160

784

1161

/**

785

/**

1162

     * Evaluates this Expr based on the given context node and processor state

786

     * Virtual methods from Expr

1163

     * @param context the context node for evaluation of this Expr

1164

     * @param ps the ContextState containing the stack information needed

1165

     * for evaluation

1166

     * @return the result of the evaluation

1167

**/

787

**/

1168

    virtual ExprResult* evaluate(Node* context, ContextState* cs);

788

    virtual ExprResult* evaluate(Node* context, ContextState* cs);

1169

1170

/**

1171

     * Returns the String representation of this Expr.

1172

     * @param dest the String to use when creating the String

1173

     * representation. The String representation will be appended to

1174

     * any data in the destination String, to allow cascading calls to

1175

     * other #toString() methods for Expressions.

1176

     * @return the String representation of this Expr.

1177

**/

1178

    virtual void toString(String& str);

789

    virtual void toString(String& str);

1179

790

1180

791

Lines 1215-1242	Link Here

1215

**/

826

**/

1216

    void setRightExpr(Expr* rightExpr);

827

    void setRightExpr(Expr* rightExpr);

1217

828

1218

1219

/**

829

/**

1220

     * Evaluates this Expr based on the given context node and processor state

830

     * Virtual methods from Expr

1221

     * @param context the context node for evaluation of this Expr

1222

     * @param ps the ContextState containing the stack information needed

1223

     * for evaluation

1224

     * @return the result of the evaluation

1225

**/

831

**/

1226

    virtual ExprResult* evaluate(Node* context, ContextState* cs);

832

    virtual ExprResult* evaluate(Node* context, ContextState* cs);

1227

1228

/**

1229

     * Returns the String representation of this Expr.

1230

     * @param dest the String to use when creating the String

1231

     * representation. The String representation will be appended to

1232

     * any data in the destination String, to allow cascading calls to

1233

     * other #toString() methods for Expressions.

1234

     * @return the String representation of this Expr.

1235

**/

1236

    virtual void toString(String& str);

833

    virtual void toString(String& str);

1237

834

1238

1239

1240

private:

835

private:

1241

    short op;

836

    short op;

1242

    Expr* leftExpr;

837

    Expr* leftExpr;

Lines 1273-1298	Link Here

1273

     ~RelationalExpr();

868

     ~RelationalExpr();

1274

869

1275

/**

870

/**

1276

     * Evaluates this Expr based on the given context node and processor state

871

     * Virtual methods from Expr

1277

     * @param context the context node for evaluation of this Expr

1278

     * @param ps the ContextState containing the stack information needed

1279

     * for evaluation

1280

     * @return the result of the evaluation

1281

**/

872

**/

1282

    virtual ExprResult* evaluate(Node* context, ContextState* cs);

873

    virtual ExprResult* evaluate(Node* context, ContextState* cs);

1283

1284

/**

1285

     * Returns the String representation of this Expr.

1286

     * @param dest the String to use when creating the String

1287

     * representation. The String representation will be appended to

1288

     * any data in the destination String, to allow cascading calls to

1289

     * other #toString() methods for Expressions.

1290

     * @return the String representation of this Expr.

1291

**/

1292

    virtual void toString(String& str);

874

    virtual void toString(String& str);

1293

875

1294

1295

1296

private:

876

private:

1297

    short op;

877

    short op;

1298

    Expr* leftExpr;

878

    Expr* leftExpr;

Lines 1320-1341	Link Here

1320

    void setName(const String& name);

900

    void setName(const String& name);

1321

901

1322

/**

902

/**

1323

     * Evaluates this Expr based on the given context node and processor state

903

     * Virtual methods from Expr

1324

     * @param context the context node for evaluation of this Expr

1325

     * @param ps the ContextState containing the stack information needed

1326

     * for evaluation

1327

     * @return the result of the evaluation

1328

**/

904

**/

1329

    virtual ExprResult* evaluate(Node* context, ContextState* cs);

905

    virtual ExprResult* evaluate(Node* context, ContextState* cs);

1330

1331

/**

1332

     * Returns the String representation of this Expr.

1333

     * @param dest the String to use when creating the String

1334

     * representation. The String representation will be appended to

1335

     * any data in the destination String, to allow cascading calls to

1336

     * other #toString() methods for Expressions.

1337

     * @return the String representation of this Expr.

1338

**/

1339

    virtual void toString(String& str);

906

    virtual void toString(String& str);

1340

907

1341

private:

908

private:

Lines 1346-1352	Link Here

1346

/**

913

/**

1347

 *  Represents a PathExpr

914

 *  Represents a PathExpr

1348

**/

915

**/

1349

class PathExpr : public PatternExpr {

916

class PathExpr : public Expr {

1350

917

1351

public:

918

public:

1352

919

Lines 1361-1426	Link Here

1361

    PathExpr();

928

    PathExpr();

1362

929

1363

/**

930

/**

1364

     * Destructor, will delete all Pattern Expressions

931

     * Destructor, will delete all Expressions

1365

**/

932

**/

1366

    virtual ~PathExpr();

933

    virtual ~PathExpr();

1367

934

1368

/**

935

/**

1369

     * Adds the PatternExpr to this PathExpr

936

     * Adds the Expr to this PathExpr

1370

     * @param expr the Expr to add to this PathExpr

937

     * @param expr the Expr to add to this PathExpr

1371

     * @param index the index at which to add the given Expr

938

     * @param index the index at which to add the given Expr

1372

**/

939

**/

1373

    void addPatternExpr(int index, PatternExpr* expr, short ancestryOp);

940

    void addExpr(int index, Expr* expr, short ancestryOp);

1374

941

1375

/**

942

/**

1376

     * Adds the PatternExpr to this PathExpr

943

     * Adds the Expr to this PathExpr

1377

     * @param expr the Expr to add to this PathExpr

944

     * @param expr the Expr to add to this PathExpr

1378

**/

945

**/

1379

    void addPatternExpr(PatternExpr* expr, short ancestryOp);

946

    void addExpr(Expr* expr, short ancestryOp);

1380

947

1381

    virtual MBool isAbsolute();

948

    virtual MBool isAbsolute();

1382

949

1383

      //------------------------------------/

1384

     //- Virtual methods from PatternExpr -/

1385

    //------------------------------------/

1386

1387

/**

950

/**

1388

     * Evaluates this Expr based on the given context node and processor state

951

     * Virtual methods from Expr

1389

     * @param context the context node for evaluation of this Expr

1390

     * @param ps the ContextState containing the stack information needed

1391

     * for evaluation

1392

     * @return the result of the evaluation

1393

**/

952

**/

1394

    virtual ExprResult* evaluate(Node* context, ContextState* cs);

953

    virtual ExprResult* evaluate(Node* context, ContextState* cs);

1395

1396

/**

1397

     * Returns the default priority of this Pattern based on the given Node,

1398

     * context Node, and ContextState.

1399

     * If this pattern does not match the given Node under the current context Node and

1400

     * ContextState then Negative Infinity is returned.

1401

**/

1402

    virtual double getDefaultPriority(Node* node, Node* context, ContextState* cs);

1403

1404

/**

1405

     * Determines whether this PatternExpr matches the given node within

1406

     * the given context

1407

**/

1408

    virtual MBool matches(Node* node, Node* context, ContextState* cs);

954

    virtual MBool matches(Node* node, Node* context, ContextState* cs);

1409

955

    virtual double getDefaultPriority(Node* node, Node* context, ContextState* cs);

1410

/**

1411

     * Returns the String representation of this PatternExpr.

1412

     * @param dest the String to use when creating the String

1413

     * representation. The String representation will be appended to

1414

     * any data in the destination String, to allow cascading calls to

1415

     * other #toString() methods for Expressions.

1416

     * @return the String representation of this PatternExpr.

1417

**/

1418

    virtual void toString(String& dest);

956

    virtual void toString(String& dest);

1419

957

1420

private:

958

private:

1421

959

1422

    struct PathExprItem {

960

    struct PathExprItem {

1423

        PatternExpr* pExpr;

961

        Expr* expr;

1424

        short ancestryOp;

962

        short ancestryOp;

1425

};

963

};

1426

964

Lines 1428-1440	Link Here

1428

966

1429

/**

967

/**

1430

    * Selects from the descendants of the context node

968

    * Selects from the descendants of the context node

1431

    * all nodes that match the PatternExpr

969

    * all nodes that match the Expr

1432

    * -- this will be moving to a Utility class

970

    * -- this will be moving to a Utility class

1433

**/

971

**/

1434

   void evalDescendants(PatternExpr* pExpr,

972

   void evalDescendants(Expr* expr,

1435

                        Node* context,

973

                        Node* context,

1436

                        ContextState* cs,

974

                        ContextState* cs,

1437

                        NodeSet* nodes);

975

                        NodeSet* resNodes);

1438

976

1439

}; //-- PathExpr

977

}; //-- PathExpr

1440

978

Lines 1450-1496	Link Here

1450

    //------------------/

988

    //------------------/

1451

989

1452

/**

990

/**

1453

     * Evaluates this Expr based on the given context node and processor state

991

     * Virtual methods from Expr

1454

     * @param context the context node for evaluation of this Expr

1455

     * @param ps the ContextState containing the stack information needed

1456

     * for evaluation

1457

     * @return the result of the evaluation

1458

**/

992

**/

1459

    virtual ExprResult* evaluate(Node* context, ContextState* cs);

993

    virtual ExprResult* evaluate(Node* context, ContextState* cs);

1460

1461

    virtual MBool isAbsolute();

1462

1463

/**

1464

     * Returns the default priority of this Pattern based on the given Node,

1465

     * context Node, and ContextState.

1466

     * If this pattern does not match the given Node under the current context Node and

1467

     * ContextState then Negative Infinity is returned.

1468

**/

1469

    virtual double getDefaultPriority(Node* node, Node* context, ContextState* cs);

1470

1471

/**

1472

     * Determines whether this NodeExpr matches the given node within

1473

     * the given context

1474

**/

1475

    virtual MBool matches(Node* node, Node* context, ContextState* cs);

994

    virtual MBool matches(Node* node, Node* context, ContextState* cs);

1476

995

    virtual double getDefaultPriority(Node* node, Node* context, ContextState* cs);

1477

/**

1478

     * Returns the String representation of this PatternExpr.

1479

     * @param dest the String to use when creating the String

1480

     * representation. The String representation will be appended to

1481

     * any data in the destination String, to allow cascading calls to

1482

     * other #toString() methods for Expressions.

1483

     * @return the String representation of this PatternExpr.

1484

**/

1485

    virtual void toString(String& dest);

996

    virtual void toString(String& dest);

1486

997

998

    virtual MBool isAbsolute();

999

1487

1000

1488

}; //-- RootExpr

1001

}; //-- RootExpr

1489

1002

1490

/**

1003

/**

1491

 *  Represents a UnionExpr

1004

 *  Represents a UnionExpr

1492

**/

1005

**/

1493

class UnionExpr : public PatternExpr {

1006

class UnionExpr : public Expr {

1494

1007

1495

public:

1008

public:

1496

1009

Lines 1508-1556	Link Here

1508

     * Adds the PathExpr to this UnionExpr

1021

     * Adds the PathExpr to this UnionExpr

1509

     * @param expr the Expr to add to this UnionExpr

1022

     * @param expr the Expr to add to this UnionExpr

1510

**/

1023

**/

1511

    void addPathExpr(PathExpr* expr);

1024

    void addExpr(Expr* expr);

1512

1025

1513

/**

1026

/**

1514

     * Adds the PathExpr to this UnionExpr at the specified index

1027

     * Adds the PathExpr to this UnionExpr at the specified index

1515

     * @param expr the Expr to add to this UnionExpr

1028

     * @param expr the Expr to add to this UnionExpr

1516

**/

1029

**/

1517

    void addPathExpr(int index, PathExpr* expr);

1030

    void addExpr(int index, Expr* expr);

1518

1519

      //------------------------------------/

1520

     //- Virtual methods from PatternExpr -/

1521

    //------------------------------------/

1522

1031

1523

/**

1032

/**

1524

     * Evaluates this Expr based on the given context node and processor state

1033

     * Virtual methods from Expr

1525

     * @param context the context node for evaluation of this Expr

1526

     * @param ps the ContextState containing the stack information needed

1527

     * for evaluation

1528

     * @return the result of the evaluation

1529

**/

1034

**/

1530

    virtual ExprResult* evaluate(Node* context, ContextState* cs);

1035

    virtual ExprResult* evaluate(Node* context, ContextState* cs);

1531

1532

/**

1533

     * Returns the default priority of this Pattern based on the given Node,

1534

     * context Node, and ContextState.

1535

     * If this pattern does not match the given Node under the current context Node and

1536

     * ContextState then Negative Infinity is returned.

1537

**/

1538

    virtual double getDefaultPriority(Node* node, Node* context, ContextState* cs);

1539

1540

/**

1541

     * Determines whether this PatternExpr matches the given node within

1542

     * the given context

1543

**/

1544

    virtual MBool matches(Node* node, Node* context, ContextState* cs);

1036

    virtual MBool matches(Node* node, Node* context, ContextState* cs);

1545

1037

    virtual double getDefaultPriority(Node* node, Node* context, ContextState* cs);

1546

/**

1547

     * Returns the String representation of this PatternExpr.

1548

     * @param dest the String to use when creating the String

1549

     * representation. The String representation will be appended to

1550

     * any data in the destination String, to allow cascading calls to

1551

     * other #toString() methods for Expressions.

1552

     * @return the String representation of this PatternExpr.

1553

**/

1554

    virtual void toString(String& dest);

1038

    virtual void toString(String& dest);

1555

1039

1556

private:

1040

private:

(-)ExprLexer.cpp (-585 / +355 lines)

Line	Link Here

Lines 1-4	Link Here

/*

/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-

 * The contents of this file are subject to the Mozilla Public

 * The contents of this file are subject to the Mozilla Public

 * License Version 1.1 (the "License"); you may not use this file

 * License Version 1.1 (the "License"); you may not use this file

 * except in compliance with the License. You may obtain a copy of

 * except in compliance with the License. You may obtain a copy of

Lines 29-34	Link Here

 *   -- Fixed bug in parse method so that we make sure we check for

 *   -- Fixed bug in parse method so that we make sure we check for

 *      axis identifier wild cards, such as ancestor::*

 *      axis identifier wild cards, such as ancestor::*

 * Axel Hecht <axel@pike.org>

 *   -- big beating, general overhaul

 * $Id: ExprLexer.cpp,v 1.13 2001/05/12 11:59:44 peterv%netscape.com Exp $

 * $Id: ExprLexer.cpp,v 1.13 2001/05/12 11:59:44 peterv%netscape.com Exp $

*/

*/

Lines 48-63	Link Here

/**

/**

 * Default constructor for Token

 * Default constructor for Token

**/

**/

Token::Token() {

Token::Token()

    this->type =0;

  this->type =0;

} //-- Token;

} //-- Token;

/**

/**

 * Constructor for Token

 * Constructor for Token

 * @param type, the type of Token being represented

 * @param type, the type of Token being represented

**/

**/

Token::Token(short type) {

Token::Token(short type)

    this->type = type;

  this->type = type;

} //-- Token;

} //-- Token;

/**

/**

Lines 65-94	Link Here

 * @param value the value of this Token

 * @param value the value of this Token

 * @param type, the type of Token being represented

 * @param type, the type of Token being represented

**/

**/

Token::Token(const String& value, short type) {

Token::Token(const String& value, short type)

    this->type = type;

    //-- make copy of value String

  this->type = type;

    this->value = value;

  //-- make copy of value String

  this->value = value;

} //-- Token

} //-- Token

Token::Token(UNICODE_CHAR uniChar, short type) {

Token::Token(UNICODE_CHAR uniChar, short type)

    this->type = type;

    this->value.append(uniChar);

  this->type = type;

  this->value.append(uniChar);

} //-- Token

} //-- Token

/**

/**

 * Copy Constructor

 * Copy Constructor

**/

**/

Token::Token(const Token& token) {

Token::Token(const Token& token)

    this->type = token.type;

    this->value = token.value;

  this->type = token.type;

  this->value = token.value;

} //-- Token

} //-- Token

/**

/**

 * Destructor for Token

 * Destructor for Token

**/

**/

Token::~Token() {

Token::~Token()

    //-- currently nothing is needed

100

  //-- currently nothing is needed

} //-- ~Token

101

} //-- ~Token

102

103

Lines 113-140	Link Here

113

const String ExprLexer::MODULUS = "mod";

122

const String ExprLexer::MODULUS = "mod";

114

const String ExprLexer::DIVIDE  = "div";

123

const String ExprLexer::DIVIDE  = "div";

115

124

116

117

/**

125

/**

118

 * The set of a XSL Expression Tokens

126

 * The set of Lexer error messages

119

**/

127

**/

120

const Token ExprLexer::TOKENS[] = {

128

const String ExprLexer::error_message[] =

121

129

122

    //-- Nodetype tokens

130

  "VariableReference expected",

123

    Token(ExprLexer::COMMENT,       Token::COMMENT),

131

  "Operator expected",

124

    Token(ExprLexer::NODE,          Token::NODE),

132

  "Literal is not closed",

125

    Token(ExprLexer::PROC_INST,     Token::PROC_INST),

133

  ": not expected",

126

    Token(ExprLexer::TEXT,          Token::TEXT),

134

  "! not expected, use != or not()",

127

    //-- boolean operators

135

  "found a unkown character"

128

    Token(ExprLexer::AND,           Token::AND_OP),

129

    Token(ExprLexer::OR,            Token::OR_OP),

130

131

    //-- multiplicative operators

132

    Token(ExprLexer::MODULUS,       Token::MODULUS_OP),

133

    Token(ExprLexer::DIVIDE,        Token::DIVIDE_OP)

134

};

136

};

135

137

136

const short ExprLexer::NUMBER_OF_TOKENS  = 8;

137

138

  //---------------/

138

  //---------------/

139

 //- Contructors -/

139

 //- Contructors -/

140

//---------------/

140

//---------------/

Lines 142-725	Link Here

142

/**

142

/**

143

 * Creates a new ExprLexer using the given String

143

 * Creates a new ExprLexer using the given String

144

**/

144

**/

145

ExprLexer::ExprLexer(const String& pattern) {

145

ExprLexer::ExprLexer(const String& pattern)

146

147

    firstItem    = 0;

147

  firstItem    = 0;

148

    lastItem     = 0;

148

  lastItem     = 0;

149

    tokenCount   = 0;

149

  tokenCount   = 0;

150

    prevToken    = 0;

150

  prevToken    = 0;

151

    parse(pattern);

151

  endToken.type = Token::END;

152

    currentItem = firstItem;

152

  parse(pattern);

153

  currentItem = firstItem;

153

} //-- ExprLexer

154

} //-- ExprLexer

154

155

/**

156

/**

156

 * Destroys this instance of an ExprLexer

157

 * Destroys this instance of an ExprLexer

157

**/

158

**/

158

ExprLexer::~ExprLexer() {

159

ExprLexer::~ExprLexer()

159

   //-- delete tokens

160

161

  //-- delete tokens

161

   //cout << "~ExprLexer() - start"<<endl;

162

  currentItem = firstItem;

162

   currentItem = firstItem;

163

  while ( currentItem ) {

163

   while ( currentItem ) {

164

    TokenListItem* temp = currentItem->next;

164

       TokenListItem* temp = currentItem->next;

165

    delete currentItem->token;

165

       //cout << "deleting token: " << currentItem->token->value << endl;

166

    delete currentItem;

166

       delete currentItem->token;

167

    currentItem = temp;

167

       delete currentItem;

168

       currentItem = temp;

169

170

   //cout << "~ExprLexer() - done"<<endl;

171

} //-- ~ExprLexer

169

} //-- ~ExprLexer

172

170

173

174

int ExprLexer::countAllTokens() {

175

    return tokenCount;

176

} //-- countAllTokens

177

178

int ExprLexer::countRemainingTokens() {

179

    TokenListItem* temp = currentItem;

180

    int c = 0;

181

    while ( temp ) {

182

        ++c;

183

        temp = temp->next;

184

185

    return c;

186

} //-- countRemainingTokens

187

188

171

189

MBool ExprLexer::hasMoreTokens() {

172

MBool ExprLexer::hasMoreTokens()

190

    return (MBool) ( currentItem );

173

174

  return (MBool) ( currentItem );

191

} //-- hasMoreTokens

175

} //-- hasMoreTokens

192

176

193

Token* ExprLexer::nextToken() {

177

Token* ExprLexer::nextToken()

194

    if ( currentItem ) {

178

195

        Token* token = currentItem->token;

179

  if ( currentItem ) {

196

        currentItem = currentItem->next;

180

    Token* token = currentItem->token;

197

        return token;

181

    currentItem = currentItem->next;

198

182

    return token;

199

    return 0;

183

184

  return &endToken;

200

} //-- nextToken

185

} //-- nextToken

201

186

202

void ExprLexer::pushBack() {

187

void ExprLexer::pushBack()

203

    if ( !currentItem ) {

188

204

        currentItem = lastItem;

189

  if ( !currentItem ) {

205

190

    currentItem = lastItem;

206

    else currentItem = currentItem->previous;

191

192

  else currentItem = currentItem->previous;

207

} //-- pushBack

193

} //-- pushBack

208

209

/*

210

Token* ExprLexer::lastToken() {

211

    if (lastItem) {

212

        return lastItem->token;

213

214

    return 0;

215

} //-- lastToken

216

*/

217

194

218

Token* ExprLexer::peek() {

195

Token* ExprLexer::peek()

219

    Token* token = 0;

196

220

    TokenListItem* tlItem = currentItem;

197

  if ( currentItem )

221

    if (tlItem) token = tlItem->token;

198

    return currentItem->token;

222

    return token;

199

  return &endToken;

223

} //-- peek

200

} //-- peek

224

201

225

Token* ExprLexer::lookAhead(int offset) {

202

void ExprLexer::addToken(Token* token)

226

    Token* token = 0;

203

227

    TokenListItem* tlItem = currentItem;

204

  TokenListItem* tlItem = new TokenListItem;

228

    //-- advance to proper offset

205

  tlItem->token = token;

229

    for ( int i = 0; i < offset; i++ )

206

  tlItem->next  = 0;

230

        if ( tlItem ) tlItem = currentItem->next;

207

  if (lastItem) {

231

208

    tlItem->previous = lastItem;

232

    if (tlItem) token = tlItem->token;

209

    lastItem->next = tlItem;

233

    return token;

210

234

} //-- lookAhead

211

  if (!firstItem) firstItem = tlItem;

235

212

  lastItem = tlItem;

236

void ExprLexer::addToken(Token* token) {

213

  prevToken = token;

237

    TokenListItem* tlItem = new TokenListItem;

214

  ++tokenCount;

238

    tlItem->token = token;

239

    tlItem->next  = 0;

240

    if (lastItem) {

241

        tlItem->previous = lastItem;

242

        lastItem->next = tlItem;

243

244

    if (!firstItem) firstItem = tlItem;

245

    lastItem = tlItem;

246

    prevToken = token;

247

    ++tokenCount;

248

} //-- addToken

215

} //-- addToken

249

216

250

/**

251

 * Returns true if the given character represents an Alpha letter

252

**/

253

MBool ExprLexer::isAlphaChar(Int32 ch) {

254

    if ((ch >= 'a' ) && (ch <= 'z' )) return MB_TRUE;

255

    if ((ch >= 'A' ) && (ch <= 'Z' )) return MB_TRUE;

256

    return MB_FALSE;

257

} //-- isAlphaChar

258

259

/**

217

/**

260

 * Returns true if the given character represents a numeric letter (digit)

218

 * Returns true if the following Token should be an operator.

261

**/

219

 * This is a helper for the first bullet of [XPath 3.7]

262

MBool ExprLexer::isDigit(Int32 ch) {

220

 *  Lexical Structure

263

    if ((ch >= '0') && (ch <= '9'))   return MB_TRUE;

221

**/

222

MBool ExprLexer::nextIsOperatorToken(Token* token)

223

224

  if ( !token || token->type == Token::NULL_TOKEN) return MB_FALSE;

225

  /* This relies on the tokens having the right order in ExprLexer.h */

226

  if (token->type >= Token::COMMA &&

227

      token->type <= Token::UNION_OP)

264

    return MB_FALSE;

228

    return MB_FALSE;

265

} //-- isDigit

229

  return MB_TRUE;

266

230

} //-- nextIsOperatorToken

267

/**

268

 * Returns true if the given character is an allowable NCName character

269

**/

270

MBool ExprLexer::isNCNameChar(Int32 ch) {

271

    if (isDigit(ch) || isAlphaChar(ch)) return MB_TRUE;

272

    return (MBool) ((ch == '.') || (ch == '_') || (ch == '-'));

273

} //-- isNCNameChar

274

231

275

/**

232

/**

276

 * Returns true if the given character is an allowable QName character

233

 *  Parses the given String into the set of Tokens

277

**/

278

MBool ExprLexer::isQNameChar(Int32 ch) {

279

    return (MBool) (( ch == ':') || isNCNameChar(ch));

280

} //-- isQNameChar

281

282

/**

283

 * Returns true if the given String is a valid XML QName

284

**/

234

**/

285

MBool ExprLexer::isValidQName(String& name) {

235

void ExprLexer::parse(const String& pattern)

286

236

287

    int size = name.length();

237

  String tokenBuffer;

288

    if ( size == 0 ) return MB_FALSE;

238

  Int32 iter = 0, start;

289

    else if ( !isAlphaChar(name.charAt(0))) return MB_FALSE;

239

  Int32 size = pattern.length();

290

    else {

240

  short defType;

291

        for ( int i = 1; i < size; i++) {

241

  UNICODE_CHAR ch;

292

            if ( ! isQNameChar(name.charAt(i))) return MB_FALSE;

242

  if ( size==0 ) return;

243

244

  //-- initialize previous token, this will automatically get

245

  //-- deleted when it goes out of scope

246

  Token nullToken('\0', Token::NULL_TOKEN);

247

248

  prevToken = &nullToken;

249

250

  while (iter < size) {

251

252

    ch = pattern.charAt(iter);

253

    defType = Token::CNAME;

254

255

    if (ch==DOLLAR_SIGN) {

256

      if (++iter == size || !isLetter(ch=pattern.charAt(iter))) {

257

        // Error, VariableReference expected

258

        errorPos = iter;

259

        errorCode = ERROR_UNRESOLVED_VAR_REFERENCE;

260

        if (firstItem)

261

          firstItem->token->type=Token::ERROR;

262

        else

263

          addToken(new Token('\0',Token::ERROR));

264

        iter=size; // bail

265

      } else

266

        defType = Token::VAR_REFERENCE;

267

268

    // just reuse the QName parsing, which will use defType

269

    // the token to construct

270

271

    if ( isLetter(ch) ) {

272

      // NCName, can get QName or OperatorName;

273

      //  FunctionName, NodeName, and AxisSpecifier may want whitespace,

274

      //  and are dealt with below

275

      start = iter;

276

      while (++iter < size &&

277

             isNCNameChar(pattern.charAt(iter))) /* just go */ ;

278

      Int32 end = iter;

279

      if (pattern.charAt(iter)==COLON) {

280

        // try QName or wildcard, might need to step back for axis

281

        if (++iter < size)

282

          if (isLetter(pattern.charAt(iter)))

283

            while(++iter < size &&

284

                  isNCNameChar(pattern.charAt(iter))) /* just go */ ;

285

          else if (pattern.charAt(iter)=='*'

286

                   && defType != Token::VAR_REFERENCE)

287

            ++iter; /* eat wildcard for NameTest, bail for var ref at COLON */

288

          else

289

            iter--; // step back

290

291

      if (nextIsOperatorToken(prevToken)) {

292

        if (pattern.subString(start,end,subStr).isEqual(AND))

293

          defType = Token::AND_OP;

294

        else if (pattern.subString(start,end,subStr).isEqual(OR))

295

          defType = Token::OR_OP;

296

        else if (pattern.subString(start,end,subStr).isEqual(MODULUS))

297

          defType = Token::MODULUS_OP;

298

        else if (pattern.subString(start,end,subStr).isEqual(DIVIDE))

299

          defType = Token::DIVIDE_OP;

300

        else {

301

          // Error "operator expected"

302

          // XXX QUESTION: spec is not too precise

303

          // badops is sure an error, but is bad:ops, too? We say yes!

304

          errorPos = iter;

305

          errorCode = ERROR_OP_EXPECTED;

306

          if (firstItem)

307

            firstItem->token->type=Token::ERROR;

308

          else

309

            addToken(new Token('\0',Token::ERROR));

310

          iter=size; // bail

293

311

294

312

295

    return MB_TRUE;

313

      addToken(new Token(pattern.subString(start,iter,subStr),defType));

296

} //-- isValidQName

314

    } else if ( isDigit(ch) ) {

297

315

      start = iter;

298

MBool ExprLexer::isOperatorToken(Token* token) {

316

      while (++iter < size &&

299

    if ( !token ) return MB_FALSE;

317

             isDigit(pattern.charAt(iter))) /* just go */;

300

    switch ( token->type ) {

318

      if (pattern.charAt(iter)=='.')

301

        //-- boolean operators

319

        while (++iter < size &&

302

        case Token::AND_OP:

320

               isDigit(pattern.charAt(iter))) /* just go */;

303

        case Token::OR_OP:

321

      addToken(new Token(pattern.subString(start,iter,subStr),Token::NUMBER));

304

        //-- relational operators

322

    } else {

305

        case Token::EQUAL_OP:

323

      switch (ch) {

306

        case Token::NOT_EQUAL_OP:

324

        //-- ignore whitespace

307

        case Token::LESS_THAN_OP:

325

      case SPACE:

308

        case Token::GREATER_THAN_OP:

326

      case TX_TAB:

309

        case Token::LESS_OR_EQUAL_OP:

327

      case TX_CR:

310

        case Token::GREATER_OR_EQUAL_OP:

328

      case TX_LF:

311

        //-- additive operators

329

        ++iter;

312

        case Token::ADDITION_OP:

330

        break;

313

        case Token::SUBTRACTION_OP:

331

      case S_QUOTE :

314

        //-- multiplicative operators

332

      case D_QUOTE :

315

        case Token::DIVIDE_OP:

333

        start=iter;

316

        case Token::MODULUS_OP:

334

        iter = pattern.indexOf(ch,start+1);

317

        case Token::MULTIPLY_OP:

335

        if (iter==NOT_FOUND) {

318

            return MB_TRUE;

336

          // XXX Error reporting "unclosed literal"

319

        default:

337

          errorPos = start;

320

            break;

338

          errorCode = ERROR_UNCLOSED_LITERAL;

321

339

          if (firstItem)

322

340

            firstItem->token->type=Token::ERROR;

323

    return MB_FALSE;

341

          else

324

} //-- isOperatorToken

342

            addToken(new Token('\0',Token::ERROR));

325

343

          iter=size; // bail

326

MBool ExprLexer::matchDelimiter(UNICODE_CHAR ch) {

344

        } else {

327

345

          addToken(new Token(pattern.subString(start+1,iter,subStr),

328

    short tokenType = 0;

346

                             Token::LITERAL));

329

    MBool addChar = MB_TRUE;

347

          ++iter;

330

    switch (ch) {

331

        case FORWARD_SLASH :

332

            tokenType = Token::PARENT_OP;

333

            break;

334

        case L_PAREN :

335

            tokenType = Token::L_PAREN;

336

            break;

337

        case R_PAREN :

338

            tokenType = Token::R_PAREN;

339

            break;

340

        case L_BRACKET :

341

            tokenType = Token::L_BRACKET;

342

            break;

343

        case R_BRACKET :

344

            tokenType = Token::R_BRACKET;

345

            break;

346

        case L_ANGLE :

347

            tokenType = Token::LESS_THAN_OP;

348

            break;

349

        case R_ANGLE :

350

            tokenType = Token::GREATER_THAN_OP;

351

            break;

352

        case COMMA :

353

            tokenType = Token::COMMA;

354

            break;

355

        case PERIOD :

356

            tokenType = Token::SELF_NODE;

357

            break;

358

        case EQUAL :

359

            tokenType = Token::EQUAL_OP;

360

            break;

361

        case PLUS :

362

            tokenType = Token::ADDITION_OP;

363

            break;

364

        case HYPHEN :

365

            tokenType = Token::SUBTRACTION_OP;

366

            break;

367

        case VERT_BAR:

368

            tokenType = Token::UNION_OP;

369

            break;

370

        case AT_SIGN:

371

            tokenType = Token::AT_SIGN;

372

            break;

373

        case DOLLAR_SIGN:

374

            tokenType = Token::VAR_REFERENCE;

375

            addChar = MB_FALSE;

376

            break;

377

        default:

378

            return MB_FALSE;

379

380

    Token* token = 0;

381

    if ( addChar ) token = new Token(ch, tokenType);

382

    else token = new Token(tokenType);

383

384

    addToken(token);

385

    return MB_TRUE;

386

} //-- matchDelimiter

387

388

/**

389

 * Returns true if the value of the given String matches

390

 * an OperatorName

391

**/

392

MBool ExprLexer::matchesOperator(String& buffer) {

393

394

    int index = 0;

395

    while (index < NUMBER_OF_TOKENS) {

396

        Token tok = TOKENS[index++];

397

        if ( tok.value.isEqual(buffer) ) {

398

            if (isOperatorToken( &tok )) return MB_TRUE;

399

348

400

349

        break;

401

    return MB_FALSE;

350

      case PERIOD:

402

351

        // period can be .., .(DIGITS)+ or ., check next

403

} //-- matchesOperator

352

        if (++iter < size) {

404

353

          ch=pattern.charAt(iter);

405

/**

354

          if (isDigit(ch)) {

406

 * Matches the given String to the appropriate Token

355

            start=iter-1;

407

 * @param buffer the current StringBuffer representing the value of the Token

356

            while (++iter < size &&

408

 * @param ch, the current delimiter token

357

                   isDigit(pattern.charAt(iter))) /* just go */;

409

**/

358

            addToken(new Token(pattern.subString(start,iter,subStr),

410

void ExprLexer::matchToken(String& buffer, UNICODE_CHAR ch) {

359

                               Token::NUMBER));

411

360

          } else if (ch==PERIOD) {

412

    if ( buffer.length() == 0) return;

361

            addToken(new Token(pattern.subString(iter-1,iter++,subStr),

413

362

                               Token::PARENT_NODE));

414

    Token* match = new Token();

363

          } else

415

    MBool foundMatch = MB_FALSE;

364

            addToken(new Token(PERIOD, Token::SELF_NODE));

416

    int index = 0;

365

        } else

417

366

          addToken(new Token(ch, Token::SELF_NODE));

418

    //-- check previous token

367

        // iter++ is already in the number test

419

    switch(prevToken->type) {

368

420

        case Token::VAR_REFERENCE :

369

        break;

421

            if ( prevToken->value.length() == 0) {

370

      case COLON: // QNames are dealt above, must be axis ident

422

                prevToken->value.append(buffer);

371

        if (++iter < size && pattern.charAt(iter)==COLON &&

423

                buffer.clear();

372

            prevToken->type == Token::CNAME) {

424

                return;

373

          prevToken->type = Token::AXIS_IDENTIFIER;

425

374

          ++iter;

426

            break;

375

        } else {

427

        default:

376

          // XXX Error report "colon is neither QName nor axis"

428

            break;

377

          errorPos = iter;

429

378

          errorCode = ERROR_COLON;

430

379

          if (firstItem)

431

    //-- look for next match

380

            firstItem->token->type=Token::ERROR;

432

    while ( !foundMatch && (index < NUMBER_OF_TOKENS) ) {

381

          else

433

382

            addToken(new Token('\0',Token::ERROR));

434

        Token tok = TOKENS[index++];

383

          iter=size; // bail

435

436

        if ( tok.value.isEqual(buffer) ) {

437

438

            foundMatch = MB_TRUE;

439

440

            switch (tok.type) {

441

442

                //-- NodeType tokens

443

                case Token::COMMENT:

444

                case Token::NODE :

445

                case Token::PROC_INST :

446

                case Token::TEXT :

447

                    // make sure next delimiter is '('

448

                    if ( ch != L_PAREN) {

449

                        foundMatch = MB_FALSE;

450

                        break;

451

452

                    //-- copy buffer

453

                    match->value = buffer;

454

                    //-- copy type

455

                    match->type = tok.type;

456

                    break;

457

               case Token::MULTIPLY_OP :

458

               case Token::DIVIDE_OP:

459

               case Token::MODULUS_OP:

460

                    switch ( prevToken->type ) {

461

                        case Token::AT_SIGN :

462

                        case Token::NULL_TOKEN:

463

                        case Token::L_PAREN:

464

                        case Token::L_BRACKET:

465

                            foundMatch = MB_FALSE;

466

                            break; //-- do not match

467

                        default:

468

                            if ( isOperatorToken(prevToken) ) {

469

                                foundMatch = MB_FALSE;

470

                                break; //-- do not match

471

472

                            match->value = buffer;

473

                            match->type = tok.type;

474

475

                    break;

476

               default :

477

                    //-- copy buffer

478

                    match->value = buffer;

479

                    match->type = tok.type;

480

                    break;

481

482

        } //-- if equal

483

    } //-- while

484

485

    if (!foundMatch) {

486

        //-- copy buffer

487

        match->value = buffer;

488

        //-- look for function name

489

        if ( ch == L_PAREN) match->type = Token::FUNCTION_NAME;

490

        else match->type = Token::CNAME;

491

492

    addToken(match);

493

    buffer.clear();

494

} //-- matchToken

495

496

/**

497

 *  Parses the given String into the set of Tokens

498

**/

499

void ExprLexer::parse(const String& pattern) {

500

501

502

    String tokenBuffer;

503

    UNICODE_CHAR inLiteral = '\0';

504

    MBool inNumber  = MB_FALSE;

505

506

    Int32 currentPos = 0;

507

508

    UNICODE_CHAR ch = '\0';

509

    UNICODE_CHAR prevCh = ch;

510

511

    //-- initialize previous token, this will automatically get

512

    //-- deleted when it goes out of scope

513

    Token nullToken('\0', Token::NULL_TOKEN);

514

515

    prevToken = &nullToken;

516

517

    while (currentPos < pattern.length()) {

518

519

        prevCh = ch;

520

        ch = pattern.charAt(currentPos);

521

522

        if ( inLiteral ) {

523

            //-- look for end of literal

524

            if ( ch == inLiteral ) {

525

                inLiteral = '\0';

526

                addToken(new Token(tokenBuffer, Token::LITERAL));

527

                tokenBuffer.clear();

528

529

            else {

530

                tokenBuffer.append(ch);

531

532

384

533

        else if ( inNumber ) {

385

        break;

534

            if (isDigit(ch) || (ch == '.')) {

386

      case FORWARD_SLASH :

535

                tokenBuffer.append(ch);

387

        if (++iter < size && pattern.charAt(iter)==ch) {

536

388

          addToken(new Token(pattern.subString(iter-1,++iter,subStr),

537

            else {

389

                             Token::ANCESTOR_OP));

538

                inNumber = MB_FALSE;

390

        } else {

539

                addToken(new Token(tokenBuffer, Token::NUMBER));

391

          addToken(new Token(ch, Token::PARENT_OP));

540

                tokenBuffer.clear();

541

                //-- push back last char

542

                --currentPos;

543

544

392

545

        else if (isDigit(ch)) {

393

        break;

546

            if  ((tokenBuffer.length() == 0 ) || matchesOperator(tokenBuffer) ) {

394

      case BANG : // can only be !=

547

                //-- match operator and free up token buffer

395

        if (++iter < size && pattern.charAt(iter)==EQUAL) {

548

                matchToken(tokenBuffer, ch);

396

          addToken(new Token(pattern.subString(iter-1,++iter,subStr),

549

                inNumber = MB_TRUE;

397

                             Token::NOT_EQUAL_OP));

550

398

        } else {

551

            else if (( tokenBuffer.length() == 1 ) && (prevCh = '-')) {

399

          // Error ! is not not()

552

                inNumber = MB_TRUE;

400

          errorPos = iter;

553

401

          errorCode = ERROR_BANG;

554

            tokenBuffer.append(ch);

402

          if (firstItem)

403

            firstItem->token->type=Token::ERROR;

404

          else

405

            addToken(new Token('\0',Token::ERROR));

406

          iter=size; // bail

555

407

556

        else {

408

        break;

557

            switch (ch) {

409

      case EQUAL:

558

                //-- ignore whitespace

410

        addToken(new Token(ch,Token::EQUAL_OP));

559

                case SPACE:

411

        ++iter;

560

                case TX_TAB:

412

        break;

561

                case TX_CR:

413

      case L_ANGLE:

562

                case TX_LF:

414

        if (++iter < size && pattern.charAt(iter)==EQUAL) {

563

                    break;

415

          addToken(new Token(pattern.subString(iter-1,++iter,subStr),

564

                case S_QUOTE :

416

                             Token::LESS_OR_EQUAL_OP));

565

                case D_QUOTE :

417

        } else

566

                    matchToken(tokenBuffer, ch);

418

          addToken(new Token(ch,Token::LESS_THAN_OP));

567

                    inLiteral = ch;

419

        break;

568

                    break;

420

      case R_ANGLE:

569

                case PERIOD:

421

        if (++iter < size && pattern.charAt(iter)==EQUAL) {

570

                    if ( inNumber ) tokenBuffer.append(ch);

422

          addToken(new Token(pattern.subString(iter-1,++iter,subStr),

571

                    else if ( prevToken->type == Token::SELF_NODE ) {

423

                             Token::GREATER_OR_EQUAL_OP));

572

                        prevToken->type = Token::PARENT_NODE;

424

        } else

573

425

          addToken(new Token(ch,Token::GREATER_THAN_OP));

574

                    else if ( tokenBuffer.length() > 0 )

426

        break;

575

                        tokenBuffer.append(ch);

427

      case HYPHEN :

576

                    else matchDelimiter(ch);

428

        addToken(new Token(ch,Token::SUBTRACTION_OP));

577

                    break;

429

        ++iter;

578

                case COLON:

430

        break;

579

                    if ( prevCh == ch) {

431

      case ASTERIX:

580

                        Int32 bufSize = tokenBuffer.length();

432

        if (nextIsOperatorToken(prevToken))

581

                        tokenBuffer.setLength(bufSize-1);

433

          addToken(new Token(ch,Token::MULTIPLY_OP));

582

                        addToken(new Token(tokenBuffer, Token::AXIS_IDENTIFIER));

434

        else

583

                        tokenBuffer.clear();

435

          addToken(new Token(ch,Token::CNAME));

584

436

        ++iter;

585

                    else tokenBuffer.append(ch);

437

        break;

586

                    break;

438

      case L_PAREN:

587

                case FORWARD_SLASH :

439

        if (prevToken->type == Token::CNAME) {

588

                    matchToken(tokenBuffer, ch);

440

          if (prevToken->value.isEqual(COMMENT))

589

                    if ( prevToken->type == Token::PARENT_OP ) {

441

            prevToken->type = Token::COMMENT;

590

                        prevToken->type = Token::ANCESTOR_OP;

442

          else if (prevToken->value.isEqual(NODE))

591

                        prevToken->value.append(ch);

443

            prevToken->type = Token::NODE;

592

444

          else if (prevToken->value.isEqual(PROC_INST))

593

                    //-- handle possible error in using /

445

            prevToken->type = Token::PROC_INST;

594

                    else if ( prevToken->type == Token::NUMBER ) {

446

          else if (prevToken->value.isEqual(TEXT))

595

                        prevToken->type = Token::ERROR;

447

            prevToken->type = Token::TEXT;

596

                        prevToken->value = "Error in expression, misuse of '/', try 'div' instead.";

448

          else

597

449

            prevToken->type = Token::FUNCTION_NAME;

598

                    else matchDelimiter(ch);

599

                    break;

600

                case BANG : //-- used as previous...see EQUAL

601

                    matchToken(tokenBuffer,ch);

602

                    addToken(new Token(ch, Token::ERROR));

603

                    break;

604

                case EQUAL:

605

                    switch ( prevCh ) {

606

                        case BANG:

607

                            prevToken->type = Token::NOT_EQUAL_OP;

608

                            prevToken->value.append("=");

609

                            break;

610

                        case L_ANGLE:

611

                            prevToken->type = Token::LESS_OR_EQUAL_OP;

612

                            prevToken->value.append("=");

613

                            break;

614

                        case R_ANGLE:

615

                            prevToken->type = Token::GREATER_OR_EQUAL_OP;

616

                            prevToken->value.append("=");

617

                            break;

618

                        default:

619

                            matchToken(tokenBuffer, ch);

620

                            matchDelimiter(ch);

621

                            break;

622

623

                    break;

624

                case L_ANGLE :

625

                case R_ANGLE :

626

                    matchToken(tokenBuffer, ch);

627

                    matchDelimiter(ch);

628

                    break;

629

                case HYPHEN :

630

                    if ( isValidQName(tokenBuffer) &&

631

                         !( prevCh==SPACE || prevCh==TX_TAB||

632

                            prevCh==TX_CR || prevCh==TX_LF ) )

633

                        tokenBuffer.append(ch);

634

                    else {

635

                        switch ( prevToken->type ) {

636

                            case Token::NULL_TOKEN:

637

                            case Token::L_PAREN:

638

                            case Token::L_BRACKET:

639

                            case Token::COMMA:

640

                                inNumber = MB_TRUE;

641

                                tokenBuffer.append(ch);

642

                                break;

643

                            default:

644

                                matchToken(tokenBuffer, ch);

645

                                matchDelimiter(ch);

646

                                break;

647

648

649

                    break;

650

                case ASTERIX:

651

                    matchToken(tokenBuffer, ch);

652

                    switch ( prevToken->type ) {

653

                        //-- temporary fix for Namespace wild-cards - KV

654

                        case Token::CNAME :

655

                            prevToken->value.append(ch);

656

                            break;

657

                        //-- end temporary fix for Namespace wild-cards

658

659

                        //-- Fix: make sure check for axis identifier wild cards, such as

660

                        //-- ancestor::* - Marina M.

661

                        case Token::AXIS_IDENTIFIER :

662

                        //-- End Fix

663

                        case Token::PARENT_OP :

664

                        case Token::ANCESTOR_OP:

665

                        case Token::AT_SIGN :

666

                        case Token::NULL_TOKEN:

667

                        case Token::L_PAREN:

668

                        case Token::L_BRACKET:

669

                            tokenBuffer.append(ch);

670

                            //matchDelimiter(ch);

671

                            break;

672

                        default:

673

                            if ( isOperatorToken(prevToken) ) {

674

                                matchDelimiter(ch);

675

                                break; //-- do not match

676

677

                            addToken( new Token(ch, Token::MULTIPLY_OP) );

678

679

                    break;

680

                case L_PAREN:

681

                case R_PAREN:

682

                case L_BRACKET:

683

                case R_BRACKET:

684

                case COMMA:

685

                case AT_SIGN :

686

                case PLUS:

687

                case DOLLAR_SIGN :

688

                    matchToken(tokenBuffer, ch);

689

                    matchDelimiter(ch);

690

                    break;

691

                case VERT_BAR:

692

                    matchToken(tokenBuffer, ch);

693

                    matchDelimiter(ch);

694

                    //-- Reset previous token to Null, since this is the "Union Operator"

695

                    //-- and the next set of tokens should start as a fresh expression

696

                    prevToken = &nullToken;

697

                    break;

698

                default:

699

                    switch (prevCh) {

700

                        case SPACE :

701

                        case TX_TAB :

702

                        case TX_CR :

703

                        case TX_LF :

704

                            matchToken(tokenBuffer, ch);

705

                            tokenBuffer.append(ch);

706

                            break;

707

                        default:

708

                            tokenBuffer.append(ch);

709

                            break;

710

711

                    break;

712

713

450

714

        ++currentPos;

451

        ++iter;

715

452

        addToken(new Token(ch,Token::L_PAREN));

716

    //-- end lexical parsing of current token

453

        break;

717

    //-- freeBuffer if needed

454

      case R_PAREN:

718

455

        ++iter;

719

    if ( inNumber ) {

456

        addToken(new Token(ch,Token::R_PAREN));

720

        addToken(new Token(tokenBuffer, Token::NUMBER));

457

        break;

458

      case L_BRACKET:

459

        ++iter;

460

        addToken(new Token(ch,Token::L_BRACKET));

461

        break;

462

      case R_BRACKET:

463

        ++iter;

464

        addToken(new Token(ch,Token::R_BRACKET));

465

        break;

466

      case COMMA:

467

        ++iter;

468

        addToken(new Token(ch,Token::COMMA));

469

        break;

470

      case AT_SIGN :

471

        ++iter;

472

        addToken(new Token(ch,Token::AT_SIGN));

473

        break;

474

      case PLUS:

475

        ++iter;

476

        addToken(new Token(ch,Token::ADDITION_OP));

477

        break;

478

      case VERT_BAR:

479

        ++iter;

480

        addToken(new Token(ch,Token::UNION_OP));

481

        break;

482

      default:

483

        // Error, don't grok character :-(

484

        errorPos = iter;

485

        errorCode = ERROR_UNKNOWN_CHAR;

486

        if (firstItem)

487

          firstItem->token->type=Token::ERROR;

488

        else

489

          addToken(new Token('\0',Token::ERROR));

490

        iter=size; // bail

491

721

492

722

    else matchToken(tokenBuffer, ch);

493

723

    prevToken = 0;

724

} //-- parse

494

} //-- parse

725

495





/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
 * The contents of this file are subject to the Mozilla Public
 * License Version 1.1 (the "License"); you may not use this file
 * except in compliance with the License. You may obtain a copy of

 * Larry Fitzpatrick
 *    -- changed constant short declarations in Token and ExprLexer to
 *       enumerations, commented with //--LF
 *
 * $Id: ExprLexer.h,v 1.7 2001/05/12 11:59:51 peterv%netscape.com Exp $
 */



 * This class was ported from XSL:P, an open source Java based 
 * XSLT processor, written by yours truly.
 * @author <a href="mailto:kvisco@ziplink.net">Keith Visco</a>
 * @version $Revision: 1.7 $ $Date: 2001/05/12 11:59:51 $
**/
class Token {


        LITERAL,
        NUMBER,
        CNAME,
        L_PAREN,
        R_PAREN,
        L_BRACKET,
        R_BRACKET,
        COMMA,
        FUNCTION_NAME,
        AT_SIGN,
        VAR_REFERENCE,
        PARENT_NODE,
        SELF_NODE,
        R_PAREN,
        R_BRACKET, // 10
        /**
         * start of tokens for 3.7, bullet 1
         * ExprLexer::nextIsOperatorToken bails if the tokens aren't
         * consecutive.
         **/
        COMMA,
        AT_SIGN,
        L_PAREN,
        L_BRACKET,
        AXIS_IDENTIFIER,
          //-------------/
         //- operators -/
        //-------------/

        //-- boolean ops
        AND_OP, // 16
        OR_OP,

        //-- relational
        EQUAL_OP, // 18
        NOT_EQUAL_OP,
        LESS_THAN_OP,
        GREATER_THAN_OP,
        LESS_OR_EQUAL_OP,
        GREATER_OR_EQUAL_OP,
        //-- additive operators
        ADDITION_OP, // 24
        SUBTRACTION_OP,
        //-- multiplicative
        DIVIDE_OP , // 26
        MULTIPLY_OP,
        MODULUS_OP,
        //-- path operators
        PARENT_OP, // 29
        ANCESTOR_OP,
        UNION_OP,
        /**
         * end of tokens for 3.7, bullet 1 -/
         **/
        //-- node type tokens
        COMMENT, // 32
        NODE,
        PROC_INST,
        TEXT,
        
        //-- Special endtoken
        END // 36
    };



        TX_LF             = '\r'
    };

    enum _error_consts {
        ERROR_UNRESOLVED_VAR_REFERENCE = 0,
        ERROR_OP_EXPECTED,
        ERROR_UNCLOSED_LITERAL,
        ERROR_COLON,
        ERROR_BANG,
        ERROR_UNKNOWN_CHAR
    };
    static const String error_message[];
    Int32 errorPos;
    short errorCode;

    /*
     * Complex Tokens


    ~ExprLexer();

    /**
     * Counts the total number of tokens in this Lexer, even if the token
     * has already been seen
     * @return the total number of tokens in this Lexer
    **/
    int countAllTokens();

    /**
     * Counts the remaining number of tokens in this Lexer
     * @return the number of remaining tokens in this Lexer
    **/
    int countRemainingTokens();

    /**
     * Functions for iterating over the TokenList
    **/

    Token* lookAhead(int offset);
    Token* nextToken();
    Token* peek();
    void   pushBack();
    MBool  hasMoreTokens();

    MBool isOperatorToken(Token* token);

private:

    struct TokenListItem {

    int tokenCount;

    Token* prevToken;
    Token endToken;

    void addToken(Token* token);

    /**
     * Returns true if the following Token should be an operator.
     * This is a helper for the first bullet of [XPath 3.7]
     *  Lexical Structure
     **/
    MBool nextIsOperatorToken(Token* token);

    /**
     * Returns true if the given character represents an Alpha letter
     * Implemented in ExprLexerChars.cpp
    **/
    static MBool isLetter(UNICODE_CHAR ch);

    /**
     * Returns true if the given character represents a numeric letter (digit)
     * Implemented in ExprLexerChars.cpp
    **/
    static MBool isDigit(UNICODE_CHAR ch);

    /**
     * Returns true if the given character is an allowable NCName character
     * Implemented in ExprLexerChars.cpp
    static MBool isNCNameChar(Int32 ch);

    /**
     * Returns true if the given String is a valid XML QName
    **/
    static MBool isValidQName(String& name);

    MBool matchDelimiter(UNICODE_CHAR ch);

    /**
     * Returns true if the value of the given String matches
     * an OperatorName
    **/
    static MBool isNCNameChar(UNICODE_CHAR ch);

    /**
     * Matches the given String to the appropriate Token
     * @param buffer the current StringBuffer representing the value of the Token
     * @param ch, the current delimiter token
    **/
    void matchToken(String& buffer, UNICODE_CHAR ch);


    String subStr;
    void parse(const String& pattern);

}; //-- ExprLexer





/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- 
 * The contents of this file are subject to the Mozilla Public
 * License Version 1.1 (the "License"); you may not use this file
 * except in compliance with the License. You may obtain a copy of
 * the License at http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS
 * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
 * implied. See the License for the specific language governing
 * rights and limitations under the License.
 *
 * The Original Code is mozilla.org code.
 *
 * The Initial Developer of the Original Code is Axel Hecht.  Portions
 * created by Axel Hecht are Copyright (C) 2001 Axel Hecht. All
 * Rights Reserved.
 *
 * Contributor(s): 
 *   Axel Hecht <axel@pike.org> (Original Author)
 */

#include "ExprLexer.h"

// macros for inclusion of char range headers
#define TX_CHAR_RANGE(a,b) if (ch<a) return MB_FALSE; \
  if (ch<=b) return MB_TRUE
#define TX_MATCH_CHAR(a) if (ch<a) return MB_FALSE; \
  if (ch==a) return MB_TRUE

/**
 * Returns true if the given character represents a numeric letter (digit)
**/
MBool ExprLexer::isDigit(UNICODE_CHAR ch)
{
  TX_CHAR_RANGE('0','9');
  return MB_FALSE;
} //-- isDigit

/**
 * Returns true if the given character represents an Alpha letter
**/
MBool ExprLexer::isLetter(UNICODE_CHAR ch)
{
/* Letter = BaseChar | Ideographic; and _ */
  TX_CHAR_RANGE(0x0041,0x005A);
  TX_MATCH_CHAR(0x005F);        /* '_' */
  TX_CHAR_RANGE(0x0061,0x007A);
  TX_CHAR_RANGE(0x00C0,0x00D6);
  TX_CHAR_RANGE(0x00D8,0x00F6);
  TX_CHAR_RANGE(0x00F8,0x00FF);
  TX_CHAR_RANGE(0x0100,0x0131);
  TX_CHAR_RANGE(0x0134,0x013E);
  TX_CHAR_RANGE(0x0141,0x0148);
  TX_CHAR_RANGE(0x014A,0x017E);
  TX_CHAR_RANGE(0x0180,0x01C3);
  TX_CHAR_RANGE(0x01CD,0x01F0);
  TX_CHAR_RANGE(0x01F4,0x01F5);
  TX_CHAR_RANGE(0x01FA,0x0217);
  TX_CHAR_RANGE(0x0250,0x02A8);
  TX_CHAR_RANGE(0x02BB,0x02C1);
  TX_MATCH_CHAR(0x0386);
  TX_CHAR_RANGE(0x0388,0x038A);
  TX_MATCH_CHAR(0x038C);
  TX_CHAR_RANGE(0x038E,0x03A1);
  TX_CHAR_RANGE(0x03A3,0x03CE);
  TX_CHAR_RANGE(0x03D0,0x03D6);
  TX_MATCH_CHAR(0x03DA);
  TX_MATCH_CHAR(0x03DC);
  TX_MATCH_CHAR(0x03DE);
  TX_MATCH_CHAR(0x03E0);
  TX_CHAR_RANGE(0x03E2,0x03F3);
  TX_CHAR_RANGE(0x0401,0x040C);
  TX_CHAR_RANGE(0x040E,0x044F);
  TX_CHAR_RANGE(0x0451,0x045C);
  TX_CHAR_RANGE(0x045E,0x0481);
  TX_CHAR_RANGE(0x0490,0x04C4);
  TX_CHAR_RANGE(0x04C7,0x04C8);
  TX_CHAR_RANGE(0x04CB,0x04CC);
  TX_CHAR_RANGE(0x04D0,0x04EB);
  TX_CHAR_RANGE(0x04EE,0x04F5);
  TX_CHAR_RANGE(0x04F8,0x04F9);
  TX_CHAR_RANGE(0x0531,0x0556);
  TX_MATCH_CHAR(0x0559);
  TX_CHAR_RANGE(0x0561,0x0586);
  TX_CHAR_RANGE(0x05D0,0x05EA);
  TX_CHAR_RANGE(0x05F0,0x05F2);
  TX_CHAR_RANGE(0x0621,0x063A);
  TX_CHAR_RANGE(0x0641,0x064A);
  TX_CHAR_RANGE(0x0671,0x06B7);
  TX_CHAR_RANGE(0x06BA,0x06BE);
  TX_CHAR_RANGE(0x06C0,0x06CE);
  TX_CHAR_RANGE(0x06D0,0x06D3);
  TX_MATCH_CHAR(0x06D5);
  TX_CHAR_RANGE(0x06E5,0x06E6);
  TX_CHAR_RANGE(0x0905,0x0939);
  TX_MATCH_CHAR(0x093D);
  TX_CHAR_RANGE(0x0958,0x0961);
  TX_CHAR_RANGE(0x0985,0x098C);
  TX_CHAR_RANGE(0x098F,0x0990);
  TX_CHAR_RANGE(0x0993,0x09A8);
  TX_CHAR_RANGE(0x09AA,0x09B0);
  TX_MATCH_CHAR(0x09B2);
  TX_CHAR_RANGE(0x09B6,0x09B9);
  TX_CHAR_RANGE(0x09DC,0x09DD);
  TX_CHAR_RANGE(0x09DF,0x09E1);
  TX_CHAR_RANGE(0x09F0,0x09F1);
  TX_CHAR_RANGE(0x0A05,0x0A0A);
  TX_CHAR_RANGE(0x0A0F,0x0A10);
  TX_CHAR_RANGE(0x0A13,0x0A28);
  TX_CHAR_RANGE(0x0A2A,0x0A30);
  TX_CHAR_RANGE(0x0A32,0x0A33);
  TX_CHAR_RANGE(0x0A35,0x0A36);
  TX_CHAR_RANGE(0x0A38,0x0A39);
  TX_CHAR_RANGE(0x0A59,0x0A5C);
  TX_MATCH_CHAR(0x0A5E);
  TX_CHAR_RANGE(0x0A72,0x0A74);
  TX_CHAR_RANGE(0x0A85,0x0A8B);
  TX_MATCH_CHAR(0x0A8D);
  TX_CHAR_RANGE(0x0A8F,0x0A91);
  TX_CHAR_RANGE(0x0A93,0x0AA8);
  TX_CHAR_RANGE(0x0AAA,0x0AB0);
  TX_CHAR_RANGE(0x0AB2,0x0AB3);
  TX_CHAR_RANGE(0x0AB5,0x0AB9);
  TX_MATCH_CHAR(0x0ABD);
  TX_MATCH_CHAR(0x0AE0);
  TX_CHAR_RANGE(0x0B05,0x0B0C);
  TX_CHAR_RANGE(0x0B0F,0x0B10);
  TX_CHAR_RANGE(0x0B13,0x0B28);
  TX_CHAR_RANGE(0x0B2A,0x0B30);
  TX_CHAR_RANGE(0x0B32,0x0B33);
  TX_CHAR_RANGE(0x0B36,0x0B39);
  TX_MATCH_CHAR(0x0B3D);
  TX_CHAR_RANGE(0x0B5C,0x0B5D);
  TX_CHAR_RANGE(0x0B5F,0x0B61);
  TX_CHAR_RANGE(0x0B85,0x0B8A);
  TX_CHAR_RANGE(0x0B8E,0x0B90);
  TX_CHAR_RANGE(0x0B92,0x0B95);
  TX_CHAR_RANGE(0x0B99,0x0B9A);
  TX_MATCH_CHAR(0x0B9C);
  TX_CHAR_RANGE(0x0B9E,0x0B9F);
  TX_CHAR_RANGE(0x0BA3,0x0BA4);
  TX_CHAR_RANGE(0x0BA8,0x0BAA);
  TX_CHAR_RANGE(0x0BAE,0x0BB5);
  TX_CHAR_RANGE(0x0BB7,0x0BB9);
  TX_CHAR_RANGE(0x0C05,0x0C0C);
  TX_CHAR_RANGE(0x0C0E,0x0C10);
  TX_CHAR_RANGE(0x0C12,0x0C28);
  TX_CHAR_RANGE(0x0C2A,0x0C33);
  TX_CHAR_RANGE(0x0C35,0x0C39);
  TX_CHAR_RANGE(0x0C60,0x0C61);
  TX_CHAR_RANGE(0x0C85,0x0C8C);
  TX_CHAR_RANGE(0x0C8E,0x0C90);
  TX_CHAR_RANGE(0x0C92,0x0CA8);
  TX_CHAR_RANGE(0x0CAA,0x0CB3);
  TX_CHAR_RANGE(0x0CB5,0x0CB9);
  TX_MATCH_CHAR(0x0CDE);
  TX_CHAR_RANGE(0x0CE0,0x0CE1);
  TX_CHAR_RANGE(0x0D05,0x0D0C);
  TX_CHAR_RANGE(0x0D0E,0x0D10);
  TX_CHAR_RANGE(0x0D12,0x0D28);
  TX_CHAR_RANGE(0x0D2A,0x0D39);
  TX_CHAR_RANGE(0x0D60,0x0D61);
  TX_CHAR_RANGE(0x0E01,0x0E2E);
  TX_MATCH_CHAR(0x0E30);
  TX_CHAR_RANGE(0x0E32,0x0E33);
  TX_CHAR_RANGE(0x0E40,0x0E45);
  TX_CHAR_RANGE(0x0E81,0x0E82);
  TX_MATCH_CHAR(0x0E84);
  TX_CHAR_RANGE(0x0E87,0x0E88);
  TX_MATCH_CHAR(0x0E8A);
  TX_MATCH_CHAR(0x0E8D);
  TX_CHAR_RANGE(0x0E94,0x0E97);
  TX_CHAR_RANGE(0x0E99,0x0E9F);
  TX_CHAR_RANGE(0x0EA1,0x0EA3);
  TX_MATCH_CHAR(0x0EA5);
  TX_MATCH_CHAR(0x0EA7);
  TX_CHAR_RANGE(0x0EAA,0x0EAB);
  TX_CHAR_RANGE(0x0EAD,0x0EAE);
  TX_MATCH_CHAR(0x0EB0);
  TX_CHAR_RANGE(0x0EB2,0x0EB3);
  TX_MATCH_CHAR(0x0EBD);
  TX_CHAR_RANGE(0x0EC0,0x0EC4);
  TX_CHAR_RANGE(0x0F40,0x0F47);
  TX_CHAR_RANGE(0x0F49,0x0F69);
  TX_CHAR_RANGE(0x10A0,0x10C5);
  TX_CHAR_RANGE(0x10D0,0x10F6);
  TX_MATCH_CHAR(0x1100);
  TX_CHAR_RANGE(0x1102,0x1103);
  TX_CHAR_RANGE(0x1105,0x1107);
  TX_MATCH_CHAR(0x1109);
  TX_CHAR_RANGE(0x110B,0x110C);
  TX_CHAR_RANGE(0x110E,0x1112);
  TX_MATCH_CHAR(0x113C);
  TX_MATCH_CHAR(0x113E);
  TX_MATCH_CHAR(0x1140);
  TX_MATCH_CHAR(0x114C);
  TX_MATCH_CHAR(0x114E);
  TX_MATCH_CHAR(0x1150);
  TX_CHAR_RANGE(0x1154,0x1155);
  TX_MATCH_CHAR(0x1159);
  TX_CHAR_RANGE(0x115F,0x1161);
  TX_MATCH_CHAR(0x1163);
  TX_MATCH_CHAR(0x1165);
  TX_MATCH_CHAR(0x1167);
  TX_MATCH_CHAR(0x1169);
  TX_CHAR_RANGE(0x116D,0x116E);
  TX_CHAR_RANGE(0x1172,0x1173);
  TX_MATCH_CHAR(0x1175);
  TX_MATCH_CHAR(0x119E);
  TX_MATCH_CHAR(0x11A8);
  TX_MATCH_CHAR(0x11AB);
  TX_CHAR_RANGE(0x11AE,0x11AF);
  TX_CHAR_RANGE(0x11B7,0x11B8);
  TX_MATCH_CHAR(0x11BA);
  TX_CHAR_RANGE(0x11BC,0x11C2);
  TX_MATCH_CHAR(0x11EB);
  TX_MATCH_CHAR(0x11F0);
  TX_MATCH_CHAR(0x11F9);
  TX_CHAR_RANGE(0x1E00,0x1E9B);
  TX_CHAR_RANGE(0x1EA0,0x1EF9);
  TX_CHAR_RANGE(0x1F00,0x1F15);
  TX_CHAR_RANGE(0x1F18,0x1F1D);
  TX_CHAR_RANGE(0x1F20,0x1F45);
  TX_CHAR_RANGE(0x1F48,0x1F4D);
  TX_CHAR_RANGE(0x1F50,0x1F57);
  TX_MATCH_CHAR(0x1F59);
  TX_MATCH_CHAR(0x1F5B);
  TX_MATCH_CHAR(0x1F5D);
  TX_CHAR_RANGE(0x1F5F,0x1F7D);
  TX_CHAR_RANGE(0x1F80,0x1FB4);
  TX_CHAR_RANGE(0x1FB6,0x1FBC);
  TX_MATCH_CHAR(0x1FBE);
  TX_CHAR_RANGE(0x1FC2,0x1FC4);
  TX_CHAR_RANGE(0x1FC6,0x1FCC);
  TX_CHAR_RANGE(0x1FD0,0x1FD3);
  TX_CHAR_RANGE(0x1FD6,0x1FDB);
  TX_CHAR_RANGE(0x1FE0,0x1FEC);
  TX_CHAR_RANGE(0x1FF2,0x1FF4);
  TX_CHAR_RANGE(0x1FF6,0x1FFC);
  TX_MATCH_CHAR(0x2126);
  TX_CHAR_RANGE(0x212A,0x212B);
  TX_MATCH_CHAR(0x212E);
  TX_CHAR_RANGE(0x2180,0x2182);
  TX_MATCH_CHAR(0x3007);
  TX_CHAR_RANGE(0x3021,0x3029);
  TX_CHAR_RANGE(0x3041,0x3094);
  TX_CHAR_RANGE(0x30A1,0x30FA);
  TX_CHAR_RANGE(0x3105,0x312C);
  TX_CHAR_RANGE(0x4E00,0x9FA5);
  TX_CHAR_RANGE(0xAC00,0xD7A3);
  return MB_FALSE;
} //-- isAlphaChar

/**
 * Returns true if the given character is an allowable NCName character
**/
MBool ExprLexer::isNCNameChar(UNICODE_CHAR ch)
{
/* NCNameChar = Letter | Digit ('0'-'9') | '.' | '-' | '_'  | 
   CombiningChar | Extender */
  if (isLetter(ch)) return MB_TRUE;  /* Letter | '_' */

  TX_CHAR_RANGE(0x002D,0x002E);  /* '-' | '.' */
  TX_CHAR_RANGE(0x0030,0x0039);  /* Digit */
  TX_MATCH_CHAR(0x00B7);
  TX_MATCH_CHAR(0x02D0);
  TX_MATCH_CHAR(0x02D1);
  TX_CHAR_RANGE(0x0300,0x0345);
  TX_CHAR_RANGE(0x0360,0x0361);
  TX_MATCH_CHAR(0x0387);
  TX_CHAR_RANGE(0x0483,0x0486);
  TX_CHAR_RANGE(0x0591,0x05A1);
  TX_CHAR_RANGE(0x05A3,0x05B9);
  TX_CHAR_RANGE(0x05BB,0x05BD);
  TX_MATCH_CHAR(0x05BF);
  TX_CHAR_RANGE(0x05C1,0x05C2);
  TX_MATCH_CHAR(0x05C4);
  TX_MATCH_CHAR(0x0640);
  TX_CHAR_RANGE(0x064B,0x0652);
  TX_MATCH_CHAR(0x0670);
  TX_CHAR_RANGE(0x06D6,0x06DC);
  TX_CHAR_RANGE(0x06DD,0x06DF);
  TX_CHAR_RANGE(0x06E0,0x06E4);
  TX_CHAR_RANGE(0x06E7,0x06E8);
  TX_CHAR_RANGE(0x06EA,0x06ED);
  TX_CHAR_RANGE(0x0901,0x0903);
  TX_MATCH_CHAR(0x093C);
  TX_CHAR_RANGE(0x093E,0x094C);
  TX_MATCH_CHAR(0x094D);
  TX_CHAR_RANGE(0x0951,0x0954);
  TX_CHAR_RANGE(0x0962,0x0963);
  TX_CHAR_RANGE(0x0981,0x0983);
  TX_MATCH_CHAR(0x09BC);
  TX_MATCH_CHAR(0x09BE);
  TX_MATCH_CHAR(0x09BF);
  TX_CHAR_RANGE(0x09C0,0x09C4);
  TX_CHAR_RANGE(0x09C7,0x09C8);
  TX_CHAR_RANGE(0x09CB,0x09CD);
  TX_MATCH_CHAR(0x09D7);
  TX_CHAR_RANGE(0x09E2,0x09E3);
  TX_MATCH_CHAR(0x0A02);
  TX_MATCH_CHAR(0x0A3C);
  TX_MATCH_CHAR(0x0A3E);
  TX_MATCH_CHAR(0x0A3F);
  TX_CHAR_RANGE(0x0A40,0x0A42);
  TX_CHAR_RANGE(0x0A47,0x0A48);
  TX_CHAR_RANGE(0x0A4B,0x0A4D);
  TX_CHAR_RANGE(0x0A70,0x0A71);
  TX_CHAR_RANGE(0x0A81,0x0A83);
  TX_MATCH_CHAR(0x0ABC);
  TX_CHAR_RANGE(0x0ABE,0x0AC5);
  TX_CHAR_RANGE(0x0AC7,0x0AC9);
  TX_CHAR_RANGE(0x0ACB,0x0ACD);
  TX_CHAR_RANGE(0x0B01,0x0B03);
  TX_MATCH_CHAR(0x0B3C);
  TX_CHAR_RANGE(0x0B3E,0x0B43);
  TX_CHAR_RANGE(0x0B47,0x0B48);
  TX_CHAR_RANGE(0x0B4B,0x0B4D);
  TX_CHAR_RANGE(0x0B56,0x0B57);
  TX_CHAR_RANGE(0x0B82,0x0B83);
  TX_CHAR_RANGE(0x0BBE,0x0BC2);
  TX_CHAR_RANGE(0x0BC6,0x0BC8);
  TX_CHAR_RANGE(0x0BCA,0x0BCD);
  TX_MATCH_CHAR(0x0BD7);
  TX_CHAR_RANGE(0x0C01,0x0C03);
  TX_CHAR_RANGE(0x0C3E,0x0C44);
  TX_CHAR_RANGE(0x0C46,0x0C48);
  TX_CHAR_RANGE(0x0C4A,0x0C4D);
  TX_CHAR_RANGE(0x0C55,0x0C56);
  TX_CHAR_RANGE(0x0C82,0x0C83);
  TX_CHAR_RANGE(0x0CBE,0x0CC4);
  TX_CHAR_RANGE(0x0CC6,0x0CC8);
  TX_CHAR_RANGE(0x0CCA,0x0CCD);
  TX_CHAR_RANGE(0x0CD5,0x0CD6);
  TX_CHAR_RANGE(0x0D02,0x0D03);
  TX_CHAR_RANGE(0x0D3E,0x0D43);
  TX_CHAR_RANGE(0x0D46,0x0D48);
  TX_CHAR_RANGE(0x0D4A,0x0D4D);
  TX_MATCH_CHAR(0x0D57);
  TX_MATCH_CHAR(0x0E31);
  TX_CHAR_RANGE(0x0E34,0x0E3A);
  TX_MATCH_CHAR(0x0E46);
  TX_CHAR_RANGE(0x0E47,0x0E4E);
  TX_MATCH_CHAR(0x0EB1);
  TX_CHAR_RANGE(0x0EB4,0x0EB9);
  TX_CHAR_RANGE(0x0EBB,0x0EBC);
  TX_MATCH_CHAR(0x0EC6);
  TX_CHAR_RANGE(0x0EC8,0x0ECD);
  TX_CHAR_RANGE(0x0F18,0x0F19);
  TX_MATCH_CHAR(0x0F35);
  TX_MATCH_CHAR(0x0F37);
  TX_MATCH_CHAR(0x0F39);
  TX_MATCH_CHAR(0x0F3E);
  TX_MATCH_CHAR(0x0F3F);
  TX_CHAR_RANGE(0x0F71,0x0F84);
  TX_CHAR_RANGE(0x0F86,0x0F8B);
  TX_CHAR_RANGE(0x0F90,0x0F95);
  TX_MATCH_CHAR(0x0F97);
  TX_CHAR_RANGE(0x0F99,0x0FAD);
  TX_CHAR_RANGE(0x0FB1,0x0FB7);
  TX_MATCH_CHAR(0x0FB9);
  TX_CHAR_RANGE(0x20D0,0x20DC);
  TX_MATCH_CHAR(0x20E1);
  TX_MATCH_CHAR(0x3005);
  TX_CHAR_RANGE(0x302A,0x302F);
  TX_CHAR_RANGE(0x3031,0x3035);
  TX_MATCH_CHAR(0x3099);
  TX_MATCH_CHAR(0x309A);
  TX_CHAR_RANGE(0x309D,0x309E);
  TX_CHAR_RANGE(0x30FC,0x30FE);
  return MB_FALSE;
} //-- isNCNameChar






/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
 * The contents of this file are subject to the Mozilla Public
 * License Version 1.1 (the "License"); you may not use this file
 * except in compliance with the License. You may obtain a copy of

#include "FunctionLib.h"
#include "Names.h"

const String ExprParser::L_CURLY_BRACE = "{";
const String ExprParser::R_CURLY_BRACE = "}";

/**
 * Creates a new ExprParser
**/


/**
 * Creates an Attribute Value Template using the given value
 * This should move to XSLProcessor class
**/
AttributeValueTemplate* ExprParser::createAttributeValueTemplate
    (const String& attValue)
{

    AttributeValueTemplate* avt = new AttributeValueTemplate();

    Int32 size = attValue.length();
    if ( size == 0) return avt; //XXX should return 0, but that causes crash in lre12

    int cc = 0;
    UNICODE_CHAR nextCh;
    UNICODE_CHAR ch;
    String buffer;
    MBool inExpr    = MB_FALSE;
    MBool inLiteral = MB_FALSE;
    UNICODE_CHAR endLiteral;
    UNICODE_CHAR prevCh = '\0';

    nextCh = attValue.charAt(cc);
    while ( cc++ < size) {
        ch = nextCh;
        nextCh = cc != size ? attValue.charAt(cc) : 0;
        
        // if in literal just add ch to buffer
        if ( inLiteral && (ch != endLiteral) ) {
                buffer.append(ch);
                prevCh = ch;
                continue;
        }
        switch ( ch ) {
            case '\'' :
            case '"' :
                buffer.append(ch);
                if (inLiteral)
                    inLiteral = MB_FALSE;
                else if (inExpr) {
                    inLiteral = MB_TRUE;
                    endLiteral = ch;
                }
                break;
            case  '{' :
                // Ignore case where we find two { without a }
                if (!inExpr) {
                    // Ignore case where we find two {
                    if ( nextCh == ch ) {
                        buffer.append(ch); //-- append '{'
                        cc++;
                        nextCh = cc != size ? attValue.charAt(cc) : 0;
                    }
                    else {
                        if ( buffer.length() > 0)
                            avt->addExpr(new StringExpr(buffer));
                        buffer.clear();
                        inExpr = MB_TRUE;
                    }
                    inExpr = MB_TRUE;
                }
                else
                    inExpr = MB_FALSE;
                    buffer.append(ch);
                }
                else {
                    buffer.append(ch); //-- simply append '{'
                    ch = '\0';
                }
                break;
            case '}':
                if (inExpr) {
                    inExpr = MB_FALSE;
                    Expr* expr = createExpr(buffer);
                    if (!expr) {
                        delete avt;
                        return 0;
                    }
                    avt->addExpr(expr);
                    buffer.clear();
                    //-- change in case another '}' follows
                    ch = '\0';
                }
                else if (nextCh == ch) {
                    buffer.append(ch);
                    cc++;
                    nextCh = cc != size ? attValue.charAt(cc) : 0;
                }
                else {
                    //XXX ErrorReport: unmatched '}' found
                    delete avt;
                    return 0;
                }
                break;
            default:
                buffer.append(ch);
                break;
        }
        prevCh = ch;
    }

    if ( inExpr ) {
        //XXX ErrorReport: ending '}' missing
        delete avt;
        return 0;
            errMsg.append(buffer);
            avt->addExpr(new StringExpr(errMsg));
        }
        else avt->addExpr(new StringExpr(buffer));
    }

    if ( buffer.length() > 0)
        avt->addExpr(new StringExpr(buffer));

    return avt;

} //-- createAttributeValueTemplate

    return createExpr(lexer);
} //-- createExpr

Expr* ExprParser::createPatternExpr(const String& pattern) {
    ExprLexer lexer(pattern);
    Expr* expr = createUnionExpr(lexer);
    return expr;
} //-- createPatternExpr

LocationStep* ExprParser::createLocationStep(const String& path) {

} //-- createBinaryExpr


Expr* ExprParser::createExpr(ExprLexer& lexer) {

    MBool done = MB_FALSE;



    Stack exprs;
    Stack ops;
    
    while ( !done ) {

        MBool unary = MB_FALSE;
        while( lexer.peek()->type == Token::SUBTRACTION_OP ) {
            unary = !unary;
            lexer.nextToken();
        }

        expr = createUnionExpr(lexer);
        if ( !expr )
            break;

        if ( unary )
            expr = new UnaryExpr(expr);

        Token* tok = lexer.nextToken();
        switch ( tok->type ) {
            case Token::L_BRACKET: // Predicate starts here
            case Token::R_BRACKET:
            case Token::R_PAREN:
            case Token::COMMA :
                lexer.pushBack();
                done = MB_TRUE;
                break;
            case Token::L_PAREN: //-- Grouping Expression
                expr = createExpr(lexer);
                //-- look for end ')'
                if ( lexer.hasMoreTokens() &&
                        ( lexer.nextToken()->type == Token::R_PAREN ) ) break;
                else {
                    //-- error
                    delete expr;
                    expr = new StringExpr("missing ')' in expression");
                }
                break;
            case Token::ANCESTOR_OP:
            case Token::PARENT_OP:
                lexer.pushBack();
                if ( !expr ) expr = createPathExpr(lexer);
                else {
                    PathExpr* pathExpr = createPathExpr(lexer);
                    pathExpr->addPatternExpr(0, (PatternExpr*)expr,
                                                 PathExpr::RELATIVE_OP);
                    expr = pathExpr;
                }
                //done = MB_TRUE;
                break;
            case Token::UNION_OP :
            {
                UnionExpr* unionExpr = createUnionExpr(lexer);
                unionExpr->addPathExpr(0, (PathExpr*)expr );
                expr = unionExpr;
                done = MB_TRUE;
                break;
            }
            case Token::LITERAL :
                expr = new StringExpr(tok->value);
                break;
            case Token::NUMBER:
            {
                StringResult str(tok->value);
                expr = new NumberExpr(str.numberValue());
                break;
            }
            case Token::FUNCTION_NAME:
            {
                lexer.pushBack();
                expr = createFunctionCall(lexer);
                break;
            }
            case Token::VAR_REFERENCE:
                expr = new VariableRefExpr(tok->value);
                break;
            //-- additive ops
            case Token::ADDITION_OP:
            case Token::DIVIDE_OP:
            //-- boolean ops

            case Token::MULTIPLY_OP:
            case Token::SUBTRACTION_OP:
            {
                while ( !exprs.empty() &&
                        precedenceLevel(tok->type) <= precedenceLevel(((Token*)ops.peek())->type)) {
                    expr = createBinaryExpr((Expr*)exprs.pop(),
                                             expr,
                                             (Token*)ops.pop());
                    }
                }
                exprs.push(expr);
                ops.push(tok);
                expr = 0; // OG, prevent reuse of expr
                break;
            }
            default:
                lexer.pushBack();
                done = MB_TRUE;
                break;
        }
    }

    // make sure expr != 0
    if ( expr == 0 ) {
        while (!exprs.empty() ) {
            delete (Expr*)exprs.pop();
        }
        return 0;
    }

    while (!exprs.empty() ) {
        expr = createBinaryExpr((Expr*)exprs.pop(), expr, (Token*)ops.pop());


} //-- createExpr

Expr* ExprParser::createFilterExpr(ExprLexer& lexer) {

    FilterExpr* filterExpr = new FilterExpr();
    Token* tok = lexer.nextToken();
    if ( !tok ) return filterExpr;

    Expr* expr = 0;
    switch ( tok->type ) {
        case Token::FUNCTION_NAME :
            lexer.pushBack();
            expr = createFunctionCall(lexer);
            filterExpr->setExpr(expr);
            break;
        case Token::VAR_REFERENCE :
            expr = new VariableRefExpr(tok->value);
            filterExpr->setExpr(expr);
            break;
        case Token::L_PAREN:
            //-- primary group expr:
            expr = createExpr(lexer);
            if(!expr) return 0;

            if ( lexer.nextToken()->type != Token::R_PAREN ) {
                lexer.pushBack();
                //XXX ErrorReport: right parenthesis expected
                delete expr;
                return 0;
            }
            filterExpr->setExpr(expr);
            break;
        case Token::LITERAL :
            expr = new StringExpr(tok->value);
            filterExpr->setExpr(expr);
            break;
        case Token::NUMBER:
        {
            StringResult str(tok->value);
            expr = new NumberExpr(str.numberValue());
            break;
        }
        default:
            // this should never ever happen.
            lexer.pushBack();
            //XXX ErrorReport: error in parser, please report on bugzilla.mozilla.org
            return 0;
            break;
    }
    if(!expr) return 0;

    if ( lexer.peek()->type == Token::L_BRACKET ) {
    parsePredicates(filterExpr, lexer);

        FilterExpr* filterExpr = new FilterExpr();
        filterExpr->setExpr(expr);

        //-- handle predicates
        if(!parsePredicates(filterExpr, lexer)) {
            delete filterExpr;
            return 0;
        }
        expr = filterExpr;
    }

    return expr;

} //-- createFilterExpr

FunctionCall* ExprParser::createFunctionCall(ExprLexer& lexer) {

    if ( !lexer.hasMoreTokens() ) {
        //-- should never see this, I hope
        return new ErrorFunctionCall("no tokens, invalid function call");
    }

    FunctionCall* fnCall = 0;

    Token* tok = lexer.nextToken();

    if ( tok->type != Token::FUNCTION_NAME ) {
        //XXX ErrorReport: error in parser, please report on bugzilla.mozilla.org
        return 0;
    }

    String fnName = tok->value;

        //-- not our job to report an invalid function call here
        fnCall = new ExtensionFunctionCall(fnName);
    }
    
    //-- handle parametes
    if(!parseParameters(fnCall, lexer)) {
        delete fnCall;
        return 0;
        String err("error with function call, \"");
        err.append(fnName);
        err.append("\" : ");
        err.append(*errMsg);
        fnCall = new ErrorFunctionCall(err);
        delete errMsg;
    }
    // copy params
    else if (params.getLength() > 0) {
        ListIterator* iter = params.iterator();
        while ( iter->hasNext() ) fnCall->addParam( (Expr*)iter->next() );
        delete iter;
    }
    return fnCall;
} //-- createFunctionCall

LocationStep* ExprParser::createLocationStep(ExprLexer& lexer) {

    LocationStep* lstep = new LocationStep();

    //-- child axis is default
    short axisIdentifier = LocationStep::CHILD_AXIS;
    NodeExpr* nodeExpr = 0;

    //-- get Axis Identifier or AbbreviatedStep, if present
    Token* tok = lexer.peek();
    switch (tok->type) {
        case Token::AXIS_IDENTIFIER:

                axisIdentifier = LocationStep::PRECEDING_SIBLING_AXIS;
            else if ( SELF_AXIS.isEqual(tok->value) )
                axisIdentifier = LocationStep::SELF_AXIS;
            else {
                delete lstep;
                //XXX ErrorReport: unknow axis
                return 0;
                //-- is implemented
            }
            break;
        }

            lexer.nextToken();
            axisIdentifier = LocationStep::ATTRIBUTE_AXIS;
            break;
        case Token::PARENT_NODE :
            //-- eat token
            lexer.nextToken();
            axisIdentifier = LocationStep::PARENT_AXIS;
            nodeExpr = new BasicNodeExpr();
            break;
        case Token::SELF_NODE :
            //-- eat token
            lexer.nextToken();
            axisIdentifier = LocationStep::SELF_AXIS;
            nodeExpr = new BasicNodeExpr();
            break;
        default:
            break;
    }

    //-- get NodeTest unless AbbreviatedStep was found
    if ( !nodeExpr ) {
        tok = lexer.nextToken();

        switch(tok->type) {
            case Token::CNAME :
                // NameTest
                // XXX Namespace: handle namespaces here
                if (axisIdentifier ==  LocationStep::ATTRIBUTE_AXIS)
                    nodeExpr = new AttributeExpr(tok->value);
                else
                    nodeExpr = new ElementExpr(tok->value);
                break;
            default:
                lexer.pushBack();
                nodeExpr = createNodeExpr(lexer);
                if(!nodeExpr) {
                    delete lstep;
                    return 0;
                }
        }
    // NodeType
    else {
       nodeExpr = createNodeExpr(lexer);
    }
    
    lstep->setAxisIdentifier(axisIdentifier);
    lstep->setNodeExpr(nodeExpr);



    //-- handle predicates
    if(!parsePredicates(lstep, lexer)) {
        delete lstep;
        return 0;
    }
    //String tmp;
    //lstep->toString(tmp);
    //cout << "returning LocationStep: "<< tmp <<endl;
    //</debug>

    return lstep;
} //-- createLocationPath

**/
NodeExpr* ExprParser::createNodeExpr(ExprLexer& lexer) {

    //cout << "creating NodeExpr: "<<endl;
    if (!lexer.hasMoreTokens() )  cout << "Lexer has no Tokens"<<endl;

    if (!lexer.hasMoreTokens() )  return 0;

    NodeExpr* nodeExpr = 0;

    Token* tok = lexer.nextToken();
    //cout << "Token #" << tok->type <<endl;
    List params;

    Token* nodeTok = lexer.nextToken();

    switch ( nodeTok->type ) {
        case Token::COMMENT:
            nodeExpr = new BasicNodeExpr(NodeExpr::COMMENT_EXPR);
            errMsg = parseParameters(&params, lexer);
            //-- ignore errMsg for now
            delete errMsg;
            break;
        case Token::NODE :
            nodeExpr = new BasicNodeExpr();
            errMsg = parseParameters(&params, lexer);
            //-- ignore errMsg for now
            delete errMsg;
            break;
        case Token::PROC_INST :
            nodeExpr = new BasicNodeExpr(NodeExpr::PI_EXPR);
            errMsg = parseParameters(&params, lexer);
            //-- ignore errMsg for now
            delete errMsg;
            break;
        case Token::TEXT :
            nodeExpr = new TextExpr();
            errMsg = parseParameters(&params, lexer);
            //-- ignore errMsg for now
            delete errMsg;
            break;
        default:
            lexer.pushBack();
            // XXX ErrorReport: unexpected token
            return 0;
            break;
    }

    if ( lexer.nextToken()->type != Token::L_PAREN ) {
        lexer.pushBack();
        //XXX ErrorReport: left parenthesis expected
        delete nodeExpr;
        return 0;
    }
    if ( nodeTok->type == Token::PROC_INST &&
         lexer.peek()->type == Token::LITERAL ) {
        Token* tok = lexer.nextToken();
        ((BasicNodeExpr*)nodeExpr)->setNodeName(tok->value);
    }
    if ( lexer.nextToken()->type != Token::R_PAREN ) {
        lexer.pushBack();
        //XXX ErrorReport: right parenthesis expected (or literal for pi)
        delete nodeExpr;
        return 0;
    }

    return nodeExpr;
} //-- createNodeExpr


 * Creates a PathExpr using the given ExprLexer
 * @param lexer the ExprLexer for retrieving Tokens
**/
Expr* ExprParser::createPathExpr(ExprLexer& lexer) {

    Expr* expr = 0;

    Token* tok = lexer.peek();

    // is this a root expression?
    if ( tok->type == Token::PARENT_OP ) {
        lexer.nextToken();
        if ( !isLocationStepToken(lexer.peek()) )
            return new RootExpr;

        lexer.pushBack();
    }

    // parse first step (possibly a FilterExpr)
    if ( tok->type != Token::PARENT_OP &&
         tok->type != Token::ANCESTOR_OP ) {
        if ( isFilterExprToken(tok) ) {
            expr = createFilterExpr(lexer);
        }
        else
            expr = createLocationStep(lexer);

        if ( !expr ) {
            return 0;
        if ( lexer.isOperatorToken(tok) ) {
            lexer.pushBack();
            return pathExpr;
        }
        
        // is this a singlestep path expression?
        tok = lexer.peek();
        if ( tok->type != Token::PARENT_OP &&
             tok->type != Token::ANCESTOR_OP)
            return expr;
    }
    
    //we have a pathexpression containing several steps
    PathExpr* pathExpr = new PathExpr();
    if(expr)
        pathExpr->addExpr(expr, PathExpr::RELATIVE_OP);

    // this is ugly
    while (1) {
        short ancestryOp;
        tok = lexer.nextToken();
        switch ( tok->type ) {
            case Token::R_PAREN:
            case Token::R_BRACKET:
            case Token::UNION_OP:
                //Marina, addition start
                // When parsing a list of parameters for a function comma should signal a spot
                // without it further processing pathExpr was causing "invalid token" error
            case Token::COMMA:
                // Marina, addition ends
                lexer.pushBack();
                return pathExpr;
            case Token::ANCESTOR_OP :
                ancestryOp = PathExpr::ANCESTOR_OP;
                break;

                break;
            default:
                lexer.pushBack();
                return pathExpr;
        }
        
        expr = createLocationStep(lexer);
        if ( !expr ) {
            delete pathExpr;
            return 0;
        }
        
        pathExpr->addExpr(expr, ancestryOp);
    }

    /* <debug> *
    String tmp;
    pathExpr->toString(tmp);
    cout << "creating pathExpr: " << tmp << endl;
    /* </debug> */

    return pathExpr;
} //-- createPathExpr

/**
 * Creates a PathExpr using the given ExprLexer
 * XXX temporary use as top of XSLT Pattern
 * @param lexer the ExprLexer for retrieving Tokens
**/
Expr* ExprParser::createUnionExpr(ExprLexer& lexer) {

    Expr* expr = createPathExpr(lexer);
    if(!expr)
        return 0;
    
    if ( lexer.peek()->type != Token::UNION_OP )
        return expr;
        pExpr = createFilterExpr(lexer);
    }
    else {
        cout << "invalid token: " << tok->value << endl;
        //-- eat token for now
        lexer.nextToken();
    }
    return pExpr;
} //-- createPatternExpr

/**
 * Creates a PathExpr using the given ExprLexer
 * @param lexer the ExprLexer for retrieving Tokens
**/
UnionExpr* ExprParser::createUnionExpr(ExprLexer& lexer) {
    UnionExpr* unionExpr = new UnionExpr();
    unionExpr->addExpr(expr);

    while ( lexer.peek()->type == Token::UNION_OP ) {
        lexer.nextToken(); //-- eat token
        switch ( tok->type ) {

        expr = createPathExpr(lexer);
        if ( !expr ) {
            delete unionExpr;
            return 0;
            case Token::UNION_OP :
                //-- eat token
                break;
            default:
                lexer.pushBack();
                unionExpr->addPathExpr(createPathExpr(lexer));
                break;
        }
        unionExpr->addExpr(expr);
    }

    //unionExpr->toString(tmp);
    //cout << "creating UnionExpr: " << tmp << endl;
    return unionExpr;
} //-- createUnionExpr

MBool ExprParser::isFilterExprToken(Token* token) {
    if ( !token ) return MB_FALSE;
    switch (token->type) {
        case Token::LITERAL:
        case Token::NUMBER:
        case Token::FUNCTION_NAME:
        case Token::VAR_REFERENCE:
        case Token::L_PAREN:            // grouping expr
        case Token::PARENT_NODE:
        case Token::SELF_NODE :
            return MB_TRUE;
        default:
            return MB_FALSE;

} //-- isFilterExprToken

MBool ExprParser::isLocationStepToken(Token* token) {
    switch (token->type) {
        case Token::AXIS_IDENTIFIER :
        case Token::AT_SIGN :
        case Token::PARENT_NODE :
        case Token::SELF_NODE :
            return MB_TRUE;
        default:
            return isNodeTypeToken(token);
    }
} //-- isLocationStepToken

MBool ExprParser::isNodeTypeToken(Token* token) {
    if (!token) return MB_FALSE;

    switch ( token->type ) {
        case Token::AT_SIGN:
        case Token::CNAME:
        case Token::COMMENT:
        case Token::NODE :

        default:
            return MB_FALSE;
    }
} //-- isNodeTypeToken

/**
 * Using the given lexer, parses the tokens if they represent a predicate list

 * @param lexer the ExprLexer to use for parsing tokens
 * @return 0 if successful, or a String pointer to the error message
**/
MBool ExprParser::parsePredicates(PredicateList* predicateList, ExprLexer& lexer) {

    String* errorMsg = 0;

    Token* tok = lexer.peek();

    if ( !tok ) return 0; //-- no predicates
    if ( tok->type != Token::L_BRACKET ) return 0; //-- not start of predicate list

    while ( lexer.peek()->type == Token::L_BRACKET ) {
        //-- eat Token
        lexer.nextToken();

        Expr* expr = createExpr(lexer);
        if(!expr)
            return MB_FALSE;
            //-- error missing ']'
            errorMsg = new String("missing close of predicate expression ']'");
            break;
        }
        if ( tok->type == Token::R_BRACKET) {
            lexer.nextToken(); //-- eat ']'

        predicateList->add(expr);

        if(lexer.nextToken()->type != Token::R_BRACKET) {
            lexer.pushBack();
            //XXX ErrorReport: right bracket expected
            return MB_FALSE;
        }

        //-- Fix: handle multiple predicates - Marina M.
        if (tok->type == Token::L_BRACKET)
            lexer.nextToken(); //-- swallow '['
        //-- /Fix

        Expr* expr = createExpr(lexer);
        predicateList->add(expr);
    }
    return MB_TRUE;

} //-- parsePredicates


 * error message.
 * @param list, the List to add parameter expressions to
 * @param lexer the ExprLexer to use for parsing tokens
 * @return MB_TRUE if successful, or a MB_FALSE otherwise
**/
MBool ExprParser::parseParameters(FunctionCall* fnCall, ExprLexer& lexer) {

    String* errorMsg = 0;

    if ( lexer.nextToken()->type != Token::L_PAREN ) {
        lexer.pushBack();
        //XXX ErrorReport: left parenthesis expected
        return MB_FALSE;
    }

    if( lexer.peek()->type == Token::R_PAREN ) {
        lexer.nextToken();
        return MB_TRUE;
    }

    while ( 1 ) {
        Expr* expr = createExpr(lexer);
        if(!expr)
            return MB_FALSE;

        fnCall->addParam(expr);
            
        switch ( lexer.nextToken()->type ) {
            case Token::R_PAREN :
                return MB_TRUE;
                lexer.nextToken(); //-- eat R_PAREN
                done = MB_TRUE;
                break;
            case Token::COMMA: //-- param separator
                //-- eat COMMA
                lexer.nextToken();
                foundSep = MB_TRUE;
                break;
            default:
                lexer.pushBack();
                //XXX ErrorReport: right parenthesis or comma expected
                return MB_FALSE;
                    break;
                }
                foundSep = MB_FALSE;
                Expr* expr = createExpr(lexer);
                list->add(expr);
                break;
        }
    }

    return MB_FALSE;

} //-- parseParameters






/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
 * The contents of this file are subject to the Mozilla Public
 * License Version 1.1 (the "License"); you may not use this file
 * except in compliance with the License. You may obtain a copy of


public:

    static const String R_CURLY_BRACE;
    static const String L_CURLY_BRACE;

    /**
     * Creates a new ExprParser
    **/

    ~ExprParser();

    Expr*          createExpr        (const String& pattern);
    Expr*          createPatternExpr (const String& pattern);
    LocationStep*  createLocationStep(const String& path);

    /**


    Expr*          createBinaryExpr   (Expr* left, Expr* right, Token* op);
    Expr*          createExpr         (ExprLexer& lexer);
    Expr*          createFilterExpr   (ExprLexer& lexer);
    FunctionCall*  createFunctionCall (ExprLexer& lexer);
    LocationStep*  createLocationStep (ExprLexer& lexer);
    NodeExpr*      createNodeExpr     (ExprLexer& lexer);
    Expr*          createPathExpr     (ExprLexer& lexer);
    Expr*          createUnionExpr    (ExprLexer& lexer);
    UnionExpr*     createUnionExpr    (ExprLexer& lexer);

    MBool          isFilterExprToken   (Token* tok);
    MBool          isLocationStepToken (Token* tok);

     * @param lexer the ExprLexer to use for parsing tokens
     * @return 0 if successful, or a String pointer to the error message
    **/
    MBool parsePredicates(PredicateList* predicateList, ExprLexer& lexer);
    MBool parseParameters(FunctionCall* fnCall, ExprLexer& lexer);


}; //-- ExprParser

-      Line
+  Link Here
-       Lines 101-106
+  Link Here
 } //-- addParam
 /**
+ * Returns the default priority of this Expr based on the given Node,
+ * context Node, and ContextState.
+**/
+double FunctionCall::getDefaultPriority(Node* node, Node* context, ContextState* cs) {
+    return 0.5;
+} //-- getDefaultPriority
+/**
+ * Determines whether this Expr matches the given node within
+ * the given context
+**/
+MBool FunctionCall::matches(Node* node, Node* context, ContextState* cs) {
+    MBool result = MB_FALSE;
+    ExprResult* exprResult = evaluate(node, cs);
+    if ( exprResult->getResultType() == ExprResult::NODESET ) {
+        NodeSet* nodes = (NodeSet*)exprResult;
+        result = (nodes->contains(node));
+    }
+    delete exprResult;
+    return result;
+} //-- matches
+/**
  * Evaluates the given Expression and converts it's result to a String.
  * The value is appended to the given destination String
 **/





        BooleanResult.cpp \
        ElementExpr.cpp \
        ErrorFunctionCall.cpp \
        Expr.cpp \
        ExprLexer.cpp \
        ExprLexerChars.cpp \
        ExprParser.cpp \
        ExtensionFunctionCall.cpp \
        FilterExpr.cpp \
        FunctionCall.cpp \
        IdentityExpr.cpp \
        LocationStep.cpp \
        MultiplicativeExpr.cpp \
        NodeSet.cpp \

        NumberExpr.cpp \
        NumberFunctionCall.cpp \
        NumberResult.cpp \
        ParentExpr.cpp \
        PathExpr.cpp \
        PredicateList.cpp \
        RelationalExpr.cpp \

        StringResult.cpp \
        TextExpr.cpp \
        UnionExpr.cpp \
        UnaryExpr.cpp \
        VariableRefExpr.cpp \
        XPathNames.cpp
ifndef TX_EXE





}

/**
 * Destructor, will delete all Expressions
**/
PathExpr::~PathExpr() {
    ListIterator* iter = expressions.iterator();
    while ( iter->hasNext() ) {
         iter->next();
         PathExprItem* pxi = (PathExprItem*)iter->remove();
         delete pxi->expr;
         delete pxi;
    }
    delete iter;
} //-- ~PathExpr

/**
 * Adds the Expr to this PathExpr
 * @param expr the Expr to add to this PathExpr
 * @param index the index at which to add the given Expr
**/
void PathExpr::addExpr(int index, Expr* expr, short ancestryOp) {
    if (expr) {
        PathExprItem* pxi = new PathExprItem;
        pxi->expr = expr;
        pxi->ancestryOp = ancestryOp;
        expressions.insert(index, pxi);
    }
} //-- addPattenExpr

/**
 * Adds the Expr to this PathExpr
 * @param expr the Expr to add to this PathExpr
**/
void PathExpr::addExpr(Expr* expr, short ancestryOp) {
    if (expr) {
        PathExprItem* pxi = new PathExprItem;
        pxi->expr = expr;
        pxi->ancestryOp = ancestryOp;
        expressions.add(pxi);
    }

    return MB_FALSE;
} //-- isAbsolute

    //-----------------------------/
  //- Virtual methods from Expr -/
//-----------------------------/

/**
 * Evaluates this Expr based on the given context node and processor state

            NodeSet* resNodes;
            if ( pxi->ancestryOp == ANCESTOR_OP) {
                resNodes = new NodeSet;
                evalDescendants(pxi->expr, node, cs, resNodes);
            }
            else {
                ExprResult *res = pxi->expr->evaluate(node, cs);
                if (!res || res->getResultType() != ExprResult::NODESET) {
                    //XXX ErrorReport: report nonnodeset error
                    delete res;


/**
 * Selects from the descendants of the context node
 * all nodes that match the Expr
 * -- this will be moving to a Utility class
**/
void PathExpr::evalDescendants
    (Expr* expr, Node* context, ContextState* cs, NodeSet* resNodes)
{
    ExprResult *res = expr->evaluate(context, cs);
    if (!res || res->getResultType() != ExprResult::NODESET) {
        //XXX ErrorReport: report nonnodeset error
    }

    while(child) {
        if(!(filterWS && child->getNodeType() == Node::TEXT_NODE &&
             XMLUtils::shouldStripTextnode(child->getNodeValue())))
            evalDescendants(expr, child, cs, resNodes);
        child = child->getNextSibling();
    }
} //-- evalDescendants

            ListIterator* iter = expressions.iterator();
            PathExprItem* pxi = (PathExprItem*)iter->next();
            delete iter;
            return pxi->expr->getDefaultPriority(node, context, cs);
        }
        else if ( size > 1 ) {
            return 0.5;

} //-- getDefaultPriority

/**
 * Determines whether this Expr matches the given node within
 * the given context
**/
MBool PathExpr::matches(Node* node, Node* context, ContextState* cs) {

            {
                Node* ancestor = node;
                while (ancestor = cs->getParentNode(ancestor))  {
                    if (pxi->expr->matches(node, ancestor, cs))
                        return MB_TRUE;
                }
                break;

                if (parent) {
                    //-- make sure node is Document node
                    if (parent->getNodeType() == Node::DOCUMENT_NODE)
                        return pxi->expr->matches(node, parent, cs);
                }
                break;
            }
            default:
                return pxi->expr->matches(node, context, cs);

        }


                {
                    Node* parent = tnode;
                    while (parent = cs->getParentNode(parent))  {
                        if (pxi->expr->matches(tnode, parent, cs))
                            tmpNodes.add(parent);
                    }
                    break;

                        if ( !iter->hasNext() )
                            if (parent->getNodeType() != Node::DOCUMENT_NODE) break;

                        if (pxi->expr->matches(tnode, parent, cs))
                            tmpNodes.add(parent);
                    }
                    break;

                    if ( !iter->hasNext() ) {

                        /*
                          // PREVIOUS // result = pxi->expr->matches(tnode, context, cs);
                          // result was being overwritten if there was more than one
                          // node in nodes during the final iteration  (Marina)

                          result = result || pxi->expr->matches(tnode, context, cs)
                        */

                        //-- Just return true if we match here
                        if (pxi->expr->matches(tnode, context, cs)) {
                            delete iter;
                            return MB_TRUE;
                        }



/**
 * Returns the String representation of this Expr.
 * @param dest the String to use when creating the String
 * representation. The String representation will be appended to
 *  any data in the destination String, to allow cascading calls to
 * other #toString() methods for Expressions.
 * @return the String representation of this Expr.
**/
void PathExpr::toString(String& dest) {
    ListIterator* iter = expressions.iterator();

            default:
                break;
        }
        pxi->expr->toString(dest);
    }
    delete iter;
} //-- toString

(-)StringExpr.cpp (-2 / +5 lines)

Line	Link Here

Lines 77-84	Link Here

 * @return the String representation of this Expr.

 * @return the String representation of this Expr.

**/

**/

void StringExpr::toString(String& str) {

void StringExpr::toString(String& str) {

    str.append('\'');

    UNICODE_CHAR ch = '\'';

    if ( value.indexOf(ch) != NOT_FOUND )

        ch = '\"';

    str.append(ch);

    str.append(value);

    str.append(value);

    str.append('\'');

    str.append(ch);

} //-- toString

} //-- toString





/*
 * The contents of this file are subject to the Mozilla Public
 * License Version 1.1 (the "License"); you may not use this file
 * except in compliance with the License. You may obtain a copy of
 * the License at http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS
 * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
 * implied. See the License for the specific language governing
 * rights and limitations under the License.
 *
 * The Initial Developer of the Original Code is Jonas Sicking.
 * Portions created by Jonas Sicking are Copyright (C) 2001, Jonas Sicking.
 * All rights reserved.
 *
 * Contributor(s):
 * Jonas Sicking, sicking@bigfoot.com
 *   -- original author.
 */

#include "Expr.h"

  //-------------/
 //- UnaryExpr -/
//-------------/

UnaryExpr::UnaryExpr() {
    expr = 0;
}

UnaryExpr::UnaryExpr(Expr* expr) {
    this->expr = expr;
}

UnaryExpr::~UnaryExpr() {
    delete expr;
}

void UnaryExpr::setExpr(Expr* expr) {
    delete this->expr;
    this->expr = expr;
}

/**
 * Evaluates this Expr based on the given context node and processor state
 * @param context the context node for evaluation of this Expr
 * @param ps the ContextState containing the stack information needed
 * for evaluation
 * @return the result of the evaluation
**/
ExprResult* UnaryExpr::evaluate(Node* context, ContextState* cs) {
    ExprResult* exprRes = expr->evaluate(context, cs);
    double value = exprRes->numberValue();
    delete exprRes;
    return new NumberResult(-value);
}

/**
 * Returns the String representation of this Expr.
 * @param dest the String to use when creating the String
 * representation. The String representation will be appended to
 * any data in the destination String, to allow cascading calls to
 * other #toString() methods for Expressions.
 * @return the String representation of this Expr.
**/
void UnaryExpr::toString(String& str) {
    if (!expr) return;
    str.append('-');
    expr->toString(str);
}






    ListIterator* iter = expressions.iterator();
    while ( iter->hasNext() ) {
         iter->next();
         delete  (Expr*)iter->remove();
    }
    delete iter;
} //-- ~UnionExpr

/**
 * Adds the Expr to this UnionExpr
 * @param expr the Expr to add to this UnionExpr
**/
void UnionExpr::addExpr(Expr* expr) {
    if (expr) expressions.add(expr);
} //-- addExpr

/**
 * Adds the Expr to this UnionExpr
 * @param expr the Expr to add to this UnionExpr
**/
void UnionExpr::addExpr(int index, Expr* expr) {
    if (expr) expressions.insert(index, expr);
} //-- addExpr

    //------------------------------------/
  //- Virtual methods from Expr -/
//------------------------------------/

/**


    while ( iter->hasNext() ) {

        Expr* expr = (Expr*)iter->next();
        ExprResult* exprResult = expr->evaluate(context, cs);
        if ( exprResult->getResultType() == ExprResult::NODESET ) {
            ((NodeSet*)exprResult)->copyInto(*nodes);
        }
        delete tmpNodes;
    }

    delete iter;

    double priority = Double::NEGATIVE_INFINITY;
    ListIterator* iter = expressions.iterator();
    while ( iter->hasNext() ) {
        Expr* expr = (Expr*)iter->next();
        if ( expr->matches(node, context, cs) ) {
            double tmpPriority = expr->getDefaultPriority(node, context, cs);
            priority = (tmpPriority > priority) ? tmpPriority : priority;
        }
    }

    ListIterator* iter = expressions.iterator();

    while ( iter->hasNext() ) {
        Expr* expr = (Expr*)iter->next();
        if ( expr->matches(node, context, cs) ) {
             delete iter;
             return MB_TRUE;
        }



/**
 * Returns the String representation of this Expr.
 * @param dest the String to use when creating the String
 * representation. The String representation will be appended to
 *  any data in the destination String, to allow cascading calls to
 * other #toString() methods for Expressions.
 * @return the String representation of this Expr.
**/
void UnionExpr::toString(String& dest) {
    ListIterator* iter = expressions.iterator();

    while ( iter->hasNext() ) {
        //-- set operator
        if (count > 0) dest.append(" | ");
        ((Expr*)iter->next())->toString(dest);
        ++count;
    }
    delete iter;





	BooleanResult.cpp		\
	ElementExpr.cpp			\
	ErrorFunctionCall.cpp		\
	Expr.cpp			\
	ExprLexer.cpp			\
	ExprLexerChars.cpp		\
	ExprParser.cpp			\
	ExtensionFunctionCall.cpp	\
	FilterExpr.cpp			\
	FunctionCall.cpp		\
	IdentityExpr.cpp		\
	LocationStep.cpp		\
	MultiplicativeExpr.cpp		\
	NodeSet.cpp			\

	NumberExpr.cpp			\
	NumberFunctionCall.cpp		\
	NumberResult.cpp		\
	ParentExpr.cpp			\
	PathExpr.cpp			\
	PredicateList.cpp		\
	RelationalExpr.cpp		\

	StringResult.cpp		\
	TextExpr.cpp			\
	UnionExpr.cpp			\
	UnaryExpr.cpp			\
	VariableRefExpr.cpp		\
	XPathNames.cpp			\
!if !defined(TX_EXE)

	.\$(OBJDIR)\BooleanResult.obj			\
	.\$(OBJDIR)\ElementExpr.obj			\
	.\$(OBJDIR)\ErrorFunctionCall.obj		\
	.\$(OBJDIR)\Expr.obj				\
	.\$(OBJDIR)\ExprLexer.obj			\
	.\$(OBJDIR)\ExprLexerChars.obj			\
	.\$(OBJDIR)\ExprParser.obj			\
	.\$(OBJDIR)\ExtensionFunctionCall.obj		\
	.\$(OBJDIR)\FilterExpr.obj			\
	.\$(OBJDIR)\FunctionCall.obj			\
	.\$(OBJDIR)\IdentityExpr.obj			\
	.\$(OBJDIR)\LocationStep.obj			\
	.\$(OBJDIR)\MultiplicativeExpr.obj		\
	.\$(OBJDIR)\NodeSet.obj				\

	.\$(OBJDIR)\NumberExpr.obj			\
	.\$(OBJDIR)\NumberFunctionCall.obj		\
	.\$(OBJDIR)\NumberResult.obj			\
	.\$(OBJDIR)\ParentExpr.obj			\
	.\$(OBJDIR)\PathExpr.obj			\
	.\$(OBJDIR)\PredicateList.obj			\
	.\$(OBJDIR)\RelationalExpr.obj			\

	.\$(OBJDIR)\StringResult.obj			\
	.\$(OBJDIR)\TextExpr.obj			\
	.\$(OBJDIR)\UnionExpr.obj			\
	.\$(OBJDIR)\UnaryExpr.obj			\
	.\$(OBJDIR)\VariableRefExpr.obj			\
	.\$(OBJDIR)\XPathNames.obj			\
!if !defined(TX_EXE)

(-)ProcessorState.cpp (-2 / +4 lines)

Line	Link Here

Lines 196-203	Link Here

196

        namedTemplates.put(name,mObj);

196

        namedTemplates.put(name,mObj);

197

        if ( oldObj ) delete oldObj;

197

        if ( oldObj ) delete oldObj;

198

199

    patternExprHash.put(match, exprParser.createPatternExpr(match));

199

    if ( match.length() > 0 ) {

200

    templates.add(xslTemplate);

200

        patternExprHash.put(match, exprParser.createPatternExpr(match));

201

        templates.add(xslTemplate);

202

201

} //-- addTempalte

203

} //-- addTempalte

202

204

203

/**

205

/**

Return to bug 75102