Pegged produced parse tree

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] PROGRAMPROGRAM

EP.BNVProgramName [8, 14] arraycarrayc

EP.Identifier [8, 14] arraycarrayc

EP.BNVAnyIdentifier [8, 14] arraycarrayc

EP.ProgramParameterList [16, 22] outputoutput

EP.IdentifierList [16, 22] outputoutput

EP.Identifier [16, 22] outputoutput

EP.BNVAnyIdentifier [16, 22] outputoutput

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] daysdays

EP.Identifier [128, 132] daysdays

EP.BNVAnyIdentifier [128, 132] daysdays

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!} satsun,mon {First work day},tues,weds,thurs,fri, {Party!} sat

EP.Identifier [136, 139] sunsun

EP.BNVAnyIdentifier [136, 139] sunsun

EP.COMMA [139, 140] ,,

EP.Identifier [140, 143] monmon

EP.BNVAnyIdentifier [140, 143] monmon

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 dayFirst work day

EP.CommentClose [159, 160] }}

EP.COMMA [160, 161] ,,

EP.Identifier [161, 165] tuestues

EP.BNVAnyIdentifier [161, 165] tuestues

EP.COMMA [165, 166] ,,

EP.Identifier [166, 170] wedsweds

EP.BNVAnyIdentifier [166, 170] wedsweds

EP.COMMA [170, 171] ,,

EP.Identifier [171, 176] thursthurs

EP.BNVAnyIdentifier [171, 176] thursthurs

EP.COMMA [176, 177] ,,

EP.Identifier [177, 180] frifri

EP.BNVAnyIdentifier [177, 180] frifri

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] satsat

EP.BNVAnyIdentifier [191, 194] satsat

EP._ [196, 203]

EP.Spacing [196, 203]

EP.TypeDefinition [203, 220] dname = string(8)dname = string(8)

EP.BNVTypeDefName [203, 208] dnamedname

EP.Identifier [203, 208] dnamedname

EP.BNVAnyIdentifier [203, 208] dnamedname

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] stringstring

EP.SchemaIdentifier [211, 217] stringstring

EP.Identifier [211, 217] stringstring

EP.BNVAnyIdentifier [211, 217] stringstring

EP.ActualDiscriminantPart [217, 220] (8)(8)

EP.DiscriminantValue [218, 219] 88

EP.Expression [218, 219] 88

EP.SimpleExpression [218, 219] 88

EP.Term [218, 219] 88

EP.Factor [218, 219] 88

EP.Primary [218, 219] 88

EP.UnsignedConstant [218, 219] 88

EP.UnsignedNumber [218, 219] 88

EP.UnsignedInteger [218, 219] 88

EP.DigitSequence [218, 219] 88

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: daysd: days

EP.IdentifierList [229, 230] dd

EP.Identifier [229, 230] dd

EP.BNVAnyIdentifier [229, 230] dd

EP._ [231, 232]

EP.Spacing [231, 232]

EP.TypeDenoter [232, 236] daysdays

EP.TypeName [232, 236] daysdays

EP.TypeIdentifier [232, 236] daysdays

EP.Identifier [232, 236] daysdays

EP.BNVAnyIdentifier [232, 236] daysdays

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): dnameFUNCTION DayName (fd: days): dname

EP._ [247, 248]

EP.Spacing [247, 248]

EP.Identifier [248, 255] DayNameDayName

EP.BNVAnyIdentifier [248, 255] DayNameDayName

EP._ [255, 256]

EP.Spacing [255, 256]

EP.FormalParameterList [256, 266] (fd: days)(fd: days)

EP.FormalParameterSection [257, 265] fd: daysfd: days

EP.ValueParameterSpecification [257, 265] fd: daysfd: days

EP.IdentifierList [257, 259] fdfd

EP.Identifier [257, 259] fdfd

EP.BNVAnyIdentifier [257, 259] fdfd

EP._ [260, 261]

EP.Spacing [260, 261]

EP.ParameterForm [261, 265] daysdays

EP.TypeName [261, 265] daysdays

EP.TypeIdentifier [261, 265] daysdays

EP.Identifier [261, 265] daysdays

EP.BNVAnyIdentifier [261, 265] daysdays

EP._ [267, 268]

EP.Spacing [267, 268]

EP.ResultType [268, 273] dnamedname

EP.TypeName [268, 273] dnamedname

EP.TypeIdentifier [268, 273] dnamedname

EP.Identifier [268, 273] dnamedname

EP.BNVAnyIdentifier [268, 273] dnamedname

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] OFTYPE  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] OFTYPE  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] OFTYPE  abbrevs = ARRAY [days] OF
          PACKED ARRAY [1..5] OF char;

EP._ [373, 375]

EP.Spacing [373, 375]

EP.TypeDefinition [375, 438]

abbrevs = ARRAY [days] OFabbrevs = ARRAY [days] OF
          PACKED ARRAY [1..5] OF char

EP.BNVTypeDefName [375, 382] abbrevsabbrevs

EP.Identifier [375, 382] abbrevsabbrevs

EP.BNVAnyIdentifier [375, 382] abbrevsabbrevs

EP._ [382, 383]

EP.Spacing [382, 383]

EP._ [384, 385]

EP.Spacing [384, 385]

EP.TypeDenoter [385, 438]

ARRAY [days] OFARRAY [days] OF
          PACKED ARRAY [1..5] OF char

EP.NewType [385, 438]

ARRAY [days] OFARRAY [days] OF
          PACKED ARRAY [1..5] OF char

EP.NewStructuredType [385, 438]

ARRAY [days] OFARRAY [days] OF
          PACKED ARRAY [1..5] OF char

EP.UnpackedStructuredType [385, 438]

ARRAY [days] OFARRAY [days] OF
          PACKED ARRAY [1..5] OF char

EP.ArrayType [385, 438]

ARRAY [days] OFARRAY [days] OF
          PACKED ARRAY [1..5] OF char

EP._ [390, 391]

EP.Spacing [390, 391]

EP.IndexType [392, 396] daysdays

EP.OrdinalType [392, 396] daysdays

EP.OrdinalTypeName [392, 396] daysdays

EP.TypeName [392, 396] daysdays

EP.TypeIdentifier [392, 396] daysdays

EP.Identifier [392, 396] daysdays

EP.BNVAnyIdentifier [392, 396] daysdays

EP._ [397, 398]

EP.Spacing [397, 398]

EP._ [400, 411]

EP.Spacing [400, 411]

EP.ComponentType [411, 438] PACKED ARRAY [1..5] OF charPACKED ARRAY [1..5] OF char

EP.TypeDenoter [411, 438] PACKED ARRAY [1..5] OF charPACKED ARRAY [1..5] OF char

EP.NewType [411, 438] PACKED ARRAY [1..5] OF charPACKED ARRAY [1..5] OF char

EP.NewStructuredType [411, 438] PACKED ARRAY [1..5] OF charPACKED ARRAY [1..5] OF char

EP._ [417, 418]

EP.Spacing [417, 418]

EP.UnpackedStructuredType [418, 438] ARRAY [1..5] OF charARRAY [1..5] OF char

EP.ArrayType [418, 438] ARRAY [1..5] OF charARRAY [1..5] OF char

EP._ [423, 424]

EP.Spacing [423, 424]

EP.IndexType [425, 429] 1..51..5

EP.OrdinalType [425, 429] 1..51..5

EP.NewOrdinalType [425, 429] 1..51..5

EP.SubrangeType [425, 429] 1..51..5

EP.SubrangeBound [425, 426] 11

EP.Expression [425, 426] 11

EP.SimpleExpression [425, 426] 11

EP.Term [425, 426] 11

EP.Factor [425, 426] 11

EP.Primary [425, 426] 11

EP.UnsignedConstant [425, 426] 11

EP.UnsignedNumber [425, 426] 11

EP.UnsignedInteger [425, 426] 11

EP.DigitSequence [425, 426] 11

EP.SubrangeBound [428, 429] 55

EP.Expression [428, 429] 55

EP.SimpleExpression [428, 429] 55

EP.Term [428, 429] 55

EP.Factor [428, 429] 55

EP.Primary [428, 429] 55

EP.UnsignedConstant [428, 429] 55

EP.UnsignedNumber [428, 429] 55

EP.UnsignedInteger [428, 429] 55

EP.DigitSequence [428, 429] 55

EP._ [430, 431]

EP.Spacing [430, 431]

EP._ [433, 434]

EP.Spacing [433, 434]

EP.ComponentType [434, 438] charchar

EP.TypeDenoter [434, 438] charchar

EP.TypeName [434, 438] charchar

EP.TypeIdentifier [434, 438] charchar

EP.Identifier [434, 438] charchar

EP.BNVAnyIdentifier [434, 438] charchar

EP._ [439, 442]

EP.Spacing [439, 442]

EP.ConstantDefinitionPart [442, 583]

CONST DayNames = abbrevsCONST 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 = abbrevsDayNames = abbrevs
    [ sun: 'Sun'; mon: 'Mon'; tues: 'Tues';
      weds: 'Weds'; thurs: 'Thurs'; fri: 'Fri';
      sat: 'Satur' ]

EP.Identifier [448, 456] DayNamesDayNames

EP.BNVAnyIdentifier [448, 456] DayNamesDayNames

EP._ [456, 457]

EP.Spacing [456, 457]

EP._ [458, 459]

EP.Spacing [458, 459]

EP.ConstantExpression [459, 579]

abbrevsabbrevs
    [ sun: 'Sun'; mon: 'Mon'; tues: 'Tues';
      weds: 'Weds'; thurs: 'Thurs'; fri: 'Fri';
      sat: 'Satur' ]

EP.Expression [459, 579]

abbrevsabbrevs
    [ sun: 'Sun'; mon: 'Mon'; tues: 'Tues';
      weds: 'Weds'; thurs: 'Thurs'; fri: 'Fri';
      sat: 'Satur' ]

EP.SimpleExpression [459, 579]

abbrevsabbrevs
    [ sun: 'Sun'; mon: 'Mon'; tues: 'Tues';
      weds: 'Weds'; thurs: 'Thurs'; fri: 'Fri';
      sat: 'Satur' ]

EP.Term [459, 579]

abbrevsabbrevs
    [ sun: 'Sun'; mon: 'Mon'; tues: 'Tues';
      weds: 'Weds'; thurs: 'Thurs'; fri: 'Fri';
      sat: 'Satur' ]

EP.Factor [459, 579]

abbrevsabbrevs
    [ sun: 'Sun'; mon: 'Mon'; tues: 'Tues';
      weds: 'Weds'; thurs: 'Thurs'; fri: 'Fri';
      sat: 'Satur' ]

EP.Primary [459, 579]

abbrevsabbrevs
    [ sun: 'Sun'; mon: 'Mon'; tues: 'Tues';
      weds: 'Weds'; thurs: 'Thurs'; fri: 'Fri';
      sat: 'Satur' ]

EP.StructuredValueConstructor [459, 579]

abbrevsabbrevs
    [ sun: 'Sun'; mon: 'Mon'; tues: 'Tues';
      weds: 'Weds'; thurs: 'Thurs'; fri: 'Fri';
      sat: 'Satur' ]

EP.ArrayTypeName [459, 466] abbrevsabbrevs

EP.TypeName [459, 466] abbrevsabbrevs

EP.TypeIdentifier [459, 466] abbrevsabbrevs

EP.Identifier [459, 466] abbrevsabbrevs

EP.BNVAnyIdentifier [459, 466] abbrevsabbrevs

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] sunsun

EP.CaseRange [473, 476] sunsun

EP.CaseConstant [473, 476] sunsun

EP.ConstantExpression [473, 476] sunsun

EP.Expression [473, 476] sunsun

EP.SimpleExpression [473, 476] sunsun

EP.Term [473, 476] sunsun

EP.Factor [473, 476] sunsun

EP.Primary [473, 476] sunsun

EP.FunctionAccess [473, 476] sunsun

EP.EntireFunctionAccess [473, 476] sunsun

EP.FunctionDesignator [473, 476] sunsun

EP.FunctionName [473, 476] sunsun

EP.FunctionIdentifier [473, 476] sunsun

EP.Identifier [473, 476] sunsun

EP.BNVAnyIdentifier [473, 476] sunsun

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] SS

EP.StringCharacter [479, 480] SS

EP.StringElement [480, 481] uu

EP.StringCharacter [480, 481] uu

EP.StringElement [481, 482] nn

EP.StringCharacter [481, 482] nn

EP._ [484, 485]

EP.Spacing [484, 485]

EP.ArrayValueElement [485, 495] mon: 'Mon'mon: 'Mon'

EP.CaseConstantList [485, 488] monmon

EP.CaseRange [485, 488] monmon

EP.CaseConstant [485, 488] monmon

EP.ConstantExpression [485, 488] monmon

EP.Expression [485, 488] monmon

EP.SimpleExpression [485, 488] monmon

EP.Term [485, 488] monmon

EP.Factor [485, 488] monmon

EP.Primary [485, 488] monmon

EP.FunctionAccess [485, 488] monmon

EP.EntireFunctionAccess [485, 488] monmon

EP.FunctionDesignator [485, 488] monmon

EP.FunctionName [485, 488] monmon

EP.FunctionIdentifier [485, 488] monmon

EP.Identifier [485, 488] monmon

EP.BNVAnyIdentifier [485, 488] monmon

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] MM

EP.StringCharacter [491, 492] MM

EP.StringElement [492, 493] oo

EP.StringCharacter [492, 493] oo

EP.StringElement [493, 494] nn

EP.StringCharacter [493, 494] nn

EP._ [496, 497]

EP.Spacing [496, 497]

EP.ArrayValueElement [497, 509] tues: 'Tues'tues: 'Tues'

EP.CaseConstantList [497, 501] tuestues

EP.CaseRange [497, 501] tuestues

EP.CaseConstant [497, 501] tuestues

EP.ConstantExpression [497, 501] tuestues

EP.Expression [497, 501] tuestues

EP.SimpleExpression [497, 501] tuestues

EP.Term [497, 501] tuestues

EP.Factor [497, 501] tuestues

EP.Primary [497, 501] tuestues

EP.FunctionAccess [497, 501] tuestues

EP.EntireFunctionAccess [497, 501] tuestues

EP.FunctionDesignator [497, 501] tuestues

EP.FunctionName [497, 501] tuestues

EP.FunctionIdentifier [497, 501] tuestues

EP.Identifier [497, 501] tuestues

EP.BNVAnyIdentifier [497, 501] tuestues

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] TT

EP.StringCharacter [504, 505] TT

EP.StringElement [505, 506] uu

EP.StringCharacter [505, 506] uu

EP.StringElement [506, 507] ee

EP.StringCharacter [506, 507] ee

EP.StringElement [507, 508] ss

EP.StringCharacter [507, 508] ss

EP._ [510, 517]

EP.Spacing [510, 517]

EP.ArrayValueElement [517, 529] weds: 'Weds'weds: 'Weds'

EP.CaseConstantList [517, 521] wedsweds

EP.CaseRange [517, 521] wedsweds

EP.CaseConstant [517, 521] wedsweds

EP.ConstantExpression [517, 521] wedsweds

EP.Expression [517, 521] wedsweds

EP.SimpleExpression [517, 521] wedsweds

EP.Term [517, 521] wedsweds

EP.Factor [517, 521] wedsweds

EP.Primary [517, 521] wedsweds

EP.FunctionAccess [517, 521] wedsweds

EP.EntireFunctionAccess [517, 521] wedsweds

EP.FunctionDesignator [517, 521] wedsweds

EP.FunctionName [517, 521] wedsweds

EP.FunctionIdentifier [517, 521] wedsweds

EP.Identifier [517, 521] wedsweds

EP.BNVAnyIdentifier [517, 521] wedsweds

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] WW

EP.StringCharacter [524, 525] WW

EP.StringElement [525, 526] ee

EP.StringCharacter [525, 526] ee

EP.StringElement [526, 527] dd

EP.StringCharacter [526, 527] dd

EP.StringElement [527, 528] ss

EP.StringCharacter [527, 528] ss

EP._ [530, 531]

EP.Spacing [530, 531]

EP.ArrayValueElement [531, 545] thurs: 'Thurs'thurs: 'Thurs'

EP.CaseConstantList [531, 536] thursthurs

EP.CaseRange [531, 536] thursthurs

EP.CaseConstant [531, 536] thursthurs

EP.ConstantExpression [531, 536] thursthurs

EP.Expression [531, 536] thursthurs

EP.SimpleExpression [531, 536] thursthurs

EP.Term [531, 536] thursthurs

EP.Factor [531, 536] thursthurs

EP.Primary [531, 536] thursthurs

EP.FunctionAccess [531, 536] thursthurs

EP.EntireFunctionAccess [531, 536] thursthurs

EP.FunctionDesignator [531, 536] thursthurs

EP.FunctionName [531, 536] thursthurs

EP.FunctionIdentifier [531, 536] thursthurs

EP.Identifier [531, 536] thursthurs

EP.BNVAnyIdentifier [531, 536] thursthurs

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] TT

EP.StringCharacter [539, 540] TT

EP.StringElement [540, 541] hh

EP.StringCharacter [540, 541] hh

EP.StringElement [541, 542] uu

EP.StringCharacter [541, 542] uu

EP.StringElement [542, 543] rr

EP.StringCharacter [542, 543] rr

EP.StringElement [543, 544] ss

EP.StringCharacter [543, 544] ss

EP._ [546, 547]

EP.Spacing [546, 547]

EP.ArrayValueElement [547, 557] fri: 'Fri'fri: 'Fri'

EP.CaseConstantList [547, 550] frifri

EP.CaseRange [547, 550] frifri

EP.CaseConstant [547, 550] frifri

EP.ConstantExpression [547, 550] frifri

EP.Expression [547, 550] frifri

EP.SimpleExpression [547, 550] frifri

EP.Term [547, 550] frifri

EP.Factor [547, 550] frifri

EP.Primary [547, 550] frifri

EP.FunctionAccess [547, 550] frifri

EP.EntireFunctionAccess [547, 550] frifri

EP.FunctionDesignator [547, 550] frifri

EP.FunctionName [547, 550] frifri

EP.FunctionIdentifier [547, 550] frifri

EP.Identifier [547, 550] frifri

EP.BNVAnyIdentifier [547, 550] frifri

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] FF

EP.StringCharacter [553, 554] FF

EP.StringElement [554, 555] rr

EP.StringCharacter [554, 555] rr

EP.StringElement [555, 556] ii

EP.StringCharacter [555, 556] ii

EP._ [558, 565]

EP.Spacing [558, 565]

EP.ArrayValueElement [565, 577] sat: 'Satur'sat: 'Satur'

EP.CaseConstantList [565, 568] satsat

EP.CaseRange [565, 568] satsat

EP.CaseConstant [565, 568] satsat

EP.ConstantExpression [565, 568] satsat

EP.Expression [565, 568] satsat

EP.SimpleExpression [565, 568] satsat

EP.Term [565, 568] satsat

EP.Factor [565, 568] satsat

EP.Primary [565, 568] satsat

EP.FunctionAccess [565, 568] satsat

EP.EntireFunctionAccess [565, 568] satsat

EP.FunctionDesignator [565, 568] satsat

EP.FunctionName [565, 568] satsat

EP.FunctionIdentifier [565, 568] satsat

EP.Identifier [565, 568] satsat

EP.BNVAnyIdentifier [565, 568] satsat

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] SS

EP.StringCharacter [571, 572] SS

EP.StringElement [572, 573] aa

EP.StringCharacter [572, 573] aa

EP.StringElement [573, 574] tt

EP.StringCharacter [573, 574] tt

EP.StringElement [574, 575] uu

EP.StringCharacter [574, 575] uu

EP.StringElement [575, 576] rr

EP.StringCharacter [575, 576] rr

EP._ [577, 578]

EP.Spacing [577, 578]

EP._ [580, 583]

EP.Spacing [580, 583]

EP.StatementPart [583, 637]

BEGINBEGIN
    DayName := trim(DayNames[fd]) + 'day';
  END

EP.CompoundStatement [583, 637]

BEGINBEGIN
    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] DayNameDayName

EP.EntireVariable [593, 600] DayNameDayName

EP.VariableName [593, 600] DayNameDayName

EP.VariableIdentifier [593, 600] DayNameDayName

EP.Identifier [593, 600] DayNameDayName

EP.BNVAnyIdentifier [593, 600] DayNameDayName

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] trimtrim

EP.FunctionIdentifier [604, 608] trimtrim

EP.Identifier [604, 608] trimtrim

EP.BNVAnyIdentifier [604, 608] trimtrim

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] DayNamesDayNames

EP.TypeName [609, 617] DayNamesDayNames

EP.TypeIdentifier [609, 617] DayNamesDayNames

EP.Identifier [609, 617] DayNamesDayNames

EP.BNVAnyIdentifier [609, 617] DayNamesDayNames

EP.SetValue [617, 621] [fd][fd]

EP.SetConstructor [617, 621] [fd][fd]

EP.MemberDesignator [618, 620] fdfd

EP.Expression [618, 620] fdfd

EP.SimpleExpression [618, 620] fdfd

EP.Term [618, 620] fdfd

EP.Factor [618, 620] fdfd

EP.Primary [618, 620] fdfd

EP.FunctionAccess [618, 620] fdfd

EP.EntireFunctionAccess [618, 620] fdfd

EP.FunctionDesignator [618, 620] fdfd

EP.FunctionName [618, 620] fdfd

EP.FunctionIdentifier [618, 620] fdfd

EP.Identifier [618, 620] fdfd

EP.BNVAnyIdentifier [618, 620] fdfd

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] dd

EP.StringCharacter [626, 627] dd

EP.StringElement [627, 628] aa

EP.StringCharacter [627, 628] aa

EP.StringElement [628, 629] yy

EP.StringCharacter [628, 629] yy

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] DayNameDayName

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] programprogram

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] FORFOR

EP._ [671, 672]

EP.Spacing [671, 672]

EP.ControlVariable [672, 673] dd

EP.EntireVariable [672, 673] dd

EP.VariableName [672, 673] dd

EP.VariableIdentifier [672, 673] dd

EP.Identifier [672, 673] dd

EP.BNVAnyIdentifier [672, 673] dd

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] frifri

EP.Expression [677, 680] frifri

EP.SimpleExpression [677, 680] frifri

EP.Term [677, 680] frifri

EP.Factor [677, 680] frifri

EP.Primary [677, 680] frifri

EP.FunctionAccess [677, 680] frifri

EP.EntireFunctionAccess [677, 680] frifri

EP.FunctionDesignator [677, 680] frifri

EP.FunctionName [677, 680] frifri

EP.FunctionIdentifier [677, 680] frifri

EP.Identifier [677, 680] frifri

EP.BNVAnyIdentifier [677, 680] frifri

EP._ [680, 681]

EP.Spacing [680, 681]

EP.DOWNTO [681, 687] DOWNTODOWNTO

EP._ [687, 688]

EP.Spacing [687, 688]

EP.FinalValue [688, 691] monmon

EP.Expression [688, 691] monmon

EP.SimpleExpression [688, 691] monmon

EP.Term [688, 691] monmon

EP.Factor [688, 691] monmon

EP.Primary [688, 691] monmon

EP.FunctionAccess [688, 691] monmon

EP.EntireFunctionAccess [688, 691] monmon

EP.FunctionDesignator [688, 691] monmon

EP.FunctionName [688, 691] monmon

EP.FunctionIdentifier [688, 691] monmon

EP.Identifier [688, 691] monmon

EP.BNVAnyIdentifier [688, 691] monmon

EP._ [691, 692]

EP.Spacing [691, 692]

EP.DO [692, 694] DODO

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] writelnwriteln

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] DayNameDayName

EP.FunctionIdentifier [703, 710] DayNameDayName

EP.Identifier [703, 710] DayNameDayName

EP.BNVAnyIdentifier [703, 710] DayNameDayName

EP.ActualParameterList [710, 713] (d)(d)

EP.ActualParameter [711, 712] dd

EP.Expression [711, 712] dd

EP.SimpleExpression [711, 712] dd

EP.Term [711, 712] dd

EP.Factor [711, 712] dd

EP.Primary [711, 712] dd

EP.FunctionAccess [711, 712] dd

EP.EntireFunctionAccess [711, 712] dd

EP.FunctionDesignator [711, 712] dd

EP.FunctionName [711, 712] dd

EP.FunctionIdentifier [711, 712] dd

EP.Identifier [711, 712] dd

EP.BNVAnyIdentifier [711, 712] dd

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]