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.1.1.1 2000/03/10 16:32:23 engin 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 extern "C" {
47 int strcasecmp(...);
48 }
49
50 ////////////////////////////// RPType ////////////////////
51
52 RPType *RPType::newRPType(char *name) {
53 if (!strcasecmp(name, "integer"))
54 return new RPTypeInt;
55 if (!strcasecmp(name, "real"))
56 return new RPTypeReal;
57 if (!strcasecmp(name, "rpsl_word"))
58 return new RPTypeWord;
59 // if (!strcasecmp(name, "blob"))
60 // return new RPTypeBlob;
61 if (!strcasecmp(name, "as_number"))
62 return new RPTypeASNumber;
63 if (!strcasecmp(name, "ipv4_address"))
64 return new RPTypeIPv4Address;
65 if (!strcasecmp(name, "address_prefix"))
66 return new RPTypeIPv4Prefix;
67 if (!strcasecmp(name, "ipv6_prefix"))
68 return new RPTypeIPv6Prefix;
69 if (!strcasecmp(name, "address_prefix_range"))
70 return new RPTypeIPv4PrefixRange;
71 if (!strcasecmp(name, "connection"))
72 return new RPTypeConnection;
73 if (!strcasecmp(name, "dns_name"))
74 return new RPTypeDNSName;
75 if (!strcasecmp(name, "filter"))
76 return new RPTypeFilter;
77 if (!strcasecmp(name, "as_set_name"))
78 return new RPTypeASName;
79 if (!strcasecmp(name, "route_set_name"))
80 return new RPTypeRSName;
81 if (!strcasecmp(name, "rtr_set_name"))
82 return new RPTypeRtrsName;
83 if (!strcasecmp(name, "peering_set_name"))
84 return new RPTypePrngName;
85 if (!strcasecmp(name, "filter_set_name"))
86 return new RPTypeFltrName;
87 if (!strcasecmp(name, "string"))
88 return new RPTypeString;
89 if (!strcasecmp(name, "time_stamp"))
90 return new RPTypeTimeStamp;
91 if (!strcasecmp(name, "boolean"))
92 return new RPTypeBoolean;
93 if (!strcasecmp(name, "free_text"))
94 return new RPTypeFreeText;
95 if (!strcasecmp(name, "email"))
96 return new RPTypeEMail;
97 // if(!strcasecmp(name, "nichdl"))
98 // return new RPTypeNICHdl;
99 if(!strcasecmp(name, "keycrtname"))
100 return new RPTypeKeyCrtName;
101
102 return schema.searchTypedef(name);
103 }
104
105 RPType *RPType::newRPType(char *name, long long int min, long long int max) {
/* [<][>][^][v][top][bottom][index][help] */
106 if (!strcasecmp(name, "integer"))
107 return new RPTypeInt(min, max);
108 if (!strcasecmp(name, "real"))
109 return new RPTypeReal(min, max);
110
111 return NULL;
112 }
113
114 RPType *RPType::newRPType(char *name, double min, double max) {
/* [<][>][^][v][top][bottom][index][help] */
115 if (!strcasecmp(name, "real"))
116 return new RPTypeReal(min, max);
117
118 return NULL;
119 }
120
121 RPType *RPType::newRPType(char *name, List<WordNode> *words) {
/* [<][>][^][v][top][bottom][index][help] */
122 if (!strcasecmp(name, "enum"))
123 return new RPTypeEnum(words);
124
125 return NULL;
126 }
127
128 RPType *RPType::newRPType(char *name, List<RPTypeNode> *types) {
/* [<][>][^][v][top][bottom][index][help] */
129 if (types && !types->isEmpty())
130 if (!strcasecmp(name, "union"))
131 return new RPTypeUnion(types);
132
133 return NULL;
134 }
135
136 bool RPType::validate(const Item *item) const {
/* [<][>][^][v][top][bottom][index][help] */
137 return false;
138 }
139 Item *RPType::typeCast(const Item *item) const {
/* [<][>][^][v][top][bottom][index][help] */
140 return NULL;
141 }
142 bool RPType::validate(ItemList *list) const {
/* [<][>][^][v][top][bottom][index][help] */
143 if (! list->isSingleton())
144 return false;
145 if (validate(list->head()))
146 return true;
147
148 Item *w = typeCast(list->head());
149 if (!w)
150 return false;
151
152 list->clear();
153 list->append(w);
154
155 return true;
156 }
157
158 ////////////////////////////// RPTypeInt ////////////////////
159
160 bool RPTypeInt::validate(const Item *item) const {
/* [<][>][^][v][top][bottom][index][help] */
161 return (typeid(*item) == typeid(ItemINT)
162 && min <= ((ItemINT *) item)->i
163 && max >= ((ItemINT *) item)->i);
164 }
165
166 ////////////////////////////// RPTypeReal ////////////////////
167
168 bool RPTypeReal::validate(const Item *item) const {
/* [<][>][^][v][top][bottom][index][help] */
169 return (typeid(*item) == typeid(ItemREAL)
170 && min <= ((ItemREAL *) item)->real
171 && max >= ((ItemREAL *) item)->real);
172 }
173
174 Item *RPTypeReal::typeCast(const Item *item) const {
/* [<][>][^][v][top][bottom][index][help] */
175 if (typeid(*item) == typeid(ItemINT)
176 && min <= ((ItemINT *) item)->i
177 && max >= ((ItemINT *) item)->i)
178 return new ItemREAL(((ItemINT *) item)->i);
179
180 return NULL;
181 }
182
183 ////////////////////////////// RPTypeString ////////////////////
184
185 bool RPTypeString::validate(const Item *item) const {
/* [<][>][^][v][top][bottom][index][help] */
186 return (typeid(*item) == typeid(ItemSTRING));
187 }
188
189 ////////////////////////////// RPTypeTimeStamp ////////////////////
190
191 bool RPTypeTimeStamp::validate(const Item *item) const {
/* [<][>][^][v][top][bottom][index][help] */
192 return (typeid(*item) == typeid(ItemTimeStamp));
193 }
194
195 ////////////////////////////// RPTypeWORD ////////////////////
196
197 bool RPTypeWord::validate(const Item *item) const {
/* [<][>][^][v][top][bottom][index][help] */
198 return (typeid(*item) == typeid(ItemWORD));
199 }
200 Item *RPTypeWord::typeCast(const Item *item) const {
/* [<][>][^][v][top][bottom][index][help] */
201 if (typeid(*item) == typeid(ItemASNAME)){
202 return new ItemWORD(strdup(((ItemASNAME *) item)->name));
203 }
204 if (typeid(*item) == typeid(ItemRSNAME))
205 return new ItemWORD(strdup(((ItemRSNAME *) item)->name));
206 if (typeid(*item) == typeid(ItemRTRSNAME))
207 return new ItemWORD(strdup(((ItemRTRSNAME *) item)->name));
208 if (typeid(*item) == typeid(ItemPRNGNAME))
209 return new ItemWORD(strdup(((ItemPRNGNAME *) item)->name));
210 // if (typeid(*item) == typeid(ItemNICHDL)){
211 // cout << "typecasting: ItemNICHDL->ItemWORD" << endl;
212 // return new ItemWORD(strdup(((ItemNICHDL *) item)->nichdl));
213 // }
214 if (typeid(*item) == typeid(ItemFLTRNAME))
215 return new ItemWORD(strdup(((ItemFLTRNAME *) item)->name));
216 if (typeid(*item) == typeid(ItemKEYCRTNAME))
217 return new ItemWORD(strdup(((ItemKEYCRTNAME *) item)->name));
218 if (typeid(*item) == typeid(ItemBOOLEAN))
219 if (((ItemBOOLEAN *) item)->i)
220 return new ItemWORD(strdup("true"));
221 else
222 return new ItemWORD(strdup("false"));
223 if (typeid(*item) == typeid(ItemASNO)) {
224 char buffer[64];
225 sprintf(buffer, "AS%d", ((ItemASNO *) item)->asno);
226 return new ItemWORD(strdup(buffer));
227 }
228
229 return NULL;
230 }
231
232 ////////////////////////////// RPTypeNICHdl ////////////////////
233 /*
234 bool RPTypeNICHdl::validate(const Item *item) const {
235 if(typeid(*item) == typeid(ItemNICHDL)){
236 cout << "Debug: RPTypeNICHdl::validate (nichdl = "<< ((ItemNICHDL *) item)->nichdl << ")" << endl;
237 }else{
238 cout << "Debug: RPTypeNICHdl::validate" << endl;
239 }
240 cout << "Debug: RPTypeNICHdl::validate " << typeid(*item).name() << " " << typeid(ItemNICHDL).name() << endl;
241 // return false;
242 return (typeid(*item) == typeid(ItemNICHDL)
243 && ((strchr(((ItemNICHDL *) item)->nichdl,'q') != NULL)
244 || (strchr(((ItemNICHDL *) item)->nichdl,'Q') != NULL)));
245 }
246 */
247 /*Item *RPTypeNICHdl::typeCast(const Item *item) const {
248 if (typeid(*item) == typeid(ItemWORD)){
249 cout << "typecasting: ItemWORD -> ItemNICHDL" << endl;
250 return new ItemNICHDL(strdup(((ItemWORD *) item)->word));
251 }
252 if (typeid(*item) == typeid(ItemASNAME))
253 return new ItemNICHDL(strdup(((ItemASNAME *) item)->name));
254 if (typeid(*item) == typeid(ItemRSNAME))
255 return new ItemNICHDL(strdup(((ItemRSNAME *) item)->name));
256 if (typeid(*item) == typeid(ItemRTRSNAME))
257 return new ItemNICHDL(strdup(((ItemRTRSNAME *) item)->name));
258 if (typeid(*item) == typeid(ItemPRNGNAME))
259 return new ItemNICHDL(strdup(((ItemPRNGNAME *) item)->name));
260 if (typeid(*item) == typeid(ItemFLTRNAME))
261 return new ItemNICHDL(strdup(((ItemFLTRNAME *) item)->name));
262 if (typeid(*item) == typeid(ItemKEYCRTNAME))
263 return new ItemWORD(strdup(((ItemKEYCRTNAME *) item)->name));
264 if (typeid(*item) == typeid(ItemBOOLEAN))
265 if (((ItemBOOLEAN *) item)->i)
266 return new ItemNICHDL(strdup("true"));
267 else
268 return new ItemNICHDL(strdup("false"));
269 if (typeid(*item) == typeid(ItemASNO)) {
270 char buffer[64];
271 sprintf(buffer, "AS%d", ((ItemASNO *) item)->asno);
272 return new ItemNICHDL(strdup(buffer));
273 }
274
275 return NULL;
276 }*/
277
278 ////////////////////////////// RPTypeKeyCrtName ////////////////////
279
280 bool RPTypeKeyCrtName::validate(const Item *item) const {
/* [<][>][^][v][top][bottom][index][help] */
281 return (typeid(*item) == typeid(ItemKEYCRTNAME));
282 }
283 //Item *RPTypeKeyCrtName::typeCast(const Item *item) const {
284 // if (typeid(*item) == typeid(ItemWORD))
285 // return new ItemKEYCRTNAME(strdup(((ItemWORD *) item)->word));
286 // if (typeid(*item) == typeid(ItemASNAME))
287 // return new ItemKEYCRTNAME(strdup(((ItemASNAME *) item)->name));
288 // if (typeid(*item) == typeid(ItemRSNAME))
289 // return new ItemKEYCRTNAME(strdup(((ItemRSNAME *) item)->name));
290 // if (typeid(*item) == typeid(ItemRTRSNAME))
291 // return new ItemKEYCRTNAME(strdup(((ItemRTRSNAME *) item)->name));
292 // if (typeid(*item) == typeid(ItemPRNGNAME))
293 // return new ItemKEYCRTNAME(strdup(((ItemPRNGNAME *) item)->name));
294 // if (typeid(*item) == typeid(ItemFLTRNAME))
295 // return new ItemKEYCRTNAME(strdup(((ItemFLTRNAME *) item)->name));
296 // if (typeid(*item) == typeid(ItemNICHDL))
297 // return new ItemKEYCRTNAME(strdup(((ItemNICHDL *) item)->nichdl));
298 // if (typeid(*item) == typeid(ItemBOOLEAN))
299 // if (((ItemBOOLEAN *) item)->i)
300 // return new ItemNICHDL(strdup("true"));
301 // else
302 // return new ItemNICHDL(strdup("false"));
303 // if (typeid(*item) == typeid(ItemASNO)) {
304 // char buffer[64];
305 // sprintf(buffer, "AS%d", ((ItemASNO *) item)->asno);
306 // return new ItemNICHDL(strdup(buffer));
307 // }
308 //
309 // return NULL;
310 //}
311
312 ////////////////////////////// RPTypeBlob ////////////////////
313
314 bool RPTypeBlob::validate(const Item *item) const {
/* [<][>][^][v][top][bottom][index][help] */
315 return (typeid(*item) == typeid(ItemBLOB));
316 }
317
318 Item *RPTypeBlob::typeCast(const Item *item) const {
/* [<][>][^][v][top][bottom][index][help] */
319 if (typeid(*item) == typeid(ItemASNAME))
320 return new ItemBLOB(strdup(((ItemASNAME *) item)->name));
321 if (typeid(*item) == typeid(ItemRSNAME))
322 return new ItemBLOB(strdup(((ItemRSNAME *) item)->name));
323 if (typeid(*item) == typeid(ItemRTRSNAME))
324 return new ItemBLOB(strdup(((ItemRTRSNAME *) item)->name));
325 if (typeid(*item) == typeid(ItemPRNGNAME))
326 return new ItemBLOB(strdup(((ItemPRNGNAME *) item)->name));
327 if (typeid(*item) == typeid(ItemFLTRNAME))
328 return new ItemBLOB(strdup(((ItemFLTRNAME *) item)->name));
329 // if (typeid(*item) == typeid(ItemNICHDL))
330 // return new ItemBLOB(strdup(((ItemNICHDL *) item)->nichdl));
331 if (typeid(*item) == typeid(ItemKEYCRTNAME))
332 return new ItemBLOB(strdup(((ItemKEYCRTNAME *) item)->name));
333 if (typeid(*item) == typeid(ItemBOOLEAN))
334 if (((ItemBOOLEAN *) item)->i)
335 return new ItemBLOB(strdup("true"));
336 else
337 return new ItemBLOB(strdup("false"));
338 if (typeid(*item) == typeid(ItemASNO)) {
339 char buffer[64];
340 sprintf(buffer, "AS%d", ((ItemASNO *) item)->asno);
341 return new ItemWORD(strdup(buffer));
342 }
343
344 return NULL;
345 }
346
347 ////////////////////////////// RPTypeASName ////////////////////
348
349 bool RPTypeASName::validate(const Item *item) const {
/* [<][>][^][v][top][bottom][index][help] */
350 return (typeid(*item) == typeid(ItemASNAME));
351 }
352
353 ////////////////////////////// RPTypeRSName ////////////////////
354
355 bool RPTypeRSName::validate(const Item *item) const {
/* [<][>][^][v][top][bottom][index][help] */
356 return (typeid(*item) == typeid(ItemRSNAME));
357 }
358
359 ////////////////////////////// RPTypeRTRSName ////////////////////
360
361 bool RPTypeRtrsName::validate(const Item *item) const {
/* [<][>][^][v][top][bottom][index][help] */
362 return (typeid(*item) == typeid(ItemRTRSNAME));
363 }
364
365 ////////////////////////////// RPTypePrngName ////////////////////
366
367 bool RPTypePrngName::validate(const Item *item) const {
/* [<][>][^][v][top][bottom][index][help] */
368 return (typeid(*item) == typeid(ItemPRNGNAME));
369 }
370
371 ////////////////////////////// RPTypeFltrName ////////////////////
372
373 bool RPTypeFltrName::validate(const Item *item) const {
/* [<][>][^][v][top][bottom][index][help] */
374 return (typeid(*item) == typeid(ItemFLTRNAME));
375 }
376
377 ////////////////////////////// RPTypeEMail ////////////////////
378
379 bool RPTypeEMail::validate(const Item *item) const {
/* [<][>][^][v][top][bottom][index][help] */
380 return (typeid(*item) == typeid(ItemEMAIL));
381 }
382
383 ////////////////////////////// RPTypeFreeText ////////////////////
384
385 bool RPTypeFreeText::validate(const Item *item) const {
/* [<][>][^][v][top][bottom][index][help] */
386 return (typeid(*item) == typeid(ItemFREETEXT));
387 }
388
389 ////////////////////////////// RPTypeEnum ////////////////////
390
391 bool RPTypeEnum::validate(const Item *item) const {
/* [<][>][^][v][top][bottom][index][help] */
392 if (typeid(*item) != typeid(ItemWORD))
393 return false;
394
395 for (WordNode* p = words->head(); p; p = words->next(p))
396 if (!strcasecmp(((ItemWORD *) item)->word, p->word))
397 return true;
398
399 return false;
400 }
401
402 Item *RPTypeEnum::typeCast(const Item *item) const {
/* [<][>][^][v][top][bottom][index][help] */
403 ItemWORD *w = NULL;
404
405 if (typeid(*item) == typeid(ItemASNAME))
406 w = new ItemWORD(strdup(((ItemASNAME *) item)->name));
407 if (typeid(*item) == typeid(ItemRSNAME))
408 w = new ItemWORD(strdup(((ItemRSNAME *) item)->name));
409 if (typeid(*item) == typeid(ItemRTRSNAME))
410 w = new ItemWORD(strdup(((ItemRTRSNAME *) item)->name));
411 if (typeid(*item) == typeid(ItemPRNGNAME))
412 w = new ItemWORD(strdup(((ItemPRNGNAME *) item)->name));
413 if (typeid(*item) == typeid(ItemFLTRNAME))
414 w = new ItemWORD(strdup(((ItemFLTRNAME *) item)->name));
415 // if (typeid(*item) == typeid(ItemNICHDL))
416 // w = new ItemWORD(strdup(((ItemNICHDL *) item)->nichdl));
417 if (typeid(*item) == typeid(ItemKEYCRTNAME))
418 w = new ItemWORD(strdup(((ItemKEYCRTNAME *) item)->name));
419 if (typeid(*item) == typeid(ItemBOOLEAN))
420 if (((ItemBOOLEAN *) item)->i)
421 w = new ItemWORD(strdup("true"));
422 else
423 w = new ItemWORD(strdup("false"));
424 if (typeid(*item) == typeid(ItemASNO)) {
425 char buffer[64];
426 sprintf(buffer, "AS%d", ((ItemASNO *) item)->asno);
427 w = new ItemWORD(strdup(buffer));
428 }
429
430 if (w && validate(w))
431 return w;
432 if (w)
433 delete w;
434
435 return NULL;
436 }
437
438 ////////////////////////////// RPTypeBoolean ////////////////////
439
440 bool RPTypeBoolean::validate(const Item *item) const {
/* [<][>][^][v][top][bottom][index][help] */
441 return (typeid(*item) == typeid(ItemBOOLEAN));
442 }
443
444 ////////////////////////////// RPTypeASNumber ////////////////////
445
446 bool RPTypeASNumber::validate(const Item *item) const {
/* [<][>][^][v][top][bottom][index][help] */
447 return ((typeid(*item) == typeid(ItemASNO))
448 && ((ItemASNO *) item)->asno <= 65535);
449 }
450
451 ////////////////////////////// RPTypeIPv4Address ////////////////////
452
453 bool RPTypeIPv4Address::validate(const Item *item) const {
/* [<][>][^][v][top][bottom][index][help] */
454 return (typeid(*item) == typeid(ItemIPV4));
455 }
456
457 ////////////////////////////// RPTypeIPv4Prefix ////////////////////
458
459 bool RPTypeIPv4Prefix::validate(const Item *item) const {
/* [<][>][^][v][top][bottom][index][help] */
460 return (typeid(*item) == typeid(ItemPRFXV4));
461 }
462
463 ////////////////////////////// RPTypeIPv6Prefix ////////////////////
464
465 bool RPTypeIPv6Prefix::validate(const Item *item) const {
/* [<][>][^][v][top][bottom][index][help] */
466 return (typeid(*item) == typeid(ItemPRFXV6));
467 }
468
469 ////////////////////////////// RPTypeIPv4PrefixRange ////////////////////
470
471 bool RPTypeIPv4PrefixRange::validate(const Item *item) const {
/* [<][>][^][v][top][bottom][index][help] */
472 return (typeid(*item) == typeid(ItemPRFXV4Range));
473 }
474
475 Item *RPTypeIPv4PrefixRange::typeCast(const Item *item) const {
/* [<][>][^][v][top][bottom][index][help] */
476 if (typeid(*item) == typeid(ItemPRFXV4))
477 return new ItemPRFXV4Range
478 (new PrefixRange(*((ItemPRFXV4 *) item)->prfxv4));
479 return NULL;
480 }
481
482 ////////////////////////////// RPTypeConnection ////////////////////
483
484 bool RPTypeConnection::validate(const Item *item) const {
/* [<][>][^][v][top][bottom][index][help] */
485 return (typeid(*item) == typeid(ItemConnection));
486 }
487
488 ////////////////////////////// RPTypeDNSName ////////////////////
489
490 bool RPTypeDNSName::validate(const Item *item) const {
/* [<][>][^][v][top][bottom][index][help] */
491 return (typeid(*item) == typeid(ItemDNS));
492 }
493
494 ////////////////////////////// RPTypeFilter ////////////////////
495
496 bool RPTypeFilter::validate(const Item *item) const {
/* [<][>][^][v][top][bottom][index][help] */
497 return (typeid(*item) == typeid(ItemFilter));
498 }
499
500 Item *RPTypeFilter::typeCast(const Item *item) const {
/* [<][>][^][v][top][bottom][index][help] */
501 if (typeid(*item) == typeid(ItemASNAME))
502 return new ItemFilter(new FilterASNAME(((ItemASNAME *) item)->name));
503 if (typeid(*item) == typeid(ItemRSNAME))
504 return new ItemFilter(new FilterRSNAME(((ItemRSNAME *) item)->name));
505 if (typeid(*item) == typeid(ItemRTRSNAME))
506 return new ItemFilter(new FilterRTRSNAME(((ItemRTRSNAME *) item)->name));
507 if (typeid(*item) == typeid(ItemFLTRNAME))
508 return new ItemFilter(new FilterFLTRNAME(((ItemFLTRNAME *) item)->name));
509 if (typeid(*item) == typeid(ItemASNO))
510 return new ItemFilter(new FilterASNO(((ItemASNO *) item)->asno));
511
512 return NULL;
513 }
514
515 ////////////////////////////// RPTypeUnion ////////////////////
516
517 bool RPTypeUnion::validate(const Item *item) const {
/* [<][>][^][v][top][bottom][index][help] */
518 for (RPTypeNode* p = types->head(); p; p = types->next(p))
519 if (p->type->validate(item))
520 return true;
521
522 return false;
523 }
524
525 Item *RPTypeUnion::typeCast(const Item *item) const {
/* [<][>][^][v][top][bottom][index][help] */
526 Item *w;
527 for (RPTypeNode* p = types->head(); p; p = types->next(p)) {
528 w = p->type->typeCast(item);
529 if (w)
530 return w;
531 }
532
533 return NULL;
534 }
535
536 const char *RPTypeUnion::name() {
/* [<][>][^][v][top][bottom][index][help] */
537 if (!_name) {
538 char buffer[1024];
539 strcpy(buffer, "union ");
540 for (RPTypeNode *n = types->head(); n; ) {
541 strcat(buffer, n->type->name());
542 n = types->next(n);
543 if (n)
544 strcat(buffer, ", ");
545 }
546 _name = strdup(buffer);
547 }
548 return _name;
549 }
550
551 ////////////////////////////// RPTypeRange ////////////////////
552
553 bool RPTypeRange::validate(const Item *item) const {
/* [<][>][^][v][top][bottom][index][help] */
554 if (typeid(*item) == typeid(ItemRange))
555 return type->validate(((ItemRange*) item)->begin)
556 && type->validate(((ItemRange*) item)->end)
557 && (*((ItemRange*) item)->begin) <= (*((ItemRange*) item)->end);
558 return false;
559 }
560
561 Item *RPTypeRange::typeCast(const Item *item) const {
/* [<][>][^][v][top][bottom][index][help] */
562 Item *w = NULL;
563
564 if (type->validate(item))
565 w = item->dup();
566 else
567 w = type->typeCast(item);
568
569 if (w)
570 return new ItemRange(w, w->dup());
571
572 return NULL;
573 }
574
575 ////////////////////////////// RPTypeList ////////////////////
576
577 bool RPTypeList::validate(const Item *item) const {
/* [<][>][^][v][top][bottom][index][help] */
578 if (typeid(*item) == typeid(ItemList))
579 return validate((ItemList*) item);
580 return false;
581 }
582 bool RPTypeList::validate(ItemList *l) const {
/* [<][>][^][v][top][bottom][index][help] */
583 Item *w;
584
585 if (! (min_elms <= l->size() && l->size() <= max_elms))
586 return false;
587
588 for (Item *item = l->head(); item; item = l->next(item))
589 if (! type->validate(item)) {
590 w = type->typeCast(item);
591 if (w) {
592 l->insertAfter(item, w);
593 l->remove(item);
594 delete item;
595 item = w;
596 } else
597 return false;
598 }
599
600 return true;
601 }
602