Date: Sat, 11 Aug 2018 20:21:34 +0200 Subject: Initial commit --- docs/doxygen/nel/a05383.html | 1566 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1566 insertions(+) create mode 100644 docs/doxygen/nel/a05383.html (limited to 'docs/doxygen/nel/a05383.html') diff --git a/docs/doxygen/nel/a05383.html b/docs/doxygen/nel/a05383.html new file mode 100644 index 00000000..06cfaf80 --- /dev/null +++ b/docs/doxygen/nel/a05383.html @@ -0,0 +1,1566 @@ + + +NeL: STRING_MANAGER Namespace Reference + + + +

STRING_MANAGER Namespace Reference

+ +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Data Structures
class CMakeDiff
struct CMakeDiff::IDiffCallback
struct TClause
struct TGetHashValue
struct TGetIdentifier
struct TGetWorksheetHashValue
struct TGetWorksheetIdentifier
struct TPhrase
struct TPhraseDiffContext
struct TStringDiffContext
struct TStringInfo
struct TTestItem
struct TTestWorksheetItem
struct TWordsDiffContext
struct TWorksheet

Typedefs
typedef CMakeDiff< TPhrase,
+ TPhraseDiffContext > TPhraseDiff
typedef CMakeDiff< TStringInfo,
+ TStringDiffContext > TStringDiff
typedef CMakeDiff< TWorksheet::TRow,
+ TWordsDiffContext, TGetWorksheetIdentifier,
+ TGetWorksheetHashValue, TTestWorksheetItem > TWorkSheetDiff

Functions
bool loadExcelSheet (const string filename, TWorksheet &worksheet, bool checkUnique)
bool loadStringFile (const std::string filename, vector< TStringInfo > &stringInfos, bool forceRehash, ucchar openMark, ucchar closeMark, bool specialCase)
void makeHashCode (TWorksheet &sheet, bool forceRehash)
uint64 makePhraseHash (const TPhrase &phrase)
bool parseHashFromComment (const ucstring &comments, uint64 &hashValue)
ucstring prepareExcelSheet (const TWorksheet &worksheet)
ucstring preparePhraseFile (const std::vector< TPhrase > &phrases, bool removeDiffComments)
ucstring preparePhraseFile (const vector< TPhrase > &phrases, bool removeDiffComments)
ucstring prepareStringFile (const std::vector< TStringInfo > &strings, bool removeDiffComments)
ucstring prepareStringFile (const vector< TStringInfo > &strings, bool removeDiffComments)
bool readExcelSheet (const ucstring &str, TWorksheet &worksheet, bool checkUnique)
bool readPhraseFile (const std::string &filename, vector< TPhrase > &phrases, bool forceRehash)
ucstring tabLines (uint nbTab, const ucstring &str)

Variables
const ucstring nl ("\r\n")
+

Typedef Documentation

+ + + + +
+ + +
typedef CMakeDiff<TPhrase, TPhraseDiffContext> STRING_MANAGER::TPhraseDiff +
+
+ + + + + +
+ + + +
+ +
+Definition at line 493 of file diff_tool.h.
+

+ + + + +
+ + +
typedef CMakeDiff<TStringInfo, TStringDiffContext> STRING_MANAGER::TStringDiff +
+
+ + + + + +
+ + + +
+ +
+Definition at line 492 of file diff_tool.h.
+

+ + + + +
+ + +
typedef CMakeDiff<TWorksheet::TRow, TWordsDiffContext, TGetWorksheetIdentifier, TGetWorksheetHashValue, TTestWorksheetItem> STRING_MANAGER::TWorkSheetDiff +
+
+ + + + + +
+ + + +
+ +
+Definition at line 494 of file diff_tool.h.
+

Function Documentation

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
bool STRING_MANAGER::loadExcelSheet ( const string filename,
TWorksheet & worksheet,
bool checkUnique = true
)
+
+ + + + + +
+ + + +
+ +
+Definition at line 558 of file diff_tool.cpp. +
+References NLMISC::CIFile::close(), nldebug, NLMISC::CIFile::open(), and readExcelSheet(). +
+Referenced by NLMISC::CWordsDictionary::init(). +
+
00559 { +00560 // Yoyo: must test with CIFile because can be packed into a .bnp on client... +00561 CIFile fp; +00562 if(!fp.open(filename)) +00563 { +00564 nldebug("DT: Can't open file [%s]\n", filename.c_str()); +00565 return true; +00566 } +00567 fp.close(); +00568 +00569 ucstring str; +00570 CI18N::readTextFile(filename, str, false, false); +00571 +00572 if (!readExcelSheet(str, worksheet, checkUnique)) +00573 return false; +00574 +00575 return true; +00576 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
bool STRING_MANAGER::loadStringFile ( const std::string filename,
std::vector< TStringInfo > & stringInfos,
bool forceRehash,
ucchar openMark = '[',
ucchar closeMark = ']',
bool specialCase = false
)
+
+ + + + + +
+ + + +
+ +
+Definition at line 71 of file diff_tool.cpp. +
+References STRING_MANAGER::TStringInfo::Comments, STRING_MANAGER::TStringInfo::HashValue, STRING_MANAGER::TStringInfo::Identifier, nlwarning, parseHashFromComment(), STRING_MANAGER::TStringInfo::Text, STRING_MANAGER::TStringInfo::Text2, ucchar, and uint. +
+
00072 { +00073 /* uint8 *buffer = 0; +00074 uint size; +00075 +00076 try +00077 { +00078 CIFile fp(filename); +00079 size = fp.getFileSize(); +00080 buffer = new uint8[size]; +00081 fp.serialBuffer(buffer, size); +00082 } +00083 catch(Exception &e) +00084 { +00085 nlinfo("Can't open file [%s] (%s)\n", filename.c_str(), e.what()); +00086 return true; +00087 } +00088 */ +00089 /* FILE *fp = fopen(filename.c_str(), "rb"); +00090 +00091 if (fp == NULL) +00092 { +00093 nlinfo("Can't open file [%s]\n", filename.c_str()); +00094 if (buffer != 0) +00095 delete [] buffer; +00096 return true; +00097 } +00098 +00099 // move to end of file +00100 fseek(fp, 0, SEEK_END); +00101 +00102 fpos_t pos; +00103 fgetpos(fp, &pos); +00104 +00105 uint8 *buffer = new uint8[uint(pos)]; +00106 +00107 rewind(fp); +00108 uint size = fread(buffer, 1, uint(pos), fp); +00109 fclose (fp); +00110 */ +00111 ucstring text; +00112 +00113 CI18N::readTextFile(filename, text, false, false, true); +00114 // CI18N::readTextBuffer(buffer, size, text); +00115 // delete [] buffer; +00116 +00117 // ok, parse the file now. +00118 ucstring::const_iterator first(text.begin()), last(text.end()); +00119 std::string lastLabel("nothing"); +00120 +00121 while (first != last) +00122 { +00123 TStringInfo si; +00124 CI18N::skipWhiteSpace(first, last, &si.Comments); +00125 +00126 if (first == last) +00127 { +00128 // check if there is only swap command remaining in comment +00129 if (si.Comments.find(ucstring("// DIFF SWAP ")) != ucstring::npos) +00130 { +00131 stringInfos.push_back(si); +00132 } +00133 break; +00134 } +00135 +00136 if (!CI18N::parseLabel(first, last, si.Identifier)) +00137 { +00138 nlwarning("DT: Fatal : Invalid label will reading %s after %s\n", filename.c_str(), lastLabel.c_str()); +00139 return false; +00140 } +00141 lastLabel = si.Identifier; +00142 +00143 CI18N::skipWhiteSpace(first, last, &si.Comments); +00144 +00145 if (!CI18N::parseMarkedString(openMark, closeMark, first, last, si.Text)) +00146 { +00147 nlwarning("DT: Fatal : Invalid text value reading %s for label %s\n", filename.c_str(), lastLabel.c_str()); +00148 return false; +00149 } +00150 +00151 if (specialCase) +00152 { +00153 CI18N::skipWhiteSpace(first, last, &si.Comments); +00154 +00155 if (!CI18N::parseMarkedString(openMark, closeMark, first, last, si.Text2)) +00156 { +00157 nlwarning("DT: Fatal : Invalid text2 value reading %s for label %s\n", filename.c_str(), lastLabel.c_str()); +00158 return false; +00159 } +00160 +00161 } +00162 +00163 if (forceRehash || !parseHashFromComment(si.Comments, si.HashValue)) +00164 { +00165 // compute the hash value from text. +00166 si.HashValue = CI18N::makeHash(si.Text); +00167 // nldebug("Generating hash for %s as %s", si.Identifier.c_str(), CI18N::hashToString(si.HashValue).c_str()); +00168 } +00169 else +00170 { +00171 // nldebug("Comment = [%s]", si.Comments.toString().c_str()); +00172 // nldebug("Retreiving hash for %s as %s", si.Identifier.c_str(), CI18N::hashToString(si.HashValue).c_str()); +00173 } +00174 stringInfos.push_back(si); +00175 } +00176 +00177 +00178 // check identifier uniqueness +00179 { +00180 bool error = false; +00181 set<string> unik; +00182 set<string>::iterator it; +00183 for (uint i=0; i<stringInfos.size(); ++i) +00184 { +00185 it = unik.find(stringInfos[i].Identifier); +00186 if (it != unik.end()) +00187 { +00188 nlwarning("DT: loadStringFile : identifier '%s' exist twice", stringInfos[i].Identifier.c_str() ); +00189 error = true; +00190 } +00191 else +00192 unik.insert(stringInfos[i].Identifier); +00193 +00194 } +00195 if (error) +00196 return false; +00197 } +00198 +00199 return true; +00200 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
void STRING_MANAGER::makeHashCode ( TWorksheet & sheet,
bool forceRehash
)
+
+ + + + + +
+ + + +
+ +
+Definition at line 749 of file diff_tool.cpp. +
+References STRING_MANAGER::TWorksheet::ColCount, STRING_MANAGER::TWorksheet::Data, index, STRING_MANAGER::TWorksheet::insertColumn(), uint, and uint64. +
+
00750 { +00751 if (!sheet.Data.empty()) +00752 { +00753 TWorksheet::TRow::iterator it = find(sheet.Data[0].begin(), sheet.Data[0].end(), ucstring("*HASH_VALUE")); +00754 if (forceRehash || it == sheet.Data[0].end()) +00755 { +00756 // we need to generate HASH_VALUE column ! +00757 if (it == sheet.Data[0].end()) +00758 { +00759 sheet.insertColumn(0); +00760 sheet.Data[0][0] = ucstring("*HASH_VALUE"); +00761 } +00762 +00763 // Check columns +00764 vector<bool> columnOk; +00765 columnOk.resize(sheet.ColCount, false); +00766 for (uint k=1; k<sheet.ColCount; ++k) +00767 { +00768 if (sheet.Data[0][k].find(ucstring("*")) != 0 && sheet.Data[0][k].find(ucstring("DIFF ")) != 0) +00769 { +00770 columnOk[k]= true; +00771 } +00772 } +00773 +00774 // make hash for each line +00775 ucstring str; +00776 for (uint j=1; j<sheet.Data.size(); ++j) +00777 { +00778 str.erase(); +00779 for (uint k=1; k<sheet.ColCount; ++k) +00780 { +00781 if (columnOk[k]) +00782 { +00783 str += sheet.Data[j][k]; +00784 } +00785 } +00786 uint64 hash = CI18N::makeHash(str); +00787 CI18N::hashToUCString(hash, sheet.Data[j][0]); +00788 } +00789 } +00790 else +00791 { +00792 uint index = it - sheet.Data[0].begin(); +00793 for (uint j=1; j<sheet.Data.size(); ++j) +00794 { +00795 ucstring &field = sheet.Data[j][index]; +00796 +00797 if (!field.empty() && field[0] == '_') +00798 field = field.substr(1); +00799 } +00800 } +00801 } +00802 } +

+

+ + + + +
+ + + + + + + + + + +
uint64 STRING_MANAGER::makePhraseHash ( const TPhrase & phrase )
+
+ + + + + +
+ + + +
+ +
+Definition at line 37 of file diff_tool.cpp. +
+References STRING_MANAGER::TPhrase::Clauses, STRING_MANAGER::TPhrase::Parameters, uint, and uint64. +
+Referenced by readPhraseFile(). +
+
00038 { +00039 ucstring text; +00040 text = phrase.Parameters; +00041 for (uint i=0; i<phrase.Clauses.size(); ++i) +00042 { +00043 text += phrase.Clauses[i].Conditions; +00044 text += phrase.Clauses[i].Identifier; +00045 text += phrase.Clauses[i].Text; +00046 } +00047 +00048 return CI18N::makeHash(text); +00049 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
bool STRING_MANAGER::parseHashFromComment ( const ucstring & comments,
uint64 & hashValue
)
+
+ + + + + +
+ + + +
+ +
+Definition at line 54 of file diff_tool.cpp. +
+References ucstring::toString(), and uint64. +
+Referenced by loadStringFile(), and readPhraseFile(). +
+
00055 { +00056 string str = comments.toString(); +00057 +00058 string::size_type pos = str.find("HASH_VALUE "); +00059 if (pos == string::npos) +00060 return false; +00061 +00062 string hashStr = str.substr(pos + 11, 16); +00063 +00064 hashValue = CI18N::stringToHash(hashStr); +00065 return true; +00066 } +

+

+ + + + +
+ + + + + + + + + + +
ucstring STRING_MANAGER::prepareExcelSheet ( const TWorksheet & worksheet )
+
+ + + + + +
+ + + +
+ +
+Definition at line 804 of file diff_tool.cpp. +
+References STRING_MANAGER::TWorksheet::Data, nl, and uint. +
+
00805 { +00806 if(worksheet.Data.empty()) +00807 return ucstring(); +00808 +00809 // **** First pass: count approx the size +00810 uint approxSize= 0; +00811 for (uint i=0; i<worksheet.Data.size(); ++i) +00812 { +00813 for (uint j=0; j<worksheet.Data[i].size(); ++j) +00814 { +00815 approxSize+= worksheet.Data[i][j].size() + 1; +00816 } +00817 approxSize++; +00818 } +00819 +00820 // Hash value for each column? +00821 vector<bool> hashValue; +00822 hashValue.resize(worksheet.Data[0].size()); +00823 for (uint j=0; j<worksheet.Data[0].size(); ++j) +00824 { +00825 hashValue[j]= worksheet.Data[0][j] == ucstring("*HASH_VALUE"); +00826 } +00827 +00828 // **** Second pass: fill +00829 ucstring text; +00830 text.reserve(approxSize*2); +00831 for (uint i=0; i<worksheet.Data.size(); ++i) +00832 { +00833 for (uint j=0; j<worksheet.Data[i].size(); ++j) +00834 { +00835 if (i > 0 && hashValue[j]) +00836 text += "_"; +00837 text += worksheet.Data[i][j]; +00838 if (j != worksheet.Data[i].size()-1) +00839 text += '\t'; +00840 } +00841 text += nl; +00842 } +00843 +00844 return text; +00845 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
ucstring preparePhraseFile ( const std::vector< TPhrase > & phrases,
bool removeDiffComments
)
+
+ + + + + +
+ + + +
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
ucstring preparePhraseFile ( const vector< TPhrase > & phrases,
bool removeDiffComments
)
+
+ + + + + +
+ + + +
+ +
+Definition at line 472 of file diff_tool.cpp. +
+References STRING_MANAGER::TPhrase::Clauses, comment(), STRING_MANAGER::TClause::Comments, STRING_MANAGER::TPhrase::Comments, STRING_MANAGER::TClause::Conditions, NLMISC::explode(), STRING_MANAGER::TPhrase::HashValue, STRING_MANAGER::TClause::Identifier, STRING_MANAGER::TPhrase::Identifier, nl, STRING_MANAGER::TPhrase::Parameters, tabLines(), STRING_MANAGER::TClause::Text, ucstring::toString(), and uint. +
+
00473 { +00474 ucstring ret; +00475 vector<TPhrase>::const_iterator first(phrases.begin()), last(phrases.end()); +00476 for (; first != last; ++first) +00477 { +00478 const TPhrase &p = *first; +00479 +00480 if (removeDiffComments) +00481 { +00482 string comment = p.Comments.toString(); +00483 vector<string> lines; +00484 explode(comment, "\n", lines, true); +00485 +00486 uint i; +00487 for (i=0; i<lines.size(); ++i) +00488 { +00489 if (lines[i].find("// DIFF ") != string::npos) +00490 { +00491 lines.erase(lines.begin()+i); +00492 --i; +00493 } +00494 } +00495 +00496 comment.erase(); +00497 for (i=0; i<lines.size(); ++i) +00498 { +00499 comment += lines[i] + "\n"; +00500 } +00501 p.Comments = ucstring(comment); +00502 } +00503 ret += p.Comments; +00504 +00505 if (!p.Identifier.empty() || !p.Clauses.empty()) +00506 { +00507 if (p.Comments.find(ucstring("// HASH_VALUE ")) == ucstring::npos) +00508 { +00509 // add the hash value. +00510 ret += ucstring("// HASH_VALUE ")+CI18N::hashToString(p.HashValue) + nl; +00511 } +00512 ret += p.Identifier + " ("+p.Parameters + ")" + nl; +00513 ret += '{'; +00514 ret += nl; +00515 for (uint i=0; i<p.Clauses.size(); ++i) +00516 { +00517 const TClause &c = p.Clauses[i]; +00518 if (!c.Comments.empty()) +00519 { +00520 ucstring comment = tabLines(1, c.Comments); +00521 ret += comment; // + '\r'+'\n'; +00522 } +00523 if (!c.Conditions.empty()) +00524 { +00525 ucstring cond = tabLines(1, c.Conditions); +00526 ret += cond + nl; +00527 } +00528 ret += '\t'; +00529 // ucstring text = CI18N::makeMarkedString('[', ']', c.Text); +00530 +00531 ucstring text = CI18N::makeMarkedString('[', ']', c.Text);; +00532 ucstring text2; +00533 // add new line and tab after each \n tag +00534 ucstring::size_type pos; +00535 const ucstring nlTag("\\n"); +00536 while ((pos = text.find(nlTag)) != ucstring::npos) +00537 { +00538 text2 += text.substr(0, pos+2) + nl; +00539 text = text.substr(pos+2); +00540 } +00541 text2 += text;//.substr(0, pos+2); +00542 +00543 text.swap(text2); +00544 +00545 text = tabLines(3, text); +00546 // remove begin tabs +00547 text = text.substr(3); +00548 ret += '\t' + c.Identifier + '\t' + text + nl + nl; +00549 } +00550 ret += '}'; +00551 } +00552 ret += nl + nl; +00553 } +00554 +00555 return ret; +00556 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
ucstring prepareStringFile ( const std::vector< TStringInfo > & strings,
bool removeDiffComments
)
+
+ + + + + +
+ + + +
+
+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
ucstring prepareStringFile ( const vector< TStringInfo > & strings,
bool removeDiffComments
)
+
+ + + + + +
+ + + +
+ +
+Definition at line 203 of file diff_tool.cpp. +
+References comment(), STRING_MANAGER::TStringInfo::Comments, NLMISC::explode(), STRING_MANAGER::TStringInfo::HashValue, STRING_MANAGER::TStringInfo::Identifier, nl, STRING_MANAGER::TStringInfo::Text, NLMISC::toString(), ucstring::toString(), and uint. +
+
00204 { +00205 ucstring diff; +00206 +00207 vector<TStringInfo>::const_iterator first(strings.begin()), last(strings.end()); +00208 for (; first != last; ++first) +00209 { +00210 ucstring str; +00211 const TStringInfo &si = *first; +00212 string comment = si.Comments.toString(); +00213 vector<string> lines; +00214 explode(comment, "\n", lines, true); +00215 +00216 uint i; +00217 for (i=0; i<lines.size(); ++i) +00218 { +00219 if (removeDiffComments) +00220 { +00221 if (lines[i].find("// DIFF ") != string::npos) +00222 { +00223 lines.erase(lines.begin()+i); +00224 --i; +00225 continue; +00226 } +00227 } +00228 if (lines[i].find("// INDEX ") != string::npos) +00229 { +00230 lines.erase(lines.begin()+i); +00231 --i; +00232 } +00233 else if (lines[i].find("// HASH_VALUE ") != string::npos) +00234 { +00235 lines.erase(lines.begin()+i); +00236 --i; +00237 } +00238 } +00239 +00240 comment.erase(); +00241 for (i=0; i<lines.size(); ++i) +00242 { +00243 comment += lines[i] + "\n"; +00244 } +00245 si.Comments = ucstring(comment); +00246 +00247 str = si.Comments; +00248 if (!si.Identifier.empty() || !si.Text.empty()) +00249 { +00250 // add hash value comment if needed +00251 // if (si.Comments.find(ucstring("// HASH_VALUE ")) == ucstring::npos) +00252 str += ucstring("// HASH_VALUE ") + CI18N::hashToString(si.HashValue)+ nl; +00253 str += ucstring("// INDEX ") + NLMISC::toString("%u", first-strings.begin())+ nl; +00254 str += si.Identifier + '\t'; +00255 +00256 ucstring text = CI18N::makeMarkedString('[', ']', si.Text);; +00257 ucstring text2; +00258 // add new line and tab after each \n tag +00259 ucstring::size_type pos; +00260 const ucstring nlTag("\\n"); +00261 while ((pos = text.find(nlTag)) != ucstring::npos) +00262 { +00263 text2 += text.substr(0, pos+2) + nl + "\t"; +00264 text = text.substr(pos+2); +00265 } +00266 text2 += text;//.substr(0, pos+2); +00267 str += text2 + nl + nl; +00268 // str += CI18N::makeMarkedString('[', ']', si.Text) + nl + nl; +00269 } +00270 +00271 // nldebug("Adding string [%s]", str.toString().c_str()); +00272 diff += str; +00273 } +00274 +00275 return diff; +00276 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
bool STRING_MANAGER::readExcelSheet ( const ucstring & text,
TWorksheet & worksheet,
bool checkUnique = true
)
+
+ + + + + +
+ + + +
+append last cell +
+Definition at line 578 of file diff_tool.cpp. +
+References STRING_MANAGER::TWorksheet::ColCount, STRING_MANAGER::TWorksheet::getData(), STRING_MANAGER::TWorksheet::insertColumn(), nl, nlassert, nlwarning, STRING_MANAGER::TWorksheet::resize(), STRING_MANAGER::TWorksheet::setData(), STRING_MANAGER::TWorksheet::size(), ucstring::toString(), ucchar, uint, and uint16. +
+Referenced by loadExcelSheet(). +
+
00579 { +00580 if(str.empty()) +00581 return true; +00582 +00583 // copy the str to a big ucchar array => Avoid allocation / free +00584 vector<ucchar> strArray; +00585 // append a '\0' +00586 strArray.resize(str.size()+1); +00587 strArray[strArray.size()-1]= 0; +00588 memcpy(&strArray[0], &str[0], str.size()*sizeof(ucchar)); +00589 +00590 +00591 // **** Build array of lines. just point to strArray, and fill 0 where appropriated +00592 vector<ucchar*> lines; +00593 lines.reserve(500); +00594 ucstring::size_type pos = 0; +00595 ucstring::size_type lastPos = 0; +00596 while ((pos = str.find(nl, lastPos)) != ucstring::npos) +00597 { +00598 if (pos>lastPos) +00599 { +00600 strArray[pos]= 0; +00601 // nldebug("Found line : [%s]", ucstring(&strArray[lastPos]).toString().c_str()); +00602 lines.push_back(&strArray[lastPos]); +00603 } +00604 lastPos = pos + 2; +00605 } +00606 +00607 // Must add last line if no \r\n ending +00608 if (lastPos < str.size()) +00609 { +00610 pos= str.size(); +00611 strArray[pos]= 0; +00612 // nldebug("Found line : [%s]", ucstring(&strArray[lastPos]).toString().c_str()); +00613 lines.push_back(&strArray[lastPos]); +00614 } +00615 +00616 // nldebug("Found %u lines", lines.size()); +00617 +00618 // **** Do 2 pass.1st count the cell number, then fill. => avoid reallocation +00619 uint newColCount= 0; +00620 uint i; +00621 for (i=0; i<lines.size(); ++i) +00622 { +00623 uint numCells; +00624 numCells= 0; +00625 +00626 ucchar *first= lines[i]; +00627 for (; *first != 0; ++first) +00628 { +00629 if (*first == '\t') +00630 { +00631 numCells++; +00632 } +00633 else if (*first == '"' && first==lines[i]) +00634 { +00635 // read a quoted field. +00636 first++; +00637 while (*first != 0 && *first != '"' && *(first+1) != 0 && *(first+1) != '"') +00638 { +00639 first++; +00640 if (*first != 0 && *first == '"') +00641 { +00642 // skip this +00643 first++; +00644 } +00645 } +00646 } +00647 } +00648 // last cell +00649 numCells++; +00650 +00651 // take max cell of all lines +00652 newColCount= max(newColCount, numCells); +00653 } +00654 +00655 +00656 // **** alloc / enlarge worksheet +00657 // enlarge Worksheet column size, as needed +00658 while (worksheet.ColCount < newColCount) +00659 worksheet.insertColumn(worksheet.ColCount); +00660 +00661 // enlarge Worksheet row size, as needed +00662 uint startLine= worksheet.size(); +00663 worksheet.resize(startLine + lines.size()); +00664 +00665 +00666 // **** fill worksheet +00667 ucstring cell; +00668 for (i=0; i<lines.size(); ++i) +00669 { +00670 uint numCells; +00671 numCells= 0; +00672 cell.erase(); +00673 +00674 ucchar *first= lines[i]; +00675 for (; *first != 0; ++first) +00676 { +00677 if (*first == '\t') +00678 { +00679 // nldebug("Found cell [%s]", cell.toString().c_str()); +00680 worksheet.setData(startLine + i, numCells, cell); +00681 numCells++; +00682 cell.erase(); +00683 } +00684 else if (*first == '"' && first==lines[i]) +00685 { +00686 // read a quoted field. +00687 first++; +00688 while (*first != 0 && *first != '"' && *(first+1) != 0 && *(first+1) != '"') +00689 { +00690 cell += *first; +00691 first++; +00692 if (*first != 0 && *first == '"') +00693 { +00694 // skip this +00695 first++; +00696 } +00697 } +00698 } +00699 else +00700 { +00701 cell += *first; +00702 } +00703 } +00704 // nldebug("Found cell [%s]", cell.toString().c_str()); +00706 worksheet.setData(startLine + i, numCells, cell); +00707 numCells++; +00708 nlassert(numCells<=newColCount); +00709 // nldebug("Found %u cells in line %u", numCells, i); +00710 } +00711 +00712 +00713 // **** identifier uniqueness checking. +00714 if (checkUnique) +00715 { +00716 if (worksheet.size() > 0) +00717 { +00718 // look for the first non '* tagged' or 'DIFF_CMD' column +00719 uint nameCol = 0; +00720 while (nameCol < worksheet.ColCount && (*worksheet.getData(0, nameCol).begin() == uint16('*') || worksheet.getData(0, nameCol) == ucstring("DIFF_CMD"))) +00721 ++nameCol; +00722 +00723 if (nameCol < worksheet.ColCount ) +00724 { +00725 // ok we can check unikness +00726 bool error = false; +00727 set<ucstring> unik; +00728 set<ucstring>::iterator it; +00729 for (uint j=0; j<worksheet.size(); ++j) +00730 { +00731 it = unik.find(worksheet.getData(j, nameCol)); +00732 if (it != unik.end()) +00733 { +00734 nlwarning("DT: loadStringFile : identifier '%s' exist twice", worksheet.getData(j, nameCol).toString().c_str() ); +00735 error = true; +00736 } +00737 else +00738 unik.insert(worksheet.getData(j, nameCol)); +00739 } +00740 if (error) +00741 return false; +00742 } +00743 } +00744 } +00745 +00746 return true; +00747 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
bool STRING_MANAGER::readPhraseFile ( const std::string & filename,
std::vector< TPhrase > & phrases,
bool forceRehash
)
+
+ + + + + +
+ + + +
+ +
+Definition at line 279 of file diff_tool.cpp. +
+References STRING_MANAGER::TPhrase::Clauses, STRING_MANAGER::TClause::Comments, STRING_MANAGER::TPhrase::Comments, STRING_MANAGER::TClause::Conditions, STRING_MANAGER::TPhrase::HashValue, STRING_MANAGER::TClause::Identifier, STRING_MANAGER::TPhrase::Identifier, makePhraseHash(), nlwarning, STRING_MANAGER::TPhrase::Parameters, parseHashFromComment(), STRING_MANAGER::TClause::Text, and uint. +
+
00280 { +00281 ucstring doc; +00282 +00283 CI18N::readTextFile(filename, doc, false, false, true); +00284 +00285 // CI18N::writeTextFile("test.txt", doc, false); +00286 +00287 /* uint8 *buffer = 0; +00288 uint size; +00289 */ +00290 +00291 /* try +00292 { +00293 CIFile fp(filename); +00294 size = fp.getFileSize(); +00295 buffer = new uint8[size]; +00296 fp.serialBuffer(buffer, size); +00297 } +00298 catch(Exception &e) +00299 { +00300 nlinfo("Can't open file [%s] (%s)\n", filename.c_str(), e.what()); +00301 return true; +00302 } +00303 */ +00304 /* FILE *fp = fopen(filename.c_str(), "rb"); +00305 if (fp == 0) +00306 { +00307 nlinfo("Could't not open %s\n", filename.c_str()); +00308 return true; +00309 } +00310 uint size = CFile::getFileSize(fp); +00311 uint8 *buffer = new uint8[size]; +00312 fread(buffer, 1, size, fp); +00313 fclose(fp); +00314 */ +00315 /* CI18N::readTextBuffer(buffer, size, doc); +00316 delete [] buffer; +00317 */ +00318 std::string lastRead("nothing"); +00319 +00320 ucstring::const_iterator first(doc.begin()), last(doc.end()); +00321 while (first != last) +00322 { +00323 TPhrase phrase; +00324 // parse the phrase +00325 CI18N::skipWhiteSpace(first, last, &phrase.Comments); +00326 +00327 if (first == last) +00328 break; +00329 if (!CI18N::parseLabel(first, last, phrase.Identifier)) +00330 { +00331 nlwarning("DT: Error parsing phrase identifier after %s\n", lastRead.c_str()); +00332 return false; +00333 } +00334 // nldebug("DT: parsing phrase '%s'", phrase.Identifier.c_str()); +00335 lastRead = phrase.Identifier; +00336 CI18N::skipWhiteSpace(first, last, &phrase.Comments); +00337 if (!CI18N::parseMarkedString('(', ')', first, last, phrase.Parameters)) +00338 { +00339 nlwarning("DT: Error parsing parameter list for phrase %s\n", phrase.Identifier.c_str()); +00340 return false; +00341 } +00342 CI18N::skipWhiteSpace(first, last, &phrase.Comments); +00343 if (first == last || *first != '{') +00344 { +00345 nlwarning("DT: Error parsing block opening '{' in phase %s\n", phrase.Identifier.c_str()); +00346 return false; +00347 } +00348 ++first; +00349 +00350 ucstring temp; +00351 +00352 while (first != last && *first != '}') +00353 { +00354 TClause clause; +00355 // append the comment preread at previous pass +00356 clause.Comments = temp; +00357 temp.erase(); +00358 // parse the clauses +00359 CI18N::skipWhiteSpace(first, last, &clause.Comments); +00360 if (first == last) +00361 { +00362 nlwarning("DT: Found end of file in non closed block for phrase %s\n", phrase.Identifier.c_str()); +00363 return false; +00364 } +00365 +00366 if (*first == '}') +00367 break; +00368 +00369 // skip the conditionnal expression +00370 ucstring cond; +00371 while (first != last && *first == '(') +00372 { +00373 if (!CI18N::parseMarkedString('(', ')', first, last, cond)) +00374 { +00375 nlwarning("DT: Error parsing conditionnal expression in phrase %s, clause %u\n", phrase.Identifier.c_str(), phrase.Clauses.size()+1); +00376 return false; +00377 } +00378 clause.Conditions += "(" + cond + ") "; +00379 CI18N::skipWhiteSpace(first, last, &clause.Comments); +00380 } +00381 if (first == last) +00382 { +00383 nlwarning("DT: Found end of file in non closed block for phrase %s\n", phrase.Identifier.c_str()); +00384 return false; +00385 } +00386 // read the idnetifier (if any) +00387 CI18N::parseLabel(first, last, clause.Identifier); +00388 CI18N::skipWhiteSpace(first, last, &temp); +00389 // read the text +00390 if (CI18N::parseMarkedString('[', ']', first, last, clause.Text)) +00391 { +00392 // the last read comment is for this clause. +00393 clause.Comments += temp; +00394 temp.erase(); +00395 } +00396 else +00397 { +00398 nlwarning("DT: Error reading text for clause %u (%s) in phrase %s\n", +00399 phrase.Clauses.size()+1, +00400 clause.Identifier.c_str(), +00401 phrase.Identifier.c_str()); +00402 return false; +00403 +00404 } +00405 +00406 phrase.Clauses.push_back(clause); +00407 } +00408 CI18N::skipWhiteSpace(first, last); +00409 if (first == last || *first != '}') +00410 { +00411 nlwarning("DT: Missing block clogin tag '}' in phrase %s\n", phrase.Identifier.c_str()); +00412 return false; +00413 } +00414 ++first; +00415 +00416 // handle hash value. +00417 if (forceRehash || !parseHashFromComment(phrase.Comments, phrase.HashValue)) +00418 { +00419 // the hash is not in the comment, compute it. +00420 phrase.HashValue = makePhraseHash(phrase); +00421 } +00422 +00423 // nldebug("DT : storing phrase '%s'", phrase.Identifier.c_str()); +00424 phrases.push_back(phrase); +00425 } +00426 +00427 // check identifier uniqueness +00428 { +00429 bool error = false; +00430 set<string> unik; +00431 set<string>::iterator it; +00432 for (uint i=0; i<phrases.size(); ++i) +00433 { +00434 it = unik.find(phrases[i].Identifier); +00435 if (it != unik.end()) +00436 { +00437 nlwarning("DT: loadStringFile : identifier '%s' exist twice", phrases[i].Identifier.c_str() ); +00438 error = true; +00439 } +00440 else +00441 unik.insert(phrases[i].Identifier); +00442 } +00443 if (error) +00444 return false; +00445 } +00446 +00447 return true; +00448 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
ucstring STRING_MANAGER::tabLines ( uint nbTab,
const ucstring & str
)
+
+ + + + + +
+ + + +
+ +
+Definition at line 449 of file diff_tool.cpp. +
+References uint. +
+Referenced by preparePhraseFile(). +
+
00450 { +00451 ucstring ret; +00452 ucstring tabs; +00453 +00454 for (uint i =0; i<nbTab; ++i) +00455 tabs.push_back('\t'); +00456 +00457 ret = tabs; +00458 ucstring::const_iterator first(str.begin()), last(str.end()); +00459 for (; first != last; ++first) +00460 { +00461 ret += *first; +00462 if (*first == '\n') +00463 ret += tabs; +00464 } +00465 +00466 while (ret[ret.size()-1] == '\t') +00467 ret = ret.substr(0, ret.size()-1); +00468 +00469 return ret; +00470 } +

+

Variable Documentation

+ + + + +
+ + +
const ucstring STRING_MANAGER::nl("\r\n") +
+
+ + + + + +
+ + + +
+ +
+Referenced by prepareExcelSheet(), preparePhraseFile(), prepareStringFile(), and readExcelSheet().
+

Generated on Tue Mar 16 14:54:11 2004 for NeL by + +

+1.3.6

+ + -- cgit v1.2.1


Data Structures
class	CMakeDiff
struct	CMakeDiff::IDiffCallback
struct	TClause
struct	TGetHashValue
struct	TGetIdentifier
struct	TGetWorksheetHashValue
struct	TGetWorksheetIdentifier
struct	TPhrase
struct	TPhraseDiffContext
struct	TStringDiffContext
struct	TStringInfo
struct	TTestItem
struct	TTestWorksheetItem
struct	TWordsDiffContext
struct	TWorksheet
Typedefs
typedef CMakeDiff< TPhrase, + TPhraseDiffContext >	TPhraseDiff
typedef CMakeDiff< TStringInfo, + TStringDiffContext >	TStringDiff
typedef CMakeDiff< TWorksheet::TRow, + TWordsDiffContext, TGetWorksheetIdentifier, + TGetWorksheetHashValue, TTestWorksheetItem >	TWorkSheetDiff
Functions
bool	loadExcelSheet (const string filename, TWorksheet &worksheet, bool checkUnique)
bool	loadStringFile (const std::string filename, vector< TStringInfo > &stringInfos, bool forceRehash, ucchar openMark, ucchar closeMark, bool specialCase)
void	makeHashCode (TWorksheet &sheet, bool forceRehash)
uint64	makePhraseHash (const TPhrase &phrase)
bool	parseHashFromComment (const ucstring &comments, uint64 &hashValue)
ucstring	prepareExcelSheet (const TWorksheet &worksheet)
ucstring	preparePhraseFile (const std::vector< TPhrase > &phrases, bool removeDiffComments)
ucstring	preparePhraseFile (const vector< TPhrase > &phrases, bool removeDiffComments)
ucstring	prepareStringFile (const std::vector< TStringInfo > &strings, bool removeDiffComments)
ucstring	prepareStringFile (const vector< TStringInfo > &strings, bool removeDiffComments)
bool	readExcelSheet (const ucstring &str, TWorksheet &worksheet, bool checkUnique)
bool	readPhraseFile (const std::string &filename, vector< TPhrase > &phrases, bool forceRehash)
ucstring	tabLines (uint nbTab, const ucstring &str)
Variables
const ucstring	nl ("\r\n")