modules/up/src/rpsl/rpsl/rptype.cc
/* [<][>][^][v][top][bottom][index][help] */
FUNCTIONS
This source file includes following functions.
- Attribute
- newRPType
- newRPType
- newRPType
- newRPType
- validate
- typeCast
- validate
- validate
- validate
- typeCast
- validate
- validate
- validate
- typeCast
- validate
- validate
- typeCast
- validate
- validate
- validate
- validate
- validate
- validate
- validate
- validate
- typeCast
- validate
- validate
- validate
- validate
- validate
- validate
- typeCast
- validate
- validate
- validate
- typeCast
- validate
- typeCast
- name
- validate
- typeCast
- validate
- validate
1 // $Id: rptype.cc,v 1.2 2001/09/07 11:43:11 shane Exp $
2 //
3 // Copyright (c) 1994 by the University of Southern California
4 // All rights reserved.
5 //
6 // Permission to use, copy, modify, and distribute this software and its
7 // documentation in source and binary forms for lawful non-commercial
8 // purposes and without fee is hereby granted, provided that the above
9 // copyright notice appear in all copies and that both the copyright
10 // notice and this permission notice appear in supporting documentation,
11 // and that any documentation, advertising materials, and other materials
12 // related to such distribution and use acknowledge that the software was
13 // developed by the University of Southern California, Information
14 // Sciences Institute. The name of the USC may not be used to endorse or
15 // promote products derived from this software without specific prior
16 // written permission.
17 //
18 // THE UNIVERSITY OF SOUTHERN CALIFORNIA DOES NOT MAKE ANY
19 // REPRESENTATIONS ABOUT THE SUITABILITY OF THIS SOFTWARE FOR ANY
20 // PURPOSE. THIS SOFTWARE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR
21 // IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
22 // WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE,
23 // TITLE, AND NON-INFRINGEMENT.
24 //
25 // IN NO EVENT SHALL USC, OR ANY OTHER CONTRIBUTOR BE LIABLE FOR ANY
26 // SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES, WHETHER IN CONTRACT, TORT,
27 // OR OTHER FORM OF ACTION, ARISING OUT OF OR IN CONNECTION WITH, THE USE
28 // OR PERFORMANCE OF THIS SOFTWARE.
29 //
30 // Questions concerning this software should be directed to
31 // ratoolset@isi.edu.
32 //
33 // Author(s): Cengiz Alaettinoglu <cengiz@ISI.EDU>
34
35 #include "config.h"
36 #include <cstring>
37 #include <cstdarg>
38 #include <cstdio>
39 #include <typeinfo>
40 #include "util/List.hh"
41
42 class Attribute;
/* [<][>][^][v][top][bottom][index][help] */
43 #include "rptype.hh"
44 #include "schema.hh"
45
46
47 ////////////////////////////// RPType ////////////////////
48
49 RPType *RPType::newRPType(char *name) {
50 if (!strcasecmp(name, "integer"))
51 return new RPTypeInt;
52 if (!strcasecmp(name, "real"))
53 return new RPTypeReal;
54 if (!strcasecmp(name, "rpsl_word"))
55 return new RPTypeWord;
56 // if (!strcasecmp(name, "blob"))
57 // return new RPTypeBlob;
58 if (!strcasecmp(name, "as_number"))
59 return new RPTypeASNumber;
60 if (!strcasecmp(name, "ipv4_address"))
61 return new RPTypeIPv4Address;
62 if (!strcasecmp(name, "address_prefix"))
63 return new RPTypeIPv4Prefix;
64 if (!strcasecmp(name, "ipv6_prefix"))
65 return new RPTypeIPv6Prefix;
66 if (!strcasecmp(name, "address_prefix_range"))
67 return new RPTypeIPv4PrefixRange;
68 if (!strcasecmp(name, "connection"))
69 return new RPTypeConnection;
70 if (!strcasecmp(name, "dns_name"))
71 return new RPTypeDNSName;
72 if (!strcasecmp(name, "filter"))
73 return new RPTypeFilter;
74 if (!strcasecmp(name, "as_set_name"))
75 return new RPTypeASName;
76 if (!strcasecmp(name, "route_set_name"))
77 return new RPTypeRSName;
78 if (!strcasecmp(name, "rtr_set_name"))
79 return new RPTypeRtrsName;
80 if (!strcasecmp(name, "peering_set_name"))
81 return new RPTypePrngName;
82 if (!strcasecmp(name, "filter_set_name"))
83 return new RPTypeFltrName;
84 if (!strcasecmp(name, "string"))
85 return new RPTypeString;
86 if (!strcasecmp(name, "time_stamp"))
87 return new RPTypeTimeStamp;
88 if (!strcasecmp(name, "boolean"))
89 return new RPTypeBoolean;
90 if (!strcasecmp(name, "free_text"))
91 return new RPTypeFreeText;
92 if (!strcasecmp(name, "email"))
93 return new RPTypeEMail;
94 // if(!strcasecmp(name, "nichdl"))
95 // return new RPTypeNICHdl;
96 if(!strcasecmp(name, "keycrtname"))
97 return new RPTypeKeyCrtName;
98
99 return schema.searchTypedef(name);
100 }
101
102 RPType *RPType::newRPType(char *name, long long int min, long long int max) {
/* [<][>][^][v][top][bottom][index][help] */
103 if (!strcasecmp(name, "integer"))
104 return new RPTypeInt(min, max);
105 if (!strcasecmp(name, "real"))
106 return new RPTypeReal(min, max);
107
108 return NULL;
109 }
110
111 RPType *RPType::newRPType(char *name, double min, double max) {
/* [<][>][^][v][top][bottom][index][help] */
112 if (!strcasecmp(name, "real"))
113 return new RPTypeReal(min, max);
114
115 return NULL;
116 }
117
118 RPType *RPType::newRPType(char *name, List<WordNode> *words) {
/* [<][>][^][v][top][bottom][index][help] */
119 if (!strcasecmp(name, "enum"))
120 return new RPTypeEnum(words);
121
122 return NULL;
123 }
124
125 RPType *RPType::newRPType(char *name, List<RPTypeNode> *types) {
/* [<][>][^][v][top][bottom][index][help] */
126 if (types && !types->isEmpty())
127 if (!strcasecmp(name, "union"))
128 return new RPTypeUnion(types);
129
130 return NULL;
131 }
132
133 bool RPType::validate(const Item *item) const {
/* [<][>][^][v][top][bottom][index][help] */
134 return false;
135 }
136 Item *RPType::typeCast(const Item *item) const {
/* [<][>][^][v][top][bottom][index][help] */
137 return NULL;
138 }
139 bool RPType::validate(ItemList *list) const {
/* [<][>][^][v][top][bottom][index][help] */
140 if (! list->isSingleton())
141 return false;
142 if (validate(list->head()))
143 return true;
144
145 Item *w = typeCast(list->head());
146 if (!w)
147 return false;
148
149 list->clear();
150 list->append(w);
151
152 return true;
153 }
154
155 ////////////////////////////// RPTypeInt ////////////////////
156
157 bool RPTypeInt::validate(const Item *item) const {
/* [<][>][^][v][top][bottom][index][help] */
158 return (typeid(*item) == typeid(ItemINT)
159 && min <= ((ItemINT *) item)->i
160 && max >= ((ItemINT *) item)->i);
161 }
162
163 ////////////////////////////// RPTypeReal ////////////////////
164
165 bool RPTypeReal::validate(const Item *item) const {
/* [<][>][^][v][top][bottom][index][help] */
166 return (typeid(*item) == typeid(ItemREAL)
167 && min <= ((ItemREAL *) item)->real
168 && max >= ((ItemREAL *) item)->real);
169 }
170
171 Item *RPTypeReal::typeCast(const Item *item) const {
/* [<][>][^][v][top][bottom][index][help] */
172 if (typeid(*item) == typeid(ItemINT)
173 && min <= ((ItemINT *) item)->i
174 && max >= ((ItemINT *) item)->i)
175 return new ItemREAL(((ItemINT *) item)->i);
176
177 return NULL;
178 }
179
180 ////////////////////////////// RPTypeString ////////////////////
181
182 bool RPTypeString::validate(const Item *item) const {
/* [<][>][^][v][top][bottom][index][help] */
183 return (typeid(*item) == typeid(ItemSTRING));
184 }
185
186 ////////////////////////////// RPTypeTimeStamp ////////////////////
187
188 bool RPTypeTimeStamp::validate(const Item *item) const {
/* [<][>][^][v][top][bottom][index][help] */
189 return (typeid(*item) == typeid(ItemTimeStamp));
190 }
191
192 ////////////////////////////// RPTypeWORD ////////////////////
193
194 bool RPTypeWord::validate(const Item *item) const {
/* [<][>][^][v][top][bottom][index][help] */
195 return (typeid(*item) == typeid(ItemWORD));
196 }
197 Item *RPTypeWord::typeCast(const Item *item) const {
/* [<][>][^][v][top][bottom][index][help] */
198 if (typeid(*item) == typeid(ItemASNAME)){
199 return new ItemWORD(strdup(((ItemASNAME *) item)->name));
200 }
201 if (typeid(*item) == typeid(ItemRSNAME))
202 return new ItemWORD(strdup(((ItemRSNAME *) item)->name));
203 if (typeid(*item) == typeid(ItemRTRSNAME))
204 return new ItemWORD(strdup(((ItemRTRSNAME *) item)->name));
205 if (typeid(*item) == typeid(ItemPRNGNAME))
206 return new ItemWORD(strdup(((ItemPRNGNAME *) item)->name));
207 // if (typeid(*item) == typeid(ItemNICHDL)){
208 // cout << "typecasting: ItemNICHDL->ItemWORD" << endl;
209 // return new ItemWORD(strdup(((ItemNICHDL *) item)->nichdl));
210 // }
211 if (typeid(*item) == typeid(ItemFLTRNAME))
212 return new ItemWORD(strdup(((ItemFLTRNAME *) item)->name));
213 if (typeid(*item) == typeid(ItemKEYCRTNAME))
214 return new ItemWORD(strdup(((ItemKEYCRTNAME *) item)->name));
215 if (typeid(*item) == typeid(ItemBOOLEAN))
216 if (((ItemBOOLEAN *) item)->i)
217 return new ItemWORD(strdup("true"));
218 else
219 return new ItemWORD(strdup("false"));
220 if (typeid(*item) == typeid(ItemASNO)) {
221 char buffer[64];
222 sprintf(buffer, "AS%d", ((ItemASNO *) item)->asno);
223 return new ItemWORD(strdup(buffer));
224 }
225
226 return NULL;
227 }
228
229 ////////////////////////////// RPTypeNICHdl ////////////////////
230 /*
231 bool RPTypeNICHdl::validate(const Item *item) const {
232 if(typeid(*item) == typeid(ItemNICHDL)){
233 cout << "Debug: RPTypeNICHdl::validate (nichdl = "<< ((ItemNICHDL *) item)->nichdl << ")" << endl;
234 }else{
235 cout << "Debug: RPTypeNICHdl::validate" << endl;
236 }
237 cout << "Debug: RPTypeNICHdl::validate " << typeid(*item).name() << " " << typeid(ItemNICHDL).name() << endl;
238 // return false;
239 return (typeid(*item) == typeid(ItemNICHDL)
240 && ((strchr(((ItemNICHDL *) item)->nichdl,'q') != NULL)
241 || (strchr(((ItemNICHDL *) item)->nichdl,'Q') != NULL)));
242 }
243 */
244 /*Item *RPTypeNICHdl::typeCast(const Item *item) const {
245 if (typeid(*item) == typeid(ItemWORD)){
246 cout << "typecasting: ItemWORD -> ItemNICHDL" << endl;
247 return new ItemNICHDL(strdup(((ItemWORD *) item)->word));
248 }
249 if (typeid(*item) == typeid(ItemASNAME))
250 return new ItemNICHDL(strdup(((ItemASNAME *) item)->name));
251 if (typeid(*item) == typeid(ItemRSNAME))
252 return new ItemNICHDL(strdup(((ItemRSNAME *) item)->name));
253 if (typeid(*item) == typeid(ItemRTRSNAME))
254 return new ItemNICHDL(strdup(((ItemRTRSNAME *) item)->name));
255 if (typeid(*item) == typeid(ItemPRNGNAME))
256 return new ItemNICHDL(strdup(((ItemPRNGNAME *) item)->name));
257 if (typeid(*item) == typeid(ItemFLTRNAME))
258 return new ItemNICHDL(strdup(((ItemFLTRNAME *) item)->name));
259 if (typeid(*item) == typeid(ItemKEYCRTNAME))
260 return new ItemWORD(strdup(((ItemKEYCRTNAME *) item)->name));
261 if (typeid(*item) == typeid(ItemBOOLEAN))
262 if (((ItemBOOLEAN *) item)->i)
263 return new ItemNICHDL(strdup("true"));
264 else
265 return new ItemNICHDL(strdup("false"));
266 if (typeid(*item) == typeid(ItemASNO)) {
267 char buffer[64];
268 sprintf(buffer, "AS%d", ((ItemASNO *) item)->asno);
269 return new ItemNICHDL(strdup(buffer));
270 }
271
272 return NULL;
273 }*/
274
275 ////////////////////////////// RPTypeKeyCrtName ////////////////////
276
277 bool RPTypeKeyCrtName::validate(const Item *item) const {
/* [<][>][^][v][top][bottom][index][help] */
278 return (typeid(*item) == typeid(ItemKEYCRTNAME));
279 }
280 //Item *RPTypeKeyCrtName::typeCast(const Item *item) const {
281 // if (typeid(*item) == typeid(ItemWORD))
282 // return new ItemKEYCRTNAME(strdup(((ItemWORD *) item)->word));
283 // if (typeid(*item) == typeid(ItemASNAME))
284 // return new ItemKEYCRTNAME(strdup(((ItemASNAME *) item)->name));
285 // if (typeid(*item) == typeid(ItemRSNAME))
286 // return new ItemKEYCRTNAME(strdup(((ItemRSNAME *) item)->name));
287 // if (typeid(*item) == typeid(ItemRTRSNAME))
288 // return new ItemKEYCRTNAME(strdup(((ItemRTRSNAME *) item)->name));
289 // if (typeid(*item) == typeid(ItemPRNGNAME))
290 // return new ItemKEYCRTNAME(strdup(((ItemPRNGNAME *) item)->name));
291 // if (typeid(*item) == typeid(ItemFLTRNAME))
292 // return new ItemKEYCRTNAME(strdup(((ItemFLTRNAME *) item)->name));
293 // if (typeid(*item) == typeid(ItemNICHDL))
294 // return new ItemKEYCRTNAME(strdup(((ItemNICHDL *) item)->nichdl));
295 // if (typeid(*item) == typeid(ItemBOOLEAN))
296 // if (((ItemBOOLEAN *) item)->i)
297 // return new ItemNICHDL(strdup("true"));
298 // else
299 // return new ItemNICHDL(strdup("false"));
300 // if (typeid(*item) == typeid(ItemASNO)) {
301 // char buffer[64];
302 // sprintf(buffer, "AS%d", ((ItemASNO *) item)->asno);
303 // return new ItemNICHDL(strdup(buffer));
304 // }
305 //
306 // return NULL;
307 //}
308
309 ////////////////////////////// RPTypeBlob ////////////////////
310
311 bool RPTypeBlob::validate(const Item *item) const {
/* [<][>][^][v][top][bottom][index][help] */
312 return (typeid(*item) == typeid(ItemBLOB));
313 }
314
315 Item *RPTypeBlob::typeCast(const Item *item) const {
/* [<][>][^][v][top][bottom][index][help] */
316 if (typeid(*item) == typeid(ItemASNAME))
317 return new ItemBLOB(strdup(((ItemASNAME *) item)->name));
318 if (typeid(*item) == typeid(ItemRSNAME))
319 return new ItemBLOB(strdup(((ItemRSNAME *) item)->name));
320 if (typeid(*item) == typeid(ItemRTRSNAME))
321 return new ItemBLOB(strdup(((ItemRTRSNAME *) item)->name));
322 if (typeid(*item) == typeid(ItemPRNGNAME))
323 return new ItemBLOB(strdup(((ItemPRNGNAME *) item)->name));
324 if (typeid(*item) == typeid(ItemFLTRNAME))
325 return new ItemBLOB(strdup(((ItemFLTRNAME *) item)->name));
326 // if (typeid(*item) == typeid(ItemNICHDL))
327 // return new ItemBLOB(strdup(((ItemNICHDL *) item)->nichdl));
328 if (typeid(*item) == typeid(ItemKEYCRTNAME))
329 return new ItemBLOB(strdup(((ItemKEYCRTNAME *) item)->name));
330 if (typeid(*item) == typeid(ItemBOOLEAN))
331 if (((ItemBOOLEAN *) item)->i)
332 return new ItemBLOB(strdup("true"));
333 else
334 return new ItemBLOB(strdup("false"));
335 if (typeid(*item) == typeid(ItemASNO)) {
336 char buffer[64];
337 sprintf(buffer, "AS%d", ((ItemASNO *) item)->asno);
338 return new ItemWORD(strdup(buffer));
339 }
340
341 return NULL;
342 }
343
344 ////////////////////////////// RPTypeASName ////////////////////
345
346 bool RPTypeASName::validate(const Item *item) const {
/* [<][>][^][v][top][bottom][index][help] */
347 return (typeid(*item) == typeid(ItemASNAME));
348 }
349
350 ////////////////////////////// RPTypeRSName ////////////////////
351
352 bool RPTypeRSName::validate(const Item *item) const {
/* [<][>][^][v][top][bottom][index][help] */
353 return (typeid(*item) == typeid(ItemRSNAME));
354 }
355
356 ////////////////////////////// RPTypeRTRSName ////////////////////
357
358 bool RPTypeRtrsName::validate(const Item *item) const {
/* [<][>][^][v][top][bottom][index][help] */
359 return (typeid(*item) == typeid(ItemRTRSNAME));
360 }
361
362 ////////////////////////////// RPTypePrngName ////////////////////
363
364 bool RPTypePrngName::validate(const Item *item) const {
/* [<][>][^][v][top][bottom][index][help] */
365 return (typeid(*item) == typeid(ItemPRNGNAME));
366 }
367
368 ////////////////////////////// RPTypeFltrName ////////////////////
369
370 bool RPTypeFltrName::validate(const Item *item) const {
/* [<][>][^][v][top][bottom][index][help] */
371 return (typeid(*item) == typeid(ItemFLTRNAME));
372 }
373
374 ////////////////////////////// RPTypeEMail ////////////////////
375
376 bool RPTypeEMail::validate(const Item *item) const {
/* [<][>][^][v][top][bottom][index][help] */
377 return (typeid(*item) == typeid(ItemEMAIL));
378 }
379
380 ////////////////////////////// RPTypeFreeText ////////////////////
381
382 bool RPTypeFreeText::validate(const Item *item) const {
/* [<][>][^][v][top][bottom][index][help] */
383 return (typeid(*item) == typeid(ItemFREETEXT));
384 }
385
386 ////////////////////////////// RPTypeEnum ////////////////////
387
388 bool RPTypeEnum::validate(const Item *item) const {
/* [<][>][^][v][top][bottom][index][help] */
389 if (typeid(*item) != typeid(ItemWORD))
390 return false;
391
392 for (WordNode* p = words->head(); p; p = words->next(p))
393 if (!strcasecmp(((ItemWORD *) item)->word, p->word))
394 return true;
395
396 return false;
397 }
398
399 Item *RPTypeEnum::typeCast(const Item *item) const {
/* [<][>][^][v][top][bottom][index][help] */
400 ItemWORD *w = NULL;
401
402 if (typeid(*item) == typeid(ItemASNAME))
403 w = new ItemWORD(strdup(((ItemASNAME *) item)->name));
404 if (typeid(*item) == typeid(ItemRSNAME))
405 w = new ItemWORD(strdup(((ItemRSNAME *) item)->name));
406 if (typeid(*item) == typeid(ItemRTRSNAME))
407 w = new ItemWORD(strdup(((ItemRTRSNAME *) item)->name));
408 if (typeid(*item) == typeid(ItemPRNGNAME))
409 w = new ItemWORD(strdup(((ItemPRNGNAME *) item)->name));
410 if (typeid(*item) == typeid(ItemFLTRNAME))
411 w = new ItemWORD(strdup(((ItemFLTRNAME *) item)->name));
412 // if (typeid(*item) == typeid(ItemNICHDL))
413 // w = new ItemWORD(strdup(((ItemNICHDL *) item)->nichdl));
414 if (typeid(*item) == typeid(ItemKEYCRTNAME))
415 w = new ItemWORD(strdup(((ItemKEYCRTNAME *) item)->name));
416 if (typeid(*item) == typeid(ItemBOOLEAN))
417 if (((ItemBOOLEAN *) item)->i)
418 w = new ItemWORD(strdup("true"));
419 else
420 w = new ItemWORD(strdup("false"));
421 if (typeid(*item) == typeid(ItemASNO)) {
422 char buffer[64];
423 sprintf(buffer, "AS%d", ((ItemASNO *) item)->asno);
424 w = new ItemWORD(strdup(buffer));
425 }
426
427 if (w && validate(w))
428 return w;
429 if (w)
430 delete w;
431
432 return NULL;
433 }
434
435 ////////////////////////////// RPTypeBoolean ////////////////////
436
437 bool RPTypeBoolean::validate(const Item *item) const {
/* [<][>][^][v][top][bottom][index][help] */
438 return (typeid(*item) == typeid(ItemBOOLEAN));
439 }
440
441 ////////////////////////////// RPTypeASNumber ////////////////////
442
443 bool RPTypeASNumber::validate(const Item *item) const {
/* [<][>][^][v][top][bottom][index][help] */
444 return ((typeid(*item) == typeid(ItemASNO))
445 && ((ItemASNO *) item)->asno <= 65535);
446 }
447
448 ////////////////////////////// RPTypeIPv4Address ////////////////////
449
450 bool RPTypeIPv4Address::validate(const Item *item) const {
/* [<][>][^][v][top][bottom][index][help] */
451 return (typeid(*item) == typeid(ItemIPV4));
452 }
453
454 ////////////////////////////// RPTypeIPv4Prefix ////////////////////
455
456 bool RPTypeIPv4Prefix::validate(const Item *item) const {
/* [<][>][^][v][top][bottom][index][help] */
457 return (typeid(*item) == typeid(ItemPRFXV4));
458 }
459
460 ////////////////////////////// RPTypeIPv6Prefix ////////////////////
461
462 bool RPTypeIPv6Prefix::validate(const Item *item) const {
/* [<][>][^][v][top][bottom][index][help] */
463 return (typeid(*item) == typeid(ItemPRFXV6));
464 }
465
466 ////////////////////////////// RPTypeIPv4PrefixRange ////////////////////
467
468 bool RPTypeIPv4PrefixRange::validate(const Item *item) const {
/* [<][>][^][v][top][bottom][index][help] */
469 return (typeid(*item) == typeid(ItemPRFXV4Range));
470 }
471
472 Item *RPTypeIPv4PrefixRange::typeCast(const Item *item) const {
/* [<][>][^][v][top][bottom][index][help] */
473 if (typeid(*item) == typeid(ItemPRFXV4))
474 return new ItemPRFXV4Range
475 (new PrefixRange(*((ItemPRFXV4 *) item)->prfxv4));
476 return NULL;
477 }
478
479 ////////////////////////////// RPTypeConnection ////////////////////
480
481 bool RPTypeConnection::validate(const Item *item) const {
/* [<][>][^][v][top][bottom][index][help] */
482 return (typeid(*item) == typeid(ItemConnection));
483 }
484
485 ////////////////////////////// RPTypeDNSName ////////////////////
486
487 bool RPTypeDNSName::validate(const Item *item) const {
/* [<][>][^][v][top][bottom][index][help] */
488 return (typeid(*item) == typeid(ItemDNS));
489 }
490
491 ////////////////////////////// RPTypeFilter ////////////////////
492
493 bool RPTypeFilter::validate(const Item *item) const {
/* [<][>][^][v][top][bottom][index][help] */
494 return (typeid(*item) == typeid(ItemFilter));
495 }
496
497 Item *RPTypeFilter::typeCast(const Item *item) const {
/* [<][>][^][v][top][bottom][index][help] */
498 if (typeid(*item) == typeid(ItemASNAME))
499 return new ItemFilter(new FilterASNAME(((ItemASNAME *) item)->name));
500 if (typeid(*item) == typeid(ItemRSNAME))
501 return new ItemFilter(new FilterRSNAME(((ItemRSNAME *) item)->name));
502 if (typeid(*item) == typeid(ItemRTRSNAME))
503 return new ItemFilter(new FilterRTRSNAME(((ItemRTRSNAME *) item)->name));
504 if (typeid(*item) == typeid(ItemFLTRNAME))
505 return new ItemFilter(new FilterFLTRNAME(((ItemFLTRNAME *) item)->name));
506 if (typeid(*item) == typeid(ItemASNO))
507 return new ItemFilter(new FilterASNO(((ItemASNO *) item)->asno));
508
509 return NULL;
510 }
511
512 ////////////////////////////// RPTypeUnion ////////////////////
513
514 bool RPTypeUnion::validate(const Item *item) const {
/* [<][>][^][v][top][bottom][index][help] */
515 for (RPTypeNode* p = types->head(); p; p = types->next(p))
516 if (p->type->validate(item))
517 return true;
518
519 return false;
520 }
521
522 Item *RPTypeUnion::typeCast(const Item *item) const {
/* [<][>][^][v][top][bottom][index][help] */
523 Item *w;
524 for (RPTypeNode* p = types->head(); p; p = types->next(p)) {
525 w = p->type->typeCast(item);
526 if (w)
527 return w;
528 }
529
530 return NULL;
531 }
532
533 const char *RPTypeUnion::name() {
/* [<][>][^][v][top][bottom][index][help] */
534 if (!_name) {
535 char buffer[1024];
536 strcpy(buffer, "union ");
537 for (RPTypeNode *n = types->head(); n; ) {
538 strcat(buffer, n->type->name());
539 n = types->next(n);
540 if (n)
541 strcat(buffer, ", ");
542 }
543 _name = strdup(buffer);
544 }
545 return _name;
546 }
547
548 ////////////////////////////// RPTypeRange ////////////////////
549
550 bool RPTypeRange::validate(const Item *item) const {
/* [<][>][^][v][top][bottom][index][help] */
551 if (typeid(*item) == typeid(ItemRange))
552 return type->validate(((ItemRange*) item)->begin)
553 && type->validate(((ItemRange*) item)->end)
554 && (*((ItemRange*) item)->begin) <= (*((ItemRange*) item)->end);
555 return false;
556 }
557
558 Item *RPTypeRange::typeCast(const Item *item) const {
/* [<][>][^][v][top][bottom][index][help] */
559 Item *w = NULL;
560
561 if (type->validate(item))
562 w = item->dup();
563 else
564 w = type->typeCast(item);
565
566 if (w)
567 return new ItemRange(w, w->dup());
568
569 return NULL;
570 }
571
572 ////////////////////////////// RPTypeList ////////////////////
573
574 bool RPTypeList::validate(const Item *item) const {
/* [<][>][^][v][top][bottom][index][help] */
575 if (typeid(*item) == typeid(ItemList))
576 return validate((ItemList*) item);
577 return false;
578 }
579 bool RPTypeList::validate(ItemList *l) const {
/* [<][>][^][v][top][bottom][index][help] */
580 Item *w;
581
582 if (! (min_elms <= l->size() && l->size() <= max_elms))
583 return false;
584
585 for (Item *item = l->head(); item; item = l->next(item))
586 if (! type->validate(item)) {
587 w = type->typeCast(item);
588 if (w) {
589 l->insertAfter(item, w);
590 l->remove(item);
591 delete item;
592 item = w;
593 } else
594 return false;
595 }
596
597 return true;
598 }
599