[Libreoffice-commits] .: connectivity/source
Muthu Subramanian
sumuthu at kemper.freedesktop.org
Thu Mar 1 00:59:49 PST 2012
connectivity/source/parse/sqliterator.cxx | 132 ++++++++++++++----------------
connectivity/source/parse/sqlnode.cxx | 106 +++++++++++-------------
2 files changed, 117 insertions(+), 121 deletions(-)
New commits:
commit d1e5860bc001f092477421cb871636f3b0071e28
Author: Philipp Weissenbacher <p.weissenbacher at gmail.com>
Date: Thu Mar 1 14:53:10 2012 +0530
Translate German comments.
diff --git a/connectivity/source/parse/sqliterator.cxx b/connectivity/source/parse/sqliterator.cxx
index ae31689..6a3b157 100644
--- a/connectivity/source/parse/sqliterator.cxx
+++ b/connectivity/source/parse/sqliterator.cxx
@@ -72,8 +72,8 @@ namespace connectivity
Reference< XNameAccess > m_xTableContainer;
Reference< XNameAccess > m_xQueryContainer;
- ::boost::shared_ptr< OSQLTables > m_pTables; /// all tables which participate in the SQL statement
- ::boost::shared_ptr< OSQLTables > m_pSubTables; /// all tables from sub queries not the tables from the select tables
+ ::boost::shared_ptr< OSQLTables > m_pTables; // all tables which participate in the SQL statement
+ ::boost::shared_ptr< OSQLTables > m_pSubTables; // all tables from sub queries not the tables from the select tables
::boost::shared_ptr< QueryNameSet > m_pForbiddenQueryNames;
sal_uInt32 m_nIncludeMask;
@@ -216,14 +216,14 @@ void OSQLParseTreeIterator::setParseTree(const OSQLParseNode * pNewParseTree)
return;
}
- // falls m_pParseTree aber keine Connection, dann Fehler
+ // If m_pParseTree, but no connection then return
if ( !m_pImpl->m_xTableContainer.is() )
return;
m_aErrors = SQLException();
- // Statement-Typ ermitteln ...
+ // Determine statement type ...
if (SQL_ISRULE(m_pParseTree,select_statement) || SQL_ISRULE(m_pParseTree,union_statement) )
{
m_eStatementType = SQL_STATEMENT_SELECT;
@@ -456,7 +456,7 @@ void OSQLParseTreeIterator::traverseOneTableName( OSQLTables& _rTables,const OSQ
::rtl::OUString aSchema,aTableName,aComposedName;
::rtl::OUString aTableRange(rTableRange);
- // Tabellenname abholen
+ // Get table name
OSQLParseNode::getTableComponents(pTableName,aCatalog,aSchema,aTableName,m_pImpl->m_xDatabaseMetaData);
// create the composed name like DOMAIN.USER.TABLE1
@@ -479,16 +479,16 @@ void OSQLParseTreeIterator::traverseOneTableName( OSQLTables& _rTables,const OSQ
//-----------------------------------------------------------------------------
void OSQLParseTreeIterator::impl_fillJoinConditions(const OSQLParseNode* i_pJoinCondition)
{
- if (i_pJoinCondition->count() == 3 && // Ausdruck is geklammert
+ if (i_pJoinCondition->count() == 3 && // Expression with brackets
SQL_ISPUNCTUATION(i_pJoinCondition->getChild(0),"(") &&
SQL_ISPUNCTUATION(i_pJoinCondition->getChild(2),")"))
{
impl_fillJoinConditions(i_pJoinCondition->getChild(1));
}
- else if (SQL_ISRULEOR2(i_pJoinCondition,search_condition,boolean_term) && // AND/OR-Verknuepfung:
+ else if (SQL_ISRULEOR2(i_pJoinCondition,search_condition,boolean_term) && // AND/OR logic operation:
i_pJoinCondition->count() == 3)
{
- // nur AND Verkn�pfung zulassen
+ // Only allow AND logic operation
if ( SQL_ISTOKEN(i_pJoinCondition->getChild(1),AND) )
{
impl_fillJoinConditions(i_pJoinCondition->getChild(0));
@@ -498,7 +498,7 @@ void OSQLParseTreeIterator::impl_fillJoinConditions(const OSQLParseNode* i_pJoin
else if (SQL_ISRULE(i_pJoinCondition,comparison_predicate))
{
// only the comparison of columns is allowed
- OSL_ENSURE(i_pJoinCondition->count() == 3,"OQueryDesignView::InsertJoinConnection: Fehler im Parse Tree");
+ OSL_ENSURE(i_pJoinCondition->count() == 3,"OQueryDesignView::InsertJoinConnection: error in the parse tree");
if (SQL_ISRULE(i_pJoinCondition->getChild(0),column_ref) &&
SQL_ISRULE(i_pJoinCondition->getChild(2),column_ref) &&
i_pJoinCondition->getChild(1)->getNodeType() == SQL_NODE_EQUAL)
@@ -540,7 +540,7 @@ void OSQLParseTreeIterator::getQualified_join( OSQLTables& _rTables, const OSQLP
else
{
const OSQLParseNode* pColumnCommalist = pJoin_spec->getChild(2);
- // Alle Columns in der column_commalist ...
+ // All columns in the column_commalist ...
for (sal_uInt32 i = 0; i < pColumnCommalist->count(); i++)
{
const OSQLParseNode * pCol = pColumnCommalist->getChild(i);
@@ -631,7 +631,7 @@ void OSQLParseTreeIterator::getSelect_statement(OSQLTables& _rTables,const OSQLP
const OSQLParseNode* pTableName = NULL;
::rtl::OUString aTableRange;
for (sal_uInt32 i = 0; i < pTableRefCommalist->count(); i++)
- { // from clause durchlaufen
+ { // Process FROM clause
aTableRange = ::rtl::OUString();
const OSQLParseNode* pTableListElement = pTableRefCommalist->getChild(i);
@@ -641,10 +641,10 @@ void OSQLParseTreeIterator::getSelect_statement(OSQLTables& _rTables,const OSQLP
}
else if ( SQL_ISRULE( pTableListElement, table_ref ) )
{
- // Tabellenreferenz kann aus Tabellennamen, Tabellennamen (+),'('joined_table')'(+) bestehen
+ // Table refereneces can be made up of table names, table names (+),'('joined_table')'(+)
pTableName = pTableListElement->getChild(0);
if( isTableNode( pTableName ) )
- { // Tabellennamen gefunden
+ { // Found table names
aTableRange = OSQLParseNode::getTableRange(pTableListElement);
traverseOneTableName( _rTables, pTableName, aTableRange );
}
@@ -762,7 +762,7 @@ namespace
}
}
else if(SQL_ISRULE(_pColumnRef,general_set_fct) || SQL_ISRULE(_pColumnRef,set_fct_spec))
- { // Funktion
+ { // Function
_pColumnRef->parseNodeToStr( _out_rColumnName, _rxConnection );
}
else if(_pColumnRef->getNodeType() == SQL_NODE_NAME)
@@ -803,14 +803,14 @@ void OSQLParseTreeIterator::getColumnRange( const OSQLParseNode* _pColumnRef,
sal_Bool OSQLParseTreeIterator::getColumnTableRange(const OSQLParseNode* pNode, ::rtl::OUString &rTableRange) const
{
RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen at sun.com", "OSQLParseTreeIterator::getColumnTableRange" );
- // Ermitteln ob alle Spalten zu einer Tabelle gehoeren
+ // See if all columns belong to one table
if (SQL_ISRULE(pNode,column_ref))
{
::rtl::OUString aColName, aTableRange;
getColumnRange(pNode, aColName, aTableRange);
if (aTableRange.isEmpty()) // keinen gefunden
{
- // dann die Spalte in den Tabellen suchen
+ // Look for the columns in the tables
for (ConstOSQLTablesIterator aIter = m_pImpl->m_pTables->begin(); aIter != m_pImpl->m_pTables->end(); ++aIter)
{
if (aIter->second.is())
@@ -936,7 +936,7 @@ bool OSQLParseTreeIterator::traverseSelectColumnNames(const OSQLParseNode* pSele
}
static ::rtl::OUString aEmptyString;
- // nyi: mehr Pruefung auf korrekte Struktur!
+ // nyi: more checks for correct structure!
if (pSelectNode->getChild(2)->isRule() && SQL_ISPUNCTUATION(pSelectNode->getChild(2)->getChild(0),"*"))
{
// SELECT * ...
@@ -957,7 +957,7 @@ bool OSQLParseTreeIterator::traverseSelectColumnNames(const OSQLParseNode* pSele
pColumnRef->getChild(0)->count() == 3 &&
SQL_ISPUNCTUATION(pColumnRef->getChild(0)->getChild(2),"*"))
{
- // alle Spalten der Tabelle
+ // All the table's columns
::rtl::OUString aTableRange;
pColumnRef->getChild(0)->parseNodeToStr( aTableRange, m_pImpl->m_xConnection, NULL, sal_False, sal_False );
setSelectColumnName(m_aSelectColumns,::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("*")), aEmptyString,aTableRange);
@@ -965,7 +965,7 @@ bool OSQLParseTreeIterator::traverseSelectColumnNames(const OSQLParseNode* pSele
}
else if (SQL_ISRULE(pColumnRef,derived_column))
{
- ::rtl::OUString aColumnAlias(getColumnAlias(pColumnRef)); // kann leer sein
+ ::rtl::OUString aColumnAlias(getColumnAlias(pColumnRef)); // can be empty
::rtl::OUString sColumnName;
::rtl::OUString aTableRange;
sal_Int32 nType = DataType::VARCHAR;
@@ -981,20 +981,20 @@ bool OSQLParseTreeIterator::traverseSelectColumnNames(const OSQLParseNode* pSele
if (SQL_ISRULE(pColumnRef,column_ref))
{
getColumnRange(pColumnRef,sColumnName,aTableRange);
- OSL_ENSURE(!sColumnName.isEmpty(),"Columnname darf nicht leer sein");
+ OSL_ENSURE(!sColumnName.isEmpty(),"Column name must not be empty!");
}
else /*if (SQL_ISRULE(pColumnRef,general_set_fct) || SQL_ISRULE(pColumnRef,set_fct_spec) ||
SQL_ISRULE(pColumnRef,position_exp) || SQL_ISRULE(pColumnRef,extract_exp) ||
SQL_ISRULE(pColumnRef,length_exp) || SQL_ISRULE(pColumnRef,char_value_fct)||
SQL_ISRULE(pColumnRef,num_value_exp) || SQL_ISRULE(pColumnRef,term))*/
{
- /* Funktionsaufruf vorhanden */
+ // Function call present
pColumnRef->parseNodeToStr( sColumnName, m_pImpl->m_xConnection, NULL, sal_False, sal_True );
::rtl::OUString sTableRange;
// check if the column is also a parameter
traverseORCriteria(pColumnRef); // num_value_exp
- // gehoeren alle beteiligten Spalten der Funktion zu einer Tabelle
+ // Do all involved columns of the function belong to one table?
if (m_pImpl->m_pTables->size() == 1)
{
aTableRange = m_pImpl->m_pTables->begin()->first;
@@ -1097,13 +1097,13 @@ void OSQLParseTreeIterator::traverseByColumnNames(const OSQLParseNode* pSelectNo
sColumnName = ::rtl::OUString();
if ( SQL_ISRULE(pColumnRef,column_ref) )
{
- // Column-Name (und TableRange):
+ // Column name (and TableRange):
if(SQL_ISRULE(pColumnRef,column_ref))
getColumnRange(pColumnRef,sColumnName,aTableRange);
- else // eine Expression
+ else // an expression
pColumnRef->parseNodeToStr( sColumnName, m_pImpl->m_xConnection, NULL, sal_False, sal_False );
- OSL_ENSURE(!sColumnName.isEmpty(),"sColumnName darf nicht leer sein");
+ OSL_ENSURE(!sColumnName.isEmpty(),"sColumnName must not be empty!");
}
else
{ // here I found a predicate
@@ -1212,8 +1212,8 @@ bool OSQLParseTreeIterator::traverseSelectionCriteria(const OSQLParseNode* pSele
return false;
- // Parse Tree analysieren (je nach Statement-Typ)
- // und Zeiger auf WHERE-Klausel setzen:
+ // Analyse parse tree (depending on statement type)
+ // and set pointer to WHERE clause:
OSQLParseNode * pWhereClause = NULL;
if (m_eStatementType == SQL_STATEMENT_SELECT)
@@ -1241,25 +1241,24 @@ bool OSQLParseTreeIterator::traverseSelectionCriteria(const OSQLParseNode* pSele
// nyi
OSL_FAIL("OSQLParseTreeIterator::getSelectionCriteria: positioned nyi");
} else {
- // Anderes Statement. Keine Selektionskriterien.
+ // Other statement, no selection criteria
return false;
}
if (! SQL_ISRULE(pWhereClause,where_clause)) {
- // Die Where Clause ist meistens optional, d. h. es koennte sich auch
- // um "optional_where_clause" handeln.
+ // The WHERE clause is optional most of the time; which means it could be a "optional_where_clause".
OSL_ENSURE(SQL_ISRULE(pWhereClause,opt_where_clause),"OSQLParseTreeIterator: error in parse tree!");
return false;
}
- // Wenn es aber eine where_clause ist, dann darf sie nicht leer sein:
+ // But if it's a where_clause, then it must not be empty
OSL_ENSURE(pWhereClause->count() == 2,"OSQLParseTreeIterator: error in parse tree!");
OSQLParseNode * pComparisonPredicate = pWhereClause->getChild(1);
OSL_ENSURE(pComparisonPredicate != NULL,"OSQLParseTreeIterator: error in parse tree!");
//
- // Und nun die Vergleichskriterien abarbeiten (rekursiv, alles ist erstmal ein OR-Kriterium):
+ // Process the comparison criteria now (recursively, for a start everything is an OR criterion)
//
traverseORCriteria(pComparisonPredicate);
@@ -1279,28 +1278,27 @@ void OSQLParseTreeIterator::traverseORCriteria(OSQLParseNode * pSearchCondition)
SQL_ISPUNCTUATION(pSearchCondition->getChild(2),")")
)
{
- // Runde Klammern um den Ausdruck
+ // Round brackets around the expression
traverseORCriteria(pSearchCondition->getChild(1));
} else if (SQL_ISRULE(pSearchCondition,search_condition) &&
pSearchCondition->count() == 3 &&
SQL_ISTOKEN(pSearchCondition->getChild(1),OR))
{
- // OR-Verknuepfung:
-
+ // OR logic operation
for (int i = 0; i < 3; i++) {
- if (i == 1) continue; // Schluesselwort OR ueberspringen
+ if (i == 1) continue; // Skip OR keyword
- // Ist das erste Element wieder eine OR-Verknuepfung?
+ // Is the first element an OR again?
if (i == 0 &&
SQL_ISRULE(pSearchCondition->getChild(0),search_condition) &&
pSearchCondition->getChild(0)->count() == 3 &&
SQL_ISTOKEN(pSearchCondition->getChild(0)->getChild(1),OR))
{
- // Dann rekursiv absteigen ...
+ // Then process recursively
traverseORCriteria(pSearchCondition->getChild(0));
} else {
- // AND-Kriterien ...
+ // AND criteria
traverseANDCriteria(pSearchCondition->getChild(i));
// if (! aIteratorStatus.IsSuccessful()) break;
}
@@ -1308,13 +1306,13 @@ void OSQLParseTreeIterator::traverseORCriteria(OSQLParseNode * pSearchCondition)
// if (! aIteratorStatus.IsSuccessful()) break;
}
} else {
- // Nur *ein* Kriterium oder eine AND-Verknuepfung von Kriterien.
- // Direkt die AND-Kriterien behandeln.
+ // Only *one* criterion or one AND logical operation of criteria
+ // Process the AND criteria directly
traverseANDCriteria(pSearchCondition);
// if (! aIteratorStatus.IsSuccessful()) return;
}
- // Fehler einfach weiterreichen.
+ // Just pass on the error
}
//-----------------------------------------------------------------------------
@@ -1330,32 +1328,32 @@ void OSQLParseTreeIterator::traverseANDCriteria(OSQLParseNode * pSearchCondition
SQL_ISPUNCTUATION(pSearchCondition->getChild(2),")")
)
{
- // Runde Klammern
+ // Round brackets
traverseANDCriteria(pSearchCondition->getChild(1));
}
- // Das erste Element ist eine OR-Verknuepfung
+ // The first element is an OR logical operation
else if ( SQL_ISRULE(pSearchCondition,search_condition) && pSearchCondition->count() == 3 )
{
- // Dann rekursiv absteigen (dieselbe Row benutzen) ...
+ // Then process recursively (use the same row) ...
traverseORCriteria(pSearchCondition->getChild(0));
// if (! aIteratorStatus.IsSuccessful())
// return;
- // Und mit dem rechten Child weitermachen:
+ // Continue with the right child
traverseANDCriteria(pSearchCondition->getChild(2));
}
- // Das erste Element ist (wieder) eine AND-Verknuepfung
+ // The first element is an AND logical operation (again)
else if ( SQL_ISRULE(pSearchCondition,boolean_term) && pSearchCondition->count() == 3 )
{
- // Dann rekursiv absteigen (dieselbe Row benutzen) ...
+ // Then process recursively (use the same row)
traverseANDCriteria(pSearchCondition->getChild(0));
// if (! aIteratorStatus.IsSuccessful())
// return;
- // Und mit dem rechten Child weitermachen:
+ // Continue with the right child
traverseANDCriteria(pSearchCondition->getChild(2));
}
- // Sonst einzelne Suchkriterien wie =, !=, ..., LIKE, IS NULL usw. behandeln:
+ // Else, process single search criteria (like =, !=, ..., LIKE, IS NULL etc.)
else if (SQL_ISRULE(pSearchCondition,comparison_predicate) )
{
::rtl::OUString aValue;
@@ -1389,7 +1387,7 @@ void OSQLParseTreeIterator::traverseANDCriteria(OSQLParseNode * pSearchCondition
if (SQL_ISRULE(pNum_value_exp,parameter))
pParam = pNum_value_exp;
else if(pNum_value_exp->isToken())
- // Normaler Wert
+ // Normal value
aValue = pNum_value_exp->getTokenValue();
else
{
@@ -1442,7 +1440,7 @@ void OSQLParseTreeIterator::traverseANDCriteria(OSQLParseNode * pSearchCondition
traverseOnePredicate(pSearchCondition->getChild(0),aString,pSearchCondition->getChild(0));
traverseOnePredicate(pSearchCondition->getChild(2),aString,pSearchCondition->getChild(2));
}
- // Fehler einfach weiterreichen.
+ // Just pass on the error
}
//-----------------------------------------------------------------------------
void OSQLParseTreeIterator::traverseParameter(const OSQLParseNode* _pParseNode
@@ -1589,7 +1587,7 @@ void OSQLParseTreeIterator::traverseOnePredicate(
if ( !pParseNode )
return;
- // Column-Name (und TableRange):
+ // Column name (and TableRange):
::rtl::OUString aColumnName, aTableRange, sColumnAlias;
getColumnRange( pColumnRef, aColumnName, aTableRange, sColumnAlias);
@@ -1659,7 +1657,7 @@ void OSQLParseTreeIterator::impl_traverse( sal_uInt32 _nIncludeMask )
}
}
-// Dummy-Implementationen:
+// Dummy implementations
//-----------------------------------------------------------------------------
OSQLTable OSQLParseTreeIterator::impl_createTableObject( const ::rtl::OUString& rTableName,
@@ -1816,7 +1814,7 @@ void OSQLParseTreeIterator::setSelectColumnName(::rtl::Reference<OSQLColumns>& _
_rColumns->get().push_back(xCol);
}
}
- else // ColumnName und Tablename vorhanden
+ else // ColumnName and TableName exist
{
ConstOSQLTablesIterator aFind = m_pImpl->m_pTables->find(rTableRange);
@@ -1859,7 +1857,7 @@ void OSQLParseTreeIterator::setSelectColumnName(::rtl::Reference<OSQLColumns>& _
else
bError = sal_True;
- // Tabelle existiert nicht oder Feld nicht vorhanden
+ // Table does not exist or lacking field
if (bError)
{
::rtl::OUString aNewColName(getUniqueColumnName(rColumnAlias));
@@ -1953,8 +1951,8 @@ const OSQLParseNode* OSQLParseTreeIterator::getWhereTree() const
if (!m_pParseTree)
return NULL;
- // Parse Tree analysieren (je nach Statement-Typ)
- // und Zeiger auf WHERE-Klausel setzen:
+ // Analyse parse tree (depending on statement type)
+ // and set pointer to WHERE clause:
OSQLParseNode * pWhereClause = NULL;
if(getStatementType() == SQL_STATEMENT_SELECT)
{
@@ -1985,8 +1983,8 @@ const OSQLParseNode* OSQLParseTreeIterator::getOrderTree() const
if (!m_pParseTree || getStatementType() != SQL_STATEMENT_SELECT)
return NULL;
- // Parse Tree analysieren (je nach Statement-Typ)
- // und Zeiger auf ORDER-Klausel setzen:
+ // Analyse parse tree (depending on statement type)
+ // and set pointer to ORDER clause:
OSQLParseNode * pOrderClause = NULL;
OSL_ENSURE(m_pParseTree->count() >= 4,"ParseTreeIterator: error in parse tree!");
OSQLParseNode * pTableExp = m_pParseTree->getChild(3);
@@ -2007,8 +2005,8 @@ const OSQLParseNode* OSQLParseTreeIterator::getGroupByTree() const
if (!m_pParseTree || getStatementType() != SQL_STATEMENT_SELECT)
return NULL;
- // Parse Tree analysieren (je nach Statement-Typ)
- // und Zeiger auf ORDER-Klausel setzen:
+ // Analyse parse tree (depending on statement type)
+ // and set pointer to ORDER clause:
OSQLParseNode * pGroupClause = NULL;
OSL_ENSURE(m_pParseTree->count() >= 4,"ParseTreeIterator: error in parse tree!");
OSQLParseNode * pTableExp = m_pParseTree->getChild(3);
@@ -2028,8 +2026,8 @@ const OSQLParseNode* OSQLParseTreeIterator::getHavingTree() const
if (!m_pParseTree || getStatementType() != SQL_STATEMENT_SELECT)
return NULL;
- // Parse Tree analysieren (je nach Statement-Typ)
- // und Zeiger auf ORDER-Klausel setzen:
+ // Analyse parse tree (depending on statement type)
+ // and set pointer to ORDER clause:
OSQLParseNode * pHavingClause = NULL;
OSL_ENSURE(m_pParseTree->count() >= 4,"ParseTreeIterator: error in parse tree!");
OSQLParseNode * pTableExp = m_pParseTree->getChild(3);
@@ -2038,7 +2036,7 @@ const OSQLParseNode* OSQLParseTreeIterator::getHavingTree() const
OSL_ENSURE(pTableExp->count() == TABLE_EXPRESSION_CHILD_COUNT,"OSQLParseTreeIterator: error in parse tree!");
pHavingClause = pTableExp->getChild(3);
- // Wenn es aber eine order_by ist, dann darf sie nicht leer sein:
+ // If it is an order_by, then it must not be empty
if(pHavingClause->count() < 1)
pHavingClause = NULL;
return pHavingClause;
@@ -2116,7 +2114,7 @@ Reference< XPropertySet > OSQLParseTreeIterator::findColumn(const OSQLTables& _r
if( xColumns.is() && xColumns->hasByName(rColumnName) && (xColumns->getByName(rColumnName) >>= xColumn) )
{
OSL_ENSURE(xColumn.is(),"Column isn't a propertyset!");
- break; // diese Column darf nur einmal vorkommen
+ break; // This column must only exits once
}
}
}
@@ -2186,7 +2184,7 @@ sal_Int32 OSQLParseTreeIterator::getFunctionReturnType(const OSQLParseNode* _pNo
::rtl::OUString sColumnName;
::rtl::OUString aTableRange;
getColumnRange(pValueExp,sColumnName,aTableRange);
- OSL_ENSURE(!sColumnName.isEmpty(),"Columnname darf nicht leer sein");
+ OSL_ENSURE(!sColumnName.isEmpty(),"Columnname must not be empty!");
Reference<XPropertySet> xColumn = findColumn( sColumnName, aTableRange, true );
if ( xColumn.is() )
diff --git a/connectivity/source/parse/sqlnode.cxx b/connectivity/source/parse/sqlnode.cxx
index d076f57..7b4e4dd 100644
--- a/connectivity/source/parse/sqlnode.cxx
+++ b/connectivity/source/parse/sqlnode.cxx
@@ -129,7 +129,7 @@ namespace
{
::rtl::OUString rNewValue = rQuot;
rNewValue += rValue;
- sal_Int32 nIndex = (sal_Int32)-1; // Quotes durch zweifache Quotes ersetzen, sonst kriegt der Parser Probleme
+ sal_Int32 nIndex = (sal_Int32)-1; // Replace quotes with double quotes or the parser gets into problems
if (!rQuot.isEmpty())
{
@@ -363,7 +363,7 @@ void OSQLParseNode::impl_parseNodeToString_throw(::rtl::OUStringBuffer& rString,
return;
}
- // einmal auswerten wieviel Subtrees dieser Knoten besitzt
+ // Lets see how many nodes this subtree has
sal_uInt32 nCount = count();
bool bHandled = false;
@@ -412,9 +412,9 @@ void OSQLParseNode::impl_parseNodeToString_throw(::rtl::OUStringBuffer& rString,
break;
case like_predicate:
- // je nachdem ob international angegeben wird oder nicht wird like anders behandelt
- // interanational: *, ? sind Platzhalter
- // sonst SQL92 konform: %, _
+ // Depending on whether international is given, LIKE is treated differently
+ // international: *, ? are placeholders
+ // else SQL92 conform: %, _
impl_parseLikeNodeToString_throw( rString, rParam );
bHandled = true;
break;
@@ -428,7 +428,7 @@ void OSQLParseNode::impl_parseNodeToString_throw(::rtl::OUStringBuffer& rString,
{
if (!addDateValue(rString, rParam))
{
- // Funktionsname nicht quoten
+ // Do not quote function name
SQLParseNodeParameter aNewParam(rParam);
aNewParam.bQuote = ( SQL_ISRULE(this,length_exp) || SQL_ISRULE(this,char_value_fct) );
@@ -443,7 +443,7 @@ void OSQLParseNode::impl_parseNodeToString_throw(::rtl::OUStringBuffer& rString,
{
pSubTree->impl_parseNodeToString_throw( aStringPara, aNewParam );
- // bei den CommaListen zwischen alle Subtrees Commas setzen
+ // In the comma lists, put commas in-between all subtrees
if ((m_eNodeType == SQL_NODE_COMMALISTRULE) && (i < (nCount - 1)))
aStringPara.appendAscii(",");
}
@@ -527,7 +527,7 @@ void OSQLParseNode::impl_parseNodeToString_throw(::rtl::OUStringBuffer& rString,
pSubTree->impl_parseNodeToString_throw( rString, aNewParam );
++i;
- // bei den CommaListen zwischen alle Subtrees Commas setzen
+ // In the comma lists, put commas in-between all subtrees
if ((m_eNodeType == SQL_NODE_COMMALISTRULE) && (i != m_aChildren.end()))
rString.appendAscii(",");
}
@@ -537,7 +537,7 @@ void OSQLParseNode::impl_parseNodeToString_throw(::rtl::OUStringBuffer& rString,
pSubTree->impl_parseNodeToString_throw( rString, aNewParam );
++i;
- // bei den CommaListen zwischen alle Subtrees Commas setzen
+ // In the comma lists, put commas in-between all subtrees
if ((m_eNodeType == SQL_NODE_COMMALISTRULE) && (i != m_aChildren.end()))
{
if (SQL_ISRULE(this,value_exp_commalist) && rParam.bPredicate)
@@ -877,7 +877,7 @@ OSQLParseNode* OSQLParser::convertNode(sal_Int32 nType,OSQLParseNode*& pLiteral)
case DataType::FLOAT:
case DataType::REAL:
case DataType::DOUBLE:
- // kill thousand seperators if any
+ // kill thousand seperators if any
killThousandSeparator(pReturn);
break;
case DataType::CHAR:
@@ -1236,7 +1236,7 @@ OSQLParseNode* OSQLParser::predicateTree(::rtl::OUString& rErrorMessage, const :
m_pParseTree = NULL;
m_sErrorMessage= ::rtl::OUString();
- // ... und den Parser anwerfen ...
+ // Start the parser
if (SQLyyparse() != 0)
{
m_sFieldName= ::rtl::OUString();
@@ -1266,11 +1266,10 @@ OSQLParseNode* OSQLParser::predicateTree(::rtl::OUString& rErrorMessage, const :
m_nFormatKey = 0;
m_nDateFormatKey = 0;
- // Das Ergebnis liefern (den Root Parse Node):
+ // Return the result (the root parse node):
- // Stattdessen setzt die Parse-Routine jetzt den Member pParseTree
- // - einfach diesen zurueckliefern:
- OSL_ENSURE(m_pParseTree != NULL,"OSQLParser: Parser hat keinen ParseTree geliefert");
+ // Instead, the parse method sets the member pParseTree and simply returns that
+ OSL_ENSURE(m_pParseTree != NULL,"OSQLParser: Parser did not return a ParseTree!");
return m_pParseTree;
}
}
@@ -1296,7 +1295,7 @@ OSQLParser::OSQLParser(const ::com::sun::star::uno::Reference< ::com::sun::star:
#endif
::osl::MutexGuard aGuard(getMutex());
- // do we have to initialize the data
+ // Do we have to initialize the data?
if (s_nRefCount == 0)
{
s_pScanner = new OSQLScanner();
@@ -1306,7 +1305,7 @@ OSQLParser::OSQLParser(const ::com::sun::star::uno::Reference< ::com::sun::star:
if(!s_xLocaleData.is())
s_xLocaleData = Reference<XLocaleData>(m_xServiceFactory->createInstance(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.i18n.LocaleData"))),UNO_QUERY);
- // auf 0 zuruecksetzen
+ // reset to 0
memset(OSQLParser::s_nRuleIDs,0,sizeof(OSQLParser::s_nRuleIDs[0]) * (OSQLParseNode::rule_count+1));
struct
@@ -1442,7 +1441,7 @@ OSQLParser::~OSQLParser()
{
{
::osl::MutexGuard aGuard(getMutex());
- OSL_ENSURE(s_nRefCount > 0, "OSQLParser::~OSQLParser() : suspicious call : have a refcount of 0 !");
+ OSL_ENSURE(s_nRefCount > 0, "OSQLParser::~OSQLParser() : suspicious call : has a refcount of 0 !");
if (!--s_nRefCount)
{
s_pScanner->setScanner(sal_True);
@@ -1451,7 +1450,7 @@ OSQLParser::~OSQLParser()
delete s_pGarbageCollector;
s_pGarbageCollector = NULL;
- // is only set the first time so we should delete it only when there no more instances
+ // Is only set the first time, so we should delete it only when there are no more instances
s_xLocaleData = NULL;
RuleIDMap aEmpty;
@@ -1560,7 +1559,7 @@ OSQLParseNode::OSQLParseNode(const sal_Char * pNewValue,
{
RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen at sun.com", "OSQLParseNode::OSQLParseNode" );
- OSL_ENSURE(m_eNodeType >= SQL_NODE_RULE && m_eNodeType <= SQL_NODE_CONCAT,"OSQLParseNode: mit unzulaessigem NodeType konstruiert");
+ OSL_ENSURE(m_eNodeType >= SQL_NODE_RULE && m_eNodeType <= SQL_NODE_CONCAT,"OSQLParseNode: created with invalid NodeType");
}
//-----------------------------------------------------------------------------
OSQLParseNode::OSQLParseNode(const ::rtl::OString &_rNewValue,
@@ -1573,7 +1572,7 @@ OSQLParseNode::OSQLParseNode(const ::rtl::OString &_rNewValue,
{
RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen at sun.com", "OSQLParseNode::OSQLParseNode" );
- OSL_ENSURE(m_eNodeType >= SQL_NODE_RULE && m_eNodeType <= SQL_NODE_CONCAT,"OSQLParseNode: mit unzulaessigem NodeType konstruiert");
+ OSL_ENSURE(m_eNodeType >= SQL_NODE_RULE && m_eNodeType <= SQL_NODE_CONCAT,"OSQLParseNode: created with invalid NodeType");
}
//-----------------------------------------------------------------------------
OSQLParseNode::OSQLParseNode(const sal_Unicode * pNewValue,
@@ -1586,7 +1585,7 @@ OSQLParseNode::OSQLParseNode(const sal_Unicode * pNewValue,
{
RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen at sun.com", "OSQLParseNode::OSQLParseNode" );
- OSL_ENSURE(m_eNodeType >= SQL_NODE_RULE && m_eNodeType <= SQL_NODE_CONCAT,"OSQLParseNode: mit unzulaessigem NodeType konstruiert");
+ OSL_ENSURE(m_eNodeType >= SQL_NODE_RULE && m_eNodeType <= SQL_NODE_CONCAT,"OSQLParseNode: created with invalid NodeType");
}
//-----------------------------------------------------------------------------
OSQLParseNode::OSQLParseNode(const ::rtl::OUString &_rNewValue,
@@ -1599,29 +1598,28 @@ OSQLParseNode::OSQLParseNode(const ::rtl::OUString &_rNewValue,
{
RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen at sun.com", "OSQLParseNode::OSQLParseNode" );
- OSL_ENSURE(m_eNodeType >= SQL_NODE_RULE && m_eNodeType <= SQL_NODE_CONCAT,"OSQLParseNode: mit unzulaessigem NodeType konstruiert");
+ OSL_ENSURE(m_eNodeType >= SQL_NODE_RULE && m_eNodeType <= SQL_NODE_CONCAT,"OSQLParseNode: created with invalid NodeType");
}
//-----------------------------------------------------------------------------
OSQLParseNode::OSQLParseNode(const OSQLParseNode& rParseNode)
{
RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen at sun.com", "OSQLParseNode::OSQLParseNode" );
- // klemm den getParent auf NULL
+ // Set the getParent to NULL
m_pParent = NULL;
- // kopiere die member
+ // Copy the members
m_aNodeValue = rParseNode.m_aNodeValue;
m_eNodeType = rParseNode.m_eNodeType;
m_nNodeID = rParseNode.m_nNodeID;
- // denk dran, dass von Container abgeleitet wurde, laut SV-Help erzeugt
- // copy-Constructor des Containers einen neuen Container mit den gleichen
- // Zeigern als Inhalt -> d.h. nach dem Kopieren des Container wird fuer
- // alle Zeiger ungleich NULL eine Kopie hergestellt und anstelle des alten
- // Zeigers wieder eingehangen.
+ // Remember that we derived from Container. According to SV-Help the Container's
+ // copy ctor creates a new Container with the same pointers for content.
+ // This means after copying the Container, for all non-NULL pointers a copy is
+ // created and reattached instead of the old pointer.
- // wenn kein Blatt, dann SubTrees bearbeiten
+ // If not a leaf, then process SubTrees
for (OSQLParseNodes::const_iterator i = rParseNode.m_aChildren.begin();
i != rParseNode.m_aChildren.end(); ++i)
append(new OSQLParseNode(**i));
@@ -1632,7 +1630,7 @@ OSQLParseNode& OSQLParseNode::operator=(const OSQLParseNode& rParseNode)
{
if (this != &rParseNode)
{
- // kopiere die member - pParent bleibt der alte
+ // Copy the members - pParent remains the same
m_aNodeValue = rParseNode.m_aNodeValue;
m_eNodeType = rParseNode.m_eNodeType;
m_nNodeID = rParseNode.m_nNodeID;
@@ -1653,7 +1651,7 @@ OSQLParseNode& OSQLParseNode::operator=(const OSQLParseNode& rParseNode)
//-----------------------------------------------------------------------------
sal_Bool OSQLParseNode::operator==(OSQLParseNode& rParseNode) const
{
- // die member muessen gleich sein
+ // The members must be equal
sal_Bool bResult = (m_nNodeID == rParseNode.m_nNodeID) &&
(m_eNodeType == rParseNode.m_eNodeType) &&
(m_aNodeValue == rParseNode.m_aNodeValue) &&
@@ -1683,14 +1681,14 @@ void OSQLParseNode::append(OSQLParseNode* pNewNode)
{
RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen at sun.com", "OSQLParseNode::append" );
- OSL_ENSURE(pNewNode != NULL, "OSQLParseNode: ungueltiger NewSubTree");
- OSL_ENSURE(pNewNode->getParent() == NULL, "OSQLParseNode: Knoten ist kein Waise");
+ OSL_ENSURE(pNewNode != NULL, "OSQLParseNode: invalid NewSubTree");
+ OSL_ENSURE(pNewNode->getParent() == NULL, "OSQLParseNode: Node is not an orphan");
OSL_ENSURE(::std::find(m_aChildren.begin(), m_aChildren.end(), pNewNode) == m_aChildren.end(),
"OSQLParseNode::append() Node already element of parent");
- // stelle Verbindung zum getParent her:
+ // Create connection to getParent
pNewNode->setParent( this );
- // und haenge den SubTree hinten an
+ // and attach the SubTree at the end
m_aChildren.push_back(pNewNode);
}
// -----------------------------------------------------------------------------
@@ -1936,7 +1934,7 @@ void OSQLParseNode::negateSearchCondition(OSQLParseNode*& pSearchCondition,sal_B
replaceAndReset(pSearchCondition,pBooleanTest);
if (!bNegate)
- negateSearchCondition(pSearchCondition,sal_True); // negate all deeper values
+ negateSearchCondition(pSearchCondition,sal_True); // negate all deeper values
}
// row_value_constructor comparison row_value_constructor
// row_value_constructor comparison any_all_some subquery
@@ -2132,7 +2130,7 @@ void OSQLParseNode::absorptions(OSQLParseNode*& pSearchCondition)
void OSQLParseNode::compress(OSQLParseNode *&pSearchCondition)
{
RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen at sun.com", "OSQLParseNode::compress" );
- if(!pSearchCondition) // no where condition at entry point
+ if(!pSearchCondition) // no WHERE condition at entry point
return;
OSQLParseNode::eraseBraces(pSearchCondition);
@@ -2252,7 +2250,7 @@ void OSQLParseNode::showParseTree( ::rtl::OUStringBuffer& _inout_rBuffer, sal_uI
if ( !isToken() )
{
- // Regelnamen als rule: ...
+ // Rule name as rule
_inout_rBuffer.appendAscii( "RULE_ID: " );
_inout_rBuffer.append( (sal_Int32)getRuleID() );
_inout_rBuffer.append( sal_Unicode( '(' ) );
@@ -2260,7 +2258,7 @@ void OSQLParseNode::showParseTree( ::rtl::OUStringBuffer& _inout_rBuffer, sal_uI
_inout_rBuffer.append( sal_Unicode( ')' ) );
_inout_rBuffer.append( sal_Unicode( '\n' ) );
- // hol dir den ersten Subtree
+ // Get the first sub tree
for ( OSQLParseNodes::const_iterator i = m_aChildren.begin();
i != m_aChildren.end();
++i
@@ -2269,7 +2267,7 @@ void OSQLParseNode::showParseTree( ::rtl::OUStringBuffer& _inout_rBuffer, sal_uI
}
else
{
- // ein Token gefunden
+ // Found a token
switch (m_eNodeType)
{
@@ -2360,20 +2358,20 @@ void OSQLParseNode::showParseTree( ::rtl::OUStringBuffer& _inout_rBuffer, sal_uI
}
#endif // OSL_DEBUG_LEVEL > 0
// -----------------------------------------------------------------------------
-// Insert-Methoden
+// Insert methods
//-----------------------------------------------------------------------------
void OSQLParseNode::insert(sal_uInt32 nPos, OSQLParseNode* pNewSubTree)
{
RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen at sun.com", "OSQLParseNode::insert" );
- OSL_ENSURE(pNewSubTree != NULL, "OSQLParseNode: ungueltiger NewSubTree");
- OSL_ENSURE(pNewSubTree->getParent() == NULL, "OSQLParseNode: Knoten ist kein Waise");
+ OSL_ENSURE(pNewSubTree != NULL, "OSQLParseNode: invalid NewSubTree");
+ OSL_ENSURE(pNewSubTree->getParent() == NULL, "OSQLParseNode: Node is not an orphan");
- // stelle Verbindung zum getParent her:
+ // Create connection to getParent
pNewSubTree->setParent( this );
m_aChildren.insert(m_aChildren.begin() + nPos, pNewSubTree);
}
-// removeAt-Methoden
+// removeAt methods
//-----------------------------------------------------------------------------
OSQLParseNode* OSQLParseNode::removeAt(sal_uInt32 nPos)
{
@@ -2382,7 +2380,7 @@ OSQLParseNode* OSQLParseNode::removeAt(sal_uInt32 nPos)
OSQLParseNodes::iterator aPos(m_aChildren.begin() + nPos);
OSQLParseNode* pNode = *aPos;
- // setze den getParent des removeten auf NULL
+ // Set the getParent of the removed node to NULL
pNode->setParent( NULL );
m_aChildren.erase(aPos);
@@ -2392,11 +2390,11 @@ OSQLParseNode* OSQLParseNode::removeAt(sal_uInt32 nPos)
OSQLParseNode* OSQLParseNode::remove(OSQLParseNode* pSubTree)
{
RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen at sun.com", "OSQLParseNode::remove" );
- OSL_ENSURE(pSubTree != NULL, "OSQLParseNode: ungueltiger SubTree");
+ OSL_ENSURE(pSubTree != NULL, "OSQLParseNode: invalid SubTree");
OSQLParseNodes::iterator aPos = ::std::find(m_aChildren.begin(), m_aChildren.end(), pSubTree);
if (aPos != m_aChildren.end())
{
- // setze den getParent des removeten auf NULL
+ // Set the getParent of the removed node to NULL
pSubTree->setParent( NULL );
m_aChildren.erase(aPos);
return pSubTree;
@@ -2405,7 +2403,7 @@ OSQLParseNode* OSQLParseNode::remove(OSQLParseNode* pSubTree)
return NULL;
}
-// Replace-Methoden
+// Replace methods
//-----------------------------------------------------------------------------
OSQLParseNode* OSQLParseNode::replaceAt(sal_uInt32 nPos, OSQLParseNode* pNewSubNode)
{
@@ -2418,7 +2416,7 @@ OSQLParseNode* OSQLParseNode::replaceAt(sal_uInt32 nPos, OSQLParseNode* pNewSubN
OSQLParseNode* pOldSubNode = m_aChildren[nPos];
- // stelle Verbindung zum getParent her:
+ // Create connection to getParent
pNewSubNode->setParent( this );
pOldSubNode->setParent( NULL );
@@ -2446,8 +2444,8 @@ OSQLParseNode* OSQLParseNode::replace (OSQLParseNode* pOldSubNode, OSQLParseNode
void OSQLParseNode::parseLeaf(::rtl::OUStringBuffer& rString, const SQLParseNodeParameter& rParam) const
{
RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "parse", "Ocke.Janssen at sun.com", "OSQLParseNode::parseLeaf" );
- // ein Blatt ist gefunden
- // Inhalt dem Ausgabestring anfuegen
+ // Found a leaf
+ // Append content to the output string
switch (m_eNodeType)
{
case SQL_NODE_KEYWORD:
More information about the Libreoffice-commits
mailing list