void
GDBPlot2DCommand::UpdateRange
(
const JIndex curveIndex,
const JInteger min,
const JInteger max
)
{
CMPlot2DCommand::UpdateRange(curveIndex, min, max);
JString cmd = "set print pretty off\nset print array off\n"
"set print repeats 0\nset width 0\n";
for (JInteger i=min; i<=max; i++)
{
cmd += "print ";
cmd += GetDirector()->GetXExpression(curveIndex, i);
cmd.AppendCharacter('\n');
cmd += "print ";
cmd += GetDirector()->GetYExpression(curveIndex, i);
cmd.AppendCharacter('\n');
}
SetCommand(cmd);
}
JString
CMLink::Build1DArrayExpressionForCFamilyLanguage
(
const JCharacter* origExpr,
const JInteger index
)
{
JString expr = origExpr;
const JString indexStr(index, 0); // must use floating point conversion
if (expr.Contains("$i"))
{
const JCharacter* map[] =
{
"i", indexStr.GetCString()
};
(JGetStringManager())->Replace(&expr, map, sizeof(map));
}
else
{
if (expr.GetFirstCharacter() != '(' ||
expr.GetLastCharacter() != ')')
{
expr.PrependCharacter('(');
expr.AppendCharacter(')');
}
expr.AppendCharacter('[');
expr += indexStr;
expr.AppendCharacter(']');
}
return expr;
}
JString
CMLink::Build2DArrayExpressionForCFamilyLanguage
(
const JCharacter* origExpr,
const JInteger rowIndex,
const JInteger colIndex
)
{
JString expr = origExpr;
const JBoolean usesI = expr.Contains("$i"); // row
const JBoolean usesJ = expr.Contains("$j"); // col
const JString iStr(rowIndex, 0); // must use floating point conversion
const JString jStr(colIndex, 0); // must use floating point conversion
// We have to do both at the same time because otherwise we lose a $.
if (usesI || usesJ)
{
const JCharacter* map[] =
{
"i", iStr.GetCString(),
"j", jStr.GetCString()
};
(JGetStringManager())->Replace(&expr, map, sizeof(map));
}
if (!usesI || !usesJ)
{
if (expr.GetFirstCharacter() != '(' ||
expr.GetLastCharacter() != ')')
{
expr.PrependCharacter('(');
expr.AppendCharacter(')');
}
if (!usesI)
{
expr.AppendCharacter('[');
expr += iStr;
expr.AppendCharacter(']');
}
if (!usesJ)
{
expr.AppendCharacter('[');
expr += jStr;
expr.AppendCharacter(']');
}
}
return expr;
}
JString
JPrepArgForExec
(
const JCharacter* arg
)
{
JString str = arg;
JBoolean quote = kJFalse;
const JSize length = str.GetLength();
for (JIndex i=length; i>=1; i--)
{
const JCharacter c = str.GetCharacter(i);
if (c == '"' || c == '\'' || c == '\\' || c == ';')
{
str.InsertSubstring("\\", i);
}
else if (isspace(c))
{
quote = kJTrue;
}
}
if (quote)
{
str.PrependCharacter('"');
str.AppendCharacter('"');
}
return str;
}
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;
}
void
CBFileNode::OpenComplementFile()
const
{
JString fullName;
if (GetFullName(&fullName))
{
const CBTextFileType type = (CBGetPrefsManager())->GetFileType(fullName);
if (type == kCBHTMLFT || type == kCBXMLFT)
{
(JXGetWebBrowser())->ShowFileContent(fullName);
}
else
{
(CBGetDocumentManager())->OpenComplementFile(fullName, type);
}
}
else
{
JString msg = "Unable to find complement of \"";
msg += GetFileName();
msg.AppendCharacter('"');
(JGetUserNotification())->ReportError(msg);
}
}
JString
XDLink::Build1DArrayExpression
(
const JCharacter* origExpr,
const JInteger index
)
{
JString expr = origExpr;
const JString indexStr(index, 0); // must use floating point conversion
if (expr.Contains("$i"))
{
// double literal $'s
for (JIndex i=expr.GetLength()-1; i>=1; i--)
{
if (expr.GetCharacter(i) == '$' &&
expr.GetCharacter(i+1) != 'i')
{
expr.InsertCharacter('$', i);
}
}
const JCharacter* map[] =
{
"i", indexStr.GetCString()
};
(JGetStringManager())->Replace(&expr, map, sizeof(map));
}
else
{
expr.AppendCharacter('[');
expr += indexStr;
expr.AppendCharacter(']');
}
return expr;
}
JString
JCombineRootAndSuffix
(
const JCharacter* root,
const JCharacter* suffix
)
{
JString name = root;
if (suffix[0] != '.')
{
name.AppendCharacter('.');
}
name.Append(suffix);
return name;
}
void
JXTextMenu::SetToPopupChoice
(
const JBoolean isPopup,
const JIndex initialChoice
)
{
const JString& origTitle = GetTitleText();
if (isPopup && !origTitle.IsEmpty() && !origTitle.EndsWith(":"))
{
JString newTitle = origTitle;
newTitle.AppendCharacter(':');
SetTitle(newTitle, NULL, kJFalse);
}
JXMenu::SetToPopupChoice(isPopup, initialChoice);
}
void
JXFileHistoryMenu::AddFile
(
const JCharacter* origPath,
const JCharacter* name
)
{
if (JStringEmpty(origPath) || JStringEmpty(name))
{
return;
}
JString path = origPath;
path.PrependCharacter(' ');
path.AppendCharacter(' ');
AddItem(name, path);
}
void
JDirInfo::AppendRegex
(
const JCharacter* origStr,
JString* regexStr
)
{
JIndex i;
JString str = origStr;
// Convert wildcard multiples (*) to regex multiples (.*)
// and wildcard singles (?) to regex singles (.)
for (i = str.GetLength(); i>=1; i--)
{
const JCharacter c = str.GetCharacter(i);
if (c == '*')
{
str.InsertSubstring(".", i);
}
else if (c == '?')
{
str.SetCharacter(i, '.');
}
else if (JRegex::NeedsBackslashToBeLiteral(c))
{
str.InsertSubstring("\\", i);
}
}
// Add instructions that it must match the entire file name.
str.PrependCharacter('^');
str.AppendCharacter('$');
// append to regexStr
if (!regexStr->IsEmpty())
{
regexStr->AppendCharacter('|');
}
*regexStr += str;
}
JString
JXFileInput::GetTextForChooseFile()
const
{
JString text = GetText();
if (text.IsEmpty() && HasBasePath())
{
text = itsBasePath;
JAppendDirSeparator(&text);
}
if (text.EndsWith(ACE_DIRECTORY_SEPARATOR_STR))
{
text.AppendCharacter('*');
}
if (!text.IsEmpty() && JIsRelativePath(text) && HasBasePath())
{
text = JCombinePathAndName(itsBasePath, text);
}
return text;
}
JString
JCombinePathAndName
(
const JCharacter* path,
const JCharacter* name
)
{
assert( !JStringEmpty(path) );
assert( !JStringEmpty(name) );
JString file = path;
if (file.GetLastCharacter() != ACE_DIRECTORY_SEPARATOR_CHAR &&
name[0] != ACE_DIRECTORY_SEPARATOR_CHAR)
{
file.AppendCharacter(ACE_DIRECTORY_SEPARATOR_CHAR);
}
file += name;
JCleanPath(&file);
return file;
}
JString
JConvertToRelativePath
(
const JCharacter* origPath,
const JCharacter* origBase
)
{
// Check that they are both absolute paths.
assert( origPath != NULL && origPath[0] == '/' &&
origBase != NULL && origBase[0] == '/' );
// Remove extra directory separators
// and make sure that base ends with one.
JString path = origPath;
JCleanPath(&path);
JString base = origBase;
JCleanPath(&base);
JAppendDirSeparator(&base);
// Find and remove the matching directories at the beginning.
// The while loop backs us up so we only consider complete directory names.
JBoolean hadTDS = kJTrue;
if (path.GetLastCharacter() != '/')
{
path.AppendCharacter('/');
hadTDS = kJFalse;
}
JSize matchLength = JCalcMatchLength(path, base);
if (!hadTDS)
{
path.RemoveSubstring(path.GetLength(), path.GetLength());
}
while (base.GetCharacter(matchLength) != '/')
{
matchLength--;
}
assert( matchLength >= 1 );
if (matchLength == 1)
{
return path;
}
if (matchLength > path.GetLength())
{
base.RemoveSubstring(matchLength, matchLength);
matchLength--;
}
path.RemoveSubstring(1, matchLength);
base.RemoveSubstring(1, matchLength);
if (base.IsEmpty())
{
path.Prepend("./");
return path;
}
// The number of remaining directory separators in base
// is the number of levels to go up.
JSize upCount = 0;
const JSize baseLength = base.GetLength();
for (JIndex i=1; i<=baseLength; i++)
{
if (base.GetCharacter(i) == '/')
{
upCount++;
path.Prepend("../");
}
}
assert( upCount > 0 );
return path;
}
void
CMVarNode::ConvertToBase()
{
itsCanConvertBaseFlag = kJFalse;
if (itsOrigValue != NULL && !itsOrigValue->IsEmpty())
{
JTree* tree;
if (itsValue != *itsOrigValue && GetTree(&tree))
{
tree->BroadcastChange(this);
}
itsValue = *itsOrigValue;
}
if (itsBase == 0 || itsIsPointerFlag)
{
return; // avoid constructing matchList
}
JArray<JIndexRange> matchList;
if (valuePattern.Match(itsValue, &matchList))
{
JString vStr = itsValue.GetSubstring(matchList.GetElement(2));
JUInt v;
itsCanConvertBaseFlag = JI2B(
vStr.ConvertToUInt(&v, vStr.GetFirstCharacter() == '0' ? 8 : 10) &&
(itsBase != 1 || (0 <= v && v <= 255)));
if (itsCanConvertBaseFlag)
{
// save value for when base reset to "default"
itsOrigValue = new JString(itsValue);
assert( itsOrigValue != NULL );
// replace only the value, preserving whatever else is there
if (itsBase == 1)
{
assert( 0 <= v && v <= 255 );
vStr = JString(v, JString::kBase16, kJTrue);
vStr += " '";
JBoolean found = kJFalse;
for (JIndex i=0; i<kSpecialCharCount; i++)
{
if (JCharacter(v) == kSpecialCharInfo[i].c)
{
vStr += kSpecialCharInfo[i].s;
found = kJTrue;
}
}
if (!found)
{
vStr.AppendCharacter(v);
}
vStr.AppendCharacter('\'');
}
else
{
vStr = JString(v, (JString::Base) itsBase, kJTrue);
if (itsBase == 8)
{
vStr.PrependCharacter('0');
}
}
JIndexRange r;
itsValue.ReplaceSubstring(matchList.GetElement(2), vStr, &r);
JTree* tree;
if (GetTree(&tree))
{
tree->BroadcastChange(this);
}
}
}
}
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
LLDBGetAssembly::HandleSuccess
(
const JString& cmdData
)
{
LLDBLink* link = dynamic_cast<LLDBLink*>(CMGetLink());
if (link == NULL)
{
return;
}
lldb::SBCommandInterpreter interp = link->GetDebugger()->GetCommandInterpreter();
if (!interp.IsValid())
{
return;
}
const CMLocation& loc = (GetDirector())->GetDisassemblyLocation();
const JString cmd = "disassemble -n " + JPrepArgForExec(loc.GetFunctionName());
lldb::SBCommandReturnObject result;
interp.HandleCommand(cmd, result);
JPtrArray<JString> addrList(JPtrArrayT::kDeleteAll);
JString instText;
if (result.IsValid() && result.Succeeded() && result.HasResult())
{
std::istringstream input(result.GetOutput());
JString line, s;
JSize maxOffsetLength = 0;
while (!input.eof() && !input.fail())
{
line = JReadLine(input);
JIndex i;
if (line.LocateSubstring(":", &i) && i < line.GetLength())
{
s = line.GetSubstring(1, i-1);
if (s.BeginsWith("->") && s.GetLength() > 2)
{
s = s.GetSubstring(3, s.GetLength());
}
s.TrimWhitespace();
addrList.Append(s);
JIndexRange r;
if (offsetPattern.Match(s, &r))
{
maxOffsetLength = JMax(maxOffsetLength, r.GetLength());
}
if (!instText.IsEmpty())
{
instText.AppendCharacter('\n');
}
s = line.GetSubstring(i+1, line.GetLength());
s.TrimWhitespace();
instText.Append(s);
}
}
const JSize count = addrList.GetElementCount();
for (JIndex i=1; i<count; i++)
{
JString* s = addrList.NthElement(i);
JIndexRange r;
if (offsetPattern.Match(*s, &r))
{
const JSize pad = maxOffsetLength - r.GetLength();
for (JIndex j=0; j<pad; j++)
{
s->InsertCharacter('0', r.first+2);
}
}
}
}
(GetDirector())->DisplayDisassembly(&addrList, instText);
}
JString
XDLink::Build2DArrayExpression
(
const JCharacter* origExpr,
const JInteger rowIndex,
const JInteger colIndex
)
{
JString expr = origExpr;
const JBoolean usesI = expr.Contains("$i"); // row
const JBoolean usesJ = expr.Contains("$j"); // col
const JString iStr(rowIndex, 0); // must use floating point conversion
const JString jStr(colIndex, 0); // must use floating point conversion
// We have to do both at the same time because otherwise we lose a $.
if (usesI || usesJ)
{
// double literal $'s
for (JIndex i=expr.GetLength()-1; i>=1; i--)
{
if (expr.GetCharacter(i) == '$' &&
expr.GetCharacter(i+1) != 'i' &&
expr.GetCharacter(i+1) != 'j')
{
expr.InsertCharacter('$', i);
}
}
const JCharacter* map[] =
{
"i", iStr.GetCString(),
"j", jStr.GetCString()
};
(JGetStringManager())->Replace(&expr, map, sizeof(map));
}
if (!usesI || !usesJ)
{
if (expr.GetFirstCharacter() != '(' ||
expr.GetLastCharacter() != ')')
{
expr.PrependCharacter('(');
expr.AppendCharacter(')');
}
if (!usesI)
{
expr.AppendCharacter('[');
expr += iStr;
expr.AppendCharacter(']');
}
if (!usesJ)
{
expr.AppendCharacter('[');
expr += jStr;
expr.AppendCharacter(']');
}
}
return expr;
}
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();
}
JString
GMessageHeader::DecodeMIMEWord
(
const JBoolean qType,
JString* header,
const JIndexRange range
)
{
JString temp;
JIndex findex = range.first;
// first ? '=?'
JBoolean ok = header->LocateNextSubstring("?", &findex);
if (!ok)
{
return temp;
}
findex++;
// second ? '?Q'
ok = header->LocateNextSubstring("?", &findex);
if (!ok)
{
return temp;
}
// third ? 'Q?'
findex++;
ok = header->LocateNextSubstring("?", &findex);
if (!ok || (findex > range.last))
{
return temp;
}
JIndex endIndex = findex + 1;
// final ? '?='
ok = header->LocateNextSubstring("?", &endIndex);
if (!ok || (endIndex > range.last))
{
return temp;
}
// so the encoded text is between findex and endIndex.
if (qType)
{
JIndex dIndex = findex + 1;
while (dIndex < endIndex)
{
JCharacter c = header->GetCharacter(dIndex);
if (c == '=')
{
JString hex = header->GetSubstring(dIndex + 1, dIndex + 2);
hex.Prepend("0x");
JInteger hexVal;
if (hex.ConvertToInteger(&hexVal))
{
c = (JCharacter)hexVal;
temp.AppendCharacter(c);
dIndex += 3;
}
}
else if (c == '_')
{
temp.AppendCharacter(' ');
dIndex++;
}
else
{
temp.AppendCharacter(c);
dIndex++;
}
}
}
else
{
if (findex + 1 > header->GetLength())
{
return temp;
}
if (endIndex - 1 < findex + 1)
{
return temp;
}
temp = header->GetSubstring(findex + 1, endIndex - 1);
const std::string s(temp.GetCString(), temp.GetLength());
std::istringstream is(s);
std::ostringstream os;
JDecodeBase64(is, os);
temp = os.str();
}
return temp;
}
