transactd 1.2.0 → 2.0.0

data/source/global/ormsrcgen/srcgen.cpp

@@ -0,0 +1,763 @@
+/*=================================================================
+   Copyright (C) 2014 BizStation Corp All rights reserved.
+
+   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, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+   02111-1307, USA.
+=================================================================*/
+#include "srcgen.h"
+#include <iostream>
+#include <fstream>
+#include <boost/algorithm/string.hpp>
+
+using namespace std;
+#pragma package(smart_init)
+
+#define LF "\n"
+#define MAP_CLASS_SUFFIX "_map"
+
+bool loadFromFile(const string& filename, string& reval)
+{
+    ifstream ifs(filename.c_str());
+    if (ifs.fail())
+    {
+        cerr << "File not exist.\n";
+        return false;
+    }
+    string s;
+    while (getline(ifs, s))
+    {
+        if (s.size() && s[s.size() - 1] == '\r')
+            s.erase(s.size() - 1);
+        reval += s + LF;
+    }
+    return true;
+}
+
+bool saveToFile(const string& filename, const string& val)
+{
+    ofstream ofs(filename.c_str());
+    if (ofs.fail())
+    {
+        cerr << "Output file is not created.\n";
+        return false;
+    }
+    ofs << val << LF;
+    return true;
+}
+
+string intReadMenbaName(fielddef* fd)
+{
+    switch (fd->len)
+    {
+    case 1:
+        return "i8()";
+    case 2:
+        return "i16()";
+    case 3:
+        return "i()";
+    case 4:
+        return "i()";
+    }
+    return "i64()";
+}
+
+cppSrcGen::cppSrcGen(const tabledef* tabledef, conf_parmas& pm)
+    : m_tabledef(tabledef), m_pm(pm)
+{
+}
+
+void cppSrcGen::replace(string& source, const char* convTgtStr,
+                        const string& replaceStr)
+{
+    size_t pos = 0;
+    while ((pos = source.find(convTgtStr, pos)) != string::npos)
+    {
+        source.replace(pos, strlen(convTgtStr), replaceStr);
+        pos += replaceStr.size();
+    }
+}
+
+string cppSrcGen::membaNameGet(string s)
+{
+    char v[2] = { 0 };
+    if ((s.size() > 0) && (m_pm.setPrefix == "get"))
+    {
+        v[0] = s[0] - 32;
+        s.replace(0, 1, v);
+    }
+    return m_pm.getPrefix + s;
+}
+
+string cppSrcGen::membaNameSet(string s)
+{
+    char v[2] = { 0 };
+
+    if ((s.size() > 0) && (m_pm.setPrefix == "set"))
+    {
+        v[0] = s[0] - 32;
+        s.replace(0, 1, v);
+    }
+    return m_pm.setPrefix + s;
+}
+
+string cppSrcGen::membaName(fielddef* fielddef)
+{
+    string s = m_fnames.getName(fielddef->nameA());
+    char v[2] = { 0 };
+    if ((s.size() > 0) && ((s[0] >= 'A') && (s[0] <= 'Z')))
+    {
+        v[0] = s[0] + 32;
+        s.replace(0, 1, v);
+    }
+    return s;
+}
+
+string cppSrcGen::makeFdiMembaString()
+{
+    string retVal;
+    for (int i = 0; i < m_tabledef->fieldCount; i++)
+    {
+        fielddef* fd = &m_tabledef->fieldDefs[i];
+        retVal = retVal + "\tshort " + membaName(fd) + ";" LF;
+    }
+    return retVal;
+}
+
+int cppSrcGen::typeNum(int type)
+{
+    int t = type;
+    if (t == ft_autoinc)
+        t = 1;
+    if (t == ft_autoIncUnsigned)
+        t = 1;
+    else if (t == ft_logical)
+        t = 1;
+    else if (t == ft_uinteger)
+        t = 1;
+    else if (t == ft_currency)
+        t = 1;
+    else if ((t == ft_note) || (t == ft_zstring) || (t == ft_wzstring) ||
+             (t == ft_myvarchar) || (t == ft_mywvarchar) ||
+             (t == ft_myvarbinary) || (t == ft_mywvarbinary) ||
+             (t == ft_mytext) || (t == ft_guid) || (t == ft_lstring))
+        t = 0;
+    else if (t == ft_float)
+        t = 2;
+    else if ((t == ft_date) || (t == ft_mydate))
+        t = 3;
+    else if ((t == ft_time) || (t == ft_mytime))
+        t = 4;
+    else if ((t == ft_datetime) || (t == ft_mydatetime))
+        t = 30;
+    else if ((t == ft_lvar) || (t == ft_blob) || (t == ft_myblob))
+        t = ft_lvar;
+    return t;
+}
+
+string cppSrcGen::typeName(int t, int len)
+{
+    if ((t == 0) && (len == 1))
+        return "char";
+    else if (t == 0)
+        return "string";
+    else if ((t == 1) && (len == 4))
+        return "int";
+    else if ((t == 1) && (len == 2))
+        return "short";
+    else if ((t == 1) && (len == 1))
+        return "char";
+    else if ((t == 1) && (len == 8))
+        return "__int64";
+    else if ((t == 2) && (len == 4))
+        return "float";
+    else if ((t == 2) && (len == 8))
+        return "double";
+    else if (t == 3)
+        return "btrDate";
+    else if (t == 4)
+        return "btrTime";
+    return "";
+}
+
+const char* cppSrcGen::typeString(int type, int size)
+{
+    switch (type)
+    {
+    case ft_string:
+    case ft_note:
+    case ft_mychar:
+        if (size == 1)
+            return "char";
+        return "_tstring";
+    case ft_wstring:
+    case ft_mywchar:
+        if (size == 2)
+            return "wchar_t";
+        return "_tstring";
+    case ft_autoinc:
+    case ft_integer:
+        if (size == 1)
+            return "char";
+        else if (size == 2)
+            return "short";
+        else if ((size == 3) || (size == 4))
+            return "int";
+        else if (size == 8)
+            return "__int64";
+        THROW_BZS_ERROR_WITH_MSG(_T("Invalid int size"));
+    case ft_currency:
+    case ft_float:
+        if (size == 4)
+            return "float";
+        else if (size == 8)
+            return "double";
+        THROW_BZS_ERROR_WITH_MSG(_T("Invalid float size"));
+    case ft_date:
+    case ft_mydate:
+        return "td::btrDate";
+    case ft_time:
+    case ft_mytime:
+        return "td::btrTime";
+    case ft_datetime:
+    case ft_timestamp:
+        return "td::btrDateTime";
+    case ft_logical:
+        return "char";
+    case ft_zstring:
+    case ft_wzstring:
+    case ft_myvarchar:
+    case ft_mywvarchar:
+    case ft_myvarbinary:
+    case ft_mywvarbinary:
+    case ft_mytext:
+    case ft_guid:
+    case ft_lstring:
+        return "_tstring";
+    case ft_uinteger:
+    case ft_autoIncUnsigned:
+        if (size == 1)
+            return "unsigned char";
+        else if (size == 2)
+            return "unsigned short";
+        else if ((size == 3) || (size == 4))
+            return "unsigned int";
+        else if (size == 8)
+            return "unsigned __int64";
+        THROW_BZS_ERROR_WITH_MSG(_T("Invalid uint size"));
+    case ft_lvar:
+    case ft_myblob:
+        return "void*";
+    case ft_numericsts:
+    case ft_numericsa:
+    case ft_decimal:
+    case ft_mydatetime:
+    case ft_mytimestamp:
+        THROW_BZS_ERROR_WITH_MSG(_T("non support type"));
+    default:
+        THROW_BZS_ERROR_WITH_MSG(_T("invalid field type"));
+    }
+}
+
+void removeEndchar(string& s)
+{
+    while (s.size() && ((s[s.size() - 1] == '\t') || (s[s.size() - 1] == ',') ||
+                        (s[s.size() - 1] == '\n') || (s[s.size() - 1] == '\r')))
+        s.erase(s.end() - 1);
+}
+
+string cppSrcGen::makeDataMembaInitString()
+{
+    string retVal;
+    string retVal2;
+    int n = 0;
+    for (int i = 0; i < m_tabledef->fieldCount; i++)
+    {
+        fielddef* fd = &m_tabledef->fieldDefs[i];
+        int t = typeNum(fd->type);
+        string ts = typeString(fd->type, fd->len);
+        string name = membaName(fd);
+        if ((t != ft_date) && (t != ft_time) && (t != ft_datetime))
+        {
+            if ((t != ft_string) || (fd->len == 1))
+            {
+                retVal = retVal + name + "(0),";
+                if ((++n % 4) == 0)
+                    retVal += LF "\t\t";
+            }
+        }
+        if ((t == ft_time) || (t == ft_date))
+            retVal2 = retVal2 + "\t\t" + name + ".i = 0;" LF;
+        else if (t == ft_datetime)
+            retVal2 = retVal2 + "\t\t" + name + ".i64 = 0;" LF;
+    }
+    removeEndchar(retVal);
+    retVal2 = "\t{" LF + retVal2 + "\t}" LF;
+    return retVal + LF + retVal2;
+}
+
+string cppSrcGen::makeDataMembaString()
+{
+    string retVal;
+    for (int i = 0; i < m_tabledef->fieldCount; i++)
+    {
+        fielddef* fd = &m_tabledef->fieldDefs[i];
+        string ts = typeString(fd->type, fd->len);
+        int t = typeNum(fd->type);
+        if (t == ft_lvar)
+            ts = "vector<char>";
+        string name = membaName(fd);
+        retVal = retVal + "\t" + ts + " " + name + ";" LF;
+    }
+    return retVal;
+}
+
+string cppSrcGen::makeDataMembaFuncString()
+{
+    string retVal1;
+    string retVal2;
+
+    for (int i = 0; i < m_tabledef->fieldCount; i++)
+    {
+        fielddef* fd = &m_tabledef->fieldDefs[i];
+        int t = typeNum(fd->type);
+        string ts = typeString(fd->type, fd->len);
+        string name = membaName(fd);
+        string tmp;
+        string tmp2;
+        if ((typeNum(fd->type) == 0) && (fd->len != 1))
+        {
+            tmp = "const _TCHAR* " + m_pm.dataClassName + "::" +
+                  membaNameGet(name) + "()const" LF "{" LF "\treturn m_impl->" +
+                  name + ".c_str();" LF "}" LF;
+            tmp2 = "void " + m_pm.dataClassName + "::" + membaNameSet(name) +
+                   "(const _TCHAR* v)" LF "{" LF "\tm_impl->" + name +
+                   " = v;" LF "}" LF;
+        }
+        else if ((t == ft_time) || (t == ft_date))
+        {
+            tmp = string("const ") + ts + "& " + m_pm.dataClassName + "::" +
+                  membaNameGet(name) +
+                  "() const" LF "{" LF "\treturn m_impl->" + name + ";" LF
+                                                                    "}" LF;
+            tmp2 = "void " + m_pm.dataClassName + "::" + membaNameSet(name) +
+                   "(int v)" LF "{" LF "\tm_impl->" + name + ".i = v;" LF
+                                                             "}" LF;
+        }
+        else if (t == ft_datetime)
+        {
+            tmp = string("const ") + ts + "& " + m_pm.dataClassName + "::" +
+                  membaNameGet(name) +
+                  "() const" LF "{" LF "\treturn m_impl->" + name + ";" LF
+                                                                    "}" LF;
+            tmp2 = "void " + m_pm.dataClassName + "::" + membaNameSet(name) +
+                   "(__int64 v)" LF "{" LF "\tm_impl->" + name + ".i64 = v;" LF
+                                                                 "}" LF;
+        }
+        else if (t == ft_lvar)
+        {
+            tmp = string() + ts + string(" ") + m_pm.dataClassName + "::" +
+                  membaNameGet(name) + "(unsigned int& size) const" LF "{" LF
+                                       "\tsize=m_impl->" +
+                  name + ".size();" LF "\treturn &(m_impl->" + name + "[0]);" LF
+                                                                      "}" LF;
+            tmp2 = "void " + m_pm.dataClassName + "::" + membaNameSet(name) +
+                   "(" + ts + " v, unsigned int size)" LF "{" LF "\tm_impl->" +
+                   name + ".reserve(size);" LF "\tmemcpy(&m_impl->" + name +
+                   "[0], v , size);" LF "}";
+        }
+        else
+        {
+            tmp = string() + ts + string(" ") + m_pm.dataClassName + "::" +
+                  membaNameGet(name) +
+                  "() const" LF "{" LF "\treturn m_impl->" + name + ";" LF
+                                                                    "}" LF;
+            tmp2 = "void " + m_pm.dataClassName + "::" + membaNameSet(name) +
+                   "(" + ts + " v)" LF "{" LF "\tm_impl->" + name + " = v;" LF
+                                                                    "}" LF;
+        }
+        retVal1 = retVal1 + tmp + LF;
+        retVal2 = retVal2 + tmp2 + LF;
+    }
+    return retVal1 + retVal2;
+}
+
+string cppSrcGen::makeDataMembaFuncDecString()
+{
+
+    string retVal1;
+    string retVal2;
+    for (int i = 0; i < m_tabledef->fieldCount; i++)
+    {
+        fielddef* fd = &m_tabledef->fieldDefs[i];
+        int t = typeNum(fd->type);
+        string ts = typeString(fd->type, fd->len);
+        string name = membaName(fd);
+        string tmp;
+        string tmp2;
+        if ((t == 0) && (fd->len != 1))
+        {
+            tmp = "const _TCHAR* " + membaNameGet(name) + "()const;" LF;
+            tmp2 = "void " + membaNameSet(name) + "(const _TCHAR* v);" LF;
+        }
+        else if ((t == ft_time) || (t == ft_date))
+        {
+            tmp = string("const ") + ts + "& " + membaNameGet(name) +
+                  "() const;" LF;
+            tmp2 = "void " + membaNameSet(name) + "(int v);" LF;
+        }
+        else if (t == ft_datetime)
+        {
+            tmp = string("const ") + ts + "& " + membaNameGet(name) +
+                  "() const;" LF;
+            tmp2 = "void " + membaNameSet(name) + "(__int64 v);" LF;
+        }
+        else if (t == ft_lvar)
+        {
+
+            tmp = ts + " " + membaNameGet(name) +
+                  "(unsigned int& size) const;" LF;
+            tmp2 = "void " + membaNameSet(name) +
+                   "(void* v, unsigned int size);" LF;
+        }
+        else
+        {
+            tmp = ts + string(" ") + membaNameGet(name) + "() const;" LF;
+            tmp2 = "void " + membaNameSet(name) + "(" + ts + " v);" LF;
+        }
+        retVal1 = retVal1 + "\t" + tmp;
+        retVal2 = retVal2 + "\t" + tmp2;
+    }
+    return retVal1 + retVal2;
+}
+
+string cppSrcGen::makeFdiResolverString()
+{
+    string retVal;
+    for (int i = 0; i < m_tabledef->fieldCount; i++)
+    {
+        fielddef* fd = &m_tabledef->fieldDefs[i];
+        string name = membaName(fd);
+        retVal = retVal + "\t" + name + " = tb->fieldNumByName(_T(\"" +
+                 m_tabledef->fieldDefs[i].nameA() + "\"));" LF;
+    }
+    removeEndchar(retVal);
+    return retVal;
+}
+
+string cppSrcGen::makeMapReadStringLine(int i)
+{
+
+    fielddef* fd = &m_tabledef->fieldDefs[i];
+    string name = membaName(fd);
+
+    int t = typeNum(fd->type);
+    int n = fd->len;
+    string retVal = "\tm." + membaNameSet(name) + "(fds[m_fdi." + name + "].";
+    char tmp[30];
+    if ((t == ft_string) && (n == 1))
+        retVal += string("i8()");
+    else if (t == ft_string)
+        retVal += string("c_str()");
+    else if ((t == ft_float) && (n == 4))
+        retVal += string("f()");
+    else if ((t == ft_float) && (n == 8))
+        retVal += string("d()");
+    else if ((t == ft_integer) || (t == ft_date) || (t == ft_time))
+        retVal += intReadMenbaName(fd);
+    else if (t == ft_lvar)
+    {
+        retVal.insert(1, "unsigned int size;" LF "\t");
+        retVal += string("getBin(size), size");
+    }
+    else
+    {
+        _ltoa_s(t, tmp, 30, 10);
+        retVal = string("unknown type:") + tmp;
+    }
+    retVal += string(");" LF);
+    return retVal;
+}
+
+string cppSrcGen::makeMapReadString()
+{
+    string retVal;
+
+    for (int i = 0; i < m_tabledef->fieldCount; i++)
+        retVal = retVal + makeMapReadStringLine(i);
+    removeEndchar(retVal);
+    return retVal;
+}
+
+string cppSrcGen::makeMapWriteStringLine(int index)
+{
+    fielddef* fd = &m_tabledef->fieldDefs[index];
+    string name = membaName(fd);
+    int t = typeNum(fd->type);
+
+    string s = "\tfds[m_fdi." + name + "] = m." + membaNameGet(name) + "()";
+    if ((t == ft_time) || (t == ft_date))
+        s += string(".i");
+    else if (t == ft_datetime)
+        s += string(".i64");
+    else if (t == ft_lvar)
+    {
+        s = "\t{" LF "\t\tunsigned int size;" LF;
+        s += "\t\tvoid* p = m." + membaNameGet(name) + "(size);" LF;
+        s += "\t\tfds[m_fdi." + name + "].setBin(p, size);" LF "\t}";
+    }
+    s += string(";" LF);
+    return s;
+}
+
+string cppSrcGen::makeMapWriteString()
+{
+    string retVal;
+    for (int i = 0; i < m_tabledef->fieldCount; i++)
+        retVal = retVal + makeMapWriteStringLine(i);
+    removeEndchar(retVal);
+    return retVal;
+}
+
+string cppSrcGen::makeMapKeyCompString()
+{
+    string ret;
+    if ((m_tabledef->primaryKeyNum >= 0) &&
+        (m_tabledef->primaryKeyNum < m_tabledef->keyCount))
+    {
+        keydef* kd = &m_tabledef->keyDefs[m_tabledef->primaryKeyNum];
+        string idt = "\t";
+        size_t pos = 0;
+        string tostr = "";
+        string tostrend = "";
+        for (int i = 0; i < kd->segmentCount; i++)
+        {
+            fielddef* fd = &(m_tabledef->fieldDefs[kd->segments[i].fieldNum]);
+
+            string s = membaName(fd) + "()";
+            int t = typeNum(fd->type);
+            if (t == 0 && (fd->len > 1))
+            {
+                tostr = "std::string(";
+                tostrend = ")";
+            }
+            else
+            {
+                tostr = "";
+                tostrend = "";
+            }
+            if ((t == ft_time) || (t == ft_date))
+                s += string(".i");
+            else if (t == ft_datetime)
+                s += string(".i64");
+            string tmp;
+            size_t size = 0;
+            if (i != kd->segmentCount - 1)
+            {
+                tmp = idt + "if (" + tostr + "l." + s + tostrend + " == " +
+                      tostr + "r." + s + tostrend + ")" LF + idt + "{" LF;
+                size = tmp.size();
+                if (i == 0)
+                    tmp += idt + "}" LF;
+                else
+                    tmp += idt + "}" LF + idt + "else" LF "\t";
+            }
+            tmp += idt + "return (" + tostr + "l." + s + tostrend + " < " +
+                   tostr + "r." + s + tostrend + ");" LF;
+            ret.insert(pos, tmp);
+            idt += "\t";
+            pos += size;
+        }
+    }
+    else
+        ret = "\t return true;" LF;
+    removeEndchar(ret);
+    return ret;
+}
+
+string cppSrcGen::makeMapKeyValueString()
+{
+    string s = "\tswitch (keyNum)" LF "\t{" LF;
+    char buf[20];
+
+    for (int j = 0; j < m_tabledef->keyCount; ++j)
+    {
+        _ltoa_s(j, buf, 20, 10);
+        s += "\tcase " + string(buf) + ":" LF;
+        for (int i = 0; i < m_tabledef->keyDefs[j].segmentCount; i++)
+            s += "\t" + makeMapWriteStringLine(
+                            m_tabledef->keyDefs[j].segments[i].fieldNum);
+        s += "\t\tbreak;" LF;
+    }
+    s += "\t}" LF;
+    removeEndchar(s);
+    return s;
+}
+
+string cppSrcGen::makeMapAutoIncString()
+{
+    string retVal;
+    for (int i = 0; i < m_tabledef->fieldCount; i++)
+    {
+        fielddef* fd = &(m_tabledef->fieldDefs[i]);
+        if ((fd->type == ft_autoinc) || (fd->type == ft_autoIncUnsigned))
+        {
+            string name = membaName(fd);
+            retVal = retVal + "\tm." + membaNameSet(name) + "(fds[m_fdi." +
+                     name + "]." + intReadMenbaName(fd) + ");" LF;
+        }
+    }
+    removeEndchar(retVal);
+    return retVal;
+}
+
+string cppSrcGen::makeMapKeyEnumString()
+{
+    string s = "\t";
+    for (int j = 0; j < m_tabledef->keyCount; ++j)
+    {
+        const keydef& kd = m_tabledef->keyDefs[j];
+        int n = std::min<int>(4, kd.segmentCount);
+        for (int i = 0; i < n; ++i)
+        {
+            fielddef* fd = &(m_tabledef->fieldDefs[kd.segments[i].fieldNum]);
+            s += membaName(fd) + "_";
+        }
+        s.erase(s.end() - 1);
+        s += string("," LF "\t\t");
+    }
+    removeEndchar(s);
+    return s;
+}
+
+string cppSrcGen::makeFileName(bool data, bool header)
+{
+    string s = m_pm.dataClassName;
+    if (!data)
+        s += string(MAP_CLASS_SUFFIX);
+    if (header)
+        return m_pm.saveDir + PSEPARATOR_A + s + ".h";
+    else
+        return m_pm.saveDir + PSEPARATOR_A + s + ".cpp";
+}
+
+string cppSrcGen::makeNameSpaceBegin(const vector<string>& list)
+{
+    vector<string>::const_iterator it = list.begin();
+    string s;
+    while (it != list.end())
+        s += string("namespace ") + *it++ + LF "{" LF;
+    return s;
+}
+
+string cppSrcGen::makeNameSpaceEnd(const vector<string>& list)
+{
+    vector<string>::const_iterator it = list.begin();
+    string s;
+    while (it != list.end())
+        s.insert(0, string("}//") + "namespace " + *it++ + LF);
+    return s;
+}
+
+string cppSrcGen::makeIncludeGurdeString(bool data)
+{
+    const vector<string>& list =
+        data ? m_pm.name_spaces() : m_pm.name_spaces_map();
+
+    vector<string>::const_iterator it = list.begin();
+    string s;
+    while (it != list.end())
+        s += *it++ + string("_");
+    s += m_pm.dataClassName;
+    boost::algorithm::to_upper(s);
+    return s;
+}
+
+bool cppSrcGen::doMake(const string templeHeader, const string templeCpp,
+                       bool data)
+{
+    // header
+    {
+        string hd;
+        loadFromFile(templeHeader, hd);
+        replace(hd, "%className%", m_pm.dataClassName);
+        replace(hd, "%extern%", m_pm.externWord);
+        replace(hd, "%includegurde%", makeIncludeGurdeString(data));
+        if (data)
+        {
+            replace(hd, "%dataClassMembaFuncDec%",
+                    makeDataMembaFuncDecString());
+            replace(hd, "%nameSpaceBegin%",
+                    makeNameSpaceBegin(m_pm.name_spaces()));
+            replace(hd, "%nameSpaceEnd%", makeNameSpaceEnd(m_pm.name_spaces()));
+        }
+        else
+        {
+            replace(hd, "%keyEnum%", makeMapKeyEnumString());
+            replace(hd, "%tableName%", string(m_tabledef->tableNameA()));
+            replace(hd, "%fdiMemba%", makeFdiMembaString());
+            replace(hd, "%nameSpaceMapBegin%",
+                    makeNameSpaceBegin(m_pm.name_spaces_map()));
+            replace(hd, "%nameSpaceMapEnd%",
+                    makeNameSpaceEnd(m_pm.name_spaces_map()));
+        }
+        saveToFile(makeFileName(data, true), hd);
+    }
+
+    // cpp
+    {
+
+        string cpp;
+        loadFromFile(templeCpp, cpp);
+        replace(cpp, "%className%", m_pm.dataClassName);
+        if (data)
+        {
+            replace(cpp, "%datamemba%", makeDataMembaString());
+            replace(cpp, "%menbaInit%", makeDataMembaInitString());
+            replace(cpp, "%dataClassMembaFunc%", makeDataMembaFuncString());
+            replace(cpp, "%nameSpaceBegin%",
+                    makeNameSpaceBegin(m_pm.name_spaces()));
+            replace(cpp, "%nameSpaceEnd%",
+                    makeNameSpaceEnd(m_pm.name_spaces()));
+        }
+        else
+        {
+            replace(cpp, "%fdiResolver%", makeFdiResolverString());
+            replace(cpp, "%read%", makeMapReadString());
+            replace(cpp, "%writeKeyValue%", makeMapKeyValueString());
+            replace(cpp, "%write%", makeMapWriteString());
+            replace(cpp, "%autoinc%", makeMapAutoIncString());
+            replace(cpp, "%keyComp%", makeMapKeyCompString());
+            replace(cpp, "%nameSpaceMapBegin%",
+                    makeNameSpaceBegin(m_pm.name_spaces_map()));
+            replace(cpp, "%nameSpaceMapEnd%",
+                    makeNameSpaceEnd(m_pm.name_spaces_map()));
+        }
+        saveToFile(makeFileName(data, false), cpp);
+    }
+    return true;
+}
+
+void cppSrcGen::make()
+{
+
+    if (m_pm.fieldRenameList != "")
+        m_fnames.loadFromFile(m_pm.fieldRenameList);
+    if (m_pm.dataClassName == "")
+        m_pm.dataClassName = m_fnames.getName(m_tabledef->tableNameA());
+    if (m_pm.file[0] != "")
+        doMake(m_pm.file[0] + ".h", m_pm.file[0] + ".cpp", true);
+    if (m_pm.file[1] != "")
+        doMake(m_pm.file[1] + ".h", m_pm.file[1] + ".cpp", false);
+}