← Back to branch summary

~ubuntu-branches/ubuntu/quantal/mysql-workbench/quantal

« back to all changes in this revision

Viewing changes to ext/scintilla/lexlib/LexAccessor.h

  • Committer: Package Import Robot
  • Author(s): Dmitry Smirnov
  • Date: 2012-03-01 21:57:30 UTC
  • Revision ID: package-import@ubuntu.com-20120301215730-o7y8av8y38n162ro
Tags: upstream-5.2.38+dfsg
Import upstream version 5.2.38+dfsg

Show diffs side-by-side

added added

removed removed

Lines of Context:
ext/scintilla/lexlib/LexAccessor.h
 
1
// Scintilla source code edit control
 
2
/** @file LexAccessor.h
 
3
 ** Interfaces between Scintilla and lexers.
 
4
 **/
 
5
// Copyright 1998-2010 by Neil Hodgson <neilh@scintilla.org>
 
6
// The License.txt file describes the conditions under which this software may be distributed.
 
7
 
 
8
#ifndef LEXACCESSOR_H
 
9
#define LEXACCESSOR_H
 
10
 
 
11
#ifdef SCI_NAMESPACE
 
12
namespace Scintilla {
 
13
#endif
 
14
 
 
15
class LexAccessor {
 
16
private:
 
17
        IDocument *pAccess;
 
18
        enum {extremePosition=0x7FFFFFFF};
 
19
        /** @a bufferSize is a trade off between time taken to copy the characters
 
20
         * and retrieval overhead.
 
21
         * @a slopSize positions the buffer before the desired position
 
22
         * in case there is some backtracking. */
 
23
        enum {bufferSize=4000, slopSize=bufferSize/8};
 
24
        char buf[bufferSize+1];
 
25
        int startPos;
 
26
        int endPos;
 
27
        int codePage;
 
28
        int lenDoc;
 
29
        int mask;
 
30
        char styleBuf[bufferSize];
 
31
        int validLen;
 
32
        char chFlags;
 
33
        char chWhile;
 
34
        unsigned int startSeg;
 
35
        int startPosStyling;
 
36
 
 
37
        void Fill(int position) {
 
38
                startPos = position - slopSize;
 
39
                if (startPos + bufferSize > lenDoc)
 
40
                        startPos = lenDoc - bufferSize;
 
41
                if (startPos < 0)
 
42
                        startPos = 0;
 
43
                endPos = startPos + bufferSize;
 
44
                if (endPos > lenDoc)
 
45
                        endPos = lenDoc;
 
46
 
 
47
                pAccess->GetCharRange(buf, startPos, endPos-startPos);
 
48
                buf[endPos-startPos] = '\0';
 
49
        }
 
50
 
 
51
public:
 
52
        LexAccessor(IDocument *pAccess_) :
 
53
                pAccess(pAccess_), startPos(extremePosition), endPos(0),
 
54
                codePage(pAccess->CodePage()), lenDoc(pAccess->Length()),
 
55
                mask(127), validLen(0), chFlags(0), chWhile(0),
 
56
                startSeg(0), startPosStyling(0) {
 
57
        }
 
58
        char operator[](int position) {
 
59
                if (position < startPos || position >= endPos) {
 
60
                        Fill(position);
 
61
                }
 
62
                return buf[position - startPos];
 
63
        }
 
64
        /** Safe version of operator[], returning a defined value for invalid position. */
 
65
        char SafeGetCharAt(int position, char chDefault=' ') {
 
66
                if (position < startPos || position >= endPos) {
 
67
                        Fill(position);
 
68
                        if (position < startPos || position >= endPos) {
 
69
                                // Position is outside range of document
 
70
                                return chDefault;
 
71
                        }
 
72
                }
 
73
                return buf[position - startPos];
 
74
        }
 
75
        bool IsLeadByte(char ch) {
 
76
                return pAccess->IsDBCSLeadByte(ch);
 
77
        }
 
78
 
 
79
        bool Match(int pos, const char *s) {
 
80
                for (int i=0; *s; i++) {
 
81
                        if (*s != SafeGetCharAt(pos+i))
 
82
                                return false;
 
83
                        s++;
 
84
                }
 
85
                return true;
 
86
        }
 
87
        char StyleAt(int position) {
 
88
                return static_cast<char>(pAccess->StyleAt(position) & mask);
 
89
        }
 
90
        int GetLine(int position) {
 
91
                return pAccess->LineFromPosition(position);
 
92
        }
 
93
        int LineStart(int line) {
 
94
                return pAccess->LineStart(line);
 
95
        }
 
96
        int LevelAt(int line) {
 
97
                return pAccess->GetLevel(line);
 
98
        }
 
99
        int Length() const {
 
100
                return lenDoc;
 
101
        }
 
102
        void Flush() {
 
103
                startPos = extremePosition;
 
104
                if (validLen > 0) {
 
105
                        pAccess->SetStyles(validLen, styleBuf);
 
106
                        startPosStyling += validLen;
 
107
                        validLen = 0;
 
108
                }
 
109
        }
 
110
        int GetLineState(int line) {
 
111
                return pAccess->GetLineState(line);
 
112
        }
 
113
        int SetLineState(int line, int state) {
 
114
                return pAccess->SetLineState(line, state);
 
115
        }
 
116
        // Style setting
 
117
        void StartAt(unsigned int start, char chMask=31) {
 
118
                // Store the mask specified for use with StyleAt.
 
119
                mask = chMask;
 
120
                pAccess->StartStyling(start, chMask);
 
121
                startPosStyling = start;
 
122
        }
 
123
        void SetFlags(char chFlags_, char chWhile_) {
 
124
                chFlags = chFlags_;
 
125
                chWhile = chWhile_;
 
126
        }
 
127
        unsigned int GetStartSegment() const {
 
128
                return startSeg;
 
129
        }
 
130
        void StartSegment(unsigned int pos) {
 
131
                startSeg = pos;
 
132
        }
 
133
        void ColourTo(unsigned int pos, int chAttr) {
 
134
                // Only perform styling if non empty range
 
135
                if (pos != startSeg - 1) {
 
136
                        assert(pos >= startSeg);
 
137
                        if (pos < startSeg) {
 
138
                                return;
 
139
                        }
 
140
 
 
141
                        if (validLen + (pos - startSeg + 1) >= bufferSize)
 
142
                                Flush();
 
143
                        if (validLen + (pos - startSeg + 1) >= bufferSize) {
 
144
                                // Too big for buffer so send directly
 
145
                                pAccess->SetStyleFor(pos - startSeg + 1, static_cast<char>(chAttr));
 
146
                        } else {
 
147
                                if (chAttr != chWhile)
 
148
                                        chFlags = 0;
 
149
                                chAttr |= chFlags;
 
150
                                for (unsigned int i = startSeg; i <= pos; i++) {
 
151
                                        assert((startPosStyling + validLen) < Length());
 
152
                                        styleBuf[validLen++] = static_cast<char>(chAttr);
 
153
                                }
 
154
                        }
 
155
                }
 
156
                startSeg = pos+1;
 
157
        }
 
158
        void SetLevel(int line, int level) {
 
159
                pAccess->SetLevel(line, level);
 
160
        }
 
161
        void IndicatorFill(int start, int end, int indicator, int value) {
 
162
                pAccess->DecorationSetCurrentIndicator(indicator);
 
163
                pAccess->DecorationFillRange(start, value, end - start);
 
164
        }
 
165
 
 
166
        void ChangeLexerState(int start, int end) {
 
167
                pAccess->ChangeLexerState(start, end);
 
168
        }
 
169
};
 
170
 
 
171
#ifdef SCI_NAMESPACE
 
172
}
 
173
#endif
 
174
 
 
175
#endif