This file is indexed.

/usr/share/pyshared/yapps/runtime.py is in yapps2-runtime 2.1.1-17.2.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below.

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
# Yapps 2 Runtime, part of Yapps 2 - yet another python parser system
# Copyright 1999-2003 by Amit J. Patel <amitp@cs.stanford.edu>
# Enhancements copyright 2003-2004 by Matthias Urlichs <smurf@debian.org>
#
# This version of the Yapps 2 Runtime can be distributed under the
# terms of the MIT open source license, either found in the LICENSE file
# included with the Yapps distribution
# <http://theory.stanford.edu/~amitp/yapps/> or at
# <http://www.opensource.org/licenses/mit-license.php>
#

"""Run time libraries needed to run parsers generated by Yapps.

This module defines parse-time exception classes, a scanner class, a
base class for parsers produced by Yapps, and a context class that
keeps track of the parse stack.

"""

import sys, re

MIN_WINDOW=4096
# File lookup window

class SyntaxError(Exception):
	"""When we run into an unexpected token, this is the exception to use"""
	def __init__(self, pos=None, msg="Bad Token", context=None):
		Exception.__init__(self)
		self.pos = pos
		self.msg = msg
		self.context = context
		
	def __str__(self):
		if not self.pos: return 'SyntaxError'
		else: return 'SyntaxError@%s(%s)' % (repr(self.pos), self.msg)

class NoMoreTokens(Exception):
	"""Another exception object, for when we run out of tokens"""
	pass

class Token(object):
	"""Yapps token.

	This is a container for a scanned token.
	"""

	def __init__(self, type,value, pos=None):
		"""Initialize a token."""
		self.type = type
		self.value = value
		self.pos = pos

	def __repr__(self):
		output = '<%s: %s' % (self.type, repr(self.value))
		if self.pos:
			output += " @ "
			if self.pos[0]:
				output += "%s:" % self.pos[0]
			if self.pos[1]:
				output += "%d" % self.pos[1]
			if self.pos[2] is not None:
				output += ".%d" % self.pos[2]
		output += ">"
		return output

in_name=0
class Scanner(object):
	"""Yapps scanner.

	The Yapps scanner can work in context sensitive or context
	insensitive modes.  The token(i) method is used to retrieve the
	i-th token.  It takes a restrict set that limits the set of tokens
	it is allowed to return.  In context sensitive mode, this restrict
	set guides the scanner.  In context insensitive mode, there is no
	restriction (the set is always the full set of tokens).
	
	"""
	
	def __init__(self, patterns, ignore, input="",
			file=None,filename=None,stacked=False):
		"""Initialize the scanner.

		Parameters:
		  patterns : [(terminal, uncompiled regex), ...] or None
		  ignore : {terminal:None, ...}
		  input : string

		If patterns is None, we assume that the subclass has
		defined self.patterns : [(terminal, compiled regex), ...].
		Note that the patterns parameter expects uncompiled regexes,
		whereas the self.patterns field expects compiled regexes.

		The 'ignore' value is either None or a callable, which is called
		with the scanner and the to-be-ignored match object; this can
		be used for include file or comment handling.
		"""

		if not filename:
			global in_name
			filename="<f.%d>" % in_name
			in_name += 1

		self.input = input
		self.ignore = ignore
		self.file = file
		self.filename = filename
		self.pos = 0
		self.del_pos = 0 # skipped
		self.line = 1
		self.del_line = 0 # skipped
		self.col = 0
		self.tokens = []
		self.stack = None
		self.stacked = stacked
		
		self.last_read_token = None
		self.last_token = None
		self.last_types = None

		if patterns is not None:
			# Compile the regex strings into regex objects
			self.patterns = []
			for terminal, regex in patterns:
				self.patterns.append( (terminal, re.compile(regex)) )

	def stack_input(self, input="", file=None, filename=None):
		"""Temporarily parse from a second file."""

		# Already reading from somewhere else: Go on top of that, please.
		if self.stack:
			# autogenerate a recursion-level-identifying filename
			if not filename:
				filename = 1
			else:
				try:
					filename += 1
				except TypeError:
					pass
				# now pass off to the include file
			self.stack.stack_input(input,file,filename)
		else:

			try:
				filename += 0
			except TypeError:
				pass
			else:
				filename = "<str_%d>" % filename

#			self.stack = object.__new__(self.__class__)
#			Scanner.__init__(self.stack,self.patterns,self.ignore,input,file,filename, stacked=True)

			# Note that the pattern+ignore are added by the generated
			# scanner code
			self.stack = self.__class__(input,file,filename, stacked=True)

	def get_pos(self):
		"""Return a file/line/char tuple."""
		if self.stack: return self.stack.get_pos()

		return (self.filename, self.line+self.del_line, self.col)

#	def __repr__(self):
#		"""Print the last few tokens that have been scanned in"""
#		output = ''
#		for t in self.tokens:
#			output += '%s\n' % (repr(t),)
#		return output
	
	def print_line_with_pointer(self, pos, length=0, out=sys.stderr):
		"""Print the line of 'text' that includes position 'p',
		along with a second line with a single caret (^) at position p"""

		file,line,p = pos
		if file != self.filename:
			if self.stack: return self.stack.print_line_with_pointer(pos,length=length,out=out)
			print >>out, "(%s: not in input buffer)" % file
			return

		text = self.input
		p += length-1 # starts at pos 1

		origline=line
		line -= self.del_line
		spos=0
		if line > 0:
			while 1:
				line = line - 1
				try:
					cr = text.index("\n",spos)
				except ValueError:
					if line:
						text = ""
					break
				if line == 0:
					text = text[spos:cr]
					break
				spos = cr+1
		else:
			print >>out, "(%s:%d not in input buffer)" % (file,origline)
			return

		# Now try printing part of the line
		text = text[max(p-80, 0):p+80]
		p = p - max(p-80, 0)

		# Strip to the left
		i = text[:p].rfind('\n')
		j = text[:p].rfind('\r')
		if i < 0 or (0 <= j < i): i = j
		if 0 <= i < p:
			p = p - i - 1
			text = text[i+1:]

		# Strip to the right
		i = text.find('\n', p)
		j = text.find('\r', p)
		if i < 0 or (0 <= j < i): i = j
		if i >= 0:
			text = text[:i]

		# Now shorten the text
		while len(text) > 70 and p > 60:
			# Cut off 10 chars
			text = "..." + text[10:]
			p = p - 7

		# Now print the string, along with an indicator
		print >>out, '> ',text
		print >>out, '> ',' '*p + '^'
	
	def grab_input(self):
		"""Get more input if possible."""
		if not self.file: return
		if len(self.input) - self.pos >= MIN_WINDOW: return

		data = self.file.read(MIN_WINDOW)
		if data is None or data == "":
			self.file = None

		# Drop bytes from the start, if necessary.
		if self.pos > 2*MIN_WINDOW:
			self.del_pos += MIN_WINDOW
			self.del_line += self.input[:MIN_WINDOW].count("\n")
			self.pos -= MIN_WINDOW
			self.input = self.input[MIN_WINDOW:] + data
		else:
			self.input = self.input + data

	def getchar(self):
		"""Return the next character."""
		self.grab_input()

		c = self.input[self.pos]
		self.pos += 1
		return c

	def token(self, restrict, context=None):
		"""Scan for another token."""

		while 1:
			if self.stack:
				try:
					return self.stack.token(restrict, context)
				except StopIteration:
					self.stack = None

		# Keep looking for a token, ignoring any in self.ignore
			self.grab_input()

			# special handling for end-of-file
			if self.stacked and self.pos==len(self.input):
				raise StopIteration

			# Search the patterns for the longest match, with earlier
			# tokens in the list having preference
			best_match = -1
			best_pat = '(error)'
			best_m = None
			for p, regexp in self.patterns:
				# First check to see if we're ignoring this token
				if restrict and p not in restrict and p not in self.ignore:
					continue
				m = regexp.match(self.input, self.pos)
				if m and m.end()-m.start() > best_match:
					# We got a match that's better than the previous one
					best_pat = p
					best_match = m.end()-m.start()
					best_m = m
					
			# If we didn't find anything, raise an error
			if best_pat == '(error)' and best_match < 0:
				msg = 'Bad Token'
				if restrict:
					msg = 'Trying to find one of '+', '.join(restrict)
				raise SyntaxError(self.get_pos(), msg, context=context)

			ignore = best_pat in self.ignore
			value = self.input[self.pos:self.pos+best_match]
			if not ignore:
				tok=Token(type=best_pat, value=value, pos=self.get_pos())

			self.pos += best_match

			npos = value.rfind("\n")
			if npos > -1:
				self.col = best_match-npos
				self.line += value.count("\n")
			else:
				self.col += best_match

			# If we found something that isn't to be ignored, return it
			if not ignore:
				if len(self.tokens) >= 10:
					del self.tokens[0]
				self.tokens.append(tok)
				self.last_read_token = tok
				# print repr(tok)
				return tok
			else:
				ignore = self.ignore[best_pat]
				if ignore:
					ignore(self, best_m)

	def peek(self, *types, **kw):
		"""Returns the token type for lookahead; if there are any args
		then the list of args is the set of token types to allow"""
		context = kw.get("context",None)
		if self.last_token is None:
			self.last_types = types
			self.last_token = self.token(types,context)
		elif self.last_types:
			for t in types:
				if t not in self.last_types:
					raise NotImplementedError("Unimplemented: restriction set changed")
		return self.last_token.type
		
	def scan(self, type, **kw):
		"""Returns the matched text, and moves to the next token"""
		context = kw.get("context",None)

		if self.last_token is None:
			tok = self.token([type],context)
		else:
			if self.last_types and type not in self.last_types:
				raise NotImplementedError("Unimplemented: restriction set changed")

			tok = self.last_token
			self.last_token = None
		if tok.type != type:
			if not self.last_types: self.last_types=[]
			raise SyntaxError(tok.pos, 'Trying to find '+type+': '+ ', '.join(self.last_types)+", got "+tok.type, context=context)
		return tok.value

class Parser(object):
	"""Base class for Yapps-generated parsers.

	"""
	
	def __init__(self, scanner):
		self._scanner = scanner
		
	def _stack(self, input="",file=None,filename=None):
		"""Temporarily read from someplace else"""
		self._scanner.stack_input(input,file,filename)
		self._tok = None

	def _peek(self, *types, **kw):
		"""Returns the token type for lookahead; if there are any args
		then the list of args is the set of token types to allow"""
		return self._scanner.peek(*types, **kw)
		
	def _scan(self, type, **kw):
		"""Returns the matched text, and moves to the next token"""
		return self._scanner.scan(type, **kw)

class Context(object):
	"""Class to represent the parser's call stack.

	Every rule creates a Context that links to its parent rule.  The
	contexts can be used for debugging.

	"""
	
	def __init__(self, parent, scanner, rule, args=()):
		"""Create a new context.

		Args:
		parent: Context object or None
		scanner: Scanner object
		rule: string (name of the rule)
		args: tuple listing parameters to the rule

		"""
		self.parent = parent
		self.scanner = scanner
		self.rule = rule
		self.args = args
		while scanner.stack: scanner = scanner.stack
		self.token = scanner.last_read_token

	def __str__(self):
		output = ''
		if self.parent: output = str(self.parent) + ' > '
		output += self.rule
		return output
	
def print_error(err, scanner, max_ctx=None):
	"""Print error messages, the parser stack, and the input text -- for human-readable error messages."""
	# NOTE: this function assumes 80 columns :-(
	# Figure out the line number
	pos = err.pos
	if not pos:
		pos = scanner.get_pos()

	file_name, line_number, column_number = pos
	print >>sys.stderr, '%s:%d:%d: %s' % (file_name, line_number, column_number, err.msg)

	scanner.print_line_with_pointer(pos)
		
	context = err.context
	token = None
	while context:
		print >>sys.stderr, 'while parsing %s%s:' % (context.rule, tuple(context.args))
		if context.token:
			token = context.token
		if token:
			scanner.print_line_with_pointer(token.pos, length=len(token.value))
		context = context.parent
		if max_ctx:
			max_ctx = max_ctx-1
			if not max_ctx:
				break

def wrap_error_reporter(parser, rule, *args,**kw):
	try:
		return getattr(parser, rule)(*args,**kw)
	except SyntaxError, e:
		print_error(e, parser._scanner)
	except NoMoreTokens:
		print >>sys.stderr, 'Could not complete parsing; stopped around here:'
		print >>sys.stderr, parser._scanner