Features

Leonardo is an integrated environment for developing and animating C programs.

It is made specifically for learning the C language, visually debugging C programs, and creating algorithm animations in a declarative style. For a comprehensive review of Leonardo, see Joseph Strout, "Learning from Leonardo", MacTech 15(10).

Leonardo includes (in a single executable file):

• a text editor with syntax coloring
• a compiler for the ANSI C language
• a compiler for the ALPHA visualization language
• a reversible virtual CPU
• a basic operating system for process, I/O and memory management
• an integrated logic-based visualization system
• a simple graph editor

Main features:

• It allows you to edit, compile and execute arbitrary C programs on the virtual CPU.
• No size limits are imposed on C programs.
• It's a multitasking environment.
• Programs can be executed both forward and backward: it is possible to reverse the execution of a program at any time by means of a control tool window:

  

  A reduced control tool is also available:

  

  All available standard ANSI C library functions (including fprintf, fscanf, malloc and free) are fully reversible. The more space you have on your working secondary memory, the more program instructions you can reverse.

• Programs can be animated by embedding in the C source special declarations written in a simple logic-based programming language called ALPHA. For example, if you want a window to appear on the screen you have simply to declare it by means of the "View" ALPHA predicate. In the same way you may want a rectangle to appear in your window: just declare it with "Rectangle".

  Consider the following example:

  int i; /** // Note Alpha declarations are always embedded as // they were special C comments... // We declare a window whose label is 1 View(Out V) Assign V=1; // We declare a rectangle whose ID is 0, left-top corner in (10,10), // height 15, length always equal to the content of program's // variable i, and belonging only to the view 1 Rectangle(Out ID,Out X,Out Y,Out L,Out H,V) If V==1 Assign ID=0 X=10 Y=10 L=i H=15; // We declare that each rectangle having ID 0 in the view 1 must be cyan RectangleColor(ID,Out C,V) If ID==0 && V==1 Assign C=Cyan; **/ void main() { for (i=0; i<=100; i+=10) ; }

  Once you have written, successfully compiled and launched this program you will spot a rectangle in a window on the screen automatically growing up as the variable "i" gets incremented in the loop "for" as shown in the following (slowed down) animation:

Note the visualization system keeps track of the computation state and updates the images depicted on the screen to reflect automatically any significant change of program's variables. This is a powerful high level debugging facility and is the way programs are animated in Leonardo.

Note ALPHA allows you to be more concise, and the declarations above could have been written in the following equivalent form:

View(Out 1); Rectangle(Out 0,Out 10,Out 10,Out L,Out 15,1) Assign L=i; RectangleColor(0,Out Cyan,1);



• Leonardo features a repository that includes dozens of animated algorithms: the menu "Programs" allows it to run programs from a repository of examples ranging from classical algorithms to games such as Tetris and Checkers and some demos showing Leonardo's graphic capabilities. If you don't have enough free space on your HD to execute a program completely, you might want to disable the reversible execution feature from the "Edit" menu at program's startup or from the project settings at compile time. In this way no temporary memory will be allocated on your disk and you will not be able to reverse execution.
  
  
• IMPORTANT NOTE: Leonardo is NOT able to generate native PowerPC/68K code, so you cannot use it for creating Macintosh stand-alone applications.
  Instead, Leonardo allows you to run programs on the Virtual CPU that supports fully-reversible execution and helps you find subtle programming errors (e.g., memory leaks, invalid format string passed to a printf family function, use of invalid file pointers etc.) that other environments may fail to highlight. Moreover, it supports powerful logic-based visualization. If you want to create fast Macintosh stand-alone applications you should consider using a full-featured programming environment such as Metrowerks Codewarrior, MPW or Vip-C (see The Macintosh Programmer's Link Library for details.)