rem stringlengths 0 322k | add stringlengths 0 2.05M | context stringlengths 8 228k |
|---|---|---|
self.size = self.size + filesize self.write_file(filename, filesize, newsector); | if filename: self.size = self.size + filesize self.write_file(filename, filesize, newsector); else: log("warning: file without filename (offset:%d ,size:%d)" % \ (newsector, filesize) ) | def browse_file_internal(self, (sector, offset)): # browse an iso file entry add_list = [] if self.canceled: return add_list # jump to sector self.iso.seek(sector*2048+offset, SEEK_SET) # read file header ltable, rtable, newsector, filesize, attributes, filename_size \ = read_unpack(self.iso, "<HHLLBB") # read fil... |
if time_inactive > 5.0 and not xiso.paused: | if upload and time_inactive > 5.0 and not xiso.paused: | def extract_xiso(self): self.extracted_filename = None # get infos from ui drives = ["/c/","/e/","/f/","/g/"] filename = self.ui_entry_xiso.get_text() local_folder = self.ui_entry_folder.get_text() ftp_folder = drives[self.ui_combobox_xbox_drive.get_active()] + \ self.ui_entry_xbox_folder.get_text() |
for i in range(80): | for i in range(len(name)): | def parse_xbe(self,sector): # search for xbe name self.iso.seek(sector*2048,SEEK_SET) self.iso.seek(0x190,SEEK_CUR) name = self.iso.read(80) |
def browse_file(self, sector, offset=0): | def browse_file_internal(self, (sector, offset)): | def parse_xbe(self,sector): # search for xbe name self.iso.seek(sector*2048,SEEK_SET) self.iso.seek(0x190,SEEK_CUR) name = self.iso.read(80) |
return | return None | def browse_file(self, sector, offset=0): # browse an iso file entry if self.canceled: return # jump to sector self.iso.seek(sector*2048+offset, SEEK_SET) # read file header ltable, rtable, newsector, filesize, attributes, filename_size \ = read_unpack(self.iso, "<HHLLBB") # read file name filename = self.iso.read(f... |
self.browse_file(newsector) | add_list.append( (newsector, 0) ) | def browse_file(self, sector, offset=0): # browse an iso file entry if self.canceled: return # jump to sector self.iso.seek(sector*2048+offset, SEEK_SET) # read file header ltable, rtable, newsector, filesize, attributes, filename_size \ = read_unpack(self.iso, "<HHLLBB") # read file name filename = self.iso.read(f... |
self.browse_file(sector,rtable*4) | add_list.append( (sector, rtable*4) ) | def browse_file(self, sector, offset=0): # browse an iso file entry if self.canceled: return # jump to sector self.iso.seek(sector*2048+offset, SEEK_SET) # read file header ltable, rtable, newsector, filesize, attributes, filename_size \ = read_unpack(self.iso, "<HHLLBB") # read file name filename = self.iso.read(f... |
self.browse_file(sector,ltable*4) | add_list.append( (sector, ltable*4) ) return add_list def browse_file(self, sector): file_list = [ (sector, 0) ] while file_list: current_file = file_list.pop() file_list += self.browse_file_internal( current_file ) | def browse_file(self, sector, offset=0): # browse an iso file entry if self.canceled: return # jump to sector self.iso.seek(sector*2048+offset, SEEK_SET) # read file header ltable, rtable, newsector, filesize, attributes, filename_size \ = read_unpack(self.iso, "<HHLLBB") # read file name filename = self.iso.read(f... |
import ftplib | def quit(self): pass | |
raise ExtractError(_("Cannot connect to xbox:\n"+detail[1]+"\n\nIs the xbox FTP server running?\nVerify address, login and password.")) | print str(detail) raise ExtractError(_("<b>Cannot connect to xbox:\n"+detail[1]+"</b>\n\nIs the xbox FTP server running?\nVerify address, login and password.")) | def init(self): log("connecting to %s@%s" % (self.login,self.ip)) try: self.session = ftplib.FTP(self.ip,self.login,self.password) self.chdir(self.base_folder) except ftplib.all_errors, detail: raise ExtractError(_("Cannot connect to xbox:\n"+detail[1]+"\n\nIs the xbox FTP server running?\nVerify address, login and pas... |
self.file = file("/tmp/gxiso.tmp","wb") | thread.start_new_thread(self.upload,(filename,)) | def open(self, filename): self.buffer = "" self.closing = False #thread.start_new_thread(self.session.storbinary,("STOR %s" % filename, self)) self.file = file("/tmp/gxiso.tmp","wb") self.filename = filename |
self.file.write(buffer) | while len(self.buffer) > 0: | def write(self, buffer): #print "write: %d bytes in buffer, adding %d bytes" % (len(self.buffer), len(buffer)) |
time.sleep(0.001) | def write(self, buffer): #print "write: %d bytes in buffer, adding %d bytes" % (len(self.buffer), len(buffer)) | |
self.lock.acquire() self.buffer += buffer self.lock.release() | def write(self, buffer): #print "write: %d bytes in buffer, adding %d bytes" % (len(self.buffer), len(buffer)) | |
self.file.close self.file = file("/tmp/gxiso.tmp","rb") self.session.storbinary("STOR %s" % self.filename, self) self.file.close() | while True: wait = True self.lock.acquire() if self.buffer == None: wait = False self.lock.release() if not wait: break time.sleep(0.001) | def close(self): self.closing = True |
buffer = self.file.read(size) | while True: self.lock.acquire() l = len(self.buffer) self.lock.release() if l > 0: break time.sleep(0.001) if self.closing: return "" self.lock.acquire() l = len(self.buffer) buffer = self.buffer[:size] self.buffer = self.buffer[size:] self.lock.release() | def read(self, size): #print "read: %d bytes in buffer, removing %d bytes" % (len(self.buffer), size) buffer = self.file.read(size) return buffer #while len(self.buffer) == 0: # wait buffer write #time.sleep(0.1) #if self.closing: #return "" #self.lock.acquire() #buffer = self.buffer[:size] #self.buffer = self.buffe... |
pass | def write_file_parse(self,filename,size,sector): if filename == "default.xbe": # search xbe real name self.parse_xbe(sector) pass | |
self.active=False | def extract(self,iso_name): # parse and extract iso saved_folder = os.getcwd() try: self.writer.init() self.write_file = self.write_file_real self.parse_internal(iso_name) except ExtractError, details: os.chdir(saved_folder) self.error = details.message os.chdir(saved_folder) | |
return "Cannot open '"+iso_name+"'" | return _("<b>Cannot open '%s'</b>" % iso_name) signature = "MICROSOFT*XBOX*MEDIA" | def parse_internal(self,iso_name): # internal parser |
if header != HEADER_SIGNATURE: return "Not a valid xbox iso image" | if header != signature: return _("<b>Not a valid xbox iso image</b>") | def parse_internal(self,iso_name): # internal parser |
self.ui_label_iso_infos.set_markup("Title name: <b>%s</b> (%d MB)" % | self.ui_label_iso_infos.set_markup(_("Title name: <b>%s</b> (%d MB)") % | def get_iso_infos(self, filename): xiso = XisoExtractor(NullWriter()) error = xiso.parse(filename) if error: self.xbe_name = None self.ui_label_iso_infos.set_markup("<b>not a valid xbox iso image!</b>") else: self.xbe_name = xiso.xbe_name self.ui_label_iso_infos.set_markup("Title name: <b>%s</b> (%d MB)" % (self.xbe_na... |
size = xiso.size | total_size = xiso.size | def extract_xiso(self): # get infos from ui filename = self.ui_entry_xiso.get_text() local_folder = self.ui_entry_folder.get_text() ftp_folder = "/g/tmp" ftp_ip = self.ui_entry_xbox_address.get_text() ftp_login = self.ui_entry_xbox_login.get_text() ftp_password = self.ui_entry_xbox_password.get_text() # init progress ... |
progress.hide() | progress.stop() | def extract_xiso(self): # get infos from ui filename = self.ui_entry_xiso.get_text() local_folder = self.ui_entry_folder.get_text() ftp_folder = "/g/tmp" ftp_ip = self.ui_entry_xbox_address.get_text() ftp_login = self.ui_entry_xbox_login.get_text() ftp_password = self.ui_entry_xbox_password.get_text() # init progress ... |
while (xiso.write_position < size) and (not xiso.canceled) and (not xiso.error): fraction = float(xiso.write_position)/float(size) | while xiso.active: | def extract_xiso(self): # get infos from ui filename = self.ui_entry_xiso.get_text() local_folder = self.ui_entry_folder.get_text() ftp_folder = "/g/tmp" ftp_ip = self.ui_entry_xbox_address.get_text() ftp_login = self.ui_entry_xbox_login.get_text() ftp_password = self.ui_entry_xbox_password.get_text() # init progress ... |
progress.set_current_operation(operation) | if operation: progress.set_current_operation(operation) operation = None fraction = float(xiso.write_position)/float(total_size) | def extract_xiso(self): # get infos from ui filename = self.ui_entry_xiso.get_text() local_folder = self.ui_entry_folder.get_text() ftp_folder = "/g/tmp" ftp_ip = self.ui_entry_xbox_address.get_text() ftp_login = self.ui_entry_xbox_login.get_text() ftp_password = self.ui_entry_xbox_password.get_text() # init progress ... |
print _("done, %.2f MiB/s)") % (size/(time.time()-progress.starttime)/(1024*1024)) | print "OK! (%.2f MiB/s)" % (total_size/(time.time()-progress.starttime)/(1024*1024)) | def extract_xiso(self): # get infos from ui filename = self.ui_entry_xiso.get_text() local_folder = self.ui_entry_folder.get_text() ftp_folder = "/g/tmp" ftp_ip = self.ui_entry_xbox_address.get_text() ftp_login = self.ui_entry_xbox_login.get_text() ftp_password = self.ui_entry_xbox_password.get_text() # init progress ... |
try: log("Disabling FREEROOTSPACE on Avalaunch") self.session.sendcmd("SITE FREEROOTSPACEDISABLE") except ftplib.all_errors, details: log(" Avalaunch is not here.") | def init(self): # connect to ftp log("connecting to %s@%s" % (self.login,self.ip)) try: self.session = ftplib.FTP(self.ip,self.login,self.password) self.makedirs(self.base_folder) self.session.set_pasv(False) except ftplib.all_errors, details: if details.__class__ == socket.error: details = details[1] raise ExtractErr... | |
return None | return add_list | def browse_file_internal(self, (sector, offset)): # browse an iso file entry add_list = [] if self.canceled: return None # jump to sector self.iso.seek(sector*2048+offset, SEEK_SET) # read file header ltable, rtable, newsector, filesize, attributes, filename_size \ = read_unpack(self.iso, "<HHLLBB") # read file na... |
class RarReader: patterns = (".rar", ".000", ".001") | class GenericArchiveReader: | def close(self): self.file.close() print "skipped %d bytes." % self.skipped |
unrar_list=("rar","unrar") unrar = None for i in unrar_list: if os.popen(i).read(): unrar = i if not unrar: raise ReaderError(_("Cannot find a RAR extractor")) list_stream = os.popen('%s v "%s"' % (unrar, filename) ) list = list_stream.read() results = re.findall(r" (.+)\s+(\d+) (\d+)",list) iso = [file for file in r... | self.create_stream(filename) | def __init__(self, filename): self.position = 0 self.skipped = 0 try: f = open(filename, "r") f.close() except IOError: raise ReaderError(_("Cannot open archive: '%s'") % filename) # detecting unrar unrar_list=("rar","unrar") unrar = None for i in unrar_list: if os.popen(i).read(): unrar = i if not unrar: raise Reader... |
print "skipped %d bytes." % self.skipped | class RarReader (GenericArchiveReader): patterns = (".rar", ".000", ".001", ".r00", ".r01") def create_stream(self, filename): unrar_list=("rar","unrar") unrar = None for i in unrar_list: if os.popen(i).read(): unrar = i if not unrar: raise ReaderError(_("Cannot find a RAR extractor")) list_stream = os.popen('%s v "... | def close(self): self.stream.close() print "skipped %d bytes." % self.skipped |
name = self.create_tmp_folder(ftp_ip,ftp_login,ftp_password,ftp_folder) | def extract_xiso(self): self.extracted_filename = None | |
fraction = float(xiso.write_position)/float(xiso.iso.size) progress.set_current_file(xiso.current_file) | fraction = float(xiso.write_position)/float(:xiso.iso.size) | def extract_xiso(self): self.extracted_filename = None |
delay = 0 | delay = 0 else: progress.pulse() | def extract_xiso(self): self.extracted_filename = None |
dialog = CreateFileChooser(_("Open Xbox Iso"), \ ("*.iso","*.ISO","*.gz","*.bz2","*.rar","*.000","*.001")) | patterns = [] for p in readers: patterns.extend( ["*"+i.lower() for i in p.patterns] ) patterns.extend( ["*"+i.upper() for i in p.patterns] ) print patterns dialog = CreateFileChooser(_("Open Xbox Iso"), patterns) | def on_button_xiso_browse_clicked(self, widget): dialog = CreateFileChooser(_("Open Xbox Iso"), \ ("*.iso","*.ISO","*.gz","*.bz2","*.rar","*.000","*.001")) dialog.show_all() result = dialog.run() dialog.hide_all() if result == gtk.RESPONSE_OK: self.iso_name = dialog.get_filename() self.ui_entry_xiso.set_text(self.iso_n... |
os.symlink("../../%s.mo"%lang,"po/tmp/%s/%s.mo"%(lang, PACKAGE)) | def update_translations(): # update main pot file potfile = 'po/POTFILES.in' if not os.path.exists(potfile): sys.exit("No such file: '%s'" % potfile) f = open(potfile) files = "" for line in f: # ignore comments and newline if line.startswith('#') or line.startswith('\n'): continue else: files += " "+line.strip() f... | |
filter = gtk.FileFilter() for pattern in patterns: filter.add_pattern(pattern) dialog.set_filter(filter) | if patterns: filter = gtk.FileFilter() for pattern in patterns: filter.add_pattern(pattern) dialog.set_filter(filter) dialog.set_local_only(True) | def CreateFileChooser(title="", patterns=()): |
dialog = gtk.FileChooserDialog(_("Open Xbox Iso"),None, action=gtk.FILE_CHOOSER_ACTION_OPEN, buttons=(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, gtk.STOCK_OPEN, gtk.RESPONSE_OK)) filter = gtk.FileFilter() filter.add_pattern("*.iso") filter.add_pattern("*.ISO") filter.add_pattern("*.gz") filter.add_pattern("*.bz2") di... | dialog = CreateFileChooser(_("Open Xbox Iso"),("*.iso","*.ISO","*.gz","*.bz2")) | def on_button_xiso_browse_clicked(self, widget): dialog = gtk.FileChooserDialog(_("Open Xbox Iso"),None, action=gtk.FILE_CHOOSER_ACTION_OPEN, buttons=(gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, gtk.STOCK_OPEN, gtk.RESPONSE_OK)) |
def format_speed(speed) """ convert a speed in bytes per second in """ speed = speed/1024 if speed > 1024: return "%d MiB/s" % speed/1024 else: return "%d KiB/s" % speed | def is_archive(filename): root, ext = os.path.splitext(filename) if not ext: return False for reader in readers: for pattern in reader.patterns: if ext.lower() == pattern: if reader.archive: return True return False | |
self.current_file = number self.total_files = total def set_current_speed(self, speed) | def set_current_speed(self, speed): | def set_current_file(self, filename): self.ui_label_detail.set_markup("<i>%s</i>" % filename) self.current_file = number self.total_files = total |
if self.paused: return | def set_fraction(self, fraction): if self.paused: return | |
self.ui_progressbar.set_text(_("%s, %s") % (format_speed(self.current_speed), text)) | self.ui_progressbar.set_text(_("%.3f MiB/s, %s") % (self.current_speed/(1024*1024.0), text)) | def set_fraction(self, fraction): if self.paused: return |
if self.ui_entry_folder.get_text() != "": | if self.ui_entry_folder.get_text() and self.xbe_name != "": | def get_iso_infos(self, filename): xiso = XisoExtractor(NullWriter()) error = xiso.parse(filename) if error: self.xbe_name = None self.ui_label_iso_infos.set_markup(error) else: self.xbe_name = xiso.xbe_name self.ui_label_iso_infos.set_markup(_("Title name: <b>%s</b> (%d MB)") % (self.xbe_name, os.path.getsize(filename... |
progress.set_current_file("",0,0) | progress.set_current_file("") | def extract_xiso(self): self.extracted_filename = None |
speed = (xiso.write_position - previous_position)/0.1 previous_position = xiso.write_position progress.set_current_speed(speed) | mean_speed = xiso.write_position/(time.time()-progress.starttime) if not xiso.paused: progress.set_current_speed(mean_speed) | def extract_xiso(self): self.extracted_filename = None |
else: log( "done! (in %ds, %.2f MiB/s)" % (time.time()-progress.starttime,total_size/(time.time()-progress.starttime)/(1024*1024))) | elif not xiso.canceled: log( "done! (in %ds, %.3f MiB/s)" % (time.time()-progress.starttime,total_size/(time.time()-progress.starttime)/(1024*1024.0))) | def extract_xiso(self): self.extracted_filename = None |
print DATADIR | def find_data_dir(): # search for our data :) dir = "." # current folder if os.path.exists(os.path.join(dir,"gxiso.glade")): return dir # executable folder dir, t = os.path.split(os.path.abspath(sys.argv[0])) if os.path.exists(os.path.join(dir,"gxiso.glade")): return dir # or system folder h, t = os.path.split(dir)... | |
gtk.glade.bindtextdomain(name) gtk.glade.textdomain(name) gettext.install(name, unicode=1) | try: gtk.glade.bindtextdomain(name) gtk.glade.textdomain(name) gettext.install(name, unicode=1) except LookupError: log("gettext error, disabling...") def _(str): return str | def excepthook(type, value, tb): import StringIO, traceback trace = StringIO.StringIO() traceback.print_exception(type, value, tb, None, trace) print trace.getvalue() message = _( "<big><b>A programming error has been detected during the execution of this program.</b></big>" "\n\n<tt><small>%s</small></tt>") % trace.ge... |
def browse_file_internal(self, (sector, offset)): add_list = [] if self.canceled: return add_list self.iso.seek(sector*2048+offset, SEEK_SET) ltable, rtable, newsector, filesize, attributes, filename_size \ = read_unpack(self.iso, "<HHLLBB") filename = self.iso.read(filename_size) self.files = self.files + 1 ... | def browse_folder(self, sector, offset): file_list = [ (sector, offset) ] while file_list: sector, offset = file_list.pop() if self.canceled: return self.iso.seek(sector*2048+offset, SEEK_SET) ltable, rtable, newsector, filesize, attributes, filename_size \ = read_unpack(self.iso, "<HHLLBB") filename = self.i... | def browse_file_internal(self, (sector, offset)): # browse an iso file entry add_list = [] if self.canceled: return add_list # jump to sector self.iso.seek(sector*2048+offset, SEEK_SET) # read file header ltable, rtable, newsector, filesize, attributes, filename_size \ = read_unpack(self.iso, "<HHLLBB") # read fil... |
log("warning: file without filename (offset:%d ,size:%d)" % \ (newsector, filesize) ) if rtable > 0: add_list.append( (sector, rtable*4) ) if ltable > 0: add_list.append( (sector, ltable*4) ) return add_list def browse_file(self, sector): file_list = [ (sector, 0) ] while file_list: current_file = file_list.pop() f... | if filename: self.size = self.size + filesize self.write_file(filename, filesize, newsector); else: log("warning: file without filename (offset:%d ,size:%d)" % \ (newsector, filesize) ) if rtable > 0: file_list.append( (sector, rtable*4) ) if ltable > 0: file_list.append( (sector, ltable*4) ) return def browse_folde... | def browse_file_internal(self, (sector, offset)): # browse an iso file entry add_list = [] if self.canceled: return add_list # jump to sector self.iso.seek(sector*2048+offset, SEEK_SET) # read file header ltable, rtable, newsector, filesize, attributes, filename_size \ = read_unpack(self.iso, "<HHLLBB") # read fil... |
self.browse_file(root_sector) | self.browse_folders(root_sector) | def parse_internal(self,iso_name): # internal parser |
if self.parser.openElements[-1].name != "select": | node = self.parser.openElements.pop() while node.name != "select": | def endTagSelect(self, name): if self.parser.elementInScope(name, True): if self.parser.openElements[-1].name != "select": node = self.parser.openElements.pop() while node.name != "select": node = self.parser.openElements.pop() self.parser.resetInsertionMode() else: # innerHTML case self.parser.parseError() |
while node.name != "select": node = self.parser.openElements.pop() | def endTagSelect(self, name): if self.parser.elementInScope(name, True): if self.parser.openElements[-1].name != "select": node = self.parser.openElements.pop() while node.name != "select": node = self.parser.openElements.pop() self.parser.resetInsertionMode() else: # innerHTML case self.parser.parseError() | |
charAsInt = entitiesWindows1252[128 - charAsInt] | charAsInt = entitiesWindows1252[charAsInt - 128] | def consumeNumberEntity(self, isHex): """This function returns either U+FFFD or the character based on the decimal or hexadecimal representation. It also discards ";" if present. If not present self.tokenQueue.append({"type": "ParseError"}) is invoked. """ |
self.parser.processStartTag("form", []) self.parser.processStartTag("hr", []) self.parser.processStartTag("p", []) self.parser.processStartTag("label", []) self.parser.processCharacters( | self.processStartTag("form", {}) self.processStartTag("hr", {}) self.processStartTag("p", {}) self.processStartTag("label", {}) self.processCharacters( | def startTagIsIndex(self, name, attributes): self.parser.parseError() if self.parser.formPointer: return self.parser.processStartTag("form", []) self.parser.processStartTag("hr", []) self.parser.processStartTag("p", []) self.parser.processStartTag("label", []) self.parser.processCharacters( "This is a searchable index.... |
self.parser.processStartTag("input", attrs) self.parser.processEndTag("label") self.parser.processEndTag("p") self.parser.processStartTag("hr") self.parser.processEndTag("form") | self.processStartTag("input", dict(attrs)) self.processEndTag("label") self.processEndTag("p") self.processStartTag("hr", {}) self.processEndTag("form") | def startTagIsIndex(self, name, attributes): self.parser.parseError() if self.parser.formPointer: return self.parser.processStartTag("form", []) self.parser.processStartTag("hr", []) self.parser.processStartTag("p", []) self.parser.processStartTag("label", []) self.parser.processCharacters( "This is a searchable index.... |
self.parser.parseError() | def endTagImply(self, name): if self.parser.elementInScope(name): self.closeCell() self.parser.processEndTag(name) else: self.parser.parseError() # sometimes innerHTML case | |
assert False | self.parser.switchPhase("trailingEnd") | def endTagHtml(self, name): # XXX trailing end assert False |
self.changeState('data') | self.changeState("data") | def emitCurrentToken(self): """This method is a generic handler for emitting the StartTag, EndTag, Comment and Doctype. It also sets the state to "data" because that's what's needed after a token has been emitted. """ |
self.contentModelFlag != contentModelFlags['PLAINTEXT']): | self.contentModelFlag != contentModelFlags["PLAINTEXT"]): | def dataState(self): data = self.consumeChar() if (data == u"&" and (self.contentModelFlag in (contentModelFlags["PCDATA"], contentModelFlags["RCDATA"]))): self.changeState("entityData") elif (data == u"<" and self.contentModelFlag != contentModelFlags['PLAINTEXT']): self.changeState("tagOpen") elif data == EOF: self.p... |
import parser | def runParserTest(self, input, output, errors): import parser #XXX - move this out into the setup function #concatenate all consecutive character tokens into a single token p = parser.HTMLParser() document = p.parse(StringIO.StringIO(input)) errorMsg = "\n".join(["\n\nExpected:", output, "\nRecieved:", convertTreeDump(... | |
convertTreeDump(document.printTree())]) self.assertEquals(output, convertTreeDump(document.printTree()), errorMsg) errorMsg2 = "\n".join(["\n\nInput errors:\n" + "\n".join(errors), "Actual errors:\n" + "\n".join(p.errors)]) self.assertEquals(len(p.errors), len(errors), errorMsg2) | convertTreeDump(p.tree.testSerializer(document))]) self.assertEquals(output, convertTreeDump(p.tree.testSerializer(document)), errorMsg) | def runParserTest(self, input, output, errors): import parser #XXX - move this out into the setup function #concatenate all consecutive character tokens into a single token p = parser.HTMLParser() document = p.parse(StringIO.StringIO(input)) errorMsg = "\n".join(["\n\nExpected:", output, "\nRecieved:", convertTreeDump(... |
if self.parser.openElements[-1] in ("title", "style", "script"): | if self.parser.openElements[-1].name in ("title", "style", "script"): | def processNonSpaceCharacter(self, data): if self.parser.openElements[-1] in ("title", "style", "script"): self.parser.openElements[-1].appendChild(TextNode(data)) else: self.endTagHead("head") self.parser.switchInsertionMode("afterHead") self.parser.processCharacter(data) """ if self.collectingCharacters: self.charact... |
if self.parser.openElements[-1] == name: | if self.parser.openElements[-1].name == name: | def endTagTitleStyleScript(self, name): if self.parser.openElements[-1] == name: self.parser.openElements.pop() else: self.parser.parseError() |
self.parser.document.appendChild(Comment(data)) | self.parser.document.appendChild(CommentNode(data)) | def processComment(self, data): self.parser.document.appendChild(Comment(data)) |
element = self.createElement(name, attributes) | element = self.parser.createElement(name, attributes) | def startTagBaseLinkMeta(self, name, attributes): element = self.createElement(name, attributes) self.appendToHead(element) |
def processNonSpaceCharacter(self, data): InBody(self.parser).processCharacter(data) | def closeCell(self): if self.parser.elementInScope("td", True): self.endTagTableCell("td") elif self.parser.elementInScope("th", True): self.endTagTableCell("th") | |
self.parser.switchInsertionMode("inBody") self.parser.processEndTag(name) self.parser.switchInsertionMode("inCell") | InBody(self.parser).processEndTag(name) | def endTagOther(self, name): self.parser.switchInsertionMode("inBody") self.parser.processEndTag(name) self.parser.switchInsertionMode("inCell") |
self.parser.switchInsertionMode("inBody") self.processStartTag(name, attributes) | InBody(self.parser).processStartTag(name, attributes) | def startTagNoframes(self, name, attributes): self.parser.switchInsertionMode("inBody") self.processStartTag(name, attributes) |
def concatanateCharacterTokens(tokens): | def concatenateCharacterTokens(tokens): | def concatanateCharacterTokens(tokens): outputTokens = [] for token in tokens: if not "ParseError" in token and token[0] == "Character": if (outputTokens and not "ParseError" in outputTokens[-1] and outputTokens[-1][0] == "Character"): outputTokens[-1][1] += token[1] else: outputTokens.append(token) else: outputTokens.... |
tokens appears anywhere in the sequqnce of returned tokens. | tokens appears anywhere in the sequence of returned tokens. | def tokensMatch(expectedTokens, recievedTokens): """Test whether the test has passed or failed For brevity in the tests, the test has passed if the sequence of expected tokens appears anywhere in the sequqnce of returned tokens. """ return expectedTokens == recievedTokens for i, token in enumerate(recievedTokens): if ... |
yield (runTokenizerTest, test['description'], test['input'], test['output']) def runTokenizerTest(description, input, output): output = concatanateCharacterTokens(output) parser = TokenizerTestParser() tokens = parser.parse(StringIO.StringIO(input)) tokens = concatanateCharacterTokens(tokens) print "Got", tokens, "e... | yield (TestCase.runTokenizerTest, test['description'], test['input'], test['output']) | def test_tokenizer(): for filename in glob.glob('tokenizer/*.test'): tests = simplejson.load(file(filename)) for test in tests['tests']: yield (runTokenizerTest, test['description'], test['input'], test['output']) |
try: func(desc, input, output) except AssertionError: print "Failed test %s"%(desc,) parser = TokenizerTestParser() tokens = parser.parse(StringIO.StringIO(input)) print "Got", tokens, "expected", output failed +=1 print "Ran %i tests, failed %i"%(tests, failed) | testName = 'test%d' % tests testFunc = lambda self, method=func, input=input, output=output: \ method(self, input, output) testFunc.__doc__ = desc instanceMethod = new.instancemethod(testFunc, None, TestCase) setattr(TestCase, testName, instanceMethod) unittest.main() | def main(): failed = 0 tests = 0 for func, desc, input, output in test_tokenizer(): tests += 1 try: func(desc, input, output) except AssertionError: print "Failed test %s"%(desc,) parser = TokenizerTestParser() tokens = parser.parse(StringIO.StringIO(input)) print "Got", tokens, "expected", output failed +=1 print "Ran... |
def processCharacter(data): | def processCharacter(self, data): | def processCharacter(data): InBody(self.parser).processCharacter(data) |
self.generateImpliedEndTags() | self.parser.generateImpliedEndTags() | def endTagCaption(self, name): if self.parser.elementInScope(name, True): # XXX this code is quite similar to endTagTable in "InTable" self.generateImpliedEndTags() if self.parser.openElements[-1].name == "caption": self.parser.parseError() while self.parser.openElements[-1].name != "caption": self.parser.openElements.... |
"""Check if an element eists between the end of the active | """Check if an element exists between the end of the active | def elementInActiveFormattingElements(self, name): """Check if an element eists between the end of the active formatting elements and the last marker. If it does, return it, else return false""" |
not self.parser.elementInScope(afeElement)): | not self.parser.elementInScope(afeElement.name)): | def endTagFormatting(self, name): """The much-feared adoption agency algorithm""" afeElement = self.parser.elementInActiveFormattingElements(name) if not afeElement or (afeElement in self.parser.openElements and not self.parser.elementInScope(afeElement)): self.parser.parseError() return elif afeElement not in self.par... |
elif afeElement not in self.parser.activeFormattingElements: | elif afeElement not in self.parser.openElements: | def endTagFormatting(self, name): """The much-feared adoption agency algorithm""" afeElement = self.parser.elementInActiveFormattingElements(name) if not afeElement or (afeElement in self.parser.openElements and not self.parser.elementInScope(afeElement)): self.parser.parseError() return elif afeElement not in self.par... |
(("address", "blockquote", "centre", "div", "dl", "fieldset", | (("address", "blockquote", "center", "div", "dl", "fieldset", | def processEndTag(self, name): handlers = utils.MethodDispatcher([ ("p",self.endTagP), ("body",self.endTagBody), ("html",self.endTagHtml), (("address", "blockquote", "centre", "div", "dl", "fieldset", "listing", "menu", "ol", "pre", "ul"), self.endTagBlock), ("form", self.endTagForm), (("dd", "dt", "li"), self.endTagLi... |
if self.parser.elementInScope(name): | inScope = self.parser.elementInScope(name) if inScope: | def endTagBlock(self, name): if self.parser.elementInScope(name): self.parser.generateImpliedEndTags() if self.parser.openElements[-1].name != name: self.parser.parseError() |
if self.parser.openElements[-1].name != name: self.parser.parseError() if self.parser.elementInScope(name): | if self.parser.openElements[-1].name != name: self.parser.parseError() if inScope: | def endTagBlock(self, name): if self.parser.elementInScope(name): self.parser.generateImpliedEndTags() if self.parser.openElements[-1].name != name: self.parser.parseError() |
self.parser.switchInsertionMode("inBody") self.parser.processEndTag(name) self.parser.switchInsertionMode("inCaption") | InBody(self.parser).processEndTag(name) | def endTagOther(self, name): # Handle it "as if" it was inBody. This means we have to switch back. self.parser.switchInsertionMode("inBody") self.parser.processEndTag(name) self.parser.switchInsertionMode("inCaption") |
_("Named entity did not end in ';'.")}) | _("Named entity did not ';'.")}) | def entitiesStartingWith(name): return [e for e in filteredEntityList if e.startswith(name)] |
_("Unexpected '--' sequence found in comment.")}) | _("Unexpected '-' after '--' found in comment.")}) | def commentEndState(self): data = self.stream.char() if data == u">": # XXX EMIT self.emitCurrentToken() elif data == u"-": self.tokenQueue.append({"type": "ParseError", "data": _("Unexpected '--' sequence found in comment.")}) self.currentToken["data"] += data elif data == EOF: # XXX EMIT self.emitCurrentTokenWithPars... |
self.parser.activeFormattingElements.append(Marker) | def startTagTableCell(name, attributes): self.clearStackToTableRowContext() self.parser.insertElement(name, attributes) self.parser.switchInsertionMode("inCell") # XXX insert marker?! | |
assert False | if self.parser.elementInScope("tr", True): self.clearStackToTableRowContext() self.parser.openElements.pop() self.parser.switchInsertionMode("inTableBody") else: self.parser.parseError() | def endTagTr(self, name="tr"): # XXX lots of checks assert False |
assert False | if self.parser.elementInScope(name, True): self.endTagTr() self.parser.processEndTag(name) else: self.parser.parseError() | def endTagTableRowGroup(self, name): # XXX assert False |
self.collectingCharacters = True self.collectionStartTag = name | def startTagTitleStyle(self, name, attributes): cmFlags = {"title":"RCDATA", "style":"CDATA"} element = self.parser.createElement(name, attributes) self.appendToHead(element) self.parser.tokenizer.contentModelFlag =\ contentModelFlags[cmFlags[name]] # We have to start collecting characters self.collectingCharacters = T... | |
("html", self.endTagHtml) | ("html", self.endTagHtml), (("title", "style", "script"), self.endTagTitleStyleScript) | def processEndTag(self, name): if self.collectingCharacters: self.finishCollectingCharacters(name, True) handlers = utils.MethodDispatcher([ ("head", self.endTagHead), ("html", self.endTagHtml) ]) handlers.setDefaultValue(self.endTagOther) handlers[name](name) |
self.changeState("dataState") | self.changeState("data") | def tagOpenState(self): data = self.consumeChar() if (self.contentModelFlag in (contentModelFlags["RCDATA"], contentModelFlags["CDATA"])): if data == u"/": self.changeState("closeTagOpen") else: self.parser.processCharacter(u"<") self.characterQueue.append(data) self.changeState("data") elif self.contentModelFlag == co... |
return "".join(["'",self.value, "'\n"]) | return "".join([" \"",self.value, "\"\n"]) | def _printNode(self): return "".join(["'",self.value, "'\n"]) |
return " ".join(["<"+self.name+">", str(self.attributes), "\n"]) | atts = self.attributes.keys() atts.sort() rv = "<"+self.name+">" for attr in atts: rv += "\n " + str(attr) + str(self.attributes[key]) rv += "\n" return rv | def _printNode(self): return " ".join(["<"+self.name+">", str(self.attributes), "\n"]) |
if name in frozenset("dd", "dt", "li", "p", "td", "th", "tr") and name != exclude: | if name in frozenset(("dd", "dt", "li", "p", "td", "th", "tr")) and name != exclude: | def generateImpliedEndTags(self, exclude=None): while True: name = self.openElements[-1].name if name in frozenset("dd", "dt", "li", "p", "td", "th", "tr") and name != exclude: self.phase.processEndTag(name) else: break # XXX AT: # name = self.openElements[-1].name # while name in frozenset("dd", "dt", "li", "p", "td",... |
def processEndTag(self, tagname, attributes): | def processEndTag(self, tagname): | def processEndTag(self, tagname, attributes): self.parser.parseError() |
def processEOF(self, data): | def processEOF(self): | def processEOF(self, data): self.createHTMLNode() self.parser.phase.processEOF() |
self.parser.headPointer = self.openElements[-1] | self.parser.headPointer = self.parser.openElements[-1] | def createHeadNode(self, name, attributes): self.startTagHead("head", attributes) self.parser.headPointer = self.openElements[-1] self.parser.switchInsertionMode("inHead") |
pass | if character in spaceCharacters: self.parser.openElements[-1].appendChild(TextNode(character)) else: raise NotImplementedError() | def processCharacter(self, data): # XXX pass |
self.parser.activeFormattingElements.append(Marker) self.parser.insertElement(name, attributes) self.parser.switchInsertionMode("inCaption") | def startTagCaption(self, name, attributes): self.clearStackToTableContext() # XXX insert marker etc. | |
self.parser.insertElement(name, attributes) self.parser.switchInsertionMode("inColgroup") | def startTagColgroup(self, name="colgroup", attributes={}): self.clearStackToTableContext() # XXX switch modes | |
def processComment(self, data): self.parser.openElements[-1].appendChild(CommentNode(data)) | def processCharacter(self, data): if character in spaceCharacters: self.parser.openElements[-1].appendChild(TextNode(character)) else: raise NotImplementedError() |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.