Published digup 0.6.23 - A Digest Updating Tool
Posted on 2009-11-10 22:30 by Timo at Permlink with Comments. Tags: c++
Published a small, but very useful console tool to update md5sum or shasum digest files. It will read existing md5sum.txt files and add new files to it without rereading the whole directory tree.
This makes digup very useful to update and verify incremental archives like chronological data storages or music collections, which are nowadays commonly stored and backuped on hard disks. Using a full file digest scan even slowly creeping bad blocks on old hard disks can be detected. By using a crontab entry, this check can be performed unattended and routinely.
For more information, the source code and binaries for various platforms see the digup web page.
Published Flex Bison C++ Example 0.1.4
Posted on 2009-09-05 10:40 by Timo at Permlink with Comments. Tags: flex-bison-cpp-example c++ code-example
Released a minor updated source code version for Flex Bison C++ Example. The example source code is released into the public domain or, at your option, under the Do What The Fuck You Want To Public License (WTFPL).
This minor bugfix release fixes up two simple compilation issues with the newest bison version 2.4.1.
For more information and the download package see the Flex Bison C++ Example web page.
Published CryptoTE 0.5.390
Posted on 2009-08-08 11:25 by Timo at Permlink with Comments. Tags: cryptote c++ cryptography
After almost one year of personally testing the program, I decided to publicly released the first version of CryptoTE v0.5.390. One year in the making, CryptoTE is a very useful little text-editor with integrated cryptography. The name stands for CRYPTOgraphy Text Editor and it transparently encrypts text files storing them into secure containers. The program incorporates the popular editing component Scintilla and makes heavy use of wxWidgets.
For more information, the source code and binaries for various platforms see the CryptoTE web page.
Published Flex Bison C++ Example 0.1.3
Posted on 2008-10-23 11:25 by Timo at Permlink with Comments. Tags: flex-bison-cpp-example c++ code-example
Released yet another updated source code package for Flex Bison C++ Example. The example source code is released into the public domain or, at your option, under the Do What The Fuck You Want To Public License (WTFPL).
This bugfix release solves a subtle, severe bug, which rendered the template code useless. Even the example exprtext program segfaulted with any expression.
Corrected a very subtle bug with the newly introduced virtual yywrap() function in the FlexLexer class. Depending on how the header was included, the class contained the virtual yywrap() function or not. These differing class declarations lead to very strange NULL pointer exceptions, because the different compiled objects assume different class memory layouts. Ultimately the exprtest program always segfaulted.
For more information and the download package see the Flex Bison C++ Example web page.
Update Release of STX B+ Tree 0.8.3
Posted on 2008-09-07 18:31 by Timo at Permlink with Comments. Tags: c++ stx-btree
Released another updated version 0.8.3 of the STX B+ Tree C++ Template Classes package. The updated release fixes up issues with the root node == NULL when the tree is initially empty.
Fixed crash when running verify() on an empty btree object. Now the root node is freed when the last item is removed. Also fixed crash when attempting to copy an empty btree or when trying to remove a non-existing item from an empty btree.
Also enhancing the speedtest to test the hash table container implementation from __gnu_cxx. Extending tests by another set of runs measuring only the find/lookup functions. See the speed results web page for more information.
The updated source code package is available for download from this webpage.
Some compiled binaries of wxBTreeDemo for Win32 and Linux are available on the demo download page.
As before, the updated main B+ tree implementation can be found in doxygen stx/btree.h or with plain text comments stx/btree.h.
C++ Code Snippet - Print Stack Backtrace Programmatically with Demangled Function Names
Posted on 2008-09-01 22:30 by Timo at Permlink with Comments. Tags: c++ code-snippet
Yesterday I was tasked to analyzed an inner function of a reasonably complex software package. The inner function was called thousands of times from many different parts of the program, a simple counter print-out showed that. However I was interested in which execution paths reach this inner function and how often the different parts access the function.
My straight-forward idea was to dump a stack backtrace each time the inner function is called, similar to the one printed by a debugger. However I needed some code snippet to dump the stack backtrace programmatically, without using gdb to halt the program each time.
Stack backtraces can be saved with backtrace(3), resolved into symbolic names using backtrace_symbols(3) and printed using backtrace_symbols_fd(3). These functions are well documented and fairly easy to use.
However I was debugging a C++ program, which made heavy use of templates and classes. C++ symbols names (including namespace, class and parameters) are mangled by the compiler into plain text symbols: e.g. the function N::A<int>::B::func(int) becomes the symbol _ZN1N1AIiE1B4funcEi. This makes the standard backtrace output very unreadable for C++ programs.
To demangle these strings the GNU libstdc++ library (integrated into the GNU Compiler Collection) provides a function called __cxa_demangle(). Combined with backtrace(3) a pretty stack backtrace can be outputted. The demangling function only works for programs compiled with g++.
The following header file contains a function print_stacktrace(), which uses backtrace(3), backtrace_symbols(3) and __cxa_demangle() to print a readable C++ stack backtrace.
Update Release of STX B+ Tree 0.8.2
Posted on 2008-08-13 16:48 by Timo at Permlink with Comments. Tags: c++ stx-btree
Released an updated version 0.8.2 of the STX B+ Tree C++ Template Classes package. The updated release fixes up all issues with iterators and one harmless bad-memory access.
The reverse_iterator classes of the B+ tree were completely reworked. Now they are real implementations and do not use STL magic. Both reverse_iterator and const_reverse_iterator should work as expected now. Added two large test cases for iterators. Enabled public default-constructors on iterators.
Also fixed a memory access bug which happens in erase_one_descend(): leaf->slotkey[leaf->slotuse - 1] if leaf-slotuse == 0. This doesn't have any other bad effect, because the case only occurs when leaf == root and then the resulting btree_update_lastkey message is never really processed. However it still is a bad-memory access.
The updated source code package including the wxBTreeDemo source is available for download from this webpage.
Some compiled binaries of wxBTreeDemo for Win32 and Linux are available on the demo download page.
As before, the updated main B+ tree implementation can be found in doxygen stx/btree.h or with plain text comments stx/btree.h.
Published Flex Bison C++ Example 0.1.2
Posted on 2008-08-03 14:26 by Timo at Permlink with Comments. Tags: flex-bison-cpp-example c++ code-example
Released an updated source code package for Flex Bison C++ Example. The example source code is released into the public domain or, at your option, under the Do What The Fuck You Want To Public License (WTFPL).
This bugfix release solves two problems there were reported to me via e-mail:
The first problem were compilation errors that occured when no %union directive is used in the grammar: in this case the include headers order is changed around by bison and thereby breaks compilation. This was fixed by never including parser.h directly, but always using scanner.h.
And the second issue was raised because new versions of flex were released after years of stagnation. The new flex version 2.5.35 adds a virtual function yywrap() to the yyFlexLexer class. This function is automatically defined in any lexer source file generated by flex. However because I copied FlexLexer.h from an older flex distribution, the function definition throughs a "no yywrap() member function" compiler error. Updating the FlexLexer.h with a conditional declaration of yywrap() hopefully did the trick and now works on all versions. Usually this file should be taken from /usr/include and not from the package. However that will break compilation if flex is not installed, and a self-sufficient compilation package was a primary goal of the example.
For more information and the download package see the Flex Bison C++ Example web page.
Bugfix Release of STX B+ Tree 0.8.1
Posted on 2008-01-25 15:48 by Timo at Permlink with Comments. Tags: c++ stx-btree
Released a bugfix version 0.8.1 of the STX B+ Tree C++ Template Classes package. The bug fixed is a possibly illegal memory access during find() function.
I received a new test case via email in which valgrind detected an uninitialized memory access. By tracing it, I soon found that it happens during any find(key) call with a key that is larger than any item contained in the tree. During the find() function find_lower() is called on a leaf node and returns the slot number with the smallest or equal key. However if the queried key is larger than all keys in a leaf node or in the whole tree, find_lower() returns a slot number past the last valid key slot. Comparison of this invalid slot with the queried key then yields an uninitialized memory error in valgrind.
The updated source code package including the wxBTreeDemo source is available for download from this webpage.
Some compiled binaries of wxBTreeDemo for Win32 and Linux are available on the demo download page.
As before, the updated main B+ tree implementation can be found in doxygen stx/btree.h or with plain text comments stx/btree.h.
Published Flex Bison C++ Example 0.1
Posted on 2007-08-20 11:53 by Timo at Permlink with Comments. Tags: flex-bison-cpp-example c++ code-example
Released example source code package Flex Bison C++ Example. The example source code is released into the public domain or, at your option, under the Do What The Fuck You Want To Public License (WTFPL).
This example shows how to use both Flex and Bison in C++ mode. This way both lexer and parser code and data is encapsulated into classes. Thus the lexer and parser are fully re-entrant, because all state variables are contained in the class objects. Furthermore multiple different lexer-parser pairs can easily be linked into one binary, because they have different class names and/or are located in a different namespace.
Why Use These Old Tools? Well, they are here to stay and they work well. But most important, the code generated by Flex and Bison requires no compile-time dependencies, because they generate fully autonomous source code. So far I have not found any modern parser generator which outputs independent code. It is even possible to compile the generated source on Windows with Visual C++ 2005.
For more information and the download package see the Flex Bison C++ Example web page.
Published STX Expression Parser Framework Version 0.7
Posted on 2007-07-17 17:10 by Timo at Permlink with Comments. Tags: c++ stx-exparser c++
Released the first version 0.7 of the STX Expression Parser C++ Framework package. The library is licensed under the GNU Lesser General Public License (LGPL) (2.1 or later).
The STX Expression Parser provides a C++ framework, which can process user-specified expression strings containing program-specific variables. It can be integrated into applications to allow user-customized data selection and filtering. The expresssion strings are intuitive SQL-like WHERE-clauses and can contain arbitrarily complex arithmetic. At the same time the expression processing time is guaranteed to be fast enough to safely iterate over larger data sets.
The expression parser can process arbitrarily complex arithmetic expressions like those seen below. To access application-defined data, functions and variables may be included in the expression. An expression can be used as a boolean filter by using comparison and logic operators.
6 + 3 * 12(a - 28) * (int)(e + 0.4 * 2.5 / (PI() - EXP(-0.644) * 4))6 * 9 == 42a >= 5 OR (42 <= field2 AND field2 <= 48) || NOT(got == "yes")
For more information see the STX Expression Parser web page.
Most impressive are the interactive online CGI parser demo and the online CSV file filter.
C++ Code Snippet - In-Place and String-Copy Uppercase/Lowercase Conversion of STL Strings
Posted on 2007-06-02 13:22 by Timo at Permlink with Comments. Tags: c++ code-snippet
This post completes the small C++ function collection of simple STL string manipulations. The following code snippet shows simple locale-unware uppercase and lowercase conversion functions using tolower and toupper. Nothing revolutionary; I'm just misusing this weblog as a code-paste dump for reuseable code.
Sometimes it is better to have a case-insensitive string class. More about ci_string can be found at Guru of the Week (GotW) #29: Case-Insensitive Strings.
#include <cctype>
// functionals for std::transform with correct signature
static inline char string_toupper_functional(char c)
{
return std::toupper(c);
}
static inline char string_tolower_functional(char c)
{
return std::tolower(c);
}
static inline void string_upper_inplace(std::string &str)
{
std::transform(str.begin(), str.end(), str.begin(), string_toupper_functional);
}
static inline void string_lower_inplace(std::string &str)
{
std::transform(str.begin(), str.end(), str.begin(), string_tolower_functional);
}
static inline std::string string_upper(const std::string &str)
{
std::string strcopy(str.size(), 0);
std::transform(str.begin(), str.end(), strcopy.begin(), string_toupper_functional);
return strcopy;
}
static inline std::string string_lower(const std::string &str)
{
std::string strcopy(str.size(), 0);
std::transform(str.begin(), str.end(), strcopy.begin(), string_tolower_functional);
return strcopy;
}
C++ Code Snippet - In-Place and String-Copy Space Trimming of STL Strings
Posted on 2007-05-30 17:28 by Timo at Permlink with Comments. Tags: c++ code-snippet
Yesterday I once again stumbled upon whitespace trimming of STL strings: a check was required if the given user input is empty. Where "empty" also means some user-given string containing only spaces. After one hour of unproductive searching for something as simple as a space trimming function, I decided to put the resulting code here for future reference.
The following code snippet contains two versions of the function: in-place trimming and string-copy trimming. I prefer the copy-trimming function because they allow a more functional programming style. The functions only trim spaces, but can be modified by replacing each ' ' with something like " \n\r\t".
static inline void string_trim_left_inplace(std::string &str)
{
str.erase(0, str.find_first_not_of(' '));
}
static inline void string_trim_right_inplace(std::string &str)
{
str.erase(str.find_last_not_of(' ') + 1, std::string::npos);
}
static inline std::string string_trim_left(const std::string &str)
{
std::string::size_type pos = str.find_first_not_of(' ');
if (pos == std::string::npos) return std::string();
return str.substr(pos, std::string::npos);
}
static inline std::string string_trim_right(const std::string &str)
{
std::string::size_type pos = str.find_last_not_of(' ');
if (pos == std::string::npos) return std::string();
return str.substr(0, pos + 1);
}
static inline std::string string_trim(const std::string& str)
{
std::string::size_type pos1 = str.find_first_not_of(' ');
if (pos1 == std::string::npos) return std::string();
std::string::size_type pos2 = str.find_last_not_of(' ');
if (pos2 == std::string::npos) return std::string();
return str.substr(pos1 == std::string::npos ? 0 : pos1,
pos2 == std::string::npos ? (str.length() - 1) : (pos2 - pos1 + 1));
}
static inline void string_trim_inplace(std::string& str)
{
std::string::size_type pos = str.find_last_not_of(' ');
if(pos != std::string::npos) {
str.erase(pos + 1);
pos = str.find_first_not_of(' ');
if(pos != std::string::npos) str.erase(0, pos);
}
else
str.erase(str.begin(), str.end());
}
Updated STX B+ Tree to 0.8 which now includes wxBTreeDemo
Posted on 2007-05-13 19:48 by Timo at Permlink with Comments. Tags: c++ stx-btree
Released an updated version 0.8 of the STX B+ Tree C++ Template Classes package. The update fixes a few segmentation faults with empty trees without root node.
This new release includes the demonstration program wxBTreeDemo. This program draws illustrations of the B+ trees constructed by the STX B+ Tree template classes. It allows the user to selected different types of B+ tree instantiations: integer or string keys and different slot numbers. The user may insert and erase key/data pairs from the tree and run different search operations. The demo program uses the cross-platform wxWidgets toolkit and can be compiled on Linux, Windows and MacOSX.
The source code package including the wxBTreeDemo source is available for download from this webpage.
Some compiled binaries of wxBTreeDemo for Win32 and Linux are available on the demo download page.
As before, the only slightly changed main B+ tree implementation can be found in doxygen stx/btree.h or with plain text comments stx/btree.h.
lcov: A Good HTML Generator for gcov Results
Posted on 2007-05-08 11:08 by Timo at Permlink with Comments. Tags: c++ linux
Writing test cases is a good way to prevent and detect problems or bugs in source code. They improve understanding of the difficult parts by requiring deeper thought into how to test of those areas. By rerunning the same test sequences one can assure that the code still produces the same results even after making significant changes. cppunit provides a C++ test framework which is sort of over-bloated. However reduced to a set of reusable template files the framework gets quite handy.
To measure how much of the code is tested, gcov provides a way to determine which lines are executed during a test suite run. Note that this simple line-is-touched metric is only one aspect of how well a piece of code is tested. However gcov's results are printed in text mode and it cannot merge the results from multiple coverage files, so multi-file test suites cannot be measured as a whole.
Yesterday I finally found a good open-source Linux tool to get correct coverage results: lcov. It was designed to measure coverage in the Linux kernel, but works very well on user-space programs as well. lcov builds on gcov's data files and generates HTML report files. It even highlights the untested source code lines.
I uploaded the test coverage results of the STX B+ Tree test suite. It shows 89.2% coverage of the main, most difficult header file implementing the insert and erase algorithms.
Published STX B+ Tree C++ Template Classes Version 0.7
Posted on 2007-04-27 15:02 by Timo at Permlink with Comments. Tags: stx-btree c++
Released the first version 0.7 of the STX B+ Tree C++ Template Classes package. The template classes are licensed under the LGPL.
The STX B+ Tree package is a set of C++ template classes implementing a B+ tree key/data container in main memory. The classes are designed as drop-in replacements of the STL containers set, map, multiset and multimap and follow their interfaces very closely. By packing multiple value pairs into each node of the tree the B+ tree reduces heap fragmentation and utilizes cache-line effects better than the standard red-black binary tree. The tree algorithms are based on the implementation in Cormen, Leiserson and Rivest's Introduction into Algorithms, Jan Jannink's paper and other algorithm resources. The classes contain extensive assertion and verification mechanisms to ensure the implementation's correctness by testing the tree invariants.
The main B+ tree implementation can be found in doxygen stx/btree.h or with plain text comments stx/btree.h.
The source code package is available for download from this webpage.
The classes are documented extensively using doxygen. The generated HTML documentation can be browsed online or downloaded.
Special interest was put into performing a speed comparison test between the standard red-black tree and the new B+ tree implementation. The speed test results are interesting and show the B+ tree to be significantly faster for trees containing more than 16,000 items.
C++ Code Snippet - Compressing STL Strings with zlib
Posted on 2007-03-28 18:23 by Timo at Permlink with Comments. Tags: c++ code-snippet
The zlib library can be found on virtually every computer. It is THE general-purpose lossless patent-free compression library.
This small C++ code snippet features a pair of functions which use this ubiquitous library to compress ordinary STL strings. There are many uses for this code snippet, like compressing string data stored in a database or binary data transfered over a network. Keep in mind that the compressed string data is binary, so the string's c_str() representation must be avoided.
#include <stdexcept>
#include <iostream>
#include <iomanip>
#include <sstream>
#include <zlib.h>
/** Compress a STL string using zlib with given compression level and return
* the binary data. */
std::string compress_string(const std::string& str,
int compressionlevel = Z_BEST_COMPRESSION)
{
z_stream zs; // z_stream is zlib's control structure
memset(&zs, 0, sizeof(zs));
if (deflateInit(&zs, compressionlevel) != Z_OK)
throw(std::runtime_error("deflateInit failed while compressing."));
zs.next_in = (Bytef*)str.data();
zs.avail_in = str.size(); // set the z_stream's input
int ret;
char outbuffer[32768];
std::string outstring;
// retrieve the compressed bytes blockwise
do {
zs.next_out = reinterpret_cast<Bytef*>(outbuffer);
zs.avail_out = sizeof(outbuffer);
ret = deflate(&zs, Z_FINISH);
if (outstring.size() < zs.total_out) {
// append the block to the output string
outstring.append(outbuffer,
zs.total_out - outstring.size());
}
} while (ret == Z_OK);
deflateEnd(&zs);
if (ret != Z_STREAM_END) { // an error occurred that was not EOF
std::ostringstream oss;
oss << "Exception during zlib compression: (" << ret << ") " << zs.msg;
throw(std::runtime_error(oss.str()));
}
return outstring;
}
/** Decompress an STL string using zlib and return the original data. */
std::string decompress_string(const std::string& str)
{
z_stream zs; // z_stream is zlib's control structure
memset(&zs, 0, sizeof(zs));
if (inflateInit(&zs) != Z_OK)
throw(std::runtime_error("inflateInit failed while decompressing."));
zs.next_in = (Bytef*)str.data();
zs.avail_in = str.size();
int ret;
char outbuffer[32768];
std::string outstring;
// get the decompressed bytes blockwise using repeated calls to inflate
do {
zs.next_out = reinterpret_cast<Bytef*>(outbuffer);
zs.avail_out = sizeof(outbuffer);
ret = inflate(&zs, 0);
if (outstring.size() < zs.total_out) {
outstring.append(outbuffer,
zs.total_out - outstring.size());
}
} while (ret == Z_OK);
inflateEnd(&zs);
if (ret != Z_STREAM_END) { // an error occurred that was not EOF
std::ostringstream oss;
oss << "Exception during zlib decompression: (" << ret << ") "
<< zs.msg;
throw(std::runtime_error(oss.str()));
}
return outstring;
}
/** Small dumb tool (de)compressing cin to cout. It holds all input in memory,
* so don't use it for huge files. */
int main(int argc, char* argv[])
{
std::string allinput;
while (std::cin.good()) // read all input from cin
{
char inbuffer[32768];
std::cin.read(inbuffer, sizeof(inbuffer));
allinput.append(inbuffer, std::cin.gcount());
}
if (argc >= 2 && strcmp(argv[1], "-d") == 0)
{
std::string cstr = decompress_string( allinput );
std::cerr << "Inflated data: "
<< allinput.size() << " -> " << cstr.size()
<< " (" << std::setprecision(1) << std::fixed
<< ( ((float)cstr.size() / (float)allinput.size() - 1.0) * 100.0 )
<< "% increase).\n";
std::cout << cstr;
}
else
{
std::string cstr = compress_string( allinput );
std::cerr << "Deflated data: "
<< allinput.size() << " -> " << cstr.size()
<< " (" << std::setprecision(1) << std::fixed
<< ( (1.0 - (float)cstr.size() / (float)allinput.size()) * 100.0)
<< "% saved).\n";
std::cout << cstr;
}
}
C++ Code Snippet - Using the Boost.Regex Library
Posted on 2007-03-14 14:43 by Timo at Permlink with Comments. Tags: c++ code-snippet
The Boost library is a collection of very useful C++ (template) libraries. However it's documentation is very complex and using the library straight-forward usually results in g++ scrolling endless pages of template instantiation errors.
This code snippet shows by example how to use the Boost.Regex library. It compiles and executes regular expressions on strings. Some test I ran showed that it is not as fast as pcre, however Boost.Regex it is easier and more elegant to use in C++ programs. The program must be linked with -lboost_regex.
#include <stdlib.h>
#include <boost/regex.hpp>
#include <boost/lexical_cast.hpp>
int main()
{
// This regex is compiled at start-up and matches YYYY-MM-DD dates. If it
// contains a syntax error, the program aborts at start-up with an
// exception.
static const boost::regex
date_regex("(199[0-9]|200[0-9])-([1-9]|0[1-9]|1[012])-([1-9]|[0-2][1-9]|3[01])");
// First example: char* c-style input strings use boost::cmatch results.
{
const char *input_cstr = "2007-03-14";
boost::cmatch char_matches;
if (boost::regex_match(input_cstr, char_matches, date_regex))
{
// Convert the parsed number using boost's lexical_cast library
int year = boost::lexical_cast<int>( char_matches[1] );
// Or use the old way: get the std::string object, then it's char*
int month = atoi( char_matches[2].str().c_str() );
std::cout << "First example:"
<< " year " << year
<< " month " << month
<< " day " << char_matches[3] << "\n";
}
else
{
std::cout << "First example should have matched the regex.\n";
}
}
// Second example: STL strings use boost::smatch results.
{
std::string input_stlstr = "2007-03-34";
boost::smatch str_matches;
if (boost::regex_match(input_stlstr, str_matches, date_regex))
{
std::cout << "Second example shouldn't have matched the regex.\n";
}
else
{
std::cout << "Second example didn't match the regex. This was intended.\n";
}
}
// Third example: Temporary regex object and no capture results needed.
{
if (boost::regex_match("2007", boost::regex("(199[0-9]|200[0-9])")))
{
std::cout << "Third example matched the temporary regex object.\n";
}
else
{
std::cout << "Third example should have matched the regex.\n";
}
}
// Fourth example: regex_match matches the whole string while regex_search
// matches substrings just like perl.
{
std::string input = "Today is 2007-03-14, how are you?";
if (boost::regex_match(input, date_regex))
{
std::cout << "Fourth example (regex_match) shouldn't match.\n";
}
else
{
std::cout << "As expected, the fourth example (regex_match) didn't match.\n";
}
if (boost::regex_search(input, date_regex))
{
std::cout << "While the fourth example using regex_search did matched.\n";
}
else
{
std::cout << "Fourth example using regex_search should have matched the regex.\n";
}
}
}
C++ Code Snippet - Making a Custom Class ostream Outputable
Posted on 2007-03-01 14:47 by Timo at Permlink with Comments. Tags: c++ code-snippet
How to get a custom class to work with std::cout << obj; ? I for my part always forget the exact prototype of the required operator<<. Here is an minimal working example to copy code from:
struct myclass
{
int a, b;
myclass(int _a, int _b)
: a(_a), b(_b)
{ }
};
// make myclass ostream outputtable
std::ostream& operator<< (std::ostream &stream, const myclass &obj)
{
return stream << "(" << obj.a << "," << obj.b << ")";
}
int main()
{
myclass obj(42, 46);
std::cout << obj << std::endl;
}
QtSqlView 0.8.0 Released
Posted on 2006-10-10 12:56 by Timo at Permlink with Comments. Tags: qtsqlview c++
Released the first version 0.8.0 of QtSqlView under the GPL.
QtSqlView is a simple and easy to use SQL database browser written in Qt 4.x using the excellent QtSql components. Using QtSql drivers it can natively connect to MySQL, PostgreSQL and SQLite databases. Furthermore other database systems may be accessed using their ODBC drivers. QtSqlView is released under the GNU General Public License: source code and win32 binary may be downloaded here.
This short program was initially written for a set of windows users, who need to access and edit a PostgreSQL database. All this is possible with M$ Access and ODBC, but the configuration of PostgreSQL's ODBC driver and the ODBC DSN is far too complicated for the average database editor. Thus problem-free access of open-source databases was top priority for QtSqlView.
QtSqlView boasts the following features:
- Problem-free connecting to MySQL, PostgreSQL and SQLite databases on Windows.
- Add, delete and modify a list of database connections.
- Browse, edit, save and revert SQL tables, system tables and views of registered connections
- Copy selected cells as tab-separated text to the clipboard.
- View table schema including primary key.
- Execute custom SQL queries on the database connect and view results.
- SQL syntax highlighting in query editor.
- Uses Qt4's greatly improved SQL components.
You may download the source code for Linux/OSX or a setup package for Windows.
More screenshots are available as well.
SDIOS06 - Source Code and Ready-To-Run Image
Posted on 2006-09-14 09:26 by Timo at Permlink with Comments. Tags: sdios06 university c++
As promised the source code to SDIOS06 was released under the GPL.
SDIOS06 is a toy operating system developed during the practical course SDI (System Design and Implementation) at the Systems Architecture Group of the University of Karlsruhe. It was designed and written by Timo Bingmann, Matthias Braun, Torsten Geiger and Andreas Mähler. Two games were ported to a custom SDL implementation using the VMware "hard"-ware: SDLjump and SuperTux. For more information and screenshots see my blog entry 20060727-SDI-Demo.
The source code archive was published on the L4Ka.org page: http://www.l4ka.org/projects/SDIOS06/
A local copy of the source archive (7.4 MB) is available as well. The README file contains a great deal of information about SDIOS06's design and modules. The complete source code can be browsed on the web.
To make demonstration as easy as possible a ready-to-run binary vmware image (3.8 MB) can be downloaded. The image contains SDIOS06 installed on a virtual vmware disk image. The VMware image can be run using the free VMware Player.
sdlfractal 0.1
Posted on 2006-08-09 21:33 by Timo at Permlink with Comments. Tags: sdlfractal c++
Sdlfractal is a port of a simple little fractal generator which I wrote some five years ago. It is not supposed to replace wonderful tools like xfractint so it is very simple and not very fast. The main goal of this project was to learn SDL and it turned out that fltk was also required. The main construction is an SDL surface extended by a canvas class which simulates a high-resolution coordinate system. On this coordinate system the fractals can be drawn.
To control fractal parameters the generator displays a second window using the fltk engine. From this dialog the currently displayed fractal and it's parameters can be changed. This requires a dual engine event loop in the program.
By dragging the mouse on the drawing canvas you can zoom into all fractals. If fractal drawing takes too long (and nothing is shown), then just click the canvas and the generator will stop.
The fractal generator can also save high-resolution PNG files. The following images are some examples created by the fractal generator.
The source code to sdlfractal 0.1 can be downloaded in a tar.bz2 archive (121 KB). It is also browsable on the web.
Sdlfractal was designed to the portable to Win32 using SDL and fltk compiled with MinGW. A compiled version which should run out of the box on most windows. Download the zip archive (267 KB) containing the executable.
MD5sums of the source and binary archives:
538da60a5ef2d427fbb901d6080e631e sdlfractal-0.1.tar.bz2
5bab1ccb93e170f5c42d995a6761ca7a sdlfractal-0.1-win32.zip
 | This section of the mandelbrot fractal is so beautiful that it is my current wallpaper. It can be downloaded at 800x600 (242 KB), 1024x768 (372 KB) or 1280x960 (552 KB). |
Studienarbeit "Visualisierung sehr großer Graphen" fertiggestellt
Posted on 2006-06-20 17:31 by Timo at Permlink with Comments. Tags: compsci study thesis university c++
Heute habe ich meine Studienarbeit "Visualisierung sehr großer Graphen" am Institut für Theoretische Informatik fertig gestellt und abgegeben. Die Studienarbeit ist eine 3-4 monatige wissenschaftliche Arbeit und dient als Vorbereitung auf die Diplomarbeit.
Die Studienarbeit kann zum Durchlesen als PDF (2,4 MB) herunter geladen werden. Auf diesen Abschnitt folgenden die deutsche und englische Zusammenfassung der Arbeit. Weiter gibt es eine Version zum Ausdrucken (PDF 15,3 MB) mit einer hochauflösenden Vektorgraphik im Anhang.
Zusammenfassung
In dieser Studienarbeit wird untersucht, mit welchen Methoden sehr große Graphen wie ein Straßennetzwerk von Europa effizient und komfortabel visualisiert werden können. Als Ausarbeitung entsteht ein C++ Rahmenwerk für die Datenhaltung eines Graphen mit Attributen und ein Java Applet, das mit dem Datenhaltungs-Server mittels CORBA kommuniziert. Das Rahmenwerk kann leicht in bestehende Graphanwendungen integriert werden, um deren Algorithmen zu animieren.
Als Basis-Graphstruktur wird ein Adjazenz-Array verwendet und um Strukturen erweitert, die zu jedem Knoten und jeder Kante beliebig viele Attributwerte speichern. Zwei der Knotenattribute werden als Zeichenkoordinaten verwendet. Der Grundgraph und die Datenhaltung der Attributwerte wird auf möglichst kompakte Art und Weise gelöst. Graphanwendungen können eine Liste von temporären Änderungen erzeugen, die mit dem großen globalen Graphen zusammengeführt werden können. Um das Vorgehen der Graph-Algorithmen zu visualisieren, werden deren Funktionsaufrufe in einer Änderungsfolge kodiert, welche als Animation zum Java Client übertragen wird.
Um die Geschwindigkeit einer Ausschnittsanfrage zu erhöhen, wird die mehrdimensionale Indexstruktur R-Tree verwendet. Diese ermöglicht Anfragezeiten, die linear zur Anzahl der zurückgelieferten Kanten und unabhängig vom gewählten Ausschnitt sind. Es können komplexe Filterausdrücke aus Vergleichsbedingungen mit boolschen und arithmetische Operatoren verwendet werden, um die angezeigten Kanten in einem Visualisierungsauschnitt einzuschränken und so komfortabel bestimmte Aspekte der Anwendungs-Algorithmen zu untersuchen oder hervorzuheben.
Als Referenzanwendung wird das Rahmenwerk von der am Institut für Theoretische Informatik in Karlsruhe entwickelten Routenplanungsanwendung zur Visualisiserung mittels Web Applet verwendet.
Abstract
This study thesis investigates and implements methods used to efficiently visualize very large graphs like a street network of Europe. A C++ server framework is designed, which implements a data management library for graphs with attributes. A Java applet communicates with the data server via CORBA and draws sections of the graph. The graph data management library can easily be integrated into existing graph application to visual and animate calculations.
The data management library uses the adjacency array structure for representing the base graph. It is extended by similar data structures to hold an arbitrary number of attributes for each vertex and edge. The data structures are optimized towards highest storage efficiency. To modify the static global graph an application may construct a list of changes, which are efficiently merged into permanent data storage. To visualize the workings of an algorithm its function call sequence can be recorded into a list of graph changes. This change time line can be transfered to the Java client and displayed as an animation.
To accelerate access to arbitrary sections of the graph the spatial index structure R-Tree is used. It enables query times to linearly increase with the number of returned edges and be independent of the section size or position.
Furthermore complex filter expressions including comparisons and arithmetic operators can be applied to limit the displayed edges. This enables the client to explore the graph's details comfortably and highlight interesting aspects of an algorithm.
The graph data management library is used in a route planning application, which is being developed in a research group of the University of Karlsruhe. It will be used to visualize the route using a web applet.
Vortrag "Objekt-orientiertes Programmieren in C"
Posted on 2006-05-03 16:19 by Timo at Permlink with Comments. Tags: university talk c++
Im Sommersemester 2005 habe ich am Praktikum "Real-Life Programming" am IPD Lehrstuhl der UniKa teilgenommen. Hier platt die Beschreibung von der Homepage zitiert:
Wie programmiert man richtig?
Viele performancekritische Software wird immer noch in C geschrieben. C erlaubt dem Compiler einen sehr großen Optimierungsspielraum, in diesem Praktikum wird geübt, wie dieser ausgenutzt werden kann und wie die dabei auftretenden Klippen zu umschiffen sind.
In diesem Kontext könnt ihr lernen:
- Den Umgang mit den UNIX Entwicklungswerkzeugen
- Schreiben von portablem Code
- Verständnis des Übersetzungsprozesses von C
- Analysieren des durch Übersetzer erzeugten Assemblertextes
- Programmieren, so dass der Übersetzer guten Code erzeugen kann
- Wie man die Performance von Programmen steigern kann
- Umgang mit großen Projekten
- Das Finden von Fehlern in großen und alten Softwaresystemen
- Beherrschen von Debugging und Profiling Werkzeugen
- Kniffe des C-Präprozessors
- Die "Geheimnisse" von C
In diesem Zusammenhang haben zwei Komilitonen und ich einen Vortrag über "Objekt-orientiertes Programmieren in C" (ohne ++) ausgearbeitet und gehalten. Weiteres Schwerpunktthema war die Darstellung von C++ in Maschine, also wie der C++ Übersetzer dann die Klassen abbildet.
| Vortragsfolien: | OOC-Folien.pdf | 179 kB |
| Handout: | OOC-Handout.pdf | 122 kB |
| Beispielcode: | OOC-Beispiele.tar.gz | 4 kB |
Hier noch ein Auszug des Inhaltsverzeichnisses:
- Objekt-Orientierte Konzepte
- OO in C
- Kapselung und Geheimnisprinzip
- Vererbung und Polymorphie
- Generiztiät
- Darstellung von C++ in Maschine
- vtable
- Name-Mangling
- Run-Time-Type Information (RTTI)
Diese Folien geben einen kompetenten Überblick über den Themenbereich.
