languages/WMLScript/pmc/wmlsinvalid.pmc

   1 /*
   2 Copyright (C) 2006-2008, The Perl Foundation.
   3 $Id$
   4
   5 =head1 NAME
   6
   7 pmc/wmlsinvalid.pmc - WMLScript Invalid
   8
   9 =head1 DESCRIPTION
  10
  11 C<WmlsInvalid> extends C<Undef> to provide a class with the behaviour of
  12 the WMLScript C<Invalid> type.
  13
  14 =head2 Methods
  15
  16 =over 4
  17
  18 =cut
  19
  20 */
  21
  22 #include "parrot/embed.h"
  23
  24 static INTVAL dynpmc_WmlsBoolean;
  25 static INTVAL dynpmc_WmlsInteger;
  26 static INTVAL dynpmc_WmlsInvalid;
  27
  28 pmclass WmlsInvalid
  29     extends Undef
  30     provides scalar
  31     dynpmc
  32     group wmls_group
  33     hll WMLScript maps Undef {
  34
  35 /* Class initialization. Caches constant strings that will be used later.
  36 */
  37     void class_init() {
  38         if (pass) {
  39             dynpmc_WmlsBoolean = pmc_type(INTERP,
  40               const_string(INTERP, "WmlsBoolean"));
  41             dynpmc_WmlsInteger = pmc_type(INTERP,
  42               const_string(INTERP, "WmlsInteger"));
  43             dynpmc_WmlsInvalid = pmc_type(INTERP,
  44               const_string(INTERP, "WmlsInvalid"));
  45         }
  46     }
  47
  48 /*
  49
  50 =item C<PMC *clone()>
  51
  52 =cut
  53
  54 */
  55     PMC* clone() {
  56         return pmc_new(INTERP, dynpmc_WmlsInvalid);
  57     }
  58
  59 /*
  60
  61 =item C<PMC* get_class()>
  62
  63 Return the integer 4.
  64
  65 =cut
  66
  67 */
  68     PMC* get_class() {
  69         PMC* retval = pmc_new(interp, dynpmc_WmlsInteger);
  70         PMC_int_val(retval) = 4;
  71         return retval;
  72     }
  73
  74 /*
  75
  76 =item C<STRING* get_string()>
  77
  78 Return the string "invalid".
  79
  80 =cut
  81
  82 */
  83     STRING* get_string() {
  84         return const_string(INTERP, "invalid");
  85     }
  86
  87 /*
  88
  89 =item C<void increment()>
  90
  91 =cut
  92
  93 */
  94     void increment() {
  95         return;
  96     }
  97
  98 /*
  99
 100 =item C<void decrement()>
 101
 102 =cut
 103
 104 */
 105     void decrement() {
 106         return;
 107     }
 108
 109 /*
 110
 111 =item C<PMC* absolute(PMC *dest)>
 112
 113 =item C<void i_absolute()>
 114
 115 =cut
 116
 117 */
 118     PMC* absolute(PMC* dest) {
 119         return pmc_new(INTERP, dynpmc_WmlsInvalid);
 120     }
 121
 122     void i_absolute() {
 123         return;
 124     }
 125
 126 /*
 127
 128 =item C<PMC* neg(PMC *dest)>
 129
 130 =item C<void i_neg()>
 131
 132 =cut
 133
 134 */
 135     PMC* neg(PMC* dest) {
 136         return pmc_new(INTERP, dynpmc_WmlsInvalid);
 137     }
 138
 139     void i_neg() {
 140         return;
 141     }
 142
 143 /*
 144
 145 =item C<PMC* bitwise_not(PMC *dest)>
 146
 147 =item C<void i_bitwise_not()>
 148
 149 =cut
 150
 151 */
 152     PMC* bitwise_not(PMC* dest) {
 153         return pmc_new(INTERP, dynpmc_WmlsInvalid);
 154     }
 155
 156     void i_bitwise_not() {
 157         return;
 158     }
 159
 160 /*
 161
 162 =item C<PMC* logical_not(PMC *dest)>
 163
 164 =item C<void i_logical_not()>
 165
 166 =cut
 167
 168 */
 169     PMC* logical_not(PMC* dest) {
 170         return pmc_new(INTERP, dynpmc_WmlsInvalid);
 171     }
 172
 173     void i_logical_not() {
 174         return;
 175     }
 176
 177 /*
 178
 179 =back
 180
 181 =head2 non-Vtable Methods
 182
 183 =over 4
 184
 185 =item C<void add(PMC *value, PMC *dest)>
 186
 187 =item C<void i_add(PMC *value)>
 188
 189 =cut
 190
 191 */
 192     PMC* add(PMC* value, PMC* dest) {
 193             return pmc_new(INTERP, dynpmc_WmlsInvalid);
 194     }
 195
 196     void i_add(PMC* value) {
 197             return;
 198     }
 199
 200 /*
 201
 202 =item C<PMC* subtract(PMC *value, PMC *dest)>
 203
 204 =item C<void i_subtract(PMC *value)>
 205
 206 =cut
 207
 208 */
 209     PMC* subtract(PMC* value, PMC* dest) {
 210             return pmc_new(INTERP, dynpmc_WmlsInvalid);
 211     }
 212
 213     void i_subtract(PMC* value) {
 214             return;
 215     }
 216
 217 /*
 218
 219 =item C<PMC* multiply(PMC *value, PMC *dest)>
 220
 221 =item C<void i_multiply(PMC *value)>
 222
 223 =cut
 224
 225 */
 226     PMC* multiply(PMC* value, PMC* dest) {
 227             return pmc_new(INTERP, dynpmc_WmlsInvalid);
 228     }
 229
 230     void i_multiply(PMC* value) {
 231             return;
 232     }
 233
 234 /*
 235
 236 =item C<PMC* divide(PMC *value, PMC *dest)>
 237
 238 =item C<void i_divide(PMC *value)>
 239
 240 =cut
 241
 242 */
 243     PMC* divide(PMC* value, PMC* dest) {
 244             return pmc_new(INTERP, dynpmc_WmlsInvalid);
 245     }
 246
 247     void i_divide(PMC* value) {
 248             return;
 249     }
 250
 251 /*
 252
 253 =item C<PMC* floor_divide(PMC *value, PMC *dest)>
 254
 255 =item C<void i_floor_divide(PMC *value)>
 256
 257 =cut
 258
 259 */
 260     PMC* floor_divide(PMC* value, PMC* dest) {
 261             return pmc_new(INTERP, dynpmc_WmlsInvalid);
 262     }
 263
 264     void i_floor_divide(PMC* value) {
 265             return;
 266     }
 267
 268 /*
 269
 270 =item C<PMC* cmodulus(PMC *value, PMC *dest)>
 271
 272 =item C<void i_cmodulus(PMC *value)>
 273
 274 =cut
 275
 276 */
 277     PMC* cmodulus(PMC* value, PMC* dest) {
 278             return pmc_new(INTERP, dynpmc_WmlsInvalid);
 279     }
 280
 281     void i_cmodulus(PMC* value) {
 282             return;
 283     }
 284
 285 /*
 286
 287 =item C<PMC* bitwise_or(PMC *value, PMC *dest)>
 288
 289 =item C<void i_bitwise_or(PMC *value)>
 290
 291 =cut
 292
 293 */
 294     PMC* bitwise_or(PMC* value, PMC* dest) {
 295             return pmc_new(INTERP, dynpmc_WmlsInvalid);
 296     }
 297
 298     void i_bitwise_or(PMC* value) {
 299             return;
 300     }
 301
 302 /*
 303
 304 =item C<PMC* bitwise_and(PMC *value, PMC *dest)>
 305
 306 =item C<void i_bitwise_and(PMC *value)>
 307
 308 =cut
 309
 310 */
 311     PMC* bitwise_and(PMC* value, PMC* dest) {
 312             return pmc_new(INTERP, dynpmc_WmlsInvalid);
 313     }
 314
 315     void i_bitwise_and(PMC* value) {
 316             return;
 317     }
 318
 319 /*
 320
 321 =item C<void bitwise_xor(PMC *value, PMC *dest)>
 322
 323 =item C<void i_bitwise_xor(PMC *value)>
 324
 325 =cut
 326
 327 */
 328     PMC* bitwise_xor(PMC* value, PMC* dest) {
 329             return pmc_new(INTERP, dynpmc_WmlsInvalid);
 330     }
 331
 332     void i_bitwise_xor(PMC* value) {
 333             return;
 334     }
 335
 336 /*
 337
 338 =item C<PMC* bitwise_shr(PMC *value, PMC *dest)>
 339
 340 =item C<void i_bitwise_shr(PMC *value)>
 341
 342 =cut
 343
 344 */
 345     PMC* bitwise_shr(PMC* value, PMC* dest) {
 346             return pmc_new(INTERP, dynpmc_WmlsInvalid);
 347     }
 348
 349     void i_bitwise_shr(PMC* value) {
 350             return;
 351     }
 352
 353 /*
 354
 355 =item C<PMC* bitwise_lsr(PMC *value, PMC *dest)>
 356
 357 =item C<void i_bitwise_lsr(PMC *value)>
 358
 359 =cut
 360
 361 */
 362     PMC* bitwise_lsr(PMC* value, PMC* dest) {
 363             return pmc_new(INTERP, dynpmc_WmlsInvalid);
 364     }
 365
 366     void i_bitwise_lsr(PMC* value) {
 367             return;
 368     }
 369
 370 /*
 371
 372 =item C<PMC* bitwise_shl(PMC *value, PMC *dest)>
 373
 374 =item C<void i_bitwise_shl(PMC *value)>
 375
 376 =cut
 377
 378 */
 379     PMC* bitwise_shl(PMC* value, PMC* dest) {
 380             return pmc_new(INTERP, dynpmc_WmlsInvalid);
 381     }
 382
 383     void i_bitwise_shl(PMC* value) {
 384             return;
 385     }
 386
 387 /*
 388
 389 =item C<PMC* is_equal(PMC* value)>
 390
 391 =cut
 392
 393 */
 394     INTVAL is_equal(PMC* value) {
 395             return 4;
 396     }
 397
 398 /*
 399
 400 =item C<PMC* cmp(PMC *value)>
 401
 402 =cut
 403
 404 */
 405     INTVAL cmp(PMC* value) {
 406             return 4;
 407     }
 408
 409 }
 410
 411 /*
 412
 413 =back
 414
 415 =head1 AUTHORS
 416
 417 Francois Perrad.
 418
 419 =cut
 420
 421 */
 422
 423
 424 /*
 425  * Local variables:
 426  *   c-file-style: "parrot"
 427  * End:
 428  * vim: expandtab shiftwidth=4:
 429  */