def decode_WML(self, data):
p = wmlparser.Parser(None, no_macros_in_string=True)
p.verbose = False
p.do_preprocessor_logic = True
p.no_macros = True
p.parse_text(data, binary=True)
doc = wmldata.DataSub("WML")
p.parse_top(doc)
return doc
def done():
return pos[0] >= len(data)
def next():
c = data[pos[0]]
pos[0] += 1
return c
def literal():
s = pos[0]
e = data.find("\00", s)
pack = data[s:e]
pack = pack.replace("\01\01", "\00")
pack = pack.replace("\01\02", "\01")
pos[0] = e + 1
return pack
while not done():
code = ord(next())
if code == 0: # open element (name code follows)
open_element = True
elif code == 1: # close current element
tag.pop()
elif code == 2: # add code
self.words[self.wordcount] = literal()
self.wordcount += 1
else:
if code == 3:
word = literal() # literal word
else:
word = self.words[code] # code
if open_element: # we handle opening an element
element = wmldata.DataSub(word)
tag[-1].insert(element) # add it to the current one
tag.append(element) # put to our stack to keep track
elif word == "contents": # detect any binary attributes
binary = wmldata.DataBinary(word, literal())
tag[-1].insert(binary)
else: # others are text attributes
text = wmldata.DataText(word, literal())
tag[-1].insert(text)
open_element = False
return WML
def parse(self,
text_to_parse,
ignore_macros=None,
ignore_fatal_errors=False,
verbose=False):
# Create the real parser.
parser = wmlparser.Parser(self.datadir, self.userdir)
parser.verbose = verbose
parser.gettext = self.gettext
parser.macros = copy.copy(self.core_macros)
#parser.verbose = True
# Suppress complaints about undefined terrain macros
parser.set_macro_not_found_callback(
lambda wmlparser, name, params: name.startswith(
"TERRAIN") or name == "DISABLE_TRANSITIONS")
if ignore_macros:
parser.macro_callback = ignore_macros
# Create a WML root element and parse the given text into it.
WML = wmldata.DataSub("WML")
parser.parse_text(text_to_parse)
parser.parse_top(WML)
return WML
def delete_campaign(self, name, passphrase):
"""
Deletes the named campaign on the server.
"""
request = wmldata.DataSub("delete")
request.set_text_val("name", name)
request.set_text_val("passphrase", passphrase)
self.send_packet(self.make_packet(request))
return self.decode(self.read_packet())
def validate_campaign(self, name, passphrase):
"""
Validates python scripts in the named campaign.
"""
request = wmldata.DataSub("validate_scripts")
request.set_text_val("name", name)
request.set_text_val("master_password", passphrase)
self.send_packet(self.make_packet(request))
return self.decode(self.read_packet())
def list_campaigns(self):
"""
Returns a WML object containing all available info from the server.
"""
if self.error:
return None
request = wmldata.DataSub("request_campaign_list")
self.send_packet(self.make_packet(request))
return self.decode(self.read_packet())
def change_passphrase(self, name, old, new):
"""
Changes the passphrase of a campaign on the server.
"""
request = wmldata.DataSub("change_passphrase")
request.set_text_val("name", name)
request.set_text_val("passphrase", old)
request.set_text_val("new_passphrase", new)
self.send_packet(self.make_packet(request))
return self.decode(self.read_packet())
def get_campaign_raw(self, name):
"""
Downloads the named campaign and returns it as a raw binary WML packet.
"""
request = wmldata.DataSub("request_campaign")
request.insert(wmldata.DataText("name", name))
self.send_packet(self.make_packet(request))
raw_packet = self.read_packet()
if self.canceled:
return None
return raw_packet
def put_dir(name, path):
for ig in ign:
if ig[-1] == "/" and fnmatch.fnmatch(name, ig[:-1]):
print("Ignored dir", name)
return None
dataNode = wmldata.DataSub("dir")
dataNode.set_text_val("name", name)
for fn in glob.glob(path + "/*"):
if os.path.isdir(fn):
sub = put_dir(os.path.basename(fn), fn)
else:
sub = put_file(os.path.basename(fn), file(fn))
if sub: dataNode.insert(sub)
return dataNode
def put_file(name, f):
for ig in ign:
if ig[-1] != "/" and fnmatch.fnmatch(name, ig):
print("Ignored file", name)
return None
fileNode = wmldata.DataSub("file")
# Order in which we apply escape sequences matters.
contents = f.read()
contents = contents.replace("\x01", "\x01\x02")
contents = contents.replace("\x00", "\x01\x01")
contents = contents.replace("\x0d", "\x01\x0e")
contents = contents.replace("\xfe", "\x01\xff")
fileContents = wmldata.DataText("contents", contents)
fileNode.insert(fileContents)
fileNode.set_text_val("name", name)
return fileNode
def make_packet(self, doc):
root = wmldata.DataSub("WML")
root.insert(doc)
return root.make_string()
def put_campaign(self, name, cfgfile, directory, ign, stuff):
"""
Uploads a campaign to the server. The title, name, author, passphrase,
description, version and icon parameters are what would normally be
found in a .pbl file.
The cfgfile is the name of the main .cfg file of the campaign.
The directory is the name of the campaign's directory.
"""
request = wmldata.DataSub("upload")
for k, v in stuff.items():
request.set_text_val(k, v)
request.set_text_val("name", name)
data = wmldata.DataSub("data")
request.insert(data)
def put_file(name, f):
for ig in ign:
if ig[-1] != "/" and fnmatch.fnmatch(name, ig):
print("Ignored file", name)
return None
fileNode = wmldata.DataSub("file")
# Order in which we apply escape sequences matters.
contents = f.read()
contents = contents.replace("\x01", "\x01\x02")
contents = contents.replace("\x00", "\x01\x01")
contents = contents.replace("\x0d", "\x01\x0e")
contents = contents.replace("\xfe", "\x01\xff")
fileContents = wmldata.DataText("contents", contents)
fileNode.insert(fileContents)
fileNode.set_text_val("name", name)
return fileNode
def put_dir(name, path):
for ig in ign:
if ig[-1] == "/" and fnmatch.fnmatch(name, ig[:-1]):
print("Ignored dir", name)
return None
dataNode = wmldata.DataSub("dir")
dataNode.set_text_val("name", name)
for fn in glob.glob(path + "/*"):
if os.path.isdir(fn):
sub = put_dir(os.path.basename(fn), fn)
else:
sub = put_file(os.path.basename(fn), file(fn))
if sub: dataNode.insert(sub)
return dataNode
# Only used if it's an old-style campaign directory
# with an external config.
if cfgfile:
data.insert(put_file(name + ".cfg", file(cfgfile)))
sys.stderr.write("Adding directory %s as %s.\n" % (directory, name))
data.insert(put_dir(name, directory))
packet = self.make_packet(request)
open("packet.dump", "wb").write(packet)
self.send_packet(packet)
return self.decode(self.read_packet())
