doc/8.0.new-in-1.2

   1
   2 new stuff in lwc 1.2
   3 ====================
   4
   5
   6 0. Changed '(operator)' to '->operator'
   7 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   8
   9 See 4.2.operator-overloading.
  10 This should only interest people who have already written lwc code
  11 using the old syntax.
  12
  13
  14 1. Destruction through stack unwind
  15 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  16
  17   This is achieved with the introduction of a new declaration specifier (and
  18 also a reserved word), '__unwind__'. Presented in 3.2.exceptions
  19
  20
  21 2. Pure non-virtuals
  22 ~~~~~~~~~~~~~~~~~~~~
  23
  24   Useful as a hint to auto-functions to emit no code. Presented in
  25 3.1.auto-functions
  26
  27
  28 3. Long break and continue
  29 ~~~~~~~~~~~~~~~~~~~~~~~~~~
  30
  31   break and continue may be followed by a small integer number. This number
  32 denotes how many loop bodies will the control break out of.  For example:
  33
  34         int f ()
  35         {
  36                 for (;;)
  37                         for (;;)
  38                                 break 2;
  39         }
  40
  41 will break out of both loops and has *almost* the same effect as:
  42
  43         int f ()
  44         {
  45                 for (;;)
  46                         for (;;)
  47                                 goto out;
  48         out:
  49         }
  50
  51
  52 It's not that we hate 'goto'.  On the contrary; many lwc developers feel
  53 that goto is a wonderful thing.  The problem is that the lwc preprocessor
  54 does not work around goto and destruction of local objects.
  55 Long break and long continue will make sure that all the nested local
  56 objects will be properly destructed.
  57
  58 That can be seen in:
  59
  60         class A { ~A(){} };
  61
  62         int f ()
  63         {
  64                 A a1;
  65                 for (;;) {
  66                         A a2;
  67                         for (;;) {
  68                                 A a3;
  69                                 if (1) {
  70                                         A a4;
  71                                         break 2;
  72                                 }
  73                         }
  74                 }
  75         }
  76
  77 4. Calling parent's functions
  78 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  79
  80   Since lwc doesn't have C++'s scope operator (::), we used casts to call
  81 specific functions from parent classes.  This worked but it had a lot of
  82 typing.  Now it's possible to use the syntax 'class.func()'.  For example:
  83
  84         class A {
  85                 A () {}
  86                 int i;
  87         };
  88
  89         class B {
  90                 B () {}
  91                 int j;
  92         };
  93
  94         class C : A, B {
  95                 C () {
  96                         A.ctor ();
  97                         B.ctor ();
  98                 }
  99         };
 100
 101 This only happens inside other member functions, for classes that are parent
 102 and only for functions.
 103
 104 5. Modular data members
 105 ~~~~~~~~~~~~~~~~~~~~~~~
 106
 107   Data class members declared 'modular' are exactly the same as C++'s
 108 'static' data members: they are global data in reallity.  This is just a
 109 decorative feature but it completes the 'modular functions' feature.
 110 For example:
 111
 112         class A {
 113         modular int I;
 114         };
 115
 116         int main ()
 117         {
 118                 A.I = 0;
 119                 A a;
 120                 a.I;    // same as A.I
 121         }
 122
 123 Moreover, if the 'modular' precedes the declaration of a class it is
 124 not only applied for member functions, but for data members as well.
 125 Therefore, we can have something like namespaces:
 126
 127         #define namespace modular class
 128
 129         namespace FOO {
 130                 int I;
 131                 int f ();
 132         };
 133
 134         int FOO.f ()
 135         {
 136                 return I++;
 137         }
 138
 139         int main ()
 140         {
 141                 FOO.I = 0;
 142         }
 143
 144 A more extreme example:
 145
 146         #define namespace modular class
 147
 148         namespace ZOO
 149         {
 150                 int X [100];
 151                 int &operator [] (int i)        { return X [2*i]; }
 152         } ZOO;
 153
 154         int main ()
 155         {
 156                 ZOO [20] = ZOO [30];
 157         }
 158
 159 And countless other combinations...