// searches a new source for the atom node head.
// If a new source is found the function returns true.
// Otherwise the function returns false and unfounded_ contains head
// as well as atoms with no source that circularly depend on head.
bool DefaultUnfoundedCheck::findSource(NodeId head) {
assert(unfounded_.empty());
enqueueUnfounded(head); // unfounded, unless we find a new source
VarVec noSourceYet;
bool changed = false;
const NodeId* bodyIt, *bodyEnd;
while (!unfounded_.empty()) {
head = unfounded_.front();
if (!atoms_[head].hasSource()) { // no source
unfounded_.pop_front(); // note: current atom is still marked
AtomNodeP headNode(graph_->getAtom(head));
for (bodyIt = headNode.node->bodies(), bodyEnd = headNode.node->bodies_end(); bodyIt != bodyEnd; ++bodyIt) {
BodyNodeP bodyNode(graph_->getBody(*bodyIt));
if (!solver_->isFalse(bodyNode.node->lit)) {
if (bodyNode.node->scc != headNode.node->scc || isValidSource(bodyNode)) {
atoms_[head].ufs = 0; // found a new source,
setSource(headNode, bodyNode); // set the new source
propagateSource(); // and propagate it forward
changed = true; // may source atoms in noSourceYet!
break;
}
else {
addUnsourced(bodyNode);
}
}
}
if (!atoms_[head].hasSource()) {
noSourceYet.push_back(head);// no source found
}
}
else { // head has a source
dequeueUnfounded();
}
} // while unfounded_.emtpy() == false
unfounded_.clear();
if (changed) {
// remove all atoms that have a source as they are not unfounded
VarVec::iterator it;
for (it = noSourceYet.begin(); it != noSourceYet.end(); ++it) {
if ( atoms_[*it].hasSource() ) {
atoms_[*it].ufs = 0;
}
else {
unfounded_.push_back(*it);
}
}
}
else {
// all atoms in noSourceYet are unfounded!
noSourceYet.swap(unfounded_.vec_);
}
return unfounded_.empty();
}
/**
* The parser uses a code sandwich to wrap the parsing process. Before
* the process begins, WillBuildModel() is called. Afterwards the parser
* calls DidBuildModel().
* @update gess5/18/98
* @param aFilename is the name of the file being parsed.
* @return error code (almost always 0)
*/
NS_IMETHODIMP CViewSourceHTML::BuildModel(nsITokenizer* aTokenizer,
PRBool aCanInterrupt,
PRBool aCountLines,
const nsCString* aCharsetPtr)
{
nsresult result=NS_OK;
if(aTokenizer) {
nsITokenizer* oldTokenizer=mTokenizer;
mTokenizer=aTokenizer;
nsTokenAllocator* theAllocator=mTokenizer->GetTokenAllocator();
if(!mHasOpenRoot) {
// For the stack-allocated tokens below, it's safe to pass a null
// token allocator, because there are no attributes on the tokens.
CStartToken htmlToken(NS_LITERAL_STRING("HTML"), eHTMLTag_html);
nsCParserNode htmlNode(&htmlToken, 0/*stack token*/);
mSink->OpenContainer(htmlNode);
CStartToken headToken(NS_LITERAL_STRING("HEAD"), eHTMLTag_head);
nsCParserNode headNode(&headToken, 0/*stack token*/);
mSink->OpenContainer(headNode);
CStartToken titleToken(NS_LITERAL_STRING("TITLE"), eHTMLTag_title);
nsCParserNode titleNode(&titleToken, 0/*stack token*/);
mSink->OpenContainer(titleNode);
// Note that XUL will automatically add the prefix "Source of: "
if (StringBeginsWith(mFilename, NS_LITERAL_STRING("data:")) &&
mFilename.Length() > 50) {
nsAutoString dataFilename(Substring(mFilename, 0, 50));
dataFilename.AppendLiteral("...");
CTextToken titleText(dataFilename);
nsCParserNode titleTextNode(&titleText, 0/*stack token*/);
mSink->AddLeaf(titleTextNode);
} else {
CTextToken titleText(mFilename);
nsCParserNode titleTextNode(&titleText, 0/*stack token*/);
mSink->AddLeaf(titleTextNode);
}
mSink->CloseContainer(eHTMLTag_title);
if (theAllocator) {
CStartToken* theToken=
static_cast<CStartToken*>
(theAllocator->CreateTokenOfType(eToken_start,
eHTMLTag_link,
NS_LITERAL_STRING("LINK")));
if (theToken) {
nsCParserStartNode theNode(theToken, theAllocator);
AddAttrToNode(theNode, theAllocator,
NS_LITERAL_STRING("rel"),
NS_LITERAL_STRING("stylesheet"));
AddAttrToNode(theNode, theAllocator,
NS_LITERAL_STRING("type"),
NS_LITERAL_STRING("text/css"));
AddAttrToNode(theNode, theAllocator,
NS_LITERAL_STRING("href"),
NS_LITERAL_STRING("resource://gre/res/viewsource.css"));
mSink->AddLeaf(theNode);
}
IF_FREE(theToken, theAllocator);
}
result = mSink->CloseContainer(eHTMLTag_head);
if(NS_SUCCEEDED(result)) {
mHasOpenRoot = PR_TRUE;
}
}
if (NS_SUCCEEDED(result) && !mHasOpenBody) {
if (theAllocator) {
CStartToken* bodyToken=
static_cast<CStartToken*>
(theAllocator->CreateTokenOfType(eToken_start,
eHTMLTag_body,
NS_LITERAL_STRING("BODY")));
if (bodyToken) {
nsCParserStartNode bodyNode(bodyToken, theAllocator);
AddAttrToNode(bodyNode, theAllocator,
NS_LITERAL_STRING("id"),
NS_ConvertASCIItoUTF16(kBodyId));
if (mWrapLongLines) {
AddAttrToNode(bodyNode, theAllocator,
NS_LITERAL_STRING("class"),
NS_ConvertASCIItoUTF16(kBodyClassWrap));
}
result = mSink->OpenContainer(bodyNode);
if(NS_SUCCEEDED(result)) mHasOpenBody=PR_TRUE;
}
IF_FREE(bodyToken, theAllocator);
if (NS_SUCCEEDED(result)) {
CStartToken* preToken =
static_cast<CStartToken*>
(theAllocator->CreateTokenOfType(eToken_start,
eHTMLTag_pre,
NS_LITERAL_STRING("PRE")));
if (preToken) {
nsCParserStartNode preNode(preToken, theAllocator);
AddAttrToNode(preNode, theAllocator,
NS_LITERAL_STRING("id"),
NS_LITERAL_STRING("line1"));
result = mSink->OpenContainer(preNode);
} else {
result = NS_ERROR_OUT_OF_MEMORY;
}
IF_FREE(preToken, theAllocator);
}
}
}
NS_ASSERTION(aCharsetPtr, "CViewSourceHTML::BuildModel expects a charset!");
mCharset = *aCharsetPtr;
NS_ASSERTION(aCanInterrupt, "CViewSourceHTML can't run scripts, so "
"document.write should not forbid interruptions. Why is "
"the parser telling us not to interrupt?");
while(NS_SUCCEEDED(result)){
CToken* theToken=mTokenizer->PopToken();
if(theToken) {
result=HandleToken(theToken);
if(NS_SUCCEEDED(result)) {
IF_FREE(theToken, mTokenizer->GetTokenAllocator());
if (mSink->DidProcessAToken() == NS_ERROR_HTMLPARSER_INTERRUPTED) {
result = NS_ERROR_HTMLPARSER_INTERRUPTED;
break;
}
} else {
mTokenizer->PushTokenFront(theToken);
}
}
else break;
}//while
mTokenizer=oldTokenizer;
}
else result=NS_ERROR_HTMLPARSER_BADTOKENIZER;
return result;
}
