Changeset 13751


Ignore:
Timestamp:
Oct 15, 2019 1:21:32 PM (5 weeks ago)
Author:
molsson
Message:

Merged revision(s) 13732 from trunk

Location:
branches/dev-jk-2483
Files:
10 edited

Legend:

Unmodified
Added
Removed
  • branches/dev-jk-2483

  • branches/dev-jk-2483/Compiler/ModelicaCompiler/src/jastadd/DebugCompiler.jrag

    r11966 r13751  
    130130                mc.setLogger(out);
    131131                ModelicaCompiler.TargetObject targ = (ModelicaCompiler.TargetObject) target.getSelectedItem();
    132                 mc.compileModel(new String[] { file.getAbsolutePath() }, name, targ, null, null);
     132                mc.compileModel(new String[] { file.getAbsolutePath() }, name, targ, null);
    133133            } catch (Exception ex) {
    134134                out.writeException(ex);
  • branches/dev-jk-2483/Compiler/ModelicaCompiler/src/jastadd/ModelicaCompiler.jrag

    r13721 r13751  
    348348            hooks.packFmu(this, fc, dir);
    349349        }
    350         fc.root().getUtilInterface().packFmu(fc);
     350        fc.root().getUtilInterface().packFmu(fc, dir.toPath());
    351351    }
    352352   
     
    358358            hooks.fmuPacked(this, fc, path);
    359359        }
    360         fc.root().getUtilInterface().fmuPacked(fc, path);
     360        fc.root().getUtilInterface().fmuPacked(fc, path.toPath());
    361361    }
    362362   
     
    811811             * Compile mo-file and generate code for all templates that are not null.
    812812             */
    813             String flatName = null;
    814             if (!Files.isDirectory(compileTo)) {
    815                 flatName = compileTo.getFileName().toString();
    816                 int i = flatName.lastIndexOf('.');
    817                 if (i > 0) {
    818                     flatName = flatName.substring(0, i);
    819                 }
    820             }
    821             FClass fc = compileModel(fileName, className, target, flatName, compileTo);
     813            FClass fc = compileModel(fileName, className, target, compileTo);
    822814
    823815            if (!target.getCodeGenFlag()) {
     
    832824             */
    833825            hookCheckAbort();
    834             doCompileCCode(target, fc, className, flatName);
     826            doCompileCCode(target, fc);
    835827
    836828            /*
     
    838830             */
    839831            ASTNode.beginStep("packUnit()");
    840             File unitPath = packUnit(className, target, fc);
     832            Path unitPath = packUnit(className, target, fc);
    841833            unit = log.logCompiledUnit(unitPath, warnings, fc.numberOfComponents());
    842834            ASTNode.endStep("packUnit()");
     
    13691361        ASTNode.beginStep("generateCode()");
    13701362        log.info("Generating code...");
     1363       
    13711364        String name = fc.nameUnderscore();
    1372        
    13731365        Templates templates = target.getTemplates(getOptions());
    1374    
    1375         templates.generateCFiles(this, fc, createCGenerator(fc), sourceDir, name);
    1376         templates.generateXMLFiles(this, fc, target.getXMLGenerator(fc), outDir, "modelDescription");
     1366       
     1367        generateAllFiles(fc, target, templates, name);
    13771368        hookCodeGenerated(fc, outDir);
    13781369       
     
    19601951     * @param target
    19611952     *            The target object for the compiler.
    1962      * @param flatName
    1963      *            Name of the unit/flat model supplied by the user, if any.
    19641953     *
    19651954     * @return A flat representation of the class specified by <code>cl</code>.
     
    19831972     * @deprecated Use {@link #compileModel(Path[], String, TargetObject, String, Path)} instead
    19841973     */
    1985     public FClass ModelicaCompiler.compileModel(String files[], String cl, TargetObject target, String flatName, String compileTo)
     1974    public FClass ModelicaCompiler.compileModel(String files[], String cl, TargetObject target, String compileTo)
    19861975          throws ModelicaException, FileNotFoundException, IOException, beaver.Parser.Exception {
    1987         return compileModel(stringsToPaths(files), cl, target, flatName, compileTo == null ? null : Paths.get(compileTo));
     1976        return compileModel(stringsToPaths(files), cl, target, compileTo == null ? null : Paths.get(compileTo));
    19881977    }
    19891978   
     
    19991988     * @param target
    20001989     *            The target object for the compiler.
    2001      * @param flatName
    2002      *            Name of the unit/flat model supplied by the user, if any.
    20031990     *
    20041991     * @return A flat representation of the class specified by <code>cl</code>.
     
    20222009     * @deprecated Use {@link #compileModel(Path[], String, TargetObject, String, Path)} instead
    20232010     */
    2024      public FClass ModelicaCompiler.compileModel(Path files[], String cl, TargetObject target, String flatName, Path compileTo)
     2011     public FClass ModelicaCompiler.compileModel(Path files[], String cl, TargetObject target, Path compileTo)
    20252012          throws ModelicaException, FileNotFoundException, IOException, beaver.Parser.Exception {
    20262013        boolean doTearDown = true;
    20272014        try {
    20282015            doTearDown = trySetUp();
    2029             return doCompileModel(files, cl, target, flatName, compileTo);
     2016            return doCompileModel(files, cl, target, compileTo);
    20302017        } finally {
    20312018            tryTearDown(doTearDown);
     
    20332020    }
    20342021   
    2035     public FClass ModelicaCompiler.doCompileModel(String name[], String cl, TargetObject target, String flatName, String compileTo)
    2036           throws ModelicaException, FileNotFoundException, IOException, beaver.Parser.Exception {
    2037         return doCompileModel(stringsToPaths(name), cl, target, flatName, compileTo == null ? null : Paths.get(compileTo));
    2038     }
    2039    
    2040    
    2041     public FClass ModelicaCompiler.doCompileModel(Path name[], String cl, TargetObject target, String flatName, Path compileTo)
     2022   
     2023    public FClass ModelicaCompiler.doCompileModel(Path name[], String cl, TargetObject target, Path compileTo)
    20422024          throws ModelicaException, FileNotFoundException, IOException, beaver.Parser.Exception {
    20432025        if (target.equals(TargetObject.PARSE)) {
     
    20622044            // compute instance tree
    20632045            InstClassDecl icl = instantiateModel(name, cl, target);
     2046            UtilInterface util = icl.root().getUtilInterface();
     2047            if (compileTo != null) {
     2048                Path unitFile = makePackagingDirs(cl, compileTo, target);
     2049                util.setCompilationOutputPath(unitFile);
     2050            }
    20642051           
    2065             if (compileTo != null) {
    2066                 File unitFile = makePackagingDirs(cl, compileTo.toFile(), target);
    2067                 icl.root().getUtilInterface().setCompilationOutputPath(unitFile);
    2068             }
     2052            String flatName = computeFlatName(compileTo, util);
    20692053           
    20702054            // flattening
     
    22072191     * Packs an FMU (helper function for {@link #compileUnit()}).
    22082192     */
    2209     protected File ModelicaCompiler.packUnit(String className,
     2193    protected Path ModelicaCompiler.packUnit(String className,
    22102194            TargetObject target, FClass fClass) throws PackingFailedException {
    2211 
    2212         File unitFile = fClass.root().getUtilInterface().getCompilationOutputPath();
    2213 
     2195        Path unitFile = fClass.root().getUtilInterface().getCompilationOutputPath();
     2196       
    22142197        hookPackFmu(fClass, outDir);
     2198        hookCheckAbort();
     2199        packUnit(className, target, fClass, unitFile);
     2200        hookFmuPacked(fClass, unitFile.toAbsolutePath().toFile());
     2201       
     2202        return unitFile;
     2203    }
     2204   
     2205    private void ModelicaCompiler.packUnit(String className, TargetObject target, FClass fClass, Path unitFile) {
    22152206        try {
    2216             hookCheckAbort();
    22172207            copySourceFiles(fClass, sourceDir, outDir);
    2218 
    2219             OutputStream dest = new BufferedOutputStream(new FileOutputStream(unitFile));
    2220             ZipOutputStream out = new ZipOutputStream(new BufferedOutputStream(dest));
    2221             out.setMethod(ZipOutputStream.DEFLATED);
    2222 
    2223             zipDir(outDir, out);
    2224             out.close();
    2225         } catch (CompilationAbortedException e) {
    2226             throw e;
     2208            try (ZipOutputStream out = new ZipOutputStream(new BufferedOutputStream(Files.newOutputStream(unitFile)))) {
     2209                out.setMethod(ZipOutputStream.DEFLATED);
     2210                zipDir(outDir, out);
     2211            }
    22272212        } catch (Exception e) {
    22282213            throw new PackingFailedException(String.format("Could not write to '%s'.", unitFile), e);
    22292214        }
    2230 
    2231         hookFmuPacked(fClass, unitFile.getAbsoluteFile());
    2232         return unitFile;
    22332215    }
    22342216
     
    22482230    }
    22492231
    2250     private void ModelicaCompiler.doCompileCCode(TargetObject target,  FClass fc, String className, String flatName) {
     2232    private void ModelicaCompiler.doCompileCCode(TargetObject target,  FClass fc) {
    22512233        if (target.getMakeFileFlag() != null) {
    22522234                ASTNode.beginStep("compileCCode()");
    2253                 String cFileName = (flatName != null) ? flatName : FClass.convertClassNameToUnderscore(className);
     2235                String cFileName = fc.nameUnderscore();
    22542236                CCompilerDelegator ccompiler = getCCompiler();
    22552237                CCompilerArguments ccArgs = new CCompilerArguments(cFileName, fc.myOptions(), target, fc.externalLibraries(), fc.externalLibraryDirectories(),
     
    22642246    /**
    22652247     * Calculates the destination directory for a packaged unit. If the specified destination is a file its directory
    2266      * is chosen as destination. If the destination does not exist, it is created (using {@link File#mkdirs()}).
     2248     * is chosen as destination. If the destination does not exist, it is created (using {@link Filed#createDirectories()}).
    22672249     *
    22682250     * @param className
     
    22732255     *          A {@link TargetObject} containing information about the target.
    22742256     * @return
    2275      *          the path to the destination directory of the packaged unit.
     2257     *          the path to the destination file of the packaged unit.
    22762258     */
    2277     private File ModelicaCompiler.makePackagingDirs(String className, File destination, TargetObject target) {
    2278         File dest = new File(destination.getAbsolutePath());
    2279         if (dest.isDirectory()) {
     2259    private Path ModelicaCompiler.makePackagingDirs(String className, Path destination, TargetObject target)
     2260            throws IOException {
     2261        Path dest = destination.toAbsolutePath();
     2262        if (Files.isDirectory(dest)) {
    22802263            String mangledName = FClass.convertClassNameToUnderscore(className);
    2281             dest = new File(dest, mangledName + "." + target.getUnitSuffix());
     2264            dest = dest.resolve(mangledName + "." + target.getUnitSuffix());
    22822265        } else {
    2283             File destDir = dest.getParentFile();
    2284             if (destDir != null && !destDir.isDirectory()) {
    2285                 dest.getParentFile().mkdirs();
     2266            Path destDir = dest.getParent();
     2267            if (destDir != null && !Files.isDirectory(destDir)) {
     2268                Files.createDirectories(dest.getParent());
    22862269            }
    22872270        }
    22882271        return dest;
     2272    }
     2273   
     2274    private void ModelicaCompiler.generateAllFiles(FClass fc, TargetObject target, Templates templates, String name)
     2275            throws FileNotFoundException {
     2276        templates.generateCFiles(this, fc, createCGenerator(fc), sourceDir, name);
     2277        templates.generateXMLFiles(this, fc, target.getXMLGenerator(fc), outDir, "modelDescription");
     2278    }
     2279   
     2280    private String ModelicaCompiler.computeFlatName(Path compileTo, UtilInterface util) {
     2281        String flatName = null;
     2282        if (compileTo != null && !Files.isDirectory(compileTo)) {
     2283            flatName = compileTo.getFileName().toString();
     2284            int i = flatName.lastIndexOf('.');
     2285            if (i > 0) {
     2286                flatName = flatName.substring(0, i);
     2287            }
     2288        }
     2289        return flatName;
    22892290    }
    22902291
  • branches/dev-jk-2483/Compiler/ModelicaCompiler/src/jastadd/UtilInterface.jrag

    r13396 r13751  
    4141             * Called after code has been compiled.
    4242             */
    43             public void packFmu(FClass fc) {}
     43            public void packFmu(FClass fc, Path outDir) {}
    4444           
    4545            /**
    4646             * Called after code has been compiled.
    4747             */
    48             public void fmuPacked(FClass fc, File path) {}
     48            public void fmuPacked(FClass fc, Path outDir) {}
    4949           
    5050            /**
     
    7272        private ExternalFunctionCache efc;
    7373        private GUIDManager guidManager;
    74         private File compilationOutputPath;
     74        private Path compilationOutputPath;
    7575       
    76         protected UtilInterface(ModelicaCompiler mc, OptionRegistry options, IErrorHandler eh, ExternalFunctionCache efc, File compilationOutputPath) {
     76        protected UtilInterface(ModelicaCompiler mc, OptionRegistry options, IErrorHandler eh, ExternalFunctionCache efc, Path compilationOutputPath) {
    7777            this.mc = mc;
    7878            this.options = options;
     
    110110        }
    111111       
    112         public File getCompilationOutputPath() {
     112        public Path getCompilationOutputPath() {
    113113            return compilationOutputPath;
    114114        }
    115115       
    116         public void setCompilationOutputPath(File compilationOutputPath) {
     116        public void setCompilationOutputPath(Path compilationOutputPath) {
    117117            this.compilationOutputPath = compilationOutputPath;
    118118        }
     
    146146    }
    147147   
    148     public void UtilInterface.packFmu(FClass fc) {
     148    public void UtilInterface.packFmu(FClass fc, Path outDir) {
    149149        for (Interfacer interfacer : interfacers) {
    150             interfacer.packFmu(fc);
     150            interfacer.packFmu(fc, outDir);
    151151        }
    152152    }
    153153   
    154     public void UtilInterface.fmuPacked(FClass fc, File path) {
     154    public void UtilInterface.fmuPacked(FClass fc, Path outDir) {
    155155        for (Interfacer interfacer : interfacers) {
    156             interfacer.fmuPacked(fc, path);
     156            interfacer.fmuPacked(fc, outDir);
    157157        }
    158158    }
  • branches/dev-jk-2483/Compiler/ModelicaCompilerCasADi/src/jastadd/FExpToCasADi.jrag

    r12770 r13751  
    3131            target.setDefaultOptions(options);
    3232            try {
    33                 return compileModel(name, cl, target, null, null);
     33                return compileModel(name, cl, target, null);
    3434            } finally {
    3535                options.copyAllOptions(tempOptions);
  • branches/dev-jk-2483/Compiler/ModelicaFrontEnd/src/jastadd/instance/InstLookupClasses.jrag

    r13532 r13751  
    261261        HashMap<String,SrcLibNode> map = new HashMap<String,SrcLibNode>(prog.getNumSrcLibNode() * 4 / 3 + 1);
    262262        for (SrcLibNode ln : prog.getSrcLibNodes()) {
    263             if (!map.containsKey(ln.name())) {
    264                 map.put(ln.name(), ln);
     263            String name = ln.name().toLowerCase();
     264            if (!map.containsKey(name)) {
     265                map.put(name, ln);
    265266            }
    266267        }
     
    269270
    270271    syn lazy InstLookupResult<InstClassDecl> InstProgramRoot.lookupLibrary(String name) {
    271         SrcLibNode ln = libraryMap().get(name);
     272        SrcLibNode ln = libraryMap().get(name.toLowerCase());
    272273        if (ln != null) {
    273274            InstClassDecl icd = createInstClassDecl(ln);
  • branches/dev-jk-2483/Compiler/ModelicaFrontEnd/src/java/org/jmodelica/common/GUIDManager.java

    r13396 r13751  
    22
    33import java.io.BufferedReader;
    4 import java.io.BufferedWriter;
     4import java.io.ByteArrayInputStream;
    55import java.io.ByteArrayOutputStream;
    66import java.io.File;
    7 import java.io.FileNotFoundException;
    8 import java.io.FileReader;
    9 import java.io.FileWriter;
    107import java.io.IOException;
    11 import java.io.OutputStreamWriter;
    12 import java.io.Reader;
    13 import java.io.StringReader;
    14 import java.io.Writer;
     8import java.io.InputStream;
     9import java.io.InputStreamReader;
     10import java.io.OutputStream;
     11import java.io.PrintWriter;
    1512import java.math.BigInteger;
    1613import java.nio.charset.Charset;
     14import java.nio.file.Files;
     15import java.nio.file.Path;
    1716import java.security.MessageDigest;
    1817import java.security.NoSuchAlgorithmException;
     
    6564
    6665    public void setSourceFile(File source) {
     66        this.source = new FileOpenable(source.toPath());
     67    }
     68
     69    public void setSourceFile(Path source) {
    6770        this.source = new FileOpenable(source);
    6871    }
     
    7376
    7477    public void addDependentFile(File dependentFile) {
     78        dependentFiles.add(new FileOpenable(dependentFile.toPath()));
     79    }
     80
     81    public void addDependentFile(Path dependentFile) {
    7582        dependentFiles.add(new FileOpenable(dependentFile));
    7683    }
    7784
    78     public void addDependentString(String input, StringBuilder output) {
     85    public void addDependentString(String input, ByteArrayOutputStream output) {
    7986        dependentFiles.add(new StringOpenable(input, output));
    8087    }
     
    8592            final MessageDigest md5 = MessageDigest.getInstance("MD5");
    8693
    87             try (final BufferedReader reader = new BufferedReader(source.openInput())) {
     94            try (final BufferedReader reader = new BufferedReader(new InputStreamReader(source.openInput()))) {
    8895                String line = reader.readLine();
    8996                while (line != null) {
     
    118125        for (final Openable openable : dependentFiles) {
    119126            try {
    120                 ByteArrayOutputStream os = new ByteArrayOutputStream();
    121                 try (final Writer tmp = new OutputStreamWriter(os)) {
    122                     processFiles(openable.openInput(), tmp);
    123                 }
    124 
    125                 try (BufferedWriter writer = new BufferedWriter(openable.openOutput())) {
    126                     writer.append(os.toString());
     127                try (ByteArrayOutputStream os = new ByteArrayOutputStream()) {
     128                    processFiles(openable.openInput(), os);
     129                    try (PrintWriter writer = new PrintWriter(openable.openOutput())) {
     130                        writer.append(os.toString());
     131                    }
    127132                }
    128133            } catch (IOException e) {
     
    132137    }
    133138
    134     private void processFiles(Reader source, Writer destination) throws IOException {
    135         try (final BufferedReader reader = new BufferedReader(source);
    136                 final BufferedWriter writer = new BufferedWriter(destination)) {
     139    private void processFiles(InputStream source, OutputStream destination) throws IOException {
     140        try (final BufferedReader reader = new BufferedReader(new InputStreamReader(source));
     141             final PrintWriter writer = new PrintWriter(destination)) {
    137142
    138143            String line =  reader.readLine();
     
    200205
    201206    private static interface Openable {
    202         public Reader openInput();
    203         public Writer openOutput();
     207        public InputStream openInput();
     208        public OutputStream openOutput();
    204209    }
    205210   
    206     private static class FileOpenable implements Openable{
    207         private File file;
    208        
    209         public FileOpenable(File file) {
    210             this.file = file;
    211         }
    212        
    213         @Override
    214         public Reader openInput() {
     211    private static class FileOpenable implements Openable {
     212        private Path path;
     213       
     214        public FileOpenable(Path file) {
     215            this.path = file;
     216        }
     217       
     218        @Override
     219        public InputStream openInput() {
    215220            try {
    216                 return new FileReader(file);
    217             } catch (FileNotFoundException e) {
    218                 throw new RuntimeException(e);
    219             }
    220         }
    221        
    222         @Override
    223         public Writer openOutput() {
    224             try {
    225                 return new FileWriter(file);
     221                return Files.newInputStream(path);
    226222            } catch (IOException e) {
    227223                throw new RuntimeException(e);
     
    230226       
    231227        @Override
     228        public OutputStream openOutput() {
     229            try {
     230                return Files.newOutputStream(path);
     231            } catch (IOException e) {
     232                throw new RuntimeException(e);
     233            }
     234        }
     235       
     236        @Override
    232237        public String toString() {
    233             return file.toString();
     238            return path.toString();
    234239        }
    235240    }
     
    238243       
    239244        private String input;
    240         private StringBuilder output;
    241        
    242         public StringOpenable(String input, StringBuilder output) {
     245        private ByteArrayOutputStream output;
     246       
     247        public StringOpenable(String input, ByteArrayOutputStream output) {
    243248            this.input = input;
    244249            this.output = output;
     
    246251       
    247252        @Override
    248         public Reader openInput() {
    249             return new StringReader(input);
    250         }
    251        
    252         @Override
    253         public Writer openOutput() {
    254             return new Writer() {
    255                
    256                 @Override
    257                 public void write(char[] cbuf, int off, int len) throws IOException {
    258                     output.append(cbuf, off, len);
    259                 }
    260                
    261                 @Override
    262                 public void flush() throws IOException {
    263                     // Do nothing
    264                 }
    265                
    266                 @Override
    267                 public void close() throws IOException {
    268                     // Do nothing
    269                 }
    270             };
     253        public InputStream openInput() {
     254            return new ByteArrayInputStream(input.getBytes());
     255        }
     256       
     257        @Override
     258        public OutputStream openOutput() {
     259            return output;
    271260        }
    272261    }
  • branches/dev-jk-2483/Compiler/ModelicaFrontEnd/src/java/org/jmodelica/util/files/FileUtil.java

    r11394 r13751  
    33import java.io.File;
    44import java.io.IOException;
     5import java.nio.file.DirectoryStream;
    56import java.nio.file.Files;
     7import java.nio.file.Path;
    68import java.nio.file.Paths;
    79import java.nio.file.StandardCopyOption;
     
    155157        return names;
    156158    }
     159   
     160    /**
     161     * @return A collection of all files in {@code dir} matching the {@code glob}
     162     *         pattern
     163     */
     164    public static Collection<Path> getMatching(Path dir, String glob) throws IOException {
     165        Collection<Path> res = new ArrayList<>();
     166        try (DirectoryStream<Path> stream = Files.newDirectoryStream(dir, glob)) {
     167            for (Path path : stream) {
     168                res.add(path);
     169            }
     170        }
     171        return res;
     172    }
    157173
    158174    /**
     
    234250     *             if there was any error copying the files.
    235251     */
    236     public static void copyRecursive(Collection<File> files, File destination, boolean replace) throws IOException {
     252    public static void copyRecursive(Iterable<File> files, File destination, boolean replace) throws IOException {
    237253        for (File file : files) {
    238254            copyRecursive(file, destination, replace);
     255        }
     256    }
     257   
     258    /**
     259     * Copies file to a directory. Contents of directories is copied recursively.
     260     *
     261     * @param sourceFile
     262     *            The file to copy.
     263     * @param destDir
     264     *            The destination directory.
     265     * @throws IOException
     266     *             if there was any error copying the files.
     267     */
     268    public static void copyRecursive(Path sourceFile, Path destDir) throws IOException {
     269        Path outFile = destDir.resolve(sourceFile.getFileName());
     270        if (Files.isDirectory(sourceFile)) {
     271            if (!Files.exists(outFile)) {
     272                Files.createDirectory(outFile);
     273            }
     274            try (DirectoryStream<Path> stream = Files.newDirectoryStream(sourceFile)) {
     275                copyRecursive(stream, outFile);
     276            }
     277        } else {
     278            Files.copy(sourceFile, outFile, StandardCopyOption.REPLACE_EXISTING);
     279        }
     280    }
     281   
     282    /**
     283     * Copies several files to a directory.
     284     *
     285     * @param sourceFiles
     286     *            The files to copy.
     287     * @param destDir
     288     *            The destination directory.
     289     * @throws IOException
     290     *             if there was any error copying the files.
     291     */
     292    public static void copyRecursive(Iterable<Path> sourceFiles, Path destDir) throws IOException {
     293        for (Path file : sourceFiles) {
     294            copyRecursive(file, destDir);
    239295        }
    240296    }
  • branches/dev-jk-2483/Compiler/ModelicaFrontEnd/test/junit/org/jmodelica/test/common/GUIDManagerTest.java

    r13396 r13751  
    44import static org.junit.Assert.assertFalse;
    55import static org.junit.Assert.assertTrue;
     6
     7import java.io.ByteArrayOutputStream;
    68
    79import org.jmodelica.common.GUIDManager;
     
    2022    private void test(String source, String[] dependent, String[] expected) {
    2123        guidManager.setSourceString(source);
    22         StringBuilder[] output = new StringBuilder[dependent.length];
     24        ByteArrayOutputStream[] output = new ByteArrayOutputStream[dependent.length];
    2325        for (int i = 0; i < dependent.length; i++) {
    24             output[i] = new StringBuilder();
     26            output[i] = new ByteArrayOutputStream();
    2527            guidManager.addDependentString(dependent[i], output[i]);
    2628        }
     
    4749        String expected = "guid=277efff8e9f33c422aa6e3fecb8b592";
    4850        guidManager.setSourceString(input);
    49         StringBuilder output = new StringBuilder();
     51        ByteArrayOutputStream output = new ByteArrayOutputStream();
    5052        guidManager.addDependentString(input, output);
    5153        guidManager.processDependentFiles();
  • branches/dev-jk-2483/Compiler/TestFramework/src/jastadd/CodeGenTestCase.jrag

    r11966 r13751  
    4444       
    4545        GUIDManager guidManager = fc.guidManager();
    46         StringBuilder actual = new StringBuilder();
     46        ByteArrayOutputStream actual = new ByteArrayOutputStream();
    4747        guidManager.setSourceString(test);
    4848        guidManager.addDependentString(test, actual);
Note: See TracChangeset for help on using the changeset viewer.