void
GDBPlot2DCommand::HandleSuccess
(
const JString& data
)
{
JArray<JFloat>* x = GetX();
JArray<JFloat>* y = GetY();
if ((GetLastResult()).BeginsWith("error,msg=\"No symbol"))
{
x->RemoveAll();
y->RemoveAll();
return;
}
const JIndex count = x->GetElementCount();
JIndex i;
JIndexRange r;
JArray<JIndexRange> matchRange1, matchRange2;
JString v1, v2;
for (i=1; i<=count; i++)
{
if (!prefixPattern.MatchAfter(data, r, &matchRange1))
{
break;
}
r = matchRange1.GetElement(1);
if (!prefixPattern.MatchAfter(data, r, &matchRange2))
{
break;
}
r = matchRange2.GetElement(1);
v1 = data.GetSubstring(matchRange1.GetElement(2));
v1.TrimWhitespace();
v2 = data.GetSubstring(matchRange2.GetElement(2));
v2.TrimWhitespace();
JFloat x1, y1;
if (!v1.ConvertToFloat(&x1) ||
!v2.ConvertToFloat(&y1))
{
break;
}
x->SetElement(i, x1);
y->SetElement(i, y1);
}
if (i <= count)
{
const JSize delta = count - (i-1);
x->RemoveNextElements(count - delta + 1, delta);
y->RemoveNextElements(count - delta + 1, delta);
}
}
JBoolean
JSplitPathAndName
(
const JCharacter* fullName,
JString* path,
JString* name
)
{
assert( !JStringEmpty(fullName) );
JString pathAndName = fullName;
assert( pathAndName.GetLastCharacter() != ACE_DIRECTORY_SEPARATOR_CHAR );
JIndex i;
if (pathAndName.LocateLastSubstring(ACE_DIRECTORY_SEPARATOR_STR, &i))
{
*path = pathAndName.GetSubstring(1,i);
*name = pathAndName.GetSubstring(i+1, pathAndName.GetLength());
JCleanPath(path);
return kJTrue;
}
else
{
*path = JGetCurrentDirectory();
*name = pathAndName;
return kJFalse;
}
}
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;
}
void
GMMIMEParser::ParseContentParameters
(
const JString& text,
JPtrArray<JString>* strings
)
{
JString tmp = text;
JString* str;
JIndex findex;
while (tmp.LocateSubstring("=", &findex) && findex > 1)
{
str = new JString(tmp.GetSubstring(1, findex - 1));
assert(str != NULL);
str->TrimWhitespace();
str->ToLower();
strings->Append(str);
tmp.RemoveSubstring(1, findex);
tmp.TrimWhitespace();
// now we need to get the corresponding value.
// we need to check for quotes first.
JIndex index = 1;
if (tmp.GetLength() > 1 && tmp.GetCharacter(1) == '\"')
{
FindStringEnd(tmp, &index);
str = new JString(tmp.GetSubstring(2, index-1));
assert(str != NULL);
if (tmp.LocateSubstring(";", &findex))
{
tmp.RemoveSubstring(1, findex);
}
}
else if (tmp.LocateSubstring(";", &index))
{
str = new JString();
assert(str != NULL);
if (index > 1)
{
*str = tmp.GetSubstring(1, index-1);
}
tmp.RemoveSubstring(1, index);
}
else
{
str = new JString(tmp);
assert(str != NULL);
}
str->TrimWhitespace();
strings->Append(str);
tmp.TrimWhitespace();
}
}
inline JBoolean
jTranslateLocalToRemote1
(
const JString& localPath,
const JCharacter* mountDev,
const JCharacter* mountDir,
JBoolean* found,
JString* host,
JString* remotePath
)
{
if (!JIsSamePartition(localPath, mountDir))
{
return kJFalse;
}
const JString dev = mountDev;
JIndex hostEndIndex;
if (dev.LocateSubstring(":/", &hostEndIndex) && hostEndIndex > 1)
{
*host = dev.GetSubstring(1, hostEndIndex-1);
#ifdef _J_CYGWIN
if (host->GetLength() == 1 &&
'A' <= host->GetFirstCharacter() && host->GetFirstCharacter() <= 'Z')
{
*host = JGetHostName();
*remotePath = localPath;
JCleanPath(remotePath);
*found = kJTrue;
return kJTrue;
}
#endif
jGetFullHostName(host);
*remotePath = dev.GetSubstring(hostEndIndex+1, dev.GetLength());
JAppendDirSeparator(remotePath);
// use JIndexRange to allow empty
JIndexRange r(strlen(mountDir)+1, localPath.GetLength());
*remotePath += localPath.GetSubstring(r);
JCleanPath(remotePath);
*found = kJTrue;
}
return kJTrue;
}
JXPSPrintSetupDialog*
CBPSPrinter::CreatePrintSetupDialog
(
const Destination destination,
const JCharacter* printCmd,
const JCharacter* fileName,
const JBoolean collate,
const JBoolean bw
)
{
assert( itsCBPrintSetupDialog == NULL );
if (itsFontSize == kUnsetFontSize)
{
JString fontName;
CBGetPrefsManager()->GetDefaultFont(&fontName, &itsFontSize);
JArray<JIndexRange> matchList;
if (nxmRegex.Match(fontName, &matchList))
{
const JString hStr = fontName.GetSubstring(matchList.GetElement(2));
const JBoolean ok = hStr.ConvertToUInt(&itsFontSize);
assert( ok );
itsFontSize--;
}
}
itsCBPrintSetupDialog =
CBPSPrintSetupDialog::Create(destination, printCmd, fileName,
collate, bw, itsFontSize,
(CBGetPTTextPrinter())->WillPrintHeader());
return itsCBPrintSetupDialog;
}
JError
JCreateDirectory
(
const JCharacter* dirName,
const mode_t mode
)
{
if (JDirectoryExists(dirName))
{
return JSetPermissions(dirName, mode);
}
JString path = dirName;
JCleanPath(&path);
JAppendDirSeparator(&path);
JString dir;
JIndex slashIndex = 2;
while (path.LocateNextSubstring("/", &slashIndex))
{
dir = path.GetSubstring(1, slashIndex);
if (!JDirectoryExists(dir))
{
const JError err = JMkDir(dir, mode);
if (!err.OK())
{
return err;
}
}
slashIndex++; // move past the slash we found
}
return JNoError();
}
JBoolean
JDirInfo::BuildRegexFromWildcardFilter
(
const JCharacter* origFilterStr,
JString* regexStr
)
{
regexStr->Clear();
JString filterStr = origFilterStr;
filterStr.TrimWhitespace();
if (filterStr.IsEmpty())
{
return kJFalse;
}
JIndex index;
while (filterStr.LocateSubstring(" ", &index))
{
assert( index > 1 );
const JString str = filterStr.GetSubstring(1, index-1);
AppendRegex(str, regexStr);
filterStr.RemoveSubstring(1, index);
filterStr.TrimWhitespace();
}
assert( !filterStr.IsEmpty() );
AppendRegex(filterStr, regexStr);
return kJTrue;
}
JBoolean
CBHTMLStyler::GetXMLStyle
(
const JString& tagName,
JFontStyle* style
)
{
JIndex i;
if (!tagName.LocateLastSubstring(":", &i))
{
return kJFalse;
}
// tag name takes priority over XML namespaces
JString s;
if (i < tagName.GetLength())
{
s = tagName.GetSubstring(i+1, tagName.GetLength());
if (GetWordStyle(s, style))
{
itsLatestTagName = s;
return kJTrue;
}
}
do
{
s = tagName.GetSubstring(1, i);
if (GetWordStyle(s, style))
{
itsLatestTagName = s;
return kJTrue;
}
i--; // skip past the one we found
}
while (itsLatestTagName.LocatePrevSubstring(":", &i));
return kJFalse;
}
JBoolean
SplitClassNameAndArgs
(
const JString& str,
JString* name,
JString* args
)
{
JIndex i;
const JBoolean hasArgs = str.LocateSubstring("(", &i);
if (hasArgs && 1 < i && i < str.GetLength())
{
*name = str.GetSubstring(1, i-1);
*args = str.GetSubstring(i+1, str.GetLength());
name->TrimWhitespace();
args->TrimWhitespace();
return kJTrue;
}
else if (hasArgs && i == 1)
{
cerr << "No class name in " << str << endl;
name->Clear();
args->Clear();
return kJFalse;
}
else
{
if (hasArgs)
{
*name = str.GetSubstring(1, i-1);
}
else
{
*name = str;
}
name->TrimWhitespace();
args->Clear();
return kJTrue;
}
}
void
GMMIMEParser::CleanParmValPair
(
const JString& parmValPair,
JString* parm,
JString* val
)
{
JIndex findex;
JBoolean ok = parmValPair.LocateSubstring(":", &findex);
JSize length = parmValPair.GetLength();
if (ok && (findex > 1) && (findex < length))
{
*parm = parmValPair.GetSubstring(1, findex - 1);
*val = parmValPair.GetSubstring(findex + 1, length);
JIndex index = 1;
while (index <= val->GetLength())
{
JCharacter c = val->GetCharacter(index);
if (c == '\"')
{
FindStringEnd(*val, &index);
index++;
}
else if (c == '(')
{
Remove822Comment(val, index);
}
else
{
if (c == '\n')
{
val->SetCharacter(index, ' ');
}
index++;
}
}
}
}
inline void
jGetFullHostName
(
JString* host
)
{
if (!host->Contains("."))
{
const JString localhost = JGetHostName();
JIndex dotIndex;
if (localhost.LocateSubstring(".", &dotIndex))
{
*host += localhost.GetSubstring(dotIndex, localhost.GetLength());
}
}
}
void
GFGLink::ParseClass
(
GFGClass* list,
const JCharacter* filename,
const JCharacter* classname
)
{
JBoolean ok = kJTrue;
if (itsCTagsProcess == NULL)
{
ok = StartCTags();
}
if (ok)
{
itsClassList = list;
itsCurrentClass = classname;
itsCurrentFile = filename;
JConvertToAbsolutePath(filename, "", &itsCurrentFile);
itsCurrentFile.Print(*itsOutputLink);
*itsOutputLink << std::endl;
itsOutputLink->flush();
JBoolean found = kJFalse;
JString result = JReadUntil(itsInputFD, kDelimiter, &found);
if (found)
{
JIndex findex;
while ( result.LocateSubstring("\n", &findex) &&
findex > 1)
{
JString line = result.GetSubstring(1, findex - 1);
result.RemoveSubstring(1, findex);
ParseLine(line);
}
Broadcast(FileParsed());
}
}
}
JBoolean
SVNInfoLog::GetBaseRevision
(
JString* rev
)
{
JString s;
JArray<JIndexRange> matchList;
if (GetSelection(&s) && revisionPattern.Match(s, &matchList))
{
*rev = s.GetSubstring(matchList.GetElement(2));
return kJTrue;
}
else
{
rev->Clear();
return kJFalse;
}
}
JBoolean
GMMIMEParser::GetTextSegment
(
const JIndex index,
JString* text,
TextFormat* format,
JString* charset
)
{
assert(itsTextInfo != NULL);
assert(index <= itsTextInfo->GetEntryCount());
JString name = itsTextInfo->GetEntry(index).GetFullName();
std::ifstream is(name);
if (is.good())
{
JReadAll(is, text);
if (name.EndsWith(kPlainType))
{
*format = kPlain;
}
else if (name.EndsWith(kHTMLType))
{
*format = kHTML;
}
JIndex findex;
JBoolean ok = name.LocateLastSubstring(".", &findex);
assert(ok);
name.RemoveSubstring(findex, name.GetLength());
ok = name.LocateLastSubstring(".", &findex);
if (findex < name.GetLength())
{
*charset = name.GetSubstring(findex + 1, name.GetLength());
}
}
else
{
itsIsSuccessful = kJFalse;
}
return itsIsSuccessful;
}
JBoolean
GAddressBookMgr::GetNextRecord
(
JString& line,
JString& record,
std::istream& is
)
{
if (line.IsEmpty())
{
return kJFalse;
}
JIndex index;
if (line.LocateSubstring("\t", &index))
{
if (index > 1)
{
record = line.GetSubstring(1, index - 1);
line.RemoveSubstring(1, index);
return kJTrue;
}
line.RemoveSubstring(1, 1);
return kJFalse;
}
record = line;
if (record.Contains("(") && !record.Contains(")"))
{
JString temp = JReadUntil(is, ')');
record += temp + ")";
line = JReadLine(is);
if (!line.IsEmpty() && (line.GetFirstCharacter() == '\t'))
{
line.RemoveSubstring(1, 1);
}
}
else
{
line.Clear();
}
return kJTrue;
}
void
JFunctionWithVar::DrawString
(
const JExprRenderer& renderer,
const JCoordinate left,
const JCoordinate midline,
const JSize fontSize,
const JString& str
)
const
{
JCoordinate x = left;
const JCharacter* greekPrefix = JPGetGreekCharPrefixString();
const JSize greekPrefixLength = JPGetGreekCharPrefixLength();
JString s = str;
JIndex greekIndex;
while (s.LocateSubstring(greekPrefix, &greekIndex) &&
greekIndex < s.GetLength() - greekPrefixLength + 1)
{
if (greekIndex > 1)
{
const JString s1 = s.GetSubstring(1, greekIndex-1);
renderer.DrawString(x, midline, fontSize, s1);
x += renderer.GetStringWidth(fontSize, s1);
}
const JCharacter c = s.GetCharacter(greekIndex + greekPrefixLength);
renderer.DrawGreekCharacter(x, midline, fontSize, c);
x += renderer.GetGreekCharWidth(fontSize, c);
s.RemoveSubstring(1, greekIndex + greekPrefixLength);
}
if (!s.IsEmpty())
{
renderer.DrawString(x, midline, fontSize, s);
}
}
JSize
JFunctionWithVar::GetStringWidth
(
const JExprRenderer& renderer,
const JSize fontSize,
const JString& str
)
const
{
JSize w = 0;
const JCharacter* greekPrefix = JPGetGreekCharPrefixString();
const JSize greekPrefixLength = JPGetGreekCharPrefixLength();
JString s = str;
JIndex greekIndex;
while (s.LocateSubstring(greekPrefix, &greekIndex) &&
greekIndex < s.GetLength() - greekPrefixLength + 1)
{
if (greekIndex > 1)
{
const JString s1 = s.GetSubstring(1, greekIndex-1);
w += renderer.GetStringWidth(fontSize, s1);
}
const JCharacter c = s.GetCharacter(greekIndex + greekPrefixLength);
w += renderer.GetGreekCharWidth(fontSize, c);
s.RemoveSubstring(1, greekIndex + greekPrefixLength);
}
if (!s.IsEmpty())
{
w += renderer.GetStringWidth(fontSize, s);
}
return w;
}
void
GDBGetProgramName::HandleSuccess
(
const JString& data
)
{
JString fileName;
JArray<JIndexRange> matchList;
if (fileNamePattern.Match(data, &matchList) ||
osxNamePattern.Match(data, &matchList))
{
fileName = data.GetSubstring(matchList.GetElement(2));
}
else
{
(CMGetLink())->Log("GDBGetProgramName failed to match");
}
// CMLink has to broadcast SymbolsLoaded regardless of whether or not
// we get what we expect from gdb.
dynamic_cast<GDBLink*>(CMGetLink())->SaveProgramName(fileName);
}
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
SMTPMessage::ReadReturnValue()
{
JString line;
JBoolean ok = itsLink->GetNextMessage(&line);
assert(ok);
if (itsCurrentMode != kDataHeader)
{
GMGetSMTPDebugDir()->AddText(line);
}
if ((itsCurrentMode != kStartUp) && (itsCurrentMode != kDataHeader))
{
JInteger value;
JIndex findex;
ok = line.LocateSubstring(" ", &findex);
if (ok && (findex > 1))
{
JString number = line.GetSubstring(1, findex - 1);
if (number.IsInteger())
{
number.ConvertToInteger(&value);
}
else
{
ok = kJFalse;
}
}
else
{
ok = kJFalse;
}
if (!ok)
{
const JIndex kDashIndex = 4;
if (line.GetCharacter(kDashIndex) == '-')
{
// this is a multiline response.
return;
}
}
if (!ok || (value != kOKValue))
{
if (!itsIsTryingToQuit)
{
const JCharacter* map[] =
{
"err", line
};
const JString msg = JGetString("SMTPERROR", map, sizeof(map));
JGetUserNotification()->ReportError(msg);
}
itsIsFinished = kJTrue;
Broadcast(SendFailure());
if (!itsIsTryingToQuit)
{
itsDeleteTask = new JXTimerTask(1000,kJTrue);
assert( itsDeleteTask != NULL );
itsDeleteTask->Start();
ListenTo(itsDeleteTask);
}
return;
}
}
if (itsCurrentMode < kTo)
{
itsCurrentMode++;
}
else if (itsCurrentMode == kTo)
{
if (itsCurrentIndex < itsToNames->GetElementCount())
{
itsCurrentIndex++;
}
else if (itsCcNames->GetElementCount() != 0)
{
itsCurrentMode = kCc;
itsCurrentIndex = 1;
}
else if (itsBccNames->GetElementCount() != 0)
{
itsCurrentMode = kBcc;
itsCurrentIndex = 1;
}
else
{
itsCurrentMode = kDataHeader;
}
}
else if (itsCurrentMode == kCc)
{
if (itsCurrentIndex < itsCcNames->GetElementCount())
{
itsCurrentIndex++;
}
else if (itsBccNames->GetElementCount() != 0)
{
itsCurrentMode = kBcc;
itsCurrentIndex = 1;
}
else
{
itsCurrentMode = kDataHeader;
}
}
else if (itsCurrentMode == kBcc)
{
if (itsCurrentIndex < itsBccNames->GetElementCount())
{
itsCurrentIndex++;
}
else
{
itsCurrentMode = kDataHeader;
}
}
else if (itsCurrentMode == kData)
{
itsIsFinished = kJTrue;
Broadcast(MessageSent());
GMGetSMTPDebugDir()->AddText("\n-------------------------------------\n");
if (!itsIsTryingToQuit)
{
itsDeleteTask = new JXTimerTask(1000,kJTrue);
assert( itsDeleteTask != NULL );
itsDeleteTask->Start();
ListenTo(itsDeleteTask);
}
return;
}
else
{
itsCurrentMode++;
}
SendNextData();
}
void
GMMIMEParser::ParseContentType
(
const JString& val,
GMIMEHeader* header
)
{
// we first need to determine the type. this will be found before the
// first '/' which will be followed by the subtype.
JString tVal = val;
tVal.TrimWhitespace();
JSize length = tVal.GetLength();
JString type;
JIndex findex;
if (tVal.LocateSubstring("/", &findex) && (findex > 1))
{
type = tVal.GetSubstring(1, findex - 1);
tVal.RemoveSubstring(1, findex);
tVal.TrimWhitespace();
type.ToLower();
header->SetType(type);
}
else
{
return;
}
// now we need to determine the subtype
JString subType;
length = tVal.GetLength();
JBoolean found = kJFalse;
JIndex index;
if (tVal.LocateSubstring(";", &index))
{
subType = tVal.GetSubstring(1, index - 1);
tVal.RemoveSubstring(1, index);
}
else
{
subType = tVal;
tVal.Clear();
}
tVal.TrimWhitespace();
subType.TrimWhitespace();
subType.ToLower();
header->SetSubType(subType);
if (tVal.IsEmpty())
{
return;
}
JPtrArray<JString> strings(JPtrArrayT::kDeleteAll);
ParseContentParameters(tVal, &strings);
JSize count = strings.GetElementCount();
for (JIndex i = 1; i <= count; i += 2)
{
JString* str = strings.NthElement(i);
if (type == kTextType)
{
if (*str == "charset")
{
if (strings.IndexValid(i+1))
{
str = strings.NthElement(i+1);
header->SetCharSet(*str);
}
}
}
else if (type == kMultipartType)
{
if (*str == "boundary")
{
if (strings.IndexValid(i+1))
{
str = strings.NthElement(i+1);
header->SetBoundary(*str);
}
}
}
if ((type == kAppType) ||
(type == kImageType) ||
(type == kTextType))
{
if (*str == "name")
{
if (strings.IndexValid(i+1))
{
str = strings.NthElement(i+1);
if (str->LocateLastSubstring("/", &findex))
{
str->RemoveSubstring(1, findex);
}
if (str->LocateLastSubstring("\\", &findex))
{
str->RemoveSubstring(1, findex);
}
header->SetFileName(*str);
}
}
}
}
}
JBoolean
CBCtagsUser::HasExuberantCtags()
{
if (itsHasExuberantCtagsFlag == kUntested)
{
itsHasExuberantCtagsFlag = kFailure;
// this hack is required on Linux kernel 2.3.x (4/19/2000)
j_sig_func* origHandler = signal(SIGCHLD, emptyHandler);
pid_t pid;
#if defined _J_SUNOS
pid_t* ppid = NULL;
#else
pid_t* ppid = &pid;
#endif
int fromFD;
JError err = JExecute(kCheckVersionCmd, ppid,
kJIgnoreConnection, NULL,
kJCreatePipe, &fromFD,
kJTossOutput, NULL);
if (err.OK())
{
JString vers;
JReadAll(fromFD, &vers);
JArray<JIndexRange> matchList;
if (versionPattern.Match(vers, &matchList))
{
matchList.RemoveElement(1);
const JSize count = matchList.GetElementCount();
JString s;
for (JIndex i=1; i<=count; i++)
{
JUInt v = 0;
const JIndexRange r = matchList.GetElement(i);
if (!r.IsEmpty())
{
s = vers.GetSubstring(r);
while (!isdigit(s.GetFirstCharacter()))
{
s.RemoveSubstring(1, 1);
}
const JBoolean ok = s.ConvertToUInt(&v);
assert( ok );
}
if (v > kMinVersion[i-1] ||
(i == count && v == kMinVersion[i-1]))
{
itsHasExuberantCtagsFlag = kSuccess;
break;
}
else if (v < kMinVersion[i-1])
{
break;
}
}
}
}
if (origHandler != SIG_ERR)
{
signal(SIGCHLD, origHandler);
}
}
return JI2B( itsHasExuberantCtagsFlag == kSuccess );
}
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());
}
}
void
GenerateCode
(
istream& input,
ostream& output,
const JString& stringPath,
const JString& formName,
const JString& tagName,
const JString& userTopEnclVarName,
JPtrArray<JString>* objTypes,
JPtrArray<JString>* objNames
)
{
JIndex i;
// width
input >> ws;
JString line = JReadUntilws(input);
assert( line == kFormWidthMarker );
JSize formWidth;
input >> formWidth;
// height
input >> ws;
line = JReadUntilws(input);
assert( line == kFormHeightMarker );
JSize formHeight;
input >> formHeight;
// object count (marker contains whitespace)
input >> ws;
line = JReadUntil(input, ':') + ":";
assert( line == kFormObjCountMarker );
JSize itemCount;
input >> itemCount;
// create window
const JString topEnclFrameName = tagName + "_Frame";
const JString topEnclApName = tagName + "_Aperture";
JString topEnclVarName;
if (tagName == kDefaultDelimTag)
{
topEnclVarName = kDefTopEnclVarName;
output << " JXWindow* window = new JXWindow(this, ";
output << formWidth << ',' << formHeight;
output << ", \"\");" << endl;
output << " assert( window != NULL );" << endl;
output << endl;
}
else
{
assert( !userTopEnclVarName.IsEmpty() );
topEnclVarName = userTopEnclVarName;
output << " const JRect ";
topEnclFrameName.Print(output);
output << " = ";
topEnclVarName.Print(output);
output << "->GetFrame();" << endl;
output << " const JRect ";
topEnclApName.Print(output);
output << " = ";
topEnclVarName.Print(output);
output << "->GetAperture();" << endl;
output << " ";
topEnclVarName.Print(output);
output << "->AdjustSize(" << formWidth << " - ";
topEnclApName.Print(output);
output << ".width(), " << formHeight << " - ";
topEnclApName.Print(output);
output << ".height());" << endl;
output << endl;
}
// We need to calculate the enclosure for each object. Since objects
// are drawn in the order added, an object must come after its enclosure
// in the list in order to be visible.
JArray<JRect> rectList(10);
JArray<JBoolean> isInstanceVar(10);
// This array is used to send the options to ApplyOptions.
// It does not own the pointers that it contains.
JPtrArray<JString> optionValues(JPtrArrayT::kForgetAll, kOptionCount);
for (i=1; i<=kOptionCount; i++)
{
optionValues.Append(NULL);
}
// generate code for each object
JStringManager stringMgr;
JIndex objCount = 1;
for (i=1; i<=itemCount; i++)
{
// check for start-of-object
input >> ws;
line = JReadLine(input);
assert( line == kBeginObjLine );
// object class
JString flClass = JReadLine(input);
RemoveIdentifier(kObjClassMarker, &flClass);
// object type
JString flType = JReadLine(input);
RemoveIdentifier(kObjTypeMarker, &flType);
// object frame
input >> ws;
line = JReadUntilws(input);
assert( line == kObjRectMarker );
JCoordinate x,y,w,h;
input >> x >> y >> w >> h >> ws;
const JRect frame(y, x, y+h, x+w);
rectList.AppendElement(frame);
// box type
JString boxType = JReadLine(input);
RemoveIdentifier(kObjBoxTypeMarker, &boxType);
// colors
input >> ws;
line = JReadUntilws(input);
assert( line == kObjColorsMarker );
JString col1 = JReadUntilws(input);
optionValues.SetElement(kCol1Index, &col1, JPtrArrayT::kForget);
JString col2 = JReadUntilws(input);
optionValues.SetElement(kCol2Index, &col2, JPtrArrayT::kForget);
// label info
JString lAlign = JReadLine(input);
RemoveIdentifier(kObjLAlignMarker, &lAlign);
JString lStyle = JReadLine(input);
RemoveIdentifier(kObjLStyleMarker, &lStyle);
JString lSize = JReadLine(input);
RemoveIdentifier(kObjLSizeMarker, &lSize);
JString lColor = JReadLine(input);
RemoveIdentifier(kObjLColorMarker, &lColor);
JString label = JReadLine(input);
RemoveIdentifier(kObjLabelMarker, &label);
// shortcuts
JString shortcuts = JReadLine(input);
RemoveIdentifier(kObjShortcutMarker, &shortcuts);
optionValues.SetElement(kShortcutsIndex, &shortcuts, JPtrArrayT::kForget);
// resizing (ignored)
JIgnoreLine(input);
// gravity
input >> ws;
line = JReadUntilws(input);
assert( line == kObjGravityMarker );
const JString nwGravity = JReadUntilws(input);
const JString seGravity = JReadUntilws(input);
// variable name
JBoolean isLocal = kJFalse;
JString* varName = new JString(JReadLine(input));
assert( varName != NULL );
RemoveIdentifier(kObjNameMarker, varName);
if (varName->IsEmpty())
{
isInstanceVar.AppendElement(kJFalse);
GetTempVarName(tagName, varName, *objNames);
isLocal = kJTrue;
}
else if (varName->GetFirstCharacter() == '(' &&
varName->GetLastCharacter() == ')')
{
isInstanceVar.AppendElement(kJFalse);
isLocal = kJTrue;
*varName = varName->GetSubstring(2, varName->GetLength()-1);
}
else if (varName->GetFirstCharacter() == '<' &&
varName->GetLastCharacter() == '>')
{
isInstanceVar.AppendElement(kJFalse);
*varName = varName->GetSubstring(2, varName->GetLength()-1);
}
else
{
isInstanceVar.AppendElement(kJTrue);
}
objNames->Append(varName);
// callback (ignored)
JIgnoreLine(input);
// callback argument
JString cbArg = JReadLine(input);
RemoveIdentifier(kObjCBArgMarker, &cbArg);
JString cbArgExtra;
do
{
cbArgExtra = JReadLine(input);
cbArgExtra.TrimWhitespace();
}
while (!cbArgExtra.IsEmpty());
// don't bother to generate code for initial box
// if it is FL_BOX, FLAT_BOX, FL_COL1
if (i==1 && flClass == "FL_BOX" && flType == "FLAT_BOX" && col1 == "FL_COL1")
{
rectList.RemoveElement(objCount);
isInstanceVar.RemoveElement(objCount);
objNames->DeleteElement(objCount);
continue;
}
// check for errors -- safe since we have read in entire object
JString hSizing, vSizing;
if (!ParseGravity(nwGravity, &hSizing, &vSizing))
{
cerr << "Illegal sizing specification ";
cerr << nwGravity << ',' << seGravity;
cerr << " for '" << *varName << '\'' << endl;
rectList.RemoveElement(objCount);
isInstanceVar.RemoveElement(objCount);
objNames->DeleteElement(objCount);
continue;
}
if (*varName == topEnclVarName)
{
cerr << "Cannot use reserved name '" << topEnclVarName << '\'' << endl;
rectList.RemoveElement(objCount);
isInstanceVar.RemoveElement(objCount);
objNames->DeleteElement(objCount);
continue;
}
// get the object's enclosure
JIndex enclIndex;
JString enclName;
JRect localFrame = frame;
if (GetEnclosure(rectList, objCount, &enclIndex))
{
enclName = *(objNames->NthElement(enclIndex));
const JRect enclFrame = rectList.GetElement(enclIndex);
localFrame.Shift(-enclFrame.topLeft());
}
else
{
enclName = topEnclVarName;
}
// get the class name and additional arguments
JString* className = new JString;
assert( className != NULL );
objTypes->Append(className);
JString argList;
if (!GetConstructor(flClass, flType, &label, className, &argList))
{
cerr << "Unsupported class: " << flClass << ", " << flType << endl;
rectList.RemoveElement(objCount);
isInstanceVar.RemoveElement(objCount);
objNames->DeleteElement(objCount);
objTypes->DeleteElement(objCount);
continue;
}
// generate the actual code
const JBoolean needCreate = NeedsCreateFunction(*className);
output << " ";
if (isLocal)
{
className->Print(output);
output << "* ";
}
varName->Print(output);
output << " =" << endl;
output << " ";
if (!needCreate)
{
output << "new ";
}
className->Print(output);
if (needCreate)
{
output << "::Create";
}
output << '(';
if (!argList.IsEmpty())
{
argList.Print(output);
if (argList.GetLastCharacter() != ',')
{
output << ',';
}
output << ' ';
}
if (!cbArg.IsEmpty())
{
cbArg.Print(output);
if (cbArg.GetLastCharacter() != ',')
{
output << ',';
}
output << ' ';
}
if ((*className == "JXStaticText" && cbArg.IsEmpty()) ||
NeedsStringArg(*className))
{
JString id = *varName;
id += "::";
id += formName;
id += "::";
id += tagName; // last since it is almost always the same
output << "JGetString(\"";
id.Print(output);
output << "\"), ";
stringMgr.SetElement(id, label, JPtrArrayT::kDelete);
}
enclName.Print(output);
output << ',' << endl;
output << " JXWidget::";
hSizing.Print(output);
output << ", JXWidget::";
vSizing.Print(output);
output << ", " << localFrame.left << ',' << localFrame.top << ", ";
output << localFrame.width() << ',' << localFrame.height() << ");" << endl;
output << " assert( ";
varName->Print(output);
output << " != NULL );" << endl;
ApplyOptions(output, *className, formName, tagName, *varName, optionValues,
lSize, lStyle, lColor, &stringMgr);
if (*className == "JXStaticText" && cbArg.IsEmpty() &&
!lAlign.Contains("FL_ALIGN_TOP") && localFrame.height() <= 20)
{
output << " ";
varName->Print(output);
output << "->SetToLabel();" << endl;
}
output << endl;
// now we know the object is valid
objCount++;
}
// write string database
JString dbFileName = stringPath + formName;
if (tagName != kDefaultDelimTag)
{
dbFileName += kCustomTagMarker + tagName;
}
dbFileName += "_layout";
if (stringMgr.GetElementCount() > 0)
{
JEditVCS(dbFileName);
ofstream dbOutput(dbFileName);
stringMgr.WriteFile(dbOutput);
}
else
{
JRemoveVCS(dbFileName);
JRemoveFile(dbFileName);
}
// reset enclosure size
if (tagName != kDefaultDelimTag)
{
output << " ";
topEnclVarName.Print(output);
output << "->SetSize(";
topEnclFrameName.Print(output);
output << ".width(), ";
topEnclFrameName.Print(output);
output << ".height());" << endl;
output << endl;
}
// throw away temporary variables
objCount--;
assert( objCount == isInstanceVar.GetElementCount() );
assert( objCount == objTypes->GetElementCount() );
assert( objCount == objNames->GetElementCount() );
for (i=objCount; i>=1; i--)
{
if (!isInstanceVar.GetElement(i))
{
objTypes->DeleteElement(i);
objNames->DeleteElement(i);
}
}
}
JBoolean
JGetUserMountPointList
(
JMountPointList* list,
JMountState* state
)
{
JProcess* p;
int outFD;
const JError err = JProcess::Create(&p, kMountCmd,
kJIgnoreConnection, NULL,
kJCreatePipe, &outFD,
kJIgnoreConnection, NULL);
if (!err.OK())
{
if (state != NULL)
{
jdelete state->mountCmdOutput;
state->mountCmdOutput = NULL;
}
return kJFalse;
}
JString mountData;
JReadAll(outFD, &mountData);
p->WaitUntilFinished();
const JBoolean success = p->SuccessfulFinish();
jdelete p;
p = NULL;
if (!success)
{
if (state != NULL)
{
jdelete state->mountCmdOutput;
state->mountCmdOutput = NULL;
}
return kJFalse;
}
if (state != NULL && state->mountCmdOutput != NULL &&
mountData == *(state->mountCmdOutput))
{
return kJFalse;
}
list->CleanOut();
if (state != NULL && state->mountCmdOutput == NULL)
{
state->mountCmdOutput = jnew JString(mountData);
assert( state->mountCmdOutput != NULL );
}
else if (state != NULL)
{
*(state->mountCmdOutput) = mountData;
}
JIndexRange r;
JArray<JIndexRange> matchList;
JString options;
ACE_stat stbuf;
while (theLinePattern.MatchAfter(mountData, r, &matchList))
{
r = matchList.GetFirstElement();
options = mountData.GetSubstring(matchList.GetElement(4));
if (options.Contains("nobrowse"))
{
continue;
}
JString* path = jnew JString(mountData.GetSubstring(matchList.GetElement(3)));
assert( path != NULL );
JString* devicePath = jnew JString(mountData.GetSubstring(matchList.GetElement(2)));
assert( devicePath != NULL );
const JMountType type =
JGetUserMountPointType(*path, *devicePath, "");
if (type == kJUnknownMountType ||
ACE_OS::stat(*path, &stbuf) != 0)
{
jdelete path;
jdelete devicePath;
continue;
}
JFileSystemType fsType = kOtherFSType;
if (options.Contains("msdos"))
{
fsType = kVFATType;
}
list->AppendElement(JMountPoint(path, type, stbuf.st_dev, devicePath, fsType));
}
return kJTrue;
}
void
JXTextMenuData::ParseMenuItemStr
(
JString* text,
JBoolean* isActive,
JBoolean* hasSeparator,
JBoolean* isCheckbox,
JBoolean* isRadio,
JString* shortcuts,
JString* nmShortcut,
JString* id
)
const
{
*isActive = kJTrue;
*hasSeparator = kJFalse;
*isCheckbox = kJFalse;
*isRadio = kJFalse;
shortcuts->Clear();
nmShortcut->Clear();
id->Clear();
JIndex opIndex;
while (text->LocateLastSubstring("%", &opIndex))
{
const JSize textLength = text->GetLength();
if (opIndex == textLength) // can't assert() because of menu_strings file
{
text->RemoveSubstring(textLength, textLength);
continue;
}
JString op = text->GetSubstring(opIndex+1, textLength);
text->RemoveSubstring(opIndex, textLength);
const JCharacter opc = op.GetFirstCharacter();
if (opc == 'd')
{
*isActive = kJFalse;
}
else if (opc == 'l')
{
*hasSeparator = kJTrue;
}
else if (opc == 'b' || opc == 'B')
{
*isCheckbox = kJTrue;
}
else if (opc == 'r' || opc == 'R')
{
*isCheckbox = kJTrue;
*isRadio = kJTrue;
}
else if (opc == 'h' && shortcuts->IsEmpty())
{
*shortcuts = op.GetSubstring(2, op.GetLength());
shortcuts->TrimWhitespace();
}
else if (opc == 'h')
{
cerr << "Tried to use %h more than once in '" << *text << '\'' << endl;
}
else if (opc == 'k' && nmShortcut->IsEmpty())
{
*nmShortcut = op.GetSubstring(2, op.GetLength());
nmShortcut->TrimWhitespace();
}
else if (opc == 'k')
{
cerr << "Tried to use %k more than once in '" << *text << '\'' << endl;
}
else if (opc == 'i' && id->IsEmpty())
{
*id = op.GetSubstring(2, op.GetLength());
id->TrimWhitespace();
}
else if (opc == 'i')
{
cerr << "Tried to use %i more than once in '" << *text << '\'' << endl;
}
else
{
cerr << "Unsupported option %" << op << " in '" << *text << '\'' << endl;
}
}
text->TrimWhitespace();
}
void
JXTextMenuData::InsertMenuItems
(
const JIndex startIndex,
const JCharacter* menuStr,
const JCharacter* idNamespace
)
{
JStringManager* strMgr = JGetStringManager();
JSize currIndex = startIndex;
JString str = menuStr;
JBoolean done = kJFalse;
JString itemText, shortcuts, nmShortcut, id, strID, id1;
while (!done)
{
JIndex sepIndex;
const JBoolean found = str.LocateSubstring("|", &sepIndex);
if (found)
{
assert( sepIndex > 1 );
itemText = str.GetSubstring(1, sepIndex-1);
str.RemoveSubstring(1, sepIndex);
}
else
{
itemText = str;
done = kJTrue;
}
JBoolean isActive, hasSeparator, isCheckbox, isRadio;
ParseMenuItemStr(&itemText, &isActive, &hasSeparator,
&isCheckbox, &isRadio, &shortcuts, &nmShortcut, &id);
if (!JStringEmpty(idNamespace) && !id.IsEmpty())
{
strID = id;
strID += "::";
strID += idNamespace;
JString* itemText1;
if (strMgr->GetElement(strID, &itemText1) && itemText1 != NULL)
{
itemText = *itemText1;
JBoolean isActive1, hasSeparator1, isCheckbox1, isRadio1;
ParseMenuItemStr(&itemText, &isActive1, &hasSeparator1,
&isCheckbox1, &isRadio1, &shortcuts, &nmShortcut, &id1);
}
}
InsertItem(currIndex, itemText, isCheckbox, isRadio, shortcuts, nmShortcut, id);
if (!isActive)
{
DisableItem(currIndex);
}
if (hasSeparator)
{
ShowSeparatorAfter(currIndex);
}
currIndex++;
}
}
int
main
(
int argc,
char* argv[]
)
{
// find the configuration files
if (!FindConfigFile(&classMapFile) ||
!FindConfigFile(&optionMapFile) ||
!FindConfigFile(&needFontListFile) ||
!FindConfigFile(&needStringListFile) ||
!FindConfigFile(&needCreateListFile))
{
return 1;
}
// parse the command line options
JString inputName, codePath, stringPath, codeSuffix, headerSuffix;
JString postCmd;
JPtrArray<JString> userFormList(JPtrArrayT::kDeleteAll); // empty => generate all forms
JPtrArray<JString> backupList(JPtrArrayT::kDeleteAll); // forms that have been backed up
GetOptions(argc, argv, &inputName, &codePath, &stringPath,
&codeSuffix, &headerSuffix, &postCmd, &userFormList);
// generate each requested form
JBoolean changed = kJFalse;
ifstream input(inputName);
while (!input.eof() && !input.fail())
{
const JString line = JReadLine(input);
if (line == kBeginFormLine)
{
// get form name
JString formName = JReadLine(input);
RemoveIdentifier(kFormNameMarker, &formName);
// look for custom tag
const JSize formNameLength = formName.GetLength();
JString tagName = kDefaultDelimTag;
JString enclName;
JIndex tagMarkerIndex;
if (formName.LocateSubstring(kCustomTagMarker, &tagMarkerIndex) &&
tagMarkerIndex <= formNameLength - kCustomTagMarkerLength)
{
tagName = formName.GetSubstring(
tagMarkerIndex + kCustomTagMarkerLength, formNameLength);
formName.RemoveSubstring(tagMarkerIndex, formNameLength);
// get enclosure name
const JSize tagNameLength = tagName.GetLength();
JIndex enclMarkerIndex;
if (tagName.LocateSubstring(kCustomTagMarker, &enclMarkerIndex) &&
enclMarkerIndex <= tagNameLength - kCustomTagMarkerLength)
{
enclName = tagName.GetSubstring(
enclMarkerIndex + kCustomTagMarkerLength, tagNameLength);
tagName.RemoveSubstring(enclMarkerIndex, tagNameLength);
}
// report errors
if (tagName != kDefaultDelimTag)
{
if (enclName.IsEmpty())
{
cerr << formName << ", " << tagName;
cerr << ": no enclosure specified" << endl;
}
}
else if (!enclName.IsEmpty() && enclName != kDefTopEnclVarName)
{
cerr << formName << ", " << tagName;
cerr << ": not allowed to specify enclosure other than ";
cerr << kDefTopEnclVarName << endl;
}
}
if (ShouldGenerateForm(formName, userFormList))
{
GenerateForm(input, formName, tagName, enclName,
codePath, stringPath, codeSuffix, headerSuffix, &backupList);
changed = kJTrue;
}
}
}
if (changed && !postCmd.IsEmpty())
{
const JError err = JExecute(postCmd, NULL);
err.ReportIfError();
}
return 0;
}
