Source: nodes.h


Annotated List
Files
Globals
Hierarchy
Index
/*
 *  This file is part of the KDE libraries
 *  Copyright (C) 1999 Harri Porten (porten@kde.org)
 *
 *  This library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Library General Public
 *  License as published by the Free Software Foundation; either
 *  version 2 of the License, or (at your option) any later version.
 *
 *  This library is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *  Library General Public License for more details.
 *
 *  You should have received a copy of the GNU Library General Public License
 *  along with this library; see the file COPYING.LIB.  If not, write to
 *  the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 *  Boston, MA 02111-1307, USA.
 */

#ifndef _NODES_H_
#define _NODES_H_

#include <stdlib.h> // for free()
#include <strings.h>
#include <iostream.h>

#include "global.h"
#include "kjsstring.h"

namespace KJS {

class KJSO;
class KJSArgList;
class ProgramNode;

class Node {
public:
  Node();
  virtual ~Node();
  virtual KJSO *evaluate() = 0;
  int lineNo() { return line; }
  static ProgramNode *progNode() { return prog; }
  static void deleteAllNodes();
protected:
  static ProgramNode *prog;
private:
  // disallow assignment and copy-construction
  Node(const Node &);
  Node& operator=(const Node&);
  int line;
  static  int nodeCount;
  Node *nextNode;
  static Node *firstNode;
};

class StatementNode : public Node {
public:
  KJSO *evaluate() = 0;
};

class NullNode : public Node {
public:
  KJSO *evaluate();
};

class BooleanNode : public Node {
public:
  BooleanNode(bool v) : value(v) {}
  KJSO *evaluate();
private:
  bool value;
};

class NumberNode : public Node {
public:
  NumberNode(int v) : value((double)v) { }
  NumberNode(double v) : value(v) { }
  KJSO *evaluate();
private:
  double value;
};

class StringNode : public Node {
public:
  StringNode(const UString &v) { value = v; }
  KJSO *evaluate();
private:
  UString value;
};

class ThisNode : public Node {
public:
  KJSO *evaluate();
};

class ResolveNode : public Node {
public:
  ResolveNode(const CString &s) : ident(s) { }
  KJSO *evaluate();
private:
  CString ident;
};

class GroupNode : public Node {
public:
  GroupNode(Node *g) : group(g) { }
  KJSO *evaluate();
private:
  Node *group;
};

class AccessorNode1 : public Node {
public:
  AccessorNode1(Node *e1, Node *e2) : expr1(e1), expr2(e2) {}
  KJSO *evaluate();
private:
  Node *expr1;
  Node *expr2;
};

class AccessorNode2 : public Node {
public:
  AccessorNode2(Node *e, const CString &s) : expr(e), ident(s) { }
  KJSO *evaluate();
private:
  Node *expr;
  CString ident;
};

class ArgumentListNode : public Node {
public:
  ArgumentListNode(Node *e);
  ArgumentListNode(ArgumentListNode *l, Node *e);
  KJSO *evaluate();
private:
  ArgumentListNode *list;
  Node *expr;
};

class ArgumentsNode : public Node {
public:
  ArgumentsNode(ArgumentListNode *l);
  KJSO *evaluate();
  KJSArgList *evaluateList();
private:
  ArgumentListNode *list;
};

class NewExprNode : public Node {
public:
  NewExprNode(Node *e) : expr(e), args(0L) {}
  NewExprNode(Node *e, ArgumentsNode *a) : expr(e), args(a) {}
  KJSO *evaluate();
private:
  Node *expr;
  ArgumentsNode *args;
};

class FunctionCallNode : public Node {
public:
  FunctionCallNode(Node *e, ArgumentsNode *a) : expr(e), args(a) {}
  KJSO *evaluate();
private:
  Node *expr;
  ArgumentsNode *args;
};

class PostfixNode : public Node {
public:
  PostfixNode(Node *e, Operator o) : expr(e), oper(o) {}
  KJSO *evaluate();
private:
  Node *expr;
  Operator oper;
};

class DeleteNode : public Node {
public:
  DeleteNode(Node *e) : expr(e) {}
  KJSO *evaluate();
private:
  Node *expr;
};

class VoidNode : public Node {
public:
  VoidNode(Node *e) : expr(e) {}
  KJSO *evaluate();
private:
  Node *expr;
};

class TypeOfNode : public Node {
public:
  TypeOfNode(Node *e) : expr(e) {}
  KJSO *evaluate();
private:
  Node *expr;
};

class PrefixNode : public Node {
public:
  PrefixNode(Operator o, Node *e) : oper(o), expr(e) {}
  KJSO *evaluate();
private:
  Operator oper;
  Node *expr;
};

class UnaryPlusNode : public Node {
public:
  UnaryPlusNode(Node *e) : expr(e) {}
  KJSO *evaluate();
private:
  Node *expr;
};

class NegateNode : public Node {
public:
  NegateNode(Node *e) : expr(e) {}
  KJSO *evaluate();
private:
  Node *expr;
};

class BitwiseNotNode : public Node {
public:
  BitwiseNotNode(Node *e) : expr(e) {}
  KJSO *evaluate();
private:
  Node *expr;
};

class LogicalNotNode : public Node {
public:
  LogicalNotNode(Node *e) : expr(e) {}
  KJSO *evaluate();
private:
  Node *expr;
};

class MultNode : public Node {
public:
  MultNode(Node *t1, Node *t2, int op) : term1(t1), term2(t2), oper(op) {}
  KJSO *evaluate();
private:
  Node *term1, *term2;
  int oper;
};

class AddNode : public Node {
public:
  AddNode(Node *t1, Node *t2, int op) : term1(t1), term2(t2), oper(op) {}
  KJSO *evaluate();
private:
  Node *term1, *term2;
  int oper;
};

class ShiftNode : public Node {
public:
  ShiftNode(Node *t1, Operator o, Node *t2) : term1(t1), term2(t2), oper(o) {}
  KJSO *evaluate();
private:
  Node *term1, *term2;
  Operator oper;
};

class RelationalNode : public Node {
public:
  RelationalNode(Node *e1, Operator o, Node *e2) :
    expr1(e1), expr2(e2), oper(o) {}
  KJSO *evaluate();
private:
  Node *expr1, *expr2;
  Operator oper;
};

class EqualNode : public Node {
public:
  EqualNode(Node *e1, Operator o, Node *e2) : expr1(e1), expr2(e2), oper(o) {}
  KJSO *evaluate();
private:
  Node *expr1, *expr2;
  Operator oper;
};

class BitOperNode : public Node {
public:
  BitOperNode(Node *e1, Operator o, Node *e2) :
    expr1(e1), expr2(e2), oper(o) {}
  KJSO *evaluate();
private:
  Node *expr1, *expr2;
  Operator oper;
};

class BinaryLogicalNode : public Node {
public:
  BinaryLogicalNode(Node *e1, Operator o, Node *e2) :
    expr1(e1), expr2(e2), oper(o) {}
  KJSO *evaluate();
private:
  Node *expr1, *expr2;
  Operator oper;
};

class ConditionalNode : public Node {
public:
  ConditionalNode(Node *l, Node *e1, Node *e2) :
    logical(l), expr1(e1), expr2(e2) {}
  KJSO *evaluate();
private:
  Node *logical, *expr1, *expr2;
};

class AssignNode : public Node {
public:
  AssignNode(Node *l, Operator o, Node *e) : left(l), oper(o), expr(e) {}
  KJSO *evaluate();
private:
  Node *left;
  Operator oper;
  Node *expr;
};

class CommaNode : public Node {
public:
  CommaNode(Node *e1, Node *e2) : expr1(e1), expr2(e2) {}
  KJSO *evaluate();
private:
  Node *expr1, *expr2;
};

class StatListNode : public Node {
public:
  StatListNode(StatementNode *s) : statement(s), list(0L) { }
  StatListNode(StatListNode *l, StatementNode *s) : statement(s), list(l) { }
  KJSO *evaluate();
private:
  StatementNode *statement;
  StatListNode *list;
};

class AssignExprNode : public Node {
public:
  AssignExprNode(Node *e) : expr(e) {}
  KJSO *evaluate();
private:
  Node *expr;
};

class VarDeclNode : public Node {
public:
  VarDeclNode(const CString &id, AssignExprNode *in);
  KJSO *evaluate();
private:
  CString ident;
  AssignExprNode *init;
};

class VarDeclListNode : public Node {
public:
  VarDeclListNode(VarDeclNode *v) : list(0L), var(v) {}
  VarDeclListNode(Node *l, VarDeclNode *v) : list(l), var(v) {}
  KJSO *evaluate();
private:
  Node *list;
  VarDeclNode *var;
};

class VarStatementNode : public StatementNode {
public:
  VarStatementNode(VarDeclListNode *l) : list(l) {}
  KJSO *evaluate();
private:
  VarDeclListNode *list;
};

class BlockNode : public StatementNode {
public:
  BlockNode(StatListNode *s) : statlist(s) {}
  KJSO *evaluate();
private:
  StatListNode *statlist;
};

class EmptyStatementNode : public StatementNode {
public:
  EmptyStatementNode() { } // debug
public:
  KJSO *evaluate();
};

class ExprStatementNode : public StatementNode {
public:
  ExprStatementNode(Node *e) : expr(e) { }
  KJSO *evaluate();
private:
  Node *expr;
};

class IfNode : public StatementNode {
public:
  IfNode(Node *e, StatementNode *s1, StatementNode *s2)
    : expr(e), statement1(s1), statement2(s2) {}
  KJSO *evaluate();
private:
  Node *expr;
  StatementNode *statement1, *statement2;
};

class WhileNode : public StatementNode {
public:
  WhileNode(Node *e, StatementNode *s) : expr(e), statement(s) {}
  KJSO *evaluate();
private:
  Node *expr;
  StatementNode *statement;
};

class ForNode : public StatementNode {
public:
  ForNode(Node *e1, Node *e2, Node *e3, StatementNode *s) :
    expr1(e1), expr2(e2), expr3(e3), stat(s) {}
  KJSO *evaluate();
private:
  Node *expr1, *expr2, *expr3;
  StatementNode *stat;
};

class ForInNode : public StatementNode {
public:
  ForInNode(Node *l, Node *e, StatementNode *s) :
    init(0L), lexpr(l), expr(e), stat(s) {}
  ForInNode(const CString &i, AssignExprNode *in, Node *e, StatementNode *s) :
    ident(i), init(in), lexpr(0L), expr(e), stat(s) {}
  KJSO *evaluate();
private:
  CString ident;
  AssignExprNode *init;
  Node *lexpr, *expr;
  StatementNode *stat;
};

class ContinueNode : public StatementNode {
public:
  KJSO *evaluate();
};

class BreakNode : public StatementNode {
public:
  KJSO *evaluate();
};


class ReturnNode : public StatementNode {
public:
  ReturnNode(Node *v) : value(v) {}
  KJSO *evaluate();
private:
  Node *value;
};

class WithNode : public StatementNode {
public:
  WithNode(Node *e, StatementNode *s) : expr(e), stat(s) {}
  KJSO *evaluate();
private:
  Node *expr;
  StatementNode *stat;
};

class ParameterNode : public Node {
public:
  ParameterNode(const CString &i) : id(i), next(0L) { }
  ParameterNode(ParameterNode *l, const CString &i) : id(i), next(l) { } 
  KJSO *evaluate();
  CString ident() { return id; }
  ParameterNode *nextParam() { return next; }
private:
  CString id;
  ParameterNode *next;
};

class FuncDeclNode : public StatementNode {
public:
  FuncDeclNode(const CString &i, ParameterNode *p, StatementNode *b)
    : ident(i), param(p), block(b) { }
  KJSO *evaluate() { /* empty */ return 0L; }
  void processFuncDecl();
private:
  CString ident;
  ParameterNode *param;
  StatementNode *block;
};

class SourceElementNode : public Node {
public:
  SourceElementNode(StatementNode *s) { statement = s; function = 0L; }
  SourceElementNode(FuncDeclNode *f) { function = f; statement = 0L;}
  KJSO *evaluate();
  virtual void processFuncDecl();
private:
  StatementNode *statement;
  FuncDeclNode *function;
};

class SourceElementsNode : public Node {
public:
  SourceElementsNode(SourceElementNode *s1) { element = s1; elements = 0L; }
  SourceElementsNode(SourceElementsNode *s1, SourceElementNode *s2)
    { elements = s1; element = s2; }
  KJSO *evaluate();
  virtual void processFuncDecl();
private:
  SourceElementNode *element;
  SourceElementsNode *elements;
};

class ProgramNode : public Node {
public:
  ProgramNode(SourceElementsNode *s) : source(s) { Node::prog = this; }
  KJSO *evaluate();
private:
  SourceElementsNode *source;
};

// for debugging
class DebugNode : public StatementNode {
public:
  DebugNode(Node *e) : expr(e) { }
  KJSO *evaluate();
private:
  Node *expr;
};

// for debugging
class AlertNode : public StatementNode {
public:
  AlertNode(Node *e) : expr(e) { }
  KJSO *evaluate();
private:
  Node *expr;
};

};

#endif

Generated by: root@tantive.terraplex.com on Sun Feb 27 17:39:38 2000, using kdoc 2.0a33.