Пример #1
0
def parse(src):
    def enlisp(s):
        if isa(s,list):
            return map(enlisp,s)
        else:
            return atom(s)
    return enlisp(sexpr.parse(src))
Пример #2
0
 def run(self):
     while not self.enclosing.shutdown:
         try:
             msg_len = self.read_length()
             msg = self.read_msg(msg_len)
             parsed = sexpr.parse(msg)
             # dispatch to handler or just print unhandled
             self.enclosing.on(parsed)
         except Exception as e:
             msg = unicode(e).encode('utf8').replace('"', '\\"')
             self.printer.err('exception in reader thread: %s' % msg)
Пример #3
0
 def run(self):
     while not self.enclosing.shutdown:
         try:
             msg_len = self.read_length()
             msg = self.read_msg(msg_len)
             parsed = sexpr.parse(msg)
             # dispatch to handler or just print unhandled
             self.enclosing.on(parsed)
         except Exception as e:
             msg = unicode(e).encode('utf8').replace('"', '\\"')
             self.printer.err('exception in reader thread: %s' % msg)
Пример #4
0
def runProgram(program):
    sexprs = sexpr.parse(program)
    asm = compiler.compile(sexprs)
    llvmPrelude = llvmTargetInfo()
    f = open("out.ll", 'wt')
    f.write(llvmPrelude)
    f.write(asm)
    f.close()
    outName = 'out'
    if sys.platform == 'win32':
        outName += '.exe'
    while os.path.exists(outName):
        os.unlink(outName)
    myExec("llvmc driver.c out.ll -o out")
    if sys.platform == 'win32':
        return myExec("out")
    else:
        return myExec("./out")
Пример #5
0
    def __init__(self, filename):
        lst = sexpr.parse(filename)
        if lst[0][0] != "supertux-addoninfo":
            raise Exception("not a supertux-addoninfo: %s" % lst[0][0])
        else:
            for k, v in lst[0][1:]:
                if k == "id":
                    self.id = v
                elif k == "version":
                    self.version = int(v)
                elif k == "type":
                    self.type = v
                elif k == "title":
                    self.title = v
                elif k == "author":
                    self.author = v
                elif k == "license":
                    self.license = v
                else:
                    raise Exception("unknown tag: %s" % k)

            self.md5 = ""
            self.url = ""
Пример #6
0
    def parse(self, name):
        """
        Parse an XDLRC file.

        @param name: The filename of the XDLRC file (.xdlrc suffix is optional).
        @type name: String
        """

        SUFFIX = '.xdlrc'
        if not name.endswith(SUFFIX):
            name += SUFFIX

        file = open(name)

        # remove comment lines
        source = ""
        for line in file.readlines():
            if line[0] != '#':
                source += line

        input(source)
        s = parse()
        self.parsedevice(s[0])
Пример #7
0
    def __init__(self, filename):
        lst = sexpr.parse(filename)
        if lst[0][0] != "supertux-addoninfo":
            raise Exception("not a supertux-addoninfo: %s" % lst[0][0])
        else:
            for k, v in lst[0][1:]:
                if k == "id":
                    self.id = v
                elif k == "version":
                    self.version = int(v)
                elif k == "type":
                    self.type = v
                elif k == "title":
                    self.title = v
                elif k == "author":
                    self.author = v
                elif k == "license":
                    self.license = v
                else:
                    raise Exception("unknown tag: %s" % k)

            self.md5 = ""
            self.url = ""
Пример #8
0
def add_version(username):
    if request.method == "POST":
        pprint(request.form)
        if not username == g.user.nickname:
            flash("You're not allowed to publish under this user's id.")
            redirect(url_for("index"))
        # Search for the addon
        addon = Addon.query.filter_by(name=request.form["addon-name"]).first()
        if addon == None:
            return jsonify({"err":"Addon not found!"})
        # Addon exists, check if Version exists
        if db.session.query(AddonVersion,Addon).filter(Addon.user == g.user).filter(AddonVersion.version == request.form["versionnumb"]).first() != None:
            return jsonify({"err": "Version exists!"})
        pprint(request.form)
        os.chdir(os.path.dirname(os.path.realpath(__file__)))
        # Upload from the datasource into directory tmp/:username/
        if request.form["sourcetype"] == "http":
            if 'addonfile' not in request.files:
                return jsonify({"err": "No file given!"})
            # Check if a file was submitted (not empty)

            if request.files["addonfile"] == "":
                return jsonify({"err": "No file selected!"})
            # Check if extension is either 7z or zip
            file = request.files["addonfile"]
            if not (file and allowed_file(file.filename)):
                return jsonify({"err": "Incorrect file selected!"})
            filename = secure_filename(file.filename)
            dirname = os.path.join(app.config['UPLOAD_FOLDER'],addon.name+request.form["versionnumb"])
            if os.path.isdir(dirname):
                shutil.rmtree(dirname)
            os.mkdir(dirname)
            #dirname = os.path.join(dirname, addon.name + request.form["versionnumb"])
            #os.mkdir(dirname)
            filename = os.path.join(dirname, filename)

            file.save(filename)
            os.chdir(dirname)
            # Unzip (or un7zip) the file
            with zipfile.ZipFile(filename, 'r') as myzip:
                for file in myzip.namelist():
                    dir = file.split("/")[0]
                    myzip.extract(file,path=dirname)
            # rename folder
            print(dir)
            os.remove(filename)
            #os.rename(dir,addon.name+request.form["versionnumb"])
            filename = dirname
            print("Uploaded")
            print(filename)
            #return jsonify({"err":fname.filename})
        elif request.form["sourcetype"] == "githubupl":
            print("Uploading from github")
            repo = request.form["reposelect"]
            #  #
            repoapi = github.get("repos/%s/%s"%(g.user.nickname,repo))
            pprint(repoapi)
            dirname = os.path.join(app.config['UPLOAD_FOLDER'], addon.name + request.form["versionnumb"])
            if os.path.isdir(dirname):
                shutil.rmtree(dirname)
            os.mkdir(dirname)
            dirname = os.path.join(dirname, addon.name + request.form["versionnumb"])
            os.mkdir(dirname)
            repo = git.Repo.init(dirname)
            origin = repo.create_remote('origin', repoapi["git_url"])
            origin.fetch()
            origin.pull(origin.refs[0].remote_head)
            filename = dirname
            # Uploaded from github
        elif request.form["sourcetype"] == "superdata":
            # Download from repo
            addonssrc = github.get("repos/SuperTux/addons-src/contents/")
            # Create directory, download zip , then only unpack appropriate folder
            dirname = os.path.join(app.config['UPLOAD_FOLDER'], addon.name + request.form["versionnumb"])
            if os.path.isdir(dirname):
                shutil.rmtree(dirname)
            os.mkdir(dirname)
            zip_file_url = "https://github.com/SuperTux/addons-src/archive/master.zip"

            with open(dirname+'/addons.zip', 'wb') as handle:
                response = requests.get(zip_file_url)

                if not response.ok:
                    return jsonify({"err":"Unable to fetch supertux/addons-src. Please upload manually (e.g. via ftp)"})
                # Something went wrong

                for block in response.iter_content(1024):
                    handle.write(block)
            with zipfile.ZipFile(dirname+'/addons.zip',"r") as z:
                for item in z.namelist():
                    if item.startswith("addons-src-master/"+request.form["import-folder"]+"/"):
                        print("Found file")
                        z.extract(item,path=dirname)
                        if item == "addons-src-master/"+request.form["import-folder"]+"/":
                            filename = os.path.join(dirname,item)
            os.remove(dirname+"/addons.zip")
            print(filename)
            os.rename(filename, os.path.join(dirname,addon.name + request.form["versionnumb"]))
            filename = os.path.join(dirname, addon.name + request.form["versionnumb"])

        else:
            return jsonify({"err": "Source unknown!"})
        version = AddonVersion()
        version.addon = addon
        olddir  = os.getcwd()
        version.changes = request.form.get("description","")
        q = AddonVersion.query.filter_by(addon=addon).order_by(AddonVersion.int_version.desc())
        if q.first().int_version == None:
            version.int_version = 1
        else:
            version.int_version = q.first().int_version + 1
        print("Generating .nfo file")
        #### File is now uploaded #### => if managed mode it's nearly done, else check for md5 hash, version number
        if addon.automaticmode:
            os.chdir(filename)
            if len(glob.glob("*.nfo")) != 0:
                return jsonify({"err":"A .nfo file was found in this addon. Please delete it (a .nfo file will be generated.)"})
            print("Generating ... ")
            version.version = request.form["versionnumb"]
            version.author = addon.author
            version.license = addon.license
            # create .nfo file
            f = open(os.path.join(filename,"addon.nfo"),"w")
            f.write(version.generateNFO())
            f.close()
            print(version.generateNFO())
        else:
            # Check for NFO File in directory

            print("Searching for .nfo file")
            os.chdir(filename)
            if len(glob.glob("*.nfo")) == 0:
                print("No .nfo file was found")
                return jsonify({"err":"No .nfo file was found!"})
            if len(glob.glob("*.nfo")) > 1:
                print("Too many .nfo files were found")
                return jsonify({"err": "Too many .nfo files were found!"})
            nfofile = glob.glob("*.nfo")[0]
            print(nfofile)
            f = open(nfofile,"r")
            fcon = ("".join(f.readlines()))

            # Redo is used for indicating, that the .nfo file will have to be rewritten
            redo = False
            # Use grumbel's sexpr to parse the file
            try:
                x = sexpr.parse(fcon)
            except Exception:
                print("Bad format!")
                return jsonify({"err":"The nfo file seems to be poorly formatted. (Please recheck)"})
            for elem in x[0]:
                print(elem)
                if elem[0] == "version":
                    version.version = elem[1]
                if elem[0] == "license":
                    version.license = elem[1]
                if elem[0] == "author":
                    version.author = elem[1]
                if elem[0] == "id":
                    print(elem)
                    if not addon.name == elem[1]:
                        if request.form.get("correctId") == "on":
                            redo = True
                        else:
                            return jsonify({"err":"The id in the .nfo file must match %s"%(addon.name)})
            if redo:
                # Overwrite version info
                f = open(nfofile,"w")
                f.write(version.generateNFO())
                f.close()
        print("Done here!")
        # Internal version number was set
        print(version.int_version)
        # Finally zip and 7z the addon
        # Return to "main" directory
        os.chdir(os.path.dirname(os.path.realpath(__file__)))
        print("******* CREATING ZIP FILE ***********")
        print(filename)
        os.chdir(filename)
        subprocess.call(["zip", "-X", "-r", "--quiet", '%s_%s.zip'%(addon.name,version.int_version), "."], cwd=filename)
        time.sleep(4)
        shutil.copy('%s_%s.zip'%(addon.name,version.int_version), os.path.join(os.path.dirname(os.path.realpath(__file__)),'addons/%s_%s.zip'%(addon.name,version.int_version)))
        # Add file
        f = AddonFiles()
        f.addonvers = version
        f.format = "zip"
        f.path = 'addons/%s_%s.zip'%(addon.name,version.int_version)

        db.session.add(version)
        db.session.add(f)

        # Add supported Versions

        db.session.commit()
        for aversion in request.form["versions-selected"].split(","):
            svers = SuperTuxVersions.query.filter_by(version=aversion).first()
            if svers != None:
                svers.addons.append(version)
                db.session.add(svers)
        db.session.commit()
        return "ok"
    # Check if user exists available
    user = User.query.filter_by(nickname=username).first()
    if user == None or user != g.user:
        flash("That user doesn't exist, or you don't have permission.")
        redirect(url_for("index"))
    # Get github data
    repos = []
    reposraw = github.get("user/repos")
    print(reposraw)
    for repo in reposraw:
        repos.append(repo["name"])

    addonssrc = github.get("repos/SuperTux/addons-src/contents/")
    print(addonssrc)
    dirs = []
    for f in addonssrc:
        if f["type"] == "dir":
            dirs.append(f["name"])
    print(dirs)
    versions = []
    for version in SuperTuxVersions.query.all():
        versions.append(version.version)
    addons =user.addons.all()
    return render_template("addon/update.html", **locals())
Пример #9
0
import sexpr
import sys
import os
from pprint import pprint
from subprocess import Popen, PIPE

fname = sys.argv[1]
name = os.path.basename(fname).split('.')[0]
file = open(fname)

source = ""
for line in file.readlines():
    if line[0] != "#":
        source += line
sexpr.input(source)
s = sexpr.parse()
while len(s) == 1:
    s = s[0]
table = {}
for x in s:
    table[x[0]] = x[1:]


class Element():
    def __init__(self, name):
        self.name = name
        self.cfg = []
        self.inputs = []
        self.outputs = []

    def canelide(self):
Пример #10
0
 def test_2_integers(self):
     self.assertEqual([32,33], sexpr.parse("32 33"))
Пример #11
0
 def test_2_empty_lists(self):
     self.assertEqual([[],[]], sexpr.parse("()()"))