switch to git no-history version

src/ltk/CMakeLists.txt

@@ -0,0 +1,12 @@
+
+set(HEADERS
+    ltktypes.h
+    ltkmacros.h
+    ltkdebug.h
+)
+
+SET(SOURCES)
+
+set(LIBRARIES)
+
+uLib_add_shared_library(${uLib-module})

src/ltk/DenseMatrix.h

@@ -0,0 +1,111 @@
+/*//////////////////////////////////////////////////////////////////////////////
+// CMT Cosmic Muon Tomography project //////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+
+  Copyright (c) 2014, Universita' degli Studi di Padova, INFN sez. di Padova
+  All rights reserved
+
+  Authors: Andrea Rigoni Garola < andrea.rigoni@pd.infn.it >
+
+  ------------------------------------------------------------------
+  This library is free software;  you  can  redistribute  it  and/or
+  modify it  under the  terms  of  the  GNU  Lesser  General  Public
+  License as published  by  the  Free  Software  Foundation;  either
+  version 3.0 of the License, or (at your option) any later version.
+
+  This library is  distributed in  the hope that it will  be useful,
+  but  WITHOUT ANY WARRANTY;  without  even  the implied warranty of
+  MERCHANTABILITY  or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of  the GNU Lesser General  Public
+  License along with this library.
+
+//////////////////////////////////////////////////////////////////////////////*/
+
+
+
+
+#ifndef DENSEMATRIX_H
+#define DENSEMATRIX_H
+
+#include "templates.h"
+#include "Vector.h"
+
+BEGIN_NAMESPACE(ltk)
+
+/* ////////////////////////////////////////////////////////////////////////// */
+/* //////////////////////////// MATRIX ////////////////////////////////////// */
+/* ////////////////////////////////////////////////////////////////////////// */
+
+C_BEGIN_DECLS
+
+#define LTK_MATRIX_DECLARE_FUNC(Type,ltkType,Class_name,csize,rsize)	\
+  inline Type ltkType##_##Class_name##_get(ltkType m,			\
+					unsigned int c,			\
+					unsigned int r)			\
+  {									\
+    assert(c + r * csize < csize * rsize);				\
+    return *((ltkType)m + c + r * csize);				\
+  }									\
+  inline void ltkType##_##Class_name##_set(ltkType m,			\
+			       unsigned int c,				\
+			       unsigned int r,				\
+			       Type t)					\
+  { 									\
+    assert (c + r * csize < csize * rsize);				\
+    *((ltkType)m + c + r * csize) = t;					\
+  }									
+
+
+#define LTK_MATRIX_DECLARE(Type,Type_name,csize,rsize)	                \
+  typedef Type * Type_name;						\
+  LTK_SIMPLE_ALLOC_FUNC(Type, Type_name,ltk_matrix,csize * rsize)       \
+  LTK_MATRIX_DECLARE_FUNC(Type,Type_name,ltk_matrix,csize,rsize)
+
+C_END_DECLS
+
+#ifdef __cplusplus
+
+template <typename T, unsigned int csize, unsigned int rsize> class ltkDenseMatrix
+: public ltkAbstractBuffer< T, csize * rsize >
+{
+protected:
+    typedef ltkDenseMatrix<T, csize, rsize> ThisClass;
+    typedef ltkAbstractBuffer<T, csize * rsize> BaseClass;
+public:
+    ltkDenseMatrix() {}
+    ~ltkDenseMatrix() { }
+    
+    inline T* getBuffer() {
+	return (T*)m_buffer;
+    }
+    inline const T* getBuffer() const {
+	return (const T*)m_buffer;
+    }
+
+    ThisClass & operator =(const ThisClass &src) {
+	if (this != &src) {
+	    CType_ltk_matrix_copy(m_buffer, (const CType) src.getBuffer());
+	}
+    }
+
+    typedef struct BaseClass::CommaInit CommaInit;
+    inline CommaInit operator = (T scalar) {
+	return this->operator <<(scalar);
+    }
+
+
+private:
+    LTK_MATRIX_DECLARE(T,CType, csize, rsize);
+    T m_buffer [csize * rsize];
+};
+
+
+
+
+#endif // __cplusplus
+
+END_NAMESPACE
+
+#endif // DENSEMATRIX_H

src/ltk/Makefile.am

@@ -0,0 +1,6 @@
+include $(top_srcdir)/Common.am
+
+library_includedir = $(includedir)/libmutom-${PACKAGE_VERSION}/ltk
+library_include_HEADERS = 	ltktypes.h	\
+				ltkmacros.h     \
+				ltkdebug.h

src/ltk/Object.c

@@ -0,0 +1,18 @@
+#include "Object.h"
+
+
+static const struct _ltkObjectClass {
+  size_t class_size;
+  void (* constructor)(struct _Object *);
+  void (* destructor) (struct _Object *);
+  int  (* GetElement) (struct _Object *);
+} _ObjectClassInstance;
+
+const struct _ltkObjectClass *ltkObjectClass = &_ObjectClassInstance;
+
+ltkPointer Object_new(struct _ObjectClass klass)
+{
+  struct _Object *ob = (struct _Object)malloc(klass->class_size);
+  klass->constructor(ob);
+  return ob;
+}

src/ltk/Object.h

@@ -0,0 +1,78 @@
+/*//////////////////////////////////////////////////////////////////////////////
+// CMT Cosmic Muon Tomography project //////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+
+  Copyright (c) 2014, Universita' degli Studi di Padova, INFN sez. di Padova
+  All rights reserved
+
+  Authors: Andrea Rigoni Garola < andrea.rigoni@pd.infn.it >
+
+  ------------------------------------------------------------------
+  This library is free software;  you  can  redistribute  it  and/or
+  modify it  under the  terms  of  the  GNU  Lesser  General  Public
+  License as published  by  the  Free  Software  Foundation;  either
+  version 3.0 of the License, or (at your option) any later version.
+
+  This library is  distributed in  the hope that it will  be useful,
+  but  WITHOUT ANY WARRANTY;  without  even  the implied warranty of
+  MERCHANTABILITY  or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of  the GNU Lesser General  Public
+  License along with this library.
+
+//////////////////////////////////////////////////////////////////////////////*/
+
+
+
+#ifndef OBJECT_H
+#define OBJECT_H
+
+#include <stdlib.h>      // for std allocator   //
+#include <string.h>      // for memcpy //
+#include <assert.h>
+
+#include "templates.h"
+
+BEGIN_NAMESPACE(ltk) 
+
+
+C_BEGIN_DECLS
+
+struct _ltkObject
+{
+  int element;
+};
+
+struct _ltkObjectClass {
+  size_t class_size;
+  void (* constructor)(struct _ltkObject *);
+  void (* destructor) (struct _ltkObject *);
+  int  (* GetElement) (struct _ltkObject *);
+};
+
+struct _ltkObject *ltk_object_new() 
+{
+  return NULL;  
+}
+
+
+C_END_DECLS
+
+#ifdef __cplusplus
+
+class Object 
+{
+  struct _ltkObject *d;
+  typedef struct _ltkObject ObjectType;
+ public:
+ Object() : d(new ObjectType()) { d->element = 5552368; }
+  int GetElement() { return d->element; }
+};
+
+#endif
+
+
+END_NAMESPACE
+
+#endif //OBJECT_H

src/ltk/Vector.h

@@ -0,0 +1,195 @@
+/*//////////////////////////////////////////////////////////////////////////////
+// CMT Cosmic Muon Tomography project //////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+
+  Copyright (c) 2014, Universita' degli Studi di Padova, INFN sez. di Padova
+  All rights reserved
+
+  Authors: Andrea Rigoni Garola < andrea.rigoni@pd.infn.it >
+
+  ------------------------------------------------------------------
+  This library is free software;  you  can  redistribute  it  and/or
+  modify it  under the  terms  of  the  GNU  Lesser  General  Public
+  License as published  by  the  Free  Software  Foundation;  either
+  version 3.0 of the License, or (at your option) any later version.
+
+  This library is  distributed in  the hope that it will  be useful,
+  but  WITHOUT ANY WARRANTY;  without  even  the implied warranty of
+  MERCHANTABILITY  or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of  the GNU Lesser General  Public
+  License along with this library.
+
+//////////////////////////////////////////////////////////////////////////////*/
+
+
+
+/* 
+ * File:   denseVector.h
+ * Author: andrea
+ *
+ * Created on July 6, 2012, 3:41 PM
+ */
+
+#ifndef VECTOR_H
+#define	VECTOR_H
+
+#include <stdlib.h>      // for std allocator   //
+#include <string.h>      // for memcpy //
+#include <assert.h>
+
+#include "templates.h"
+
+BEGIN_NAMESPACE(ltk) 
+
+/* ////////////////////////////////////////////////////////////////////////// */
+/* //////////////////////////// VECTOR  ///////////////////////////////////// */
+/* ////////////////////////////////////////////////////////////////////////// */
+
+C_BEGIN_DECLS
+
+#define LTK_VECTOR_DECLARE(Type,Type_name,size)				\
+    typedef Type *Type_name;						\
+    LTK_SIMPLE_ALLOC_FUNC(Type,Type_name,ltk_vector,size)                 \
+    inline unsigned int Type_name##_ltk_vector_size() { return size; }	\
+    inline Type Type_name##_ltk_vector_get(Type_name vector, unsigned int i)    \
+      { return *(vector+i); }						      \
+    inline void Type_name##_ltk_vector_set(Type_name vector, unsigned int i,    \
+      Type data) { *(vector+i) = data; }
+
+C_END_DECLS
+
+#ifdef __cplusplus
+
+template <typename T, unsigned int size> class ltkVector
+: public ltkAbstractBuffer< T, size >
+{
+    T m_vector [size];
+protected:
+    typedef ltkVector<T, size>          ThisClass;
+    typedef ltkAbstractBuffer<T, size>  BaseClass;
+public:
+    ltkVector() {}
+    ltkVector(const ltkVector<T, size> &copy) {
+	CType_ltk_vector_copy(m_vector, (const CType) copy.getBuffer());
+    }
+
+    virtual ~ltkVector() { }
+
+    inline unsigned int getSize() const {
+	return size;
+    }
+    inline T* getBuffer() {
+	return (T*)m_vector;
+    }
+    inline const T* getBuffer() const {
+	return (const T*)m_vector;
+    }
+
+
+
+    ThisClass & operator =(const ThisClass &src) {
+	if (this != &src) {
+	    CType_ltk_vector_copy(m_vector, (const CType) src.getBuffer());
+	}
+    }
+
+    typedef struct BaseClass::CommaInit CommaInit;
+    inline CommaInit operator = (T scalar) {
+	return this->operator <<(scalar);
+    }
+
+    // MATH //
+    inline bool operator ==(const ThisClass &in) {
+	int test = 0;
+	for (int i = 0; i < size; ++i) test += this->at(i) != in(i);
+	return test == 0;
+    }
+
+    inline bool operator !=(const ThisClass &in) {
+	return !this->operator ==(in);
+    }
+
+    inline void operator +=(const ThisClass &in) {
+	for (int i = 0; i < size; ++i) this->at(i) += in(i);
+    }
+    inline void operator -=(const ThisClass &in) {
+	for (int i = 0; i < size; ++i) this->at(i) -= in(i);
+    }
+    inline void operator *=(const ThisClass &in) {
+	for (int i = 0; i < size; ++i) this->at(i) *= in(i);
+    }
+    inline void operator /=(const ThisClass &in) {
+	for (int i = 0; i < size; ++i) this->at(i) /= in(i);
+    }
+
+    inline void operator +=(const T t) {
+	for (int i = 0; i < size; ++i) this->at(i) += t;
+    }
+    inline void operator -=(const T t) {
+	for (int i = 0; i < size; ++i) this->at(i) -= t;
+    }
+    inline void operator *=(const T t) {
+	for (int i = 0; i < size; ++i) this->at(i) *= t;
+    }
+    inline void operator /=(const T t) {
+	for (int i = 0; i < size; ++i) this->at(i) /= t;
+    }
+
+    inline ThisClass & operator + (const ThisClass &in) {
+	ThisClass *out = new ThisClass();
+	for (int i = 0; i < size; ++i) out->at(i) = this->at(i) + in(i);
+	return *out;
+    }
+    inline ThisClass & operator - (const ThisClass &in) {
+	ThisClass *out = new ThisClass();
+	for (int i = 0; i < size; ++i) out->at(i) = this->at(i) - in(i);
+	return *out;
+    }
+
+    // fix with constructor and product null element ------------- //
+    inline T operator * (const ThisClass &in) {
+	T out = 0;
+	for (int i = 0; i < size; ++i) out += this->at(i) * in(i);
+	return out;
+    }
+    inline T operator / (const ThisClass &in) {
+	T out = 0;
+	for (int i = 0; i < size; ++i) out += this->at(i) / in(i);
+	return out;
+    }
+    // ------------------------------------------------------------- //
+
+    inline ThisClass & operator +(const T t) {
+	ThisClass *out = new ThisClass();
+	for (int i = 0; i < size; ++i) out->at(i) = this->at(i) + t;
+	return *out;
+    }
+    inline ThisClass & operator -(const T t) {
+	ThisClass *out = new ThisClass();
+	for (int i = 0; i < size; ++i) out->at(i) = this->at(i) - t;
+	return *out;
+    }
+    inline ThisClass & operator *(const T t) {
+	ThisClass *out = new ThisClass();
+	for (int i = 0; i < size; ++i) out->at(i) = this->at(i) * t;
+	return *out;
+    }
+    inline ThisClass & operator /(const T t) {
+      ThisClass *out = new ThisClass();
+      for (int i = 0; i < size; ++i) out->at(i) = this->at(i) / t;
+      return *out;
+    }
+private:
+    LTK_VECTOR_DECLARE(T,CType, size)
+};
+
+#endif // __cplusplus
+
+
+
+
+END_NAMESPACE // ltk
+#endif	/* DENSEVECTOR_H */
+

src/ltk/container.h

@@ -0,0 +1,43 @@
+/*//////////////////////////////////////////////////////////////////////////////
+// CMT Cosmic Muon Tomography project //////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+
+  Copyright (c) 2014, Universita' degli Studi di Padova, INFN sez. di Padova
+  All rights reserved
+
+  Authors: Andrea Rigoni Garola < andrea.rigoni@pd.infn.it >
+
+  ------------------------------------------------------------------
+  This library is free software;  you  can  redistribute  it  and/or
+  modify it  under the  terms  of  the  GNU  Lesser  General  Public
+  License as published  by  the  Free  Software  Foundation;  either
+  version 3.0 of the License, or (at your option) any later version.
+
+  This library is  distributed in  the hope that it will  be useful,
+  but  WITHOUT ANY WARRANTY;  without  even  the implied warranty of
+  MERCHANTABILITY  or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of  the GNU Lesser General  Public
+  License along with this library.
+
+//////////////////////////////////////////////////////////////////////////////*/
+
+
+
+/* 
+ * File:   comma_init.h
+ * Author: andrea
+ *
+ * Created on May 24, 2012, 3:12 PM
+ */
+
+#ifndef CONTAINER_H
+#define	CONTAINER_H
+
+#include <assert.h>
+
+
+
+#endif	/* CONTAINER_H */
+

src/ltk/ltk.h

@@ -0,0 +1,32 @@
+/*//////////////////////////////////////////////////////////////////////////////
+// CMT Cosmic Muon Tomography project //////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+
+  Copyright (c) 2014, Universita' degli Studi di Padova, INFN sez. di Padova
+  All rights reserved
+
+  Authors: Andrea Rigoni Garola < andrea.rigoni@pd.infn.it >
+
+  ------------------------------------------------------------------
+  This library is free software;  you  can  redistribute  it  and/or
+  modify it  under the  terms  of  the  GNU  Lesser  General  Public
+  License as published  by  the  Free  Software  Foundation;  either
+  version 3.0 of the License, or (at your option) any later version.
+
+  This library is  distributed in  the hope that it will  be useful,
+  but  WITHOUT ANY WARRANTY;  without  even  the implied warranty of
+  MERCHANTABILITY  or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of  the GNU Lesser General  Public
+  License along with this library.
+
+//////////////////////////////////////////////////////////////////////////////*/
+
+
+
+
+
+#include "templates.h"
+#include "Vector.h"
+#include "DenseMatrix.h"

src/ltk/ltk_bridge/ltkb.c

@@ -0,0 +1,339 @@
+//#include <linux/config.h>
+#include <linux/version.h>
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/fs.h>
+#include <linux/cdev.h>
+#include <linux/slab.h>
+#include <linux/vmalloc.h>
+#include <linux/mm.h>
+#include <linux/ioctl.h>
+#ifdef MODVERSIONS
+#  include <linux/modversions.h>
+#endif
+#include <asm/io.h>
+#include <asm/system.h>
+#include <asm/uaccess.h>
+
+
+
+/* methods of the character device */
+static int ltkb_open(struct inode *inode, struct file *filp);
+static int ltkb_release(struct inode *inode, struct file *filp);
+static int ltkb_mmap(struct file *filp, struct vm_area_struct *vma);
+static ssize_t ltkb_read(struct file *filp,
+			 char __user *buffer,
+			 size_t count,
+			 loff_t *offp);
+static ssize_t ltkb_write(struct file *filp,
+			  const char __user *buffer,
+			  size_t count,
+			  loff_t *offp);
+
+
+// internal data
+// length of the two memory areas
+#define NPAGES 16
+// pointer to the vmalloc'd area - alway page aligned
+static int *vmalloc_area;
+// pointer to the kmalloc'd area, rounded up to a page boundary
+static int *kmalloc_area;
+// original pointer for kmalloc'd area as returned by kmalloc
+static void *kmalloc_ptr;
+
+
+#define BUF_LEN 80
+static int Device_Open = 0;
+
+static char Message[BUF_LEN];
+/*
+ * How far did the process reading the message get?
+ * Useful if the message is larger than the size of the
+ * buffer we get to fill in device_read.
+ */
+static char *Message_Ptr;
+
+
+struct ltkb_dev {
+  struct cdev cdev;              // device structure
+  struct semaphore semaphore;    // lock semaphore for race control
+  char *message;                 // message passing from/to user
+  unsigned int size;             // size of data stored
+  unsigned int acl_key;          // user access control
+};
+
+struct ltkb_dev *_ltkb_devices;   // devices array //
+
+
+
+
+
+/////// OPEN AND RELEASE ///////////////////////////////////////////////////////
+static int ltkb_open(struct inode *inode, struct file *filp)
+{
+  // insert cdev data in dev structure and file->private_data //
+  struct ltkb_dev *dev;
+  dev = container_of (inode->i_cdev, struct ltkb_dev, cdev);
+
+  // this shares dev for all methods //
+  filp->private_data = dev;
+
+  pr_debug("ltk bridge opened");
+  return 0;
+}
+/* character device last close method */
+static int ltkb_release(struct inode *inode, struct file *filp)
+{
+  pr_debug("ltk bridge released");
+  return 0;
+}
+// -------------------------------------------------------------------------- //
+
+
+
+// kmalloc instancer //
+int ltkb_kmem(struct file *filp, struct vm_area_struct *vma)
+{
+  int ret;
+  long length = vma->vm_end - vma->vm_start;
+
+  /* check length - do not allow larger mappings than the number of
+     pages allocated */
+  if (length > NPAGES * PAGE_SIZE)
+    return -EIO;
+
+  /* map the whole physically contiguous area in one piece */
+  if ((ret = remap_pfn_range(vma,
+			     vma->vm_start,
+			     virt_to_phys((void *)kmalloc_area) >> PAGE_SHIFT,
+			     length,
+			     vma->vm_page_prot)) < 0) {
+    return ret;
+  }
+  return 0;
+}
+// vmalloc instancer //
+int ltkb_vmem(struct file *filp, struct vm_area_struct *vma)
+{
+  int ret;
+  long length = vma->vm_end - vma->vm_start;
+  unsigned long start = vma->vm_start;
+  char *vmalloc_area_ptr = (char *)vmalloc_area;
+  unsigned long pfn;
+
+  /* check length - do not allow larger mappings than the number of
+     pages allocated */
+  if (length > NPAGES * PAGE_SIZE)
+    return -EIO;
+
+  /* loop over all pages, map it page individually */
+  while (length > 0) {
+    pfn = vmalloc_to_pfn(vmalloc_area_ptr);
+    if ((ret = remap_pfn_range(vma, start, pfn, PAGE_SIZE,
+			       PAGE_SHARED)) < 0) {
+      return ret;
+    }
+    start += PAGE_SIZE;
+    vmalloc_area_ptr += PAGE_SIZE;
+    length -= PAGE_SIZE;
+  }
+  return 0;
+}
+
+
+
+// mmap function //
+static int ltkb_mmap(struct file *filp, struct vm_area_struct *vma)
+{
+  /* at offset 0 we map the vmalloc'd area */
+  if (vma->vm_pgoff == 0) {
+    return ltkb_vmem(filp, vma);
+  }
+  /* at offset NPAGES we map the kmalloc'd area */
+  if (vma->vm_pgoff == NPAGES) {
+    return ltkb_kmem(filp, vma);
+  }
+  /* at any other offset we return an error */
+  return -EIO;
+}
+
+
+
+
+////////////// CHAR DEVICE READ/WRITE  /////////////////////////////////////////
+static ssize_t ltkb_read(struct file *filp,	/* see include/linux/fs.h   */
+			 char __user *buffer,	/* buffer to fill with data */
+			 size_t length,	/* length of the buffer     */
+			 loff_t * offset)
+{
+
+#ifdef _DEBUG
+  printk(KERN_INFO "device_read(%p,%s,%d)", filp, buffer, (int)length);
+#endif
+  
+  return 0;
+}
+
+static ssize_t ltkb_write(struct file *filp,
+			  const char __user *buffer,
+			  size_t length,
+			  loff_t * offset)
+{
+#ifdef _DEBUG
+  printk(KERN_INFO "device_write(%p,%s,%d)", filp, buffer, (int)length);
+#endif
+  return 0;
+}
+// -------------------------------------------------------------------------  //
+
+
+#define LTKB_IOC_HEADER 'b'
+
+#define LTKB_IOC_RESET _IO(LTKB_IOC_HEADER, 0)
+#define LTKB_IOC_PING  _IOWR(LTKB_IOC_HEADER, 1, char)
+
+#define LTKB_IOC_MAXNR 1
+
+////////////// IOCTL ///////////////////////////////////////////////////////////
+int ltkb_ioctl(struct inode *inode, struct file *filp, 
+	       unsigned int cmd, unsigned long arg)
+{
+  char c = 0;
+  int retval = 0;
+
+  /*
+   * extract the type and number bitfields, and don't decode
+   * wrong cmds: return ENOTTY (inappropriate ioctl) before access_ok()
+   */
+  if (_IOC_TYPE(cmd) != LTKB_IOC_HEADER) return -ENOTTY;
+  if (_IOC_NR(cmd) > LTKB_IOC_MAXNR) return -ENOTTY;
+
+  // TODO user access control //
+
+
+  switch(cmd) {
+  case LTKB_IOC_RESET:
+    if(!capable(CAP_SYS_ADMIN))
+      return -EPERM;
+    // TODO free all memory mapping//
+    break;
+  case LTKB_IOC_PING:
+    retval = __get_user(c,(char __user *)arg);
+    c++;    
+    retval = __put_user(c,(char __user *)arg);
+    break;
+  default:
+    return -ENOTTY;
+  }
+  return retval;
+
+}
+// -------------------------------------------------------------------------  //
+
+
+
+
+
+#ifndef LTKB_MAJOR
+#define LTKB_MAJOR 0
+#endif
+
+#ifndef LTKB_NR_DEVS
+#define LTKB_NR_DEVS 4
+#endif
+
+#ifndef LTKB_DEVICE_NAME
+#define LTKB_DEVICE_NAME "ltkb"
+#endif
+
+
+
+/* the file operations, i.e. all character device methods */
+static struct file_operations ltkb_fops = {
+  .open = ltkb_open,
+  .release = ltkb_release,
+  .read = ltkb_read,
+  .write = ltkb_write,
+  .ioctl = ltkb_ioctl,
+  .mmap = ltkb_mmap,
+  .owner = THIS_MODULE,
+};
+
+static int _ltkb_major_number = LTKB_MAJOR;
+
+// Module init function ////////////////////////////////////////////////////////
+static int __init ltkb_init(void)
+{
+  int i,ret = 0;
+  dev_t dev = 0;
+
+  // REGISTER DEVICE //
+  if(_ltkb_major_number)
+    {
+      dev = MKDEV(_ltkb_major_number,0);
+      ret = register_chrdev_region(dev, LTKB_NR_DEVS, LTKB_DEVICE_NAME);
+    }
+  else {
+    ret = alloc_chrdev_region(&dev, 0, LTKB_NR_DEVS, LTKB_DEVICE_NAME );
+    _ltkb_major_number = MAJOR(dev);
+  }
+  if (ret < 0) {
+    printk(KERN_WARNING "could not allocate major number %d for ltkb\n",
+	   _ltkb_major_number);
+    return ret;
+  }
+
+  // ALLOCATE DEVICES //
+  _ltkb_devices = kmalloc( LTKB_NR_DEVS * sizeof(struct ltkb_dev), GFP_KERNEL );
+  if(!_ltkb_devices) {
+    printk(KERN_ERR "error allocating device structure in memory");
+    return -ENOMEM;
+  }
+  memset(_ltkb_devices, 0, LTKB_NR_DEVS * sizeof(struct ltkb_dev));
+
+  // SETUP DEVICES //
+  for (i = 0 ; i < LTKB_NR_DEVS ; i++ )
+    {
+      struct ltkb_dev *dev = &_ltkb_devices[i];
+      int devno = MKDEV(_ltkb_major_number, i);
+      cdev_init (&dev->cdev, &ltkb_fops);
+      dev->cdev.owner = THIS_MODULE;
+      dev->cdev.ops = &ltkb_fops;
+      ret = cdev_add(&dev->cdev,devno,1);
+      if(ret) printk(KERN_NOTICE "Error %d adding ltkb%d device", ret, i);
+      init_MUTEX(&dev->semaphore);
+    }
+  printk( KERN_NOTICE "ltk bridge module loaded");
+  return ret;
+}
+
+// module release //
+static void __exit ltkb_exit(void)
+{
+  // remove the character deivce //
+  int i;
+  dev_t devno = MKDEV(_ltkb_major_number,0);
+  if(_ltkb_devices)
+    {
+      for(i=0;i<LTKB_NR_DEVS;i++)
+	cdev_del(&_ltkb_devices[i].cdev);
+      kfree(_ltkb_devices);
+    }
+  unregister_chrdev_region(devno,LTKB_NR_DEVS);
+  printk( KERN_NOTICE "ltk bridge module unloaded");
+}
+//  ------------------------------------------------------------------------  //
+
+
+
+
+//////////////////// Main Module Init ///////////////////
+						       //
+module_init(ltkb_init);                                //
+module_exit(ltkb_exit);                                //
+						       //
+MODULE_DESCRIPTION("ltk bridge memory dispatcher");    //
+MODULE_AUTHOR("andrea");                               //
+MODULE_LICENSE("Not licenced yet");                    //
+						       //
+/////////////////////////////////////////////////////////

src/ltk/ltk_bridge/ltkb_test.c

@@ -0,0 +1,40 @@
+#include <stdio.h>
+#include <unistd.h>
+#include <sys/mman.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <stdlib.h>
+#include <sys/ioctl.h>
+
+#define LTKB_IOC_HEADER 'b'
+
+#define LTKB_IOC_RESET _IO(LTKB_IOC_HEADER, 0)
+#define LTKB_IOC_PING  _IOWR(LTKB_IOC_HEADER, 1, char)
+
+#define LTKB_IOC_MAXNR 1
+
+
+int main(void)
+{
+  int fd;
+
+  if ((fd=open("ltkb0", O_RDWR|O_SYNC))<0)
+  {
+      perror("open");
+      exit(-1);
+  }
+
+  char buffer[200] = "hello";
+  write(fd, (void *)&buffer, 6);
+
+  char c = 'a';
+  printf("%c ",c);
+  ioctl(fd, LTKB_IOC_PING, &c);
+  printf("%c ",c);
+  ioctl(fd, LTKB_IOC_PING, &c);
+  printf("%c\n",c);
+  close(fd);
+  return(0);
+}
+

src/ltk/ltk_bridge/setup.sh

@@ -0,0 +1,21 @@
+#!/bin/sh
+module="ltkb"
+device="ltkb"
+mode="664"
+
+/sbin/insmod ./$module.ko $* || exit 1
+
+rm -f ./${device}[0-3]
+
+major=$(awk "\$2==\"$module\" {print \$1}" /proc/devices)
+
+mknod ./${device}0 c $major 0
+mknod ./${device}1 c $major 1
+mknod ./${device}2 c $major 2
+mknod ./${device}3 c $major 3
+
+group="mutom"
+grep -q '^mutom:' /etc/group || group="adm"
+
+chgrp $group ./${device}[0-3]
+chmod $mode ./${device}[0-3]

src/ltk/ltkdebug.c

@@ -0,0 +1,4 @@
+
+#include "ltkdebug.h"
+
+

src/ltk/ltkdebug.h

@@ -0,0 +1,105 @@
+/*//////////////////////////////////////////////////////////////////////////////
+// CMT Cosmic Muon Tomography project //////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+
+  Copyright (c) 2014, Universita' degli Studi di Padova, INFN sez. di Padova
+  All rights reserved
+
+  Authors: Andrea Rigoni Garola < andrea.rigoni@pd.infn.it >
+
+  ------------------------------------------------------------------
+  This library is free software;  you  can  redistribute  it  and/or
+  modify it  under the  terms  of  the  GNU  Lesser  General  Public
+  License as published  by  the  Free  Software  Foundation;  either
+  version 3.0 of the License, or (at your option) any later version.
+
+  This library is  distributed in  the hope that it will  be useful,
+  but  WITHOUT ANY WARRANTY;  without  even  the implied warranty of
+  MERCHANTABILITY  or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of  the GNU Lesser General  Public
+  License along with this library.
+
+//////////////////////////////////////////////////////////////////////////////*/
+
+
+
+#ifndef LTKDEBUG_H
+#define LTKDEBUG_H
+
+
+#include "ltkmacros.h"
+#include "ltktypes.h"
+
+//! Provide a string for current function, non-concatenatable
+#if defined (__GNUC__) || (defined (__STDC_VERSION__) && __STDC_VERSION__ >= 19901L)
+#  define __func_to_string__     ((const char*) (__func__))
+#else
+#  define __func_to_string__  ((const char*) ("???"))
+#endif
+
+//! Provide a string for current function in pretty format, non-concatenatable
+#if defined (__GNUC__)
+#  define __pfunc_to_string__     ((const char*) (__PRETTY_FUNCTION__))
+#elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 19901L
+#  define __pfunc_to_string__  ((const char*) (__func__))
+#else
+#  define __pfunc_to_string__  ((const char*) ("???"))
+#endif
+
+
+
+////////////////////////////////////////////////////////////////////////////////
+//// Pragma Messages for debug allerts during compilation  /////////////////////
+////////////////////////////////////////////////////////////////////////////////
+
+#ifdef PRAGMA_MESSAGES
+#define DEBUG_DO_PRAGMA(x) _Pragma (#x)
+#else
+#define DEBUG_DO_PRAGMA(x) ;
+#endif
+
+#define TODO(x) DEBUG_DO_PRAGMA(message ("\n\n [TODO] >> " #x " <<\n"))
+#define OPTIMIZE(x) DEBUG_DO_PRAGMA(message ("\n\n [OPTIMIZE]  > " #x " <\n"))
+#define DUMP(x) DEBUG_DO_PRAGMA(message ("\n\n [DUMP]  > " #x " <\n"))
+
+//  ------------------------------------------------------------------------  //
+
+
+
+C_BEGIN_DECLS
+
+
+typedef enum
+{
+    LOG_FLAG_ACTIVE = 1 << 0,
+            LOG_FLAG_FATAL = 1 << 1,
+            LOG_LEVEL_ERROR = 1 << 2,
+            LOG_LEVEL_CRITICAL = 1 << 3,
+            LOG_LEVEL_WARNING = 1 << 4,
+            LOG_LEVEL_MESSAGE = 1 << 5,
+            LOG_LEVEL_INFO = 1 << 6,
+            LOG_LEVEL_DEBUG = 1 << 7,
+            LOG_LEVEL_ANNOING = 1 << 8,
+            LOG_LEVEL_PARANOID = 1 << 9
+} LogLevelFlags;
+
+
+
+
+void debug_log(
+            void *handler,
+            LogLevelFlags flags,
+            const char *function_name,
+            const char *message,
+            ...);
+
+
+
+C_END_DECLS
+
+
+
+
+#endif // LTKDEBUG_H

src/ltk/ltkmacros.h

@@ -0,0 +1,61 @@
+/*//////////////////////////////////////////////////////////////////////////////
+// CMT Cosmic Muon Tomography project //////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+
+  Copyright (c) 2014, Universita' degli Studi di Padova, INFN sez. di Padova
+  All rights reserved
+
+  Authors: Andrea Rigoni Garola < andrea.rigoni@pd.infn.it >
+
+  ------------------------------------------------------------------
+  This library is free software;  you  can  redistribute  it  and/or
+  modify it  under the  terms  of  the  GNU  Lesser  General  Public
+  License as published  by  the  Free  Software  Foundation;  either
+  version 3.0 of the License, or (at your option) any later version.
+
+  This library is  distributed in  the hope that it will  be useful,
+  but  WITHOUT ANY WARRANTY;  without  even  the implied warranty of
+  MERCHANTABILITY  or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of  the GNU Lesser General  Public
+  License along with this library.
+
+//////////////////////////////////////////////////////////////////////////////*/
+
+
+
+/* 
+ * File:   macros.h
+ * Author: andrea
+ *
+ * Created on May 23, 2012, 9:01 AM
+ */
+
+#ifndef LTK_MACROS_H
+#define	LTK_MACROS_H
+
+// C code in headers, while including them from C++
+#ifdef  __cplusplus
+
+# define C_BEGIN_DECLS  extern "C" {
+# define C_END_DECLS    }
+
+#define BEGIN_NAMESPACE(name) namespace name {
+#define END_NAMESPACE         }
+
+#else
+
+# define C_BEGIN_DECLS
+# define C_END_DECLS
+
+#define BEGIN_NAMESPACE(name)
+#define END_NAMESPACE
+
+#endif
+
+
+
+
+#endif	/* MACROS_H */
+

src/ltk/ltktypes.h

@@ -0,0 +1,127 @@
+/*//////////////////////////////////////////////////////////////////////////////
+// CMT Cosmic Muon Tomography project //////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+
+  Copyright (c) 2014, Universita' degli Studi di Padova, INFN sez. di Padova
+  All rights reserved
+
+  Authors: Andrea Rigoni Garola < andrea.rigoni@pd.infn.it >
+
+  ------------------------------------------------------------------
+  This library is free software;  you  can  redistribute  it  and/or
+  modify it  under the  terms  of  the  GNU  Lesser  General  Public
+  License as published  by  the  Free  Software  Foundation;  either
+  version 3.0 of the License, or (at your option) any later version.
+
+  This library is  distributed in  the hope that it will  be useful,
+  but  WITHOUT ANY WARRANTY;  without  even  the implied warranty of
+  MERCHANTABILITY  or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of  the GNU Lesser General  Public
+  License along with this library.
+
+//////////////////////////////////////////////////////////////////////////////*/
+
+
+
+#ifndef LTK_TYPE_H
+#define LTK_TYPE_H
+
+#include <assert.h>
+#include <sys/types.h>
+
+//#include "templates.h"
+#include "ltkmacros.h"
+
+#ifdef __cplusplus
+# define LTK_TYPECAST(T, Type) static_cast< T >(Type)
+#else
+# define LTK_TYPECAST(T, Type) ((T)(Type))
+#endif
+
+
+BEGIN_NAMESPACE(ltk) 
+
+C_BEGIN_DECLS
+
+/* ////////////////////////////////////////////////////////////////////////// */
+/* //////////////////////////// TYPE DEFINITIONS   ////////////////////////// */
+/* ////////////////////////////////////////////////////////////////////////// */
+
+
+typedef void *     Pointer_t;
+typedef id_t       Id_t;
+typedef size_t     Size_t;
+
+#ifndef LTK_DOUBLE_PRECISION
+typedef float      Real_t;
+#else
+typedef double     Real_t;
+#endif
+
+#define LTK_SIGNED_CHAR_MIN        LTK_TYPECAST(signed char, 0x80)
+#define LTK_SIGNED_CHAR_MAX        LTK_TYPECAST(signed char, 0x7f)
+
+#define LTK_UNSIGNED_CHAR_MIN      LTK_TYPECAST(unsigned char, 0u)
+#define LTK_UNSIGNED_CHAR_MAX      LTK_TYPECAST(unsigned char, 0xffu) 
+
+#define LTK_SHORT_MIN              LTK_TYPECAST(short, 0x8000)
+#define LTK_SHORT_MAX              LTK_TYPECAST(short, 0x7fff)
+
+#define LTK_UNSIGNED_SHORT_MIN     LTK_TYPECAST(unsigned short, 0u)
+#define LTK_UNSIGNED_SHORT_MAX     LTK_TYPECAST(unsigned short, 0xffffu)
+
+#define LTK_INT_MIN                LTK_TYPECAST(int, ~(~0u >> 1))
+#define LTK_INT_MAX                LTK_TYPECAST(int, ~0u >> 1)
+
+#define LTK_INT8_MIN               LTK_TYPECAST(int8_t, 0x80)
+#define LTK_INT8_MAX               LTK_TYPECAST(int8_t,  0x7f)
+
+#define LTK_INT16_MIN              LTK_TYPECAST(int16_t,  0x8000u)
+#define LTK_INT16_MAX              LTK_TYPECAST(int16_t,  0x7fffu)
+
+#define LTK_UNSIGNED_INT16_MIN     LTK_TYPECAST(int16_t, 0u)
+#define LTK_UNSIGNED_INT16_MAX     LTK_TYPECAST(unsigned int16_t, 0xffffu)
+
+#define LTK_INT32_MIN              LTK_TYPECAST(int32_t,  0x80000000u)
+#define LTK_INT32_MAX              LTK_TYPECAST(int32_t,  0x7fffffffu)
+
+#define LTK_UNSIGNED_INT32_MIN     LTK_TYPECAST(unsigned int32_t, 0u)
+#define LTK_UNSIGNED_INT32_MAX     LTK_TYPECAST(unsigned int32_t, 0xffffffffu)
+
+#define LTK_INT64_MIN              LTK_TYPECAST(int64_t, 0x8000000000000000u)
+#define LTK_INT64_MAX              LTK_TYPECAST(int64_t, 0x7fffffffffffffffu)
+
+#define LTK_UNSIGNED_INT8_MIN      LTK_TYPECAST(int8_t, 0u)
+#define LTK_UNSIGNED_INT8_MAX      LTK_TYPECAST(int8_t, 0xffu)
+
+#define LTK_UNSIGNED_INT64_MIN     LTK_TYPECAST(unsigned int64_t, 0u)
+#define LTK_UNSIGNED_INT64_MAX     LTK_TYPECAST(unsigned int64_t, \
+                                                0xffffffffffffffffu)
+
+#define LTK_UNSIGNED_INT_MIN       LTK_TYPECAST(unsigned int, 0)
+#define LTK_UNSIGNED_INT_MAX       LTK_TYPECAST(unsigned int, ~0u)
+
+#define LTK_LONG_MIN               LTK_TYPECAST(long, ~(~0ul >> 1))
+#define LTK_LONG_MAX               LTK_TYPECAST(long, ~0ul >> 1)
+
+#define LTK_UNSIGNED_LONG_MIN      LTK_TYPECAST(unsigned long, 0ul)
+#define LTK_UNSIGNED_LONG_MAX      LTK_TYPECAST(unsigned long, ~0ul)
+
+#define LTK_FLOAT_MIN              LTK_TYPECAST(float, -1.0e+38f)
+#define LTK_FLOAT_MAX              LTK_TYPECAST(float, 1.0e+38f)
+
+#define LTK_DOUBLE_MIN             LTK_TYPECAST(double, -1.0e+299)
+#define LTK_DOUBLE_MAX             LTK_TYPECAST(double, 1.0e+299)
+
+
+
+
+
+C_END_DECLS
+
+END_NAMESPACE
+
+
+#endif //TYPE_H

src/ltk/main.C

@@ -0,0 +1,35 @@
+/*//////////////////////////////////////////////////////////////////////////////
+// CMT Cosmic Muon Tomography project //////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+
+  Copyright (c) 2014, Universita' degli Studi di Padova, INFN sez. di Padova
+  All rights reserved
+
+  Authors: Andrea Rigoni Garola < andrea.rigoni@pd.infn.it >
+
+  ------------------------------------------------------------------
+  This library is free software;  you  can  redistribute  it  and/or
+  modify it  under the  terms  of  the  GNU  Lesser  General  Public
+  License as published  by  the  Free  Software  Foundation;  either
+  version 3.0 of the License, or (at your option) any later version.
+
+  This library is  distributed in  the hope that it will  be useful,
+  but  WITHOUT ANY WARRANTY;  without  even  the implied warranty of
+  MERCHANTABILITY  or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of  the GNU Lesser General  Public
+  License along with this library.
+
+//////////////////////////////////////////////////////////////////////////////*/
+
+
+
+
+#include "Object.h"
+
+
+int main()
+{
+  return 0;
+}

src/ltk/main.c

@@ -0,0 +1,72 @@
+
+#include "DenseMatrix.h"
+#include "Vector.h"
+#include "Object.h"
+
+#include "vectormath/simd/instrset.h"
+
+/* LTK_VECTOR_DECLARE(int,LtkInt4,4) */
+
+/* LTK_MATRIX_DECLARE(int,LtkInt2x2,2,2) */
+/* LTK_MATRIX_DECLARE(int,LtkInt4x1,4,1) */
+/* LTK_MATRIX_DECLARE(int,LtkInt4x4,4,4) */
+
+int test(int a) { return 0; }
+ 
+
+int main(void)
+{
+
+  // testing dense matrix //
+  /****************************************************/
+  /* LtkInt2x2 a;				      */
+  /* LtkInt4x1 b;				      */
+  /* LtkInt4x4 c;				      */
+  /* LtkInt4 v, w;				      */
+  /* 						      */
+  /* v = LtkInt4_ltk_vector_new ();		      */
+  /* w = LtkInt4_ltk_vector_new ();		      */
+  /* 						      */
+  /* int i;					      */
+  /* for (i = 0; i < LtkInt4_ltk_vector_size (); ++i) */
+  /*   {					      */
+  /*     LtkInt4_ltk_vector_set (v, i, 0);	      */
+  /*     LtkInt4_ltk_vector_set (w, i, 3);	      */
+  /*   }					      */
+  /* 						      */
+  /* printf ("v = ");				      */
+  /* for (i = 0; i < 4; ++i)			      */
+  /*   printf ("%d ", LtkInt4_ltk_vector_get (v, i)); */
+  /* printf ("\n");				      */
+  /* 						      */
+  /* printf ("w = ");				      */
+  /* for (i = 0; i < 4; ++i)			      */
+  /*   printf ("%d ", LtkInt4_ltk_vector_get (w, i)); */
+  /* printf ("\n");				      */
+  /****************************************************/
+
+  // testing intrinsics //
+  printf("INSTRUCTION SET -> %d\n",INSTRSET);
+  __m128 aligned_float = _mm_setzero_ps();
+  float *p = &aligned_float;
+  printf("%f,%f,%f,%f\n",p[0],p[1],p[2],p[3]);
+
+  // adder //
+  __m128 a_1,a_2;
+  a_1 = _mm_set_ps(3,3,3,3);
+  a_2 = _mm_set_ps(1,2,3,4);
+
+
+  aligned_float = _mm_add_ps(a_1,a_2);
+  p = &aligned_float; printf("%f,%f,%f,%f\n",p[0],p[1],p[2],p[3]);
+
+
+
+  // testing Objects //
+  //LTK_MATRIX_DECLARE(TypeName, type, r, c);
+  // Object *ob = New(ObjectClass);
+  // int el = ObjectClass->GetElement(ob);
+  
+
+  return 0;
+}

src/ltk/templates.c

@@ -0,0 +1,92 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include "templates.h"
+
+
+LtkList ltk_list_new()
+{
+  LtkList list = malloc(sizeof(struct _template_list));
+  list->size = 0;
+  list->start = NULL;
+  list->end = NULL;
+  return list;
+}
+
+void ltk_list_nodepush(LtkList list,LtkListNode node)
+{
+  if(list == NULL) return;
+  node->next = list->start;
+  list->start = node;
+  if(list->end == NULL) list->end = node;
+  list->size++;
+}
+
+LtkListNode ltk_list_get_start(LtkList list)
+{
+  if (list==NULL || list->start==NULL) return NULL;
+  return list->start;
+}
+
+LtkListNode ltk_list_get_end(LtkList list)
+{
+  if (list==NULL || list->end==NULL) return NULL;
+  return list->end;
+}
+
+void ltk_list_remove(LtkList list,LtkListNode node)
+{
+  if (list == NULL || list->start==NULL) return;
+  struct _template_list_node *node_tofree,*prev;
+  node_tofree=list->start;
+  while (node_tofree != node) {
+    if(node_tofree->next == NULL) return;
+    prev = node_tofree;
+    node_tofree = node_tofree->next;
+  }
+  if(node_tofree == list->start) list->start = node_tofree->next;
+  else prev->next = node_tofree->next;
+  free(node_tofree);
+}
+
+void ltk_list_pop_start(LtkList list)
+{
+  if (list==NULL || list->start==NULL) return;
+  struct _template_list_node *nodetofree;
+  nodetofree=list->start;
+  list->start = list->start->next;
+  free(nodetofree);
+}
+
+void ltk_list_pop_end(LtkList list)
+{
+  if (list==NULL || list->end==NULL) return;
+  struct _template_list_node *iter;
+  iter=list->start;
+  if(iter==list->end) {
+    free(iter);
+    list->start = list->end = NULL;
+  }
+  else { 
+    while(iter->next!=list->end) iter=iter->next;
+    free(iter->next);
+    iter->next = NULL;
+    list->end = iter;
+  }
+  list->size--;
+}
+
+int ltk_list_get_size(LtkList list)
+{
+  if(list==NULL) return 0;
+  return list->size;
+}
+
+
+LtkListIterator ltk_list_iterator_new(LtkList list)
+{
+  if(list==NULL || list->start == NULL) return NULL;
+  return (LtkListIterator)list->start;
+}
+
+

src/ltk/templates.h

@@ -0,0 +1,303 @@
+/*//////////////////////////////////////////////////////////////////////////////
+// CMT Cosmic Muon Tomography project //////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+
+  Copyright (c) 2014, Universita' degli Studi di Padova, INFN sez. di Padova
+  All rights reserved
+
+  Authors: Andrea Rigoni Garola < andrea.rigoni@pd.infn.it >
+
+  ------------------------------------------------------------------
+  This library is free software;  you  can  redistribute  it  and/or
+  modify it  under the  terms  of  the  GNU  Lesser  General  Public
+  License as published  by  the  Free  Software  Foundation;  either
+  version 3.0 of the License, or (at your option) any later version.
+
+  This library is  distributed in  the hope that it will  be useful,
+  but  WITHOUT ANY WARRANTY;  without  even  the implied warranty of
+  MERCHANTABILITY  or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of  the GNU Lesser General  Public
+  License along with this library.
+
+//////////////////////////////////////////////////////////////////////////////*/
+
+
+
+/* 
+ * <one line to give the program's name and a brief idea of what it does.>
+ * Copyright (C) 2012  Andrea Rigoni Garola <andrea.rigoni@pd.infn.it>
+ * 
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or (at
+ * your option) any later version.
+ * 
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ * 
+ */
+
+
+#ifndef TEMPLATES_H
+#define TEMPLATES_H
+
+#include <stdlib.h>      // for std allocator   //
+#include <string.h>      // for memcpy //
+#include <assert.h>
+
+#include "ltkmacros.h"      // default environment //
+#include "container.h"   // TODO !!! //
+
+#include <stdio.h>
+
+
+
+
+
+/* ////////////////////////////////////////////////////////////////////////// */
+/* //////////////////////////// ALLOC FUNCTIONS ///////////////////////////// */
+/* ////////////////////////////////////////////////////////////////////////// */
+
+C_BEGIN_DECLS
+
+//inline ltkPointer ltk_malloc(unsigned int size) { return malloc(size); }
+//inline void       ltk_free  (ltkPointer ptr)    { free(ptr); }
+
+#define LTK_SIMPLE_ALLOC_FUNC(Type, ltkType, Class_name, size)		\
+  inline ltkType ltkType##_##Class_name##_new()				        \
+  {									\
+    return LTK_TYPECAST(ltkType, malloc(sizeof(Type) * size));     	\
+  }                                                                 \
+  inline void ltkType##_##Class_name##_delete(ltkType t)		    \
+  { free(t); }								                        \
+  inline void ltkType##_##Class_name##_copy(ltkType dst, const ltkType src) \
+  { memcpy((ltkPointer)dst, (ltkPointer)src, sizeof(Type) * size ); }
+
+C_END_DECLS
+
+
+
+
+
+/* ////////////////////////////////////////////////////////////////////////// */
+/* //////////////////////////// ABSTRACT C BUFFER /////////////////////////// */
+/* ////////////////////////////////////////////////////////////////////////// */
+
+C_BEGIN_DECLS
+
+#define LTK_ABSTRACT_BUFFER_DECLARE_FUNC(Type,ltkType,Class_name,size)        \
+  inline int ltkType##_##Class_name##_size() { return size; }                 \
+  inline Type ltkType##_##Class_name##_get(ltkType v, unsigned int c)         \
+   { assert(c < size); return *((ltkType)m + c); }                            \
+  inline void ltkType##_##Class_name##_set(ltkType v, Type t, unsigned int c) \
+   { assert(c < size); *((ltkType)m + c) = t; }
+
+// FINIRE !!! //
+
+C_END_DECLS
+
+#ifdef __cplusplus
+
+template <typename T, unsigned int size> class ltkAbstractBuffer
+{
+  typedef ltkAbstractBuffer<T, size> ThisClass;  
+protected:
+    typedef T ContentType;
+    virtual       T* getBuffer()       = 0;
+    virtual const T* getBuffer() const = 0;
+
+    struct CommaInit
+    {
+	inline explicit CommaInit(ltkAbstractBuffer<T, size> *container,float s)
+	: container(container) {
+	    this->index = 0;
+	    this->container->getBuffer()[0] = s;
+	}
+	inline CommaInit & operator, (float s) {
+	    this->index++;
+	    assert(index < size);
+	    this->container->getBuffer()[this->index] = s;
+	    return *this;
+	}
+	ltkAbstractBuffer<T, size> *container;
+	unsigned int index;
+    };
+
+public:
+    inline CommaInit operator =(T scalar) {
+	return CommaInit(this, scalar);
+    }
+    inline CommaInit operator <<(T scalar) {
+	return CommaInit(this, scalar);
+    }    
+
+    inline T& at(const unsigned int i) {
+	return *(this->getBuffer() + i);
+    }
+
+    inline T & operator[](unsigned int i) {
+	return *(this->getBuffer() + i);
+    }
+    inline const T & operator[](unsigned int i) const {
+	return *(this->getBuffer() + i);
+    }
+    inline T & operator()(unsigned int i) {
+	return *(this->getBuffer() + i);
+    }
+    inline const T & operator()(unsigned int i) const {
+	return *(this->getBuffer() + i);
+    }
+
+
+};
+
+#endif // __cplusplus
+
+
+/* ////////////////////////////////////////////////////////////////////////// */
+/* //////////////////////////// ARRAY /////////////////////////////////////// */
+/* ////////////////////////////////////////////////////////////////////////// */
+
+// COMING SOON //
+
+
+
+
+
+
+
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+/// DO NOT USE ANYTHING AFTER THIS LINE ... EXPERIMENTAL      //////////////////
+
+
+
+
+
+
+
+
+
+/* ////////////////////////////////////////////////////////////////////////// */
+/* //////////////////////////// CIRCULAR BUFFER ///////////////////////////// */
+/* ////////////////////////////////////////////////////////////////////////// */
+/* CIRCULAR BUFFER */
+
+struct _ltk_template_buffer {
+  void *pos;
+  void *head;
+};
+
+#define LTK_BUFFER_DECLARE(Type, Type_name, size, overlap) \
+typedef struct _ltk_template_buffer *Type_name;                                \
+inline Type_name Type_name##_ltk_buffer_new()                                  \
+{ Type_name out = (Type_name)ltk_malloc                                        \
+                  (sizeof(Type) * (size + overlap) + 2);                       \
+  out->head = (void *)out + 2 + overlap * sizeof(Type); \
+  out->pos = out->head; \
+return out;              }                     \
+inline void Type_name##_ltk_buffer_free(Type_name buffer) { ltk_free(buffer); }\
+
+
+
+// TO BE CONTINUED.... //
+
+
+
+
+
+
+
+
+///// LtkPTree ////////
+
+struct _LtkPTreeNode
+{
+  struct _LtkPTreeNode *parent;
+};
+typedef struct _LtkPTreeNode *LtkPtree;
+
+
+
+
+
+
+
+
+
+
+
+
+/*
+  one way list template usable as FIFO or LIFO by macros
+  Element must be a pointer to a real allocated object.
+*/
+// this acts as dummy node, never really instanciated //
+struct _template_list_node { 
+  struct _template_list_node *next; 
+};
+typedef struct _template_list_node *LtkListNode;
+#define LTK_LIST_HEADER LtkListNode ltk_list_node_next;
+
+struct _template_list {
+  int size;
+  struct _template_list_node *start;
+  struct _template_list_node *end;
+};
+
+typedef struct _template_list *LtkList;
+typedef struct _template_list_node *LtkListIterator;
+
+LtkList ltk_list_new();
+void ltk_list_nodepush(LtkList list,LtkListNode node);
+LtkListNode ltk_list_get_start(LtkList list);
+LtkListNode ltk_list_get_end(LtkList list);
+void ltk_list_remove(LtkList list,LtkListNode node);
+void ltk_list_pop_start(LtkList list);
+void ltk_list_pop_end(LtkList list);
+
+
+#define LTK_LIST_DECLARE(Type,Type_name) \
+    static LtkList (* Type_name##_list_new)(void) = ltk_list_new;\
+    void    (* Type_name##_list_nodepush)(LtkList list, Type *node) = (void (*)(LtkList, Type *))ltk_list_nodepush; \
+    Type *  (* Type_name##_list_get_start)(LtkList list)            = (Type *(*)(LtkList))ltk_list_get_start;       \
+    Type *  (* Type_name##_list_get_end)(LtkList list)              = (Type *(*)(LtkList))ltk_list_get_end;         \
+    void    (* Type_name##_list_remove)(LtkList list, Type *node)   = (void (*)(LtkList, Type *))ltk_list_remove;   \
+    void    (* Type_name##_list_pop_start)(LtkList list)            = (void (*)(LtkList))ltk_list_pop_start;        \
+    void    (* Type_name##_list_pop_end)(LtkList list)              = (void (*)(LtkList))ltk_list_pop_end;
+
+#define LTK_LIST_DECLARE_KEYACCESS(Type,Type_name,KeyType,key_member_name,key_function) \
+    Type * Type_name##_list_key_lookup(LtkList list, KeyType key)  { \
+    LtkListIterator iter = ltk_list_iterator_new(list);             \
+    while(iter) { \
+    if (key_function( ((Type *)iter)->key_member_name, key )) \
+    return (Type *)iter; \
+    iter = iter->next; } \
+    return NULL; } \
+    \
+    void Type_name##_list_key_remove(LtkList list, KeyType key) { \
+    LtkListNode node = (LtkListNode)Type_name##_list_key_lookup(list,key); \
+    if(node) ltk_list_remove(list,node); } \
+
+
+LtkListIterator ltk_list_iterator_new(LtkList list);
+
+#endif // TEMPLATES_H

src/ltk/test_comma.h

@@ -0,0 +1,117 @@
+/*//////////////////////////////////////////////////////////////////////////////
+// CMT Cosmic Muon Tomography project //////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+
+  Copyright (c) 2014, Universita' degli Studi di Padova, INFN sez. di Padova
+  All rights reserved
+
+  Authors: Andrea Rigoni Garola < andrea.rigoni@pd.infn.it >
+
+  ------------------------------------------------------------------
+  This library is free software;  you  can  redistribute  it  and/or
+  modify it  under the  terms  of  the  GNU  Lesser  General  Public
+  License as published  by  the  Free  Software  Foundation;  either
+  version 3.0 of the License, or (at your option) any later version.
+
+  This library is  distributed in  the hope that it will  be useful,
+  but  WITHOUT ANY WARRANTY;  without  even  the implied warranty of
+  MERCHANTABILITY  or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of  the GNU Lesser General  Public
+  License along with this library.
+
+//////////////////////////////////////////////////////////////////////////////*/
+
+
+
+/* 
+ * File:   test_comma.h
+ * Author: andrea
+ *
+ * Created on May 24, 2012, 4:47 PM
+ */
+
+#ifndef TEST_COMMA_H
+#define	TEST_COMMA_H
+
+#include <assert.h>
+
+struct Vector3
+{
+    union
+    {
+	struct { float x, y, z; };
+	float data[3];
+    };
+
+   struct CommaAssign;
+
+    CommaAssign operator=(float _x)
+   {
+      x = _x;
+      return CommaAssign(this,1);
+   }
+
+   struct CommaAssign
+    {
+	Vector3 *vec3;
+	int index;
+
+	explicit CommaAssign(Vector3 *vec3, int index) : vec3(vec3) {
+	    this->index = index;
+	}
+	CommaAssign operator, (float f) {
+	    vec3->data[index] = f;
+	    return CommaAssign(vec3, index + 1);
+	}
+
+    };
+
+};
+
+
+
+struct Container
+{
+    union
+    {
+	struct { float x, y, z; };
+	float data[3];
+    };
+
+    inline float *getBuffer() {
+	return this->data;
+    }
+
+   template <typename T, unsigned int size> class CommaAssign
+    {
+    private:
+	T *container;
+	int index;
+
+    public:
+	inline explicit CommaAssign(T *container, float s) : container(container) {
+	    this->index = 0;
+	    this->container->getBuffer()[0] = s;
+	}
+
+	inline CommaAssign& operator, (float s) {
+	    this->index++;
+	    assert(index < size);
+	    this->container->getBuffer()[this->index] = s;
+	    return *this;
+	}
+    };
+
+    CommaAssign<Container, 3> operator=(float s) {
+	return CommaAssign<Container, 3 > (this, s);
+    }
+
+};
+
+
+
+
+#endif	/* TEST_COMMA_H */
+

src/ltk/testing/Makefile.am

@@ -0,0 +1,37 @@
+
+include $(top_srcdir)/Common.am
+
+#AM_DEFAULT_SOURCE_EXT = .cpp
+
+
+
+TESTS = LtkDebugTest \
+	LtkFunctionToStringTest
+
+LDADD = ../../../libmutom-0.1.la
+check_PROGRAMS = $(TESTS)
+
+
+####################################################
+# Hybrid c/c++ Ltk Specific tests                  #
+####################################################
+
+check_PROGRAMS += Vector-test
+Vector_test_SOURCES = Vector.c
+TESTS += Vector-test
+
+check_PROGRAMS += Vector-test-cc
+Vector_test_cc_SOURCES = Vector-cc.cpp
+TESTS += Vector-test-cc
+
+check_PROGRAMS += Object-test
+Object_test_SOURCES = Object.c
+TESTS += Object-test
+
+check_PROGRAMS += Object-test-cc
+Object_test_cc_SOURCES = Object-cc.cpp
+TESTS += Object-test-cc
+
+####################################################
+
+AM_COLOR_TESTS = always

src/ltk/testing/Object-cc.cpp

@@ -0,0 +1,40 @@
+/*//////////////////////////////////////////////////////////////////////////////
+// CMT Cosmic Muon Tomography project //////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+
+  Copyright (c) 2014, Universita' degli Studi di Padova, INFN sez. di Padova
+  All rights reserved
+
+  Authors: Andrea Rigoni Garola < andrea.rigoni@pd.infn.it >
+
+  ------------------------------------------------------------------
+  This library is free software;  you  can  redistribute  it  and/or
+  modify it  under the  terms  of  the  GNU  Lesser  General  Public
+  License as published  by  the  Free  Software  Foundation;  either
+  version 3.0 of the License, or (at your option) any later version.
+
+  This library is  distributed in  the hope that it will  be useful,
+  but  WITHOUT ANY WARRANTY;  without  even  the implied warranty of
+  MERCHANTABILITY  or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of  the GNU Lesser General  Public
+  License along with this library.
+
+//////////////////////////////////////////////////////////////////////////////*/
+
+
+
+#include "testing-prototype.h"
+#include "../Object.h"
+
+using namespace ltk;
+
+int main() {
+    BEGIN_TESTING(Object - cc);
+
+    Object ob;
+    TEST1( ob.GetElement() == 5552368 );
+
+    END_TESTING;
+}

src/ltk/testing/Object.c

@@ -0,0 +1,11 @@
+#include "testing-prototype.h"
+#include "../Object.h"
+
+
+int main() {
+    BEGIN_TESTING(Object);
+
+    struct _Object *ob = Object_new(ObjectClass);
+
+    END_TESTING;
+}

src/ltk/testing/Vector-cc.cpp

@@ -0,0 +1,79 @@
+/*//////////////////////////////////////////////////////////////////////////////
+// CMT Cosmic Muon Tomography project //////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+
+  Copyright (c) 2014, Universita' degli Studi di Padova, INFN sez. di Padova
+  All rights reserved
+
+  Authors: Andrea Rigoni Garola < andrea.rigoni@pd.infn.it >
+
+  ------------------------------------------------------------------
+  This library is free software;  you  can  redistribute  it  and/or
+  modify it  under the  terms  of  the  GNU  Lesser  General  Public
+  License as published  by  the  Free  Software  Foundation;  either
+  version 3.0 of the License, or (at your option) any later version.
+
+  This library is  distributed in  the hope that it will  be useful,
+  but  WITHOUT ANY WARRANTY;  without  even  the implied warranty of
+  MERCHANTABILITY  or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of  the GNU Lesser General  Public
+  License along with this library.
+
+//////////////////////////////////////////////////////////////////////////////*/
+
+
+
+#include "testing-prototype.h"
+#include "../Vector.h"
+
+using namespace ltk;
+
+int main() {
+    BEGIN_TESTING(Vector - cc);
+
+    typedef ltkVector<int, 4 > ltkInt4;
+
+    ltkInt4 v, w;
+    v = 1, 2, 3, 4;
+    w = v;
+
+    printf("v -> %d,%d,%d,%d\n", v[0], *(v.getBuffer() + 1), v.at(2), v(3));
+
+
+    // test assign operator
+    TEST1(v == w);
+    TEST0(v != w);
+
+    // test accessors
+    TEST1(v[0] == 1);
+    TEST1(*(v.getBuffer() + 1) == 2);
+    TEST1(v.at(2) == 3);
+    TEST1(v(3) == 4);
+
+    // setter
+    w << 1, 4, 9, 16;
+    TEST1(w[0] == 1);
+    TEST1(w[1] == 4);
+    TEST1(w[2] == 9);
+    TEST1(w[3] == 16);
+
+    // math operators
+    v *= v;
+    w = 1, 4, 9, 16;
+    TEST1(v == w);
+    v /= v;
+    w = 1, 1, 1, 1;
+    TEST1(v == w);
+    v += v;
+    w = 2, 2, 2, 2;
+    TEST1(v == w);
+
+    v << 1, 1, -1, 1;
+    w << -1, 1, 1, 1;
+    TEST0(v * w);
+    TEST0(v / w);
+
+    END_TESTING;
+}

src/ltk/testing/Vector.c

@@ -0,0 +1,14 @@
+#include <stdio.h>
+#include "testing-prototype.h"
+#include "../Vector.h"
+
+
+LTK_VECTOR_DECLARE (float, uFloat4, 4)
+
+int main()
+{
+  BEGIN_TESTING (Vector);
+  uFloat4 f = uFloat4_ltk_vector_new ();
+
+  END_TESTING;
+}

src/ltk/testing/testing-prototype.h

@@ -0,0 +1,37 @@
+/*//////////////////////////////////////////////////////////////////////////////
+// CMT Cosmic Muon Tomography project //////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+
+  Copyright (c) 2014, Universita' degli Studi di Padova, INFN sez. di Padova
+  All rights reserved
+
+  Authors: Andrea Rigoni Garola < andrea.rigoni@pd.infn.it >
+
+  ------------------------------------------------------------------
+  This library is free software;  you  can  redistribute  it  and/or
+  modify it  under the  terms  of  the  GNU  Lesser  General  Public
+  License as published  by  the  Free  Software  Foundation;  either
+  version 3.0 of the License, or (at your option) any later version.
+
+  This library is  distributed in  the hope that it will  be useful,
+  but  WITHOUT ANY WARRANTY;  without  even  the implied warranty of
+  MERCHANTABILITY  or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of  the GNU Lesser General  Public
+  License along with this library.
+
+//////////////////////////////////////////////////////////////////////////////*/
+
+
+
+#include <stdio.h>
+
+#define BEGIN_TESTING(name)                \
+static int _fail = 0;                      \
+printf("..:: Testing " #name " ::..\n");
+
+#define TEST1(val) _fail += (val)==0
+#define TEST0(val) _fail += (val)!=0
+#define END_TESTING return _fail;
+