Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
   *
   * Copyright 1997-2007 Sun Microsystems, Inc. All rights reserved.
   *
   * The contents of this file are subject to the terms of either the GNU
   * General Public License Version 2 only ("GPL") or the Common
   * Development and Distribution License("CDDL") (collectively, the
   * "License"). You may not use this file except in compliance with the
  * License. You can obtain a copy of the License at
  * http://www.netbeans.org/cddl-gplv2.html
  * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
  * specific language governing permissions and limitations under the
  * License.  When distributing the software, include this License Header
  * Notice in each file and include the License file at
  * nbbuild/licenses/CDDL-GPL-2-CP.  Sun designates this
  * particular file as subject to the "Classpath" exception as provided
  * by Sun in the GPL Version 2 section of the License file that
  * accompanied this code. If applicable, add the following below the
  * License Header, with the fields enclosed by brackets [] replaced by
  * your own identifying information:
  * "Portions Copyrighted [year] [name of copyright owner]"
  *
  * Contributor(s):
  *
  * The Original Software is NetBeans. The Initial Developer of the Original
  * Software is Sun Microsystems, Inc. Portions Copyright 1997-2007 Sun
  * Microsystems, Inc. All Rights Reserved.
  *
  * If you wish your version of this file to be governed by only the CDDL
  * or only the GPL Version 2, indicate your decision by adding
  * "[Contributor] elects to include this software in this distribution
  * under the [CDDL or GPL Version 2] license." If you do not indicate a
  * single choice of license, a recipient has the option to distribute
  * your version of this file under either the CDDL, the GPL Version 2 or
  * to extend the choice of license to its licensees as provided above.
  * However, if you add GPL Version 2 code and therefore, elected the GPL
  * Version 2 license, then the option applies only if the new code is
  * made subject to such option by the copyright holder.
  */
 package org.netbeans.modules.cnd.makeproject.api.configurations;
 
 import java.util.List;
 import java.util.Set;
 
 public class MakeConfiguration extends Configuration {
 
     public static final String MAKEFILE_IMPL = "Makefile-impl.mk"// NOI18N
     public static final String BUILD_FOLDER = "build"// NOI18N
     public static final String DIST_FOLDER = "dist"// NOI18N
     public static final String EXT_FOLDER = "_ext"// NOI18N
     public static final String OBJECTDIR_MACRO_NAME = "OBJECTDIR"// NOI18N
     public static final String OBJECTDIR_MACRO = "${" +  + "}"// NOI18N
     // Project Types
     private static String[] TYPE_NAMES = {
         getString("MakefileName"),
         getString("ApplicationName"),
         getString("DynamicLibraryName"),
         getString("StaticLibraryName"),
         getString("QtApplicationName"),
         getString("QtDynamicLibraryName"),
         getString("QtStaticLibraryName")
     };
     public static final int TYPE_MAKEFILE = 0;
     public static final int TYPE_APPLICATION = 1;
     public static final int TYPE_DYNAMIC_LIB = 2;
     public static final int TYPE_STATIC_LIB = 3;
     public static final int TYPE_QT_APPLICATION = 4;
     public static final int TYPE_QT_DYNAMIC_LIB = 5;
     public static final int TYPE_QT_STATIC_LIB = 6;
 
     // Configurations
    private boolean languagesDirty = true;
    // Constructors
    public MakeConfiguration(MakeConfigurationDescriptor makeConfigurationDescriptorString nameint configurationTypeValue) {
        this(makeConfigurationDescriptor.getBaseDir(), nameconfigurationTypeValue, CompilerSetManager.getDefaultDevelopmentHost());
    }
    public MakeConfiguration(String baseDirString nameint configurationTypeValue) {
        this(baseDirnameconfigurationTypeValue, CompilerSetManager.getDefaultDevelopmentHost());
    }
    public MakeConfiguration(String baseDirString nameint configurationTypeValueString host) {
        super(baseDirname);
         = new IntConfiguration(nullconfigurationTypeValuenull);
         = new DevelopmentHostConfiguration(ExecutionEnvironmentFactory.fromUniqueID(host));
         = new LanguageBooleanConfiguration();
         = new LanguageBooleanConfiguration();
         = new MakefileConfiguration(this);
         = new BooleanConfiguration(nullisMakefileConfiguration() ? false : MakeOptions.getInstance().getDepencyChecking());
         = new CCompilerConfiguration(baseDirnull);
         = new CCCompilerConfiguration(baseDirnull);
         = new FortranCompilerConfiguration(baseDirnull);
         = new AssemblerConfiguration(baseDirnull);
         = new LinkerConfiguration(this);
         = new ArchiverConfiguration(this);
         = new PackagingConfiguration(this);
         = new QmakeConfiguration(this);
    }
    public void setMakefileConfiguration(MakefileConfiguration makefileConfiguration) {
        this. = makefileConfiguration;
    }
        return ;
    }
        return ;
    }
    public void setConfigurationType(IntConfiguration configurationType) {
        this. = configurationType;
    }
        return ;
    }
    public void setDependencyChecking(BooleanConfiguration dependencyChecking) {
        this. = dependencyChecking;
    }
        return ;
    }
    public void setCompilerSet(CompilerSet2Configuration compilerSet) {
        this. = compilerSet;
    }
        return ;
    }
        return ;
    }
        return ;
    }
    public void setCRequired(LanguageBooleanConfiguration cRequired) {
        this. = cRequired;
    }
    public void setCppRequired(LanguageBooleanConfiguration cppRequired) {
        this. = cppRequired;
    }
    public void setFortranRequired(LanguageBooleanConfiguration fortranRequired) {
        this. = fortranRequired;
    }
        return ;
    }
    public void setAssemblerRequired(LanguageBooleanConfiguration assemblerRequired) {
        this. = assemblerRequired;
    }
    public PlatformInfo getPlatformInfo() {
        PlatformInfo platformInfo = PlatformInfo.getDefault(getDevelopmentHost().getExecutionEnvironment());
//        assert platformInfo.getPlatform() == getPlatform().getValue();
        return platformInfo;
    }
        return ;
    }
    public void setDevelopmentHost(DevelopmentHostConfiguration developmentHost) {
        this. = developmentHost;
    }
    public boolean isApplicationConfiguration() {
        switch (getConfigurationType().getValue()) {
            case :
            case :
                return true;
            default:
                return false;
        }
    }
    public boolean isCompileConfiguration() {
    }
    public boolean isLibraryConfiguration() {
        switch (getConfigurationType().getValue()) {
            case :
            case :
            case :
            case :
                return true;
            default:
                return false;
        }
    }
    public boolean isLinkerConfiguration() {
    }
    public boolean isMakefileConfiguration() {
        return getConfigurationType().getValue() == ;
    }
    public boolean isDynamicLibraryConfiguration() {
        switch (getConfigurationType().getValue()) {
            case :
            case :
                return true;
            default:
                return false;
        }
    }
    public boolean isArchiverConfiguration() {
        return getConfigurationType().getValue() == ;
    }
    public boolean isQmakeConfiguration() {
        switch (getConfigurationType().getValue()) {
            case :
            case :
            case :
                return true;
            default:
                return false;
        }
    }
    public void setCCompilerConfiguration(CCompilerConfiguration cCompilerConfiguration) {
        this. = cCompilerConfiguration;
    }
        return ;
    }
    public void setCCCompilerConfiguration(CCCompilerConfiguration ccCompilerConfiguration) {
        this. = ccCompilerConfiguration;
    }
        return ;
    }
    public void setFortranCompilerConfiguration(FortranCompilerConfiguration fortranCompilerConfiguration) {
        this. = fortranCompilerConfiguration;
    }
        return ;
    }
    public void setAssemblerConfiguration(AssemblerConfiguration assemblerConfiguration) {
        this. = assemblerConfiguration;
    }
        return ;
    }
    public void setLinkerConfiguration(LinkerConfiguration linkerConfiguration) {
        this. = linkerConfiguration;
        this..setMakeConfiguration(this);
    }
        return ;
    }
    public void setArchiverConfiguration(ArchiverConfiguration archiverConfiguration) {
        this. = archiverConfiguration;
    }
        return ;
    }
    public void setPackagingConfiguration(PackagingConfiguration packagingConfiguration) {
        this. = packagingConfiguration;
    }
        return ;
    }
    // LibrariesConfiguration
        return ;
    }
    public void setRequiredProjectsConfiguration(RequiredProjectsConfiguration requiredProjectsConfiguration) {
        this. = requiredProjectsConfiguration;
    }
        return ;
    }
    public void setDebuggerChooserConfiguration(DebuggerChooserConfiguration debuggerChooserConfiguration) {
        this. = debuggerChooserConfiguration;
    }
        return ;
    }
    public void setQmakeConfiguration(QmakeConfiguration qmakeConfiguration) {
        this. = qmakeConfiguration;
    }
    public void assign(Configuration conf) {
        MakeConfiguration makeConf = (MakeConfigurationconf;
        setName(makeConf.getName());
        setBaseDir(makeConf.getBaseDir());
        getConfigurationType().assign(makeConf.getConfigurationType());
        getDevelopmentHost().assign(makeConf.getDevelopmentHost());
        getCompilerSet().assign(makeConf.getCompilerSet());
        getCRequired().assign(makeConf.getCRequired());
        getCppRequired().assign(makeConf.getCppRequired());
        getFortranRequired().assign(makeConf.getFortranRequired());
        getAssemblerRequired().assign(makeConf.getAssemblerRequired());
        // do assign on all aux objects
        ConfigurationAuxObject[] auxs = getAuxObjects(); // from this profile
        //ConfigurationAuxObject[] p_auxs = conf.getAuxObjects(); // from the 'other' profile
        for (int i = 0; i < auxs.lengthi++) {
            // unsafe using! suppose same set of objects and same object order
            String id = auxs[i].getId();
            ConfigurationAuxObject object = conf.getAuxObject(id);
            if (object != null) {
                // safe using
                auxs[i].assign(object);
            } else {
                ..println("Configuration - assign: Object ID " + id + " do not found"); // NOI18N
            }
        }
    }
    public Configuration cloneConf() {
        return (Configurationclone();
    }

    
Make a copy of configuration requested from Project Properties

Returns:
Copy of configuration
    public Configuration copy() {
        copy.assign(this);
        // copy aux objects
        ConfigurationAuxObject[] auxs = getAuxObjects();
        Vector<ConfigurationAuxObjectcopiedAuxs = new Vector<ConfigurationAuxObject>();
        for (int i = 0; i < auxs.lengthi++) {
            if (auxs[iinstanceof ItemConfiguration) {
                copiedAuxs.add(((ItemConfigurationauxs[i]).copy(copy));
            } else {
                String id = auxs[i].getId();
                ConfigurationAuxObject copyAux = copy.getAuxObject(id);
                if (copyAux != null) {
                    copyAux.assign(auxs[i]);
                    copiedAuxs.add(copyAux);
                } else {
                    copiedAuxs.add(auxs[i]);
                }
            }
        }
        copy.setAuxObjects(copiedAuxs);
        return copy;
    }

    
Clone object
    @Override
    public Object clone() {
        MakeConfiguration clone = new MakeConfiguration(getBaseDir(), getName(),
                getConfigurationType().getValue(), getDevelopmentHost().getHostKey());
        super.cloneConf(clone);
        clone.setCloneOf(this);
        clone.setDevelopmentHost(dhconf);
        CompilerSet2Configuration csconf = getCompilerSet().clone();
        csconf.setDevelopmentHostConfiguration(dhconf);
        clone.setCompilerSet(csconf);
        clone.setCRequired(getCRequired().clone());
        clone.setCppRequired(getCppRequired().clone());
        clone.setFortranRequired(getFortranRequired().clone());
        dhconf.addPropertyChangeListener(csconf);
        // Clone all the aux objects
        //Vector clonedAuxObjects = new Vector();
        //for (Enumeration e = auxObjects.elements() ; e.hasMoreElements() ;) {
        //    ConfigurationAuxObject o = (ConfigurationAuxObject)e.nextElement();
        //    ConfigurationAuxObject clone2 = (ConfigurationAuxObject)o.clone();
        //    clonedAuxObjects.add(clone2);
        //}
        ConfigurationAuxObject[] objects = getAuxObjects();
        List<ConfigurationAuxObjectclonedAuxObjects = new ArrayList<ConfigurationAuxObject>();
        for (int i = 0; i < objects.lengthi++) {
            clonedAuxObjects.add(objects[i].clone(this));
        }
        clone.setAuxObjects(clonedAuxObjects);
        return clone;
    }
//    /** @deprecated Use org.netbeans.modules.cnd.makeproject.api.configurations.MakeConfiguration.getBuildSheet() instead */
//    public Sheet getGeneralSheet(Project project) {
//        return getBuildSheet(project);
//    }
    public Sheet getBuildSheet(Project project) {
        Sheet sheet = new Sheet();
        Sheet.Set set = new Sheet.Set();
        set.setName("ProjectDefaults"); // NOI18N
        set.setDisplayName(getString("ProjectDefaultsTxt"));
        set.setShortDescription(getString("ProjectDefaultsHint"));
        set.put(new DevelopmentHostNodeProp(getDevelopmentHost(), truegetString("DevelopmentHostTxt"), getString("DevelopmentHostHint"))); // NOI18N
        set.put(new CompilerSetNodeProp(getCompilerSet(), true"CompilerSCollection2"getString("CompilerCollectionTxt"), getString("CompilerCollectionHint"))); // NOI18N
        //set.put(new PlatformNodeProp(getPlatform(), false, getString("PlatformTxt"), getString("PlatformHint"))); // NOI18N
        set.put(new BooleanNodeProp(getCRequired(), true"cRequired"getString("CRequiredTxt"), getString("CRequiredHint"))); // NOI18N
        set.put(new BooleanNodeProp(getCppRequired(), true"cppRequired"getString("CppRequiredTxt"), getString("CppRequiredHint"))); // NOI18N
        set.put(new BooleanNodeProp(getFortranRequired(), true"fortranRequired"getString("FortranRequiredTxt"), getString("FortranRequiredHint"))); // NOI18N
        set.put(new BooleanNodeProp(getAssemblerRequired(), true"assemblerRequired"getString("AssemblerRequiredTxt"), getString("AssemblerRequiredHint"))); // NOI18N
        set.put(new IntNodeProp(getConfigurationType(), true"ConfigurationType"getString("ConfigurationTypeTxt"), getString("ConfigurationTypeHint"))); // NOI18N
        sheet.put(set);
        if (isCompileConfiguration()) {
            set = Sheet.createExpertSet();
            set.put(new BooleanNodeProp(getDependencyChecking(), true"DependencyChecking"getString("DependencyCheckingTxt"), getString("DependencyCheckingHint"))); // NOI18N
            sheet.put(set);
        }
        return sheet;
    }
    public Sheet getRequiredProjectsSheet(Project projectMakeConfiguration conf) {
        Sheet sheet = new Sheet();
        String[] texts = new String[]{getString("ProjectsTxt1"), getString("ProjectsHint"), getString("ProjectsTxt2"), getString("AllOptionsTxt2")};
        Sheet.Set set2 = new Sheet.Set();
        set2.setName("Projects"); // NOI18N
        set2.setDisplayName(getString("ProjectsTxt1"));
        set2.setShortDescription(getString("ProjectsHint"));
        set2.put(new RequiredProjectsNodeProp(getRequiredProjectsConfiguration(), projectconfgetBaseDir(), texts));
        sheet.put(set2);
        return sheet;
    }
    public void setRequiredLanguagesDirty(boolean b) {
         = b;
    }
    public boolean getRequiredLanguagesDirty() {
        return ;
    }
    public boolean hasCFiles(MakeConfigurationDescriptor configurationDescriptor) {
        reCountLanguages(configurationDescriptor);
        return .getValue();
    }
    public boolean hasCPPFiles(MakeConfigurationDescriptor configurationDescriptor) {
        reCountLanguages(configurationDescriptor);
        return .getValue();
    }
    public boolean hasFortranFiles(MakeConfigurationDescriptor configurationDescriptor) {
        reCountLanguages(configurationDescriptor);
        return .getValue();
    }
    public boolean hasAssemblerFiles(MakeConfigurationDescriptor configurationDescriptor) {
        reCountLanguages(configurationDescriptor);
        return .getValue();
    }
//    public boolean hasAsmFiles(MakeConfigurationDescriptor configurationDescriptor) {
//        if (getLanguagesDirty())
//            reCountLanguages(configurationDescriptor);
//        return asmRequired.getValue();
//    }
    public void reCountLanguages(MakeConfigurationDescriptor configurationDescriptor) {
        boolean hasCFiles = false;
        boolean hasCPPFiles = false;
        boolean hasFortranFiles = false;
        boolean hasAssemblerFiles = false;
        //boolean hasCAsmFiles = false;
        if (!getRequiredLanguagesDirty()) {
            return;
        }
        Item[] items = configurationDescriptor.getProjectItems();
        if (items.length == 0 && isMakefileConfiguration()) {
            // This may not be true but is our best guess. No way to know since no files have been added to project.
            hasCFiles = true;
            hasCPPFiles = true;
        } else {
            // Base it on actual files added to project
            for (int x = 0; x < items.lengthx++) {
                ItemConfiguration itemConfiguration = items[x].getItemConfiguration(this);
                if (itemConfiguration == null ||
                        itemConfiguration.getExcluded() == null ||
                        itemConfiguration.getExcluded().getValue()) {
                    continue;
                }
                if (itemConfiguration.getTool() == .) {
                    hasCFiles = true;
                }
                if (itemConfiguration.getTool() == .) {
                    hasCPPFiles = true;
                }
                if (itemConfiguration.getTool() == .) {
                    hasFortranFiles = true;
                }
                if (itemConfiguration.getTool() == .) {
                    hasAssemblerFiles = true;
                }
            //            if (itemConfiguration.getTool() == Tool.AsmCompiler) {
            //                hasCAsmFiles = false;
            //            }
            }
        }
        .setDefault(hasCFiles);
        .setDefault(hasCPPFiles);
        .setDefault(hasFortranFiles);
        .setDefault(hasAssemblerFiles);
        //asmRequired.setValueDef(hasCAsmFiles);
         = false;
    }
    public class LanguageBooleanConfiguration extends BooleanConfiguration {
        private boolean notYetSet = true;
        LanguageBooleanConfiguration() {
            super(nullfalse);
        }
        @Override
        public void setValue(boolean b) {
            if () {
                setValue(bb);
            } else {
                super.setValue(b);
            }
             = false;
        }
        @Override
        public void setDefault(boolean b) {
            if (getValue() == getDefault()) {
                setValue(bb);
            } else {
                super.setDefault(b);
            }
             = false;
        }
        public void setValue(boolean vboolean d) {
            super.setValue(v);
            super.setDefault(d);
             = false;
        }
        @Override
        public LanguageBooleanConfiguration clone() {
            LanguageBooleanConfiguration clone = new LanguageBooleanConfiguration();
            clone.setValue(getValue(), getDefault());
            clone.setModified(getModified());
            return clone;
        }
        public void assign(LanguageBooleanConfiguration conf) {
            setValue(conf.getValue(), conf.getDefault());
            setModified(conf.getModified());
        }
    }
    public String getVariant() {
        String ret = "";
        if (getCompilerSet().getCompilerSet() == null) {
            return ret;
        }
//        ret += getCompilerSet().getCompilerSet().getName() + "-"; // NOI18N
//        ret += Platforms.getPlatform(getPlatform().getValue()).getName();
//        return ret;
    }
    public static String getVariant(CompilerSet compilerSetint platform) {
        return compilerSet.getName() + "-" + Platforms.getPlatform(platform).getName(); // NOI18N
    }
    public Set<ProjectgetSubProjects() {
        Set<ProjectsubProjects = new HashSet<Project>();
        LibrariesConfiguration librariesConfiguration = getLinkerConfiguration().getLibrariesConfiguration();
        for (LibraryItem item : librariesConfiguration.getValue()) {
            if (item instanceof LibraryItem.ProjectItem) {
                LibraryItem.ProjectItem projectItem = (LibraryItem.ProjectItemitem;
                Project project = projectItem.getProject(getBaseDir());
                if (project != null) {
                    subProjects.add(project);
                } else {
                    // FIXUP ERROR
                }
            }
        }
        for (LibraryItem.ProjectItem libProject : getRequiredProjectsConfiguration().getValue()) {
            Project project = libProject.getProject(getBaseDir());
            if (project != null) {
                subProjects.add(project);
            }
        }
        return subProjects;
    }
    public Set<StringgetSubProjectLocations() {
        Set<StringsubProjectLocations = new HashSet<String>();
        LibrariesConfiguration librariesConfiguration = getLinkerConfiguration().getLibrariesConfiguration();
        for (LibraryItem item : librariesConfiguration.getValue()) {
            if (item instanceof LibraryItem.ProjectItem) {
                LibraryItem.ProjectItem projectItem = (LibraryItem.ProjectItemitem;
                subProjectLocations.add(projectItem.getMakeArtifact().getProjectLocation());
            }
        }
        return subProjectLocations;
    }
        Set<StringsubProjectOutputLocations = new HashSet<String>();
        LibrariesConfiguration librariesConfiguration = getLinkerConfiguration().getLibrariesConfiguration();
        for (LibraryItem item : librariesConfiguration.getValue()) {
            if (item instanceof LibraryItem.ProjectItem) {
                LibraryItem.ProjectItem projectItem = (LibraryItem.ProjectItemitem;
                String outputLocation = IpeUtils.getDirName(projectItem.getMakeArtifact().getOutput());
                if (IpeUtils.isPathAbsolute(outputLocation)) {
                    subProjectOutputLocations.add(outputLocation);
                } else {
                    subProjectOutputLocations.add(projectItem.getMakeArtifact().getProjectLocation() + "/" + outputLocation); // NOI18N
                } // NOI18N
            }
        }
        return subProjectOutputLocations;
    }
    public String getOutputValue() {
        String output = null;
        if (isLinkerConfiguration()) {
            output = getLinkerConfiguration().getOutputValue();
        } else if (isArchiverConfiguration()) {
            output = getArchiverConfiguration().getOutputValue();
        } else if (isMakefileConfiguration()) {
            output = getMakefileConfiguration().getOutput().getValue();
        } else if (isQmakeConfiguration()) {
            output = getQmakeConfiguration().getOutputValue();
        } else {
            assert false;
        }
        return output;
    }
    public String getAbsoluteOutputValue() {
        String output = getOutputValue();
        if (output == null) {
            return output;
        }
        if (!IpeUtils.isPathAbsolute(output)) {
            output = getBaseDir() + "/" + output// NOI18N
            output = FilePathAdaptor.normalize(output);
        }
        return expandMacros(output);
    }
    public boolean hasDebugger() {
        return ProjectActionSupport.getInstance().canHandle(this..);
    }
    public String expandMacros(String val) {
        // Substitute macros
        val = IpeUtils.expandMacro(val"${OUTPUT_PATH}"getOutputValue()); // NOI18N
        val = IpeUtils.expandMacro(val"${OUTPUT_BASENAME}", IpeUtils.getBaseName(getOutputValue())); // NOI18N
        val = IpeUtils.expandMacro(val"${PLATFORM}"getVariant()); // Backward compatibility // NOI18N
        val = IpeUtils.expandMacro(val"${CND_PLATFORM}"getVariant()); // NOI18N
        val = IpeUtils.expandMacro(val"${CND_CONF}"getName()); // NOI18N
        val = IpeUtils.expandMacro(val"${CND_DISTDIR}".); // NOI18N
        return val;
    }
//
//    private String[] getCompilerSetDisplayNames() {
//        ArrayList<String> names = new ArrayList();
//        for (CompilerSet cs : CompilerSetManager.getDefault(getDevelopmentHost().getName()).getCompilerSets()) {
//            names.add(cs.getDisplayName());
//        }
//        return names.toArray(new String[0]);
//    }
//
//    private String[] getCompilerSetNames() {
//        ArrayList<String> names = new ArrayList();
//        for (CompilerSet cs : CompilerSetManager.getDefault(getDevelopmentHost().getName()).getCompilerSets()) {
//            names.add(cs.getName());
//        }
//        return names.toArray(new String[0]);
//    }
//
//    private int getDefaultCompilerSetIndex() {
//        String name = CppSettings.getDefault().getCompilerSetName();
//        int i = 0;
//        for (CompilerSet cs : CompilerSetManager.getDefault(getDevelopmentHost().getName()).getCompilerSets()) {
//            if (name.equals(cs.getName())) {
//                return i;
//            }
//            i++;
//        }
//        return 0; // shouldn't happen
//    }

    
Look up i18n strings here
    private static String getString(String s) {
        return NbBundle.getMessage(MakeConfiguration.classs);
    }