OpenCores
URL https://opencores.org/ocsvn/socgen/socgen/trunk

Subversion Repositories socgen

[/] [socgen/] [trunk/] [tools/] [ip-xact/] [1685-2014/] [generator.xsd] - Blame information for rev 135

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 135 jt_eaton
2
3
50
51
        
52
        
53
        
54
        
55
                
56
                        
57
                                
58
                                
59
                                        
60
                                                
61
                                                        Select other generator chain files for inclusion into this chain. The boolean attribute "unique" (default false) specifies that only a single generator is valid in this context. If more that one generator is selected based on the selection criteria, DE will prompt the user to resolve to a single generator.
62
                                                
63
                                                
64
                                                        
65
                                                                
66
                                                                
67
                                                                        
68
                                                                                Select another generator chain using the unique identifier of this generator chain.
69
                                                                        
70
                                                                
71
                                                        
72
                                                        
73
                                                                
74
                                                                        Specifies that only a single generator is valid in this context. If more that one generator is selcted based on the selection criteria, DE will prompt the user to resolve to a single generator.
75
                                                                
76
                                                        
77
                                                        
78
                                                
79
                                        
80
                                        
81
                                                
82
                                                        Selects generators declared in components of the current design for inclusion into this generator chain.
83
                                                
84
                                        
85
                                        
86
                                
87
                                
88
                                        
89
                                                Identifies this generator chain as belonging to the named group. This is used by other generator chains to select this chain for programmatic inclusion.
90
                                        
91
                                        
92
                                                
93
                                                        
94
                                                                
95
                                                        
96
                                                
97
                                        
98
                                
99
                                
100
                                
101
                                
102
                                
103
                                
104
                                
105
                        
106
                        
107
                                
108
                                        If this attribute is true then the generator should not be presented to the user, it may be part of a chain and has no useful meaning when invoked standalone.
109
                                
110
                        
111
                        
112
                
113
        
114
        
115
                
116
                        Specifies a set of generators.
117
                
118
                
119
                        
120
                                
121
                        
122
                
123
        
124
        
125
                
126
                        Specifies a set of component generators. The scope attribute applies to component generators and specifies whether the generator should be run for each instance of the entity (or module) or just once for all instances of the entity.
127
                
128
        
129
        
130
                
131
                        Specifies a set of abstractor generators. The scope attribute applies to abstractor generators and specifies whether the generator should be run for each instance of the entity (or module) or just once for all instances of the entity.
132
                
133
        
134
        
135
                
136
                        Specifies a set of group names used to select subsequent generators. The attribute "multipleGroupOperator" specifies the OR or AND selection operator if there is more than one group name (default=OR).
137
                
138
                
139
                        
140
                                
141
                                        
142
                                                Specifies a generator group name or a generator chain group name to be selected for inclusion in the generator chain.
143
                                        
144
                                        
145
                                                
146
                                                        
147
                                                                
148
                                                        
149
                                                
150
                                        
151
                                
152
                        
153
                        
154
                                
155
                                        Specifies the OR or AND selection operator if there is more than one group name.
156
                                
157
                                
158
                                        
159
                                                
160
                                                
161
                                        
162
                                
163
                        
164
                        
165
                
166
        
167
        
168
                
169
                        This is an non-negative floating point number that is used to sequence when a generator is run. The generators are run in order starting with zero. There may be multiple generators with the same phase number. In this case, the order should not matter with respect to other generators at the same phase. If no phase number is given the generator will be considered in the "last" phase and these generators will be run in the order in which they are encountered while processing generator elements.
170
                
171
        
172
        
173
                
174
                        
175
                                
176
                                        
177
                                                
178
                                                        An identifier to specify the generator group. This is used by generator chains for selecting which generators to run.
179
                                                
180
                                                
181
                                                        
182
                                                                
183
                                                                        
184
                                                                
185
                                                        
186
                                                
187
                                        
188
                                
189
                                
190
                                        
191
                                                The scope attribute applies to component generators and specifies whether the generator should be run for each instance of the entity (or module) or just once for all instances of the entity.
192
                                        
193
                                        
194
                                                
195
                                                        
196
                                                        
197
                                                
198
                                        
199
                                
200
                        
201
                
202
        
203
        
204
                
205
                        
206
                
207
                
208
        
209
        
210
                
211
                        List of component generators.
212
                
213
                
214
                        
215
                                
216
                        
217
                
218
        
219
        
220
                
221
                        List of abstractor generators.
222
                
223
                
224
                        
225
                                
226
                        
227
                
228
        
229
        
230
                
231
                        
232
                        
233
                        
234
                        
235
                
236
        
237
        
238
                
239
                        
240
                
241
        
242
        
243
                
244
                        Types of generators
245
                
246
                
247
                        
248
                        
249
                        
250
                        
251
                                
252
                                        Indicates the type of API used by the generator. Valid value are TGI_2009, TGI_2014_BASE, TGI_2014_EXTENDED, and none. If this element is not present, TGI_2014_BASE is assumed. The type TGI_2009 indicates a generator using the 1685-2009 version of the TGI API. This is not part of the 1685-2014 version of the standard and may not be supported by Design Environments.
253
                                
254
                                
255
                                        
256
                                                
257
                                                        
258
                                                
259
                                        
260
                                
261
                        
262
                        
263
                                
264
                                        
265
                                                
266
                                                        
267
                                                                Defines a SOAP transport protocol other than HTTP which is supported by this generator. The only other currently supported protocol is 'file'.
268
                                                        
269
                                                        
270
                                                                
271
                                                                        
272
                                                                                
273
                                                                        
274
                                                                
275
                                                        
276
                                                
277
                                        
278
                                        
279
                                
280
                        
281
                        
282
                                
283
                                        The pathname to the executable file that implements the generator
284
                                
285
                        
286
                        
287
                
288
                
289
                        
290
                                If this attribute is true then the generator should not be presented to the user, it may be part of a chain and has no useful meaning when invoked standalone.
291
                        
292
                
293
                
294
        
295

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.