00001
00002
00003
00004
00005
00006
00007
00008
00009 case '?':
00010 if (!CAR(n)) {
00011 if (!CDR(n)) {
00012 #ifdef PIKE_DEBUG
00013 if (l_flag > 4) {
00014 fprintf(stderr, "Match: ""'?'{615}(-{616}, -{617})""\n");
00015 }
00016 #endif
00017 #ifdef PIKE_DEBUG
00018 if (l_flag > 4) {
00019 fprintf(stderr, "=> ""-{618}""\n");
00020 }
00021 #endif
00022 goto zap_node;
00023 } else {
00024 if (CDR(n)->token == ':') {
00025 #ifdef PIKE_DEBUG
00026 if (l_flag > 4) {
00027 fprintf(stderr, "Match: ""'?'{619}(-{620}, ':'{621}(*, 0 = *{623}))""\n");
00028 }
00029 #endif
00030 #ifdef PIKE_DEBUG
00031 if (l_flag > 4) {
00032 fprintf(stderr, "=> ""0 = *{624}""\n");
00033 }
00034 #endif
00035 {
00036 ADD_NODE_REF2(CDDR(n),
00037 tmp1 = CDDR(n);
00038 );
00039 goto use_tmp1;
00040 }
00041 }
00042 }
00043 } else if (!CDR(n)) {
00044 #ifdef PIKE_DEBUG
00045 if (l_flag > 4) {
00046 fprintf(stderr, "Match: ""'?'{625}(0 = *{626}, -{627})""\n");
00047 }
00048 #endif
00049 #ifdef PIKE_DEBUG
00050 if (l_flag > 4) {
00051 fprintf(stderr, "=> ""0 = *{628}""\n");
00052 }
00053 #endif
00054 goto use_car;
00055 } else {
00056 if (CAR(n)->token == F_APPLY) {
00057 if (!CAAR(n)) {
00058 } else {
00059 if (CAAR(n)->token == F_CONSTANT) {
00060 if ((CAAR(n)->u.sval.type == T_FUNCTION) &&
00061 (CAAR(n)->u.sval.subtype == FUNCTION_BUILTIN) &&
00062 (CAAR(n)->u.sval.u.efun->function == f_not)) {
00063 if (!CDR(n)) {
00064 } else {
00065 if (CDR(n)->token == ':') {
00066 #ifdef PIKE_DEBUG
00067 if (l_flag > 4) {
00068 fprintf(stderr, "Match: ""'?'{635}(F_APPLY{636}(F_CONSTANT{637}[CAAR(n)->u.sval.type == T_FUNCTION][CAAR(n)->u.sval.subtype == FUNCTION_BUILTIN][CAAR(n)->u.sval.u.efun->function == f_not], 0 = *{638}), ':'{639}(1 = *{640}, 2 = *{641}))""\n");
00069 }
00070 #endif
00071 #ifdef PIKE_DEBUG
00072 if (l_flag > 4) {
00073 fprintf(stderr, "=> ""'?'{642}""\n");
00074 }
00075 #endif
00076 {
00077 ADD_NODE_REF2(CDAR(n),
00078 ADD_NODE_REF2(CDDR(n),
00079 ADD_NODE_REF2(CADR(n),
00080 tmp1 = mknode('?', CDAR(n), mknode(':', CDDR(n), CADR(n)));
00081 )));
00082 goto use_tmp1;
00083 }
00084 }
00085 }
00086 }
00087 }
00088 }
00089 }
00090 if (CDR(n)->token == ':') {
00091 if (!CADR(n)) {
00092 if (!CDDR(n)) {
00093 #ifdef PIKE_DEBUG
00094 if (l_flag > 4) {
00095 fprintf(stderr, "Match: ""'?'{629}(0 = *{630}, ':'{631}(-{632}, -{633}))""\n");
00096 }
00097 #endif
00098 #ifdef PIKE_DEBUG
00099 if (l_flag > 4) {
00100 fprintf(stderr, "=> ""0 = *{634}""\n");
00101 }
00102 #endif
00103 goto use_car;
00104 }
00105 } else if (!CDDR(n)) {
00106 } else {
00107 if ((CDDR(n) == CADR(n))
00108 #ifdef SHARED_NODES_MK2
00109 || (CDDR(n) && CADR(n) &&
00110 ((CDDR(n)->master?CDDR(n)->master:CDDR(n))==
00111 (CADR(n)->master?CADR(n)->master:CADR(n))))
00112 #endif
00113 ) {
00114 #ifdef PIKE_DEBUG
00115 if (l_flag > 4) {
00116 fprintf(stderr, "Match: ""'?'{659}(0 = *{660}, ':'{661}(1 = *{662}, $CADR(n)$))""\n");
00117 }
00118 #endif
00119 #ifdef PIKE_DEBUG
00120 if (l_flag > 4) {
00121 fprintf(stderr, "=> ""F_COMMA_EXPR{663}""\n");
00122 }
00123 #endif
00124 {
00125 ADD_NODE_REF2(CAR(n),
00126 ADD_NODE_REF2(CADR(n),
00127 tmp1 = mknode(F_COMMA_EXPR, CAR(n), CADR(n));
00128 ));
00129 goto use_tmp1;
00130 }
00131 }
00132 {
00133 if (CADR(n)->token == F_COMMA_EXPR) {
00134 if (!CDDR(n)) {
00135 } else {
00136 if ((CDDR(n) == CDADR(n))
00137 #ifdef SHARED_NODES_MK2
00138 || (CDDR(n) && CDADR(n) &&
00139 ((CDDR(n)->master?CDDR(n)->master:CDDR(n))==
00140 (CDADR(n)->master?CDADR(n)->master:CDADR(n))))
00141 #endif
00142 ) {
00143 #ifdef PIKE_DEBUG
00144 if (l_flag > 4) {
00145 fprintf(stderr, "Match: ""'?'{666}(0 = *{667}, ':'{668}(F_COMMA_EXPR{669}(1 = *{670}, 2 = *{671}), $CDADR(n)$))""\n");
00146 }
00147 #endif
00148 #ifdef PIKE_DEBUG
00149 if (l_flag > 4) {
00150 fprintf(stderr, "=> ""F_COMMA_EXPR{672}""\n");
00151 }
00152 #endif
00153 {
00154 ADD_NODE_REF2(CAR(n),
00155 ADD_NODE_REF2(CAADR(n),
00156 ADD_NODE_REF2(CDADR(n),
00157 tmp1 = mknode(F_COMMA_EXPR, mknode('?', CAR(n), mknode(':', CAADR(n), 0)), CDADR(n));
00158 )));
00159 goto use_tmp1;
00160 }
00161 }
00162 {
00163 if (CDDR(n)->token == F_COMMA_EXPR) {
00164 {
00165 if ((CDDDR(n) == CDADR(n))
00166 #ifdef SHARED_NODES_MK2
00167 || (CDDDR(n) && CDADR(n) &&
00168 ((CDDDR(n)->master?CDDDR(n)->master:CDDDR(n))==
00169 (CDADR(n)->master?CDADR(n)->master:CDADR(n))))
00170 #endif
00171 ) {
00172 #ifdef PIKE_DEBUG
00173 if (l_flag > 4) {
00174 fprintf(stderr, "Match: ""'?'{692}(0 = *{693}, ':'{694}(F_COMMA_EXPR{695}(1 = *{696}, 2 = *{697}), F_COMMA_EXPR{698}(3 = *{699}, $CDADR(n)$)))""\n");
00175 }
00176 #endif
00177 #ifdef PIKE_DEBUG
00178 if (l_flag > 4) {
00179 fprintf(stderr, "=> ""F_COMMA_EXPR{700}""\n");
00180 }
00181 #endif
00182 {
00183 ADD_NODE_REF2(CAR(n),
00184 ADD_NODE_REF2(CAADR(n),
00185 ADD_NODE_REF2(CADDR(n),
00186 ADD_NODE_REF2(CDADR(n),
00187 tmp1 = mknode(F_COMMA_EXPR, mknode('?', CAR(n), mknode(':', CAADR(n), CADDR(n))), CDADR(n));
00188 ))));
00189 goto use_tmp1;
00190 }
00191 }
00192 }
00193 }
00194 }
00195 }
00196 }
00197 if (CDDR(n)->token == F_COMMA_EXPR) {
00198 {
00199 if ((CDDDR(n) == CADR(n))
00200 #ifdef SHARED_NODES_MK2
00201 || (CDDDR(n) && CADR(n) &&
00202 ((CDDDR(n)->master?CDDDR(n)->master:CDDDR(n))==
00203 (CADR(n)->master?CADR(n)->master:CADR(n))))
00204 #endif
00205 ) {
00206 #ifdef PIKE_DEBUG
00207 if (l_flag > 4) {
00208 fprintf(stderr, "Match: ""'?'{679}(0 = *{680}, ':'{681}(1 = *{682}, F_COMMA_EXPR{683}(2 = *{684}, $CADR(n)$)))""\n");
00209 }
00210 #endif
00211 #ifdef PIKE_DEBUG
00212 if (l_flag > 4) {
00213 fprintf(stderr, "=> ""F_COMMA_EXPR{685}""\n");
00214 }
00215 #endif
00216 {
00217 ADD_NODE_REF2(CAR(n),
00218 ADD_NODE_REF2(CADDR(n),
00219 ADD_NODE_REF2(CADR(n),
00220 tmp1 = mknode(F_COMMA_EXPR, mknode('?', CAR(n), mknode(':', 0, CADDR(n))), CADR(n));
00221 )));
00222 goto use_tmp1;
00223 }
00224 }
00225 }
00226 }
00227 if (!CDDR(n)) {
00228 } else {
00229 if (((pike_types_le(CADR(n)->type, void_type_string) !=
00230 pike_types_le(CDDR(n)->type, void_type_string)))) {
00231 #ifdef PIKE_DEBUG
00232 if (l_flag > 4) {
00233 fprintf(stderr, "Match: ""'?'{707}(*, ':'{709}(0 = +{710}, +{711}[(pike_types_le(CADR(n)->type, void_type_string) !=\n\t\t pike_types_le(CDDR(n)->type, void_type_string))]))""\n");
00234 }
00235 #endif
00236 {
00237 yyerror("The arguments to ?: may not be void.");
00238 }
00239 }
00240 }
00241 }
00242 }
00243 }
00244 if (( node_is_tossable(CAR(n)) )) {
00245 if (!CDR(n)) {
00246 } else {
00247 if (CDR(n)->token == ':') {
00248 if (!CADR(n)) {
00249 } else {
00250 if (CADR(n)->token == F_RETURN) {
00251 {
00252 if ((CAADR(n) == CAR(n))
00253 #ifdef SHARED_NODES_MK2
00254 || (CAADR(n) && CAR(n) &&
00255 ((CAADR(n)->master?CAADR(n)->master:CAADR(n))==
00256 (CAR(n)->master?CAR(n)->master:CAR(n))))
00257 #endif
00258 ) {
00259 #ifdef PIKE_DEBUG
00260 if (l_flag > 4) {
00261 fprintf(stderr, "Match: ""'?'{1200}(0 = +{1201}[ node_is_tossable(CAR(n)) ], ':'{1202}(F_RETURN{1203}($CAR(n)$, *), 1 = *{1205}))""\n");
00262 }
00263 #endif
00264 {
00265 struct pike_type *type = CAR(n)->type;
00266 struct pike_string *tmpname;
00267 int tmpvar;
00268 void add_local_name(struct pike_string *, struct pike_type *, node *);
00269
00270 MAKE_CONST_STRING(tmpname, " ");
00271 tmpvar = islocal(tmpname);
00272 if(tmpvar == -1)
00273 {
00274 add_ref(mixed_type_string);
00275 add_local_name(tmpname, mixed_type_string, 0);
00276 tmpvar = islocal(tmpname);
00277 }
00278
00279 ADD_NODE_REF2(CDDR(n),
00280 ADD_NODE_REF2(CAR(n),
00281 tmp1 = mknode('?', mknode(F_ASSIGN, CAR(n), mklocalnode(tmpvar,0)),
00282 mknode(':',mknode(F_RETURN,
00283 mksoftcastnode(type, mklocalnode(tmpvar,0)),
00284 0),
00285 CDDR(n)));
00286 ));
00287 goto use_tmp1;
00288 }
00289 }
00290 }
00291 }
00292 }
00293 }
00294 }
00295 }
00296 if ((node_is_false(CAR(n)))) {
00297 if (!CDR(n)) {
00298 } else {
00299 if (CDR(n)->token == ':') {
00300 #ifdef PIKE_DEBUG
00301 if (l_flag > 4) {
00302 fprintf(stderr, "Match: ""'?'{653}(+{654}[node_is_false(CAR(n))], ':'{655}(*, 0 = *{657}))""\n");
00303 }
00304 #endif
00305 #ifdef PIKE_DEBUG
00306 if (l_flag > 4) {
00307 fprintf(stderr, "=> ""0 = *{658}""\n");
00308 }
00309 #endif
00310 {
00311 ADD_NODE_REF2(CDDR(n),
00312 tmp1 = CDDR(n);
00313 );
00314 goto use_tmp1;
00315 }
00316 }
00317 }
00318 }
00319 if ((node_is_true(CAR(n)))) {
00320 if (!CDR(n)) {
00321 } else {
00322 if (CDR(n)->token == ':') {
00323 #ifdef PIKE_DEBUG
00324 if (l_flag > 4) {
00325 fprintf(stderr, "Match: ""'?'{647}(+{648}[node_is_true(CAR(n))], ':'{649}(0 = *{650}, *))""\n");
00326 }
00327 #endif
00328 #ifdef PIKE_DEBUG
00329 if (l_flag > 4) {
00330 fprintf(stderr, "=> ""0 = *{652}""\n");
00331 }
00332 #endif
00333 {
00334 ADD_NODE_REF2(CADR(n),
00335 tmp1 = CADR(n);
00336 );
00337 goto use_tmp1;
00338 }
00339 }
00340 }
00341 }
00342 }
00343 break;
00344
00345 case F_ADD_EQ:
00346 if (!CAR(n)) {
00347 } else if (!CDR(n)) {
00348 } else {
00349 if (CDR(n)->token == F_CONSTANT) {
00350 if ((CDR(n)->u.sval.type == T_INT) &&
00351 ((CDR(n)->u.sval.u.integer) == -1)) {
00352 #ifdef PIKE_DEBUG
00353 if (l_flag > 4) {
00354 fprintf(stderr, "Match: ""F_ADD_EQ{774}(0 = *{775}, 1 = F_CONSTANT{776}[CDR(n)->u.sval.type == T_INT][(CDR(n)->u.sval.u.integer) == -1])""\n");
00355 }
00356 #endif
00357 #ifdef PIKE_DEBUG
00358 if (l_flag > 4) {
00359 fprintf(stderr, "=> ""F_DEC{777}""\n");
00360 }
00361 #endif
00362 {
00363 ADD_NODE_REF2(CAR(n),
00364 tmp1 = mknode(F_DEC, CAR(n), 0);
00365 );
00366 goto use_tmp1;
00367 }
00368 }
00369 if ((CDR(n)->u.sval.type == T_INT) &&
00370 ((CDR(n)->u.sval.u.integer) == 1)) {
00371 #ifdef PIKE_DEBUG
00372 if (l_flag > 4) {
00373 fprintf(stderr, "Match: ""F_ADD_EQ{768}(0 = *{769}, 1 = F_CONSTANT{770}[CDR(n)->u.sval.type == T_INT][(CDR(n)->u.sval.u.integer) == 1])""\n");
00374 }
00375 #endif
00376 #ifdef PIKE_DEBUG
00377 if (l_flag > 4) {
00378 fprintf(stderr, "=> ""F_INC{771}""\n");
00379 }
00380 #endif
00381 {
00382 ADD_NODE_REF2(CAR(n),
00383 tmp1 = mknode(F_INC, CAR(n), 0);
00384 );
00385 goto use_tmp1;
00386 }
00387 }
00388 }
00389 if (( CAR(n)->token != F_AUTO_MAP_MARKER )) {
00390 if (!CDR(n)) {
00391 } else {
00392 if (CDR(n)->token == F_CONSTANT) {
00393 if ((CDR(n)->u.sval.type == T_INT) &&
00394 (!(CDR(n)->u.sval.u.integer))) {
00395 #ifdef PIKE_DEBUG
00396 if (l_flag > 4) {
00397 fprintf(stderr, "Match: ""F_ADD_EQ{764}(0 = +{765}[ CAR(n)->token != F_AUTO_MAP_MARKER ], 1 = F_CONSTANT{766}[CDR(n)->u.sval.type == T_INT][!(CDR(n)->u.sval.u.integer)])""\n");
00398 }
00399 #endif
00400 #ifdef PIKE_DEBUG
00401 if (l_flag > 4) {
00402 fprintf(stderr, "=> ""0 = *{767}""\n");
00403 }
00404 #endif
00405 goto use_car;
00406 }
00407 }
00408 }
00409 }
00410 }
00411 break;
00412
00413 case F_APPLY:
00414 if (!CAR(n)) {
00415 #ifdef PIKE_DEBUG
00416 if (l_flag > 4) {
00417 fprintf(stderr, "Match: ""F_APPLY{6}(-{7}, *)""\n");
00418 }
00419 #endif
00420 #ifdef PIKE_DEBUG
00421 if (l_flag > 4) {
00422 fprintf(stderr, "=> ""F_COMMA_EXPR{9}""\n");
00423 }
00424 #endif
00425 {
00426 ADD_NODE_REF2(CDR(n),
00427 tmp1 = mknode(F_COMMA_EXPR, mknode(F_POP_VALUE, CDR(n), 0), mkintnode(0));
00428 );
00429 goto use_tmp1;
00430 }
00431 } else {
00432 if (CAR(n)->token == F_CONSTANT) {
00433 if ((CAR(n)->u.sval.type == T_FUNCTION) &&
00434 (CAR(n)->u.sval.subtype == FUNCTION_BUILTIN) &&
00435 (CAR(n)->u.sval.u.efun->function == f_add)) {
00436 if (!CDR(n)) {
00437 } else {
00438 if (CDR(n)->token == F_ARG_LIST) {
00439 if (!CADR(n)) {
00440 } else {
00441 if (CADR(n)->token == F_APPLY) {
00442 {
00443 if ((CAADR(n) == CAR(n))
00444 #ifdef SHARED_NODES_MK2
00445 || (CAADR(n) && CAR(n) &&
00446 ((CAADR(n)->master?CAADR(n)->master:CAADR(n))==
00447 (CAR(n)->master?CAR(n)->master:CAR(n))))
00448 #endif
00449 ) {
00450 #ifdef PIKE_DEBUG
00451 if (l_flag > 4) {
00452 fprintf(stderr, "Match: ""F_APPLY{57}(0 = F_CONSTANT{58}[CAR(n)->u.sval.type == T_FUNCTION][CAR(n)->u.sval.subtype == FUNCTION_BUILTIN][CAR(n)->u.sval.u.efun->function == f_add], 2 = F_ARG_LIST{59}(F_APPLY{60}($CAR(n)$, 1 = *{61}), 3 = *{62}))""\n");
00453 }
00454 #endif
00455 {
00456 node *arglist = CDR(n);
00457 #ifdef SHARED_NODES
00458 sub_node(n);
00459 #endif
00460 ADD_NODE_REF2(CDADR(n),
00461 ADD_NODE_REF2(CDDR(n),
00462 _CDR(n) = mknode(F_ARG_LIST, CDADR(n), CDDR(n))));
00463 #ifdef SHARED_NODES
00464 n->hash = hash_node(n);
00465 n->node_info |= OPT_DEFROSTED;
00466 #endif
00467 _CDR(n)->parent = NULL;
00468 fix_type_field(_CDR(n));
00469 free_node(arglist);
00470 #ifdef PIKE_DEBUG
00471 if (l_flag > 4) {
00472 fprintf(stderr, "Result: ");
00473 print_tree(n);
00474 }
00475 #endif
00476 continue;
00477 }
00478 }
00479 }
00480 }
00481 }
00482 }
00483 }
00484 }
00485 if ((CAR(n)->u.sval.type == T_FUNCTION) &&
00486 (CAR(n)->u.sval.subtype == FUNCTION_BUILTIN) &&
00487 (CAR(n)->u.sval.u.efun->function == f_minus)) {
00488 if (!CDR(n)) {
00489 } else {
00490 if (CDR(n)->token == F_ARG_LIST) {
00491 if (!CADR(n)) {
00492 } else {
00493 if (CADR(n)->token == F_APPLY) {
00494 {
00495 if ((CAADR(n) == CAR(n))
00496 #ifdef SHARED_NODES_MK2
00497 || (CAADR(n) && CAR(n) &&
00498 ((CAADR(n)->master?CAADR(n)->master:CAADR(n))==
00499 (CAR(n)->master?CAR(n)->master:CAR(n))))
00500 #endif
00501 ) {
00502 if (!CDADR(n)) {
00503 } else {
00504 if (CDADR(n)->token == F_ARG_LIST) {
00505 if (!CADADR(n)) {
00506 } else {
00507 if (!CDDADR(n)) {
00508 } else {
00509 #ifdef PIKE_DEBUG
00510 if (l_flag > 4) {
00511 fprintf(stderr, "Match: ""F_APPLY{63}(0 = F_CONSTANT{64}[CAR(n)->u.sval.type == T_FUNCTION][CAR(n)->u.sval.subtype == FUNCTION_BUILTIN][CAR(n)->u.sval.u.efun->function == f_minus], 2 = F_ARG_LIST{65}(F_APPLY{66}($CAR(n)$, 1 = F_ARG_LIST{67}(+{68}, +{69})), 3 = *{70}))""\n");
00512 }
00513 #endif
00514 {
00515 node *arglist = CDR(n);
00516 #ifdef SHARED_NODES
00517 sub_node(n);
00518 #endif
00519 ADD_NODE_REF2(CDADR(n),
00520 ADD_NODE_REF2(CDDR(n),
00521 _CDR(n) = mknode(F_ARG_LIST, CDADR(n), CDDR(n))));
00522 #ifdef SHARED_NODES
00523 n->hash = hash_node(n);
00524 n->node_info |= OPT_DEFROSTED;
00525 #endif
00526 _CDR(n)->parent = NULL;
00527 fix_type_field(_CDR(n));
00528 free_node(arglist);
00529 #ifdef PIKE_DEBUG
00530 if (l_flag > 4) {
00531 fprintf(stderr, "Result: ");
00532 print_tree(n);
00533 }
00534 #endif
00535 continue;
00536 }
00537 }
00538 }
00539 }
00540 }
00541 }
00542 }
00543 }
00544 }
00545 }
00546 }
00547 }
00548 if ((CAR(n)->u.sval.type == T_FUNCTION) &&
00549 (CAR(n)->u.sval.subtype == FUNCTION_BUILTIN) &&
00550 (CAR(n)->u.sval.u.efun->function == f_multiply)) {
00551 if (!CDR(n)) {
00552 } else {
00553 if (CDR(n)->token == F_ARG_LIST) {
00554 if (!CADR(n)) {
00555 } else {
00556 if (CADR(n)->token == F_APPLY) {
00557 {
00558 if ((CAADR(n) == CAR(n))
00559 #ifdef SHARED_NODES_MK2
00560 || (CAADR(n) && CAR(n) &&
00561 ((CAADR(n)->master?CAADR(n)->master:CAADR(n))==
00562 (CAR(n)->master?CAR(n)->master:CAR(n))))
00563 #endif
00564 ) {
00565 #ifdef PIKE_DEBUG
00566 if (l_flag > 4) {
00567 fprintf(stderr, "Match: ""F_APPLY{71}(0 = F_CONSTANT{72}[CAR(n)->u.sval.type == T_FUNCTION][CAR(n)->u.sval.subtype == FUNCTION_BUILTIN][CAR(n)->u.sval.u.efun->function == f_multiply], 2 = F_ARG_LIST{73}(F_APPLY{74}($CAR(n)$, 1 = *{75}), 3 = *{76}))""\n");
00568 }
00569 #endif
00570 {
00571 node *arglist = CDR(n);
00572 #ifdef SHARED_NODES
00573 sub_node(n);
00574 #endif
00575 ADD_NODE_REF2(CDADR(n),
00576 ADD_NODE_REF2(CDDR(n),
00577 _CDR(n) = mknode(F_ARG_LIST, CDADR(n), CDDR(n))));
00578 #ifdef SHARED_NODES
00579 n->hash = hash_node(n);
00580 n->node_info |= OPT_DEFROSTED;
00581 #endif
00582 _CDR(n)->parent = NULL;
00583 fix_type_field(_CDR(n));
00584 free_node(arglist);
00585 #ifdef PIKE_DEBUG
00586 if (l_flag > 4) {
00587 fprintf(stderr, "Result: ");
00588 print_tree(n);
00589 }
00590 #endif
00591 continue;
00592 }
00593 }
00594 }
00595 }
00596 }
00597 }
00598 }
00599 }
00600 if ((CAR(n)->u.sval.type == T_FUNCTION) &&
00601 (CAR(n)->u.sval.subtype == FUNCTION_BUILTIN) &&
00602 (CAR(n)->u.sval.u.efun->function == f_sizeof)) {
00603 if (!CDR(n)) {
00604 } else {
00605 if (CDR(n)->token == F_APPLY) {
00606 if (!CADR(n)) {
00607 } else {
00608 if (CADR(n)->token == F_CONSTANT) {
00609 if ((CADR(n)->u.sval.type == T_FUNCTION) &&
00610 (CADR(n)->u.sval.subtype == FUNCTION_BUILTIN) &&
00611 (CADR(n)->u.sval.u.efun->function == f_multiply)) {
00612 if (!CDDR(n)) {
00613 } else {
00614 if (CDDR(n)->token == F_ARG_LIST) {
00615 if (!CADDR(n)) {
00616 } else {
00617 if ((!match_types(object_type_string, CADDR(n)->type))) {
00618 if (!CDDDR(n)) {
00619 } else {
00620 if ((pike_types_le(CDDDR(n)->type, int_type_string))) {
00621 #ifdef PIKE_DEBUG
00622 if (l_flag > 4) {
00623 fprintf(stderr, "Match: ""F_APPLY{43}(0 = F_CONSTANT{44}[CAR(n)->u.sval.type == T_FUNCTION][CAR(n)->u.sval.subtype == FUNCTION_BUILTIN][CAR(n)->u.sval.u.efun->function == f_sizeof], F_APPLY{45}(1 = F_CONSTANT{46}[CADR(n)->u.sval.type == T_FUNCTION][CADR(n)->u.sval.subtype == FUNCTION_BUILTIN][CADR(n)->u.sval.u.efun->function == f_multiply], F_ARG_LIST{47}(2 = +{48}[!match_types(object_type_string, CADDR(n)->type)], 3 = +{49}[pike_types_le(CDDDR(n)->type, int_type_string)])))""\n");
00624 }
00625 #endif
00626 #ifdef PIKE_DEBUG
00627 if (l_flag > 4) {
00628 fprintf(stderr, "=> ""F_APPLY{50}""\n");
00629 }
00630 #endif
00631 {
00632 ADD_NODE_REF2(CADR(n),
00633 ADD_NODE_REF2(CAR(n),
00634 ADD_NODE_REF2(CADDR(n),
00635 ADD_NODE_REF2(CDDDR(n),
00636 tmp1 = mknode(F_APPLY, CADR(n), mknode(F_ARG_LIST, mknode(F_APPLY, CAR(n), CADDR(n)), CDDDR(n)));
00637 ))));
00638 goto use_tmp1;
00639 }
00640 }
00641 }
00642 }
00643 if ((pike_types_le(CADDR(n)->type, int_type_string))) {
00644 if (!CDDDR(n)) {
00645 } else {
00646 if ((!match_types(object_type_string, CDDDR(n)->type))) {
00647 #ifdef PIKE_DEBUG
00648 if (l_flag > 4) {
00649 fprintf(stderr, "Match: ""F_APPLY{29}(0 = F_CONSTANT{30}[CAR(n)->u.sval.type == T_FUNCTION][CAR(n)->u.sval.subtype == FUNCTION_BUILTIN][CAR(n)->u.sval.u.efun->function == f_sizeof], F_APPLY{31}(1 = F_CONSTANT{32}[CADR(n)->u.sval.type == T_FUNCTION][CADR(n)->u.sval.subtype == FUNCTION_BUILTIN][CADR(n)->u.sval.u.efun->function == f_multiply], F_ARG_LIST{33}(2 = +{34}[pike_types_le(CADDR(n)->type, int_type_string)], 3 = +{35}[!match_types(object_type_string, CDDDR(n)->type)])))""\n");
00650 }
00651 #endif
00652 #ifdef PIKE_DEBUG
00653 if (l_flag > 4) {
00654 fprintf(stderr, "=> ""F_APPLY{36}""\n");
00655 }
00656 #endif
00657 {
00658 ADD_NODE_REF2(CADR(n),
00659 ADD_NODE_REF2(CADDR(n),
00660 ADD_NODE_REF2(CAR(n),
00661 ADD_NODE_REF2(CDDDR(n),
00662 tmp1 = mknode(F_APPLY, CADR(n), mknode(F_ARG_LIST, CADDR(n), mknode(F_APPLY, CAR(n), CDDDR(n))));
00663 ))));
00664 goto use_tmp1;
00665 }
00666 }
00667 }
00668 }
00669 }
00670 }
00671 }
00672 }
00673 }
00674 }
00675 }
00676 }
00677 }
00678 if ((CAR(n)->u.sval.type == T_FUNCTION) &&
00679 (CAR(n)->u.sval.subtype == FUNCTION_BUILTIN) &&
00680 (CAR(n)->u.sval.u.efun->optimize) &&
00681 ( (tmp1=CAR(n)->u.sval.u.efun->optimize(n)) )) {
00682 #ifdef PIKE_DEBUG
00683 if (l_flag > 4) {
00684 fprintf(stderr, "Match: ""0 = F_APPLY{0}(F_CONSTANT{1}[CAR(n)->u.sval.type == T_FUNCTION][CAR(n)->u.sval.subtype == FUNCTION_BUILTIN][CAR(n)->u.sval.u.efun->optimize][ (tmp1=CAR(n)->u.sval.u.efun->optimize(n)) ], *)""\n");
00685 }
00686 #endif
00687 {
00688 goto use_tmp1;
00689 }
00690 }
00691 if ((CAR(n)->u.sval.type == T_PROGRAM) &&
00692 (CAR(n)->u.sval.u.program->optimize) &&
00693 ( (tmp1=CAR(n)->u.sval.u.program->optimize(n)) )) {
00694 #ifdef PIKE_DEBUG
00695 if (l_flag > 4) {
00696 fprintf(stderr, "Match: ""0 = F_APPLY{3}(F_CONSTANT{4}[CAR(n)->u.sval.type == T_PROGRAM][CAR(n)->u.sval.u.program->optimize][ (tmp1=CAR(n)->u.sval.u.program->optimize(n)) ], *)""\n");
00697 }
00698 #endif
00699 {
00700 goto use_tmp1;
00701 }
00702 }
00703 }
00704 }
00705 break;
00706
00707 case F_ARG_LIST:
00708 if (!CAR(n)) {
00709 #ifdef PIKE_DEBUG
00710 if (l_flag > 4) {
00711 fprintf(stderr, "Match: ""F_ARG_LIST{401}(-{402}, 0 = *{403})""\n");
00712 }
00713 #endif
00714 #ifdef PIKE_DEBUG
00715 if (l_flag > 4) {
00716 fprintf(stderr, "=> ""0 = *{404}""\n");
00717 }
00718 #endif
00719 goto use_cdr;
00720 } else if (!CDR(n)) {
00721 #ifdef PIKE_DEBUG
00722 if (l_flag > 4) {
00723 fprintf(stderr, "Match: ""F_ARG_LIST{405}(0 = *{406}, -{407})""\n");
00724 }
00725 #endif
00726 #ifdef PIKE_DEBUG
00727 if (l_flag > 4) {
00728 fprintf(stderr, "=> ""0 = *{408}""\n");
00729 }
00730 #endif
00731 goto use_car;
00732 } else {
00733 if (CAR(n)->token == F_BREAK) {
00734 if (!CDR(n)) {
00735 } else {
00736 if ((!(CDR(n)->tree_info & OPT_CASE))) {
00737 #ifdef PIKE_DEBUG
00738 if (l_flag > 4) {
00739 fprintf(stderr, "Match: ""F_ARG_LIST{427}(0 = F_BREAK{428}, +{429}[!(CDR(n)->tree_info & OPT_CASE)])""\n");
00740 }
00741 #endif
00742 #ifdef PIKE_DEBUG
00743 if (l_flag > 4) {
00744 fprintf(stderr, "=> ""0 = *{430}""\n");
00745 }
00746 #endif
00747 goto use_car;
00748 }
00749 }
00750 } else if (CAR(n)->token == F_COMMA_EXPR) {
00751 if (!CDAR(n)) {
00752 } else {
00753 if (CDAR(n)->token == F_BREAK) {
00754 if (!CDR(n)) {
00755 } else {
00756 if ((!(CDR(n)->tree_info & OPT_CASE))) {
00757 #ifdef PIKE_DEBUG
00758 if (l_flag > 4) {
00759 fprintf(stderr, "Match: ""F_ARG_LIST{443}(0 = F_COMMA_EXPR{444}(*, F_BREAK{446}), +{447}[!(CDR(n)->tree_info & OPT_CASE)])""\n");
00760 }
00761 #endif
00762 #ifdef PIKE_DEBUG
00763 if (l_flag > 4) {
00764 fprintf(stderr, "=> ""0 = *{448}""\n");
00765 }
00766 #endif
00767 goto use_car;
00768 }
00769 }
00770 } else if (CDAR(n)->token == F_CONTINUE) {
00771 if (!CDR(n)) {
00772 } else {
00773 if ((!(CDR(n)->tree_info & OPT_CASE))) {
00774 #ifdef PIKE_DEBUG
00775 if (l_flag > 4) {
00776 fprintf(stderr, "Match: ""F_ARG_LIST{437}(0 = F_COMMA_EXPR{438}(*, F_CONTINUE{440}), +{441}[!(CDR(n)->tree_info & OPT_CASE)])""\n");
00777 }
00778 #endif
00779 #ifdef PIKE_DEBUG
00780 if (l_flag > 4) {
00781 fprintf(stderr, "=> ""0 = *{442}""\n");
00782 }
00783 #endif
00784 goto use_car;
00785 }
00786 }
00787 } else if (CDAR(n)->token == F_RETURN) {
00788 if (!CDR(n)) {
00789 } else {
00790 if ((!(CDR(n)->tree_info & OPT_CASE))) {
00791 #ifdef PIKE_DEBUG
00792 if (l_flag > 4) {
00793 fprintf(stderr, "Match: ""F_ARG_LIST{431}(0 = F_COMMA_EXPR{432}(*, F_RETURN{434}), +{435}[!(CDR(n)->tree_info & OPT_CASE)])""\n");
00794 }
00795 #endif
00796 #ifdef PIKE_DEBUG
00797 if (l_flag > 4) {
00798 fprintf(stderr, "=> ""0 = *{436}""\n");
00799 }
00800 #endif
00801 goto use_car;
00802 }
00803 }
00804 }
00805 }
00806 } else if (CAR(n)->token == F_CONTINUE) {
00807 if (!CDR(n)) {
00808 } else {
00809 if ((!(CDR(n)->tree_info & OPT_CASE))) {
00810 #ifdef PIKE_DEBUG
00811 if (l_flag > 4) {
00812 fprintf(stderr, "Match: ""F_ARG_LIST{423}(0 = F_CONTINUE{424}, +{425}[!(CDR(n)->tree_info & OPT_CASE)])""\n");
00813 }
00814 #endif
00815 #ifdef PIKE_DEBUG
00816 if (l_flag > 4) {
00817 fprintf(stderr, "=> ""0 = *{426}""\n");
00818 }
00819 #endif
00820 goto use_car;
00821 }
00822 }
00823 } else if (CAR(n)->token == F_RETURN) {
00824 if (!CDR(n)) {
00825 } else {
00826 if ((!(CDR(n)->tree_info & OPT_CASE))) {
00827 #ifdef PIKE_DEBUG
00828 if (l_flag > 4) {
00829 fprintf(stderr, "Match: ""F_ARG_LIST{419}(0 = F_RETURN{420}, +{421}[!(CDR(n)->tree_info & OPT_CASE)])""\n");
00830 }
00831 #endif
00832 #ifdef PIKE_DEBUG
00833 if (l_flag > 4) {
00834 fprintf(stderr, "=> ""0 = *{422}""\n");
00835 }
00836 #endif
00837 goto use_car;
00838 }
00839 }
00840 }
00841 if (CDR(n)->token == F_ARG_LIST) {
00842 #ifdef PIKE_DEBUG
00843 if (l_flag > 4) {
00844 fprintf(stderr, "Match: ""F_ARG_LIST{409}(0 = *{410}, F_ARG_LIST{411}(1 = *{412}, 2 = *{413}))""\n");
00845 }
00846 #endif
00847 #ifdef PIKE_DEBUG
00848 if (l_flag > 4) {
00849 fprintf(stderr, "=> ""F_ARG_LIST{414}""\n");
00850 }
00851 #endif
00852 {
00853 ADD_NODE_REF2(CAR(n),
00854 ADD_NODE_REF2(CADR(n),
00855 ADD_NODE_REF2(CDDR(n),
00856 tmp1 = mknode(F_ARG_LIST, mknode(F_ARG_LIST, CAR(n), CADR(n)), CDDR(n));
00857 )));
00858 goto use_tmp1;
00859 }
00860 }
00861 }
00862 break;
00863
00864 case F_ARROW:
00865 if (!CAR(n)) {
00866 #ifdef PIKE_DEBUG
00867 if (l_flag > 4) {
00868 fprintf(stderr, "Match: ""F_ARROW{810}(-{811}, *)""\n");
00869 }
00870 #endif
00871 #ifdef PIKE_DEBUG
00872 if (l_flag > 4) {
00873 fprintf(stderr, "=> ""F_COMMA_EXPR{813}""\n");
00874 }
00875 #endif
00876 {
00877 ADD_NODE_REF2(CDR(n),
00878 tmp1 = mknode(F_COMMA_EXPR, mknode(F_POP_VALUE, CDR(n), 0), mkintnode(0));
00879 );
00880 goto use_tmp1;
00881 }
00882 } else {
00883 if (CAR(n)->token == F_CONSTANT) {
00884 if ((CAR(n)->u.sval.type == T_OBJECT) &&
00885 (CAR(n)->u.sval.u.object->prog)) {
00886 if (!CDR(n)) {
00887 } else {
00888 if (CDR(n)->token == F_CONSTANT) {
00889 if ((CDR(n)->u.sval.type == T_STRING)) {
00890 #ifdef PIKE_DEBUG
00891 if (l_flag > 4) {
00892 fprintf(stderr, "Match: ""F_ARROW{818}(0 = F_CONSTANT{819}[CAR(n)->u.sval.type == T_OBJECT][CAR(n)->u.sval.u.object->prog], 1 = F_CONSTANT{820}[CDR(n)->u.sval.type == T_STRING])""\n");
00893 }
00894 #endif
00895 {
00896
00897
00898
00899
00900
00901
00902
00903
00904
00905
00906
00907
00908
00909
00910
00911
00912
00913
00914
00915 }
00916 }
00917 }
00918 }
00919 }
00920 }
00921 }
00922 break;
00923
00924 case F_CAST:
00925 if (!CAR(n)) {
00926 #ifdef PIKE_DEBUG
00927 if (l_flag > 4) {
00928 fprintf(stderr, "Match: ""F_CAST{185}(-{186}, *)""\n");
00929 }
00930 #endif
00931 #ifdef PIKE_DEBUG
00932 if (l_flag > 4) {
00933 fprintf(stderr, "=> ""-{188}""\n");
00934 }
00935 #endif
00936 goto zap_node;
00937 } else {
00938 if (CAR(n)->token == F_CAST) {
00939 if ((CAR(n)->type == n->type)) {
00940 #ifdef PIKE_DEBUG
00941 if (l_flag > 4) {
00942 fprintf(stderr, "Match: ""0 = F_CAST{192}(1 = F_CAST{193}[CAR(n)->type == n->type], *)""\n");
00943 }
00944 #endif
00945 #ifdef PIKE_DEBUG
00946 if (l_flag > 4) {
00947 fprintf(stderr, "=> ""1 = *{197}""\n");
00948 }
00949 #endif
00950 goto use_car;
00951 }
00952 } else if (CAR(n)->token == F_CONSTANT) {
00953 if ((CAR(n)->type == n->type)) {
00954 #ifdef PIKE_DEBUG
00955 if (l_flag > 4) {
00956 fprintf(stderr, "Match: ""0 = F_CAST{198}(1 = F_CONSTANT{199}[CAR(n)->type == n->type], *)""\n");
00957 }
00958 #endif
00959 #ifdef PIKE_DEBUG
00960 if (l_flag > 4) {
00961 fprintf(stderr, "=> ""1 = *{203}""\n");
00962 }
00963 #endif
00964 goto use_car;
00965 }
00966 }
00967 if ((CAR(n)->type == void_type_string)) {
00968 #ifdef PIKE_DEBUG
00969 if (l_flag > 4) {
00970 fprintf(stderr, "Match: ""F_CAST{189}(0 = +{190}[CAR(n)->type == void_type_string], *)""\n");
00971 }
00972 #endif
00973 {
00974 yywarning("Casting a void expression\n");
00975
00976 ADD_NODE_REF2(CAR(n),
00977 tmp1 = CAR(n);
00978 );
00979 goto use_tmp1;
00980 }
00981 }
00982 }
00983 break;
00984
00985 case F_COMMA_EXPR:
00986 if (!CAR(n)) {
00987 #ifdef PIKE_DEBUG
00988 if (l_flag > 4) {
00989 fprintf(stderr, "Match: ""F_COMMA_EXPR{218}(-{219}, 0 = *{220})""\n");
00990 }
00991 #endif
00992 #ifdef PIKE_DEBUG
00993 if (l_flag > 4) {
00994 fprintf(stderr, "=> ""0 = *{221}""\n");
00995 }
00996 #endif
00997 goto use_cdr;
00998 } else if (!CDR(n)) {
00999 #ifdef PIKE_DEBUG
01000 if (l_flag > 4) {
01001 fprintf(stderr, "Match: ""F_COMMA_EXPR{222}(0 = *{223}, -{224})""\n");
01002 }
01003 #endif
01004 #ifdef PIKE_DEBUG
01005 if (l_flag > 4) {
01006 fprintf(stderr, "=> ""0 = *{225}""\n");
01007 }
01008 #endif
01009 goto use_car;
01010 } else {
01011 if (CAR(n)->token == F_ARG_LIST) {
01012 #ifdef PIKE_DEBUG
01013 if (l_flag > 4) {
01014 fprintf(stderr, "Match: ""F_COMMA_EXPR{291}(F_ARG_LIST{292}(0 = *{293}, 1 = *{294}), 2 = *{295})""\n");
01015 }
01016 #endif
01017 #ifdef PIKE_DEBUG
01018 if (l_flag > 4) {
01019 fprintf(stderr, "=> ""F_COMMA_EXPR{296}""\n");
01020 }
01021 #endif
01022 {
01023 ADD_NODE_REF2(CAAR(n),
01024 ADD_NODE_REF2(CDAR(n),
01025 ADD_NODE_REF2(CDR(n),
01026 tmp1 = mknode(F_COMMA_EXPR, mknode(F_COMMA_EXPR, CAAR(n), CDAR(n)), CDR(n));
01027 )));
01028 goto use_tmp1;
01029 }
01030 } else if (CAR(n)->token == F_ASSIGN) {
01031 if (!CDAR(n)) {
01032 } else {
01033 if (CDAR(n)->token == F_LOCAL) {
01034 if (!CDR(n)) {
01035 } else {
01036 if (CDR(n)->token == F_COMMA_EXPR) {
01037 if (!CADR(n)) {
01038 } else {
01039 if (CADR(n)->token == F_DEC) {
01040 if (!CDADR(n)) {
01041 if (!CAADR(n)) {
01042 } else {
01043 if (CAADR(n)->token == F_LOCAL) {
01044 if ((CDAR(n)->u.integer.a == CAADR(n)->u.integer.a) &&
01045 (CDAR(n)->u.integer.b == CAADR(n)->u.integer.b)) {
01046 #ifdef PIKE_DEBUG
01047 if (l_flag > 4) {
01048 fprintf(stderr, "Match: ""F_COMMA_EXPR{383}(F_ASSIGN{384}(0 = *{385}, 1 = F_LOCAL{386}), F_COMMA_EXPR{387}(F_DEC{388}(F_LOCAL{389}[CDAR(n)->u.integer.a == CAADR(n)->u.integer.a][CDAR(n)->u.integer.b == CAADR(n)->u.integer.b], -{390}), 2 = *{391}))""\n");
01049 }
01050 #endif
01051 {
01052
01053 ADD_NODE_REF2(CDDR(n),
01054 ADD_NODE_REF2(CDAR(n),
01055 ADD_NODE_REF2(CAAR(n),
01056 tmp1 = mknode(F_COMMA_EXPR,
01057 mknode(F_ASSIGN,
01058 mkefuncallnode("`-",
01059 mknode(F_ARG_LIST, CAAR(n), mkintnode(1))),
01060 CDAR(n)),
01061 CDDR(n));
01062 )));
01063 goto use_tmp1;
01064 }
01065 }
01066 }
01067 }
01068 }
01069 } else if (CADR(n)->token == F_INC) {
01070 if (!CDADR(n)) {
01071 if (!CAADR(n)) {
01072 } else {
01073 if (CAADR(n)->token == F_LOCAL) {
01074 if ((CDAR(n)->u.integer.a == CAADR(n)->u.integer.a) &&
01075 (CDAR(n)->u.integer.b == CAADR(n)->u.integer.b)) {
01076 #ifdef PIKE_DEBUG
01077 if (l_flag > 4) {
01078 fprintf(stderr, "Match: ""F_COMMA_EXPR{392}(F_ASSIGN{393}(0 = *{394}, 1 = F_LOCAL{395}), F_COMMA_EXPR{396}(F_INC{397}(F_LOCAL{398}[CDAR(n)->u.integer.a == CAADR(n)->u.integer.a][CDAR(n)->u.integer.b == CAADR(n)->u.integer.b], -{399}), 2 = *{400}))""\n");
01079 }
01080 #endif
01081 {
01082
01083 ADD_NODE_REF2(CDDR(n),
01084 ADD_NODE_REF2(CDAR(n),
01085 ADD_NODE_REF2(CAAR(n),
01086 tmp1 = mknode(F_COMMA_EXPR,
01087 mknode(F_ASSIGN,
01088 mkefuncallnode("`+",
01089 mknode(F_ARG_LIST, CAAR(n), mkintnode(1))),
01090 CDAR(n)),
01091 CDDR(n));
01092 )));
01093 goto use_tmp1;
01094 }
01095 }
01096 }
01097 }
01098 }
01099 }
01100 }
01101 } else if (CDR(n)->token == F_DEC) {
01102 if (!CDDR(n)) {
01103 if (!CADR(n)) {
01104 } else {
01105 if (CADR(n)->token == F_LOCAL) {
01106 if (( CDAR(n)->u.integer.a == CADR(n)->u.integer.a ) &&
01107 ( CDAR(n)->u.integer.b == CADR(n)->u.integer.b )) {
01108 #ifdef PIKE_DEBUG
01109 if (l_flag > 4) {
01110 fprintf(stderr, "Match: ""F_COMMA_EXPR{369}(F_ASSIGN{370}(0 = *{371}, 1 = F_LOCAL{372}), F_DEC{373}(F_LOCAL{374}[ CDAR(n)->u.integer.a == CADR(n)->u.integer.a ][ CDAR(n)->u.integer.b == CADR(n)->u.integer.b ], -{375}))""\n");
01111 }
01112 #endif
01113 {
01114
01115 ADD_NODE_REF2(CDAR(n),
01116 ADD_NODE_REF2(CAAR(n),
01117 tmp1 = mknode(F_ASSIGN,
01118 mkefuncallnode("`-",
01119 mknode(F_ARG_LIST, CAAR(n), mkintnode(1))), CDAR(n));
01120 ));
01121 goto use_tmp1;
01122 }
01123 }
01124 }
01125 }
01126 }
01127 } else if (CDR(n)->token == F_INC) {
01128 if (!CDDR(n)) {
01129 if (!CADR(n)) {
01130 } else {
01131 if (CADR(n)->token == F_LOCAL) {
01132 if (( CDAR(n)->u.integer.a == CADR(n)->u.integer.a ) &&
01133 ( CDAR(n)->u.integer.b == CADR(n)->u.integer.b )) {
01134 #ifdef PIKE_DEBUG
01135 if (l_flag > 4) {
01136 fprintf(stderr, "Match: ""F_COMMA_EXPR{376}(F_ASSIGN{377}(0 = *{378}, 1 = F_LOCAL{379}), F_INC{380}(F_LOCAL{381}[ CDAR(n)->u.integer.a == CADR(n)->u.integer.a ][ CDAR(n)->u.integer.b == CADR(n)->u.integer.b ], -{382}))""\n");
01137 }
01138 #endif
01139 {
01140
01141 ADD_NODE_REF2(CDAR(n),
01142 ADD_NODE_REF2(CAAR(n),
01143 tmp1 = mknode(F_ASSIGN,
01144 mkefuncallnode("`+",
01145 mknode(F_ARG_LIST, CAAR(n), mkintnode(1))), CDAR(n));
01146 ));
01147 goto use_tmp1;
01148 }
01149 }
01150 }
01151 }
01152 }
01153 }
01154 }
01155 }
01156 if ((!depend_p(CDAR(n), CDAR(n)))) {
01157 if (!CDR(n)) {
01158 } else {
01159 if (CDR(n)->token == F_COMMA_EXPR) {
01160 if (!CADR(n)) {
01161 } else {
01162 if (CADR(n)->token == F_DEC) {
01163 {
01164 if ((CAADR(n) == CDAR(n))
01165 #ifdef SHARED_NODES_MK2
01166 || (CAADR(n) && CDAR(n) &&
01167 ((CAADR(n)->master?CAADR(n)->master:CAADR(n))==
01168 (CDAR(n)->master?CDAR(n)->master:CDAR(n))))
01169 #endif
01170 ) {
01171 if (!CDADR(n)) {
01172 #ifdef PIKE_DEBUG
01173 if (l_flag > 4) {
01174 fprintf(stderr, "Match: ""F_COMMA_EXPR{353}(F_ASSIGN{354}(0 = *{355}, 1 = +{356}[!depend_p(CDAR(n), CDAR(n))]), F_COMMA_EXPR{357}(F_DEC{358}($CDAR(n)$, -{359}), 2 = *{360}))""\n");
01175 }
01176 #endif
01177 {
01178
01179 ADD_NODE_REF2(CDDR(n),
01180 ADD_NODE_REF2(CDAR(n),
01181 ADD_NODE_REF2(CAAR(n),
01182 tmp1 = mknode(F_COMMA_EXPR,
01183 mknode(F_ASSIGN,
01184 mkefuncallnode("`-",
01185 mknode(F_ARG_LIST, CAAR(n), mkintnode(1))),
01186 CDAR(n)),
01187 CDDR(n));
01188 )));
01189 goto use_tmp1;
01190 }
01191 }
01192 }
01193 }
01194 } else if (CADR(n)->token == F_INC) {
01195 {
01196 if ((CAADR(n) == CDAR(n))
01197 #ifdef SHARED_NODES_MK2
01198 || (CAADR(n) && CDAR(n) &&
01199 ((CAADR(n)->master?CAADR(n)->master:CAADR(n))==
01200 (CDAR(n)->master?CDAR(n)->master:CDAR(n))))
01201 #endif
01202 ) {
01203 if (!CDADR(n)) {
01204 #ifdef PIKE_DEBUG
01205 if (l_flag > 4) {
01206 fprintf(stderr, "Match: ""F_COMMA_EXPR{361}(F_ASSIGN{362}(0 = *{363}, 1 = +{364}[!depend_p(CDAR(n), CDAR(n))]), F_COMMA_EXPR{365}(F_INC{366}($CDAR(n)$, -{367}), 2 = *{368}))""\n");
01207 }
01208 #endif
01209 {
01210
01211 ADD_NODE_REF2(CDDR(n),
01212 ADD_NODE_REF2(CDAR(n),
01213 ADD_NODE_REF2(CAAR(n),
01214 tmp1 = mknode(F_COMMA_EXPR,
01215 mknode(F_ASSIGN,
01216 mkefuncallnode("`+",
01217 mknode(F_ARG_LIST, CAAR(n), mkintnode(1))),
01218 CDAR(n)),
01219 CDDR(n));
01220 )));
01221 goto use_tmp1;
01222 }
01223 }
01224 }
01225 }
01226 }
01227 }
01228 } else if (CDR(n)->token == F_DEC) {
01229 {
01230 if ((CADR(n) == CDAR(n))
01231 #ifdef SHARED_NODES_MK2
01232 || (CADR(n) && CDAR(n) &&
01233 ((CADR(n)->master?CADR(n)->master:CADR(n))==
01234 (CDAR(n)->master?CDAR(n)->master:CDAR(n))))
01235 #endif
01236 ) {
01237 if (!CDDR(n)) {
01238 #ifdef PIKE_DEBUG
01239 if (l_flag > 4) {
01240 fprintf(stderr, "Match: ""F_COMMA_EXPR{341}(F_ASSIGN{342}(0 = *{343}, 1 = +{344}[!depend_p(CDAR(n), CDAR(n))]), F_DEC{345}($CDAR(n)$, -{346}))""\n");
01241 }
01242 #endif
01243 {
01244
01245 ADD_NODE_REF2(CDAR(n),
01246 ADD_NODE_REF2(CAAR(n),
01247 tmp1 = mknode(F_ASSIGN,
01248 mkefuncallnode("`-",
01249 mknode(F_ARG_LIST, CAAR(n), mkintnode(1))), CDAR(n));
01250 ));
01251 goto use_tmp1;
01252 }
01253 }
01254 }
01255 }
01256 } else if (CDR(n)->token == F_INC) {
01257 {
01258 if ((CADR(n) == CDAR(n))
01259 #ifdef SHARED_NODES_MK2
01260 || (CADR(n) && CDAR(n) &&
01261 ((CADR(n)->master?CADR(n)->master:CADR(n))==
01262 (CDAR(n)->master?CDAR(n)->master:CDAR(n))))
01263 #endif
01264 ) {
01265 if (!CDDR(n)) {
01266 #ifdef PIKE_DEBUG
01267 if (l_flag > 4) {
01268 fprintf(stderr, "Match: ""F_COMMA_EXPR{347}(F_ASSIGN{348}(0 = *{349}, 1 = +{350}[!depend_p(CDAR(n), CDAR(n))]), F_INC{351}($CDAR(n)$, -{352}))""\n");
01269 }
01270 #endif
01271 {
01272
01273 ADD_NODE_REF2(CDAR(n),
01274 ADD_NODE_REF2(CAAR(n),
01275 tmp1 = mknode(F_ASSIGN,
01276 mkefuncallnode("`+",
01277 mknode(F_ARG_LIST, CAAR(n), mkintnode(1))), CDAR(n));
01278 ));
01279 goto use_tmp1;
01280 }
01281 }
01282 }
01283 }
01284 }
01285 }
01286 }
01287 }
01288 } else if (CAR(n)->token == F_BREAK) {
01289 if (!CDR(n)) {
01290 } else {
01291 if ((!(CDR(n)->tree_info & OPT_CASE))) {
01292 #ifdef PIKE_DEBUG
01293 if (l_flag > 4) {
01294 fprintf(stderr, "Match: ""F_COMMA_EXPR{319}(0 = F_BREAK{320}, +{321}[!(CDR(n)->tree_info & OPT_CASE)])""\n");
01295 }
01296 #endif
01297 #ifdef PIKE_DEBUG
01298 if (l_flag > 4) {
01299 fprintf(stderr, "=> ""0 = *{322}""\n");
01300 }
01301 #endif
01302 goto use_car;
01303 }
01304 }
01305 } else if (CAR(n)->token == F_CAST) {
01306 if (!CDR(n)) {
01307 } else {
01308 #ifdef PIKE_DEBUG
01309 if (l_flag > 4) {
01310 fprintf(stderr, "Match: ""F_COMMA_EXPR{278}(F_CAST{279}(0 = *{280}, *), 1 = +{282})""\n");
01311 }
01312 #endif
01313 #ifdef PIKE_DEBUG
01314 if (l_flag > 4) {
01315 fprintf(stderr, "=> ""F_COMMA_EXPR{283}""\n");
01316 }
01317 #endif
01318 {
01319 ADD_NODE_REF2(CAAR(n),
01320 ADD_NODE_REF2(CDR(n),
01321 tmp1 = mknode(F_COMMA_EXPR, CAAR(n), CDR(n));
01322 ));
01323 goto use_tmp1;
01324 }
01325 }
01326 } else if (CAR(n)->token == F_COMMA_EXPR) {
01327 if (!CDAR(n)) {
01328 } else {
01329 if (CDAR(n)->token == F_BREAK) {
01330 if (!CDR(n)) {
01331 } else {
01332 if ((!(CDR(n)->tree_info & OPT_CASE))) {
01333 #ifdef PIKE_DEBUG
01334 if (l_flag > 4) {
01335 fprintf(stderr, "Match: ""F_COMMA_EXPR{335}(0 = F_COMMA_EXPR{336}(*, F_BREAK{338}), +{339}[!(CDR(n)->tree_info & OPT_CASE)])""\n");
01336 }
01337 #endif
01338 #ifdef PIKE_DEBUG
01339 if (l_flag > 4) {
01340 fprintf(stderr, "=> ""0 = *{340}""\n");
01341 }
01342 #endif
01343 goto use_car;
01344 }
01345 }
01346 } else if (CDAR(n)->token == F_CONSTANT) {
01347 if (!CDR(n)) {
01348 } else {
01349 #ifdef PIKE_DEBUG
01350 if (l_flag > 4) {
01351 fprintf(stderr, "Match: ""F_COMMA_EXPR{234}(F_COMMA_EXPR{235}(0 = *{236}, F_CONSTANT{237}), 1 = +{238})""\n");
01352 }
01353 #endif
01354 #ifdef PIKE_DEBUG
01355 if (l_flag > 4) {
01356 fprintf(stderr, "=> ""F_COMMA_EXPR{239}""\n");
01357 }
01358 #endif
01359 {
01360 ADD_NODE_REF2(CAAR(n),
01361 ADD_NODE_REF2(CDR(n),
01362 tmp1 = mknode(F_COMMA_EXPR, CAAR(n), CDR(n));
01363 ));
01364 goto use_tmp1;
01365 }
01366 }
01367 } else if (CDAR(n)->token == F_CONTINUE) {
01368 if (!CDR(n)) {
01369 } else {
01370 if ((!(CDR(n)->tree_info & OPT_CASE))) {
01371 #ifdef PIKE_DEBUG
01372 if (l_flag > 4) {
01373 fprintf(stderr, "Match: ""F_COMMA_EXPR{329}(0 = F_COMMA_EXPR{330}(*, F_CONTINUE{332}), +{333}[!(CDR(n)->tree_info & OPT_CASE)])""\n");
01374 }
01375 #endif
01376 #ifdef PIKE_DEBUG
01377 if (l_flag > 4) {
01378 fprintf(stderr, "=> ""0 = *{334}""\n");
01379 }
01380 #endif
01381 goto use_car;
01382 }
01383 }
01384 } else if (CDAR(n)->token == F_POP_VALUE) {
01385 if (!CDR(n)) {
01386 } else {
01387 if (CDR(n)->token == F_POP_VALUE) {
01388 if (!CADR(n)) {
01389 } else {
01390 if ((!(CADR(n)->tree_info & OPT_APPLY))) {
01391 #ifdef PIKE_DEBUG
01392 if (l_flag > 4) {
01393 fprintf(stderr, "Match: ""F_COMMA_EXPR{262}(F_COMMA_EXPR{263}(0 = *{264}, F_POP_VALUE{265}(1 = *{266}, *)), F_POP_VALUE{268}(2 = +{269}[!(CADR(n)->tree_info & OPT_APPLY)], *))""\n");
01394 }
01395 #endif
01396 #ifdef PIKE_DEBUG
01397 if (l_flag > 4) {
01398 fprintf(stderr, "=> ""F_COMMA_EXPR{271}""\n");
01399 }
01400 #endif
01401 {
01402 ADD_NODE_REF2(CAAR(n),
01403 ADD_NODE_REF2(CADAR(n),
01404 ADD_NODE_REF2(CADR(n),
01405 tmp1 = mknode(F_COMMA_EXPR, CAAR(n), mknode(F_POP_VALUE, mknode(F_COMMA_EXPR, CADAR(n), CADR(n)), 0));
01406 )));
01407 goto use_tmp1;
01408 }
01409 }
01410 }
01411 }
01412 }
01413 } else if (CDAR(n)->token == F_RETURN) {
01414 if (!CDR(n)) {
01415 } else {
01416 if ((!(CDR(n)->tree_info & OPT_CASE))) {
01417 #ifdef PIKE_DEBUG
01418 if (l_flag > 4) {
01419 fprintf(stderr, "Match: ""F_COMMA_EXPR{323}(0 = F_COMMA_EXPR{324}(*, F_RETURN{326}), +{327}[!(CDR(n)->tree_info & OPT_CASE)])""\n");
01420 }
01421 #endif
01422 #ifdef PIKE_DEBUG
01423 if (l_flag > 4) {
01424 fprintf(stderr, "=> ""0 = *{328}""\n");
01425 }
01426 #endif
01427 goto use_car;
01428 }
01429 }
01430 }
01431 if ((node_is_tossable(CDAR(n)))) {
01432 if (!CDR(n)) {
01433 } else {
01434 #ifdef PIKE_DEBUG
01435 if (l_flag > 4) {
01436 fprintf(stderr, "Match: ""F_COMMA_EXPR{242}(F_COMMA_EXPR{243}(0 = *{244}, +{245}[node_is_tossable(CDAR(n))]), 1 = +{246})""\n");
01437 }
01438 #endif
01439 #ifdef PIKE_DEBUG
01440 if (l_flag > 4) {
01441 fprintf(stderr, "=> ""F_COMMA_EXPR{247}""\n");
01442 }
01443 #endif
01444 {
01445 ADD_NODE_REF2(CAAR(n),
01446 ADD_NODE_REF2(CDR(n),
01447 tmp1 = mknode(F_COMMA_EXPR, CAAR(n), CDR(n));
01448 ));
01449 goto use_tmp1;
01450 }
01451 }
01452 }
01453 }
01454 } else if (CAR(n)->token == F_CONSTANT) {
01455 if (!CDR(n)) {
01456 } else {
01457 #ifdef PIKE_DEBUG
01458 if (l_flag > 4) {
01459 fprintf(stderr, "Match: ""F_COMMA_EXPR{226}(F_CONSTANT{227}, 0 = +{228})""\n");
01460 }
01461 #endif
01462 #ifdef PIKE_DEBUG
01463 if (l_flag > 4) {
01464 fprintf(stderr, "=> ""0 = *{229}""\n");
01465 }
01466 #endif
01467 goto use_cdr;
01468 }
01469 } else if (CAR(n)->token == F_CONTINUE) {
01470 if (!CDR(n)) {
01471 } else {
01472 if ((!(CDR(n)->tree_info & OPT_CASE))) {
01473 #ifdef PIKE_DEBUG
01474 if (l_flag > 4) {
01475 fprintf(stderr, "Match: ""F_COMMA_EXPR{315}(0 = F_CONTINUE{316}, +{317}[!(CDR(n)->tree_info & OPT_CASE)])""\n");
01476 }
01477 #endif
01478 #ifdef PIKE_DEBUG
01479 if (l_flag > 4) {
01480 fprintf(stderr, "=> ""0 = *{318}""\n");
01481 }
01482 #endif
01483 goto use_car;
01484 }
01485 }
01486 } else if (CAR(n)->token == F_POP_VALUE) {
01487 if (!CDR(n)) {
01488 } else {
01489 if (CDR(n)->token == F_POP_VALUE) {
01490 if (!CADR(n)) {
01491 } else {
01492 if ((!(CADR(n)->tree_info & OPT_APPLY))) {
01493 #ifdef PIKE_DEBUG
01494 if (l_flag > 4) {
01495 fprintf(stderr, "Match: ""F_COMMA_EXPR{250}(F_POP_VALUE{251}(0 = *{252}, *), F_POP_VALUE{254}(1 = +{255}[!(CADR(n)->tree_info & OPT_APPLY)], *))""\n");
01496 }
01497 #endif
01498 #ifdef PIKE_DEBUG
01499 if (l_flag > 4) {
01500 fprintf(stderr, "=> ""F_POP_VALUE{257}""\n");
01501 }
01502 #endif
01503 {
01504 ADD_NODE_REF2(CAAR(n),
01505 ADD_NODE_REF2(CADR(n),
01506 tmp1 = mknode(F_POP_VALUE, mknode(F_COMMA_EXPR, CAAR(n), CADR(n)), 0);
01507 ));
01508 goto use_tmp1;
01509 }
01510 }
01511 }
01512 }
01513 }
01514 } else if (CAR(n)->token == F_RETURN) {
01515 if (!CDR(n)) {
01516 } else {
01517 if ((!(CDR(n)->tree_info & OPT_CASE))) {
01518 #ifdef PIKE_DEBUG
01519 if (l_flag > 4) {
01520 fprintf(stderr, "Match: ""F_COMMA_EXPR{311}(0 = F_RETURN{312}, +{313}[!(CDR(n)->tree_info & OPT_CASE)])""\n");
01521 }
01522 #endif
01523 #ifdef PIKE_DEBUG
01524 if (l_flag > 4) {
01525 fprintf(stderr, "=> ""0 = *{314}""\n");
01526 }
01527 #endif
01528 goto use_car;
01529 }
01530 }
01531 }
01532 if (CDR(n)->token == F_CAST) {
01533 #ifdef PIKE_DEBUG
01534 if (l_flag > 4) {
01535 fprintf(stderr, "Match: ""F_COMMA_EXPR{286}(0 = *{287}, 1 = F_CAST{288}(2 = *{289}, *))""\n");
01536 }
01537 #endif
01538 {
01539 struct pike_type *type = CDR(n)->type;
01540
01541 ADD_NODE_REF2(CADR(n),
01542 ADD_NODE_REF2(CAR(n),
01543 tmp1 = mkcastnode(type, mknode(F_COMMA_EXPR, CAR(n), CADR(n)));
01544 ));
01545 goto use_tmp1;
01546 }
01547 } else if (CDR(n)->token == F_COMMA_EXPR) {
01548 #ifdef PIKE_DEBUG
01549 if (l_flag > 4) {
01550 fprintf(stderr, "Match: ""F_COMMA_EXPR{301}(0 = *{302}, F_COMMA_EXPR{303}(1 = *{304}, 2 = *{305}))""\n");
01551 }
01552 #endif
01553 #ifdef PIKE_DEBUG
01554 if (l_flag > 4) {
01555 fprintf(stderr, "=> ""F_COMMA_EXPR{306}""\n");
01556 }
01557 #endif
01558 {
01559 ADD_NODE_REF2(CAR(n),
01560 ADD_NODE_REF2(CADR(n),
01561 ADD_NODE_REF2(CDDR(n),
01562 tmp1 = mknode(F_COMMA_EXPR, mknode(F_COMMA_EXPR, CAR(n), CADR(n)), CDDR(n));
01563 )));
01564 goto use_tmp1;
01565 }
01566 }
01567 if ((node_is_tossable(CAR(n)))) {
01568 if (!CDR(n)) {
01569 } else {
01570 #ifdef PIKE_DEBUG
01571 if (l_flag > 4) {
01572 fprintf(stderr, "Match: ""F_COMMA_EXPR{230}(+{231}[node_is_tossable(CAR(n))], 0 = +{232})""\n");
01573 }
01574 #endif
01575 #ifdef PIKE_DEBUG
01576 if (l_flag > 4) {
01577 fprintf(stderr, "=> ""0 = *{233}""\n");
01578 }
01579 #endif
01580 goto use_cdr;
01581 }
01582 }
01583 }
01584 break;
01585
01586 case F_DO:
01587 if (!CAR(n)) {
01588 if (!CDR(n)) {
01589 } else {
01590 if ((node_is_true(CDR(n)))) {
01591 #ifdef PIKE_DEBUG
01592 if (l_flag > 4) {
01593 fprintf(stderr, "Match: ""F_DO{829}(-{830}, 0 = +{831}[node_is_true(CDR(n))])""\n");
01594 }
01595 #endif
01596 {
01597
01598
01599 ADD_NODE_REF2(CDR(n),
01600 tmp1 = mknode(F_DO, mkefuncallnode("sleep", mkintnode(255)), CDR(n));
01601 );
01602 goto use_tmp1;
01603 }
01604 }
01605 }
01606 } else if (!CDR(n)) {
01607 if (!CAR(n)) {
01608 } else {
01609 if ((!(CAR(n)->tree_info & (OPT_BREAK|OPT_CONTINUE)))) {
01610 #ifdef PIKE_DEBUG
01611 if (l_flag > 4) {
01612 fprintf(stderr, "Match: ""F_DO{821}(0 = +{822}[!(CAR(n)->tree_info & (OPT_BREAK|OPT_CONTINUE))], -{823})""\n");
01613 }
01614 #endif
01615 #ifdef PIKE_DEBUG
01616 if (l_flag > 4) {
01617 fprintf(stderr, "=> ""0 = *{824}""\n");
01618 }
01619 #endif
01620 goto use_car;
01621 }
01622 }
01623 } else {
01624 if ((!(CAR(n)->tree_info & (OPT_BREAK|OPT_CONTINUE)))) {
01625 if (!CDR(n)) {
01626 } else {
01627 if ((node_is_false(CDR(n)))) {
01628 #ifdef PIKE_DEBUG
01629 if (l_flag > 4) {
01630 fprintf(stderr, "Match: ""F_DO{825}(0 = +{826}[!(CAR(n)->tree_info & (OPT_BREAK|OPT_CONTINUE))], +{827}[node_is_false(CDR(n))])""\n");
01631 }
01632 #endif
01633 #ifdef PIKE_DEBUG
01634 if (l_flag > 4) {
01635 fprintf(stderr, "=> ""0 = *{828}""\n");
01636 }
01637 #endif
01638 goto use_car;
01639 }
01640 }
01641 }
01642 }
01643 break;
01644
01645 case F_FOR:
01646 if (!CAR(n)) {
01647 #ifdef PIKE_DEBUG
01648 if (l_flag > 4) {
01649 fprintf(stderr, "Match: ""F_FOR{909}(-{910}, *)""\n");
01650 }
01651 #endif
01652 #ifdef PIKE_DEBUG
01653 if (l_flag > 4) {
01654 fprintf(stderr, "=> ""-{912}""\n");
01655 }
01656 #endif
01657 goto zap_node;
01658 } else if (!CDR(n)) {
01659 if (!CAR(n)) {
01660 } else {
01661 if (CAR(n)->token == F_DEC) {
01662 #ifdef PIKE_DEBUG
01663 if (l_flag > 4) {
01664 fprintf(stderr, "Match: ""F_FOR{1027}(F_DEC{1028}(0 = *{1029}, *), -{1031})""\n");
01665 }
01666 #endif
01667 #ifdef PIKE_DEBUG
01668 if (l_flag > 4) {
01669 fprintf(stderr, "=> ""F_DEC_NEQ_LOOP{1032}""\n");
01670 }
01671 #endif
01672 {
01673 ADD_NODE_REF2(CAAR(n),
01674 tmp1 = mknode(F_DEC_NEQ_LOOP, mknode(F_VAL_LVAL, mkintnode(0), CAAR(n)), 0);
01675 );
01676 goto use_tmp1;
01677 }
01678 } else if (CAR(n)->token == F_INC) {
01679 #ifdef PIKE_DEBUG
01680 if (l_flag > 4) {
01681 fprintf(stderr, "Match: ""F_FOR{931}(F_INC{932}(0 = *{933}, *), -{935})""\n");
01682 }
01683 #endif
01684 #ifdef PIKE_DEBUG
01685 if (l_flag > 4) {
01686 fprintf(stderr, "=> ""F_INC_NEQ_LOOP{936}""\n");
01687 }
01688 #endif
01689 {
01690 ADD_NODE_REF2(CAAR(n),
01691 tmp1 = mknode(F_INC_NEQ_LOOP, mknode(F_VAL_LVAL, mkintnode(0), CAAR(n)), 0);
01692 );
01693 goto use_tmp1;
01694 }
01695 } else if (CAR(n)->token == F_POST_DEC) {
01696 #ifdef PIKE_DEBUG
01697 if (l_flag > 4) {
01698 fprintf(stderr, "Match: ""F_FOR{1075}(F_POST_DEC{1076}(0 = *{1077}, *), -{1079})""\n");
01699 }
01700 #endif
01701 #ifdef PIKE_DEBUG
01702 if (l_flag > 4) {
01703 fprintf(stderr, "=> ""F_DEC_NEQ_LOOP{1080}""\n");
01704 }
01705 #endif
01706 {
01707 ADD_NODE_REF2(CAAR(n),
01708 tmp1 = mknode(F_DEC_NEQ_LOOP, mknode(F_VAL_LVAL, mkintnode(-1), CAAR(n)), 0);
01709 );
01710 goto use_tmp1;
01711 }
01712 } else if (CAR(n)->token == F_POST_INC) {
01713 #ifdef PIKE_DEBUG
01714 if (l_flag > 4) {
01715 fprintf(stderr, "Match: ""F_FOR{979}(F_POST_INC{980}(0 = *{981}, *), -{983})""\n");
01716 }
01717 #endif
01718 #ifdef PIKE_DEBUG
01719 if (l_flag > 4) {
01720 fprintf(stderr, "=> ""F_INC_NEQ_LOOP{984}""\n");
01721 }
01722 #endif
01723 {
01724 ADD_NODE_REF2(CAAR(n),
01725 tmp1 = mknode(F_INC_NEQ_LOOP, mknode(F_VAL_LVAL, mkintnode(1), CAAR(n)), 0);
01726 );
01727 goto use_tmp1;
01728 }
01729 }
01730 if ((node_is_false(CAR(n)))) {
01731 #ifdef PIKE_DEBUG
01732 if (l_flag > 4) {
01733 fprintf(stderr, "Match: ""F_FOR{921}(+{922}[node_is_false(CAR(n))], *)""\n");
01734 }
01735 #endif
01736 #ifdef PIKE_DEBUG
01737 if (l_flag > 4) {
01738 fprintf(stderr, "=> ""-{924}""\n");
01739 }
01740 #endif
01741 goto zap_node;
01742 }
01743 if ((node_is_tossable(CAR(n)))) {
01744 #ifdef PIKE_DEBUG
01745 if (l_flag > 4) {
01746 fprintf(stderr, "Match: ""F_FOR{928}(0 = +{929}[node_is_tossable(CAR(n))], -{930})""\n");
01747 }
01748 #endif
01749 {
01750
01751
01752 ADD_NODE_REF2(CAR(n),
01753 tmp1 = mknode(F_FOR, CAR(n), mknode(':',
01754 mkefuncallnode("sleep", mkintnode(1)),
01755 0));
01756 );
01757 goto use_tmp1;
01758 }
01759 }
01760 if ((node_is_true(CAR(n)))) {
01761 #ifdef PIKE_DEBUG
01762 if (l_flag > 4) {
01763 fprintf(stderr, "Match: ""F_FOR{925}(0 = +{926}[node_is_true(CAR(n))], -{927})""\n");
01764 }
01765 #endif
01766 {
01767
01768
01769 ADD_NODE_REF2(CAR(n),
01770 tmp1 = mknode(F_FOR, CAR(n), mknode(':',
01771 mkefuncallnode("sleep", mkintnode(255)),
01772 0));
01773 );
01774 goto use_tmp1;
01775 }
01776 }
01777 }
01778 } else {
01779 if (CAR(n)->token == F_APPLY) {
01780 if (!CAAR(n)) {
01781 } else {
01782 if (CAAR(n)->token == F_CONSTANT) {
01783 if ((CAAR(n)->u.sval.type == T_FUNCTION) &&
01784 (CAAR(n)->u.sval.subtype == FUNCTION_BUILTIN)) {
01785 if (!CDR(n)) {
01786 } else {
01787 if (CDR(n)->token == ':') {
01788 #ifdef PIKE_DEBUG
01789 if (l_flag > 4) {
01790 fprintf(stderr, "Match: ""F_FOR{1135}(0 = F_APPLY{1136}(1 = F_CONSTANT{1137}[CAAR(n)->u.sval.type == T_FUNCTION][CAAR(n)->u.sval.subtype == FUNCTION_BUILTIN], 2 = *{1138}), 4 = ':'{1139}(3 = *{1140}, *))""\n");
01791 }
01792 #endif
01793 {
01794 node **last;
01795
01796
01797
01798
01799
01800 last = &_CDR(CDR(n));
01801 tmp1 = *last;
01802
01803
01804 while(tmp1 &&
01805 ( (tmp1->token == F_CAST && tmp1->type == void_type_string) ||
01806 tmp1->token == F_POP_VALUE))
01807 {
01808 last = &_CAR(tmp1);
01809 tmp1 = *last;
01810 }
01811
01812
01813 if(tmp1 && (tmp1->token == F_INC ||
01814 tmp1->token == F_POST_INC ||
01815 tmp1->token == F_DEC ||
01816 tmp1->token == F_POST_DEC))
01817 {
01818 node **arg1, **arg2;
01819 int oper;
01820 int inc;
01821 int token;
01822
01823
01824 inc = (tmp1->token==F_INC || tmp1->token==F_POST_INC);
01825
01826
01827
01828 if(CAAR(n)->u.sval.u.efun->function == f_gt)
01829 oper = F_GT;
01830 else if(CAAR(n)->u.sval.u.efun->function == f_ge)
01831 oper = F_GE;
01832 else if(CAAR(n)->u.sval.u.efun->function == f_lt)
01833 oper = F_LT;
01834 else if(CAAR(n)->u.sval.u.efun->function == f_le)
01835 oper = F_LE;
01836 else if(CAAR(n)->u.sval.u.efun->function == f_ne)
01837 oper = F_NE;
01838 else
01839 goto next_for_opt;
01840
01841 if(count_args(CDAR(n)) != 2)
01842 goto next_for_opt;
01843
01844 arg1 = my_get_arg(&_CDR(CAR(n)), 0);
01845 arg2 = my_get_arg(&_CDR(CAR(n)), 1);
01846
01847
01848 if(!node_is_eq(*arg1, CAR(tmp1)) ||
01849 depend_p(*arg2, *arg2) ||
01850 depend_p(*arg2, *arg1) ||
01851 depend_p(*arg2, CADR(n)) ||
01852 depend_p(*arg2, tmp1))
01853 {
01854
01855 if(!node_is_eq(*arg2, CAR(tmp1)) ||
01856 depend_p(*arg1, *arg2) ||
01857 depend_p(*arg1, *arg1) ||
01858 depend_p(*arg1, CADR(n)) ||
01859 depend_p(*arg1, tmp1))
01860 {
01861
01862 goto next_for_opt;
01863 }else{
01864 node **tmparg;
01865
01866
01867 switch(oper)
01868 {
01869 case F_LT: oper = F_GT; break;
01870 case F_LE: oper = F_GE; break;
01871 case F_GT: oper = F_LT; break;
01872 case F_GE: oper = F_LE; break;
01873 }
01874
01875 tmparg = arg1;
01876 arg1 = arg2;
01877 arg2 = tmparg;
01878 }
01879 }
01880
01881 if(inc)
01882 {
01883 if(oper == F_LE) {
01884 static struct pike_string *plus_name;
01885 node *n;
01886 if ((!plus_name && !(plus_name = findstring("`+"))) ||
01887 !(n=find_module_identifier(plus_name, 0))) {
01888 yyerror("Internally used efun undefined: `+");
01889 tmp3 = mkintnode(0);
01890 } else {
01891 ADD_NODE_REF2(*arg2,
01892 tmp3 = mkapplynode(n, mknode(F_ARG_LIST, *arg2, mkintnode(1)));
01893 );
01894 }
01895 } else if(oper == F_LT) {
01896 ADD_NODE_REF2(*arg2,
01897 tmp3 = *arg2;
01898 );
01899 } else
01900 goto next_for_opt;
01901 }else{
01902 if(oper == F_GE) {
01903 static struct pike_string *minus_name;
01904 node *n;
01905 if ((!minus_name && !(minus_name = findstring("`-"))) ||
01906 !(n=find_module_identifier(minus_name, 0))) {
01907 yyerror("Internally used efun undefined: `-");
01908 tmp3 = mkintnode(0);
01909 } else {
01910 ADD_NODE_REF2(*arg2,
01911 tmp3 = mkapplynode(n, mknode(F_ARG_LIST, *arg2, mkintnode(1)));
01912 );
01913 }
01914 } else if(oper == F_GT) {
01915 ADD_NODE_REF2(*arg2,
01916 tmp3 = *arg2;
01917 );
01918 } else
01919 goto next_for_opt;
01920 }
01921 if(oper == F_NE)
01922 {
01923 if(inc)
01924 token = F_INC_NEQ_LOOP;
01925 else
01926 token = F_DEC_NEQ_LOOP;
01927 }else{
01928 if(inc)
01929 token = F_INC_LOOP;
01930 else
01931 token = F_DEC_LOOP;
01932 }
01933
01934 tmp1=CAR(*last);
01935 ADD_NODE_REF(CAR(*last));
01936 ADD_NODE_REF2(*arg1,
01937 ADD_NODE_REF2(CADR(n),
01938 tmp2 = mknode(token, mknode(F_VAL_LVAL, tmp3, *arg1), CADR(n));
01939 ));
01940
01941 tmp1 = mknode(F_COMMA_EXPR, mkcastnode(void_type_string,
01942 mknode(inc ? F_DEC : F_INC, tmp1, 0)), tmp2);
01943 goto use_tmp1;
01944 }
01945 next_for_opt:
01946 ;
01947 }
01948 }
01949 }
01950 }
01951 }
01952 }
01953 } else if (CAR(n)->token == F_DEC) {
01954 if (!CDR(n)) {
01955 } else {
01956 if (CDR(n)->token == ':') {
01957 if (!CADR(n)) {
01958 if (!CDDR(n)) {
01959 } else {
01960 if ((!(CDDR(n)->tree_info & OPT_CONTINUE))) {
01961 #ifdef PIKE_DEBUG
01962 if (l_flag > 4) {
01963 fprintf(stderr, "Match: ""F_FOR{1037}(F_DEC{1038}(0 = *{1039}, *), ':'{1041}(-{1042}, 1 = +{1043}[!(CDDR(n)->tree_info & OPT_CONTINUE)]))""\n");
01964 }
01965 #endif
01966 #ifdef PIKE_DEBUG
01967 if (l_flag > 4) {
01968 fprintf(stderr, "=> ""F_DEC_NEQ_LOOP{1044}""\n");
01969 }
01970 #endif
01971 {
01972 ADD_NODE_REF2(CAAR(n),
01973 ADD_NODE_REF2(CDDR(n),
01974 tmp1 = mknode(F_DEC_NEQ_LOOP, mknode(F_VAL_LVAL, mkintnode(0), CAAR(n)), CDDR(n));
01975 ));
01976 goto use_tmp1;
01977 }
01978 }
01979 }
01980 } else if (!CDDR(n)) {
01981 if (!CADR(n)) {
01982 } else {
01983 if ((!(CADR(n)->tree_info & OPT_CONTINUE))) {
01984 #ifdef PIKE_DEBUG
01985 if (l_flag > 4) {
01986 fprintf(stderr, "Match: ""F_FOR{1049}(F_DEC{1050}(0 = *{1051}, *), ':'{1053}(1 = +{1054}[!(CADR(n)->tree_info & OPT_CONTINUE)], -{1055}))""\n");
01987 }
01988 #endif
01989 #ifdef PIKE_DEBUG
01990 if (l_flag > 4) {
01991 fprintf(stderr, "=> ""F_DEC_NEQ_LOOP{1056}""\n");
01992 }
01993 #endif
01994 {
01995 ADD_NODE_REF2(CAAR(n),
01996 ADD_NODE_REF2(CADR(n),
01997 tmp1 = mknode(F_DEC_NEQ_LOOP, mknode(F_VAL_LVAL, mkintnode(0), CAAR(n)), CADR(n));
01998 ));
01999 goto use_tmp1;
02000 }
02001 }
02002 }
02003 } else {
02004 if ((!(CADR(n)->tree_info & OPT_CONTINUE))) {
02005 if (!CDDR(n)) {
02006 } else {
02007 if ((!(CDDR(n)->tree_info & OPT_CONTINUE))) {
02008 #ifdef PIKE_DEBUG
02009 if (l_flag > 4) {
02010 fprintf(stderr, "Match: ""F_FOR{1061}(F_DEC{1062}(0 = *{1063}, *), ':'{1065}(1 = +{1066}[!(CADR(n)->tree_info & OPT_CONTINUE)], 2 = +{1067}[!(CDDR(n)->tree_info & OPT_CONTINUE)]))""\n");
02011 }
02012 #endif
02013 #ifdef PIKE_DEBUG
02014 if (l_flag > 4) {
02015 fprintf(stderr, "=> ""F_DEC_NEQ_LOOP{1068}""\n");
02016 }
02017 #endif
02018 {
02019 ADD_NODE_REF2(CAAR(n),
02020 ADD_NODE_REF2(CADR(n),
02021 ADD_NODE_REF2(CDDR(n),
02022 tmp1 = mknode(F_DEC_NEQ_LOOP, mknode(F_VAL_LVAL, mkintnode(0), CAAR(n)), mknode(F_COMMA_EXPR, CADR(n), CDDR(n)));
02023 )));
02024 goto use_tmp1;
02025 }
02026 }
02027 }
02028 }
02029 }
02030 }
02031 }
02032 } else if (CAR(n)->token == F_INC) {
02033 if (!CDR(n)) {
02034 } else {
02035 if (CDR(n)->token == ':') {
02036 if (!CADR(n)) {
02037 if (!CDDR(n)) {
02038 } else {
02039 if ((!(CDDR(n)->tree_info & OPT_CONTINUE))) {
02040 #ifdef PIKE_DEBUG
02041 if (l_flag > 4) {
02042 fprintf(stderr, "Match: ""F_FOR{941}(F_INC{942}(0 = *{943}, *), ':'{945}(-{946}, 1 = +{947}[!(CDDR(n)->tree_info & OPT_CONTINUE)]))""\n");
02043 }
02044 #endif
02045 #ifdef PIKE_DEBUG
02046 if (l_flag > 4) {
02047 fprintf(stderr, "=> ""F_INC_NEQ_LOOP{948}""\n");
02048 }
02049 #endif
02050 {
02051 ADD_NODE_REF2(CAAR(n),
02052 ADD_NODE_REF2(CDDR(n),
02053 tmp1 = mknode(F_INC_NEQ_LOOP, mknode(F_VAL_LVAL, mkintnode(0), CAAR(n)), CDDR(n));
02054 ));
02055 goto use_tmp1;
02056 }
02057 }
02058 }
02059 } else if (!CDDR(n)) {
02060 if (!CADR(n)) {
02061 } else {
02062 if ((!(CADR(n)->tree_info & OPT_CONTINUE))) {
02063 #ifdef PIKE_DEBUG
02064 if (l_flag > 4) {
02065 fprintf(stderr, "Match: ""F_FOR{953}(F_INC{954}(0 = *{955}, *), ':'{957}(1 = +{958}[!(CADR(n)->tree_info & OPT_CONTINUE)], -{959}))""\n");
02066 }
02067 #endif
02068 #ifdef PIKE_DEBUG
02069 if (l_flag > 4) {
02070 fprintf(stderr, "=> ""F_INC_NEQ_LOOP{960}""\n");
02071 }
02072 #endif
02073 {
02074 ADD_NODE_REF2(CAAR(n),
02075 ADD_NODE_REF2(CADR(n),
02076 tmp1 = mknode(F_INC_NEQ_LOOP, mknode(F_VAL_LVAL, mkintnode(0), CAAR(n)), CADR(n));
02077 ));
02078 goto use_tmp1;
02079 }
02080 }
02081 }
02082 } else {
02083 if ((!(CADR(n)->tree_info & OPT_CONTINUE))) {
02084 if (!CDDR(n)) {
02085 } else {
02086 if ((!(CDDR(n)->tree_info & OPT_CONTINUE))) {
02087 #ifdef PIKE_DEBUG
02088 if (l_flag > 4) {
02089 fprintf(stderr, "Match: ""F_FOR{965}(F_INC{966}(0 = *{967}, *), ':'{969}(1 = +{970}[!(CADR(n)->tree_info & OPT_CONTINUE)], 2 = +{971}[!(CDDR(n)->tree_info & OPT_CONTINUE)]))""\n");
02090 }
02091 #endif
02092 #ifdef PIKE_DEBUG
02093 if (l_flag > 4) {
02094 fprintf(stderr, "=> ""F_INC_NEQ_LOOP{972}""\n");
02095 }
02096 #endif
02097 {
02098 ADD_NODE_REF2(CAAR(n),
02099 ADD_NODE_REF2(CADR(n),
02100 ADD_NODE_REF2(CDDR(n),
02101 tmp1 = mknode(F_INC_NEQ_LOOP, mknode(F_VAL_LVAL, mkintnode(0), CAAR(n)), mknode(F_COMMA_EXPR, CADR(n), CDDR(n)));
02102 )));
02103 goto use_tmp1;
02104 }
02105 }
02106 }
02107 }
02108 }
02109 }
02110 }
02111 } else if (CAR(n)->token == F_POST_DEC) {
02112 if (!CDR(n)) {
02113 } else {
02114 if (CDR(n)->token == ':') {
02115 if (!CADR(n)) {
02116 if (!CDDR(n)) {
02117 } else {
02118 if ((!(CDDR(n)->tree_info & OPT_CONTINUE))) {
02119 #ifdef PIKE_DEBUG
02120 if (l_flag > 4) {
02121 fprintf(stderr, "Match: ""F_FOR{1085}(F_POST_DEC{1086}(0 = *{1087}, *), ':'{1089}(-{1090}, 1 = +{1091}[!(CDDR(n)->tree_info & OPT_CONTINUE)]))""\n");
02122 }
02123 #endif
02124 #ifdef PIKE_DEBUG
02125 if (l_flag > 4) {
02126 fprintf(stderr, "=> ""F_DEC_NEQ_LOOP{1092}""\n");
02127 }
02128 #endif
02129 {
02130 ADD_NODE_REF2(CAAR(n),
02131 ADD_NODE_REF2(CDDR(n),
02132 tmp1 = mknode(F_DEC_NEQ_LOOP, mknode(F_VAL_LVAL, mkintnode(-1), CAAR(n)), CDDR(n));
02133 ));
02134 goto use_tmp1;
02135 }
02136 }
02137 }
02138 } else if (!CDDR(n)) {
02139 if (!CADR(n)) {
02140 } else {
02141 if ((!(CADR(n)->tree_info & OPT_CONTINUE))) {
02142 #ifdef PIKE_DEBUG
02143 if (l_flag > 4) {
02144 fprintf(stderr, "Match: ""F_FOR{1097}(F_POST_DEC{1098}(0 = *{1099}, *), ':'{1101}(1 = +{1102}[!(CADR(n)->tree_info & OPT_CONTINUE)], -{1103}))""\n");
02145 }
02146 #endif
02147 #ifdef PIKE_DEBUG
02148 if (l_flag > 4) {
02149 fprintf(stderr, "=> ""F_DEC_NEQ_LOOP{1104}""\n");
02150 }
02151 #endif
02152 {
02153 ADD_NODE_REF2(CAAR(n),
02154 ADD_NODE_REF2(CADR(n),
02155 tmp1 = mknode(F_DEC_NEQ_LOOP, mknode(F_VAL_LVAL, mkintnode(-1), CAAR(n)), CADR(n));
02156 ));
02157 goto use_tmp1;
02158 }
02159 }
02160 }
02161 } else {
02162 if ((!(CADR(n)->tree_info & OPT_CONTINUE))) {
02163 if (!CDDR(n)) {
02164 } else {
02165 if ((!(CDDR(n)->tree_info & OPT_CONTINUE))) {
02166 #ifdef PIKE_DEBUG
02167 if (l_flag > 4) {
02168 fprintf(stderr, "Match: ""F_FOR{1109}(F_POST_DEC{1110}(0 = *{1111}, *), ':'{1113}(1 = +{1114}[!(CADR(n)->tree_info & OPT_CONTINUE)], 2 = +{1115}[!(CDDR(n)->tree_info & OPT_CONTINUE)]))""\n");
02169 }
02170 #endif
02171 #ifdef PIKE_DEBUG
02172 if (l_flag > 4) {
02173 fprintf(stderr, "=> ""F_DEC_NEQ_LOOP{1116}""\n");
02174 }
02175 #endif
02176 {
02177 ADD_NODE_REF2(CAAR(n),
02178 ADD_NODE_REF2(CADR(n),
02179 ADD_NODE_REF2(CDDR(n),
02180 tmp1 = mknode(F_DEC_NEQ_LOOP, mknode(F_VAL_LVAL, mkintnode(-1), CAAR(n)), mknode(F_COMMA_EXPR, CADR(n), CDDR(n)));
02181 )));
02182 goto use_tmp1;
02183 }
02184 }
02185 }
02186 }
02187 }
02188 }
02189 }
02190 } else if (CAR(n)->token == F_POST_INC) {
02191 if (!CDR(n)) {
02192 } else {
02193 if (CDR(n)->token == ':') {
02194 if (!CADR(n)) {
02195 if (!CDDR(n)) {
02196 } else {
02197 if ((!(CDDR(n)->tree_info & OPT_CONTINUE))) {
02198 #ifdef PIKE_DEBUG
02199 if (l_flag > 4) {
02200 fprintf(stderr, "Match: ""F_FOR{989}(F_POST_INC{990}(0 = *{991}, *), ':'{993}(-{994}, 1 = +{995}[!(CDDR(n)->tree_info & OPT_CONTINUE)]))""\n");
02201 }
02202 #endif
02203 #ifdef PIKE_DEBUG
02204 if (l_flag > 4) {
02205 fprintf(stderr, "=> ""F_INC_NEQ_LOOP{996}""\n");
02206 }
02207 #endif
02208 {
02209 ADD_NODE_REF2(CAAR(n),
02210 ADD_NODE_REF2(CDDR(n),
02211 tmp1 = mknode(F_INC_NEQ_LOOP, mknode(F_VAL_LVAL, mkintnode(1), CAAR(n)), CDDR(n));
02212 ));
02213 goto use_tmp1;
02214 }
02215 }
02216 }
02217 } else if (!CDDR(n)) {
02218 if (!CADR(n)) {
02219 } else {
02220 if ((!(CADR(n)->tree_info & OPT_CONTINUE))) {
02221 #ifdef PIKE_DEBUG
02222 if (l_flag > 4) {
02223 fprintf(stderr, "Match: ""F_FOR{1001}(F_POST_INC{1002}(0 = *{1003}, *), ':'{1005}(1 = +{1006}[!(CADR(n)->tree_info & OPT_CONTINUE)], -{1007}))""\n");
02224 }
02225 #endif
02226 #ifdef PIKE_DEBUG
02227 if (l_flag > 4) {
02228 fprintf(stderr, "=> ""F_INC_NEQ_LOOP{1008}""\n");
02229 }
02230 #endif
02231 {
02232 ADD_NODE_REF2(CAAR(n),
02233 ADD_NODE_REF2(CADR(n),
02234 tmp1 = mknode(F_INC_NEQ_LOOP, mknode(F_VAL_LVAL, mkintnode(1), CAAR(n)), CADR(n));
02235 ));
02236 goto use_tmp1;
02237 }
02238 }
02239 }
02240 } else {
02241 if ((!(CADR(n)->tree_info & OPT_CONTINUE))) {
02242 if (!CDDR(n)) {
02243 } else {
02244 if ((!(CDDR(n)->tree_info & OPT_CONTINUE))) {
02245 #ifdef PIKE_DEBUG
02246 if (l_flag > 4) {
02247 fprintf(stderr, "Match: ""F_FOR{1013}(F_POST_INC{1014}(0 = *{1015}, *), ':'{1017}(1 = +{1018}[!(CADR(n)->tree_info & OPT_CONTINUE)], 2 = +{1019}[!(CDDR(n)->tree_info & OPT_CONTINUE)]))""\n");
02248 }
02249 #endif
02250 #ifdef PIKE_DEBUG
02251 if (l_flag > 4) {
02252 fprintf(stderr, "=> ""F_INC_NEQ_LOOP{1020}""\n");
02253 }
02254 #endif
02255 {
02256 ADD_NODE_REF2(CAAR(n),
02257 ADD_NODE_REF2(CADR(n),
02258 ADD_NODE_REF2(CDDR(n),
02259 tmp1 = mknode(F_INC_NEQ_LOOP, mknode(F_VAL_LVAL, mkintnode(1), CAAR(n)), mknode(F_COMMA_EXPR, CADR(n), CDDR(n)));
02260 )));
02261 goto use_tmp1;
02262 }
02263 }
02264 }
02265 }
02266 }
02267 }
02268 }
02269 }
02270 if (CDR(n)->token == ':') {
02271 if (!CADR(n)) {
02272 if (!CDDR(n)) {
02273 #ifdef PIKE_DEBUG
02274 if (l_flag > 4) {
02275 fprintf(stderr, "Match: ""F_FOR{913}(0 = *{914}, ':'{915}(-{916}, -{917}))""\n");
02276 }
02277 #endif
02278 #ifdef PIKE_DEBUG
02279 if (l_flag > 4) {
02280 fprintf(stderr, "=> ""F_FOR{918}""\n");
02281 }
02282 #endif
02283 {
02284 ADD_NODE_REF2(CAR(n),
02285 tmp1 = mknode(F_FOR, CAR(n), 0);
02286 );
02287 goto use_tmp1;
02288 }
02289 }
02290 } else if (!CDDR(n)) {
02291 } else {
02292 if (CDDR(n)->token == F_CAST) {
02293 if ((CDDR(n)->type == void_type_string)) {
02294 #ifdef PIKE_DEBUG
02295 if (l_flag > 4) {
02296 fprintf(stderr, "Match: ""F_FOR{1123}(0 = *{1124}, ':'{1125}(1 = *{1126}, F_CAST{1127}[CDDR(n)->type == void_type_string](2 = *{1128}, *)))""\n");
02297 }
02298 #endif
02299 #ifdef PIKE_DEBUG
02300 if (l_flag > 4) {
02301 fprintf(stderr, "=> ""F_FOR{1130}""\n");
02302 }
02303 #endif
02304 {
02305 ADD_NODE_REF2(CAR(n),
02306 ADD_NODE_REF2(CADR(n),
02307 ADD_NODE_REF2(CADDR(n),
02308 tmp1 = mknode(F_FOR, CAR(n), mknode(':', CADR(n), CADDR(n)));
02309 )));
02310 goto use_tmp1;
02311 }
02312 }
02313 }
02314 }
02315 }
02316 if ((node_is_false(CAR(n)))) {
02317 #ifdef PIKE_DEBUG
02318 if (l_flag > 4) {
02319 fprintf(stderr, "Match: ""F_FOR{921}(+{922}[node_is_false(CAR(n))], *)""\n");
02320 }
02321 #endif
02322 #ifdef PIKE_DEBUG
02323 if (l_flag > 4) {
02324 fprintf(stderr, "=> ""-{924}""\n");
02325 }
02326 #endif
02327 goto zap_node;
02328 }
02329 }
02330 break;
02331
02332 case F_FOREACH:
02333 if (!CAR(n)) {
02334 } else if (!CDR(n)) {
02335 if (!CAR(n)) {
02336 } else {
02337 if (CAR(n)->token == F_VAL_LVAL) {
02338 #ifdef PIKE_DEBUG
02339 if (l_flag > 4) {
02340 fprintf(stderr, "Match: ""F_FOREACH{832}(F_VAL_LVAL{833}(0 = *{834}, *), -{836})""\n");
02341 }
02342 #endif
02343 #ifdef PIKE_DEBUG
02344 if (l_flag > 4) {
02345 fprintf(stderr, "=> ""F_POP_VALUE{837}""\n");
02346 }
02347 #endif
02348 {
02349 ADD_NODE_REF2(CAAR(n),
02350 tmp1 = mknode(F_POP_VALUE, CAAR(n), 0);
02351 );
02352 goto use_tmp1;
02353 }
02354 }
02355 }
02356 } else {
02357 if (CAR(n)->token == F_VAL_LVAL) {
02358 if (!CAAR(n)) {
02359 } else if (!CDAR(n)) {
02360 #ifdef PIKE_DEBUG
02361 if (l_flag > 4) {
02362 fprintf(stderr, "Match: ""F_FOREACH{858}(F_VAL_LVAL{859}(0 = *{860}, -{861}), 1 = *{862})""\n");
02363 }
02364 #endif
02365 {
02366
02367 ADD_NODE_REF2(CDR(n),
02368 ADD_NODE_REF2(CAAR(n),
02369 tmp1 = mknode(F_LOOP, mkefuncallnode("sizeof", CAAR(n)), CDR(n));
02370 ));
02371 goto use_tmp1;
02372 }
02373 } else {
02374 if (CAAR(n)->token == F_APPLY) {
02375 if (!CAAAR(n)) {
02376 } else {
02377 if (CAAAR(n)->token == F_CONSTANT) {
02378 if ((CAAAR(n)->u.sval.type == T_FUNCTION) &&
02379 (CAAAR(n)->u.sval.subtype == FUNCTION_BUILTIN) &&
02380 (CAAAR(n)->u.sval.u.efun->function == f_divide)) {
02381 if (!CDAAR(n)) {
02382 } else {
02383 if (CDAAR(n)->token == F_ARG_LIST) {
02384 if (!CADAAR(n)) {
02385 } else {
02386 if ((CADAAR(n)->type == string_type_string)) {
02387 if (!CDDAAR(n)) {
02388 } else {
02389 if (CDDAAR(n)->token == F_CONSTANT) {
02390 if ((CDDAAR(n)->u.sval.type == T_STRING) &&
02391 (CDDAAR(n)->u.sval.u.string->len == 1)) {
02392 #ifdef PIKE_DEBUG
02393 if (l_flag > 4) {
02394 fprintf(stderr, "Match: ""F_FOREACH{870}(F_VAL_LVAL{871}(F_APPLY{872}(F_CONSTANT{873}[CAAAR(n)->u.sval.type == T_FUNCTION][CAAAR(n)->u.sval.subtype == FUNCTION_BUILTIN][CAAAR(n)->u.sval.u.efun->function == f_divide], F_ARG_LIST{874}(0 = +{875}[CADAAR(n)->type == string_type_string], 1 = F_CONSTANT{876}[CDDAAR(n)->u.sval.type == T_STRING][CDDAAR(n)->u.sval.u.string->len == 1])), 2 = *{877}), 3 = *{878})""\n");
02395 }
02396 #endif
02397 {
02398 extern struct program *string_split_iterator_program;
02399 node *vars;
02400 p_wchar2 split = index_shared_string(CDDAAR(n)->u.sval.u.string, 0);
02401
02402 ADD_NODE_REF2(CDAR(n),
02403 if (CDAR(n)->token == ':') {
02404 vars = CDAR(n);
02405 } else {
02406
02407 vars = mknode(':', NULL, CDAR(n));
02408 }
02409 );
02410
02411
02412 ADD_NODE_REF2(CDR(n),
02413 ADD_NODE_REF2(CADAAR(n),
02414 tmp1 = mknode(F_FOREACH,
02415 mknode(F_VAL_LVAL,
02416 mkapplynode(mkprgnode(string_split_iterator_program),
02417 mknode(F_ARG_LIST, CADAAR(n),
02418 mkintnode(split))),
02419 vars),
02420 CDR(n));
02421 ));
02422 goto use_tmp1;
02423 }
02424 }
02425 }
02426 }
02427 }
02428 }
02429 }
02430 }
02431 }
02432 if ((CAAAR(n)->u.sval.type == T_FUNCTION) &&
02433 (CAAAR(n)->u.sval.subtype == FUNCTION_BUILTIN) &&
02434 (CAAAR(n)->u.sval.u.efun->function == f_minus)) {
02435 if (!CDAAR(n)) {
02436 } else {
02437 if (CDAAR(n)->token == F_ARG_LIST) {
02438 if (!CADAAR(n)) {
02439 } else {
02440 if (CADAAR(n)->token == F_APPLY) {
02441 if (!CAADAAR(n)) {
02442 } else {
02443 if (CAADAAR(n)->token == F_CONSTANT) {
02444 if ((CAADAAR(n)->u.sval.type == T_FUNCTION) &&
02445 (CAADAAR(n)->u.sval.subtype == FUNCTION_BUILTIN) &&
02446 (CAADAAR(n)->u.sval.u.efun->function == f_divide)) {
02447 if (!CDADAAR(n)) {
02448 } else {
02449 if (CDADAAR(n)->token == F_ARG_LIST) {
02450 if (!CADADAAR(n)) {
02451 } else {
02452 if ((CADADAAR(n)->type == string_type_string)) {
02453 if (!CDDADAAR(n)) {
02454 } else {
02455 if (CDDADAAR(n)->token == F_CONSTANT) {
02456 if ((CDDADAAR(n)->u.sval.type == T_STRING) &&
02457 (CDDADAAR(n)->u.sval.u.string->len == 1)) {
02458 if (!CDDAAR(n)) {
02459 } else {
02460 if (CDDAAR(n)->token == F_APPLY) {
02461 if (!CADDAAR(n)) {
02462 } else {
02463 if (CADDAAR(n)->token == F_CONSTANT) {
02464 if ((CADDAAR(n)->u.sval.type == T_FUNCTION) &&
02465 (CADDAAR(n)->u.sval.subtype == FUNCTION_BUILTIN) &&
02466 (CADDAAR(n)->u.sval.u.efun->function == f_allocate)) {
02467 if (!CDDDAAR(n)) {
02468 } else {
02469 if (CDDDAAR(n)->token == F_ARG_LIST) {
02470 if (!CADDDAAR(n)) {
02471 } else {
02472 if (CADDDAAR(n)->token == F_CONSTANT) {
02473 if ((CADDDAAR(n)->u.sval.type == T_INT) &&
02474 (CADDDAAR(n)->u.sval.u.integer == 1)) {
02475 if (!CDDDDAAR(n)) {
02476 } else {
02477 if (CDDDDAAR(n)->token == F_CONSTANT) {
02478 if ((CDDDDAAR(n)->u.sval.type == T_STRING) &&
02479 (CDDDDAAR(n)->u.sval.u.string->len == 0)) {
02480 #ifdef PIKE_DEBUG
02481 if (l_flag > 4) {
02482 fprintf(stderr, "Match: ""F_FOREACH{892}(F_VAL_LVAL{893}(F_APPLY{894}(F_CONSTANT{895}[CAAAR(n)->u.sval.type == T_FUNCTION][CAAAR(n)->u.sval.subtype == FUNCTION_BUILTIN][CAAAR(n)->u.sval.u.efun->function == f_minus], F_ARG_LIST{896}(F_APPLY{897}(F_CONSTANT{898}[CAADAAR(n)->u.sval.type == T_FUNCTION][CAADAAR(n)->u.sval.subtype == FUNCTION_BUILTIN][CAADAAR(n)->u.sval.u.efun->function == f_divide], F_ARG_LIST{899}(0 = +{900}[CADADAAR(n)->type == string_type_string], 1 = F_CONSTANT{901}[CDDADAAR(n)->u.sval.type == T_STRING][CDDADAAR(n)->u.sval.u.string->len == 1])), F_APPLY{902}(F_CONSTANT{903}[CADDAAR(n)->u.sval.type == T_FUNCTION][CADDAAR(n)->u.sval.subtype == FUNCTION_BUILTIN][CADDAAR(n)->u.sval.u.efun->function == f_allocate], F_ARG_LIST{904}(F_CONSTANT{905}[CADDDAAR(n)->u.sval.type == T_INT][CADDDAAR(n)->u.sval.u.integer == 1], F_CONSTANT{906}[CDDDDAAR(n)->u.sval.type == T_STRING][CDDDDAAR(n)->u.sval.u.string->len == 0])))), 2 = *{907}), 3 = *{908})""\n");
02483 }
02484 #endif
02485 {
02486 extern struct program *string_split_iterator_program;
02487 node *vars;
02488 p_wchar2 split = index_shared_string(CDDADAAR(n)->u.sval.u.string, 0);
02489
02490 ADD_NODE_REF2(CDAR(n),
02491 if (CDAR(n)->token == ':') {
02492 vars = CDAR(n);
02493 } else {
02494
02495 vars = mknode(':', NULL, CDAR(n));
02496 }
02497 );
02498
02499
02500 ADD_NODE_REF2(CDR(n),
02501 ADD_NODE_REF2(CADADAAR(n),
02502 tmp1 = mknode(F_FOREACH,
02503 mknode(F_VAL_LVAL,
02504 mkapplynode(mkprgnode(string_split_iterator_program),
02505 mknode(F_ARG_LIST, CADADAAR(n),
02506 mknode(F_ARG_LIST,
02507 mkintnode(split),
02508 mkintnode(1)))),
02509 vars),
02510 CDR(n));
02511 ));
02512 goto use_tmp1;
02513 }
02514 }
02515 }
02516 }
02517 }
02518 }
02519 }
02520 }
02521 }
02522 }
02523 }
02524 }
02525 } else if (CDDAAR(n)->token == F_CONSTANT) {
02526 if ((CDDAAR(n)->u.sval.type == T_ARRAY) &&
02527 (CDDAAR(n)->u.sval.u.array->size == 1) &&
02528 (CDDAAR(n)->u.sval.u.array->item[0].type == T_STRING) &&
02529 (CDDAAR(n)->u.sval.u.array->item[0].u.string->len == 0)) {
02530 #ifdef PIKE_DEBUG
02531 if (l_flag > 4) {
02532 fprintf(stderr, "Match: ""F_FOREACH{879}(F_VAL_LVAL{880}(F_APPLY{881}(F_CONSTANT{882}[CAAAR(n)->u.sval.type == T_FUNCTION][CAAAR(n)->u.sval.subtype == FUNCTION_BUILTIN][CAAAR(n)->u.sval.u.efun->function == f_minus], F_ARG_LIST{883}(F_APPLY{884}(F_CONSTANT{885}[CAADAAR(n)->u.sval.type == T_FUNCTION][CAADAAR(n)->u.sval.subtype == FUNCTION_BUILTIN][CAADAAR(n)->u.sval.u.efun->function == f_divide], F_ARG_LIST{886}(0 = +{887}[CADADAAR(n)->type == string_type_string], 1 = F_CONSTANT{888}[CDDADAAR(n)->u.sval.type == T_STRING][CDDADAAR(n)->u.sval.u.string->len == 1])), F_CONSTANT{889}[CDDAAR(n)->u.sval.type == T_ARRAY][CDDAAR(n)->u.sval.u.array->size == 1][CDDAAR(n)->u.sval.u.array->item[0].type == T_STRING][CDDAAR(n)->u.sval.u.array->item[0].u.string->len == 0])), 2 = *{890}), 3 = *{891})""\n");
02533 }
02534 #endif
02535 {
02536 extern struct program *string_split_iterator_program;
02537 node *vars;
02538 p_wchar2 split = index_shared_string(CDDADAAR(n)->u.sval.u.string, 0);
02539
02540 ADD_NODE_REF2(CDAR(n),
02541 if (CDAR(n)->token == ':') {
02542 vars = CDAR(n);
02543 } else {
02544
02545 vars = mknode(':', NULL, CDAR(n));
02546 }
02547 );
02548
02549
02550 ADD_NODE_REF2(CDR(n),
02551 ADD_NODE_REF2(CADADAAR(n),
02552 tmp1 = mknode(F_FOREACH,
02553 mknode(F_VAL_LVAL,
02554 mkapplynode(mkprgnode(string_split_iterator_program),
02555 mknode(F_ARG_LIST, CADADAAR(n),
02556 mknode(F_ARG_LIST,
02557 mkintnode(split),
02558 mkintnode(1)))),
02559 vars),
02560 CDR(n));
02561 ));
02562 goto use_tmp1;
02563 }
02564 }
02565 }
02566 }
02567 }
02568 }
02569 }
02570 }
02571 }
02572 }
02573 }
02574 }
02575 }
02576 }
02577 }
02578 }
02579 }
02580 }
02581 }
02582 }
02583 }
02584 }
02585 if (CDAR(n)->token == ':') {
02586 if (!CADAR(n)) {
02587 if (!CDDAR(n)) {
02588 #ifdef PIKE_DEBUG
02589 if (l_flag > 4) {
02590 fprintf(stderr, "Match: ""F_FOREACH{863}(F_VAL_LVAL{864}(0 = *{865}, ':'{866}(-{867}, -{868})), 1 = *{869})""\n");
02591 }
02592 #endif
02593 {
02594
02595 ADD_NODE_REF2(CDR(n),
02596 ADD_NODE_REF2(CAAR(n),
02597 tmp1 = mknode(F_LOOP, mkefuncallnode("sizeof", CAAR(n)), CDR(n));
02598 ));
02599 goto use_tmp1;
02600 }
02601 }
02602 }
02603 }
02604 if (( pike_types_le(CAAR(n)->type, array_type_string) )) {
02605 if (!CDAR(n)) {
02606 } else {
02607 if (CDAR(n)->token == ':') {
02608 if (!CADAR(n)) {
02609 #ifdef PIKE_DEBUG
02610 if (l_flag > 4) {
02611 fprintf(stderr, "Match: ""F_FOREACH{846}(F_VAL_LVAL{847}(0 = +{848}[ pike_types_le(CAAR(n)->type, array_type_string) ], ':'{849}(-{850}, 1 = *{851})), 2 = *{852})""\n");
02612 }
02613 #endif
02614 #ifdef PIKE_DEBUG
02615 if (l_flag > 4) {
02616 fprintf(stderr, "=> ""F_FOREACH{853}""\n");
02617 }
02618 #endif
02619 {
02620 ADD_NODE_REF2(CAAR(n),
02621 ADD_NODE_REF2(CDDAR(n),
02622 ADD_NODE_REF2(CDR(n),
02623 tmp1 = mknode(F_FOREACH, mknode(F_VAL_LVAL, CAAR(n), CDDAR(n)), CDR(n));
02624 )));
02625 goto use_tmp1;
02626 }
02627 }
02628 }
02629 }
02630 }
02631 }
02632 }
02633 }
02634 break;
02635
02636 case F_INC_LOOP:
02637 if (!CAR(n)) {
02638 } else {
02639 if (CAR(n)->token == F_VAL_LVAL) {
02640 if (!CDAR(n)) {
02641 } else {
02642 if (( !(CDAR(n)->tree_info & (OPT_SIDE_EFFECT|OPT_ASSIGNMENT|
02643 OPT_CASE|OPT_CONTINUE|
02644 OPT_BREAK|OPT_RETURN)) )) {
02645 if (!CDR(n)) {
02646 } else {
02647 if (( !(CDR(n)->tree_info & (OPT_BREAK|OPT_CONTINUE)) ) &&
02648 ( !depend2_p(CDR(n), CDAR(n)) )) {
02649 #ifdef PIKE_DEBUG
02650 if (l_flag > 4) {
02651 fprintf(stderr, "Match: ""F_INC_LOOP{1142}(F_VAL_LVAL{1143}(0 = *{1144}, 1 = +{1145}[ !(CDAR(n)->tree_info & (OPT_SIDE_EFFECT|OPT_ASSIGNMENT|\n\t\t\t\t\t\tOPT_CASE|OPT_CONTINUE|\n\t\t\t\t\t\tOPT_BREAK|OPT_RETURN)) ]), 2 = +{1146}[ !(CDR(n)->tree_info & (OPT_BREAK|OPT_CONTINUE)) ][ !depend2_p(CDR(n), CDAR(n)) ])""\n");
02652 }
02653 #endif
02654 {
02655
02656 ADD_NODE_REF2(CDAR(n),
02657 ADD_NODE_REF2(CDAR(n),
02658 ADD_NODE_REF2(CAAR(n),
02659 ADD_NODE_REF2(CAAR(n),
02660 ADD_NODE_REF2(CDR(n),
02661 tmp1 = mknode(F_COMMA_EXPR,
02662 mknode(F_LOOP,
02663 mkefuncallnode("`+",
02664 mknode(F_ARG_LIST,
02665 mkefuncallnode("`-", CDAR(n)),
02666 mknode(F_ARG_LIST,
02667 mkintnode(-1),
02668 CAAR(n)))), CDR(n)),
02669 mkcastnode(void_type_string, mknode(F_ASSIGN, CAAR(n), CDAR(n))));
02670 )))));
02671 goto use_tmp1;
02672 }
02673 }
02674 }
02675 }
02676 }
02677 }
02678 }
02679 break;
02680
02681 case F_INDEX:
02682 if (!CAR(n)) {
02683 #ifdef PIKE_DEBUG
02684 if (l_flag > 4) {
02685 fprintf(stderr, "Match: ""F_INDEX{796}(-{797}, *)""\n");
02686 }
02687 #endif
02688 #ifdef PIKE_DEBUG
02689 if (l_flag > 4) {
02690 fprintf(stderr, "=> ""F_COMMA_EXPR{799}""\n");
02691 }
02692 #endif
02693 {
02694 ADD_NODE_REF2(CDR(n),
02695 tmp1 = mknode(F_COMMA_EXPR, mknode(F_POP_VALUE, CDR(n), 0), mkintnode(0));
02696 );
02697 goto use_tmp1;
02698 }
02699 } else {
02700 if (( !match_types(CAR(n)->type, object_type_string) )) {
02701 if (!CDR(n)) {
02702 } else {
02703 if (CDR(n)->token == F_CONSTANT) {
02704 if ((CDR(n)->u.sval.type == T_STRING)) {
02705 #ifdef PIKE_DEBUG
02706 if (l_flag > 4) {
02707 fprintf(stderr, "Match: ""F_INDEX{804}(0 = +{805}[ !match_types(CAR(n)->type, object_type_string) ], 1 = F_CONSTANT{806}[CDR(n)->u.sval.type == T_STRING])""\n");
02708 }
02709 #endif
02710 #ifdef PIKE_DEBUG
02711 if (l_flag > 4) {
02712 fprintf(stderr, "=> ""F_ARROW{807}""\n");
02713 }
02714 #endif
02715 {
02716 ADD_NODE_REF2(CAR(n),
02717 ADD_NODE_REF2(CDR(n),
02718 tmp1 = mknode(F_ARROW, CAR(n), CDR(n));
02719 ));
02720 goto use_tmp1;
02721 }
02722 }
02723 }
02724 }
02725 }
02726 }
02727 break;
02728
02729 case F_LAND:
02730 if (!CAR(n)) {
02731 #ifdef PIKE_DEBUG
02732 if (l_flag > 4) {
02733 fprintf(stderr, "Match: ""F_LAND{552}(-{553}, 0 = *{554})""\n");
02734 }
02735 #endif
02736 #ifdef PIKE_DEBUG
02737 if (l_flag > 4) {
02738 fprintf(stderr, "=> ""-{555}""\n");
02739 }
02740 #endif
02741 goto zap_node;
02742 } else if (!CDR(n)) {
02743 if (!CAR(n)) {
02744 } else {
02745 if ((node_is_false(CAR(n)))) {
02746 #ifdef PIKE_DEBUG
02747 if (l_flag > 4) {
02748 fprintf(stderr, "Match: ""F_LAND{611}(0 = +{612}[node_is_false(CAR(n))], *)""\n");
02749 }
02750 #endif
02751 #ifdef PIKE_DEBUG
02752 if (l_flag > 4) {
02753 fprintf(stderr, "=> ""0 = *{614}""\n");
02754 }
02755 #endif
02756 goto use_car;
02757 }
02758 if ((node_is_true(CAR(n)))) {
02759 #ifdef PIKE_DEBUG
02760 if (l_flag > 4) {
02761 fprintf(stderr, "Match: ""F_LAND{607}(+{608}[node_is_true(CAR(n))], 0 = *{609})""\n");
02762 }
02763 #endif
02764 #ifdef PIKE_DEBUG
02765 if (l_flag > 4) {
02766 fprintf(stderr, "=> ""0 = *{610}""\n");
02767 }
02768 #endif
02769 goto use_cdr;
02770 }
02771 }
02772 #ifdef PIKE_DEBUG
02773 if (l_flag > 4) {
02774 fprintf(stderr, "Match: ""F_LAND{556}(0 = *{557}, -{558})""\n");
02775 }
02776 #endif
02777 #ifdef PIKE_DEBUG
02778 if (l_flag > 4) {
02779 fprintf(stderr, "=> ""F_COMMA_EXPR{559}""\n");
02780 }
02781 #endif
02782 {
02783 ADD_NODE_REF2(CAR(n),
02784 tmp1 = mknode(F_COMMA_EXPR, CAR(n), mkintnode(0));
02785 );
02786 goto use_tmp1;
02787 }
02788 } else {
02789 if (CAR(n)->token == F_APPLY) {
02790 if (!CAAR(n)) {
02791 } else {
02792 if (CAAR(n)->token == F_CONSTANT) {
02793 if ((CAAR(n)->u.sval.type == T_FUNCTION) &&
02794 (CAAR(n)->u.sval.subtype == FUNCTION_BUILTIN) &&
02795 (CAAR(n)->u.sval.u.efun->function == f_not)) {
02796 if (!CDR(n)) {
02797 } else {
02798 if (CDR(n)->token == F_APPLY) {
02799 {
02800 if ((CADR(n) == CAAR(n))
02801 #ifdef SHARED_NODES_MK2
02802 || (CADR(n) && CAAR(n) &&
02803 ((CADR(n)->master?CADR(n)->master:CADR(n))==
02804 (CAAR(n)->master?CAAR(n)->master:CAAR(n))))
02805 #endif
02806 ) {
02807 #ifdef PIKE_DEBUG
02808 if (l_flag > 4) {
02809 fprintf(stderr, "Match: ""F_LAND{562}(F_APPLY{563}(0 = F_CONSTANT{564}[CAAR(n)->u.sval.type == T_FUNCTION][CAAR(n)->u.sval.subtype == FUNCTION_BUILTIN][CAAR(n)->u.sval.u.efun->function == f_not], 1 = *{565}), F_APPLY{566}($CAAR(n)$, 2 = *{567}))""\n");
02810 }
02811 #endif
02812 #ifdef PIKE_DEBUG
02813 if (l_flag > 4) {
02814 fprintf(stderr, "=> ""F_APPLY{568}""\n");
02815 }
02816 #endif
02817 {
02818 ADD_NODE_REF2(CAAR(n),
02819 ADD_NODE_REF2(CDAR(n),
02820 ADD_NODE_REF2(CDDR(n),
02821 tmp1 = mknode(F_APPLY, CAAR(n), mknode(F_LOR, CDAR(n), CDDR(n)));
02822 )));
02823 goto use_tmp1;
02824 }
02825 }
02826 }
02827 }
02828 }
02829 }
02830 }
02831 }
02832 } else if (CAR(n)->token == F_ASSIGN) {
02833 if (!CDAR(n)) {
02834 } else {
02835 if ((node_is_false(CDAR(n)))) {
02836 #ifdef PIKE_DEBUG
02837 if (l_flag > 4) {
02838 fprintf(stderr, "Match: ""F_LAND{591}(0 = F_ASSIGN{592}(*, +{594}[node_is_false(CDAR(n))]), *)""\n");
02839 }
02840 #endif
02841 #ifdef PIKE_DEBUG
02842 if (l_flag > 4) {
02843 fprintf(stderr, "=> ""0 = *{596}""\n");
02844 }
02845 #endif
02846 goto use_car;
02847 }
02848 if ((node_is_true(CDAR(n)))) {
02849 #ifdef PIKE_DEBUG
02850 if (l_flag > 4) {
02851 fprintf(stderr, "Match: ""F_LAND{583}(0 = F_ASSIGN{584}(*, +{586}[node_is_true(CDAR(n))]), 2 = *{587})""\n");
02852 }
02853 #endif
02854 #ifdef PIKE_DEBUG
02855 if (l_flag > 4) {
02856 fprintf(stderr, "=> ""F_COMMA_EXPR{588}""\n");
02857 }
02858 #endif
02859 {
02860 ADD_NODE_REF2(CAR(n),
02861 ADD_NODE_REF2(CDR(n),
02862 tmp1 = mknode(F_COMMA_EXPR, CAR(n), CDR(n));
02863 ));
02864 goto use_tmp1;
02865 }
02866 }
02867 }
02868 } else if (CAR(n)->token == F_COMMA_EXPR) {
02869 #ifdef PIKE_DEBUG
02870 if (l_flag > 4) {
02871 fprintf(stderr, "Match: ""F_LAND{597}(F_COMMA_EXPR{598}(0 = *{599}, 1 = *{600}), 2 = *{601})""\n");
02872 }
02873 #endif
02874 #ifdef PIKE_DEBUG
02875 if (l_flag > 4) {
02876 fprintf(stderr, "=> ""F_COMMA_EXPR{602}""\n");
02877 }
02878 #endif
02879 {
02880 ADD_NODE_REF2(CAAR(n),
02881 ADD_NODE_REF2(CDAR(n),
02882 ADD_NODE_REF2(CDR(n),
02883 tmp1 = mknode(F_COMMA_EXPR, CAAR(n), mknode(F_LAND, CDAR(n), CDR(n)));
02884 )));
02885 goto use_tmp1;
02886 }
02887 }
02888 if (CDR(n)->token == F_LAND) {
02889 #ifdef PIKE_DEBUG
02890 if (l_flag > 4) {
02891 fprintf(stderr, "Match: ""F_LAND{573}(0 = *{574}, F_LAND{575}(1 = *{576}, 2 = *{577}))""\n");
02892 }
02893 #endif
02894 #ifdef PIKE_DEBUG
02895 if (l_flag > 4) {
02896 fprintf(stderr, "=> ""F_LAND{578}""\n");
02897 }
02898 #endif
02899 {
02900 ADD_NODE_REF2(CAR(n),
02901 ADD_NODE_REF2(CADR(n),
02902 ADD_NODE_REF2(CDDR(n),
02903 tmp1 = mknode(F_LAND, mknode(F_LAND, CAR(n), CADR(n)), CDDR(n));
02904 )));
02905 goto use_tmp1;
02906 }
02907 }
02908 if ((node_is_false(CAR(n)))) {
02909 #ifdef PIKE_DEBUG
02910 if (l_flag > 4) {
02911 fprintf(stderr, "Match: ""F_LAND{611}(0 = +{612}[node_is_false(CAR(n))], *)""\n");
02912 }
02913 #endif
02914 #ifdef PIKE_DEBUG
02915 if (l_flag > 4) {
02916 fprintf(stderr, "=> ""0 = *{614}""\n");
02917 }
02918 #endif
02919 goto use_car;
02920 }
02921 if ((node_is_true(CAR(n)))) {
02922 #ifdef PIKE_DEBUG
02923 if (l_flag > 4) {
02924 fprintf(stderr, "Match: ""F_LAND{607}(+{608}[node_is_true(CAR(n))], 0 = *{609})""\n");
02925 }
02926 #endif
02927 #ifdef PIKE_DEBUG
02928 if (l_flag > 4) {
02929 fprintf(stderr, "=> ""0 = *{610}""\n");
02930 }
02931 #endif
02932 goto use_cdr;
02933 }
02934 }
02935 break;
02936
02937 case F_LOOP:
02938 if (!CAR(n)) {
02939 } else if (!CDR(n)) {
02940 #ifdef PIKE_DEBUG
02941 if (l_flag > 4) {
02942 fprintf(stderr, "Match: ""F_LOOP{840}(0 = *{841}, -{842})""\n");
02943 }
02944 #endif
02945 #ifdef PIKE_DEBUG
02946 if (l_flag > 4) {
02947 fprintf(stderr, "=> ""F_POP_VALUE{843}""\n");
02948 }
02949 #endif
02950 {
02951 ADD_NODE_REF2(CAR(n),
02952 tmp1 = mknode(F_POP_VALUE, CAR(n), 0);
02953 );
02954 goto use_tmp1;
02955 }
02956 } else {
02957 if (CDR(n)->token == F_POP_VALUE) {
02958 if (!CDDR(n)) {
02959 #ifdef PIKE_DEBUG
02960 if (l_flag > 4) {
02961 fprintf(stderr, "Match: ""F_LOOP{1147}(0 = *{1148}, F_POP_VALUE{1149}(1 = *{1150}, -{1151}))""\n");
02962 }
02963 #endif
02964 #ifdef PIKE_DEBUG
02965 if (l_flag > 4) {
02966 fprintf(stderr, "=> ""F_LOOP{1152}""\n");
02967 }
02968 #endif
02969 {
02970 ADD_NODE_REF2(CAR(n),
02971 ADD_NODE_REF2(CADR(n),
02972 tmp1 = mknode(F_LOOP, CAR(n), CADR(n));
02973 ));
02974 goto use_tmp1;
02975 }
02976 }
02977 }
02978 if (( !depend_p(CAR(n), CAR(n)) )) {
02979 if (!CDR(n)) {
02980 } else {
02981 if (CDR(n)->token == F_DEC) {
02982 if (( pike_types_le(CDR(n)->type, int_type_string) )) {
02983 if (!CDDR(n)) {
02984 if (!CADR(n)) {
02985 } else {
02986 if (( !depend_p(CADR(n), CADR(n)) )) {
02987 #ifdef PIKE_DEBUG
02988 if (l_flag > 4) {
02989 fprintf(stderr, "Match: ""F_LOOP{1175}(0 = +{1176}[ !depend_p(CAR(n), CAR(n)) ], F_DEC{1177}[ pike_types_le(CDR(n)->type, int_type_string) ](1 = +{1178}[ !depend_p(CADR(n), CADR(n)) ], -{1179}))""\n");
02990 }
02991 #endif
02992 #ifdef PIKE_DEBUG
02993 if (l_flag > 4) {
02994 fprintf(stderr, "=> ""F_POP_VALUE{1180}""\n");
02995 }
02996 #endif
02997 {
02998 ADD_NODE_REF2(CADR(n),
02999 ADD_NODE_REF2(CAR(n),
03000 tmp1 = mknode(F_POP_VALUE, mknode(F_SUB_EQ, CADR(n), CAR(n)), 0);
03001 ));
03002 goto use_tmp1;
03003 }
03004 }
03005 }
03006 }
03007 }
03008 } else if (CDR(n)->token == F_INC) {
03009 if (( pike_types_le(CDR(n)->type, int_type_string) )) {
03010 if (!CDDR(n)) {
03011 if (!CADR(n)) {
03012 } else {
03013 if (( !depend_p(CADR(n), CADR(n)) )) {
03014 #ifdef PIKE_DEBUG
03015 if (l_flag > 4) {
03016 fprintf(stderr, "Match: ""F_LOOP{1155}(0 = +{1156}[ !depend_p(CAR(n), CAR(n)) ], F_INC{1157}[ pike_types_le(CDR(n)->type, int_type_string) ](1 = +{1158}[ !depend_p(CADR(n), CADR(n)) ], -{1159}))""\n");
03017 }
03018 #endif
03019 #ifdef PIKE_DEBUG
03020 if (l_flag > 4) {
03021 fprintf(stderr, "=> ""F_POP_VALUE{1160}""\n");
03022 }
03023 #endif
03024 {
03025 ADD_NODE_REF2(CADR(n),
03026 ADD_NODE_REF2(CAR(n),
03027 tmp1 = mknode(F_POP_VALUE, mknode(F_ADD_EQ, CADR(n), CAR(n)), 0);
03028 ));
03029 goto use_tmp1;
03030 }
03031 }
03032 }
03033 }
03034 }
03035 } else if (CDR(n)->token == F_POST_DEC) {
03036 if (( pike_types_le(CDR(n)->type, int_type_string) )) {
03037 if (!CDDR(n)) {
03038 if (!CADR(n)) {
03039 } else {
03040 if (( !depend_p(CADR(n), CADR(n)) )) {
03041 #ifdef PIKE_DEBUG
03042 if (l_flag > 4) {
03043 fprintf(stderr, "Match: ""F_LOOP{1185}(0 = +{1186}[ !depend_p(CAR(n), CAR(n)) ], F_POST_DEC{1187}[ pike_types_le(CDR(n)->type, int_type_string) ](1 = +{1188}[ !depend_p(CADR(n), CADR(n)) ], -{1189}))""\n");
03044 }
03045 #endif
03046 #ifdef PIKE_DEBUG
03047 if (l_flag > 4) {
03048 fprintf(stderr, "=> ""F_POP_VALUE{1190}""\n");
03049 }
03050 #endif
03051 {
03052 ADD_NODE_REF2(CADR(n),
03053 ADD_NODE_REF2(CAR(n),
03054 tmp1 = mknode(F_POP_VALUE, mknode(F_SUB_EQ, CADR(n), CAR(n)), 0);
03055 ));
03056 goto use_tmp1;
03057 }
03058 }
03059 }
03060 }
03061 }
03062 } else if (CDR(n)->token == F_POST_INC) {
03063 if (( pike_types_le(CDR(n)->type, int_type_string) )) {
03064 if (!CDDR(n)) {
03065 if (!CADR(n)) {
03066 } else {
03067 if (( !depend_p(CADR(n), CADR(n)) )) {
03068 #ifdef PIKE_DEBUG
03069 if (l_flag > 4) {
03070 fprintf(stderr, "Match: ""F_LOOP{1165}(0 = +{1166}[ !depend_p(CAR(n), CAR(n)) ], F_POST_INC{1167}[ pike_types_le(CDR(n)->type, int_type_string) ](1 = +{1168}[ !depend_p(CADR(n), CADR(n)) ], -{1169}))""\n");
03071 }
03072 #endif
03073 #ifdef PIKE_DEBUG
03074 if (l_flag > 4) {
03075 fprintf(stderr, "=> ""F_POP_VALUE{1170}""\n");
03076 }
03077 #endif
03078 {
03079 ADD_NODE_REF2(CADR(n),
03080 ADD_NODE_REF2(CAR(n),
03081 tmp1 = mknode(F_POP_VALUE, mknode(F_ADD_EQ, CADR(n), CAR(n)), 0);
03082 ));
03083 goto use_tmp1;
03084 }
03085 }
03086 }
03087 }
03088 }
03089 }
03090 }
03091 }
03092 if (( !depend_p(CAR(n), CAR(n))) &&
03093 ( !(CAR(n)->tree_info & (OPT_SIDE_EFFECT|OPT_ASSIGNMENT|
03094 OPT_CASE|OPT_CONTINUE|
03095 OPT_BREAK|OPT_RETURN)) )) {
03096 if (!CDR(n)) {
03097 } else {
03098 if (CDR(n)->token == F_ADD_EQ) {
03099 if (!CADR(n)) {
03100 } else {
03101 if (( !depend_p(CADR(n), CADR(n)) )) {
03102 if (!CDDR(n)) {
03103 } else {
03104 if (( !depend_p(CDDR(n), CADR(n)) ) &&
03105 ( !depend_p(CDDR(n), CDDR(n)) ) &&
03106 ( !(CDDR(n)->tree_info & OPT_SIDE_EFFECT) ) &&
03107 ( (((CDDR(n)->type == int_type_string) &&
03108 (CADR(n)->type == int_type_string)) ||
03109 (CDDR(n)->type == string_type_string)) )) {
03110 #ifdef PIKE_DEBUG
03111 if (l_flag > 4) {
03112 fprintf(stderr, "Match: ""F_LOOP{1195}(0 = +{1196}[ !depend_p(CAR(n), CAR(n))][ !(CAR(n)->tree_info & (OPT_SIDE_EFFECT|OPT_ASSIGNMENT|\n\t\t\t OPT_CASE|OPT_CONTINUE|\n\t\t\t OPT_BREAK|OPT_RETURN)) ], F_ADD_EQ{1197}(1 = +{1198}[ !depend_p(CADR(n), CADR(n)) ], 2 = +{1199}[ !depend_p(CDDR(n), CADR(n)) ][ !depend_p(CDDR(n), CDDR(n)) ][ !(CDDR(n)->tree_info & OPT_SIDE_EFFECT) ][ (((CDDR(n)->type == int_type_string) &&\n\t\t (CADR(n)->type == int_type_string)) ||\n\t\t (CDDR(n)->type == string_type_string)) ]))""\n");
03113 }
03114 #endif
03115 {
03116
03117 ADD_NODE_REF2(CAR(n),
03118 ADD_NODE_REF2(CAR(n),
03119 ADD_NODE_REF2(CDDR(n),
03120 ADD_NODE_REF2(CADR(n),
03121 tmp1 = mknode(F_POP_VALUE,
03122 mknode('?',
03123 mkefuncallnode("`>",
03124 mknode(F_ARG_LIST,
03125 CAR(n), mkintnode(0))),
03126 mknode(':',
03127 mknode(F_ADD_EQ,
03128 CADR(n),
03129 mkefuncallnode("`*",
03130 mknode(F_ARG_LIST,
03131 CDDR(n), CAR(n)))),
03132 mkintnode(0))),
03133 NULL);
03134 ))));
03135 goto use_tmp1;
03136 }
03137 }
03138 }
03139 }
03140 }
03141 }
03142 }
03143 }
03144 }
03145 break;
03146
03147 case F_LOR:
03148 if (!CAR(n)) {
03149 #ifdef PIKE_DEBUG
03150 if (l_flag > 4) {
03151 fprintf(stderr, "Match: ""F_LOR{487}(-{488}, 0 = *{489})""\n");
03152 }
03153 #endif
03154 #ifdef PIKE_DEBUG
03155 if (l_flag > 4) {
03156 fprintf(stderr, "=> ""0 = *{490}""\n");
03157 }
03158 #endif
03159 goto use_cdr;
03160 } else if (!CDR(n)) {
03161 if (!CAR(n)) {
03162 } else {
03163 if ((node_is_false(CAR(n)))) {
03164 #ifdef PIKE_DEBUG
03165 if (l_flag > 4) {
03166 fprintf(stderr, "Match: ""F_LOR{544}(+{545}[node_is_false(CAR(n))], 0 = *{546})""\n");
03167 }
03168 #endif
03169 #ifdef PIKE_DEBUG
03170 if (l_flag > 4) {
03171 fprintf(stderr, "=> ""0 = *{547}""\n");
03172 }
03173 #endif
03174 goto use_cdr;
03175 }
03176 if ((node_is_true(CAR(n)))) {
03177 #ifdef PIKE_DEBUG
03178 if (l_flag > 4) {
03179 fprintf(stderr, "Match: ""F_LOR{548}(0 = +{549}[node_is_true(CAR(n))], *)""\n");
03180 }
03181 #endif
03182 #ifdef PIKE_DEBUG
03183 if (l_flag > 4) {
03184 fprintf(stderr, "=> ""0 = *{551}""\n");
03185 }
03186 #endif
03187 goto use_car;
03188 }
03189 }
03190 #ifdef PIKE_DEBUG
03191 if (l_flag > 4) {
03192 fprintf(stderr, "Match: ""F_LOR{491}(0 = *{492}, -{493})""\n");
03193 }
03194 #endif
03195 #ifdef PIKE_DEBUG
03196 if (l_flag > 4) {
03197 fprintf(stderr, "=> ""0 = *{494}""\n");
03198 }
03199 #endif
03200 goto use_car;
03201 } else {
03202 if (CAR(n)->token == F_APPLY) {
03203 if (!CAAR(n)) {
03204 } else {
03205 if (CAAR(n)->token == F_CONSTANT) {
03206 if ((CAAR(n)->u.sval.type == T_FUNCTION) &&
03207 (CAAR(n)->u.sval.subtype == FUNCTION_BUILTIN) &&
03208 (CAAR(n)->u.sval.u.efun->function == f_not)) {
03209 if (!CDR(n)) {
03210 } else {
03211 if (CDR(n)->token == F_APPLY) {
03212 {
03213 if ((CADR(n) == CAAR(n))
03214 #ifdef SHARED_NODES_MK2
03215 || (CADR(n) && CAAR(n) &&
03216 ((CADR(n)->master?CADR(n)->master:CADR(n))==
03217 (CAAR(n)->master?CAAR(n)->master:CAAR(n))))
03218 #endif
03219 ) {
03220 #ifdef PIKE_DEBUG
03221 if (l_flag > 4) {
03222 fprintf(stderr, "Match: ""F_LOR{495}(F_APPLY{496}(0 = F_CONSTANT{497}[CAAR(n)->u.sval.type == T_FUNCTION][CAAR(n)->u.sval.subtype == FUNCTION_BUILTIN][CAAR(n)->u.sval.u.efun->function == f_not], 1 = *{498}), F_APPLY{499}($CAAR(n)$, 2 = *{500}))""\n");
03223 }
03224 #endif
03225 #ifdef PIKE_DEBUG
03226 if (l_flag > 4) {
03227 fprintf(stderr, "=> ""F_APPLY{501}""\n");
03228 }
03229 #endif
03230 {
03231 ADD_NODE_REF2(CAAR(n),
03232 ADD_NODE_REF2(CDAR(n),
03233 ADD_NODE_REF2(CDDR(n),
03234 tmp1 = mknode(F_APPLY, CAAR(n), mknode(F_LAND, CDAR(n), CDDR(n)));
03235 )));
03236 goto use_tmp1;
03237 }
03238 }
03239 }
03240 }
03241 }
03242 }
03243 }
03244 }
03245 } else if (CAR(n)->token == F_ASSIGN) {
03246 if (!CDAR(n)) {
03247 } else {
03248 if ((node_is_false(CDAR(n)))) {
03249 #ifdef PIKE_DEBUG
03250 if (l_flag > 4) {
03251 fprintf(stderr, "Match: ""F_LOR{516}(0 = F_ASSIGN{517}(*, +{519}[node_is_false(CDAR(n))]), 2 = *{520})""\n");
03252 }
03253 #endif
03254 #ifdef PIKE_DEBUG
03255 if (l_flag > 4) {
03256 fprintf(stderr, "=> ""F_COMMA_EXPR{521}""\n");
03257 }
03258 #endif
03259 {
03260 ADD_NODE_REF2(CAR(n),
03261 ADD_NODE_REF2(CDR(n),
03262 tmp1 = mknode(F_COMMA_EXPR, CAR(n), CDR(n));
03263 ));
03264 goto use_tmp1;
03265 }
03266 }
03267 if ((node_is_true(CDAR(n)))) {
03268 #ifdef PIKE_DEBUG
03269 if (l_flag > 4) {
03270 fprintf(stderr, "Match: ""F_LOR{534}(0 = F_ASSIGN{535}(*, +{537}[node_is_true(CDAR(n))]), *)""\n");
03271 }
03272 #endif
03273 #ifdef PIKE_DEBUG
03274 if (l_flag > 4) {
03275 fprintf(stderr, "=> ""0 = *{539}""\n");
03276 }
03277 #endif
03278 goto use_car;
03279 }
03280 }
03281 } else if (CAR(n)->token == F_COMMA_EXPR) {
03282 #ifdef PIKE_DEBUG
03283 if (l_flag > 4) {
03284 fprintf(stderr, "Match: ""F_LOR{524}(F_COMMA_EXPR{525}(0 = *{526}, 1 = *{527}), 2 = *{528})""\n");
03285 }
03286 #endif
03287 #ifdef PIKE_DEBUG
03288 if (l_flag > 4) {
03289 fprintf(stderr, "=> ""F_COMMA_EXPR{529}""\n");
03290 }
03291 #endif
03292 {
03293 ADD_NODE_REF2(CAAR(n),
03294 ADD_NODE_REF2(CDAR(n),
03295 ADD_NODE_REF2(CDR(n),
03296 tmp1 = mknode(F_COMMA_EXPR, CAAR(n), mknode(F_LOR, CDAR(n), CDR(n)));
03297 )));
03298 goto use_tmp1;
03299 }
03300 }
03301 if (CDR(n)->token == F_CONSTANT) {
03302 if ((node_is_false(CDR(n)))) {
03303 #ifdef PIKE_DEBUG
03304 if (l_flag > 4) {
03305 fprintf(stderr, "Match: ""F_LOR{540}(0 = *{541}, F_CONSTANT{542}[node_is_false(CDR(n))])""\n");
03306 }
03307 #endif
03308 #ifdef PIKE_DEBUG
03309 if (l_flag > 4) {
03310 fprintf(stderr, "=> ""0 = *{543}""\n");
03311 }
03312 #endif
03313 goto use_car;
03314 }
03315 } else if (CDR(n)->token == F_LOR) {
03316 #ifdef PIKE_DEBUG
03317 if (l_flag > 4) {
03318 fprintf(stderr, "Match: ""F_LOR{506}(0 = *{507}, F_LOR{508}(1 = *{509}, 2 = *{510}))""\n");
03319 }
03320 #endif
03321 #ifdef PIKE_DEBUG
03322 if (l_flag > 4) {
03323 fprintf(stderr, "=> ""F_LOR{511}""\n");
03324 }
03325 #endif
03326 {
03327 ADD_NODE_REF2(CAR(n),
03328 ADD_NODE_REF2(CADR(n),
03329 ADD_NODE_REF2(CDDR(n),
03330 tmp1 = mknode(F_LOR, mknode(F_LOR, CAR(n), CADR(n)), CDDR(n));
03331 )));
03332 goto use_tmp1;
03333 }
03334 }
03335 if ((node_is_false(CAR(n)))) {
03336 #ifdef PIKE_DEBUG
03337 if (l_flag > 4) {
03338 fprintf(stderr, "Match: ""F_LOR{544}(+{545}[node_is_false(CAR(n))], 0 = *{546})""\n");
03339 }
03340 #endif
03341 #ifdef PIKE_DEBUG
03342 if (l_flag > 4) {
03343 fprintf(stderr, "=> ""0 = *{547}""\n");
03344 }
03345 #endif
03346 goto use_cdr;
03347 }
03348 if ((node_is_true(CAR(n)))) {
03349 #ifdef PIKE_DEBUG
03350 if (l_flag > 4) {
03351 fprintf(stderr, "Match: ""F_LOR{548}(0 = +{549}[node_is_true(CAR(n))], *)""\n");
03352 }
03353 #endif
03354 #ifdef PIKE_DEBUG
03355 if (l_flag > 4) {
03356 fprintf(stderr, "=> ""0 = *{551}""\n");
03357 }
03358 #endif
03359 goto use_car;
03360 }
03361 }
03362 break;
03363
03364 case F_LVALUE_LIST:
03365 if (!CAR(n)) {
03366 #ifdef PIKE_DEBUG
03367 if (l_flag > 4) {
03368 fprintf(stderr, "Match: ""F_LVALUE_LIST{449}(-{450}, 0 = *{451})""\n");
03369 }
03370 #endif
03371 #ifdef PIKE_DEBUG
03372 if (l_flag > 4) {
03373 fprintf(stderr, "=> ""0 = *{452}""\n");
03374 }
03375 #endif
03376 goto use_cdr;
03377 } else if (!CDR(n)) {
03378 #ifdef PIKE_DEBUG
03379 if (l_flag > 4) {
03380 fprintf(stderr, "Match: ""F_LVALUE_LIST{453}(0 = *{454}, -{455})""\n");
03381 }
03382 #endif
03383 #ifdef PIKE_DEBUG
03384 if (l_flag > 4) {
03385 fprintf(stderr, "=> ""0 = *{456}""\n");
03386 }
03387 #endif
03388 goto use_car;
03389 } else {
03390 if (CAR(n)->token == F_BREAK) {
03391 if (!CDR(n)) {
03392 } else {
03393 if ((!(CDR(n)->tree_info & OPT_CASE))) {
03394 #ifdef PIKE_DEBUG
03395 if (l_flag > 4) {
03396 fprintf(stderr, "Match: ""F_LVALUE_LIST{465}(0 = F_BREAK{466}, +{467}[!(CDR(n)->tree_info & OPT_CASE)])""\n");
03397 }
03398 #endif
03399 #ifdef PIKE_DEBUG
03400 if (l_flag > 4) {
03401 fprintf(stderr, "=> ""0 = *{468}""\n");
03402 }
03403 #endif
03404 goto use_car;
03405 }
03406 }
03407 } else if (CAR(n)->token == F_COMMA_EXPR) {
03408 if (!CDAR(n)) {
03409 } else {
03410 if (CDAR(n)->token == F_BREAK) {
03411 if (!CDR(n)) {
03412 } else {
03413 if ((!(CDR(n)->tree_info & OPT_CASE))) {
03414 #ifdef PIKE_DEBUG
03415 if (l_flag > 4) {
03416 fprintf(stderr, "Match: ""F_LVALUE_LIST{481}(0 = F_COMMA_EXPR{482}(*, F_BREAK{484}), +{485}[!(CDR(n)->tree_info & OPT_CASE)])""\n");
03417 }
03418 #endif
03419 #ifdef PIKE_DEBUG
03420 if (l_flag > 4) {
03421 fprintf(stderr, "=> ""0 = *{486}""\n");
03422 }
03423 #endif
03424 goto use_car;
03425 }
03426 }
03427 } else if (CDAR(n)->token == F_CONTINUE) {
03428 if (!CDR(n)) {
03429 } else {
03430 if ((!(CDR(n)->tree_info & OPT_CASE))) {
03431 #ifdef PIKE_DEBUG
03432 if (l_flag > 4) {
03433 fprintf(stderr, "Match: ""F_LVALUE_LIST{475}(0 = F_COMMA_EXPR{476}(*, F_CONTINUE{478}), +{479}[!(CDR(n)->tree_info & OPT_CASE)])""\n");
03434 }
03435 #endif
03436 #ifdef PIKE_DEBUG
03437 if (l_flag > 4) {
03438 fprintf(stderr, "=> ""0 = *{480}""\n");
03439 }
03440 #endif
03441 goto use_car;
03442 }
03443 }
03444 } else if (CDAR(n)->token == F_RETURN) {
03445 if (!CDR(n)) {
03446 } else {
03447 if ((!(CDR(n)->tree_info & OPT_CASE))) {
03448 #ifdef PIKE_DEBUG
03449 if (l_flag > 4) {
03450 fprintf(stderr, "Match: ""F_LVALUE_LIST{469}(0 = F_COMMA_EXPR{470}(*, F_RETURN{472}), +{473}[!(CDR(n)->tree_info & OPT_CASE)])""\n");
03451 }
03452 #endif
03453 #ifdef PIKE_DEBUG
03454 if (l_flag > 4) {
03455 fprintf(stderr, "=> ""0 = *{474}""\n");
03456 }
03457 #endif
03458 goto use_car;
03459 }
03460 }
03461 }
03462 }
03463 } else if (CAR(n)->token == F_CONTINUE) {
03464 if (!CDR(n)) {
03465 } else {
03466 if ((!(CDR(n)->tree_info & OPT_CASE))) {
03467 #ifdef PIKE_DEBUG
03468 if (l_flag > 4) {
03469 fprintf(stderr, "Match: ""F_LVALUE_LIST{461}(0 = F_CONTINUE{462}, +{463}[!(CDR(n)->tree_info & OPT_CASE)])""\n");
03470 }
03471 #endif
03472 #ifdef PIKE_DEBUG
03473 if (l_flag > 4) {
03474 fprintf(stderr, "=> ""0 = *{464}""\n");
03475 }
03476 #endif
03477 goto use_car;
03478 }
03479 }
03480 } else if (CAR(n)->token == F_RETURN) {
03481 if (!CDR(n)) {
03482 } else {
03483 if ((!(CDR(n)->tree_info & OPT_CASE))) {
03484 #ifdef PIKE_DEBUG
03485 if (l_flag > 4) {
03486 fprintf(stderr, "Match: ""F_LVALUE_LIST{457}(0 = F_RETURN{458}, +{459}[!(CDR(n)->tree_info & OPT_CASE)])""\n");
03487 }
03488 #endif
03489 #ifdef PIKE_DEBUG
03490 if (l_flag > 4) {
03491 fprintf(stderr, "=> ""0 = *{460}""\n");
03492 }
03493 #endif
03494 goto use_car;
03495 }
03496 }
03497 }
03498 }
03499 break;
03500
03501 case F_NOT:
03502 if (!CAR(n)) {
03503 #ifdef PIKE_DEBUG
03504 if (l_flag > 4) {
03505 fprintf(stderr, "Match: ""F_NOT{712}(-{713}, *)""\n");
03506 }
03507 #endif
03508 #ifdef PIKE_DEBUG
03509 if (l_flag > 4) {
03510 fprintf(stderr, "=> ""1 = T_INT{715}""\n");
03511 }
03512 #endif
03513 {
03514 tmp1 = mkintnode(1);
03515 goto use_tmp1;
03516 }
03517 } else {
03518 if (CAR(n)->token == F_EQ) {
03519 #ifdef PIKE_DEBUG
03520 if (l_flag > 4) {
03521 fprintf(stderr, "Match: ""F_NOT{748}(F_EQ{749}(0 = *{750}, 1 = *{751}), *)""\n");
03522 }
03523 #endif
03524 #ifdef PIKE_DEBUG
03525 if (l_flag > 4) {
03526 fprintf(stderr, "=> ""F_NE{753}""\n");
03527 }
03528 #endif
03529 {
03530 ADD_NODE_REF2(CAAR(n),
03531 ADD_NODE_REF2(CDAR(n),
03532 tmp1 = mknode(F_NE, CAAR(n), CDAR(n));
03533 ));
03534 goto use_tmp1;
03535 }
03536 } else if (CAR(n)->token == F_GE) {
03537 if (!CAAR(n)) {
03538 } else {
03539 if ((pike_types_le(CAAR(n)->type, int_type_string))) {
03540 if (!CDAR(n)) {
03541 } else {
03542 if ((pike_types_le(CDAR(n)->type, int_type_string))) {
03543 #ifdef PIKE_DEBUG
03544 if (l_flag > 4) {
03545 fprintf(stderr, "Match: ""F_NOT{740}(F_GE{741}(0 = +{742}[pike_types_le(CAAR(n)->type, int_type_string)], 1 = +{743}[pike_types_le(CDAR(n)->type, int_type_string)]), *)""\n");
03546 }
03547 #endif
03548 #ifdef PIKE_DEBUG
03549 if (l_flag > 4) {
03550 fprintf(stderr, "=> ""F_LT{745}""\n");
03551 }
03552 #endif
03553 {
03554 ADD_NODE_REF2(CAAR(n),
03555 ADD_NODE_REF2(CDAR(n),
03556 tmp1 = mknode(F_LT, CAAR(n), CDAR(n));
03557 ));
03558 goto use_tmp1;
03559 }
03560 }
03561 }
03562 }
03563 }
03564 } else if (CAR(n)->token == F_GT) {
03565 if (!CAAR(n)) {
03566 } else {
03567 if ((pike_types_le(CAAR(n)->type, int_type_string))) {
03568 if (!CDAR(n)) {
03569 } else {
03570 if ((pike_types_le(CDAR(n)->type, int_type_string))) {
03571 #ifdef PIKE_DEBUG
03572 if (l_flag > 4) {
03573 fprintf(stderr, "Match: ""F_NOT{724}(F_GT{725}(0 = +{726}[pike_types_le(CAAR(n)->type, int_type_string)], 1 = +{727}[pike_types_le(CDAR(n)->type, int_type_string)]), *)""\n");
03574 }
03575 #endif
03576 #ifdef PIKE_DEBUG
03577 if (l_flag > 4) {
03578 fprintf(stderr, "=> ""F_LE{729}""\n");
03579 }
03580 #endif
03581 {
03582 ADD_NODE_REF2(CAAR(n),
03583 ADD_NODE_REF2(CDAR(n),
03584 tmp1 = mknode(F_LE, CAAR(n), CDAR(n));
03585 ));
03586 goto use_tmp1;
03587 }
03588 }
03589 }
03590 }
03591 }
03592 } else if (CAR(n)->token == F_LE) {
03593 if (!CAAR(n)) {
03594 } else {
03595 if ((pike_types_le(CAAR(n)->type, int_type_string))) {
03596 if (!CDAR(n)) {
03597 } else {
03598 if ((pike_types_le(CDAR(n)->type, int_type_string))) {
03599 #ifdef PIKE_DEBUG
03600 if (l_flag > 4) {
03601 fprintf(stderr, "Match: ""F_NOT{732}(F_LE{733}(0 = +{734}[pike_types_le(CAAR(n)->type, int_type_string)], 1 = +{735}[pike_types_le(CDAR(n)->type, int_type_string)]), *)""\n");
03602 }
03603 #endif
03604 #ifdef PIKE_DEBUG
03605 if (l_flag > 4) {
03606 fprintf(stderr, "=> ""F_GT{737}""\n");
03607 }
03608 #endif
03609 {
03610 ADD_NODE_REF2(CAAR(n),
03611 ADD_NODE_REF2(CDAR(n),
03612 tmp1 = mknode(F_GT, CAAR(n), CDAR(n));
03613 ));
03614 goto use_tmp1;
03615 }
03616 }
03617 }
03618 }
03619 }
03620 } else if (CAR(n)->token == F_LT) {
03621 if (!CAAR(n)) {
03622 } else {
03623 if ((pike_types_le(CAAR(n)->type, int_type_string))) {
03624 if (!CDAR(n)) {
03625 } else {
03626 if ((pike_types_le(CDAR(n)->type, int_type_string))) {
03627 #ifdef PIKE_DEBUG
03628 if (l_flag > 4) {
03629 fprintf(stderr, "Match: ""F_NOT{716}(F_LT{717}(0 = +{718}[pike_types_le(CAAR(n)->type, int_type_string)], 1 = +{719}[pike_types_le(CDAR(n)->type, int_type_string)]), *)""\n");
03630 }
03631 #endif
03632 #ifdef PIKE_DEBUG
03633 if (l_flag > 4) {
03634 fprintf(stderr, "=> ""F_GE{721}""\n");
03635 }
03636 #endif
03637 {
03638 ADD_NODE_REF2(CAAR(n),
03639 ADD_NODE_REF2(CDAR(n),
03640 tmp1 = mknode(F_GE, CAAR(n), CDAR(n));
03641 ));
03642 goto use_tmp1;
03643 }
03644 }
03645 }
03646 }
03647 }
03648 } else if (CAR(n)->token == F_NE) {
03649 #ifdef PIKE_DEBUG
03650 if (l_flag > 4) {
03651 fprintf(stderr, "Match: ""F_NOT{756}(F_NE{757}(0 = *{758}, 1 = *{759}), *)""\n");
03652 }
03653 #endif
03654 #ifdef PIKE_DEBUG
03655 if (l_flag > 4) {
03656 fprintf(stderr, "=> ""F_EQ{761}""\n");
03657 }
03658 #endif
03659 {
03660 ADD_NODE_REF2(CAAR(n),
03661 ADD_NODE_REF2(CDAR(n),
03662 tmp1 = mknode(F_EQ, CAAR(n), CDAR(n));
03663 ));
03664 goto use_tmp1;
03665 }
03666 }
03667 }
03668 break;
03669
03670 case F_POP_VALUE:
03671 if (!CAR(n)) {
03672 #ifdef PIKE_DEBUG
03673 if (l_flag > 4) {
03674 fprintf(stderr, "Match: ""F_POP_VALUE{77}(-{78}, *)""\n");
03675 }
03676 #endif
03677 #ifdef PIKE_DEBUG
03678 if (l_flag > 4) {
03679 fprintf(stderr, "=> ""-{80}""\n");
03680 }
03681 #endif
03682 goto zap_node;
03683 } else {
03684 if (CAR(n)->token == '?') {
03685 if (!CDAR(n)) {
03686 } else {
03687 if (CDAR(n)->token == ':') {
03688 #ifdef PIKE_DEBUG
03689 if (l_flag > 4) {
03690 fprintf(stderr, "Match: ""F_POP_VALUE{169}('?'{170}(0 = *{171}, ':'{172}(1 = *{173}, 2 = *{174})), *)""\n");
03691 }
03692 #endif
03693 #ifdef PIKE_DEBUG
03694 if (l_flag > 4) {
03695 fprintf(stderr, "=> ""'?'{176}""\n");
03696 }
03697 #endif
03698 {
03699 ADD_NODE_REF2(CAAR(n),
03700 ADD_NODE_REF2(CADAR(n),
03701 ADD_NODE_REF2(CDDAR(n),
03702 tmp1 = mknode('?', CAAR(n), mknode(':', mknode(F_POP_VALUE, CADAR(n), 0), mknode(F_POP_VALUE, CDDAR(n), 0)));
03703 )));
03704 goto use_tmp1;
03705 }
03706 }
03707 }
03708 } else if (CAR(n)->token == F_BREAK) {
03709 #ifdef PIKE_DEBUG
03710 if (l_flag > 4) {
03711 fprintf(stderr, "Match: ""F_POP_VALUE{121}(0 = F_BREAK{122}, *)""\n");
03712 }
03713 #endif
03714 #ifdef PIKE_DEBUG
03715 if (l_flag > 4) {
03716 fprintf(stderr, "=> ""0 = *{124}""\n");
03717 }
03718 #endif
03719 goto use_car;
03720 } else if (CAR(n)->token == F_CASE) {
03721 #ifdef PIKE_DEBUG
03722 if (l_flag > 4) {
03723 fprintf(stderr, "Match: ""F_POP_VALUE{125}(0 = F_CASE{126}, *)""\n");
03724 }
03725 #endif
03726 #ifdef PIKE_DEBUG
03727 if (l_flag > 4) {
03728 fprintf(stderr, "=> ""0 = *{128}""\n");
03729 }
03730 #endif
03731 goto use_car;
03732 } else if (CAR(n)->token == F_CASE_RANGE) {
03733 #ifdef PIKE_DEBUG
03734 if (l_flag > 4) {
03735 fprintf(stderr, "Match: ""F_POP_VALUE{129}(0 = F_CASE_RANGE{130}, *)""\n");
03736 }
03737 #endif
03738 #ifdef PIKE_DEBUG
03739 if (l_flag > 4) {
03740 fprintf(stderr, "=> ""0 = *{132}""\n");
03741 }
03742 #endif
03743 goto use_car;
03744 } else if (CAR(n)->token == F_CAST) {
03745 if ((!(CAR(n)->node_info & OPT_SIDE_EFFECT))) {
03746 #ifdef PIKE_DEBUG
03747 if (l_flag > 4) {
03748 fprintf(stderr, "Match: ""F_POP_VALUE{85}(F_CAST{86}[!(CAR(n)->node_info & OPT_SIDE_EFFECT)](0 = *{87}, *), *)""\n");
03749 }
03750 #endif
03751 #ifdef PIKE_DEBUG
03752 if (l_flag > 4) {
03753 fprintf(stderr, "=> ""F_POP_VALUE{90}""\n");
03754 }
03755 #endif
03756 {
03757 ADD_NODE_REF2(CAAR(n),
03758 tmp1 = mknode(F_POP_VALUE, CAAR(n), 0);
03759 );
03760 goto use_tmp1;
03761 }
03762 }
03763 } else if (CAR(n)->token == F_CONSTANT) {
03764 #ifdef PIKE_DEBUG
03765 if (l_flag > 4) {
03766 fprintf(stderr, "Match: ""F_POP_VALUE{93}(F_CONSTANT{94}, *)""\n");
03767 }
03768 #endif
03769 #ifdef PIKE_DEBUG
03770 if (l_flag > 4) {
03771 fprintf(stderr, "=> ""-{96}""\n");
03772 }
03773 #endif
03774 goto zap_node;
03775 } else if (CAR(n)->token == F_CONTINUE) {
03776 #ifdef PIKE_DEBUG
03777 if (l_flag > 4) {
03778 fprintf(stderr, "Match: ""F_POP_VALUE{117}(0 = F_CONTINUE{118}, *)""\n");
03779 }
03780 #endif
03781 #ifdef PIKE_DEBUG
03782 if (l_flag > 4) {
03783 fprintf(stderr, "=> ""0 = *{120}""\n");
03784 }
03785 #endif
03786 goto use_car;
03787 } else if (CAR(n)->token == F_DEC_LOOP) {
03788 #ifdef PIKE_DEBUG
03789 if (l_flag > 4) {
03790 fprintf(stderr, "Match: ""F_POP_VALUE{149}(0 = F_DEC_LOOP{150}, *)""\n");
03791 }
03792 #endif
03793 #ifdef PIKE_DEBUG
03794 if (l_flag > 4) {
03795 fprintf(stderr, "=> ""0 = *{152}""\n");
03796 }
03797 #endif
03798 goto use_car;
03799 } else if (CAR(n)->token == F_DEC_NEQ_LOOP) {
03800 #ifdef PIKE_DEBUG
03801 if (l_flag > 4) {
03802 fprintf(stderr, "Match: ""F_POP_VALUE{157}(0 = F_DEC_NEQ_LOOP{158}, *)""\n");
03803 }
03804 #endif
03805 #ifdef PIKE_DEBUG
03806 if (l_flag > 4) {
03807 fprintf(stderr, "=> ""0 = *{160}""\n");
03808 }
03809 #endif
03810 goto use_car;
03811 } else if (CAR(n)->token == F_DEFAULT) {
03812 #ifdef PIKE_DEBUG
03813 if (l_flag > 4) {
03814 fprintf(stderr, "Match: ""F_POP_VALUE{133}(0 = F_DEFAULT{134}, *)""\n");
03815 }
03816 #endif
03817 #ifdef PIKE_DEBUG
03818 if (l_flag > 4) {
03819 fprintf(stderr, "=> ""0 = *{136}""\n");
03820 }
03821 #endif
03822 goto use_car;
03823 } else if (CAR(n)->token == F_EXTERNAL) {
03824 #ifdef PIKE_DEBUG
03825 if (l_flag > 4) {
03826 fprintf(stderr, "Match: ""F_POP_VALUE{109}(F_EXTERNAL{110}, *)""\n");
03827 }
03828 #endif
03829 #ifdef PIKE_DEBUG
03830 if (l_flag > 4) {
03831 fprintf(stderr, "=> ""-{112}""\n");
03832 }
03833 #endif
03834 goto zap_node;
03835 } else if (CAR(n)->token == F_FOR) {
03836 #ifdef PIKE_DEBUG
03837 if (l_flag > 4) {
03838 fprintf(stderr, "Match: ""F_POP_VALUE{137}(0 = F_FOR{138}, *)""\n");
03839 }
03840 #endif
03841 #ifdef PIKE_DEBUG
03842 if (l_flag > 4) {
03843 fprintf(stderr, "=> ""0 = *{140}""\n");
03844 }
03845 #endif
03846 goto use_car;
03847 } else if (CAR(n)->token == F_FOREACH) {
03848 #ifdef PIKE_DEBUG
03849 if (l_flag > 4) {
03850 fprintf(stderr, "Match: ""F_POP_VALUE{141}(0 = F_FOREACH{142}, *)""\n");
03851 }
03852 #endif
03853 #ifdef PIKE_DEBUG
03854 if (l_flag > 4) {
03855 fprintf(stderr, "=> ""0 = *{144}""\n");
03856 }
03857 #endif
03858 goto use_car;
03859 } else if (CAR(n)->token == F_GLOBAL) {
03860 #ifdef PIKE_DEBUG
03861 if (l_flag > 4) {
03862 fprintf(stderr, "Match: ""F_POP_VALUE{105}(F_GLOBAL{106}, *)""\n");
03863 }
03864 #endif
03865 #ifdef PIKE_DEBUG
03866 if (l_flag > 4) {
03867 fprintf(stderr, "=> ""-{108}""\n");
03868 }
03869 #endif
03870 goto zap_node;
03871 } else if (CAR(n)->token == F_INC_LOOP) {
03872 #ifdef PIKE_DEBUG
03873 if (l_flag > 4) {
03874 fprintf(stderr, "Match: ""F_POP_VALUE{145}(0 = F_INC_LOOP{146}, *)""\n");
03875 }
03876 #endif
03877 #ifdef PIKE_DEBUG
03878 if (l_flag > 4) {
03879 fprintf(stderr, "=> ""0 = *{148}""\n");
03880 }
03881 #endif
03882 goto use_car;
03883 } else if (CAR(n)->token == F_INC_NEQ_LOOP) {
03884 #ifdef PIKE_DEBUG
03885 if (l_flag > 4) {
03886 fprintf(stderr, "Match: ""F_POP_VALUE{153}(0 = F_INC_NEQ_LOOP{154}, *)""\n");
03887 }
03888 #endif
03889 #ifdef PIKE_DEBUG
03890 if (l_flag > 4) {
03891 fprintf(stderr, "=> ""0 = *{156}""\n");
03892 }
03893 #endif
03894 goto use_car;
03895 } else if (CAR(n)->token == F_LOCAL) {
03896 #ifdef PIKE_DEBUG
03897 if (l_flag > 4) {
03898 fprintf(stderr, "Match: ""F_POP_VALUE{101}(F_LOCAL{102}, *)""\n");
03899 }
03900 #endif
03901 #ifdef PIKE_DEBUG
03902 if (l_flag > 4) {
03903 fprintf(stderr, "=> ""-{104}""\n");
03904 }
03905 #endif
03906 goto zap_node;
03907 } else if (CAR(n)->token == F_LOOP) {
03908 #ifdef PIKE_DEBUG
03909 if (l_flag > 4) {
03910 fprintf(stderr, "Match: ""F_POP_VALUE{161}(0 = F_LOOP{162}, *)""\n");
03911 }
03912 #endif
03913 #ifdef PIKE_DEBUG
03914 if (l_flag > 4) {
03915 fprintf(stderr, "=> ""0 = *{164}""\n");
03916 }
03917 #endif
03918 goto use_car;
03919 } else if (CAR(n)->token == F_POP_VALUE) {
03920 #ifdef PIKE_DEBUG
03921 if (l_flag > 4) {
03922 fprintf(stderr, "Match: ""F_POP_VALUE{81}(0 = F_POP_VALUE{82}, *)""\n");
03923 }
03924 #endif
03925 #ifdef PIKE_DEBUG
03926 if (l_flag > 4) {
03927 fprintf(stderr, "=> ""0 = *{84}""\n");
03928 }
03929 #endif
03930 goto use_car;
03931 } else if (CAR(n)->token == F_RETURN) {
03932 #ifdef PIKE_DEBUG
03933 if (l_flag > 4) {
03934 fprintf(stderr, "Match: ""F_POP_VALUE{113}(0 = F_RETURN{114}, *)""\n");
03935 }
03936 #endif
03937 #ifdef PIKE_DEBUG
03938 if (l_flag > 4) {
03939 fprintf(stderr, "=> ""0 = *{116}""\n");
03940 }
03941 #endif
03942 goto use_car;
03943 } else if (CAR(n)->token == F_SWITCH) {
03944 #ifdef PIKE_DEBUG
03945 if (l_flag > 4) {
03946 fprintf(stderr, "Match: ""F_POP_VALUE{165}(0 = F_SWITCH{166}, *)""\n");
03947 }
03948 #endif
03949 #ifdef PIKE_DEBUG
03950 if (l_flag > 4) {
03951 fprintf(stderr, "=> ""0 = *{168}""\n");
03952 }
03953 #endif
03954 goto use_car;
03955 }
03956 if ((node_is_tossable(CAR(n)))) {
03957 #ifdef PIKE_DEBUG
03958 if (l_flag > 4) {
03959 fprintf(stderr, "Match: ""F_POP_VALUE{97}(+{98}[node_is_tossable(CAR(n))], *)""\n");
03960 }
03961 #endif
03962 #ifdef PIKE_DEBUG
03963 if (l_flag > 4) {
03964 fprintf(stderr, "=> ""-{100}""\n");
03965 }
03966 #endif
03967 goto zap_node;
03968 }
03969 }
03970 break;
03971
03972 case F_PUSH_ARRAY:
03973 if (!CAR(n)) {
03974 } else {
03975 if (CAR(n)->token == F_APPLY) {
03976 if (!CAAR(n)) {
03977 } else {
03978 if (CAAR(n)->token == F_CONSTANT) {
03979 if ((CAAR(n)->u.sval.type == T_FUNCTION) &&
03980 (CAAR(n)->u.sval.subtype == FUNCTION_BUILTIN) &&
03981 (CAAR(n)->u.sval.u.efun->function == debug_f_aggregate)) {
03982 #ifdef PIKE_DEBUG
03983 if (l_flag > 4) {
03984 fprintf(stderr, "Match: ""F_PUSH_ARRAY{20}(F_APPLY{21}(F_CONSTANT{22}[CAAR(n)->u.sval.type == T_FUNCTION][CAAR(n)->u.sval.subtype == FUNCTION_BUILTIN][CAAR(n)->u.sval.u.efun->function == debug_f_aggregate], 0 = *{23}), *)""\n");
03985 }
03986 #endif
03987 #ifdef PIKE_DEBUG
03988 if (l_flag > 4) {
03989 fprintf(stderr, "=> ""0 = *{25}""\n");
03990 }
03991 #endif
03992 {
03993 ADD_NODE_REF2(CDAR(n),
03994 tmp1 = CDAR(n);
03995 );
03996 goto use_tmp1;
03997 }
03998 }
03999 }
04000 }
04001 } else if (CAR(n)->token == F_CONSTANT) {
04002 if ((CAR(n)->u.sval.type == T_ARRAY)) {
04003 #ifdef PIKE_DEBUG
04004 if (l_flag > 4) {
04005 fprintf(stderr, "Match: ""F_PUSH_ARRAY{26}(0 = F_CONSTANT{27}[CAR(n)->u.sval.type == T_ARRAY], *)""\n");
04006 }
04007 #endif
04008 {
04009 struct array *a = CAR(n)->u.sval.u.array;
04010 node *n = NULL;
04011 int i;
04012 for(i=0; i<a->size; i++) {
04013 if (n) {
04014 n = mknode(F_ARG_LIST, n, mksvaluenode(a->item+i));
04015 } else {
04016
04017 n = mksvaluenode(a->item);
04018 }
04019 }
04020
04021 tmp1 = n;
04022 goto use_tmp1;
04023 }
04024 }
04025 }
04026 }
04027 break;
04028
04029 case F_RANGE:
04030 if (!CDR(n)) {
04031 } else {
04032 if (CDR(n)->token == ':') {
04033 if (!CDDR(n)) {
04034 } else {
04035 if (CDDR(n)->token == F_RANGE_FROM_BEG) {
04036 if (!CADDR(n)) {
04037 } else {
04038 if (CADDR(n)->token == F_CONSTANT) {
04039 if ((CADDR(n)->u.sval.type == T_FLOAT) &&
04040 (CADDR(n)->u.sval.u.float_number < 0.0)) {
04041 #ifdef PIKE_DEBUG
04042 if (l_flag > 4) {
04043 fprintf(stderr, "Match: ""F_RANGE{211}(*, ':'{213}(*, F_RANGE_FROM_BEG{215}(F_CONSTANT{216}[CADDR(n)->u.sval.type == T_FLOAT][CADDR(n)->u.sval.u.float_number < 0.0], *)))""\n");
04044 }
04045 #endif
04046 {
04047 yywarning("Range end is negative.");
04048 }
04049 }
04050 if ((CADDR(n)->u.sval.type == T_INT) &&
04051 (CADDR(n)->u.sval.u.integer < 0)) {
04052 #ifdef PIKE_DEBUG
04053 if (l_flag > 4) {
04054 fprintf(stderr, "Match: ""F_RANGE{204}(*, ':'{206}(*, F_RANGE_FROM_BEG{208}(F_CONSTANT{209}[CADDR(n)->u.sval.type == T_INT][CADDR(n)->u.sval.u.integer < 0], *)))""\n");
04055 }
04056 #endif
04057 {
04058 yywarning("Range end is negative.");
04059 }
04060 }
04061 }
04062 }
04063 }
04064 }
04065 }
04066 }
04067 break;
04068
04069 case F_RETURN:
04070 if (!CAR(n)) {
04071 #ifdef PIKE_DEBUG
04072 if (l_flag > 4) {
04073 fprintf(stderr, "Match: ""F_RETURN{14}(-{15}, *)""\n");
04074 }
04075 #endif
04076 #ifdef PIKE_DEBUG
04077 if (l_flag > 4) {
04078 fprintf(stderr, "=> ""F_RETURN{17}""\n");
04079 }
04080 #endif
04081 {
04082 tmp1 = mknode(F_RETURN, mkintnode(0), 0);
04083 goto use_tmp1;
04084 }
04085 }
04086 break;
04087
04088 case F_SUB_EQ:
04089 if (!CAR(n)) {
04090 } else if (!CDR(n)) {
04091 } else {
04092 if (CDR(n)->token == F_CONSTANT) {
04093 if ((CDR(n)->u.sval.type == T_INT) &&
04094 ((CDR(n)->u.sval.u.integer) == -1)) {
04095 #ifdef PIKE_DEBUG
04096 if (l_flag > 4) {
04097 fprintf(stderr, "Match: ""F_SUB_EQ{790}(0 = *{791}, 1 = F_CONSTANT{792}[CDR(n)->u.sval.type == T_INT][(CDR(n)->u.sval.u.integer) == -1])""\n");
04098 }
04099 #endif
04100 #ifdef PIKE_DEBUG
04101 if (l_flag > 4) {
04102 fprintf(stderr, "=> ""F_INC{793}""\n");
04103 }
04104 #endif
04105 {
04106 ADD_NODE_REF2(CAR(n),
04107 tmp1 = mknode(F_INC, CAR(n), 0);
04108 );
04109 goto use_tmp1;
04110 }
04111 }
04112 if ((CDR(n)->u.sval.type == T_INT) &&
04113 ((CDR(n)->u.sval.u.integer) == 1)) {
04114 #ifdef PIKE_DEBUG
04115 if (l_flag > 4) {
04116 fprintf(stderr, "Match: ""F_SUB_EQ{784}(0 = *{785}, 1 = F_CONSTANT{786}[CDR(n)->u.sval.type == T_INT][(CDR(n)->u.sval.u.integer) == 1])""\n");
04117 }
04118 #endif
04119 #ifdef PIKE_DEBUG
04120 if (l_flag > 4) {
04121 fprintf(stderr, "=> ""F_DEC{787}""\n");
04122 }
04123 #endif
04124 {
04125 ADD_NODE_REF2(CAR(n),
04126 tmp1 = mknode(F_DEC, CAR(n), 0);
04127 );
04128 goto use_tmp1;
04129 }
04130 }
04131 }
04132 if (( CAR(n)->token != F_AUTO_MAP_MARKER )) {
04133 if (!CDR(n)) {
04134 } else {
04135 if (CDR(n)->token == F_CONSTANT) {
04136 if ((CDR(n)->u.sval.type == T_INT) &&
04137 (!(CDR(n)->u.sval.u.integer))) {
04138 #ifdef PIKE_DEBUG
04139 if (l_flag > 4) {
04140 fprintf(stderr, "Match: ""F_SUB_EQ{780}(0 = +{781}[ CAR(n)->token != F_AUTO_MAP_MARKER ], 1 = F_CONSTANT{782}[CDR(n)->u.sval.type == T_INT][!(CDR(n)->u.sval.u.integer)])""\n");
04141 }
04142 #endif
04143 #ifdef PIKE_DEBUG
04144 if (l_flag > 4) {
04145 fprintf(stderr, "=> ""0 = *{783}""\n");
04146 }
04147 #endif
04148 goto use_car;
04149 }
04150 }
04151 }
04152 }
04153 }
04154 break;
04155
