Svn-commit is a command line utility for making rapid commit with subversion. Suppose you’re working on your local copy of a subversion project. If you forget to run commands like svn del file or svn add file each time you add or remove a file, when you’ll try to commit your working copy you’ll obtain something like this:

• ? file: for each file/directory that isn’t under the revision system

• ! file: for each file/directory you’ve removed without the command svn del svn-commit will prevent these errors because it will tell svn to:

• add all your unversioned files to the repository

• delete all the files you’ve removed from your working directory (be careful !!)

Requirements:

svn-commit requires:

• python
• svn client utilities

Synopsis:

svn-commit syntax: svn-commit directory A simple example: svn commitpwd``

Code

{% codeblock [svn-commit.py] [lang:python ] %} #! /usr/bin/python

svn-commit

Created by Flavio Castelli flavio.castelli@gmail.com

svn-commit follows GPL v2

import os,popen2 from sys import argv

if name == “main“:

dir=argv[1]; pipe = os.popen (‘svn status %s’%(dir)) #executes shell command

result = [x.strip() for x in pipe.readlines() ] pipe.close()

to_add=[] to_remove=[]

for x in result: if x.find(‘?’)!=-1: to_add+=[x[x.find(‘/’):len(x)]] elif x.find(‘!’)!=-1: to_remove+=[x[x.find(‘/’):len(x)]]

print “To add\n”; for x in to_add: print (“Command svn add %s”%(x)) pipe= os.popen (“svn add \“%s\“”%(x)) result = [x.strip() for x in pipe.readlines() ] for y in result: print y pipe.close() print “To remove\n”; for x in to_remove: print (“Command svn delete \“%s\“”%(x)) pipe= os.popen (“svn delete \“%s\“”%(x)) result = [x.strip() for x in pipe.readlines() ] for y in result: print y pipe.close()

{% endcodeblock %}

How can you add regular expressions to C++? Here you’re three small examples.

Pattern matching

In this example you’ll find how you can match a regexp in a string.

{% codeblock [pattern matching] [lang:c++ ] %} // Created by Flavio Castelli // distrubuted under GPL v2 license

#include #include

int main() { boost::regex pattern (“bg|olug”,boost::regex_constants::icase|boost::regex_constants::perl); std::string stringa (“Searching for BsLug”);

if (boost::regex_search (stringa, pattern, boost::regex_constants::format_perl)) printf (“found\n”); else printf(“not found\n”);

return 0; } {% endcodeblock %}

Substitutions

In this example you’ll find how you can replace a string matching a pattern.

{% codeblock [substitutions] [lang:c++ ] %} // Created by Flavio Castelli flavio.castelli@gmail.com // distrubuted under GPL v2 license

#include #include

int main() { boost::regex pattern (“b.lug”,boost::regex_constants::icase|boost::regex_constants::perl); std::string stringa (“Searching for bolug”); std::string replace (“BgLug”); std::string newString;

newString = boost::regex_replace (stringa, pattern, replace);

printf(“The new string is: |%s|\n”,newString.c_str());

return 0; } {% endcodeblock %}

Split

In this example you’ll find how you tokenize a string with a pattern.

{% codeblock [split] [lang:c++ ] %} // Created by Flavio Castelli flavio.castelli@gmail.com // distrubuted under GPL v2 license

#include #include

int main() { boost::regex pattern (”\D”,boost::regex_constants::icase|boost::regex_constants::perl);

std::string stringa (“26/11/2005 17:30”); std::string temp;

boost::sregex_token_iterator i(stringa.begin(), stringa.end(), pattern, -1); boost::sregex_token_iterator j;

unsigned int counter = 0;

while(i != j) { temp = *i; printf (“token %i = |%s|\n”, ++counter, temp.c_str()); i++; }

return 0; } {% endcodeblock %}

Requirements

In order to build this examples you’ll need:

• a c++ compiler (like g++)
• boost regexp library

This simple program removes recursively all .svn directories.

Requirements: In order to run remove-svn requires python.

Synopsis: remove-svn syntax is: remove-svn dir in this way remove-svn will recursively remove all .svn directories found under dir.
An example: remove-svnpwd``

UPDATE A faster way for removing .svn file through this simple bash command: find ./ -name *svn* | xargs rm -rf

The old script has been removed.

Another keyword that is almost never used in C++ is "auto". Did you see it ever? Do you understand its meaning? Explain when it should be used.

After a discussion about open-sourcing a tool Szann recommended to make a puzzle about a topic that currently is irrelevant for software that relies on an open source tool chain.

C++ does provide a keyword "export". Most people don't even know about this keyword because unfortunately there currently is no open source compiler that does support it and commercial compilers that support it are quite rare as well. Instead of making use of the export keyword people are used to put all template code into header files that have to be included from every source file that creates concrete instances of the template code. This is a problem because it makes the compiler compiling the same code multiple times and it is a problem because commercial software vendors have to ship the full source code of template code of their libraries.

Explain how the export keyword can be used instead of including the full template code from each translation unit. Does this improve compilation time? Does this allow commercial software vendors to build a shared library of their template code instead of shipping the full code?

It is always important to have a good friend. C++ has a special keyword for this purpose. Thus you sometimes read code like this:

namespace n { template<typename T> void f(T o); }
class a { friend void n::f(a); };

Is this code correct? Do you have reasons for your opinion given you have an opinion at all? Ignoring the fact whether this code is correct or not, is it smart to write code like this or is something else to be preferred? Explain.

Because I had no time to do a puzzle today myself and there was still one from my former colleague Thomas in the queue I will present this puzzle today.

The question is what the following application does produce when built with a standard compliant compiler.

#include <iostream>

struct A {};

void foo(bool t) {
    if (t)
        throw A();
}

void bar(bool t) {
    try {
        try {
            foo(t);
            throw;
        } catch (const A&) {
            std::cout << "catched const A&" << std::endl;
            throw;
        }
    } catch (...) {
        std::cout << "catched ..." << std::endl;
    }
}

int main() {
    bar(true);
    bar(false);
    std::cout << "done." << std::endl;
}

If you want to test whether someone has understood how template specialization works is the following which is derived from a famous example by Peter Dimov and Dave Abrahams. So let's test you!

What's the return value of the function g in the following code? Explain your opinion!

template<typename T> int f(T) { return 1; }
template<> int f<>(int*) { return 2; }
template<typename T> int f(T*) { return 3; }
int g(int* i) { return f(i); }

Today's C++ puzzle was originally developed together with my student assistant Juergen as a geeky idea on how to write a full blown Java application without a main method. The same "technology" does work on C++ as well but you have to fake the linker with a symbol main to translate the program. You can do this by providing a global integer variable main instead of a main method.

Now for today's puzzle: Write a Hello World application without a function main. What is the drawback of this "technology" to write applications, apart from the obvious one that it is a ugly hack?