| ------------------------------------------------------------------------------ |
| -- -- |
| -- GNAT COMPILER COMPONENTS -- |
| -- -- |
| -- S E M _ D I M -- |
| -- -- |
| -- S p e c -- |
| -- -- |
| -- Copyright (C) 2011-2013, Free Software Foundation, Inc. -- |
| -- -- |
| -- GNAT is free software; you can redistribute it and/or modify it under -- |
| -- terms of the GNU General Public License as published by the Free Soft- -- |
| -- ware Foundation; either version 3, or (at your option) any later ver- -- |
| -- sion. GNAT is distributed in the hope that it will be useful, but WITH- -- |
| -- OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY -- |
| -- or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -- |
| -- for more details. You should have received a copy of the GNU General -- |
| -- Public License distributed with GNAT; see file COPYING3. If not, go to -- |
| -- http://www.gnu.org/licenses for a complete copy of the license. -- |
| -- -- |
| -- GNAT was originally developed by the GNAT team at New York University. -- |
| -- Extensive contributions were provided by Ada Core Technologies Inc. -- |
| -- -- |
| ------------------------------------------------------------------------------ |
| |
| -- This package provides support for numerical systems with dimensions. A |
| -- "dimension" is a compile-time property of a numerical type which represents |
| -- a relation between various quantifiers such as length, velocity, etc. |
| |
| -- Package System.Dim.Mks offers a ready-to-use system of SI base units. In |
| -- addition, the implementation of this feature offers the ability to define |
| -- an arbitrary system of units through the use of Ada 2012 aspects. |
| |
| -- Dimensionality checking is part of type analysis performed by the compiler. |
| -- It ensures that manipulation of quantified numeric values is sensible with |
| -- respect to the system of units. |
| |
| ----------------------------- |
| -- Aspect_Dimension_System -- |
| ----------------------------- |
| |
| -- In order to enable the user to create their own dimension system, a new |
| -- aspect: Aspect_Dimension_System has been created. |
| |
| -- Note that this aspect applies for type declaration of type derived from any |
| -- numeric type. |
| |
| -- It defines the names of each dimension |
| |
| ---------------------- |
| -- Aspect_Dimension -- |
| ---------------------- |
| |
| -- This new aspect applies for subtype and object declarations in order to |
| -- define new dimensions. |
| |
| -- Using this aspect, the user is able to create new subtype/object with any |
| -- dimension needed. |
| |
| -- Note that the base type of the subtype/object must be the type that defines |
| -- the corresponding dimension system. |
| |
| -- The expression of this aspect is an aggregate of rational values for each |
| -- dimension in the corresponding dimension system. |
| |
| ------------------------------------------- |
| -- Dimensionality checking & propagation -- |
| ------------------------------------------- |
| |
| -- For each node (when needed), a dimension analysis (Analyze_Dimension) is |
| -- performed as part of the Resolution routine or the Analysis routine if no |
| -- Resolution. |
| |
| -- The dimension analysis is divided into two phases: |
| |
| -- Phase 1: dimension checking |
| |
| -- Phase 2: propagation of dimensions |
| |
| -- Depending on the node kind, either none, one phase or two phases are |
| -- executed. |
| |
| -- Phase 2 is called only when the node allows a dimension (see body of |
| -- Sem_Dim to get the list of nodes that permit dimensions). |
| |
| with Types; use Types; |
| |
| package Sem_Dim is |
| |
| procedure Analyze_Aspect_Dimension |
| (N : Node_Id; |
| Id : Entity_Id; |
| Aggr : Node_Id); |
| -- Analyze the contents of aspect Dimension. Associate the provided values |
| -- and quantifiers with the related context N. Id is the corresponding |
| -- Aspect_Id (Aspect_Dimension) Aggr is the corresponding expression for |
| -- the aspect Dimension declared by the declaration of N. |
| |
| procedure Analyze_Aspect_Dimension_System |
| (N : Node_Id; |
| Id : Entity_Id; |
| Aggr : Node_Id); |
| -- Analyze the contents of aspect Dimension_System. Extract the numerical |
| -- type, unit name and corresponding symbol from each indivitual dimension. |
| -- Id is the corresponding Aspect_Id (Aspect_Dimension_System). Aggr is |
| -- the corresponding expression for the aspect Dimension_System from the |
| -- declaration of N. |
| |
| procedure Analyze_Dimension (N : Node_Id); |
| -- N may denote any of the following contexts: |
| -- * aggregate |
| -- * assignment statement |
| -- * attribute reference |
| -- * binary operator |
| -- * call |
| -- * compontent declaration |
| -- * extended return statement |
| -- * expanded name |
| -- * identifier |
| -- * indexed component |
| -- * object declaration |
| -- * object renaming declaration |
| -- * procedure call statement |
| -- * qualified expression |
| -- * selected component |
| -- * simple return statement |
| -- * slice |
| -- * subtype declaration |
| -- * type conversion |
| -- * unary operator |
| -- * unchecked type conversion |
| -- Depending on the context, ensure that all expressions and entities |
| -- involved do not violate the rules of a system. |
| |
| procedure Analyze_Dimension_Array_Aggregate |
| (N : Node_Id; |
| Comp_Typ : Entity_Id); |
| -- Check, for each component of the array aggregate denoted by N, the |
| -- dimensions of the component expression match the dimensions of the |
| -- component type Comp_Typ. |
| |
| procedure Analyze_Dimension_Call (N : Node_Id; Nam : Entity_Id); |
| -- This routine is split in two steps. Note the second step applies only to |
| -- function calls. |
| -- Step 1. Dimension checking: |
| -- * General case: check the dimensions of each actual parameter match |
| -- the dimensions of the corresponding formal parameter. |
| -- * Elementary function case: check each actual is dimensionless except |
| -- for Sqrt call. |
| -- Step 2. Dimension propagation (only for functions): |
| -- * General case: propagate the dimensions from the returned type to the |
| -- function call. |
| -- * Sqrt case: the resulting dimensions equal to half the dimensions of |
| -- the actual |
| |
| procedure Analyze_Dimension_Extension_Or_Record_Aggregate (N : Node_Id); |
| -- Check, for each component of the extension or record aggregate denoted |
| -- by N, the dimensions of the component expression match the dimensions of |
| -- the component type. |
| |
| procedure Analyze_Dimension_Formals (N : Node_Id; Formals : List_Id); |
| -- For sub spec N, issue a warning for each dimensioned formal with a |
| -- literal default value in the list of formals Formals. |
| |
| procedure Copy_Dimensions (From, To : Node_Id); |
| -- Copy dimension vector of node From to node To. Note that To must be a |
| -- node that is allowed to contain a dimension (see OK_For_Dimension in |
| -- body of Sem_Dim). |
| |
| procedure Eval_Op_Expon_For_Dimensioned_Type |
| (N : Node_Id; |
| Btyp : Entity_Id); |
| -- Evaluate the Expon operator for dimensioned type with rational exponent. |
| -- Indeed the regular Eval_Op_Expon routine (see package Sem_Eval) is |
| -- restricted to Integer exponent. This routine deals only with rational |
| -- exponent which is not an integer if Btyp is a dimensioned type. |
| |
| procedure Expand_Put_Call_With_Symbol (N : Node_Id); |
| -- Determine whether N denotes a subprogram call to one of the routines |
| -- defined in System.Dim.Float_IO or System.Dim.Integer_IO and add an |
| -- extra actual to the call to represent the symbolic representation of |
| -- a dimension. |
| |
| function Has_Dimension_System (Typ : Entity_Id) return Boolean; |
| -- Return True if type Typ has aspect Dimension_System applied to it |
| |
| function Is_Dim_IO_Package_Instantiation (N : Node_Id) return Boolean; |
| -- Return True if N is a package instantiation of System.Dim.Integer_IO or |
| -- of System.Dim.Float_IO. |
| |
| procedure Remove_Dimension_In_Statement (Stmt : Node_Id); |
| -- Remove the dimensions associated with Stmt |
| |
| end Sem_Dim; |
