Attachment #162732 for bug #268773

This Bugzilla instance is a read-only archive of historic NetBeans bug reports. To report a bug in NetBeans please follow the project's instructions for reporting issues.

View | Details | Raw Unified | Return to bug 268773
Collapse All | Expand All




import org.netbeans.modules.cnd.api.toolchain.CompilerSet;
import org.netbeans.modules.cnd.api.toolchain.PredefinedToolKind;
import org.netbeans.modules.cnd.api.remote.PathMap;
import org.netbeans.modules.cnd.api.remote.RemoteFileUtil;
import org.netbeans.modules.cnd.api.remote.RemoteSyncSupport;
import org.netbeans.modules.cnd.api.toolchain.CompilerSetManager;
import org.netbeans.modules.cnd.api.toolchain.Tool;


    protected FileObject relativeTo;
    protected final ExecutionEnvironment execEnv;
    protected final ExecutionEnvironment soucreEnv;
    private final PathMap pathMap;
    private NativeProject nativeProject;
    private NativeFileSearch nativeFileSearch;

        this.relativeTo = relativeTo;
        this.execEnv = execEnv;
        pathMap = RemoteSyncSupport.getPathMap(execEnv, project);
        soucreEnv = RemoteFileUtil.getProjectSourceExecutionEnvironment(project);
        init(project);
    }


            return FileSystemProvider.getFileObject(ExecutionEnvironmentFactory.getLocal(), 
                    FileSystemProvider.normalizeAbsolutePath(localFileName, ExecutionEnvironmentFactory.getLocal()));
        }
        FileObject res = FileSystemProvider.getFileObject(soucreEnv, FileSystemProvider.normalizeAbsolutePath(fileName, soucreEnv));
        if (res == null && !execEnv.equals(soucreEnv)) {
             res = FileSystemProvider.getFileObject(execEnv, FileSystemProvider.normalizeAbsolutePath(fileName, execEnv));
        }
        return res;
    }

    protected FileObject resolveRelativePath(FileObject relativeDir, String relativePath) {




    private Stack<FileObject> relativesTo = new Stack<FileObject>();
    private Stack<Integer> relativesLevel = new Stack<Integer>();
    private ArrayList<StackIncludeItem> errorInludes = new ArrayList<StackIncludeItem>();
    private boolean isEntered;
    private OutputListenerRegistry listenerRegistry;

    public GCCErrorParser(Project project, CompilerFlavor flavor, ExecutionEnvironment execEnv, FileObject relativeTo) {
        super(project, execEnv, relativeTo);
        this.relativesTo.push(relativeTo);
        this.relativesLevel.push(0);
    	init(flavor);
	init(flavor);
    }

    private void init(CompilerFlavor flavor) {


    private Result handleLine(String line, Matcher m) {
        if (m.pattern() == GCC_DIRECTORY_ENTER || m.pattern() == GCC_DIRECTORY_LEAVE) {
            boolean isEntered = m.pattern() == GCC_DIRECTORY_ENTER;
            String levelString = m.group(1);
            int level = levelString == null ? 0 : Integer.parseInt(levelString);
            int baseLavel = relativesLevel.peek();

                relativesLevel.push(level);
                isEntered = true;
            } else if (level == baseLavel) {
                //
            } else {
                isEntered = false;
                popLevel();
            }
            if (isEntered) {
                if (!CndPathUtilities.isAbsolute(directory)) {

                }
                FileObject relativeDir = resolveFile(directory);
                if (relativeDir != null && relativeDir.isValid()) {
                    if (relativesTo.size() == relativesLevel.size()) {
                        popPath();
                        relativesTo.push(relativeDir);
                    } else {
                        relativesTo.push(relativeDir);
                    }
                }
                return ErrorParserProvider.NO_RESULT;
            } else {
                popPath();
                popLevel();
                return ErrorParserProvider.NO_RESULT;
            }
        }

Return to bug 268773

Lines 53-58 Link Here

(-)a/cnd.toolchain/src/org/netbeans/modules/cnd/toolchain/execution/ErrorParser.java (-1 / +8 lines)
53	import org.netbeans.modules.cnd.api.toolchain.CompilerSet;	53	import org.netbeans.modules.cnd.api.toolchain.CompilerSet;
54	import org.netbeans.modules.cnd.api.toolchain.PredefinedToolKind;	54	import org.netbeans.modules.cnd.api.toolchain.PredefinedToolKind;
55	import org.netbeans.modules.cnd.api.remote.PathMap;	55	import org.netbeans.modules.cnd.api.remote.PathMap;
		56	import org.netbeans.modules.cnd.api.remote.RemoteFileUtil;
56	import org.netbeans.modules.cnd.api.remote.RemoteSyncSupport;	57	import org.netbeans.modules.cnd.api.remote.RemoteSyncSupport;
57	import org.netbeans.modules.cnd.api.toolchain.CompilerSetManager;	58	import org.netbeans.modules.cnd.api.toolchain.CompilerSetManager;
58	import org.netbeans.modules.cnd.api.toolchain.Tool;	59	import org.netbeans.modules.cnd.api.toolchain.Tool;
Lines 72-77 Link Here
72		73
73	protected FileObject relativeTo;	74	protected FileObject relativeTo;
74	protected final ExecutionEnvironment execEnv;	75	protected final ExecutionEnvironment execEnv;
		76	protected final ExecutionEnvironment soucreEnv;
75	private final PathMap pathMap;	77	private final PathMap pathMap;
76	private NativeProject nativeProject;	78	private NativeProject nativeProject;
77	private NativeFileSearch nativeFileSearch;	79	private NativeFileSearch nativeFileSearch;
Lines 81-86 Link Here
81	this.relativeTo = relativeTo;	83	this.relativeTo = relativeTo;
82	this.execEnv = execEnv;	84	this.execEnv = execEnv;
83	pathMap = RemoteSyncSupport.getPathMap(execEnv, project);	85	pathMap = RemoteSyncSupport.getPathMap(execEnv, project);
		86	soucreEnv = RemoteFileUtil.getProjectSourceExecutionEnvironment(project);
84	init(project);	87	init(project);
85	}	88	}
86		89
Lines 122-128 Link Here
122	return FileSystemProvider.getFileObject(ExecutionEnvironmentFactory.getLocal(),	125	return FileSystemProvider.getFileObject(ExecutionEnvironmentFactory.getLocal(),
123	FileSystemProvider.normalizeAbsolutePath(localFileName, ExecutionEnvironmentFactory.getLocal()));	126	FileSystemProvider.normalizeAbsolutePath(localFileName, ExecutionEnvironmentFactory.getLocal()));
124	}	127	}
125	return FileSystemProvider.getFileObject(execEnv, FileSystemProvider.normalizeAbsolutePath(fileName, execEnv));	128	FileObject res = FileSystemProvider.getFileObject(soucreEnv, FileSystemProvider.normalizeAbsolutePath(fileName, soucreEnv));
		129	if (res == null && !execEnv.equals(soucreEnv)) {
		130	res = FileSystemProvider.getFileObject(execEnv, FileSystemProvider.normalizeAbsolutePath(fileName, execEnv));
		131	}
		132	return res;
126	}	133	}
127		134
128	protected FileObject resolveRelativePath(FileObject relativeDir, String relativePath) {	135	protected FileObject resolveRelativePath(FileObject relativeDir, String relativePath) {

Lines 76-90 Link Here

(-)a/cnd.toolchain/src/org/netbeans/modules/cnd/toolchain/execution/GCCErrorParser.java (-6 / +10 lines)
76	private Stack<FileObject> relativesTo = new Stack<FileObject>();	76	private Stack<FileObject> relativesTo = new Stack<FileObject>();
77	private Stack<Integer> relativesLevel = new Stack<Integer>();	77	private Stack<Integer> relativesLevel = new Stack<Integer>();
78	private ArrayList<StackIncludeItem> errorInludes = new ArrayList<StackIncludeItem>();	78	private ArrayList<StackIncludeItem> errorInludes = new ArrayList<StackIncludeItem>();
79	private boolean isEntered;
80	private OutputListenerRegistry listenerRegistry;	79	private OutputListenerRegistry listenerRegistry;
81		80
82	public GCCErrorParser(Project project, CompilerFlavor flavor, ExecutionEnvironment execEnv, FileObject relativeTo) {	81	public GCCErrorParser(Project project, CompilerFlavor flavor, ExecutionEnvironment execEnv, FileObject relativeTo) {
83	super(project, execEnv, relativeTo);	82	super(project, execEnv, relativeTo);
84	this.relativesTo.push(relativeTo);	83	this.relativesTo.push(relativeTo);
85	this.relativesLevel.push(0);	84	this.relativesLevel.push(0);
86	this.isEntered = false;	85	init(flavor);
87	init(flavor);
88	}	86	}
89		87
90	private void init(CompilerFlavor flavor) {	88	private void init(CompilerFlavor flavor) {
Lines 201-206 Link Here
201		199
202	private Result handleLine(String line, Matcher m) {	200	private Result handleLine(String line, Matcher m) {
203	if (m.pattern() == GCC_DIRECTORY_ENTER \|\| m.pattern() == GCC_DIRECTORY_LEAVE) {	201	if (m.pattern() == GCC_DIRECTORY_ENTER \|\| m.pattern() == GCC_DIRECTORY_LEAVE) {
		202	boolean isEntered = m.pattern() == GCC_DIRECTORY_ENTER;
204	String levelString = m.group(1);	203	String levelString = m.group(1);
205	int level = levelString == null ? 0 : Integer.parseInt(levelString);	204	int level = levelString == null ? 0 : Integer.parseInt(levelString);
206	int baseLavel = relativesLevel.peek();	205	int baseLavel = relativesLevel.peek();
Lines 210-219 Link Here
210	relativesLevel.push(level);	209	relativesLevel.push(level);
211	isEntered = true;	210	isEntered = true;
212	} else if (level == baseLavel) {	211	} else if (level == baseLavel) {
213	isEntered = !this.isEntered;	212	//
214	} else {	213	} else {
215	isEntered = false;	214	isEntered = false;
216	popLevel();
217	}	215	}
218	if (isEntered) {	216	if (isEntered) {
219	if (!CndPathUtilities.isAbsolute(directory)) {	217	if (!CndPathUtilities.isAbsolute(directory)) {
Lines 225-235 Link Here
225	}	223	}
226	FileObject relativeDir = resolveFile(directory);	224	FileObject relativeDir = resolveFile(directory);
227	if (relativeDir != null && relativeDir.isValid()) {	225	if (relativeDir != null && relativeDir.isValid()) {
228	relativesTo.push(relativeDir);	226	if (relativesTo.size() == relativesLevel.size()) {
		227	popPath();
		228	relativesTo.push(relativeDir);
		229	} else {
		230	relativesTo.push(relativeDir);
		231	}
229	}	232	}
230	return ErrorParserProvider.NO_RESULT;	233	return ErrorParserProvider.NO_RESULT;
231	} else {	234	} else {
232	popPath();	235	popPath();
		236	popLevel();
233	return ErrorParserProvider.NO_RESULT;	237	return ErrorParserProvider.NO_RESULT;
234	}	238	}
235	}	239	}