← Back to branch summary

~ubuntu-branches/ubuntu/feisty/monodevelop/feisty

« back to all changes in this revision

Viewing changes to Extras/NemerleBinding/NemerleBindingCompilerServices.cs

  • Committer: Bazaar Package Importer
  • Author(s): Sebastian Dröge
  • Date: 2006-08-18 00:51:23 UTC
  • mfrom: (1.1.3 upstream)
  • Revision ID: james.westby@ubuntu.com-20060818005123-5iit07y0j7wjg55f
Tags: 0.11+svn20060818-0ubuntu1
* New SVN snapshot
  + Works with Gtk# 2.9.0
* debian/control:
  + Updated Build-Depends
* debian/patches/use_nunit2.2.dpatch,
  debian/patches/use_real_libs.dpatch:
  + Updated
* debian/patches/versioncontrol_buildfix.dpatch:
  + Fix build failure in the version control addin

Show diffs side-by-side

added added

removed removed

Lines of Context:
Extras/NemerleBinding/NemerleBindingCompilerServices.cs
21
21
                        
22
22
                        bool SetErrorType(CompilerError error, string t)
23
23
                        {
24
 
                                switch(t)
 
24
                                switch(t.Trim ())
25
25
                                {
26
26
                                        case "error":
27
27
                                                error.IsWarning = false;
31
31
                                                return true;
32
32
                                        case "hint":
33
33
                                                error.IsWarning = true;
34
 
                                                error.ErrorNumber = "COMMENT";
35
34
                                                return true;
36
35
                                        default:
37
36
                                                return false;
44
43
                                error.ErrorNumber = String.Empty;
45
44
 
46
45
                                char [] delim = {':'};
47
 
                                string [] s = l.Split(delim, 5);
48
 
                                
49
 
                                if (SetErrorType(error, s[0]))
50
 
                                {
51
 
                                        error.ErrorText = l.Substring(l.IndexOf(s[0]+": ") + s[0].Length+2);
 
46
                                string [] s = l.Split(delim, 7);
 
47
                                
 
48
                                try
 
49
                                {
 
50
                                    SetErrorType (error, s[5]);
 
51
                                    if (s[6].StartsWith ("N") && s[6].Contains (": "))
 
52
                                    {
 
53
                                        string[] e = s[6].Split (delim, 2);
 
54
                                        error.ErrorNumber = s[0];
 
55
                                        error.ErrorText = s[1].Trim ();
 
56
                                    }
 
57
                                    else
 
58
                                        error.ErrorText = s[6].Trim ();
 
59
                                    error.FileName = s[0];
 
60
                                    error.Line = int.Parse(s[1]);
 
61
                                    error.Column = int.Parse(s[2]);
 
62
                                }
 
63
                                catch
 
64
                                {
 
65
                                    SetErrorType (error, s[0]);
 
66
                                    error.ErrorText = s[1].Trim ();
 
67
                                    error.FileName = "";
 
68
                                    error.Line = 0;
 
69
                                    error.Column = 0;
 
70
                                }
 
71
                                
 
72
                                /*if (SetErrorType(error, s[5]))
 
73
                                {
 
74
                                        error.ErrorText = s[6]; // l.Substring(l.IndexOf(s[0]+": ") + s[0].Length+2);
52
75
                                        error.FileName  = "";
53
76
                                        error.Line      = 0;
54
77
                                        error.Column    = 0;
66
89
                                        error.Line      = 0;
67
90
                                        error.Column    = 0;
68
91
                                        error.IsWarning = false;                                        
69
 
                                }
 
92
                                }*/
70
93
                                Errors.Add(error);
71
94
                        }
72
95
 
88
111
                                options += " -no-stdlib";
89
112
                        if (cp.Ot)
90
113
                                options += " -Ot";
91
 
                        if (cp.Obcm)
92
 
                                options += " -Obcm";
93
 
                        if (cp.Oocm)
94
 
                                options += " -Oocm";
95
 
                        if (cp.Oscm)
96
 
                                options += " -Oscm";
 
114
                        if (cp.Greedy)
 
115
                                options += " -greedy";
 
116
                        if (cp.Pedantic)
 
117
                                options += " -pedantic-lexer";
97
118
                        if (configuration.CompileTarget == CompileTarget.Library)
98
119
                                options += " -tdll";
99
120
                                
102
123
 
103
124
                public bool CanCompile(string fileName)
104
125
                {
105
 
                        return Path.GetExtension(fileName) == ".n";
 
126
                        return (Path.GetExtension(fileName).ToLower() == ".n");
106
127
                } 
107
128
 
108
129
                public ICompilerResult Compile (ProjectFileCollection projectFiles, ProjectReferenceCollection projectReferences, DotNetProjectConfiguration configuration, IProgressMonitor monitor)
114
135
                        string files   = "";
115
136
                        
116
137
                        foreach (ProjectReference lib in projectReferences)
117
 
                                references += " -r \"" + lib.GetReferencedFileName() + "\"";
 
138
                                foreach (string a in lib.GetReferencedFileNames())
 
139
                                        references += " -r \"" + a + "\"";
118
140
                        
119
141
                        foreach (ProjectFile f in projectFiles)
120
142
                                if (f.Subtype != Subtype.Directory)
182
204
                        
183
205
                        return cr.GetResult();
184
206
                }
185
 
 
186
 
                public void GenerateMakefile (Project project, Combine parentCombine)
187
 
                {
188
 
                        StreamWriter stream = new StreamWriter (Path.Combine (project.BaseDirectory, "Makefile." + project.Name.Replace (" ", "")));
189
 
 
190
 
                        DotNetProjectConfiguration configuration = (DotNetProjectConfiguration) project.ActiveConfiguration;
191
 
                        NemerleParameters cp = (NemerleParameters) configuration.CompilationParameters;
192
 
                        
193
 
                        string outputName = Path.GetFileName (configuration.CompiledOutputName);
194
 
 
195
 
                        string relativeOutputDir = fileUtilityService.AbsoluteToRelativePath (project.BaseDirectory, parentCombine.OutputDirectory);
196
 
 
197
 
                        ArrayList compile_files = new ArrayList ();
198
 
                        ArrayList pkg_references = new ArrayList ();
199
 
                        ArrayList assembly_references = new ArrayList ();
200
 
                        ArrayList project_references = new ArrayList ();
201
 
                        ArrayList system_references = new ArrayList ();
202
 
                        
203
 
                        foreach (ProjectFile finfo in project.ProjectFiles) {
204
 
                                if (finfo.Subtype != Subtype.Directory) {
205
 
                                        switch (finfo.BuildAction) {
206
 
                                        case BuildAction.Compile:
207
 
                                                string rel_path = fileUtilityService.AbsoluteToRelativePath (project.BaseDirectory, Path.GetDirectoryName (finfo.Name));
208
 
                                                if (CanCompile (finfo.Name));
209
 
                                                compile_files.Add (Path.Combine (rel_path, Path.GetFileName (finfo.Name)));
210
 
                                                break;
211
 
                                        }
212
 
                                }
213
 
                        }
214
 
 
215
 
                        SystemAssemblyService sas = (SystemAssemblyService)ServiceManager.GetService (typeof (SystemAssemblyService));
216
 
                        foreach (ProjectReference lib in project.ProjectReferences) {
217
 
                                switch (lib.ReferenceType) {
218
 
                                case ReferenceType.Gac:
219
 
                                        string pkg = sas.GetPackageFromFullName (lib.Reference);
220
 
                                        if (pkg == "MONO-SYSTEM") {
221
 
                                                system_references.Add (Path.GetFileName (lib.GetReferencedFileName ()));
222
 
                                        } else if (!pkg_references.Contains (pkg)) {
223
 
                                                pkg_references.Add (pkg);
224
 
                                        }
225
 
                                        break;
226
 
                                case ReferenceType.Assembly:
227
 
                                        string assembly_fileName = lib.GetReferencedFileName ();
228
 
                                        string rel_path_to = fileUtilityService.AbsoluteToRelativePath (project.BaseDirectory, Path.GetDirectoryName (assembly_fileName));
229
 
                                        assembly_references.Add (Path.Combine (rel_path_to, Path.GetFileName (assembly_fileName)));
230
 
                                        break;
231
 
                                case ReferenceType.Project:
232
 
                                        CombineEntryCollection allProjects = project.RootCombine.GetAllProjects();
233
 
                                        
234
 
                                        foreach (Project projectEntry in allProjects) {
235
 
                                                if (projectEntry.Name == lib.Reference) {
236
 
                                                        string project_base_dir = fileUtilityService.AbsoluteToRelativePath (project.BaseDirectory, projectEntry.BaseDirectory);
237
 
                                                        
238
 
                                                        string project_output_fileName = projectEntry.GetOutputFileName ();
239
 
                                                        project_references.Add (Path.Combine (project_base_dir, Path.GetFileName (project_output_fileName)));
240
 
                                                }
241
 
                                        }
242
 
                                        break;
243
 
                                }
244
 
                        }
245
 
 
246
 
                        stream.WriteLine ("# This makefile is autogenerated by MonoDevelop");
247
 
                        stream.WriteLine ("# Do not modify this file");
248
 
                        stream.WriteLine ();
249
 
                        stream.WriteLine ("SOURCES = \\");
250
 
                        for (int i = 0; i < compile_files.Count; i++) {
251
 
                                stream.Write (((string)compile_files[i]).Replace (" ", "\\ "));
252
 
                                if (i != compile_files.Count - 1)
253
 
                                        stream.WriteLine (" \\");
254
 
                                else
255
 
                                        stream.WriteLine ();
256
 
                        }
257
 
                        stream.WriteLine ();
258
 
 
259
 
                        if (pkg_references.Count > 0) {
260
 
                                stream.WriteLine ("PKG_REFERENCES = \\");
261
 
                                for (int i = 0; i < pkg_references.Count; i++) {
262
 
                                        stream.Write (pkg_references[i]);
263
 
                                        if (i != pkg_references.Count - 1)
264
 
                                                stream.WriteLine (" \\");
265
 
                                        else
266
 
                                                stream.WriteLine ();
267
 
                                }
268
 
                                
269
 
                                stream.WriteLine ();
270
 
                                stream.WriteLine ("PKG_REFERENCES_BUILD = $(addprefix -pkg:, $(PKG_REFERENCES))");
271
 
                                stream.WriteLine ();
272
 
                                stream.WriteLine ("PKG_REFERENCES_CHECK = $(addsuffix .pkgcheck, $(PKG_REFERENCES))");
273
 
                                stream.WriteLine ();
274
 
                        }
275
 
                        
276
 
                        if (system_references.Count > 0) {
277
 
                                stream.WriteLine ("SYSTEM_REFERENCES = \\");
278
 
                                for (int i = 0; i < system_references.Count; i++) {
279
 
                                        stream.Write (system_references[i]);
280
 
                                        if (i != system_references.Count - 1)
281
 
                                                stream.WriteLine (" \\");
282
 
                                        else
283
 
                                                stream.WriteLine ();
284
 
                                }
285
 
                                stream.WriteLine ();
286
 
                                stream.WriteLine ("SYSTEM_REFERENCES_BUILD = $(addprefix -r:, $(SYSTEM_REFERENCES))");
287
 
                                stream.WriteLine ();
288
 
                                stream.WriteLine ("SYSTEM_REFERENCES_CHECK = $(addsuffix .check, $(SYSTEM_REFERENCES))");
289
 
                                stream.WriteLine ();
290
 
                        }
291
 
 
292
 
                        if (assembly_references.Count > 0) {
293
 
                                stream.WriteLine ("ASSEMBLY_REFERENCES = \\");
294
 
                                for (int i = 0; i < assembly_references.Count; i++) {
295
 
                                        stream.Write ("\"" + assembly_references[i] + "\"");
296
 
                                        if (i != assembly_references.Count - 1)
297
 
                                                stream.WriteLine (" \\");
298
 
                                        else
299
 
                                                stream.WriteLine ();
300
 
                                }
301
 
                                
302
 
                                stream.WriteLine ();
303
 
                                stream.WriteLine ("ASSEMBLY_REFERENCES_BUILD = $(addprefix -r:, $(ASSEMBLY_REFERENCES))");
304
 
                                stream.WriteLine ();
305
 
                        }
306
 
 
307
 
                        if (project_references.Count > 0) {
308
 
                                stream.WriteLine ("PROJECT_REFERENCES = \\");
309
 
                                for (int i = 0; i < project_references.Count; i++) {
310
 
                                        stream.Write ("\"" + project_references[i] + "\"");
311
 
                                        if (i != project_references.Count - 1)
312
 
                                                stream.WriteLine (" \\");
313
 
                                        else
314
 
                                                stream.WriteLine ();
315
 
                                }
316
 
                                
317
 
                                stream.WriteLine ();
318
 
                                stream.WriteLine ("PROJECT_REFERENCES_BUILD = $(addprefix -r:, $(PROJECT_REFERENCES))");
319
 
                                stream.WriteLine ();
320
 
                        }
321
 
 
322
 
                        stream.Write ("NCC_OPTIONS = " + GetOptionsString (configuration, cp));
323
 
 
324
 
                        stream.WriteLine ();
325
 
                        stream.WriteLine ();
326
 
 
327
 
                        stream.WriteLine ("all: " + outputName);
328
 
                        stream.WriteLine ();
329
 
                        
330
 
                        stream.WriteLine(outputName + ": $(SOURCES)");
331
 
                        
332
 
                        stream.Write ("\t{0} $(NCC_OPTIONS) -out:\"{1}\"", ncc, outputName);
333
 
                        if (pkg_references.Count > 0) {
334
 
                                stream.Write (" $(PKG_REFERENCES_BUILD)");
335
 
                        }
336
 
                        if (assembly_references.Count > 0) {
337
 
                                stream.Write (" $(ASSEMBLY_REFERENCES_BUILD)");
338
 
                        }
339
 
                        if (project_references.Count > 0) {
340
 
                                stream.Write (" $(PROJECT_REFERENCES_BUILD)");
341
 
                        }
342
 
                        if (system_references.Count > 0) {
343
 
                                stream.Write (" $(SYSTEM_REFERENCES_BUILD)");
344
 
                        }
345
 
                        stream.WriteLine (" $(SOURCES) \\");
346
 
                        stream.WriteLine ("\t&& cp \"{0}\" {1}/.", outputName, relativeOutputDir);
347
 
                        
348
 
                        stream.WriteLine ();
349
 
                        stream.WriteLine ("clean:");
350
 
                        stream.WriteLine ("\trm -f {0}", outputName);
351
 
                        stream.WriteLine ();
352
 
                        
353
 
                        stream.Write ("depcheck: ");
354
 
                        if (pkg_references.Count > 0) {
355
 
                                stream.Write ("PKG_depcheck ");
356
 
                        }
357
 
                        if (system_references.Count > 0) {
358
 
                                stream.Write ("SYSTEM_depcheck");
359
 
                        }
360
 
                        stream.WriteLine ();
361
 
                        stream.WriteLine ();
362
 
                        if (pkg_references.Count > 0) {
363
 
                                stream.WriteLine ("PKG_depcheck: $(PKG_REFERENCES_CHECK)");
364
 
                                stream.WriteLine ();
365
 
                                stream.WriteLine ("%.pkgcheck:");
366
 
                                stream.WriteLine ("\t@echo -n Checking for package $(subst .pkgcheck,,$@)...");
367
 
                                stream.WriteLine ("\t@if pkg-config --libs $(subst .pkgcheck,,$@) &> /dev/null; then \\");
368
 
                                stream.WriteLine ("\t\techo yes; \\");
369
 
                                stream.WriteLine ("\telse \\");
370
 
                                stream.WriteLine ("\t\techo no; \\");
371
 
                                stream.WriteLine ("\t\texit 1; \\");
372
 
                                stream.WriteLine ("\tfi");
373
 
                                stream.WriteLine ();
374
 
                        }
375
 
 
376
 
                        if (system_references.Count > 0) {
377
 
                                stream.WriteLine ("SYSTEM_depcheck: $(SYSTEM_REFERENCES_CHECK)");
378
 
                                stream.WriteLine ();
379
 
                                stream.WriteLine ("%.check:");
380
 
                                stream.WriteLine ("\t@echo -n Checking for $(subst .check,,$@)...");
381
 
                                stream.WriteLine ("\t@if [ ! -e `pkg-config --variable=libdir mono`/mono/1.0/$(subst .check,,$@) ]; then \\");
382
 
                                stream.WriteLine ("\t\techo no; \\");
383
 
                                stream.WriteLine ("\t\texit 1; \\");
384
 
                                stream.WriteLine ("\telse \\");
385
 
                                stream.WriteLine ("\t\techo yes; \\");
386
 
                                stream.WriteLine ("\tfi");
387
 
                        }
388
 
                        
389
 
                        stream.Flush ();
390
 
                        stream.Close ();
391
 
                }               
392
207
        }
393
208
}