DataMuseum.dk

top - metrics - download

    Length: 19712 (0x4d00)
    Types: TextFile
    Names: »EOSP.OV1«

└─⟦61d7681d7⟧ Bits:30009789/_.ft.Ibm2.50006629.imd Mogens Pelles Zilog 80,000 / EOS projekt
    └─⟦this⟧ »EOSP.OV1« 

TextFile

^U1. Indledning.^u

     Formålet med dette skrift er at give læseren en bedre
oversigt over EosPascal end man får ved læsning af Erik Reehs
EosPascal-manual. Endvidere indeholder skriftet en del
kommentarer til og uddybninger af forskellige EosPascal-faciliteter.
     I afsnit 2 gengives den komplette syntaks for EosPascal, og i
afsnit 3 gøres der rede for virkefeltsreglerne. Endelig indeholder
afsnit 4 kommentarer og uddybninger.


^U2. Syntaks for EosPascal.^u

     Nedenstående syntaksbeskrivelse for EosPascal er fremkommet
ved sammenskrivning af de syntaksregler, der findes i ISO-standarden
for Pascal og i Erik Reehs EosPascal-manual. Dog er syntaksreglerne
for "conformant array parameters" udeladt, da denne konstruktion
$#liste 48
$#punkt -
er en tilføjelse til Pascal, som er gjort under standardiseringsarbejdet,
$#punkt -
er valgfri (man kan undlade at implementere den, og alligevel
hævde, at oversætteren accepterer standard-Pascal).
$#punkt -
er uinteressant for os, da den overlapper kraftigt med EosPascals
"adaptable arrays".
$#liste0

     Endvidere er alt om filer og standard-I/O udeladt, da vi har
aftalt ikke at medtage dette i EosPascal-oversætteren. Endelig er
procedurer og funktioner som parametre udeladt. De bruges (så vidt
jeg ved) ikke i Eos-teksterne, og så slipper jeg da for at implementere
^Udet^u.
     Syntaksreglerne er skrevet på den måde, der bruges i
Pascal-standarden (for at gøre det lettere for mig at skrive af).
Bemærk, at Erik Reeh har brugt en notation, der afviger lidt.
Der er også lidt forskel i den "stil", der bruges de to steder. Dette
har gjort det nødvendigt at foretage mindre ændringer i syntaksreglerne
(både standard-Pascal-reglerne og EosPascal-reglerne). Disse ændringer
er ^Uikke^u afmærkede på nogen måde.
     Dele af syntaksregler, der stammer fra EosPascal-manualen,
er understregede. Hvis en hel syntaksregel stammer fra EosPascal-manualen,
er dog kun nonterminalens navn understreget. På denne måde kan man
også se, hvilke nonterminaler, der er særegne for EosPascal.
     Ind i mellem vil man finde kommentarer til syntaksreglerne.
Disse kommentarer er på engelsk,
da der bruges visse engelske specialtegn i syntaksreglerne, og
det er besværligt hele tiden at skifte mellem dansk og amerikansk
tegnsæt på skriveren.
$#kopier
▶1b◀R


-- The following is Standard-Pascal, but probably should be
left out (!)

program = program-heading ";" program-block "." .
program-heading = "program" identifier
                  Æ "(" program-parameters ")" Å .
program-parameters = identifier-list .
program-block = block .


-- The following is the corresponding EosPascal syntax:

^UEosPascal-program^u = "object" "program" identifier ";"
                    æ constant-definition-part
                    ø type-definition-part
                    ø procedure-and-function-declaration-part
                    ø object-type-definition
                    ø program-segment-definition
                    ø program-segment-selection
                    ø object-implementation
                    å
                    installation-part
                    "end" "." .

block = label-declaration-part
        constant-definition-part
        type-definition-part
        variable-declaration-part
        procedure-and-function-declaration-part
        statement-part .

-- Note that declarations come in a fixed order; e.g. no
   variable declarations after a procedure declaration.
   I am not sure that this is required in EosPascal. It
   certainly is not required in the list of declarations
   that constitute an EosPascal-program or an object
   implementation (but of course these are not blocks...)

label-declaration-part =    Æ "label" label
                              æ "," label å ";" Å .

constant-definition-part =  Æ "const" constant-definition ";"
                              æ constant-definition ";" å Å .

type-definition-part =      Æ "type" type-definition ";"
                              æ type-definition ";" å Å .

variable-declaration-part = Æ "var" variable-declaration ";"
                              æ variable-declaration ";" å Å .

procedure-and-function-declaration-part =
                            æ ( procedure-declaration
                              ø function-declaration ) ";" å .

statement-part = compound-statement .


constant-definition = identifier "=" constant .
constant = Æ sign Å (unsigned-number ø constant-identifier)
         ø character-string .
constant-identifier = identifier .

-- General note: Occurrences of identifiers may be of two
   kinds: Defining occurrences and applied occurrences.
   In the syntax, the nonterminal "identifier" is used for
   defining occurrences of identifiers. In applied
   occurrences, nonterminals like "constant-identifier",
   "variable-identifier" etc. are used.

type-definition = identifier "=" type-denoter .
type-denoter = type-identifier ø new-type .
new-type = new-ordinal-type
         ø new-array-type
         ø new-record-type
         ø new-set-type
         ^Uø new-adaptable-type^u
         ø new-pointer-type
         ^Uø new-kernel-pointer-type^u .

simple-type-identifier = type-identifier .
array-type-identifier = type-identifier .
record-type-identifier = type-identifier .
set-type-identifier = type-identifier .
^Uadaptable-type-identifier^u = type-identifier .
pointer-type-identifier = type-identifier .
^Ukernel-pointer-type-identifier^u = type-identifier .
type-identifier = identifier .

simple-type = ordinal-type ø real-type-identifier .
ordinal-type = new-ordinal-type ø ordinal-type-identifier .
new-ordinal-type = enumerated-type ø subrange-type .
ordinal-type-identifier = type-identifier .
real-type-identifier = type-identifier .

-- And then there are the "required identifiers": ^Kreal^k,
   ^Kinteger^k, ^Kboolean^k, ^Kchar^k.

enumerated-type = "(" identifier-list ")" .
identifier-list = identifier æ "," identifier å .

subrange-type = constant ".." constant .

-- Note to "packed" types below:
   Since the EosPascal compiler is built upon the Pascal-P
   compiler (in the last end), and the Pascal-P compiler
   accepts the keyword "packed", but discards it, I think
   that "packed" in EosPascal has no effect. This is in
   contrast to standard Pascal, where it affects parameter
   passing to procedures (and others), even if no packing
   actually takes place.

array-type = new-array-type ø array-type-identifier .
new-array-type = Æ "packed" Å unpacked-array-type .
unpacked-array-type = "array" "Æ" index-type æ
                                  "," index-type å "Å"
                      "of" component-type .
index-type = ordinal-type .
component-type = type-denoter .

record-type = new-record-type ø record-type-identifier .
new-record-type = Æ "packed" Å unpacked-record-type .
unpacked-record-type = "record" field-list "end" .
field-list = Æ ( fixed-part Æ ";" variant-part Å
               ø variant-part
               ) Æ ";" Å
             Å .
fixed-part = record-section æ ";" record-section å .
record-section = identifier-list ":" type-denoter .
variant-part = "case" variant-selector "of" variant
                                       æ ";" variant å .
variant-selector = Æ tag-field ":" Å tag-type .
tag-field = identifier .
variant = case-constant-list ":" "(" field-list ")" .
tag-type = ordinal-type-identifier .
case-constant-list = case-constant æ "," case-constant å .
case-constant = constant .

set-type = new-set-type ø set-type-identifier .
new-set-type = Æ "packed" Å unpacked-set-type .
unpacked-set-type = "set" "of" base-type .
base-type = ordinal-type .

^Uadaptable-type^u = new-adaptable-type ø adaptable-type-identifier .
^Unew-adaptable-type^u = "^^" adaptable-target .
^Uadaptable-target^u = "Æ" "Å" target-array-type-identifier .
^Utarget-array-type-identifier^u = array-type-identifier .

pointer-type = new-pointer-type ø pointer-type-identifier .
new-pointer-type = "^^" domain-type .
domain-type = type-identifier .

^Ukernel-pointer-type^u = new-kernel-pointer-type
                    ø kernel-pointer-type-identifier .
^Unew-kernel-pointer-type^u = "^^^^" target .
^Utarget^u = object-type-identifier
       ø type-identifier
       ø segment-identifier
       ø adaptable-target
       ø empty .
^Uempty^u = .

-- Note that type-^Uidentifiers^u and not type-^Udenoters^u
   are possible domain-types and targets.
   Note also that object-type-identifiers are ^Unot^u
   type-identifiers, since object types are not types
   (foolish name clash!)

variable-declaration = identifier-list ":" type-denoter .

variable-access = entire-variable
                ø component-variable
                ø identified-variable
                ^Uø target-variable^u
                ^Uø typed-variable^u .

entire-variable = variable-identifier .
variable-identifier = identifier .

component-variable = indexed-variable ø field-designator .

indexed-variable = array-component
                 ^Uø adaptable-array-component^u .

array-component = array-variable "Æ" index-expression
                               æ "," index-expression å "Å" .
array-variable = variable-access .
^Uadaptable-array-component^u =
                  adaptable-array "Æ" index-expression
                               æ "," index-expression å "Å" .
^Uadaptable-array^u = adaptable-array-variable
                ø array slice .
^Uadaptable-array-variable^u = variable-access .
^Uarray-slice^u = array-variable "Æ" æ index-expression "," å
                                 range "Å"
            ø adaptable-array "Æ" æ index-expression "," å
                                  range "Å"
^Urange^u = index-expression ".." index-expression .
index-expression = expression .

field-designator = record-variable "." field-specifier
                 ø field-designator-identifier .
record-variable = variable-access .
field-specifier = field-identifier .
field-identifier = identifier .

identified-variable = pointer-variable "^^" .
pointer-variable = variable-access .

^Utarget-variable^u = kernel-pointer-variable "^^^^" .
^Ukernel-pointer-variable^u = variable-access .

^Utyped-variable^u = variable-access ":" type-identifier .


procedure-declaration = procedure-heading ";" directive
                      ø procedure-identification ";"
                        procedure-block
                      ø procedure-heading ";" procedure-block .
procedure-heading = "procedure" identifier
                    Æ formal-parameter-list Å .
procedure-identification = "procedure" procedure-identifier .
procedure-identifier = identifier .
procedure-block = block .

directive = "forward" .

-- And possibly also "external".

$#ny-side
function-declaration = function-heading ";" directive
                     ø function-identification ";"
                       function-block
                     ø function-heading ";" function-block .
function-heading = "function" identifier
                   Æ formal-parameter-list Å ":" result-type.
function-identification = "function" function-identifier .
function-identifier = identifier .
result-type = simple-type-identifier ø pointer-type-identifier .
function-block = block .

formal-parameter-list = "(" formal-parameter-section
                        æ ";" formal-parameter-section å ")" .

formal-parameter-section = value-parameter-specification
                         ø variable-parameter-specification
                         ^Uø universal-parameter-specification^u .

-- Procedural and functional parameters have been left out.

value-parameter-specification = parameter-group .
variable-parameter-specification = "var" parameter-group .
^Uuniversal-parameter-specification^u = "univ" parameter-group
                                  ø "univ" "var" parameter-group .
parameter-group = identifier-list ":" type-identifier .


^Uentry-definition^u = entry-head external-name ";" .
^Uentry-implementation^u = entry-head
                       "with" temporary-kernel-pointers ";"
                       block ";" .
^Uentry-head^u = entry-kind identifier entry-argument-part .
^Uentry-kind^u = "entry" ø "private" ø "otherwise" .
^Uexternal-name^u = character-string .

-- In the EosPascal program that we have got, "external-names"
   are not actually used in entry-definitions and object-type-
   definitions (below). They are used ^Uonly^u in installation-
   parts (also below) !

^Uentry-argument-part^u = Æ "(" entry-arguments
                            æ ";" entry-arguments å ")" Å
^Uentry-arguments^u = direction identifier-list ":" type-identifier .
^Udirection^u = empty ø "in" ø "out" ø "in" "out" .

^Utemporary-kernel-pointers^u = kernel-pointer-record-type .
^Ukernel-pointer-record-type^u = record-type .


^Uobject-type-definition^u = "object" identifier external-name ";"
                         æ constant-definition-part
                         ø type-definition-part
                         ø entry-definition
                         ø object-type-definition
                         å
                         "end" ";" .

-- The last line is an amendment (and hopefully a correction)
   to the EosPascal manual.

^Uidentifier^u > qualified-identifier .
^Uqualified-identifier^u = qualifier "." identifier .
^Uqualifier^u = object-type-identifier .
^Uobject-type-identifier^u = identifier .

-- The ">" replacing a "=" in the definition of "identifier"
   means that this is not the only definition of that
   nonterminal. It corresponds to the "::+" used by Erik Reeh.

^Uobject-implementation^u = "program" identifier "object" implemented
                        "with" local-kernel-pointers
                          æ constant-definition-part
                          ø type-definition-part
                          ø entry-definition
                          ø entry-implementation
                          ø procedure-and-function-declaration-part
                          ø program-segment-definition
                          ø program-segment-selection
                          æ
                        "end" ";" .
^Uimplemented^u = object-type-identifier .
^Ulocal-kernel-pointers^u = kernel-pointer-record-type .


^Uprogram-segment-definition^u = "seg" identifier variable-part ";" .
^Uvariable-part^u = Æ "with" type-denoter Å .

^Uprogram-segment-selection^u = "seg" segment-identifier ":" .
^Usegment-identifier^u = identifier .


^Uinstallation-part^u = Æ "initialize" implementation-identifier
                       external-name ":"
                       local-kernel-pointer-initialization
                       æ "," local-kernel-pointer-initialization å
                    Å
^Ulocal-kernel-pointer-initialization^u = field-identifier
                                      Æ external-name Å
^Ufield-identifier^u = identifier .


expression = simple-expression
             Æ relational-operator simple-expression Å
simple-expression = Æ sign Å term æ adding-operator term å .
term = factor æ multiplying-operator factor å .
factor = variable-access
       ø unsigned-constant
       ø function-designator
       ø set-constructor
       ø "(" expression ")"
       ø "not" factor
       ^Uø array-slice^u
       ^Uø entry-number^u
       ^Uø object-call^u .

unsigned-constant = unsigned-number
                  ø character-string
                  ø constant-identifier
                  ø "nil" .

set-constructor = "Æ" Æ member-designator
                        æ "," member-designator å Å "Å" .
member-designator = expression Æ ".." expression Å .

^Uentry-number^u = entry-identifier .
^Uentry-identifier^u = identifier .

^Uobject-call^u = entry Æ "(" reference-arguments value-arguments ")" Å
^Uentry^u = kernel-pointer-variable "." ( entry-identifier
                                    ø expression ) .
^Ureference-arguments^u = Æ reference-argument
                        æ "," reference-argument å Å .
^Ureference-argument^u = direction expression
                   ø subsegment-argument
                   ø "while" Boolean-expression "do"
                       "(" reference-argument
                           æ "," reference-argument å ")" .
^Usubsegment-argument^u = "var" use expression .
^Uuse^u = Æ "program" Å direction .
^Uvalue-arguments^u = Æ ";" value-argument æ "," value-argument å Å .
^Uvalue-argument^u = direction expression
               ø "while" Boolean-expression "do"
                   "(" value-argument æ "," value-argument å ")" .


multiplying-operator = "*" ø "/" ø "div" ø "mod" ø "and" .
adding-operator = "+" ø "-" ø "or" .
relational-operator = "=" ø "<>" ø "<" ø ">" ø "<=" ø ">=" ø "in" .

function-designator = function-identifier
                      Æ actual-parameter-list Å .
actual-parameter-list = "(" actual-parameter
                        æ "," actual-parameter å ")" .
actual-parameter = expression ø variable-access .


Boolean-expression = expression .

statement = Æ label ":" Å ( simple-statement
                          ø structured-statement ) .
simple-statement = empty-statement
                 ø assignment-statement
                 ø procedure-statement
                 ø goto-statement .

empty-statement = .
assignment-statement = ( variable-access ø function-identifier )
                       ":=" expression .
procedure-statement = procedure-identifier
                      Æ actual-parameter-list Å .

-- The special kinds of parameter lists to the I/O procedures
   "read", "readln", "write" and "writeln" have been omitted.

goto-statement = "goto" label .

structured-statement = compound-statement
                     ø conditional-statement
                     ø repetitive-statement
                     ø with-statement
                     ^Uø exception-statement^u .
statement-sequence = statement æ ";" statement å .

compound-statement = "begin" statement-sequence "end" .

conditional-statement = if-statement ø case-statement .

if-statement = "if" Boolean-expression "then" statement
               Æ else-part Å .
else-part = "else" statement .

$#ny-side
case-statement = "case" case-index "of" case-list-element
                 æ ";" case-list-element å Æ ";" Å "end" .
case-list-element = case-constant-list ":" statement .
case-index = expression .

repetitive-statement = repeat-statement
                     ø while-statement
                     ø for-statement .

repeat-statement = "repeat" statement-sequence
                   "until" Boolean-expression .

while-statement = "while" Boolean-expression "do" statement .

for-statement = "for" control-variable ":=" initial-value
                ( "to" ø "downto" ) final-value "do" statement .
control-variable = entire-variable .
initial-value = expression .
final-value = expression .

with-statement = "with" with-list "do" statement .
with-list = with-element æ "," with-element å .
with-element = record-variable
             ^Uø synonym-element^u
             ^Uø mapping-element^u .
^Usynonym-element^u = identifier "=" variable-access
                ø identifier "=" array-slice .
^Umapping-element^u = record-variable
                ø synonym-element .
field-designator-identifier = identifier.

^Uexception-statement^u = "in" statement-sequence "do" statement .
▶1b◀R▶04◀
$#formatter ny-side
«eof»