char str[512];
scanf(" [^\n]", &str);

1. 1. Copy database tables and Mambo code from remote server to local system. I used WAMP to do all migration. By doing that the site was still online, while I was doing some research. If for some reason you don’t have access to phpMyAdmin or any other database client, use SIDU 3.2 DB Web GUI
2. 2. Convert SQL file to UTF8 encoding.You can do this using i.e. Notepad++ – use Convert to UTF8 (without BOM).
   Also change tables encoding to UTF8. This operation will cause problems with ‘ocp_core_acl_aro’ table "#1071, Specified key was too long; max key length is 1000 bytes". Rewrite it as below

   CREATE TABLE `ocp_core_acl_aro` (
   `aro_id` int(11) NOT NULL auto_increment,
   `section_value` varchar(240) NOT NULL default '0',
   `value` varchar(240) NOT NULL default '',
   `order_value` int(11) NOT NULL default '0',
   `name` varchar(255) NOT NULL default '',
   `hidden` int(11) NOT NULL default '0',
   PRIMARY KEY  (`aro_id`),
   UNIQUE KEY `ocp_gacl_section_value_value_aro` (`section_value`(100),`value`(75)),
   UNIQUE KEY `section_value_value_aro` (`section_value`(100),`value`(75)),
   KEY `hidden_aro` (`hidden`),
   KEY `ocp_gacl_hidden_aro` (`hidden`)
   ) ENGINE=MyISAM AUTO_INCREMENT=13 DEFAULT CHARSET=utf8
   

3. 3. Migrate to Mambo 4.5.2 Create local database for Mambo 4.5.2 and use utf8_general_ci for connection and comparison. Download and extract Mambo 4.5.2 to webserver directory. Change db settings in configuration.php and apply sql script upgrade451to452.sql from installation\sql direcotry
4. 4. Install Joomla 1.5 but do not load sample data
5. 5. Install mtwmigrator for Joomla 1.5 You can download it here mtwmigrator-v0-2-1. Run component and go to Preference. Set db name, location, login and password. Select data you want to migrate and launch migration process. After this step you should have all data from Joomla 1.0 availbale in new installation on Joomla 1.5
6. 6. Migrate to Joomla 1.6 using jUpgrade. You can download it here jUpgrade. All you have to do is to install it within Joomla 1.5 and start. If some problem occurs try enabling Debuging in jUpgrade

Now, you should have new installation of Joomla 1.6 created for you and available in jUpgrade dir in Joomla 1.5 directory. New tables were created in same database as Joomla 1.5, so depending on needs, final step might be to dump those tables and move to new, dedicated location.

int ena = 1;
if( setsockopt(queuefd, SOL_SOCKET, SO_TIMESTAMP, &ena, sizeof(ena)) )
{
    SYS_LOG(E_WARNING, "Unable to enable timestamping");
}

and then in queue handle function:

int handle_queue(struct nfq_q_handle *pQh, struct nfgenmsg *pNfmsg, struct nfq_data *pNfa, void *pData)
{
    struct nfqnl_msg_packet_hdr *ph;
    struct timeval tv;
    int id;

    ph = nfq_get_msg_packet_hdr(pNfa);
    if(ph)
    {
        id = ntohl(ph->packet_id);
    }

    nfq_get_timestamp(pNfa, &tv);
    /* do sth. with read timestamp */

    return nfq_set_verdict(pQh, id, NF_ACCEPT, 0, NULL);
}

This is a solution for a issue, that as far as i know, have not been solved since this post:
„So far the biggest issues I’ve run into are that marking doesn’t work in 2.6.15 (I think it should in 2.6.16), and I can’t seem to ever read the timestamp for a packet, no matter hat hook it comes in on. I’ve just been using gettimeofday for that for now.”
http://lists.netfilter.org/pipermail/netfilter-devel/2006-February/023490.html

#include <iostream>

int foo(int x, int y)
{
    return x + y;
}

int main()
{
    int z, k;
    z = 10;
    k = foo(z = 20, z += 1);
    std::cout << k << std::endl;
}

Najłatwiej zweryfikować korzystając z kompilatora. Na rozważanie przyczyna takie czy innego wyniku nie warto poświęcać zbyt wiele czasu, ponieważ dodanie flagi -Wall rozwiewa wszystkie wątpliwości:

zadanie.cpp: In function ‘int main()’:
zadanie.cpp:14: warning: operation on ‘z’ may be undefined

Zatem poprawna odpowiedź na pytanie: „to zależy od kompilatora, sprzętu, systemu”

class Foo {
public:
  methodA() {
    printf("Wykonano...\n");
  }
}

struct data_t {
  int i_;
  Foo* obj_;
}

std::list<data_t*> data_;

for(std::list<data_t*>::iterator i  = data_.begin(); i != data_.end(); i++ ) {
   // operacje
}

W jaki sposób wykonać blok operacji ? Możliwości mamy kilka:

/* 1 */ i->obj_->methodA();
/* 2 */ *i->obj_->methodA();
/* 3 */ (*i)->obj_->methodA();

Rozwiązanie zagadki jest proste, ale wymaga znajomości priorytetów operatorów. Pierwsze wywołania jest całkowicie błędne, ponieważ lista przecowuje wskaźniki do strkutury, a nie samą strukturę. Zatem należy najpier wyłuskać strukturę znajdującą się pod wskazywanym adresem i dopiero wtedy wykonać metodę. Okazuje się że rowiązania 2 również jest nie poprawne, właśnie ze względu na priorytety operatorów. Dopiero numer 3 daje zamierzony efekt. Na szczęście błąd ujawnia się na etapie kompilacji…

// Copyright (C) 2001-2003
// William E. Kempf
//
// Permission to use, copy, modify, distribute and sell this software
// and its documentation for any purpose is hereby granted without fee,
// provided that the above copyright notice appear in all copies and
// that both that copyright notice and this permission notice appear
// in supporting documentation.  William E. Kempf makes no representations
// about the suitability of this software for any purpose.
// It is provided "as is" without express or implied warranty.

#include <boost/thread/thread.hpp>;
#include <;boost/thread/xtime.hpp>;
#include <iostream>;

struct thread_alarm
{
    thread_alarm(int secs) : m_secs(secs) { }
    void operator()()
    {
        boost::xtime xt;
        boost::xtime_get(&xt, boost::TIME_UTC);
        xt.sec += m_secs;

        boost::thread::sleep(xt);

        std::cout << "alarm sounded..." << std::endl;
    }

    int m_secs;
};

int main(int argc, char* argv[])
{
    int secs = 5;
    std::cout << "setting alarm for 5 seconds..." << std::endl;
    thread_alarm alarm(secs);
    boost::thread thrd(alarm);
    thrd.join();
}

Jednak ten sposób nie działa w przypadku korzystania z natywnego mechanizmu wielowątkowości dostępnego w każdym systemie *nix. Biblioteka pthreads nie radzi sobie z wywołaniem przeciążonego operatora (). Problem trzeba było rozwiązać jak najszybciej, żeby projekt mógł ruszy dalej. Dlatego powstał ten sprytny „work-around” umożliwiający uruchomienie dowolnej metody obiektu w nowym wątku. Jest to właściwie funkcja proxy, takie proste a ułatwia życie:

template<class T>
struct ThreadParams
{
	T *obj;
	void *params;
};

template<class T, void* (T::*method)(void*)>
void* run_thread(void *params)
{
	ThreadParams<T> *t = static_cast<ThreadParams><T*>(params);
	T* obj = static_cast<T*>(t->obj);
	(obj->*method)(t->params);
	return NULL;
}

Dodatkowy wkład pracy jaki należy włożyć aby wykorzystać powyższy kod ogranicza się właściwie tylko do wypełnienia struktury ThreadParams:

class Test
{
public:
	void* fun(void* params) {
	printf("Hello World! \n");
	printf("Params: %d\n", reinterpret_cast<int>(params));
	pthread_exit(NULL);
	}
 };

 int main() {

	pthread_t tid;
	void* status;
	Test test;
	ThreadParams<Test> params;

	params.obj = &test;
	params.params = reinterpret_cast<void>(123);

	pthread_create(&tid, NULL, run_thread<Test, &Test::fun>, (void*)(&params));
	pthread_join(tid, &status);
 }

Na wszelki, skopiowany kod poprawki poniżej:

— ZSI-2.1-a1/ZSI/ServiceContainer.py 2007-08-08 00:56:37.000000000 +0200
+++ ServiceContainer.py 2008-06-19 13:50:11.000000000 +0200
@@ -5,6 +5,7 @@

import urlparse, types, os, sys, cStringIO as StringIO, thread,re
from BaseHTTPServer import BaseHTTPRequestHandler, HTTPServer
+from SocketServer import ThreadingMixIn
from ZSI import ParseException, FaultFromException,
FaultFromZSIException, Fault
from ZSI import _copyright, _seqtypes, _get_element_nsuri_name, resolvers
from ZSI import _get_idstr
@@ -30,6 +31,7 @@
SimpleWSResource
SOAPRequestHandler
ServiceContainer
+ ThreadedServiceContainer
„”"
class NoSuchService(Exception): pass
class UnknownRequestException(Exception): pass
@@ -141,12 +143,16 @@
return SendFault(FaultFromException(e, 0, sys.exc_info()[2]), **kw)

-def AsServer(port=80, services=()):
+def AsServer(port=80, services=(), threaded=False):
”’port –
services — list of service instances
+ threaded — in modo multithread ?
”’
address = (”, port)
- sc = ServiceContainer(address, services)
+ if threaded:
+ sc = ThreadedServiceContainer(address, services)
+ else:
+ sc = ServiceContainer(address, services)
sc.serve_forever()

@@ -467,6 +473,11 @@
def removeNode(self, url):
self._nodes.removeNode(url)

+class ThreadedServiceContainer(ThreadingMixIn, ServiceContainer):
+ ”’Multithreaded version of ServiceContainer.
+ ”’
+ pass
+

class SimpleWSResource(ServiceSOAPBinding):

# gry - lista skladajaca sie z list reprezentujacych gre. Kazda reprezentacja
# gry to kolejna lista zaiwerajaca ilosc 'kijkow' na kolejnych stosach
def graj(gry):
    sg = (0, 0, 1, 1, 2, 2, 3)
    for gra in gry:
        g = []
        reszty = []
        for stos in gra:
            reszta = int(stos)%7
            g.append(sg[reszta])
            reszty.append(reszta)
        wynik = reduce(lambda x,y: x^y, g)

        if wynik :
            print "Julia wins."
        else :
            print "Robert wins.\n"

Lekki problem pojawia się przy ustalaniu ruchu wygrywającego. Nie wiem czy istnieje jakieś szybsze rozwiązanie niż takie trochę brute-force’owe która ja wykorzystałem. Polega ono na stwierdzeniu na jakiej pozycji ( wygrywającej czy przegrywającej ) znalazł by się gracz gdyby nie było jednego stosiku, a następnie obliczeniu czy da się odjąć taką liczbę patyczków żeby zostawić przeciwnika na pozycji przegrywającej.
Dodatkowo oprócz wskazania ruchu wygrywającego należy wskazać ten podczas którego bierze się najwięcej patyczków ze stosu o najmniejszym numerze, co w lekki sposób komplikuje sprawę.:

        stos_wygrywajacy = 0;
        licznik = 0
        blokada_5 = False
        blokada_3 = False

        # odwrocenie list, sprawdzanie od konca
        gra_rev = gra[:]
        gra_rev.reverse()

        g_rev = g[:]
        g_rev.reverse()

        reszty.reverse()
        for reszta in reszty:
            # lista reszt bez kolejnych stosow
            tmpr = reszty[:]
            tmpr.pop(licznik)

            # xor wartosci f. Sprague-Grundy'ego
            # bez kolejnych stosow
            tmpg = g_rev[:]
            tmpg.pop(licznik)
            tmpw = reduce(lambda x,y: x^y, tmpg ,0)

            if sg[reszta-5] == tmpw and int(gra_rev[licznik]) >= 5:
                wygrywajacy = 5
                stos_wygrywajacy = len(reszty) - licznik
                blokada_5 = True
            elif sg[reszta-3] == tmpw and int(gra_rev[licznik]) >= 3 and blokada_5 == False:
                wygrywajacy = 3
                stos_wygrywajacy = len(reszty) - licznik
                blokada_3 = True
            elif sg[reszta-2] == tmpw and int(gra_rev[licznik]) >= 2 and blokada_5 == False and blokada_3 == False:
                wygrywajacy = 2
                stos_wygrywajacy = len(reszty) - licznik

            licznik += 1

Jeśli ktoś zna szybsze rozwiązanie chętnie je przeanalizuję
Zaznaczam, że nie dam sobie głowy uciąć że algorytm jest poprawny, bo nie ma już możliwości zgłoszenia rozwiązania – upłynęły terminy.

EDIT:
Lekko poprawiona wersja, działa trochę szybciej, natomiast i tak nie umożliwia zdobycia maximum punktów. Jesli nie ma jakiejś sztuczki na ruch wygrywający, a podejrzewam że coś jest, to lepiej zakodzić to w C…

        stos_wygrywajacy = 0
        blokada_3 = False
        blokada_2 = False
        licznik = 0
        for reszta in reszty :
            tmpg = g[:]
            tmpg.pop(licznik)
            tmpw = reduce(lambda x,y: x^y, tmpg, 0)

            if sg[reszta-5] == tmpw and int(gra[licznik]) >= 5:
                wygrywajacy = 5
                stos_wygrywajacy = licznik + 1
                break
            elif sg[reszta-3] == tmpw and int(gra[licznik]) >= 3 and blokada_3 == False:
                wygrywajacy = 3
                stos_wygrywajacy = licznik + 1
                blokada_3 = True
            elif sg[reszta-2] == tmpw and int(gra[licznik]) >= 2 and blokada_3 == False and blokada_2 == False:
                wygrywajacy = 2
                stos_wygrywajacy = licznik + 1
                blokada_2 = True
            licznik += 1

Aby istniała możliwość ustawiania przezroczystości dla okna, musi być ono utworzone w sposób do tego przystosowany. Wystarczy skorzystać z innej funkcji tworzącej okno, nie CreateWindow, a CreateWindowEx
[cc lang="c"]
HWND CreateWindowEx(
DWORD dwExStyle,
LPCTSTR lpClassName,
LPCTSTR lpWindowName,
DWORD dwStyle,
int x,
int y,
int nWidth,
int nHeight,
HWND hWndParent,
HMENU hMenu,
HINSTANCE hInstance,
LPVOID lpParam
);
[/cc]
To co umożliwia później modyfikacje przezroczystości jest ukryte w ramach dodatkowego stylu okna, podawanego poprzez argument dwExStyle. Lista dopuszczalnych wartości jest długa, ale warto się z nią zapoznać. W tym konkretnym przypadku należy zainteresować się wartością WS_EX_LAYERED, utworzone wtedy okno będzie tzw. Layered Window, które obsługuje modyfikacje przezroczystości. Do ustawienia nowej wartości kanału alpha służy SetLayeredWindowAttributes(HWND hwnd, COLORREF crKey, BYTE bAlpha, DWROD dwFlags) – szczegóły w dokumentacji.
Pełny kod tworzący przykładowe, półprzezroczyste okno:
[cc lang="c"]
#include

LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
LPSTR lpCmdLine, int nCmdShow)
{
MSG msg;
HWND hwnd;
WNDCLASSEX wcx;

wcx.cbSize = sizeof(wcx);
wcx.style = CS_HREDRAW | CS_VREDRAW;
wcx.lpfnWndProc = WndProc;
wcx.cbClsExtra = 0;
wcx.cbWndExtra = 0;
wcx.hInstance = hInstance;
wcx.hIcon = LoadIcon(NULL, IDI_APPLICATION);
wcx.hCursor = LoadCursor(NULL, IDC_ARROW);
wcx.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);
wcx.lpszMenuName = (LPCSTR)”MainMenu”;
wcx.lpszClassName = (LPCSTR)”MainWClass”;
wcx.hIconSm = (HICON)LoadImage(hInstance, MAKEINTRESOURCE(5), IMAGE_ICON,
GetSystemMetrics(SM_CXSMICON), GetSystemMetrics(SM_CYSMICON), (UINT)LR_DEFAULTCOLOR);

RegisterClassEx(&wcx);

hwnd = CreateWindowEx(WS_EX_LAYERED, (LPCSTR)”MainWClass”, (LPCSTR)”Sample”, WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, (HWND)NULL, (HMENU)NULL, hInstance, (LPVOID) NULL);

ShowWindow(hwnd, nCmdShow);
SetLayeredWindowAttributes(hwnd, 0, 180, LWA_ALPHA);
UpdateWindow(hwnd);

while(GetMessage(&msg, NULL, 0, 0))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}

return msg.wParam;
}

LRESULT CALLBACK WndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
switch(uMsg)
{
case WM_CREATE:
return 0;

case WM_PAINT:
return 0;

case WM_DESTROY:
PostQuitMessage(0);
return 0;

default:
return DefWindowProc(hwnd, uMsg, wParam, lParam);
}
return 0;
}
[/cc]

To co należy zrobić, aby kontrolować przezroczystość okien innych niż własne przedstawia się następująco:

1. 1. Pobrać wszystkie otwarte okna typu top-level
2. 2. Nadać oknom styl dwExStyle
3. 3. Zmienić wartość kanału alpha

1. Pobrać wszystkie otwarte okna typu top-level
Dobrym pomysłem wydaje się pobranie uchwytu do rodzica wszystkich okien(Desktop/Pulpit) i przejście w pętli po liście jego dzieci (jak wiadomo każde okno ma kilka przydatnych wskaźników, między innymi do okna-brata). Mogłoby to wyglądać tak:
[cc lang="c"]
HWND hDesktop = GetDesktopWindow();
HWND hChild = GetWindow(hDesktop, GW_CHILD);
HWND hTemp;
/* … */
while(hTemp != GetWindow(hChild, GW_HWNDLAST))
{
/* … */
hTemp = GetWindow(hChild, GW_HWNDNEXT);
}
[/cc]
Pomysł zły ! Okazuje się że taka pętla może działać w nieskończoność. Wzmianaka na temat takiego przypadku znajduje się nawet w dokumentacji. Dlatego należy wykorzystać inny sposób, polegający na użyciu funkcji BOOL EnumWindows(WNDENUMPROC lpEnumFunc, LPARAM lParam):
[cc lang="c"]
EnumWindows(EnumWindowsProc, NULL);
/* … */
BOOL CALLBACK EnumWindowsProc(HWND hwndChild, LPARAM lParam)
{
char buffer[100];

int count = GetWindowText(hwndChild, buffer, 100);
if(count && IsWindowVisible(hwndChild))
{
/* … */
}
return TRUE;
}
[/cc]

2. Nadać oknom styl dwExStyle
Wydaje się najtrudniejsze, przecież dodatkowy styl należy podać przy tworzeniu okna, a okna które widzimy zostały już przecież utworzone. Na szczęście z pomocą przychodzi funkcja LONG SetWindowLong(HWND hWnd, int iIndex, LONG dwNewLong):
[cc lang="c"]
SetWindowLong(hwndChild, GWL_EXSTYLE, WS_EX_LAYERED);
[/cc]

3. Zmienić wartość kanału alpha
Bardziej uważni czytelnicy już na pewno wiedzą jak wygląda zestaw parametrów i jak skorzystać z SetLayeredWindowAttributes. Wykorzystanie pokazane 3 listingi wyżej, przy okazji tworzenia „własnego” przezroczystego okna.

I to tyle tym temacie, wypada jeszcze stworzyć GUI, może obsługę tray’a. Program wydaje się „magiczny” a korzysta raptem z 4 funkcji API systemowego.