09-130 To: J3 From: Malcolm Cohen Subject: Spurious defined terms in clause 12. Date: 2009 February 04 1. Introduction --------------- The system for "defining" terms we used in previous versions of the standard is not in accordance with the ISO guidelines, so we need to stop using it. We have already introduced the ISO-compliant defined terms subclause, and moved/copied many definitions into it. However, quite a lot have not been revised. These should either - be turned into normal text ("untermified") or - become proper defined terms. This paper deals with the terms in clause 12. 2. Terms and what to do with them --------------------------------- - statement function: Special Term, Widely Used, Obsolescent; = untermify, do not index here because it is not a definition. Were statement functions not obsolescent it should definitely be a proper defined term. Should it be indexed everywhere? - interface: Special Term; = termify, index as definition. - abstract interface: Special Term; = termify, index as definition. - specific interface: Antonym Of Defined Term; Widely Used With Variation, Not A Definition; = termify, index not as definition. - module procedure interface body: Too Long, Too Misleading; = untermify, rename as "separate interface body", index as definition, reword usage to avoid when unnecessary. - module procedure interface: Completely Spurious; = just delete "module procedure", reword/delete uses. A "module procedure interface (body)" *IS* a declaration of a procedure! It declares its interface - just like a normal interface body is a declaration of an external procedure. - IMPORT statement: It's A Statement; = untermify, index as statement. - PROCEDURE statement: It's A Statement; = untermify, index as statement. - generic name: Subset Of Existing Term (generic identifier); = untermify, do not index, reword? - TKR compatible: Only Used In 12.4.3.4.5 (plus Annex C); = untermify, index as definition. - distinguishable: Only Used In 12.4.3.4.5 (plus Annex C); = untermify, index as definition. - effective position: Only Used in 12.4.3.4.5 paras 3&4 (the same page); = untermify, index as definition. - procedure declaration statement: It's A Statement; = untermify, index as statement. - element sequence: Special Term, Only In Clause 12; = untermify, index as definition. - present: Normal Usage; = untermify, index as definition. - function subprogram: Special Term, BNF Analogue, Obvious; = untermify, do not index. - FUNCTION statement: It's A Statement; = untermify, index as statement. - subroutine subprogram: Special Term, BNF Analogue, Obvious; = untermify, do not index. - SUBROUTINE statement: It's A Statement; = untermify, index as statement. - instance: Normal Usage; = untermify, index not as definition. - separate module procedure: Special Term, Not Used Much, Variant; = untermify, index as definition. - correspond: Unnecessary; = delete and reword. - ENTRY statement: It's A Statement, Font Only; = unfontify, index as statement. - RETURN statement: It's A Statement, Font Only; = unfontify, index as statement. - CONTAINS statement: It's A Statement, Font Only; = unfontify, index as statement. 3. Edits to 09-007 ------------------ [c01] Define terms "\term{abstract interface} set of procedure characteristics with dummy argument names (\ref{D12:Interface and abstract interface}) \term{interface} of a procedure, its name, procedure characteristics, dummy argument names, binding label, and generic identifiers (\ref{D12:Interface and abstract interface}) \subtermm{specific}{interface} \termi{interface} identified by a nongeneric name" {NOTE: An abstract interface is ***NOT*** a kind of interface, thus it needs to be its own top-level term.} [throughout] Hyperlink the above terms as appropriate. CONSIDER: [10:5-7(1.3.61)] Make "generic interface" a subterm of "interface". [10:37(1.3.69.1p1)] Before "abstract interfaces" insert "named". {The key point of an abstract interface block is that it is used to give an abstract interface a name; this fact should be in the definition.} [275:2(11.2.2p2)] Delete "interface blocks,", {If "interface blocks" are not declaring procedure, abstract interfaces, and generic identifiers, and nothing else, then I'm confused.} delete module procedure interfaces," {And these are covered by "procedures", and were also covered by "interface blocks"! Triple redundancy!} [277:9(11.2.3p3)] Before "module procedures" insert "separate", and afterwards insert "(12.6.2.5)". {That's what we mean. 12.6.2.5 is \ref{D12:Separate module procedures}.} [277:9-10(11.2.3p3)] Delete "by a module procedure interface body", after "12.4.3.2" insert ", 12.6.2.5". {Remove a redundancy, insert appropriate cross-ref. [282:9(12.2.2.5p1)] Unembolden "statement function", do not index. [283:4(12.4.1 heading)] Rename to be "Interface and abstract interface". {Pick a better name for this subclause.} [283:5(12.4.1p1)] Unembolden "interface", index as definition. [283:6-7(12.4.1p1)] Change "its abstract ... if any." to "its name, binding label, generic identifiers, characteristics, and the names of its dummy arguments". {If we don't need "if any" after "dummy arguments", we don't need it after "binding label" and "generic identifiers" either. Also, procedures don't have abstract interfaces (that definition does not tie an abstract interface to a procedure, quite rightly) so list the actual things. Also, "name", "binding label", and "generic identifiers" are all identifiers of the procedure so list them together. Finally, factor out "its" which was not even being used consistently.} [283:7-9(12.4.1p1)] After "characteristics" insert "and binding label", after "names," delete "binding label,". {This used to say that the binding label could be different in different scoping units, which is wrong seeing as how that is a global identifier and not subject to use-renaming. The fixedness of the binding label is not a special feature of separate module procedures.} [283:9(12.4.1p1)] "module procedure"->"separate". [283:11 (12.4.1p2)] Unembolden "abstract interface", index as definition, and change "consists of"->"is a set of", "and the names of dummy arguments"->"with the dummy argument names". {Improve wording. Use "with" to indicate its the dummy arguments in the characteristics that have the names...} [285:21(12.4.3.2p4)] "<>" ->"separate interface body", index as definition. [285:22(12.4.3.2p4)] "defines the <>" ->"specifies the interface". {We don't need a new term for "interface" just because it's one for a separate module procedure.} [285:27(12.4.3.2 C1210)] Delete constraint. {All the other constraints on MODULE in the prefix are on p310.} [286:6(12.4.3.3p1)] Unembolden "IMPORT statement", index as statement. [287:3-4(12.4.3.4.1p1)] Unembolden "PROCEDURE statement", index as stmt. [287:9(12.4.3.4.1p3)] Change "<> ... reference" to "generic name is a generic identifier that refers to". {NB: Hyperlink generic identifier.} [289:17(12.4.3.4.5p2)] Unembolden "TKR compatible", index as definition. [289:20(12.4.3.4.5p3)] Unembolden "distinguishable", index as definition. [289:27(12.4.3.4.5p4)] Unembolden "effective position", index as defn. [291:2(12.4.3.6p1)] Unembolden "procedure declaration statement", index as statement. [302:30(12.5.2.11p1)] Unembolden "element sequence", index as definition. [303:11(12.5.2.12p1)] Unembolden "present", index as definition. [310:13(12.6.2.1 C1246)] "an"->"a nonabstract" before "interface body". {Make this syntax constraint do the correct restriction.} [310:21(12.6.2.1 C1249)] "module procedure"->"separate". [310:23(12.6.2.1 C1250)] "module procedure"->"separate". [310:31(12.6.2.2p1)] Unembolden "function subprogram", do not index. [310:31(12.6.2.2p1)] Unembolden "FUNCTION statement", index as statement. [312:2(12.6.2.3p1)] Unembolden "subroutine subprogram", do not index. [312:2(12.6.2.3p1)] Unembolden "SUBROUTINE statement", index as statement. [313:7(12.6.2.4p1)] Unembolden "instance", index not as definition. [313:21(12.6.2.5p1)] Unembolden "separate module procedure", index as definition. [313:24(12.6.2.5p1)] "module procedure interface"->"separate interface". [313:24-25(12.6.2.5p1)] "module or submodule"->"program unit", "module or submodule"->"thereof". {Simplify.} [313:34(12.6.2.5 C1261)] Replace entire constraint "The shall have been declared to be a separate module procedure in the containing program unit or an ancestor of that program unit." {Simplify and avoid unnecessary terminology.} [314:1-5(12.6.2.5p2)] Replace entire paragraph with "A separate module procedure shall not be defined more than once." {Simplify. We don't need all this correspond guff, the scoping rules are quite sufficient.} [314:6-7(12.6.2.5p3)] Delete whole paragraph. {We already said the whole *INTERFACE* is declared by the separate interface body, back in para 1, we don't need to say that a subset of that interface is also declared by the separate interface body.} [314:9(12.6.2.5p4)] "module procedure interface"->"separate interface". [314:12(12.6.2.6p1)] Unembolden "ENTRY statement", index as statement. [314:27(12.6.2.7p1)] Unembolden "RETURN statement", index as statement. [314:36(12.6.2.8p1)] Unembolden "CONTAINS statement", index as statement. [448:21-22(16.3.1p3)] Delete ", and a separate ... (12.6.2.5)". {Once we get over the silliness of making the interface of a separate module procedure into a separate entity, we can forget about excluding the results of that silliness.} [452:2(16.5.1.4p1)] "module procedure interface"->"separate interface". {Did I mention how much I hate having different classes of interface body having different incompatible scoping rules?} [452:4(16.5.1.4p1)] "module procedure interface"->"separate interface". {Did I mention how much I hate having different classes of interface body having different incompatible scoping rules?} [452:8(16.5.1.4p1)] Delete "module procedure interfaces,". {These are "procedures" what are being accessed.} [453:0+1(16.5.1.4 Note 16.8)] "module procedure"->"separate". {Did I mention how much I hate having different classes of interface body having different incompatible scoping rules?} [509:19-21(C.8.4p2)] Replace "If ... by use association." by "A separate module procedure that is declared in a module to have public accessibility can be accessed by use association even if it is defined in a submodule." {Once again, we declare it with a separate interface body, and define it by a subprogram with the MODULE keyword. The same entity. Not two different ones with the same name.} [510:23(C.8.4p7)] Before "separate" insert "the", Replace "for which ... are provided" by "that were declared". {Simplify and correct.} [411:6(C.8.4 p9+)] "module procedure interfaces" ->"separate module procedures". ===END===