Ejemplo n.º 1
0
GMMIMEParser::GMMIMEParser
	(
	JString*			data,
	const JCharacter*	rootDir
	)
	:
	itsTextSegments(NULL),
	itsTextInfo(NULL),
	itsAttachInfo(NULL),
	itsIsSuccessful(kJTrue),
	itsTextFileIndex(100),
	itsData(data)
{
	std::istrstream input(data->GetCString(), data->GetLength());

	JError err = JCreateTempDirectory(rootDir, kAttachDirPrefix, &itsAttachDir);
	if (!err.OK())
		{
		itsIsSuccessful	= kJFalse;
		err.ReportIfError();
		}

	err = JCreateTempDirectory(rootDir, kTextDirPrefix, &itsTextDir);
	if (!err.OK())
		{
		itsIsSuccessful	= kJFalse;
		err.ReportIfError();
		}

	if (itsIsSuccessful)
		{
		if (!JDirInfo::Create(itsTextDir, &itsTextInfo))
			{
			itsIsSuccessful	= kJFalse;
			err.ReportIfError();
			}
		if (!JDirInfo::Create(itsAttachDir, &itsAttachInfo))
			{
			itsIsSuccessful	= kJFalse;
			err.ReportIfError();
			}
		}

	if (itsIsSuccessful)
		{
		itsTextInfo->ShowHidden(kJTrue);
		itsAttachInfo->ShowHidden(kJTrue);
		Parse(input, itsData->GetLength());
		}
}
Ejemplo n.º 2
0
JBoolean
SyGExec
	(
	const JCharacter*	cmd,
	const JBoolean		report
	)
{
	JString errOutput;
	const JError err = JRunProgram(cmd, &errOutput);
	if (!err.OK() && report)
		{
		(JGetUserNotification())->ReportError(err.GetMessage());
		}
	return err.OK();
}
Ejemplo n.º 3
0
JBoolean
GFGLink::StartCTags()
{
	assert( itsCTagsProcess == NULL );

	JString cmd = kCTagsCmd;

	int toFD, fromFD;
	const JError err = JProcess::Create(&itsCTagsProcess, cmd,
										kJCreatePipe, &toFD,
										kJCreatePipe, &fromFD,
										kJAttachToFromFD, NULL);
	if (err.OK())
		{
		itsOutputLink = jnew JOutPipeStream(toFD, kJTrue);
		assert( itsOutputLink != NULL );

		itsInputFD = fromFD;
		assert( itsInputFD != ACE_INVALID_HANDLE );

		ListenTo(itsCTagsProcess);

		return kJTrue;
		}
	else
		{
		(JGetStringManager())->ReportError(kUnableToStartCTagsID, err);
		return kJFalse;
		}
}
JError
JDirInfo::GoTo
	(
	const JCharacter* origDirName
	)
{
	JString dirName;
	if (JStringEmpty(origDirName) ||
		!JConvertToAbsolutePath(origDirName, NULL, &dirName))
		{
		return JBadPath(origDirName);
		}

	if (JSameDirEntry(dirName, *itsCWD))
		{
		Update();
		return JNoError();
		}
	JAppendDirSeparator(&dirName);

	const JString origCWD = *itsCWD;

	*itsCWD = dirName;
	const JError err = BuildInfo();
	if (err.OK())
		{
		Broadcast(PathChanged());
		}
	else
		{
		*itsCWD = origCWD;
		}

	return err;
}
Ejemplo n.º 5
0
void
SVNListBase::RefreshContent()
{
	if (itsProcess != NULL)
		{
		JProcess* p = itsProcess;
		itsProcess  = NULL;

		p->Kill();
		delete p;

		DeleteLinks();
		}
	else
		{
		itsSavedSelection->CleanOut();
		JTableSelection& s = GetTableSelection();
		JTableSelectionIterator iter(&s);
		JPoint cell;
		while (iter.Next(&cell))
			{
			const JString* line = itsLineList->NthElement(cell.y);
			itsSavedSelection->InsertSorted(new JString(ExtractRelativePath(*line)));
			}
		}

	itsDisplayState = SaveDisplayState();
	itsLineList->CleanOut();

	int outFD, errFD;
	JError err = JNoError();
	if ((GetDirector())->HasPath())
		{
		err = JProcess::Create(&itsProcess, GetPath(), itsCmd,
							   kJIgnoreConnection, NULL,
							   kJCreatePipe, &outFD,
							   kJCreatePipe, &errFD);
		}
	else	// working with URL
		{
		err = JProcess::Create(&itsProcess, itsCmd,
							   kJIgnoreConnection, NULL,
							   kJCreatePipe, &outFD,
							   kJCreatePipe, &errFD);
		}

	if (err.OK())
		{
		itsProcess->ShouldDeleteWhenFinished();
		ListenTo(itsProcess);
		(GetDirector())->RegisterActionProcess(this, itsProcess, itsRefreshRepoFlag,
											   itsRefreshStatusFlag, itsReloadOpenFilesFlag);

		SetConnection(outFD, errFD);
		}
	else
		{
		err.ReportIfError();
		}
}
JMemoryManager*
JMemoryManager::Instance()
{
	// Guarantees access is only through this function
	static JMemoryManager* manager = NULL;

	if (manager == NULL)
		{
		theConstructingFlag = kJTrue;
		manager = new(__FILE__, __LINE__) JMemoryManager;
		assert(manager != NULL);

		// Create the error printer proxy to do the printing work.
		// Construction of the error printer must take place here, after
		// the manager is fully constructed; the recursive call to Instance
		// is harmless.
		manager->itsErrorPrinter = new(__FILE__, __LINE__) JMMErrorPrinter;
		assert(manager->itsErrorPrinter != NULL);

		const JCharacter* pipeName = getenv("JMM_PIPE");
		if (!JStringEmpty(pipeName))
			{
			manager->itsErrorStream = new(__FILE__, __LINE__) JMMDebugErrorStream;
			assert(manager->itsErrorStream != NULL);
			}

		theConstructingFlag = kJFalse;
		manager->EmptyStacks();

		// do it here since it calls delete as well as new

		if (!JStringEmpty(pipeName))
			{
			manager->ConnectToDebugger(pipeName);
			ACE_Object_Manager::at_exit(NULL, ::JMMHandleACEExit, NULL);

			// If we create the file when we actually need it, it
			// re-constructs JStringManager.

			JString fileName;
			const JError err = JCreateTempFile(&fileName);
			if (err.OK())
				{
				theInternalFlag = kJTrue;

				manager->itsExitStatsFileName = new JString(fileName);
				assert( manager->itsExitStatsFileName != NULL );

				theInternalFlag = kJFalse;
				}
			else
				{
				cerr << "Failed to create exit stats file:" << endl;
				cerr << err.GetMessage() << endl;
				}
			}
		}

	return manager;
}
CMChooseProcessDialog::CMChooseProcessDialog
	(
	JXDirector*		supervisor,
	const JBoolean	attachToSelection,
	const JBoolean	stopProgram
	)
	:
	JXDialogDirector(supervisor, kJTrue),
	itsAttachToSelectionFlag(attachToSelection),
	itsStopProgramFlag(stopProgram)
{
	BuildWindow();

	int inFD;
	const JError err = JExecute(kCmdStr, NULL,
								kJIgnoreConnection, NULL,
								kJCreatePipe, &inFD);
	if (err.OK())
		{
		JString text;
		JReadAll(inFD, &text);
		text.TrimWhitespace();
		itsText->SetText(text);
		}

	ListenTo(this);
}
void
JXFLInputBase::Receive
	(
	JBroadcaster*	sender,
	const Message&	message
	)
{
	if (sender == itsHistoryMenu && message.Is(JXMenu::kItemSelected))
		{
		const JString origStr = GetText();
		const JString newStr  = itsHistoryMenu->GetItemText(message);
		SetText(newStr);

		const JError err = Apply();
		if (err.OK())
			{
			itsHistoryMenu->AddString(newStr);
			}
		else
			{
			SetText(origStr);
			err.ReportIfError();
			}
		}

	else
		{
		JXInputField::Receive(sender, message);
		}
}
Ejemplo n.º 9
0
JError
JXImage::CreateFromJPEG
	(
	JXDisplay*			display,
	JXColormap*			colormap,
	const JCharacter*	fileName,
	JXImage**			image,
	const JBoolean		allowApproxColors
	)
{
	*image = new JXImage(display, colormap);
	assert( *image != NULL );

	const JBoolean saveApprox = colormap->WillApproximateColors();
	const JBoolean savePre    = colormap->WillPreemptivelyApproximateColors();
	colormap->ShouldApproximateColors(allowApproxColors);
	colormap->ShouldPreemptivelyApproximateColors(kJTrue);

	const JError err = (**image).ReadJPEG(fileName);

	colormap->ShouldApproximateColors(saveApprox);
	colormap->ShouldPreemptivelyApproximateColors(savePre);

	if (!err.OK())
		{
		delete *image;
		*image = NULL;
		}
	return err;
}
Ejemplo n.º 10
0
void
GMMIMEParser::WriteAttachment
	(
	const JString&		data,
	const GMIMEHeader&	header
	)
{
	JString filename = header.GetFileName();
	if (filename.IsEmpty())
		{
		const JError err = JCreateTempFile(itsAttachDir, NULL, &filename);
		if (!err.OK())
			{
			err.ReportIfError();
			return;
			}
		}
	else
		{
		filename = JCombinePathAndName(itsAttachDir, filename);
		}

	AdjustAttachmentName(header, &filename);
	std::ofstream os(filename);
	if (header.GetEncoding() == kBase64Encoding)
		{
		std::istrstream is(data.GetCString(), data.GetLength());
		JDecodeBase64(is, os);
		}
	else
		{
		data.Print(os);
		}
}
JBoolean
JXRegexReplaceInput::InputValid()
{
	if (!JXInputField::InputValid())
		{
		return kJFalse;
		}
	else
		{
		const JString& text = GetText();

		if (!IsRequired() && text.IsEmpty())
			{
			return kJTrue;
			}

		const JError err = itsTestRegex->SetReplacePattern(text);
		if (err.OK())
			{
			return kJTrue;
			}
		else
			{
			err.ReportIfError();
			return kJFalse;
			}
		}
}
JBoolean
JDirInfo::ForceUpdate()
{
	if (JDirectoryExists(*itsCWD))
		{
		Broadcast(ContentsWillBeUpdated());

		const JError err = BuildInfo();
		if (err.OK())
			{
			return kJTrue;
			}
		}

	if (itsSwitchIfInvalidFlag)
		{
		JString path;
		if (!JGetHomeDirectory(&path) || !OKToCreate(path))
			{
			path = JGetRootDirectory();
			}
		GoTo(path);
		}
	else
		{
		itsIsValidFlag    = kJFalse;
		itsIsWritableFlag = kJFalse;
		itsDirEntries->CleanOut();
		itsVisEntries->CleanOut();
		itsAlphaEntries->CleanOut();
		}

	return kJFalse;
}
Ejemplo n.º 13
0
void
SVNInfoLog::Execute
	(
	const JCharacter* cmd
	)
{
	(JXGetApplication())->DisplayBusyCursor();

	pid_t pid;
	int outFD, errFD;
	JError err = JExecute(cmd, &pid,
						  kJIgnoreConnection, NULL,
						  kJCreatePipe, &outFD,
						  kJCreatePipe, &errFD);
	if (!err.OK())
		{
		err.ReportIfError();
		return;
		}

	const JFontStyle red(kJTrue, kJFalse, 0, kJFalse, (GetColormap())->GetRedColor());

	JString text;
	JReadAll(errFD, &text);
	SetCurrentFontStyle(red);
	Paste(text);

	JReadAll(outFD, &text);
	SetCurrentFontStyle(JFontStyle());
	Paste(text);
}
Ejemplo n.º 14
0
JError
JSimpleProcess::Create
(
    JSimpleProcess**			process,
    const JPtrArray<JString>&	argList,
    const JBoolean				deleteWhenFinished
)
{
    pid_t childPID;
    int errFD;
    const JError err = JExecute(argList, &childPID,
                                kJIgnoreConnection, NULL,
                                kJTossOutput, NULL,
                                kJCreatePipe, &errFD);
    if (err.OK())
    {
        *process = new JSimpleProcess(childPID, errFD, deleteWhenFinished);
        assert( *process != NULL );
    }
    else
    {
        *process = NULL;
    }

    return err;
}
JError
JExecute
	(
	const JCharacter*		workingDirectory,
	const JCharacter*		argv[],
	const JSize				size,
	pid_t*					childPID,
	const JExecuteAction	toAction,
	int*					toFD,
	const JExecuteAction	fromAction,
	int*					fromFD,
	const JExecuteAction	errAction,
	int*					errFD
	)
{
	const JString origPath = JGetCurrentDirectory();
	JError err             = JChangeDirectory(workingDirectory);
	if (err.OK())
		{
		err = JExecute(argv, size, childPID, toAction, toFD, fromAction, fromFD, errAction, errFD);
		JChangeDirectory(origPath);
		}

	return err;
}
JBoolean
SVNPropertiesList::RemoveNextProperty()
{
	if (!itsRemovePropertyCmdList->IsEmpty())
		{
		const JString cmd = *(itsRemovePropertyCmdList->FirstElement());
		itsRemovePropertyCmdList->DeleteElement(1);

		JSimpleProcess* p;
		const JError err = JSimpleProcess::Create(&p, cmd, kJTrue);
		if (err.OK())
			{
			itsProcessList->Append(p);
			ListenTo(p);
			return kJTrue;
			}
		else
			{
			err.ReportIfError();
			return kJFalse;
			}
		}
	else
		{
		if ((GetDirector())->OKToStartActionProcess())
			{
			RefreshContent();
			}

		(GetDirector())->ScheduleStatusRefresh();
		return kJTrue;
		}
}
JBoolean
SVNPropertiesList::CreateProperty1()
{
	assert( itsCreatePropertyDialog != NULL );

	const JString prop = JPrepArgForExec(itsCreatePropertyDialog->GetString());
	const JString file = JPrepArgForExec(itsFullName);

	JSubstitute subst;
	subst.DefineVariable("prop_name", prop);
	subst.DefineVariable("file_name", file);

	JString cmd = kPropEditCmd;
	subst.Substitute(&cmd);

	JSimpleProcess* p;
	const JError err = JSimpleProcess::Create(&p, cmd, kJTrue);
	if (err.OK())
		{
		itsProcessList->Append(p);
		ListenTo(p);
		return kJTrue;
		}
	else
		{
		err.ReportIfError();
		return kJFalse;
		}
}
Ejemplo n.º 18
0
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();
}
JError
JFormatPartition
	(
	const JCharacter*	path,
	const JCharacter*	type,
	JProcess**			process
	)
{
	JBoolean writable, isTop;
	JString device;
	if (JIsMounted(path, &writable, &isTop, &device) && isTop)
		{
		JMount(path, kJFalse, kJTrue);
		if (!JIsMounted(path))
			{
			const JCharacter* argv[] = { "xterm", "-T", "Format disk", "-n", "Format disk",
										 "-e", "/sbin/mkfs", "-t", type, "-c", device, NULL };
			const JError err = JProcess::Create(process, argv, sizeof(argv));
			if (err.OK())
				{
				JThisProcess::Ignore(*process);
				}
			return err;
			}
		}

	*process = NULL;
	return JAccessDenied(path);
}
void
CBFileListTable::ScanDirectory
	(
	const JString&				origPath,
	const JBoolean				recurse,
	const JPtrArray<JString>&	allSuffixList,
	CBSymbolList*				symbolList,
	CBCTree*					cTree,
	CBJavaTree*					javaTree,
	JProgressDisplay&			pg
	)
{
	JString path;
	JDirInfo* info;
	if (!JGetTrueName(origPath, &path) ||
		!JDirInfo::Create(path, &info))
		{
		return;
		}

	const JSize count = info->GetEntryCount();
	for (JIndex i=1; i<=count; i++)
		{
		const JDirEntry& entry = info->GetEntry(i);

		// If it's a directory, recurse.

		if (entry.IsDirectory() && recurse &&
			!entry.IsLink() && !JIsVCSDirectory(entry.GetName()))
			{
			ScanDirectory(entry.GetFullName(), recurse,
						  allSuffixList, symbolList,
						  cTree, javaTree,
						  pg);
			}

		// If it's a file ending in one of the suffixes, parse it.

		else if (entry.IsFile())
			{
			JString trueName = entry.GetFullName();
			time_t modTime   = entry.GetModTime();
			if (entry.IsWorkingLink())
				{
				const JBoolean ok = JGetTrueName(entry.GetFullName(), &trueName);
				assert( ok );
				const JError err = JGetModificationTime(trueName, &modTime);
				assert( err.OK() );
				}

			ParseFile(trueName, allSuffixList, modTime,
					  symbolList, cTree, javaTree);
			}

		pg.IncrementProgress();
		}

	delete info;
}
Ejemplo n.º 21
0
JVCSType
JGetVCSType
	(
	const JCharacter*	path,
	const JBoolean		deepInspection
	)
{
	JString p = path, n;
	if (JFileExists(path) ||
		!JDirectoryExists(path))	// broken link
		{
		JSplitPathAndName(path, &p, &n);
		}

	// can't read newer versions

	JString vcsDir = JCombinePathAndName(p, kSubversionDirName);
	vcsDir         = JCombinePathAndName(vcsDir, kSubversionFileName);
	if (JFileExists(vcsDir))
		{
		if (!deepInspection)
			{
			return kJSVNType;
			}

		JSize size;
		const JError err = JGetFileLength(vcsDir, &size);
		if (err.OK() && size > 10)
			{
			return kJSVNType;
			}
		}

	vcsDir = JCombinePathAndName(p, kCVSDirName);
	if (JDirectoryExists(vcsDir))
		{
		return kJCVSType;
		}

	vcsDir = JCombinePathAndName(p, kSCCSDirName);
	if (JDirectoryExists(vcsDir))
		{
		return kJSCCSType;
		}

	// check git & new svc last, since they need to search directory tree up to root

	if (JSearchGitRoot(p, &n))
	{
		return kJGitType;
	}
	else if (!deepInspection && jSearchVCSRoot(p, kSubversionDirName, &n))
	{
		return kJSVNType;
	}

	return kJUnknownVCSType;
}
JError
JDirInfo::BuildInfo()
{
	if (!JDirectoryReadable(*itsCWD))
		{
		return JAccessDenied(*itsCWD);
		}

	const JString origDir = JGetCurrentDirectory();

	JError err = JChangeDirectory(*itsCWD);
	if (!err.OK())
		{
		return err;
		}

	// clear old information

	itsDirEntries->CleanOut();

	// update instance variables

	JStripTrailingDirSeparator(itsCWD);		// keep Windows happy

	ACE_stat stbuf;
	ACE_OS::stat(*itsCWD, &stbuf);
	itsIsValidFlag    = kJTrue;
	itsIsWritableFlag = JDirectoryWritable(*itsCWD);
	itsModTime        = stbuf.st_mtime;
	itsStatusTime     = stbuf.st_ctime;

	JAppendDirSeparator(itsCWD);

	// process files in the directory

	JLatentPG pg(itsContentRegex == NULL ? 100 : 10);
	if (itsPG != NULL)
		{
		pg.SetPG(itsPG, kJFalse);
		}
	pg.VariableLengthProcessBeginning("Scanning directory...", kJTrue, kJFalse);

	BuildInfo1(pg);

	pg.ProcessFinished();

	err = JChangeDirectory(origDir);
	assert_ok( err );

	ApplyFilters(kJFalse);
	return JNoError();
}
JBoolean
JXFSBindingTable::ExtractInputData
	(
	const JPoint& cell
	)
{
	assert( itsTextInput != NULL );

	const JString& s = itsTextInput->GetText();
	JBoolean ok      = itsTextInput->InputValid();

	if (ok && cell.x == kPatternColumn)
		{
		const JFSBinding* b    = itsBindingList->GetBinding(cell.y);
		const JBoolean changed = JI2B(b->GetPattern() != s);

		if (JFSBinding::WillBeRegex(s))
			{
			const JError err = itsTestRegex->SetPattern(s);
			err.ReportIfError();
			ok = err.OK();
			}

		JIndex newIndex;
		if (ok && changed && itsBindingList->SetPattern(cell.y, s, &newIndex))
			{
			JTableSelection& s = GetTableSelection();
			s.ClearSelection();
			s.SelectCell(newIndex, kPatternColumn);
			Broadcast(DataChanged());
			}
		else if (ok && changed)
			{
			ok = kJFalse;

			const JCharacter* map[] =
				{
				"pattern", s.GetCString()
				};
			const JString msg = JGetString(kPatternUsedID, map, sizeof(map));
			(JGetUserNotification())->ReportError(msg);
			}
		}

	else if (ok && cell.x == kCommandColumn &&
			 itsBindingList->SetCommand(cell.y, s))
		{
		Broadcast(DataChanged());
		}

	return ok;
}
Ejemplo n.º 24
0
void
JStringManager::ReportError
	(
	const JCharacter*	id,
	const JError&		err
	)
	const
{
	if (!err.OK())
		{
		ReportError(id, err.GetMessage());
		}
}
Ejemplo n.º 25
0
JBoolean
SyGGetTrashDirectory
	(
	JString*		path,
	const JBoolean	reportErrors
	)
{
	if (!theTrashDir.IsEmpty())
		{
		*path = theTrashDir;
		return kJTrue;
		}

	if (!JGetPrefsDirectory(path))
		{
		if (reportErrors)
			{
			(JGetUserNotification())->ReportError(JGetString(kNoPrefsDirID));
			}
		return kJFalse;
		}

	*path = JCombinePathAndName(*path, kTrashDirName);

	JError err = JNoError();
	if (!JDirectoryExists(*path))
		{
		err = JCreateDirectory(*path, kTrashCanPerms);
		}
	else
		{
		err = JSetPermissions(*path, kTrashCanPerms);
		}

	if (err.OK())
		{
		theTrashDir       = *path;
		const JBoolean ok = JDirInfo::Create(theTrashDir, &theTrashDirInfo);
		assert( ok );
		return kJTrue;
		}
	else
		{
		path->Clear();
		if (reportErrors)
			{
			(JGetStringManager())->ReportError(kCreateTrashErrorID, err);
			}
		return kJFalse;
		}
}
void
JXSaveFileDialog::Save
	(
	const JCharacter* path
	)
{
	JDirInfo* dirInfo = GetDirInfo();
	const JError err  = dirInfo->GoTo(path);
	err.ReportIfError();
	if (err.OK() && itsFileNameInput->Focus())
		{
		EndDialog(kJTrue);
		}
}
Ejemplo n.º 27
0
JBoolean
SyGGetRecentFileDirectory
	(
	JString*		path,
	const JBoolean	reportErrors
	)
{
	if (!theRecentFileDir.IsEmpty())
		{
		*path = theRecentFileDir;
		return kJTrue;
		}

	if (!JGetPrefsDirectory(path))
		{
		if (reportErrors)
			{
			(JGetUserNotification())->ReportError(JGetString(kNoPrefsDirID));
			}
		return kJFalse;
		}

	*path = JCombinePathAndName(*path, kRecentFileDirName);

	JError err = JNoError();
	if (!JDirectoryExists(*path))
		{
		err = JCreateDirectory(*path, kRecentFileDirPerms);
		}
	else
		{
		err = JSetPermissions(*path, kRecentFileDirPerms);
		}

	if (err.OK())
		{
		theRecentFileDir = *path;
		return kJTrue;
		}
	else
		{
		path->Clear();
		if (reportErrors)
			{
			(JGetStringManager())->ReportError(kCreateRecentFileDirErrorID, err);
			}
		return kJFalse;
		}
}
JBoolean
CBCtagsUser::StartProcess
	(
	const CBTextFileType	fileType,
	CBLanguage*				lang
	)
{
	*lang = kCBOtherLang;

	if (itsIsActiveFlag && itsProcess == NULL)
		{
		JString cmd = kBaseExecCmd;
		cmd += itsArgs;

		int toFD, fromFD;
		const JError err =
			JProcess::Create(&itsProcess, cmd,
							 kJCreatePipe, &toFD,
							 kJCreatePipe, &fromFD);
		if (err.OK())
			{
			ListenTo(itsProcess);

			itsCmdPipe = new JOutPipeStream(toFD, kJTrue);
			assert( itsCmdPipe != NULL );

			itsResultFD = fromFD;
			assert( itsResultFD != ACE_INVALID_HANDLE );

			InitCtags(*itsCmdPipe);
			}
		else
			{
			itsIsActiveFlag = kJFalse;
			DeleteProcess();
			}
		}

	if (itsProcess != NULL)
		{
		assert( kFTCount == kCBFTCount && kFTInfo[fileType].fileType == fileType );

		*lang = kFTInfo[fileType].lang;
		*itsCmdPipe << kFTInfo[fileType].cmd << endl;
		}

	return itsIsActiveFlag;
}
Ejemplo n.º 29
0
JError
JSimpleProcess::Create
(
    const JCharacter*	cmdStr,
    const JBoolean		detach
)
{
    JSimpleProcess* p;
    const JError err = Create(&p, cmdStr, kJTrue);
    err.ReportIfError();
    if (err.OK() && detach)
    {
        JThisProcess::Ignore(p);
    }
    return err;
}
Ejemplo n.º 30
0
JError
JSimpleProcess::Create
(
    const JPtrArray<JString>&	argList,
    const JBoolean				detach
)
{
    JSimpleProcess* p;
    const JError err = Create(&p, argList, kJTrue);
    err.ReportIfError();
    if (err.OK() && detach)
    {
        JThisProcess::Ignore(p);
    }
    return err;
}