Attachment #30266 for bug #75102

Attachment #30266: parser, lexer, + stuff needed, needs following extra files for bug #75102

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





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

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

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





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

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

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





  ../xpath/BooleanResult.o \
  ../xpath/ElementExpr.o \
  ../xpath/ErrorFunctionCall.o \
  ../xpath/Expr.o \
  ../xpath/ExprLexer.o \
  ../xpath/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)/ExprParser.obj \
  ../xpath/$(OBJDIR)/ExtensionFunctionCall.obj \
  ../xpath/$(OBJDIR)/FilterExpr.obj \
  ../xpath/$(OBJDIR)/FunctionCall.obj \
  ../xpath/$(OBJDIR)/IdentityExpr.obj \
  ../xpath/$(OBJDIR)/LocationStep.obj \
  ../xpath/$(OBJDIR)/MultiplicativeExpr.obj \
  ../xpath/$(OBJDIR)/NodeSet.obj \

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

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





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

/**

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

/**

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

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

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

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

    return nodeSet;
} //-- evaluate

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

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


        case NodeExpr::COMMENT_EXPR:
            return (MBool) (node->getNodeType() == Node::COMMENT_NODE);
        case NodeExpr::PI_EXPR :
            return (MBool) (node->getNodeType() == Node::PROCESSING_INSTRUCTION_NODE &&
                            !nodeNameSet || nodeName.isEqual(node->getNodeName()));
        default: //-- node()
            //XXX WhiteSpace: filter whitespace nodes properly
            return (MBool) !(node->getNodeType() == Node::TEXT_NODE &&
                             node->getParentNode() == node->getOwnerDocument());
            break;
    }
    return MB_TRUE;

            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 (-278 / +178 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.10 2001/04/08 14:33:45 peterv%netscape.com Exp $

 * $Id: Expr.h,v 1.10 2001/04/08 14:33:45 peterv%netscape.com Exp $

*/

*/

Lines 52-57	Link Here

//necessary prototypes

//necessary prototypes

class FunctionCall;

class FunctionCall;

typedef class Expr Pattern;

typedef class Expr PatternExpr;

/**

/**

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

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

**/

**/

Lines 115-121	Link Here

115

/**

122

/**

116

     * Virtual destructor, important for subclasses

123

     * Virtual destructor, important for subclasses

117

**/

124

**/

118

    virtual ~Expr() {};

125

    virtual ~Expr();

119

126

120

/**

127

/**

121

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

128

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

Lines 127-132	Link Here

127

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

134

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

128

135

129

/**

136

/**

137

     * Determines whether this Expr matches the given node within

138

     * the given context

139

**/

140

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

141

142

/**

143

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

144

     * context Node, and ContextState.

145

**/

146

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

147

148

/**

130

     * Returns the String representation of this Expr.

149

     * Returns the String representation of this Expr.

131

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

150

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

132

     * representation. The String representation will be appended to

151

     * representation. The String representation will be appended to

Lines 138-144	Link Here

138

157

139

}; //-- Expr

158

}; //-- Expr

140

159

141

142

/**

160

/**

143

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

161

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

144

 * Recommendation.

162

 * Recommendation.

Lines 168-173	Link Here

168

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

186

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

169

187

170

/**

188

/**

189

     * Determines whether this FunctionCall matches the given node within

190

     * the given context

191

**/

192

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

193

194

/**

195

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

196

     * context Node, and ContextState.

197

**/

198

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

199

200

/**

171

     * Returns the name of this FunctionCall

201

     * Returns the name of this FunctionCall

172

     * @return the name of this FunctionCall

202

     * @return the name of this FunctionCall

173

**/

203

**/

Lines 185-196	Link Here

185

**/

215

**/

186

    void setName(const String& name);

216

    void setName(const String& name);

187

/**

217

/**

188

     * Returns the String representation of this Pattern.

218

     * Returns the String representation of this Expr.

189

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

219

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

190

     * representation. The String representation will be appended to

220

     * representation. The String representation will be appended to

191

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

221

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

192

     * other #toString() methods for Expressions.

222

     * other #toString() methods for Expressions.

193

     * @return the String representation of this Pattern.

223

     * @return the String representation of this Expr.

194

**/

224

**/

195

    virtual void toString(String& dest);

225

    virtual void toString(String& dest);

196

226

Lines 221-317	Link Here

221

    String name;

251

    String name;

222

}; //-- FunctionCall

252

}; //-- FunctionCall

223

253

224

/**

225

 * A base Pattern class

226

**/

227

class Pattern {

228

229

public:

230

231

/**

232

     * Virtual destructor, important for subclasses

233

**/

234

    virtual ~Pattern() {};

235

236

/**

237

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

238

     * context Node, and ContextState.

239

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

240

     * ContextState then Negative Infinity is returned.

241

**/

242

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

243

244

/**

245

     * Determines whether this Pattern matches the given node within

246

     * the given context

247

**/

248

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

249

250

251

/**

252

     * Returns the String representation of this Pattern.

253

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

254

     * representation. The String representation will be appended to

255

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

256

     * other #toString() methods for Expressions.

257

     * @return the String representation of this Pattern.

258

**/

259

    virtual void toString(String& dest) = 0;

260

261

}; //-- Pattern

262

254

263

264

/**

255

/**

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

256

 * Represents an AttributeValueTemplate

316

**/

257

**/

317

class AttributeValueTemplate: public Expr {

258

class AttributeValueTemplate: public Expr {

Lines 355-361	Link Here

355

 * This class represents a NodeTestExpr as defined by the XSL

296

 * This class represents a NodeTestExpr as defined by the XSL

356

 * Working Draft

297

 * Working Draft

357

**/

298

**/

358

class NodeExpr : public PatternExpr {

299

class NodeExpr : public Expr {

359

300

360

public:

301

public:

361

302

Lines 379-392	Link Here

379

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

320

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

380

321

381

/**

322

/**

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

323

     * Returns the type of this NodeExpr

391

     * @return the type of this NodeExpr

324

     * @return the type of this NodeExpr

392

**/

325

**/

Lines 399-410	Link Here

399

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

332

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

400

333

401

/**

334

/**

402

     * Returns the String representation of this Pattern.

335

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

336

     * context Node, and ContextState.

337

**/

338

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

339

340

/**

341

     * Returns the String representation of this Expr.

403

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

342

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

404

     * representation. The String representation will be appended to

343

     * representation. The String representation will be appended to

405

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

344

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

406

     * other #toString() methods for Expressions.

345

     * other #toString() methods for Expressions.

407

     * @return the String representation of this Pattern.

346

     * @return the String representation of this Expr.

408

**/

347

**/

409

    virtual void toString(String& dest) = 0;

348

    virtual void toString(String& dest) = 0;

410

349

Lines 445-458	Link Here

445

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

384

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

446

385

447

/**

386

/**

448

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

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

387

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

457

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

388

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

458

     * @param ps the ContextState containing the stack information needed

389

     * @param ps the ContextState containing the stack information needed

Lines 474-479	Link Here

474

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

405

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

475

406

476

/**

407

/**

408

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

409

     * context Node, and ContextState.

410

**/

411

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

412

413

/**

477

     * Returns the String representation of this NodeExpr.

414

     * Returns the String representation of this NodeExpr.

478

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

415

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

479

     * representation. The String representation will be appended to

416

     * representation. The String representation will be appended to

Lines 521-540	Link Here

521

     * Destroys this BasicNodeExpr

458

     * Destroys this BasicNodeExpr

522

**/

459

**/

523

    virtual ~BasicNodeExpr();

460

    virtual ~BasicNodeExpr();

461

462

/**

463

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

464

**/

465

    void setNodeName(const String& name);

524

466

525

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

467

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

526

   //- Method signatures from NodeExpr -/

468

   //- Method signatures from NodeExpr -/

527

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

469

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

528

470

529

/**

471

/**

530

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

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

**/

535

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

536

537

/**

538

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

472

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

539

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

473

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

540

     * @param ps the ContextState containing the stack information needed

474

     * @param ps the ContextState containing the stack information needed

Lines 556-561	Link Here

556

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

490

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

557

491

558

/**

492

/**

493

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

494

     * context Node, and ContextState.

495

**/

496

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

497

498

/**

559

     * Returns the String representation of this NodeExpr.

499

     * Returns the String representation of this NodeExpr.

560

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

500

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

561

     * representation. The String representation will be appended to

501

     * representation. The String representation will be appended to

Lines 567-572	Link Here

567

507

568

private:

508

private:

569

    NodeExprType type;

509

    NodeExprType type;

510

    String nodeName;

511

    MBool nodeNameSet;

570

}; //-- BasicNodeExpr

512

}; //-- BasicNodeExpr

571

513

572

/**

514

/**

Lines 611-620	Link Here

611

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

553

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

612

554

613

/**

555

/**

614

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

556

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

615

     * context Node, and ContextState.

557

     * 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

**/

558

**/

619

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

559

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

620

560

Lines 655-727	Link Here

655

}; //-- ElementExpr

595

}; //-- ElementExpr

656

596

657

/**

597

/**

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

598

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

726

**/

599

**/

727

class TextExpr : public NodeExpr {

600

class TextExpr : public NodeExpr {

Lines 742-755	Link Here

742

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

615

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

743

616

744

/**

617

/**

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

618

     * Returns the type of this NodeExpr

754

     * @return the type of this NodeExpr

619

     * @return the type of this NodeExpr

755

**/

620

**/

Lines 761-766	Link Here

761

**/

626

**/

762

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

627

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

763

628

629

/**

630

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

631

     * context Node, and ContextState.

632

**/

633

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

764

634

765

/**

635

/**

766

     * Returns the String representation of this NodeExpr.

636

     * Returns the String representation of this NodeExpr.

Lines 827-833	Link Here

827

    List predicates;

697

    List predicates;

828

}; //-- PredicateList

698

}; //-- PredicateList

829

699

830

class LocationStep : public PredicateList, public PatternExpr {

700

class LocationStep : public PredicateList, public Expr {

831

701

832

public:

702

public:

833

703

Lines 887-895	Link Here

887

**/

757

**/

888

    void setNodeExpr(NodeExpr* nodeExpr);

758

    void setNodeExpr(NodeExpr* nodeExpr);

889

759

890

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

760

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

891

     //- Virtual methods from PatternExpr -/

761

     //- Virtual methods from Expr -/

892

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

762

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

893

763

894

/**

764

/**

895

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

765

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

Lines 901-940	Link Here

901

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

771

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

902

772

903

/**

773

/**

904

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

774

     * Determines whether this Expr matches the given node within

905

     * context Node, and ContextState.

775

     * the given context

906

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

907

     * ContextState then Negative Infinity is returned.

908

**/

776

**/

909

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

777

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

910

778

911

/**

779

/**

912

     * Determines whether this PatternExpr matches the given node within

780

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

913

     * the given context

781

     * context Node, and ContextState.

914

**/

782

**/

915

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

783

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

916

784

917

/**

785

/**

918

     * Returns the String representation of this PatternExpr.

786

     * Returns the String representation of this Expr.

919

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

787

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

920

     * representation. The String representation will be appended to

788

     * representation. The String representation will be appended to

921

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

789

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

922

     * other #toString() methods for Expressions.

790

     * other #toString() methods for Expressions.

923

     * @return the String representation of this PatternExpr.

791

     * @return the String representation of this Expr.

924

**/

792

**/

925

    virtual void toString(String& dest);

793

    virtual void toString(String& dest);

926

794

927

private:

795

private:

928

796

929

  NodeExpr* nodeExpr;

797

    NodeExpr* nodeExpr;

930

  short     axisIdentifier;

798

    short     axisIdentifier;

931

799

932

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

800

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

801

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

933

802

934

}; //-- LocationStep

803

}; //-- LocationStep

935

804

936

805

937

class FilterExpr : public PredicateList, public PatternExpr {

806

class FilterExpr : public PredicateList, public Expr {

938

807

939

public:

808

public:

940

809

Lines 961-969	Link Here

961

**/

830

**/

962

    void setExpr(Expr* expr);

831

    void setExpr(Expr* expr);

963

832

964

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

833

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

965

     //- Virtual methods from PatternExpr -/

834

     //- Virtual methods from Expr -/

966

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

835

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

967

836

968

/**

837

/**

969

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

838

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

Lines 975-1006	Link Here

975

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

844

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

976

845

977

/**

846

/**

978

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

847

     * Determines whether this Expr matches the given node within

979

     * context Node, and ContextState.

848

     * the given context

980

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

981

     * ContextState then Negative Infinity is returned.

982

**/

849

**/

983

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

850

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

984

851

985

/**

852

/**

986

     * Determines whether this PatternExpr matches the given node within

853

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

987

     * the given context

854

     * context Node, and ContextState.

988

**/

855

**/

989

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

856

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

990

857

991

/**

858

/**

992

     * Returns the String representation of this PatternExpr.

859

     * Returns the String representation of this Expr.

993

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

860

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

994

     * representation. The String representation will be appended to

861

     * representation. The String representation will be appended to

995

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

862

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

996

     * other #toString() methods for Expressions.

863

     * other #toString() methods for Expressions.

997

     * @return the String representation of this PatternExpr.

864

     * @return the String representation of this Expr.

998

**/

865

**/

999

    virtual void toString(String& dest);

866

    virtual void toString(String& dest);

1000

867

1001

private:

868

private:

1002

869

1003

  Expr*     expr;

870

    Expr* expr;

1004

871

1005

}; //-- FilterExpr

872

}; //-- FilterExpr

1006

873

Lines 1131-1136	Link Here

1131

}; //-- AdditiveExpr

998

}; //-- AdditiveExpr

1132

999

1133

/**

1000

/**

1001

 * Represents an UnaryExpr.

1002

**/

1003

class UnaryExpr : public Expr {

1004

1005

public:

1006

1007

     UnaryExpr();

1008

     UnaryExpr(Expr* expr);

1009

     ~UnaryExpr();

1010

1011

/**

1012

     * Sets the expression to negate

1013

**/

1014

    void setExpr(Expr* expr);

1015

1016

/**

1017

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

1018

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

1019

     * @param ps the ContextState containing the stack information needed

1020

     * for evaluation

1021

     * @return the result of the evaluation

1022

**/

1023

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

1024

1025

/**

1026

     * Returns the String representation of this Expr.

1027

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

1028

     * representation. The String representation will be appended to

1029

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

1030

     * other #toString() methods for Expressions.

1031

     * @return the String representation of this Expr.

1032

**/

1033

    virtual void toString(String& str);

1034

1035

private:

1036

    Expr* expr;

1037

}; //-- AdditiveExpr

1038

1039

/**

1134

 * Represents a BooleanExpr, a binary expression that

1040

 * Represents a BooleanExpr, a binary expression that

1135

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

1041

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

1136

**/

1042

**/

Lines 1344-1350	Link Here

1344

/**

1250

/**

1345

 *  Represents a PathExpr

1251

 *  Represents a PathExpr

1346

**/

1252

**/

1347

class PathExpr : public PatternExpr {

1253

class PathExpr : public Expr {

1348

1254

1349

public:

1255

public:

1350

1256

Lines 1359-1386	Link Here

1359

    PathExpr();

1265

    PathExpr();

1360

1266

1361

/**

1267

/**

1362

     * Destructor, will delete all Pattern Expressions

1268

     * Destructor, will delete all Expressions

1363

**/

1269

**/

1364

    virtual ~PathExpr();

1270

    virtual ~PathExpr();

1365

1271

1366

/**

1272

/**

1367

     * Adds the PatternExpr to this PathExpr

1273

     * Adds the Expr to this PathExpr

1368

     * @param expr the Expr to add to this PathExpr

1274

     * @param expr the Expr to add to this PathExpr

1369

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

1275

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

1370

**/

1276

**/

1371

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

1277

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

1372

1278

1373

/**

1279

/**

1374

     * Adds the PatternExpr to this PathExpr

1280

     * Adds the Expr to this PathExpr

1375

     * @param expr the Expr to add to this PathExpr

1281

     * @param expr the Expr to add to this PathExpr

1376

**/

1282

**/

1377

    void addPatternExpr(PatternExpr* expr, short ancestryOp);

1283

    void addExpr(Expr* expr, short ancestryOp);

1378

1284

1379

    virtual MBool isAbsolute();

1285

    virtual MBool isAbsolute();

1380

1286

1381

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

1287

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

1382

     //- Virtual methods from PatternExpr -/

1288

     //- Virtual methods from Expr -/

1383

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

1289

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

1384

1290

1385

/**

1291

/**

1386

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

1292

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

Lines 1392-1424	Link Here

1392

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

1298

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

1393

1299

1394

/**

1300

/**

1395

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

1301

     * Determines whether this Expr matches the given node within

1396

     * context Node, and ContextState.

1302

     * the given context

1397

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

1398

     * ContextState then Negative Infinity is returned.

1399

**/

1303

**/

1400

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

1304

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

1401

1305

1402

/**

1306

/**

1403

     * Determines whether this PatternExpr matches the given node within

1307

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

1404

     * the given context

1308

     * context Node, and ContextState.

1405

**/

1309

**/

1406

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

1310

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

1407

1311

1408

/**

1312

/**

1409

     * Returns the String representation of this PatternExpr.

1313

     * Returns the String representation of this Expr.

1410

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

1314

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

1411

     * representation. The String representation will be appended to

1315

     * representation. The String representation will be appended to

1412

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

1316

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

1413

     * other #toString() methods for Expressions.

1317

     * other #toString() methods for Expressions.

1414

     * @return the String representation of this PatternExpr.

1318

     * @return the String representation of this Expr.

1415

**/

1319

**/

1416

    virtual void toString(String& dest);

1320

    virtual void toString(String& dest);

1417

1321

1418

private:

1322

private:

1419

1323

1420

    struct PathExprItem {

1324

    struct PathExprItem {

1421

        PatternExpr* pExpr;

1325

        Expr* expr;

1422

        short ancestryOp;

1326

        short ancestryOp;

1423

};

1327

};

1424

1328

Lines 1426-1438	Link Here

1426

1330

1427

/**

1331

/**

1428

    * Selects from the descendants of the context node

1332

    * Selects from the descendants of the context node

1429

    * all nodes that match the PatternExpr

1333

    * all nodes that match the Expr

1430

    * -- this will be moving to a Utility class

1334

    * -- this will be moving to a Utility class

1431

**/

1335

**/

1432

   void fromDescendants(PatternExpr* pExpr,

1336

   void evalDescendants(Expr* expr,

1433

                        Node* context,

1337

                        Node* context,

1434

                        ContextState* cs,

1338

                        ContextState* cs,

1435

                        NodeSet* nodes);

1339

                        NodeSet* resNodes);

1436

1340

1437

}; //-- PathExpr

1341

}; //-- PathExpr

1438

1342

Lines 1459-1484	Link Here

1459

    virtual MBool isAbsolute();

1363

    virtual MBool isAbsolute();

1460

1364

1461

/**

1365

/**

1462

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

1463

     * context Node, and ContextState.

1464

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

1465

     * ContextState then Negative Infinity is returned.

1466

**/

1467

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

1468

1469

/**

1470

     * Determines whether this NodeExpr matches the given node within

1366

     * Determines whether this NodeExpr matches the given node within

1471

     * the given context

1367

     * the given context

1472

**/

1368

**/

1473

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

1369

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

1474

1370

1371

/**

1372

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

1373

     * context Node, and ContextState.

1374

**/

1375

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

1376

1475

/**

1377

/**

1476

     * Returns the String representation of this PatternExpr.

1378

     * Returns the String representation of this Expr.

1477

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

1379

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

1478

     * representation. The String representation will be appended to

1380

     * representation. The String representation will be appended to

1479

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

1381

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

1480

     * other #toString() methods for Expressions.

1382

     * other #toString() methods for Expressions.

1481

     * @return the String representation of this PatternExpr.

1383

     * @return the String representation of this Expr.

1482

**/

1384

**/

1483

    virtual void toString(String& dest);

1385

    virtual void toString(String& dest);

1484

1386

Lines 1488-1494	Link Here

1488

/**

1390

/**

1489

 *  Represents a UnionExpr

1391

 *  Represents a UnionExpr

1490

**/

1392

**/

1491

class UnionExpr : public PatternExpr {

1393

class UnionExpr : public Expr {

1492

1394

1493

public:

1395

public:

1494

1396

Lines 1506-1522	Link Here

1506

     * Adds the PathExpr to this UnionExpr

1408

     * Adds the PathExpr to this UnionExpr

1507

     * @param expr the Expr to add to this UnionExpr

1409

     * @param expr the Expr to add to this UnionExpr

1508

**/

1410

**/

1509

    void addPathExpr(PathExpr* expr);

1411

    void addExpr(Expr* expr);

1510

1412

1511

/**

1413

/**

1512

     * Adds the PathExpr to this UnionExpr at the specified index

1414

     * Adds the PathExpr to this UnionExpr at the specified index

1513

     * @param expr the Expr to add to this UnionExpr

1415

     * @param expr the Expr to add to this UnionExpr

1514

**/

1416

**/

1515

    void addPathExpr(int index, PathExpr* expr);

1417

    void addExpr(int index, Expr* expr);

1516

1418

1517

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

1419

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

1518

     //- Virtual methods from PatternExpr -/

1420

     //- Virtual methods from Expr -/

1519

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

1421

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

1520

1422

1521

/**

1423

/**

1522

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

1424

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

Lines 1528-1553	Link Here

1528

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

1430

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

1529

1431

1530

/**

1432

/**

1531

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

1433

     * Determines whether this Expr matches the given node within

1532

     * context Node, and ContextState.

1434

     * the given context

1533

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

1534

     * ContextState then Negative Infinity is returned.

1535

**/

1435

**/

1536

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

1436

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

1537

1437

1538

/**

1438

/**

1539

     * Determines whether this PatternExpr matches the given node within

1439

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

1540

     * the given context

1440

     * context Node, and ContextState.

1541

**/

1441

**/

1542

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

1442

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

1543

1443

1544

/**

1444

/**

1545

     * Returns the String representation of this PatternExpr.

1445

     * Returns the String representation of this Expr.

1546

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

1446

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

1547

     * representation. The String representation will be appended to

1447

     * representation. The String representation will be appended to

1548

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

1448

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

1549

     * other #toString() methods for Expressions.

1449

     * other #toString() methods for Expressions.

1550

     * @return the String representation of this PatternExpr.

1450

     * @return the String representation of this Expr.

1551

**/

1451

**/

1552

    virtual void toString(String& dest);

1452

    virtual void toString(String& dest);

1553

1453

(-)ExprLexer.cpp (-541 / +351 lines)

Line	Link Here

Lines 1-4	Link Here

/*

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

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

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

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

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

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

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

Lines 29-34	Link Here

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

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

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

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

 * Axel Hecht <axel@pike.org>

 *   -- big beating, general overhaul

 * $Id: ExprLexer.cpp,v 1.12 2001/04/03 12:25:03 peterv%netscape.com Exp $

 * $Id: ExprLexer.cpp,v 1.12 2001/04/03 12:25:03 peterv%netscape.com Exp $

*/

*/

Lines 40-55	Link Here

#include "ExprLexer.h"

#include "ExprLexer.h"

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

 //- Implementation of Token -/

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

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

//- Implementation of Token -/

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

/**

/**

 * Default constructor for Token

 * Default constructor for Token

**/

**/

Token::Token() {

Token::Token() {

    this->type =0;

  this->type =0;

} //-- Token;

} //-- Token;

/**

/**

Lines 57-63	Link Here

 * @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 66-99	Link Here

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

  this->type = type;

    //-- make copy of value String

  //-- make copy of value String

    this->value = value;

  this->value = value;

} //-- Token

} //-- Token

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

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

    this->type = type;

  this->type = type;

    this->value.append(uniChar);

  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->type = token.type;

    this->value = token.value;

  this->value = token.value;

} //-- Token

} //-- Token

/**

/**

 * Destructor for Token

 * Destructor for Token

**/

**/

Token::~Token() {

Token::~Token() {

    //-- currently nothing is needed

  //-- currently nothing is needed

} //-- ~Token

} //-- ~Token

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

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

 //- Implementation of ExprLexer -/

//- Implementation of ExprLexer -/

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

100

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

101

/*

102

/*

Lines 110-115	Link Here

110

const String ExprLexer::OR      = "or";

113

const String ExprLexer::OR      = "or";

111

114

112

//-- multiplicative operators

115

//-- multiplicative operators

116

const String ExprLexer::MULTIPLY= "*";

113

const String ExprLexer::MODULUS = "mod";

117

const String ExprLexer::MODULUS = "mod";

114

const String ExprLexer::DIVIDE  = "div";

118

const String ExprLexer::DIVIDE  = "div";

115

119

Lines 119-725	Link Here

119

**/

123

**/

120

const Token ExprLexer::TOKENS[] = {

124

const Token ExprLexer::TOKENS[] = {

121

125

122

    //-- Nodetype tokens

126

  //-- Nodetype tokens

123

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

127

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

124

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

128

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

125

    Token(ExprLexer::PI,            Token::PI),

129

  Token(ExprLexer::PI,            Token::PI),

126

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

130

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

127

    //-- boolean operators

131

  //-- boolean operators

128

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

132

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

129

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

133

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

130

134

131

    //-- multiplicative operators

135

  //-- multiplicative operators

132

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

136

  Token(ExprLexer::MULTIPLY,      Token::MULTIPLY_OP),

133

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

137

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

138

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

134

};

139

};

140

141

const short ExprLexer::NUMBER_OF_TOKENS  = 9;

135

142

136

const short ExprLexer::NUMBER_OF_TOKENS  = 8;

143

/**

144

 * The set of Lexer error messages

145

**/

146

const String ExprLexer::error_message[] = {

147

  "VariableReference expected",

148

  "Operator expected",

149

  "Literal is not closed",

150

  ": not expected",

151

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

152

};

137

153

138

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

139

 //- Contructors -/

140

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

154

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

155

//- Contructors -/

156

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

141

157

142

/**

158

/**

143

 * Creates a new ExprLexer using the given String

159

 * Creates a new ExprLexer using the given String

144

**/

160

**/

145

ExprLexer::ExprLexer(const String& pattern) {

161

ExprLexer::ExprLexer(const String& pattern) {

146

162

147

    firstItem    = 0;

163

  firstItem    = 0;

148

    lastItem     = 0;

164

  lastItem     = 0;

149

    tokenCount   = 0;

165

  tokenCount   = 0;

150

    prevToken    = 0;

166

  prevToken    = 0;

151

    parse(pattern);

167

  endToken.type = Token::END;

152

    currentItem = firstItem;

168

  parse(pattern);

169

  currentItem = firstItem;

153

} //-- ExprLexer

170

} //-- ExprLexer

154

171

155

/**

172

/**

156

 * Destroys this instance of an ExprLexer

173

 * Destroys this instance of an ExprLexer

157

**/

174

**/

158

ExprLexer::~ExprLexer() {

175

ExprLexer::~ExprLexer() {

159

   //-- delete tokens

176

  //-- delete tokens

160

177

161

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

178

  currentItem = firstItem;

162

   currentItem = firstItem;

179

  while ( currentItem ) {

163

   while ( currentItem ) {

180

    TokenListItem* temp = currentItem->next;

164

       TokenListItem* temp = currentItem->next;

181

    delete currentItem->token;

165

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

182

    delete currentItem;

166

       delete currentItem->token;

183

    currentItem = temp;

167

       delete currentItem;

184

168

       currentItem = temp;

169

170

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

171

} //-- ~ExprLexer

185

} //-- ~ExprLexer

172

186

173

187

174

int ExprLexer::countAllTokens() {

188

int ExprLexer::countAllTokens() {

175

    return tokenCount;

189

  return tokenCount;

176

} //-- countAllTokens

190

} //-- countAllTokens

177

191

178

int ExprLexer::countRemainingTokens() {

192

int ExprLexer::countRemainingTokens() {

179

    TokenListItem* temp = currentItem;

193

  TokenListItem* temp = currentItem;

180

    int c = 0;

194

  int c = 0;

181

    while ( temp ) {

195

  while ( temp ) {

182

        ++c;

196

    ++c;

183

        temp = temp->next;

197

    temp = temp->next;

184

198

185

    return c;

199

  return c;

186

} //-- countRemainingTokens

200

} //-- countRemainingTokens

187

201

188

202

189

MBool ExprLexer::hasMoreTokens() {

203

MBool ExprLexer::hasMoreTokens() {

190

    return (MBool) ( currentItem );

204

  return (MBool) ( currentItem );

191

} //-- hasMoreTokens

205

} //-- hasMoreTokens

192

206

193

Token* ExprLexer::nextToken() {

207

Token* ExprLexer::nextToken() {

194

    if ( currentItem ) {

208

  if ( currentItem ) {

195

        Token* token = currentItem->token;

209

    Token* token = currentItem->token;

196

        currentItem = currentItem->next;

210

    currentItem = currentItem->next;

197

        return token;

211

    return token;

198

212

199

    return 0;

213

  return &endToken;

200

} //-- nextToken

214

} //-- nextToken

201

215

202

void ExprLexer::pushBack() {

216

void ExprLexer::pushBack() {

203

    if ( !currentItem ) {

217

  if ( !currentItem ) {

204

        currentItem = lastItem;

218

    currentItem = lastItem;

205

219

206

    else currentItem = currentItem->previous;

220

  else currentItem = currentItem->previous;

207

} //-- pushBack

221

} //-- pushBack

208

222

209

/*

210

Token* ExprLexer::lastToken() {

211

    if (lastItem) {

212

        return lastItem->token;

213

214

    return 0;

215

} //-- lastToken

216

*/

217

218

Token* ExprLexer::peek() {

223

Token* ExprLexer::peek() {

219

    Token* token = 0;

224

  if ( currentItem )

220

    TokenListItem* tlItem = currentItem;

225

    return currentItem->token;

221

    if (tlItem) token = tlItem->token;

226

  return &endToken;

222

    return token;

223

} //-- peek

227

} //-- peek

224

228

225

Token* ExprLexer::lookAhead(int offset) {

229

Token* ExprLexer::lookAhead(int offset) {

226

    Token* token = 0;

230

  Token* token = &endToken;

227

    TokenListItem* tlItem = currentItem;

231

  TokenListItem* tlItem = currentItem;

228

    //-- advance to proper offset

232

  //-- advance to proper offset

229

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

233

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

230

        if ( tlItem ) tlItem = currentItem->next;

234

    if ( tlItem ) tlItem = currentItem->next;

231

235

232

    if (tlItem) token = tlItem->token;

236

  if (tlItem) token = tlItem->token;

233

    return token;

237

  return token;

234

} //-- lookAhead

238

} //-- lookAhead

235

239

236

void ExprLexer::addToken(Token* token) {

240

void ExprLexer::addToken(Token* token) {

237

    TokenListItem* tlItem = new TokenListItem;

241

  TokenListItem* tlItem = new TokenListItem;

238

    tlItem->token = token;

242

  tlItem->token = token;

239

    tlItem->next  = 0;

243

  tlItem->next  = 0;

240

    if (lastItem) {

244

  if (lastItem) {

241

        tlItem->previous = lastItem;

245

    tlItem->previous = lastItem;

242

        lastItem->next = tlItem;

246

    lastItem->next = tlItem;

243

247

244

    if (!firstItem) firstItem = tlItem;

248

  if (!firstItem) firstItem = tlItem;

245

    lastItem = tlItem;

249

  lastItem = tlItem;

246

    prevToken = token;

250

  prevToken = token;

247

    ++tokenCount;

251

  ++tokenCount;

248

} //-- addToken

252

} //-- addToken

249

253

254

// macros for inclusion of char range headers

255

#define TX_CHAR_RANGE(a,b) if (ch<a) return MB_FALSE; \

256

  if (ch<=b) return MB_TRUE

257

#define TX_MATCH_CHAR(a) if (ch<a) return MB_FALSE; \

258

  if (ch==a) return MB_TRUE

259

250

/**

260

/**

251

 * Returns true if the given character represents an Alpha letter

261

 * Returns true if the given character represents an Alpha letter

252

**/

262

**/

253

MBool ExprLexer::isAlphaChar(Int32 ch) {

263

MBool ExprLexer::isLetter(UNICODE_CHAR ch) {

254

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

264

#include "Letter.h"

255

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

265

  return MB_FALSE;

256

    return MB_FALSE;

257

} //-- isAlphaChar

266

} //-- isAlphaChar

258

267

259

/**

268

/**

260

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

269

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

261

**/

270

**/

262

MBool ExprLexer::isDigit(Int32 ch) {

271

MBool ExprLexer::isDigit(UNICODE_CHAR ch) {

263

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

272

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

264

    return MB_FALSE;

273

  return MB_FALSE;

265

} //-- isDigit

274

} //-- isDigit

266

275

267

/**

276

/**

268

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

277

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

269

**/

278

**/

270

MBool ExprLexer::isNCNameChar(Int32 ch) {

279

MBool ExprLexer::isNCNameChar(UNICODE_CHAR ch) {

271

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

280

#include "NCNameChar.h"

272

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

281

  return MB_FALSE;

273

} //-- isNCNameChar

282

} //-- isNCNameChar

274

283

275

/**

284

/**

276

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

285

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

277

**/

286

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

278

MBool ExprLexer::isQNameChar(Int32 ch) {

287

 *  Lexical Structure

279

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

288

**/

280

} //-- isQNameChar

289

MBool ExprLexer::nextIsOperatorToken(Token* token) {

281

290

  if ( !token ) return MB_FALSE;

282

/**

291

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

283

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

292

      token->type <= Token::UNION_OP)

284

**/

285

MBool ExprLexer::isValidQName(String& name) {

286

287

    int size = name.length();

288

    if ( size == 0 ) return MB_FALSE;

289

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

290

    else {

291

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

292

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

293

294

295

    return MB_TRUE;

296

} //-- isValidQName

297

298

MBool ExprLexer::isOperatorToken(Token* token) {

299

    if ( !token ) return MB_FALSE;

300

    switch ( token->type ) {

301

        //-- boolean operators

302

        case Token::AND_OP:

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;

293

    return MB_FALSE;

294

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

295

  if (token->type == Token::L_PAREN) return MB_FALSE;

296

  if (token->type == Token::L_BRACKET) return MB_FALSE;

297

  if (token->type == Token::AT_SIGN) return MB_FALSE;

298

  return MB_TRUE;

324

} //-- isOperatorToken

299

} //-- isOperatorToken

325

300

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

380

    Token* token = 0;

381

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

382

    else token = new Token(tokenType);

383

384

    addToken(token);

385

    return MB_TRUE;

386

} //-- matchDelimiter

387

388

/**

301

/**

389

 * Returns true if the value of the given String matches

390

 * an OperatorName

391

**/

392

MBool ExprLexer::matchesOperator(String& buffer) {

393

394

    int index = 0;

395

    while (index < NUMBER_OF_TOKENS) {

396

        Token tok = TOKENS[index++];

397

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

398

            if (isOperatorToken( &tok )) return MB_TRUE;

399

400

401

    return MB_FALSE;

402

403

} //-- matchesOperator

404

405

/**

406

 * Matches the given String to the appropriate Token

407

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

408

 * @param ch, the current delimiter token

409

**/

410

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

411

412

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

413

414

    Token* match = new Token();

415

    MBool foundMatch = MB_FALSE;

416

    int index = 0;

417

418

    //-- check previous token

419

    switch(prevToken->type) {

420

        case Token::VAR_REFERENCE :

421

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

422

                prevToken->value.append(buffer);

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::PI :

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

302

 *  Parses the given String into the set of Tokens

498

**/

303

**/

499

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

304

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

500

305

306

  String tokenBuffer;

501

307

502

    String tokenBuffer;

308

  Int32 iter = 0, start;

503

    UNICODE_CHAR inLiteral = '\0';

309

  Int32 size = pattern.length();

504

    MBool inNumber  = MB_FALSE;

310

  short defType = Token::CNAME;

505

311

  UNICODE_CHAR ch;

506

    Int32 currentPos = 0;

312

  if ( size==0 ) return;

507

313

508

    UNICODE_CHAR ch = '\0';

314

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

509

    UNICODE_CHAR prevCh = ch;

315

  //-- deleted when it goes out of scope

510

316

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

511

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

317

512

    //-- deleted when it goes out of scope

318

  prevToken = &nullToken;

513

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

319

514

320

  while (iter < size) {

515

    prevToken = &nullToken;

321

516

322

    ch = pattern.charAt(iter);

517

    while (currentPos < pattern.length()) {

323

    defType = Token::CNAME;

518

324

519

        prevCh = ch;

325

    if (ch==DOLLAR_SIGN){

520

        ch = pattern.charAt(currentPos);

326

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

521

327

        // Error, VariableReference expected

522

        if ( inLiteral ) {

328

        errorPos = iter;

523

            //-- look for end of literal

329

        errorCode = ERROR_UNRESOLVED_VAR_REFERENCE;

524

            if ( ch == inLiteral ) {

330

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

525

                inLiteral = '\0';

331

        iter=size; // bail

526

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

332

      } else

527

                tokenBuffer.clear();

333

        defType = Token::VAR_REFERENCE;

528

334

529

            else {

335

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

530

                tokenBuffer.append(ch);

336

    // the token to construct

531

337

338

    if ( isLetter(ch) ) {

339

      // NCName, can get QName or OperatorName;

340

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

341

      //  and are dealt with below

342

      start = iter;

343

      while (iter++ < size &&

344

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

345

      Int32 end = iter;

346

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

347

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

348

        while(iter++ < size &&

349

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

350

        if (iter==end+1) iter--; // step back

351

352

      if (nextIsOperatorToken(prevToken)){

353

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

354

          defType = Token::AND_OP;

355

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

356

          defType = Token::OR_OP;

357

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

358

          defType = Token::MODULUS_OP;

359

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

360

          defType = Token::DIVIDE_OP;

361

        else {

362

          // Error "operator expected"

363

          // XXX QUESTION: spec is not too precise

364

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

365

          errorPos = iter;

366

          errorCode = ERROR_OP_EXPECTED;

367

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

368

          iter=size; // bail

532

369

533

        else if ( inNumber ) {

370

534

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

371

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

535

                tokenBuffer.append(ch);

372

    } else if ( isDigit(ch) ) {

536

373

      start = iter;

537

            else {

374

      while (iter++ < size &&

538

                inNumber = MB_FALSE;

375

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

539

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

376

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

540

                tokenBuffer.clear();

377

        while (iter++ < size &&

541

                //-- push back last char

378

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

542

                --currentPos;

379

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

543

380

    } else {

381

      switch (ch) {

382

        //-- ignore whitespace

383

      case SPACE:

384

      case TX_TAB:

385

      case TX_CR:

386

      case TX_LF:

387

        iter++;

388

        break;

389

      case S_QUOTE :

390

      case D_QUOTE :

391

        start=iter;

392

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

393

        if (iter==NOT_FOUND){

394

          // XXX Error reporting "unclosed literal"

395

          errorPos = start;

396

          errorCode = ERROR_UNCLOSED_LITERAL;

397

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

398

          iter=size; // bail

399

        } else {

400

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

401

                             Token::LITERAL));

402

          iter++;

544

403

545

        else if (isDigit(ch)) {

404

        break;

546

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

405

      case PERIOD:

547

                //-- match operator and free up token buffer

406

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

548

                matchToken(tokenBuffer, ch);

407

        if (iter++ < size){

549

                inNumber = MB_TRUE;

408

          if (isDigit(ch=pattern.charAt(iter))){

550

409

            start=iter-1;

551

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

410

            while (iter++ < size &&

552

                inNumber = MB_TRUE;

411

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

553

412

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

554

            tokenBuffer.append(ch);

413

                               Token::NUMBER));

414

          } else if (ch==PERIOD) {

415

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

416

                               Token::PARENT_NODE));

417

          } else

418

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

419

          // iter++ is already in the number test

555

420

556

        else {

421

        break;

557

            switch (ch) {

422

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

558

                //-- ignore whitespace

423

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

559

                case SPACE:

424

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

560

                case TX_TAB:

425

          prevToken->type = Token::AXIS_IDENTIFIER;

561

                case TX_CR:

426

          iter++;

562

                case TX_LF:

427

        } else {

563

                    break;

428

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

564

                case S_QUOTE :

429

          errorPos = iter;

565

                case D_QUOTE :

430

          errorCode = ERROR_COLON;

566

                    matchToken(tokenBuffer, ch);

431

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

567

                    inLiteral = ch;

432

          iter=size; // bail

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

                        Int32 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

433

714

        ++currentPos;

434

        break;

715

435

      case FORWARD_SLASH :

716

    //-- end lexical parsing of current token

436

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

717

    //-- freeBuffer if needed

437

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

718

438

                             Token::ANCESTOR_OP));

719

    if ( inNumber ) {

439

        } else {

720

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

440

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

441

442

        break;

443

      case BANG : // can only be !=

444

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

445

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

446

                             Token::NOT_EQUAL_OP));

447

          iter++;

448

        } else {

449

          // Error ! is not not()

450

          errorPos = iter;

451

          errorCode = ERROR_BANG;

452

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

453

          iter=size; // bail

454

455

        break;

456

      case EQUAL:

457

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

458

        iter++;

459

        break;

460

      case L_ANGLE:

461

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

462

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

463

                             Token::LESS_OR_EQUAL_OP));

464

          iter++;

465

        } else

466

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

467

        break;

468

      case R_ANGLE:

469

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

470

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

471

                             Token::GREATER_OR_EQUAL_OP));

472

          iter++;

473

        } else

474

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

475

        break;

476

      case HYPHEN :

477

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

478

        iter++;

479

        break;

480

      case ASTERIX:

481

        if (nextIsOperatorToken(prevToken))

482

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

483

        else

484

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

485

        iter++;

486

        break;

487

      case L_PAREN:

488

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

489

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

490

            prevToken->type = Token::COMMENT;

491

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

492

            prevToken->type = Token::NODE;

493

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

494

            prevToken->type = Token::PI;

495

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

496

            prevToken->type = Token::TEXT;

497

          else

498

            prevToken->type = Token::FUNCTION_NAME;

499

500

        iter++;

501

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

502

        break;

503

      case R_PAREN:

504

        iter++;

505

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

506

        break;

507

      case L_BRACKET:

508

        iter++;

509

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

510

        break;

511

      case R_BRACKET:

512

        iter++;

513

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

514

        break;

515

      case COMMA:

516

        iter++;

517

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

518

        break;

519

      case AT_SIGN :

520

        iter++;

521

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

522

        break;

523

      case PLUS:

524

        iter++;

525

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

526

        break;

527

      case VERT_BAR:

528

        iter++;

529

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

530

        break;

531

721

532

722

    else matchToken(tokenBuffer, ch);

533

723

    prevToken = 0;

724

} //-- parse

534

} //-- parse

725

535





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

 *    -- changed constant short declarations in Token and ExprLexer to
 *       enumerations, commented with //--LF
 * 
 * $Id: ExprLexer.h,v 1.5 2001/01/22 09:36:16 kvisco%ziplink.net 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.5 $ $Date: 2001/01/22 09:36:16 $
**/
class Token {


        L_BRACKET,
        R_BRACKET,
        COMMA,
        FUNCTION_NAME, // 10
        AT_SIGN,
        VAR_REFERENCE,
        PARENT_NODE,

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

        //-- 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,
        //-- node type tokens
        COMMENT, // 32
        NODE,
        PI,
        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
    };
    static const String error_message[];
    Int32 errorPos;
    short errorCode;

    /*
     * Complex Tokens

    static const String OR;

    //-- Multiplicative
    static const String MULTIPLY;
    static const String MODULUS;
    static const String DIVIDE;


    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
    **/
    static MBool isLetter(UNICODE_CHAR ch);

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

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

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

    MBool matchDelimiter(UNICODE_CHAR ch);

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

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


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

}; //-- ExprLexer





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

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

/**
 * Creates a new ExprParser
**/


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

    AttributeValueTemplate* avt = new AttributeValueTemplate();

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

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

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

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

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

    return avt;

} //-- createAttributeValueTemplate

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

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

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

} //-- createBinaryExpr


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

    MBool done = MB_FALSE;



    Stack exprs;
    Stack ops;
    
    if (lexer.peek()->type == Token::ERROR) {
      done = MB_TRUE;
      // XXX Error notification of caller
    }
    while ( !done ) {

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

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

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

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

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

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

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


} //-- createExpr

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

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

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

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

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

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

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

    return expr;

} //-- createFilterExpr

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

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

    FunctionCall* fnCall = 0;

    Token* tok = lexer.nextToken();

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

    String fnName = tok->value;

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

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

    LocationStep* lstep = new LocationStep();

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

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

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

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

    lstep->setAxisIdentifier(axisIdentifier);


    NodeExpr* nodeExpr = 0;

    tok = lexer.peek();
    if (!tok) {
        ///XXXXX We need to create an ErrorExpr or something to
        ///XXXXX handle errors
    }
    // NameTest
    else if (tok->type == Token::CNAME) {
        //-- handle NameTest
        //-- eat token
        lexer.nextToken();
        if (axisIdentifier ==  LocationStep::ATTRIBUTE_AXIS)
            nodeExpr = new AttributeExpr(tok->value);
        else
            nodeExpr = new ElementExpr(tok->value);

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

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

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

    NodeExpr* nodeExpr = 0;

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

    Token* nodeTok = lexer.nextToken();

    switch ( nodeTok->type ) {
        case Token::COMMENT:
            nodeExpr = new BasicNodeExpr(NodeExpr::COMMENT_EXPR);
            errMsg = parseParameters(&params, lexer);
            //-- ignore errMsg for now
            delete errMsg;
            break;
        case Token::NODE :
            nodeExpr = new BasicNodeExpr();
            errMsg = parseParameters(&params, lexer);
            //-- ignore errMsg for now
            delete errMsg;
            break;
        case Token::PI :
            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::PI && lexer.peek()->type == Token::LITERAL ) {
        Token* tok = lexer.nextToken();
        ((BasicNodeExpr*)nodeExpr)->setNodeName(tok->value);
    }
    if ( lexer.nextToken()->type != Token::R_PAREN ) {
        lexer.pushBack();
        //XXX ErrorReport: right parenthesis expected (or literal for pi)
        delete nodeExpr;
        return 0;
    }
    
        
    return nodeExpr;
} //-- createNodeExpr


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

    Expr* expr = 0;

    Token* tok = lexer.peek();

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

        lexer.pushBack();
    }

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

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

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

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

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

    return pathExpr;
} //-- createPathExpr

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

    if (lexer.peek()->type == Token::ERROR) {
      // XXX Error notification of caller
      return 0;
        pExpr = createLocationStep(lexer);
    }
    else if ( isFilterExprToken(tok) ) {
        pExpr = createFilterExpr(lexer);
    }
    else {
        cout << "invalid token: " << tok->value << endl;
        //-- eat token for now
        lexer.nextToken();
    }
    return pExpr;
} //-- createPatternExpr

    Expr* expr = createPathExpr(lexer);
    if(!expr)
        return 0;
    
    if ( lexer.peek()->type != Token::UNION_OP )
        return expr;

    UnionExpr* unionExpr = new UnionExpr();
    unionExpr->addExpr(expr);

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

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

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

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

} //-- isFilterExprToken

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

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

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

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

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

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

    String* errorMsg = 0;

    Token* tok = lexer.peek();

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

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

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

        predicateList->add(expr);

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

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

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

} //-- parsePredicates


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

    String* errorMsg = 0;

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

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

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

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

    return MB_FALSE;

} //-- parseParameters







public:

    static const String R_CURLY_BRACE;
    static const String L_CURLY_BRACE;

    /**
     * Creates a new ExprParser
    **/

    ~ExprParser();

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

    /**


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

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

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


}; //-- ExprParser

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





             BooleanExpr.o \
             BooleanResult.o \
             ElementExpr.o \
             Expr.o \
             ExprLexer.o \
             ExprParser.o \
             FilterExpr.o \
             IdentityExpr.o \
             LocationStep.o \
             MultiplicativeExpr.o \
             NodeSet.o \
             NumberExpr.o \
             NumberResult.o \
             PredicateList.o \
             ParentExpr.o \
             PathExpr.o \
             RelationalExpr.o \
             RootExpr.o \

             StringResult.o \
	         TextExpr.o \
             UnionExpr.o \
             UnaryExpr.o \
             VariableRefExpr.o \
             XPathNames.o


ElementExpr.o: Expr.h ElementExpr.cpp
	$(CC) $(INCLUDE_PATHS) -c ElementExpr.cpp

Expr.o: Expr.cpp Expr.h
	$(CC) $(INCLUDE_PATHS) -c Expr.cpp

ExprLexer.o: ExprLexer.cpp ExprLexer.h
	$(CC) $(INCLUDE_PATHS) -c ExprLexer.cpp



UnionExpr.o: Expr.h UnionExpr.cpp
	$(CC) $(INCLUDE_PATHS) -c UnionExpr.cpp

UnaryExpr.o: Expr.h UnaryExpr.cpp
	$(CC) $(INCLUDE_PATHS) -c UnaryExpr.cpp

VariableRefExpr.o: Expr.h VariableRefExpr.cpp
	$(CC) $(INCLUDE_PATHS) -c VariableRefExpr.cpp





        BooleanResult.cpp \
        ElementExpr.cpp \
        ErrorFunctionCall.cpp \
        Expr.cpp \
        ExprLexer.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
ifdef MOZ_XSL





}

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

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

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

    return MB_FALSE;
} //-- isAbsolute

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

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


    ListIterator* iter = expressions.iterator();

    MBool ancestorMode = MB_FALSE;
    while ( iter->hasNext() ) {

        PathExprItem* pxi = (PathExprItem*)iter->next();
        ancestorMode = (ancestorMode || (pxi->ancestryOp == ANCESTOR_OP));
        NodeSet* tmpNodes = 0;
        cs->getNodeSetStack()->push(nodes);
        for (int i = 0; i < nodes->size(); i++) {
            Node* node = nodes->get(i);
            
            NodeSet* resNodes;
            if ( pxi->ancestryOp == ANCESTOR_OP) {
                resNodes = new NodeSet;
                evalDescendants(pxi->expr, node, cs, resNodes);
               continue;
            NodeSet* xNodes = (NodeSet *) res;
#endif
            if ( tmpNodes ) {
                xNodes->copyInto(*tmpNodes);
            }
            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;
            }
            else
                tmpNodes = resNodes;

        }
        delete (NodeSet*) cs->getNodeSetStack()->pop();
        nodes = tmpNodes;


/**
 * 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
    }
    ((NodeSet*)res)->copyInto(*resNodes);
    delete res;
    
    Node* child = context->getFirstChild();
    while(child) {
        //XXX WhiteSpace: filter whitespace nodes
        evalDescendants(expr, child, cs, resNodes);
        child = child->getNextSibling();
    }
    

} //-- fromDescendants

/**
 * 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 PathExpr::getDefaultPriority(Node* node, Node* context, ContextState* cs) {

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

    ListIterator* iter = expressions.iterator();
    PathExprItem* pxi = (PathExprItem*)iter->next();
    delete iter;
    return pxi->expr->getDefaultPriority(node, context, cs);

} //-- getDefaultPriority

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

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

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

        }


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

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

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

                    if ( !iter->hasNext() ) {

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

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

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



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

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

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

Line	Link Here

Lines 72-79	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





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

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

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

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

/**


    while ( iter->hasNext() ) {

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

    delete iter;

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

    ListIterator* iter = expressions.iterator();

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



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

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





	BooleanResult.cpp		\
	ElementExpr.cpp			\
	ErrorFunctionCall.cpp		\
	Expr.cpp			\
	ExprLexer.cpp			\
	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(MOZ_XSL)

	.\$(OBJDIR)\BooleanResult.obj			\
	.\$(OBJDIR)\ElementExpr.obj			\
	.\$(OBJDIR)\ErrorFunctionCall.obj		\
	.\$(OBJDIR)\Expr.obj				\
	.\$(OBJDIR)\ExprLexer.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(MOZ_XSL)

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

Line	Link Here

Lines 197-204	Link Here

197

        namedTemplates.put(name,mObj);

197

        namedTemplates.put(name,mObj);

198

        if ( oldObj ) delete oldObj;

198

        if ( oldObj ) delete oldObj;

199

200

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

200

    if ( match.length() > 0 ) {

201

    templates.add(xslTemplate);

201

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

202

        templates.add(xslTemplate);

203

202

} //-- addTempalte

204

} //-- addTempalte

203

205

204

/**

206

/**

Return to bug 75102