Statistics
| Revision:

svn-gvsig-desktop / trunk / org.gvsig.desktop / org.gvsig.desktop.library / org.gvsig.utils / src / main / java / org / gvsig / utils / console / jedit / MakefileTokenMarker.java @ 40561

History | View | Annotate | Download (4.05 KB)

1
/**
2
 * gvSIG. Desktop Geographic Information System.
3
 *
4
 * Copyright (C) 2007-2013 gvSIG Association.
5
 *
6
 * This program is free software; you can redistribute it and/or
7
 * modify it under the terms of the GNU General Public License
8
 * as published by the Free Software Foundation; either version 3
9
 * of the License, or (at your option) any later version.
10
 *
11
 * This program is distributed in the hope that it will be useful,
12
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14
 * GNU General Public License for more details.
15
 *
16
 * You should have received a copy of the GNU General Public License
17
 * along with this program; if not, write to the Free Software
18
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
19
 * MA  02110-1301, USA.
20
 *
21
 * For any additional information, do not hesitate to contact us
22
 * at info AT gvsig.com, or visit our website www.gvsig.com.
23
 */
24
package org.gvsig.utils.console.jedit;
25
/*
26
 * MakefileTokenMarker.java - Makefile token marker
27
 * Copyright (C) 1998, 1999 Slava Pestov
28
 *
29
 * You may use and modify this package for any purpose. Redistribution is
30
 * permitted, in both source and binary form, provided that this notice
31
 * remains intact in all source distributions of this package.
32
 */
33

    
34
import javax.swing.text.Segment;
35

    
36
/**
37
 * Makefile token marker.
38
 *
39
 * @author Slava Pestov
40
 * @version $Id$
41
 */
42
public class MakefileTokenMarker extends TokenMarker
43
{
44
        // public members
45
        public byte markTokensImpl(byte token, Segment line, int lineIndex)
46
        {
47
                char[] array = line.array;
48
                int offset = line.offset;
49
                int lastOffset = offset;
50
                int length = line.count + offset;
51
                boolean backslash = false;
52
loop:                for(int i = offset; i < length; i++)
53
                {
54
                        int i1 = (i+1);
55

    
56
                        char c = array[i];
57
                        if(c == '\\')
58
                        {
59
                                backslash = !backslash;
60
                                continue;
61
                        }
62

    
63
                        switch(token)
64
                        {
65
                        case Token.NULL:
66
                                switch(c)
67
                                {
68
                                case ':': case '=': case ' ': case '\t':
69
                                        backslash = false;
70
                                        if(lastOffset == offset)
71
                                        {
72
                                                addToken(i1 - lastOffset,Token.KEYWORD1);
73
                                                lastOffset = i1;
74
                                        }
75
                                        break;
76
                                case '#':
77
                                        if(backslash)
78
                                                backslash = false;
79
                                        else
80
                                        {
81
                                                addToken(i - lastOffset,token);
82
                                                addToken(length - i,Token.COMMENT1);
83
                                                lastOffset = length;
84
                                                break loop;
85
                                        }
86
                                        break;
87
                                case '$':
88
                                        if(backslash)
89
                                                backslash = false;
90
                                        else if(lastOffset != offset)
91
                                        {
92
                                                addToken(i - lastOffset,token);
93
                                                lastOffset = i;
94
                                                if(length - i > 1)
95
                                                {
96
                                                        char c1 = array[i1];
97
                                                        if(c1 == '(' || c1 == '{')
98
                                                                token = Token.KEYWORD2;
99
                                                        else
100
                                                        {
101
                                                                addToken(2,Token.KEYWORD2);
102
                                                                lastOffset += 2;
103
                                                                i++;
104
                                                        }
105
                                                }
106
                                        }
107
                                        break;
108
                                case '"':
109
                                        if(backslash)
110
                                                backslash = false;
111
                                        else
112
                                        {
113
                                                addToken(i - lastOffset,token);
114
                                                token = Token.LITERAL1;
115
                                                lastOffset = i;
116
                                        }
117
                                        break;
118
                                case '\'':
119
                                        if(backslash)
120
                                                backslash = false;
121
                                        else
122
                                        {
123
                                                addToken(i - lastOffset,token);
124
                                                token = Token.LITERAL2;
125
                                                lastOffset = i;
126
                                        }
127
                                        break;
128
                                default:
129
                                        backslash = false;
130
                                        break;
131
                                }
132
                        case Token.KEYWORD2:
133
                                backslash = false;
134
                                if(c == ')' || c == '}')
135
                                {
136
                                        addToken(i1 - lastOffset,token);
137
                                        token = Token.NULL;
138
                                        lastOffset = i1;
139
                                }
140
                                break;
141
                        case Token.LITERAL1:
142
                                if(backslash)
143
                                        backslash = false;
144
                                else if(c == '"')
145
                                {
146
                                        addToken(i1 - lastOffset,token);
147
                                        token = Token.NULL;
148
                                        lastOffset = i1;
149
                                }
150
                                else
151
                                        backslash = false;
152
                                break;
153
                        case Token.LITERAL2:
154
                                if(backslash)
155
                                        backslash = false;
156
                                else if(c == '\'')
157
                                {
158
                                        addToken(i1 - lastOffset,Token.LITERAL1);
159
                                        token = Token.NULL;
160
                                        lastOffset = i1;
161
                                }
162
                                else
163
                                        backslash = false;
164
                                break;
165
                        }
166
                }
167
                switch(token)
168
                {
169
                case Token.KEYWORD2:
170
                        addToken(length - lastOffset,Token.INVALID);
171
                        token = Token.NULL;
172
                        break;
173
                case Token.LITERAL2:
174
                        addToken(length - lastOffset,Token.LITERAL1);
175
                        break;
176
                default:
177
                        addToken(length - lastOffset,token);
178
                        break;
179
                }
180
                return token;
181
        }
182
}