dbh.do(
  'INSERT INTO album(title, artist, asin) VALUES (?, ?, ?');',
  title, artist, asin)

cgi    =CGI::new()
title  =cgi.params[title]
artist =cgi.params[artist]
asin   =cgi.params[asin]

<table>
  <tr>
    <th>タイトル</th>
    <td><%=CGI::escapeHTML(title)%></td>
  </tr>
  <tr>
    <th>アーティスト</th>
    <td><%=CGI::escapeHTML(artist)%></td>
  </tr>
  <tr>
    <th>購入</th>
    <td><a href="http://www.amazon.co.jp/dp/<%=CGI::escapeHTML(asin)%>">Amazon.co.jp<a></td>
  </tr>
</table>

#ifndef __QWORD_H__
#define __QWORD_H__

//32ビット整数
typedef unsigned long DWORD;

//64ビット整数
typedef struct {
    DWORD dwLow;  //下位32ビット
    DWORD dwHigh; //上位32ビット
} QWORD;

#undef //__QWORD_H__
//[EOF]

#define NULL 0

//略記用マクロ
#define LOWORD(dw) (0xFFFFUL & dw)
#define HIWORD(dw) (0xFFFFUL & (dw >> 16);

//32ビット整数の加算
DWORD add32(DWORD dw1, DWORD dw2, DWORD* lpdwCarry =NULL){

    DWORD dwTmp1 =LOWORD(dw1) + LOWORD(dw2);
    DWORD dwTmp2 =HIWORD(dw1) + HIWORD(dw2) + HIWORD(dwTmp1);

    DWORD dwSum   =LOWORD(dwTmp1) | (dwTmp2 << 16))
    DWORD dwCarry =HIWORD(dwTmp2);

    //繰り上がりの格納
    if (lpdwCarry) *lpdwCarry =dwCarry;

    return dwSum;
}

//64ビット整数の加算
QWORD add(QWORD qw1, QWORD qw2){

    DWORD dwCarry;

    QWORD qwSum;
    qwSum.dwLow  =add32(qw1.dwLow, qw2.dwLow, &dwCarry);
    qwSum.dwHigh =add32(add32(qw1.dwHigh, qw2.dwHigh), dwCarry);

    return dwSum;
}

#include <stdio.h>

int main(){

    QWORD qw1;
    qw1.dwLow  =0xFFFFFFFF;
    qw1.dwHigh  =0x00000007;

    QWORD qw2;
    qw2.dwLow  =0xB;
    qw2.dwHigh =0x8;

    QWORD qwSum =add(qw1, qw2);

    printf("qwSum.dwLow  => %08X\n", qwSum.dwLow);
    printf("qwSum.dwHigh => %08X\n", qwSum.dwHigh);

    return 0;
}

////////////////////////////////////////////////////////////////////////////////
//
//  ListNode.h
//

#ifndef __LISTNODE_H__
#define __LISTNODE_H__

#include <assert.h>

#ifndef NULL
#define NULL 0

#endif

//略記用マクロ
#define LPCNODE   const ListNode<T>*
#define LPNODE    ListNode<T>*

#define _TEMPLATE template <typename T>

//プロトタイプ宣言
_TEMPLATE class List;

//リストノード

_TEMPLATE class ListNode {
    friend class List<T>;
public:

    T   value; //ノード値

    //construction

    ListNode(LPNODE lpPrev, LPNODE lpNext, const T& value);

    //member access (getting)
    LPNODE  Prev();
    LPCNODE Prev() const;
    LPNODE  Next();
    LPCNODE Next() const;

protected:

    LPNODE  m_lpPrev; //前ノードのアドレス

    LPNODE  m_lpNext; //次ノードのアドレス

};

////////////////////////////////////////////////////////////////////////////////
//construction

//コンストラクタ
_TEMPLATE ListNode<T>::ListNode(LPNODE lpPrev, LPNODE lpNext, const T& value)
: m_lpPrev(lpPrev), m_lpNext(lpNext), value(value) {
}▼実装部を表示


////////////////////////////////////////////////////////////////////////////////
//member access (getting)

//前ノードアドレス
_TEMPLATE LPNODE ListNode<T>::Prev() {
    return m_lpPrev;
}

//前ノードアドレス (const)

_TEMPLATE LPCNODE ListNode<T>::Prev() const {
    return m_lpPrev;
}

//次ノードアドレス
_TEMPLATE LPNODE ListNode<T>::Next() {
    return m_lpNext;
}


//次ノードアドレス (const)
_TEMPLATE LPCNODE ListNode<T>::Next() const {
    return m_lpNext;
}▼実装部を表示


//略記用マクロ解除

#undef LPCNODE
#undef LPNODE
#undef _TEMPLATE

#endif //__LISTNODE_H__
//[EOF]

////////////////////////////////////////////////////////////////////////////////
//
//  List.h
//

#ifndef __LIST_H__
#define __LIST_H__


#include "ListNode.h"


//略記用マクロ
#define LPCNODE   const ListNode<T>*
#define LPNODE    ListNode<T>*

#define _TEMPLATE template <typename T>


_TEMPLATE class List {
public:

    const int& size;

    //construction

    List();
    List(const List<T>&);

    //destruction
    virtual ~List();

    //operator
    List<T>& operator = (const List<T>&);
    T&       operator [] (int nIndex) ;
    const T& operator [] (int nIndex) const;

    //operation

    LPNODE  Append(const T&);


protected:

    LPNODE  m_lpHead; //始端ノードのアドレス
    LPNODE  m_lpTail; //終端ノードのアドレス
    int     m_nSize;  //要素数

    //operation
    LPNODE  GetLPNode(int nIndex);
    LPCNODE GetLPNode(int nIndex) const;

private:

    //destruction

    void    Destroy();

};


////////////////////////////////////////////////////////////////////////////////
//construction

//コンストラクタ
_TEMPLATE List<T>::List()
: m_lpHead(NULL), m_lpTail(NULL), m_nSize(0), size(m_nSize) {
}


//コンストラクタ
_TEMPLATE List<T>::List(const List<T>& l)
: size(m_nSize) {

    if (l.m_nSize){

        LPCNODE p     =l.m_lpHead;
        int     nSize =l.m_nSize;

        LPNODE lpHead =new ListNode<T>(NULL, NULL, p->value);
        LPNODE lpTail =lpHead;

        while (p =p->m_lpNext){
            lpTail =lpTail->m_lpNext =new ListNode<T>(lpTail, NULL, p->value);
        }

        m_lpHead =lpHead;
        m_lpTail =lpTail;
        m_nSize  =nSize;
    }
    else {
        m_lpHead =NULL;
        m_lpTail =NULL;
        m_nSize  =0;
    }
}▼実装部を表示


////////////////////////////////////////////////////////////////////////////////
//destruction

//デストラクタ
_TEMPLATE List<T>::~List(){
    Destroy();
}

//オブジェクトの破棄 [for internal use]
_TEMPLATE void List<T>::Destroy(){

    LPNODE p =m_lpHead;
    while (p){

        LPNODE q =p->m_lpNext;

        delete p;

        p =q;
    }

    return;
}▼実装部を表示


////////////////////////////////////////////////////////////////////////////////
//operator

//代入
_TEMPLATE List<T>& List<T>::operator = (const List<T>& l){

    if (l.m_nSize){

        LPCNODE p     =l.m_lpHead;
        int     nSize =l.m_nSize;

        LPNODE lpHead =new ListNode<T>(NULL, NULL, p->value);
        LPNODE lpTail =lpHead;

        while (p =p->m_lpNext){
            lpTail =lpTail->m_lpNext =new ListNode<T>(lpTail, NULL, p->value);
        }

        Destroy();

        m_lpHead =lpHead;
        m_lpTail =lpTail;
        m_nSize  =nSize;
    }
    else {

        Destroy();

        m_lpHead =NULL;
        m_lpTail =NULL;
        m_nSize  =0;
    }

    return *this;
}


//要素参照
_TEMPLATE inline T& List<T>::operator [] (int nIndex){
    assert(0 <= nIndex && nIndex < m_nSize);
    return GetLPNode(nIndex)->value;
}


////要素参照 (const)
_TEMPLATE inline const T& List<T>::operator [] (int nIndex) const {
    assert(0 <= nIndex && nIndex < m_nSize);
    return GetLPNode(nIndex)->value;
}▼実装部を表示


////////////////////////////////////////////////////////////////////////////////
//operation

//要素の追加
_TEMPLATE LPNODE List<T>::Append(const T& value){

    LPNODE lpNode;

    if (m_lpTail){

        lpNode =new Node(m_lpTail, NULL, value);

        m_lpTail =m_lpTail->m_lpNext =lpNode;
        ++m_nSize;
    }
    else {

        lpNode =new Node(NULL, NULL, value);

        m_lpHead =lpNode;
        m_lpTail =lpNode;
        m_nSize  =1;
    }

    return lpNode;
}


//ノードアドレスの取得 [for internal use]
_TEMPLATE LPNODE List<T>::GetLPNode(int nIndex){
    assert(0 <= nIndex && nIndex < m_nSize);

    LPNODE p =m_lpHead;

    int i;
    for (i=0; i<nIndex; ++i) p =p->m_lpNext;

    return p;
}


//ノードアドレスの取得 (const) [for internal use]
_TEMPLATE LPCNODE List<T>::GetLPNode(int nIndex) const {
    assert(0 <= nIndex && nIndex < m_nSize);

    LPCNODE p =m_lpHead;

    int i;
    for (i=0; i<nIndex; ++i) p =p->m_lpNext;

    return p;
}▼実装部を表示


//略記用マクロ解除
#undef LPNODE
#undef _TEMPLATE

#endif //__LIST_H__
//[EOF]

#include <stdio.h>

#include "List.h"

int main(){

    List<char> list;

    //読み込み

    for (;;){

        int n =getc(stdin);
        if (n == EOF) break;

        list.Append(static_cast<char>(n));
    }

    //出力

    int i;
    for (i=0; i<list.size; ++i){
        putc(list[i], stdout);
    } //i

    return 0;
}