inline JBoolean
JXFontManager::IsPostscript
(
const JString& name
)
const
{
#if ONLY_STD_PS_FONTS
return JI2B(name == "Arial" || // Helvetica sucks on OS X
name.BeginsWith("Courier") ||
name.BeginsWith("Helvetica") ||
name == "Symbol" ||
name == "Times" ||
name.Contains("Bookman") ||
name.Contains("Century Schoolbook") ||
name.Contains("Chancery") ||
name.Contains("Palatino"));
#else
return kJTrue;
#endif
}
JString
JVMVarNode::GetFullName
(
JBoolean* isPointer
)
const
{
JString str;
if (IsRoot())
{
return str;
}
const JVMVarNode* parent = dynamic_cast<const JVMVarNode*>(GetVarParent());
const JString& name = GetName();
if (parent->IsRoot())
{
str = "(" + name + ")";
}
else if (name.IsEmpty())
{
JIndex i;
const JBoolean found = parent->FindChild(this, &i);
assert( found );
str = parent->GetFullName(isPointer);
if (!str.BeginsWith("(") || !str.EndsWith(")"))
{
str.PrependCharacter('(');
str.AppendCharacter(')');
}
str += "[" + JString(i-1, JString::kBase10) + "]";
}
else if (name.BeginsWith("<"))
{
if (isPointer != NULL)
{
*isPointer = parent->IsPointer();
}
str = parent->GetFullName(isPointer);
}
else if (name.BeginsWith("["))
{
str = parent->GetFullName(isPointer) + name;
}
else if (name.BeginsWith("*"))
{
str = parent->GetPath() + "(" + name + ")";
}
else
{
str = name;
if (str.BeginsWith("static "))
{
str.RemoveSubstring(1,7);
}
str.Prepend(parent->GetPath());
}
return str;
}
JBoolean
JFSBinding::Match
(
const JString& fileName,
const JString& content
)
const
{
if (itsCmd.IsEmpty())
{
return kJFalse;
}
else if (itsContentRegex != NULL)
{
return JI2B(content.BeginsWith(itsLiteralPrefix) &&
itsContentRegex->Match(content));
}
else if (itsNameRegex != NULL)
{
return itsNameRegex->Match(fileName);
}
else
{
return JI2B(!itsPattern.IsEmpty() &&
fileName.EndsWith(itsPattern, kJFalse));
}
}
void
CBExecOutputDocument::ReceiveRecord()
{
assert( itsRecordLink != NULL );
JString text;
const JBoolean ok = itsRecordLink->GetNextMessage(&text);
assert( ok );
// remove text that has already been printed
if (!itsLastPrompt.IsEmpty() && text.BeginsWith(itsLastPrompt))
{
text.RemoveSubstring(1, itsLastPrompt.GetLength());
}
itsLastPrompt.Clear();
const JXTEBase::DisplayState state = GetTextEditor()->SaveDisplayState();
AppendText(text);
GetTextEditor()->ClearUndo();
if (!itsReceivedDataFlag)
{
itsReceivedDataFlag = kJTrue;
if (!IsActive())
{
Activate();
}
}
GetTextEditor()->RestoreDisplayState(state);
}
void
XDLink::SwitchToFrame
(
const JUInt64 id
)
{
if (id != itsStackFrameIndex)
{
itsStackFrameIndex = id;
Broadcast(FrameChanged());
}
const CMStackFrameNode* frame;
JString fileName;
JIndex lineIndex;
if (CMGetCommandDirector()->GetStackDir()->GetStackWidget()->GetStackFrame(id, &frame) &&
frame->GetFile(&fileName, &lineIndex))
{
if (fileName.BeginsWith("file://"))
{
fileName.RemoveSubstring(1, 7);
}
Broadcast(ProgramStopped(CMLocation(fileName, lineIndex)));
}
}
inline JBoolean
jTranslateRemoteToLocal1
(
const JCharacter* host,
const JString& remotePath,
const JCharacter* mountDev,
const JCharacter* mountDir,
JString* localPath
)
{
const JString dev = mountDev;
JIndex hostEndIndex;
if (dev.LocateSubstring(":/", &hostEndIndex) && hostEndIndex > 1)
{
JString h = dev.GetSubstring(1, hostEndIndex-1);
jGetFullHostName(&h);
JString p = dev.GetSubstring(hostEndIndex+1, dev.GetLength());
JAppendDirSeparator(&p); // force complete name when check BeginsWith()
if (host == h && remotePath.BeginsWith(p))
{
*localPath = remotePath;
localPath->ReplaceSubstring(1, p.GetLength()-1, mountDir);
JCleanPath(localPath);
return kJTrue;
}
}
return kJFalse;
}
JBoolean
JFSBinding::WillBeRegex
(
const JString& pattern
)
{
return pattern.BeginsWith(kContentRegexMarker);
}
JBoolean
CBCtagsUser::IgnoreSymbol
(
const JString& s
)
{
return s.BeginsWith("::");
}
void
JWebBrowser::ShowURL
(
const JCharacter* url
)
{
JString s = url;
if (s.BeginsWith(kMailURLPrefix, kJFalse))
{
s.RemoveSubstring(1, kMailURLPrefixLength);
ComposeMail(s);
}
else if (s.BeginsWith(kFileURLPrefix, kJFalse))
{
s.RemoveSubstring(1, kFileURLPrefixLength);
ShowFileContent(s);
}
else
{
Exec(itsShowURLCmd, kURLVarName, url);
}
}
void
GDBGetSourceFileList::HandleSuccess
(
const JString& origData
)
{
if (origData.BeginsWith("Source files for which symbols have been read in:"))
{
(JXGetApplication())->DisplayBusyCursor();
JXFileListTable* table = (GetFileList())->GetTable();
table->RemoveAllFiles();
JString data = origData;
JIndex i,j;
while (data.LocateSubstring("Source files for which symbols", &i))
{
j = i;
if (!data.LocateNextSubstring(":", &j))
{
j = data.GetLength();
}
data.ReplaceSubstring(i, j, ",");
}
data.TrimWhitespace(); // no comma after last file
std::istrstream input(data.GetCString(), data.GetLength());
JString fullName, path, name, s;
JBoolean foundDelimiter;
do
{
input >> ws;
fullName = JReadUntil(input, ',', &foundDelimiter);
fullName.TrimWhitespace();
if (!fullName.IsEmpty())
{
JSplitPathAndName(fullName, &path, &name);
table->AddFile(name);
}
}
while (foundDelimiter);
}
JString
CMLineAddressTable::GetLineTextFromAddress
(
const JString& addr
)
const
{
JString s = addr;
if (s.BeginsWith("0x"))
{
s.RemoveSubstring(1,2);
}
while (s.GetFirstCharacter() == '0' &&
s.GetLength() > itsLineTextList->LastElement()->GetLength())
{
s.RemoveSubstring(1,1);
}
return s;
}
JBoolean
CBSymbolList::InContext
(
const JString& fullName,
const JPtrArray<JString>& contextNamespace,
const JBoolean caseSensitive
)
const
{
const JSize count = contextNamespace.GetElementCount();
for (JIndex i=1; i<=count; i+=2)
{
const JString* cns1 = contextNamespace.NthElement(i);
const JString* cns2 = contextNamespace.NthElement(i+1);
if (fullName.BeginsWith(*cns1, caseSensitive) ||
fullName.Contains(*cns2, caseSensitive))
{
return kJTrue;
}
}
return kJFalse;
}
void
GFGLink::ParseLine
(
const JString& data
)
{
// we only care about virtual functions
JBoolean required = kJFalse;
if (data.Contains("implementation:pure virtual"))
{
required = kJTrue;
}
else if (!data.Contains("implementation:virtual"))
{
return;
}
JArray<JIndexRange> subList;
if (memberLine.Match(data, &subList))
{
JIndexRange sRange = subList.GetElement(2);
JString name = data.GetSubstring(sRange);
if (name.BeginsWith("~"))
{
return;
}
GFGMemberFunction* fn = jnew GFGMemberFunction();
assert(fn != NULL);
fn->SetFnName(name);
fn->ShouldBeRequired(required);
sRange = subList.GetElement(3);
JIndex line;
JString lineStr = data.GetSubstring(sRange);
lineStr.ConvertToUInt(&line);
sRange = subList.GetElement(4);
JString base = data.GetSubstring(sRange);
if (base != itsCurrentClass)
{
jdelete fn;
return;
}
sRange = subList.GetElement(5);
JString access = data.GetSubstring(sRange);
if (access == "protected")
{
fn->ShouldBeProtected(kJTrue);
}
ParseInterface(fn, line);
// Override entry from base class so function will only be
// marked as pure virtual if nobody implemented it.
JBoolean found;
const JIndex i =
itsClassList->SearchSorted1(fn, JOrderedSetT::kAnyMatch, &found);
if (found)
{
itsClassList->DeleteElement(i);
}
itsClassList->InsertAtIndex(i, fn);
}
}
void
GAddressBookMgr::AddAddressBook
(
const JCharacter* name,
JTree* tree
)
{
if (!JFileExists(name))
{
return;
}
JDirEntry* dirEntry = new JDirEntry(name);
assert(dirEntry != NULL);
JTreeNode* jbase = tree->GetRoot();
JNamedTreeNode* base = dynamic_cast<JNamedTreeNode*>(jbase);
assert(base != NULL);
GAddressBookTreeNode* book = new
GAddressBookTreeNode(dirEntry, base, dirEntry->GetName());
assert(book != NULL);
std::ifstream is(name);
while (is.good())
{
JString line = JReadLine(is);
GAddressBookEntry* entry = new GAddressBookEntry();
assert( entry != NULL );
JString name;
if (GetNextRecord(line, name, is))
{
GetNextRecord(line, entry->fullname, is);
if (GetNextRecord(line, entry->address, is))
{
GetNextRecord(line, entry->fcc, is);
GetNextRecord(line, entry->comment, is);
itsAddresses->SetElement(name, entry, JPtrArrayT::kDelete);
GAddressEntryTreeNode* aEntry =
new GAddressEntryTreeNode(book, entry->fullname);
assert(aEntry != NULL);
GAddressItemTreeNode* item =
new GAddressItemTreeNode(GAddressItemTreeNode::kName,
aEntry, name, kJFalse);
assert(item != NULL);
JString address = entry->address;
if (address.BeginsWith("(") && address.GetLength() > 2)
{
address = address.GetSubstring(2, address.GetLength() - 1);
JPtrArray<JString> list(JPtrArrayT::kForgetAll);
GParseNameList(address, list);
const JSize count = list.GetElementCount();
for (JSize i = count; i >= 1; i--)
{
item =
new GAddressItemTreeNode(GAddressItemTreeNode::kEMail,
aEntry, *(list.NthElement(i)), kJFalse);
assert(item != NULL);
}
list.DeleteAll();
}
else
{
item =
new GAddressItemTreeNode(GAddressItemTreeNode::kEMail,
aEntry, address, kJFalse);
}
if (!entry->comment.IsEmpty())
{
item =
new GAddressItemTreeNode(GAddressItemTreeNode::kComment,
aEntry, entry->comment, kJFalse);
assert(item != NULL);
}
if (!entry->fcc.IsEmpty())
{
item =
new GAddressItemTreeNode(GAddressItemTreeNode::kFcc,
aEntry, entry->fcc, kJFalse);
assert(item != NULL);
}
book->InsertSorted(aEntry);
continue;
}
}
delete entry;
}
}
void
JXFontManager::GetMonospaceFontNames
(
JPtrArray<JString>* fontNames
)
const
{
if (itsMonoFontNames != NULL)
{
fontNames->CopyObjects(*itsMonoFontNames, fontNames->GetCleanUpAction(), kJFalse);
}
else
{
(JXGetApplication())->DisplayBusyCursor();
fontNames->CleanOut();
fontNames->SetCompareFunction(JCompareStringsCaseInsensitive);
fontNames->SetSortOrder(JOrderedSetT::kSortAscending);
JPtrArray<JString> allFontNames(JPtrArrayT::kDeleteAll);
allFontNames.SetCompareFunction(JCompareStringsCaseInsensitive);
allFontNames.SetSortOrder(JOrderedSetT::kSortAscending);
JString name;
#if ENABLE_TRUE_TYPE
FcFontSet* set =
XftListFonts(*itsDisplay, itsDisplay->GetScreen(),
FC_SPACING, FcTypeInteger, FC_MONO, NULL,
FC_FAMILY, NULL);
for (int i=0; i < set->nfont; i++)
{
FcChar8* s = FcNameUnparse(set->fonts[i]);
name.Set((JCharacter*) s);
// cout << "tt mono: " << name << endl;
#if ONLY_STD_MONOSPACE
if (!name.BeginsWith("Courier") &&
!name.BeginsWith("Consolas") &&
!name.Contains(" Mono") &&
name != "LucidaTypewriter")
{
FcStrFree(s);
continue;
}
#endif
if (IsUseless(name))
{
FcStrFree(s);
continue;
}
JBoolean isDuplicate;
const JIndex index =
allFontNames.GetInsertionSortIndex(&name, &isDuplicate);
if (!isDuplicate)
{
allFontNames.InsertAtIndex(index, name);
JString* n = new JString(name);
assert( n != NULL );
const JBoolean ok = fontNames->InsertSorted(n, kJFalse);
assert( ok );
}
FcStrFree(s);
}
FcFontSetDestroy(set);
#else
for (int j=0; j<kMonospaceFontPatternCount; j++)
{
int nameCount;
char** nameList = XListFonts(*itsDisplay, kMonospaceFontPattern[j],
INT_MAX, &nameCount);
if (nameList == NULL)
{
return;
}
for (int i=0; i<nameCount; i++)
{
const std::string s(nameList[i], strlen(nameList[i]));
std::istringstream input(s);
input.ignore(); // initial dash
JIgnoreUntil(input, '-'); // foundry name
name = JReadUntil(input, '-'); // font name
if (name.IsEmpty() || name == "nil")
{
continue;
}
ConvertToPSFontName(&name);
// cout << "std mono: " << name << endl;
#if ONLY_STD_MONOSPACE
if (name != "Clean" && name != "Fixed" && name != "Terminal" &&
name != "Courier" && name != "Lucidatypewriter" &&
name != "Profontwindows")
{
continue;
}
#endif
if (IsUseless(name))
{
continue;
}
JBoolean isDuplicate;
const JIndex index =
allFontNames.GetInsertionSortIndex(&name, &isDuplicate);
if (!isDuplicate)
{
allFontNames.InsertAtIndex(index, name);
XFontStruct* xfont = XLoadQueryFont(*itsDisplay, nameList[i]);
if (xfont != NULL)
{
if (xfont->min_bounds.width == xfont->max_bounds.width)
{
JString* n = new JString(name);
assert( n != NULL );
const JBoolean ok = fontNames->InsertSorted(n, kJFalse);
assert( ok );
}
XFreeFont(*itsDisplay, xfont);
}
}
}
XFreeFontNames(nameList);
}
#endif
// save names for next time
itsMonoFontNames = new JDCCPtrArray<JString>(*fontNames, JPtrArrayT::kDeleteAll);
assert( itsMonoFontNames != NULL );
}
}
void
CBShellEditor::HandleKeyPress
(
const int key,
const JXKeyModifiers& modifiers
)
{
const JBoolean controlOn = modifiers.control();
const JBoolean metaOn = modifiers.meta();
const JBoolean shiftOn = modifiers.shift();
if ((key == kJLeftArrow && metaOn && !controlOn && !shiftOn) ||
(key == JXCtrl('A') && controlOn && !metaOn && !shiftOn))
{
const JIndex index = GetInsertionIndex();
const JRunArray<Font>& styles = GetStyles();
if (index > 1 && styles.GetElement(index-1) == GetDefaultFont())
{
JIndex runIndex, firstIndexInRun;
const JBoolean ok = styles.FindRun(index-1, &runIndex, &firstIndexInRun);
SetCaretLocation(firstIndexInRun);
return;
}
}
if (key == kJReturnKey)
{
SetCurrentFont(itsInsertFont);
}
else
{
SetCurrentFont(GetDefaultFont());
}
JBoolean sentCmd = kJFalse;
if (key == kJReturnKey && !modifiers.shift() && !HasSelection())
{
JIndex index;
JBoolean ok = GetCaretLocation(&index);
assert( ok );
JString cmd;
const JRunArray<Font>& styles = GetStyles();
if (index > 1 && styles.GetElement(index-1) == GetDefaultFont())
{
JIndex runIndex, firstIndexInRun;
ok = styles.FindRun(index-1, &runIndex, &firstIndexInRun);
const JIndex endIndex = firstIndexInRun + styles.GetRunLength(runIndex);
cmd = (GetText()).GetSubstring(firstIndexInRun, endIndex - 1);
SetCaretLocation(endIndex);
if (cmd.BeginsWith("man "))
{
cmd.ReplaceSubstring(1, 4, "jcc --man ");
}
else if (cmd.BeginsWith("apropos "))
{
cmd.ReplaceSubstring(1, 8, "jcc --apropos ");
}
else if (cmd.BeginsWith("vi "))
{
cmd.ReplaceSubstring(1, 3, "jcc ");
}
else if (cmd.BeginsWith("less ") || cmd.BeginsWith("more "))
{
cmd.ReplaceSubstring(1, 5, "jcc ");
}
else if (cmd == "more" || cmd == "less" || cmd == "vi")
{
cmd = "jcc";
}
}
cmd += "\n";
itsShellDoc->SendCommand(cmd);
sentCmd = kJTrue;
}
CBTextEditor::HandleKeyPress(key, modifiers);
if (sentCmd)
{
itsInsertIndex = GetInsertionIndex();
}
}
void
GetOptions
(
const JSize argc,
char* argv[],
JPtrArray<JString>* inputFileList,
JString* dataVarName,
JString* outputFileName,
JString* databaseFileName,
JBoolean* debug
)
{
inputFileList->CleanOut();
dataVarName->Clear();
outputFileName->Clear();
databaseFileName->Clear();
*debug = kJFalse;
JIndex index = 1;
while (index < argc)
{
if (JIsVersionRequest(argv[index]))
{
PrintVersion();
exit(0);
}
else if (JIsHelpRequest(argv[index]))
{
PrintHelp();
exit(0);
}
else if (strcmp(argv[index], "--code") == 0)
{
JCheckForValues(2, &index, argc, argv);
*dataVarName = argv[index];
*outputFileName = argv[index+1];
index++;
}
else if (strcmp(argv[index], "--db") == 0)
{
JCheckForValues(1, &index, argc, argv);
*databaseFileName = argv[index];
}
else if (strcmp(argv[index], "--debug") == 0)
{
*debug = kJTrue;
}
else if (argv[index][0] == '-')
{
cerr << argv[0] << ": unknown command line option: " << argv[index] << endl;
}
else
{
JString* inputFileName = new JString(argv[index]);
assert( inputFileName != NULL );
if (inputFileName->EndsWith("~") ||
inputFileName->BeginsWith("#"))
{
delete inputFileName;
}
else
{
inputFileList->Append(inputFileName);
}
}
index++;
}
if (inputFileList->IsEmpty())
{
cerr << argv[0] << ": no input files" << endl;
exit(1);
}
}
void
GMMIMEParser::ParseMixed
(
std::istream& input,
const GMIMEHeader& header
)
{
JString boundary = "-" + header.GetBoundary();
JString endBoundary = boundary + "--";
// slurp the initial empty part
JIndex bstart, bend;
ReadUntilBoundary(input, boundary, &bstart, &bend);
JIndex current = JTellg(input);
JString data;
data.Read(input, bend - current + 1);
while (1)
{
GMIMEHeader child;
ParseMIMEHeader(input, &child);
// when the following function returns true, it has found the
// last boundary
data.Clear();
JBoolean end;
if (child.GetEncoding() == kBase64Encoding)
{
JString filename = child.GetFileName();
if (filename.IsEmpty())
{
JCreateTempFile(itsAttachDir, NULL, &filename);
}
else
{
filename = JCombinePathAndName(itsAttachDir, filename);
}
if (!filename.IsEmpty())
{
AdjustAttachmentName(child, &filename);
std::ofstream os(filename);
JDecodeBase64(input, os);
end = ReadUntilBoundary(input, boundary, &bstart, &bend);
// JBoolean found;
// JString line;
// while (line.IsEmpty() && !input.fail())
// {
// line = JReadLine(input, &found);
// }
// JString endBoundary = boundary + "--";
// if (line.Contains(endBoundary))
// {
// end = kJTrue;
// }
}
}
else if ((child.GetType() != kMultipartType) &&
(!child.GetFileName().IsEmpty()))
{
JIndex startI = JTellg(input);
JIndex findex = startI;
if (itsData->LocateNextSubstring(boundary, &findex))
{
const JCharacter* c = itsData->GetCString() + startI;
JString filename = child.GetFileName();
if (filename.IsEmpty())
{
JCreateTempFile(itsAttachDir, NULL, &filename);
}
else
{
filename = JCombinePathAndName(itsAttachDir, filename);
}
if (!filename.IsEmpty())
{
AdjustAttachmentName(child, &filename);
std::ofstream os(filename);
JSeekg(input, findex - 1);
if (child.GetEncoding() == kQPEncoding)
{
JString data = itsData->GetSubstring(startI, findex - 3);
ParseQuotedPrintable(&data);
data.Print(os);
}
else
{
os.write(c, findex - startI - 3);
}
JBoolean found;
JString line = JReadLine(input, &found);
if (line.BeginsWith(endBoundary))
{
end = kJTrue;
}
}
}
}
else
{
end = ReadUntilBoundary(input, boundary, &bstart, &bend);
ParseByType(input, child, bstart - 1);
current = JTellg(input);
data.Read(input, bend - current + 1);
}
if (end)
{
break;
}
}
if (itsTextInfo != NULL)
{
itsTextInfo->ForceUpdate();
}
if (itsAttachInfo != NULL)
{
itsAttachInfo->ForceUpdate();
}
}
void
SMTPMessage::HandleAddresses()
{
JPtrArray<JString> names(JPtrArrayT::kForgetAll);
GParseNameList(*itsTo, names);
ReplaceAliases(names);
while (!names.IsEmpty())
{
JString* str = names.GetFirstElement();
if (!str->BeginsWith("<"))
{
str->Prepend("<");
str->Append(">");
}
if (itsToNames->InsertSorted(str,kJFalse))
{
names.RemoveElement(1);
}
else
{
names.DeleteElement(1);
}
}
GParseNameList(*itsCC, names);
ReplaceAliases(names);
while (!names.IsEmpty())
{
JString* str = names.GetFirstElement();
if (!str->BeginsWith("<"))
{
str->Prepend("<");
str->Append(">");
}
JIndex findex;
if (itsToNames->SearchSorted(str, JOrderedSetT::kFirstMatch, &findex))
{
names.DeleteElement(1);
}
else
{
if (itsCcNames->InsertSorted(str,kJFalse))
{
names.RemoveElement(1);
}
else
{
names.DeleteElement(1);
}
}
}
GParseNameList(*itsBCC, names);
ReplaceAliases(names);
while (!names.IsEmpty())
{
JString* str = names.GetFirstElement();
if (!str->BeginsWith("<"))
{
str->Prepend("<");
str->Append(">");
}
JIndex findex;
if (itsToNames->SearchSorted(str, JOrderedSetT::kFirstMatch, &findex))
{
names.DeleteElement(1);
}
else
{
if (itsCcNames->SearchSorted(str, JOrderedSetT::kFirstMatch, &findex))
{
names.DeleteElement(1);
}
else
{
if (itsBccNames->InsertSorted(str,kJFalse))
{
names.RemoveElement(1);
}
else
{
names.DeleteElement(1);
}
}
}
}
}
void
XDLink::SetProgram
(
const JCharacter* fileName
)
{
Send("detach");
// StopDebugger(); // avoid broadcasting DebuggerRestarted
// StartDebugger();
itsProgramConfigFileName.Clear();
itsSourcePathList->DeleteAll();
JString fullName;
if (!JConvertToAbsolutePath(fileName, NULL, &fullName) ||
!JFileReadable(fullName))
{
const JString error = JGetString("ConfigFileUnreadable::XDLink");
Broadcast(UserOutput(error, kJTrue));
return;
}
else if (CMMDIServer::IsBinary(fullName))
{
const JString error = JGetString("ConfigFileIsBinary::XDLink");
Broadcast(UserOutput(error, kJTrue));
return;
}
JString line;
if (!CMMDIServer::GetLanguage(fullName, &line) ||
JStringCompare(line, "php", kJFalse) != 0)
{
const JString error = JGetString("ConfigFileWrongLanguage::XDLink");
Broadcast(UserOutput(error, kJTrue));
return;
}
JString path, name, suffix;
JSplitPathAndName(fullName, &path, &name);
JSplitRootAndSuffix(name, &itsProgramName, &suffix);
itsProgramConfigFileName = fullName;
ifstream input(fullName);
while (1)
{
line = JReadLine(input);
line.TrimWhitespace();
if (line.BeginsWith("source-path:"))
{
line.RemoveSubstring(1, 12);
line.TrimWhitespace();
name = JCombinePathAndName(path, line);
itsSourcePathList->Append(name);
}
else if (!line.IsEmpty() && !line.BeginsWith("code-medic:"))
{
line.Prepend("Unknown option: ");
line.AppendCharacter('\n');
Broadcast(UserOutput(line, kJTrue));
}
if (!input.good())
{
break;
}
}
XDSetProgramTask* task = new XDSetProgramTask();
assert( task != NULL );
task->Go();
}
void
JXPathInput::AdjustStylesBeforeRecalc
(
const JString& buffer,
JRunArray<Font>* styles,
JIndexRange* recalcRange,
JIndexRange* redrawRange,
const JBoolean deletion
)
{
const JColormap* colormap = GetColormap();
const JSize totalLength = buffer.GetLength();
JString fullPath = buffer;
if ((JIsRelativePath(buffer) && !HasBasePath()) ||
!JExpandHomeDirShortcut(buffer, &fullPath))
{
fullPath.Clear();
}
// Last clause because if JConvertToAbsolutePath() succeeds, we don't
// want to further modify fullName.
else if (JIsRelativePath(buffer) &&
!JConvertToAbsolutePath(buffer, itsBasePath, &fullPath))
{
if (HasBasePath())
{
fullPath = JCombinePathAndName(itsBasePath, buffer);
}
else
{
fullPath.Clear();
}
}
JSize errLength;
if (fullPath.IsEmpty())
{
errLength = totalLength;
}
else
{
const JString closestDir = JGetClosestDirectory(fullPath, itsRequireWriteFlag);
if (fullPath.BeginsWith(closestDir))
{
errLength = fullPath.GetLength() - closestDir.GetLength();
}
else
{
errLength = totalLength;
}
}
if (errLength > 0 && buffer.EndsWith(kThisDirSuffix))
{
errLength++; // trailing . is trimmed
}
Font f = styles->GetFirstElement();
styles->RemoveAll();
if (errLength >= totalLength)
{
f.style.color = colormap->GetRedColor();
styles->AppendElements(f, totalLength);
}
else
{
f.style.color = colormap->GetBlackColor();
styles->AppendElements(f, totalLength - errLength);
if (errLength > 0)
{
f.style.color = colormap->GetRedColor();
styles->AppendElements(f, errLength);
}
}
*redrawRange += JIndexRange(1, totalLength);
}
JString
JGetClosestDirectory
(
const JCharacter* origDirName,
const JBoolean requireWrite,
const JCharacter* basePath
)
{
assert( !JStringEmpty(origDirName) );
JString workingDir;
if (!JStringEmpty(basePath))
{
workingDir = basePath;
JAppendDirSeparator(&workingDir);
}
else
{
workingDir = JGetCurrentDirectory();
}
JString dirName = origDirName;
JString homeDir;
JSize homeLength;
if (origDirName[0] == '~' &&
!JExpandHomeDirShortcut(origDirName, &dirName, &homeDir, &homeLength))
{
return JGetRootDirectory();
}
else if (JIsRelativePath(origDirName))
{
dirName.Prepend(workingDir);
}
assert( !JIsRelativePath(dirName) );
JString newDir, junkName;
while (!JDirectoryExists(dirName) ||
!JCanEnterDirectory(dirName) ||
!JDirectoryReadable(dirName) ||
(requireWrite && !JDirectoryWritable(dirName)))
{
JStripTrailingDirSeparator(&dirName);
if (JIsRootDirectory(dirName))
{
break;
}
JSplitPathAndName(dirName, &newDir, &junkName);
dirName = newDir;
}
// convert back to partial path, if possible
if (origDirName[0] == '~' &&
dirName.BeginsWith(homeDir))
{
dirName.ReplaceSubstring(1, homeDir.GetLength(), origDirName, homeLength);
}
else if (JIsRelativePath(origDirName) &&
dirName.GetLength() > workingDir.GetLength() &&
dirName.BeginsWith(workingDir))
{
dirName.RemoveSubstring(1, workingDir.GetLength());
}
return dirName;
}
void
GMMIMEParser::ParseMIMEHeader
(
std::istream& input,
GMIMEHeader* header,
const JBoolean display
)
{
JString data;
JCharacter c = input.peek();
if (c == '\n')
{
// input.get(c);
}
// input >> std::ws;
// first we need to search for the first empty line. This line is the
// end of the header.
JString line;
while (1)
{
JBoolean found;
line = JReadLine(input, &found);
if (line.IsEmpty())
{
break;
}
if (isspace(line.GetFirstCharacter()))
{
line.TrimWhitespace();
if (line.IsEmpty())
{
break;
}
data.AppendCharacter(' ');
}
else if (!data.IsEmpty())
{
data.AppendCharacter('\n');
}
data += line;
}
data.AppendCharacter('\n');
// we now need to search through the header for parameter:value pairs
// using the gmime_header_regex defined above.
JArray<JIndexRange> ranges;
gmime_header_regex.MatchAll(data, &ranges);
JSize count = ranges.GetElementCount();
for (JSize i = 1; i <= count; i++)
{
JIndexRange range = ranges.GetElement(i);
JString parmValPair = data.GetSubstring(range);
JString parm;
JString val;
if (parmValPair.BeginsWith("MIME") ||
parmValPair.BeginsWith("Mime") ||
parmValPair.BeginsWith("Content"))
{
CleanParmValPair(parmValPair, &parm, &val);
parm.ToLower();
if (parm == "mime-Version")
{
val.TrimWhitespace();
header->SetVersion(val);
}
else if (parm == "content-type")
{
ParseContentType(val, header);
}
else if (parm == "content-transfer-encoding")
{
val.TrimWhitespace();
val.ToLower();
header->SetEncoding(val);
}
else if (parm == "content-disposition")
{
ParseContentDisposition(val, header);
}
}
}
// this is a nested message, so some of the headers need to be displayed
if (display)
{
JString text = "---------\n";
JIndex findex = 1;
if (data.BeginsWith("From: ") || data.LocateSubstring("\nFrom: ", &findex))
{
if (findex > 1)
{
findex ++;
}
JIndex eindex = findex;
if (data.LocateNextSubstring("\n", &eindex) && (eindex > findex + 1))
{
text += data.GetSubstring(findex, eindex - 1);
text += "\n";
}
}
findex = 1;
if (data.BeginsWith("Date: ") || data.LocateSubstring("\nDate: ", &findex))
{
if (findex > 1)
{
findex ++;
}
JIndex eindex = findex;
if (data.LocateNextSubstring("\n", &eindex) && (eindex > findex + 1))
{
text += data.GetSubstring(findex, eindex - 1);
text += "\n";
}
}
findex = 1;
const JCharacter* kSubjectStr = "Subject: ";
if (data.BeginsWith("Subject: ") || data.LocateSubstring("\nSubject: ", &findex))
{
if (findex > 1)
{
findex ++;
}
JIndex eindex = findex;
if (data.LocateNextSubstring("\n", &eindex) && (eindex > findex + 1))
{
text += data.GetSubstring(findex, eindex - 1);
text += "\n";
}
}
WriteTextString(&text, GMIMEHeader());
}
}