The Project | About Us | Contribute | Donations | License
HOME My courses Completed
◄ Previous
◄

Basic Syntax and Structure

Next ►
►

In this section, we will cover the fundamental syntax and structure of the Ada programming language. Understanding these basics is crucial for writing and reading Ada code effectively.

Key Concepts

  1. Program Structure
  2. Comments
  3. Identifiers
  4. Data Types
  5. Statements and Expressions
  6. Control Structures

  1. Program Structure

An Ada program is composed of one or more compilation units. The most basic unit is the procedure. Here is a simple example:

with Ada.Text_IO; use Ada.Text_IO;

procedure Hello_World is
begin
   Put_Line("Hello, World!");
end Hello_World;

Explanation:

  • with Ada.Text_IO; use Ada.Text_IO;: These lines include the Ada.Text_IO package, which provides input/output functionalities.
  • procedure Hello_World is: This line declares a procedure named Hello_World.
  • begin ... end Hello_World;: This block contains the executable statements of the procedure.

  1. Comments

Comments in Ada are denoted by -- and extend to the end of the line.

-- This is a single-line comment
Put_Line("Hello, World!"); -- This is an inline comment

  1. Identifiers

Identifiers are names given to various program elements such as variables, procedures, and packages. They must start with a letter and can include letters, digits, and underscores.

My_Variable : Integer;

Rules:

  • Must start with a letter.
  • Can contain letters, digits, and underscores.
  • Case insensitive (My_Variable and my_variable are the same).

  1. Data Types

Ada is a strongly typed language. Here are some basic data types:

  • Integer: Whole numbers.
  • Float: Floating-point numbers.
  • Boolean: True or False values.
  • Character: Single characters.
  • String: Sequences of characters.

Example:

My_Integer : Integer := 10;
My_Float : Float := 3.14;
My_Boolean : Boolean := True;
My_Character : Character := 'A';
My_String : String := "Hello, Ada!";

  1. Statements and Expressions

Statements in Ada are instructions executed by the program. Expressions are combinations of variables, constants, and operators that are evaluated to produce a value.

Example:

Sum : Integer := 5 + 3; -- Expression
Put_Line(Integer'Image(Sum)); -- Statement

Explanation:

  • Sum : Integer := 5 + 3;: This is an assignment statement where 5 + 3 is an expression.
  • Put_Line(Integer'Image(Sum));: This statement prints the value of Sum.

  1. Control Structures

Control structures in Ada include conditional statements and loops.

Conditional Statements

if My_Integer > 5 then
   Put_Line("Greater than 5");
elsif My_Integer = 5 then
   Put_Line("Equal to 5");
else
   Put_Line("Less than 5");
end if;

Loops

For Loop

for I in 1 .. 10 loop
   Put_Line(Integer'Image(I));
end loop;

While Loop

I : Integer := 1;
while I <= 10 loop
   Put_Line(Integer'Image(I));
   I := I + 1;
end loop;

Practical Exercises

Exercise 1: Simple Procedure

Write a procedure named Greet that prints "Welcome to Ada!".

Solution:

with Ada.Text_IO; use Ada.Text_IO;

procedure Greet is
begin
   Put_Line("Welcome to Ada!");
end Greet;

Exercise 2: Conditional Statement

Write a procedure that checks if a number is positive, negative, or zero and prints the result.

Solution:

with Ada.Text_IO; use Ada.Text_IO;

procedure Check_Number is
   Number : Integer := -5;
begin
   if Number > 0 then
      Put_Line("Positive");
   elsif Number < 0 then
      Put_Line("Negative");
   else
      Put_Line("Zero");
   end if;
end Check_Number;

Exercise 3: Loop

Write a procedure that prints numbers from 1 to 5 using a for loop.

Solution:

with Ada.Text_IO; use Ada.Text_IO;

procedure Print_Numbers is
begin
   for I in 1 .. 5 loop
      Put_Line(Integer'Image(I));
   end loop;
end Print_Numbers;

Common Mistakes and Tips

  • Case Sensitivity: Remember that Ada is case insensitive, but it's good practice to follow a consistent naming convention.
  • Semicolons: Ensure every statement ends with a semicolon.
  • Indentation: Properly indent your code for better readability.

Conclusion

In this section, we covered the basic syntax and structure of Ada, including program structure, comments, identifiers, data types, statements, expressions, and control structures. These fundamentals are essential for writing and understanding Ada programs. In the next module, we will delve deeper into variables and data types.

◄ Previous
◄
Next ►
►
The Project | About Us | Contribute | Donations | License
© Copyright 2024. All rights reserved