Doc Doc::CreateFromFile(const WCHAR *filePath)
{
Doc doc;
if (EpubDoc::IsSupportedFile(filePath))
doc = Doc(EpubDoc::CreateFromFile(filePath));
else if (Fb2Doc::IsSupportedFile(filePath))
doc = Doc(Fb2Doc::CreateFromFile(filePath));
else if (MobiDoc::IsSupportedFile(filePath)) {
doc = Doc(MobiDoc::CreateFromFile(filePath));
// MobiDoc is also used for loading PalmDoc - don't expose that to Doc users, though
if (doc.mobiDoc && doc.mobiDoc->GetDocType() != Pdb_Mobipocket) {
doc.Delete();
// .prc files can be both MobiDoc or PalmDoc
if (PalmDoc::IsSupportedFile(filePath))
doc = Doc(PalmDoc::CreateFromFile(filePath));
}
}
else if (PalmDoc::IsSupportedFile(filePath))
doc = Doc(PalmDoc::CreateFromFile(filePath));
// if failed to load and more specific error message hasn't been
// set above, set a generic error message
if (doc.IsNone()) {
CrashIf(doc.error);
doc.error = Error_Unknown;
doc.filePath.Set(str::Dup(filePath));
}
else {
CrashIf(!Doc::IsSupportedFile(filePath));
}
CrashIf(!doc.generic && !doc.IsNone());
return doc;
}
void wxStfView::OnActivateView(bool activate, wxView *activeView, wxView *deactiveView) {
//this function will be called whenever the view is activated
if (activeView!=NULL) {
wxStfDoc *pDoc = ((wxStfView*)activeView)->Doc();
if (pDoc) {
// Update menu checks:
// pDoc->UpdateMenuCheckmarks();
if (frame!=NULL)
frame->SetSingleChannel(pDoc->size()<2);
pDoc->UpdateSelectedButton();
if (wxGetApp().GetCursorsDialog()!=NULL && wxGetApp().GetCursorsDialog()->IsShown()) {
wxGetApp().GetCursorsDialog()->SetActiveDoc(Doc());
try {
wxGetApp().GetCursorsDialog()->UpdateCursors();
}
catch (const std::runtime_error& e) {
wxGetApp().ExceptMsg(wxString( e.what(), wxConvLocal ));
}
}
}
#ifdef __WXGTK__
wxStfGraph *pGraph = ((wxStfView*)activeView)->GetGraph();
if (pGraph)
pGraph->SetFocus();
#endif
}
#ifdef __WXMAC__
wxGetApp().SetMRActiveDoc(Doc());
#endif
wxView::OnActivateView(activate,activeView,deactiveView);
}
void TSkyGridBinDoc::LoadBinDocV(const TStr& InBinFNm){
printf("Processing SkyGrid News-Binary file '%s'...\n", InBinFNm.CStr());
TFIn SIn(InBinFNm); int Docs=0;
while (!SIn.Eof()){
TSkyGridBinDoc Doc(SIn);
Docs++; printf("%d\r", Docs);
}
printf("\nDone.\n");
}
void Path::Decode(std::string &path) {
if (path[0] != 94) // "^"
return;
try {
if (path.find("^CONFIG") == 0) {
path.replace(0, 7, Config());
return;
}
if (path.find("^USER") == 0) {
path.replace(0, 5, User());
return;
}
if (path.find("^DATA") == 0) {
path.replace(0, 5, Data());
return;
}
if (path.find("^DOC") == 0) {
path.replace(0, 4, Doc());
return;
}
if (path.find("^TEMP") == 0) {
path.replace(0, 5, Temp());
return;
}
if (path.find("^AUDIO") == 0) {
std::string path_str(opt->Get("Last/Audio")->GetString());
Decode(path_str);
path.replace(0, 6, path_str);
return;
}
if (path.find("^VIDEO") == 0) {
std::string path_str(opt->Get("Last/Video")->GetString());
Decode(path_str);
path.replace(0, 6, path_str);
return;
}
if (path.find("^SUBTITLE") == 0) {
std::string path_str(opt->Get("Last/Subtitle")->GetString());
Decode(path_str);
path.replace(0, 5, path_str);
return;
}
throw PathErrorInvalid("Invalid cookie used");
} catch (OptionErrorNotFound&) {
throw PathErrorInternal("Failed to find key in Decode");
}
}
/////////////////////////////////////////////////
// SkyGrid-Document
void TSkyGridBinDoc::SaveBinDocV(
const TStr& InXmlFPath, const TStr& OutBinFNm, const int& MxDocs){
printf("Processing SkyGrid-News-Xml files from '%s'...\n", InXmlFPath.CStr());
TFOut SOut(OutBinFNm);
TFFile FFile(InXmlFPath, true); TStr FNm;
int Docs=0; int DateDocs=0; uint64 PrevTm=0;
while (FFile.Next(FNm)){
if ((MxDocs!=-1)&&(Docs>=MxDocs)){break;}
//printf(" Processing '%s' ...", FNm.CStr());
PXmlDoc XmlDoc=TXmlDoc::LoadTxt(FNm);
PXmlTok ContentTok=XmlDoc->GetTagTok("item|content");
TStr SwIdStr=ContentTok->GetTagTok("swid")->GetArgVal("value");
TStr UrlStr=ContentTok->GetTagTok("url")->GetTokStr(false);
TStr TitleStr=ContentTok->GetTagTok("title")->GetTokStr(false);
TStr FetchedValStr=ContentTok->GetTagTok("fetched")->GetArgVal("value");
TXmlTokV EntityTokV; ContentTok->GetTagTokV("annotations|entity", EntityTokV);
TStr BodyStr=ContentTok->GetTagTok("body")->GetTokStr(false);
// extract date
TStr DateStr=SwIdStr.GetSubStr(0, 7);
TStr YearStr=DateStr.GetSubStr(0, 3);
TStr MonthStr=DateStr.GetSubStr(4, 5);
TStr DayStr=DateStr.GetSubStr(6, 7);
TTm DateTm(YearStr.GetInt(), MonthStr.GetInt(), DayStr.GetInt());
uint64 Tm=TTm::GetMSecsFromTm(DateTm);
// extract entities
TStrIntH EntNmToFqH;
for (int EntityTokN=0; EntityTokN<EntityTokV.Len(); EntityTokN++){
PXmlTok EntityTok=EntityTokV[EntityTokN];
if (!EntityTok->IsTag("entity")){continue;}
TStr CanonicalNm=EntityTok->GetArgVal("canonical", "");
TStr TextStr=EntityTok->GetArgVal("text", "");
TStr TypeNm=EntityTok->GetArgVal("type", "");
TStr EntNm=CanonicalNm.Empty() ? TextStr : CanonicalNm;
EntNmToFqH.AddDat(EntNm)++;
}
TIntStrPrV FqEntNmPrV; EntNmToFqH.GetDatKeyPrV(FqEntNmPrV); FqEntNmPrV.Sort(false);
// extract headline
TChA HeadlineChA=BodyStr.GetSubStr(0, 250);
while ((HeadlineChA.Len()>0)&&(HeadlineChA.LastCh()!=' ')){
HeadlineChA.Trunc(HeadlineChA.Len()-1);}
HeadlineChA+="...";
// create document
TSkyGridBinDoc Doc(SwIdStr, Tm, TitleStr, HeadlineChA, FqEntNmPrV);
// save document
Doc.Save(SOut);
// screen log
if (PrevTm!=Tm){
if (PrevTm!=0){printf("\n");}
PrevTm=Tm; DateDocs=0;
}
Docs++; DateDocs++;
printf(" %s [Day:%d / All:%d]\r", DateStr.CStr(), DateDocs, Docs);
}
printf("\nDone.\n");
}
Doc Doc::CreateFromFile(const WCHAR *filePath)
{
Doc doc;
if (EpubDoc::IsSupportedFile(filePath))
doc = Doc(EpubDoc::CreateFromFile(filePath));
else if (Fb2Doc::IsSupportedFile(filePath))
doc = Doc(Fb2Doc::CreateFromFile(filePath));
else if (MobiDoc::IsSupportedFile(filePath))
doc = Doc(MobiDoc::CreateFromFile(filePath));
// if failed to load and more specific error message hasn't been
// set above, set a generic error message
if (doc.IsNone()) {
CrashIf(doc.error);
doc.error = Error_Unknown;
doc.filePath.Set(str::Dup(filePath));
}
CrashIf(!doc.generic && !doc.IsNone());
return doc;
}
void QsCodeParser::doneParsingSourceFiles(Tree *tree)
{
tree->root()->normalizeOverloads();
NodeList::ConstIterator c = tree->root()->childNodes().begin();
while (c != tree->root()->childNodes().end()) {
if ((*c)->type() == Node::Class) {
QMap<QString, Node *>::ConstIterator cwnqd =
classesWithNoQuickDoc.find((*c)->name());
if (cwnqd != classesWithNoQuickDoc.end()) {
(*cwnqd)->location().warning(tr("No '\\%1' documentation for"
" class '%2'")
.arg(COMMAND_QUICKCLASS)
.arg(cwnqd.key()));
(*cwnqd)->setDoc(Doc(), true);
}
}
++c;
}
// ### check which enum types are used
}
HRESULT CTxtSlave::ComputeFormats(CFormatInfo* pCFI, CTreeNode* pNodeTarget)
{
HRESULT hr = S_OK;
CTreeNode* pNodeMaster = NULL;
CElement* pElemMaster = MarkupMaster();
CDocument* pDoc = Doc();
THREADSTATE* pts = GetThreadState();
BOOL fComputeFFOnly = pNodeTarget->_iCF != -1;
COMPUTEFORMATSTYPE eExtraValues = pCFI->_eExtraValues;
Assert(pCFI);
Assert(SameScope(this, pNodeTarget));
Assert(eExtraValues!=ComputeFormatsType_Normal || ((pNodeTarget->_iCF==-1 && pNodeTarget->_iPF==-1) || pNodeTarget->_iFF==-1));
if(pElemMaster)
{
pNodeMaster = pElemMaster->GetFirstBranch();
// Get the format of our master before applying our own format.
if(pNodeMaster)
{
// If the master node has not computed formats yet, recursively compute them
if(pNodeMaster->_iCF==-1 || pNodeMaster->_iFF==-1
|| eExtraValues==ComputeFormatsType_GetInheritedValue)
{
hr = pElemMaster->ComputeFormats(pCFI, pNodeMaster);
if(hr)
{
goto Cleanup;
}
}
Assert(pNodeMaster->_iCF >= 0);
Assert(pNodeMaster->_iPF >= 0);
Assert(pNodeMaster->_iFF >= 0);
}
}
// NOTE: From this point forward any errors must goto Error instead of Cleanup!
pCFI->Reset();
pCFI->_pNodeContext = pNodeTarget;
if(pNodeMaster)
{
// Inherit para format directly from the master node.
pCFI->_iffSrc = pNodeMaster->_iFF;
pCFI->_pffSrc = pCFI->_pff = &(*pts->_pFancyFormatCache)[pCFI->_iffSrc];
pCFI->_fHasExpandos = (pCFI->_pff->_iExpandos >= 0);
if(!fComputeFFOnly)
{
// Inherit the Char and Para formats from the master node
pCFI->_icfSrc = pNodeMaster->_iCF;
pCFI->_pcfSrc = pCFI->_pcf = &(*pts->_pCharFormatCache)[pCFI->_icfSrc];
pCFI->_ipfSrc = pNodeMaster->_iPF;
pCFI->_ppfSrc = pCFI->_ppf = &(*pts->_pParaFormatCache)[pCFI->_ipfSrc];
// If the parent had layoutness, clear the inner formats
if(pCFI->_pcf->_fHasDirtyInnerFormats)
{
pCFI->PrepareCharFormat();
pCFI->_cf().ClearInnerFormats();
pCFI->UnprepareForDebug();
}
if(pCFI->_ppf->_fHasDirtyInnerFormats)
{
pCFI->PrepareParaFormat();
pCFI->_pf().ClearInnerFormats();
pCFI->UnprepareForDebug();
}
if(pCFI->_ppf->_fPre != pCFI->_ppf->_fPreInner
|| pCFI->_ppf->_fInclEOLWhite != pCFI->_ppf->_fInclEOLWhiteInner
|| pCFI->_ppf->_bBlockAlign != pCFI->_ppf->_bBlockAlignInner)
{
pCFI->PrepareParaFormat();
pCFI->_pf()._fPre = pCFI->_pf()._fPreInner;
pCFI->_pf()._fInclEOLWhite = pCFI->_pf()._fInclEOLWhiteInner;
pCFI->_pf()._bBlockAlign = pCFI->_pf()._bBlockAlignInner;
pCFI->UnprepareForDebug();
}
if(pCFI->_pcf->_fNoBreak != pCFI->_pcf->_fNoBreakInner)
{
pCFI->PrepareCharFormat();
pCFI->_cf()._fNoBreak = pCFI->_cf()._fNoBreakInner;
pCFI->UnprepareForDebug();
}
}
else
{
pCFI->_icfSrc = pDoc->_icfDefault;
pCFI->_pcfSrc = pCFI->_pcf = pDoc->_pcfDefault;
pCFI->_ipfSrc = pts->_ipfDefault;
pCFI->_ppfSrc = pCFI->_ppf = pts->_ppfDefault;
}
}
else
{
pCFI->_iffSrc = pts->_iffDefault;
pCFI->_pffSrc = pCFI->_pff = pts->_pffDefault;
pCFI->_icfSrc = pDoc->_icfDefault;
pCFI->_pcfSrc = pCFI->_pcf = pDoc->_pcfDefault;
pCFI->_ipfSrc = pts->_ipfDefault;
pCFI->_ppfSrc = pCFI->_ppf = pts->_ppfDefault;
Assert(pCFI->_pffSrc->_pszFilters == NULL);
}
if(pCFI->_pff->_fHasLayout || !pCFI->_pff->_fBlockNess)
{
pCFI->PrepareFancyFormat();
pCFI->_ff()._fHasLayout = FALSE;
pCFI->_ff()._fBlockNess = TRUE;
pCFI->UnprepareForDebug();
}
if(eExtraValues == ComputeFormatsType_Normal)
{
hr = pNodeTarget->CacheNewFormats(pCFI);
if(hr)
{
goto Error;
}
// Cache whether an element is a block element or not for fast retrieval.
pNodeTarget->_fBlockNess = TRUE;
pNodeTarget->_fHasLayout = FALSE;
}
Cleanup:
RRETURN(hr);
Error:
pCFI->Cleanup();
goto Cleanup;
}
// Returns true on error.
static bool format(StringRef FileName) {
ErrorOr<std::unique_ptr<MemoryBuffer>> CodeOrErr =
MemoryBuffer::getFileOrSTDIN(FileName);
if (std::error_code EC = CodeOrErr.getError()) {
llvm::errs() << EC.message() << "\n";
return true;
}
std::unique_ptr<llvm::MemoryBuffer> Code = std::move(CodeOrErr.get());
if (Code->getBufferSize() == 0)
return false; // Empty files are formatted correctly.
FormatterDocument Doc(std::move(Code));
if (!Offsets.empty() || !Lengths.empty()) {
if (Offsets.size() != Lengths.size()) {
llvm::errs() << "error: number of offsets not equal to number of lengths.\n";
return true;
}
for ( unsigned i=0 ; i < Offsets.size() ; i++ ) {
unsigned FromLine = Doc.getLineAndColumn(Offsets[i]).first;
unsigned ToLine = Doc.getLineAndColumn(Offsets[i] + Lengths[i]).first;
if (ToLine == 0) {
llvm::errs() << "error: offset + length after end of file\n";
return true;
}
std::ostringstream s;
s << FromLine << ":" << ToLine;
LineRanges.push_back(s.str());
}
}
if (LineRanges.empty())
LineRanges.push_back("1:999999");
std::string Output = Doc.memBuffer().getBuffer();
Replacements Replaces;
for ( unsigned Range = 0 ; Range < LineRanges.size() ; Range++ ) {
unsigned FromLine, ToLine;
if (parseLineRange(LineRanges[Range], FromLine, ToLine)) {
llvm::errs() << "error: invalid <start line>:<end line> pair\n";
return true;
}
if (FromLine > ToLine) {
llvm::errs() << "error: start line should be less than end line\n";
return true;
}
for ( unsigned Line = FromLine ; Line<=ToLine ; Line++ ) {
size_t Offset = getOffsetOfLine(Line,Output);
ssize_t Length = getOffsetOfLine(Line+1,Output)-1-Offset;
if (Length < 0)
break;
std::string Formatted = Doc.reformat(LineRange(Line,1), FormatOptions).second;
if (Formatted.find_first_not_of(" \t\v\f", 0) == StringRef::npos)
Formatted = "";
if (Formatted == Output.substr(Offset, Length))
continue;
Output.replace(Offset, Length, Formatted);
Doc.updateCode(std::move(MemoryBuffer::getMemBuffer(Output)));
Replaces.insert(clang::tooling::Replacement(FileName, Offset, Length, Formatted));
}
}
if (OutputXML) {
llvm::outs() << "<?xml version='1.0'?>\n<replacements>\n";
outputReplacementsXML(Replaces);
llvm::outs() << "</replacements>\n";
} else {
if (Inplace) {
if (FileName == "-") {
llvm::errs() << "error: cannot use -i when reading from stdin.\n";
return true;
}
else {
std::error_code EC;
raw_fd_ostream writer(FileName, EC, llvm::sys::fs::F_None);
if (EC) {
llvm::errs() << "error: writing " << FileName << ": " << EC.message() << "\n";
return true;
}
writer << Output;
}
} else {
llvm::outs() << Output;
}
}
return false;
}
HRESULT CBlockElement::ApplyDefaultFormat(CFormatInfo* pCFI)
{
HRESULT hr = S_OK;
CDocument* pDoc = Doc();
LONG lFontHeightTwips;
if(pCFI->_ppf->_fTabStops)
{
pCFI->PrepareParaFormat();
pCFI->_pf()._fTabStops = FALSE;
pCFI->UnprepareForDebug();
}
switch(Tag())
{
case ETAG_P:
pCFI->PrepareFancyFormat();
ApplyDefaultBeforeSpace(&pCFI->_ff()); // No more nav compat, (pCF->_yHeight + 40) / 20 );
if(_fExplicitEndTag)
{
ApplyDefaultAfterSpace(&pCFI->_ff()); // No more nav compat, (pCF->_yHeight + 40) / 20 );
}
pCFI->UnprepareForDebug();
// Note that we inherit the after space from the parent.
break;
case ETAG_ADDRESS:
pCFI->PrepareCharFormat();
pCFI->_cf()._fItalic = TRUE;
pCFI->UnprepareForDebug();
break;
case ETAG_BLOCKQUOTE:
pCFI->PrepareFancyFormat();
ApplyDefaultVerticalSpace(&pCFI->_ff());
// Set the default indent values
pCFI->_ff()._cuvMarginLeft.SetPoints(BLOCKQUOTE_INDENT_POINTS);
pCFI->_ff()._cuvMarginRight.SetPoints(BLOCKQUOTE_INDENT_POINTS);
pCFI->_ff()._fHasMargins = TRUE;
pCFI->UnprepareForDebug();
pCFI->PrepareParaFormat();
pCFI->_pf()._cuvOffsetPoints.SetPoints(LIST_FIRST_REDUCTION_POINTS);
pCFI->_pf()._cuvNonBulletIndentPoints.SetPoints(
pCFI->_pf()._cuvNonBulletIndentPoints.GetPoints()+BLOCKQUOTE_INDENT_POINTS);
pCFI->UnprepareForDebug();
break;
case ETAG_CENTER:
pCFI->_bBlockAlign = (BYTE) htmlBlockAlignCenter;
pCFI->_bCtrlBlockAlign = (BYTE) htmlBlockAlignCenter;
break;
case ETAG_LISTING:
// NB (cthrash) Inside a listing, we drop the font size by 2.
// We drop it by one here, and then set BUMPSIZEDOWN on
// to drop another.
pCFI->PrepareCharFormat();
pCFI->_cf().ChangeHeightRelative(-1);
pCFI->UnprepareForDebug();
case ETAG_XMP:
case ETAG_PRE:
case ETAG_PLAINTEXT:
pCFI->PrepareParaFormat();
pCFI->_pf()._fTabStops = TRUE;
pCFI->UnprepareForDebug();
pCFI->_fPre = TRUE;
pCFI->_fInclEOLWhite = TRUE;
pCFI->_fNoBreak = TRUE;
pCFI->PrepareCharFormat();
pCFI->_cf()._fBumpSizeDown = TRUE;
pCFI->UnprepareForDebug();
// Netscape puts a lot of space between PLAINTEXT and the preceeding lines.
if(Tag() == ETAG_PLAINTEXT)
{
if(!pCFI->_pff->_fExplicitTopMargin)
{
pCFI->PrepareFancyFormat();
pCFI->_ff()._cuvSpaceBefore.SetPoints(26);
pCFI->UnprepareForDebug();
}
if(!pCFI->_pff->_fExplicitBottomMargin)
{
pCFI->PrepareFancyFormat();
pCFI->_ff()._cuvSpaceAfter.SetPoints(26);
pCFI->UnprepareForDebug();
}
}
else
{
pCFI->PrepareFancyFormat();
ApplyDefaultVerticalSpace(&pCFI->_ff());
pCFI->UnprepareForDebug();
}
{
pCFI->PrepareCharFormat();
CODEPAGESETTINGS* pCS = pDoc->_pCodepageSettings;
// Thai does not have a fixed pitch font. Leave it as proportional
if(pDoc->GetCodePage() != CP_THAI)
{
pCFI->_cf()._bPitchAndFamily = FIXED_PITCH;
pCFI->_cf()._latmFaceName = pCS->latmFixedFontFace;
}
pCFI->_cf()._bCharSet = pCS->bCharSet;
pCFI->_cf()._fNarrow = IsNarrowCharSet(pCFI->_cf()._bCharSet);
pCFI->UnprepareForDebug();
}
break;
}
// we need to call super AFTER the above code, because this is where in-linestyles get
// applied. by calling super first we overwrote explicitly set values (e.g. margin-top)
hr = super::ApplyDefaultFormat(pCFI);
if(hr)
{
goto Cleanup;
}
// set up for potential EM, EN, ES converstions
lFontHeightTwips = pCFI->_pcf->GetHeightInTwips(pDoc);
if(lFontHeightTwips <= 0)
{
lFontHeightTwips = 1;
}
if(pCFI->_ppf->_lFontHeightTwips != lFontHeightTwips)
{
pCFI->PrepareParaFormat();
pCFI->_pf()._lFontHeightTwips = lFontHeightTwips;
pCFI->UnprepareForDebug();
}
Cleanup:
RRETURN(hr);
}
xml::Doc xml::Doc::fromString(const std::string& str)
{
return Doc(xmlParseDoc((xmlChar*)str.c_str()));
}
xml::Doc xml::Doc::fromFile(const std::string& fname)
{
return Doc(xmlParseFile(fname.c_str()));
}