Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed

  • src/Common/PassVisitor.impl.h

    ra8a2b0a ra16764a6  
    22772277}
    22782278
    2279 //--------------------------------------------------------------------------
    2280 // TupleType
     2279
    22812280template< typename pass_type >
    22822281void PassVisitor< pass_type >::visit( TupleType * node ) {
    2283         VISIT_START( node );
    2284 
    2285         maybeAccept_impl( node->forall, *this );
    2286         maybeAccept_impl( node->types, *this );
    2287         maybeAccept_impl( node->members, *this );
    2288 
    2289         VISIT_END( node );
    2290 }
     2282        VISIT_BODY( node );
     2283}
     2284
     2285template< typename pass_type >
     2286void PassVisitor< pass_type >::visit( TypeofType * node ) {
     2287        VISIT_BODY( node );
     2288}
     2289
     2290template< typename pass_type >
     2291void PassVisitor< pass_type >::visit( AttrType * node ) {
     2292        VISIT_BODY( node );
     2293}
     2294
     2295template< typename pass_type >
     2296void PassVisitor< pass_type >::visit( VarArgsType * node ) {
     2297        VISIT_BODY( node );
     2298}
     2299
     2300template< typename pass_type >
     2301void PassVisitor< pass_type >::visit( ZeroType * node ) {
     2302        VISIT_BODY( node );
     2303}
     2304
     2305template< typename pass_type >
     2306void PassVisitor< pass_type >::visit( OneType * node ) {
     2307        VISIT_BODY( node );
     2308}
     2309
     2310template< typename pass_type >
     2311void PassVisitor< pass_type >::visit( Designation * node ) {
     2312        VISIT_START( node );
     2313
     2314        maybeAccept_impl( node->get_designators(), *this );
     2315
     2316        VISIT_END( node );
     2317}
     2318
     2319template< typename pass_type >
     2320Designation * PassVisitor< pass_type >::mutate( Designation * node ) {
     2321        MUTATE_START( node );
     2322
     2323        maybeMutate_impl( node->get_designators(), *this );
     2324
     2325        MUTATE_END( Designation, node );
     2326}
     2327
     2328//--------------------------------------------------------------------------
     2329// SingleInit
     2330template< typename pass_type >
     2331void PassVisitor< pass_type >::visit( SingleInit * node ) {
     2332        VISIT_START( node );
     2333
     2334        visitExpression( node->get_value() );
     2335
     2336        VISIT_END( node );
     2337}
     2338
     2339template< typename pass_type >
     2340Initializer * PassVisitor< pass_type >::mutate( SingleInit * node ) {
     2341        MUTATE_START( node );
     2342
     2343        node->set_value( mutateExpression( node->get_value() ) );
     2344
     2345        MUTATE_END( Initializer, node );
     2346}
     2347
     2348template< typename pass_type >
     2349void PassVisitor< pass_type >::visit( ListInit * node ) {
     2350        VISIT_BODY( node );
     2351}
     2352
     2353template< typename pass_type >
     2354void PassVisitor< pass_type >::visit( ConstructorInit * node ) {
     2355        VISIT_BODY( node );
     2356}
     2357
     2358template< typename pass_type >
     2359void PassVisitor< pass_type >::visit( Subrange * node ) {
     2360        VISIT_BODY( node );
     2361}
     2362
     2363template< typename pass_type >
     2364void PassVisitor< pass_type >::visit( Constant * node ) {
     2365        VISIT_BODY( node );
     2366}
     2367
     2368template< typename pass_type >
     2369void PassVisitor< pass_type >::visit( Attribute * node ) {
     2370        VISIT_BODY( node );
     2371}
     2372
     2373//---------------------------------------------------------------------------------------------------------------
    22912374
    22922375template< typename pass_type >
    22932376Type * PassVisitor< pass_type >::mutate( TupleType * node ) {
    2294         MUTATE_START( node );
    2295 
    2296         maybeMutate_impl( node->forall, *this );
    2297         maybeMutate_impl( node->types, *this );
    2298         maybeMutate_impl( node->members, *this );
    2299 
    2300         MUTATE_END( Type, node );
    2301 }
    2302 
    2303 //--------------------------------------------------------------------------
    2304 // TypeofType
    2305 template< typename pass_type >
    2306 void PassVisitor< pass_type >::visit( TypeofType * node ) {
    2307         VISIT_START( node );
    2308 
    2309         assert( node->expr );
    2310         maybeAccept_impl( node->expr, *this );
    2311 
    2312         VISIT_END( node );
     2377        MUTATE_BODY( Type, node );
    23132378}
    23142379
    23152380template< typename pass_type >
    23162381Type * PassVisitor< pass_type >::mutate( TypeofType * node ) {
    2317         MUTATE_START( node );
    2318 
    2319         assert( node->expr );
    2320         maybeMutate_impl( node->expr, *this );
    2321 
    2322         MUTATE_END( Type, node );
    2323 }
    2324 
    2325 //--------------------------------------------------------------------------
    2326 // AttrType
    2327 template< typename pass_type >
    2328 void PassVisitor< pass_type >::visit( AttrType * node ) {
    2329         VISIT_START( node );
    2330 
    2331         if ( node->isType ) {
    2332                 assert( node->type );
    2333                 maybeAccept_impl( node->type, *this );
    2334         } else {
    2335                 assert( node->expr );
    2336                 maybeAccept_impl( node->expr, *this );
    2337         } // if
    2338 
    2339         VISIT_END( node );
     2382        MUTATE_BODY( Type, node );
    23402383}
    23412384
    23422385template< typename pass_type >
    23432386Type * PassVisitor< pass_type >::mutate( AttrType * node ) {
    2344         MUTATE_START( node );
    2345 
    2346         if ( node->isType ) {
    2347                 assert( node->type );
    2348                 maybeMutate_impl( node->type, *this );
    2349         } else {
    2350                 assert( node->expr );
    2351                 maybeMutate_impl( node->expr, *this );
    2352         } // if
    2353 
    2354         MUTATE_END( Type, node );
    2355 }
    2356 
    2357 //--------------------------------------------------------------------------
    2358 // VarArgsType
    2359 template< typename pass_type >
    2360 void PassVisitor< pass_type >::visit( VarArgsType * node ) {
    2361         VISIT_START( node );
    2362 
    2363         maybeAccept_impl( node->forall, *this );
    2364 
    2365         VISIT_END( node );
     2387        MUTATE_BODY( Type, node );
    23662388}
    23672389
    23682390template< typename pass_type >
    23692391Type * PassVisitor< pass_type >::mutate( VarArgsType * node ) {
    2370         MUTATE_START( node );
    2371 
    2372         maybeMutate_impl( node->forall, *this );
    2373 
    2374         MUTATE_END( Type, node );
    2375 }
    2376 
    2377 //--------------------------------------------------------------------------
    2378 // ZeroType
    2379 template< typename pass_type >
    2380 void PassVisitor< pass_type >::visit( ZeroType * node ) {
    2381         VISIT_START( node );
    2382 
    2383         maybeAccept_impl( node->forall, *this );
    2384 
    2385         VISIT_END( node );
     2392        MUTATE_BODY( Type, node );
    23862393}
    23872394
    23882395template< typename pass_type >
    23892396Type * PassVisitor< pass_type >::mutate( ZeroType * node ) {
    2390         MUTATE_START( node );
    2391 
    2392         maybeMutate_impl( node->forall, *this );
    2393 
    2394         MUTATE_END( Type, node );
    2395 }
    2396 
    2397 //--------------------------------------------------------------------------
    2398 // OneType
    2399 template< typename pass_type >
    2400 void PassVisitor< pass_type >::visit( OneType * node ) {
    2401         VISIT_START( node );
    2402 
    2403         maybeAccept_impl( node->forall, *this );
    2404 
    2405         VISIT_END( node );
     2397        MUTATE_BODY( Type, node );
    24062398}
    24072399
    24082400template< typename pass_type >
    24092401Type * PassVisitor< pass_type >::mutate( OneType * node ) {
    2410         MUTATE_START( node );
    2411 
    2412         maybeMutate_impl( node->forall, *this );
    2413 
    2414         MUTATE_END( Type, node );
    2415 }
    2416 
    2417 //--------------------------------------------------------------------------
    2418 // Designation
    2419 template< typename pass_type >
    2420 void PassVisitor< pass_type >::visit( Designation * node ) {
    2421         VISIT_START( node );
    2422 
    2423         maybeAccept_impl( node->designators, *this );
    2424 
    2425         VISIT_END( node );
    2426 }
    2427 
    2428 template< typename pass_type >
    2429 Designation * PassVisitor< pass_type >::mutate( Designation * node ) {
    2430         MUTATE_START( node );
    2431 
    2432         maybeMutate_impl( node->designators, *this );
    2433 
    2434         MUTATE_END( Designation, node );
    2435 }
    2436 
    2437 //--------------------------------------------------------------------------
    2438 // SingleInit
    2439 template< typename pass_type >
    2440 void PassVisitor< pass_type >::visit( SingleInit * node ) {
    2441         VISIT_START( node );
    2442 
    2443         visitExpression( node->value );
    2444 
    2445         VISIT_END( node );
    2446 }
    2447 
    2448 template< typename pass_type >
    2449 Initializer * PassVisitor< pass_type >::mutate( SingleInit * node ) {
    2450         MUTATE_START( node );
    2451 
    2452         node->value = mutateExpression( node->value );
    2453 
    2454         MUTATE_END( Initializer, node );
    2455 }
    2456 
    2457 //--------------------------------------------------------------------------
    2458 // ListInit
    2459 template< typename pass_type >
    2460 void PassVisitor< pass_type >::visit( ListInit * node ) {
    2461         VISIT_START( node );
    2462 
    2463         maybeAccept_impl( node->designations, *this );
    2464         maybeAccept_impl( node->initializers, *this );
    2465 
    2466         VISIT_END( node );
     2402        MUTATE_BODY( Type, node );
    24672403}
    24682404
    24692405template< typename pass_type >
    24702406Initializer * PassVisitor< pass_type >::mutate( ListInit * node ) {
    2471         MUTATE_START( node );
    2472 
    2473         maybeMutate_impl( node->designations, *this );
    2474         maybeMutate_impl( node->initializers, *this );
    2475 
    2476         MUTATE_END( Initializer, node );
    2477 }
    2478 
    2479 //--------------------------------------------------------------------------
    2480 // ConstructorInit
    2481 template< typename pass_type >
    2482 void PassVisitor< pass_type >::visit( ConstructorInit * node ) {
    2483         VISIT_START( node );
    2484 
    2485         maybeAccept_impl( node->ctor, *this );
    2486         maybeAccept_impl( node->dtor, *this );
    2487         maybeAccept_impl( node->init, *this );
    2488 
    2489         VISIT_END( node );
     2407        MUTATE_BODY( Initializer, node );
    24902408}
    24912409
    24922410template< typename pass_type >
    24932411Initializer * PassVisitor< pass_type >::mutate( ConstructorInit * node ) {
    2494         MUTATE_START( node );
    2495 
    2496         maybeMutate_impl( node->ctor, *this );
    2497         maybeMutate_impl( node->dtor, *this );
    2498         maybeMutate_impl( node->init, *this );
    2499 
    2500         MUTATE_END( Initializer, node );
    2501 }
    2502 
    2503 //--------------------------------------------------------------------------
    2504 // Subrange
    2505 template< typename pass_type >
    2506 void PassVisitor< pass_type >::visit( Subrange * node ) {
    2507         VISIT_START( node );
    2508 
    2509         VISIT_END( node );
     2412        MUTATE_BODY( Initializer, node );
    25102413}
    25112414
    25122415template< typename pass_type >
    25132416Subrange * PassVisitor< pass_type >::mutate( Subrange * node  )  {
    2514         MUTATE_START( node );
    2515 
    2516         MUTATE_END( Subrange, node );
    2517 }
    2518 
    2519 //--------------------------------------------------------------------------
    2520 // Attribute
    2521 template< typename pass_type >
    2522 void PassVisitor< pass_type >::visit( Constant * node ) {
    2523         VISIT_START( node );
    2524 
    2525         VISIT_END( node );
     2417        MUTATE_BODY( Subrange, node );
    25262418}
    25272419
    25282420template< typename pass_type >
    25292421Constant * PassVisitor< pass_type >::mutate( Constant * node  )  {
    2530         MUTATE_START( node );
    2531 
    2532         MUTATE_END( Constant, node );
    2533 }
    2534 
    2535 //--------------------------------------------------------------------------
    2536 // Attribute
    2537 template< typename pass_type >
    2538 void PassVisitor< pass_type >::visit( Attribute * node ) {
    2539         VISIT_START( node );
    2540 
    2541         maybeAccept_impl( node->parameters, *this );
    2542 
    2543         VISIT_END( node );
     2422        MUTATE_BODY( Constant, node );
    25442423}
    25452424
    25462425template< typename pass_type >
    25472426Attribute * PassVisitor< pass_type >::mutate( Attribute * node  )  {
    2548         MUTATE_START( node );
    2549 
    2550         maybeMutate_impl( node->parameters, *this );
    2551 
    2552         MUTATE_END( Attribute, node );
    2553 }
    2554 
    2555 //--------------------------------------------------------------------------
    2556 // TypeSubstitution
     2427        MUTATE_BODY( Attribute, node );
     2428}
     2429
    25572430template< typename pass_type >
    25582431TypeSubstitution * PassVisitor< pass_type >::mutate( TypeSubstitution * node ) {
Note: See TracChangeset for help on using the changeset viewer.