Help on record to a Newbie

Help on record to a Newbie

[Cedric]

Hi All,

I started learning Ada (it's the third time I try!).

I defined and declared the following:

  type t_terminal_type is (black_n_white, black_n_yellow,
                           black_n_green, color);
  type t_color_type is (red, green, blue, yellow, black, white, grey);
  type t_configure_type is
    record
      terminal   : t_terminal_type;
      foreground,
      background : t_color_type;
    end record;

 t_config : t_configure_type;

  t_config.terminal   := black_n_white;
  t_config.background := black;
  t_config.foreground := white;

The compiler (GNAT 2012) comes back with "declaration expected" for the last three lines.

As far as I understood the language I have declared the variable "t_config". This variable has the components terminal, background and foreground of their respective types which can be accessed using dot-notation.

What did I miss here?

Kind regards

Cedric

Re: Help on record to a Newbie

[Jeffrey Carter]

On 12/27/2012 12:31 PM, Cedric wrote:
>
> What did I miss here?

You started every declaration with "t_" and ended every type declaration with 
"_type". When you've corrected this horrible coding standard we can help you 
with your real problem.

-- 
Jeff Carter
"He didn't get that nose from playing ping-pong."
Never Give a Sucker an Even Break
110

Re: Help on record to a Newbie

[Niklas Holsti]

On 12-12-27 21:31 , Cedric wrote:
> Hi All,
> 
> I started learning Ada (it's the third time I try!).

Wishing you well in this...

It would be easier to help you if you showed the whole compilation unit
that is giving you trouble, and not just an extract of it.

> I defined and declared the following:
> 
>   type t_terminal_type is (black_n_white, black_n_yellow,
>                            black_n_green, color);
>   type t_color_type is (red, green, blue, yellow, black, white, grey);
>   type t_configure_type is
>     record
>       terminal   : t_terminal_type;
>       foreground,
>       background : t_color_type;
>     end record;
> 
>  t_config : t_configure_type;

That all looks like good declarations of some types and one object (a
variable).

But the following lines are *statements*, not declarations. You cannot
mix declarations and statements, you must separate them syntactically.
In most cases, the separator is the "begin" keyword.

>   t_config.terminal   := black_n_white;
>   t_config.background := black;
>   t_config.foreground := white;
> 
> The compiler (GNAT 2012) comes back with "declaration expected" for the last three lines.

That is expected: if the compiler accepted the declarations quoted
earlier, it expects more declarations, or some syntax that indicates the
end of the declaration list, such as "begin".

> As far as I understood the language I have declared the variable "t_config".

Yes.

> This variable has the components terminal, background and
> foreground of their respective types which can be accessed
> using dot-notation.

Yes.

> What did I miss here?

Perhaps a "begin" between the declarations and the statements?

I'm not sure exactly how to correct your code, since you didn't say if
the declarations are in a package declaration (.ads file -- you cannot
put any executable statements there), in a body (.adb file), or within a
subprogram in a body. If you show the whole file that contains the
things you quoted, you will get more precise help.

-- 
Niklas Holsti
Tidorum Ltd
niklas holsti tidorum fi
      .      @       .

Re: Help on record to a Newbie

[Shark8]

Partitioning the code given into a package, called terminal, compiled quite easily. I cleaned up the names, a bit, too.

   -- Declare a package for defining types and operations on a terminal.
   Package Terminal is

      type terminal_type is (black_n_white, black_n_yellow,
                             black_n_green, color);
      type terminal_color is (red, green, blue, yellow, black, white, grey);
      type terminal_configuration is
         record
            terminal   : terminal_type;
            foreground,
            background : terminal_color;
         end record;

      -- Declare a variable for the configuration; use of this package implies
      -- usage of a terminal.
      t_config : terminal_configuration;
   End Terminal;

   Package Body Terminal is
      
   -- Here we set the defaults for the configuration. Alternatively, in the
   -- package specification we could have used named association to set the
   -- default: 
   -- t_config : terminal_configuration := 
   --    (Terminal => black_n_white, background => black, foreground => white);
   Begin
      t_config.terminal   := black_n_white;
      t_config.background := black;
      t_config.foreground := white; 
   End Terminal;

Re: Help on record to a Newbie

[Cedric]

Am Donnerstag, 27. Dezember 2012 20:31:19 UTC+1 schrieb Cedric:

Hi All,

many thanks for all your help.

I think you got the point: I missed to define the specification and the body of the package.

The things is: I have learnt Pascal sometime and liked it a lot. I have still a book about Pascal containing a set of units that helped me learn programming in Pascal and write my own programs. I thought it would be a good training to use the little knowledge of Ada I have so far and implement the Pascal library in Ada. I think I will come across a lot of difficulties. If I solve them, I will be good in programming Ada in the end.

@Jeffrey:
What is so bad about my programming style? I thought it would be good to have a letter indicating the library I write.

Another question: How do you distinguish between types and variables. When reading my programs I find it a lot easier to see directly if it is a type or a variable. What does your programming style look like?

@Niklas:
Please find below the complete file:

-----------------------------------------------------------
-- file         : t_decl.ads
--
-- date         : 2012-12-20
-- update       : 2012-12-27
--
-- compiler     : GNAT GPL 2012 (20120509)
--
-- Author       : Cedric
-----------------------------------------------------------
-- This file contains general definitions.
-- Types and constants are declared and variables defined.
-----------------------------------------------------------

package t_decl is

  -- types --

  subtype t_str2_type is string (2);
  subtype t_str3_type is string (3);
  subtype t_str4_type is string (4);
  subtype t_str5_type is string (5);
  subtype t_str6_type is string (6);
  subtype t_str7_type is string (7);
  subtype t_str8_type is string (8);
  subtype t_str9_type is string (9);
  subtype t_str10_type is string (10);
  subtype t_str11_type is string (11);
  subtype t_str20_type is string (20);
  subtype t_str30_type is string (30);
  subtype t_str40_type is string (40);
  subtype t_str50_type is string (50);
  subtype t_str60_type is string (60);

  -- maximum length of line
  subtype t_longstring_type is string (127);

  -- work string of 79 characters
  subtype t_workstring_type is string (79);

  type t_yes_type is ('j', 'J');
  type t_no_type is ('n', 'N');

  -- Different alternatives of declaring that type
  -- Alternative 1 is not a good choice
  -- cause the type can get any character instead of
  -- only "J" or "N"
  -- type t_yes_or_no is array(1..1) of character;
  -- Alternative 2 is not a good choice
  -- cause the input of a character can not directly
  -- be compared with that type
  -- type t_yes_or_no is (j, J, n, N);
  -- Alternative 3 is OK
  -- type t_yes_or_no_type is character('j', 'J', 'n', 'N');
  -- Alternative 4 is OK and chosen
  type t_yes_or_no_type is ('j', 'J', 'n', 'N');

  -- This type definition for an array is used to store 500
  -- strings with a maximum length of 10 characters.
  -- This array is handed over to a procedure which converts
  -- the array into numbers of type float. These numbers will
  -- then be processed.
 type t_ary500_str10_type is array (integer range 1 .. 500) of t_str10_type;

  -- The record definition and the type
  -- t_selection_rec_type will be used within the function
  -- t_selection_bar from the unit t_io.
  -- It is assumed that the program will run on terminals
  -- displaying 80 columns and 40 lines.
  subtype t_lines_type   is integer range 1 .. 40;
  subtype t_columns_type is integer range 1 .. 80;
  type t_selection_rec_type is
    record
      label  : string (1 .. 30);
      line   : t_lines_type;
      column : t_columns_type;
    end record;

  type t_bar_type is array (integer range 1 .. 40) of t_selection_rec_type;

  -- For the drop down menu the 8 items of length 20 are
  -- defined.
  type t_ary_menu1_type is array (integer range 1 .. 8) of t_str30_type;

  -- This type definition is used for the selection of the 
  -- terminal and for the setting of foreground and back-
  -- ground colors. The following values can be used:
  type t_terminal_type is (black_n_white, black_n_yellow,
                           black_n_green, color);
  type t_color_type is (red, green, blue, yellow, black, white, grey);
  type t_configure_type is
    record
      terminal   : t_terminal_type;
      foreground,
      background : t_color_type;
    end record;

  -- constants --

  t_esc : constant character := ASCII.ESC;

  -- variables --

  t_key : character; -- for key stroke, e. g. ctrl-key
  t_ok  : boolean;   -- for general use

  -- A type register has to be defined. This type shall be
  -- used to access the processor registers of a standard
  -- Intel processor.
  -- to be done

  -- Error information, e. g. for procedures that convert
  -- something:
  -- t_err := 0 --> Conversion OK
  -- t_err := 1 --> Conversion not OK
  -- The variable will be set to "0" in the unit t_check.
  -- Conversion will be done anyway but with result "0".
  -- Ann.: This way of Turbo Pascal programming has to be
  --       changed to the Ada way of programming.
  t_err : integer range 1 .. 1000;

  -- Terminal type and colors
  t_config : t_configure_type;

  t_yes_no : t_yes_no_type;
  t_yes    : t_yes_type;
  t_no     : t_no_type;

  t_config.terminal   := black_n_white;
  t_config.background := black;
  t_config.foreground := white;

  -- Set the terminal background color
  -- Set the terminal foreground color
  -- to be done, but do not know how to do it
  
  -- Clear the screen
  -- to be done, but do not know how to do it

end t_decl;

-- EOF

Kind regards

Cedric

Re: Help on record to a Newbie

[Niklas Holsti]

On 12-12-28 01:53 , Cedric wrote:
> Am Donnerstag, 27. Dezember 2012 20:31:19 UTC+1 schrieb Cedric:
> 
> Hi All,
> 
> many thanks for all your help.
> 
> I think you got the point: I missed to define the specification and
> the body of the package.

That is not the whole point. The point is that executable statements,
like your assignment statements, must be written in a different place
than declarations. Most executable statements go in subprograms
(procedures or functions). Your package has no subprograms; don't you
think that it needs some? At least a main procedure? Or do you plan to
put subprograms in other packages?

> The things is: I have learnt Pascal sometime and liked it a lot. I
> have still a book about Pascal containing a set of units that helped

Aha, "unit": you have used Turbo Pascal, not standard Pascal. Good,
because the "unit" concept has some similarity with the Ada package
concept. But be warned that they are not identical.

> me learn programming in Pascal and write my own programs. I thought
> it would be a good training to use the little knowledge of Ada I have
> so far and implement the Pascal library in Ada.

It seems that you are starting from the Pascal style and trying to
implement bits of Pascal code in Ada, one bit at a time. This can teach
you how details of Pascal map to details in Ada, but you also (and
mainly, IMO) need to understand how an Ada program is put together
overall, including the differences between subprograms and packages.
That understanding seems to be missing still.

> I think I will come across a lot of difficulties.

I think you will avoid many difficulties if you start by learning some
Ada from its basics, and later come back to your Pascal-translation
approach.

> @Jeffrey: What is so bad about my programming style? I thought it
> would be good to have a letter indicating the library I write.

I'm not Jeffrey, but I don't like your naming style either. Of course,
this is a personal and subjective choice; today I don't like the naming
style that I used 15 years ago, and now I prefer the "standard" styles
recommended for Ada programming.

You have to decide if you are going to use the Ada "use" clause a lot,
or not.

The names of things (types, variables, subprograms) declared in an Ada
package declaration are not, by default, usable as such from another
package. In your case, if you want to use your "t_decl" package from
some other package, you write at the start of the other package file:

   with t_decl;  -- Warning! Not the same as "with" in Pascal!

and when you then refer to things in t_decl, you use qualified names of
the form

   t_decl.t_str2_type

So you see that the "t_" prefix is redundant on the things inside the
package. It would be simpler to omit the "t_" prefix within the package,
and then you would write

   t_decl.str2_type

(I don't know if you intend the package name "t_decl" to be the final
name, but to me it seems a poor one. Is the prefix "t_" intended to
identify a library? Then it is too short. Is the "_decl" suffix intended
to explain that the package contains declarations? Well, most packages
contain declarations, so this part of the name is too general. In my
opinion, of course.)

Some Ada programmers like to avoid the need for qualified naming, at
least in some cases, and they use the Ada "use" clause to avoid it. If
you want to do this, you start the other package with this:

   with t_decl;
   use  t_decl;

and then you can refer to items from t_decl directly, for example as

   t_string2_type

You can still also use the qualified name, t_decl.t_string2_type. The
"use" clause can also be written more locally, for example among the
local declarations of a subprogram, and then applies only within that
subprogram.

I prefer to avoid "use" clauses generally, and only use them in special
cases. I find it easier to read and understand programs where items from
other packages are named in the qualified form, including the package
name. This means that I don't need to put any special prefixes or
suffixes on the names I declare within packages, because the package
name itself will be a used as a prefix for the names, when the names are
used in other packages.

> Another question: How do you distinguish between types and variables.
> When reading my programs I find it a lot easier to see directly if it
> is a type or a variable. What does your programming style look like?

I use the "_T" suffix for type names, and no suffix for variables.

   type Tree_T is (Birch, Fir, Aspen, Oak);

   Tree : Tree_T;

> @Niklas: Please find below the complete file:

Some comments on it:

>   subtype t_str2_type is string (2);

Not a valid subtype declaration. When you constrain an array index
range, you must give both lower and upper bounds, for example like this:

   subtype t_str2_type is string (1..2);

(GNAT did not complain about this to you, because it first found the
other errors (statements where declarations were expected) later in the
file, and abandonded the compilation. This is an irritating feature in
GNAT, but nothing is perfect...)

>   t_yes_no : t_yes_no_type;

GNAT says t_decl.ads:125:14: "t_yes_no_type" is undefined

>  -- A type register has to be defined. This type shall be
>  -- used to access the processor registers of a standard
>  -- Intel processor.

Why? What are you trying to do, that requires access to processor registers?

As I said, the following are statements and cannot be written after the
declarations, but must be placed in a subprogram or in the executable
statement block of the package body:

>   t_config.terminal   := black_n_white;
>   t_config.background := black;
>   t_config.foreground := white;

If you only want to give t_config an initial value, you can do it in the
declaration of t_config, like this:

  t_config : t_configure_type := (
    terminal   => black_n_white,
    background => black,
    foreground => white);

>   -- Set the terminal background color
>   -- Set the terminal foreground color
>   -- to be done, but do not know how to do it
>
>   -- Clear the screen
>   -- to be done, but do not know how to do it

For alphanumeric screen control, you have the option of directly using
standard (ANSI) control codes, or some OS-specific system such as
"curses" on Unix-like systems. I think others on comp.lang.ada can help
you find Ada bindings to such tools.

-- 
Niklas Holsti
Tidorum Ltd
niklas holsti tidorum fi
      .      @       .

Re: Help on record to a Newbie

[Cedric]

Hi Niklas,

many thanks for all your comments. I learnt a lot of them and will change my program according to this.

It is interesting to see that you also have a style that indicates types. You mentioned the current Ada style. Can you send me a link to the document you referenced?

What does "alphanumeric screen control" in Ada mean?

Kind regards

Cedric

Re: Help on record to a Newbie

[Simon Wright]

Cedric <georg.maubach@gmail.com> writes:

> It is interesting to see that you also have a style that indicates
> types. You mentioned the current Ada style. Can you send me a link to
> the document you referenced?

You're on the point of igniting a flame war here!

Even the Ada language is inconsistent here: we don't say
{Standard.}Integer_Type, but we do say {Ada.Text_IO.}File_Type.

Personally I don't use _Type or _T, you know the name is that of a type
from context (eg, in 

   Foo : Bar;

you know Bar is a type). I will admit that this sometimes requires more
thought; it's easy to say

   Bar : Bar_T;

But more thought is usually a Good Thing.

The only "standard" style guide I know is the Ada 95 Quality and Style
Guide[1]. There is an Ada 2005 update in the form of a wikibook[2].

[1] http://www.adaic.org/resources/add_content/docs/95style/95style.pdf
[2] http://en.wikibooks.org/wiki/Ada_Style_Guide

Re: Help on record to a Newbie

[Niklas Holsti]

On 12-12-28 10:30 , Cedric wrote:

> What does "alphanumeric screen control" in Ada mean?

If your program uses Text_IO to display its output, the output text
appears sequentially, left to right, top to down, in your command
window, as if written on a typewriter. You can control the format a bit
by Set_Col and New_Line, but not a lot.

By alphanumeric screen control I mean the ability to address the command
window / screen as an array of characters, for example in the classic 24
x 80 lay-out, and have some form of "go to row r, column c" control.
Your mention of clearing the screen made me think that you want this
kind of control.

Libraries for such control over the screen often also allow setting the
color of the text, and/or the background color, and/or some style
options such as bold, italic, blinking (don't!), and perhaps include
also the ability to use some "line-drawing" character set that lets you
draw simple box graphics on the screen.

Of course, all of that is superseded by GUIs, but (as another thread
discusses) GUI coding is not so easy...

-- 
Niklas Holsti
Tidorum Ltd
niklas holsti tidorum fi
      .      @       .

Re: Help on record to a Newbie

[Cedric]

Hi again,

thanks for the links to the Ada Style Guide for Ada95 and Ada2005.

I hope that my questions do not rise a flame war. I think everyone should write his/her programs as they like. If there is a document that suits all the better.

The comments with "register" in it were meant to define variables that can access processor registers. As I learnt last night, this is normally not needed when using Ada. I try to find a solution with the Ada way.

Regards

Cedric

Re: Help on record to a Newbie

[Shark8]

On Friday, December 28, 2012 5:52:42 AM UTC-6, Cedric wrote:
> Hi again,
> 
> The comments with "register" in it were meant to define variables that can access processor registers. As I learnt last night, this is normally not needed when using Ada. I try to find a solution with the Ada way.

"Pragma Volatile(VARIABLE);" will mark a variable as 'undecidably mutable', something like a memory-mapped clock where any access of the value could have a different value -- I don't recall any way to bind a variable to a register, and in any case that's likely a bad idea: the compiler is typically smart enough to know when to put things in a register. -- Many men, working multiple years on the problem, are likely to have a better understanding of the how/when... this is precisely why the "big new overhaul" in programming is parallelism: the market selected C/C++ and thus bonded to a low-level view of computing (because it was "more efficient" and they had more "control") which is inherently a poor fit for the problem of parallelization.

You will get the same result every time you try to fit the code to the machine rather than the code to the problem. (Of course, sometimes the machine is the 'problem' as is the case with OSes and device rivers.)

Re: Help on record to a Newbie

[Niklas Holsti]

On 12-12-28 13:52 , Cedric wrote:

> I hope that my questions do not rise a flame war. I think everyone
> should write his/her programs as they like.

Sure. Except if they are part of a programming team that must share code.

The point of that discussion was, IMO, to show you that perhaps you
don't need to use a prefix in Ada, just to separate names in one module
from names in other modules (as you often must do in C, for example).

> The comments with "register" in it were meant to define variables
> that can access processor registers. As I learnt last night, this is
> normally not needed when using Ada.

I would still be interested to know what you want to do, that requires
access to processor registers in some other language.

Of course, in assembly language one uses registers all the time, but one
of the points of higher languages is to avoid that.

In some processors, one accesses "special function registers" or "device
registers" to do input/output on a HW level. To a program, such
registers are just memory locations (addresses) with some special
semantics attached. In Ada, as in other languages, one only needs to
tell the compiler or linker to use a certain memory address for a
certain variable, and then mark that variable as "volatile" to make sure
that the compiled code actually accesses memory. (Sometimes it is
necessary to worry about the "width" of the memory access, too, but then
it usually best to fall back to assembly language for these small parts
of the program.)

> I try to find a solution with the Ada way.

If you tell us what you want to do, we can help you find an Ada solution.

-- 
Niklas Holsti
Tidorum Ltd
niklas holsti tidorum fi
      .      @       .