ev++.h

   1 /*
   2  * libev simple C++ wrapper classes
   3  *
   4  * Copyright (c) 2007 Marc Alexander Lehmann <libev@schmorp.de>
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without modifica-
   8  * tion, are permitted provided that the following conditions are met:
   9  *
  10  *   1.  Redistributions of source code must retain the above copyright notice,
  11  *       this list of conditions and the following disclaimer.
  12  *
  13  *   2.  Redistributions in binary form must reproduce the above copyright
  14  *       notice, this list of conditions and the following disclaimer in the
  15  *       documentation and/or other materials provided with the distribution.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
  18  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MER-
  19  * CHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO
  20  * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPE-
  21  * CIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  22  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  23  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  24  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTH-
  25  * ERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
  26  * OF THE POSSIBILITY OF SUCH DAMAGE.
  27  *
  28  * Alternatively, the contents of this file may be used under the terms of
  29  * the GNU General Public License ("GPL") version 2 or any later version,
  30  * in which case the provisions of the GPL are applicable instead of
  31  * the above. If you wish to allow the use of your version of this file
  32  * only under the terms of the GPL and not to allow others to use your
  33  * version of this file under the BSD license, indicate your decision
  34  * by deleting the provisions above and replace them with the notice
  35  * and other provisions required by the GPL. If you do not delete the
  36  * provisions above, a recipient may use your version of this file under
  37  * either the BSD or the GPL.
  38  */
  39
  40 #ifndef EVPP_H__
  41 #define EVPP_H__
  42
  43 #ifdef EV_H
  44 # include EV_H
  45 #else
  46 # include "ev.h"
  47 #endif
  48
  49 #ifndef EV_USE_STDEXCEPT
  50 # define EV_USE_STDEXCEPT 1
  51 #endif
  52
  53 #if EV_USE_STDEXCEPT
  54 # include <stdexcept>
  55 #endif
  56
  57 namespace ev {
  58
  59   typedef ev_tstamp tstamp;
  60
  61   enum {
  62     UNDEF    = EV_UNDEF,
  63     NONE     = EV_NONE,
  64     READ     = EV_READ,
  65     WRITE    = EV_WRITE,
  66     TIMEOUT  = EV_TIMEOUT,
  67     PERIODIC = EV_PERIODIC,
  68     SIGNAL   = EV_SIGNAL,
  69     CHILD    = EV_CHILD,
  70     STAT     = EV_STAT,
  71     IDLE     = EV_IDLE,
  72     CHECK    = EV_CHECK,
  73     PREPARE  = EV_PREPARE,
  74     FORK     = EV_FORK,
  75     EMBED    = EV_EMBED,
  76     ERROR    = EV_ERROR,
  77   };
  78
  79   enum
  80   {
  81     AUTO = EVFLAG_AUTO,
  82     NOENV = EVFLAG_NOENV,
  83     FORKCHECK = EVFLAG_FORKCHECK,
  84     SELECT = EVBACKEND_SELECT,
  85     POLL = EVBACKEND_POLL,
  86     EPOLL = EVBACKEND_EPOLL,
  87     KQUEUE = EVBACKEND_KQUEUE,
  88     DEVPOLL = EVBACKEND_DEVPOLL,
  89     PORT = EVBACKEND_PORT
  90   };
  91
  92   enum
  93   {
  94     NONBLOCK = EVLOOP_NONBLOCK,
  95     ONESHOT = EVLOOP_ONESHOT
  96   };
  97
  98   enum how_t
  99   {
 100     ONE = EVUNLOOP_ONE,
 101     ALL = EVUNLOOP_ALL
 102   };
 103
 104   struct bad_loop
 105 #if EV_USE_STDEXCEPT
 106   : std::runtime_error
 107 #endif
 108   {
 109 #if EV_USE_STDEXCEPT
 110     bad_loop ()
 111     : std::runtime_error ("libev event loop cannot be initialized, bad value of LIBEV_FLAGS?")
 112     {
 113     }
 114 #endif
 115   };
 116
 117 #ifdef EV_AX
 118 #  undef EV_AX
 119 #endif
 120
 121 #ifdef EV_AX_
 122 #  undef EV_AX_
 123 #endif
 124
 125 #if EV_MULTIPLICITY
 126 #  define EV_AX  raw_loop
 127 #  define EV_AX_ raw_loop,
 128 #else
 129 #  define EV_AX
 130 #  define EV_AX_
 131 #endif
 132
 133   struct loop_ref
 134   {
 135
 136     loop_ref (EV_P) throw (bad_loop)
 137 #if EV_MULTIPLICITY
 138     : EV_AX (EV_A)
 139 #endif
 140     {
 141 #if EV_MULTIPLICITY
 142       if (!EV_AX)
 143         throw bad_loop ();
 144 #endif
 145     }
 146
 147     bool operator == (const loop_ref &other) const throw ()
 148     {
 149 #if EV_MULTIPLICITY
 150       return EV_AX == other.EV_AX;
 151 #else
 152       return true;
 153 #endif
 154     }
 155
 156     bool operator != (const loop_ref &other) const throw ()
 157     {
 158 #if EV_MULTIPLICITY
 159       return ! (*this == other);
 160 #else
 161       return false;
 162 #endif
 163     }
 164
 165 #if EV_MULTIPLICITY
 166     bool operator== (struct ev_loop *other) const throw ()
 167     {
 168       return this->EV_AX == other;
 169     }
 170
 171     bool operator!= (struct ev_loop *other) const throw ()
 172     {
 173       return ! (*this == other);
 174     }
 175
 176     bool operator== (const struct ev_loop *other) const throw ()
 177     {
 178       return this->EV_AX == other;
 179     }
 180
 181     bool operator!= (const struct ev_loop *other) const throw ()
 182     {
 183       return (*this == other);
 184     }
 185
 186     operator struct ev_loop * () const throw ()
 187     {
 188       return EV_AX;
 189     }
 190
 191     operator const struct ev_loop * () const throw ()
 192     {
 193       return EV_AX;
 194     }
 195
 196     bool is_default () const throw ()
 197     {
 198       return EV_AX == ev_default_loop (0);
 199     }
 200 #endif
 201
 202     void loop (int flags = 0)
 203     {
 204       ev_loop (EV_AX_ flags);
 205     }
 206
 207     void unloop (how_t how = ONE) throw ()
 208     {
 209       ev_unloop (EV_AX_ how);
 210     }
 211
 212     void post_fork () throw ()
 213     {
 214 #if EV_MULTIPLICITY
 215       ev_loop_fork (EV_AX);
 216 #else
 217       ev_default_fork ();
 218 #endif
 219     }
 220
 221     unsigned int count () const throw ()
 222     {
 223       return ev_loop_count (EV_AX);
 224     }
 225
 226     unsigned int backend () const throw ()
 227     {
 228       return ev_backend (EV_AX);
 229     }
 230
 231     tstamp now () const throw ()
 232     {
 233       return ev_now (EV_AX);
 234     }
 235
 236     void ref () throw ()
 237     {
 238       ev_ref (EV_AX);
 239     }
 240
 241     void unref () throw ()
 242     {
 243       ev_unref (EV_AX);
 244     }
 245
 246     void set_io_collect_interval (tstamp interval) throw ()
 247     {
 248       ev_set_io_collect_interval (EV_AX_ interval);
 249     }
 250
 251     void set_timeout_collect_interval (tstamp interval) throw ()
 252     {
 253       ev_set_timeout_collect_interval (EV_AX_ interval);
 254     }
 255
 256     // function callback
 257     void once (int fd, int events, tstamp timeout, void (*cb)(int, void *), void* arg = 0) throw ()
 258     {
 259       ev_once (EV_AX_ fd, events, timeout, cb, arg);
 260     }
 261
 262     // method callback
 263     template<class K, void (K::*method)(int)>
 264     void once (int fd, int events, tstamp timeout, K *object) throw ()
 265     {
 266       once (fd, events, timeout, method_thunk<K, method>, object);
 267     }
 268
 269     template<class K, void (K::*method)(int)>
 270     static void method_thunk (int revents, void* arg)
 271     {
 272       K *obj = static_cast<K *>(arg);
 273       (obj->*method) (revents);
 274     }
 275
 276     // const method callback
 277     template<class K, void (K::*method)(int) const>
 278     void once (int fd, int events, tstamp timeout, const K *object) throw ()
 279     {
 280       once (fd, events, timeout, const_method_thunk<K, method>, object);
 281     }
 282
 283     template<class K, void (K::*method)(int) const>
 284     static void const_method_thunk (int revents, void* arg)
 285     {
 286       K *obj = static_cast<K *>(arg);
 287       (obj->*method) (revents);
 288     }
 289
 290     // simple method callback
 291     template<class K, void (K::*method)()>
 292     void once (int fd, int events, tstamp timeout, K *object) throw ()
 293     {
 294       once (fd, events, timeout, method_noargs_thunk<K, method>, object);
 295     }
 296
 297     template<class K, void (K::*method)()>
 298     static void method_noargs_thunk (int revents, void* arg)
 299     {
 300       K *obj = static_cast<K *>(arg);
 301       (obj->*method) ();
 302     }
 303
 304     // simpler function callback
 305     template<void (*cb)(int)>
 306     void once (int fd, int events, tstamp timeout) throw ()
 307     {
 308       once (fd, events, timeout, simpler_func_thunk<cb>);
 309     }
 310
 311     template<void (*cb)(int)>
 312     static void simpler_func_thunk (int revents, void* arg)
 313     {
 314       (*cb) (revents);
 315     }
 316
 317     // simplest function callback
 318     template<void (*cb)()>
 319     void once (int fd, int events, tstamp timeout) throw ()
 320     {
 321       once (fd, events, timeout, simplest_func_thunk<cb>);
 322     }
 323
 324     template<void (*cb)()>
 325     static void simplest_func_thunk (int revents, void* arg)
 326     {
 327       (*cb) ();
 328     }
 329
 330     void feed_fd_event (int fd, int revents) throw ()
 331     {
 332       ev_feed_fd_event (EV_AX_ fd, revents);
 333     }
 334
 335     void feed_signal_event (int signum) throw ()
 336     {
 337       ev_feed_signal_event (EV_AX_ signum);
 338     }
 339
 340 #if EV_MULTIPLICITY
 341     struct ev_loop* EV_AX;
 342 #endif
 343
 344   };
 345
 346 #if EV_MULTIPLICITY
 347   struct dynamic_loop: loop_ref
 348   {
 349
 350     dynamic_loop (unsigned int flags = AUTO) EV_THROW (bad_loop)
 351       : loop_ref (ev_loop_new (flags))
 352     {
 353     }
 354
 355     ~dynamic_loop () throw ()
 356     {
 357       ev_loop_destroy (EV_AX);
 358       EV_AX = 0;
 359     }
 360
 361   private:
 362
 363     dynamic_loop (const dynamic_loop &);
 364
 365     dynamic_loop & operator= (const dynamic_loop &);
 366
 367   };
 368 #endif
 369
 370   struct default_loop: loop_ref
 371   {
 372
 373     default_loop (unsigned int flags = AUTO) throw (bad_loop)
 374 #if EV_MULTIPLICITY
 375     : loop_ref (ev_default_loop (flags))
 376 #endif
 377     {
 378 #ifndef EV_MULTIPLICITY
 379     if (!ev_default_loop (flags))
 380       throw bad_loop ();
 381 #endif
 382     }
 383
 384     ~default_loop () throw ()
 385     {
 386       ev_default_destroy ();
 387     }
 388
 389   private:
 390     default_loop (const default_loop &);
 391     default_loop &operator = (const default_loop &);
 392   };
 393
 394   inline loop_ref get_default_loop () throw ()
 395   {
 396 #if EV_MULTIPLICITY
 397     return ev_default_loop (0);
 398 #else
 399     return loop_ref ();
 400 #endif
 401   }
 402
 403 #undef EV_AX
 404 #undef EV_AX_
 405
 406 #undef EV_PX
 407 #undef EV_PX_
 408 #if EV_MULTIPLICITY
 409 #  define EV_PX  loop_ref EV_A
 410 #  define EV_PX_ loop_ref EV_A_
 411 #else
 412 #  define EV_PX
 413 #  define EV_PX_
 414 #endif
 415
 416   template<class ev_watcher, class watcher>
 417   struct base : ev_watcher
 418   {
 419     #if EV_MULTIPLICITY
 420       EV_PX;
 421
 422       void set (EV_PX) throw ()
 423       {
 424         this->EV_A = EV_A;
 425       }
 426     #endif
 427
 428     base (EV_PX) throw ()
 429     #if EV_MULTIPLICITY
 430       : EV_A (EV_A)
 431     #endif
 432     {
 433       ev_init (this, 0);
 434     }
 435
 436     void set_ (void *data, void (*cb)(EV_P_ ev_watcher *w, int revents)) throw ()
 437     {
 438       this->data = data;
 439       ev_set_cb (static_cast<ev_watcher *>(this), cb);
 440     }
 441
 442     // method callback
 443     template<class K, void (K::*method)(watcher &w, int)>
 444     void set (K *object) throw ()
 445     {
 446       set_ (object, method_thunk<K, method>);
 447     }
 448
 449     template<class K, void (K::*method)(watcher &w, int)>
 450     static void method_thunk (EV_P_ ev_watcher *w, int revents)
 451     {
 452       K *obj = static_cast<K *>(w->data);
 453       (obj->*method) (*static_cast<watcher *>(w), revents);
 454     }
 455
 456     // const method callback
 457     template<class K, void (K::*method)(watcher &w, int) const>
 458     void set (const K *object) throw ()
 459     {
 460       set_ (object, const_method_thunk<K, method>);
 461     }
 462
 463     template<class K, void (K::*method)(watcher &w, int) const>
 464     static void const_method_thunk (EV_P_ ev_watcher *w, int revents)
 465     {
 466       K *obj = static_cast<K *>(w->data);
 467       (static_cast<K *>(w->data)->*method) (*static_cast<watcher *>(w), revents);
 468     }
 469
 470     // function callback
 471     template<void (*function)(watcher &w, int)>
 472     void set (void *data = 0) throw ()
 473     {
 474       set_ (data, function_thunk<function>);
 475     }
 476
 477     template<void (*function)(watcher &w, int)>
 478     static void function_thunk (EV_P_ ev_watcher *w, int revents)
 479     {
 480       function (*static_cast<watcher *>(w), revents);
 481     }
 482
 483     // simple callback
 484     template<class K, void (K::*method)()>
 485     void set (K *object) throw ()
 486     {
 487       set_ (object, method_noargs_thunk<K, method>);
 488     }
 489
 490     template<class K, void (K::*method)()>
 491     static void method_noargs_thunk (EV_P_ ev_watcher *w, int revents)
 492     {
 493       K *obj = static_cast<K *>(w->data);
 494       (obj->*method) ();
 495     }
 496
 497     void operator ()(int events = EV_UNDEF)
 498     {
 499       return ev_cb (static_cast<ev_watcher *>(this))
 500         (static_cast<ev_watcher *>(this), events);
 501     }
 502
 503     bool is_active () const throw ()
 504     {
 505       return ev_is_active (static_cast<const ev_watcher *>(this));
 506     }
 507
 508     bool is_pending () const throw ()
 509     {
 510       return ev_is_pending (static_cast<const ev_watcher *>(this));
 511     }
 512
 513     void feed_event (int revents) throw ()
 514     {
 515       ev_feed_event (EV_A_ static_cast<const ev_watcher *>(this), revents);
 516     }
 517   };
 518
 519   inline tstamp now () throw ()
 520   {
 521     return ev_time ();
 522   }
 523
 524   inline void delay (tstamp interval) throw ()
 525   {
 526     ev_sleep (interval);
 527   }
 528
 529   inline int version_major () throw ()
 530   {
 531     return ev_version_major ();
 532   }
 533
 534   inline int version_minor () throw ()
 535   {
 536     return ev_version_minor ();
 537   }
 538
 539   inline unsigned int supported_backends () throw ()
 540   {
 541     return ev_supported_backends ();
 542   }
 543
 544   inline unsigned int recommended_backends () throw ()
 545   {
 546     return ev_recommended_backends ();
 547   }
 548
 549   inline unsigned int embeddable_backends () throw ()
 550   {
 551     return ev_embeddable_backends ();
 552   }
 553
 554   inline void set_allocator (void *(*cb)(void *ptr, long size)) throw ()
 555   {
 556     ev_set_allocator (cb);
 557   }
 558
 559   inline void set_syserr_cb (void (*cb)(const char *msg)) throw ()
 560   {
 561     ev_set_syserr_cb (cb);
 562   }
 563
 564   #if EV_MULTIPLICITY
 565     #define EV_CONSTRUCT(cppstem,cstem)                                                 \
 566       (EV_PX = get_default_loop ()) throw ()                                         \
 567         : base<ev_ ## cstem, cppstem> (EV_A)                                            \
 568       {                                                                                 \
 569       }
 570   #else
 571     #define EV_CONSTRUCT(cppstem,cstem)                                                 \
 572       () throw ()                                                                    \
 573       {                                                                                 \
 574       }
 575   #endif
 576
 577   /* using a template here would require quite a bit more lines,
 578    * so a macro solution was chosen */
 579   #define EV_BEGIN_WATCHER(cppstem,cstem)                                               \
 580                                                                                         \
 581   struct cppstem : base<ev_ ## cstem, cppstem>                                          \
 582   {                                                                                     \
 583     void start () throw ()                                                           \
 584     {                                                                                   \
 585       ev_ ## cstem ## _start (EV_A_ static_cast<ev_ ## cstem *>(this));                 \
 586     }                                                                                   \
 587                                                                                         \
 588     void stop () throw ()                                                            \
 589     {                                                                                   \
 590       ev_ ## cstem ## _stop (EV_A_ static_cast<ev_ ## cstem *>(this));                  \
 591     }                                                                                   \
 592                                                                                         \
 593     cppstem EV_CONSTRUCT(cppstem,cstem)                                                 \
 594                                                                                         \
 595     ~cppstem () throw ()                                                             \
 596     {                                                                                   \
 597       stop ();                                                                          \
 598     }                                                                                   \
 599                                                                                         \
 600     using base<ev_ ## cstem, cppstem>::set;                                             \
 601                                                                                         \
 602   private:                                                                              \
 603                                                                                         \
 604     cppstem (const cppstem &o);                                                         \
 605                                                                                         \
 606     cppstem & operator =(const cppstem &o);                                             \
 607                                                                                         \
 608   public:
 609
 610   #define EV_END_WATCHER(cppstem,cstem)                                                 \
 611   };
 612
 613   EV_BEGIN_WATCHER (io, io)
 614     void set (int fd, int events) throw ()
 615     {
 616       int active = is_active ();
 617       if (active) stop ();
 618       ev_io_set (static_cast<ev_io *>(this), fd, events);
 619       if (active) start ();
 620     }
 621
 622     void set (int events) throw ()
 623     {
 624       int active = is_active ();
 625       if (active) stop ();
 626       ev_io_set (static_cast<ev_io *>(this), fd, events);
 627       if (active) start ();
 628     }
 629
 630     void start (int fd, int events) throw ()
 631     {
 632       set (fd, events);
 633       start ();
 634     }
 635   EV_END_WATCHER (io, io)
 636
 637   EV_BEGIN_WATCHER (timer, timer)
 638     void set (ev_tstamp after, ev_tstamp repeat = 0.) throw ()
 639     {
 640       int active = is_active ();
 641       if (active) stop ();
 642       ev_timer_set (static_cast<ev_timer *>(this), after, repeat);
 643       if (active) start ();
 644     }
 645
 646     void start (ev_tstamp after, ev_tstamp repeat = 0.) throw ()
 647     {
 648       set (after, repeat);
 649       start ();
 650     }
 651
 652     void again () throw ()
 653     {
 654       ev_timer_again (EV_A_ static_cast<ev_timer *>(this));
 655     }
 656   EV_END_WATCHER (timer, timer)
 657
 658   #if EV_PERIODIC_ENABLE
 659   EV_BEGIN_WATCHER (periodic, periodic)
 660     void set (ev_tstamp at, ev_tstamp interval = 0.) throw ()
 661     {
 662       int active = is_active ();
 663       if (active) stop ();
 664       ev_periodic_set (static_cast<ev_periodic *>(this), at, interval, 0);
 665       if (active) start ();
 666     }
 667
 668     void start (ev_tstamp at, ev_tstamp interval = 0.) throw ()
 669     {
 670       set (at, interval);
 671       start ();
 672     }
 673
 674     void again () throw ()
 675     {
 676       ev_periodic_again (EV_A_ static_cast<ev_periodic *>(this));
 677     }
 678   EV_END_WATCHER (periodic, periodic)
 679   #endif
 680
 681   EV_BEGIN_WATCHER (sig, signal)
 682     void set (int signum) throw ()
 683     {
 684       int active = is_active ();
 685       if (active) stop ();
 686       ev_signal_set (static_cast<ev_signal *>(this), signum);
 687       if (active) start ();
 688     }
 689
 690     void start (int signum) throw ()
 691     {
 692       set (signum);
 693       start ();
 694     }
 695   EV_END_WATCHER (sig, signal)
 696
 697   EV_BEGIN_WATCHER (child, child)
 698     void set (int pid) throw ()
 699     {
 700       int active = is_active ();
 701       if (active) stop ();
 702       ev_child_set (static_cast<ev_child *>(this), pid);
 703       if (active) start ();
 704     }
 705
 706     void start (int pid) throw ()
 707     {
 708       set (pid);
 709       start ();
 710     }
 711   EV_END_WATCHER (child, child)
 712
 713   #if EV_STAT_ENABLE
 714   EV_BEGIN_WATCHER (stat, stat)
 715     void set (const char *path, ev_tstamp interval = 0.) throw ()
 716     {
 717       int active = is_active ();
 718       if (active) stop ();
 719       ev_stat_set (static_cast<ev_stat *>(this), path, interval);
 720       if (active) start ();
 721     }
 722
 723     void start (const char *path, ev_tstamp interval = 0.) throw ()
 724     {
 725       stop ();
 726       set (path, interval);
 727       start ();
 728     }
 729
 730     void update () throw ()
 731     {
 732       ev_stat_stat (EV_A_ static_cast<ev_stat *>(this));
 733     }
 734   EV_END_WATCHER (stat, stat)
 735   #endif
 736
 737   EV_BEGIN_WATCHER (idle, idle)
 738     void set () throw () { }
 739   EV_END_WATCHER (idle, idle)
 740
 741   EV_BEGIN_WATCHER (prepare, prepare)
 742     void set () throw () { }
 743   EV_END_WATCHER (prepare, prepare)
 744
 745   EV_BEGIN_WATCHER (check, check)
 746     void set () throw () { }
 747   EV_END_WATCHER (check, check)
 748
 749   #if EV_EMBED_ENABLE
 750   EV_BEGIN_WATCHER (embed, embed)
 751     void start (struct ev_loop *embedded_loop) throw ()
 752     {
 753       stop ();
 754       ev_embed_set (static_cast<ev_embed *>(this), embedded_loop);
 755       start ();
 756     }
 757
 758     void sweep ()
 759     {
 760       ev_embed_sweep (EV_A_ static_cast<ev_embed *>(this));
 761     }
 762   EV_END_WATCHER (embed, embed)
 763   #endif
 764
 765   #if EV_FORK_ENABLE
 766   EV_BEGIN_WATCHER (fork, fork)
 767     void set () throw () { }
 768   EV_END_WATCHER (fork, fork)
 769   #endif
 770
 771   #undef EV_PX
 772   #undef EV_PX_
 773   #undef EV_CONSTRUCT
 774   #undef EV_BEGIN_WATCHER
 775   #undef EV_END_WATCHER
 776
 777 }
 778
 779 #undef EV_THROW
 780
 781 #endif
 782