Changeset 1162:3d7c2150b7af

Timestamp:

02/22/09 14:15:38 (3 years ago)

Author:

niam

Branch:

libdodo

Message:

uncrustify

Files:

• trunk/src/cgiBasicExchange.cc (modified) (1 diff)
• trunk/src/cgiBasicServer.cc (modified) (1 diff)
• trunk/src/cgiDialogue.cc (modified) (23 diffs)
• trunk/src/cgiFastExchange.cc (modified) (8 diffs)
• trunk/src/cgiFastServer.cc (modified) (4 diffs)
• trunk/src/dataBaseAccumulator.cc (modified) (20 diffs)
• trunk/src/dataBaseMysql.cc (modified) (15 diffs)
• trunk/src/dataBasePostgresql.cc (modified) (17 diffs)
• trunk/src/dataBaseSqlConstructor.cc (modified) (15 diffs)
• trunk/src/dataBaseSqlite.cc (modified) (17 diffs)
• trunk/src/dataFormatJsonNode.cc (modified) (16 diffs)
• trunk/src/dataFormatJsonProcessor.cc (modified) (6 diffs)
• trunk/src/dataFormatXmlNode.cc (modified) (6 diffs)
• trunk/src/dataFormatXmlProcessor.cc (modified) (19 diffs)
• trunk/src/dataMemoryShared.cc (modified) (7 diffs)
• trunk/src/dataTplProcessor.cc (modified) (28 diffs)
• trunk/src/exceptionBasic.cc (modified) (12 diffs)
• trunk/src/graphicsDraw.cc (modified) (8 diffs)
• trunk/src/graphicsImage.cc (modified) (20 diffs)
• trunk/src/graphicsTransform.cc (modified) (4 diffs)
• trunk/src/ioChannel.cc (modified) (4 diffs)
• trunk/src/ioEvent.cc (modified) (6 diffs)
• trunk/src/ioFileFifo.cc (modified) (16 diffs)
• trunk/src/ioFileRegular.cc (modified) (16 diffs)
• trunk/src/ioFileTemp.cc (modified) (12 diffs)
• trunk/src/ioNetworkClient.cc (modified) (6 diffs)
• trunk/src/ioNetworkConnection.cc (modified) (18 diffs)
• trunk/src/ioNetworkExchange.cc (modified) (10 diffs)
• trunk/src/ioNetworkHttp.cc (modified) (28 diffs)
• trunk/src/ioNetworkServer.cc (modified) (10 diffs)
• trunk/src/ioNetworkSslClient.cc (modified) (10 diffs)
• trunk/src/ioNetworkSslExchange.cc (modified) (8 diffs)
• trunk/src/ioNetworkSslServer.cc (modified) (12 diffs)
• trunk/src/ioPipe.cc (modified) (13 diffs)
• trunk/src/ioSsl.cc (modified) (1 diff)
• trunk/src/ioStdio.cc (modified) (5 diffs)
• trunk/src/ioString.cc (modified) (10 diffs)
• trunk/src/pcProcessCollection.cc (modified) (21 diffs)
• trunk/src/pcSyncProcessDataCollection.cc (modified) (6 diffs)
• trunk/src/pcSyncProcessDataSingle.cc (modified) (7 diffs)
• trunk/src/pcSyncProcessSection.cc (modified) (5 diffs)
• trunk/src/pcSyncThreadDataCollection.cc (modified) (6 diffs)
• trunk/src/pcSyncThreadDataSingle.cc (modified) (4 diffs)
• trunk/src/pcSyncThreadSection.cc (modified) (2 diffs)
• trunk/src/pcThreadCollection.cc (modified) (23 diffs)
• trunk/src/rpcCgiServer.cc (modified) (2 diffs)
• trunk/src/rpcClient.cc (modified) (1 diff)
• trunk/src/rpcHttpClient.cc (modified) (2 diffs)
• trunk/src/rpcJsonClient.cc (modified) (5 diffs)
• trunk/src/rpcJsonMethod.cc (modified) (2 diffs)
• trunk/src/rpcJsonResponse.cc (modified) (2 diffs)
• trunk/src/rpcJsonServer.cc (modified) (4 diffs)
• trunk/src/rpcJsonValue.cc (modified) (4 diffs)
• trunk/src/rpcMethod.cc (modified) (3 diffs)
• trunk/src/rpcResponse.cc (modified) (7 diffs)
• trunk/src/rpcServer.cc (modified) (5 diffs)
• trunk/src/rpcValue.cc (modified) (16 diffs)
• trunk/src/rpcXmlClient.cc (modified) (4 diffs)
• trunk/src/rpcXmlMethod.cc (modified) (2 diffs)
• trunk/src/rpcXmlResponse.cc (modified) (2 diffs)
• trunk/src/rpcXmlServer.cc (modified) (4 diffs)
• trunk/src/rpcXmlValue.cc (modified) (3 diffs)
• trunk/src/toolsCode.cc (modified) (50 diffs)
• trunk/src/toolsFilesystem.cc (modified) (36 diffs)
• trunk/src/toolsLibrary.cc (modified) (4 diffs)
• trunk/src/toolsLogger.cc (modified) (4 diffs)
• trunk/src/toolsMisc.cc (modified) (15 diffs)
• trunk/src/toolsNetwork.cc (modified) (12 diffs)
• trunk/src/toolsOs.cc (modified) (48 diffs)
• trunk/src/toolsRegexp.cc (modified) (6 diffs)
• trunk/src/toolsString.cc (modified) (30 diffs)
• trunk/src/toolsTime.cc (modified) (9 diffs)
• trunk/src/xexec.cc (modified) (33 diffs)
• uncrustify/.uncrustify.cfg (modified) (2 diffs)

trunk/src/cgiBasicExchange.cc

@@ -55 +55 @@
 //-------------------------------------------------------------------
 
-char *exchange::getenv(const char *buf)
+char *
+exchange::getenv(const char *buf)
 {
         return ::getenv(buf);

trunk/src/cgiBasicServer.cc

@@ -50 +50 @@
 //-------------------------------------------------------------------
 
-void server::serve(serverHandler func)
+void
+server::serve(serverHandler func)
 {
         exchange cSTD;

trunk/src/cgiDialogue.cc

@@ -236 +236 @@
 //-------------------------------------------------------------------
 
-dialogue::operator exchange*()
+dialogue::operator exchange
+*()
 {
         printHeaders();
@@ -245 +246 @@
 //-------------------------------------------------------------------
 
-void dialogue::flush()
+void
+dialogue::flush()
 {
         cgiIO.flush();
@@ -252 +254 @@
 //-------------------------------------------------------------------
 
-void dialogue::printStream(const dodoString &buf)
+void
+dialogue::printStream(const dodoString &buf)
 {
         printHeaders();
@@ -261 +264 @@
 //-------------------------------------------------------------------
 
-dodoString dialogue::getCharset()
+dodoString
+dialogue::getCharset()
 {
         unsigned long temp;
@@ -280 +284 @@
 }
 
-void dialogue::print(const dodoString &buf)
+void
+dialogue::print(const dodoString &buf)
 {
         printHeaders();
@@ -290 +295 @@
 //-------------------------------------------------------------------
 
-void dialogue::makeAuth()
+void
+dialogue::makeAuth()
 {
         dodoString &httpAuthorization = ENVIRONMENT[CGI_ENVIRONMENT_HTTPAUTHORIZATION];
@@ -399 +405 @@
 //-------------------------------------------------------------------
 
-void dialogue::requestAuthentication(const dodoString &realm,
-                                                                         short            type)
+void
+dialogue::requestAuthentication(const dodoString &realm,
+                                                                short            type)
 {
         returnCode = CGI_STATUSCODE_UNAUTHORIZED;
@@ -421 +428 @@
 //-------------------------------------------------------------------
 
-__cgiAuthInfo dialogue::getAuthenticationInfo()
+__cgiAuthInfo
+dialogue::getAuthenticationInfo()
 {
         __cgiAuthInfo info =
@@ -433 +441 @@
 //-------------------------------------------------------------------
 
-bool dialogue::isAuthenticated(const dodoString &user,
-                                                           const dodoString &password)
+bool
+dialogue::isAuthenticated(const dodoString &user,
+                                                  const dodoString &password)
 {
         if (authInfo.type == CGI_AUTHTYPE_BASIC)
@@ -492 +501 @@
 //-------------------------------------------------------------------
 
-void dialogue::cleanTmp()
+void
+dialogue::cleanTmp()
 {
         dodoMap<dodoString, __cgiFile>::iterator i(FILES.begin()), j(FILES.end());
@@ -506 +516 @@
 //-------------------------------------------------------------------
 
-void dialogue::detectMethod()
+void
+dialogue::detectMethod()
 {
         if (tools::string::iequal(ENVIRONMENT[CGI_ENVIRONMENT_REQUESTMETHOD], "GET"))
@@ -527 +538 @@
 //-------------------------------------------------------------------
 
-int dialogue::getMethod() const
+int
+dialogue::getMethod() const
 {
         return method;
@@ -534 +546 @@
 //-------------------------------------------------------------------
 
-void dialogue::make(dodoStringMap    &val,
-                                        const dodoString &string,
-                                        const char       *delim)
+void
+dialogue::make(dodoStringMap    &val,
+                           const dodoString &string,
+                           const char       *delim)
 {
         dodoStringArray getPair = tools::misc::split(tools::code::decodeUrl(string), delim);
@@ -556 +569 @@
 //-------------------------------------------------------------------
 
-void dialogue::makeEnv()
+void
+dialogue::makeEnv()
 {
         char *env;
@@ -612 +626 @@
 //-------------------------------------------------------------------
 
-void dialogue::initHeaders(dodoMap<short, dodoString> &headers)
+void
+dialogue::initHeaders(dodoMap<short, dodoString> &headers)
 {
         if (headers.size() > 0)
@@ -627 +642 @@
 //-------------------------------------------------------------------
 
-void dialogue::setResponseStatus(short code)
+void
+dialogue::setResponseStatus(short code)
 {
         if (code <= CGI_STATUSCODE_HTTPVERSIONNOTSUPPORTED)
@@ -641 +657 @@
 //-------------------------------------------------------------------
 
-void dialogue::printHeaders() const
+void
+dialogue::printHeaders() const
 {
         if (headersPrinted)
@@ -691 +708 @@
 //-------------------------------------------------------------------
 
-void dialogue::makeContent()
+void
+dialogue::makeContent()
 {
         unsigned long inSize = tools::string::stringToUL(ENVIRONMENT[CGI_ENVIRONMENT_CONTENTLENGTH]);
@@ -707 +725 @@
 //-------------------------------------------------------------------
 
-void dialogue::makePost()
+void
+dialogue::makePost()
 {
         if (content.size() == 0)
@@ -843 +862 @@
                                                                         switch (errno)
                                                                         {
-                                                                                case EACCES:
-                                                                                case EISDIR:
-
-                                                                                        file.error = CGI_POSTFILEERR_ACCESS_DENY;
-
-                                                                                        break;
-
-                                                                                case ENAMETOOLONG:
-                                                                                case ENOTDIR:
-
-                                                                                        file.error = CGI_POSTFILEERR_BAD_FILE_NAME;
-
-                                                                                        break;
-
-                                                                                case ENOMEM:
-
-                                                                                        file.error = CGI_POSTFILEERR_NO_SPACE;
-
-                                                                                        break;
-
-                                                                                default:
-
-                                                                                        throw exception::basic(exception::ERRMODULE_CGIDIALOGUE, DIALOGUEEX_MAKEPOST, exception::ERRNO_ERRNO, errno, strerror(errno), __LINE__, __FILE__);
+                                                                        case EACCES:
+                                                                        case EISDIR:
+
+                                                                                file.error = CGI_POSTFILEERR_ACCESS_DENY;
+
+                                                                                break;
+
+                                                                        case ENAMETOOLONG:
+                                                                        case ENOTDIR:
+
+                                                                                file.error = CGI_POSTFILEERR_BAD_FILE_NAME;
+
+                                                                                break;
+
+                                                                        case ENOMEM:
+
+                                                                                file.error = CGI_POSTFILEERR_NO_SPACE;
+
+                                                                                break;
+
+                                                                        default:
+
+                                                                                throw exception::basic(exception::ERRMODULE_CGIDIALOGUE, DIALOGUEEX_MAKEPOST, exception::ERRNO_ERRNO, errno, strerror(errno), __LINE__, __FILE__);
                                                                         }
                                                                 }
@@ -940 +959 @@
 //-------------------------------------------------------------------
 
-dodoString dialogue::request(const dodoString &varName)
+dodoString
+dialogue::request(const dodoString &varName)
 {
         dodoStringMap::iterator item = GET.find(varName);
@@ -959 +979 @@
 //-------------------------------------------------------------------
 
-void dialogue::setCookie(const dodoString &name,
-                                                 const dodoString &value,
-                                                 const dodoString &expires,
-                                                 const dodoString &path,
-                                                 const dodoString &domain,
-                                                 bool             secure)
+void
+dialogue::setCookie(const dodoString &name,
+                                        const dodoString &value,
+                                        const dodoString &expires,
+                                        const dodoString &path,
+                                        const dodoString &domain,
+                                        bool             secure)
 {
         __cgiCookie temp(secure);
@@ -978 +999 @@
 //-------------------------------------------------------------------
 
-void dialogue::setCookie(const __cgiCookie &cookie)
+void
+dialogue::setCookie(const __cgiCookie &cookie)
 {
         cookies.push_back(cookie);

trunk/src/cgiFastExchange.cc

@@ -57 +57 @@
 //-------------------------------------------------------------------
 
-void exchange::flush()
+void
+exchange::flush()
 {
         if (FCGX_FFlush(request->out) == -1)
@@ -67 +68 @@
 //-------------------------------------------------------------------
 
-char *exchange::getenv(const char *buf)
+char *
+exchange::getenv(const char *buf)
 {
         return FCGX_GetParam(buf, request->envp);
@@ -74 +76 @@
 //-------------------------------------------------------------------
 
-int exchange::getInDescriptor() const
+int
+exchange::getInDescriptor() const
 {
         return -1;
@@ -81 +84 @@
 //-------------------------------------------------------------------
 
-int exchange::getOutDescriptor() const
+int
+exchange::getOutDescriptor() const
 {
         return -1;
@@ -88 +92 @@
 //-------------------------------------------------------------------
 
-void exchange::_read(char * const a_data)
+void
+exchange::_read(char * const a_data)
 {
         memset(a_data, '\0', inSize);
@@ -97 +102 @@
 //-------------------------------------------------------------------
 
-void exchange::_write(const char *const buf)
+void
+exchange::_write(const char *const buf)
 {
         if (FCGX_PutStr(buf, outSize, request->out) == -1)
@@ -107 +113 @@
 //-------------------------------------------------------------------
 
-void exchange::_writeStream(const char * const data)
+void
+exchange::_writeStream(const char * const data)
 {
         unsigned long _outSize = outSize;
@@ -134 +141 @@
 //-------------------------------------------------------------------
 
-unsigned long exchange::_readStream(char * const data)
+unsigned long
+exchange::_readStream(char * const data)
 {
         unsigned long _inSize = inSize++;

trunk/src/cgiFastServer.cc

@@ -54 +54 @@
 //-------------------------------------------------------------------
 
-void dummyStackThread(dodo::cgi::exchange &data)
+void
+dummyStackThread(dodo::cgi::exchange &data)
 {
 }
@@ -116 +117 @@
 #ifdef PTHREAD_EXT
 
-void *server::stackThread(void *data)
+void *
+server::stackThread(void *data)
 {
         FCGX_Request request;
@@ -164 +166 @@
 //-------------------------------------------------------------------
 
-void server::serve(serverHandler func)
+void
+server::serve(serverHandler func)
 {
         if (!isFastCgi())
@@ -228 +231 @@
 //-------------------------------------------------------------------
 
-bool server::isFastCgi()
+bool
+server::isFastCgi()
 {
         return !FCGX_IsCGI();

trunk/src/dataBaseAccumulator.cc

@@ -63 +63 @@
 //-------------------------------------------------------------------
 
-void accumulator::callFunction(const dodoString      &name,
-                                                           const dodoStringArray &arguments,
-                                                           const dodoString      &as)
+void
+accumulator::callFunction(const dodoString      &name,
+                                                  const dodoStringArray &arguments,
+                                                  const dodoString      &as)
 {
         collectedData.qType = ACCUMULATOR_REQUEST_CALL_FUNCTION;
@@ -87 +88 @@
 //-------------------------------------------------------------------
 
-void accumulator::callProcedure(const dodoString      &name,
-                                                                const dodoStringArray &arguments)
+void
+accumulator::callProcedure(const dodoString      &name,
+                                                   const dodoStringArray &arguments)
 {
         collectedData.qType = ACCUMULATOR_REQUEST_CALL_PROCEDURE;
@@ -102 +104 @@
 //-------------------------------------------------------------------
 
-void accumulator::select(const dodoString      &a_table,
-                                                 const dodoStringArray &a_fields,
-                                                 const dodoString      &a_where)
+void
+accumulator::select(const dodoString      &a_table,
+                                        const dodoStringArray &a_fields,
+                                        const dodoString      &a_where)
 {
         collectedData.qType = ACCUMULATOR_REQUEST_SELECT;
@@ -126 +129 @@
 //-------------------------------------------------------------------
 
-void accumulator::selectAll(const dodoString &a_table,
-                                                        const dodoString &a_where)
+void
+accumulator::selectAll(const dodoString &a_table,
+                                           const dodoString &a_where)
 {
         collectedData.qType = ACCUMULATOR_REQUEST_SELECT;
@@ -150 +154 @@
 //-------------------------------------------------------------------
 
-void accumulator::insert(const dodoString    &a_table,
-                                                 const dodoStringMap &a_fields)
+void
+accumulator::insert(const dodoString    &a_table,
+                                        const dodoStringMap &a_fields)
 {
         collectedData.qType = ACCUMULATOR_REQUEST_INSERT;
@@ -177 +182 @@
 //-------------------------------------------------------------------
 
-void accumulator::insert(const dodoString               &a_table,
-                                                 const dodoArray<dodoStringMap> &a_fields)
+void
+accumulator::insert(const dodoString               &a_table,
+                                        const dodoArray<dodoStringMap> &a_fields)
 {
         collectedData.qType = ACCUMULATOR_REQUEST_INSERT;
@@ -217 +223 @@
 //-------------------------------------------------------------------
 
-void accumulator::insert(const dodoString      &a_table,
-                                                 const dodoStringArray &a_values,
-                                                 const dodoStringArray &a_fields)
+void
+accumulator::insert(const dodoString      &a_table,
+                                        const dodoStringArray &a_values,
+                                        const dodoStringArray &a_fields)
 {
         collectedData.qType = ACCUMULATOR_REQUEST_INSERT;
@@ -237 +244 @@
 //-------------------------------------------------------------------
 
-void accumulator::insert(const dodoString                 &a_table,
-                                                 const dodoArray<dodoStringArray> &a_values,
-                                                 const dodoStringArray            &a_fields)
+void
+accumulator::insert(const dodoString                 &a_table,
+                                        const dodoArray<dodoStringArray> &a_values,
+                                        const dodoStringArray            &a_fields)
 {
         collectedData.qType = ACCUMULATOR_REQUEST_INSERT;
@@ -259 +267 @@
 //-------------------------------------------------------------------
 
-void accumulator::insertSelect(const dodoString      &a_tableTo,
-                                                           const dodoString      &a_tableFrom,
-                                                           const dodoStringArray &a_fieldsTo,
-                                                           const dodoStringArray &a_fieldsFrom,
-                                                           const dodoString      &a_where)
+void
+accumulator::insertSelect(const dodoString      &a_tableTo,
+                                                  const dodoString      &a_tableFrom,
+                                                  const dodoStringArray &a_fieldsTo,
+                                                  const dodoStringArray &a_fieldsFrom,
+                                                  const dodoString      &a_where)
 {
         collectedData.qType = ACCUMULATOR_REQUEST_INSERT_SELECT;
@@ -290 +299 @@
 //-------------------------------------------------------------------
 
-void accumulator::update(const dodoString    &a_table,
-                                                 const dodoStringMap &a_fields,
-                                                 const dodoString    &a_where)
+void
+accumulator::update(const dodoString    &a_table,
+                                        const dodoStringMap &a_fields,
+                                        const dodoString    &a_where)
 {
         collectedData.qType = ACCUMULATOR_REQUEST_UPDATE;
@@ -327 +337 @@
 //-------------------------------------------------------------------
 
-void accumulator::update(const dodoString      &a_table,
-                                                 const dodoStringArray &a_values,
-                                                 const dodoStringArray &a_fields,
-                                                 const dodoString      &a_where)
+void
+accumulator::update(const dodoString      &a_table,
+                                        const dodoStringArray &a_values,
+                                        const dodoStringArray &a_fields,
+                                        const dodoString      &a_where)
 {
         collectedData.qType = ACCUMULATOR_REQUEST_UPDATE;
@@ -356 +367 @@
 //-------------------------------------------------------------------
 
-void accumulator::del(const dodoString &a_table,
-                                          const dodoString &a_where)
+void
+accumulator::del(const dodoString &a_table,
+                                 const dodoString &a_where)
 {
         collectedData.qType = ACCUMULATOR_REQUEST_DELETE;
@@ -380 +392 @@
 //-------------------------------------------------------------------
 
-void accumulator::subquery(const dodoStringArray &sub,
-                                                   int                   type)
+void
+accumulator::subquery(const dodoStringArray &sub,
+                                          int                   type)
 {
         collectedData.qType = type;
@@ -390 +403 @@
 //-------------------------------------------------------------------
 
-void accumulator::limit(unsigned int a_number)
+void
+accumulator::limit(unsigned int a_number)
 {
         addFlag(collectedData.qShift, 1 << ACCUMULATOR_ADDREQUEST_LIMIT);
@@ -398 +412 @@
 //-------------------------------------------------------------------
 
-void accumulator::offset(unsigned int a_number)
+void
+accumulator::offset(unsigned int a_number)
 {
         addFlag(collectedData.qShift, 1 << ACCUMULATOR_ADDREQUEST_OFFSET);
@@ -407 +422 @@
 //-------------------------------------------------------------------
 
-void accumulator::order(const dodoString &order)
+void
+accumulator::order(const dodoString &order)
 {
         collectedData.order = order;
@@ -416 +432 @@
 //-------------------------------------------------------------------
 
-void accumulator::group(const dodoString &group)
+void
+accumulator::group(const dodoString &group)
 {
         collectedData.group = group;
@@ -425 +442 @@
 //-------------------------------------------------------------------
 
-void accumulator::having(const dodoString &having)
+void
+accumulator::having(const dodoString &having)
 {
         collectedData.having = having;
@@ -434 +452 @@
 //-------------------------------------------------------------------
 
-void accumulator::join(const dodoString &table,
-                                           int              type,
-                                           const dodoString &condition)
+void
+accumulator::join(const dodoString &table,
+                                  int              type,
+                                  const dodoString &condition)
 {
         collectedData.joinTables.push_back(table);
@@ -447 +466 @@
 //-------------------------------------------------------------------
 
-void accumulator::cleanCollected()
+void
+accumulator::cleanCollected()
 {
         collectedData.qType = -1;

trunk/src/dataBaseMysql.cc

@@ -112 +112 @@
 //-------------------------------------------------------------------
 
-void mysql::connectSettings(unsigned long           a_type,
-                                                        const __mysqlSslOptions &options)
+void
+mysql::connectSettings(unsigned long           a_type,
+                                           const __mysqlSslOptions &options)
 {
         if (mysqlHandle == NULL)
@@ -135 +136 @@
 //-------------------------------------------------------------------
 
-void mysql::connect(const __connectionInfo &info)
+void
+mysql::connect(const __connectionInfo &info)
 {
         collectedData.dbInfo = info;
@@ -189 +191 @@
 //-------------------------------------------------------------------
 
-void mysql::disconnect()
+void
+mysql::disconnect()
 {
         if (mysqlHandle != NULL)
@@ -216 +219 @@
 //-------------------------------------------------------------------
 
-dodoArray<dodo::dodoStringArray>mysql::fetchRows() const
+dodoArray<dodo::dodoStringArray>
+mysql::fetchRows() const
 {
         if (mysqlHandle == NULL)
@@ -283 +287 @@
 //-------------------------------------------------------------------
 
-dodo::dodoStringArray mysql::fetchFields() const
+dodo::dodoStringArray
+mysql::fetchFields() const
 {
         if (mysqlHandle == NULL)
@@ -325 +330 @@
 //-------------------------------------------------------------------
 
-__tuples mysql::fetch() const
+__tuples
+mysql::fetch() const
 {
         return __tuples(fetchRows(), fetchFields());
@@ -332 +338 @@
 //-------------------------------------------------------------------
 
-unsigned int mysql::rowsCount() const
+unsigned int
+mysql::rowsCount() const
 {
         if (mysqlHandle == NULL)
@@ -351 +358 @@
 //-------------------------------------------------------------------
 
-unsigned int mysql::fieldsCount() const
+unsigned int
+mysql::fieldsCount() const
 {
         if (mysqlHandle == NULL)
@@ -370 +378 @@
 //-------------------------------------------------------------------
 
-unsigned int mysql::affectedRowsCount() const
+unsigned int
+mysql::affectedRowsCount() const
 {
         if (mysqlHandle == NULL)
@@ -389 +398 @@
 //-------------------------------------------------------------------
 
-void mysql::getFieldsTypes(const dodoString &table)
+void
+mysql::getFieldsTypes(const dodoString &table)
 {
         if (mysqlHandle == NULL)
@@ -495 +505 @@
 //-------------------------------------------------------------------
 
-void mysql::exec(const dodoString &query,
-                                 bool             result)
+void
+mysql::exec(const dodoString &query,
+                        bool             result)
 {
         if (mysqlHandle == NULL)
@@ -562 +573 @@
 //-------------------------------------------------------------------
 
-void mysql::setCharset(const dodoString &charset)
+void
+mysql::setCharset(const dodoString &charset)
 {
         if (mysqlHandle == NULL)
@@ -574 +586 @@
 //-------------------------------------------------------------------
 
-void mysql::setConnectTimeout(unsigned int time)
+void
+mysql::setConnectTimeout(unsigned int time)
 {
         if (mysqlHandle == NULL)
@@ -586 +599 @@
 //-------------------------------------------------------------------
 
-dodoString mysql::getCharset() const
+dodoString
+mysql::getCharset() const
 {
         if (mysqlHandle == NULL)
@@ -598 +612 @@
 //-------------------------------------------------------------------
 
-dodo::dodoStringMapArray mysql::fetchFieldsToRows() const
+dodo::dodoStringMapArray
+mysql::fetchFieldsToRows() const
 {
         if (mysqlHandle == NULL)

trunk/src/dataBasePostgresql.cc

@@ -146 +146 @@
 //-------------------------------------------------------------------
 
-void postgresql::connect(const __connectionInfo &info)
+void
+postgresql::connect(const __connectionInfo &info)
 {
         collectedData.dbInfo = info;
@@ -193 +194 @@
 //-------------------------------------------------------------------
 
-void postgresql::disconnect()
+void
+postgresql::disconnect()
 {
         if (pgHandle != NULL)
@@ -220 +222 @@
 //-------------------------------------------------------------------
 
-dodoArray<dodo::dodoStringArray>postgresql::fetchRows() const
+dodoArray<dodo::dodoStringArray>
+postgresql::fetchRows() const
 {
         if (pgHandle == NULL)
@@ -281 +284 @@
 //-------------------------------------------------------------------
 
-dodo::dodoStringArray postgresql::fetchFields() const
+dodo::dodoStringArray
+postgresql::fetchFields() const
 {
         if (pgHandle == NULL)
@@ -320 +324 @@
 //-------------------------------------------------------------------
 
-__tuples postgresql::fetch() const
+__tuples
+postgresql::fetch() const
 {
         return __tuples(fetchRows(), fetchFields());
@@ -327 +332 @@
 //-------------------------------------------------------------------
 
-unsigned int postgresql::rowsCount() const
+unsigned int
+postgresql::rowsCount() const
 {
         if (pgHandle == NULL)
@@ -346 +352 @@
 //-------------------------------------------------------------------
 
-unsigned int postgresql::fieldsCount() const
+unsigned int
+postgresql::fieldsCount() const
 {
         if (pgHandle == NULL)
@@ -365 +372 @@
 //-------------------------------------------------------------------
 
-unsigned int postgresql::affectedRowsCount() const
+unsigned int
+postgresql::affectedRowsCount() const
 {
         if (pgHandle == NULL)
@@ -384 +392 @@
 //-------------------------------------------------------------------
 
-void postgresql::getFieldsTypes(const dodoString &table)
+void
+postgresql::getFieldsTypes(const dodoString &table)
 {
         if (pgHandle == NULL)
@@ -418 +427 @@
         switch (status)
         {
-                case PGRES_EMPTY_QUERY:
-                case PGRES_BAD_RESPONSE:
-                case PGRES_NONFATAL_ERROR:
-                case PGRES_FATAL_ERROR:
-
-                        throw exception::basic(exception::ERRMODULE_DATABASEPOSTGRESQL, POSTGRESQLEX_GETFIELDSTYPES, exception::ERRNO_MYSQL, status, PQerrorMessage(pgHandle), __LINE__, __FILE__);
+        case PGRES_EMPTY_QUERY:
+        case PGRES_BAD_RESPONSE:
+        case PGRES_NONFATAL_ERROR:
+        case PGRES_FATAL_ERROR:
+
+                throw exception::basic(exception::ERRMODULE_DATABASEPOSTGRESQL, POSTGRESQLEX_GETFIELDSTYPES, exception::ERRNO_MYSQL, status, PQerrorMessage(pgHandle), __LINE__, __FILE__);
         }
 
@@ -502 +511 @@
 //-------------------------------------------------------------------
 
-void postgresql::exec(const dodoString &query,
-                                          bool             result)
+void
+postgresql::exec(const dodoString &query,
+                                 bool             result)
 {
         if (pgHandle == NULL)
@@ -566 +576 @@
         switch (status)
         {
-                case PGRES_EMPTY_QUERY:
-                case PGRES_BAD_RESPONSE:
-                case PGRES_NONFATAL_ERROR:
-                case PGRES_FATAL_ERROR:
-
-                        throw exception::basic(exception::ERRMODULE_DATABASEPOSTGRESQL, POSTGRESQLEX_EXEC, exception::ERRNO_MYSQL, status, PQerrorMessage(pgHandle), __LINE__, __FILE__);
+        case PGRES_EMPTY_QUERY:
+        case PGRES_BAD_RESPONSE:
+        case PGRES_NONFATAL_ERROR:
+        case PGRES_FATAL_ERROR:
+
+                throw exception::basic(exception::ERRMODULE_DATABASEPOSTGRESQL, POSTGRESQLEX_EXEC, exception::ERRNO_MYSQL, status, PQerrorMessage(pgHandle), __LINE__, __FILE__);
         }
 
@@ -586 +596 @@
 //-------------------------------------------------------------------
 
-void postgresql::updateCollect()
+void
+postgresql::updateCollect()
 {
         request = statements[SQLCONSTRUCTOR_STATEMENT_UPDATE];
@@ -711 +722 @@
 //-------------------------------------------------------------------
 
-void postgresql::insertCollect()
+void
+postgresql::insertCollect()
 {
         request = statements[SQLCONSTRUCTOR_STATEMENT_INSERT];
@@ -904 +916 @@
 //-------------------------------------------------------------------
 
-dodo::dodoStringMapArray postgresql::fetchFieldsToRows() const
+dodo::dodoStringMapArray
+postgresql::fetchFieldsToRows() const
 {
         dodoStringMapArray rowsFields;
@@ -947 +960 @@
 //-------------------------------------------------------------------
 
-void postgresql::setCharset(const dodoString &charset)
+void
+postgresql::setCharset(const dodoString &charset)
 {
         if (pgHandle == NULL)
@@ -963 +977 @@
 //-------------------------------------------------------------------
 
-dodoString postgresql::getCharset() const
+dodoString
+postgresql::getCharset() const
 {
         if (pgHandle == NULL)

trunk/src/dataBaseSqlConstructor.cc

@@ -105 +105 @@
 //-------------------------------------------------------------------
 
-void constructor::setFieldType(const dodoString &table,
-                                                           const dodoString &field,
-                                                           short            type)
+void
+constructor::setFieldType(const dodoString &table,
+                                                  const dodoString &field,
+                                                  short            type)
 {
         fieldTypes[collectedData.dbInfo.db + statements[SQLCONSTRUCTOR_STATEMENT_COLON] + table][field] = type;
@@ -114 +115 @@
 //-------------------------------------------------------------------
 
-void constructor::additionalCollect(unsigned int     qTypeTocheck,
-                                                                        const dodoString &collectedString)
+void
+constructor::additionalCollect(unsigned int     qTypeTocheck,
+                                                           const dodoString &collectedString)
 {
         if (collectedData.qShift == ACCUMULATOR_NONE)
@@ -131 +133 @@
 //-------------------------------------------------------------------
 
-void constructor::callFunctionCollect()
+void
+constructor::callFunctionCollect()
 {
         request = statements[SQLCONSTRUCTOR_STATEMENT_SELECT];
@@ -142 +145 @@
 //-------------------------------------------------------------------
 
-void constructor::callProcedureCollect()
+void
+constructor::callProcedureCollect()
 {
         request = statements[SQLCONSTRUCTOR_STATEMENT_CALL];
@@ -153 +157 @@
 //-------------------------------------------------------------------
 
-void constructor::selectCollect()
+void
+constructor::selectCollect()
 {
         if (collectedData.table.size() > 0)
@@ -171 +176 @@
 //-------------------------------------------------------------------
 
-void constructor::insertCollect()
+void
+constructor::insertCollect()
 {
         request = statements[SQLCONSTRUCTOR_STATEMENT_INSERT];
@@ -302 +308 @@
 //-------------------------------------------------------------------
 
-void constructor::insertSelectCollect()
+void
+constructor::insertSelectCollect()
 {
         dodoString fieldsPartTo = tools::misc::join(collectedData.fields, statements[SQLCONSTRUCTOR_STATEMENT_COMA]);
@@ -327 +334 @@
 //-------------------------------------------------------------------
 
-void constructor::updateCollect()
+void
+constructor::updateCollect()
 {
         request = statements[SQLCONSTRUCTOR_STATEMENT_UPDATE];
@@ -422 +430 @@
 //-------------------------------------------------------------------
 
-void constructor::delCollect()
+void
+constructor::delCollect()
 {
         request = statements[SQLCONSTRUCTOR_STATEMENT_DELETE];
@@ -431 +440 @@
 //-------------------------------------------------------------------
 
-void constructor::subCollect()
+void
+constructor::subCollect()
 {
         request = tools::misc::join(collectedData.subQueries, sqlQStArr[collectedData.qType - 1]);
@@ -438 +448 @@
 //-------------------------------------------------------------------
 
-void constructor::joinCollect()
+void
+constructor::joinCollect()
 {
         dodoStringArray::iterator i = collectedData.joinTables.begin(), j = collectedData.joinTables.end();
@@ -466 +477 @@
 //-------------------------------------------------------------------
 
-dodoString constructor::queryCollect()
+dodoString
+constructor::queryCollect()
 {
         bool additionalActions = true;
@@ -473 +485 @@
         switch (collectedData.qType)
         {
-                case ACCUMULATOR_REQUEST_SELECT:
-
-                        selectCollect();
-                        selectAction = true;
-
-                        break;
-
-                case ACCUMULATOR_REQUEST_INSERT:
-
-                        insertCollect();
-                        additionalActions = false;
-
-                        break;
-
-                case ACCUMULATOR_REQUEST_UPDATE:
-
-                        updateCollect();
-
-                        break;
-
-                case ACCUMULATOR_REQUEST_DELETE:
-
-                        delCollect();
-
-                        break;
-
-                case ACCUMULATOR_REQUEST_INSERT_SELECT:
-
-                        insertSelectCollect();
-                        selectAction = true;
-
-                        break;
-
-                case SUBREQUEST_UNION:
-                case SUBREQUEST_UNION_ALL:
-                case SUBREQUEST_MINUS:
-                case SUBREQUEST_INTERSECT:
-
-                        subCollect();
-                        additionalActions = false;
-
-                        break;
-
-                case ACCUMULATOR_REQUEST_CALL_FUNCTION:
-
-                        callFunctionCollect();
-                        selectAction = true;
-
-                        break;
-
-                case ACCUMULATOR_REQUEST_CALL_PROCEDURE:
-
-                        callProcedureCollect();
-
-                        break;
-
-                default:
-
-                        additionalActions = false;
+        case ACCUMULATOR_REQUEST_SELECT:
+
+                selectCollect();
+                selectAction = true;
+
+                break;
+
+        case ACCUMULATOR_REQUEST_INSERT:
+
+                insertCollect();
+                additionalActions = false;
+
+                break;
+
+        case ACCUMULATOR_REQUEST_UPDATE:
+
+                updateCollect();
+
+                break;
+
+        case ACCUMULATOR_REQUEST_DELETE:
+
+                delCollect();
+
+                break;
+
+        case ACCUMULATOR_REQUEST_INSERT_SELECT:
+
+                insertSelectCollect();
+                selectAction = true;
+
+                break;
+
+        case SUBREQUEST_UNION:
+        case SUBREQUEST_UNION_ALL:
+        case SUBREQUEST_MINUS:
+        case SUBREQUEST_INTERSECT:
+
+                subCollect();
+                additionalActions = false;
+
+                break;
+
+        case ACCUMULATOR_REQUEST_CALL_FUNCTION:
+
+                callFunctionCollect();
+                selectAction = true;
+
+                break;
+
+        case ACCUMULATOR_REQUEST_CALL_PROCEDURE:
+
+                callProcedureCollect();
+
+                break;
+
+        default:
+
+                additionalActions = false;
         }
 
@@ -557 +569 @@
 //-------------------------------------------------------------------
 
-dodoString constructor::escapeFields(const dodoString &data)
+dodoString
+constructor::escapeFields(const dodoString &data)
 {
         dodoString temp;
@@ -587 +600 @@
 //-------------------------------------------------------------------
 
-dodoString constructor::joinFields(const dodoStringArray &fields,
-                                                                   const dodoString      &separator,
-                                                                   const dodoString      &frame,
-                                                                   int                   limit)
+dodoString
+constructor::joinFields(const dodoStringArray &fields,
+                                                const dodoString      &separator,
+                                                const dodoString      &frame,
+                                                int                   limit)
 {
         int k(0);

trunk/src/dataBaseSqlite.cc

@@ -88 +88 @@
 //-------------------------------------------------------------------
 
-void sqlite::connect(const __connectionInfo &info)
+void
+sqlite::connect(const __connectionInfo &info)
 {
         collectedData.dbInfo = info;
@@ -127 +128 @@
 //-------------------------------------------------------------------
 
-void sqlite::disconnect()
+void
+sqlite::disconnect()
 {
         if (sqliteHandle != NULL)
@@ -157 +159 @@
 //-------------------------------------------------------------------
 
-dodoArray<dodo::dodoStringArray>sqlite::fetchRows() const
+dodoArray<dodo::dodoStringArray>
+sqlite::fetchRows() const
 {
         if (sqliteHandle == NULL)
@@ -193 +196 @@
                 switch (sqlite3_step(sqliteResult))
                 {
-                        case SQLITE_BUSY:
-
-                                continue;
-
-                        case SQLITE_DONE:
-
-                                iterate = false;
-
-                                break;
-
-                        case SQLITE_ERROR:
-
-                                throw exception::basic(exception::ERRMODULE_DATABASESQLITE, SQLITEEX_FETCHROWS, exception::ERRNO_SQLITE, sqlite3_errcode(sqliteHandle), sqlite3_errmsg(sqliteHandle), __LINE__, __FILE__);
-
-                        case SQLITE_ROW:
-
-                                rowsPart.clear();
+                case SQLITE_BUSY:
+
+                        continue;
+
+                case SQLITE_DONE:
+
+                        iterate = false;
+
+                        break;
+
+                case SQLITE_ERROR:
+
+                        throw exception::basic(exception::ERRMODULE_DATABASESQLITE, SQLITEEX_FETCHROWS, exception::ERRNO_SQLITE, sqlite3_errcode(sqliteHandle), sqlite3_errmsg(sqliteHandle), __LINE__, __FILE__);
+
+                case SQLITE_ROW:
+
+                        rowsPart.clear();
 
 #ifndef USE_DEQUE
-                                rowsPart.reserve(numFields);
-#endif
-
-                                for (i = 0; i < numFields; ++i)
-                                {
-                                        switch (sqlite3_column_type(sqliteResult, i))
-                                        {
-                                                case SQLITE_INTEGER:
-
-                                                        rowsPart.push_back(tools::string::iToString(sqlite3_column_int(sqliteResult, i)));
-
-                                                        break;
-
-                                                case SQLITE_FLOAT:
-
-                                                        rowsPart.push_back(tools::string::dToString(sqlite3_column_double(sqliteResult, i)));
-
-                                                        break;
-
-                                                case SQLITE_TEXT:
-
-                                                        rowsPart.push_back(dodoString((const char *)sqlite3_column_text(sqliteResult, i), sqlite3_column_bytes(sqliteResult, i)));
-
-                                                        break;
-
-                                                case SQLITE_BLOB:
-
-                                                        rowsPart.push_back(dodoString((const char *)sqlite3_column_blob(sqliteResult, i), sqlite3_column_bytes(sqliteResult, i)));
-
-                                                        break;
-
-                                                case SQLITE_NULL:
-                                                default:
-
-                                                        rowsPart.push_back(statements[SQLCONSTRUCTOR_STATEMENT_NULL]);
-
-                                                        break;
-                                        }
-                                }
-
-                                rows.push_back(rowsPart);
-
-                                break;
+                        rowsPart.reserve(numFields);
+#endif
+
+                        for (i = 0; i < numFields; ++i)
+                        {
+                                switch (sqlite3_column_type(sqliteResult, i))
+                                {
+                                case SQLITE_INTEGER:
+
+                                        rowsPart.push_back(tools::string::iToString(sqlite3_column_int(sqliteResult, i)));
+
+                                        break;
+
+                                case SQLITE_FLOAT:
+
+                                        rowsPart.push_back(tools::string::dToString(sqlite3_column_double(sqliteResult, i)));
+
+                                        break;
+
+                                case SQLITE_TEXT:
+
+                                        rowsPart.push_back(dodoString((const char *)sqlite3_column_text(sqliteResult, i), sqlite3_column_bytes(sqliteResult, i)));
+
+                                        break;
+
+                                case SQLITE_BLOB:
+
+                                        rowsPart.push_back(dodoString((const char *)sqlite3_column_blob(sqliteResult, i), sqlite3_column_bytes(sqliteResult, i)));
+
+                                        break;
+
+                                case SQLITE_NULL:
+                                default:
+
+                                        rowsPart.push_back(statements[SQLCONSTRUCTOR_STATEMENT_NULL]);
+
+                                        break;
+                                }
+                        }
+
+                        rows.push_back(rowsPart);
+
+                        break;
                 }
         }
@@ -267 +270 @@
 //-------------------------------------------------------------------
 
-dodo::dodoStringArray sqlite::fetchFields() const
+dodo::dodoStringArray
+sqlite::fetchFields() const
 {
         if (sqliteHandle == NULL)
@@ -306 +310 @@
 //-------------------------------------------------------------------
 
-__tuples sqlite::fetch() const
+__tuples
+sqlite::fetch() const
 {
         return __tuples(fetchRows(), fetchFields());
@@ -313 +318 @@
 //-------------------------------------------------------------------
 
-unsigned int sqlite::rowsCount() const
+unsigned int
+sqlite::rowsCount() const
 {
         if (sqliteHandle == NULL)
@@ -333 +339 @@
                         switch (result)
                         {
-                                case SQLITE_BUSY:
-
-                                        continue;
-
-                                case SQLITE_DONE:
-
-                                        iterate = false;
-
-                                        break;
-
-                                case SQLITE_ERROR:
-
-                                        throw exception::basic(exception::ERRMODULE_DATABASESQLITE, SQLITEEX_FETCHROWS, exception::ERRNO_SQLITE, sqlite3_errcode(sqliteHandle), sqlite3_errmsg(sqliteHandle), __LINE__, __FILE__);
-
-                                case SQLITE_ROW:
-
-                                        ++numRows;
-
-                                        break;
+                        case SQLITE_BUSY:
+
+                                continue;
+
+                        case SQLITE_DONE:
+
+                                iterate = false;
+
+                                break;
+
+                        case SQLITE_ERROR:
+
+                                throw exception::basic(exception::ERRMODULE_DATABASESQLITE, SQLITEEX_FETCHROWS, exception::ERRNO_SQLITE, sqlite3_errcode(sqliteHandle), sqlite3_errmsg(sqliteHandle), __LINE__, __FILE__);
+
+                        case SQLITE_ROW:
+
+                                ++numRows;
+
+                                break;
                         }
                 }
@@ -365 +371 @@
 //-------------------------------------------------------------------
 
-unsigned int sqlite::fieldsCount() const
+unsigned int
+sqlite::fieldsCount() const
 {
         if (sqliteHandle == NULL)
@@ -384 +391 @@
 //-------------------------------------------------------------------
 
-unsigned int sqlite::affectedRowsCount() const
+unsigned int
+sqlite::affectedRowsCount() const
 {
         if (sqliteHandle == NULL)
@@ -403 +411 @@
 //-------------------------------------------------------------------
 
-void sqlite::getFieldsTypes(const dodoString &table)
+void
+sqlite::getFieldsTypes(const dodoString &table)
 {
         if (sqliteHandle == NULL)
@@ -558 +567 @@
                 switch (sqlite3_step(sqliteResult))
                 {
-                        case SQLITE_BUSY:
-
-                                continue;
-
-                        case SQLITE_DONE:
-
-                                iterate = false;
-
-                                break;
-
-                        case SQLITE_ERROR:
-
-                                throw exception::basic(exception::ERRMODULE_DATABASESQLITE, SQLITEEX_GETFIELDSTYPES, exception::ERRNO_SQLITE, sqlite3_errcode(sqliteHandle), sqlite3_errmsg(sqliteHandle), __LINE__, __FILE__);
-
-                        case SQLITE_ROW:
-
-                                columnName = (const char *)sqlite3_column_text(sqliteResult, 1);
-                                columnType = (const char *)sqlite3_column_text(sqliteResult, 2);
-
-                                field = types->second.find(columnName);
-
-                                if (field == fieldsEnd)
-                                {
-                                        if (strcasestr(columnType, "char") != NULL ||
-                                                strcasestr(columnType, "date") != NULL ||
-                                                strcasestr(columnType, "time") != NULL ||
-                                                strcasestr(columnType, "text") != NULL ||
-                                                strcasestr(columnType, "enum") != NULL ||
-                                                strcasestr(columnType, "set") != NULL)
-                                        {
-                                                types->second.insert(make_pair(dodoString(columnName), sql::FIELDTYPE_TEXT));
+                case SQLITE_BUSY:
+
+                        continue;
+
+                case SQLITE_DONE:
+
+                        iterate = false;
+
+                        break;
+
+                case SQLITE_ERROR:
+
+                        throw exception::basic(exception::ERRMODULE_DATABASESQLITE, SQLITEEX_GETFIELDSTYPES, exception::ERRNO_SQLITE, sqlite3_errcode(sqliteHandle), sqlite3_errmsg(sqliteHandle), __LINE__, __FILE__);
+
+                case SQLITE_ROW:
+
+                        columnName = (const char *)sqlite3_column_text(sqliteResult, 1);
+                        columnType = (const char *)sqlite3_column_text(sqliteResult, 2);
+
+                        field = types->second.find(columnName);
+
+                        if (field == fieldsEnd)
+                        {
+                                if (strcasestr(columnType, "char") != NULL ||
+                                        strcasestr(columnType, "date") != NULL ||
+                                        strcasestr(columnType, "time") != NULL ||
+                                        strcasestr(columnType, "text") != NULL ||
+                                        strcasestr(columnType, "enum") != NULL ||
+                                        strcasestr(columnType, "set") != NULL)
+                                {
+                                        types->second.insert(make_pair(dodoString(columnName), sql::FIELDTYPE_TEXT));
+                                }
+                                else
+                                {
+                                        if (strcasestr(columnType, "blob") != NULL)
+                                        {
+                                                types->second.insert(make_pair(dodoString(columnName), sql::FIELDTYPE_BINARY));
                                         }
                                         else
                                         {
-                                                if (strcasestr(columnType, "blob") != NULL)
-                                                {
-                                                        types->second.insert(make_pair(dodoString(columnName), sql::FIELDTYPE_BINARY));
-                                                }
-                                                else
-                                                {
-                                                        types->second.insert(make_pair(dodoString(columnName), sql::FIELDTYPE_NUMERIC));
-                                                }
-                                        }
+                                                types->second.insert(make_pair(dodoString(columnName), sql::FIELDTYPE_NUMERIC));
+                                        }
+                                }
+                        }
+                        else
+                        {
+                                if (strcasestr(columnType, "char") != NULL ||
+                                        strcasestr(columnType, "date") != NULL ||
+                                        strcasestr(columnType, "time") != NULL ||
+                                        strcasestr(columnType, "text") != NULL ||
+                                        strcasestr(columnType, "enum") != NULL ||
+                                        strcasestr(columnType, "set") != NULL)
+                                {
+                                        field->second = sql::FIELDTYPE_TEXT;
                                 }
                                 else
                                 {
-                                        if (strcasestr(columnType, "char") != NULL ||
-                                                strcasestr(columnType, "date") != NULL ||
-                                                strcasestr(columnType, "time") != NULL ||
-                                                strcasestr(columnType, "text") != NULL ||
-                                                strcasestr(columnType, "enum") != NULL ||
-                                                strcasestr(columnType, "set") != NULL)
-                                        {
-                                                field->second = sql::FIELDTYPE_TEXT;
+                                        if (strcasestr(columnType, "blob") != NULL)
+                                        {
+                                                field->second = sql::FIELDTYPE_BINARY;
                                         }
                                         else
                                         {
-                                                if (strcasestr(columnType, "blob") != NULL)
-                                                {
-                                                        field->second = sql::FIELDTYPE_BINARY;
-                                                }
-                                                else
-                                                {
-                                                        field->second = sql::FIELDTYPE_NUMERIC;
-                                                }
-                                        }
-                                }
-
-                                break;
+                                                field->second = sql::FIELDTYPE_NUMERIC;
+                                        }
+                                }
+                        }
+
+                        break;
                 }
         }
@@ -643 +652 @@
 //-------------------------------------------------------------------
 
-void sqlite::exec(const dodoString &query,
-                                  bool             result)
+void
+sqlite::exec(const dodoString &query,
+                         bool             result)
 {
         if (sqliteHandle == NULL)
@@ -715 +725 @@
 //-------------------------------------------------------------------
 
-void sqlite::updateCollect()
+void
+sqlite::updateCollect()
 {
         request = statements[SQLCONSTRUCTOR_STATEMENT_UPDATE];
@@ -840 +851 @@
 //-------------------------------------------------------------------
 
-void sqlite::insertCollect()
+void
+sqlite::insertCollect()
 {
         request = statements[SQLCONSTRUCTOR_STATEMENT_INSERT];
@@ -1033 +1045 @@
 //-------------------------------------------------------------------
 
-dodo::dodoStringMapArray sqlite::fetchFieldsToRows() const
+dodo::dodoStringMapArray
+sqlite::fetchFieldsToRows() const
 {
         if (sqliteHandle == NULL)
@@ -1065 +1078 @@
                 switch (sqlite3_step(sqliteResult))
                 {
-                        case SQLITE_BUSY:
-
-                                continue;
-
-                        case SQLITE_DONE:
-
-                                iterate = false;
-
-                                break;
-
-                        case SQLITE_ERROR:
-
-                                throw exception::basic(exception::ERRMODULE_DATABASESQLITE, SQLITEEX_FETCHFIELDSTOROWS, exception::ERRNO_SQLITE, sqlite3_errcode(sqliteHandle), sqlite3_errmsg(sqliteHandle), __LINE__, __FILE__);
-
-                        case SQLITE_ROW:
-
-                                rowFieldsPart.clear();
-
-                                for (i = 0; i < numFields; ++i)
-                                {
-                                        switch (sqlite3_column_type(sqliteResult, i))
-                                        {
-                                                case SQLITE_INTEGER:
-
-                                                        rowFieldsPart.insert(make_pair(sqlite3_column_name(sqliteResult, i), tools::string::iToString(sqlite3_column_int(sqliteResult, i))));
-
-                                                        break;
-
-                                                case SQLITE_FLOAT:
-
-                                                        rowFieldsPart.insert(make_pair(sqlite3_column_name(sqliteResult, i), tools::string::dToString(sqlite3_column_double(sqliteResult, i))));
-
-                                                        break;
-
-                                                case SQLITE_TEXT:
-
-                                                        rowFieldsPart.insert(make_pair(sqlite3_column_name(sqliteResult, i), dodoString((const char *)sqlite3_column_text(sqliteResult, i), sqlite3_column_bytes(sqliteResult, i))));
-
-                                                        break;
-
-                                                case SQLITE_BLOB:
-
-                                                        rowFieldsPart.insert(make_pair(sqlite3_column_name(sqliteResult, i), dodoString((const char *)sqlite3_column_blob(sqliteResult, i), sqlite3_column_bytes(sqliteResult, i))));
-
-                                                        break;
-
-                                                case SQLITE_NULL:
-                                                default:
-
-                                                        rowFieldsPart.insert(make_pair(dodoString(sqlite3_column_name(sqliteResult, i)), statements[SQLCONSTRUCTOR_STATEMENT_NULL]));
-
-                                                        break;
-                                        }
-                                }
-
-                                rowsFields.push_back(rowFieldsPart);
-
-                                break;
+                case SQLITE_BUSY:
+
+                        continue;
+
+                case SQLITE_DONE:
+
+                        iterate = false;
+
+                        break;
+
+                case SQLITE_ERROR:
+
+                        throw exception::basic(exception::ERRMODULE_DATABASESQLITE, SQLITEEX_FETCHFIELDSTOROWS, exception::ERRNO_SQLITE, sqlite3_errcode(sqliteHandle), sqlite3_errmsg(sqliteHandle), __LINE__, __FILE__);
+
+                case SQLITE_ROW:
+
+                        rowFieldsPart.clear();
+
+                        for (i = 0; i < numFields; ++i)
+                        {
+                                switch (sqlite3_column_type(sqliteResult, i))
+                                {
+                                case SQLITE_INTEGER:
+
+                                        rowFieldsPart.insert(make_pair(sqlite3_column_name(sqliteResult, i), tools::string::iToString(sqlite3_column_int(sqliteResult, i))));
+
+                                        break;
+
+                                case SQLITE_FLOAT:
+
+                                        rowFieldsPart.insert(make_pair(sqlite3_column_name(sqliteResult, i), tools::string::dToString(sqlite3_column_double(sqliteResult, i))));
+
+                                        break;
+
+                                case SQLITE_TEXT:
+
+                                        rowFieldsPart.insert(make_pair(sqlite3_column_name(sqliteResult, i), dodoString((const char *)sqlite3_column_text(sqliteResult, i), sqlite3_column_bytes(sqliteResult, i))));
+
+                                        break;
+
+                                case SQLITE_BLOB:
+
+                                        rowFieldsPart.insert(make_pair(sqlite3_column_name(sqliteResult, i), dodoString((const char *)sqlite3_column_blob(sqliteResult, i), sqlite3_column_bytes(sqliteResult, i))));
+
+                                        break;
+
+                                case SQLITE_NULL:
+                                default:
+
+                                        rowFieldsPart.insert(make_pair(dodoString(sqlite3_column_name(sqliteResult, i)), statements[SQLCONSTRUCTOR_STATEMENT_NULL]));
+
+                                        break;
+                                }
+                        }
+
+                        rowsFields.push_back(rowFieldsPart);
+
+                        break;
                 }
         }

trunk/src/dataFormatJsonNode.cc

@@ -79 +79 @@
 //-------------------------------------------------------------------
 
-void node::setString(const dodoString &value)
+void
+node::setString(const dodoString &value)
 {
         valueDataType = DATATYPE_STRING;
@@ -88 +89 @@
 //-------------------------------------------------------------------
 
-void node::setBoolean(bool value)
+void
+node::setBoolean(bool value)
 {
         valueDataType = DATATYPE_BOOLEAN;
@@ -97 +99 @@
 //-------------------------------------------------------------------
 
-void node::setNumeric(long value)
+void
+node::setNumeric(long value)
 {
         valueDataType = DATATYPE_NUMERIC;
@@ -106 +109 @@
 //-------------------------------------------------------------------
 
-void node::setNull()
+void
+node::setNull()
 {
         valueDataType = DATATYPE_NULL;
@@ -113 +117 @@
 //-------------------------------------------------------------------
 
-void node::addArrayElement(const node &value)
+void
+node::addArrayElement(const node &value)
 {
         valueDataType = DATATYPE_ARRAY;
@@ -122 +127 @@
 //-------------------------------------------------------------------
 
-void node::addObjectMember(const dodoString &name,
-                                                   const node       &value)
+void
+node::addObjectMember(const dodoString &name,
+                                          const node       &value)
 {
         valueDataType = DATATYPE_OBJECT;
@@ -132 +138 @@
 //-------------------------------------------------------------------
 
-void node::setArray(const dodoArray<node> &value)
+void
+node::setArray(const dodoArray<node> &value)
 {
         valueDataType = DATATYPE_ARRAY;
@@ -141 +148 @@
 //-------------------------------------------------------------------
 
-void node::setObject(const dodoMap<dodoString, node, dodoMapStringCompare> &value)
+void
+node::setObject(const dodoMap<dodoString, node, dodoMapStringCompare> &value)
 {
         valueDataType = DATATYPE_OBJECT;
@@ -181 +189 @@
 //-------------------------------------------------------------------
 
-short node::getType()
+short
+node::getType()
 {
         return valueDataType;
@@ -188 +197 @@
 //-------------------------------------------------------------------
 
-dodoString node::getString()
+dodoString
+node::getString()
 {
         if (valueDataType != DATATYPE_STRING)
@@ -200 +210 @@
 //-------------------------------------------------------------------
 
-bool node::getBoolean()
+bool
+node::getBoolean()
 {
         if (valueDataType != DATATYPE_BOOLEAN)
@@ -212 +223 @@
 //-------------------------------------------------------------------
 
-long node::getNumeric()
+long
+node::getNumeric()
 {
         if (valueDataType != DATATYPE_NUMERIC)
@@ -224 +236 @@
 //-------------------------------------------------------------------
 
-dodoArray<node>node::getArray()
+dodoArray<node>
+node::getArray()
 {
         if (valueDataType != DATATYPE_ARRAY)
@@ -236 +249 @@
 //-------------------------------------------------------------------
 
-dodoMap<dodoString, node, dodo::dodoMapStringCompare>node::getObject()
+dodoMap<dodoString, node, dodo::dodoMapStringCompare>
+node::getObject()
 {
         if (valueDataType != DATATYPE_OBJECT)
@@ -248 +262 @@
 //-------------------------------------------------------------------
 
-bool node::isNull()
+bool
+node::isNull()
 {
         return (valueDataType == DATATYPE_NULL);
@@ -255 +270 @@
 //-------------------------------------------------------------------
 
-void node::clear()
+void
+node::clear()
 {
         stringValue.clear();

trunk/src/dataFormatJsonProcessor.cc

@@ -44 +44 @@
 //-------------------------------------------------------------------
 
-dodoString processor::make(const node &root)
+dodoString
+processor::make(const node &root)
 {
         switch (root.valueDataType)
         {
-                case DATATYPE_STRING:
-                {
-                        dodoString jsonObject = "\"";
-                        dodoString stringValue = root.stringValue;
-                        tools::string::replace("\"", "\\\"", stringValue);
-                        jsonObject.append(stringValue);
-                        jsonObject.append("\"");
-
-                        return jsonObject;
-                }
-
-                case DATATYPE_OBJECT:
-                {
-                        dodoString jsonObject = "{";
-
-                        dodoMap<dodoString, node, dodoMapStringCompare>::const_iterator i = root.objectValue.begin(), j = root.objectValue.end();
-                        if (i != j)
-                        {
-                                for (--j; i != j; ++i)
-                                {
-                                        jsonObject.append("\"");
-                                        jsonObject.append(i->first);
-                                        jsonObject.append("\":");
-
-                                        jsonObject.append(make(i->second));
-                                        jsonObject.append(",");
-                                }
+        case DATATYPE_STRING:
+        {
+                dodoString jsonObject = "\"";
+                dodoString stringValue = root.stringValue;
+                tools::string::replace("\"", "\\\"", stringValue);
+                jsonObject.append(stringValue);
+                jsonObject.append("\"");
+
+                return jsonObject;
+        }
+
+        case DATATYPE_OBJECT:
+        {
+                dodoString jsonObject = "{";
+
+                dodoMap<dodoString, node, dodoMapStringCompare>::const_iterator i = root.objectValue.begin(), j = root.objectValue.end();
+                if (i != j)
+                {
+                        for (--j; i != j; ++i)
+                        {
                                 jsonObject.append("\"");
                                 jsonObject.append(i->first);
@@ -80 +74 @@
 
                                 jsonObject.append(make(i->second));
-                        }
-
-                        jsonObject.append("}");
-
-                        return jsonObject;
-                }
-
-                case DATATYPE_ARRAY:
-                {
-                        dodoString jsonObject = "[";
-
-                        dodoArray<node>::const_iterator i = root.arrayValue.begin(), j = root.arrayValue.end();
-                        if (i != j)
-                        {
-                                --j;
-                                for (; i != j; ++i)
-                                {
-                                        jsonObject.append(make(*i));
-                                        jsonObject.append(",");
-                                }
+                                jsonObject.append(",");
+                        }
+                        jsonObject.append("\"");
+                        jsonObject.append(i->first);
+                        jsonObject.append("\":");
+
+                        jsonObject.append(make(i->second));
+                }
+
+                jsonObject.append("}");
+
+                return jsonObject;
+        }
+
+        case DATATYPE_ARRAY:
+        {
+                dodoString jsonObject = "[";
+
+                dodoArray<node>::const_iterator i = root.arrayValue.begin(), j = root.arrayValue.end();
+                if (i != j)
+                {
+                        --j;
+                        for (; i != j; ++i)
+                        {
                                 jsonObject.append(make(*i));
-                        }
-
-                        jsonObject.append("]");
-
-                        return jsonObject;
-                }
-
-                case DATATYPE_NUMERIC:
-
-                        return tools::string::lToString(root.numericValue);
-
-                case DATATYPE_BOOLEAN:
-
-                        return root.booleanValue ? "true" : "false";
-
-                case DATATYPE_NULL:
-                default:
-
-                        return "null";
+                                jsonObject.append(",");
+                        }
+                        jsonObject.append(make(*i));
+                }
+
+                jsonObject.append("]");
+
+                return jsonObject;
+        }
+
+        case DATATYPE_NUMERIC:
+
+                return tools::string::lToString(root.numericValue);
+
+        case DATATYPE_BOOLEAN:
+
+                return root.booleanValue ? "true" : "false";
+
+        case DATATYPE_NULL:
+        default:
+
+                return "null";
         }
 
@@ -127 +128 @@
 //-------------------------------------------------------------------
 
-unsigned long processor::processArray(dodoArray<node>  &jnode,
-                                                                          const dodoString &root,
-                                                                          unsigned long    pos)
+unsigned long
+processor::processArray(dodoArray<node>  &jnode,
+                                                const dodoString &root,
+                                                unsigned long    pos)
 {
         jnode.clear();
@@ -142 +144 @@
                 switch (root[i])
                 {
-                        case ' ':
-                        case '\r':
-                        case '\n':
-                        case '\t':
+                case ' ':
+                case '\r':
+                case '\n':
+                case '\t':
+
+                        break;
+
+                case '[':
+
+                        if (initial)
+                        {
+                                initial = false;
+                        }
+                        else
+                        {
+                                i = processValue(subNode, root, i);
+
+                                jnode.push_back(subNode);
+                        }
+
+                        break;
+
+                case ']':
+
+                        return i;
+
+                case ',':
+
+                        break;
+
+                default:
+
+                        i = processValue(subNode, root, i);
+
+                        jnode.push_back(subNode);
+                }
+        }
+
+        return i;
+}
+
+//-------------------------------------------------------------------
+
+unsigned long
+processor::processValue(node             &node,
+                                                const dodoString &root,
+                                                unsigned long    pos)
+{
+        node.clear();
+
+        unsigned long i(pos), j(root.size());
+        for (; i < j; ++i)
+        {
+                switch (root[i])
+                {
+                case ' ':
+                case '\r':
+                case '\n':
+                case '\t':
+
+                        break;
+
+                case '"':
+
+                        node.valueDataType = DATATYPE_STRING;
+
+                        return processString(node.stringValue, root, i);
+
+                case '{':
+
+                        node.valueDataType = DATATYPE_OBJECT;
+
+                        return processObject(node.objectValue, root, i);
+
+                case '[':
+
+                        node.valueDataType = DATATYPE_ARRAY;
+
+                        return processArray(node.arrayValue, root, i);
+
+                case 't':
+                case 'f':
+
+                        node.valueDataType = DATATYPE_BOOLEAN;
+
+                        return processBoolean(node.booleanValue, root, i);
+
+                case 'n':
+
+                        node.valueDataType = DATATYPE_NULL;
+
+                        return processNull(root, i);
+
+                default:
+
+                        node.valueDataType = DATATYPE_NUMERIC;
+
+                        return processNumeric(node.numericValue, root, i);
+                }
+        }
+}
+
+//-------------------------------------------------------------------
+
+unsigned long
+processor::processBoolean(bool             &node,
+                                                  const dodoString &root,
+                                                  unsigned long    pos)
+{
+        if ((root.size() - pos) < 4)
+        {
+                throw exception::basic(exception::ERRMODULE_DATAFORMATJSONPROCESSOR, PROCESSOREX_PROCESSBOOLEAN, exception::ERRNO_LIBDODO, PROCESSOREX_MALFORMEDJSONBOOLEAN, DATAFORMATJSONPROCESSOREX_MALFORMEDJSONBOOLEAN_STR, __LINE__, __FILE__);
+        }
+
+        if (root[pos] == 't' && root[pos + 1] == 'r' && root[pos + 2] == 'u' && root[pos + 3] == 'e')
+        {
+                node = true;
+
+                return pos + 3;
+        }
+        else
+        {
+                if (root[pos] == 'f' && root[pos + 1] == 'a' && root[pos + 2] == 'l' && root[pos + 3] == 's' && root[pos + 4] == 'e')
+                {
+                        node = false;
+
+                        return pos + 4;
+                }
+                else
+                {
+                        throw exception::basic(exception::ERRMODULE_DATAFORMATJSONPROCESSOR, PROCESSOREX_PROCESSBOOLEAN, exception::ERRNO_LIBDODO, PROCESSOREX_MALFORMEDJSONBOOLEAN, DATAFORMATJSONPROCESSOREX_MALFORMEDJSONBOOLEAN_STR, __LINE__, __FILE__);
+                }
+        }
+
+        return pos;
+}
+
+//-------------------------------------------------------------------
+
+unsigned long
+processor::processNull(const dodoString &root,
+                                           unsigned long    pos)
+{
+        if ((root.size() - pos) < 4)
+        {
+                throw exception::basic(exception::ERRMODULE_DATAFORMATJSONPROCESSOR, PROCESSOREX_PROCESSNULL, exception::ERRNO_LIBDODO, PROCESSOREX_MALFORMEDJSONNULL, DATAFORMATJSONPROCESSOREX_MALFORMEDJSONNULL_STR, __LINE__, __FILE__);
+        }
+
+        if (root[pos] == 'n' && root[pos + 1] == 'u' && root[pos + 2] == 'l' && root[pos + 3] == 'l')
+        {
+                return pos + 3;
+        }
+        else
+        {
+                throw exception::basic(exception::ERRMODULE_DATAFORMATJSONPROCESSOR, PROCESSOREX_PROCESSNULL, exception::ERRNO_LIBDODO, PROCESSOREX_MALFORMEDJSONNULL, DATAFORMATJSONPROCESSOREX_MALFORMEDJSONNULL_STR, __LINE__, __FILE__);
+        }
+
+        return pos;
+}
+
+//-------------------------------------------------------------------
+
+unsigned long
+processor::processNumeric(long             &node,
+                                                  const dodoString &root,
+                                                  unsigned long    pos)
+{
+        dodoString numeric;
+
+        unsigned long i(pos), j(root.size());
+        for (; i < j; ++i)
+        {
+                switch (root[i])
+                {
+                case ' ':
+                case '\r':
+                case '\n':
+                case '\t':
+
+                        break;
+
+                case '1':
+                case '2':
+                case '3':
+                case '4':
+                case '5':
+                case '6':
+                case '7':
+                case '8':
+                case '9':
+                case '0':
+                case '+':
+                case '-':
+                case 'e':
+                case 'E':
+
+                        numeric.append(1, root[i]);
+
+                        break;
+
+                case ',':
+                case ']':
+                case '}':
+
+                        node = tools::string::stringToL(numeric);
+
+                        return i - 1;
+
+                default:
+
+                        throw exception::basic(exception::ERRMODULE_DATAFORMATJSONPROCESSOR, PROCESSOREX_PROCESSNUMERIC, exception::ERRNO_LIBDODO, PROCESSOREX_MALFORMEDJSONNUMERIC, DATAFORMATJSONPROCESSOREX_MALFORMEDJSONNUMERIC_STR, __LINE__, __FILE__);
+                }
+        }
+
+
+        return i;
+}
+
+//-------------------------------------------------------------------
+
+unsigned long
+processor::processObject(dodoMap<dodoString, node, dodoMapStringCompare> &jnode,
+                                                 const dodoString &root,
+                                                 unsigned long pos)
+{
+        jnode.clear();
+
+        short state = JSON_STATE_OBJECT_INITIAL;
+
+        node subNodeValue;
+        dodoString subNodeName;
+
+        unsigned long i(pos), j(root.size());
+        for (; i < j; ++i)
+        {
+                switch (root[i])
+                {
+                case ' ':
+                case '\r':
+                case '\n':
+                case '\t':
+                case ':':
+                case ',':
+
+                        break;
+
+                case '{':
+
+                        if (state == JSON_STATE_OBJECT_INITIAL)
+                        {
+                                state = JSON_STATE_OBJECT_OBJECTNAME;
 
                                 break;
-
-                        case '[':
-
+                        }
+                        else
+                        {
+                                if (state == JSON_STATE_OBJECT_OBJECTVALUE)
+                                {
+                                        subNodeValue.clear();
+
+                                        subNodeValue.valueDataType = DATATYPE_OBJECT;
+
+                                        i = processObject(subNodeValue.objectValue, root, i);
+                                        jnode.insert(make_pair(subNodeName, subNodeValue));
+
+                                        state = JSON_STATE_OBJECT_OBJECTNAME;
+
+                                        break;
+                                }
+                        }
+
+                case '}':
+
+                        return i;
+
+                case '"':
+
+                        if (state == JSON_STATE_OBJECT_OBJECTNAME)
+                        {
+                                i = processString(subNodeName, root, i);
+
+                                state = JSON_STATE_OBJECT_OBJECTVALUE;
+
+                                break;
+                        }
+                        else
+                        {
+                                if (state == JSON_STATE_OBJECT_OBJECTVALUE)
+                                {
+                                        subNodeValue.clear();
+
+                                        subNodeValue.valueDataType = DATATYPE_STRING;
+
+                                        i = processString(subNodeValue.stringValue, root, i);
+                                        jnode.insert(make_pair(subNodeName, subNodeValue));
+
+                                        state = JSON_STATE_OBJECT_OBJECTNAME;
+
+                                        break;
+                                }
+                        }
+
+                default:
+
+                        if (state == JSON_STATE_OBJECT_OBJECTVALUE)
+                        {
+                                i = processValue(subNodeValue, root, i);
+                                jnode.insert(make_pair(subNodeName, subNodeValue));
+
+                                state = JSON_STATE_OBJECT_OBJECTNAME;
+                        }
+                }
+        }
+
+        return i;
+}
+
+//-------------------------------------------------------------------
+
+node
+processor::processString(const dodoString &root)
+{
+        node node;
+
+        node.valueDataType = DATATYPE_OBJECT;
+        processObject(node.objectValue, root, 0);
+
+        return node;
+}
+
+//-------------------------------------------------------------------
+
+node
+processor::processFile(const dodoString &path)
+{
+        node node;
+
+        node.valueDataType = DATATYPE_OBJECT;
+        processObject(node.objectValue, tools::filesystem::getFileContents(path), 0);
+
+        return node;
+}
+
+//-------------------------------------------------------------------
+
+dodoString
+processor::fromMap(const dodoStringMap &root)
+{
+        node nodeDef;
+        node subNodeDef;
+
+        nodeDef.valueDataType = DATATYPE_OBJECT;
+        subNodeDef.valueDataType = DATATYPE_STRING;
+
+        dodoStringMap::const_iterator i = root.begin(), j = root.end();
+        for (; i != j; ++i)
+        {
+                subNodeDef.stringValue = i->second;
+                nodeDef.objectValue.insert(make_pair(i->first, subNodeDef));
+        }
+
+        return make(nodeDef);
+}
+
+//-------------------------------------------------------------------
+
+dodo::dodoStringMap
+processor::toMap(const dodoString &jnode)
+{
+        node JSON = processString(jnode);
+
+        dodoStringMap map;
+
+        dodoMap<dodoString, node, dodoMapStringCompare>::iterator i = JSON.objectValue.begin(), j = JSON.objectValue.end();
+        for (; i != j; ++i)
+        {
+                map.insert(make_pair(i->first, i->second.stringValue));
+        }
+
+        return map;
+}
+
+//-------------------------------------------------------------------
+
+unsigned long
+processor::processString(dodoString       &jnode,
+                                                 const dodoString &root,
+                                                 unsigned long    pos)
+{
+        jnode.clear();
+
+        bool escape = false;
+        bool initial = true;
+
+        unsigned long i(pos), j(root.size());
+        for (; i < j; ++i)
+        {
+                switch (root[i])
+                {
+                case '\\':
+
+                        if (!escape)
+                        {
+                                escape = true;
+
+                                break;
+                        }
+
+                case '"':
+
+                        if (!escape)
+                        {
                                 if (initial)
                                 {
                                         initial = false;
-                                }
-                                else
-                                {
-                                        i = processValue(subNode, root, i);
-