Method.h

Go to the documentation of this file.

// 
//   Copyright (C) 2007, 2008, 2009, 2010, 2011, 2012
//   Free Software Foundation, Inc.
// 
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 3 of the License, or
// (at your option) any later version.
// 
// This program 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 General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

#ifndef GNASH_AS_METHOD_H
#define GNASH_AS_METHOD_H

#ifdef HAVE_CONFIG_H
#include "gnashconfig.h"
#endif

#include "string_table.h"
#include "AbcBlock.h"

#include <map>
#include <vector>
#include <list>

// Forward declarations
namespace gnash {
    namespace abc {
        class Machine;
        class abc_function;
        class Namespace;
        class Class;
    }
    class CodeStream;
    class as_object;
}

namespace gnash {
namespace abc {

typedef Property asBinding;

class Method
{
public:
        
    typedef std::list<Class*> ArgumentList;

        Method();

    std::uint32_t methodID() const {
        return _methodID;
    }

    void setMethodID(std::uint32_t m) {
        _methodID = m;
    }

        void initPrototype(Machine* machine);

        std::uint32_t getMaxRegisters() { return _maxRegisters;}

        void setMaxRegisters(std::uint32_t maxRegisters) {
        _maxRegisters = maxRegisters;
    }

        std::uint32_t getBodyLength(){ return _bodyLength;}

        void setBodyLength(std::uint32_t length){ _bodyLength = length;}

    void setMaxStack(std::uint32_t max) {
        _maxStack = max;
    }
 
    std::uint32_t maxStack() const {
        return _maxStack;
    }

    void setMaxScope(std::uint32_t max) {
        _maxScope = max;
    }
 
    std::uint32_t maxScope() const {
        return _maxScope;
    }
    
    void setScopeDepth(std::uint32_t depth) {
        _scopeDepth = depth;
    }
 
    std::uint32_t scopeDepth() const {
        return _scopeDepth;
    }

    abc_function* getPrototype() { return _prototype; }

    void addTrait(const Trait& t) {
        _traits.push_back(t);
    }


    //
    void initTraits(AbcBlock& bl);

        asBinding* getBinding(string_table::key name);

        bool isNative() { return _isNative; }
        bool hasBody() const { return _body != NULL; }

        as_object* construct(as_object* /*base_scope*/) {
        // TODO:
        return NULL;
    }

        bool needsActivation() const {
        return _needsActivation;
    }

    void setNeedsActivation() {
        _needsActivation = true;
    }

        CodeStream *getBody() { return _body; }
        void setBody(CodeStream *b) { _body = b; }

        bool addValue(string_table::key name, Namespace *ns,
            std::uint32_t slotID, Class *type, as_value& val, bool isconst);

        bool addSlot(string_table::key name, Namespace *ns,
            std::uint32_t slotID, Class *type);

        bool addMethod(string_table::key name, Namespace *ns, Method *method);

        bool addGetter(string_table::key name, Namespace *ns, Method *method);

        bool addSetter(string_table::key name, Namespace *ns, Method *method);

        bool addMemberScript(string_table::key name, Namespace *ns,
                std::uint32_t slotID, Class *type);
        
        bool addSlotFunction(string_table::key name, Namespace *ns,
                std::uint32_t slotID, Method *method);

        void setOwner(Class* s);

        Class* getReturnType() const;

    //
        void setReturnType(Class* t);

        Method *getSuper();

        void setSuper(Method* s);

        bool isFinal() const { return _flags & FLAGS_FINAL; }

        void setFinal() { _flags = _flags | FLAGS_FINAL; }

        void unsetFinal() { _flags = _flags & ~FLAGS_FINAL; }

        bool isPrivate() const { return _flags & FLAGS_PRIVATE; }

        void setPrivate() {
        _flags = (_flags & ~(FLAGS_PUBLIC | FLAGS_PROTECTED)) | FLAGS_PRIVATE;
    }

        bool isProtected() const {
        return _flags & FLAGS_PROTECTED;
    }

        void setProtected() {
        _flags = (_flags & ~(FLAGS_PUBLIC | FLAGS_PRIVATE)) | FLAGS_PROTECTED; }

        bool isPublic() const { return _flags & FLAGS_PUBLIC; }

        void setPublic() {
        _flags = (_flags & ~(FLAGS_PRIVATE | FLAGS_PROTECTED)) | FLAGS_PUBLIC;
    }

        int minArgumentCount() const { return _minArguments; }

        void setMinArgumentCount(int i) { _minArguments = i; }

        int maxArgumentCount() const { return _maxArguments; }

        void setMaxArgumentCount(int i) { _maxArguments = i; }

    //
        void pushArgument(Class* t) { _arguments.push_back(t); }

        void pushOptional(const as_value& v) { _optionalArguments.push_back(v); }

        bool optionalArguments() const {
        return minArgumentCount() != maxArgumentCount();
    }

    //
        const ArgumentList& getArgumentList() const { return _arguments; }

        as_function* getImplementation() { return _implementation; }

        void print_body();

private:

        enum Flag
        {
                FLAGS_FINAL = 0x01,
                FLAGS_PROTECTED = 0x02,
                FLAGS_PUBLIC = 0x04,
                FLAGS_PRIVATE = 0x08
        };

        typedef std::map<string_table::key, asBinding> BindingContainer;

        bool addBinding(string_table::key name, asBinding b);
    
    std::vector<Trait> _traits;
        
    std::uint32_t _methodID;

    abc_function* _prototype;
        int _minArguments;
        int _maxArguments;
        std::uint32_t _bodyLength;
        bool _isNative;
        ArgumentList _arguments;
        std::list<as_value> _optionalArguments;
        as_function* _implementation;
        unsigned char _flags;
        CodeStream* _body;
        std::uint32_t _maxRegisters;

    std::uint32_t _scopeDepth;
    std::uint32_t _maxScope;
    std::uint32_t _maxStack;

    bool _needsActivation;

};

} // namespace abc
} // namespace gnash

#endif