Dragon/Printable version

From Wikibooks, open books for an open world
Jump to navigation Jump to search


Dragon

The current, editable version of this book is available in Wikibooks, the open-content textbooks collection, at
https://en.wikibooks.org/wiki/Dragon

Permission is granted to copy, distribute, and/or modify this document under the terms of the Creative Commons Attribution-ShareAlike 3.0 License.


Lessons/Introduction

Introduction[edit | edit source]

Welcome to the Dragon programming language!

In this chapter we are going to discuss the goals behind the language design and implementation.



Lessons/History

History[edit | edit source]

In Oct. 2016 I started the design and the implementation of the Dragon programming language. After 15 months of development, in Jan 2018 the language Interpreter and environment were ready for use!

The first version of the language Dragon 1.0 was released on January 4th, 2018.




Lessons/Features

Features[edit | edit source]

The Dragon language comes with the following features:

  • Interpreted
  • Declarative programming on top of object-oriented programming
  • No explicit end for statements (No ; or ENTER is required)
  • Portable (Windows, Linux, Mac OS X, Android, etc.)
  • Comments (one line, inline, & multi-line)
  • Dynamic typing
  • Weakly typed
  • Garbage collector - automatic memory management (escape analysis and reference counting)
  • Structure-oriented programming
  • Rich control structures & operators
  • Procedures/functions
  • No main function
  • Call function before the definition
  • Recursion
  • Multi-line literals
  • Reflection and metaprogramming
  • Clear program structure (statements, then functions)
  • Exception handling
  • I/O commands
  • Math functions
  • String functions
  • Standard functions
  • File processing functions
  • Database support
  • Create GUI applications for desktop




Lessons/Variables

Variables[edit | edit source]

To create a new variable, you just need to determine the variable name & value. The value will determine the variable type and you can change the value to switch between the types using the same variable name.

Syntax:

	<Variable Name> = <Value>

.. tip::

The operator '=' is used here as an assignment operator and the same operator can be used in conditions, but for testing equality of expressions.

.. note::

The variable will contain the real value (not a reference). This means that once you change the variable value, the old value will be removed from memory (even if the variable contains a list or object).

Dynamic Typing[edit | edit source]

Dragon uses dynamic typing:

	x = "Hello"		// x is a string
	showln x  		// print list items
	x = 5			// x is a number (int)
	showln x 
	x = 1.2 		// x is a number (double)
	showln x 
	x = [1,2,3,4]	// x is a list
	showln x

Deep Copy[edit | edit source]

We can use the assignment operator '=' to copy variables. We can do that to copy values like strings & numbers, and even complete lists & objects! The assignment operator will do a complete duplication for us. This operation is called a deep copy.

	list = [1,2,3,"four","five"]
	list2 = list
	list = []
	show list	// print the first list - no items to print
	showln "********" 
	show list2	// print the second list - contains 5 items

Weakly Typed[edit | edit source]

Dragon is a weakly typed language. This means that the language can automatically convert between data types (like string & numbers) when that conversion makes sense.




Lessons/Operators

Operators[edit | edit source]

In this chapter we will introduce the operators provided by the Dragon programming language.

Arithmetic Operators[edit | edit source]

The next table presents all of the arithmetic operators provided by the Dragon language. Assume variable x = 50 and variable y = 10, then:

+------------+---------------+----------+---------+
| Operator   | Description   | Example  | Result  |
+============+===============+==========+=========+
| +          |  Add          |  x+y     |  60     |
+------------+---------------+----------+---------+
| -          |	Subtract     |	x-y     |  40     |
+------------+---------------+----------+---------+
| *          |  Multiply     |	x*y     |  500    |
+------------+---------------+----------+---------+
| /          |  Divide	     |	x/y     |  5      |
+------------+---------------+----------+---------+
| %          |  Modulus	     |	x%y     |  0      | 
+------------+---------------+----------+---------+
| ++         |  Increment    |	x++     |  51     |
+------------+---------------+----------+---------+
| --         |  Decrement    |	x--     |  49     |
+------------+---------------+----------+---------+

Relational Operators[edit | edit source]

The next table presents all of the relational operators provided by the Dragon language. Assume variable x = 50 and variable y = 10, then:

+------------+---------------------+-------------+---------+
| Operator   | Description         | Example     | Result  |
+============+=====================+=============+=========+
| ==         |  Equal	           |    x == y   |  False  |
+------------+---------------------+-------------+---------+
| !=         |	Not Equal          |	x != y   |  True   |
+------------+---------------------+-------------+---------+
| >          |  Greater than       |	x > y    |  True   |
+------------+---------------------+-------------+---------+
| <          |  Less than          |	x < y    |  False  |
+------------+---------------------+-------------+---------+
| >=         |  Greater or Equal   |	x >= y   |  True   | 
+------------+---------------------+-------------+---------+
| <=         |  Less than or Equal |	x <= y   |  False  |
+------------+---------------------+-------------+---------+

Logical Operators[edit | edit source]

The next table presents all of the logical operators provided by the Dragon language. Assume variable x = true and variable y = false, then:

+------------+---------------------+-------------+---------+
| Operator   | Description         | Example     | Result  |
+============+=====================+=============+=========+
| &&	     |  Logical AND        |    x && y   |  false  |
+------------+---------------------+-------------+---------+
| ||         |	Logical OR         |	x || y   |  true   |
+------------+---------------------+-------------+---------+
| !	         |  Logical Not        |	!x       |  false  |
+------------+---------------------+-------------+---------+

Bitwise Operators[edit | edit source]

The next table presents all of the bitwise operators provided by the Dragon language. Assume variable x = 8 and variable y = 2, then:

+------------+-----------------------------+-------------+---------+
| Operator   | Description                 | Example     | Result  |
+============+=============================+=============+=========+
| &          |  Binary AND                 |    x & y    |  0      |
+------------+-----------------------------+-------------+---------+
| |          |	Binary OR                  |	x | y    |  10     |
+------------+-----------------------------+-------------+---------+
| ^          |  Binary XOR                 |	x ^ y    |  10     |
+------------+-----------------------------+-------------+---------+
| ~          |  Binary Ones Complement 	   |	~x       |  -9     |
+------------+-----------------------------+-------------+---------+
| <<         |  Binary Left Shift          |	x << y   |  32     | 
+------------+-----------------------------+-------------+---------+
| >>         |  Binary Right Shift         |	x >> y   |  2      |
+------------+-----------------------------+-------------+---------+

Assignment Operators[edit | edit source]

The next table presents all of the assignment operators provided by the Dragon language.

Assume variable x = 8, then:

+------------+-----------------------------+-------------+---------+
| Operator   | Description                 | Example     | Result  |
+============+=============================+=============+=========+
| =          |  Assignment                 |    x = 8    |  x=8    |
+------------+-----------------------------+-------------+---------+
| +=         |	Add AND assignment         |	x += 5   |  x=13   |
+------------+-----------------------------+-------------+---------+
| -=	     |  Subtract AND assignment    |	x -= 3   |  x=10   |
+------------+-----------------------------+-------------+---------+
| *=         |  Multiply AND assignment    |	x *= 2   |  x=20   |
+------------+-----------------------------+-------------+---------+
| /=         |  Divide AND assignment      |	x /= 3   |  x=6    |
+------------+-----------------------------+-------------+---------+
| %=         |  Modulus AND assignment     |	x %= 2   |  x=0    | 
+------------+-----------------------------+-------------+---------+
| <<=        |	Left shift AND assignment  |	x <<= 2  |  x=0    |
+------------+-----------------------------+-------------+---------+
| >>=	     |  Right shift AND assignment |	x >>= 2  |  x=0    |
+------------+-----------------------------+-------------+---------+
| &=         |  Bitwise AND assignment     |	x &= 4   |  x=0    |
+------------+-----------------------------+-------------+---------+
| |=         |  Bitwise OR and assignment  |	x |= 3   |  x=3    |
+------------+-----------------------------+-------------+---------+
| ^=         |  Bitwise XOR and assignment |	x ^= 4   |  x=7    |
+------------+-----------------------------+-------------+---------+

Misc Operators[edit | edit source]

==============	======================================================================
Operator        Description
==============	======================================================================
Start:End       create list contains items from start to end
[list items]    define list items
list[index]     access list item
==============	======================================================================

Operator Precedence[edit | edit source]

The next table presents operators from highest precedence (evaluated first) to lowest precedence.

+----------------------------------------------------------------+
| Operator                                                       |
+================================================================+
| .  []   ()     {}                                              |
+----------------------------------------------------------------+
| -  ~  :Literal  [list items]                                   |
+----------------------------------------------------------------+
| ++   --                                                        |
+----------------------------------------------------------------+
| Start:End                                                      |
+----------------------------------------------------------------+
| * /  %                                                         |
+----------------------------------------------------------------+
| + -                                                            |
+----------------------------------------------------------------+
| <<   >>                                                        |
+----------------------------------------------------------------+
| &                                                              |
+----------------------------------------------------------------+
| \|  ^	                                                         |
+----------------------------------------------------------------+
| <  >  <=  >=                                                   |
+----------------------------------------------------------------+
| =  !=                                                          |
+----------------------------------------------------------------+
| not                                                            |
+----------------------------------------------------------------+
| and   or                                                       |
+----------------------------------------------------------------+
| Assignment = += -= \*= /= %= >>= <<= &= ^= \|=                 |
+----------------------------------------------------------------+

Example:

	show 3+5*4	// prints 23




Lessons/Control Structures

Control Structures[edit | edit source]

In this chapter we are going to learn about the control structures provided by the Dragon programming language.

Branching[edit | edit source]

  • If Statement

Syntax:

	if(Expression)
	{
		Block of statements
	}
	else if(Expression)
	{
		Block of statements
	}
	else {
		Block of statements
	}

Example:

	select "types"
	select "graphic"
	nOption = int(prompt("1) Say Hello \n2) About")
	
	if nOption == 1	
	{
		name = prompt("Enter your name: ")
		showln "Hello " + name 
	}
	else if nOption == 2 
	{      
		showln "Sample : using if statement" 
	}
	else
	{ 
		showln "bad option..."
	}

Looping[edit | edit source]

  • While Loop

Syntax:

	while(Expression)
	{
		Block of statements
	}


  • For Loop

Syntax:

	for (identifier=initialize value, terminating expression, step expression)
	{
		Block of statements
	}

Example:

	// print numbers from 1 to 10
	for (x = 1, x <= 10, x++)
	{
		showln x  
	}


  • Foreach Loop

Syntax:

	for (identifier : List/String)
	{
		Block of statements
	}

Example:

	aList = [1,2,3,4]  //create list contains numbers from 1 to 10
	for x : aList
	{
		showln x       // print numbers from 1 to 10
	}

Do While Loop[edit | edit source]

Syntax:

	do {
		body
	} while (condition)

Example:

	x = 1 
	do {
		showln x 
		x++ 
	}
	while (x <= 10)




Lessons/Getting Input

Getting Input[edit | edit source]

We can get input from the keyboard using the readln function.

readln function[edit | edit source]

Syntax:

	select "std"

	a = readln()

Example:

	select "std"
	select "types"
	
    showln "Enter the first number :"
	a = int(readln())
    showln "Enter the second number :"
	b = int(readln())
	
	showln "Sum is : " + (a + b)

Output:

	Enter the first number : 3
	Enter the second number : 4
	Sum is : 7




Lessons/Functions

Functions[edit | edit source]

In this chapter we are going to learn about the next topics :-

  • Define functions
  • Call functions
  • Declare parameters
  • Send parameters
  • Variables Scope
  • Return Value

Define Functions[edit | edit source]

To define a new function:

Syntax:

	func <function_name> (parameters)
	{
		Block of statements
	}


Example:

	func hello()
	{
		showln "Hello from function"
	}

Call Functions[edit | edit source]

Tip: We can call the function before the function definition.

Example:

	hello()

	func hello()
	{
		showln "Hello from function"
	}


Example:

	first()  second()

	func first() {
		showln "message from the first function" 
	}

	func second() {
		showln "message from the second function" 
	}

Declare parameters[edit | edit source]

To declare the function parameters, write them in parentheses.

Example:

	func sum(x, y)
	{
		showln x + y
	}

Send Parameters[edit | edit source]

To send parameters to function, type the parameters inside () after the function name

Syntax:

	name(parameters)

Example:

	/* output
	** 8
	** 3000
	*/

	sum(3, 5) sum(1000, 2000)

	func sum(x, y)
	{
		showln x + y
	}

Variables Scope[edit | edit source]

The Dragon programming language uses lexical scoping to determine the scope of a variable.

Variables defined inside functions (including function parameters) are local variables. Variables defined outside functions (before any function) are global variables.

Inside any function we can access the variables defined inside this function beside the global variables.

Example:

	// the program will print numbers from 10 to 1
	
	x = 10                    // x is a global variable.
	
	for(t = 1, t < 11, t++)   // t is a local variable
		mycounter()           // call function

	func mycounter() {
		showln x              // print the global variable value
		x--                   //decrement
	}

Return Value[edit | edit source]

The function can return a value using the return command.

Syntax:

	return <expression>


Example:

	showln my(30, 40)      // prints 70
	
	func my(a, b)
	{ 
		return a + b
	}