Attachment #40618 for bug #75102

Attachment #40618: XPathLexerParser20010629.patch, diff -u -N, addresses comments by jst for bug #75102

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





  ../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

**/
ExprResult* BasicNodeExpr::evaluate(Node* context, ContextState* cs) {
    NodeSet* nodeSet = new NodeSet();
    if (!context)
        return nodeSet;
    Node* node = context->getFirstChild();
    while (node) {
        if (matches(node, context, cs))

    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


 * the given context
**/
MBool BasicNodeExpr::matches(Node* node, Node* context, ContextState* cs) {
    if (!node)
        return MB_FALSE;
    switch (type) {
        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);
            return MB_TRUE;
            break;
    }
    return MB_TRUE;

} //-- matches



 * @return the String representation of this NodeExpr.
**/
void BasicNodeExpr::toString(String& dest) {
    switch (type) {
        case NodeExpr::COMMENT_EXPR:
            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()");

(-)Expr.h (-642 / +115 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 59-65	Link Here

public:

public:

/**

/**

      * Returns the value of a given variable binding within the current scope

      * Returns the value of a given variable binding within the current scope

      * @param the name to which the desired variable value has been bound

      * @param the name to which the desired variable value has been bound

Lines 82-91	Link Here

**/

**/

    virtual Node* getParentNode(Node* node) = 0;

    virtual Node* getParentNode(Node* node) = 0;

    virtual MBool isStripSpaceAllowed(Node* node) = 0;

    virtual MBool isStripSpaceAllowed(Node* node) = 0;

/**

/**

     * Returns a call to the function that has the given name.

     * Returns a call to the function that has the given name.

     * This method is used for XPath Extension Functions.

     * This method is used for XPath Extension Functions.

Lines 101-107	Link Here

101

**/

105

**/

102

    virtual void sortByDocumentOrder(NodeSet* nodes) = 0;

106

    virtual void sortByDocumentOrder(NodeSet* nodes) = 0;

103

107

104

105

}; //-- ContextState

108

}; //-- ContextState

106

109

107

110

Lines 115-121	Link Here

115

/**

118

/**

116

     * Virtual destructor, important for subclasses

119

     * Virtual destructor, important for subclasses

117

**/

120

**/

118

    virtual ~Expr() {};

121

    virtual ~Expr();

119

122

120

/**

123

/**

121

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

124

     * 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;

130

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

128

131

129

/**

132

/**

133

     * Determines whether this Expr matches the given node within

134

     * the given context

135

**/

136

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

137

138

/**

139

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

140

     * context Node, and ContextState.

141

**/

142

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

143

144

/**

130

     * Returns the String representation of this Expr.

145

     * Returns the String representation of this Expr.

131

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

146

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

132

     * representation. The String representation will be appended to

147

     * representation. The String representation will be appended to

Lines 138-144	Link Here

138

153

139

}; //-- Expr

154

}; //-- Expr

140

155

141

142

/**

156

/**

143

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

157

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

144

 * Recommendation.

158

 * Recommendation.

Lines 149-171	Link Here

149

163

150

    static const String INVALID_PARAM_COUNT;

164

    static const String INVALID_PARAM_COUNT;

151

165

152

153

    virtual ~FunctionCall();

166

    virtual ~FunctionCall();

154

167

155

/**

168

/**

156

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

169

     * Virtual methods from Expr

157

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

158

**/

170

**/

159

    void addParam(Expr* expr);

171

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

172

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

173

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

174

    virtual void toString(String& dest);

160

175

161

/**

176

/**

162

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

177

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

163

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

178

     * @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

**/

179

**/

168

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

180

    void addParam(Expr* expr);

169

181

170

/**

182

/**

171

     * Returns the name of this FunctionCall

183

     * Returns the name of this FunctionCall

Lines 184-198	Link Here

184

     * @param name the name of this Function

196

     * @param name the name of this Function

185

**/

197

**/

186

    void setName(const String& name);

198

    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

199

197

200

198

protected:

201

protected:

Lines 203-209	Link Here

203

    FunctionCall(const String& name);

206

    FunctionCall(const String& name);

204

    FunctionCall(const String& name, List* parameters);

207

    FunctionCall(const String& name, List* parameters);

205

208

206

207

/**

209

/**

208

     * Evaluates the given Expression and converts it's result to a String.

210

     * Evaluates the given Expression and converts it's result to a String.

209

     * The value is appended to the given destination String

211

     * The value is appended to the given destination String

Lines 221-317	Link Here

221

    String name;

223

    String name;

222

}; //-- FunctionCall

224

}; //-- FunctionCall

223

225

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

226

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

263

264

/**

227

/**

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

228

 * Represents an AttributeValueTemplate

316

**/

229

**/

317

class AttributeValueTemplate: public Expr {

230

class AttributeValueTemplate: public Expr {

Lines 328-349	Link Here

328

    void addExpr(Expr* expr);

241

    void addExpr(Expr* expr);

329

242

330

/**

243

/**

331

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

244

     * 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

**/

245

**/

337

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

246

    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);

247

    virtual void toString(String& str);

348

248

349

private:

249

private:

Lines 355-361	Link Here

355

 * This class represents a NodeTestExpr as defined by the XSL

255

 * This class represents a NodeTestExpr as defined by the XSL

356

 * Working Draft

256

 * Working Draft

357

**/

257

**/

358

class NodeExpr : public PatternExpr {

258

class NodeExpr : public Expr {

359

259

360

public:

260

public:

361

261

Lines 379-411	Link Here

379

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

279

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

380

280

381

/**

281

/**

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

282

     * Returns the type of this NodeExpr

391

     * @return the type of this NodeExpr

283

     * @return the type of this NodeExpr

392

**/

284

**/

393

    virtual short getType() = 0;

285

    virtual short getType() = 0;

394

286

395

/**

287

/**

396

     * Determines whether this NodeExpr matches the given node within

288

     * Virtual methods from Expr

397

     * the given context

398

**/

289

**/

399

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

290

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

400

291

    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;

292

    virtual void toString(String& dest) = 0;

410

293

411

}; //-- NodeExpr

294

}; //-- NodeExpr

Lines 440-486	Link Here

440

**/

323

**/

441

    void setName(const String& name);

324

    void setName(const String& name);

442

325

443

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

444

   //- Method signatures from NodeExpr -/

445

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

446

447

/**

326

/**

448

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

327

     * 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

**/

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

**/

328

**/

462

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

329

    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();

330

    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);

331

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

475

332

    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);

333

    virtual void toString(String& dest);

485

334

486

private:

335

private:

Lines 492-498	Link Here

492

    MBool  isNameWild;

341

    MBool  isNameWild;

493

    MBool  isNamespaceWild;

342

    MBool  isNamespaceWild;

494

343

495

496

}; //-- AttributeExpr

344

}; //-- AttributeExpr

497

345

498

/**

346

/**

Lines 521-572	Link Here

521

     * Destroys this BasicNodeExpr

369

     * Destroys this BasicNodeExpr

522

**/

370

**/

523

    virtual ~BasicNodeExpr();

371

    virtual ~BasicNodeExpr();

524

372

525

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

526

   //- Method signatures from NodeExpr -/

527

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

528

529

/**

373

/**

530

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

374

     * 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

**/

375

**/

535

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

376

    void setNodeName(const String& name);

536

377

537

/**

378

/**

538

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

379

     * 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

**/

380

**/

544

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

381

    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();

382

    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);

383

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

557

384

    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);

385

    virtual void toString(String& dest);

567

386

568

private:

387

private:

569

    NodeExprType type;

388

    NodeExprType type;

389

    String nodeName;

390

    MBool nodeNameSet;

570

}; //-- BasicNodeExpr

391

}; //-- BasicNodeExpr

571

392

572

/**

393

/**

Lines 597-643	Link Here

597

**/

418

**/

598

    void setName(const String& name);

419

    void setName(const String& name);

599

420

600

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

601

   //- Method signatures from NodeExpr -/

602

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

603

604

/**

421

/**

605

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

422

     * 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

**/

423

**/

611

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

424

    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();

425

    short getType();

626

426

    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);

427

    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);

428

    virtual void toString(String& dest);

642

429

643

private:

430

private:

Lines 655-727	Link Here

655

}; //-- ElementExpr

442

}; //-- ElementExpr

656

443

657

/**

444

/**

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

445

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

726

**/

446

**/

727

class TextExpr : public NodeExpr {

447

class TextExpr : public NodeExpr {

Lines 729-775	Link Here

729

public:

449

public:

730

450

731

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

451

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

732

     //- Public Methods -/

452

     //- Public Methods -/

733

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

453

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

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

764

454

765

/**

455

/**

766

     * Returns the String representation of this NodeExpr.

456

     * 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

**/

457

**/

458

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

459

    virtual short getType();

460

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

461

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

773

    virtual void toString(String& dest);

462

    virtual void toString(String& dest);

774

463

775

}; //-- TextExpr

464

}; //-- TextExpr

Lines 827-833	Link Here

827

    List predicates;

516

    List predicates;

828

}; //-- PredicateList

517

}; //-- PredicateList

829

518

830

class LocationStep : public PredicateList, public PatternExpr {

519

class LocationStep : public PredicateList, public Expr {

831

520

832

public:

521

public:

833

522

Lines 849-855	Link Here

849

        SELF_AXIS

538

        SELF_AXIS

850

};

539

};

851

540

852

853

/**

541

/**

854

     * Creates a new LocationStep using the default Axis Identifier and no

542

     * Creates a new LocationStep using the default Axis Identifier and no

855

     * NodeExpr (which matches nothing)

543

     * NodeExpr (which matches nothing)

Lines 887-933	Link Here

887

**/

575

**/

888

    void setNodeExpr(NodeExpr* nodeExpr);

576

    void setNodeExpr(NodeExpr* nodeExpr);

889

577

890

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

891

     //- Virtual methods from PatternExpr -/

892

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

893

894

/**

578

/**

895

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

579

     * 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

**/

580

**/

901

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

581

    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);

582

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

916

583

    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);

584

    virtual void toString(String& dest);

926

585

927

private:

586

private:

928

587

929

  NodeExpr* nodeExpr;

588

    NodeExpr* nodeExpr;

930

  short     axisIdentifier;

589

    short     axisIdentifier;

931

590

932

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

591

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

933

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

592

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

Lines 935-941	Link Here

935

}; //-- LocationStep

594

}; //-- LocationStep

936

595

937

596

938

class FilterExpr : public PredicateList, public PatternExpr {

597

class FilterExpr : public PredicateList, public Expr {

939

598

940

public:

599

public:

941

600

Lines 962-1007	Link Here

962

**/

621

**/

963

    void setExpr(Expr* expr);

622

    void setExpr(Expr* expr);

964

623

965

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

966

     //- Virtual methods from PatternExpr -/

967

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

968

969

/**

624

/**

970

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

625

     * 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

**/

626

**/

976

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

627

    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);

628

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

991

629

    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);

630

    virtual void toString(String& dest);

1001

631

1002

private:

632

private:

1003

633

1004

  Expr*     expr;

634

    Expr* expr;

1005

635

1006

}; //-- FilterExpr

636

}; //-- FilterExpr

1007

637

Lines 1015-1036	Link Here

1015

    ~NumberExpr();

645

    ~NumberExpr();

1016

646

1017

/**

647

/**

1018

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

648

     * 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

**/

649

**/

1024

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

650

    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);

651

    virtual void toString(String& str);

1035

652

1036

private:

653

private:

Lines 1052-1073	Link Here

1052

    ~StringExpr();

669

    ~StringExpr();

1053

670

1054

/**

671

/**

1055

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

672

     * 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

**/

673

**/

1061

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

674

    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);

675

    virtual void toString(String& str);

1072

676

1073

private:

677

private:

Lines 1106-1131	Link Here

1106

710

1107

711

1108

/**

712

/**

1109

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

713

     * 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

**/

714

**/

1115

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

715

    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);

716

    virtual void toString(String& str);

1126

717

1127

1128

1129

private:

718

private:

1130

    short op;

719

    short op;

1131

    Expr* leftExpr;

720

    Expr* leftExpr;

Lines 1133-1138	Link Here

1133

}; //-- AdditiveExpr

722

}; //-- AdditiveExpr

1134

723

1135

/**

724

/**

725

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

726

**/

727

class UnaryExpr : public Expr {

728

729

public:

730

731

     UnaryExpr();

732

     UnaryExpr(Expr* expr);

733

     ~UnaryExpr();

734

735

/**

736

     * Sets the expression to negate

737

**/

738

    void setExpr(Expr* expr);

739

740

/**

741

     * Virtual methods from Expr

742

**/

743

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

744

    virtual void toString(String& str);

745

746

private:

747

    Expr* expr;

748

}; //-- UnaryExpr

749

750

/**

1136

 * Represents a BooleanExpr, a binary expression that

751

 * Represents a BooleanExpr, a binary expression that

1137

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

752

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

1138

**/

753

**/

Lines 1148-1184	Link Here

1148

     ~BooleanExpr();

763

     ~BooleanExpr();

1149

764

1150

/**

765

/**

1151

     * Sets the left side of this AdditiveExpr

766

     * Sets the left side of this BooleanExpr

1152

**/

767

**/

1153

    void setLeftExpr(Expr* leftExpr);

768

    void setLeftExpr(Expr* leftExpr);

1154

769

1155

/**

770

/**

1156

     * Sets the right side of this AdditiveExpr

771

     * Sets the right side of this BooleanExpr

1157

**/

772

**/

1158

    void setRightExpr(Expr* rightExpr);

773

    void setRightExpr(Expr* rightExpr);

1159

774

1160

775

1161

/**

776

/**

1162

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

777

     * 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

**/

778

**/

1168

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

779

    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);

780

    virtual void toString(String& str);

1179

781

1180

1181

1182

private:

782

private:

1183

    short op;

783

    short op;

1184

    Expr* leftExpr;

784

    Expr* leftExpr;

Lines 1215-1242	Link Here

1215

**/

815

**/

1216

    void setRightExpr(Expr* rightExpr);

816

    void setRightExpr(Expr* rightExpr);

1217

817

1218

1219

/**

818

/**

1220

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

819

     * 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

**/

820

**/

1226

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

821

    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);

822

    virtual void toString(String& str);

1237

823

1238

1239

1240

private:

824

private:

1241

    short op;

825

    short op;

1242

    Expr* leftExpr;

826

    Expr* leftExpr;

Lines 1273-1298	Link Here

1273

     ~RelationalExpr();

857

     ~RelationalExpr();

1274

858

1275

/**

859

/**

1276

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

860

     * 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

**/

861

**/

1282

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

862

    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);

863

    virtual void toString(String& str);

1293

864

1294

1295

1296

private:

865

private:

1297

    short op;

866

    short op;

1298

    Expr* leftExpr;

867

    Expr* leftExpr;

Lines 1320-1341	Link Here

1320

    void setName(const String& name);

889

    void setName(const String& name);

1321

890

1322

/**

891

/**

1323

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

892

     * 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

**/

893

**/

1329

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

894

    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);

895

    virtual void toString(String& str);

1340

896

1341

private:

897

private:

Lines 1346-1352	Link Here

1346

/**

902

/**

1347

 *  Represents a PathExpr

903

 *  Represents a PathExpr

1348

**/

904

**/

1349

class PathExpr : public PatternExpr {

905

class PathExpr : public Expr {

1350

906

1351

public:

907

public:

1352

908

Lines 1361-1426	Link Here

1361

    PathExpr();

917

    PathExpr();

1362

918

1363

/**

919

/**

1364

     * Destructor, will delete all Pattern Expressions

920

     * Destructor, will delete all Expressions

1365

**/

921

**/

1366

    virtual ~PathExpr();

922

    virtual ~PathExpr();

1367

923

1368

/**

924

/**

1369

     * Adds the PatternExpr to this PathExpr

925

     * Adds the Expr to this PathExpr

1370

     * @param expr the Expr to add to this PathExpr

926

     * @param expr the Expr to add to this PathExpr

1371

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

927

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

1372

**/

928

**/

1373

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

929

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

1374

930

1375

/**

931

/**

1376

     * Adds the PatternExpr to this PathExpr

932

     * Adds the Expr to this PathExpr

1377

     * @param expr the Expr to add to this PathExpr

933

     * @param expr the Expr to add to this PathExpr

1378

**/

934

**/

1379

    void addPatternExpr(PatternExpr* expr, short ancestryOp);

935

    void addExpr(Expr* expr, short ancestryOp);

1380

936

1381

    virtual MBool isAbsolute();

937

    virtual MBool isAbsolute();

1382

938

1383

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

1384

     //- Virtual methods from PatternExpr -/

1385

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

1386

1387

/**

939

/**

1388

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

940

     * 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

**/

941

**/

1394

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

942

    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);

943

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

1409

944

    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);

945

    virtual void toString(String& dest);

1419

946

1420

private:

947

private:

1421

948

1422

    struct PathExprItem {

949

    struct PathExprItem {

1423

        PatternExpr* pExpr;

950

        Expr* expr;

1424

        short ancestryOp;

951

        short ancestryOp;

1425

};

952

};

1426

953

Lines 1428-1440	Link Here

1428

955

1429

/**

956

/**

1430

    * Selects from the descendants of the context node

957

    * Selects from the descendants of the context node

1431

    * all nodes that match the PatternExpr

958

    * all nodes that match the Expr

1432

    * -- this will be moving to a Utility class

959

    * -- this will be moving to a Utility class

1433

**/

960

**/

1434

   void evalDescendants(PatternExpr* pExpr,

961

   void evalDescendants(Expr* expr,

1435

                        Node* context,

962

                        Node* context,

1436

                        ContextState* cs,

963

                        ContextState* cs,

1437

                        NodeSet* nodes);

964

                        NodeSet* resNodes);

1438

965

1439

}; //-- PathExpr

966

}; //-- PathExpr

1440

967

Lines 1450-1496	Link Here

1450

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

977

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

1451

978

1452

/**

979

/**

1453

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

980

     * 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

**/

981

**/

1459

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

982

    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);

983

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

1476

984

    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);

985

    virtual void toString(String& dest);

1486

986

987

    virtual MBool isAbsolute();

988

1487

989

1488

}; //-- RootExpr

990

}; //-- RootExpr

1489

991

1490

/**

992

/**

1491

 *  Represents a UnionExpr

993

 *  Represents a UnionExpr

1492

**/

994

**/

1493

class UnionExpr : public PatternExpr {

995

class UnionExpr : public Expr {

1494

996

1495

public:

997

public:

1496

998

Lines 1508-1556	Link Here

1508

     * Adds the PathExpr to this UnionExpr

1010

     * Adds the PathExpr to this UnionExpr

1509

     * @param expr the Expr to add to this UnionExpr

1011

     * @param expr the Expr to add to this UnionExpr

1510

**/

1012

**/

1511

    void addPathExpr(PathExpr* expr);

1013

    void addExpr(Expr* expr);

1512

1014

1513

/**

1015

/**

1514

     * Adds the PathExpr to this UnionExpr at the specified index

1016

     * Adds the PathExpr to this UnionExpr at the specified index

1515

     * @param expr the Expr to add to this UnionExpr

1017

     * @param expr the Expr to add to this UnionExpr

1516

**/

1018

**/

1517

    void addPathExpr(int index, PathExpr* expr);

1019

    void addExpr(int index, Expr* expr);

1518

1519

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

1520

     //- Virtual methods from PatternExpr -/

1521

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

1522

1020

1523

/**

1021

/**

1524

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

1022

     * 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

**/

1023

**/

1530

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

1024

    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);

1025

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

1545

1026

    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);

1027

    virtual void toString(String& dest);

1555

1028

1556

private:

1029

private:

(-)ExprLexer.cpp (-585 / +370 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 28-41	Link Here

 * Marina Mechtcheriakova, mmarina@mindspring.com

 * Marina Mechtcheriakova, mmarina@mindspring.com

 *   -- 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.14 2001/06/26 14:07:49 peterv%netscape.com Exp $

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

*/

*/

/**

/**

 * Lexical analyzer for XPath expressions

 * Lexical analyzer for XPath expressions

 * @author <a href="mailto:kvisco@ziplink.net">Keith Visco</a>

 * @author <a href="mailto:kvisco@ziplink.net">Keith Visco</a>

 * @version $Revision: 1.14 $ $Date: 2001/06/26 14:07:49 $

 * @version $Revision: 1.13 $ $Date: 2001/05/12 11:59:44 $

**/

**/

#include "ExprLexer.h"

#include "ExprLexer.h"

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

  else

192

    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

225

Token* ExprLexer::lookAhead(int offset) {

226

    Token* token = 0;

227

    TokenListItem* tlItem = currentItem;

228

    //-- advance to proper offset

229

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

230

        if ( tlItem ) tlItem = currentItem->next;

231

232

    if (tlItem) token = tlItem->token;

233

    return token;

234

} //-- lookAhead

235

201

236

void ExprLexer::addToken(Token* token) {

202

void ExprLexer::addToken(Token* token)

237

    TokenListItem* tlItem = new TokenListItem;

203

238

    tlItem->token = token;

204

  TokenListItem* tlItem = new TokenListItem;

239

    tlItem->next  = 0;

205

  tlItem->token = token;

240

    if (lastItem) {

206

  tlItem->next  = 0;

241

        tlItem->previous = lastItem;

207

  if (lastItem) {

242

        lastItem->next = tlItem;

208

    tlItem->previous = lastItem;

243

209

    lastItem->next = tlItem;

244

    if (!firstItem) firstItem = tlItem;

210

245

    lastItem = tlItem;

211

  if (!firstItem)

246

    prevToken = token;

212

    firstItem = tlItem;

247

    ++tokenCount;

213

  lastItem = tlItem;

214

  prevToken = token;

215

  ++tokenCount;

248

} //-- addToken

216

} //-- addToken

249

217

250

/**

218

/**

251

 * Returns true if the given character represents an Alpha letter

219

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

252

**/

220

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

253

MBool ExprLexer::isAlphaChar(PRInt32 ch) {

221

 *  Lexical Structure

254

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

222

**/

255

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

223

MBool ExprLexer::nextIsOperatorToken(Token* token)

224

225

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

256

    return MB_FALSE;

226

    return MB_FALSE;

257

} //-- isAlphaChar

227

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

258

228

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

259

/**

229

      token->type <= Token::UNION_OP)

260

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

261

**/

262

MBool ExprLexer::isDigit(PRInt32 ch) {

263

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

264

    return MB_FALSE;

230

    return MB_FALSE;

265

} //-- isDigit

231

  return MB_TRUE;

232

} //-- nextIsOperatorToken

266

233

267

/**

234

/**

268

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

235

 *  Parses the given String into the set of Tokens

269

**/

270

MBool ExprLexer::isNCNameChar(PRInt32 ch) {

271

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

272

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

273

} //-- isNCNameChar

274

275

/**

276

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

277

**/

278

MBool ExprLexer::isQNameChar(PRInt32 ch) {

279

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

280

} //-- isQNameChar

281

282

/**

283

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

284

**/

236

**/

285

MBool ExprLexer::isValidQName(String& name) {

237

void ExprLexer::parse(const String& pattern)

286

238

287

    int size = name.length();

239

  String tokenBuffer;

288

    if ( size == 0 ) return MB_FALSE;

240

  PRInt32 iter = 0, start;

289

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

241

  PRInt32 size = pattern.length();

290

    else {

242

  short defType;

291

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

243

  UNICODE_CHAR ch;

292

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

244

  if (size==0)

245

    return;

246

247

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

248

  //-- deleted when it goes out of scope

249

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

250

251

  prevToken = &nullToken;

252

253

  while (iter < size) {

254

255

    ch = pattern.charAt(iter);

256

    defType = Token::CNAME;

257

258

    if (ch==DOLLAR_SIGN) {

259

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

260

        // Error, VariableReference expected

261

        errorPos = iter;

262

        errorCode = ERROR_UNRESOLVED_VAR_REFERENCE;

263

        if (firstItem)

264

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

265

        else

266

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

267

        iter=size; // bail

268

269

      else

270

        defType = Token::VAR_REFERENCE;

271

272

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

273

    // the token to construct

274

275

    if (isLetter(ch)) {

276

      // NCName, can get QName or OperatorName;

277

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

278

      //  and are dealt with below

279

      start = iter;

280

      while (++iter < size &&

281

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

282

      PRInt32 end = iter;

283

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

284

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

285

        if (++iter < size)

286

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

287

            while (++iter < size &&

288

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

289

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

290

                   && defType != Token::VAR_REFERENCE)

291

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

292

          else

293

            iter--; // step back

294

295

      if (nextIsOperatorToken(prevToken)) {

296

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

297

          defType = Token::AND_OP;

298

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

299

          defType = Token::OR_OP;

300

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

301

          defType = Token::MODULUS_OP;

302

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

303

          defType = Token::DIVIDE_OP;

304

        else {

305

          // Error "operator expected"

306

          // XXX QUESTION: spec is not too precise

307

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

308

          errorPos = iter;

309

          errorCode = ERROR_OP_EXPECTED;

310

          if (firstItem)

311

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

312

          else

313

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

314

          iter=size; // bail

293

315

316

317

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

294

318

295

    return MB_TRUE;

319

    else if (isDigit(ch)) {

296

} //-- isValidQName

320

      start = iter;

297

321

      while (++iter < size &&

298

MBool ExprLexer::isOperatorToken(Token* token) {

322

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

299

    if ( !token ) return MB_FALSE;

323

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

300

    switch ( token->type ) {

324

        while (++iter < size &&

301

        //-- boolean operators

325

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

302

        case Token::AND_OP:

326

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

303

        case Token::OR_OP:

304

        //-- relational operators

305

        case Token::EQUAL_OP:

306

        case Token::NOT_EQUAL_OP:

307

        case Token::LESS_THAN_OP:

308

        case Token::GREATER_THAN_OP:

309

        case Token::LESS_OR_EQUAL_OP:

310

        case Token::GREATER_OR_EQUAL_OP:

311

        //-- additive operators

312

        case Token::ADDITION_OP:

313

        case Token::SUBTRACTION_OP:

314

        //-- multiplicative operators

315

        case Token::DIVIDE_OP:

316

        case Token::MODULUS_OP:

317

        case Token::MULTIPLY_OP:

318

            return MB_TRUE;

319

        default:

320

            break;

321

322

323

    return MB_FALSE;

324

} //-- isOperatorToken

325

326

MBool ExprLexer::matchDelimiter(UNICODE_CHAR ch) {

327

328

    short tokenType = 0;

329

    MBool addChar = MB_TRUE;

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

327

380

    Token* token = 0;

328

    else {

381

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

329

      switch (ch) {

382

    else token = new Token(tokenType);

330

        //-- ignore whitespace

383

331

      case SPACE:

384

    addToken(token);

332

      case TX_TAB:

385

    return MB_TRUE;

333

      case TX_CR:

386

} //-- matchDelimiter

334

      case TX_LF:

387

335

        ++iter;

388

/**

336

        break;

389

 * Returns true if the value of the given String matches

337

      case S_QUOTE :

390

 * an OperatorName

338

      case D_QUOTE :

391

**/

339

        start=iter;

392

MBool ExprLexer::matchesOperator(String& buffer) {

340

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

393

341

        if (iter==NOT_FOUND) {

394

    int index = 0;

342

          // XXX Error reporting "unclosed literal"

395

    while (index < NUMBER_OF_TOKENS) {

343

          errorPos = start;

396

        Token tok = TOKENS[index++];

344

          errorCode = ERROR_UNCLOSED_LITERAL;

397

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

345

          if (firstItem)

398

            if (isOperatorToken( &tok )) return MB_TRUE;

346

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

347

          else

348

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

349

          iter=size; // bail

399

350

400

351

        else {

401

    return MB_FALSE;

352

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

402

353

                             Token::LITERAL));

403

} //-- matchesOperator

354

          ++iter;

404

355

405

/**

356

        break;

406

 * Matches the given String to the appropriate Token

357

      case PERIOD:

407

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

358

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

408

 * @param ch, the current delimiter token

359

        if (++iter < size) {

409

**/

360

          ch=pattern.charAt(iter);

410

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

361

          if (isDigit(ch)) {

411

362

            start=iter-1;

412

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

363

            while (++iter < size &&

413

364

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

414

    Token* match = new Token();

365

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

415

    MBool foundMatch = MB_FALSE;

366

                               Token::NUMBER));

416

    int index = 0;

367

417

368

          else if (ch==PERIOD) {

418

    //-- check previous token

369

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

419

    switch(prevToken->type) {

370

                               Token::PARENT_NODE));

420

        case Token::VAR_REFERENCE :

371

421

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

372

          else

422

                prevToken->value.append(buffer);

373

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

423

                buffer.clear();

424

                return;

425

426

            break;

427

        default:

428

            break;

429

430

431

    //-- look for next match

432

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

433

434

        Token tok = TOKENS[index++];

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

    PRInt32 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

533

        else if ( inNumber ) {

534

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

535

                tokenBuffer.append(ch);

536

537

            else {

538

                inNumber = MB_FALSE;

539

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

540

                tokenBuffer.clear();

541

                //-- push back last char

542

                --currentPos;

543

544

545

        else if (isDigit(ch)) {

546

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

547

                //-- match operator and free up token buffer

548

                matchToken(tokenBuffer, ch);

549

                inNumber = MB_TRUE;

550

551

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

552

                inNumber = MB_TRUE;

553

554

            tokenBuffer.append(ch);

555

374

375

        else

376

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

377

        // iter++ is already in the number test

378

379

        break;

380

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

381

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

382

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

383

          prevToken->type = Token::AXIS_IDENTIFIER;

384

          ++iter;

385

556

        else {

386

        else {

557

            switch (ch) {

387

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

558

                //-- ignore whitespace

388

          errorPos = iter;

559

                case SPACE:

389

          errorCode = ERROR_COLON;

560

                case TX_TAB:

390

          if (firstItem)

561

                case TX_CR:

391

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

562

                case TX_LF:

392

          else

563

                    break;

393

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

564

                case S_QUOTE :

394

          iter=size; // bail

565

                case D_QUOTE :

566

                    matchToken(tokenBuffer, ch);

567

                    inLiteral = ch;

568

                    break;

569

                case PERIOD:

570

                    if ( inNumber ) tokenBuffer.append(ch);

571

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

572

                        prevToken->type = Token::PARENT_NODE;

573

574

                    else if ( tokenBuffer.length() > 0 )

575

                        tokenBuffer.append(ch);

576

                    else matchDelimiter(ch);

577

                    break;

578

                case COLON:

579

                    if ( prevCh == ch) {

580

                        PRInt32 bufSize = tokenBuffer.length();

581

                        tokenBuffer.setLength(bufSize-1);

582

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

583

                        tokenBuffer.clear();

584

585

                    else tokenBuffer.append(ch);

586

                    break;

587

                case FORWARD_SLASH :

588

                    matchToken(tokenBuffer, ch);

589

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

590

                        prevToken->type = Token::ANCESTOR_OP;

591

                        prevToken->value.append(ch);

592

593

                    //-- handle possible error in using /

594

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

595

                        prevToken->type = Token::ERROR;

596

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

597

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

395

714

        ++currentPos;

396

        break;

715

397

      case FORWARD_SLASH :

716

    //-- end lexical parsing of current token

398

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

717

    //-- freeBuffer if needed

399

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

718

400

                             Token::ANCESTOR_OP));

719

    if ( inNumber ) {

401

720

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

402

        else {

403

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

404

405

        break;

406

      case BANG : // can only be !=

407

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

408

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

409

                             Token::NOT_EQUAL_OP));

410

411

        else {

412

          // Error ! is not not()

413

          errorPos = iter;

414

          errorCode = ERROR_BANG;

415

          if (firstItem)

416

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

417

          else

418

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

419

          iter=size; // bail

420

421

        break;

422

      case EQUAL:

423

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

424

        ++iter;

425

        break;

426

      case L_ANGLE:

427

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

428

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

429

                             Token::LESS_OR_EQUAL_OP));

430

431

        else

432

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

433

        break;

434

      case R_ANGLE:

435

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

436

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

437

                             Token::GREATER_OR_EQUAL_OP));

438

439

        else

440

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

441

        break;

442

      case HYPHEN :

443

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

444

        ++iter;

445

        break;

446

      case ASTERIX:

447

        if (nextIsOperatorToken(prevToken))

448

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

449

        else

450

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

451

        ++iter;

452

        break;

453

      case L_PAREN:

454

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

455

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

456

            prevToken->type = Token::COMMENT;

457

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

458

            prevToken->type = Token::NODE;

459

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

460

            prevToken->type = Token::PROC_INST;

461

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

462

            prevToken->type = Token::TEXT;

463

          else

464

            prevToken->type = Token::FUNCTION_NAME;

465

466

        ++iter;

467

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

468

        break;

469

      case R_PAREN:

470

        ++iter;

471

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

472

        break;

473

      case L_BRACKET:

474

        ++iter;

475

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

476

        break;

477

      case R_BRACKET:

478

        ++iter;

479

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

480

        break;

481

      case COMMA:

482

        ++iter;

483

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

484

        break;

485

      case AT_SIGN :

486

        ++iter;

487

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

488

        break;

489

      case PLUS:

490

        ++iter;

491

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

492

        break;

493

      case VERT_BAR:

494

        ++iter;

495

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

496

        break;

497

      default:

498

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

499

        errorPos = iter;

500

        errorCode = ERROR_UNKNOWN_CHAR;

501

        if (firstItem)

502

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

503

        else

504

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

505

        iter=size; // bail

506

721

507

722

    else matchToken(tokenBuffer, ch);

508

723

    prevToken = 0;

724

} //-- parse

509

} //-- parse

725

510





/* -*- 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.8 2001/06/26 14:07:54 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.8 $ $Date: 2001/06/26 14:07:54 $
**/
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[];
    PRInt32 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(PRInt32 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: 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

 *   -- fixed bug in ::parsePredicates,
 *      made sure we continue looking for more predicates.
 *
 * $Id: ExprParser.cpp,v 1.12 2001/06/20 06:00:32 margaret.chan%sun.com Exp $
 */

/**

 * This class is used to parse XSL Expressions
 * @author <A HREF="mailto:kvisco@ziplink.net">Keith Visco</A>
 * @see ExprLexer
 * @version $Revision: 1.12 $ $Date: 2001/06/20 06:00:32 $
**/

#include "ExprParser.h"
#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();

    PRInt32 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 if (prevCh == ch) {
                    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) {

 * Creates a binary Expr for the given operator
**/
Expr* ExprParser::createBinaryExpr   (Expr* left, Expr* right, Token* op) {
    if (!op)
        return 0;
    switch (op->type) {

        //-- additive ops
        case Token::ADDITION_OP :
            return new AdditiveExpr(left, right, AdditiveExpr::ADDITION);

} //-- 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) {
        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;

    //-- compare function names
    //-- * we should hash these names for speed

    if (XPathNames::BOOLEAN_FN.isEqual(tok->value)) {
        fnCall = new BooleanFunctionCall(BooleanFunctionCall::TX_BOOLEAN);
    }
    else if (XPathNames::CONCAT_FN.isEqual(tok->value)) {
        fnCall = new StringFunctionCall(StringFunctionCall::CONCAT);
    }
    else if (XPathNames::CONTAINS_FN.isEqual(tok->value)) {
        fnCall = new StringFunctionCall(StringFunctionCall::CONTAINS);
    }
    else if (XPathNames::COUNT_FN.isEqual(tok->value)) {
        fnCall = new NodeSetFunctionCall(NodeSetFunctionCall::COUNT);
    }
    else if (XPathNames::FALSE_FN.isEqual(tok->value)) {
        fnCall = new BooleanFunctionCall();
    }
    else if (XPathNames::ID_FN.isEqual(tok->value)) {
        fnCall = new NodeSetFunctionCall(NodeSetFunctionCall::ID);
    }
    else if (XPathNames::LANG_FN.isEqual(tok->value)) {
        fnCall = new BooleanFunctionCall(BooleanFunctionCall::TX_LANG);
    }
    else if (XPathNames::LAST_FN.isEqual(tok->value)) {
        fnCall = new NodeSetFunctionCall(NodeSetFunctionCall::LAST);
    }
    else if (XPathNames::LOCAL_NAME_FN.isEqual(tok->value)) {
        fnCall = new NodeSetFunctionCall(NodeSetFunctionCall::LOCAL_NAME);
    }
    else if (XPathNames::NAME_FN.isEqual(tok->value)) {
        fnCall = new NodeSetFunctionCall(NodeSetFunctionCall::NAME);
    }
    else if (XPathNames::NAMESPACE_URI_FN.isEqual(tok->value)) {
        fnCall = new NodeSetFunctionCall(NodeSetFunctionCall::NAMESPACE_URI);
    }
    else if (XPathNames::NORMALIZE_SPACE_FN.isEqual(tok->value)) {
        fnCall = new StringFunctionCall(StringFunctionCall::NORMALIZE_SPACE);
    }
    else if (XPathNames::NOT_FN.isEqual(tok->value)) {
        fnCall = new BooleanFunctionCall(BooleanFunctionCall::TX_NOT);
    }
    else if (XPathNames::POSITION_FN.isEqual(tok->value)) {
        fnCall = new NodeSetFunctionCall(NodeSetFunctionCall::POSITION);
    }
    else if (XPathNames::STARTS_WITH_FN.isEqual(tok->value)) {
        fnCall = new StringFunctionCall(StringFunctionCall::STARTS_WITH);
    }
    else if (XPathNames::STRING_FN.isEqual(tok->value)) {
        fnCall = new StringFunctionCall(StringFunctionCall::STRING);
    }
    else if (XPathNames::STRING_LENGTH_FN.isEqual(tok->value)) {
        fnCall = new StringFunctionCall(StringFunctionCall::STRING_LENGTH);
    }
    else if (XPathNames::SUBSTRING_FN.isEqual(tok->value)) {
        fnCall = new StringFunctionCall(StringFunctionCall::SUBSTRING);
    }
    else if (XPathNames::SUBSTRING_AFTER_FN.isEqual(tok->value)) {
        fnCall = new StringFunctionCall(StringFunctionCall::SUBSTRING_AFTER);
    }
    else if (XPathNames::SUBSTRING_BEFORE_FN.isEqual(tok->value)) {
        fnCall = new StringFunctionCall(StringFunctionCall::SUBSTRING_BEFORE);
    }
    else if (XPathNames::SUM_FN.isEqual(tok->value)) {
        fnCall = new NumberFunctionCall(NumberFunctionCall::SUM);
    }
    else if (XPathNames::TRANSLATE_FN.isEqual(tok->value)) {
        fnCall = new StringFunctionCall(StringFunctionCall::TRANSLATE);
    }
    else if (XPathNames::TRUE_FN.isEqual(tok->value)) {
        fnCall = new BooleanFunctionCall(BooleanFunctionCall::TX_TRUE);
    }
    else if (XPathNames::NUMBER_FN.isEqual(tok->value)) {
    else if ( XPathNames::NUMBER_FN.isEqual(tok->value) ) {
        fnCall = new NumberFunctionCall(NumberFunctionCall::NUMBER);
    }
    else if (XPathNames::ROUND_FN.isEqual(tok->value)) {
        fnCall = new NumberFunctionCall(NumberFunctionCall::ROUND);
    }
    else if (XPathNames::CEILING_FN.isEqual(tok->value)) {
        fnCall = new NumberFunctionCall(NumberFunctionCall::CEILING);
    }
    else if (XPathNames::FLOOR_FN.isEqual(tok->value)) {
        fnCall = new NumberFunctionCall(NumberFunctionCall::FLOOR);
    }
    // OG-
    else {
        //-- Most likely an Extension Function, or error, but it's
        //-- 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:

            //-- eat token
            lexer.nextToken();
            //-- should switch to a hash here for speed if necessary
            if (ANCESTOR_AXIS.isEqual(tok->value)) {
                axisIdentifier = LocationStep::ANCESTOR_AXIS;
            }
            else if (ANCESTOR_OR_SELF_AXIS.isEqual(tok->value)) {
                axisIdentifier = LocationStep::ANCESTOR_OR_SELF_AXIS;
            }
            else if (ATTRIBUTE_AXIS.isEqual(tok->value)) {
                axisIdentifier = LocationStep::ATTRIBUTE_AXIS;
            }
            else if (CHILD_AXIS.isEqual(tok->value)) {
                axisIdentifier = LocationStep::CHILD_AXIS;
            }
            else if (DESCENDANT_AXIS.isEqual(tok->value)) {
                axisIdentifier = LocationStep::DESCENDANT_AXIS;
            }
            else if (DESCENDANT_OR_SELF_AXIS.isEqual(tok->value)) {
                axisIdentifier = LocationStep::DESCENDANT_OR_SELF_AXIS;
            }
            else if (FOLLOWING_AXIS.isEqual(tok->value)) {
                axisIdentifier = LocationStep::FOLLOWING_AXIS;
            }
            else if (FOLLOWING_SIBLING_AXIS.isEqual(tok->value)) {
                axisIdentifier = LocationStep::FOLLOWING_SIBLING_AXIS;
            }
            else if (NAMESPACE_AXIS.isEqual(tok->value)) {
                axisIdentifier = LocationStep::NAMESPACE_AXIS;
            }
            else if (PARENT_AXIS.isEqual(tok->value)) {
                axisIdentifier = LocationStep::PARENT_AXIS;
            }
            else if (PRECEDING_AXIS.isEqual(tok->value)) {
                axisIdentifier = LocationStep::PRECEDING_AXIS;
            }
            else if (PRECEDING_SIBLING_AXIS.isEqual(tok->value)) {
                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;
            }
            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;
    }

    lstep->setAxisIdentifier(axisIdentifier);


    //-- 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;
                }
        }
    }
    
    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) {
#if 0
    // XXX DEBUG OUTPUT
    cout << "creating NodeExpr: "<<endl;
    if (!lexer.hasMoreTokens() ) cout << "Lexer has no Tokens"<<endl;
#endif
    if (!lexer.hasMoreTokens() )  return 0;

    NodeExpr* nodeExpr = 0;

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

    switch (nodeTok->type) {

    switch ( tok->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;

        // 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) {
        }
        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 {
#if 0
        // XXX DEBUG OUTPUT
        cout << "invalid token: " << tok->value << endl;
#endif
        //-- 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) {
    switch (token->type) {

    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;

    while (lexer.peek()->type == Token::L_BRACKET) {
        //-- eat Token
        lexer.nextToken();
    if ( tok->type != Token::L_BRACKET ) return 0; //-- not start of predicate list

    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;

    Token* tok = lexer.peek();

    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

short ExprParser::precedenceLevel(short tokenType) {
    switch (tokenType) {
        case Token::OR_OP:
            return 1;
        case Token::AND_OP:





/* -*- 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





/* -*- 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

 * Note: The object references in parameters will be deleted when this
 * FunctionCall gets destroyed.
**/
FunctionCall::FunctionCall(const String& name)
{
    //-- copy name
    this->name = name;
} //-- FunctionCall

 * Note: The object references in parameters will be deleted when this
 * FunctionCall gets destroyed.
**/
FunctionCall::FunctionCall(const String& name, List* parameters)
{
    //-- copy name
    this->name = name;

    if (parameters) {
       ListIterator* pIter = parameters->iterator();
       while (pIter->hasNext()) {
           params.add(pIter->next());
       }
       delete pIter;

/**
 * Destructor
**/
FunctionCall::~FunctionCall()
{
    ListIterator* iter = params.iterator();
    while (iter->hasNext()) {
        iter->next();
        Expr* expr = (Expr*) iter->remove();
        delete expr;

 * Adds the given parameter to this FunctionCall's parameter list
 * @param expr the Expr to add to this FunctionCall's parameter list
**/
void FunctionCall::addParam(Expr* expr)
{
    if (expr)
      params.add(expr);
} //-- 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
**/
void FunctionCall::evaluateToString(Expr* expr, Node* context, 
                                    ContextState* cs, String& dest)
{
    if (!expr)
        return;
    ExprResult* exprResult = expr->evaluate(context, cs);
    exprResult->stringValue(dest);
    delete exprResult;

/**
 * Evaluates the given Expression and converts it's result to a number.
**/
double FunctionCall::evaluateToNumber(Expr* expr, Node* context,
                                      ContextState* cs)
{
    double result = Double::NaN;
    if (!expr)
      return result;
    ExprResult* exprResult = expr->evaluate(context, cs);
    result =  exprResult->numberValue();
    delete exprResult;

 * Returns the name of this FunctionCall
 * @return the name of this FunctionCall
**/
const String& FunctionCall::getName()
{
    return (const String&)this->name;
} //-- getName

/**
 * Called to check number of parameters
**/
MBool FunctionCall::requireParams (int paramCountMin,
                                   int paramCountMax,
                                   ContextState* cs)
{

    int argc = params.getLength();
    if ((argc < paramCountMin) || (argc > paramCountMax)) {
        String err(INVALID_PARAM_COUNT);
        toString(err);
        cs->recieveError(err);

/**
 * Called to check number of parameters
**/
MBool FunctionCall::requireParams(int paramCountMin, ContextState* cs)
{
    int argc = params.getLength();
    if (argc < paramCountMin) {
        String err(INVALID_PARAM_COUNT);

 * Sets the function name of this FunctionCall
 * @param name the name of this Function
**/
void FunctionCall::setName(const String& name)
{
    this->name.clear();
    this->name.append(name);
} //-- setName

 * other #toString() methods for Expressions.
 * @return the String representation of this NodeExpr.
**/
void FunctionCall::toString(String& dest)
{
    dest.append(this->name);
    dest.append('(');
    //-- add parameters
    ListIterator* iterator = params.iterator();
    int argc = 0;
    while (iterator->hasNext()) {
        if (argc > 0)
            dest.append(',');
        Expr* expr = (Expr*)iterator->next();
        expr->toString(dest);
        ++argc;

    }
    delete iterator;
    dest.append(')');





        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





/* -*- 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

/**
 * Creates a new PathExpr
**/
PathExpr::PathExpr()
{
    //-- do nothing
}

/**
 * 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);
    }
} //-- addPattenExpr

MBool PathExpr::isAbsolute()
{
    if (expressions.getLength() > 0) {
        ListIterator* iter = expressions.iterator();
        PathExprItem* pxi = (PathExprItem*)iter->next();
        delete iter;

    return MB_FALSE;
} //-- isAbsolute

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

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

 * for evaluation
 * @return the result of the evaluation
**/
ExprResult* PathExpr::evaluate(Node* context, ContextState* cs)
{
    //-- add selectExpr functionality here

    if (!context || (expressions.getLength() == 0))
            return new NodeSet(0);

    NodeSet* nodes = new NodeSet();

    if (isAbsolute() && (context->getNodeType() != Node::DOCUMENT_NODE))
        nodes->add(context->getOwnerDocument());
    else
        nodes->add(context);


    ListIterator* iter = expressions.iterator();

    while ( iter->hasNext() ) {

    while (iter->hasNext()) {
        PathExprItem* pxi = (PathExprItem*)iter->next();
        NodeSet* tmpNodes = 0;
        cs->getNodeSetStack()->push(nodes);

            Node* node = nodes->get(i);
            
            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;
                    res = new NodeSet;
                }

                resNodes = (NodeSet*)res;
            }

            if (tmpNodes) {
                resNodes->copyInto(*tmpNodes);
                delete resNodes;
            }

        }
        delete (NodeSet*) cs->getNodeSetStack()->pop();
        nodes = tmpNodes;
        if (!nodes || (nodes->size() == 0)) break;
    }
    delete iter;



/**
 * 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
    }
    else

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

 * If this pattern does not match the given Node under the current context Node and
 * ContextState then Negative Infinity is returned.
**/
double PathExpr::getDefaultPriority(Node* node, Node* context,
                                    ContextState* cs)
{
    if (matches(node, context, cs)) {
        int size = expressions.getLength();
        if (size == 1) {
            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;
        }
    }
    return Double::NEGATIVE_INFINITY;
} //-- getDefaultPriority

/**
 * Determines whether this Expr matches the given node within
 * the given context
**/
MBool PathExpr::matches(Node* node, Node* context, ContextState* cs)
{
    if (!node || (expressions.getLength() == 0))
    if ( (!node)  || (expressions.getLength() == 0))
       return MB_FALSE;

    //-- for performance reasons, I've duplicated some code

            {
                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);

        }

        return MB_FALSE;
    }


    //-- if we reach here we have subpaths...

    NodeSet nodes(3);
    NodeSet tmpNodes(3);

    nodes.add(node);


    ListIterator* iter = expressions.iterator();
    iter->reverse();

    while (iter->hasNext()) {

        PathExprItem* pxi = (PathExprItem*)iter->next();

        for (int i = 0; i < nodes.size(); i++) {

            Node* tnode = nodes.get(i);

            //-- select node's parent or ancestors
            switch (pxi->ancestryOp) {
                case ANCESTOR_OP:
                {
                    Node* parent = tnode;
                    while (parent = cs->getParentNode(parent))  {
                        if (pxi->expr->matches(tnode, parent, cs))
                            tmpNodes.add(parent);
                    }
                    break;

                {
                    Node* parent = cs->getParentNode(tnode);
                    if (parent) {

                        //-- make sure we have a document node if necessary
                        if (!iter->hasNext())
                            if (parent->getNodeType() != Node::DOCUMENT_NODE)
                                break;
                        if (pxi->expr->matches(tnode, parent, cs))
                            tmpNodes.add(parent);
                    }
                    break;
                }
                default:
                    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;
                        }

            doc = node;
        else
            doc = node->getOwnerDocument();
        return (MBool)nodes.contains(doc);
    }

    return (MBool)(nodes.size() > 0);

} //-- matches


/**
 * 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();
    while (iter->hasNext()) {
        //-- set operator
        PathExprItem* pxi = (PathExprItem*)iter->next();
        switch (pxi->ancestryOp) {
            case ANCESTOR_OP:
                dest.append("//");
                break;

            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





**/
UnionExpr::~UnionExpr() {
    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

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

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

/**

**/
ExprResult* UnionExpr::evaluate(Node* context, ContextState* cs) {

    if (!context || (expressions.getLength() == 0))
            return new NodeSet(0);

    NodeSet* nodes = new NodeSet();

    ListIterator* iter = expressions.iterator();

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

    delete iter;

 * If this pattern does not match the given Node under the current context Node and
 * ContextState then Negative Infinity is returned.
**/
double UnionExpr::getDefaultPriority(Node* node, Node* context,
				     ContextState* cs) {
    //-- find highest priority
    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;
        }
    }
    delete iter;
    return priority;

} //-- getDefaultPriority

/**


    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();

    short count = 0;
    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 195-202	Link Here

195

        namedTemplates.put(name,mObj);

195

        namedTemplates.put(name,mObj);

196

        if ( oldObj ) delete oldObj;

196

        if ( oldObj ) delete oldObj;

197

198

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

198

    if (match.length() > 0) {

199

    templates.add(xslTemplate);

199

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

200

        templates.add(xslTemplate);

201

200

} //-- addTempalte

202

} //-- addTempalte

201

203

202

/**

204

/**

Return to bug 75102