The Liana Programming Language

Liana is both an object-oriented programming language and a development system for creating Windows applications. As a programming language, it strongly resembles C++, except Liana's syntax is smaller and less restrictive. Like C++, Liana uses classes and member functions to provide encapsulation, inheritance, and polymorphism. Unlike C++, Liana uses no pointers, offers automatic memory cleanup and typeless variables, and lacks multiple inheritance (which some might consider a feature).

As a development tool, Liana leans in the direction of interactive integrated systems such as Asymetrix Toolbook, Microsoft Visual Basic, or Digitalk Smalltalk/V for Windows. Like these systems, Liana provides a great deal of support for creating event-driven programs for the Windows environment. However, the current release of Liana is much less visual than these environments, relying solely on ASCII source files created with a text editor and compiled from the command line. Still, this compile-and-link cycle is relatively fast, painless, and can be easily done from a DOS window in the Windows environment. One benefit of the reliance on text files is that all program components are easily visible, unlike systems such as Visual Basic or Toolbook (the initial versions), in which programs consist partly of visible code fragments and partly of "invisible" data structures created by point-and-click means.

Liana 1.0 was released by Base Technology (Boulder, Colorado) for the Windows 3.0 environment in 1991. Liana 1.0 also runs on Windows 3.1. At this writing, Version 2.0 of Liana (in beta) adds numerous small enhancements to the language as well as providing an integrated-development environment (IDE) similar to those in many programming languages; the Liana IDE allows you to compile and link via a window/menu/buttonbar interface rather than from the command line. Base Technology has also demonstrated a 32-bit version of Liana for Windows NT. However, unless explicitly stated, this article refers only to the current release of Liana.

The principal design goal of Liana is to simplify and accelerate the process of writing Windows applications--especially those that are single-person in size or small in scale. Like Toolbook, Visual Basic, and Smalltalk/V, Liana works at a level of abstraction much higher than programming the raw Windows API with C or C++. The Liana system includes an application framework that packs in a goodly amount of built-in functionality. Consequently, many of the package's example programs are "one-liners" that concisely illustrate a particular subject. For example, the Liana version of the classic "hello world" program C programmers have used since time immemorial is main { (new window ("Hello world")).show; }.

While Liana does allow you to use the traditional printf("Hello world") instead of the intriguing statement above, the one-liner illustrates some of Liana's interesting aspects. The line of code completely defines the main function of a Liana program. It's similar to main() in a C/C++ program, except that, in Liana, functions without arguments don't need to be followed by an empty argument list. The function body that follows the function name consists of braces containing a single statement. This statement is a nested expression; the inner term invokes the new operator to create an instance of class window. The constructor call has one argument, which is the window title. The constructor returns an object reference which happens not to be stored anywhere, although it could have been assigned to a variable. Rather, the show() member function of this anonymous object is invoked. Because show() has no arguments, its empty argument list is omitted. If you understood all the jargon in this paragraph, then you've been reading too many C++ articles!) Happily, programming in Liana can be accomplished without much of the tedious baggage thrown onto the shoulders of C++ programmers. For example, the one-line program does not require a delete to match the call to new. Likewise, variables don't have to be explicitly declared, but are instantiated by using them in a statement. These become global in scope. Variables in Liana can be declared as one of the built-in types (int, real, string, Boolean, array, or Windows memory block), user-defined types (objects), or the generic type, any.

You may wonder what happened to main in this Liana one-liner, paint { w << "Hello world"; }. If you omit main, Liana invokes a default version of main which creates (and shows) an instance of class window and by default sets the global variable w to refer to it. As in C++, the left-shift operator (<<) is overloaded to provide printf-like output capability to the window object. In the case of this program, output occurs when the main application window needs repainting, via an automatic call to paint. The paint function is one of various callback functions Liana automatically invokes whenever an interesting event happens in the Windows environment.

Examples of interesting events include mouse click, mouse up, keystroke, window close, window paint, timer, and so on. These correspond to standard messages in Windows such as WM_LBUTTONDOWN, WM_MOUSEMOVE, WM_KEY, WM_CLOSE, WM_PAINT, WM_TIMER, and the like. The Liana language and its built-in application framework shield you from most of this "Windows grunge" (to use a Seattle-area term). In fact, the documentation doesn't mention any of the WM_* messages (although perhaps it should).

The one-line program position(x,y) { w.home; w << x << "," << y << " ";} consists of a callback function that's automatically invoked whenever the mouse moves. The function "homes" the cursor to the upper left of the main window, then displays the current x and y coordinates of the mouse.

Although Liana keeps you from getting mired in grunge--both the Windows and C++ flavors of it--you still have to deal with the essential concepts of event-driven programming and object-oriented structures. What's cool is that you can forget about the non-essential concepts: registering a window class, creating a window, exporting a WndProc in a .DEF file, writing #defines for an .RC file, making sure you dealt with the issue of whether SS equals DS, and so on. Likewise, you don't need to deal with similar C++ grunge, such as matching every new with a delete. However, at some point in using Liana, you'll likely have to declare a class and define its member functions--but not at the very start. If you were using a C++ framework such as OWL or MFC, there'd be many pages of documentation to absorb before you could begin to write code. Tools such as App-Wizard in Microsoft's Visual C++ package do help, but AppWizard can only be used once, at the very start. AppWizard is like getting a healthy push on a bike journey down a steep mountain road--you still have to navigate the sharp curves of C++ and MFC.

The freedom from mundane details that Liana provides can be exhilarating; but as you might expect, there's a price to pay for this freedom, mostly having to do with performance and scalability. In many cases, this will be worth it.

startdrag (x1, y1, x2, y2)
{
    w.line (old_x1 = x1, old_y1 = y1, old_x2 = x2, old_y2 = y2);
}
drag (x, y)
{
    w.xor = true;
    w.line (old_x1, old_y1, old_x2,     old_y2    );   // Erase prev line
    w.line (old_x1, old_y1, old_x2 = x, old_y2 = y);   // Draw  new  line
    w.xor = false;
}

startdrag (x1, y1, x2, y2)
{
    w.line (old_x1 = x1, old_y1 = y1, old_x2 = x2, old_y2 = y2);
}
drag (x, y)
{
    w.xor = true;
    w.line (old_x1, old_y1, old_x2, old_y2);          // Erase prev line
    w.line (old_x1, old_y1, old_x2 = x, old_y2 = y);  // Draw  new  line
    w.xor = false;
}
enddrag (x, y)
{
    if (! lines) lines = new array;
    lines << new line (old_x1, old_y1, old_x2, old_y2);
}
paint
{
    for (int i = 0; lines && i < lines.size; i++)
              lines [i].draw (w);
}

main { window();  w.status_line_enabled = true; }
position (x,y)  { w.status = x+","+y+"       "; }

class  MyList : array
{
     Print
     {
          for (int i = 0, int n = size; i < n; i++)
                if ((any e = this [i]).isa ("MyList"))
                  e.Print();
                else
                  cout << e.class_name+": "+e.text+"\n";
     }
};
//-------------------------------------------
void main (void)
{
        MyList  list1 =   new   MyList;
        MyList  list2 =   new   MyList;
        int     n1 =      10;
        int     n2 =      20;
        point   p1 =      new   point (2,3);
        point   p2 =      new   point (4,5);
        /* build the lists */
        list1 << n1 << n2 << p1;
        /* an obj can be in more than one lst at same time */
        list2 << n2 << p1 << p2;
        list2 << list1; /* we can even put a list into another list  */
        /* print the lists */
        cout << "\nLIST1:\n";    list1.Print;
        cout << "\nLIST2:\n";    list2.Print;
}

<a name="02c2_000b">

//**** Linked list program that uses put_to ("<<") operator to append elements.
// by Jack Krupansky, 1993.
class  MyListData
{
            Print { cout << "Object of class "+this.class_name; }
};
struct  MyListElement
{           MyListData    data;
            MyListElement next;

            MyListElement (MyListData initialData)
            {
                    data = initialData;
            }
};
class  MyList : MyListData
{          MyListElement head;
           MyListElement tail;
public:
            put_to (MyListData data)
            {
                MyListElement newElement = new MyListElement (data);
                if (head)  tail.next = newElement; // Append to non-empty list
                else       head = newElement;      // Start from an empty list
                tail = newElement;            // Point to the new end of list
                return this;
            }
            Print
            {
                for (int i = 0, MyListElement e = head; e; e = e.next)
                            e.data.Print();
            }
};
class  MyNumber : MyListData
{           int value;
            MyNumber (int initialValue) { value = initialValue; }
            Print { cout << "    Number: " + value + "\n";}
};
{           int x, y;
            MyPoint (int initialX,int initialY)
                    { x = initialX; y = initialY; }
            Print { cout << "    Point: " + x + "," + y + "\n"; }
};
void main (void)
{       MyList   list1 =   new  MyList;
        MyList   list2 =   new  MyList;
        MyNumber n1    =   new  MyNumber (10);
        MyNumber n2    =   new  MyNumber (20);
        MyPoint  p1    =   new  MyPoint  (2,3);
        MyPoint  p2    =   new  MyPoint  (4,5);
        /* build the lists */
        list1 << n1 << n2 << p1;
        /* an object can be in more than one list at same time */
        list2 << n2 << p1 << p2;
        list2 << list1; // we can even put a list into another list
        /* print the lists */
        cout << "\nLIST1:\n";    list1.Print;
        cout << "\nLIST2:\n";    list2.Print;
}


<a name="02c2_000c"><a name="02c2_000d">

<a name="02c2_000d">

//*** Linked list program that subclasses "Linkable", by Ray Valdes, 1993. ***
class Linkable {
        Linkable next;
        Linkable GetNext    { return next; }
        SetNext(Linkable n) { next = n; }
        Print { w << "Should override this method.\n"; }
};
class MyPoint : Linkable {
        int x,y;
        MyPoint(int xx,int yy) { x = xx; y = yy; }
        Print { w << "Point ("+ x + "," + y  + ")\n"; }
};
class MyNumber : Linkable {
        int value;
        MyNumber(int v) { value = v; }
        Print { w << "Integer " + value  + "\n"; }
};
class MyList : Linkable {
        Linkable head,tail;
        int count;
        AddToList(Linkable item) {
           count++;
           if(! head)  { head = tail = item; }
           else        { tail.SetNext(item); tail = item; }
        }
        Print {
           for(int i = 0, Linkable x = head; i < count; i++, x = x.GetNext)
                    x.Print;
        }
};
main {  (w = new window).show;  w << "Sample List Program in LIANA\n";
        MyList  list1 =   new   MyList;
        MyList  list2 =   new   MyList;
        MyNumber n1   =   new   MyNumber  (10);
        MyNumber n2   =   new   MyNumber  (20);
        MyPoint  p1   =   new   MyPoint   (2,3);

        // build the lists
        list1.AddToList (n1);
        list1.AddToList (n2);

        // an object can be in more than one list at same time
        list2.AddToList (n2);
        list2.AddToList (p1);

        // a list can contain another list as an element

        // print the lists (should also print the content of any sublists)
        w << "LIST1:\n";    list1.Print;
        w << "LIST2:\n";    list2.Print;
        w << "Done.\n";
}

Copyright © 1993, Dr. Dobb's Journal