Sass::Script::Lexer

     # File lib/sass/script/lexer.rb, line 128
128:       def initialize(str, line, offset, options)
129:         @scanner = str.is_a?(StringScanner) ? str : StringScanner.new(str)
130:         @line = line
131:         @offset = offset
132:         @options = options
133:         @interpolation_stack = []
134:         @prev = nil
135:       end

     # File lib/sass/script/lexer.rb, line 101
101:         def string_re(open, close)
102:           /#{open}((?:\\.|\#(?!\{)|[^#{close}\\#])*)(#{close}|#\{)/
103:         end

     # File lib/sass/script/lexer.rb, line 179
179:       def after_interpolation?
180:         @prev && @prev.type == :end_interpolation
181:       end

     # File lib/sass/script/lexer.rb, line 173
173:       def done?
174:         whitespace unless after_interpolation? && @interpolation_stack.last
175:         @scanner.eos? && @tok.nil?
176:       end

     # File lib/sass/script/lexer.rb, line 191
191:       def expected!(name)
192:         unpeek!
193:         Sass::SCSS::Parser.expected(@scanner, name, @line)
194:       end

     # File lib/sass/script/lexer.rb, line 140
140:       def next
141:         @tok ||= read_token
142:         @tok, tok = nil, @tok
143:         @prev = tok
144:         return tok
145:       end

     # File lib/sass/script/lexer.rb, line 162
162:       def peek
163:         @tok ||= read_token
164:       end

     # File lib/sass/script/lexer.rb, line 201
201:       def str
202:         old_pos = @tok ? @tok.pos : @scanner.pos
203:         yield
204:         new_pos = @tok ? @tok.pos : @scanner.pos
205:         @scanner.string[old_pos...new_pos]
206:       end

     # File lib/sass/script/lexer.rb, line 168
168:       def unpeek!
169:         @scanner.pos = @tok.pos if @tok
170:       end

     # File lib/sass/script/lexer.rb, line 150
150:       def whitespace?(tok = @tok)
151:         if tok
152:           @scanner.string[0...tok.pos] =~ /\s\Z/
153:         else
154:           @scanner.string[@scanner.pos, 1] =~ /^\s/ ||
155:             @scanner.string[@scanner.pos - 1, 1] =~ /\s\Z/
156:         end
157:       end

     # File lib/sass/script/lexer.rb, line 241
241:       def _variable(rx)
242:         line = @line
243:         offset = @offset
244:         return unless scan(rx)
245:         if @scanner[1] == '!' && @scanner[2] != 'important'
246:           Script.var_warning(@scanner[2], line, offset + 1, @options[:filename])
247:         end
248: 
249:         [:const, @scanner[2]]
250:       end

     # File lib/sass/script/lexer.rb, line 252
252:       def ident
253:         return unless scan(REGULAR_EXPRESSIONS[:ident])
254:         [@scanner[2] ? :funcall : :ident, @scanner[1]]
255:       end

     # File lib/sass/script/lexer.rb, line 210
210:       def read_token
211:         return if done?
212:         return unless value = token
213:         type, val, size = value
214:         size ||= @scanner.matched_size
215: 
216:         val.line = @line if val.is_a?(Script::Node)
217:         Token.new(type, val, @line,
218:           current_position - size, @scanner.pos - size)
219:       end

     # File lib/sass/script/lexer.rb, line 257
257:       def string(re, open)
258:         return unless scan(STRING_REGULAR_EXPRESSIONS[[re, open]])
259:         if @scanner[2] == '#{' #'
260:           @scanner.pos -= 2 # Don't actually consume the #{
261:           @interpolation_stack << re
262:         end
263:         str =
264:           if re == :uri
265:             Script::String.new("#{'url(' unless open}#{@scanner[1]}#{')' unless @scanner[2] == '#{'}")
266:           else
267:             Script::String.new(@scanner[1].gsub(/\\(['"]|\#\{)/, '\1'), :string)
268:           end
269:         [:string, str]
270:       end
271: 
272:       def number
273:         return unless scan(REGULAR_EXPRESSIONS[:number])
274:         value = @scanner[2] ? @scanner[2].to_f : @scanner[3].to_i
275:         value = -value if @scanner[1]
276:         [:number, Script::Number.new(value, Array(@scanner[4]))]
277:       end
278: 
279:       def color
280:         return unless s = scan(REGULAR_EXPRESSIONS[:color])
281:         raise Sass::SyntaxError.new(<<MESSAGE) unless s.size == 4 || s.size == 7
282: Colors must have either three or six digits: '#{s}'
283: MESSAGE
284:         value = s.scan(/^#(..?)(..?)(..?)$/).first.
285:           map {|num| num.ljust(2, num).to_i(16)}
286:         [:color, Script::Color.new(value)]
287:       end
288: 
289:       def bool
290:         return unless s = scan(REGULAR_EXPRESSIONS[:bool])
291:         [:bool, Script::Bool.new(s == 'true')]
292:       end
293: 
294:       def special_fun
295:         return unless str1 = scan(/((-[\w-]+-)?calc|expression|progid:[a-z\.]*)\(/i)
296:         str2, _ = Haml::Shared.balance(@scanner, ?(, ?), 1)
297:         c = str2.count("\n")
298:         old_line = @line
299:         old_offset = @offset
300:         @line += c
301:         @offset = (c == 0 ? @offset + str2.size : str2[/\n(.*)/, 1].size)
302:         [:special_fun,
303:           Haml::Util.merge_adjacent_strings(
304:             [str1] + Sass::Engine.parse_interp(str2, old_line, old_offset, @options)),
305:           str1.size + str2.size]
306:       end
307: 
308:       def ident_op
309:         return unless op = scan(REGULAR_EXPRESSIONS[:ident_op])
310:         [OPERATORS[op]]
311:       end
312: 
313:       def op
314:         return unless op = scan(REGULAR_EXPRESSIONS[:op])
315:         @interpolation_stack << nil if op == :begin_interpolation
316:         [OPERATORS[op]]
317:       end
318: 
319:       def raw(rx)
320:         return unless val = scan(rx)
321:         [:raw, val]
322:       end
323: 
324:       def scan(re)
325:         return unless str = @scanner.scan(re)
326:         c = str.count("\n")
327:         @line += c
328:         @offset = (c == 0 ? @offset + str.size : str[/\n(.*)/, 1].size)
329:         str
330:       end
331: 
332:       def current_position
333:         @offset + 1
334:       end
335:     end
336:   end
337: end
338: 

     # File lib/sass/script/lexer.rb, line 227
227:       def token
228:         if after_interpolation? && (interp_type = @interpolation_stack.pop)
229:           return string(interp_type, true)
230:         end
231: 
232:         variable || string(:double, false) || string(:single, false) || number ||
233:           color || bool || string(:uri, false) || raw(UNICODERANGE) ||
234:           special_fun || ident_op || ident || op
235:       end

     # File lib/sass/script/lexer.rb, line 237
237:       def variable
238:         _variable(REGULAR_EXPRESSIONS[:variable])
239:       end

     # File lib/sass/script/lexer.rb, line 221
221:       def whitespace
222:         nil while scan(REGULAR_EXPRESSIONS[:whitespace]) ||
223:           scan(REGULAR_EXPRESSIONS[:comment]) ||
224:           scan(REGULAR_EXPRESSIONS[:single_line_comment])
225:       end