| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * https://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| * |
| */ |
| |
| package org.apache.ant.dotnet.compile; |
| |
| import org.apache.ant.dotnet.NetCommand; |
| import org.apache.tools.ant.BuildException; |
| |
| |
| /** |
| * This task compiles Visual Basic.NET source into executables or modules. |
| * The task requires vbc.exe on the execute path, unless it or an equivalent |
| * program is specified in the <tt>executable</tt> parameter |
| * |
| * <p> |
| * All parameters are optional: <vbc/> should suffice to produce a debug |
| * build of all *.vb files. |
| * |
| * <p> |
| |
| * The task is a directory based task, so attributes like |
| * <tt>includes="**\/*.vb"</tt> and |
| * <tt>excludes="broken.vb"</tt> can be used to control |
| * the files pulled in. By default, |
| * all *.vb files from the project folder down are included in the command. |
| * When this happens the destFile -if not specified- |
| * is taken as the first file in the list, which may be somewhat hard to control. |
| Specifying the output file with <tt>destfile</tt> is prudent. |
| </p> |
| <p> |
| * Also, dependency checking only works if destfile is set. |
| * |
| * <p>For historical reasons the pattern |
| * <code>**</code><code>/*.vb</code> is preset as includes list and |
| * you can not override it with an explicit includes attribute. Use |
| * nested <code><src></code> elements instead of the basedir |
| * attribute if you need more control.</p> |
| * |
| * As with <csc> nested <tt>src</tt> filesets of source, |
| * reference filesets, definitions and resources can be provided. |
| * |
| * <p> |
| * Example |
| * </p> |
| * <pre><vbc |
| * optimize="true" |
| * debug="false" |
| * warnLevel="4" |
| * targetType="exe" |
| * definitions="RELEASE" |
| * excludes="src/unicode_class.vb" |
| * mainClass = "MainApp" |
| * destFile="NetApp.exe" |
| * optionExplicit="true" |
| * optionCompare="text" |
| * references="System.Xml,System.Web.Xml" |
| * > |
| * <reference file="${testCSC.dll}" /> |
| * <define name="RELEASE" /> |
| * <define name="DEBUG" if="debug.property"/> |
| * <define name="def3" unless="def2.property"/> |
| * </vbc> |
| </pre> |
| * @ant.task name="vbc" category="dotnet" |
| */ |
| |
| public class VisualBasicCompile extends DotnetCompile { |
| |
| /** |
| * Compiler option to remove integer checks. Default: false. |
| */ |
| private boolean removeIntChecks = false; |
| |
| /** |
| * Require explicit declaration of variables? Default: false. |
| */ |
| private boolean optionExplicit = false; |
| |
| /** |
| * Enforce strict language semantics? Default: false. |
| */ |
| private boolean optionStrict = false; |
| |
| /** |
| * Whether to compare strings as "text" or "binary". Default: "binary". |
| */ |
| private String optionCompare; |
| |
| /** |
| * Root namespace for all type declarations. |
| */ |
| private String rootNamespace; |
| |
| /** |
| * Declare global imports fornamespaces in referenced metadata files. |
| */ |
| private String imports; |
| |
| /** |
| * Constructor for VisualBasicCompile. |
| */ |
| public VisualBasicCompile() { |
| clear(); |
| } |
| |
| /** |
| * reset all contents. |
| */ |
| public void clear() { |
| super.clear(); |
| imports = null; |
| rootNamespace = null; |
| optionCompare = null; |
| optionExplicit = false; |
| optionStrict = false; |
| removeIntChecks = false; |
| setExecutable("vbc"); |
| } |
| |
| /** |
| * get the argument or null for no argument needed |
| * This is overridden from DotnetCompile.java because VBC uses |
| * "/win32resource:" rather than "/win32res:" |
| * |
| *@return The Win32Res Parameter to CSC |
| */ |
| protected String getWin32ResParameter() { |
| if (getWin32Res() != null) { |
| return "/win32resource:" + getWin32Res().toString(); |
| } else { |
| return null; |
| } |
| } |
| |
| /** |
| * Whether to remove integer checks. Default false. |
| * @param flag on/off flag |
| */ |
| public void setRemoveIntChecks(boolean flag) { |
| removeIntChecks = flag; |
| } |
| |
| /** |
| * Get the flag for removing integer checks. |
| * @return true if flag is turned on |
| */ |
| public boolean getRemoveIntChecks() { |
| return removeIntChecks; |
| } |
| |
| /** |
| * Form the option string for removeIntChecks. |
| * @return The parameter string. |
| */ |
| public String getRemoveIntChecksParameter() { |
| return "/removeintchecks" + (removeIntChecks ? "+" : "-"); |
| } |
| |
| /** |
| * Whether to require explicit declaration of variables. |
| * @param flag on/off flag |
| */ |
| public void setOptionExplicit(boolean flag) { |
| optionExplicit = flag; |
| } |
| |
| /** |
| * Get the flag for whether to require explicit declaration of variables. |
| *@return true if flag is turned on |
| */ |
| public boolean getOptionExplicit() { |
| return optionExplicit; |
| } |
| |
| /** |
| * Form the option string for optionExplicit.. |
| * @return The parameter string. |
| */ |
| public String getOptionExplicitParameter() { |
| return "/optionexplicit" + (optionExplicit ? "+" : "-"); |
| } |
| |
| /** |
| * Enforce strict language semantics. |
| * @param flag on/off flag |
| */ |
| public void setOptionStrict(boolean flag) { |
| optionStrict = flag; |
| } |
| |
| /** |
| * Get the flag for whether to enforce strict language semantics. |
| * @return true if flag is turned on |
| */ |
| public boolean getOptionStrict() { |
| return optionStrict; |
| } |
| |
| /** |
| * For the option string for optionStrict. |
| * @return The parameter string. |
| */ |
| public String getOptionStrictParameter() { |
| return "/optionstrict" + (optionStrict ? "+" : "-"); |
| } |
| |
| |
| /** |
| * Specifies the root namespace for all type declarations. |
| * @param rootNamespace a root namespace. |
| */ |
| public void setRootNamespace(String rootNamespace) { |
| this.rootNamespace = rootNamespace; |
| } |
| |
| |
| /** |
| * Get the root namespace. |
| * @return the root namespace. |
| */ |
| public String getRootNamespace() { |
| return this.rootNamespace; |
| } |
| |
| |
| /** |
| * Form the option string for rootNamespace. |
| * @return the root namespace option string. |
| */ |
| protected String getRootNamespaceParameter() { |
| if (rootNamespace != null && rootNamespace.length() != 0) { |
| return "/rootnamespace:" + rootNamespace; |
| } else { |
| return null; |
| } |
| } |
| |
| |
| /** |
| * Declare global imports for namespaces in referenced metadata files. |
| * @param imports the imports string |
| */ |
| public void setImports(String imports) { |
| this.imports = imports; |
| } |
| |
| |
| /** |
| * Get global imports for namespaces in referenced metadata files. |
| * @return the imports string. |
| */ |
| public String getImports() { |
| return this.imports; |
| } |
| |
| |
| /** |
| * Format the option for imports. |
| * @return the formatted import option. |
| */ |
| protected String getImportsParameter() { |
| if (imports != null && imports.length() != 0) { |
| return "/imports:" + imports; |
| } else { |
| return null; |
| } |
| } |
| |
| |
| /** |
| * Specify binary- or text-style string comparisons. Defaults |
| * to "binary" |
| * @param optionCompare the option compare style. "text" | "binary". |
| */ |
| public void setOptionCompare(String optionCompare) { |
| if ("text".equalsIgnoreCase(optionCompare)) { |
| this.optionCompare = "text"; |
| } else { |
| this.optionCompare = "binary"; |
| } |
| } |
| |
| |
| /** |
| * "binary" or "text" for the string-comparison style. |
| * @return the option compare style. |
| */ |
| public String getOptionCompare() { |
| return this.optionCompare; |
| } |
| |
| /** |
| * Format the option for string comparison style. |
| * @return The formatted option. |
| */ |
| protected String getOptionCompareParameter() { |
| if (optionCompare != null && "text".equalsIgnoreCase(optionCompare)) { |
| return "/optioncompare:text"; |
| } else { |
| return "/optioncompare:binary"; |
| } |
| } |
| |
| /** |
| * implement VBC commands |
| * @param command |
| */ |
| protected void addCompilerSpecificOptions(NetCommand command) { |
| command.addArgument(getRemoveIntChecksParameter()); |
| command.addArgument(getImportsParameter()); |
| command.addArgument(getOptionExplicitParameter()); |
| command.addArgument(getOptionStrictParameter()); |
| command.addArgument(getRootNamespaceParameter()); |
| command.addArgument(getOptionCompareParameter()); |
| } |
| |
| /** |
| * Get the delimiter that the compiler uses between references. |
| * For example, c# will return ";"; VB.NET will return "," |
| * @return The string delimiter for the reference string. |
| */ |
| public String getReferenceDelimiter() { |
| return ","; |
| } |
| |
| |
| |
| /** |
| * Get the extension of filenames to compile. |
| * @return The string extension of files to compile. |
| */ |
| public String getFileExtension() { |
| return "vb"; |
| } |
| |
| protected void createResourceParameter(NetCommand command, DotnetResource resource) { |
| resource.getParameters(getProject(), command, false); |
| } |
| |
| /** |
| * validation code |
| * @throws BuildException if validation failed |
| */ |
| protected void validate() |
| throws BuildException { |
| super.validate(); |
| if (getDestFile() == null) { |
| throw new BuildException("DestFile was not specified"); |
| } |
| } |
| } |