-- Package (and subprograms) instantiations
-- When a package is instantiated, we need to 'duplicate' its declaration.
-- This looks useless for analysis but it isn't: a type from a package
-- instantiated twice declares two different types. Without duplication, we
-- need to attach to each declaration its instance, which looks more expansive
-- that duplicating the declaration.
--
-- Furthermore, for generic type interface, it looks a good idea to duplicate
-- the body (macro expansion).
--
-- Duplicating is not trivial: internal links must be kept and external
-- links preserved. A table is used to map nodes from the uninstantiated
-- package to its duplicated node. Links from instantiated declaration to
-- the original declaration are also stored in that table.
with Tables;
with Nodes;
with Nodes_Meta;
with Types; use Types;
with Iirs_Utils; use Iirs_Utils;
with Errorout; use Errorout;
package body Sem_Inst is
-- Table of origin. This is an extension of vhdl nodes to track the
-- origin of a node. If a node has a non-null origin, then the node was
-- instantiated for the origin node.
--
-- Furthermore, during instantiation, we need to keep track of instantiated
-- nodes (ie nodes created by instantiation) used by references. As an
-- instance cannot be uninstantiated, there is no collisions, as soon as
-- such entries are cleaned after instantiation.
--
-- As an example, here are declarations of an uninstantiated package:
-- type Nat is range 0 to 1023;
-- constant N : Nat := 5;
-- A node Nat1 will be created from node Nat (an integer type definition).
-- The origin of Nat1 is Nat and this is true forever. During
-- instantiation, the instance of Nat is Nat1, so that the type of N will
-- be set to Nat1.
package Origin_Table is new Tables
(Table_Component_Type => Iir,
Table_Index_Type => Iir,
Table_Low_Bound => 2,
Table_Initial => 1024);
procedure Expand_Origin_Table
is
use Nodes;
Last : constant Iir := Iirs.Get_Last_Node;
El: Iir;
begin
El := Origin_Table.Last;
if El < Last then
Origin_Table.Set_Last (Last);
Origin_Table.Table (El + 1 .. Last) := (others => Null_Iir);
end if;
end Expand_Origin_Table;
-- This is the public function; the table may not have been extended.
function Get_Origin (N : Iir) return Iir
is
-- Make the '<=' operator visible.
use Nodes;
begin
if N <= Origin_Table.Last then
return Origin_Table.Table (N);
else
return Null_Iir;
end if;
end Get_Origin;
-- This is the private function: the table *must* have been extended.
function Get_Instance (N : Iir) return Iir
is
-- Make '<=' operator visible for the assert.
use Nodes;
begin
pragma Assert (N <= Origin_Table.Last);
return Origin_Table.Table (N);
end Get_Instance;
procedure Set_Origin (N : Iir; Orig : Iir) is
begin
-- As nodes are created, we need to expand origin table.
Expand_Origin_Table;
pragma Assert (Orig = Null_Iir
or else Origin_Table.Table (N) = Null_Iir);
Origin_Table.Table (N) := Orig;
end Set_Origin;
type Instance_Entry_Type is record
-- Node
N : Iir;
-- Old value in Origin_Table.
Old_Origin : Iir;
end record;
type Instance_Index_Type is new Natural;
-- Table of previous values in Origin_Table. The first purpose of this
-- table is to be able to revert the calls to Set_Instance, so that a unit
-- can be instantiated several times. Keep the nodes that have been
-- instantiated is cheaper than walking the tree a second time.
-- The second purpose of this table is not yet implemented: being able to
-- have uninstantiated packages in instantiated packages. In that case,
-- the slot in Origin_Table cannot be the origin and the instance at the
-- same time.
package Prev_Instance_Table is new Tables
(Table_Component_Type => Instance_Entry_Type,
Table_Index_Type => Instance_Index_Type,
Table_Low_Bound => 1,
Table_Initial => 256);
procedure Set_Instance (Orig : Iir; N : Iir)
is
use Nodes;
begin
pragma Assert (Orig <= Origin_Table.Last);
-- Save the old entry
Prev_Instance_Table.Append
(Instance_Entry_Type'(N => Orig,
Old_Origin => Origin_Table.Table (Orig)));
-- Set the entry.
Origin_Table.Table (Orig) := N;
end Set_Instance;
procedure Restore_Origin (Mark : Instance_Index_Type) is
begin
for I in reverse Mark + 1 .. Prev_Instance_Table.Last loop
declare
El : Instance_Entry_Type renames Prev_Instance_Table.Table (I);
begin
Origin_Table.Table (El.N) := El.Old_Origin;
end;
end loop;
Prev_Instance_Table.Set_Last (Mark);
end Restore_Origin;
-- The location to be used while instantiated nodes.
Instantiate_Loc : Location_Type;
function Instantiate_Iir (N : Iir; Is_Ref : Boolean) return Iir;
-- Instantiate a list. Simply create a new list and instantiate nodes of
-- that list.
function Instantiate_Iir_List (L : Iir_List; Is_Ref : Boolean)
return Iir_List
is
Res : Iir_List;
El : Iir;
begin
case L is
when Null_Iir_List
| Iir_List_All
| Iir_List_Others =>
return L;
when others =>
Res := Create_Iir_List;
for I in Natural loop
El := Get_Nth_Element (L, I);
exit when El = Null_Iir;
Append_Element (Res, Instantiate_Iir (El, Is_Ref));
end loop;
return Res;
end case;
end Instantiate_Iir_List;
-- Instantiate a chain. This is a special case to reduce stack depth.
function Instantiate_Iir_Chain (N : Iir) return Iir
is
First : Iir;
Last : Iir;
Next_N : Iir;
Next_R : Iir;
begin
if N = Null_Iir then
return Null_Iir;
end if;
First := Instantiate_Iir (N, False);
Last := First;
Next_N := Get_Chain (N);
while Next_N /= Null_Iir loop
Next_R := Instantiate_Iir (Next_N, False);
Set_Chain (Last, Next_R);
Last := Next_R;
Next_N := Get_Chain (Next_N);
end loop;
return First;
end Instantiate_Iir_Chain;
procedure Instantiate_Iir_Field
(Res : Iir; N : Iir; F : Nodes_Meta.Fields_Enum)
is
use Nodes_Meta;
begin
case Get_Field_Type (F) is
when Type_Iir =>
declare
S : constant Iir := Get_Iir (N, F);
R : Iir;
begin
case Get_Field_Attribute (F) is
when Attr_None =>
R := Instantiate_Iir (S, False);
when Attr_Ref =>
R := Instantiate_Iir (S, True);
when Attr_Maybe_Ref =>
R := Instantiate_Iir (S, Get_Is_Ref (N));
when Attr_Chain =>
R := Instantiate_Iir_Chain (S);
when Attr_Chain_Next =>
R := Null_Iir;
when Attr_Of_Ref =>
-- Can only appear in list.
raise Internal_Error;
end case;
Set_Iir (Res, F, R);
end;
when Type_Iir_List =>
declare
S : constant Iir_List := Get_Iir_List (N, F);
R : Iir_List;
begin
case Get_Field_Attribute (F) is
when Attr_None =>
R := Instantiate_Iir_List (S, False);
when Attr_Of_Ref =>
R := Instantiate_Iir_List (S, True);
when others =>
-- Ref is specially handled in Instantiate_Iir.
-- Others cannot appear for lists.
raise Internal_Error;
end case;
Set_Iir_List (Res, F, R);
end;
when Type_PSL_NFA
| Type_PSL_Node =>
-- TODO
raise Internal_Error;
when Type_String8_Id =>
Set_String8_Id (Res, F, Get_String8_Id (N, F));
when Type_Source_Ptr =>
Set_Source_Ptr (Res, F, Get_Source_Ptr (N, F));
when Type_Date_Type
| Type_Date_State_Type
| Type_Time_Stamp_Id
| Type_File_Checksum_Id =>
-- Can this happen ?
raise Internal_Error;
when Type_Base_Type =>
Set_Base_Type (Res, F, Get_Base_Type (N, F));
when Type_Iir_Constraint =>
Set_Iir_Constraint (Res, F, Get_Iir_Constraint (N, F));
when Type_Iir_Mode =>
Set_Iir_Mode (Res, F, Get_Iir_Mode (N, F));
when Type_Iir_Index32 =>
Set_Iir_Index32 (Res, F, Get_Iir_Index32 (N, F));
when Type_Iir_Int64 =>
Set_Iir_Int64 (Res, F, Get_Iir_Int64 (N, F));
when Type_Boolean =>
Set_Boolean (Res, F, Get_Boolean (N, F));
when Type_Iir_Staticness =>
Set_Iir_Staticness (Res, F, Get_Iir_Staticness (N, F));
when Type_Iir_All_Sensitized =>
Set_Iir_All_Sensitized (Res, F, Get_Iir_All_Sensitized (N, F));
when Type_Iir_Signal_Kind =>
Set_Iir_Signal_Kind (Res, F, Get_Iir_Signal_Kind (N, F));
when Type_Tri_State_Type =>
Set_Tri_State_Type (Res, F, Get_Tri_State_Type (N, F));
when Type_Iir_Pure_State =>
Set_Iir_Pure_State (Res, F, Get_Iir_Pure_State (N, F));
when Type_Iir_Delay_Mechanism =>
Set_Iir_Delay_Mechanism (Res, F, Get_Iir_Delay_Mechanism (N, F));
when Type_Iir_Predefined_Functions =>
Set_Iir_Predefined_Functions
(Res, F, Get_Iir_Predefined_Functions (N, F));
when Type_Iir_Direction =>
Set_Iir_Direction (Res, F, Get_Iir_Direction (N, F));
when Type_Location_Type =>
Set_Location_Type (Res, F, Instantiate_Loc);
when Type_Iir_Int32 =>
Set_Iir_Int32 (Res, F, Get_Iir_Int32 (N, F));
when Type_Int32 =>
Set_Int32 (Res, F, Get_Int32 (N, F));
when Type_Iir_Fp64 =>
Set_Iir_Fp64 (Res, F, Get_Iir_Fp64 (N, F));
when Type_Token_Type =>
Set_Token_Type (Res, F, Get_Token_Type (N, F));
when Type_Name_Id =>
Set_Name_Id (Res, F, Get_Name_Id (N, F));
end case;
end Instantiate_Iir_Field;
function Instantiate_Iir (N : Iir; Is_Ref : Boolean) return Iir
is
Res : Iir;
begin
-- Nothing to do for null node.
if N = Null_Iir then
return Null_Iir;
end if;
-- For a reference, do not create a new node.
if Is_Ref then
Res := Get_Instance (N);
if Res /= Null_Iir then
-- There is an instance for N.
return Res;
else
-- Reference outside the instance.
return N;
end if;
end if;
declare
use Nodes_Meta;
Kind : constant Iir_Kind := Get_Kind (N);
Fields : constant Fields_Array := Get_Fields (Kind);
F : Fields_Enum;
begin
Res := Get_Instance (N);
if Kind = Iir_Kind_Interface_Constant_Declaration
and then Get_Identifier (N) = Null_Identifier
and then Res /= Null_Iir
then
-- Anonymous constant interface declarations are the only nodes
-- that can be shared. Handle that very special case.
return Res;
end if;
pragma Assert (Res = Null_Iir);
-- Create a new node.
Res := Create_Iir (Kind);
-- The origin of this new node is N.
Set_Origin (Res, N);
-- And the instance of N is RES.
Set_Instance (N, Res);
Set_Location (Res, Instantiate_Loc);
for I in Fields'Range loop
F := Fields (I);
-- Fields that are handled specially.
case F is
when Field_Index_Subtype_List =>
-- Index_Subtype_List is always a reference, so retrieve
-- the instance of the referenced list. This is a special
-- case because there is no origins for list.
declare
List : Iir_List;
begin
case Kind is
when Iir_Kind_Array_Type_Definition =>
List := Get_Index_Subtype_Definition_List (Res);
when Iir_Kind_Array_Subtype_Definition =>
List := Get_Index_Constraint_List (Res);
if List = Null_Iir_List then
List := Get_Index_Subtype_List
(Get_Denoted_Type_Mark (Res));
end if;
when others =>
-- All the nodes where Index_Subtype_List appears
-- are handled above.
raise Internal_Error;
end case;
Set_Index_Subtype_List (Res, List);
end;
when others =>
-- Common case.
Instantiate_Iir_Field (Res, N, F);
end case;
end loop;
case Kind is
when Iir_Kind_Function_Declaration
| Iir_Kind_Procedure_Declaration =>
-- Subprogram body is a forward declaration.
Set_Subprogram_Body (Res, Null_Iir);
when others =>
-- TODO: other forward references:
-- incomplete constant
-- attribute_value
null;
end case;
return Res;
end;
end Instantiate_Iir;
-- As the scope generic interfaces extends beyond the immediate scope (see
-- LRM08 12.2 Scope of declarations), they must be instantiated.
function Instantiate_Generic_Chain (Inst : Iir; Inters : Iir) return Iir
is
Inter : Iir;
First : Iir;
Last : Iir;
Res : Iir;
begin
First := Null_Iir;
Last := Null_Iir;
Inter := Inters;
while Inter /= Null_Iir loop
-- Create a copy of the interface. FIXME: is it really needed ?
Res := Create_Iir (Get_Kind (Inter));
Set_Location (Res, Instantiate_Loc);
Set_Parent (Res, Inst);
Set_Identifier (Res, Get_Identifier (Inter));
Set_Visible_Flag (Res, Get_Visible_Flag (Inter));
Set_Origin (Res, Inter);
Set_Instance (Inter, Res);
case Get_Kind (Res) is
when Iir_Kind_Interface_Constant_Declaration =>
Set_Type (Res, Get_Type (Inter));
Set_Subtype_Indication (Res, Get_Subtype_Indication (Inter));
Set_Mode (Res, Get_Mode (Inter));
Set_Has_Mode (Res, Get_Has_Mode (Inter));
Set_Has_Class (Res, Get_Has_Class (Inter));
Set_Has_Identifier_List (Res, Get_Has_Identifier_List (Inter));
Set_Expr_Staticness (Res, Get_Expr_Staticness (Inter));
Set_Name_Staticness (Res, Get_Name_Staticness (Inter));
when Iir_Kind_Interface_Package_Declaration =>
Set_Uninstantiated_Package_Name
(Res, Get_Uninstantiated_Package_Name (Inter));
when others =>
Error_Kind ("instantiate_generic_chain", Res);
end case;
-- Append
if First = Null_Iir then
First := Res;
else
Set_Chain (Last, Res);
end if;
Last := Res;
Inter := Get_Chain (Inter);
end loop;
return First;
end Instantiate_Generic_Chain;
procedure Set_Instance_On_Chain (Chain : Iir; Inst_Chain : Iir);
procedure Set_Instance_On_Iir_List (N : Iir_List; Inst : Iir_List);
procedure Set_Instance_On_Iir (N : Iir; Inst : Iir) is
begin
if N = Null_Iir then
pragma Assert (Inst = Null_Iir);
return;
end if;
pragma Assert (Inst /= Null_Iir);
declare
use Nodes_Meta;
Kind : constant Iir_Kind := Get_Kind (N);
Fields : constant Fields_Array := Get_Fields (Kind);
F : Fields_Enum;
begin
pragma Assert (Get_Kind (Inst) = Kind);
if Kind = Iir_Kind_Interface_Constant_Declaration
and then Get_Identifier (N) = Null_Identifier
then
-- Anonymous constant interface declarations are the only nodes
-- that can be shared. Handle that very special case.
return;
end if;
-- pragma Assert (Get_Instance (N) = Null_Iir);
Set_Instance (N, Inst);
for I in Fields'Range loop
F := Fields (I);
case Get_Field_Type (F) is
when Type_Iir =>
declare
S : constant Iir := Get_Iir (N, F);
S_Inst : constant Iir := Get_Iir (Inst, F);
begin
case Get_Field_Attribute (F) is
when Attr_None =>
Set_Instance_On_Iir (S, S_Inst);
when Attr_Ref =>
null;
when Attr_Maybe_Ref =>
if not Get_Is_Ref (N) then
Set_Instance_On_Iir (S, S_Inst);
end if;
when Attr_Chain =>
Set_Instance_On_Chain (S, S_Inst);
when Attr_Chain_Next =>
null;
when Attr_Of_Ref =>
-- Can only appear in list.
raise Internal_Error;
end case;
end;
when Type_Iir_List =>
declare
S : constant Iir_List := Get_Iir_List (N, F);
S_Inst : constant Iir_List := Get_Iir_List (Inst, F);
begin
case Get_Field_Attribute (F) is
when Attr_None =>
Set_Instance_On_Iir_List (S, S_Inst);
when Attr_Of_Ref
| Attr_Ref =>
null;
when others =>
-- Ref is specially handled in Instantiate_Iir.
-- Others cannot appear for lists.
raise Internal_Error;
end case;
end;
when others =>
null;
end case;
end loop;
end;
end Set_Instance_On_Iir;
procedure Set_Instance_On_Iir_List (N : Iir_List; Inst : Iir_List)
is
El : Iir;
El_Inst : Iir;
begin
case N is
when Null_Iir_List
| Iir_List_All
| Iir_List_Others =>
pragma Assert (Inst = N);
return;
when others =>
for I in Natural loop
El := Get_Nth_Element (N, I);
El_Inst := Get_Nth_Element (Inst, I);
exit when El = Null_Iir;
pragma Assert (El_Inst /= Null_Iir);
Set_Instance_On_Iir (El, El_Inst);
end loop;
pragma Assert (El_Inst = Null_Iir);
end case;
end Set_Instance_On_Iir_List;
procedure Set_Instance_On_Chain (Chain : Iir; Inst_Chain : Iir)
is
El : Iir;
Inst_El : Iir;
begin
El := Chain;
Inst_El := Inst_Chain;
while El /= Null_Iir loop
pragma Assert (Inst_El /= Null_Iir);
Set_Instance_On_Iir (El, Inst_El);
El := Get_Chain (El);
Inst_El := Get_Chain (Inst_El);
end loop;
pragma Assert (Inst_El = Null_Iir);
end Set_Instance_On_Chain;
-- In the instance, replace references (and inner references) to interface
-- package declaration to the associated package.
procedure Instantiate_Generic_Map_Chain (Inst : Iir; Pkg : Iir)
is
pragma Unreferenced (Pkg);
Assoc : Iir;
begin
Assoc := Get_Generic_Map_Aspect_Chain (Inst);
while Assoc /= Null_Iir loop
case Get_Kind (Assoc) is
when Iir_Kind_Association_Element_By_Expression
| Iir_Kind_Association_Element_By_Individual
| Iir_Kind_Association_Element_Open =>
null;
when Iir_Kind_Association_Element_Package =>
declare
Sub_Inst : constant Iir :=
Get_Named_Entity (Get_Actual (Assoc));
Sub_Pkg : constant Iir := Get_Associated_Interface (Assoc);
begin
Set_Instance (Sub_Pkg, Sub_Inst);
Set_Instance_On_Chain (Get_Generic_Chain (Sub_Pkg),
Get_Generic_Chain (Sub_Inst));
Set_Instance_On_Chain (Get_Declaration_Chain (Sub_Pkg),
Get_Declaration_Chain (Sub_Inst));
end;
when others =>
Error_Kind ("instantiate_generic_map_chain", Assoc);
end case;
Assoc := Get_Chain (Assoc);
end loop;
end Instantiate_Generic_Map_Chain;
procedure Instantiate_Package_Declaration (Inst : Iir; Pkg : Iir)
is
Header : constant Iir := Get_Package_Header (Pkg);
Prev_Loc : constant Location_Type := Instantiate_Loc;
Mark : constant Instance_Index_Type := Prev_Instance_Table.Last;
begin
Instantiate_Loc := Get_Location (Inst);
-- Be sure Get_Origin_Priv can be called on existing nodes.
Expand_Origin_Table;
-- For Parent: the instance of PKG is INST.
Set_Origin (Pkg, Inst);
Set_Generic_Chain
(Inst, Instantiate_Generic_Chain (Inst, Get_Generic_Chain (Header)));
Instantiate_Generic_Map_Chain (Inst, Pkg);
Set_Declaration_Chain
(Inst, Instantiate_Iir_Chain (Get_Declaration_Chain (Pkg)));
Set_Origin (Pkg, Null_Iir);
Instantiate_Loc := Prev_Loc;
Restore_Origin (Mark);
end Instantiate_Package_Declaration;
end Sem_Inst;
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
The GNU General Public License, Version 3, 29 June 2007 (GPLv3)
===============================================================
> Copyright © 2007
> Free Software Foundation, Inc.
> <<http://fsf.org/>>
Everyone is permitted to copy and distribute verbatim copies of this license
document, but changing it is not allowed.
Preamble
--------
The GNU General Public License is a free, copyleft license for software and
other kinds of works.
The licenses for most software and other practical works are designed to take
away your freedom to share and change the works. By contrast, the GNU General
Public License is intended to guarantee your freedom to share and change all
versions of a program--to make sure it remains free software for all its users.
We, the Free Software Foundation, use the GNU General Public License for most of
our software; it applies also to any other work released this way by its
authors. You can apply it to your programs, too.
When we speak of free software, we are referring to freedom, not price. Our
General Public Licenses are designed to make sure that you have the freedom to
distribute copies of free software (and charge for them if you wish), that you
receive source code or can get it if you want it, that you can change the
software or use pieces of it in new free programs, and that you know you can do
these things.
To protect your rights, we need to prevent others from denying you these rights
or asking you to surrender the rights. Therefore, you have certain
responsibilities if you distribute copies of the software, or if you modify it:
responsibilities to respect the freedom of others.
For example, if you distribute copies of such a program, whether gratis or for a
fee, you must pass on to the recipients the same freedoms that you received. You
must make sure that they, too, receive or can get the source code. And you must
show them these terms so they know their rights.
Developers that use the GNU GPL protect your rights with two steps: (1) assert
copyright on the software, and (2) offer you this License giving you legal
permission to copy, distribute and/or modify it.
For the developers' and authors' protection, the GPL clearly explains that there
is no warranty for this free software. For both users' and authors' sake, the
GPL requires that modified versions be marked as changed, so that their problems
will not be attributed erroneously to authors of previous versions.
Some devices are designed to deny users access to install or run modified
versions of the software inside them, although the manufacturer can do so. This
is fundamentally incompatible with the aim of protecting users' freedom to
change the software. The systematic pattern of such abuse occurs in the area of
products for individuals to use, which is precisely where it is most
unacceptable. Therefore, we have designed this version of the GPL to prohibit
the practice for those products. If such problems arise substantially in other
domains, we stand ready to extend this provision to those domains in future
versions of the GPL, as needed to protect the freedom of users.
Finally, every program is threatened constantly by software patents. States
should not allow patents to restrict development and use of software on
general-purpose computers, but in those that do, we wish to avoid the special
danger that patents applied to a free program could make it effectively
proprietary. To prevent this, the GPL assures that patents cannot be used to
render the program non-free.
The precise terms and conditions for copying, distribution and modification
follow.
TERMS AND CONDITIONS
--------------------
### 0. Definitions.
"This License refers to version 3 of the GNU General Public License.
"Copyright" also means copyright-like laws that apply to other kinds of works,
such as semiconductor masks.
"The Program" refers to any copyrightable work licensed under this License. Each
licensee is addressed as "you". "Licensees" and "recipients" may be individuals
or organizations.
To "modify" a work means to copy from or adapt all or part of the work in a
fashion requiring copyright permission, other than the making of an exact copy.
The resulting work is called a "modified version" of the earlier work or a work
"based on" the earlier work.
A "covered work" means either the unmodified Program or a work based on the
Program.
To "propagate" a work means to do anything with it that, without permission,
would make you directly or secondarily liable for infringement under applicable
copyright law, except executing it on a computer or modifying a private copy.
Propagation includes copying, distribution (with or without modification),
making available to the public, and in some countries other activities as well.
To "convey" a work means any kind of propagation that enables other parties to
make or receive copies. Mere interaction with a user through a computer network,
with no transfer of a copy, is not conveying.
An interactive user interface displays "Appropriate Legal Notices" to the extent
that it includes a convenient and prominently visible feature that (1) displays
an appropriate copyright notice, and (2) tells the user that there is no
warranty for the work (except to the extent that warranties are provided), that
licensees may convey the work under this License, and how to view a copy of this
License. If the interface presents a list of user commands or options, such as a
menu, a prominent item in the list meets this criterion.
### 1. Source Code.
The "source code" for a work means the preferred form of the work for making
modifications to it. "Object code" means any non-source form of a work.
A "Standard Interface" means an interface that either is an official standard
defined by a recognized standards body, or, in the case of interfaces specified
for a particular programming language, one that is widely used among developers
working in that language.
The "System Libraries" of an executable work include anything, other than the
work as a whole, that (a) is included in the normal form of packaging a Major
Component, but which is not part of that Major Component, and (b) serves only to
enable use of the work with that Major Component, or to implement a Standard
Interface for which an implementation is available to the public in source code
form. A "Major Component", in this context, means a major essential component
(kernel, window system, and so on) of the specific operating system (if any) on
which the executable work runs, or a compiler used to produce the work, or an
object code interpreter used to run it.
The "Corresponding Source" for a work in object code form means all the source
code needed to generate, install, and (for an executable work) run the object
code and to modify the work, including scripts to control those activities.
However, it does not include the work's System Libraries, or general-purpose
tools or generally available free programs which are used unmodified in
performing those activities but which are not part of the work. For example,
Corresponding Source includes interface definition files associated with source
files for the work, and the source code for shared libraries and dynamically
linked subprograms that the work is specifically designed to require, such as by
intimate data communication or control flow between those subprograms and other
parts of the work.
The Corresponding Source need not include anything that users can regenerate
automatically from other parts of the Corresponding Source.
The Corresponding Source for a work in source code form is that same work.
### 2. Basic Permissions.
All rights granted under this License are granted for the term of copyright on
the Program, and are irrevocable provided the stated conditions are met. This
License explicitly affirms your unlimited permission to run the unmodified
Program. The output from running a covered work is covered by this License only
if the output, given its content, constitutes a covered work. This License
acknowledges your rights of fair use or other equivalent, as provided by
copyright law.
You may make, run and propagate covered works that you do not convey, without
conditions so long as your license otherwise remains in force. You may convey
covered works to others for the sole purpose of having them make modifications
exclusively for you, or provide you with facilities for running those works,
provided that you comply with the terms of this License in conveying all
material for which you do not control copyright. Those thus making or running
the covered works for you must do so exclusively on your behalf, under your
direction and control, on terms that prohibit them from making any copies of
your copyrighted material outside their relationship with you.
Conveying under any other circumstances is permitted solely under the conditions
stated below. Sublicensing is not allowed; section 10 makes it unnecessary.
### 3. Protecting Users' Legal Rights From Anti-Circumvention Law.
No covered work shall be deemed part of an effective technological measure under
any applicable law fulfilling obligations under article 11 of the WIPO copyright
treaty adopted on 20 December 1996, or similar laws prohibiting or restricting
circumvention of such measures.
When you convey a covered work, you waive any legal power to forbid
circumvention of technological measures to the extent such circumvention is
effected by exercising rights under this License with respect to the covered
work, and you disclaim any intention to limit operation or modification of the
work as a means of enforcing, against the work's users, your or third parties'
legal rights to forbid circumvention of technological measures.
### 4. Conveying Verbatim Copies.
You may convey verbatim copies of the Program's source code as you receive it,
in any medium, provided that you conspicuously and appropriately publish on each
copy an appropriate copyright notice; keep intact all notices stating that this
License and any non-permissive terms added in accord with section 7 apply to the
code; keep intact all notices of the absence of any warranty; and give all
recipients a copy of this License along with the Program.
You may charge any price or no price for each copy that you convey, and you may
offer support or warranty protection for a fee.
### 5. Conveying Modified Source Versions.
You may convey a work based on the Program, or the modifications to produce it
from the Program, in the form of source code under the terms of section 4,
provided that you also meet all of these conditions:
* **a)** The work must carry prominent notices stating that you modified it,
and giving a relevant date.
* **b)** The work must carry prominent notices stating that it is released
under this License and any conditions added under section 7. This
requirement modifies the requirement in section 4 to "keep intact all
notices".
* **c)** You must license the entire work, as a whole, under this License to
anyone who comes into possession of a copy. This License will therefore
apply, along with any applicable section 7 additional terms, to the whole of
the work, and all its parts, regardless of how they are packaged. This
License gives no permission to license the work in any other way, but it
does not invalidate such permission if you have separately received it.
* **d)** If the work has interactive user interfaces, each must display
Appropriate Legal Notices; however, if the Program has interactive
interfaces that do not display Appropriate Legal Notices, your work need not
make them do so.
A compilation of a covered work with other separate and independent works,
which are not by their nature extensions of the covered work, and which are
not combined with it such as to form a larger program, in or on a volume of
a storage or distribution medium, is called an "aggregate" if the
compilation and its resulting copyright are not used to limit the access or
legal rights of the compilation's users beyond what the individual works
permit. Inclusion of a covered work in an aggregate does not cause this
License to apply to the other parts of the aggregate.
### 6. Conveying Non-Source Forms.
You may convey a covered work in object code form under the terms of sections 4
and 5, provided that you also convey the machine-readable Corresponding Source
under the terms of this License, in one of these ways:
* **a)** Convey the object code in, or embodied in, a physical product
(including a physical distribution medium), accompanied by the Corresponding
Source fixed on a durable physical medium customarily used for software
interchange.
* **b)** Convey the object code in, or embodied in, a physical product
(including a physical distribution medium), accompanied by a written offer,
valid for at least three years and valid for as long as you offer spare
parts or customer support for that product model, to give anyone who
possesses the object code either (1) a copy of the Corresponding Source for
all the software in the product that is covered by this License, on a
durable physical medium customarily used for software interchange, for a
price no more than your reasonable cost of physically performing this
conveying of source, or (2) access to copy the Corresponding Source from a
network server at no charge.
* **c)** Convey individual copies of the object code with a copy of the
written offer to provide the Corresponding Source. This alternative is
allowed only occasionally and noncommercially, and only if you received the
object code with such an offer, in accord with subsection 6b.
* **d)** Convey the object code by offering access from a designated place
(gratis or for a charge), and offer equivalent access to the Corresponding
Source in the same way through the same place at no further charge. You need
not require recipients to copy the Corresponding Source along with the
object code. If the place to copy the object code is a network server, the
Corresponding Source may be on a different server (operated by you or a
third party) that supports equivalent copying facilities, provided you
maintain clear directions next to the object code saying where to find the
Corresponding Source. Regardless of what server hosts the Corresponding
Source, you remain obligated to ensure that it is available for as long as
needed to satisfy these requirements.
* **e)** Convey the object code using peer-to-peer transmission, provided you
inform other peers where the object code and Corresponding Source of the
work are being offered to the general public at no charge under subsection
6d.
A separable portion of the object code, whose source code is excluded from
the Corresponding Source as a System Library, need not be included in
conveying the object code work.
A "User Product" is either (1) a "consumer product", which means any
tangible personal property which is normally used for personal, family, or
household purposes, or (2) anything designed or sold for incorporation into
a dwelling. In determining whether a product is a consumer product, doubtful
cases shall be resolved in favor of coverage. For a particular product
received by a particular user, "normally used" refers to a typical or common
use of that class of product, regardless of the status of the particular
user or of the way in which the particular user actually uses, or expects or
is expected to use, the product. A product is a consumer product regardless
of whether the product has substantial commercial, industrial or non-
consumer uses, unless such uses represent the only significant mode of use
of the product.
"Installation Information" for a User Product means any methods, procedures,
authorization keys, or other information required to install and execute
modified versions of a covered work in that User Product from a modified
version of its Corresponding Source. The information must suffice to ensure
that the continued functioning of the modified object code is in no case
prevented or interfered with solely because modification has been made.
If you convey an object code work under this section in, or with, or
specifically for use in, a User Product, and the conveying occurs as part of
a transaction in which the right of possession and use of the User Product
is transferred to the recipient in perpetuity or for a fixed term
(regardless of how the transaction is characterized), the Corresponding
Source conveyed under this section must be accompanied by the Installation
Information. But this requirement does not apply if neither you nor any
third party retains the ability to install modified object code on the User
Product (for example, the work has been installed in ROM).
The requirement to provide Installation Information does not include a
requirement to continue to provide support service, warranty, or updates for
a work that has been modified or installed by the recipient, or for the User
Product in which it has been modified or installed. Access to a network may
be denied when the modification itself materially and adversely affects the
operation of the network or violates the rules and protocols for
communication across the network.
Corresponding Source conveyed, and Installation Information provided, in
accord with this section must be in a format that is publicly documented
(and with an implementation available to the public in source code form),
and must require no special password or key for unpacking, reading or
copying.
### 7. Additional Terms.
"Additional permissions" are terms that supplement the terms of this License by
making exceptions from one or more of its conditions. Additional permissions
that are applicable to the entire Program shall be treated as though they were
included in this License, to the extent that they are valid under applicable
law. If additional permissions apply only to part of the Program, that part may
be used separately under those permissions, but the entire Program remains
|