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

Target

Select target project
  • anders_blomdell/labcomm
  • klaren/labcomm
  • tommyo/labcomm
  • erikj/labcomm
  • sven/labcomm
5 results
Select Git revision
Show changes
Show whitespace changes
Inline Side-by-side
Showing
with 1226 additions and 809 deletions
test/ref.lc 0 → 100644
View file @ d3921882
sample sample s1;
sample sample s2;
sample sample s3;
sample sample sample_list[4];
test/relay_gen_c.py 0 → 100755
View file @ d3921882
#!/usr/bin/python
import argparse
import re
import sys
def split_match(pattern, multiline):
def match(s):
m = re.match(pattern, s)
if m:
return m.group(1)
pass
return filter(lambda s: s != None, map(match, multiline.split('\n')))
if __name__ == '__main__':
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])
if lang == 'C' and kind == 'sample':
sample.append((func, arg, stype))
pass
pass
result = []
result.extend(split_match('^[^|]*\|(.*)$', """
|// generated by relay_gen_c.py
|#include <sys/types.h>
|#include <sys/stat.h>
|#include <fcntl.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 labcomm2014_encoder *e = context;
| labcomm2014_encode_%(func)s(e%(valargstr)s);
|}""" % { 'func': func, 'arg': arg, 'valargstr': '' if stype == "void" else', v' }))
pass
result.extend(split_match('^[^|]*\|(.*)$', """
|int main(int argc, char *argv[]) {
| 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_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('^[^|]*\|(.*)$', """
| 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('^[^|]*\|(.*)$', """
| 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)
pass
test/relay_gen_cs.py 0 → 100755
View file @ d3921882
#!/usr/bin/python
import argparse
import re
import sys
import random
def split_match(pattern, multiline):
def match(s):
m = re.match(pattern, s)
if m:
return m.group(1)
pass
return filter(lambda s: s != None, map(match, multiline.split('\n')))
def shuffle(l):
result = list(l)
random.shuffle(result)
return result
if __name__ == '__main__':
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])
if lang == 'C#' and kind == 'sample':
sample.append((func, arg))
pass
pass
result = []
result.extend(split_match('^[^|]*\|(.*)$', """
|using System;
|using System.IO;
|using se.lth.control.labcomm2014;
|
|public class cs_relay :
"""))
for func,arg in sample[0:-1]:
result.append(' %s.Handler,' % func)
pass
result.append(' %s.Handler' % sample[-1][0])
result.extend(split_match('^[^|]*\|(.*)$', """
|{
| Encoder encoder;
| Decoder decoder;
|
"""))
for func,arg in sample:
if arg == 'void':
result.extend(split_match('^[^|]*\|(.*)$', """
| void %(func)s.Handler.handle() {
| %(func)s.encode(encoder);
| }
""" % { 'func': func}))
pass
else:
result.extend(split_match('^[^|]*\|(.*)$', """
| void %(func)s.Handler.handle(%(arg)s data) {
| %(func)s.encode(encoder, data);
| }
""" % { 'func': func, 'arg': arg}))
pass
pass
result.extend(split_match('^[^|]*\|(.*)$', """
| public cs_relay(String InName, String OutName) {
| FileStream InFile = new FileStream(InName,
| FileMode.Open,
| FileAccess.Read);
| 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
for func,arg in shuffle(sample):
result.append(' %s.registerSampleRef(decoder);' % func)
pass
for func,arg in shuffle(sample):
result.append(' %s.register(encoder);' % func)
pass
for func,arg in shuffle(sample):
result.append(' %s.registerSampleRef(encoder);' % func)
pass
result.extend(split_match('^[^|]*\|(.*)$', """
| try {
| decoder.run();
| } catch (EndOfStreamException) {
| }
| }
| static void Main(String[] arg) {
| new cs_relay(arg[0], arg[1]);
| }
|}
"""))
print "\n".join(result)
pass
test/relay_gen_java.py 0 → 100755
View file @ d3921882
#!/usr/bin/python
import re
import sys
import random
def split_match(pattern, multiline):
def match(s):
m = re.match(pattern, s)
if m:
return m.group(1)
pass
return filter(lambda s: s != None, map(match, multiline.split('\n')))
def shuffle(l):
result = list(l)
random.shuffle(result)
return result
if __name__ == '__main__':
f = open(sys.argv[1])
sample = []
for l in map(lambda s: s.strip(), f):
lang,kind,func,arg,dummy = l[1:].split(l[0])
if lang == 'Java' and kind == 'sample':
sample.append((func, arg))
pass
pass
result = []
result.extend(split_match('^[^|]*\|(.*)$', """
|import java.io.FileInputStream;
|import java.io.FileOutputStream;
|import java.io.IOException;
|import se.lth.control.labcomm2014.DecoderChannel;
|import se.lth.control.labcomm2014.EncoderChannel;
|import se.lth.control.labcomm2014.Sample;
|
|public class java_relay implements
"""))
for func,arg in sample[0:-1]:
result.append(' %s.Handler,' % func)
pass
result.append(' %s.Handler' % sample[-1][0])
result.extend(split_match('^[^|]*\|(.*)$', """
|{
| EncoderChannel encoder;
"""))
for func,arg in sample:
if arg == 'void':
result.extend(split_match('^[^|]*\|(.*)$', """
| public void handle_%(func)s() throws IOException {
| %(func)s.encode(encoder);
| }
""" % { 'func': func}))
pass
else:
result.extend(split_match('^[^|]*\|(.*)$', """
| public void handle_%(func)s(%(arg)s data) throws IOException {
| %(func)s.encode(encoder, data);
| }
""" % { 'func': func, 'arg': arg}))
pass
pass
result.extend(split_match('^[^|]*\|(.*)$', """
| public java_relay(String InName, String OutName) throws Exception {
| FileInputStream InFile = new FileInputStream(InName);
| DecoderChannel decoder = new DecoderChannel(InFile);
| FileOutputStream OutFile = new FileOutputStream(OutName);
| encoder = new EncoderChannel(OutFile);
|
"""))
for func,arg in shuffle(sample):
result.append(' %s.register(decoder, this);' % func)
pass
for func,arg in shuffle(sample):
result.append(' %s.registerSampleRef(decoder);' % func)
pass
for func,arg in shuffle(sample):
result.append(' %s.register(encoder);' % func)
pass
for func,arg in shuffle(sample):
result.append(' %s.registerSampleRef(encoder);' % func)
pass
result.extend(split_match('^[^|]*\|(.*)$', """
| try {
| decoder.run();
| } catch (java.io.EOFException e) {
| }
| }
| public static void main(String[] arg) throws Exception {
| new java_relay(arg[0], arg[1]);
| }
|}
"""))
print "\n".join(result)
pass
test/run deleted 100755 → 0
View file @ bb636c49
#!/usr/bin/python
# -*- coding: iso8859-15 -*-
import labcomm
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 ../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, "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)
test/run.py deleted 100755 → 0
View file @ bb636c49
#!/usr/bin/python
# -*- coding: iso8859-15 -*-
import labcomm
import math
import os
import sys
import re
import traceback
def run_labcomm(base):
if not os.path.exists("gen/java/%s" % base):
os.makedirs("gen/java/%s" % base)
cmd = " ".join([
"java -jar ../labComm.jar",
"--c=gen/%s.c" % base,
"--h=gen/%s.h" % base,
"--python=gen/%s.py" % base,
"--java=gen/java/%s" % base,
"%s.lc" % base
])
print cmd
os.system(cmd)
class hexwriter(object):
def __init__(self):
self.pos = 0
self.ascii = ''
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 = ""
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 = ""
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")
files = sys.argv[1:]
print sys.argv, files
if len(files) == 0:
files = os.listdir(".")
for f in files:
m = re.match("(.*).lc", f)
if m:
run_labcomm(m.group(1))
sys.path.insert(0, "gen")
for f in files:
m = re.match("(.*).lc", f)
if m:
print f
h = hexwriter()
encoder = labcomm.Encoder(h)
signatures = []
i = __import__(m.group(1))
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()
test/simple.lc
View file @ d3921882
test/test_encoder_decoder.py 0 → 100755
View file @ d3921882
#!/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 = 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
test/test_errors.py 0 → 100755
View file @ d3921882
#!/usr/bin/python
import sys
import argparse
import subprocess
# returns true if test fails
def test_labcomm_compile_OK(lc, args):
cmd = args.labcomm.split() + [lc]
try:
res = subprocess.check_call(cmd)
print "sucess!"
return False
except subprocess.CalledProcessError as ex:
print ex.output
print ex.returncode
return True
def test_labcomm_compile_fail(lc, args):
cmd = args.labcomm.split() + [lc]
try:
res = subprocess.check_call(cmd)
print "failed! (should have produced an error)"
return True
except subprocess.CalledProcessError as ex:
print "sucess!"
print ex.output
print ex.returncode
return False;
if __name__ == '__main__':
parser = argparse.ArgumentParser(description='Run test of error messages.')
parser.add_argument('--labcomm');
parser.add_argument('--testOK', nargs='*', default=[])
parser.add_argument('--testNOK', nargs='*', default=[])
args = parser.parse_args()
fail = False;
for test in args.testOK:
fail = fail or test_labcomm_compile_OK(test, args)
pass
for test in args.testNOK:
fail = fail or test_labcomm_compile_fail(test, args)
pass
if fail:
print "*** fail ***"
else:
print "*** success ***"
test/test_renaming_encoder_decoder.py 0 → 100755
View file @ d3921882
#!/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
test/test_simple.c deleted 100644 → 0
View file @ bb636c49
#include <labcomm.h>
#include <labcomm_fd_reader_writer.h>
#include "gen/simple.h"
void simple_an_int_handler(simple_an_int *v,
void *context)
{
struct labcomm_encoder *e = context;
labcomm_encode_simple_an_int(e, v);
}
int main(int argc, char *argv[]) {
struct labcomm_decoder *d;
struct labcomm_encoder *e;
labcomm_decoder_register_simple_an_int(d, simple_an_int_handler, e);
return 0;
}
tools/beaver-rt.jar deleted 100644 → 0
View file @ bb636c49
File deleted
tools/beaver.jar deleted 100644 → 0
View file @ bb636c49
File deleted
tools/jastadd2.jar deleted 100644 → 0
View file @ bb636c49
File deleted
tools/lc2csv.py 0 → 100755
View file @ d3921882
#!/usr/bin/env python
import argparse
import labcomm2014
import sys
import time
class Reader(object):
def __init__(self, file_):
self._file = file_
def read(self, count):
data = self._file.read(count)
if len(data) == 0:
raise EOFError()
return data
def mark(self, value, decl):
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, labcomm2014.sample):
flatten(sample, _type.decl)
elif isinstance(_type, labcomm2014.array):
for e in sample:
flatten(e, _type.decl)
elif isinstance(_type, labcomm2014.struct):
for name, decl in _type.field:
flatten(sample[name], decl)
elif isinstance(_type, labcomm2014.BOOLEAN):
print "%d," % sample,
elif isinstance(_type, labcomm2014.STRING):
print "\"%s\"," % sample,
elif isinstance(_type, labcomm2014.primitive):
print "%s," % sample,
else:
raise Exception("Unhandled type. " + str(type(type_)) + " " + str(type_))
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(_type.indices) == 0:
raise Exception("We dont't handle dynamical sizes yet %s" % _type)
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(decl,
prefix + "." + name)
elif isinstance(_type, labcomm2014.primitive):
print '"%s",' % prefix,
else:
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):
for k in sorted(_type.keys()):
flatten(sample[k], _type[k])
print
def dump_labels(type_):
for k in sorted(type_.keys()):
flatten_labels(type_[k])
print
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:
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(type_)
if not args.no_default_columns:
defaults(current, type_)
n_rows = 0
while True:
try:
o, t = d.decode()
if o is None:
continue
current[t.name] = o
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(sys.argv[1:])
tools/lc_to_matlab_coder.py 0 → 100755
View file @ d3921882
#!/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)
wiki_example/data.java deleted 100644 → 0
View file @ bb636c49
/*
sample float data;
*/
import java.io.IOException;
import se.lth.control.labcomm.LabCommDecoder;
import se.lth.control.labcomm.LabCommDispatcher;
import se.lth.control.labcomm.LabCommEncoder;
import se.lth.control.labcomm.LabCommHandler;
import se.lth.control.labcomm.LabCommSample;
public class data implements LabCommSample {
public interface Handler extends LabCommHandler {
public void handle_data(float value) throws Exception;
}
public static void register(LabCommDecoder d, Handler h) throws IOException {
d.register(new Dispatcher(), h);
}
public static void register(LabCommEncoder e) throws IOException {
e.register(new Dispatcher());
}
private static class Dispatcher implements LabCommDispatcher {
public Class getSampleClass() {
return data.class;
}
public String getName() {
return "data";
}
public byte[] getSignature() {
return signature;
}
public void decodeAndHandle(LabCommDecoder d,
LabCommHandler h) throws Exception {
((Handler)h).handle_data(data.decode(d));
}
}
public static void encode(LabCommEncoder e, float value) throws IOException {
e.begin(data.class);
e.encodeFloat(value);
e.end(data.class);
}
public static float decode(LabCommDecoder d) throws IOException {
float result;
result = d.decodeFloat();
return result;
}
private static byte[] signature = new byte[] {
0, 0, 0, 37,
};
}
wiki_example/example.c deleted 100644 → 0
View file @ bb636c49
#include "labcomm.h"
#include "labcomm_private.h"
#include "example.h"
static unsigned char signature_bytes_log_message[] = {
// struct { 2 fields
0, 0, 0, 17,
0, 0, 0, 2,
// int 'sequence'
0, 0, 0, 8,
115, 101, 113, 117, 101, 110, 99, 101,
0, 0, 0, 35,
// array [_] 'line'
0, 0, 0, 4,
108, 105, 110, 101,
// array [_]
0, 0, 0, 16,
0, 0, 0, 1,
0, 0, 0, 0,
// struct { 2 fields
0, 0, 0, 17,
0, 0, 0, 2,
// boolean 'last'
0, 0, 0, 4,
108, 97, 115, 116,
0, 0, 0, 32,
// string 'data'
0, 0, 0, 4,
100, 97, 116, 97,
0, 0, 0, 39,
// }
// }
// }
};
labcomm_signature_t labcomm_signature_example_log_message = {
LABCOMM_SAMPLE, "log_message",
(int (*)(void *))labcomm_sizeof_example_log_message,
sizeof(signature_bytes_log_message),
signature_bytes_log_message
};
static unsigned char signature_bytes_data[] = {
0, 0, 0, 37,
};
labcomm_signature_t labcomm_signature_example_data = {
LABCOMM_SAMPLE, "data",
(int (*)(void *))labcomm_sizeof_example_data,
sizeof(signature_bytes_data),
signature_bytes_data
};
static void decode_log_message(
labcomm_decoder_t *d,
void (*handle)(
example_log_message *v,
void *context
),
void *context
)
{
example_log_message v;
v.sequence = labcomm_decode_int(d);
v.line.n_0 = labcomm_decode_int(d);
v.line.a = malloc(sizeof(v.line.a[0]) * v.line.n_0);
{
int i_0_0;
for (i_0_0 = 0 ; i_0_0 < v.line.n_0 ; i_0_0++) {
int i_0 = i_0_0;
v.line.a[i_0].last = labcomm_decode_boolean(d);
v.line.a[i_0].data = labcomm_decode_string(d);
}
}
handle(&v, context);
{
{
int i_0_0;
for (i_0_0 = 0 ; i_0_0 < v.line.n_0 ; i_0_0++) {
int i_0 = i_0_0;
free(v.line.a[i_0].data);
}
}
free(v.line.a);
}
}
void labcomm_decoder_register_example_log_message(
struct labcomm_decoder *d,
void (*handler)(
example_log_message *v,
void *context
),
void *context
)
{
labcomm_internal_decoder_register(
d,
&labcomm_signature_example_log_message,
(labcomm_decoder_typecast_t)decode_log_message,
(labcomm_handler_typecast_t)handler,
context
);
}
static void encode_log_message(
labcomm_encoder_t *e,
example_log_message *v
)
{
e->writer.write(&e->writer, labcomm_writer_start);
labcomm_encode_type_index(e, &labcomm_signature_example_log_message);
{
labcomm_encode_int(e, (*v).sequence);
labcomm_encode_int(e, (*v).line.n_0);
{
int i_0_0;
for (i_0_0 = 0 ; i_0_0 < (*v).line.n_0 ; i_0_0++) {
int i_0 = i_0_0;
labcomm_encode_boolean(e, (*v).line.a[i_0].last);
labcomm_encode_string(e, (*v).line.a[i_0].data);
}
}
}
e->writer.write(&e->writer, labcomm_writer_end);
}
void labcomm_encode_example_log_message(
labcomm_encoder_t *e,
example_log_message *v
)
{
labcomm_internal_encode(e, &labcomm_signature_example_log_message, v);
}
void labcomm_encoder_register_example_log_message(
struct labcomm_encoder *e
)
{
labcomm_internal_encoder_register(
e,
&labcomm_signature_example_log_message,
(labcomm_encode_typecast_t)encode_log_message
);
}
int labcomm_sizeof_example_log_message(example_log_message *v)
{
int result = 4;
{
int i_0_0;
for (i_0_0 = 0 ; i_0_0 < (*v).line.n_0 ; i_0_0++) {
int i_0 = i_0_0;
result += 4 + strlen((*v).line.a[i_0].data);
result += 1;
}
}
result += 4;
return result;
}
static void decode_data(
labcomm_decoder_t *d,
void (*handle)(
example_data *v,
void *context
),
void *context
)
{
example_data v;
v = labcomm_decode_float(d);
handle(&v, context);
}
void labcomm_decoder_register_example_data(
struct labcomm_decoder *d,
void (*handler)(
example_data *v,
void *context
),
void *context
)
{
labcomm_internal_decoder_register(
d,
&labcomm_signature_example_data,
(labcomm_decoder_typecast_t)decode_data,
(labcomm_handler_typecast_t)handler,
context
);
}
static void encode_data(
labcomm_encoder_t *e,
example_data *v
)
{
e->writer.write(&e->writer, labcomm_writer_start);
labcomm_encode_type_index(e, &labcomm_signature_example_data);
{
labcomm_encode_float(e, (*v));
}
e->writer.write(&e->writer, labcomm_writer_end);
}
void labcomm_encode_example_data(
labcomm_encoder_t *e,
example_data *v
)
{
labcomm_internal_encode(e, &labcomm_signature_example_data, v);
}
void labcomm_encoder_register_example_data(
struct labcomm_encoder *e
)
{
labcomm_internal_encoder_register(
e,
&labcomm_signature_example_data,
(labcomm_encode_typecast_t)encode_data
);
}
int labcomm_sizeof_example_data(example_data *v)
{
return 8;
}
wiki_example/example.cs deleted 100644 → 0
View file @ bb636c49
using System;
using se.lth.control.labcomm;
/*
sample struct {
int sequence;
struct {
boolean last;
string data;
} line[_];
} log_message;
*/
public class log_message : LabCommSample {
public static class struct_line {
public boolean last;
public String data;
}
public int sequence;
public struct_line[] line;
public interface Handler : LabCommHandler {
void handle(log_message value);
}
public static void register(LabCommDecoder d, Handler h) {
d.register(new Dispatcher(), h);
}
public static void register(LabCommEncoder e) {
e.register(new Dispatcher());
}
private class Dispatcher : LabCommDispatcher {
public Type getSampleClass() {
return typeof(log_message);
}
public String getName() {
return "log_message";
}
public byte[] getSignature() {
return signature;
}
public void decodeAndHandle(LabCommDecoder d, LabCommHandler h) {
((Handler)h).handle(log_message.decode(d));
}
}
public static void encode(LabCommEncoder e, log_message value) {
e.begin(typeof(log_message));
e.encodeInt(value.sequence);
e.encodeInt(value.line.GetLength(0));
int i_0_max = value.line.GetLength(0);
for (int i_0 = 0 ; i_0 < i_0_max ; i_0++) {
e.encodeBoolean(value.line[i_0].last);
e.encodeString(value.line[i_0].data);
}
e.end(typeof(log_message));
}
public static log_message decode(LabCommDecoder d) {
log_message result;
result = new log_message();
result.sequence = d.decodeInt();
{
int i_0_max = d.decodeInt();
result.line = new struct_line[i_0_max]
;
for (int i_0 = 0 ; i_0 < i_0_max ; i_0++) {
result.line[i_0] = new struct_line();
result.line[i_0].last = d.decodeBoolean();
result.line[i_0].data = d.decodeString();
}
}
return result;
}
private static byte[] signature = new byte[] {
// struct { 2 fields
0, 0, 0, 17,
0, 0, 0, 2,
// int 'sequence'
0, 0, 0, 8,
115, 101, 113, 117, 101, 110, 99, 101,
0, 0, 0, 35,
// array [_] 'line'
0, 0, 0, 4,
108, 105, 110, 101,
// array [_]
0, 0, 0, 16,
0, 0, 0, 1,
0, 0, 0, 0,
// struct { 2 fields
0, 0, 0, 17,
0, 0, 0, 2,
// boolean 'last'
0, 0, 0, 4,
108, 97, 115, 116,
0, 0, 0, 32,
// string 'data'
0, 0, 0, 4,
100, 97, 116, 97,
0, 0, 0, 39,
// }
// }
// }
};
}
/*
sample float data;
*/
public class data : LabCommSample {
public interface Handler : LabCommHandler {
void handle(float value);
}
public static void register(LabCommDecoder d, Handler h) {
d.register(new Dispatcher(), h);
}
public static void register(LabCommEncoder e) {
e.register(new Dispatcher());
}
private class Dispatcher : LabCommDispatcher {
public Type getSampleClass() {
return typeof(data);
}
public String getName() {
return "data";
}
public byte[] getSignature() {
return signature;
}
public void decodeAndHandle(LabCommDecoder d, LabCommHandler h) {
((Handler)h).handle(data.decode(d));
}
}
public static void encode(LabCommEncoder e, float value) {
e.begin(typeof(data));
e.encodeFloat(value);
e.end(typeof(data));
}
public static float decode(LabCommDecoder d) {
float result;
result = d.decodeFloat();
return result;
}
private static byte[] signature = new byte[] {
0, 0, 0, 37,
};
}
wiki_example/example.encoded deleted 100644 → 0
View file @ bb636c49
File deleted