public Report (CompilerContext context, ReportPrinter printer) { if (context == null) throw new ArgumentNullException ("settings"); if (printer == null) throw new ArgumentNullException ("printer"); this.settings = context.Settings; this.printer = printer; }
public PlayScriptParser (CompilerSettings args) { compilerSettings = args ?? new CompilerSettings(); }
public PlayScriptParser () { compilerSettings = new CompilerSettings(); }
// // This parses the -arg and /arg options to the compiler, even if the strings // in the following text use "/arg" on the strings. // ParseResult ParseOption (string option, ref string[] args, CompilerSettings settings) { int idx = option.IndexOf (':'); string arg, value; if (idx == -1) { arg = option; value = ""; } else { arg = option.Substring (0, idx); value = option.Substring (idx + 1); } switch (arg.ToLowerInvariant ()) { case "/nologo": return ParseResult.Success; case "/t": case "/target": switch (value) { case "exe": settings.Target = Target.Exe; break; case "winexe": settings.Target = Target.WinExe; break; case "library": settings.Target = Target.Library; settings.TargetExt = ".dll"; break; case "module": settings.Target = Target.Module; settings.TargetExt = ".netmodule"; break; default: report.Error (2019, "Invalid target type for -target. Valid options are `exe', `winexe', `library' or `module'"); return ParseResult.Error; } return ParseResult.Success; case "/out": if (value.Length == 0) { Error_RequiresFileName (option); return ParseResult.Error; } settings.OutputFile = value; return ParseResult.Success; case "/o": case "/o+": case "/optimize": case "/optimize+": settings.Optimize = true; return ParseResult.Success; case "/o-": case "/optimize-": settings.Optimize = false; return ParseResult.Success; // TODO: Not supported by csc 3.5+ case "/incremental": case "/incremental+": case "/incremental-": // nothing. return ParseResult.Success; case "/d": case "/define": { if (value.Length == 0) { Error_RequiresArgument (option); return ParseResult.Error; } foreach (string d in value.Split (argument_value_separator)) { string conditional = d.Trim (); if (!Tokenizer.IsValidIdentifier (conditional)) { report.Warning (2029, 1, "Invalid conditional define symbol `{0}'", conditional); continue; } settings.AddConditionalSymbol (conditional); } return ParseResult.Success; } case "/bugreport": // // We should collect data, runtime, etc and store in the file specified // output.WriteLine ("To file bug reports, please visit: http://www.mono-project.com/Bugs"); return ParseResult.Success; case "/pkg": { string packages; if (value.Length == 0) { Error_RequiresArgument (option); return ParseResult.Error; } packages = String.Join (" ", value.Split (new Char[] { ';', ',', '\n', '\r' })); string pkgout = Driver.GetPackageFlags (packages, report); if (pkgout == null) return ParseResult.Error; string[] xargs = pkgout.Trim (new Char[] { ' ', '\n', '\r', '\t' }).Split (new Char[] { ' ', '\t' }); args = AddArgs (args, xargs); return ParseResult.Success; } case "/linkres": case "/linkresource": case "/res": case "/resource": AssemblyResource res = null; string[] s = value.Split (argument_value_separator, StringSplitOptions.RemoveEmptyEntries); switch (s.Length) { case 1: if (s[0].Length == 0) goto default; res = new AssemblyResource (s[0], Path.GetFileName (s[0])); break; case 2: res = new AssemblyResource (s[0], s[1]); break; case 3: if (s[2] != "public" && s[2] != "private") { report.Error (1906, "Invalid resource visibility option `{0}'. Use either `public' or `private' instead", s[2]); return ParseResult.Error; } res = new AssemblyResource (s[0], s[1], s[2] == "private"); break; default: report.Error (-2005, "Wrong number of arguments for option `{0}'", option); return ParseResult.Error; } if (res != null) { res.IsEmbeded = arg[1] == 'r' || arg[1] == 'R'; AddResource (res, settings); } return ParseResult.Success; case "/recurse": if (value.Length == 0) { Error_RequiresFileName (option); return ParseResult.Error; } ProcessSourceFiles (value, true, settings.SourceFiles); return ParseResult.Success; case "/r": case "/reference": { if (value.Length == 0) { Error_RequiresFileName (option); return ParseResult.Error; } string[] refs = value.Split (argument_value_separator); foreach (string r in refs) { if (r.Length == 0) continue; string val = r; int index = val.IndexOf ('='); if (index > -1) { string alias = r.Substring (0, index); string assembly = r.Substring (index + 1); AddAssemblyReference (alias, assembly, settings); if (refs.Length != 1) { report.Error (2034, "Cannot specify multiple aliases using single /reference option"); return ParseResult.Error; } } else { settings.AssemblyReferences.Add (val); } } return ParseResult.Success; } case "/addmodule": { if (value.Length == 0) { Error_RequiresFileName (option); return ParseResult.Error; } string[] refs = value.Split (argument_value_separator); foreach (string r in refs) { settings.Modules.Add (r); } return ParseResult.Success; } case "/win32res": { if (value.Length == 0) { Error_RequiresFileName (option); return ParseResult.Error; } if (settings.Win32IconFile != null) report.Error (1565, "Cannot specify the `win32res' and the `win32ico' compiler option at the same time"); settings.Win32ResourceFile = value; return ParseResult.Success; } case "/win32icon": { if (value.Length == 0) { Error_RequiresFileName (option); return ParseResult.Error; } if (settings.Win32ResourceFile != null) report.Error (1565, "Cannot specify the `win32res' and the `win32ico' compiler option at the same time"); settings.Win32IconFile = value; return ParseResult.Success; } case "/doc": { if (value.Length == 0) { Error_RequiresFileName (option); return ParseResult.Error; } settings.DocumentationFile = value; return ParseResult.Success; } case "/lib": { string[] libdirs; if (value.Length == 0) { return ParseResult.Error; } libdirs = value.Split (argument_value_separator); foreach (string dir in libdirs) settings.ReferencesLookupPaths.Add (dir); return ParseResult.Success; } case "/debug-": settings.GenerateDebugInfo = false; return ParseResult.Success; case "/debug": if (value.Equals ("full", StringComparison.OrdinalIgnoreCase) || value.Equals ("pdbonly", StringComparison.OrdinalIgnoreCase) || idx < 0) { settings.GenerateDebugInfo = true; return ParseResult.Success; } if (value.Length > 0) { report.Error (1902, "Invalid debug option `{0}'. Valid options are `full' or `pdbonly'", value); } else { Error_RequiresArgument (option); } return ParseResult.Error; case "/debug+": settings.GenerateDebugInfo = true; return ParseResult.Success; case "/checked": case "/checked+": settings.Checked = true; return ParseResult.Success; case "/checked-": settings.Checked = false; return ParseResult.Success; case "/clscheck": case "/clscheck+": settings.VerifyClsCompliance = true; return ParseResult.Success; case "/clscheck-": settings.VerifyClsCompliance = false; return ParseResult.Success; case "/unsafe": case "/unsafe+": settings.Unsafe = true; return ParseResult.Success; case "/unsafe-": settings.Unsafe = false; return ParseResult.Success; case "/warnaserror": case "/warnaserror+": if (value.Length == 0) { settings.WarningsAreErrors = true; parser_settings.WarningsAreErrors = true; } else { if (!ProcessWarningsList (value, v => settings.AddWarningAsError (v))) return ParseResult.Error; } return ParseResult.Success; case "/warnaserror-": if (value.Length == 0) { settings.WarningsAreErrors = false; } else { if (!ProcessWarningsList (value, v => settings.AddWarningOnly (v))) return ParseResult.Error; } return ParseResult.Success; case "/warn": case "/w": if (value.Length == 0) { Error_RequiresArgument (option); return ParseResult.Error; } SetWarningLevel (value, settings); return ParseResult.Success; case "/nowarn": if (value.Length == 0) { Error_RequiresArgument (option); return ParseResult.Error; } if (!ProcessWarningsList (value, v => settings.SetIgnoreWarning (v))) return ParseResult.Error; return ParseResult.Success; case "/noconfig": settings.LoadDefaultReferences = false; return ParseResult.Success; case "/platform": if (value.Length == 0) { Error_RequiresArgument (option); return ParseResult.Error; } switch (value.ToLowerInvariant ()) { case "arm": settings.Platform = Platform.Arm; break; case "anycpu": settings.Platform = Platform.AnyCPU; break; case "x86": settings.Platform = Platform.X86; break; case "x64": settings.Platform = Platform.X64; break; case "itanium": settings.Platform = Platform.IA64; break; case "anycpu32bitpreferred": settings.Platform = Platform.AnyCPU32Preferred; break; default: report.Error (1672, "Invalid -platform option `{0}'. Valid options are `anycpu', `anycpu32bitpreferred', `arm', `x86', `x64' or `itanium'", value); return ParseResult.Error; } return ParseResult.Success; case "/sdk": if (value.Length == 0) { Error_RequiresArgument (option); return ParseResult.Error; } settings.SdkVersion = value; return ParseResult.Success; // We just ignore this. case "/errorreport": case "/filealign": if (value.Length == 0) { Error_RequiresArgument (option); return ParseResult.Error; } return ParseResult.Success; case "/helpinternal": OtherFlags (); return ParseResult.Stop; case "/help": case "/?": Usage (); return ParseResult.Stop; case "/main": case "/m": if (value.Length == 0) { Error_RequiresArgument (option); return ParseResult.Error; } settings.MainClass = value; return ParseResult.Success; case "/nostdlib": case "/nostdlib+": settings.StdLib = false; return ParseResult.Success; case "/nostdlib-": settings.StdLib = true; return ParseResult.Success; case "/fullpaths": settings.ShowFullPaths = true; return ParseResult.Success; case "/keyfile": if (value.Length == 0) { Error_RequiresFileName (option); return ParseResult.Error; } settings.StrongNameKeyFile = value; return ParseResult.Success; case "/keycontainer": if (value.Length == 0) { Error_RequiresArgument (option); return ParseResult.Error; } settings.StrongNameKeyContainer = value; return ParseResult.Success; case "/delaysign+": case "/delaysign": settings.StrongNameDelaySign = true; return ParseResult.Success; case "/delaysign-": settings.StrongNameDelaySign = false; return ParseResult.Success; case "/langversion": if (value.Length == 0) { Error_RequiresArgument (option); return ParseResult.Error; } switch (value.ToLowerInvariant ()) { case "iso-1": settings.Version = LanguageVersion.ISO_1; return ParseResult.Success; case "default": settings.Version = LanguageVersion.Default; return ParseResult.Success; case "iso-2": settings.Version = LanguageVersion.ISO_2; return ParseResult.Success; case "3": settings.Version = LanguageVersion.V_3; return ParseResult.Success; case "4": settings.Version = LanguageVersion.V_4; return ParseResult.Success; case "5": settings.Version = LanguageVersion.V_5; return ParseResult.Success; case "future": settings.Version = LanguageVersion.Future; return ParseResult.Success; } report.Error (1617, "Invalid -langversion option `{0}'. It must be `ISO-1', `ISO-2', `3', `4', `5', `Default' or `Future'", value); return ParseResult.Error; case "/codepage": if (value.Length == 0) { Error_RequiresArgument (option); return ParseResult.Error; } switch (value) { case "utf8": settings.Encoding = Encoding.UTF8; break; case "reset": settings.Encoding = Encoding.Default; break; default: try { settings.Encoding = Encoding.GetEncoding (int.Parse (value)); } catch { report.Error (2016, "Code page `{0}' is invalid or not installed", value); } return ParseResult.Error; } return ParseResult.Success; default: return ParseResult.UnknownOption; } }
void AddResource (AssemblyResource res, CompilerSettings settings) { if (settings.Resources == null) { settings.Resources = new List<AssemblyResource> (); settings.Resources.Add (res); return; } if (settings.Resources.Contains (res)) { report.Error (1508, "The resource identifier `{0}' has already been used in this assembly", res.Name); return; } settings.Resources.Add (res); }
void AddAssemblyReference (string alias, string assembly, CompilerSettings settings) { if (assembly.Length == 0) { report.Error (1680, "Invalid reference alias `{0}='. Missing filename", alias); return; } if (!IsExternAliasValid (alias)) { report.Error (1679, "Invalid extern alias for -reference. Alias `{0}' is not a valid identifier", alias); return; } settings.AssemblyReferencesAliases.Add (Tuple.Create (alias, assembly)); }
public CompilerSettings ParseArguments (string[] args) { CompilerSettings settings = new CompilerSettings (); List<string> response_file_list = null; bool parsing_options = true; stop_argument = false; source_file_index = new Dictionary<string, int> (); for (int i = 0; i < args.Length; i++) { string arg = args[i]; if (arg.Length == 0) continue; if (arg[0] == '@') { string[] extra_args; string response_file = arg.Substring (1); if (response_file_list == null) response_file_list = new List<string> (); if (response_file_list.Contains (response_file)) { report.Error (1515, "Response file `{0}' specified multiple times", response_file); return null; } response_file_list.Add (response_file); extra_args = LoadArgs (response_file); if (extra_args == null) { report.Error (2011, "Unable to open response file: " + response_file); return null; } args = AddArgs (args, extra_args); continue; } if (parsing_options) { if (arg == "--") { parsing_options = false; continue; } bool dash_opt = arg[0] == '-'; bool slash_opt = arg[0] == '/'; if (dash_opt) { switch (ParseOptionUnix (arg, ref args, ref i, settings)) { case ParseResult.Error: case ParseResult.Success: continue; case ParseResult.Stop: stop_argument = true; return settings; case ParseResult.UnknownOption: if (UnknownOptionHandler != null) { var ret = UnknownOptionHandler (args, i); if (ret != -1) { i = ret; continue; } } break; } } if (dash_opt || slash_opt) { // Try a -CSCOPTION string csc_opt = dash_opt ? "/" + arg.Substring (1) : arg; switch (ParseOption (csc_opt, ref args, settings)) { case ParseResult.Error: case ParseResult.Success: continue; case ParseResult.UnknownOption: // Need to skip `/home/test.cs' however /test.cs is considered as error if ((slash_opt && arg.Length > 3 && arg.IndexOf ('/', 2) > 0)) break; if (UnknownOptionHandler != null) { var ret = UnknownOptionHandler (args, i); if (ret != -1) { i = ret; continue; } } Error_WrongOption (arg); return null; case ParseResult.Stop: stop_argument = true; return settings; } } } ProcessSourceFiles (arg, false, settings.SourceFiles); } if (report.Errors > 0) return null; return settings; }
public CommandLineParser (TextWriter errorOutput, TextWriter messagesOutput) { var rp = new StreamReportPrinter (errorOutput); parser_settings = new CompilerSettings (); report = new Report (new CompilerContext (parser_settings, rp), rp); this.output = messagesOutput; }
void SetWarningLevel (string s, CompilerSettings settings) { int level = -1; try { level = int.Parse (s); } catch { } if (level < 0 || level > 4) { report.Error (1900, "Warning level must be in the range 0-4"); return; } settings.WarningLevel = level; }
// // Currently handles the Unix-like command line options, but will be // deprecated in favor of the CSCParseOption, which will also handle the // options that start with a dash in the future. // ParseResult ParseOptionUnix (string arg, ref string[] args, ref int i, CompilerSettings settings) { switch (arg){ case "-v": settings.VerboseParserFlag++; return ParseResult.Success; case "--version": Version (); return ParseResult.Stop; case "--parse": settings.ParseOnly = true; return ParseResult.Success; case "--main": case "-m": report.Warning (-29, 1, "Compatibility: Use -main:CLASS instead of --main CLASS or -m CLASS"); if ((i + 1) >= args.Length){ Error_RequiresArgument (arg); return ParseResult.Error; } settings.MainClass = args[++i]; return ParseResult.Success; case "--unsafe": report.Warning (-29, 1, "Compatibility: Use -unsafe instead of --unsafe"); settings.Unsafe = true; return ParseResult.Success; case "/?": case "/h": case "/help": case "--help": Usage (); return ParseResult.Stop; case "--define": report.Warning (-29, 1, "Compatibility: Use -d:SYMBOL instead of --define SYMBOL"); if ((i + 1) >= args.Length){ Error_RequiresArgument (arg); return ParseResult.Error; } settings.AddConditionalSymbol (args [++i]); return ParseResult.Success; case "--tokenize": settings.TokenizeOnly = true; return ParseResult.Success; case "-o": case "--output": report.Warning (-29, 1, "Compatibility: Use -out:FILE instead of --output FILE or -o FILE"); if ((i + 1) >= args.Length){ Error_RequiresArgument (arg); return ParseResult.Error; } settings.OutputFile = args[++i]; return ParseResult.Success; case "--checked": report.Warning (-29, 1, "Compatibility: Use -checked instead of --checked"); settings.Checked = true; return ParseResult.Success; case "--stacktrace": settings.Stacktrace = true; return ParseResult.Success; case "--linkresource": case "--linkres": report.Warning (-29, 1, "Compatibility: Use -linkres:VALUE instead of --linkres VALUE"); if ((i + 1) >= args.Length){ Error_RequiresArgument (arg); return ParseResult.Error; } AddResource (new AssemblyResource (args[++i], args[i]), settings); return ParseResult.Success; case "--resource": case "--res": report.Warning (-29, 1, "Compatibility: Use -res:VALUE instead of --res VALUE"); if ((i + 1) >= args.Length){ Error_RequiresArgument (arg); return ParseResult.Error; } AddResource (new AssemblyResource (args[++i], args[i], true), settings); return ParseResult.Success; case "--target": report.Warning (-29, 1, "Compatibility: Use -target:KIND instead of --target KIND"); if ((i + 1) >= args.Length){ Error_RequiresArgument (arg); return ParseResult.Error; } string type = args [++i]; switch (type){ case "library": settings.Target = Target.Library; settings.TargetExt = ".dll"; break; case "exe": settings.Target = Target.Exe; break; case "winexe": settings.Target = Target.WinExe; break; case "module": settings.Target = Target.Module; settings.TargetExt = ".dll"; break; default: report.Error (2019, "Invalid target type for -target. Valid options are `exe', `winexe', `library' or `module'"); break; } return ParseResult.Success; case "-r": report.Warning (-29, 1, "Compatibility: Use -r:LIBRARY instead of -r library"); if ((i + 1) >= args.Length){ Error_RequiresArgument (arg); return ParseResult.Error; } string val = args [++i]; int idx = val.IndexOf ('='); if (idx > -1) { string alias = val.Substring (0, idx); string assembly = val.Substring (idx + 1); AddAssemblyReference (alias, assembly, settings); return ParseResult.Success; } settings.AssemblyReferences.Add (val); return ParseResult.Success; case "-L": report.Warning (-29, 1, "Compatibility: Use -lib:ARG instead of --L arg"); if ((i + 1) >= args.Length){ Error_RequiresArgument (arg); return ParseResult.Error; } settings.ReferencesLookupPaths.Add (args [++i]); return ParseResult.Success; case "--lint": settings.EnhancedWarnings = true; return ParseResult.Success; case "--nostdlib": report.Warning (-29, 1, "Compatibility: Use -nostdlib instead of --nostdlib"); settings.StdLib = false; return ParseResult.Success; case "--nowarn": report.Warning (-29, 1, "Compatibility: Use -nowarn instead of --nowarn"); if ((i + 1) >= args.Length){ Error_RequiresArgument (arg); return ParseResult.Error; } int warn = 0; try { warn = int.Parse (args [++i]); } catch { Usage (); Environment.Exit (1); } settings.SetIgnoreWarning (warn); return ParseResult.Success; case "--wlevel": report.Warning (-29, 1, "Compatibility: Use -warn:LEVEL instead of --wlevel LEVEL"); if ((i + 1) >= args.Length){ Error_RequiresArgument (arg); return ParseResult.Error; } SetWarningLevel (args [++i], settings); return ParseResult.Success; case "--mcs-debug": if ((i + 1) >= args.Length){ Error_RequiresArgument (arg); return ParseResult.Error; } try { settings.DebugFlags = int.Parse (args [++i]); } catch { Error_RequiresArgument (arg); return ParseResult.Error; } return ParseResult.Success; case "--about": About (); return ParseResult.Stop; case "--recurse": report.Warning (-29, 1, "Compatibility: Use -recurse:PATTERN option instead --recurse PATTERN"); if ((i + 1) >= args.Length){ Error_RequiresArgument (arg); return ParseResult.Error; } ProcessSourceFiles (args [++i], true, settings.SourceFiles); return ParseResult.Success; case "--timestamp": settings.Timestamps = true; return ParseResult.Success; case "--debug": case "-g": report.Warning (-29, 1, "Compatibility: Use -debug option instead of -g or --debug"); settings.GenerateDebugInfo = true; return ParseResult.Success; case "--noconfig": report.Warning (-29, 1, "Compatibility: Use -noconfig option instead of --noconfig"); settings.LoadDefaultReferences = false; return ParseResult.Success; case "--metadata-only": settings.WriteMetadataOnly = true; return ParseResult.Success; default: if (arg.StartsWith ("--fatal", StringComparison.Ordinal)){ int fatal = 1; if (arg.StartsWith ("--fatal=", StringComparison.Ordinal)) int.TryParse (arg.Substring (8), out fatal); settings.FatalCounter = fatal; return ParseResult.Success; } if (arg.StartsWith ("--runtime:", StringComparison.Ordinal)) { string version = arg.Substring (10); switch (version) { case "v1": case "V1": settings.StdLibRuntimeVersion = RuntimeVersion.v1; break; case "v2": case "V2": settings.StdLibRuntimeVersion = RuntimeVersion.v2; break; case "v4": case "V4": settings.StdLibRuntimeVersion = RuntimeVersion.v4; break; } return ParseResult.Success; } return ParseResult.UnknownOption; } }
public CSharpParser (SeekableStreamReader reader, CompilationSourceFile file, Report report, ParserSession session) { this.file = file; current_container = current_namespace = file; this.module = file.Module; this.compiler = file.Compiler; this.settings = compiler.Settings; this.report = report; lang_version = settings.Version; yacc_verbose_flag = settings.VerboseParserFlag; doc_support = settings.DocumentationFile != null; lexer = new Tokenizer (reader, file, session); oob_stack = new Stack<object> (); lbag = session.LocationsBag; use_global_stacks = session.UseJayGlobalArrays; parameters_bucket = session.ParametersStack; }