protected void ensureProjectHasRefactoringEnabled(RefactoringStatus status) throws PreconditionFailure { if (FortranCorePlugin.inTestingMode()) return; HashSet<IFile> filesToBeRemoved = new HashSet<IFile>(); for (IFile f : this.selectedFiles) { if (!PhotranVPG.getInstance().doesProjectHaveRefactoringEnabled(f)) { if (f.getProject() == null) { status.addWarning( Messages.bind( Messages.FortranResourceRefactoring_FileIsNotInAFortranProject, f.getName())); filesToBeRemoved.add(f); } else { status.addWarning( Messages.bind( Messages.FortranResourceRefactoring_AnalysisRefactoringNotEnabled, f.getProject().getName())); filesToBeRemoved.add(f); } } } // Remove files that didn't have Refactoring enabled in their projects this.selectedFiles.removeAll(filesToBeRemoved); }
/** * Check whether the new definition will either conflict with or shadow an existing definition */ private List<PhotranTokenRef> findReferencesToShadowedDefinitions() { List<PhotranTokenRef> referencesToShadowedDefinitions = new LinkedList<PhotranTokenRef>(); for (String newName : newNames) { Token token = definitionToCheck == null ? new FakeToken(scopeOfDefinitionToCheck, newName) : new FakeToken(definitionToCheck.getTokenRef().findToken(), newName); List<PhotranTokenRef> shadowedDefinitions = scopeOfDefinitionToCheck.manuallyResolve(token); // TODO: Does not consider rename or only lists (need to tell if this SPECIFIC definition // will be imported) for (ScopingNode importingScope : scopeOfDefinitionToCheck.findImportingScopes()) { pm.subTask( Messages.bind( Messages.FortranResourceRefactoring_CheckingForReferencesTo, newName, importingScope.describe())); shadowedDefinitions.addAll(importingScope.manuallyResolve(token)); } for (PhotranTokenRef def : shadowedDefinitions) { Definition definition = PhotranVPG.getInstance().getDefinitionFor(def); if (definition != null) referencesToShadowedDefinitions.addAll(definition.findAllReferences(false)); } } return referencesToShadowedDefinitions; }
public WebQueryWizardPage(TaskRepository repository, IRepositoryQuery query) { super(Messages.WebQueryWizardPage_New_web_query, repository, query); setTitle(Messages.WebQueryWizardPage_Create_web_query); setDescription( Messages.bind( Messages.WebQueryWizardPage_Specify_query_parameters_for_X, repository.getRepositoryUrl())); }
/** Add an additional binary type */ public void accept( IBinaryType binaryType, PackageBinding packageBinding, AccessRestriction accessRestriction) { if (this.options.verbose) { this.out.println( Messages.bind(Messages.compilation_loadBinary, new String(binaryType.getName()))); // new Exception("TRACE BINARY").printStackTrace(System.out); // System.out.println(); } this.lookupEnvironment.createBinaryTypeFrom(binaryType, packageBinding, accessRestriction); }
/** * Add the initial set of compilation units into the loop -> build compilation unit declarations, * their bindings and record their results. */ protected void internalBeginToCompile(ICompilationUnit[] sourceUnits, int maxUnits) { if (!this.useSingleThread && maxUnits >= ReadManager.THRESHOLD) this.parser.readManager = new ReadManager(sourceUnits, maxUnits); // Switch the current policy and compilation result for this unit to the requested one. for (int i = 0; i < maxUnits; i++) { CompilationResult unitResult = null; try { if (this.options.verbose) { this.out.println( Messages.bind( Messages.compilation_request, new String[] { String.valueOf(i + 1), String.valueOf(maxUnits), new String(sourceUnits[i].getFileName()) })); } // diet parsing for large collection of units CompilationUnitDeclaration parsedUnit; unitResult = new CompilationResult(sourceUnits[i], i, maxUnits, this.options.maxProblemsPerUnit); long parseStart = System.currentTimeMillis(); if (this.totalUnits < this.parseThreshold) { parsedUnit = this.parser.parse(sourceUnits[i], unitResult); } else { parsedUnit = this.parser.dietParse(sourceUnits[i], unitResult); } long resolveStart = System.currentTimeMillis(); this.stats.parseTime += resolveStart - parseStart; // initial type binding creation this.lookupEnvironment.buildTypeBindings(parsedUnit, null /*no access restriction*/); this.stats.resolveTime += System.currentTimeMillis() - resolveStart; addCompilationUnit(sourceUnits[i], parsedUnit); ImportReference currentPackage = parsedUnit.currentPackage; if (currentPackage != null) { unitResult.recordPackageName(currentPackage.tokens); } // } catch (AbortCompilationUnit e) { // requestor.acceptResult(unitResult.tagAsAccepted()); } catch (AbortCompilation a) { // best effort to find a way for reporting this problem: if (a.compilationResult == null) a.compilationResult = unitResult; throw a; } finally { sourceUnits[i] = null; // no longer hold onto the unit } } if (this.parser.readManager != null) { this.parser.readManager.shutdown(); this.parser.readManager = null; } // binding resolution this.lookupEnvironment.completeTypeBindings(); }
/** Add additional source types */ public void accept( ISourceType[] sourceTypes, PackageBinding packageBinding, AccessRestriction accessRestriction) { this.problemReporter.abortDueToInternalError( Messages.bind( Messages.abort_againstSourceModel, new String[] { String.valueOf(sourceTypes[0].getName()), String.valueOf(sourceTypes[0].getFileName()) })); }
/* * Compiler crash recovery in case of unexpected runtime exceptions */ protected void handleInternalException( Throwable internalException, CompilationUnitDeclaration unit, CompilationResult result) { if (result == null && unit != null) { result = unit.compilationResult; // current unit being processed ? } // Lookup environment may be in middle of connecting types if (result == null && this.lookupEnvironment.unitBeingCompleted != null) { result = this.lookupEnvironment.unitBeingCompleted.compilationResult; } if (result == null) { synchronized (this) { if (this.unitsToProcess != null && this.totalUnits > 0) result = this.unitsToProcess[this.totalUnits - 1].compilationResult; } } // last unit in beginToCompile ? boolean needToPrint = true; if (result != null) { /* create and record a compilation problem */ // only keep leading portion of the trace String[] pbArguments = new String[] { Messages.bind( Messages.compilation_internalError, Util.getExceptionSummary(internalException)), }; result.record( this.problemReporter.createProblem( result.getFileName(), IProblem.Unclassified, pbArguments, pbArguments, Error, // severity 0, // source start 0, // source end 0, // line number 0), // column number unit); /* hand back the compilation result */ if (!result.hasBeenAccepted) { this.requestor.acceptResult(result.tagAsAccepted()); needToPrint = false; } } if (needToPrint) { /* dump a stack trace to the console */ internalException.printStackTrace(); } }
public void save() { getPreferenceStore(); if (preferenceStore.needsSaving() || needsSaving) { try { if (defaultSet != -1) preferenceStore.setValue(KEY_DEFAULT, defaultSet > 0); preferenceStore.save(); needsSaving = false; } catch (IOException e) { String message = Messages.bind(Messages.ScopeSet_errorSaving, name); HelpUIPlugin.logError(message, e); } } }
public IPreferenceStore getPreferenceStore() { if (preferenceStore == null) { preferenceStore = new PreferenceStore(getFileName(this.name)); try { File file = new File(getFileName(this.name)); if (file.exists()) { preferenceStore.load(); } } catch (IOException e) { String message = Messages.bind(Messages.ScopeSet_errorLoading, name); HelpUIPlugin.logError(message, e); } } return preferenceStore; }
protected void removeCpreprocessedFilesFrom(Collection<IFile> files, RefactoringStatus status) { Set<IFile> filesToRemove = new HashSet<IFile>(); for (IFile file : files) { if (!filesToRemove.contains(file) && org.eclipse.photran.internal.core.sourceform.SourceForm.isCPreprocessed(file)) { status.addError( Messages.bind( Messages.FortranResourceRefactoring_CPreprocessedFileWillNotBeRefactored, file.getName())); filesToRemove.add(file); } } files.removeAll(filesToRemove); }
protected void removeFixedFormFilesFrom(Collection<IFile> files, RefactoringStatus status) { if (FIXED_FORM_REFACTORING_ENABLED) return; Set<IFile> filesToRemove = new HashSet<IFile>(); for (IFile file : files) { if (!filesToRemove.contains(file) && org.eclipse.photran.internal.core.sourceform.SourceForm.isFixedForm(file)) { status.addError( Messages.bind( Messages.FortranResourceRefactoring_FixedFormFileWillNotBeRefactored, file.getName())); filesToRemove.add(file); } } files.removeAll(filesToRemove); }
private void checkIfReferenceBindingWillChange( IConflictingBindingCallback callback, PhotranTokenRef ref, boolean shouldReferenceRenamedDefinition) { pm.subTask( Messages.bind( Messages.FortranResourceRefactoring_CheckingForBindingConflictsIn, PhotranVPG.lastSegmentOfFilename(ref.getFilename()))); Token reference = ref.findToken(); if (definitionToCheck != null) { ScopingNode scopeOfDefinitionToRename = reference.findScopeDeclaringOrImporting(definitionToCheck); if (scopeOfDefinitionToRename == null) return; for (String newName : newNames) { for (PhotranTokenRef existingBinding : new FakeToken(reference, newName).manuallyResolveBinding()) { ScopingNode scopeOfExistingBinding = existingBinding.findToken().getEnclosingScope(); boolean willReferenceRenamedDefinition = scopeOfExistingBinding.isParentScopeOf(scopeOfDefinitionToRename); if (shouldReferenceRenamedDefinition != willReferenceRenamedDefinition) callback.addReferenceWillChangeError(newName, reference); } } } else { if (scopeOfDefinitionToCheck == reference.getLocalScope() || scopeOfDefinitionToCheck.isParentScopeOf(reference.getLocalScope())) { for (String newName : newNames) { for (PhotranTokenRef existingBinding : new FakeToken(reference, newName).manuallyResolveBinding()) { ScopingNode scopeOfExistingBinding = existingBinding.findToken().getEnclosingScope(); boolean willReferenceRenamedDefinition = scopeOfExistingBinding.isParentScopeOf(scopeOfDefinitionToCheck); if (shouldReferenceRenamedDefinition != willReferenceRenamedDefinition) callback.addReferenceWillChangeError(newName, reference); } } } } }
/** * Add an additional compilation unit into the loop -> build compilation unit declarations, their * bindings and record their results. */ public void accept(ICompilationUnit sourceUnit, AccessRestriction accessRestriction) { // Switch the current policy and compilation result for this unit to the requested one. CompilationResult unitResult = new CompilationResult( sourceUnit, this.totalUnits, this.totalUnits, this.options.maxProblemsPerUnit); unitResult.checkSecondaryTypes = true; try { if (this.options.verbose) { String count = String.valueOf(this.totalUnits + 1); this.out.println( Messages.bind( Messages.compilation_request, new String[] {count, count, new String(sourceUnit.getFileName())})); } // diet parsing for large collection of unit CompilationUnitDeclaration parsedUnit; if (this.totalUnits < this.parseThreshold) { parsedUnit = this.parser.parse(sourceUnit, unitResult); } else { parsedUnit = this.parser.dietParse(sourceUnit, unitResult); } parsedUnit.bits |= ASTNode.IsImplicitUnit; // initial type binding creation this.lookupEnvironment.buildTypeBindings(parsedUnit, accessRestriction); addCompilationUnit(sourceUnit, parsedUnit); // binding resolution this.lookupEnvironment.completeTypeBindings(parsedUnit); } catch (AbortCompilationUnit e) { // at this point, currentCompilationUnitResult may not be sourceUnit, but some other // one requested further along to resolve sourceUnit. if (unitResult.compilationUnit == sourceUnit) { // only report once this.requestor.acceptResult(unitResult.tagAsAccepted()); } else { throw e; // want to abort enclosing request to compile } } }
/** @param name The name to set. */ public void setName(String name) { String oldFileName = getFileName(this.name); File oldFile = new File(oldFileName); if (oldFile.exists()) { // store under the old name already exists if (preferenceStore == null) { // just rename the file oldFile.renameTo(new File(getFileName(name))); } else { // remove the old file, set the new file name, // then save to create the new file oldFile.delete(); preferenceStore.setFilename(getFileName(name)); try { preferenceStore.save(); } catch (IOException e) { String message = Messages.bind(Messages.ScopeSet_errorSaving, name); HelpUIPlugin.logError(message, e); } } } this.name = name; }
private List<Conflict> findAllPotentiallyConflictingDefinitions() { List<Conflict> conflicts = new ArrayList<Conflict>(); if (definitionToCheck != null) { // Cannot call a main program (or function, etc.) X if it has an internal subprogram named // X, // even if that subprogram is never used (in which case it wouldn't be caught below) if (definitionToCheck.isMainProgram() || definitionToCheck.isSubprogram() || definitionToCheck.isModule()) { findAllPotentiallyConflictingDefinitionsInScope( conflicts, definitionToCheck.getTokenRef().findToken().findNearestAncestor(ScopingNode.class), false); } for (String newName : newNames) { if (definitionToCheck.isInternalSubprogramDefinition() && scopeContainingInternalSubprogram().isNamed(newName)) { conflicts.add( new Conflict( newName, scopeContainingInternalSubprogram().getNameToken().getTokenRef())); } } } for (ScopingNode importingScope : scopeItselfAndAllScopesThatImport(scopeOfDefinitionToCheck)) { pm.subTask( Messages.bind( Messages.FortranResourceRefactoring_CheckingForConflictingDefinitionsIn, importingScope.describe())); findAllPotentiallyConflictingDefinitionsInScope(conflicts, importingScope, true); } return conflicts; }
private List<Conflict> findAllPotentiallyConflictingUnboundSubprogramCalls() { final List<Conflict> conflictingDef = new ArrayList<Conflict>(); for (ScopingNode importingScope : scopeItselfAndAllScopesThatImport(scopeOfDefinitionToCheck)) { pm.subTask( Messages.bind( Messages.FortranResourceRefactoring_CheckingForSubprogramBindingConflictsIn, importingScope.describe())); importingScope.accept( new GenericASTVisitor() { @Override public void visitASTVarOrFnRefNode(ASTVarOrFnRefNode node) { if (node.getName() != null && node.getName().getName() != null) checkForConflict(node.getName().getName()); } @Override public void visitASTCallStmtNode(ASTCallStmtNode node) { if (node.getSubroutineName() != null) checkForConflict(node.getSubroutineName()); } private void checkForConflict(Token name) { if (name.getLogicalFile() != null) for (String newName : newNames) if (name != null && name.getText().equals(newName) && name.resolveBinding().isEmpty()) conflictingDef.add(new Conflict(newName, name.getTokenRef())); } }); } return conflictingDef; }
private void executeWorkflowInBackground() { DistributedComponentKnowledge compKnowledge = serviceRegistryAccess .getService(DistributedComponentKnowledgeService.class) .getCurrentComponentKnowledge(); try { WorkflowExecutionUtils.replaceNullNodeIdentifiersWithActualNodeIdentifier( wfDescription, localNodeId, compKnowledge); } catch (WorkflowExecutionException e) { handleWorkflowExecutionError(e); return; } String name = wfDescription.getName(); if (name == null) { name = Messages.bind(Messages.defaultWorkflowName, wfFile.getName().toString()); } WorkflowExecutionContextBuilder wfExeCtxBuilder = new WorkflowExecutionContextBuilder(wfDescription); wfExeCtxBuilder.setInstanceName(name); wfExeCtxBuilder.setNodeIdentifierStartedExecution(localNodeId); if (wfDescription.getAdditionalInformation() != null && !wfDescription.getAdditionalInformation().isEmpty()) { wfExeCtxBuilder.setAdditionalInformationProvidedAtStart( wfDescription.getAdditionalInformation()); } WorkflowExecutionContext wfExecutionContext = wfExeCtxBuilder.build(); final WorkflowExecutionInformation wfExeInfo; try { wfExeInfo = workflowExecutionService.executeWorkflowAsync(wfExecutionContext); } catch (WorkflowExecutionException | RemoteOperationException e) { handleWorkflowExecutionError(e); return; } // before starting the workflow, ensure that the console model is initialized // so that no console output gets lost; this is lazily initialized here // so the application startup is not slowed down try { serviceRegistryAccess .getService(ConsoleRowModelService.class) .ensureConsoleCaptureIsInitialized(); } catch (InterruptedException e) { LOG.error( "Failed initialize workflow console capturing for workflow: " + wfDescription.getName(), e); } if (inputTabEnabled) { InputModel.ensureInputCaptureIsInitialized(); } WorkflowExecutionUtils.removeDisabledWorkflowNodesWithoutNotify( wfExeInfo.getWorkflowDescription()); Display.getDefault() .asyncExec( new Runnable() { @Override public void run() { new OpenReadOnlyWorkflowRunEditorAction(wfExeInfo).run(); } }); }
protected static String describeTokenPos(Token token) { return Messages.bind( Messages.FortranResourceRefactoring_LineColumn, token.getLine(), token.getCol()); }
/** * General API -> compile each of supplied files -> recompile any required types for which we have * an incomplete principle structure */ public void compile(ICompilationUnit[] sourceUnits) { this.stats.startTime = System.currentTimeMillis(); // GROOVY start // sort the sourceUnits - java first! might be temporary, hmmm if (this.options.buildGroovyFiles == 2) { int groovyFileIndex = -1; // System.out.println("before"); // for (int u=0,max=sourceUnits.length;u<max;u++) { // System.out.println(sourceUnits[u].getFileName()); // } for (int u = 0, max = sourceUnits.length; u < max; u++) { char[] fn = sourceUnits[u].getFileName(); boolean isDotJava = fn[fn.length - 1] == 'a'; // a means .java if (isDotJava) { if (groovyFileIndex != -1) { // swap them! ICompilationUnit swap = sourceUnits[groovyFileIndex]; sourceUnits[groovyFileIndex] = sourceUnits[u]; sourceUnits[u] = swap; // find the next .groovy file after the groovyFileIndex (worst case it will be 'u') int newGroovyFileIndex = -1; for (int g = groovyFileIndex; g <= u; g++) { char[] fn2 = sourceUnits[g].getFileName(); boolean isDotGroovy = fn2[fn2.length - 1] == 'm'; // ZALUUM if (isDotGroovy) { newGroovyFileIndex = g; break; } } groovyFileIndex = newGroovyFileIndex; } } else { if (groovyFileIndex == -1) { groovyFileIndex = u; } } } // System.out.println("after"); // for (int u=0,max=sourceUnits.length;u<max;u++) { // System.out.println(sourceUnits[u].getFileName()); // } } // GROOVY end CompilationUnitDeclaration unit = null; ProcessTaskManager processingTask = null; try { // build and record parsed units reportProgress(Messages.compilation_beginningToCompile); if (this.annotationProcessorManager == null) { beginToCompile(sourceUnits); } else { ICompilationUnit[] originalUnits = (ICompilationUnit[]) sourceUnits.clone(); // remember source units in case a source type collision occurs try { beginToCompile(sourceUnits); processAnnotations(); if (!this.options.generateClassFiles) { // -proc:only was set on the command line return; } } catch (SourceTypeCollisionException e) { reset(); // a generated type was referenced before it was created // the compiler either created a MissingType or found a BinaryType for it // so add the processor's generated files & start over, // but remember to only pass the generated files to the annotation processor int originalLength = originalUnits.length; int newProcessedLength = e.newAnnotationProcessorUnits.length; ICompilationUnit[] combinedUnits = new ICompilationUnit[originalLength + newProcessedLength]; System.arraycopy(originalUnits, 0, combinedUnits, 0, originalLength); System.arraycopy( e.newAnnotationProcessorUnits, 0, combinedUnits, originalLength, newProcessedLength); this.annotationProcessorStartIndex = originalLength; compile(combinedUnits); return; } } if (this.useSingleThread) { // process all units (some more could be injected in the loop by the lookup environment) for (int i = 0; i < this.totalUnits; i++) { unit = this.unitsToProcess[i]; reportProgress( Messages.bind(Messages.compilation_processing, new String(unit.getFileName()))); try { if (this.options.verbose) this.out.println( Messages.bind( Messages.compilation_process, new String[] { String.valueOf(i + 1), String.valueOf(this.totalUnits), new String(this.unitsToProcess[i].getFileName()) })); process(unit, i); } finally { // cleanup compilation unit result unit.cleanUp(); } this.unitsToProcess[i] = null; // release reference to processed unit declaration reportWorked(1, i); this.stats.lineCount += unit.compilationResult.lineSeparatorPositions.length; long acceptStart = System.currentTimeMillis(); this.requestor.acceptResult(unit.compilationResult.tagAsAccepted()); this.stats.generateTime += System.currentTimeMillis() - acceptStart; // record accept time as part of generation if (this.options.verbose) this.out.println( Messages.bind( Messages.compilation_done, new String[] { String.valueOf(i + 1), String.valueOf(this.totalUnits), new String(unit.getFileName()) })); } } else { processingTask = new ProcessTaskManager(this); int acceptedCount = 0; // process all units (some more could be injected in the loop by the lookup environment) // the processTask can continue to process units until its fixed sized cache is full then it // must wait // for this this thread to accept the units as they appear (it only waits if no units are // available) while (true) { try { unit = processingTask.removeNextUnit(); // waits if no units are in the processed queue } catch (Error e) { unit = processingTask.unitToProcess; throw e; } catch (RuntimeException e) { unit = processingTask.unitToProcess; throw e; } if (unit == null) break; reportWorked(1, acceptedCount++); this.stats.lineCount += unit.compilationResult.lineSeparatorPositions.length; this.requestor.acceptResult(unit.compilationResult.tagAsAccepted()); if (this.options.verbose) this.out.println( Messages.bind( Messages.compilation_done, new String[] { String.valueOf(acceptedCount), String.valueOf(this.totalUnits), new String(unit.getFileName()) })); } } } catch (AbortCompilation e) { this.handleInternalException(e, unit); } catch (Error e) { this.handleInternalException(e, unit, null); throw e; // rethrow } catch (RuntimeException e) { this.handleInternalException(e, unit, null); throw e; // rethrow } finally { if (processingTask != null) { processingTask.shutdown(); processingTask = null; } reset(); this.annotationProcessorStartIndex = 0; this.stats.endTime = System.currentTimeMillis(); } if (this.options.verbose) { if (this.totalUnits > 1) { this.out.println( Messages.bind(Messages.compilation_units, String.valueOf(this.totalUnits))); } else { this.out.println(Messages.bind(Messages.compilation_unit, String.valueOf(this.totalUnits))); } } }