Web Hosting by Netfirms | Free Domain Names by Netfirms

Quick Summary: Statements

Note: The language quick summary is intended for people who already know QDL and just need a syntax reminder once in awhile. It consists of a simplified syntax spec and several examples.  This may also be helpful for expert programmers looking for a birds-eye-view of QDL syntax.

Variable Declarations

VariableList : DataType Initializer(s);

X: Integer;             // An integer named X, not initialized
Y, Z: String ("Hello"); // Strings containing "Hello" named Y and Z.
AnArray: [10] Integer;  // An array of ten integers (0 through 9)
AnArray: [-5..5] Integer { 1, 2, 3, 4, 5, ... };
    // An array of 11 integers (-5 through 5); elements -5 through -1 are
    // initialized with 1 through 5, and the rest are not initialized.

Functions & Function Calling

Function Name (Arguments) [: ReturnType] Do
[Statement(s)]
End [Function];

Function PrintHello Do
	// Prints "Hello"
	StdOut.Print "Hello!\n";
End;

Function Square (X: Double): Double Do
	// Calculates the square (X times itself)
	Return X * X;
End;

Function nPr ("[Of]" N: Integer "Pick" R: Integer)
	Result: Integer(N) Do
	// Probability function: If you have T items total, how many 
	// combinations of R items are there?  For example, if you have
	// 5 different balls and pick 3, the number of combinations is
	// nPr (Of 5 Pick 3), which equals 5*4*3=60.
	X: Integer;
	For X = N - 1; X > N - R; X++ Do
		Result *= X;
End;

Function Main Do
	PrintHello; // Calling a function with no arguments
	Square 3;   // Calling a function and ignoring the return value
	StdOut.Print Square(5), "\n"; // Calling a function (Square), and 
		// using the return value as input to another function
		// (StdOut.Print)
	StdOut.Print nPr (5 Pick 3)   // Calculate and print the number of
		// combinations of 3 out of 5 different items.
End;

/*	Output:
	Hello!
	25
	60
*/

Enum

Enum Name [Inherits IntegerTypeName] { Members };

Enum Binary { Zero, One };
	// Zero=0, One=1

Enum Fruits Inherits Int16 {
	// "Inherits Int16" means Fruits are 16-bit signed numbers
	Apple, Grape, Orange = 6, Tangerine
};	// Apple=0, Grape=1, Orange=6, Tangerine=7

Class

[Modifiers] Class ClassName :
[Clauses]
[Functions/Variables/AccessModes/InnerClasses/Enums]
End Class;

Modifiers:

• Final: The class cannot act as a base class.
• Stripped: The class does not contain an RTTI pointer.  Static RTTI is still stored.
• Exported: The class needs to be compatible with dynamically-linked QDL code.
• Abstract: The class cannot be instantiated.  This keyword must be present if one or more of the functions in the class are Abstract, including inherited functions from base classes that have not been given definitions.
• Published: The entire class interface is published in the RTTI.

Clauses:

• Inherits [Inline] InheritanceList: Specifies classes from which this class derives
• Renames: This class implements an alternate interface for an existing class.
• Tags TagName(s): Specifies one or more tags to attach to the class
• Uses Type(s): Specifies one or more classes on which this class's static constructor is dependent.
• Template T [: (SpecClass | [Inherits] BaseClass)]: Specifies that the class is parameterized. T is the name used to refer to the class within the class definition and is analogous to the T in C++'s template <class T>. Template classes either use a SpecClass, which the class T must conform to, or a BaseClass, which T must be derived from.
• Reference T [: (SpecClass | [Inherits] BaseClass)]: Specifies that the class is parameterized as a reference to a certain type.

Access Modes: these affect the accessibility of the members that are listed afterward as follows:

• Public: All code can access the members.
• Private [TypeList]: The members are private to the class and can't be accessed by outsiders, except for code in classes in the optional TypeList.
• Protected [TypeList]: The members are private to the class and can't be accessed by outsiders, except for derived classes, and code in classes in the optional TypeList.