Skip to content
Snippets Groups Projects

Compare revisions

Changes are shown as if the source revision was being merged into the target revision. Learn more about comparing revisions.

Source

Select target project
No results found
Select Git revision
Loading items

Target

Select target project
  • anders_blomdell/labcomm
  • klaren/labcomm
  • tommyo/labcomm
  • erikj/labcomm
  • sven/labcomm
5 results
Select Git revision
Loading items
Show changes
#!/usr/bin/python
import argparse
import re
import sys
......@@ -13,7 +14,13 @@ def split_match(pattern, multiline):
if __name__ == '__main__':
f = open(sys.argv[1])
parser = argparse.ArgumentParser(description='Generate C test relay.')
parser.add_argument('--renaming', action='store_true')
parser.add_argument('typeinfo', help='typeinfo file')
options = parser.parse_args(sys.argv[1:])
f = open(options.typeinfo)
sample = []
for l in map(lambda s: s.strip(), f):
lang,kind,func,arg,stype = l[1:].split(l[0])
......@@ -27,60 +34,117 @@ if __name__ == '__main__':
|#include <sys/types.h>
|#include <sys/stat.h>
|#include <fcntl.h>
|#include <labcomm.h>
|#include <labcomm_default_error_handler.h>
|#include <labcomm_default_memory.h>
|#include <labcomm_default_scheduler.h>
|#include <labcomm_fd_reader.h>
|#include <labcomm_fd_writer.h>
|#include <stdio.h>
|#include <errno.h>
|#include <labcomm2014.h>
|#include <labcomm2014_default_error_handler.h>
|#include <labcomm2014_default_memory.h>
|#include <labcomm2014_default_scheduler.h>
|#include <labcomm2014_fd_reader.h>
|#include <labcomm2014_fd_writer.h>
"""))
if options.renaming:
result.extend(split_match('^[^|]*\|(.*)$', """
|#include "labcomm2014_renaming.h"
|#include "labcomm2014_renaming_encoder.h"
|#include "labcomm2014_renaming_decoder.h"
"""))
result.extend(split_match('^[^|]*\|(.*)$', """
|#include "c_code.h"
"""))
for func,arg,stype in sample:
result.extend(split_match('^[^|]*\|(.*)$', """
|void handle_%(func)s(%(arg)s *v, void *context)
|{
| struct labcomm_encoder *e = context;
| labcomm_encode_%(func)s(e%(valargstr)s);
| struct labcomm2014_encoder *e = context;
| labcomm2014_encode_%(func)s(e%(valargstr)s);
|}""" % { 'func': func, 'arg': arg, 'valargstr': '' if stype == "void" else', v' }))
# result.extend(split_match('^[^|]*\|(.*)$', """
# |void handle_%(func)s(%(arg)s *v, void *context)
# |{
# | struct labcomm_encoder *e = context;
# | labcomm_encode_%(func)s(e, v);
# |}""" % { 'func': func, 'arg': arg }))
pass
result.extend(split_match('^[^|]*\|(.*)$', """
|int main(int argc, char *argv[]) {
| struct labcomm_encoder *e;
| struct labcomm_decoder *d;
| int in, out;
| struct labcomm2014_encoder *e, *e_e;
| struct labcomm2014_decoder *d, *d_d;
"""))
if options.renaming:
result.extend(split_match('^[^|]*\|(.*)$', """
| struct labcomm2014_renaming_registry *registry;
| struct labcomm2014_encoder *e_p, *e_s;
| struct labcomm2014_decoder *d_p, *d_s;
"""))
result.extend(split_match('^[^|]*\|(.*)$', """
| int in, out, result;
|
| if (argc < 3) { return 1; }
| in = open(argv[1], O_RDONLY);
| if (in < 0) { return 1; }
| out = open(argv[2], O_WRONLY);
| if (out < 0) { return 1; }
| e = labcomm_encoder_new(labcomm_fd_writer_new(
| labcomm_default_memory, out, 1),
| labcomm_default_error_handler,
| labcomm_default_memory,
| labcomm_default_scheduler);
| d = labcomm_decoder_new(labcomm_fd_reader_new(
| labcomm_default_memory, in, 1),
| labcomm_default_error_handler,
| labcomm_default_memory,
| labcomm_default_scheduler);
| e_e = labcomm2014_encoder_new(labcomm2014_fd_writer_new(
| labcomm2014_default_memory, out, 1),
| labcomm2014_default_error_handler,
| labcomm2014_default_memory,
| labcomm2014_default_scheduler);
| d_d = labcomm2014_decoder_new(labcomm2014_fd_reader_new(
| labcomm2014_default_memory, in, 1),
| labcomm2014_default_error_handler,
| labcomm2014_default_memory,
| labcomm2014_default_scheduler);
"""))
if not options.renaming:
result.extend(split_match('^[^|]*\|(.*)$', """
| e = e_e;
| d = d_d;
"""))
else:
result.extend(split_match('^[^|]*\|(.*)$', """
| registry = labcomm2014_renaming_registry_new(
| labcomm2014_default_error_handler,
| labcomm2014_default_memory,
| labcomm2014_default_scheduler);
| e_p = labcomm2014_renaming_encoder_new(e_e,
| registry,
| labcomm2014_renaming_prefix,
| "prefix:");
| e_s = labcomm2014_renaming_encoder_new(e_p,
| registry,
| labcomm2014_renaming_suffix,
| ":suffix");
| e = e_s;
| d_p = labcomm2014_renaming_decoder_new(d_d,
| registry,
| labcomm2014_renaming_prefix,
| "prefix:");
| d_s = labcomm2014_renaming_decoder_new(d_p,
| registry,
| labcomm2014_renaming_suffix,
| ":suffix");
| d = d_s;
"""))
for func,arg,stype in sample:
result.extend(split_match('^[^|]*\|(.*)$', """
| labcomm_encoder_register_%(func)s(e);
| labcomm_encoder_sample_ref_register(e, labcomm_signature_%(func)s);
| labcomm_decoder_register_%(func)s(d, handle_%(func)s, e);
| labcomm_decoder_sample_ref_register(d, labcomm_signature_%(func)s);
| labcomm2014_encoder_register_%(func)s(e);
| labcomm2014_encoder_sample_ref_register(e, labcomm2014_signature_%(func)s);
| labcomm2014_decoder_register_%(func)s(d, handle_%(func)s, e);
| labcomm2014_decoder_sample_ref_register(d, labcomm2014_signature_%(func)s);
""" % { 'func': func, 'arg': arg }))
result.extend(split_match('^[^|]*\|(.*)$', """
| labcomm_decoder_run(d);
| return 0;
| while ((result = labcomm2014_decoder_decode_one(d)) > 0) {};
"""))
if options.renaming:
result.extend(split_match('^[^|]*\|(.*)$', """
| labcomm2014_decoder_free(d_s);
| labcomm2014_decoder_free(d_p);
| labcomm2014_encoder_free(e_s);
| labcomm2014_encoder_free(e_p);
| labcomm2014_renaming_registry_free(registry);
"""))
result.extend(split_match('^[^|]*\|(.*)$', """
| labcomm2014_decoder_free(d_d);
| labcomm2014_encoder_free(e_e);
| if (result == 0) return 0;
| if (result == -EPIPE) return 0;
| fprintf(stderr, "Failed with %d", result);
| return 1;
|}
"""))
print "\n".join(result)
......
#!/usr/bin/python
import argparse
import re
import sys
import random
......@@ -18,7 +19,13 @@ def shuffle(l):
return result
if __name__ == '__main__':
f = open(sys.argv[1])
parser = argparse.ArgumentParser(description='Generate C test relay.')
parser.add_argument('--renaming', action='store_true')
parser.add_argument('typeinfo', help='typeinfo file')
options = parser.parse_args(sys.argv[1:])
f = open(options.typeinfo)
sample = []
for l in map(lambda s: s.strip(), f):
lang,kind,func,arg,dummy = l[1:].split(l[0])
......@@ -30,7 +37,7 @@ if __name__ == '__main__':
result.extend(split_match('^[^|]*\|(.*)$', """
|using System;
|using System.IO;
|using se.lth.control.labcomm;
|using se.lth.control.labcomm2014;
|
|public class cs_relay :
"""))
......@@ -40,7 +47,9 @@ if __name__ == '__main__':
result.append(' %s.Handler' % sample[-1][0])
result.extend(split_match('^[^|]*\|(.*)$', """
|{
| EncoderChannel encoder;
| Encoder encoder;
| Decoder decoder;
|
"""))
for func,arg in sample:
if arg == 'void':
......@@ -63,13 +72,22 @@ if __name__ == '__main__':
| FileStream InFile = new FileStream(InName,
| FileMode.Open,
| FileAccess.Read);
| DecoderChannel decoder = new DecoderChannel(InFile);
| decoder = new DecoderChannel(InFile);
| FileStream OutFile = new FileStream(OutName,
| FileMode.OpenOrCreate,
| FileAccess.Write);
| encoder = new EncoderChannel(OutFile);
|
"""))
if options.renaming:
result.extend(split_match('^[^|]*\|(.*)$', """
| RenamingRegistry registry = new RenamingRegistry();
| decoder = new RenamingDecoder(
| decoder, registry, s => "prefix:" + s + ":suffix");
| encoder = new RenamingEncoder(
| encoder, registry, s => "prefix:" + s + ":suffix");
"""))
for func,arg in shuffle(sample):
result.append(' %s.register(decoder, this);' % func)
pass
......
......@@ -31,9 +31,9 @@ if __name__ == '__main__':
|import java.io.FileInputStream;
|import java.io.FileOutputStream;
|import java.io.IOException;
|import se.lth.control.labcomm.DecoderChannel;
|import se.lth.control.labcomm.EncoderChannel;
|import se.lth.control.labcomm.Sample;
|import se.lth.control.labcomm2014.DecoderChannel;
|import se.lth.control.labcomm2014.EncoderChannel;
|import se.lth.control.labcomm2014.Sample;
|
|public class java_relay implements
"""))
......
......@@ -3,7 +3,7 @@
import argparse
import imp
import labcomm
import labcomm2014
import math
import os
import re
......@@ -37,7 +37,7 @@ def get_signatures(path):
with fp as fp:
m = imp.load_module('signatures', fp, pathname, description)
pass
return m.sample
return map(lambda s: s.signature, m.sample)
class Test:
......@@ -47,19 +47,25 @@ class Test:
pass
def generate(self, decl):
if decl.__class__ == labcomm.sample:
if decl.__class__ == labcomm2014.sample:
result = []
for values in self.generate(decl.decl):
result.append((decl, values))
return result
elif decl.__class__ == labcomm.struct:
elif decl.__class__ == labcomm2014.typedef:
result = []
for values in self.generate(decl.decl):
result.append(values)
return result
elif decl.__class__ == labcomm2014.struct:
result = []
if len(decl.field) == 0:
result.append({})
else:
values1 = self.generate(decl.field[0][1])
values2 = self.generate(labcomm.struct(decl.field[1:]))
values2 = self.generate(labcomm2014.struct(decl.field[1:]))
for v1 in values1:
for v2 in values2:
v = dict(v2)
......@@ -67,7 +73,7 @@ class Test:
result.append(v)
return result
elif decl.__class__ == labcomm.array:
elif decl.__class__ == labcomm2014.array:
if len(decl.indices) == 1:
values = self.generate(decl.decl)
if decl.indices[0] == 0:
......@@ -75,7 +81,7 @@ class Test:
else:
lengths = [ decl.indices[0] ]
else:
values = self.generate(labcomm.array(decl.indices[1:],
values = self.generate(labcomm2014.array(decl.indices[1:],
decl.decl))
if decl.indices[0] == 0:
lengths = [1, 2]
......@@ -90,53 +96,53 @@ class Test:
result.append(element)
return result
elif decl.__class__ == labcomm.BOOLEAN:
elif decl.__class__ == labcomm2014.BOOLEAN:
return [False, True]
elif decl.__class__ == labcomm.BYTE:
elif decl.__class__ == labcomm2014.BYTE:
return [0, 127, 128, 255]
elif decl.__class__ == labcomm.SHORT:
elif decl.__class__ == labcomm2014.SHORT:
return [-32768, 0, 32767]
elif decl.__class__ == labcomm.INTEGER:
elif decl.__class__ == labcomm2014.INTEGER:
return [-2147483648, 0, 2147483647]
elif decl.__class__ == labcomm.LONG:
elif decl.__class__ == labcomm2014.LONG:
return [-9223372036854775808, 0, 9223372036854775807]
elif decl.__class__ == labcomm.FLOAT:
elif decl.__class__ == labcomm2014.FLOAT:
def tofloat(v):
return struct.unpack('f', struct.pack('f', v))[0]
return [tofloat(-math.pi), 0.0, tofloat(math.pi)]
elif decl.__class__ == labcomm.DOUBLE:
elif decl.__class__ == labcomm2014.DOUBLE:
return [-math.pi, 0.0, math.pi]
elif decl.__class__ == labcomm.STRING:
elif decl.__class__ == labcomm2014.STRING:
return ['string', u'sträng' ]
elif decl.__class__ == labcomm.SAMPLE:
return [ s for n,s in self.signatures ]
elif decl.__class__ == labcomm2014.SAMPLE:
return self.signatures
print>>sys.stderr, decl
raise Exception("unhandled decl %s" % decl.__class__)
def uses_refs(self, decls):
for decl in decls:
if decl.__class__ == labcomm.sample:
if decl.__class__ == labcomm2014.sample:
if self.uses_refs([ decl.decl ]):
return True
elif decl.__class__ == labcomm.struct:
elif decl.__class__ == labcomm2014.struct:
if self.uses_refs([ d for n,d in decl.field ]):
return True
elif decl.__class__ == labcomm.array:
elif decl.__class__ == labcomm2014.array:
if self.uses_refs([ decl.decl ]):
return True
elif decl.__class__ == labcomm.SAMPLE:
elif decl.__class__ == labcomm2014.SAMPLE:
return True
return False
......@@ -153,18 +159,17 @@ class Test:
self.next = threading.Condition()
decoder = threading.Thread(target=self.decode, args=(p.stdout,))
decoder.start()
encoder = labcomm.Encoder(labcomm.StreamWriter(p.stdin))
for name,signature in self.signatures:
encoder = labcomm2014.Encoder(labcomm2014.StreamWriter(p.stdin))
for signature in self.signatures:
encoder.add_decl(signature)
pass
if self.uses_refs([ s for n,s in self.signatures ]):
for name,signature in self.signatures:
if self.uses_refs(self.signatures):
for signature in self.signatures:
encoder.add_ref(signature)
for name,signature in self.signatures:
print>>sys.stderr, "Checking", name,
for signature in self.signatures:
print>>sys.stderr, "Checking", signature.name,
for decl,value in self.generate(signature):
sys.stderr.write('.')
#print name,decl,value,value.__class__
self.next.acquire()
self.received_value = None
self.received_decl = None
......@@ -174,7 +179,7 @@ class Test:
if p.poll() != None:
print>>sys.stderr, "Failed with:", p.poll()
self.failed = True
elif value != self.received_value:
elif value != self.received_value or decl != self.received_decl:
print>>sys.stderr, "Coding error"
print>>sys.stderr, value == self.received_value
print>>sys.stderr, "Got: ", self.received_value
......@@ -197,7 +202,7 @@ class Test:
pass
def decode(self, f):
decoder = labcomm.Decoder(labcomm.StreamReader(f))
decoder = labcomm2014.Decoder(labcomm2014.StreamReader(f))
try:
while True:
value,decl = decoder.decode()
......
#!/usr/bin/python
# -*- coding: utf-8 -*-
import argparse
import imp
import labcomm2014
import math
import os
import re
import struct
import subprocess
import sys
import threading
def labcomm_compile(lc, name, args):
for lang in [ 'c', 'csharp', 'java', 'python']:
destdir = 'gen/%s/%s' % (name, lang)
if not os.path.exists(destdir):
os.makedirs(destdir)
pass
pass
cmd = args.labcomm.split() + [
"--c=gen/%s/c/%s.c" % (name, name),
"--h=gen/%s/c/%s.h" % (name, name),
"--cs=gen/%s/csharp/%s.cs" % (name, name),
"--python=gen/%s/python/%s.py" % (name, name),
"--java=gen/%s/java/" % name,
"--typeinfo=gen/%s/%s.typeinfo" % (name, name),
lc]
subprocess.check_call(cmd)
pass
def get_signatures(path):
fp, pathname, description = imp.find_module(os.path.basename(path)[0:-3],
[ os.path.dirname(path) ])
with fp as fp:
m = imp.load_module('signatures', fp, pathname, description)
pass
return map(lambda s: s.signature, m.sample)
class Test:
def __init__(self, program, signatures):
self.program = program
self.signatures = map(lambda s: s.rename('prefix:%s:suffix' % s.name),
signatures)
pass
def generate(self, decl):
if decl.__class__ == labcomm2014.sample:
result = []
for values in self.generate(decl.decl):
result.append((decl, values))
return result
elif decl.__class__ == labcomm2014.typedef:
result = []
for values in self.generate(decl.decl):
result.append(values)
return result
elif decl.__class__ == labcomm2014.struct:
result = []
if len(decl.field) == 0:
result.append({})
else:
values1 = self.generate(decl.field[0][1])
values2 = self.generate(labcomm2014.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__ == labcomm2014.array:
if len(decl.indices) == 1:
values = self.generate(decl.decl)
if decl.indices[0] == 0:
lengths = [0, 1, 2]
else:
lengths = [ decl.indices[0] ]
else:
values = self.generate(labcomm2014.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__ == labcomm2014.BOOLEAN:
return [False, True]
elif decl.__class__ == labcomm2014.BYTE:
return [0, 127, 128, 255]
elif decl.__class__ == labcomm2014.SHORT:
return [-32768, 0, 32767]
elif decl.__class__ == labcomm2014.INTEGER:
return [-2147483648, 0, 2147483647]
elif decl.__class__ == labcomm2014.LONG:
return [-9223372036854775808, 0, 9223372036854775807]
elif decl.__class__ == labcomm2014.FLOAT:
def tofloat(v):
return struct.unpack('f', struct.pack('f', v))[0]
return [tofloat(-math.pi), 0.0, tofloat(math.pi)]
elif decl.__class__ == labcomm2014.DOUBLE:
return [-math.pi, 0.0, math.pi]
elif decl.__class__ == labcomm2014.STRING:
return ['string', u'sträng' ]
elif decl.__class__ == labcomm2014.SAMPLE:
return self.signatures
print>>sys.stderr, decl
raise Exception("unhandled decl %s" % decl.__class__)
def uses_refs(self, decls):
for decl in decls:
if decl.__class__ == labcomm2014.sample:
if self.uses_refs([ decl.decl ]):
return True
elif decl.__class__ == labcomm2014.struct:
if self.uses_refs([ d for n,d in decl.field ]):
return True
elif decl.__class__ == labcomm2014.array:
if self.uses_refs([ decl.decl ]):
return True
elif decl.__class__ == labcomm2014.SAMPLE:
return True
return False
def run(self):
print>>sys.stderr, 'Testing', self.program
p = subprocess.Popen(self.program,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=sys.stderr)
self.expected = None
self.failed = False
self.next = threading.Condition()
decoder = threading.Thread(target=self.decode, args=(p.stdout,))
decoder.start()
encoder = labcomm2014.Encoder(labcomm2014.StreamWriter(p.stdin))
for signature in self.signatures:
encoder.add_decl(signature)
pass
if self.uses_refs(self.signatures):
for signature in self.signatures:
encoder.add_ref(signature)
for signature in self.signatures:
print>>sys.stderr, "Checking", signature.name,
for decl,value in self.generate(signature):
sys.stderr.write('.')
self.next.acquire()
self.received_value = None
self.received_decl = None
encoder.encode(value, decl)
self.next.wait(2)
self.next.release()
if p.poll() != None:
print>>sys.stderr, "Failed with:", p.poll()
self.failed = True
elif value != self.received_value or decl != self.received_decl:
print>>sys.stderr, "Coding error"
print>>sys.stderr, value == self.received_value
print>>sys.stderr, "Got: ", self.received_value
print>>sys.stderr, " ", self.received_decl
print>>sys.stderr, "Expected:", value
print>>sys.stderr, " ", decl
self.failed = True
if self.failed:
if p.poll() == None:
p.terminate()
exit(1)
pass
print>>sys.stderr
pass
p.stdin.close()
if p.wait() != 0:
exit(1)
pass
pass
def decode(self, f):
decoder = labcomm2014.Decoder(labcomm2014.StreamReader(f))
try:
while True:
value,decl = decoder.decode()
if value != None:
self.next.acquire()
self.received_value = value
self.received_decl = decl
self.expected = None
self.next.notify_all()
self.next.release()
pass
pass
except EOFError:
pass
pass
pass
def run(test, signatures):
t = Test(test, signatures)
t.run()
pass
if __name__ == "__main__":
parser = argparse.ArgumentParser(description='Run encoding test.')
class test_action(argparse.Action):
def __call__(self, parser, namespace, values, option_string=None):
old = list(getattr(namespace, self.dest))
def strip_slash(s):
if s.startswith('\\'):
return s[1:]
return s
old.append(map(strip_slash, values))
setattr(namespace, self.dest, old)
parser.add_argument('--signatures')
parser.add_argument('--test', nargs='*', action=test_action, default=[])
args = parser.parse_args()
signatures = get_signatures(args.signatures)
for test in args.test:
run(test, signatures)
exit(0)
for lc in args.lc:
run(lc, args)
pass
pass
#!/usr/bin/env python
import argparse
import labcomm2014
import sys
import labcomm
import time
class Reader(object):
def __init__(self, _file):
self._file = open(_file)
def __init__(self, file_):
self._file = file_
def read(self, count):
data = self._file.read(count)
......@@ -18,43 +20,91 @@ class Reader(object):
pass
class FollowingReader(Reader):
def __init__(self, file_, interval, timeout):
super(FollowingReader, self).__init__(file_)
self._interval = interval
self._timeout = timeout
def read(self, count):
data = ''
t_start = time.time()
while len(data) < count:
tmp = self._file.read(count - len(data))
if tmp:
data += tmp
else:
time.sleep(self._interval)
if self._timeout and time.time() - t_start > self._timeout:
raise EOFError()
return data
def flatten(sample, _type):
if isinstance(_type, labcomm.sample):
if isinstance(_type, labcomm2014.sample):
flatten(sample, _type.decl)
elif isinstance(_type, labcomm.array):
elif isinstance(_type, labcomm2014.array):
for e in sample:
flatten(e, _type.decl)
elif isinstance(_type, labcomm.struct):
elif isinstance(_type, labcomm2014.struct):
for name, decl in _type.field:
flatten(sample[name], decl)
elif isinstance(_type, labcomm.BOOLEAN):
elif isinstance(_type, labcomm2014.BOOLEAN):
print "%d," % sample,
elif isinstance(_type, labcomm.STRING):
elif isinstance(_type, labcomm2014.STRING):
print "\"%s\"," % sample,
elif isinstance(_type, labcomm.primitive):
elif isinstance(_type, labcomm2014.primitive):
print "%s," % sample,
else:
print sample, _type
raise Exception("Unhandled type. " + str(type(type_)) + " " + str(type_))
def flatten_labels(sample, _type, prefix=""):
if isinstance(_type, labcomm.sample):
flatten_labels(sample, _type.decl, _type.name)
elif isinstance(_type, labcomm.array):
def flatten_labels(_type, prefix=""):
if isinstance(_type, labcomm2014.sample):
flatten_labels(_type.decl, _type.name)
elif isinstance(_type, labcomm2014.array):
if len(_type.indices) != 1:
raise Exception("Fix multidimensional arrays")
if len(sample) == 0:
if len(_type.indices) == 0:
raise Exception("We dont't handle dynamical sizes yet %s" % _type)
for i in range(0, len(sample)):
flatten_labels(sample[i], _type.decl, prefix + "[%d]" % i)
elif isinstance(_type, labcomm.struct):
for i in range(0, _type.indices[0]):
flatten_labels(_type.decl, prefix + "[%d]" % i)
elif isinstance(_type, labcomm2014.struct):
for name, decl in _type.field:
flatten_labels(sample[name], decl,
flatten_labels(decl,
prefix + "." + name)
elif isinstance(_type, labcomm.primitive):
elif isinstance(_type, labcomm2014.primitive):
print '"%s",' % prefix,
else:
print sample, _type
raise Exception("Unhandled type. " + str(type(type_)) + " " + str(type_))
def default(type_):
if isinstance(type_, labcomm2014.sample):
return default(type_.decl)
elif isinstance(type_, labcomm2014.array):
if len(type_.indices) != 1:
raise Exception("Fix multidimensional arrays")
if len(type_.indices) == 0:
raise Exception("We dont't handle dynamical sizes yet %s" % type_)
for i in range(0, type_.indices[0]):
return [default(type_.decl) for _ in range(type_.indices[0])]
elif isinstance(type_, labcomm2014.struct):
return {name: default(decl) for name, decl in type_.field}
elif isinstance(type_, labcomm2014.STRING):
return ''
elif isinstance(type_, labcomm2014.BOOLEAN):
return False
elif (isinstance(type_, labcomm2014.FLOAT) or
isinstance(type_, labcomm2014.DOUBLE)):
return float('NaN')
elif (isinstance(type_, labcomm2014.BYTE) or
isinstance(type_, labcomm2014.SHORT) or
isinstance(type_, labcomm2014.INTEGER) or
isinstance(type_, labcomm2014.LONG)):
return 0
else:
raise Exception("Unhandled type. " + str(type(type_)) + " " + str(type_))
def dump(sample, _type):
......@@ -63,49 +113,84 @@ def dump(sample, _type):
print
def dump_labels(current, _type):
for k in sorted(_type.keys()):
flatten_labels(current[k], _type[k])
def dump_labels(type_):
for k in sorted(type_.keys()):
flatten_labels(type_[k])
print
def main():
if len(sys.argv) != 2:
sys.exit("Give input file as argument\n")
d = labcomm.Decoder(Reader(sys.argv[1]))
seen = {}
current = {}
_type = {}
# Do one pass through the file to find all registrations.
def defaults(current, type_):
for k in sorted(type_.keys()):
if k not in current:
current[k] = default(type_[k])
def main(main_args):
parser = argparse.ArgumentParser()
parser.add_argument('elc', type=str, help="The log file.")
parser.add_argument('-f', '--follow', action='store_true',
help="find all registrations that already "
"exist, then watch the file for changes. All "
"future registrations are ignored (because "
"the header has already been written).")
parser.add_argument('-s', '--interval', action="store", type=float,
default=0.040,
help="time to sleep between failed reads. Requires -f.")
parser.add_argument('-t', '--timeout', action="store", type=float,
help="timeout to terminate when no changes are detected. "
"Requires -f.")
parser.add_argument('-w', '--no-default-columns', action="store_true",
help="Do not fill columns for which there is no "
"data with default values. Wait instead until at least "
"one sample has arrived for each registration.")
parser.add_argument('-a', '--trigger-all', action="store_true",
help="Output one line for each sample instead of for "
"each sample of the registration that has arrived with "
"the highest frequency.")
args = parser.parse_args(main_args)
n_samples = {} # The number of received samples for each sample reg.
current = {} # The most recent sample for each sample reg.
type_ = {} # The type (declaration) of each sample reg.
file_ = open(args.elc)
if args.follow:
reader = FollowingReader(file_, args.interval, args.timeout)
else:
reader = Reader(file_)
d = labcomm2014.Decoder(reader)
while True:
try:
o, t = d.decode()
if o is None:
seen[t.name] = 0
_type[t.name] = t
n_samples[t.name] = 0
type_[t.name] = t
else:
n_samples[t.name] += 1
current[t.name] = o
break
except EOFError:
break
dump_labels(current, _type)
# Do another pass to extract the data.
current = {}
d = labcomm.Decoder(Reader(sys.argv[1]))
dump_labels(type_)
if not args.no_default_columns:
defaults(current, type_)
n_rows = 0
while True:
try:
o, t = d.decode()
if o is not None:
if o is None:
continue
current[t.name] = o
if len(current) == len(_type):
# Assume that samples arrive at different rates.
# Trigger on everything once we have a value for
# each column.
dump(current, _type)
n_samples[t.name] += 1
if len(current) < len(type_):
continue
if args.trigger_all:
dump(current, type_)
else:
if n_samples[t.name] > n_rows:
n_rows = n_samples[t.name]
dump(current, type_)
except EOFError:
break
if __name__ == "__main__":
main()
main(sys.argv[1:])
#!/usr/bin/python
import sys
import imp
import subprocess
import os
import labcomm2014
TRANSLATE={
labcomm2014.SHORT() : 'short',
labcomm2014.DOUBLE() : 'double'
}
def compile_lc(lc):
p = subprocess.Popen([ 'labcomm2014', '--python=/dev/stdout', lc],
stdout=subprocess.PIPE)
src = p.stdout.read()
code = compile(src, 'lc_import', 'exec')
mod = sys.modules.setdefault('lc_import', imp.new_module('lc_import'))
exec code in mod.__dict__
import lc_import
return (lc_import.typedef, lc_import.sample)
def gen_binding(decl, lc_prefix, prefix, suffix):
if isinstance(decl, labcomm2014.sample):
if isinstance(decl.decl, labcomm2014.typedef):
print "%(n1)s = coder.cstructname(%(n1)s, '%(lc)s_%(n2)s')" % dict(
n1=decl.name, n2=decl.decl.name, lc=lc_prefix)
else:
print "%(n1)s = coder.cstructname(%(n1)s, '%(lc)s_%(n2)s')" % dict(
n1=decl.name, n2=decl.name, lc=lc_prefix)
gen_binding(decl.decl, lc_prefix, '%s.' % decl.name, suffix)
elif isinstance(decl, labcomm2014.typedef):
print "%(p)s%(s)s = coder.cstructname(%(p)s%(s)s, '%(lc)s_%(n)s')" % dict(
n=decl.name, lc=lc_prefix, p=prefix, s=suffix)
gen_binding(decl.decl, lc_prefix, prefix, suffix)
elif isinstance(decl, labcomm2014.array):
raise Exception("Array unhandled")
elif isinstance(decl, labcomm2014.struct):
for n, d in decl.field:
gen_binding(d, lc_prefix, '%sFields.%s' % (prefix, n), suffix)
elif isinstance(decl, labcomm2014.primitive):
pass
else:
raise Exception("Unhandled type. %s", decl)
def gen_sample(lc_prefix, decl):
if isinstance(decl, labcomm2014.sample):
print "%s = " % decl.name,
gen_sample(lc_prefix, decl.decl)
print
gen_binding(decl, lc_prefix, '', '')
elif isinstance(decl, labcomm2014.typedef):
# Expand in place
gen_sample(lc_prefix, decl.decl)
elif isinstance(decl, labcomm2014.array):
raise Exception("Array unhandled")
elif isinstance(decl, labcomm2014.struct):
print "struct(..."
for n, d in decl.field:
print "'%s, " % n,
gen_sample(lc_prefix, d)
print ")..."
elif isinstance(decl, labcomm2014.primitive):
print "%s(0), ..." % TRANSLATE[decl]
else:
raise Exception("Unhandled type. %s", decl)
"""
robtarget = struct(...
'orientation', ...
struct(...
'q1', double(0), ...
'q2', double(0), ...
'q3', double(0), ...
'q4', double(0) ...
), ...
'translation', ...
struct(...
'x', double(0), ...
'y', double(0), ...
'z', double(0) ...
), ...
'configuration', ...
struct(...
'cf1', int16(0), ...
'cf4', int16(0), ...
'cf6', int16(0), ...
'cfx', int16(0) ...
) ...
);
robtarget_types = coder.typeof(robtarget);
act = coder.cstructname(robtarget_types, 'egm_pb2lc_robtarget');
act.Fields.translation = coder.cstructname(act.Fields.translation, 'egm_pb2lc_cartesian');
act.Fields.orientation = coder.cstructname(act.Fields.orientation, 'egm_pb2lc_quaternion');
act.Fields.configuration = coder.cstructname(act.Fields.configuration, 'egm_pb2lc_confdata');
"""
def gen_matlab(lc):
lc_prefix = os.path.basename(lc).split('.')[0]
typedef, sample = compile_lc(lc)
for s in sample:
gen_sample(lc_prefix, s.signature)
if __name__ == '__main__':
for lc in sys.argv[1:]:
gen_matlab(lc)