EP [0, 810] PROGRAM arrayc (output);
PROGRAM arrayc (output);

  { Extended Pascal examples http://ideone.com/YXpi4n }
  { Array constant & constant access }

TYPE  days = (sun,mon {First work day},tues,weds,thurs,fri, {Party!} sat);
      dname = string(8);

VAR   d: days;

FUNCTION DayName (fd: days): dname;
    { Elements of the array constant DayNames can be
      selected with a variable index }
  TYPE  abbrevs = ARRAY [days] OF
          PACKED ARRAY [1..5] OF char;
  CONST DayNames = abbrevs
    [ sun: 'Sun'; mon: 'Mon'; tues: 'Tues';
      weds: 'Weds'; thurs: 'Thurs'; fri: 'Fri';
      sat: 'Satur' ];
  BEGIN
    DayName := trim(DayNames[fd]) + 'day';
  END {DayName};

BEGIN {program}
  FOR d := fri DOWNTO mon DO writeln(DayName(d));
END.

  { Generated output is:
    Friday
    Thursday
    Wedsday
    Tuesday
    Monday
  }
EP.BNVCompileUnit [0, 810] PROGRAM arrayc (output);
PROGRAM arrayc (output);

  { Extended Pascal examples http://ideone.com/YXpi4n }
  { Array constant & constant access }

TYPE  days = (sun,mon {First work day},tues,weds,thurs,fri, {Party!} sat);
      dname = string(8);

VAR   d: days;

FUNCTION DayName (fd: days): dname;
    { Elements of the array constant DayNames can be
      selected with a variable index }
  TYPE  abbrevs = ARRAY [days] OF
          PACKED ARRAY [1..5] OF char;
  CONST DayNames = abbrevs
    [ sun: 'Sun'; mon: 'Mon'; tues: 'Tues';
      weds: 'Weds'; thurs: 'Thurs'; fri: 'Fri';
      sat: 'Satur' ];
  BEGIN
    DayName := trim(DayNames[fd]) + 'day';
  END {DayName};

BEGIN {program}
  FOR d := fri DOWNTO mon DO writeln(DayName(d));
END.

  { Generated output is:
    Friday
    Thursday
    Wedsday
    Tuesday
    Monday
  }
EP.Program [0, 810] PROGRAM arrayc (output);
PROGRAM arrayc (output);

  { Extended Pascal examples http://ideone.com/YXpi4n }
  { Array constant & constant access }

TYPE  days = (sun,mon {First work day},tues,weds,thurs,fri, {Party!} sat);
      dname = string(8);

VAR   d: days;

FUNCTION DayName (fd: days): dname;
    { Elements of the array constant DayNames can be
      selected with a variable index }
  TYPE  abbrevs = ARRAY [days] OF
          PACKED ARRAY [1..5] OF char;
  CONST DayNames = abbrevs
    [ sun: 'Sun'; mon: 'Mon'; tues: 'Tues';
      weds: 'Weds'; thurs: 'Thurs'; fri: 'Fri';
      sat: 'Satur' ];
  BEGIN
    DayName := trim(DayNames[fd]) + 'day';
  END {DayName};

BEGIN {program}
  FOR d := fri DOWNTO mon DO writeln(DayName(d));
END.

  { Generated output is:
    Friday
    Thursday
    Wedsday
    Tuesday
    Monday
  }
EP.ProgramBlock [0, 810] PROGRAM arrayc (output);
PROGRAM arrayc (output);

  { Extended Pascal examples http://ideone.com/YXpi4n }
  { Array constant & constant access }

TYPE  days = (sun,mon {First work day},tues,weds,thurs,fri, {Party!} sat);
      dname = string(8);

VAR   d: days;

FUNCTION DayName (fd: days): dname;
    { Elements of the array constant DayNames can be
      selected with a variable index }
  TYPE  abbrevs = ARRAY [days] OF
          PACKED ARRAY [1..5] OF char;
  CONST DayNames = abbrevs
    [ sun: 'Sun'; mon: 'Mon'; tues: 'Tues';
      weds: 'Weds'; thurs: 'Thurs'; fri: 'Fri';
      sat: 'Satur' ];
  BEGIN
    DayName := trim(DayNames[fd]) + 'day';
  END {DayName};

BEGIN {program}
  FOR d := fri DOWNTO mon DO writeln(DayName(d));
END.

  { Generated output is:
    Friday
    Thursday
    Wedsday
    Tuesday
    Monday
  }
EP.ProgramComponent [0, 720] PROGRAM arrayc (output);
PROGRAM arrayc (output);

  { Extended Pascal examples http://ideone.com/YXpi4n }
  { Array constant & constant access }

TYPE  days = (sun,mon {First work day},tues,weds,thurs,fri, {Party!} sat);
      dname = string(8);

VAR   d: days;

FUNCTION DayName (fd: days): dname;
    { Elements of the array constant DayNames can be
      selected with a variable index }
  TYPE  abbrevs = ARRAY [days] OF
          PACKED ARRAY [1..5] OF char;
  CONST DayNames = abbrevs
    [ sun: 'Sun'; mon: 'Mon'; tues: 'Tues';
      weds: 'Weds'; thurs: 'Thurs'; fri: 'Fri';
      sat: 'Satur' ];
  BEGIN
    DayName := trim(DayNames[fd]) + 'day';
  END {DayName};

BEGIN {program}
  FOR d := fri DOWNTO mon DO writeln(DayName(d));
END.
EP.MainProgramDeclaration [0, 719] PROGRAM arrayc (output);
PROGRAM arrayc (output);

  { Extended Pascal examples http://ideone.com/YXpi4n }
  { Array constant & constant access }

TYPE  days = (sun,mon {First work day},tues,weds,thurs,fri, {Party!} sat);
      dname = string(8);

VAR   d: days;

FUNCTION DayName (fd: days): dname;
    { Elements of the array constant DayNames can be
      selected with a variable index }
  TYPE  abbrevs = ARRAY [days] OF
          PACKED ARRAY [1..5] OF char;
  CONST DayNames = abbrevs
    [ sun: 'Sun'; mon: 'Mon'; tues: 'Tues';
      weds: 'Weds'; thurs: 'Thurs'; fri: 'Fri';
      sat: 'Satur' ];
  BEGIN
    DayName := trim(DayNames[fd]) + 'day';
  END {DayName};

BEGIN {program}
  FOR d := fri DOWNTO mon DO writeln(DayName(d));
END
EP.ProgramHeading [0, 23] PROGRAM arrayc (output)
PROGRAM arrayc (output)
EP.PROGRAM [0, 7] PROGRAM
PROGRAM
EP.BNVProgramName [8, 14] arrayc
arrayc
EP.Identifier [8, 14] arrayc
arrayc
EP.BNVAnyIdentifier [8, 14] arrayc
arrayc
EP.ProgramParameterList [16, 22] output
output
EP.IdentifierList [16, 22] output
output
EP.Identifier [16, 22] output
output
EP.BNVAnyIdentifier [16, 22] output
output
EP.MainProgramBlock [28, 719] { Extended Pascal examples http://ideone.com/YXpi4n }
{ Extended Pascal examples http://ideone.com/YXpi4n }
  { Array constant & constant access }

TYPE  days = (sun,mon {First work day},tues,weds,thurs,fri, {Party!} sat);
      dname = string(8);

VAR   d: days;

FUNCTION DayName (fd: days): dname;
    { Elements of the array constant DayNames can be
      selected with a variable index }
  TYPE  abbrevs = ARRAY [days] OF
          PACKED ARRAY [1..5] OF char;
  CONST DayNames = abbrevs
    [ sun: 'Sun'; mon: 'Mon'; tues: 'Tues';
      weds: 'Weds'; thurs: 'Thurs'; fri: 'Fri';
      sat: 'Satur' ];
  BEGIN
    DayName := trim(DayNames[fd]) + 'day';
  END {DayName};

BEGIN {program}
  FOR d := fri DOWNTO mon DO writeln(DayName(d));
END
EP._ [28, 122] { Extended Pascal examples http://ideone.com/YXpi4n }
{ Extended Pascal examples http://ideone.com/YXpi4n }
  { Array constant & constant access }

EP.TrailingComment [28, 81] { Extended Pascal examples http://ideone.com/YXpi4n }
{ Extended Pascal examples http://ideone.com/YXpi4n }
EP.CommentOpen [28, 29] {
{
EP.CommentContent [29, 80] Extended Pascal examples http://ideone.com/YXpi4n
 Extended Pascal examples http://ideone.com/YXpi4n 
EP.CommentClose [80, 81] }
}
EP.Spacing [81, 84]
  
EP.TrailingComment [84, 120] { Array constant & constant access }
{ Array constant & constant access }
EP.CommentOpen [84, 85] {
{
EP.CommentContent [85, 119] Array constant & constant access
 Array constant & constant access 
EP.CommentClose [119, 120] }
}
EP.Spacing [120, 122]

EP.Block [122, 719] TYPE days = (sun,mon {First work day},tues,weds,thurs,fri, {Party!} sat);
TYPE  days = (sun,mon {First work day},tues,weds,thurs,fri, {Party!} sat);
      dname = string(8);

VAR   d: days;

FUNCTION DayName (fd: days): dname;
    { Elements of the array constant DayNames can be
      selected with a variable index }
  TYPE  abbrevs = ARRAY [days] OF
          PACKED ARRAY [1..5] OF char;
  CONST DayNames = abbrevs
    [ sun: 'Sun'; mon: 'Mon'; tues: 'Tues';
      weds: 'Weds'; thurs: 'Thurs'; fri: 'Fri';
      sat: 'Satur' ];
  BEGIN
    DayName := trim(DayNames[fd]) + 'day';
  END {DayName};

BEGIN {program}
  FOR d := fri DOWNTO mon DO writeln(DayName(d));
END
EP.TypeDefinitionPart [122, 223] TYPE days = (sun,mon {First work day},tues,weds,thurs,fri, {Party!} sat);
TYPE  days = (sun,mon {First work day},tues,weds,thurs,fri, {Party!} sat);
      dname = string(8);

EP._ [126, 128]
  
EP.Spacing [126, 128]
  
EP.TypeDefinition [128, 195] days = (sun,mon {First work day},tues,weds,thurs,fri, {Party!} sat)
days = (sun,mon {First work day},tues,weds,thurs,fri, {Party!} sat)
EP.BNVTypeDefName [128, 132] days
days
EP.Identifier [128, 132] days
days
EP.BNVAnyIdentifier [128, 132] days
days
EP._ [132, 133]
 
EP.Spacing [132, 133]
 
EP._ [134, 135]
 
EP.Spacing [134, 135]
 
EP.TypeDenoter [135, 195] (sun,mon {First work day},tues,weds,thurs,fri, {Party!} sat)
(sun,mon {First work day},tues,weds,thurs,fri, {Party!} sat)
EP.NewType [135, 195] (sun,mon {First work day},tues,weds,thurs,fri, {Party!} sat)
(sun,mon {First work day},tues,weds,thurs,fri, {Party!} sat)
EP.NewOrdinalType [135, 195] (sun,mon {First work day},tues,weds,thurs,fri, {Party!} sat)
(sun,mon {First work day},tues,weds,thurs,fri, {Party!} sat)
EP.EnumeratedType [135, 195] (sun,mon {First work day},tues,weds,thurs,fri, {Party!} sat)
(sun,mon {First work day},tues,weds,thurs,fri, {Party!} sat)
EP.IdentifierList [136, 194] sun,mon {First work day},tues,weds,thurs,fri, {Party!} sat
sun,mon {First work day},tues,weds,thurs,fri, {Party!} sat
EP.Identifier [136, 139] sun
sun
EP.BNVAnyIdentifier [136, 139] sun
sun
EP.COMMA [139, 140] ,
,
EP.Identifier [140, 143] mon
mon
EP.BNVAnyIdentifier [140, 143] mon
mon
EP._ [143, 160] {First work day}
 {First work day}
EP.Spacing [143, 144]
 
EP.InlineComment [144, 160] {First work day}
{First work day}
EP.CommentOpen [144, 145] {
{
EP.CommentContent [145, 159] First work day
First work day
EP.CommentClose [159, 160] }
}
EP.COMMA [160, 161] ,
,
EP.Identifier [161, 165] tues
tues
EP.BNVAnyIdentifier [161, 165] tues
tues
EP.COMMA [165, 166] ,
,
EP.Identifier [166, 170] weds
weds
EP.BNVAnyIdentifier [166, 170] weds
weds
EP.COMMA [170, 171] ,
,
EP.Identifier [171, 176] thurs
thurs
EP.BNVAnyIdentifier [171, 176] thurs
thurs
EP.COMMA [176, 177] ,
,
EP.Identifier [177, 180] fri
fri
EP.BNVAnyIdentifier [177, 180] fri
fri
EP.COMMA [180, 181] ,
,
EP._ [181, 191] {Party!}
 {Party!} 
EP.Spacing [181, 182]
 
EP.InlineComment [182, 190] {Party!}
{Party!}
EP.CommentOpen [182, 183] {
{
EP.CommentContent [183, 189] Party!
Party!
EP.CommentClose [189, 190] }
}
EP.Spacing [190, 191]
 
EP.Identifier [191, 194] sat
sat
EP.BNVAnyIdentifier [191, 194] sat
sat
EP._ [196, 203]
      
EP.Spacing [196, 203]
      
EP.TypeDefinition [203, 220] dname = string(8)
dname = string(8)
EP.BNVTypeDefName [203, 208] dname
dname
EP.Identifier [203, 208] dname
dname
EP.BNVAnyIdentifier [203, 208] dname
dname
EP._ [208, 209]
 
EP.Spacing [208, 209]
 
EP._ [210, 211]
 
EP.Spacing [210, 211]
 
EP.TypeDenoter [211, 220] string(8)
string(8)
EP.DiscriminatedSchema [211, 220] string(8)
string(8)
EP.SchemaName [211, 217] string
string
EP.SchemaIdentifier [211, 217] string
string
EP.Identifier [211, 217] string
string
EP.BNVAnyIdentifier [211, 217] string
string
EP.ActualDiscriminantPart [217, 220] (8)
(8)
EP.DiscriminantValue [218, 219] 8
8
EP.Expression [218, 219] 8
8
EP.SimpleExpression [218, 219] 8
8
EP.Term [218, 219] 8
8
EP.Factor [218, 219] 8
8
EP.Primary [218, 219] 8
8
EP.UnsignedConstant [218, 219] 8
8
EP.UnsignedNumber [218, 219] 8
8
EP.UnsignedInteger [218, 219] 8
8
EP.DigitSequence [218, 219] 8
8
EP._ [221, 223]

EP.Spacing [221, 223]

EP.VariableDeclarationPart [223, 239] VAR d: days;
VAR   d: days;

EP._ [226, 229]
   
EP.Spacing [226, 229]
   
EP.VariableDeclaration [229, 236] d: days
d: days
EP.IdentifierList [229, 230] d
d
EP.Identifier [229, 230] d
d
EP.BNVAnyIdentifier [229, 230] d
d
EP._ [231, 232]
 
EP.Spacing [231, 232]
 
EP.TypeDenoter [232, 236] days
days
EP.TypeName [232, 236] days
days
EP.TypeIdentifier [232, 236] days
days
EP.Identifier [232, 236] days
days
EP.BNVAnyIdentifier [232, 236] days
days
EP._ [237, 239]

EP.Spacing [237, 239]

EP.ProcedureAndFunctionDeclarationPart [239, 650] FUNCTION DayName (fd: days): dname;
FUNCTION DayName (fd: days): dname;
    { Elements of the array constant DayNames can be
      selected with a variable index }
  TYPE  abbrevs = ARRAY [days] OF
          PACKED ARRAY [1..5] OF char;
  CONST DayNames = abbrevs
    [ sun: 'Sun'; mon: 'Mon'; tues: 'Tues';
      weds: 'Weds'; thurs: 'Thurs'; fri: 'Fri';
      sat: 'Satur' ];
  BEGIN
    DayName := trim(DayNames[fd]) + 'day';
  END {DayName};

EP.FunctionDeclaration [239, 647] FUNCTION DayName (fd: days): dname;
FUNCTION DayName (fd: days): dname;
    { Elements of the array constant DayNames can be
      selected with a variable index }
  TYPE  abbrevs = ARRAY [days] OF
          PACKED ARRAY [1..5] OF char;
  CONST DayNames = abbrevs
    [ sun: 'Sun'; mon: 'Mon'; tues: 'Tues';
      weds: 'Weds'; thurs: 'Thurs'; fri: 'Fri';
      sat: 'Satur' ];
  BEGIN
    DayName := trim(DayNames[fd]) + 'day';
  END {DayName}
EP.FunctionHeading [239, 273] FUNCTION DayName (fd: days): dname
FUNCTION DayName (fd: days): dname
EP._ [247, 248]
 
EP.Spacing [247, 248]
 
EP.Identifier [248, 255] DayName
DayName
EP.BNVAnyIdentifier [248, 255] DayName
DayName
EP._ [255, 256]
 
EP.Spacing [255, 256]
 
EP.FormalParameterList [256, 266] (fd: days)
(fd: days)
EP.FormalParameterSection [257, 265] fd: days
fd: days
EP.ValueParameterSpecification [257, 265] fd: days
fd: days
EP.IdentifierList [257, 259] fd
fd
EP.Identifier [257, 259] fd
fd
EP.BNVAnyIdentifier [257, 259] fd
fd
EP._ [260, 261]
 
EP.Spacing [260, 261]
 
EP.ParameterForm [261, 265] days
days
EP.TypeName [261, 265] days
days
EP.TypeIdentifier [261, 265] days
days
EP.Identifier [261, 265] days
days
EP.BNVAnyIdentifier [261, 265] days
days
EP._ [267, 268]
 
EP.Spacing [267, 268]
 
EP.ResultType [268, 273] dname
dname
EP.TypeName [268, 273] dname
dname
EP.TypeIdentifier [268, 273] dname
dname
EP.Identifier [268, 273] dname
dname
EP.BNVAnyIdentifier [268, 273] dname
dname
EP._ [274, 369]
    { Elements of the array constant DayNames can be
      selected with a variable index }
  
EP.Spacing [274, 279]
    
EP.TrailingComment [279, 366] { Elements of the array constant DayNames can be
{ Elements of the array constant DayNames can be
      selected with a variable index }
EP.CommentOpen [279, 280] {
{
EP.CommentContent [280, 365] Elements of the array constant DayNames can be
 Elements of the array constant DayNames can be
      selected with a variable index 
EP.CommentClose [365, 366] }
}
EP.Spacing [366, 369]
  
EP.FunctionBlock [369, 647] TYPE abbrevs = ARRAY [days] OF
TYPE  abbrevs = ARRAY [days] OF
          PACKED ARRAY [1..5] OF char;
  CONST DayNames = abbrevs
    [ sun: 'Sun'; mon: 'Mon'; tues: 'Tues';
      weds: 'Weds'; thurs: 'Thurs'; fri: 'Fri';
      sat: 'Satur' ];
  BEGIN
    DayName := trim(DayNames[fd]) + 'day';
  END {DayName}
EP.Block [369, 647] TYPE abbrevs = ARRAY [days] OF
TYPE  abbrevs = ARRAY [days] OF
          PACKED ARRAY [1..5] OF char;
  CONST DayNames = abbrevs
    [ sun: 'Sun'; mon: 'Mon'; tues: 'Tues';
      weds: 'Weds'; thurs: 'Thurs'; fri: 'Fri';
      sat: 'Satur' ];
  BEGIN
    DayName := trim(DayNames[fd]) + 'day';
  END {DayName}
EP.TypeDefinitionPart [369, 442] TYPE abbrevs = ARRAY [days] OF
TYPE  abbrevs = ARRAY [days] OF
          PACKED ARRAY [1..5] OF char;
  
EP._ [373, 375]
  
EP.Spacing [373, 375]
  
EP.TypeDefinition [375, 438] abbrevs = ARRAY [days] OF
abbrevs = ARRAY [days] OF
          PACKED ARRAY [1..5] OF char
EP.BNVTypeDefName [375, 382] abbrevs
abbrevs
EP.Identifier [375, 382] abbrevs
abbrevs
EP.BNVAnyIdentifier [375, 382] abbrevs
abbrevs
EP._ [382, 383]
 
EP.Spacing [382, 383]
 
EP._ [384, 385]
 
EP.Spacing [384, 385]
 
EP.TypeDenoter [385, 438] ARRAY [days] OF
ARRAY [days] OF
          PACKED ARRAY [1..5] OF char
EP.NewType [385, 438] ARRAY [days] OF
ARRAY [days] OF
          PACKED ARRAY [1..5] OF char
EP.NewStructuredType [385, 438] ARRAY [days] OF
ARRAY [days] OF
          PACKED ARRAY [1..5] OF char
EP.UnpackedStructuredType [385, 438] ARRAY [days] OF
ARRAY [days] OF
          PACKED ARRAY [1..5] OF char
EP.ArrayType [385, 438] ARRAY [days] OF
ARRAY [days] OF
          PACKED ARRAY [1..5] OF char
EP._ [390, 391]
 
EP.Spacing [390, 391]
 
EP.IndexType [392, 396] days
days
EP.OrdinalType [392, 396] days
days
EP.OrdinalTypeName [392, 396] days
days
EP.TypeName [392, 396] days
days
EP.TypeIdentifier [392, 396] days
days
EP.Identifier [392, 396] days
days
EP.BNVAnyIdentifier [392, 396] days
days
EP._ [397, 398]
 
EP.Spacing [397, 398]
 
EP._ [400, 411]
          
EP.Spacing [400, 411]
          
EP.ComponentType [411, 438] PACKED ARRAY [1..5] OF char
PACKED ARRAY [1..5] OF char
EP.TypeDenoter [411, 438] PACKED ARRAY [1..5] OF char
PACKED ARRAY [1..5] OF char
EP.NewType [411, 438] PACKED ARRAY [1..5] OF char
PACKED ARRAY [1..5] OF char
EP.NewStructuredType [411, 438] PACKED ARRAY [1..5] OF char
PACKED ARRAY [1..5] OF char
EP._ [417, 418]
 
EP.Spacing [417, 418]
 
EP.UnpackedStructuredType [418, 438] ARRAY [1..5] OF char
ARRAY [1..5] OF char
EP.ArrayType [418, 438] ARRAY [1..5] OF char
ARRAY [1..5] OF char
EP._ [423, 424]
 
EP.Spacing [423, 424]
 
EP.IndexType [425, 429] 1..5
1..5
EP.OrdinalType [425, 429] 1..5
1..5
EP.NewOrdinalType [425, 429] 1..5
1..5
EP.SubrangeType [425, 429] 1..5
1..5
EP.SubrangeBound [425, 426] 1
1
EP.Expression [425, 426] 1
1
EP.SimpleExpression [425, 426] 1
1
EP.Term [425, 426] 1
1
EP.Factor [425, 426] 1
1
EP.Primary [425, 426] 1
1
EP.UnsignedConstant [425, 426] 1
1
EP.UnsignedNumber [425, 426] 1
1
EP.UnsignedInteger [425, 426] 1
1
EP.DigitSequence [425, 426] 1
1
EP.SubrangeBound [428, 429] 5
5
EP.Expression [428, 429] 5
5
EP.SimpleExpression [428, 429] 5
5
EP.Term [428, 429] 5
5
EP.Factor [428, 429] 5
5
EP.Primary [428, 429] 5
5
EP.UnsignedConstant [428, 429] 5
5
EP.UnsignedNumber [428, 429] 5
5
EP.UnsignedInteger [428, 429] 5
5
EP.DigitSequence [428, 429] 5
5
EP._ [430, 431]
 
EP.Spacing [430, 431]
 
EP._ [433, 434]
 
EP.Spacing [433, 434]
 
EP.ComponentType [434, 438] char
char
EP.TypeDenoter [434, 438] char
char
EP.TypeName [434, 438] char
char
EP.TypeIdentifier [434, 438] char
char
EP.Identifier [434, 438] char
char
EP.BNVAnyIdentifier [434, 438] char
char
EP._ [439, 442]
  
EP.Spacing [439, 442]
  
EP.ConstantDefinitionPart [442, 583] CONST DayNames = abbrevs
CONST DayNames = abbrevs
    [ sun: 'Sun'; mon: 'Mon'; tues: 'Tues';
      weds: 'Weds'; thurs: 'Thurs'; fri: 'Fri';
      sat: 'Satur' ];
  
EP._ [447, 448]
 
EP.Spacing [447, 448]
 
EP.ConstantDefinition [448, 579] DayNames = abbrevs
DayNames = abbrevs
    [ sun: 'Sun'; mon: 'Mon'; tues: 'Tues';
      weds: 'Weds'; thurs: 'Thurs'; fri: 'Fri';
      sat: 'Satur' ]
EP.Identifier [448, 456] DayNames
DayNames
EP.BNVAnyIdentifier [448, 456] DayNames
DayNames
EP._ [456, 457]
 
EP.Spacing [456, 457]
 
EP._ [458, 459]
 
EP.Spacing [458, 459]
 
EP.ConstantExpression [459, 579] abbrevs
abbrevs
    [ sun: 'Sun'; mon: 'Mon'; tues: 'Tues';
      weds: 'Weds'; thurs: 'Thurs'; fri: 'Fri';
      sat: 'Satur' ]
EP.Expression [459, 579] abbrevs
abbrevs
    [ sun: 'Sun'; mon: 'Mon'; tues: 'Tues';
      weds: 'Weds'; thurs: 'Thurs'; fri: 'Fri';
      sat: 'Satur' ]
EP.SimpleExpression [459, 579] abbrevs
abbrevs
    [ sun: 'Sun'; mon: 'Mon'; tues: 'Tues';
      weds: 'Weds'; thurs: 'Thurs'; fri: 'Fri';
      sat: 'Satur' ]
EP.Term [459, 579] abbrevs
abbrevs
    [ sun: 'Sun'; mon: 'Mon'; tues: 'Tues';
      weds: 'Weds'; thurs: 'Thurs'; fri: 'Fri';
      sat: 'Satur' ]
EP.Factor [459, 579] abbrevs
abbrevs
    [ sun: 'Sun'; mon: 'Mon'; tues: 'Tues';
      weds: 'Weds'; thurs: 'Thurs'; fri: 'Fri';
      sat: 'Satur' ]
EP.Primary [459, 579] abbrevs
abbrevs
    [ sun: 'Sun'; mon: 'Mon'; tues: 'Tues';
      weds: 'Weds'; thurs: 'Thurs'; fri: 'Fri';
      sat: 'Satur' ]
EP.StructuredValueConstructor [459, 579] abbrevs
abbrevs
    [ sun: 'Sun'; mon: 'Mon'; tues: 'Tues';
      weds: 'Weds'; thurs: 'Thurs'; fri: 'Fri';
      sat: 'Satur' ]
EP.ArrayTypeName [459, 466] abbrevs
abbrevs
EP.TypeName [459, 466] abbrevs
abbrevs
EP.TypeIdentifier [459, 466] abbrevs
abbrevs
EP.Identifier [459, 466] abbrevs
abbrevs
EP.BNVAnyIdentifier [459, 466] abbrevs
abbrevs
EP._ [466, 471]
    
EP.Spacing [466, 471]
    
EP.ArrayValue [471, 579] [ sun: 'Sun'; mon: 'Mon'; tues: 'Tues';
[ sun: 'Sun'; mon: 'Mon'; tues: 'Tues';
      weds: 'Weds'; thurs: 'Thurs'; fri: 'Fri';
      sat: 'Satur' ]
EP._ [472, 473]
 
EP.Spacing [472, 473]
 
EP.ArrayValueElement [473, 483] sun: 'Sun'
sun: 'Sun'
EP.CaseConstantList [473, 476] sun
sun
EP.CaseRange [473, 476] sun
sun
EP.CaseConstant [473, 476] sun
sun
EP.ConstantExpression [473, 476] sun
sun
EP.Expression [473, 476] sun
sun
EP.SimpleExpression [473, 476] sun
sun
EP.Term [473, 476] sun
sun
EP.Factor [473, 476] sun
sun
EP.Primary [473, 476] sun
sun
EP.FunctionAccess [473, 476] sun
sun
EP.EntireFunctionAccess [473, 476] sun
sun
EP.FunctionDesignator [473, 476] sun
sun
EP.FunctionName [473, 476] sun
sun
EP.FunctionIdentifier [473, 476] sun
sun
EP.Identifier [473, 476] sun
sun
EP.BNVAnyIdentifier [473, 476] sun
sun
EP._ [477, 478]
 
EP.Spacing [477, 478]
 
EP.ComponentValue [478, 483] 'Sun'
'Sun'
EP.Expression [478, 483] 'Sun'
'Sun'
EP.SimpleExpression [478, 483] 'Sun'
'Sun'
EP.Term [478, 483] 'Sun'
'Sun'
EP.Factor [478, 483] 'Sun'
'Sun'
EP.Primary [478, 483] 'Sun'
'Sun'
EP.UnsignedConstant [478, 483] 'Sun'
'Sun'
EP.CharacterString [478, 483] 'Sun'
'Sun'
EP.StringElement [479, 480] S
S
EP.StringCharacter [479, 480] S
S
EP.StringElement [480, 481] u
u
EP.StringCharacter [480, 481] u
u
EP.StringElement [481, 482] n
n
EP.StringCharacter [481, 482] n
n
EP._ [484, 485]
 
EP.Spacing [484, 485]
 
EP.ArrayValueElement [485, 495] mon: 'Mon'
mon: 'Mon'
EP.CaseConstantList [485, 488] mon
mon
EP.CaseRange [485, 488] mon
mon
EP.CaseConstant [485, 488] mon
mon
EP.ConstantExpression [485, 488] mon
mon
EP.Expression [485, 488] mon
mon
EP.SimpleExpression [485, 488] mon
mon
EP.Term [485, 488] mon
mon
EP.Factor [485, 488] mon
mon
EP.Primary [485, 488] mon
mon
EP.FunctionAccess [485, 488] mon
mon
EP.EntireFunctionAccess [485, 488] mon
mon
EP.FunctionDesignator [485, 488] mon
mon
EP.FunctionName [485, 488] mon
mon
EP.FunctionIdentifier [485, 488] mon
mon
EP.Identifier [485, 488] mon
mon
EP.BNVAnyIdentifier [485, 488] mon
mon
EP._ [489, 490]
 
EP.Spacing [489, 490]
 
EP.ComponentValue [490, 495] 'Mon'
'Mon'
EP.Expression [490, 495] 'Mon'
'Mon'
EP.SimpleExpression [490, 495] 'Mon'
'Mon'
EP.Term [490, 495] 'Mon'
'Mon'
EP.Factor [490, 495] 'Mon'
'Mon'
EP.Primary [490, 495] 'Mon'
'Mon'
EP.UnsignedConstant [490, 495] 'Mon'
'Mon'
EP.CharacterString [490, 495] 'Mon'
'Mon'
EP.StringElement [491, 492] M
M
EP.StringCharacter [491, 492] M
M
EP.StringElement [492, 493] o
o
EP.StringCharacter [492, 493] o
o
EP.StringElement [493, 494] n
n
EP.StringCharacter [493, 494] n
n
EP._ [496, 497]
 
EP.Spacing [496, 497]
 
EP.ArrayValueElement [497, 509] tues: 'Tues'
tues: 'Tues'
EP.CaseConstantList [497, 501] tues
tues
EP.CaseRange [497, 501] tues
tues
EP.CaseConstant [497, 501] tues
tues
EP.ConstantExpression [497, 501] tues
tues
EP.Expression [497, 501] tues
tues
EP.SimpleExpression [497, 501] tues
tues
EP.Term [497, 501] tues
tues
EP.Factor [497, 501] tues
tues
EP.Primary [497, 501] tues
tues
EP.FunctionAccess [497, 501] tues
tues
EP.EntireFunctionAccess [497, 501] tues
tues
EP.FunctionDesignator [497, 501] tues
tues
EP.FunctionName [497, 501] tues
tues
EP.FunctionIdentifier [497, 501] tues
tues
EP.Identifier [497, 501] tues
tues
EP.BNVAnyIdentifier [497, 501] tues
tues
EP._ [502, 503]
 
EP.Spacing [502, 503]
 
EP.ComponentValue [503, 509] 'Tues'
'Tues'
EP.Expression [503, 509] 'Tues'
'Tues'
EP.SimpleExpression [503, 509] 'Tues'
'Tues'
EP.Term [503, 509] 'Tues'
'Tues'
EP.Factor [503, 509] 'Tues'
'Tues'
EP.Primary [503, 509] 'Tues'
'Tues'
EP.UnsignedConstant [503, 509] 'Tues'
'Tues'
EP.CharacterString [503, 509] 'Tues'
'Tues'
EP.StringElement [504, 505] T
T
EP.StringCharacter [504, 505] T
T
EP.StringElement [505, 506] u
u
EP.StringCharacter [505, 506] u
u
EP.StringElement [506, 507] e
e
EP.StringCharacter [506, 507] e
e
EP.StringElement [507, 508] s
s
EP.StringCharacter [507, 508] s
s
EP._ [510, 517]
      
EP.Spacing [510, 517]
      
EP.ArrayValueElement [517, 529] weds: 'Weds'
weds: 'Weds'
EP.CaseConstantList [517, 521] weds
weds
EP.CaseRange [517, 521] weds
weds
EP.CaseConstant [517, 521] weds
weds
EP.ConstantExpression [517, 521] weds
weds
EP.Expression [517, 521] weds
weds
EP.SimpleExpression [517, 521] weds
weds
EP.Term [517, 521] weds
weds
EP.Factor [517, 521] weds
weds
EP.Primary [517, 521] weds
weds
EP.FunctionAccess [517, 521] weds
weds
EP.EntireFunctionAccess [517, 521] weds
weds
EP.FunctionDesignator [517, 521] weds
weds
EP.FunctionName [517, 521] weds
weds
EP.FunctionIdentifier [517, 521] weds
weds
EP.Identifier [517, 521] weds
weds
EP.BNVAnyIdentifier [517, 521] weds
weds
EP._ [522, 523]
 
EP.Spacing [522, 523]
 
EP.ComponentValue [523, 529] 'Weds'
'Weds'
EP.Expression [523, 529] 'Weds'
'Weds'
EP.SimpleExpression [523, 529] 'Weds'
'Weds'
EP.Term [523, 529] 'Weds'
'Weds'
EP.Factor [523, 529] 'Weds'
'Weds'
EP.Primary [523, 529] 'Weds'
'Weds'
EP.UnsignedConstant [523, 529] 'Weds'
'Weds'
EP.CharacterString [523, 529] 'Weds'
'Weds'
EP.StringElement [524, 525] W
W
EP.StringCharacter [524, 525] W
W
EP.StringElement [525, 526] e
e
EP.StringCharacter [525, 526] e
e
EP.StringElement [526, 527] d
d
EP.StringCharacter [526, 527] d
d
EP.StringElement [527, 528] s
s
EP.StringCharacter [527, 528] s
s
EP._ [530, 531]
 
EP.Spacing [530, 531]
 
EP.ArrayValueElement [531, 545] thurs: 'Thurs'
thurs: 'Thurs'
EP.CaseConstantList [531, 536] thurs
thurs
EP.CaseRange [531, 536] thurs
thurs
EP.CaseConstant [531, 536] thurs
thurs
EP.ConstantExpression [531, 536] thurs
thurs
EP.Expression [531, 536] thurs
thurs
EP.SimpleExpression [531, 536] thurs
thurs
EP.Term [531, 536] thurs
thurs
EP.Factor [531, 536] thurs
thurs
EP.Primary [531, 536] thurs
thurs
EP.FunctionAccess [531, 536] thurs
thurs
EP.EntireFunctionAccess [531, 536] thurs
thurs
EP.FunctionDesignator [531, 536] thurs
thurs
EP.FunctionName [531, 536] thurs
thurs
EP.FunctionIdentifier [531, 536] thurs
thurs
EP.Identifier [531, 536] thurs
thurs
EP.BNVAnyIdentifier [531, 536] thurs
thurs
EP._ [537, 538]
 
EP.Spacing [537, 538]
 
EP.ComponentValue [538, 545] 'Thurs'
'Thurs'
EP.Expression [538, 545] 'Thurs'
'Thurs'
EP.SimpleExpression [538, 545] 'Thurs'
'Thurs'
EP.Term [538, 545] 'Thurs'
'Thurs'
EP.Factor [538, 545] 'Thurs'
'Thurs'
EP.Primary [538, 545] 'Thurs'
'Thurs'
EP.UnsignedConstant [538, 545] 'Thurs'
'Thurs'
EP.CharacterString [538, 545] 'Thurs'
'Thurs'
EP.StringElement [539, 540] T
T
EP.StringCharacter [539, 540] T
T
EP.StringElement [540, 541] h
h
EP.StringCharacter [540, 541] h
h
EP.StringElement [541, 542] u
u
EP.StringCharacter [541, 542] u
u
EP.StringElement [542, 543] r
r
EP.StringCharacter [542, 543] r
r
EP.StringElement [543, 544] s
s
EP.StringCharacter [543, 544] s
s
EP._ [546, 547]
 
EP.Spacing [546, 547]
 
EP.ArrayValueElement [547, 557] fri: 'Fri'
fri: 'Fri'
EP.CaseConstantList [547, 550] fri
fri
EP.CaseRange [547, 550] fri
fri
EP.CaseConstant [547, 550] fri
fri
EP.ConstantExpression [547, 550] fri
fri
EP.Expression [547, 550] fri
fri
EP.SimpleExpression [547, 550] fri
fri
EP.Term [547, 550] fri
fri
EP.Factor [547, 550] fri
fri
EP.Primary [547, 550] fri
fri
EP.FunctionAccess [547, 550] fri
fri
EP.EntireFunctionAccess [547, 550] fri
fri
EP.FunctionDesignator [547, 550] fri
fri
EP.FunctionName [547, 550] fri
fri
EP.FunctionIdentifier [547, 550] fri
fri
EP.Identifier [547, 550] fri
fri
EP.BNVAnyIdentifier [547, 550] fri
fri
EP._ [551, 552]
 
EP.Spacing [551, 552]
 
EP.ComponentValue [552, 557] 'Fri'
'Fri'
EP.Expression [552, 557] 'Fri'
'Fri'
EP.SimpleExpression [552, 557] 'Fri'
'Fri'
EP.Term [552, 557] 'Fri'
'Fri'
EP.Factor [552, 557] 'Fri'
'Fri'
EP.Primary [552, 557] 'Fri'
'Fri'
EP.UnsignedConstant [552, 557] 'Fri'
'Fri'
EP.CharacterString [552, 557] 'Fri'
'Fri'
EP.StringElement [553, 554] F
F
EP.StringCharacter [553, 554] F
F
EP.StringElement [554, 555] r
r
EP.StringCharacter [554, 555] r
r
EP.StringElement [555, 556] i
i
EP.StringCharacter [555, 556] i
i
EP._ [558, 565]
      
EP.Spacing [558, 565]
      
EP.ArrayValueElement [565, 577] sat: 'Satur'
sat: 'Satur'
EP.CaseConstantList [565, 568] sat
sat
EP.CaseRange [565, 568] sat
sat
EP.CaseConstant [565, 568] sat
sat
EP.ConstantExpression [565, 568] sat
sat
EP.Expression [565, 568] sat
sat
EP.SimpleExpression [565, 568] sat
sat
EP.Term [565, 568] sat
sat
EP.Factor [565, 568] sat
sat
EP.Primary [565, 568] sat
sat
EP.FunctionAccess [565, 568] sat
sat
EP.EntireFunctionAccess [565, 568] sat
sat
EP.FunctionDesignator [565, 568] sat
sat
EP.FunctionName [565, 568] sat
sat
EP.FunctionIdentifier [565, 568] sat
sat
EP.Identifier [565, 568] sat
sat
EP.BNVAnyIdentifier [565, 568] sat
sat
EP._ [569, 570]
 
EP.Spacing [569, 570]
 
EP.ComponentValue [570, 577] 'Satur'
'Satur'
EP.Expression [570, 577] 'Satur'
'Satur'
EP.SimpleExpression [570, 577] 'Satur'
'Satur'
EP.Term [570, 577] 'Satur'
'Satur'
EP.Factor [570, 577] 'Satur'
'Satur'
EP.Primary [570, 577] 'Satur'
'Satur'
EP.UnsignedConstant [570, 577] 'Satur'
'Satur'
EP.CharacterString [570, 577] 'Satur'
'Satur'
EP.StringElement [571, 572] S
S
EP.StringCharacter [571, 572] S
S
EP.StringElement [572, 573] a
a
EP.StringCharacter [572, 573] a
a
EP.StringElement [573, 574] t
t
EP.StringCharacter [573, 574] t
t
EP.StringElement [574, 575] u
u
EP.StringCharacter [574, 575] u
u
EP.StringElement [575, 576] r
r
EP.StringCharacter [575, 576] r
r
EP._ [577, 578]
 
EP.Spacing [577, 578]
 
EP._ [580, 583]
  
EP.Spacing [580, 583]
  
EP.StatementPart [583, 637] BEGIN
BEGIN
    DayName := trim(DayNames[fd]) + 'day';
  END
EP.CompoundStatement [583, 637] BEGIN
BEGIN
    DayName := trim(DayNames[fd]) + 'day';
  END
EP._ [588, 593]
    
EP.Spacing [588, 593]
    
EP.StatementSequence [593, 634] DayName := trim(DayNames[fd]) + 'day';
DayName := trim(DayNames[fd]) + 'day';
  
EP.Statement [593, 630] DayName := trim(DayNames[fd]) + 'day'
DayName := trim(DayNames[fd]) + 'day'
EP.SimpleStatement [593, 630] DayName := trim(DayNames[fd]) + 'day'
DayName := trim(DayNames[fd]) + 'day'
EP.AssignmentStatement [593, 630] DayName := trim(DayNames[fd]) + 'day'
DayName := trim(DayNames[fd]) + 'day'
EP.VariableAccess [593, 600] DayName
DayName
EP.EntireVariable [593, 600] DayName
DayName
EP.VariableName [593, 600] DayName
DayName
EP.VariableIdentifier [593, 600] DayName
DayName
EP.Identifier [593, 600] DayName
DayName
EP.BNVAnyIdentifier [593, 600] DayName
DayName
EP._ [600, 601]
 
EP.Spacing [600, 601]
 
EP._ [603, 604]
 
EP.Spacing [603, 604]
 
EP.Expression [604, 630] trim(DayNames[fd]) + 'day'
trim(DayNames[fd]) + 'day'
EP.SimpleExpression [604, 630] trim(DayNames[fd]) + 'day'
trim(DayNames[fd]) + 'day'
EP.Term [604, 622] trim(DayNames[fd])
trim(DayNames[fd])
EP.Factor [604, 622] trim(DayNames[fd])
trim(DayNames[fd])
EP.Primary [604, 622] trim(DayNames[fd])
trim(DayNames[fd])
EP.FunctionAccess [604, 622] trim(DayNames[fd])
trim(DayNames[fd])
EP.EntireFunctionAccess [604, 622] trim(DayNames[fd])
trim(DayNames[fd])
EP.FunctionDesignator [604, 622] trim(DayNames[fd])
trim(DayNames[fd])
EP.FunctionName [604, 608] trim
trim
EP.FunctionIdentifier [604, 608] trim
trim
EP.Identifier [604, 608] trim
trim
EP.BNVAnyIdentifier [604, 608] trim
trim
EP.ActualParameterList [608, 622] (DayNames[fd])
(DayNames[fd])
EP.ActualParameter [609, 621] DayNames[fd]
DayNames[fd]
EP.Expression [609, 621] DayNames[fd]
DayNames[fd]
EP.SimpleExpression [609, 621] DayNames[fd]
DayNames[fd]
EP.Term [609, 621] DayNames[fd]
DayNames[fd]
EP.Factor [609, 621] DayNames[fd]
DayNames[fd]
EP.Primary [609, 621] DayNames[fd]
DayNames[fd]
EP.StructuredValueConstructor [609, 621] DayNames[fd]
DayNames[fd]
EP.SetTypeName [609, 617] DayNames
DayNames
EP.TypeName [609, 617] DayNames
DayNames
EP.TypeIdentifier [609, 617] DayNames
DayNames
EP.Identifier [609, 617] DayNames
DayNames
EP.BNVAnyIdentifier [609, 617] DayNames
DayNames
EP.SetValue [617, 621] [fd]
[fd]
EP.SetConstructor [617, 621] [fd]
[fd]
EP.MemberDesignator [618, 620] fd
fd
EP.Expression [618, 620] fd
fd
EP.SimpleExpression [618, 620] fd
fd
EP.Term [618, 620] fd
fd
EP.Factor [618, 620] fd
fd
EP.Primary [618, 620] fd
fd
EP.FunctionAccess [618, 620] fd
fd
EP.EntireFunctionAccess [618, 620] fd
fd
EP.FunctionDesignator [618, 620] fd
fd
EP.FunctionName [618, 620] fd
fd
EP.FunctionIdentifier [618, 620] fd
fd
EP.Identifier [618, 620] fd
fd
EP.BNVAnyIdentifier [618, 620] fd
fd
EP._ [622, 623]
 
EP.Spacing [622, 623]
 
EP.AddingOperator [623, 624] +
+
EP._ [624, 625]
 
EP.Spacing [624, 625]
 
EP.Term [625, 630] 'day'
'day'
EP.Factor [625, 630] 'day'
'day'
EP.Primary [625, 630] 'day'
'day'
EP.UnsignedConstant [625, 630] 'day'
'day'
EP.CharacterString [625, 630] 'day'
'day'
EP.StringElement [626, 627] d
d
EP.StringCharacter [626, 627] d
d
EP.StringElement [627, 628] a
a
EP.StringCharacter [627, 628] a
a
EP.StringElement [628, 629] y
y
EP.StringCharacter [628, 629] y
y
EP._ [631, 634]
  
EP.Spacing [631, 634]
  
EP.Statement [634, 634]
EP.SimpleStatement [634, 634]
EP.EmptyStatement [634, 634]
EP._ [637, 647] {DayName}
 {DayName}
EP.Spacing [637, 638]
 
EP.InlineComment [638, 647] {DayName}
{DayName}
EP.CommentOpen [638, 639] {
{
EP.CommentContent [639, 646] DayName
DayName
EP.CommentClose [646, 647] }
}
EP._ [648, 650]

EP.Spacing [648, 650]

EP.StatementPart [650, 719] BEGIN {program}
BEGIN {program}
  FOR d := fri DOWNTO mon DO writeln(DayName(d));
END
EP.CompoundStatement [650, 719] BEGIN {program}
BEGIN {program}
  FOR d := fri DOWNTO mon DO writeln(DayName(d));
END
EP._ [655, 668] {program}
 {program}
  
EP.Spacing [655, 656]
 
EP.TrailingComment [656, 665] {program}
{program}
EP.CommentOpen [656, 657] {
{
EP.CommentContent [657, 664] program
program
EP.CommentClose [664, 665] }
}
EP.Spacing [665, 668]
  
EP.StatementSequence [668, 716] FOR d := fri DOWNTO mon DO writeln(DayName(d));
FOR d := fri DOWNTO mon DO writeln(DayName(d));
EP.Statement [668, 714] FOR d := fri DOWNTO mon DO writeln(DayName(d))
FOR d := fri DOWNTO mon DO writeln(DayName(d))
EP.StructuredStatement [668, 714] FOR d := fri DOWNTO mon DO writeln(DayName(d))
FOR d := fri DOWNTO mon DO writeln(DayName(d))
EP.RepetitiveStatement [668, 714] FOR d := fri DOWNTO mon DO writeln(DayName(d))
FOR d := fri DOWNTO mon DO writeln(DayName(d))
EP.ForStatement [668, 714] FOR d := fri DOWNTO mon DO writeln(DayName(d))
FOR d := fri DOWNTO mon DO writeln(DayName(d))
EP.FOR [668, 671] FOR
FOR
EP._ [671, 672]
 
EP.Spacing [671, 672]
 
EP.ControlVariable [672, 673] d
d
EP.EntireVariable [672, 673] d
d
EP.VariableName [672, 673] d
d
EP.VariableIdentifier [672, 673] d
d
EP.Identifier [672, 673] d
d
EP.BNVAnyIdentifier [672, 673] d
d
EP._ [673, 674]
 
EP.Spacing [673, 674]
 
EP.IterationClause [674, 691] := fri DOWNTO mon
:= fri DOWNTO mon
EP.SequenceIteration [674, 691] := fri DOWNTO mon
:= fri DOWNTO mon
EP._ [676, 677]
 
EP.Spacing [676, 677]
 
EP.InitialValue [677, 680] fri
fri
EP.Expression [677, 680] fri
fri
EP.SimpleExpression [677, 680] fri
fri
EP.Term [677, 680] fri
fri
EP.Factor [677, 680] fri
fri
EP.Primary [677, 680] fri
fri
EP.FunctionAccess [677, 680] fri
fri
EP.EntireFunctionAccess [677, 680] fri
fri
EP.FunctionDesignator [677, 680] fri
fri
EP.FunctionName [677, 680] fri
fri
EP.FunctionIdentifier [677, 680] fri
fri
EP.Identifier [677, 680] fri
fri
EP.BNVAnyIdentifier [677, 680] fri
fri
EP._ [680, 681]
 
EP.Spacing [680, 681]
 
EP.DOWNTO [681, 687] DOWNTO
DOWNTO
EP._ [687, 688]
 
EP.Spacing [687, 688]
 
EP.FinalValue [688, 691] mon
mon
EP.Expression [688, 691] mon
mon
EP.SimpleExpression [688, 691] mon
mon
EP.Term [688, 691] mon
mon
EP.Factor [688, 691] mon
mon
EP.Primary [688, 691] mon
mon
EP.FunctionAccess [688, 691] mon
mon
EP.EntireFunctionAccess [688, 691] mon
mon
EP.FunctionDesignator [688, 691] mon
mon
EP.FunctionName [688, 691] mon
mon
EP.FunctionIdentifier [688, 691] mon
mon
EP.Identifier [688, 691] mon
mon
EP.BNVAnyIdentifier [688, 691] mon
mon
EP._ [691, 692]
 
EP.Spacing [691, 692]
 
EP.DO [692, 694] DO
DO
EP._ [694, 695]
 
EP.Spacing [694, 695]
 
EP.Statement [695, 714] writeln(DayName(d))
writeln(DayName(d))
EP.SimpleStatement [695, 714] writeln(DayName(d))
writeln(DayName(d))
EP.ProcedureStatement [695, 714] writeln(DayName(d))
writeln(DayName(d))
EP.WRITELN [695, 702] writeln
writeln
EP.WritelnParameterList [702, 714] (DayName(d))
(DayName(d))
EP.WriteParameter [703, 713] DayName(d)
DayName(d)
EP.Expression [703, 713] DayName(d)
DayName(d)
EP.SimpleExpression [703, 713] DayName(d)
DayName(d)
EP.Term [703, 713] DayName(d)
DayName(d)
EP.Factor [703, 713] DayName(d)
DayName(d)
EP.Primary [703, 713] DayName(d)
DayName(d)
EP.FunctionAccess [703, 713] DayName(d)
DayName(d)
EP.EntireFunctionAccess [703, 713] DayName(d)
DayName(d)
EP.FunctionDesignator [703, 713] DayName(d)
DayName(d)
EP.FunctionName [703, 710] DayName
DayName
EP.FunctionIdentifier [703, 710] DayName
DayName
EP.Identifier [703, 710] DayName
DayName
EP.BNVAnyIdentifier [703, 710] DayName
DayName
EP.ActualParameterList [710, 713] (d)
(d)
EP.ActualParameter [711, 712] d
d
EP.Expression [711, 712] d
d
EP.SimpleExpression [711, 712] d
d
EP.Term [711, 712] d
d
EP.Factor [711, 712] d
d
EP.Primary [711, 712] d
d
EP.FunctionAccess [711, 712] d
d
EP.EntireFunctionAccess [711, 712] d
d
EP.FunctionDesignator [711, 712] d
d
EP.FunctionName [711, 712] d
d
EP.FunctionIdentifier [711, 712] d
d
EP.Identifier [711, 712] d
d
EP.BNVAnyIdentifier [711, 712] d
d
EP._ [715, 716]
EP.Spacing [715, 716]
EP.Statement [716, 716]
EP.SimpleStatement [716, 716]
EP.EmptyStatement [716, 716]
EP._ [720, 810]

  { Generated output is:
    Friday
    Thursday
    Wedsday
    Tuesday
    Monday
  }
EP.Spacing [720, 724]

  
EP.TrailingComment [724, 809] { Generated output is:
{ Generated output is:
    Friday
    Thursday
    Wedsday
    Tuesday
    Monday
  }
EP.CommentOpen [724, 725] {
{
EP.CommentContent [725, 808] Generated output is:
 Generated output is:
    Friday
    Thursday
    Wedsday
    Tuesday
    Monday
  
EP.CommentClose [808, 809] }
}
EP.Spacing [809, 810]