OpenCMT/uLib
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

andrea-dev #1

Merged
andrea merged 19 commits from andrea-dev into main 2026-03-06 17:17:52 +01:00
Conversation 1 Commits 19 Files Changed 135 -4336
37 changed files with 0 additions and 4336 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Showing only changes of commit 7ded15d596 - Show all commits

35
src/Gui/Qt/QVTKViewport2/Makefile.am
View File

@@ -1,35 +0,0 @@
# SUBDIRS = .
include $(top_srcdir)/Common.am
DISTSOURCES = vtkviewport.cpp main.cpp
DISTHEADERS_MOC =
DISTHEADERS_NO_MOC =
FORMS = vtkviewport.ui
FORMHEADERS = $(FORMS:.ui=.h)
MOC_CC = $(FORMS:.ui=.moc.cpp) $(DISTHEADERS_MOC:.h=.moc.cpp)
bin_PROGRAMS = QTVtkViewport
BUILT_SOURCES = $(FORMHEADERS) $(MOC_CC)
CLEANFILES = $(BUILT_SOURCES)
EXTRA_DIST = $(FORMS)
QTVtkViewport_SOURCES = $(DISTSOURCES) $(DISTHEADERS_MOC) $(DISTHEADERS_NO_MOC)
nodist_QTVtkViewport_SOURCES = $(MOC_CC)
QTVtkViewport_LDADD = $(top_srcdir)/libmutom.la
.ui.h: $(FORMS)
$(UIC) -o ui_$@ $<
.ui.hpp: $(FORMS_HPP)
$(UIC) -o $@ $<
.h.moc.cpp:
$(MOC) -o $@ $<
SUFFIXES = .h .ui .moc.cpp

18
src/Gui/Qt/QVTKViewport2/QVTKViewport2.pro
View File

@@ -1,18 +0,0 @@
#-------------------------------------------------
#
# Project created by QtCreator 2012-08-30T18:59:53
#
#-------------------------------------------------
QT += core gui
TARGET = QVTKViewport2
TEMPLATE = app
SOURCES += main.cpp\
vtkviewport.cpp
HEADERS += vtkviewport.h
FORMS += vtkviewport.ui

453
src/Gui/Qt/QVTKViewport2/QVTKViewport2.pro.user
View File

@@ -1,453 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE QtCreatorProject>
<!-- Written by Qt Creator 2.4.1, 2012-09-03T09:43:56. -->
<qtcreator>
<data>
<variable>ProjectExplorer.Project.ActiveTarget</variable>
<value type="int">0</value>
</data>
<data>
<variable>ProjectExplorer.Project.EditorSettings</variable>
<valuemap type="QVariantMap">
<value type="bool" key="EditorConfiguration.AutoIndent">true</value>
<value type="bool" key="EditorConfiguration.AutoSpacesForTabs">false</value>
<valuemap type="QVariantMap" key="EditorConfiguration.CodeStyle.0">
<value type="QString" key="language">Cpp</value>
<valuemap type="QVariantMap" key="value">
<value type="QString" key="CurrentPreferences">CppGlobal</value>
</valuemap>
</valuemap>
<valuemap type="QVariantMap" key="EditorConfiguration.CodeStyle.1">
<value type="QString" key="language">QmlJS</value>
<valuemap type="QVariantMap" key="value">
<value type="QString" key="CurrentPreferences">QmlJSGlobal</value>
</valuemap>
</valuemap>
<value type="int" key="EditorConfiguration.CodeStyle.Count">2</value>
<value type="QByteArray" key="EditorConfiguration.Codec">System</value>
<value type="bool" key="EditorConfiguration.ConstrainTooltips">false</value>
<value type="int" key="EditorConfiguration.IndentSize">4</value>
<value type="bool" key="EditorConfiguration.MouseNavigation">true</value>
<value type="int" key="EditorConfiguration.PaddingMode">1</value>
<value type="bool" key="EditorConfiguration.ScrollWheelZooming">true</value>
<value type="int" key="EditorConfiguration.SmartBackspaceBehavior">0</value>
<value type="bool" key="EditorConfiguration.SpacesForTabs">true</value>
<value type="int" key="EditorConfiguration.TabKeyBehavior">1</value>
<value type="int" key="EditorConfiguration.TabSize">8</value>
<value type="bool" key="EditorConfiguration.UseGlobal">true</value>
<value type="int" key="EditorConfiguration.Utf8BomBehavior">1</value>
<value type="bool" key="EditorConfiguration.addFinalNewLine">true</value>
<value type="bool" key="EditorConfiguration.cleanIndentation">true</value>
<value type="bool" key="EditorConfiguration.cleanWhitespace">true</value>
<value type="bool" key="EditorConfiguration.inEntireDocument">false</value>
</valuemap>
</data>
<data>
<variable>ProjectExplorer.Project.PluginSettings</variable>
<valuemap type="QVariantMap"/>
</data>
<data>
<variable>ProjectExplorer.Project.Target.0</variable>
<valuemap type="QVariantMap">
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Desktop</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName">Desktop</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.Target.DesktopTarget</value>
<value type="int" key="ProjectExplorer.Target.ActiveBuildConfiguration">0</value>
<value type="int" key="ProjectExplorer.Target.ActiveDeployConfiguration">0</value>
<value type="int" key="ProjectExplorer.Target.ActiveRunConfiguration">0</value>
<valuemap type="QVariantMap" key="ProjectExplorer.Target.BuildConfiguration.0">
<value type="QString" key="ProjectExplorer.BuildCOnfiguration.ToolChain">ProjectExplorer.ToolChain.Gcc:/usr/bin/g++.x86-linux-generic-elf-64bit.gdb</value>
<valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.0">
<valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.0">
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">qmake</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">QtProjectManager.QMakeBuildStep</value>
<value type="bool" key="QtProjectManager.QMakeBuildStep.LinkQmlDebuggingLibrary">false</value>
<value type="bool" key="QtProjectManager.QMakeBuildStep.LinkQmlDebuggingLibraryAuto">true</value>
<value type="QString" key="QtProjectManager.QMakeBuildStep.QMakeArguments"></value>
<value type="bool" key="QtProjectManager.QMakeBuildStep.QMakeForced">false</value>
</valuemap>
<valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.1">
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Make</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.MakeStep</value>
<value type="bool" key="Qt4ProjectManager.MakeStep.Clean">false</value>
<value type="QString" key="Qt4ProjectManager.MakeStep.MakeArguments"></value>
<value type="QString" key="Qt4ProjectManager.MakeStep.MakeCommand"></value>
</valuemap>
<value type="int" key="ProjectExplorer.BuildStepList.StepsCount">2</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Build</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.BuildSteps.Build</value>
</valuemap>
<valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.1">
<valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.0">
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Make</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.MakeStep</value>
<value type="bool" key="Qt4ProjectManager.MakeStep.Clean">true</value>
<value type="QString" key="Qt4ProjectManager.MakeStep.MakeArguments">clean</value>
<value type="QString" key="Qt4ProjectManager.MakeStep.MakeCommand"></value>
</valuemap>
<value type="int" key="ProjectExplorer.BuildStepList.StepsCount">1</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Clean</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.BuildSteps.Clean</value>
</valuemap>
<value type="int" key="ProjectExplorer.BuildConfiguration.BuildStepListCount">2</value>
<value type="bool" key="ProjectExplorer.BuildConfiguration.ClearSystemEnvironment">false</value>
<valuelist type="QVariantList" key="ProjectExplorer.BuildConfiguration.UserEnvironmentChanges"/>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Desktop Qt 4.7.4 for GCC (Qt SDK) Release</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.Qt4BuildConfiguration</value>
<value type="int" key="Qt4ProjectManager.Qt4BuildConfiguration.BuildConfiguration">0</value>
<value type="QString" key="Qt4ProjectManager.Qt4BuildConfiguration.BuildDirectory">/home/andrea/devel/MuonTomography/mutom/uLib/trunk/src/Gui/Qt/QVTKViewport2</value>
<value type="int" key="Qt4ProjectManager.Qt4BuildConfiguration.QtVersionId">3</value>
<value type="bool" key="Qt4ProjectManager.Qt4BuildConfiguration.UseShadowBuild">false</value>
</valuemap>
<valuemap type="QVariantMap" key="ProjectExplorer.Target.BuildConfiguration.1">
<value type="QString" key="ProjectExplorer.BuildCOnfiguration.ToolChain">ProjectExplorer.ToolChain.Gcc:/usr/bin/g++.x86-linux-generic-elf-64bit.gdb</value>
<valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.0">
<valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.0">
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">qmake</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">QtProjectManager.QMakeBuildStep</value>
<value type="bool" key="QtProjectManager.QMakeBuildStep.LinkQmlDebuggingLibrary">false</value>
<value type="bool" key="QtProjectManager.QMakeBuildStep.LinkQmlDebuggingLibraryAuto">true</value>
<value type="QString" key="QtProjectManager.QMakeBuildStep.QMakeArguments"></value>
<value type="bool" key="QtProjectManager.QMakeBuildStep.QMakeForced">false</value>
</valuemap>
<valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.1">
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Make</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.MakeStep</value>
<value type="bool" key="Qt4ProjectManager.MakeStep.Clean">false</value>
<value type="QString" key="Qt4ProjectManager.MakeStep.MakeArguments"></value>
<value type="QString" key="Qt4ProjectManager.MakeStep.MakeCommand"></value>
</valuemap>
<value type="int" key="ProjectExplorer.BuildStepList.StepsCount">2</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Build</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.BuildSteps.Build</value>
</valuemap>
<valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.1">
<valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.0">
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Make</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.MakeStep</value>
<value type="bool" key="Qt4ProjectManager.MakeStep.Clean">true</value>
<value type="QString" key="Qt4ProjectManager.MakeStep.MakeArguments">clean</value>
<value type="QString" key="Qt4ProjectManager.MakeStep.MakeCommand"></value>
</valuemap>
<value type="int" key="ProjectExplorer.BuildStepList.StepsCount">1</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Clean</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.BuildSteps.Clean</value>
</valuemap>
<value type="int" key="ProjectExplorer.BuildConfiguration.BuildStepListCount">2</value>
<value type="bool" key="ProjectExplorer.BuildConfiguration.ClearSystemEnvironment">false</value>
<valuelist type="QVariantList" key="ProjectExplorer.BuildConfiguration.UserEnvironmentChanges"/>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Desktop Qt 4.7.4 for GCC (Qt SDK) Debug</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.Qt4BuildConfiguration</value>
<value type="int" key="Qt4ProjectManager.Qt4BuildConfiguration.BuildConfiguration">2</value>
<value type="QString" key="Qt4ProjectManager.Qt4BuildConfiguration.BuildDirectory">/home/andrea/devel/MuonTomography/mutom/uLib/trunk/src/Gui/Qt/QVTKViewport2</value>
<value type="int" key="Qt4ProjectManager.Qt4BuildConfiguration.QtVersionId">3</value>
<value type="bool" key="Qt4ProjectManager.Qt4BuildConfiguration.UseShadowBuild">false</value>
</valuemap>
<valuemap type="QVariantMap" key="ProjectExplorer.Target.BuildConfiguration.2">
<value type="QString" key="ProjectExplorer.BuildCOnfiguration.ToolChain">ProjectExplorer.ToolChain.Gcc:/usr/bin/g++.x86-linux-generic-elf-64bit.gdb</value>
<valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.0">
<valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.0">
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">qmake</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">QtProjectManager.QMakeBuildStep</value>
<value type="bool" key="QtProjectManager.QMakeBuildStep.LinkQmlDebuggingLibrary">false</value>
<value type="bool" key="QtProjectManager.QMakeBuildStep.LinkQmlDebuggingLibraryAuto">true</value>
<value type="QString" key="QtProjectManager.QMakeBuildStep.QMakeArguments"></value>
<value type="bool" key="QtProjectManager.QMakeBuildStep.QMakeForced">false</value>
</valuemap>
<valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.1">
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Make</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.MakeStep</value>
<value type="bool" key="Qt4ProjectManager.MakeStep.Clean">false</value>
<value type="QString" key="Qt4ProjectManager.MakeStep.MakeArguments"></value>
<value type="QString" key="Qt4ProjectManager.MakeStep.MakeCommand"></value>
</valuemap>
<value type="int" key="ProjectExplorer.BuildStepList.StepsCount">2</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Build</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.BuildSteps.Build</value>
</valuemap>
<valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.1">
<valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.0">
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Make</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.MakeStep</value>
<value type="bool" key="Qt4ProjectManager.MakeStep.Clean">true</value>
<value type="QString" key="Qt4ProjectManager.MakeStep.MakeArguments">clean</value>
<value type="QString" key="Qt4ProjectManager.MakeStep.MakeCommand"></value>
</valuemap>
<value type="int" key="ProjectExplorer.BuildStepList.StepsCount">1</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Clean</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.BuildSteps.Clean</value>
</valuemap>
<value type="int" key="ProjectExplorer.BuildConfiguration.BuildStepListCount">2</value>
<value type="bool" key="ProjectExplorer.BuildConfiguration.ClearSystemEnvironment">false</value>
<valuelist type="QVariantList" key="ProjectExplorer.BuildConfiguration.UserEnvironmentChanges"/>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Qt 4.7.0 in PATH (System) Release</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.Qt4BuildConfiguration</value>
<value type="int" key="Qt4ProjectManager.Qt4BuildConfiguration.BuildConfiguration">0</value>
<value type="QString" key="Qt4ProjectManager.Qt4BuildConfiguration.BuildDirectory">/home/andrea/devel/MuonTomography/mutom/uLib/trunk/src/Gui/Qt/QVTKViewport2</value>
<value type="int" key="Qt4ProjectManager.Qt4BuildConfiguration.QtVersionId">4</value>
<value type="bool" key="Qt4ProjectManager.Qt4BuildConfiguration.UseShadowBuild">false</value>
</valuemap>
<valuemap type="QVariantMap" key="ProjectExplorer.Target.BuildConfiguration.3">
<value type="QString" key="ProjectExplorer.BuildCOnfiguration.ToolChain">ProjectExplorer.ToolChain.Gcc:/usr/bin/g++.x86-linux-generic-elf-64bit.gdb</value>
<valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.0">
<valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.0">
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">qmake</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">QtProjectManager.QMakeBuildStep</value>
<value type="bool" key="QtProjectManager.QMakeBuildStep.LinkQmlDebuggingLibrary">false</value>
<value type="bool" key="QtProjectManager.QMakeBuildStep.LinkQmlDebuggingLibraryAuto">true</value>
<value type="QString" key="QtProjectManager.QMakeBuildStep.QMakeArguments"></value>
<value type="bool" key="QtProjectManager.QMakeBuildStep.QMakeForced">false</value>
</valuemap>
<valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.1">
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Make</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.MakeStep</value>
<value type="bool" key="Qt4ProjectManager.MakeStep.Clean">false</value>
<value type="QString" key="Qt4ProjectManager.MakeStep.MakeArguments"></value>
<value type="QString" key="Qt4ProjectManager.MakeStep.MakeCommand"></value>
</valuemap>
<value type="int" key="ProjectExplorer.BuildStepList.StepsCount">2</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Build</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.BuildSteps.Build</value>
</valuemap>
<valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.1">
<valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.0">
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Make</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.MakeStep</value>
<value type="bool" key="Qt4ProjectManager.MakeStep.Clean">true</value>
<value type="QString" key="Qt4ProjectManager.MakeStep.MakeArguments">clean</value>
<value type="QString" key="Qt4ProjectManager.MakeStep.MakeCommand"></value>
</valuemap>
<value type="int" key="ProjectExplorer.BuildStepList.StepsCount">1</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Clean</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.BuildSteps.Clean</value>
</valuemap>
<value type="int" key="ProjectExplorer.BuildConfiguration.BuildStepListCount">2</value>
<value type="bool" key="ProjectExplorer.BuildConfiguration.ClearSystemEnvironment">false</value>
<valuelist type="QVariantList" key="ProjectExplorer.BuildConfiguration.UserEnvironmentChanges"/>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Qt 4.7.0 in PATH (System) Debug</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.Qt4BuildConfiguration</value>
<value type="int" key="Qt4ProjectManager.Qt4BuildConfiguration.BuildConfiguration">2</value>
<value type="QString" key="Qt4ProjectManager.Qt4BuildConfiguration.BuildDirectory">/home/andrea/devel/MuonTomography/mutom/uLib/trunk/src/Gui/Qt/QVTKViewport2</value>
<value type="int" key="Qt4ProjectManager.Qt4BuildConfiguration.QtVersionId">4</value>
<value type="bool" key="Qt4ProjectManager.Qt4BuildConfiguration.UseShadowBuild">false</value>
</valuemap>
<valuemap type="QVariantMap" key="ProjectExplorer.Target.BuildConfiguration.4">
<value type="QString" key="ProjectExplorer.BuildCOnfiguration.ToolChain">ProjectExplorer.ToolChain.Gcc:/usr/bin/g++.x86-linux-generic-elf-64bit.gdb</value>
<valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.0">
<valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.0">
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">qmake</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">QtProjectManager.QMakeBuildStep</value>
<value type="bool" key="QtProjectManager.QMakeBuildStep.LinkQmlDebuggingLibrary">false</value>
<value type="bool" key="QtProjectManager.QMakeBuildStep.LinkQmlDebuggingLibraryAuto">true</value>
<value type="QString" key="QtProjectManager.QMakeBuildStep.QMakeArguments"></value>
<value type="bool" key="QtProjectManager.QMakeBuildStep.QMakeForced">false</value>
</valuemap>
<valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.1">
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Make</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.MakeStep</value>
<value type="bool" key="Qt4ProjectManager.MakeStep.Clean">false</value>
<value type="QString" key="Qt4ProjectManager.MakeStep.MakeArguments"></value>
<value type="QString" key="Qt4ProjectManager.MakeStep.MakeCommand"></value>
</valuemap>
<value type="int" key="ProjectExplorer.BuildStepList.StepsCount">2</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Build</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.BuildSteps.Build</value>
</valuemap>
<valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.1">
<valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.0">
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Make</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.MakeStep</value>
<value type="bool" key="Qt4ProjectManager.MakeStep.Clean">true</value>
<value type="QString" key="Qt4ProjectManager.MakeStep.MakeArguments">clean</value>
<value type="QString" key="Qt4ProjectManager.MakeStep.MakeCommand"></value>
</valuemap>
<value type="int" key="ProjectExplorer.BuildStepList.StepsCount">1</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Clean</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.BuildSteps.Clean</value>
</valuemap>
<value type="int" key="ProjectExplorer.BuildConfiguration.BuildStepListCount">2</value>
<value type="bool" key="ProjectExplorer.BuildConfiguration.ClearSystemEnvironment">false</value>
<valuelist type="QVariantList" key="ProjectExplorer.BuildConfiguration.UserEnvironmentChanges"/>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Qt 4.7.0 (System) Release</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.Qt4BuildConfiguration</value>
<value type="int" key="Qt4ProjectManager.Qt4BuildConfiguration.BuildConfiguration">0</value>
<value type="QString" key="Qt4ProjectManager.Qt4BuildConfiguration.BuildDirectory">/home/andrea/devel/MuonTomography/mutom/uLib/trunk/src/Gui/Qt/QVTKViewport2</value>
<value type="int" key="Qt4ProjectManager.Qt4BuildConfiguration.QtVersionId">5</value>
<value type="bool" key="Qt4ProjectManager.Qt4BuildConfiguration.UseShadowBuild">false</value>
</valuemap>
<valuemap type="QVariantMap" key="ProjectExplorer.Target.BuildConfiguration.5">
<value type="QString" key="ProjectExplorer.BuildCOnfiguration.ToolChain">ProjectExplorer.ToolChain.Gcc:/usr/bin/g++.x86-linux-generic-elf-64bit.gdb</value>
<valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.0">
<valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.0">
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">qmake</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">QtProjectManager.QMakeBuildStep</value>
<value type="bool" key="QtProjectManager.QMakeBuildStep.LinkQmlDebuggingLibrary">false</value>
<value type="bool" key="QtProjectManager.QMakeBuildStep.LinkQmlDebuggingLibraryAuto">true</value>
<value type="QString" key="QtProjectManager.QMakeBuildStep.QMakeArguments"></value>
<value type="bool" key="QtProjectManager.QMakeBuildStep.QMakeForced">false</value>
</valuemap>
<valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.1">
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Make</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.MakeStep</value>
<value type="bool" key="Qt4ProjectManager.MakeStep.Clean">false</value>
<value type="QString" key="Qt4ProjectManager.MakeStep.MakeArguments"></value>
<value type="QString" key="Qt4ProjectManager.MakeStep.MakeCommand"></value>
</valuemap>
<value type="int" key="ProjectExplorer.BuildStepList.StepsCount">2</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Build</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.BuildSteps.Build</value>
</valuemap>
<valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.1">
<valuemap type="QVariantMap" key="ProjectExplorer.BuildStepList.Step.0">
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Make</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.MakeStep</value>
<value type="bool" key="Qt4ProjectManager.MakeStep.Clean">true</value>
<value type="QString" key="Qt4ProjectManager.MakeStep.MakeArguments">clean</value>
<value type="QString" key="Qt4ProjectManager.MakeStep.MakeCommand"></value>
</valuemap>
<value type="int" key="ProjectExplorer.BuildStepList.StepsCount">1</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Clean</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.BuildSteps.Clean</value>
</valuemap>
<value type="int" key="ProjectExplorer.BuildConfiguration.BuildStepListCount">2</value>
<value type="bool" key="ProjectExplorer.BuildConfiguration.ClearSystemEnvironment">false</value>
<valuelist type="QVariantList" key="ProjectExplorer.BuildConfiguration.UserEnvironmentChanges"/>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Qt 4.7.0 (System) Debug</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.Qt4BuildConfiguration</value>
<value type="int" key="Qt4ProjectManager.Qt4BuildConfiguration.BuildConfiguration">2</value>
<value type="QString" key="Qt4ProjectManager.Qt4BuildConfiguration.BuildDirectory">/home/andrea/devel/MuonTomography/mutom/uLib/trunk/src/Gui/Qt/QVTKViewport2</value>
<value type="int" key="Qt4ProjectManager.Qt4BuildConfiguration.QtVersionId">5</value>
<value type="bool" key="Qt4ProjectManager.Qt4BuildConfiguration.UseShadowBuild">false</value>
</valuemap>
<value type="int" key="ProjectExplorer.Target.BuildConfigurationCount">6</value>
<valuemap type="QVariantMap" key="ProjectExplorer.Target.DeployConfiguration.0">
<valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.0">
<value type="int" key="ProjectExplorer.BuildStepList.StepsCount">0</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Deploy</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.BuildSteps.Deploy</value>
</valuemap>
<value type="int" key="ProjectExplorer.BuildConfiguration.BuildStepListCount">1</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">No deployment</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.DefaultDeployConfiguration</value>
</valuemap>
<value type="int" key="ProjectExplorer.Target.DeployConfigurationCount">1</value>
<valuemap type="QVariantMap" key="ProjectExplorer.Target.RunConfiguration.0">
<value type="bool" key="Analyzer.Project.UseGlobal">true</value>
<value type="bool" key="Analyzer.Project.UseGlobal">true</value>
<valuelist type="QVariantList" key="Analyzer.Valgrind.AddedSuppressionFiles"/>
<valuelist type="QVariantList" key="Analyzer.Valgrind.AddedSuppressionFiles"/>
<value type="bool" key="Analyzer.Valgrind.Callgrind.CollectBusEvents">false</value>
<value type="bool" key="Analyzer.Valgrind.Callgrind.CollectBusEvents">false</value>
<value type="bool" key="Analyzer.Valgrind.Callgrind.CollectSystime">false</value>
<value type="bool" key="Analyzer.Valgrind.Callgrind.CollectSystime">false</value>
<value type="bool" key="Analyzer.Valgrind.Callgrind.EnableBranchSim">false</value>
<value type="bool" key="Analyzer.Valgrind.Callgrind.EnableBranchSim">false</value>
<value type="bool" key="Analyzer.Valgrind.Callgrind.EnableCacheSim">false</value>
<value type="bool" key="Analyzer.Valgrind.Callgrind.EnableCacheSim">false</value>
<value type="bool" key="Analyzer.Valgrind.Callgrind.EnableEventToolTips">true</value>
<value type="bool" key="Analyzer.Valgrind.Callgrind.EnableEventToolTips">true</value>
<value type="double" key="Analyzer.Valgrind.Callgrind.MinimumCostRatio">0.01</value>
<value type="double" key="Analyzer.Valgrind.Callgrind.MinimumCostRatio">0.01</value>
<value type="double" key="Analyzer.Valgrind.Callgrind.VisualisationMinimumCostRatio">10</value>
<value type="double" key="Analyzer.Valgrind.Callgrind.VisualisationMinimumCostRatio">10</value>
<value type="bool" key="Analyzer.Valgrind.FilterExternalIssues">false</value>
<value type="bool" key="Analyzer.Valgrind.FilterExternalIssues">false</value>
<value type="int" key="Analyzer.Valgrind.NumCallers">25</value>
<value type="int" key="Analyzer.Valgrind.NumCallers">25</value>
<valuelist type="QVariantList" key="Analyzer.Valgrind.RemovedSuppressionFiles"/>
<valuelist type="QVariantList" key="Analyzer.Valgrind.RemovedSuppressionFiles"/>
<value type="bool" key="Analyzer.Valgrind.TrackOrigins">true</value>
<value type="bool" key="Analyzer.Valgrind.TrackOrigins">true</value>
<value type="QString" key="Analyzer.Valgrind.ValgrindExecutable">valgrind</value>
<value type="QString" key="Analyzer.Valgrind.ValgrindExecutable">valgrind</value>
<valuelist type="QVariantList" key="Analyzer.Valgrind.VisibleErrorKinds">
<value type="int">2</value>
<value type="int">3</value>
<value type="int">4</value>
<value type="int">5</value>
<value type="int">6</value>
<value type="int">7</value>
<value type="int">8</value>
<value type="int">9</value>
<value type="int">10</value>
</valuelist>
<valuelist type="QVariantList" key="Analyzer.Valgrind.VisibleErrorKinds">
<value type="int">2</value>
<value type="int">3</value>
<value type="int">4</value>
<value type="int">5</value>
<value type="int">6</value>
<value type="int">7</value>
<value type="int">8</value>
<value type="int">9</value>
<value type="int">10</value>
</valuelist>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">QVTKViewport2</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">Qt4ProjectManager.Qt4RunConfiguration</value>
<value type="int" key="Qt4ProjectManager.Qt4RunConfiguration.BaseEnvironmentBase">2</value>
<value type="QString" key="Qt4ProjectManager.Qt4RunConfiguration.CommandLineArguments"></value>
<value type="QString" key="Qt4ProjectManager.Qt4RunConfiguration.ProFile">QVTKViewport2.pro</value>
<value type="bool" key="Qt4ProjectManager.Qt4RunConfiguration.UseDyldImageSuffix">false</value>
<value type="bool" key="Qt4ProjectManager.Qt4RunConfiguration.UseTerminal">false</value>
<valuelist type="QVariantList" key="Qt4ProjectManager.Qt4RunConfiguration.UserEnvironmentChanges"/>
<value type="QString" key="Qt4ProjectManager.Qt4RunConfiguration.UserWorkingDirectory"></value>
<value type="uint" key="RunConfiguration.QmlDebugServerPort">3768</value>
<value type="bool" key="RunConfiguration.UseCppDebugger">true</value>
<value type="bool" key="RunConfiguration.UseQmlDebugger">false</value>
<value type="bool" key="RunConfiguration.UseQmlDebuggerAuto">false</value>
</valuemap>
<value type="int" key="ProjectExplorer.Target.RunConfigurationCount">1</value>
</valuemap>
</data>
<data>
<variable>ProjectExplorer.Project.TargetCount</variable>
<value type="int">1</value>
</data>
<data>
<variable>ProjectExplorer.Project.Updater.EnvironmentId</variable>
<value type="QString">{f8bb0047-7f6e-45df-9cc8-e746abebf883}</value>
</data>
<data>
<variable>ProjectExplorer.Project.Updater.FileVersion</variable>
<value type="int">10</value>
</data>
</qtcreator>

38
src/Gui/Qt/QVTKViewport2/main.cpp
View File

@@ -1,38 +0,0 @@
/*//////////////////////////////////////////////////////////////////////////////
// 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 <QtGui/QApplication>
#include "vtkviewport.h"
int main(int argc, char *argv[])
{
QApplication a(argc, argv);
VtkViewport w;
w.show();
return a.exec();
}

41
src/Gui/Qt/QVTKViewport2/vtkviewport.cpp
View File

@@ -1,41 +0,0 @@
/*//////////////////////////////////////////////////////////////////////////////
// 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 "vtkviewport.h"
#include "ui_vtkviewport.h"
VtkViewport::VtkViewport(QWidget *parent) :
QWidget(parent),
ui(new Ui::VtkViewport)
{
ui->setupUi(this);
}
VtkViewport::~VtkViewport()
{
delete ui;
}

49
src/Gui/Qt/QVTKViewport2/vtkviewport.h
View File

@@ -1,49 +0,0 @@
/*//////////////////////////////////////////////////////////////////////////////
// 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 VTKVIEWPORT_H
#define VTKVIEWPORT_H
#include <QWidget>
namespace Ui {
class VtkViewport;
}
class VtkViewport : public QWidget
{
Q_OBJECT
public:
explicit VtkViewport(QWidget *parent = 0);
~VtkViewport();
private:
Ui::VtkViewport *ui;
};
#endif // VTKVIEWPORT_H

32
src/Gui/Qt/QVTKViewport2/vtkviewport.ui
View File

@@ -1,32 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
<class>VtkViewport</class>
<widget class="QWidget" name="VtkViewport">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>580</width>
<height>536</height>
</rect>
</property>
<property name="windowTitle">
<string>Form</string>
</property>
<widget class="QLabel" name="label">
<property name="geometry">
<rect>
<x>140</x>
<y>170</y>
<width>161</width>
<height>41</height>
</rect>
</property>
<property name="text">
<string>Hello World !</string>
</property>
</widget>
</widget>
<resources/>
<connections/>
</ui>

12
src/ltk/CMakeLists.txt
View File

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

111
src/ltk/DenseMatrix.h
View File

@@ -1,111 +0,0 @@
/*//////////////////////////////////////////////////////////////////////////////
// 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

6
src/ltk/Makefile.am
View File

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

18
src/ltk/Object.c
View File

@@ -1,18 +0,0 @@
#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;
}

78
src/ltk/Object.h
View File

@@ -1,78 +0,0 @@
/*//////////////////////////////////////////////////////////////////////////////
// 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

195
src/ltk/Vector.h
View File

@@ -1,195 +0,0 @@
/*//////////////////////////////////////////////////////////////////////////////
// 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 */

43
src/ltk/container.h
View File

@@ -1,43 +0,0 @@
/*//////////////////////////////////////////////////////////////////////////////
// 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 */

32
src/ltk/ltk.h
View File

@@ -1,32 +0,0 @@
/*//////////////////////////////////////////////////////////////////////////////
// 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"

339
src/ltk/ltk_bridge/ltkb.c
View File

@@ -1,339 +0,0 @@
//#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"); //
//
/////////////////////////////////////////////////////////

40
src/ltk/ltk_bridge/ltkb_test.c
View File

@@ -1,40 +0,0 @@
#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);
}

21
src/ltk/ltk_bridge/setup.sh
View File

@@ -1,21 +0,0 @@
#!/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]

4
src/ltk/ltkdebug.c
View File

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

105
src/ltk/ltkdebug.h
View File

@@ -1,105 +0,0 @@
/*//////////////////////////////////////////////////////////////////////////////
// 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

61
src/ltk/ltkmacros.h
View File

@@ -1,61 +0,0 @@
/*//////////////////////////////////////////////////////////////////////////////
// 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 */

127
src/ltk/ltktypes.h
View File

@@ -1,127 +0,0 @@
/*//////////////////////////////////////////////////////////////////////////////
// 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

72
src/ltk/main.c
View File

@@ -1,72 +0,0 @@
#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;
}

92
src/ltk/templates.c
View File

@@ -1,92 +0,0 @@
#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;
}

303
src/ltk/templates.h
View File

@@ -1,303 +0,0 @@
/*//////////////////////////////////////////////////////////////////////////////
// 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

117
src/ltk/test_comma.h
View File

@@ -1,117 +0,0 @@
/*//////////////////////////////////////////////////////////////////////////////
// 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 */

37
src/ltk/testing/Makefile.am
View File

@@ -1,37 +0,0 @@
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

40
src/ltk/testing/Object-cc.cpp
View File

@@ -1,40 +0,0 @@
/*//////////////////////////////////////////////////////////////////////////////
// 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;
}

11
src/ltk/testing/Object.c
View File

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

79
src/ltk/testing/Vector-cc.cpp
View File

@@ -1,79 +0,0 @@
/*//////////////////////////////////////////////////////////////////////////////
// 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;
}

14
src/ltk/testing/Vector.c
View File

@@ -1,14 +0,0 @@
#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;
}

37
src/ltk/testing/testing-prototype.h
View File

@@ -1,37 +0,0 @@
/*//////////////////////////////////////////////////////////////////////////////
// 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;

24
src/utils/moc/Makefile
View File

@@ -1,24 +0,0 @@
# Makefile example -- scanner and parser.
#
CXX = g++ -D_DEBUG
LEX = flex
YACC = bison -y -t
YFLAGS = -d
objects = parse.o scan.o
moc: $(objects)
$(CXX) -o $@ $(objects) -lfl
parse.o: parse.y
# parse.h: parse.c
# mv -f y.tab.h parse.h
scan.o: scan.l
clean:
rm -f *.o parse.tab.c parse.tab.h

92
src/utils/moc/moc_actions.h
View File

@@ -1,92 +0,0 @@
/*//////////////////////////////////////////////////////////////////////////////
// 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 MOC_ACTION_H
#define MOC_ACTION_H
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#ifndef NDEBUG
#define DEBUG( ... ) { printf(" /*["); printf( __VA_ARGS__ ); printf("]*/ "); }
#else
#define DEBUG( ... ) ;
#endif
#define CONCAT( dest , ... ) string_append(dest, __VA_ARGS__, NULL)
char * string_append(char *first, ... ) {
va_list ap;
va_start (ap, first); /* Initialize the argument list. */
char *str_in = first;
char *str = malloc(sizeof(char) * strlen(str_in));
strcat(str,str_in);
str_in = va_arg (ap,char *);
while (str_in) {
char *tmp = malloc(sizeof(char) * (strlen(str)+strlen(str_in)) );
memcpy(tmp,str,strlen(str));
memcpy(tmp+strlen(str),str_in,strlen(str_in));
free(str);
str = tmp;
str_in = va_arg (ap,char *);
}
return str;
}
// ACTIONS //
#define SIMPLE_DECLARATION simple_declaration_action
static int simple_declaration_action(const char *type, const char *ids);
// move to implementation .. //
static int simple_declaration_action(const char *type, const char *ids) {
DEBUG("simple_declaration -> type:\"%s\" decl:\"%s\" ",type,ids);
return 0;
}
#endif // MOC_ACTION_H

1257
src/utils/moc/parse.y
View File

File diff suppressed because it is too large Load Diff

51
src/utils/moc/sample.cpp
View File

@@ -1,51 +0,0 @@
/*//////////////////////////////////////////////////////////////////////////////
// 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.
//////////////////////////////////////////////////////////////////////////////*/
typedef int TestInt;
class DerivedObject {
public:
ULIB_OBJECT_PARAMETERS(test)
{
Bubu *a;
};
};
int main() {
ULIB_OBJECT_PARAMETERS(prova) {
int a,b;
char *c;
};
return 0;
}

252
src/utils/moc/scan.l
View File

@@ -1,252 +0,0 @@
%option stack
%{
/* preamble */
#include <ctype.h>
#include <stdio.h>
#include "y.tab.h"
#define PRINT(str) { printf("%s",str); }
#define ENSTATE(st) { yy_push_state(YY_START); BEGIN(st); /*printf("ST[%i]",YY_START);*/ }
#define EXSTATE { BEGIN(yy_top_state()); yy_pop_state(); /*printf("ST[%i]",YY_START);*/ }
#define SCANTEXT { fill_sval(); }
#define MATCH(name) { ECHO; SCANTEXT; return name; }
int lineno;
int moc_level = 0;
static int yywrap(void);
static void skip_until_eol(void);
static void skip_comment(void);
static int check_identifier(const char *);
static int fill_sval();
%}
blank [\t\f\v\r ]+
anyunch <*>.
intsuffix ([uU][lL]?)|([lL][uU]?)
fracconst ([0-9]*\.[0-9]+)|([0-9]+\.)
exppart [eE][-+]?[0-9]+
floatsuffix [fFlL]
chartext ([^'])|(\\.)
stringtext ([^"])|(\\.)
digit [0-9]
hex [0-9A-Fa-f]
letter [A-Z_a-z]
simple_escape_sequence (\\\'|\\\"|\\\?|\\\\|\\a|\\b|\\f|\\n|\\r|\\t|\\v)
octal_escape_sequence (\\[0-7]|\\[0-7][0-7]|\\[0-7][0-7][0-7])
hexadecimal_escape_sequence (\\x{hex}+)
escape_sequence ({simple_escape_sequence}|{octal_escape_sequence}|{hexadecimal_escape_sequence})
universal_character_name (\\u{hex}{hex}{hex}{hex}|\\U{hex}{hex}{hex}{hex}{hex}{hex}{hex}{hex})
non_digit ({letter}|{universal_character_name})
identifier ({non_digit}({non_digit}|{digit})*)
begin_comment "/*"
end_comment "*/"
begin_inline_comment "//"
end_inline_comment "\n"
%s moc
%x cmt
%x inlcmt
%%
"\n" { ++lineno; ECHO; }
{blank} ECHO;
{begin_comment} { ENSTATE(cmt); ECHO; }
<cmt>{end_comment} { EXSTATE; ECHO; }
{begin_inline_comment} { ENSTATE(inlcmt); ECHO; }
<inlcmt>{end_inline_comment} { EXSTATE; ECHO; }
property { ECHO; ENSTATE(moc); return MOC_PROPERTY; }
ULIB_OBJECT_PARAMETERS { ECHO; ENSTATE(moc); return MOC_OBJECT_PARAMETERS; }
<moc>{
"{" { moc_level++; MATCH('{'); }
"}" { if(!--moc_level)EXSTATE; MATCH('}'); }
"<%" { MATCH('{'); }
"%>" { MATCH('}'); }
"[" { MATCH('['); }
"<:" { MATCH('['); }
"]" { MATCH(']'); }
":>" { MATCH(']'); }
"(" { MATCH('('); }
")" { MATCH(')'); }
";" { MATCH(';'); }
"::" { MATCH(COLONCOLON); }
":" { MATCH(':'); }
"..." { MATCH(ELLIPSIS); }
"?" { MATCH('?'); }
"." { MATCH('.'); }
".*" { MATCH(DOTSTAR); }
"+" { MATCH('+'); }
"-" { MATCH('-'); }
"*" { MATCH('*'); }
"/" { MATCH('/'); }
"%" { MATCH('%'); }
"^" { MATCH('^'); }
"xor" { MATCH('^'); }
"&" { MATCH('&'); }
"bitand" { MATCH('&'); }
"|" { MATCH('|'); }
"bitor" { MATCH('|'); }
"~" { MATCH('~'); }
"compl" { MATCH('~'); }
"!" { MATCH('!'); }
"not" { MATCH('!'); }
"=" { MATCH('='); }
"<" { MATCH('<'); }
">" { MATCH('>'); }
"+=" { MATCH(ADDEQ); }
"-=" { MATCH(SUBEQ); }
"*=" { MATCH(MULEQ); }
"/=" { MATCH(DIVEQ); }
"%=" { MATCH(MODEQ); }
"^=" { MATCH(XOREQ); }
"xor_eq" { MATCH(XOREQ); }
"&=" { MATCH(ANDEQ); }
"and_eq" { MATCH(ANDEQ); }
"|=" { MATCH(OREQ); }
"or_eq" { MATCH(OREQ); }
"<<" { MATCH(SL); }
">>" { MATCH(SR); }
"<<=" { MATCH(SLEQ); }
">>=" { MATCH(SREQ); }
"==" { MATCH(EQ); }
"!=" { MATCH(NOTEQ); }
"not_eq" { MATCH(NOTEQ); }
"<=" { MATCH(LTEQ); }
">=" { MATCH(GTEQ); }
"&&" { MATCH(ANDAND); }
"and" { MATCH(ANDAND); }
"||" { MATCH(OROR); }
"or" { MATCH(OROR); }
"++" { MATCH(PLUSPLUS); }
"--" { MATCH(MINUSMINUS); }
"," { MATCH(','); }
"->*" { MATCH(ARROWSTAR); }
"->" { MATCH(ARROW); }
"asm" { MATCH(ASM); }
"auto" { MATCH(AUTO); }
"bool" { MATCH(BOOL); }
"break" { MATCH(BREAK); }
"case" { MATCH(CASE); }
"catch" { MATCH(CATCH); }
"char" { MATCH(CHAR); }
"class" { MATCH(CLASS); }
"const" { MATCH(CONST); }
"const_cast" { MATCH(CONST_CAST); }
"continue" { MATCH(CONTINUE); }
"default" { MATCH(DEFAULT); }
"delete" { MATCH(DELETE); }
"do" { MATCH(DO); }
"double" { MATCH(DOUBLE); }
"dynamic_cast" { MATCH(DYNAMIC_CAST); }
"else" { MATCH(ELSE); }
"enum" { MATCH(ENUM); }
"explicit" { MATCH(EXPLICIT); }
"export" { MATCH(EXPORT); }
"extern" { MATCH(EXTERN); }
"false" { MATCH(FALSE); }
"float" { MATCH(FLOAT); }
"for" { MATCH(FOR); }
"friend" { MATCH(FRIEND); }
"goto" { MATCH(GOTO); }
"if" { MATCH(IF); }
"inline" { MATCH(INLINE); }
"int" { MATCH(INT); }
"long" { MATCH(LONG); }
"mutable" { MATCH(MUTABLE); }
"namespace" { MATCH(NAMESPACE); }
"new" { MATCH(NEW); }
"operator" { MATCH(OPERATOR); }
"private" { MATCH(PRIVATE); }
"protected" { MATCH(PROTECTED); }
"public" { MATCH(PUBLIC); }
"register" { MATCH(REGISTER); }
"reinterpret_cast" { MATCH(REINTERPRET_CAST); }
"return" { MATCH(RETURN); }
"short" { MATCH(SHORT); }
"signed" { MATCH(SIGNED); }
"sizeof" { MATCH(SIZEOF); }
"static" { MATCH(STATIC); }
"static_cast" { MATCH(STATIC_CAST); }
"struct" { MATCH(STRUCT); }
"switch" { MATCH(SWITCH); }
"template" { MATCH(TEMPLATE); }
"this" { MATCH(THIS); }
"throw" { MATCH(THROW); }
"true" { MATCH(TRUE); }
"try" { MATCH(TRY); }
"typedef" { MATCH(TYPEDEF); }
"typeid" { MATCH(TYPEID); }
"typename" { MATCH(TYPENAME); }
"union" { MATCH(UNION); }
"unsigned" { MATCH(UNSIGNED); }
"using" { MATCH(USING); }
"virtual" { MATCH(VIRTUAL); }
"void" { MATCH(VOID); }
"volatile" { MATCH(VOLATILE); }
"wchar_t" { MATCH(WCHAR_T); }
"while" { MATCH(WHILE); }
[a-zA-Z_][a-zA-Z_0-9]* { ECHO; return check_identifier(yytext); }
"0"[xX][0-9a-fA-F]+{intsuffix}? { ECHO; return INTEGER; }
"0"[0-7]+{intsuffix}? { ECHO; return INTEGER; }
[0-9]+{intsuffix}? { ECHO; return INTEGER; }
{fracconst}{exppart}?{floatsuffix}? { ECHO; return FLOATING; }
[0-9]+{exppart}{floatsuffix}? { ECHO; return FLOATING; }
"'"{chartext}*"'" { ECHO; return CHARACTER; }
"L'"{chartext}*"'" { ECHO; return CHARACTER; }
"\""{stringtext}*"\"" { ECHO; return STRING; }
"L\""{stringtext}*"\"" { ECHO; return STRING; }
}
%%
static int yywrap(void)
{
return 1;
}
static int fill_sval() {
int len = strlen(yytext);
if(len) {
yylval.sval = malloc(len);
strncpy(yylval.sval, yytext, len);
}
else {
yylval.sval = strdup("");
}
return len;
}
static int check_identifier(const char *s)
{
/*
switch (s[0]) {
case 'D': return TYPEDEF_NAME;
case 'N': return NAMESPACE_NAME;
case 'C': return CLASS_NAME;
case 'E': return ENUM_NAME;
case 'T': return TEMPLATE_NAME;
}
*/
yylval.sval = malloc(strlen(yytext));
strncpy(yylval.sval, yytext, strlen(yytext));
return IDENTIFIER;
}