File: function.h

package info (click to toggle)
kdelibs 4:2.2.2-13.woody.14
  • links: PTS
  • area: main
  • in suites: woody
  • size: 36,832 kB
  • ctags: 40,077
  • sloc: cpp: 313,284; ansic: 20,558; xml: 11,448; sh: 11,318; makefile: 2,426; perl: 2,084; yacc: 1,663; java: 1,538; lex: 629; python: 300
file content (134 lines) | stat: -rw-r--r-- 3,991 bytes parent folder | download
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
/*
 *  This file is part of the KDE libraries
 *  Copyright (C) 1999-2000 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 _KJS_FUNCTION_H_
#define _KJS_FUNCTION_H_

#include <assert.h>

#include "object.h"
#include "types.h"

namespace KJS {

  enum CodeType { GlobalCode,
		  EvalCode,
		  FunctionCode,
		  AnonymousCode,
		  HostCode };

  enum FunctionAttribute { ImplicitNone, ImplicitThis, ImplicitParents };

  class Function;
  class Parameter;

  /**
   * @short Implementation class for Functions.
   */
  class FunctionImp : public ObjectImp {
    friend class Function;
  public:
    FunctionImp();
    FunctionImp(const UString &n);
    virtual ~FunctionImp();
    virtual const TypeInfo* typeInfo() const { return &info; }
    static const TypeInfo info;
    virtual Completion execute(const List &) = 0;
    bool hasAttribute(FunctionAttribute a) const { return (attr & a) != 0; }
    virtual CodeType codeType() const = 0;
    KJSO thisValue() const;
    void addParameter(const UString &n);
    void setLength(int l);
    KJSO executeCall(Imp *thisV, const List *args);
    KJSO executeCall(Imp *thisV, const List *args, const List *extraScope);
    UString name() const;
  protected:
    UString ident;
    FunctionAttribute attr;
    Parameter *param;
  private:
    void processParameters(const List *);
  };

  /**
   * @short Abstract base class for internal functions.
   */
  class InternalFunctionImp : public FunctionImp {
  public:
    InternalFunctionImp();
    InternalFunctionImp(int l);
    InternalFunctionImp(const UString &n);
    virtual ~InternalFunctionImp() { }
    virtual String toString() const;
    virtual KJSO toPrimitive(Type) const { return toString(); }
    virtual const TypeInfo* typeInfo() const { return &info; }
    static const TypeInfo info;
    virtual Completion execute(const List &);
    virtual CodeType codeType() const { return HostCode; }
  };

  /**
   * @short Base class for Function objects.
   */
  class Function : public KJSO {
  public:
    Function(Imp *);
    virtual ~Function() { }
    Completion execute(const List &);
    bool hasAttribute(FunctionAttribute a) const;
    CodeType codeType() const { return HostCode; }
    KJSO thisValue() const;
  };
  
  /**
   * @short Implementation class for Constructors.
   */
  class ConstructorImp : public InternalFunctionImp {
  public:
    ConstructorImp();
    ConstructorImp(const UString &n);	/* TODO: add length */
    ConstructorImp(const KJSO &, int);
    ConstructorImp(const UString &n, const KJSO &p, int len);
    virtual ~ConstructorImp();
    virtual const TypeInfo* typeInfo() const { return &info; }
    static const TypeInfo info;
    virtual Completion execute(const List &);
    virtual Object construct(const List &) = 0;
  };

  /**
    * @short Constructor object for use with the 'new' operator
    */
  class Constructor : public Function {
  public:
    Constructor(Imp *);
    virtual ~Constructor();
    //    Constructor(const Object& proto, int len);
    /**
     * @return @ref ConstructorType
     */
    Completion execute(const List &);
    Object construct(const List &args);
    static Constructor dynamicCast(const KJSO &obj);
  };

}; // namespace

#endif