source: branches/dev-5819/Compiler/ModelicaCompiler/src/jastadd/UtilInterface.jrag @ 13600

Last change on this file since 13600 was 13600, checked in by randersson, 3 months ago

#5819 Merged JM trunk into branch.

File size: 5.4 KB
Line 
1aspect UtilInterface {
2   
3    private UtilInterface Root.utilInterface = null;
4   
5    public void Root.setUtilInterface(UtilInterface utilInterface) {
6        if (this.utilInterface != null || utilInterface == null) {
7            throw new UnsupportedOperationException();
8        }
9        this.utilInterface = utilInterface;
10    }
11   
12    public UtilInterface Root.getUtilInterface() {
13        return utilInterface;
14    }
15   
16   
17    /**
18     * Provides easy access to non-ast utils via the AST root.
19     */
20    public class UtilInterface {
21       
22        /**
23         * Registers interfacers when UtilInterface is created.
24         */
25        interface Registrant {
26            boolean enabled(UtilInterface uif);
27            Interfacer getInterfacer(UtilInterface uif);
28        }
29       
30        /**
31         * Hooks for different steps in the compilation. Can keep states as opposed to the
32         * CompilationHooks in ModelicaCompiler.
33         */
34        static abstract class Interfacer {
35            /**
36             * Called after model has been instantiated.
37             */
38            public void modelInstantiated(InstClassDecl icd) {}
39           
40            /**
41             * Called after code has been compiled.
42             */
43            public void packFmu(FClass fc) {}
44           
45            /**
46             * Called after code has been compiled.
47             */
48            public void fmuPacked(FClass fc, File path) {}
49           
50            /**
51             * Called at each transfer and on tearDown.
52             */
53            public void clean() {}
54           
55            /**
56             * Called at end of compilation.
57             */
58            public void tearDown() {}
59        }
60       
61        private static LinkedList<Registrant> registrants = new LinkedList<>();
62        private static Registrant addRegistrant(Registrant registrant) {
63            registrants.add(registrant);
64            return registrant;
65        }
66       
67        private LinkedList<Interfacer> interfacers;
68       
69        private ModelicaCompiler mc;
70        private OptionRegistry options;
71        private IErrorHandler eh;
72        private ExternalFunctionCache efc;
73        private GUIDManager guidManager;
74        private File compilationOutputPath;
75       
76        protected UtilInterface(ModelicaCompiler mc, OptionRegistry options, IErrorHandler eh, ExternalFunctionCache efc, File compilationOutputPath) {
77            this.mc = mc;
78            this.options = options;
79            this.eh = eh;
80            this.efc = efc;
81            this.compilationOutputPath = compilationOutputPath;
82            guidManager = new GUIDManager(ASTNode.vendorName(), options.getStringOption("compiler_version"));
83           
84            interfacers = new LinkedList<>();
85            for (UtilInterface.Registrant registrant : registrants) {
86                if (registrant.enabled(this)) {
87                    interfacers.add(registrant.getInterfacer(this));
88                }
89            }
90        }
91       
92        public ModelicaCompiler getModelicaCompiler() {
93            return mc;
94        }
95       
96        public OptionRegistry getOptionRegistry() {
97            return options;
98        }
99       
100        public IErrorHandler getErrorHandler() {
101            return eh;
102        }
103       
104        public ExternalFunctionCache getExternalFunctionCache() {
105            return efc;
106        }
107       
108        public GUIDManager getGuidManager() {
109            return guidManager;
110        }
111       
112        public File getCompilationOutputPath() {
113            return compilationOutputPath;
114        }
115       
116        public void setCompilationOutputPath(File compilationOutputPath) {
117            this.compilationOutputPath = compilationOutputPath;
118        }
119    }
120   
121    UtilInterface ModelicaCompiler.createUtilInterface() {
122        return UtilInterface.create(this);
123    }
124   
125    public static UtilInterface UtilInterface.create(ModelicaCompiler mc) {
126        return new UtilInterface(mc, mc.getOptions(), mc.getErrorHandler(), mc.getExternalFunctionCache(), null);
127    }
128   
129    public static UtilInterface UtilInterface.create(OptionRegistry options) {
130        return new UtilInterface(null, options, new DefaultErrorHandler(), null, null);
131    }
132   
133    public void Root.transferRoot(Root other) {
134        other.getUtilInterface().transferRoot(this);
135    }
136   
137    public void UtilInterface.transferRoot(Root root) {
138        clean();
139        root.setUtilInterface(this);
140    }
141   
142    public void UtilInterface.modelInstantiated(InstClassDecl icd) {
143        for (Interfacer interfacer : interfacers) {
144            interfacer.modelInstantiated(icd);
145        }
146    }
147   
148    public void UtilInterface.packFmu(FClass fc) {
149        for (Interfacer interfacer : interfacers) {
150            interfacer.packFmu(fc);
151        }
152    }
153   
154    public void UtilInterface.fmuPacked(FClass fc, File path) {
155        for (Interfacer interfacer : interfacers) {
156            interfacer.fmuPacked(fc, path);
157        }
158    }
159   
160    public void UtilInterface.tearDown() {
161        clean();
162        for (Interfacer interfacer : interfacers) {
163            interfacer.tearDown();
164        }
165    }
166   
167    public void UtilInterface.clean() {
168        ExternalFunctionCache efc = getExternalFunctionCache();
169        if (efc != null) {
170            efc.destroyProcesses();
171        }
172        for (Interfacer interfacer : interfacers) {
173            interfacer.clean();
174        }
175    }
176}
Note: See TracBrowser for help on using the repository browser.