import sys
import os
-import string
import errno
import sunaudiodev
from SUNAUDIODEV import *
fp = open(readmefile)
contents = fp.read()
# wax the last page, it contains Emacs cruft
- i = string.rfind(contents, '\f')
+ i = contents.rfind('\f')
if i > 0:
- contents = string.rstrip(contents[:i])
+ contents = contents[:i].rstrip()
finally:
if fp:
fp.close()
self.argumentList.append(arg)
def docstring(self):
- import string
input = []
output = []
for arg in self.argumentList:
if not input:
instr = "()"
else:
- instr = "(%s)" % string.joinfields(input, ", ")
+ instr = "(%s)" % ", ".join(input)
if not output or output == ["void"]:
outstr = "None"
else:
- outstr = "(%s)" % string.joinfields(output, ", ")
+ outstr = "(%s)" % ", ".join(output)
return instr + " -> " + outstr
def functionbody(self):
text = format % args
if _Level > 0:
indent = '\t' * _Level
- import string
- lines = string.splitfields(text, '\n')
+ lines = text.split('\n')
for i in range(len(lines)):
if lines[i] and lines[i][0] != '#':
lines[i] = indent + lines[i]
- text = string.joinfields(lines, '\n')
+ text = '\n'.join(lines)
_File.write(text + '\n')
def IndentLevel(by = 1):
"""
# (Don't you love using triple quotes *inside* triple quotes? :-)
- import string
- lines = string.splitfields(text, '\n')
+ lines = text.split('\n')
indent = ""
for line in lines:
- if string.strip(line):
+ if line.strip():
for c in line:
- if c not in string.whitespace:
+ if not c.isspace():
break
indent = indent + c
break
"""
import re
-import string
import sys
import os
import fnmatch
for type in types:
modes = self.usedtypes[type].keys()
modes.sort()
- self.report("%s %s", type, string.join(modes))
-
+ self.report("%s %s", type, " ".join(modes))
+
def gentypetest(self, file):
fp = open(file, "w")
fp.write("types=[\n")
while line[-2:] == '\\\n':
line = line[:-2] + ' ' + f.readline()
lineno = lineno + 1
- i = string.find(line, '#')
+ i = line.find('#')
if i >= 0: line = line[:i]
- words = map(string.strip, string.splitfields(line, ':'))
+ words = [s.strip() for s in line.split(':')]
if words == ['']: continue
if len(words) <> 3:
print "Line", startlineno,
print "Empty pattern"
print `line`
continue
- patparts = map(string.strip, string.splitfields(pat, ','))
- repparts = map(string.strip, string.splitfields(rep, ','))
+ patparts = [s.strip() for s in pat.split(',')]
+ repparts = [s.strip() for s in rep.split(',')]
patterns = []
for p in patparts:
if not p:
print "Empty pattern part"
print `line`
continue
- pattern = string.split(p)
+ pattern = p.split()
if len(pattern) > 3:
print "Line", startlineno,
print "Pattern part has > 3 words"
print "Empty replacement part"
print `line`
continue
- replacement = string.split(p)
+ replacement = p.split()
if len(replacement) > 3:
print "Line", startlineno,
print "Pattern part has > 3 words"
self.generate(type, name, arglist)
def extractarglist(self, args):
- args = string.strip(args)
+ args = args.strip()
if not args or args == "void":
return []
- parts = map(string.strip, string.splitfields(args, ","))
+ parts = [s.strip() for s in args.split(",")]
arglist = []
for part in parts:
arg = self.extractarg(part)
# array matches an optional [] after the argument name
type = type + " ptr "
type = re.sub("\*", " ptr ", type)
- type = string.strip(type)
+ type = type.strip()
type = re.sub("[ \t]+", "_", type)
return self.modifyarg(type, name, mode)
if item[i] == '*':
newitem[i] = old[k][i]
elif item[i][:1] == '$':
- index = string.atoi(item[i][1:]) - 1
+ index = int(item[i][1:]) - 1
newitem[i] = old[index][i]
new.append(tuple(newitem))
##self.report("old: %s", `old`)
"""
-import sys, string, time, os, stat, re, cgi, faqconf
+import sys, time, os, stat, re, cgi, faqconf
from faqconf import * # This imports all uppercase names
now = time.time()
self.why = why
def escape(s):
- s = string.replace(s, '&', '&')
- s = string.replace(s, '<', '<')
- s = string.replace(s, '>', '>')
+ s = s.replace('&', '&')
+ s = s.replace('<', '<')
+ s = s.replace('>', '>')
return s
def escapeq(s):
s = escape(s)
- s = string.replace(s, '"', '"')
+ s = s.replace('"', '"')
return s
def _interpolate(format, args, kw):
list.append(repl)
j = len(text)
list.append(escape(text[i:j]))
- return string.join(list, '')
+ return ''.join(list)
def emphasize(line):
return re.sub(r'\*([a-zA-Z]+)\*', r'<I>\1</I>', line)
m = revparse_prog.match(rev)
if not m:
return None
- [major, minor] = map(string.atoi, m.group(1, 2))
+ [major, minor] = map(int, m.group(1, 2))
return major, minor
logon = 0
if not os.environ.has_key('HTTP_COOKIE'):
return {}
raw = os.environ['HTTP_COOKIE']
- words = map(string.strip, string.split(raw, ';'))
+ words = [s.strip() for s in raw.split(';')]
cookies = {}
for word in words:
- i = string.find(word, '=')
+ i = word.find('=')
if i >= 0:
key, value = word[:i], word[i+1:]
cookies[key] = value
return {}
import urllib
value = urllib.unquote(value)
- words = string.split(value, '/')
+ words = value.split('/')
while len(words) < 3:
words.append('')
- author = string.join(words[:-2], '/')
+ author = '/'.join(words[:-2])
email = words[-2]
password = words[-1]
return {'author': author,
except (TypeError, KeyError):
value = ''
else:
- value = string.strip(value)
+ value = value.strip()
setattr(self, name, value)
return value
if fp:
import rfc822
self.__headers = rfc822.Message(fp)
- self.body = string.strip(fp.read())
+ self.body = fp.read().strip()
else:
self.__headers = {'title': "%d.%d. " % sec_num}
self.body = ''
def __getattr__(self, name):
if name[0] == '_':
raise AttributeError
- key = string.join(string.split(name, '_'), '-')
+ key = '-'.join(name.split('_'))
try:
value = self.__headers[key]
except KeyError:
if not line:
break
if line[:5] == 'head:':
- version = string.strip(line[5:])
+ version = line[5:].strip()
p.close()
self.version = version
emit(ENTRY_HEADER2, self)
pre = 0
raw = 0
- for line in string.split(self.body, '\n'):
+ for line in self.body.split('\n'):
# Allow the user to insert raw html into a FAQ answer
# (Skip Montanaro, with changes by Guido)
- tag = string.lower(string.rstrip(line))
+ tag = line.rstrip().lower()
if tag == '<html>':
raw = 1
continue
if raw:
print line
continue
- if not string.strip(line):
+ if not line.strip():
if pre:
print '</PRE>'
pre = 0
else:
print '<P>'
else:
- if line[0] not in string.whitespace:
+ if not line[0].isspace():
if pre:
print '</PRE>'
pre = 0
if not m:
return None
sec, num = m.group(1, 2)
- return string.atoi(sec), string.atoi(num)
+ return int(sec), int(num)
def list(self):
# XXX Caller shouldn't modify result
return
words = map(lambda w: r'\b%s\b' % w, words)
if self.ui.querytype[:3] == 'any':
- queries = [string.join(words, '|')]
+ queries = ['|'.join(words)]
else:
# Each of the individual queries must match
queries = words
if not self.ui.days:
days = 1
else:
- days = string.atof(self.ui.days)
+ days = float(self.ui.days)
try:
cutoff = now - days * 24 * 3600
except OverflowError:
output = os.popen(command).read()
sys.stdout.write('<PRE>')
athead = 0
- lines = string.split(output, '\n')
+ lines = output.split('\n')
while lines and not lines[-1]:
del lines[-1]
if lines:
headrev = None
for line in lines:
if entry and athead and line[:9] == 'revision ':
- rev = string.strip(line[9:])
+ rev = line[9:].split()
mami = revparse(rev)
if not mami:
print line
print '</PRE>'
def do_new(self):
- entry = self.dir.new(section=string.atoi(self.ui.section))
+ entry = self.dir.new(section=int(self.ui.section))
entry.version = '*new*'
self.prologue(T_EDIT)
emit(EDITHEAD)
entry = self.dir.open(self.ui.file)
entry.load_version()
# Check that the FAQ entry number didn't change
- if string.split(self.ui.title)[:1] != string.split(entry.title)[:1]:
+ if self.ui.title.split()[:1] != entry.title.split()[:1]:
self.error("Don't change the entry number please!")
return
# Check that the edited version is the current version
if '\r' in self.ui.body:
self.ui.body = re.sub('\r\n?', '\n', self.ui.body)
# Normalize whitespace in title
- self.ui.title = string.join(string.split(self.ui.title))
+ self.ui.title = ' '.join(self.ui.title.split())
# Check that there were any changes
if self.ui.body == entry.body and self.ui.title == entry.title:
self.error("You didn't make any changes!")
# and one or more .o files or a lib.a file.
import os
-import string
import parsesetup
def checkextensions(unknown, extensions):
if not w:
continue
w = expandvars(w, vars)
- for w in string.split(w):
+ for w in w.split():
if skipofiles and w[-2:] == '.o':
continue
# Assume $var expands to absolute pathname
def expandvars(str, vars):
i = 0
while i < len(str):
- i = k = string.find(str, '$', i)
+ i = k = str.find('$', i)
if i < 0:
break
i = i+1
var = str[i:i+1]
i = i+1
if var == '(':
- j = string.find(str, ')', i)
+ j = str.find(')', i)
if j < 0:
break
var = str[i:j]
but an obvious enhancement would be to provide command line options.
"""
-import os, string, sys
+import os, sys
try:
import win32api
except ImportError:
module.AddCompilerOption(win32api.ExpandEnvironmentStrings(cl_options))
exclude = win32api.GetProfileVal(moduleName, "exclude", "", mapFileName)
- exclude = string.split(exclude)
+ exclude = exclude.split()
if win32api.GetProfileVal(moduleName, "Unicode", 0, mapFileName):
module.AddCompilerOption('/D UNICODE /D _UNICODE')
- libs = string.split(win32api.GetProfileVal(moduleName, "libs", "", mapFileName))
+ libs = win32api.GetProfileVal(moduleName, "libs", "", mapFileName).split()
for lib in libs:
module.AddLinkerLib(win32api.ExpandEnvironmentStrings(lib))
sys.stderr.write("%s: %s\n" % (dsp, msg))
return None
for line in lines:
- fields = string.split(string.strip(line), "=", 2)
+ fields = line.strip().split("=", 2)
if fields[0]=="SOURCE":
- if string.lower(os.path.splitext(fields[1])[1]) in ['.cpp', '.c']:
+ if os.path.splitext(fields[1])[1].lower() in ['.cpp', '.c']:
ret.append( win32api.GetFullPathName(os.path.join(dsp_path, fields[1] ) ) )
return ret
# Write fn protos
for module in modules:
# bit of a hack for .pyd's as part of packages.
- name = string.split(module.name,'.')[-1]
+ name = module.name.split('.')[-1]
fp.write('extern void init%s(void);\n' % (name) )
# Write the table
fp.write (ext_tab_header)
for module in modules:
- name = string.split(module.name,'.')[-1]
+ name = module.name.split('.')[-1]
fp.write('\t{"%s", init%s},\n' % (name, name) )
fp.write (ext_tab_footer)
import getopt
import os
-import string
import sys
# last option can not be "-i", so this ensures "pos+1" is in range!
if sys.argv[pos] == '-i':
try:
- options = string.split(open(sys.argv[pos+1]).read())
+ options = open(sys.argv[pos+1]).read().split()
except IOError, why:
usage("File name '%s' specified with the -i option "
"can not be read - %s" % (sys.argv[pos+1], why) )
if o == '-l':
addn_link.append(a)
if o == '-a':
- apply(modulefinder.AddPackagePath, tuple(string.split(a,"=", 2)))
+ apply(modulefinder.AddPackagePath, tuple(a.split("=", 2)))
if o == '-r':
- f,r = string.split(a,"=", 2)
+ f,r = a.split("=", 2)
replace_paths.append( (f,r) )
# default prefix and exec_prefix
# report unknown modules
if unknown:
sys.stderr.write('Warning: unknown modules remain: %s\n' %
- string.join(unknown))
+ ' '.join(unknown))
# windows gets different treatment
if win:
for key in makevars.keys():
somevars[key] = makevars[key]
- somevars['CFLAGS'] = string.join(cflags) # override
- somevars['CPPFLAGS'] = string.join(cppflags) # override
+ somevars['CFLAGS'] = ' '.join(cflags) # override
+ somevars['CPPFLAGS'] = ' '.join(cppflags) # override
files = [base_config_c, base_frozen_c] + \
files + supp_sources + addfiles + libs + \
['$(MODLIBS)', '$(LIBS)', '$(SYSLIBS)']
import marshal
-import string
import bkfile
mods.sort()
for mod in mods:
m = dict[mod]
- mangled = string.join(string.split(mod, "."), "__")
+ mangled = "__".join(mod.split("."))
if m.__code__:
file = 'M_' + mangled + '.c'
outfp = bkfile.open(base + file, 'w')
## def writecode(outfp, mod, str):
## outfp.write('unsigned char M_%s[%d] = "%s";\n' % (mod, len(str),
-## string.join(map(lambda s: `s`[1:-1], string.split(str, '"')), '\\"')))
+## '\\"'.join(map(lambda s: `s`[1:-1], str.split('"')))))
# Write the actual Makefile.
import os
-import string
def makemakefile(outfp, makevars, files, target):
outfp.write("# Makefile generated by freeze.py script\n\n")
files[i] = dest
deps.append(dest)
- outfp.write("\n%s: %s\n" % (target, string.join(deps)))
+ outfp.write("\n%s: %s\n" % (target, ' '.join(deps)))
outfp.write("\t$(LINKCC) $(LDFLAGS) $(LINKFORSHARED) %s -o %s $(LDLAST)\n" %
- (string.join(files), target))
+ (' '.join(files), target))
outfp.write("\nclean:\n\t-rm -f *.o %s\n" % target)
import marshal
import os
import re
-import string
import sys
import new
self.msgout(4, "determine_parent ->", parent)
return parent
if '.' in pname:
- i = string.rfind(pname, '.')
+ i = pname.rfind('.')
pname = pname[:i]
parent = self.modules[pname]
assert parent.__name__ == pname
def find_head_package(self, parent, name):
self.msgin(4, "find_head_package", parent, name)
if '.' in name:
- i = string.find(name, '.')
+ i = name.find('.')
head = name[:i]
tail = name[i+1:]
else:
self.msgin(4, "load_tail", q, tail)
m = q
while tail:
- i = string.find(tail, '.')
+ i = tail.find('.')
if i < 0: i = len(tail)
head, tail = tail[:i], tail[i+1:]
mname = "%s.%s" % (m.__name__, head)
def find_module(self, name, path):
if path:
- fullname = string.join(path, '.')+'.'+name
+ fullname = '.'.join(path)+'.'+name
else:
fullname = name
if fullname in self.excludes:
if key not in self.excludes:
mods = self.badmodules[key].keys()
mods.sort()
- print "?", key, "from", string.join(mods, ', ')
+ print "?", key, "from", ', '.join(mods)
def any_missing(self):
keys = self.badmodules.keys()
if o == '-m':
domods = 1
if o == '-p':
- addpath = addpath + string.split(a, os.pathsep)
+ addpath = addpath + a.split(os.pathsep)
if o == '-q':
debug = 0
if o == '-x':
# Parse Makefiles and Python Setup(.in) files.
import re
-import string
# Extract variable definitions from a Makefile.
continue
(name, value) = matchobj.group(1, 2)
# Strip trailing comment
- i = string.find(value, '#')
+ i = value.find('#')
if i >= 0:
value = value[:i]
- value = string.strip(value)
+ value = value.strip()
variables[name] = value
finally:
fp.close()
if not line:
break
# Strip comments
- i = string.find(line, '#')
+ i = line.find('#')
if i >= 0:
line = line[:i]
if line.endswith('\\\n'):
matchobj = setupvardef.match(line)
if matchobj:
(name, value) = matchobj.group(1, 2)
- variables[name] = string.strip(value)
+ variables[name] = value.strip()
else:
- words = string.split(line)
+ words = line.split()
if words:
modules[words[0]] = words[1:]
finally:
-import sys, os, string
+import sys, os
# Template used then the program is a GUI program
WINMAINTEMPLATE = """
print "\t\t$(cflags) $(cdebug) $(cinclude) \\"
extra = moddefn.GetCompilerOptions()
if extra:
- print "\t\t%s \\" % (string.join(extra),)
+ print "\t\t%s \\" % (' '.join(extra),)
print '\t\t"%s"' % file
print
-import string
#from Tkinter import TclError
#import tkMessageBox
#import tkSimpleDialog
return "break"
# Ick. It may require *inserting* spaces if we back up over a
# tab character! This is written to be clear, not fast.
- expand, tabwidth = string.expandtabs, self.tabwidth
- have = len(expand(chars, tabwidth))
+ tabwidth = self.tabwidth
+ have = len(chars.expandtabs(tabwidth))
assert have > 0
want = ((have - 1) // self.indentwidth) * self.indentwidth
ncharsdeleted = 0
while 1:
chars = chars[:-1]
ncharsdeleted = ncharsdeleted + 1
- have = len(expand(chars, tabwidth))
+ have = len(chars.expandtabs(tabwidth))
if have <= want or chars[-1] not in " \t":
break
text.undo_block_start()
if self.usetabs:
pad = '\t'
else:
- effective = len(string.expandtabs(prefix,
- self.tabwidth))
+ effective = len(prefix.expandtabs(self.tabwidth))
n = self.indentwidth
pad = ' ' * (n - effective % n)
text.insert("insert", pad)
head, tail, chars, lines = self.get_region()
tabwidth = self._asktabwidth()
for pos in range(len(lines)):
- lines[pos] = string.expandtabs(lines[pos], tabwidth)
+ lines[pos] = lines[pos].expandtabs(tabwidth)
self.set_region(head, tail, chars, lines)
def toggle_tabs_event(self, event):
head = text.index("insert linestart")
tail = text.index("insert lineend +1c")
chars = text.get(head, tail)
- lines = string.split(chars, "\n")
+ lines = chars.split("\n")
return head, tail, chars, lines
def set_region(self, head, tail, chars, lines):
text = self.text
- newchars = string.join(lines, "\n")
+ newchars = "\n".join(lines)
if newchars == chars:
text.bell()
return
# Debug menu here, which is only present in the PythonShell window.
import sys
-import string
from keydefs import *
menudefs = [
items.append("...")
if fob.func_code.co_flags & 0x8:
items.append("***")
- argText = string.join(items , ", ")
+ argText = ", ".join(items)
argText = "(%s)" % argText
except:
pass
import os
import sys
-import string
import pyclbr
# XXX Patch pyclbr with dummies if it's vintage Python 1.5.2:
if sup.module != cl.module:
sname = "%s.%s" % (sup.module, sname)
supers.append(sname)
- s = s + "(%s)" % string.join(supers, ", ")
+ s = s + "(%s)" % ", ".join(supers)
items.append((cl.lineno, s))
self.classes[s] = cl
items.sort()
import time
-import string
import re
import keyword
from Tkinter import *
def any(name, list):
- return "(?P<%s>" % name + string.join(list, "|") + ")"
+ return "(?P<%s>" % name + "|".join(list) + ")"
def make_pat():
kw = r"\b" + any("KEYWORD", keyword.kwlist) + r"\b"
import sys
import os
-import string
import re
import imp
from Tkinter import *
self.text.after_idle(self.set_line_and_column)
def set_line_and_column(self, event=None):
- line, column = string.split(self.text.index(INSERT), '.')
+ line, column = self.text.index(INSERT).split('.')
self.status_bar.set_label('column', 'Col: %s' % column)
self.status_bar.set_label('line', 'Ln: %s' % line)
except TclError:
name = ""
else:
- name = string.strip(name)
+ name = name.strip()
if not name:
name = tkSimpleDialog.askstring("Module",
"Enter the name of a Python module\n"
"to search on sys.path and open:",
parent=self.text)
if name:
- name = string.strip(name)
+ name = name.strip()
if not name:
return
# XXX Ought to insert current file's directory in front of path
f.close()
except IOError:
return False
- return line[:2] == '#!' and string.find(line, 'python') >= 0
+ return line.startswith('#!') and 'python' in line
def close_hook(self):
if self.flist:
if keydefs:
self.apply_bindings(keydefs)
for vevent in keydefs.keys():
- methodname = string.replace(vevent, "-", "_")
+ methodname = vevent.replace("-", "_")
while methodname[:1] == '<':
methodname = methodname[1:]
while methodname[-1:] == '>':
def prepstr(s):
# Helper to extract the underscore from a string, e.g.
# prepstr("Co_py") returns (2, "Copy").
- i = string.find(s, '_')
+ i = s.find('_')
if i >= 0:
s = s[:i] + s[i+1:]
return i, s
if not keylist:
return ""
s = keylist[0]
- s = re.sub(r"-[a-z]\b", lambda m: string.upper(m.group()), s)
+ s = re.sub(r"-[a-z]\b", lambda m: m.group().upper(), s)
s = re.sub(r"\b\w+\b", lambda m: keynames.get(m.group(), m.group()), s)
s = re.sub("Key-", "", s)
s = re.sub("Control-", "Ctrl-", s)
# spaces, they will not be considered part of the same block.
# * Fancy comments, like this bulleted list, arent handled :-)
-import string
import re
class FormatParagraph:
find_paragraph(text, text.index("insert"))
if comment_header:
# Reformat the comment lines - convert to text sans header.
- lines = string.split(data, "\n")
+ lines = data.split("\n")
lines = map(lambda st, l=len(comment_header): st[l:], lines)
- data = string.join(lines, "\n")
+ data = "\n".join(lines)
# Reformat to 70 chars or a 20 char width, whichever is greater.
format_width = max(70-len(comment_header), 20)
newdata = reformat_paragraph(data, format_width)
# re-split and re-insert the comment header.
- newdata = string.split(newdata, "\n")
+ newdata = newdata.split("\n")
# If the block ends in a \n, we dont want the comment
# prefix inserted after it. (Im not sure it makes sense to
# reformat a comment block that isnt made of complete
block_suffix = "\n"
newdata = newdata[:-1]
builder = lambda item, prefix=comment_header: prefix+item
- newdata = string.join(map(builder, newdata), '\n') + block_suffix
+ newdata = '\n'.join(map(builder, newdata)) + block_suffix
else:
# Just a normal text format
newdata = reformat_paragraph(data)
text.see("insert")
def find_paragraph(text, mark):
- lineno, col = map(int, string.split(mark, "."))
+ lineno, col = map(int, mark.split("."))
line = text.get("%d.0" % lineno, "%d.0 lineend" % lineno)
while text.compare("%d.0" % lineno, "<", "end") and is_all_white(line):
lineno = lineno + 1
return first, last, comment_header, text.get(first, last)
def reformat_paragraph(data, limit=70):
- lines = string.split(data, "\n")
+ lines = data.split("\n")
i = 0
n = len(lines)
while i < n and is_all_white(lines[i]):
word = words[j]
if not word:
continue # Can happen when line ends in whitespace
- if len(string.expandtabs(partial + word)) > limit and \
+ if len((partial + word).expandtabs()) > limit and \
partial != indent1:
- new.append(string.rstrip(partial))
+ new.append(partial.rstrip())
partial = indent2
partial = partial + word + " "
if j+1 < len(words) and words[j+1] != " ":
partial = partial + " "
i = i+1
- new.append(string.rstrip(partial))
+ new.append(partial.rstrip())
# XXX Should reformat remaining paragraphs as well
new.extend(lines[i:])
- return string.join(new, "\n")
+ return "\n".join(new)
def is_all_white(line):
return re.match(r"^\s*$", line) is not None
-import string
import os
import re
import fnmatch
-import string
-
class History:
def __init__(self, text, output_sep = "\n"):
def _get_source(self, start, end):
# Get source code from start index to end index. Lines in the
# text control may be separated by sys.ps2 .
- lines = string.split(self.text.get(start, end), self.output_sep)
- return string.join(lines, "\n")
+ lines = self.text.get(start, end).split(self.output_sep)
+ return "\n".join(lines)
def _put_source(self, where, source):
- output = string.join(string.split(source, "\n"), self.output_sep)
+ output = self.output_sep.join(source.split("\n"))
self.text.insert(where, output)
def history_do(self, reverse):
self.history_prefix = prefix
def history_store(self, source):
- source = string.strip(source)
+ source = source.strip()
if len(source) > 2:
# avoid duplicates
try:
self.history_prefix = None
def recall(self, s):
- s = string.strip(s)
+ s = s.strip()
self.text.tag_remove("sel", "1.0", "end")
self.text.delete("iomark", "end-1c")
self.text.mark_set("insert", "end-1c")
# the right list displays the substructure of the selected item
# in the left list.
-import string
from Tkinter import *
from WindowList import ListedToplevel
from Separator import HSeparator
-import string
import sys
import os
from Tkinter import *
filename = code.co_filename
funcname = code.co_name
sourceline = linecache.getline(filename, lineno)
- sourceline = string.strip(sourceline)
+ sourceline = sourceline.strip()
if funcname in ("?", "", None):
item = "%s, line %d: %s" % (modname, lineno, sourceline)
else:
extensions what to capture the same event.
"""
-import string
-
import PyParse
from AutoIndent import AutoIndent, index2line
from IdleConf import idleconf
if i is None \
or keysym_type(buf[i]) != right_keysym_type:
return None
- lines_back = string.count(buf[i:], "\n") - 1
+ lines_back = buf[i:].count("\n") - 1
# subtract one for the "\n" added to please the parser
upto_open = buf[:i]
- j = string.rfind(upto_open, "\n") + 1 # offset of column 0 of line
+ j = upto_open.rfind("\n") + 1 # offset of column 0 of line
offset = i - j
return "%d.%d" % (lno - lines_back, offset)
-import string
import re
import sys
if 0: # for throwaway debugging output
def dump(*stuff):
- sys.__stdout__.write(string.join(map(str, stuff), " ") + "\n")
+ sys.__stdout__.write(" ".join(map(str, stuff)) + "\n")
# Find what looks like the start of a popular stmt.
_tran[ord(ch)] = ')'
for ch in "\"'\\\n#":
_tran[ord(ch)] = ch
-_tran = string.join(_tran, '')
+_tran = ''.join(_tran)
del ch
try:
# Python 1.5.2 (#0, Apr 13 1999, ...
def find_good_parse_start(self, use_ps1, is_char_in_string=None,
- _rfind=string.rfind,
_synchre=_synchre):
str, pos = self.str, None
if use_ps1:
# shell window
ps1 = '\n' + sys.ps1
- i = _rfind(str, ps1)
+ i = str.rfind(ps1)
if i >= 0:
pos = i + len(ps1)
# make it look like there's a newline instead
# bumped to a legitimate synch point.
limit = len(str)
for tries in range(5):
- i = _rfind(str, ":\n", 0, limit)
+ i = str.rfind(":\n", 0, limit)
if i < 0:
break
- i = _rfind(str, '\n', 0, i) + 1 # start of colon line
+ i = str.rfind('\n', 0, i) + 1 # start of colon line
m = _synchre(str, i, limit)
if m and not is_char_in_string(m.start()):
pos = m.start()
# based) of the non-continuation lines.
# Creates self.{goodlines, continuation}.
- def _study1(self, _replace=string.replace, _find=string.find):
+ def _study1(self):
if self.study_level >= 1:
return
self.study_level = 1
# uninteresting characters. This can cut the number of chars
# by a factor of 10-40, and so greatly speed the following loop.
str = self.str
- str = string.translate(str, _tran)
- str = _replace(str, 'xxxxxxxx', 'x')
- str = _replace(str, 'xxxx', 'x')
- str = _replace(str, 'xx', 'x')
- str = _replace(str, 'xx', 'x')
- str = _replace(str, '\nx', '\n')
+ str = str.translate(_tran)
+ str = str.replace('xxxxxxxx', 'x')
+ str = str.replace('xxxx', 'x')
+ str = str.replace('xx', 'x')
+ str = str.replace('xx', 'x')
+ str = str.replace('\nx', '\n')
# note that replacing x\n with \n would be incorrect, because
# x may be preceded by a backslash
if ch == '#':
# consume the comment
- i = _find(str, '\n', i)
+ i = str.find('\n', i)
assert i >= 0
continue
# self.lastopenbracketpos
# if continuation is C_BRACKET, index of last open bracket
- def _study2(self, _rfind=string.rfind, _find=string.find,
- _ws=string.whitespace):
+ def _study2(self):
if self.study_level >= 2:
return
self._study1()
q = p
for nothing in range(goodlines[i-1], goodlines[i]):
# tricky: sets p to 0 if no preceding newline
- p = _rfind(str, '\n', 0, p-1) + 1
+ p = str.rfind('\n', 0, p-1) + 1
# The stmt str[p:q] isn't a continuation, but may be blank
# or a non-indenting comment line.
if _junkre(str, p):
if ch == '#':
# consume comment and trailing newline
- p = _find(str, '\n', p, q) + 1
+ p = str.find('\n', p, q) + 1
assert p > 0
continue
# Assuming continuation is C_BRACKET, return the number
# of spaces the next line should be indented.
- def compute_bracket_indent(self, _find=string.find):
+ def compute_bracket_indent(self):
self._study2()
assert self.continuation == C_BRACKET
j = self.lastopenbracketpos
str = self.str
n = len(str)
- origi = i = string.rfind(str, '\n', 0, j) + 1
+ origi = i = str.rfind('\n', 0, j) + 1
j = j+1 # one beyond open bracket
# find first list item; set i to start of its line
while j < n:
break
else:
# this line is junk; advance to next line
- i = j = _find(str, '\n', j) + 1
+ i = j = str.find('\n', j) + 1
else:
# nothing interesting follows the bracket;
# reproduce the bracket line's indentation + a level
while str[j] in " \t":
j = j+1
extra = self.indentwidth
- return len(string.expandtabs(str[i:j],
- self.tabwidth)) + extra
+ return len(str[i:j].expandtabs(self.tabwidth)) + extra
# Return number of physical lines in last stmt (whether or not
# it's an interesting stmt! this is intended to be called when
# See whether the initial line starts an assignment stmt; i.e.,
# look for an = operator
- endpos = string.find(str, '\n', startpos) + 1
+ endpos = str.find('\n', startpos) + 1
found = level = 0
while i < endpos:
ch = str[i]
while str[i] not in " \t\n":
i = i+1
- return len(string.expandtabs(str[self.stmt_start :
- i],
+ return len(str[self.stmt_start:i].expandtabs(\
self.tabwidth)) + 1
# Return the leading whitespace on the initial line of the last
# Stuff source in the filename cache
filename = "<pyshell#%d>" % self.gid
self.gid = self.gid + 1
- lines = string.split(source, "\n")
+ lines = source.split("\n")
linecache.cache[filename] = len(source)+1, 0, lines, filename
return filename
# If we're in the current input and there's only whitespace
# beyond the cursor, erase that whitespace first
s = self.text.get("insert", "end-1c")
- if s and not string.strip(s):
+ if s and not s.strip():
self.text.delete("insert", "end-1c")
# If we're in the current input before its last line,
# insert a newline right at the insert point
-import string
import os
import re
import fnmatch
-import string
from Tkinter import *
class SearchDialogBase:
-import string
import re
from Tkinter import *
import tkMessageBox
wrapped = 1
wrap = 0
pos = text.index("end-1c")
- line, col = map(int, string.split(pos, "."))
+ line, col = map(int, pos.split("."))
chars = text.get("%d.0" % line, "%d.0" % (line+1))
col = len(chars) - 1
return None
# Helper to parse a text index into a (line, col) tuple.
def get_line_col(index):
- line, col = map(int, string.split(index, ".")) # Fails on invalid index
+ line, col = map(int, index.split(".")) # Fails on invalid index
return line, col
import os
import sys
-import string
import linecache
from TreeWidget import TreeNode, TreeItem, ScrolledCanvas
filename = code.co_filename
funcname = code.co_name
sourceline = linecache.getline(filename, lineno)
- sourceline = string.strip(sourceline)
+ sourceline = sourceline.strip()
if funcname in ("?", "", None):
item = "%s, line %d: %s" % (modname, lineno, sourceline)
else:
import os
import sys
-import string
from Tkinter import *
import imp
strs = []
for cmd in self.cmds:
strs.append(" " + `cmd`)
- return s + "(\n" + string.join(strs, ",\n") + "\n)"
+ return s + "(\n" + ",\n".join(strs) + "\n)"
def __len__(self):
return len(self.cmds)
import re
import sys
import os
-import string
import getopt
import glob
import fileinput
if not sublist:
sublist.append('file %s' % fileinput.filename())
sublist.append('line %d' % fileinput.lineno())
- sublist.append(string.strip(line[2:-1]))
+ sublist.append(line[2:-1].strip())
else:
if sublist:
hits.append(sublist)
for sublist in hits:
d = {}
for line in sublist:
- words = string.split(line, None, 1)
+ words = line.split(None, 1)
if len(words) != 2:
continue
tag = words[0]
import sys
import os
import varsubst
-import string
error = 'genmodule.error'
if not self._subst:
if not self.__dict__.has_key('abbrev'):
self.abbrev = self.name
- self.Abbrev = string.upper(self.abbrev[0])+self.abbrev[1:]
+ self.Abbrev = self.abbrev[0].upper()+self.abbrev[1:]
subst = varsubst.Varsubst(self.__dict__)
subst.useindent(1)
self._subst = subst.subst
rv = rv + (name+'.name = '+`self.name_entry.get()`+'\n')
rv = rv + (name+'.abbrev = '+`self.abbrev_entry.get()`+'\n')
rv = rv + (name+'.methodlist = '+`getlistlist(self.method_list)`+'\n')
- rv = rv + (name+'.objects = ['+string.joinfields(onames, ',')+']\n')
+ rv = rv + (name+'.objects = ['+','.join(onames)+']\n')
rv = rv + ('\n')
return rv
#
# Variable substitution. Variables are $delimited$
#
-import string
import re
error = 'varsubst.error'
rv = rv + value
def _modindent(self, value, old):
- lastnl = string.rfind(old, '\n', 0) + 1
+ lastnl = old.rfind('\n', 0) + 1
lastnl = len(old) - lastnl
sub = '\n' + (' '*lastnl)
return re.sub('\n', sub, value)
# Options -[amc] select atime, mtime (default) or ctime as age.
import sys, os, time
-import string
from stat import *
# Use lstat() to stat files if it exists, else stat()
size = st[ST_SIZE]
age = now - anytime
byteyears = float(size) * float(age) / secs_per_year
- print string.ljust(file, maxlen),
- print string.rjust(`int(byteyears)`, 8)
+ print file.ljust(maxlen),
+ print repr(int(byteyears)).rjust(8)
sys.exit(status)
import os
import sys
-import string
import getopt
import tokenize
verbose = 0
def errprint(*args):
- msg = string.join(args)
+ msg = ' '.join(args)
sys.stderr.write(msg)
sys.stderr.write("\n")
baseexpr = '^ *\(.*\) *( *) *$'
baseprog = regex.compile(baseexpr)
-import string
-
def fixline(line):
if classprog.match(line) < 0: # No 'class' keyword -- no change
return line
basepart = line[a2+1:b2]
# Extract list of base expressions
- bases = string.splitfields(basepart, ',')
+ bases = basepart.split(',')
# Strip trailing '()' from each base expression
for i in range(len(bases)):
bases[i] = bases[i][x1:y1]
# Join the bases back again and build the new line
- basepart = string.joinfields(bases, ', ')
+ basepart = ', '.join(bases)
return head + '(' + basepart + '):' + tail
import sys
import stat
import getopt
-import string
cutofftime = 0
if cvsdir:
entries = os.path.join(cvsdir, "Entries")
for e in open(entries).readlines():
- words = string.split(e, '/')
+ words = e.split('/')
if words[0] == '' and words[1:]:
name = words[1]
fullname = os.path.join(dir, name)
#! /usr/bin/env python
# Format du output in a tree shape
-import os, string, sys, errno
+import os, sys, errno
def main():
- p = os.popen('du ' + string.join(sys.argv[1:]), 'r')
+ p = os.popen('du ' + ' '.join(sys.argv[1:]), 'r')
total, d = None, {}
for line in p.readlines():
i = 0
size = eval(line[:i])
while line[i] in ' \t': i = i+1
file = line[i:-1]
- comps = string.splitfields(file, '/')
+ comps = file.split('/')
if comps[0] == '': comps[0] = '/'
if comps[len(comps)-1] == '': del comps[len(comps)-1]
total, d = store(size, comps, total, d)
if tsub is None:
psub = prefix
else:
- print prefix + string.rjust(`tsub`, width) + ' ' + key
+ print prefix + repr(tsub).rjust(width) + ' ' + key
psub = prefix + ' '*(width-1) + '|' + ' '*(len(key)+1)
if d.has_key(key):
show(tsub, d[key][1], psub)
import sys
import regex
-import string
import os
from stat import *
import getopt
# Anything else is an operator -- don't list this explicitly because of '/*'
OutsideComment = (Identifier, Number, String, Char, CommentStart)
-OutsideCommentPattern = '\(' + string.joinfields(OutsideComment, '\|') + '\)'
+OutsideCommentPattern = '\(' + '\|'.join(OutsideComment) + '\)'
OutsideCommentProgram = regex.compile(OutsideCommentPattern)
InsideComment = (Identifier, Number, CommentEnd)
-InsideCommentPattern = '\(' + string.joinfields(InsideComment, '\|') + '\)'
+InsideCommentPattern = '\(' + '\|'.join(InsideComment) + '\)'
InsideCommentProgram = regex.compile(InsideCommentPattern)
def initfixline():
if not line: break
lineno = lineno + 1
try:
- i = string.index(line, '#')
- except string.index_error:
+ i = line.index('#')
+ except ValueError:
i = -1 # Happens to delete trailing \n
- words = string.split(line[:i])
+ words = line[:i].split()
if not words: continue
if len(words) == 3 and words[0] == 'struct':
words[:2] = [words[0] + ' ' + words[1]]
# Add some standard cpp magic to a header file
import sys
-import string
def main():
args = sys.argv[1:]
sys.stderr.write('Processing %s ...\n' % file)
magic = 'Py_'
for c in file:
- if c in string.ascii_letters + string.digits:
- magic = magic + string.upper(c)
+ if ord(c)<=0x80 and c.isalnum():
+ magic = magic + c.upper()
else: magic = magic + '_'
sys.stdout = f
print '#ifndef', magic
import sys
import time
import getopt
-import string
import ftplib
import netrc
from fnmatch import fnmatch
if mac:
# Mac listing has just filenames;
# trailing / means subdirectory
- filename = string.strip(line)
+ filename = line.strip()
mode = '-'
if filename[-1:] == '/':
filename = filename[:-1]
infostuff = ''
else:
# Parse, assuming a UNIX listing
- words = string.split(line, None, 8)
+ words = line.split(None, 8)
if len(words) < 6:
if verbose > 1: print 'Skipping short line'
continue
- filename = string.lstrip(words[-1])
- i = string.find(filename, " -> ")
+ filename = words[-1].lstrip()
+ i = filename.find(" -> ")
if i >= 0:
# words[0] had better start with 'l'...
if verbose > 1:
def askabout(filetype, filename, pwd):
prompt = 'Retrieve %s %s from %s ? [ny] ' % (filetype, filename, pwd)
while 1:
- reply = string.lower(string.strip(raw_input(prompt)))
+ reply = raw_input(prompt).strip().lower()
if reply in ['y', 'ye', 'yes']:
return 1
if reply in ['', 'n', 'no', 'nop', 'nope']:
"""#"
-import string,re,os,time,marshal
+import re,os,time,marshal
# Create numeric tables or character based ones ?
numeric = 1
'(#.+)?')
def parsecodes(codes,
-
- split=string.split,atoi=string.atoi,len=len,
- filter=filter,range=range):
+ len=len, filter=filter,range=range):
""" Converts code combinations to either a single code integer
or a tuple of integers.
"""
if not codes:
return None
- l = split(codes,'+')
+ l = codes.split('+')
if len(l) == 1:
- return atoi(l[0],16)
+ return int(l[0],16)
for i in range(len(l)):
try:
- l[i] = atoi(l[i],16)
+ l[i] = int(l[i],16)
except ValueError:
l[i] = None
l = filter(lambda x: x is not None, l)
else:
return tuple(l)
-def readmap(filename,
-
- strip=string.strip):
+def readmap(filename):
f = open(filename,'r')
lines = f.readlines()
for i in range(256):
unmapped[i] = i
for line in lines:
- line = strip(line)
+ line = line.strip()
if not line or line[0] == '#':
continue
m = mapRE.match(line)
return enc2uni
-def hexrepr(t,
-
- join=string.join):
+def hexrepr(t):
if t is None:
return 'None'
len(t)
except:
return '0x%04x' % t
- return '(' + join(map(lambda t: '0x%04x' % t, t),', ') + ')'
+ return '(' + ', '.join(map(lambda t: '0x%04x' % t, t)) + ')'
-def unicoderepr(t,
-
- join=string.join):
+def unicoderepr(t):
if t is None:
return 'None'
len(t)
except:
return repr(unichr(t))
- return repr(join(map(unichr, t),''))
-
-def keyrepr(t,
+ return repr(''.join(map(unichr, t)))
- join=string.join):
+def keyrepr(t):
if t is None:
return 'None'
return repr(chr(t))
else:
return repr(unichr(t))
- return repr(join(map(chr, t),''))
+ return repr(''.join(map(chr, t)))
def codegen(name,map,comments=1):
encoding_map = codecs.make_encoding_map(decoding_map)
''')
- return string.join(l,'\n')
+ return '\n'.join(l)
def pymap(name,map,pyfile,comments=1):
mapnames = os.listdir(dir)
for mapname in mapnames:
name = os.path.split(mapname)[1]
- name = string.replace(name,'-','_')
- name = string.split(name, '.')[0]
- name = string.lower(name)
+ name = name.replace('-','_')
+ name = name.split('.')[0]
+ name = name.lower()
codefile = name + '.py'
marshalfile = name + '.mapping'
print 'converting %s to %s and %s' % (mapname,
import sys
import regex
import getopt
-import string
defs = []
undefs = []
nextline = fpi.readline()
if not nextline: break
line = line + nextline
- tmp = string.strip(line)
+ tmp = line.strip()
if tmp[:1] != '#':
if ok: fpo.write(line)
continue
- tmp = string.strip(tmp[1:])
- words = string.split(tmp)
+ tmp = tmp[1:].strip()
+ words = tmp.split()
keyword = words[0]
if keyword not in keywords:
if ok: fpo.write(line)
"""
-import os, sys, getopt, string, re
+import os, sys, getopt, re
sep1 = '='*77 + '\n' # file separator
sep2 = '-'*28 + '\n' # revision separator
keylen = len(key)
for line in lines:
if line[:keylen] == key:
- working_file = string.strip(line[keylen:])
+ working_file = line[keylen:].strip()
break
else:
working_file = None
revline = lines[0]
dateline = lines[1]
text = lines[2:]
- words = string.split(dateline)
+ words = dateline.split()
author = None
if len(words) >= 3 and words[0] == 'date:':
dateword = words[1]
else:
date = None
text.insert(0, revline)
- words = string.split(revline)
+ words = revline.split()
if len(words) >= 2 and words[0] == 'revision':
rev = words[1]
else:
"""mailerdaemon - classes to parse mailer-daemon messages"""
-import string
import rfc822
import calendar
import re
sub = self.getheader('Subject')
if not sub:
return 0
- sub = string.lower(sub)
- if sub[:12] == 'waiting mail': return 1
- if string.find(sub, 'warning') >= 0: return 1
+ sub = sub.lower()
+ if sub.startswith('waiting mail'): return 1
+ if 'warning' in sub: return 1
self.sub = sub
return 0
if type(regexp) is type(''):
for i in range(len(emails)-1,-1,-1):
email = emails[i]
- exp = re.compile(string.join(string.split(regexp, '<>'), re.escape(email)), re.MULTILINE)
+ exp = re.compile(re.escape(email).join(regexp.split('<>')), re.MULTILINE)
res = exp.search(data)
if res is not None:
- errors.append(string.join(string.split(string.strip(email)+': '+res.group('reason'))))
+ errors.append(' '.join((email.strip()+': '+res.group('reason')).split()))
del emails[i]
continue
res = regexp.search(data)
reason = res.group('reason')
break
for email in emails:
- errors.append(string.join(string.split(string.strip(email)+': '+reason)))
+ errors.append(' '.join((email.strip()+': '+reason).split()))
return errors
EMPARSERS = [emparse_list, ]
def sort_numeric(a, b):
- a = string.atoi(a)
- b = string.atoi(b)
+ a = int(a)
+ b = int(b)
if a < b: return -1
elif a > b: return 1
else: return 0
import regex
import os
from stat import *
-import string
err = sys.stderr.write
dbg = err
return 1
if lineno == 1 and g is None and line[:2] == '#!':
# Check for non-Python scripts
- words = string.split(line[2:])
+ words = line[2:].split()
if words and regex.search('[pP]ython', words[0]) < 0:
msg = filename + ': ' + words[0]
msg = msg + ' script; not fixed\n'
option to produce this format (since it is the original v7 Unix format).
"""
-import os,re,string,sys
+import os,re,sys
PYTHONLIB = 'libpython'+sys.version[:3]+'.a'
PC_PYTHONLIB = 'Python'+sys.version[0]+sys.version[2]+'.dll'
def symbols(lib=PYTHONLIB,types=('T','C','D')):
lines = os.popen(NM % lib).readlines()
- lines = map(string.strip,lines)
+ lines = [s.strip() for s in lines]
symbols = {}
for line in lines:
if len(line) == 0 or ':' in line:
continue
- items = string.split(line)
+ items = line.split()
if len(items) != 3:
continue
address, type, name = items
data.sort()
data.append('')
code.sort()
- return string.join(data,' DATA\n')+'\n'+string.join(code,'\n')
+ return ' DATA\n'.join(data)+'\n'+'\n'.join(code)
# Definition file template
DEF_TEMPLATE = """\
import sys
-import string
import os
import getopt
import regex
import regex
import os
from stat import *
-import string
import getopt
err = sys.stderr.write
return 0
def fixline(line):
- if line[:2] != '#!':
+ if not line.startswith('#!'):
return line
- if string.find(line, "python") < 0:
+ if "python" not in line:
return line
return '#! %s\n' % new_interpreter
import sys
import regex
import os
-import string
# Main program
elif m_from.match(line) >= 0:
(a, b), (a1, b1) = m_from.regs[:2]
else: continue
- words = string.splitfields(line[a1:b1], ',')
+ words = line[a1:b1].split(',')
# print '#', line, words
for word in words:
- word = string.strip(word)
+ word = word.strip()
if word not in list:
list.append(word)
for mod in modules:
list = table[mod]
list.sort()
- print string.ljust(mod, maxlen), ':',
+ print mod.ljust(maxlen), ':',
if mod in list:
print '(*)',
for ref in list:
import os
import re
-import string
import sys
next = {}
def write(self, line):
if self.expandtabs:
- self._write(string.expandtabs(line, self.tabsize))
+ self._write(line.expandtabs(self.tabsize))
else:
self._write(line)
# end if
thiskw = ''
# end if
# end if
- indent = len(string.expandtabs(line[:i], self.tabsize))
+ indent = len(line[:i].expandtabs(self.tabsize))
while indent < current:
if firstkw:
if topid:
return r
# end def read
def readline(self):
- i = string.find(self.buf, '\n', self.pos)
+ i = self.buf.find('\n', self.pos)
return self.read(i + 1 - self.pos)
# end def readline
def readlines(self):
# end if
action = 'reformat'
elif o == '-s':
- stepsize = string.atoi(a)
+ stepsize = int(a)
elif o == '-t':
- tabsize = string.atoi(a)
+ tabsize = int(a)
elif o == '-e':
expandtabs = 1
# end if
import sys
import re
-import string
import getopt
def main():
pos = pos - size
f.seek(pos)
buffer = f.read(size)
- lines = string.split(buffer, "\n")
+ lines = buffer.split("\n")
del buffer
if leftover is None:
if not lines[-1]:
""" % bufsize
import sys
-import string
import os
import md5
import regsub
if o == '-t':
rmode = 'r'
if o == '-s':
- bufsize = string.atoi(a)
+ bufsize = int(a)
if not args: args = ['-']
return sum(args, out)
trace.print_results(show_missing=1)
"""
-import sys, os, string, tempfile, types, copy, operator, inspect, exceptions, marshal
+import sys, os, tempfile, types, copy, operator, inspect, exceptions, marshal
try:
import cPickle
pickle = cPickle
# or
# d = "/usr/local.py"
# filename = "/usr/local.py"
- if string.find(filename, d + os.sep) == 0:
+ if filename.startswith(d + os.sep):
self._ignore[modulename] = 1
return 1
# '#pragma: NO COVER' (it is possible to embed this into
# the text as a non-comment; no easy fix)
if executable_linenos.has_key(i+1) and \
- string.find(lines[i],
- string.join(['#pragma', 'NO COVER'])) == -1:
+ lines[i].find(' '.join(['#pragma', 'NO COVER'])) == -1:
outfile.write('>>>>>> ')
else:
outfile.write(' '*7)
n_lines = n_lines + 1
- outfile.write(string.expandtabs(lines[i], 8))
+ outfile.write(lines[i].expandtabs(8))
outfile.close()
continue
if opt == "--ignore-dir":
- for s in string.split(val, os.pathsep):
+ for s in val.split(os.pathsep):
s = os.path.expandvars(s)
# should I also call expanduser? (after all, could use $HOME)
- s = string.replace(s, "$prefix",
- os.path.join(sys.prefix, "lib",
- "python" + sys.version[:3]))
- s = string.replace(s, "$exec_prefix",
- os.path.join(sys.exec_prefix, "lib",
- "python" + sys.version[:3]))
+ s = s.replace("$prefix",
+ os.path.join(sys.prefix, "lib",
+ "python" + sys.version[:3]))
+ s = s.replace("$exec_prefix",
+ os.path.join(sys.exec_prefix, "lib",
+ "python" + sys.version[:3]))
s = os.path.normpath(s)
ignore_dirs.append(s)
continue
"""
-import os, sys, stat, string, getopt
+import os, sys, stat, getopt
# Interactivity options
default_answer = "ask"
if cvsdir:
entries = os.path.join(cvsdir, "Entries")
for e in open(entries).readlines():
- words = string.split(e, '/')
+ words = e.split('/')
if words[0] == '' and words[1:]:
name = words[1]
s = os.path.join(slave, name)
g.close()
def okay(prompt, answer='ask'):
- answer = string.lower(string.strip(answer))
+ answer = answer.strip().lower()
if not answer or answer[0] not in 'ny':
answer = raw_input(prompt)
- answer = string.lower(string.strip(answer))
+ answer = answer.strip().lower()
if not answer:
answer = default_answer
if answer[:1] == 'y':
import os
import sys
-import string
import getopt
def main():
except IOError, msg:
print "%s: I/O error: %s" % (`file`, str(msg))
return
- newtext = string.expandtabs(text, tabsize)
+ newtext = text.expandtabs(tabsize)
if newtext == text:
return
backup = file + "~"
import sys
if sys.path[0] in (".", ""): del sys.path[0]
-import sys, os, string
+import sys, os
from stat import *
def msg(str):
sys.stderr.write(str + '\n')
-pathlist = string.splitfields(os.environ['PATH'], ':')
+pathlist = os.environ['PATH'].split(':')
sts = 0
longlist = ''
from stat import *
import commands
import fnmatch
-import string
EXECMAGIC = '\001\140\000\010'
f = open('.xxcign', 'r')
except IOError:
return
- ignore[:] = ignore + string.split(f.read())
+ ignore[:] = ignore + f.read().split()
def skipfile(file):
for p in ignore:
record = unicode.table[char]
if record:
if record[5]:
- decomp = string.split(record[5])
+ decomp = record[5].split()
# prefix
if decomp[0][0] == "<":
prefix = decomp.pop(0)
# indicates the last character in an entire string)
ww = w[:-1] + chr(ord(w[-1])+128)
# reuse string tails, when possible
- o = string.find(lexicon, ww)
+ o = lexicon.find(ww)
if o < 0:
o = offset
lexicon = lexicon + ww
# load a unicode-data file from disk
-import string, sys
+import sys
class UnicodeData:
s = file.readline()
if not s:
break
- s = string.split(string.strip(s), ";")
- char = string.atoi(s[0], 16)
+ s = s.strip().split(";")
+ char = int(s[0], 16)
table[char] = s
# expand first-last ranges (ignore surrogates and private use)
def myhash(s, magic):
h = 0
- for c in map(ord, string.upper(s)):
+ for c in map(ord, s.upper()):
h = (h * magic) + c
ix = h & 0xff000000
if ix:
s = " " + i
else:
s = s + i
- if string.strip(s):
+ if s.strip():
file.write(s + "\n")
file.write("};\n\n")
import os
import getopt
import sys
-import string
import pyversioncheck
CHECKNAME="_checkversion.py"
sys.exit(1)
for o, a in options:
if o == '-v':
- VERBOSE = string.atoi(a)
+ VERBOSE = int(a)
if not arguments:
arguments = [sys.prefix]
for dir in arguments:
import rfc822
import urllib
import sys
-import string
# Verbose options
VERBOSE_SILENT=0 # Single-line reports per package
if verbose >= VERBOSE_EACHFILE:
print ' No "Current-Version:" header in URL or URL not found'
return -1, None, None
- version = string.strip(string.lower(version))
- newversion = string.strip(string.lower(newversion))
+ version = version.lower().strip()
+ newversion = newversion.lower().strip()
if version == newversion:
if verbose >= VERBOSE_EACHFILE:
print ' Version identical (%s)'%newversion
"""Assorted Tk-related subroutines used in Grail."""
-import string
from types import *
from Tkinter import *
"""Turn a list or tuple into a single string -- recursively."""
t = type(msg)
if t in (ListType, TupleType):
- msg = string.join(map(flatten, msg))
+ msg = ' '.join(map(flatten, msg))
elif t is ClassType:
msg = msg.__name__
else:
def boolean(s):
"""Test whether a string is a Tk boolean, without error checking."""
- if string.lower(s) in ('', '0', 'no', 'off', 'false'): return 0
+ if s.lower() in ('', '0', 'no', 'off', 'false'): return 0
else: return 1
import sys
import getopt
-import string
from Tkinter import *
import tktools
import webchecker
extra_roots = []
for o, a in opts:
if o == '-m':
- webchecker.maxpage = string.atoi(a)
+ webchecker.maxpage = int(a)
if o == '-q':
webchecker.verbose = 0
if o == '-v':
self.root_seed = None
webchecker.Checker.__init__(self)
if root:
- root = string.strip(str(root))
+ root = str(root).strip()
if root:
self.suggestroot(root)
self.newstatus()
def enterroot(self, event=None):
root = self.__rootentry.get()
- root = string.strip(root)
+ root = root.strip()
if root:
self.__checking.config(text="Adding root "+root)
self.__checking.update_idletasks()
def selectedindices(self):
l = self.list.curselection()
if not l: return []
- return map(string.atoi, l)
+ return map(int, l)
def insert(self, url):
if url not in self.items:
import sys
import os
from types import *
-import string
import StringIO
import getopt
import pickle
# Extract real version number if necessary
if __version__[0] == '$':
- _v = string.split(__version__)
+ _v = __version__.split()
if len(_v) == 3:
__version__ = _v[1]
if o == '-d':
dumpfile = a
if o == '-m':
- maxpage = string.atoi(a)
+ maxpage = int(a)
if o == '-n':
norun = 1
if o == '-q':
verbose = 0
if o == '-r':
- roundsize = string.atoi(a)
+ roundsize = int(a)
if o == '-t':
extra_roots.append(a)
if o == '-a':
f.close()
if verbose > 0:
print "Done."
- print "Root:", string.join(c.roots, "\n ")
+ print "Root:", "\n ".join(c.roots)
return c
troot = root
scheme, netloc, path, params, query, fragment = \
urlparse.urlparse(root)
- i = string.rfind(path, "/") + 1
+ i = path.rfind("/") + 1
if 0 < i < len(path):
path = path[:i]
troot = urlparse.urlunparse((scheme, netloc, path,
def checkforhtml(self, info, url):
if info.has_key('content-type'):
- ctype = string.lower(cgi.parse_header(info['content-type'])[0])
+ ctype = cgi.parse_header(info['content-type'])[0].lower()
else:
if url[-1:] == "/":
return 1
def do_link(self, attributes):
for name, value in attributes:
if name == "rel":
- parts = string.split(string.lower(value))
+ parts = value.lower().split()
if ( parts == ["stylesheet"]
or parts == ["alternate", "stylesheet"]):
self.link_attr(attributes, "href")
def link_attr(self, attributes, *args):
for name, value in attributes:
if name in args:
- if value: value = string.strip(value)
+ if value: value = value.strip()
if value: self.links[value] = None
def do_base(self, attributes):
for name, value in attributes:
if name == 'href':
- if value: value = string.strip(value)
+ if value: value = value.strip()
if value:
if self.checker:
self.checker.note(1, " Base %s", value)
import os
import sys
-import string
import urllib
import getopt
# Extract real version number if necessary
if __version__[0] == '$':
- _v = string.split(__version__)
+ _v = __version__.split()
if len(_v) == 3:
__version__ = _v[1]
def savefilename(self, url):
type, rest = urllib.splittype(url)
host, path = urllib.splithost(rest)
- while path[:1] == "/": path = path[1:]
+ path = path.lstrip("/")
user, host = urllib.splituser(host)
host, port = urllib.splitnport(host)
- host = string.lower(host)
+ host = host.lower()
if not path or path[-1] == "/":
path = path + "index.html"
if os.sep != "/":
- path = string.join(string.split(path, "/"), os.sep)
+ path = os.sep.join(path.split("/"))
if os.name == "mac":
path = os.sep + path
path = os.path.join(host, path)
from Tkinter import *
import Tkinter
-import string
import websucker
import sys
import os
return
self.url_entry.selection_range(0, END)
url = self.url_entry.get()
- url = string.strip(url)
+ url = url.strip()
if not url:
self.top.bell()
self.message("[Error: No URL entered]")
return
self.rooturl = url
- dir = string.strip(self.dir_entry.get())
+ dir = self.dir_entry.get().strip()
if not dir:
self.sucker.savedir = None
else:
text = self.top.selection_get(selection=t)
except TclError:
continue
- text = string.strip(text)
+ text = text.strip()
if text:
break
if not text:
projects / thirdparty / Python / cpython.git / commitdiff
