← Back to branch summary

~oif-team/ubuntu/natty/qt4-x11/xi2.1

« back to all changes in this revision

Viewing changes to src/3rdparty/webkit/JavaScriptCore/parser/Parser.h

  • Committer: Bazaar Package Importer
  • Author(s): Alessandro Ghersi
  • Date: 2009-11-02 18:30:08 UTC
  • mfrom: (1.2.2 upstream)
  • mto: (15.2.5 experimental)
  • mto: This revision was merged to the branch mainline in revision 88.
  • Revision ID: james.westby@ubuntu.com-20091102183008-b6a4gcs128mvfb3m
Tags: upstream-4.6.0~beta1
Import upstream version 4.6.0~beta1

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/3rdparty/webkit/JavaScriptCore/parser/Parser.h
23
23
#ifndef Parser_h
24
24
#define Parser_h
25
25
 
26
 
#include "SourceProvider.h"
27
26
#include "Debugger.h"
 
27
#include "Executable.h"
 
28
#include "JSGlobalObject.h"
 
29
#include "Lexer.h"
28
30
#include "Nodes.h"
 
31
#include "ParserArena.h"
 
32
#include "SourceProvider.h"
29
33
#include <wtf/Forward.h>
30
34
#include <wtf/Noncopyable.h>
31
35
#include <wtf/OwnPtr.h>
37
41
    class ProgramNode;
38
42
    class UString;
39
43
 
40
 
    template <typename T>
41
 
    struct ParserRefCountedData : ParserRefCounted {
42
 
        ParserRefCountedData(JSGlobalData* globalData)
43
 
            : ParserRefCounted(globalData)
44
 
        {
45
 
        }
46
 
 
47
 
        T data;
48
 
    };
49
 
 
50
 
    class Parser : Noncopyable {
 
44
    template <typename T> struct ParserArenaData : ParserArenaDeletable { T data; };
 
45
 
 
46
    class Parser : public Noncopyable {
51
47
    public:
52
 
        template <class ParsedNode> PassRefPtr<ParsedNode> parse(ExecState*, Debugger*, const SourceCode&, int* errLine = 0, UString* errMsg = 0);
53
 
        template <class ParsedNode> PassRefPtr<ParsedNode> reparse(JSGlobalData*, ParsedNode*);
54
 
        void reparseInPlace(JSGlobalData*, FunctionBodyNode*);
55
 
 
56
 
        void didFinishParsing(SourceElements*, ParserRefCountedData<DeclarationStacks::VarStack>*, 
57
 
                              ParserRefCountedData<DeclarationStacks::FunctionStack>*, CodeFeatures features, int lastLine, int numConstants);
 
48
        template <class ParsedNode>
 
49
        PassRefPtr<ParsedNode> parse(JSGlobalData* globalData, Debugger*, ExecState*, const SourceCode& source, int* errLine = 0, UString* errMsg = 0);
 
50
 
 
51
        void didFinishParsing(SourceElements*, ParserArenaData<DeclarationStacks::VarStack>*, 
 
52
                              ParserArenaData<DeclarationStacks::FunctionStack>*, CodeFeatures features, int lastLine, int numConstants);
 
53
 
 
54
        ParserArena& arena() { return m_arena; }
58
55
 
59
56
    private:
60
57
        void parse(JSGlobalData*, int* errLine, UString* errMsg);
61
58
 
 
59
        ParserArena m_arena;
62
60
        const SourceCode* m_source;
63
 
        RefPtr<SourceElements> m_sourceElements;
64
 
        RefPtr<ParserRefCountedData<DeclarationStacks::VarStack> > m_varDeclarations;
65
 
        RefPtr<ParserRefCountedData<DeclarationStacks::FunctionStack> > m_funcDeclarations;
 
61
        SourceElements* m_sourceElements;
 
62
        ParserArenaData<DeclarationStacks::VarStack>* m_varDeclarations;
 
63
        ParserArenaData<DeclarationStacks::FunctionStack>* m_funcDeclarations;
66
64
        CodeFeatures m_features;
67
65
        int m_lastLine;
68
66
        int m_numConstants;
69
67
    };
70
68
 
71
 
    template <class ParsedNode> PassRefPtr<ParsedNode> Parser::parse(ExecState* exec, Debugger* debugger, const SourceCode& source, int* errLine, UString* errMsg)
 
69
    template <class ParsedNode>
 
70
    PassRefPtr<ParsedNode> Parser::parse(JSGlobalData* globalData, Debugger* debugger, ExecState* debuggerExecState, const SourceCode& source, int* errLine, UString* errMsg)
72
71
    {
73
72
        m_source = &source;
74
 
        parse(&exec->globalData(), errLine, errMsg);
75
 
        RefPtr<ParsedNode> result;
76
 
        if (m_sourceElements) {
77
 
            result = ParsedNode::create(&exec->globalData(),
78
 
                                         m_sourceElements.get(),
79
 
                                         m_varDeclarations ? &m_varDeclarations->data : 0, 
80
 
                                         m_funcDeclarations ? &m_funcDeclarations->data : 0,
81
 
                                         *m_source,
82
 
                                         m_features,
83
 
                                         m_numConstants);
84
 
            result->setLoc(m_source->firstLine(), m_lastLine);
85
 
        }
86
 
 
87
 
        m_source = 0;
88
 
        m_sourceElements = 0;
89
 
        m_varDeclarations = 0;
90
 
        m_funcDeclarations = 0;
91
 
 
92
 
        if (debugger)
93
 
            debugger->sourceParsed(exec, source, *errLine, *errMsg);
94
 
        return result.release();
95
 
    }
96
 
 
97
 
    template <class ParsedNode> PassRefPtr<ParsedNode> Parser::reparse(JSGlobalData* globalData, ParsedNode* oldParsedNode)
98
 
    {
99
 
        m_source = &oldParsedNode->source();
100
 
        parse(globalData, 0, 0);
 
73
        if (ParsedNode::scopeIsFunction)
 
74
            globalData->lexer->setIsReparsing();
 
75
        parse(globalData, errLine, errMsg);
 
76
 
101
77
        RefPtr<ParsedNode> result;
102
78
        if (m_sourceElements) {
103
79
            result = ParsedNode::create(globalData,
104
 
                                        m_sourceElements.get(),
105
 
                                        m_varDeclarations ? &m_varDeclarations->data : 0, 
106
 
                                        m_funcDeclarations ? &m_funcDeclarations->data : 0,
107
 
                                        *m_source,
108
 
                                        oldParsedNode->features(),
109
 
                                        m_numConstants);
 
80
            m_sourceElements,
 
81
            m_varDeclarations ? &m_varDeclarations->data : 0,
 
82
            m_funcDeclarations ? &m_funcDeclarations->data : 0,
 
83
            source,
 
84
            m_features,
 
85
            m_numConstants);
110
86
            result->setLoc(m_source->firstLine(), m_lastLine);
111
87
        }
112
88
 
 
89
        m_arena.reset();
 
90
 
113
91
        m_source = 0;
114
92
        m_sourceElements = 0;
115
93
        m_varDeclarations = 0;
116
94
        m_funcDeclarations = 0;
117
95
 
 
96
        if (debugger && !ParsedNode::scopeIsFunction)
 
97
            debugger->sourceParsed(debuggerExecState, source, *errLine, *errMsg);
118
98
        return result.release();
119
99
    }
120
100