nsresult
nsFind::InitIterator(nsIDOMNode* aStartNode, PRInt32 aStartOffset,
nsIDOMNode* aEndNode, PRInt32 aEndOffset)
{
if (!mIterator)
{
mIterator = new nsFindContentIterator(mFindBackward);
NS_ENSURE_TRUE(mIterator, NS_ERROR_OUT_OF_MEMORY);
}
NS_ENSURE_ARG_POINTER(aStartNode);
NS_ENSURE_ARG_POINTER(aEndNode);
#ifdef DEBUG_FIND
printf("InitIterator search range:\n");
printf(" -- start %d, ", aStartOffset); DumpNode(aStartNode);
printf(" -- end %d, ", aEndOffset); DumpNode(aEndNode);
#endif
nsresult rv =
mIterator->Init(aStartNode, aStartOffset, aEndNode, aEndOffset);
NS_ENSURE_SUCCESS(rv, rv);
if (mFindBackward) {
mIterator->Last();
}
else {
mIterator->First();
}
return NS_OK;
}
static void GetApplication(MessageHandler *handler, NETFILE *fp,
ProcessNode *node) {
int i;
ConvFuncs *conv;
conv = handler->serialize;
LBS_EmitStart(iobuff);
RecvLargeString(fp, iobuff);
ON_IO_ERROR(fp, badio);
ConvSetRecName(handler->conv, node->mcprec->name);
conv->UnPackValue(handler->conv, LBS_Body(iobuff), node->mcprec->value);
if (node->linkrec != NULL) {
ConvSetRecName(handler->conv, node->linkrec->name);
conv->UnPackValue(handler->conv, LBS_Body(iobuff), node->linkrec->value);
}
if (node->sparec != NULL) {
ConvSetRecName(handler->conv, node->sparec->name);
conv->UnPackValue(handler->conv, LBS_Body(iobuff), node->sparec->value);
}
for (i = 0; i < node->cWindow; i++) {
if (node->scrrec[i] != NULL) {
ConvSetRecName(handler->conv, node->scrrec[i]->name);
conv->UnPackValue(handler->conv, LBS_Body(iobuff),
node->scrrec[i]->value);
}
}
DumpNode(node);
badio:
return;
}
// 递归遍历
void DumpNode(const TiXmlNode* pNode)
{
if (!pNode)
{
return;
}
const int nType = pNode->Type();
::printf("nType = %d, ", nType);
switch (nType)
{
case TiXmlNode::TINYXML_DOCUMENT:
::printf("Document\n");
break;
case TiXmlNode::TINYXML_ELEMENT:
{
const TiXmlElement* pElement = pNode->ToElement();
::printf("Element %s", pElement->Value());
// 如果有属性请打印
for (const TiXmlAttribute* pAttribute = pElement->FirstAttribute();
pAttribute != NULL; pAttribute = pAttribute->Next())
{
::printf(", %s = %s", pAttribute->Name(), pAttribute->Value());
}
::printf("\n");
}
break;
case TiXmlNode::TINYXML_COMMENT:
::printf("Comment: %s\n", pNode->Value());
break;
case TiXmlNode::TINYXML_UNKNOWN:
::printf("Unknown\n");
break;
case TiXmlNode::TINYXML_TEXT:
::printf("Text: %s\n", pNode->Value());
break;
case TiXmlNode::TINYXML_DECLARATION:
{
const TiXmlDeclaration* p = pNode->ToDeclaration();
::printf("Declaration: %s, %s, %s\n", p->Version(), p->Encoding(), p->Standalone());
}
break;
default:
break;
}
// 递归处理
for (const TiXmlNode* pSubNode = pNode->FirstChild();
pSubNode != NULL; pSubNode = pSubNode->NextSibling())
{
DumpNode(pSubNode);
}
}
void
GiST::Print(ostream& os) const
{
GiSTpath path;
path.MakeRoot();
DumpNode(os, path);
}
static TRI_aql_node_t* DumpStatementStart (TRI_aql_statement_walker_t* const walker,
TRI_aql_node_t* const node) {
if (node == NULL) {
return node;
}
assert(walker);
Indent((TRI_aql_dump_t*) walker->_data);
return DumpNode(walker, node);
}
/**
* Prints graph structure in stderr.
*/
void vf_Graph::DumpGraph()
{
#if _VF_DEBUG
VF_DEBUG("Method: " << class_get_name(m_ctx->m_class) << "::"
<< m_ctx->m_name << m_ctx->m_descriptor << endl);
VF_DEBUG("-- start --");
ResetNodeIterator();
while (HasMoreElements()) {
DumpNode(GetNextNode());
}
#endif // _VF_DEBUG
} // vf_Graph::DumpGraph
bool nsFind::SkipNode(nsIContent* aContent)
{
nsIAtom *atom;
#ifdef HAVE_BIDI_ITERATOR
atom = aContent->Tag();
// We may not need to skip comment nodes,
// now that IsTextNode distinguishes them from real text nodes.
return (aContent->IsNodeOfType(nsINode::eCOMMENT) ||
(aContent->IsHTML() &&
(atom == sScriptAtom ||
atom == sNoframesAtom ||
atom == sSelectAtom)));
#else /* HAVE_BIDI_ITERATOR */
// Temporary: eventually we will have an iterator to do this,
// but for now, we have to climb up the tree for each node
// and see whether any parent is a skipped node,
// and take the performance hit.
nsIContent *content = aContent;
while (content)
{
atom = content->Tag();
if (aContent->IsNodeOfType(nsINode::eCOMMENT) ||
(content->IsHTML() &&
(atom == nsGkAtoms::script ||
atom == nsGkAtoms::noframes ||
atom == nsGkAtoms::select)))
{
#ifdef DEBUG_FIND
printf("Skipping node: ");
nsCOMPtr<nsIDOMNode> node (do_QueryInterface(content));
DumpNode(node);
#endif
return true;
}
// Only climb to the nearest block node
if (IsBlockNode(content))
return false;
content = content->GetParent();
}
return false;
#endif /* HAVE_BIDI_ITERATOR */
}
static void DumpNodes(P_WBXML_INFO buffer)
{
P_WBXML_NODE curnode = buffer->m_tree;
BOOL bAttrsFollow = FALSE;
char* value = NULL;
if (curnode)
{
while (curnode->m_next) curnode = curnode->m_next;
while (curnode)
{
DumpNode(curnode, 0, &bAttrsFollow, FALSE, &value);
curnode = curnode->m_prev;
}
}
}
void ParseXml(const std::string& strXml)
{
TiXmlDocument cDoc;
// 解析
cDoc.Parse(strXml.c_str());
// 格式化打印
{
TiXmlPrinter cPrinter;
cDoc.Accept(&cPrinter);
// 多行的打印方式：在前面先打印一个回车
FN_LOG_INFO("\nstrXml = \n?") << cPrinter.CStr();
}
// 遍历
DumpNode(&cDoc);
}
void
nsFrameUtil::DumpTree(Node* aNode, FILE* aOutputFile, PRInt32 aIndent)
{
while (nsnull != aNode) {
DumpNode(aNode, aOutputFile, aIndent);
nsFrameUtil::NodeList* lists = aNode->lists;
if (nsnull != lists) {
while (nsnull != lists) {
nsFrame::IndentBy(aOutputFile, aIndent);
fprintf(aOutputFile, " list: %s\n",
lists->name ? lists->name : "primary");
DumpTree(lists->node, aOutputFile, aIndent + 1);
lists = lists->next;
}
}
aNode = aNode->next;
}
}
void
GiST::DumpNode (ostream& os, GiSTpath path) const
{
GiSTnode *node = ReadNode(path);
node->Print(os);
if (!node->IsLeaf()) {
TruePredicate truePredicate;
GiSTlist<GiSTentry*> list = node->Search(truePredicate);
while (!list.IsEmpty()) {
GiSTentry *e = list.RemoveFront();
path.MakeChild(e->Ptr());
DumpNode (os, path);
path.MakeParent();
delete e;
}
}
delete node;
}
//
// a helper method to dump a node list to the console
//
HRESULT DumpNodeList(IXMLDOMNodeList *domNodeList)
{
CComPtr<IXMLDOMNode> nodeCur;
LONG listLength;
HRESULT hr;
if (domNodeList == NULL)
{
return E_INVALIDARG;
}
if (FAILED(hr = domNodeList->get_length( &listLength )))
{
wprintf(L"Failed to get length from node list, error is %08.8lx", hr);
return hr;
}
if (FAILED(hr = domNodeList->reset()))
{
wprintf(L"Failed to reset node list, error is %08.8lx", hr);
return hr;
}
for (int i = 0; i < listLength; i++)
{
if (FAILED(hr = domNodeList->nextNode(&nodeCur)))
{
wprintf (L"Failed to get next node in list, error is %08.8lx", hr);
return hr;
}
if (FAILED(hr = DumpNode(nodeCur)))
{
wprintf (L"Failed to dump node, error is %08.8lx", hr);
return hr;
}
wprintf (L"\n");
nodeCur.Release();
}
return S_OK;
}
/** Dump the first 19 lines of the current page
*/
void dumpPage(void)
{
DISPLAYNODE n;
NODEPTR np;
FRESULT res;
uint16_t idx;
uint16_t charcount;
PAGEINDEXRECORD ixRec;
char data[80];
//int i;
FIL Page; // hope we have enough memory for this!
xprintf(PSTR("[dumpPage]\n\r"));
idx=pageFilterToArray(0);
np=GetNodePtr(&idx); // np points to the displaynode
xprintf(PSTR("index=%u node number=%u\n\r"),idx,np);
GetNode(&n,np);
DumpNode(np);
// At this point we need to get the pageindex out of pages.idx
// NB. Shared file access won't be a problem, I hope.
// xprintf(PSTR("Now we need to look up pages.idx[%d]\n\r"),n.pageindex);
f_lseek(&listFIL,(n.pageindex)*sizeof(PAGEINDEXRECORD)); // Seek the page index
f_read(&listFIL,&ixRec,sizeof(PAGEINDEXRECORD),&charcount); // and read it
res=f_open(&Page,"pages.all",FA_READ); // Now look for the relevant page
f_lseek(&Page,ixRec.seekptr); // Seek the actual page
// Now we need to parse the page.
while (Page.fptr<(ixRec.seekptr+ixRec.pagesize)) // Need to actually parse the data? Don't think so
{
if (!f_gets(data,sizeof(data),&Page)) break;
xprintf(PSTR("%s"),data);
}
f_close(&Page);
// and finally parse the page and dump 19 lines of text
} // dumpPage
VOID
FsRtlAddToTunnelCache (
IN PTUNNEL Cache,
IN ULONGLONG DirKey,
IN PUNICODE_STRING ShortName,
IN PUNICODE_STRING LongName,
IN BOOLEAN KeyByShortName,
IN ULONG DataLength,
IN PVOID Data
)
/*++
Routine Description:
Adds an entry to the tunnel cache keyed by
DirectoryKey ## (KeyByShortName ? ShortName : LongName)
ShortName, LongName, and Data are copied and stored in the tunnel. As a side
effect, if there are too many entries in the tunnel cache, this routine will
initiate expiration in the tunnel cache.
Arguments:
Cache - a tunnel cache initialized by FsRtlInitializeTunnelCache()
DirKey - the key value of the directory the name appeared in
ShortName - (optional if !KeyByShortName) the 8.3 name of the file
LongName - (optional if KeyByShortName) the long name of the file
KeyByShortName - specifies which name is keyed in the tunnel cache
DataLength - specifies the length of the opaque data segment (file
system specific) which contains the tunnelling information for this
file
Data - pointer to the opaque tunneling data segment
Return Value:
None
--*/
{
LONG Compare;
ULONG NodeSize;
PUNICODE_STRING NameKey;
PRTL_SPLAY_LINKS *Links;
LIST_ENTRY FreePoolList;
PTUNNEL_NODE Node = NULL;
PTUNNEL_NODE NewNode = NULL;
BOOLEAN FreeOldNode = FALSE;
BOOLEAN AllocatedFromPool = FALSE;
PAGED_CODE();
//
// If MaxEntries is 0 then tunneling is disabled.
//
if (TunnelMaxEntries == 0) return;
InitializeListHead(&FreePoolList);
//
// Grab a new node for this data
//
NodeSize = sizeof(TUNNEL_NODE) + ShortName->Length + LongName->Length + DataLength;
if (LOOKASIDE_NODE_SIZE >= NodeSize) {
NewNode = ExAllocateFromPagedLookasideList(&TunnelLookasideList);
}
if (NewNode == NULL) {
//
// Data doesn't fit in lookaside nodes
//
NewNode = ExAllocatePoolWithTag(PagedPool, NodeSize, 'PnuT');
if (NewNode == NULL) {
//
// Give up tunneling this entry
//
return;
}
AllocatedFromPool = TRUE;
}
//
// Traverse the cache to find our insertion point
//
NameKey = (KeyByShortName ? ShortName : LongName);
ExAcquireFastMutex(&Cache->Mutex);
Links = &Cache->Cache;
while (*Links) {
Node = CONTAINING_RECORD(*Links, TUNNEL_NODE, CacheLinks);
Compare = FsRtlCompareNodeAndKey(Node, DirKey, NameKey);
if (Compare > 0) {
Links = &RtlLeftChild(&Node->CacheLinks);
} else {
if (Compare < 0) {
Links = &RtlRightChild(&Node->CacheLinks);
} else {
break;
}
}
}
//
// Thread new data into the splay tree
//
RtlInitializeSplayLinks(&NewNode->CacheLinks);
if (Node) {
//
// Not inserting first node in tree
//
if (*Links) {
//
// Entry exists in the cache, so replace by swapping all splay links
//
RtlRightChild(&NewNode->CacheLinks) = RtlRightChild(*Links);
RtlLeftChild(&NewNode->CacheLinks) = RtlLeftChild(*Links);
if (RtlRightChild(*Links)) RtlParent(RtlRightChild(*Links)) = &NewNode->CacheLinks;
if (RtlLeftChild(*Links)) RtlParent(RtlLeftChild(*Links)) = &NewNode->CacheLinks;
if (!RtlIsRoot(*Links)) {
//
// Change over the parent links. Note that we've messed with *Links now
// since it is pointing at the parent member.
//
RtlParent(&NewNode->CacheLinks) = RtlParent(*Links);
if (RtlIsLeftChild(*Links)) {
RtlLeftChild(RtlParent(*Links)) = &NewNode->CacheLinks;
} else {
RtlRightChild(RtlParent(*Links)) = &NewNode->CacheLinks;
}
} else {
//
// Set root of the cache
//
Cache->Cache = &NewNode->CacheLinks;
}
//
// Free old node
//
RemoveEntryList(&Node->ListLinks);
FsRtlFreeTunnelNode(Node, &FreePoolList);
Cache->NumEntries--;
} else {
//
// Simple insertion as a leaf
//
NewNode->CacheLinks.Parent = &Node->CacheLinks;
*Links = &NewNode->CacheLinks;
}
} else {
Cache->Cache = &NewNode->CacheLinks;
}
//
// Thread onto the timer list
//
FsRtlQueryNormalizedSystemTime(&NewNode->CreateTime);
InsertTailList(&Cache->TimerQueue, &NewNode->ListLinks);
Cache->NumEntries++;
//
// Stash tunneling information
//
NewNode->DirKey = DirKey;
if (KeyByShortName) {
NewNode->Flags = TUNNEL_FLAG_KEY_SHORT;
} else {
NewNode->Flags = 0;
}
//
// Initialize the internal UNICODE_STRINGS to point at the buffer segments. For various
// reasons (UNICODE APIs are incomplete, we're avoiding calling any allocate routine more
// than once, UNICODE strings are not guaranteed to be null terminated) we have to do a lot
// of this by hand.
//
// The data is layed out like this in the allocated block:
//
// -----------------------------------------------------------------------------------
// | TUNNEL_NODE | Node->ShortName.Buffer | Node->LongName.Buffer | Node->TunnelData |
// -----------------------------------------------------------------------------------
//
NewNode->ShortName.Buffer = (PWCHAR)((PCHAR)NewNode + sizeof(TUNNEL_NODE));
NewNode->LongName.Buffer = (PWCHAR)((PCHAR)NewNode + sizeof(TUNNEL_NODE) + ShortName->Length);
NewNode->ShortName.Length = NewNode->ShortName.MaximumLength = ShortName->Length;
NewNode->LongName.Length = NewNode->LongName.MaximumLength = LongName->Length;
if (ShortName->Length) {
RtlCopyMemory(NewNode->ShortName.Buffer, ShortName->Buffer, ShortName->Length);
}
if (LongName->Length) {
RtlCopyMemory(NewNode->LongName.Buffer, LongName->Buffer, LongName->Length);
}
NewNode->TunnelData = (PVOID)((PCHAR)NewNode + sizeof(TUNNEL_NODE) + ShortName->Length + LongName->Length);
NewNode->TunnelDataLength = DataLength;
RtlCopyMemory(NewNode->TunnelData, Data, DataLength);
if (AllocatedFromPool) {
SetFlag(NewNode->Flags, TUNNEL_FLAG_NON_LOOKASIDE);
}
#if defined(TUNNELTEST) || defined (KEYVIEW)
DbgPrint("FsRtlAddToTunnelCache:\n");
DumpNode(NewNode, 1);
#ifndef KEYVIEW
DumpTunnel(Cache);
#endif
#endif // TUNNELTEST
//
// Clean out the cache, release, and then drop any pool memory we need to
//
FsRtlPruneTunnelCache(Cache, &FreePoolList);
ExReleaseFastMutex(&Cache->Mutex);
FsRtlEmptyFreePoolList(&FreePoolList);
return;
}
static void DumpNode(P_WBXML_NODE node, int indent, BOOL *inattrs, BOOL hascontent, char** value)
{
P_WBXML_NODE curnode = node->m_child;
WBXML_TAG nodetype = 0;
long dtdnum = 0;
BOOL bAttributesFollow = FALSE;
BOOL bHasContent = FALSE;
int i;
if (!(*inattrs))
{
for (i=0; i<indent; i++)
{
printf(" ");
}
}
else
{
if ((node->m_type != NODE_ATTRVALUE) && (*value))
{
printf("=\"");
OutputEncodedString((unsigned char*) *value);
printf("\"");
free(*value);
*value = NULL;
}
}
switch (node->m_type)
{
case NODE_DTD_TYPE:
printf("<?xml version=\"1.0\"?>\n<!DOCTYPE wml PUBLIC ");
dtdnum = mb_u_int32_to_long( &((DTD_NODE_DATA*)node->m_data)->m_dtdnum );
if ( dtdnum == 0)
{
printf("\"%s\">\n\n", GetStringTableString(node, mb_u_int32_to_long(&((DTD_NODE_DATA*)node->m_data)->m_index)) );
}
else
{
printf("\"%s\">\n\n", DTDTypeName(dtdnum) );
}
break;
case NODE_CODEPAGE_TAG:
nodetype = *((P_WBXML_TAG)node->m_data);
if ((nodetype & CODEPAGE_TAG_MASK) == nodetype)
{
printf("<%s/>\n", CodepageTagName(node->m_page, nodetype));
}
else
{
if ((nodetype & CODEPAGE_TAG_HAS_CONTENT) == CODEPAGE_TAG_HAS_CONTENT)
{
bHasContent = TRUE;
}
if ((nodetype & CODEPAGE_TAG_HAS_ATTRS) == CODEPAGE_TAG_HAS_ATTRS)
{
printf("<%s", CodepageTagName(node->m_page, nodetype));
bAttributesFollow = TRUE;
}
else
{
printf("<%s>\n", CodepageTagName(node->m_page, nodetype));
}
}
break;
case NODE_CODEPAGE_LITERAL_TAG:
printf("<%s>\n", GetStringTableString(node, mb_u_int32_to_long(((P_WBXML_MB_U_INT32)node->m_data))) );
break;
case NODE_ATTRSTART:
printf(" %s", CodepageAttrstartName(node->m_page, *((P_WBXML_TAG)node->m_data), value) );
break;
case NODE_ATTRSTART_LITERAL:
printf(" %s", GetStringTableString(node, mb_u_int32_to_long(((P_WBXML_MB_U_INT32)node->m_data))) );
break;
case NODE_ATTRVALUE:
CodepageAttrvalueName(node->m_page, *((P_WBXML_TAG)node->m_data), value);
break;
case NODE_ATTREND:
if (!hascontent)
{
printf("/");
}
printf(">\n");
*inattrs = FALSE;
break;
case NODE_STRING:
if (*inattrs)
{
/* concatenate the value */
if (*value)
{
if (node->m_data)
{
*value = realloc(*value, strlen(*value) + strlen((char*) node->m_data) + 1);
strcat(*value, (char*) node->m_data);
}
}
else
{
if (node->m_data)
{
*value = strdup((char*) node->m_data);
}
}
}
else
{
OutputEncodedString((unsigned char*) node->m_data);
printf("\n");
}
break;
case NODE_VARIABLE_STRING:
/* TODO: output variable string */
break;
case NODE_VARIABLE_INDEX:
/* TODO: output variable string */
break;
default:
break;
}
indent += INDENT_SIZE;
if (curnode)
{
while (curnode->m_next) curnode = curnode->m_next;
while (curnode)
{
DumpNode(curnode, indent, &bAttributesFollow, bHasContent, value);
curnode = curnode->m_prev;
}
}
indent -= INDENT_SIZE;
/* Output the element end if we have one */
if ((nodetype & CODEPAGE_TAG_HAS_CONTENT) == CODEPAGE_TAG_HAS_CONTENT)
{
for (i=0; i<indent; i++)
{
printf(" ");
}
switch (node->m_type)
{
case NODE_CODEPAGE_TAG:
printf("</%s>\n", CodepageTagName(node->m_page, *((P_WBXML_TAG)node->m_data)) );
break;
case NODE_CODEPAGE_LITERAL_TAG:
printf("</%s>\n", GetStringTableString(node, mb_u_int32_to_long(((P_WBXML_MB_U_INT32)node->m_data))) );
break;
default:
break;
}
}
}
int main(int argc, char* argv[])
{
std::string map;
std::list<Job> jobs;
std::set<osmscout::OSMId> coordIds;
if (!ParseArguments(argc,
argv,
map,
coordIds,
jobs)) {
return 1;
}
osmscout::DatabaseParameter databaseParameter;
osmscout::Database database(databaseParameter);
osmscout::DebugDatabaseParameter debugDatabaseParameter;
osmscout::DebugDatabase debugDatabase(debugDatabaseParameter);
if (!database.Open(map.c_str())) {
std::cerr << "Cannot open database" << std::endl;
}
if (!debugDatabase.Open(map.c_str())) {
std::cerr << "Cannot open debug database" << std::endl;
}
// OSM ids
std::set<osmscout::ObjectOSMRef> osmRefs;
std::set<osmscout::ObjectFileRef> fileRefs;
for (std::list<Job>::const_iterator job=jobs.begin();
job!=jobs.end();
++job) {
switch (job->osmRef.GetType()) {
case osmscout::osmRefNone:
break;
case osmscout::osmRefNode:
case osmscout::osmRefWay:
case osmscout::osmRefRelation:
osmRefs.insert(job->osmRef);
break;
}
switch (job->fileRef.GetType()) {
case osmscout::refNone:
break;
case osmscout::refNode:
case osmscout::refArea:
case osmscout::refWay:
fileRefs.insert(job->fileRef);
break;
}
}
std::map<osmscout::ObjectOSMRef,osmscout::ObjectFileRef> idFileOffsetMap;
std::map<osmscout::ObjectFileRef,osmscout::ObjectOSMRef> fileOffsetIdMap;
if (!osmRefs.empty() ||
!fileRefs.empty()) {
if (!debugDatabase.ResolveReferences(osmRefs,
fileRefs,
idFileOffsetMap,
fileOffsetIdMap)) {
std::cerr << "Error while resolving node ids and file offsets" << std::endl;
}
}
osmscout::CoordDataFile::CoordResultMap coordsMap;
std::vector<osmscout::NodeRef> nodes;
std::vector<osmscout::AreaRef> areas;
std::vector<osmscout::WayRef> ways;
if (!coordIds.empty()) {
if (!debugDatabase.GetCoords(coordIds,
coordsMap)) {
std::cerr << "Error whole loading coords by id" << std::endl;
}
}
if (!fileOffsetIdMap.empty()) {
std::list<osmscout::FileOffset> offsets;
for (std::map<osmscout::ObjectFileRef,osmscout::ObjectOSMRef>::const_iterator entry=fileOffsetIdMap.begin();
entry!=fileOffsetIdMap.end();
++entry) {
if (entry->first.GetType()==osmscout::refNode) {
offsets.push_back(entry->first.GetFileOffset());
}
}
if (!database.GetNodesByOffset(offsets,
nodes)) {
std::cerr << "Error whole loading nodes by offset" << std::endl;
}
}
if (!fileOffsetIdMap.empty()) {
std::list<osmscout::FileOffset> offsets;
for (std::map<osmscout::ObjectFileRef,osmscout::ObjectOSMRef>::const_iterator entry=fileOffsetIdMap.begin();
entry!=fileOffsetIdMap.end();
++entry) {
if (entry->first.GetType()==osmscout::refArea) {
offsets.push_back(entry->first.GetFileOffset());
}
}
if (!database.GetAreasByOffset(offsets,
areas)) {
std::cerr << "Error whole loading areas by offset" << std::endl;
}
}
if (!fileOffsetIdMap.empty()) {
std::list<osmscout::FileOffset> offsets;
for (std::map<osmscout::ObjectFileRef,osmscout::ObjectOSMRef>::const_iterator entry=fileOffsetIdMap.begin();
entry!=fileOffsetIdMap.end();
++entry) {
if (entry->first.GetType()==osmscout::refWay) {
offsets.push_back(entry->first.GetFileOffset());
}
}
if (!database.GetWaysByOffset(offsets,
ways)) {
std::cerr << "Error whole loading ways by offset" << std::endl;
}
}
for (std::set<osmscout::OSMId>::const_iterator id=coordIds.begin();
id!=coordIds.end();
++id) {
osmscout::CoordDataFile::CoordResultMap::const_iterator coordsEntry;
coordsEntry=coordsMap.find(*id);
if (coordsEntry!=coordsMap.end()) {
if (id!=coordIds.begin()) {
std::cout << std::endl;
}
DumpCoord(coordsEntry->second.point);
}
else {
std::cerr << "Cannot find coord with id " << *id << std::endl;
}
}
for (std::list<Job>::const_iterator job=jobs.begin();
job!=jobs.end();
++job) {
if (job!=jobs.begin() ||
!coordIds.empty()) {
std::cout << std::endl;
}
if (job->osmRef.GetType()!=osmscout::osmRefNone) {
std::map<osmscout::ObjectOSMRef,osmscout::ObjectFileRef>::const_iterator reference=idFileOffsetMap.find(job->osmRef);
if (reference==idFileOffsetMap.end()) {
std::cerr << "Cannot find '" << job->osmRef.GetTypeName() << "' with id " << job->osmRef.GetId() << std::endl;
continue;
}
switch (reference->second.GetType()) {
case osmscout::refNone:
break;
case osmscout::refNode:
for (size_t i=0; i<nodes.size(); i++) {
if (reference->second.GetFileOffset()==nodes[i]->GetFileOffset()) {
DumpNode(debugDatabase.GetTypeConfig(),nodes[i],reference->first.GetId());
break;
}
}
break;
case osmscout::refArea:
for (size_t i=0; i<areas.size(); i++) {
if (reference->second.GetFileOffset()==areas[i]->GetFileOffset()) {
DumpArea(debugDatabase.GetTypeConfig(),areas[i],reference->first.GetId());
break;
}
}
break;
case osmscout::refWay:
for (size_t i=0; i<ways.size(); i++) {
if (reference->second.GetFileOffset()==ways[i]->GetFileOffset()) {
DumpWay(debugDatabase.GetTypeConfig(),ways[i],reference->first.GetId());
break;
}
}
break;
}
}
else if (job->fileRef.GetType()!=osmscout::refNone) {
std::map<osmscout::ObjectFileRef,osmscout::ObjectOSMRef>::const_iterator reference=fileOffsetIdMap.find(job->fileRef);
if (reference==fileOffsetIdMap.end()) {
std::cerr << "Cannot find '" << job->fileRef.GetTypeName() << "' with offset " << job->fileRef.GetFileOffset() << std::endl;
continue;
}
switch (reference->first.GetType()) {
case osmscout::refNone:
break;
case osmscout::refNode:
for (size_t i=0; i<nodes.size(); i++) {
if (reference->first.GetFileOffset()==nodes[i]->GetFileOffset()) {
DumpNode(debugDatabase.GetTypeConfig(),nodes[i],reference->second.GetId());
break;
}
}
break;
case osmscout::refArea:
for (size_t i=0; i<areas.size(); i++) {
if (reference->first.GetFileOffset()==areas[i]->GetFileOffset()) {
DumpArea(debugDatabase.GetTypeConfig(),areas[i],reference->second.GetId());
break;
}
}
break;
case osmscout::refWay:
for (size_t i=0; i<ways.size(); i++) {
if (reference->first.GetFileOffset()==ways[i]->GetFileOffset()) {
DumpWay(debugDatabase.GetTypeConfig(),ways[i],reference->second.GetId());
break;
}
}
break;
}
}
}
database.Close();
debugDatabase.Close();
return 0;
}
static void PutApplication(MessageHandler *handler, NETFILE *fp,
ProcessNode *node) {
int i;
size_t size;
ConvFuncs *conv;
DumpNode(node);
conv = handler->serialize;
ConvSetRecName(handler->conv, node->mcprec->name);
size = conv->SizeValue(handler->conv, node->mcprec->value);
LBS_EmitStart(iobuff);
LBS_ReserveSize(iobuff, size, FALSE);
conv->PackValue(handler->conv, LBS_Body(iobuff), node->mcprec->value);
LBS_EmitEnd(iobuff);
SendLargeString(fp, iobuff);
ON_IO_ERROR(fp, badio);
Send(fp, conv->fsep, strlen(conv->fsep));
ON_IO_ERROR(fp, badio);
if (node->linkrec != NULL) {
ConvSetRecName(handler->conv, node->linkrec->name);
size = conv->SizeValue(handler->conv, node->linkrec->value);
LBS_EmitStart(iobuff);
LBS_ReserveSize(iobuff, size, FALSE);
conv->PackValue(handler->conv, LBS_Body(iobuff), node->linkrec->value);
LBS_EmitEnd(iobuff);
SendLargeString(fp, iobuff);
ON_IO_ERROR(fp, badio);
Send(fp, conv->fsep, strlen(conv->fsep));
ON_IO_ERROR(fp, badio);
}
if (node->sparec != NULL) {
ConvSetRecName(handler->conv, node->sparec->name);
size = conv->SizeValue(handler->conv, node->sparec->value);
LBS_EmitStart(iobuff);
LBS_ReserveSize(iobuff, size, FALSE);
conv->PackValue(handler->conv, LBS_Body(iobuff), node->sparec->value);
LBS_EmitEnd(iobuff);
SendLargeString(fp, iobuff);
ON_IO_ERROR(fp, badio);
}
for (i = 0; i < node->cWindow; i++) {
LBS_EmitStart(iobuff);
if (node->scrrec[i] != NULL) {
ConvSetRecName(handler->conv, node->scrrec[i]->name);
size = conv->SizeValue(handler->conv, node->scrrec[i]->value);
if (size > 0) {
Send(fp, conv->fsep, strlen(conv->fsep));
ON_IO_ERROR(fp, badio);
}
LBS_ReserveSize(iobuff, size, FALSE);
conv->PackValue(handler->conv, LBS_Body(iobuff), node->scrrec[i]->value);
}
LBS_EmitEnd(iobuff);
SendLargeString(fp, iobuff);
ON_IO_ERROR(fp, badio);
}
Send(fp, conv->bsep, strlen(conv->bsep));
ON_IO_ERROR(fp, badio);
badio:
return;
}
VOID
DumpTunnel (
PTUNNEL Tunnel
)
{
PRTL_SPLAY_LINKS SplayLinks, Ptr;
PTUNNEL_NODE Node;
PLIST_ENTRY Link;
ULONG Indent = 1, i;
ULONG EntryCount = 0;
BOOLEAN CountOff = FALSE;
DbgPrint("++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n");
DbgPrint("NumEntries = %d\n", Tunnel->NumEntries);
DbgPrint("****** Cache Tree\n");
SplayLinks = Tunnel->Cache;
if (SplayLinks == NULL) {
goto end;
}
while (RtlLeftChild(SplayLinks) != NULL) {
SplayLinks = RtlLeftChild(SplayLinks);
Indent++;
}
while (SplayLinks) {
Node = CONTAINING_RECORD( SplayLinks, TUNNEL_NODE, CacheLinks );
EntryCount++;
DumpNode(Node, Indent);
Ptr = SplayLinks;
/*
first check to see if there is a right subtree to the input link
if there is then the real successor is the left most node in
the right subtree. That is find and return P in the following diagram
Links
\
.
.
.
/
P
\
*/
if ((Ptr = RtlRightChild(SplayLinks)) != NULL) {
Indent++;
while (RtlLeftChild(Ptr) != NULL) {
Indent++;
Ptr = RtlLeftChild(Ptr);
}
SplayLinks = Ptr;
} else {
/*
we do not have a right child so check to see if have a parent and if
so find the first ancestor that we are a left decendent of. That
is find and return P in the following diagram
P
/
.
.
.
Links
*/
Ptr = SplayLinks;
while (RtlIsRightChild(Ptr)) {
Indent--;
Ptr = RtlParent(Ptr);
}
if (!RtlIsLeftChild(Ptr)) {
//
// we do not have a real successor so we simply return
// NULL
//
SplayLinks = NULL;
} else {
Indent--;
SplayLinks = RtlParent(Ptr);
}
}
}
end:
if (CountOff = (EntryCount != Tunnel->NumEntries)) {
DbgPrint("!!!!!!!!!! Splay Tree Count Mismatch (%d != %d)\n", EntryCount, Tunnel->NumEntries);
}
EntryCount = 0;
DbgPrint("****** Timer Queue\n");
for (Link = Tunnel->TimerQueue.Flink;
Link != &Tunnel->TimerQueue;
Link = Link->Flink) {
Node = CONTAINING_RECORD( Link, TUNNEL_NODE, ListLinks );
EntryCount++;
DumpNode(Node, 1);
}
if (CountOff |= (EntryCount != Tunnel->NumEntries)) {
DbgPrint("!!!!!!!!!! Timer Queue Count Mismatch (%d != %d)\n", EntryCount, Tunnel->NumEntries);
}
ASSERT(!CountOff);
DbgPrint("------------------------------------------------------------------\n");
}
CHAR16 *
DevicePathToStr (
EFI_DEVICE_PATH *DevPath
)
/*++
Turns the Device Path into a printable string. Allcoates
the string from pool. The caller must FreePool the returned
string.
--*/
{
POOL_PRINT Str;
EFI_DEVICE_PATH *DevPathNode;
VOID (*DumpNode)(POOL_PRINT *, VOID *);
UINTN Index, NewSize;
ZeroMem(&Str, sizeof(Str));
//
// Unpacked the device path
//
DevPath = UnpackDevicePath(DevPath);
ASSERT (DevPath);
//
// Process each device path node
//
DevPathNode = DevPath;
while (!IsDevicePathEnd(DevPathNode)) {
//
// Find the handler to dump this device path node
//
DumpNode = NULL;
for (Index = 0; DevPathTable[Index].Function; Index += 1) {
if (DevicePathType(DevPathNode) == DevPathTable[Index].Type &&
DevicePathSubType(DevPathNode) == DevPathTable[Index].SubType) {
DumpNode = DevPathTable[Index].Function;
break;
}
}
//
// If not found, use a generic function
//
if (!DumpNode) {
DumpNode = _DevPathNodeUnknown;
}
//
// Put a path seperator in if needed
//
if (Str.len && DumpNode != _DevPathEndInstance) {
CatPrint (&Str, L"/");
}
//
// Print this node of the device path
//
DumpNode (&Str, DevPathNode);
//
// Next device path node
//
DevPathNode = NextDevicePathNode(DevPathNode);
}
//
// Shrink pool used for string allocation
//
FreePool (DevPath);
NewSize = (Str.len + 1) * sizeof(CHAR16);
Str.str = ReallocatePool (Str.str, NewSize, NewSize);
Str.str[Str.len] = 0;
return Str.str;
}
BOOLEAN
FsRtlFindInTunnelCache (
IN PTUNNEL Cache,
IN ULONGLONG DirKey,
IN PUNICODE_STRING Name,
OUT PUNICODE_STRING ShortName,
OUT PUNICODE_STRING LongName,
IN OUT PULONG DataLength,
OUT PVOID Data
)
/*++
Routine Description:
Looks up the key
DirKey ## Name
in the tunnel cache and removes it. As a side effect, this routine will initiate
expiration of the aged entries in the tunnel cache.
Arguments:
Cache - a tunnel cache initialized by FsRtlInitializeTunnelCache()
DirKey - the key value of the directory the name will appear in
Name - the name of the entry
ShortName - return string to hold the short name of the tunneled file. Must
already be allocated and large enough for max 8.3 name
LongName - return string to hold the long name of the tunneled file. If
already allocated, may be grown if not large enough. Caller is
responsible for noticing this and freeing data regardless of return value.
DataLength - provides the length of the buffer avaliable to hold the
tunneling information, returns the size of the tunneled information
read out
Return Value:
Boolean true if found, false otherwise
--*/
{
PRTL_SPLAY_LINKS Links;
PTUNNEL_NODE Node;
LONG Compare;
LIST_ENTRY FreePoolList;
BOOLEAN Status = FALSE;
PAGED_CODE();
//
// If MaxEntries is 0 then tunneling is disabled.
//
if (TunnelMaxEntries == 0) return FALSE;
InitializeListHead(&FreePoolList);
#ifdef KEYVIEW
DbgPrint("++\nSearching for %wZ , %08x%08x\n--\n", Name, DblHex64(DirKey));
#endif
ExAcquireFastMutex(&Cache->Mutex);
//
// Expire aged entries first so we don't grab old data
//
FsRtlPruneTunnelCache(Cache, &FreePoolList);
Links = Cache->Cache;
while (Links) {
Node = CONTAINING_RECORD(Links, TUNNEL_NODE, CacheLinks);
Compare = FsRtlCompareNodeAndKey(Node, DirKey, Name);
if (Compare > 0) {
Links = RtlLeftChild(&Node->CacheLinks);
} else {
if (Compare < 0) {
Links = RtlRightChild(&Node->CacheLinks);
} else {
//
// Found tunneling information
//
#if defined(TUNNELTEST) || defined(KEYVIEW)
DbgPrint("FsRtlFindInTunnelCache:\n");
DumpNode(Node, 1);
#ifndef KEYVIEW
DumpTunnel(Cache);
#endif
#endif // TUNNELTEST
break;
}
}
}
try {
if (Links) {
//
// Copy node data into caller's area
//
ASSERT(ShortName->MaximumLength >= (8+1+3)*sizeof(WCHAR));
RtlCopyUnicodeString(ShortName, &Node->ShortName);
if (LongName->MaximumLength >= Node->LongName.Length) {
RtlCopyUnicodeString(LongName, &Node->LongName);
} else {
//
// Need to allocate more memory for the long name
//
LongName->Buffer = FsRtlAllocatePoolWithTag(PagedPool, Node->LongName.Length, '4nuT');
LongName->Length = LongName->MaximumLength = Node->LongName.Length;
RtlCopyMemory(LongName->Buffer, Node->LongName.Buffer, Node->LongName.Length);
}
ASSERT(*DataLength >= Node->TunnelDataLength);
RtlCopyMemory(Data, Node->TunnelData, Node->TunnelDataLength);
*DataLength = Node->TunnelDataLength;
Status = TRUE;
}
} finally {
ExReleaseFastMutex(&Cache->Mutex);
FsRtlEmptyFreePoolList(&FreePoolList);
}
return Status;
}
nsresult
nsFind::NextNode(nsIDOMRange* aSearchRange,
nsIDOMRange* aStartPoint, nsIDOMRange* aEndPoint,
bool aContinueOk)
{
nsresult rv;
nsCOMPtr<nsIContent> content;
if (!mIterator || aContinueOk)
{
// If we are continuing, that means we have a match in progress.
// In that case, we want to continue from the end point
// (where we are now) to the beginning/end of the search range.
nsCOMPtr<nsIDOMNode> startNode;
nsCOMPtr<nsIDOMNode> endNode;
PRInt32 startOffset, endOffset;
if (aContinueOk)
{
#ifdef DEBUG_FIND
printf("Match in progress: continuing past endpoint\n");
#endif
if (mFindBackward) {
aSearchRange->GetStartContainer(getter_AddRefs(startNode));
aSearchRange->GetStartOffset(&startOffset);
aEndPoint->GetStartContainer(getter_AddRefs(endNode));
aEndPoint->GetStartOffset(&endOffset);
} else { // forward
aEndPoint->GetEndContainer(getter_AddRefs(startNode));
aEndPoint->GetEndOffset(&startOffset);
aSearchRange->GetEndContainer(getter_AddRefs(endNode));
aSearchRange->GetEndOffset(&endOffset);
}
}
else // Normal, not continuing
{
if (mFindBackward) {
aSearchRange->GetStartContainer(getter_AddRefs(startNode));
aSearchRange->GetStartOffset(&startOffset);
aStartPoint->GetEndContainer(getter_AddRefs(endNode));
aStartPoint->GetEndOffset(&endOffset);
// XXX Needs work:
// Problem with this approach: if there is a match which starts
// just before the current selection and continues into the selection,
// we will miss it, because our search algorithm only starts
// searching from the end of the word, so we would have to
// search the current selection but discount any matches
// that fall entirely inside it.
} else { // forward
aStartPoint->GetStartContainer(getter_AddRefs(startNode));
aStartPoint->GetStartOffset(&startOffset);
aEndPoint->GetEndContainer(getter_AddRefs(endNode));
aEndPoint->GetEndOffset(&endOffset);
}
}
rv = InitIterator(startNode, startOffset, endNode, endOffset);
NS_ENSURE_SUCCESS(rv, rv);
if (!aStartPoint)
aStartPoint = aSearchRange;
content = do_QueryInterface(mIterator->GetCurrentNode());
#ifdef DEBUG_FIND
nsCOMPtr<nsIDOMNode> dnode (do_QueryInterface(content));
printf(":::::: Got the first node "); DumpNode(dnode);
#endif
if (content && content->IsNodeOfType(nsINode::eTEXT) &&
!SkipNode(content))
{
mIterNode = do_QueryInterface(content);
// Also set mIterOffset if appropriate:
nsCOMPtr<nsIDOMNode> node;
if (mFindBackward) {
aStartPoint->GetEndContainer(getter_AddRefs(node));
if (mIterNode.get() == node.get())
aStartPoint->GetEndOffset(&mIterOffset);
else
mIterOffset = -1; // sign to start from end
}
else
{
aStartPoint->GetStartContainer(getter_AddRefs(node));
if (mIterNode.get() == node.get())
aStartPoint->GetStartOffset(&mIterOffset);
else
mIterOffset = 0;
}
#ifdef DEBUG_FIND
printf("Setting initial offset to %d\n", mIterOffset);
#endif
return NS_OK;
}
}
while (1)
{
if (mFindBackward)
mIterator->Prev();
else
mIterator->Next();
content = do_QueryInterface(mIterator->GetCurrentNode());
if (!content)
break;
#ifdef DEBUG_FIND
nsCOMPtr<nsIDOMNode> dnode (do_QueryInterface(content));
printf(":::::: Got another node "); DumpNode(dnode);
#endif
// If we ever cross a block node, we might want to reset
// the match anchor:
// we don't match patterns extending across block boundaries.
// But we can't depend on this test here now, because the iterator
// doesn't give us the parent going in and going out, and we
// need it both times to depend on this.
//if (IsBlockNode(content))
// Now see if we need to skip this node --
// e.g. is it part of a script or other invisible node?
// Note that we don't ask for CSS information;
// a node can be invisible due to CSS, and we'd still find it.
if (SkipNode(content))
continue;
if (content->IsNodeOfType(nsINode::eTEXT))
break;
#ifdef DEBUG_FIND
dnode = do_QueryInterface(content);
printf("Not a text node: "); DumpNode(dnode);
#endif
}
if (content)
mIterNode = do_QueryInterface(content);
else
mIterNode = nsnull;
mIterOffset = -1;
#ifdef DEBUG_FIND
printf("Iterator gave: "); DumpNode(mIterNode);
#endif
return NS_OK;
}
PRBool
nsFrameUtil::CompareTrees(Node* tree1, Node* tree2)
{
PRBool result = PR_TRUE;
for (;; tree1 = tree1->next, tree2 = tree2->next) {
// Make sure both nodes are non-null, or at least agree with each other
if (nsnull == tree1) {
if (nsnull == tree2) {
break;
}
printf("first tree prematurely ends\n");
return PR_FALSE;
}
else if (nsnull == tree2) {
printf("second tree prematurely ends\n");
return PR_FALSE;
}
// Check the attributes that we care about
if (0 != PL_strcmp(tree1->type, tree2->type)) {
printf("frame type mismatch: %s vs. %s\n", tree1->type, tree2->type);
printf("Node 1:\n");
DumpNode(tree1, stdout, 1);
printf("Node 2:\n");
DumpNode(tree2, stdout, 1);
return PR_FALSE;
}
// Ignore the XUL scrollbar frames
static const char kScrollbarFrame[] = "ScrollbarFrame";
if (0 == PL_strncmp(tree1->type, kScrollbarFrame, sizeof(kScrollbarFrame) - 1))
continue;
if (tree1->state != tree2->state) {
printf("frame state mismatch: 0x%x vs. 0x%x\n",
tree1->state, tree2->state);
printf("Node 1:\n");
DumpNode(tree1, stdout, 1);
printf("Node 2:\n");
DumpNode(tree2, stdout, 1);
result = PR_FALSE; // we have a non-critical failure, so remember that but continue
}
if (tree1->bbox != tree2->bbox) {
printf("frame bbox mismatch: %d,%d,%d,%d vs. %d,%d,%d,%d\n",
tree1->bbox.x, tree1->bbox.y,
tree1->bbox.width, tree1->bbox.height,
tree2->bbox.x, tree2->bbox.y,
tree2->bbox.width, tree2->bbox.height);
printf("Node 1:\n");
DumpNode(tree1, stdout, 1);
printf("Node 2:\n");
DumpNode(tree2, stdout, 1);
result = PR_FALSE; // we have a non-critical failure, so remember that but continue
}
if (tree1->styleData != tree2->styleData) {
printf("frame style data mismatch: %s vs. %s\n",
tree1->styleData.get(),
tree2->styleData.get());
}
// Check child lists too
NodeList* list1 = tree1->lists;
NodeList* list2 = tree2->lists;
for (;;) {
if (nsnull == list1) {
if (nsnull != list2) {
printf("first tree prematurely ends (no child lists)\n");
printf("Node 1:\n");
DumpNode(tree1, stdout, 1);
printf("Node 2:\n");
DumpNode(tree2, stdout, 1);
return PR_FALSE;
}
else {
break;
}
}
if (nsnull == list2) {
printf("second tree prematurely ends (no child lists)\n");
printf("Node 1:\n");
DumpNode(tree1, stdout, 1);
printf("Node 2:\n");
DumpNode(tree2, stdout, 1);
return PR_FALSE;
}
if (0 != PL_strcmp(list1->name, list2->name)) {
printf("child-list name mismatch: %s vs. %s\n",
list1->name ? list1->name : "(null)",
list2->name ? list2->name : "(null)");
result = PR_FALSE; // we have a non-critical failure, so remember that but continue
}
else {
PRBool equiv = CompareTrees(list1->node, list2->node);
if (!equiv) {
return equiv;
}
}
list1 = list1->next;
list2 = list2->next;
}
}
return result;
}
//
// Find:
// Take nodes out of the tree with NextNode,
// until null (NextNode will return 0 at the end of our range).
//
NS_IMETHODIMP
nsFind::Find(const PRUnichar *aPatText, nsIDOMRange* aSearchRange,
nsIDOMRange* aStartPoint, nsIDOMRange* aEndPoint,
nsIDOMRange** aRangeRet)
{
#ifdef DEBUG_FIND
printf("============== nsFind::Find('%s'%s, %p, %p, %p)\n",
NS_LossyConvertUTF16toASCII(aPatText).get(),
mFindBackward ? " (backward)" : " (forward)",
(void*)aSearchRange, (void*)aStartPoint, (void*)aEndPoint);
#endif
NS_ENSURE_ARG(aSearchRange);
NS_ENSURE_ARG(aStartPoint);
NS_ENSURE_ARG(aEndPoint);
NS_ENSURE_ARG_POINTER(aRangeRet);
*aRangeRet = 0;
if (!aPatText)
return NS_ERROR_NULL_POINTER;
ResetAll();
nsAutoString patAutoStr(aPatText);
if (!mCaseSensitive)
ToLowerCase(patAutoStr);
// Ignore soft hyphens in the pattern
static const char kShy[] = { char(CH_SHY), 0 };
patAutoStr.StripChars(kShy);
const PRUnichar* patStr = patAutoStr.get();
PRInt32 patLen = patAutoStr.Length() - 1;
// current offset into the pattern -- reset to beginning/end:
PRInt32 pindex = (mFindBackward ? patLen : 0);
// Current offset into the fragment
PRInt32 findex = 0;
// Direction to move pindex and ptr*
int incr = (mFindBackward ? -1 : 1);
nsCOMPtr<nsIContent> tc;
const nsTextFragment *frag = nsnull;
PRInt32 fragLen = 0;
// Pointers into the current fragment:
const PRUnichar *t2b = nsnull;
const char *t1b = nsnull;
// Keep track of when we're in whitespace:
// (only matters when we're matching)
bool inWhitespace = false;
// Place to save the range start point in case we find a match:
nsCOMPtr<nsIDOMNode> matchAnchorNode;
PRInt32 matchAnchorOffset = 0;
// Get the end point, so we know when to end searches:
nsCOMPtr<nsIDOMNode> endNode;
PRInt32 endOffset;
aEndPoint->GetEndContainer(getter_AddRefs(endNode));
aEndPoint->GetEndOffset(&endOffset);
PRUnichar prevChar = 0;
while (1)
{
#ifdef DEBUG_FIND
printf("Loop ...\n");
#endif
// If this is our first time on a new node, reset the pointers:
if (!frag)
{
tc = nsnull;
NextNode(aSearchRange, aStartPoint, aEndPoint, false);
if (!mIterNode) // Out of nodes
{
// Are we in the middle of a match?
// If so, try again with continuation.
if (matchAnchorNode)
NextNode(aSearchRange, aStartPoint, aEndPoint, true);
// Reset the iterator, so this nsFind will be usable if
// the user wants to search again (from beginning/end).
ResetAll();
return NS_OK;
}
// We have a new text content. If its block parent is different
// from the block parent of the last text content, then we
// need to clear the match since we don't want to find
// across block boundaries.
nsCOMPtr<nsIDOMNode> blockParent;
GetBlockParent(mIterNode, getter_AddRefs(blockParent));
#ifdef DEBUG_FIND
printf("New node: old blockparent = %p, new = %p\n",
(void*)mLastBlockParent.get(), (void*)blockParent.get());
#endif
if (blockParent != mLastBlockParent)
{
#ifdef DEBUG_FIND
printf("Different block parent!\n");
#endif
mLastBlockParent = blockParent;
// End any pending match:
matchAnchorNode = nsnull;
matchAnchorOffset = 0;
pindex = (mFindBackward ? patLen : 0);
inWhitespace = false;
}
// Get the text content:
tc = do_QueryInterface(mIterNode);
if (!tc || !(frag = tc->GetText())) // Out of nodes
{
mIterator = nsnull;
mLastBlockParent = 0;
ResetAll();
return NS_OK;
}
fragLen = frag->GetLength();
// Set our starting point in this node.
// If we're going back to the anchor node, which means that we
// just ended a partial match, use the saved offset:
if (mIterNode == matchAnchorNode)
findex = matchAnchorOffset + (mFindBackward ? 1 : 0);
// mIterOffset, if set, is the range's idea of an offset,
// and points between characters. But when translated
// to a string index, it points to a character. If we're
// going backward, this is one character too late and
// we'll match part of our previous pattern.
else if (mIterOffset >= 0)
findex = mIterOffset - (mFindBackward ? 1 : 0);
// Otherwise, just start at the appropriate end of the fragment:
else if (mFindBackward)
findex = fragLen - 1;
else
findex = 0;
// Offset can only apply to the first node:
mIterOffset = -1;
// If this is outside the bounds of the string, then skip this node:
if (findex < 0 || findex > fragLen-1)
{
#ifdef DEBUG_FIND
printf("At the end of a text node -- skipping to the next\n");
#endif
frag = 0;
continue;
}
#ifdef DEBUG_FIND
printf("Starting from offset %d\n", findex);
#endif
if (frag->Is2b())
{
t2b = frag->Get2b();
t1b = nsnull;
#ifdef DEBUG_FIND
nsAutoString str2(t2b, fragLen);
printf("2 byte, '%s'\n", NS_LossyConvertUTF16toASCII(str2).get());
#endif
}
else
{
t1b = frag->Get1b();
t2b = nsnull;
#ifdef DEBUG_FIND
nsCAutoString str1(t1b, fragLen);
printf("1 byte, '%s'\n", str1.get());
#endif
}
}
else // still on the old node
{
// Still on the old node. Advance the pointers,
// then see if we need to pull a new node.
findex += incr;
#ifdef DEBUG_FIND
printf("Same node -- (%d, %d)\n", pindex, findex);
#endif
if (mFindBackward ? (findex < 0) : (findex >= fragLen))
{
#ifdef DEBUG_FIND
printf("Will need to pull a new node: mAO = %d, frag len=%d\n",
matchAnchorOffset, fragLen);
#endif
// Done with this node. Pull a new one.
frag = nsnull;
continue;
}
}
// Have we gone past the endpoint yet?
// If we have, and we're not in the middle of a match, return.
if (mIterNode == endNode &&
((mFindBackward && (findex < endOffset)) ||
(!mFindBackward && (findex > endOffset))))
{
ResetAll();
return NS_OK;
}
// The two characters we'll be comparing:
PRUnichar c = (t2b ? t2b[findex] : CHAR_TO_UNICHAR(t1b[findex]));
PRUnichar patc = patStr[pindex];
#ifdef DEBUG_FIND
printf("Comparing '%c'=%x to '%c' (%d of %d), findex=%d%s\n",
(char)c, (int)c, patc, pindex, patLen, findex,
inWhitespace ? " (inWhitespace)" : "");
#endif
// Do we need to go back to non-whitespace mode?
// If inWhitespace, then this space in the pat str
// has already matched at least one space in the document.
if (inWhitespace && !IsSpace(c))
{
inWhitespace = false;
pindex += incr;
#ifdef DEBUG
// This shouldn't happen -- if we were still matching, and we
// were at the end of the pat string, then we should have
// caught it in the last iteration and returned success.
if (OVERFLOW_PINDEX)
NS_ASSERTION(false, "Missed a whitespace match\n");
#endif
patc = patStr[pindex];
}
if (!inWhitespace && IsSpace(patc))
inWhitespace = true;
// convert to lower case if necessary
else if (!inWhitespace && !mCaseSensitive && IsUpperCase(c))
c = ToLowerCase(c);
// ignore soft hyphens in the document
if (c == CH_SHY)
continue;
// a '\n' between CJ characters is ignored
if (pindex != (mFindBackward ? patLen : 0) && c != patc && !inWhitespace) {
if (c == '\n' && t2b && IS_CJ_CHAR(prevChar)) {
PRInt32 nindex = findex + incr;
if (mFindBackward ? (nindex >= 0) : (nindex < fragLen)) {
if (IS_CJ_CHAR(t2b[nindex]))
continue;
}
}
}
// Compare
if ((c == patc) || (inWhitespace && IsSpace(c)))
{
prevChar = c;
#ifdef DEBUG_FIND
if (inWhitespace)
printf("YES (whitespace)(%d of %d)\n", pindex, patLen);
else
printf("YES! '%c' == '%c' (%d of %d)\n", c, patc, pindex, patLen);
#endif
// Save the range anchors if we haven't already:
if (!matchAnchorNode) {
matchAnchorNode = mIterNode;
matchAnchorOffset = findex;
}
// Are we done?
if (DONE_WITH_PINDEX)
// Matched the whole string!
{
#ifdef DEBUG_FIND
printf("Found a match!\n");
#endif
// Make the range:
nsCOMPtr<nsIDOMNode> startParent;
nsCOMPtr<nsIDOMNode> endParent;
nsCOMPtr<nsIDOMRange> range = CreateRange();
if (range)
{
PRInt32 matchStartOffset, matchEndOffset;
// convert char index to range point:
PRInt32 mao = matchAnchorOffset + (mFindBackward ? 1 : 0);
if (mFindBackward)
{
startParent = do_QueryInterface(tc);
endParent = matchAnchorNode;
matchStartOffset = findex;
matchEndOffset = mao;
}
else
{
startParent = matchAnchorNode;
endParent = do_QueryInterface(tc);
matchStartOffset = mao;
matchEndOffset = findex+1;
}
if (startParent && endParent &&
IsVisibleNode(startParent) && IsVisibleNode(endParent))
{
range->SetStart(startParent, matchStartOffset);
range->SetEnd(endParent, matchEndOffset);
*aRangeRet = range.get();
NS_ADDREF(*aRangeRet);
}
else {
startParent = nsnull; // This match is no good -- invisible or bad range
}
}
if (startParent) {
// If startParent == nsnull, we didn't successfully make range
// or, we didn't make a range because the start or end node were invisible
// Reset the offset to the other end of the found string:
mIterOffset = findex + (mFindBackward ? 1 : 0);
#ifdef DEBUG_FIND
printf("mIterOffset = %d, mIterNode = ", mIterOffset);
DumpNode(mIterNode);
#endif
ResetAll();
return NS_OK;
}
matchAnchorNode = nsnull; // This match is no good, continue on in document
}
if (matchAnchorNode) {
// Not done, but still matching.
// Advance and loop around for the next characters.
// But don't advance from a space to a non-space:
if (!inWhitespace || DONE_WITH_PINDEX || IsSpace(patStr[pindex+incr]))
{
pindex += incr;
inWhitespace = false;
#ifdef DEBUG_FIND
printf("Advancing pindex to %d\n", pindex);
#endif
}
continue;
}
}
#ifdef DEBUG_FIND
printf("NOT: %c == %c\n", c, patc);
#endif
// If we didn't match, go back to the beginning of patStr,
// and set findex back to the next char after
// we started the current match.
if (matchAnchorNode) // we're ending a partial match
{
findex = matchAnchorOffset;
mIterOffset = matchAnchorOffset;
// +incr will be added to findex when we continue
// Are we going back to a previous node?
if (matchAnchorNode != mIterNode)
{
nsCOMPtr<nsIContent> content (do_QueryInterface(matchAnchorNode));
nsresult rv = NS_ERROR_UNEXPECTED;
if (content)
rv = mIterator->PositionAt(content);
frag = 0;
NS_ASSERTION(NS_SUCCEEDED(rv), "Text content wasn't nsIContent!");
#ifdef DEBUG_FIND
printf("Repositioned anchor node\n");
#endif
}
#ifdef DEBUG_FIND
printf("Ending a partial match; findex -> %d, mIterOffset -> %d\n",
findex, mIterOffset);
#endif
}
matchAnchorNode = nsnull;
matchAnchorOffset = 0;
inWhitespace = false;
pindex = (mFindBackward ? patLen : 0);
#ifdef DEBUG_FIND
printf("Setting findex back to %d, pindex to %d\n", findex, pindex);
#endif
} // end while loop
// Out of nodes, and didn't match.
ResetAll();
return NS_OK;
}
int main(int argc, char* argv[])
{
std::string map;
std::list<Job> jobs;
std::set<osmscout::OSMId> coordIds;
std::set<osmscout::OSMId> routeNodeCoordIds;
std::set<osmscout::Id> routeNodeIds;
try {
std::locale globalLocale("");
}
catch (std::runtime_error) {
std::cerr << "ERROR: Cannot set locale" << std::endl;
}
if (!ParseArguments(argc,
argv,
map,
coordIds,
routeNodeCoordIds,
jobs)) {
return 1;
}
osmscout::DatabaseParameter databaseParameter;
osmscout::Database database(databaseParameter);
osmscout::DebugDatabaseParameter debugDatabaseParameter;
osmscout::DebugDatabase debugDatabase(debugDatabaseParameter);
osmscout::IndexedDataFile<osmscout::Id,osmscout::RouteNode> routeNodeDataFile("router.dat",
"router.idx",
6000);
if (!database.Open(map.c_str())) {
std::cerr << "Cannot open database" << std::endl;
}
if (!debugDatabase.Open(map.c_str())) {
std::cerr << "Cannot open debug database" << std::endl;
}
if (!routeNodeDataFile.Open(database.GetTypeConfig(),
map,
true,
true)) {
std::cerr << "Cannot open routing database" << std::endl;
}
// OSM ids
std::set<osmscout::ObjectOSMRef> osmRefs;
std::set<osmscout::ObjectFileRef> fileRefs;
for (const auto& job : jobs) {
switch (job.osmRef.GetType()) {
case osmscout::osmRefNone:
break;
case osmscout::osmRefNode:
case osmscout::osmRefWay:
case osmscout::osmRefRelation:
osmRefs.insert(job.osmRef);
break;
}
switch (job.fileRef.GetType()) {
case osmscout::refNone:
break;
case osmscout::refNode:
case osmscout::refArea:
case osmscout::refWay:
fileRefs.insert(job.fileRef);
break;
}
}
std::map<osmscout::ObjectOSMRef,osmscout::ObjectFileRef> idFileOffsetMap;
std::map<osmscout::ObjectFileRef,osmscout::ObjectOSMRef> fileOffsetIdMap;
if (!osmRefs.empty() ||
!fileRefs.empty()) {
if (!debugDatabase.ResolveReferences(osmRefs,
fileRefs,
idFileOffsetMap,
fileOffsetIdMap)) {
std::cerr << "Error while resolving node ids and file offsets" << std::endl;
}
}
osmscout::CoordDataFile::ResultMap coordsMap;
std::vector<osmscout::NodeRef> nodes;
std::vector<osmscout::AreaRef> areas;
std::vector<osmscout::WayRef> ways;
osmscout::CoordDataFile::ResultMap routeCoordsMap;
std::unordered_map<osmscout::Id,osmscout::RouteNodeRef> routeNodeMap;
if (!coordIds.empty()) {
if (!debugDatabase.GetCoords(coordIds,
coordsMap)) {
std::cerr << "Error whole loading coords by id" << std::endl;
}
}
if (!routeNodeCoordIds.empty()) {
if (!debugDatabase.GetCoords(routeNodeCoordIds,
routeCoordsMap)) {
std::cerr << "Error whole loading route node coords by id" << std::endl;
}
}
if (!fileOffsetIdMap.empty()) {
std::list<osmscout::FileOffset> offsets;
for (std::map<osmscout::ObjectFileRef,osmscout::ObjectOSMRef>::const_iterator entry=fileOffsetIdMap.begin();
entry!=fileOffsetIdMap.end();
++entry) {
if (entry->first.GetType()==osmscout::refNode) {
offsets.push_back(entry->first.GetFileOffset());
}
}
if (!database.GetNodesByOffset(offsets,
nodes)) {
std::cerr << "Error whole loading nodes by offset" << std::endl;
}
}
if (!fileOffsetIdMap.empty()) {
std::list<osmscout::FileOffset> offsets;
for (std::map<osmscout::ObjectFileRef,osmscout::ObjectOSMRef>::const_iterator entry=fileOffsetIdMap.begin();
entry!=fileOffsetIdMap.end();
++entry) {
if (entry->first.GetType()==osmscout::refArea) {
offsets.push_back(entry->first.GetFileOffset());
}
}
if (!database.GetAreasByOffset(offsets,
areas)) {
std::cerr << "Error whole loading areas by offset" << std::endl;
}
}
if (!fileOffsetIdMap.empty()) {
std::list<osmscout::FileOffset> offsets;
for (auto entry=fileOffsetIdMap.begin();
entry!=fileOffsetIdMap.end();
++entry) {
if (entry->first.GetType()==osmscout::refWay) {
offsets.push_back(entry->first.GetFileOffset());
}
}
if (!database.GetWaysByOffset(offsets,
ways)) {
std::cerr << "Error whole loading ways by offset" << std::endl;
}
}
for (const auto id : routeNodeCoordIds) {
auto coordsEntry=routeCoordsMap.find(id);
if (coordsEntry!=routeCoordsMap.end()) {
routeNodeIds.insert(coordsEntry->second.GetOSMScoutId());
}
else {
std::cerr << "Cannot find route node coord with id " << id << std::endl;
}
}
if (!routeNodeIds.empty() &&
routeNodeDataFile.IsOpen()) {
if (!routeNodeDataFile.Get(routeNodeIds,
routeNodeMap)) {
std::cerr << "Error loading route nodes by id" << std::endl;
}
}
bool firstCoord=true;
for (const auto id : coordIds) {
auto coordsEntry=coordsMap.find(id);
if (coordsEntry!=coordsMap.end()) {
if (!firstCoord) {
std::cout << std::endl;
}
DumpCoord(coordsEntry->first,
coordsEntry->second);
}
else {
std::cerr << "Cannot find coord with id " << id << std::endl;
}
firstCoord=false;
}
bool firstRouteNode=true;
for (const auto id : routeNodeIds) {
auto routeNodeEntry=routeNodeMap.find(id);
if (routeNodeEntry!=routeNodeMap.end()) {
if (!firstRouteNode) {
std::cout << std::endl;
}
DumpRouteNode(*routeNodeEntry->second);
}
else {
std::cerr << "Cannot find route node with id " << id << std::endl;
}
firstRouteNode=false;
}
std::streamsize oldPrecision=std::cout.precision(5);
std::ios_base::fmtflags oldFlags=std::cout.setf(std::ios::fixed,std::ios::floatfield);
for (std::list<Job>::const_iterator job=jobs.begin();
job!=jobs.end();
++job) {
if (job!=jobs.begin() ||
!coordIds.empty()) {
std::cout << std::endl;
}
if (job->osmRef.GetType()!=osmscout::osmRefNone) {
std::map<osmscout::ObjectOSMRef,osmscout::ObjectFileRef>::const_iterator reference=idFileOffsetMap.find(job->osmRef);
if (reference==idFileOffsetMap.end()) {
std::cerr << "Cannot find '" << job->osmRef.GetTypeName() << "' with id " << job->osmRef.GetId() << std::endl;
continue;
}
switch (reference->second.GetType()) {
case osmscout::refNone:
break;
case osmscout::refNode:
for (size_t i=0; i<nodes.size(); i++) {
if (reference->second.GetFileOffset()==nodes[i]->GetFileOffset()) {
DumpNode(nodes[i],reference->first.GetId());
break;
}
}
break;
case osmscout::refArea:
for (size_t i=0; i<areas.size(); i++) {
if (reference->second.GetFileOffset()==areas[i]->GetFileOffset()) {
DumpArea(areas[i],reference->first.GetId());
break;
}
}
break;
case osmscout::refWay:
for (size_t i=0; i<ways.size(); i++) {
if (reference->second.GetFileOffset()==ways[i]->GetFileOffset()) {
DumpWay(ways[i],reference->first.GetId());
break;
}
}
break;
}
}
else if (job->fileRef.GetType()!=osmscout::refNone) {
std::map<osmscout::ObjectFileRef,osmscout::ObjectOSMRef>::const_iterator reference=fileOffsetIdMap.find(job->fileRef);
if (reference==fileOffsetIdMap.end()) {
std::cerr << "Cannot find '" << job->fileRef.GetTypeName() << "' with offset " << job->fileRef.GetFileOffset() << std::endl;
continue;
}
switch (reference->first.GetType()) {
case osmscout::refNone:
break;
case osmscout::refNode:
for (size_t i=0; i<nodes.size(); i++) {
if (reference->first.GetFileOffset()==nodes[i]->GetFileOffset()) {
DumpNode(nodes[i],reference->second.GetId());
break;
}
}
break;
case osmscout::refArea:
for (size_t i=0; i<areas.size(); i++) {
if (reference->first.GetFileOffset()==areas[i]->GetFileOffset()) {
DumpArea(areas[i],reference->second.GetId());
break;
}
}
break;
case osmscout::refWay:
for (size_t i=0; i<ways.size(); i++) {
if (reference->first.GetFileOffset()==ways[i]->GetFileOffset()) {
DumpWay(ways[i],reference->second.GetId());
break;
}
}
break;
}
}
}
std::cout.setf(oldFlags,std::ios::floatfield);
std::cout.precision(oldPrecision);
database.Close();
debugDatabase.Close();
return 0;
}
