Skip to content
Snippets Groups Projects
Select Git revision
  • a733b92fd96878531b19ca859dc034e84230d5a7
  • master default
  • labcomm2006
  • typedefs
  • anders.blomdell
  • typeref
  • pragma
  • compiler-refactoring
  • labcomm2013
  • v2014.4
  • v2006.0
  • v2014.3
  • v2014.2
  • v2014.1
  • v2014.0
  • v2013.0
16 results

run

Blame
  • Forked from Anders Blomdell / LabComm
    560 commits behind the upstream repository.
    user avatar
    Sven Robertz authored
    e79e7ead
    History
    run 4.99 KiB
    #!/usr/bin/python
    # -*- coding: iso8859-15 -*-
    
    import math
    import os
    import sys
    import re
    import traceback
    import ccode
    import cscode
    
    def run_labcomm(base):
        if not os.path.exists("gen/java/%s" % base):
            os.makedirs("gen/java/%s" % base)
        if not os.path.exists("gen/csharp"):
            os.makedirs("gen/csharp")
        if not os.path.exists("gen/c"):
            os.makedirs("gen/c")
        if not os.path.exists("gen/python"):
            os.makedirs("gen/python")
        cmd = " ".join([
            "java -jar ../compiler/labComm.jar",
            "--c=gen/c/%s.c" % base,
            "--h=gen/c/%s.h" % base,
            "--cs=gen/csharp/%s.cs" % base,
            "--python=gen/python/%s.py" % base,
            "--java=gen/java/%s" % base,
            "--typeinfo=gen/%s.typeinfo" % base,
            "%s.lc" % base
            ])
        err = os.system(cmd)
        if err != 0:
            sys.exit(err / 256)
            
    class hexwriter(object):
        def __init__(self, filename=None):
            self.pos = 0
            self.ascii = ''
            if filename:
                self.outfile = open(filename, "w")
            else:
                self.outfile = None
    
        def write(self, data):
            for c in data:
                if ' ' <= c and c <= '}':
                    self.ascii += c
                else:
                    self.ascii += '.'
                sys.stdout.write("%2.2x " % ord(c))
                self.pos += 1
                if self.pos >= 15:
                    sys.stdout.write("%s\n" % self.ascii)
                    self.pos = 0
                    self.ascii = ""
            self.outfile.write(data)
            
        def mark(self):
            pass
    
        def flush(self):
            for i in range(self.pos, 15):
                sys.stdout.write("   ")
            sys.stdout.write("%s\n" % self.ascii)
            self.pos = 0
            self.ascii = ""
            if self.outfile:
                self.outfile.flush()
    
    
    def generate(decl):
        if decl.__class__ == labcomm.sample:
            result = []
            for values in generate(decl.decl):
                result.append((decl, values))
            return result
    
        elif decl.__class__ == labcomm.struct:
            result = []
            if len(decl.field) == 0:
                result.append({})
            else:
                values1 = generate(decl.field[0][1])
                values2 = generate(labcomm.struct(decl.field[1:]))
                for v1 in values1:
                    for v2 in values2:
                        v = dict(v2)
                        v[decl.field[0][0]] = v1
                        result.append(v)
            return result
        
        elif decl.__class__ == labcomm.array:
            if len(decl.indices) == 1:
                values = generate(decl.decl)
                if decl.indices[0] == 0:
                    lengths = [0, 1, 2]
                else:
                    lengths = [ decl.indices[0] ]
            else:
                values = generate(labcomm.array(decl.indices[1:],decl.decl))
                if decl.indices[0] == 0:
                    lengths = [1, 2]
                else:
                    lengths = [ decl.indices[0] ]
            result = []
            for v in values:
                for i in lengths:
                    element = []
                    for j in range(i):
                        element.append(v)
                    result.append(element)
            return result
    
        elif decl.__class__ == labcomm.BOOLEAN:
            return [False, True]
    
        elif decl.__class__ == labcomm.BYTE:
            return [-128, 0, 127]
    
        elif decl.__class__ == labcomm.SHORT:
            return [-32768, 0, 32767]
    
        elif decl.__class__ == labcomm.INTEGER:
            return [-2147483648, 0, 2147483647]
    
        elif decl.__class__ == labcomm.LONG:
            return [-9223372036854775808, 0, 9223372036854775807]
    
        elif decl.__class__ == labcomm.FLOAT:
            return [-math.pi, 0.0, math.pi]
    
        elif decl.__class__ == labcomm.DOUBLE:
            return [-math.pi, 0.0, math.pi]
    
        elif decl.__class__ == labcomm.STRING:
            return ['string',
                    'teckenstrng'.decode("iso8859-15")]
    
        print decl
        raise Exception("unhandled decl %s" % decl.__class__)
    
    if __name__ == "__main__":
        print os.getcwd(), sys.argv
        if not os.path.exists("gen"):
            os.makedirs("gen")
        if len(sys.argv) > 1:
            files = [s[0:-3] for s in sys.argv[1:] if s.endswith('.lc')]
        else:
            files = [s[0:-3] for s in os.listdir(".") if s.endswith('.lc')]
    
        for f in files:
            run_labcomm(f)
    
        for f in files:
            cscode.test_program("gen/csharp/test_%s.cs" % f,
                                "gen/%s.typeinfo" % f)
    
    
        sys.path.insert(0, "../lib/python")    
        import labcomm;
        sys.path.insert(0, "gen/python")    
        for f in files:
            print f
            h = hexwriter("gen/%s.vec" % f)
            encoder = labcomm.Encoder(h)
            signatures = []
            i = __import__(f)
            for k in dir(i):
                v = getattr(i, k)
                try:
                    s = v.signature
                except:
                    s = None
                if s:
                    signatures.append(s)
                    encoder.add_decl(s)
            for s in signatures:
                for e in generate(s):
                    encoder.encode(e[1], s)
    
            h.flush()
    
            ccode.gen(f, signatures)