xtrakcad_parser 0.1.3

// -!- rust -!- //////////////////////////////////////////////////////////////
//
//  System        : 
//  Module        : 
//  Object Name   : $RCSfile$
//  Revision      : $Revision$
//  Date          : $Date$
//  Author        : $Author$
//  Created By    : Robert Heller
//  Created       : 2025-09-24 15:04:51
//  Last Modified : <250924.1640>
//
//  Description	
//
//  Notes
//
//  History
//	
/////////////////////////////////////////////////////////////////////////////
//    Copyright (C) 2025  Robert Heller D/B/A Deepwoods Software
//			51 Locke Hill Road
//			Wendell, MA 01379-9728
//
//    This program is free software; you can redistribute it and/or modify
//    it under the terms of the GNU General Public License as published by
//    the Free Software Foundation; either version 2 of the License, or
//    (at your option) any later version.
//
//    This program is distributed in the hope that it will be useful,
//    but WITHOUT ANY WARRANTY; without even the implied warranty of
//    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//    GNU General Public License for more details.
//
//    You should have received a copy of the GNU General Public License
//    along with this program; if not, write to the Free Software
//    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
// 
//
//////////////////////////////////////////////////////////////////////////////


//use std::str::FromStr;
use crate::*;

// Define the gramar to take a layout struct as a parameter.  The result of
// the parsing is to populate this structure with the contents of the layout
// file.
grammar(layout: &mut Layout);

// Root non-terminal
pub XtrakCadLayout: () = {
    layout1 ENDTRACKS EOL
};

// A layout is zero or more definitions
layout1: () = {
    (),
    definition layout1,
};

// A definition is one logical entity in the layout.
definition: () = {
    version,
    title,
    mapscale,
    roomsize,
    scale,
    layers,
    structure,
    draw,
    cornu,
    curve,
    bezier,
    bzrlin,
    straight,
    turnout,
    turntable,
    car,
    joint,
    note,
    text,
    block,
    switchmotor,
    signal,
    sensor,
    control,
    EOL,
};    


version: () = {
    VERSION <UINTEGER> <UINTEGER> DOT <UINTEGER> DOT <UINTEGER> EOL => layout.SetVersion(<>),
};

title: () = {
    TITLE <UINTEGER> <STRINGTOEOL> EOL => layout.SetTitle(<>),
};

mapscale: () = {
    MAPSCALE <UINTEGER> EOL => layout.SetMapscale(<>),
};

roomsize: () = {
    ROOMSIZE  <FLOAT>  X  <FLOAT> EOL => layout.SetRoomsize(<>),
}; 

scale: () = {
    SCALE <scalename> EOL => layout.SetScale(<>),
}

scalename: Scale = {
    HO => Scale::HO,
    N  => Scale::N,
    O  => Scale::O,
    G  => Scale::G,
};

layers: () = {
     LAYERS <UINTEGER> <UINTEGER> <UINTEGER> <UINTEGER> <UINTEGER> <UINTEGER> 
            <UINTEGER> <UINTEGER> <UINTEGER> <STRING> <UINTEGER> <UINTEGER> 
            <FLOAT> <FLOAT> <FLOAT> <FLOAT> <FLOAT> EOL =>
            layout.AddLayer(<>),
      LAYERS CURRENT <UINTEGER> EOL => layout.SetCurrentLayer(<>),
};

structure: () = {
     STRUCTURE <UINTEGER> <UINTEGER> <UINTEGER> <UINTEGER> <UINTEGER> 
                <scalename> <UINTEGER> <FLOAT> <FLOAT> <UINTEGER> <FLOAT> 
                <STRING> EOL <adjopt> <pieropt> <structbody> ENDSEGS EOL => 
     layout.AddStructure(<>),


};

structbody: StructureBody = {
            () => StructureBody::new(),
            <e:structbodyelt> <b:structbody> => StructureBody::Append(e,b),
};

structbodyelt: StructureBodyElement = {
         D <FLOAT> <FLOAT> EOL => StructureBodyElement::D(<>),
         L <UINTEGER> <UINTEGER> <FLOAT> <FLOAT> <FLOAT> <UINTEGER> <FLOAT> 
                <FLOAT> <UINTEGER> EOL => StructureBodyElement::L(<>),
         M <UINTEGER> <UINTEGER>  <FLOAT> <FLOAT> <FLOAT> <UINTEGER> <FLOAT> 
                <FLOAT> <UINTEGER> <UINTEGER> EOL 
                => StructureBodyElement::M(<>),
         F <UINTEGER> <UINTEGER> <FLOAT> <UINTEGER> <UINTEGERorNULL> EOL 
            <fblock> => StructureBodyElement::F(<>),
         A <UINTEGER> <UINTEGER> <FLOAT> <FLOAT> <FLOAT> <FLOAT> <UINTEGER> 
            <FLOAT> <FLOAT>  EOL => StructureBodyElement::A(<>),
         B <UINTEGER> <UINTEGER> <FLOAT> <FLOAT> <FLOAT> <UINTEGER> <FLOAT> 
            <FLOAT> <UINTEGER> <UINTEGER> EOL => StructureBodyElement::B(<>),
         Q <UINTEGER> <UINTEGER> <FLOAT> <FLOAT> <FLOAT> <UINTEGER> <FLOAT> 
            <FLOAT> <UINTEGER> EOL => StructureBodyElement::Q(<>),
         G <UINTEGER> <UINTEGER> <FLOAT> <FLOAT> <FLOAT> <FLOAT> <UINTEGER> 
            EOL => StructureBodyElement::G(<>),
         Y <UINTEGER> <UINTEGER> <FLOAT> <UINTEGER> <UINTEGER> EOL <fblock>
            => StructureBodyElement::Y(<>),
         Z <UINTEGER> <FLOAT> <FLOAT> <FLOAT> <UINTEGER> <FLOAT> <STRING> EOL
            => StructureBodyElement::Z(<>),
         H <UINTEGER> <UINTEGER> <FLOAT> <FLOAT> <FLOAT> <FLOAT> <FLOAT> 
            <FLOAT> <FLOAT> <FLOAT> EOL SUBSEGS EOL <bzlsegments> SUBSEND EOL
            => StructureBodyElement::H(<>),
};

adjopt: Option<(f64, f64)> = {
    () => None,
    ADJUSTABLE <FLOAT> <FLOAT> EOL => Some((<>)),
};

pieropt: Option<(f64, String)>= {
    () => None,
    PIER <FLOAT> <STRING> EOL => Some((<>)),
};

UINTEGERorNULL: Option<u32> = {
    () => None,
    <UINTEGER> => Some(<>),
};

fblock: FBlock = {
    () => FBlock::new(),
    <e:fblock1> <b:fblock> => FBlock::Append(e,b),
};

fblock1: FBlockElement = {
    <FLOAT> <FLOAT> <UINTEGER> EOL => FBlockElement(<>),
};

bzlsegments: BZLSegments = {
    () => BZLSegments::new(),
    <e:bzlsegment> <b:bzlsegments> => BZLSegments::Append(e,b),
};
            
bzlsegment: StructureBodyElement = {
         L <UINTEGER> <UINTEGER> <FLOAT> <FLOAT> <FLOAT> <UINTEGER> <FLOAT> 
                <FLOAT> <UINTEGER> EOL => StructureBodyElement::L(<>),
         A <UINTEGER> <UINTEGER> <FLOAT> <FLOAT> <FLOAT> <FLOAT> <UINTEGER> 
            <FLOAT> <FLOAT>  EOL => StructureBodyElement::A(<>),
};

draw: () = {
    DRAW <UINTEGER> <UINTEGER> <UINTEGER> <UINTEGER> <UINTEGER> <FLOAT> <FLOAT>
         <UINTEGER> <FLOAT> EOL <structbody> ENDSEGS EOL =>
         layout.AddDrawing(<>),
};

bzrlin: () = {
    BZRLIN <UINTEGER> <UINTEGER> <UINTEGER> <UINTEGER> <UINTEGER> <scalename>
           <UINTEGER> <FLOAT> <FLOAT> <FLOAT> <FLOAT> <FLOAT> <FLOAT> <FLOAT> 
           <FLOAT> <UINTEGER> <FLOAT> <FLOAT> EOL <bzrlinbody>  ENDSEGS EOL 
                => layout.AddBZRLine(<>),
};

bzrlinbody: BZRLineBody = {
    () => BZRLineBody::new(),
    <e:bzrlinbodyelt> <b:bzrlinbody> => BZRLineBody::Append(e,b),
};

bzrlinbodyelt: StructureBodyElement = {
         A <UINTEGER> <UINTEGER> <FLOAT> <FLOAT> <FLOAT> <FLOAT> <UINTEGER> 
            <FLOAT> <FLOAT>  EOL => StructureBodyElement::A(<>),
         L <UINTEGER> <UINTEGER> <FLOAT> <FLOAT> <FLOAT> <UINTEGER> <FLOAT> 
                <FLOAT> <UINTEGER> EOL => StructureBodyElement::L(<>),
         H <UINTEGER> <UINTEGER> <FLOAT> <FLOAT> <FLOAT> <FLOAT> <FLOAT> 
            <FLOAT> <FLOAT> <FLOAT> EOL SUBSEGS EOL <bzlsegments> SUBSEND EOL
            => StructureBodyElement::H(<>),
};

cornu: () = {
    CORNU <UINTEGER> <UINTEGER> <UINTEGER> <UINTEGER> <UINTEGER> <scalename>
          <UINTEGER> <FLOAT> <FLOAT> <FLOAT> <FLOAT> <FLOAT> <FLOAT> <FLOAT>
          <FLOAT> <FLOAT> <FLOAT> <FLOAT> <FLOAT> EOL <cornubody> ENDSEGS EOL
            => layout.AddCornu(<>),
};

cornubody: CornuBody = {
    () => CornuBody::new(),
    <e:trackbodyelt> <b:cornubody> => CornuBody::AppendTrack(e,b),
    <e:cornubodyelt> <b:cornubody> => CornuBody::AppendCornu(e,b),
};

cornubodyelt: CornuBodyElement = {
         W <UINTEGER> <UINTEGER> <FLOAT> <FLOAT> <FLOAT> <FLOAT> <FLOAT>
           <FLOAT> <FLOAT> <FLOAT> <FLOAT> EOL SUBSEGS EOL <bzsegments>
           SUBSEND EOL => CornuBodyElement(<>),
};

bzsegments:  BZSegments = {
    () => BZSegments::new(),
    <e:bzsegment> <b:bzsegments> => BZSegments::AppendBZSeg(e,b),
};
           
bzsegment: BZSegment = {
    S <UINTEGER> <FLOAT> <FLOAT> <FLOAT> <FLOAT> <FLOAT> EOL
        => BZSegment::S1(<>),
    S <UINTEGER> <UINTEGER> <FLOAT> <FLOAT> <FLOAT> <FLOAT> <FLOAT> <FLOAT>
        <FLOAT> EOL
        => BZSegment::S2(<>),
    C <UINTEGER> <FLOAT> <FLOAT> <FLOAT> <FLOAT> <FLOAT> <FLOAT> EOL
        => BZSegment::C1(<>),
    C <UINTEGER> <UINTEGER> <FLOAT> <FLOAT> <FLOAT> <FLOAT> <FLOAT> <FLOAT>
        <FLOAT> EOL
        => BZSegment::C2(<>),
};
          

trackbody: TrackBody ={
    () => TrackBody::new(),
    <e:trackbodyelt> <b:trackbody> => TrackBody::AppendTrack(e,b),
};

trackbodyelt: TrackBodyElement = {
    T <UINTEGER> <FLOAT> <FLOAT> <FLOAT> <trackbodyelt1> EOL
        => TrackBodyElement::T1(<>),
    T <UINTEGER> <UINTEGER> <FLOAT> <FLOAT> <FLOAT> <trackbodyelt4> EOL
        => TrackBodyElement::T4(<>),
    E <FLOAT> <FLOAT> <FLOAT> <trackbodyelt1> EOL
        => TrackBodyElement::E1(<>),
    E <UINTEGER> <FLOAT> <FLOAT> <FLOAT> <trackbodyelt4> EOL
        => TrackBodyElement::E4(<>),
};

trackbodyelt1: Option<TrackBodySubElement> = {
    () => None,
    <UINTEGER> <FLOAT> <FLOAT> <floatornullorstring>
        => Some(TrackBodySubElement::T1(<>)),
};

trackbodyelt4: TrackBodySubElement = {
    <UINTEGER> <FLOAT> <FLOAT> <floatorstring> <FLOAT> <UINTEGER> <UINTEGER>
        <UINTEGER> <FLOAT> => TrackBodySubElement::T4(<>),
};

floatornullorstring: Option<FloatOrString> = {
    () => None,
    <floatorstring> => Some(<>),
};

floatorstring: FloatOrString = {
    <FLOAT> => FloatOrString::Float(<>),
    <STRING> => FloatOrString::String(<>),
};

curve: () = {
    CURVE <UINTEGER> <UINTEGER> <UINTEGER> <UINTEGER> <UINTEGER> <scalename> <UINTEGER> <FLOAT>
	      <FLOAT> <UINTEGER> <FLOAT> <UINTEGER> <FLOAT> <FLOAT> EOL <trackbody> ENDSEGS EOL =>
	      layout.AddCurve(<>),
};


bezier: () = {
     BEZIER <UINTEGER> <UINTEGER> <UINTEGER> <UINTEGER> <FLOAT> <scalename> <UINTEGER> <FLOAT> <FLOAT> <FLOAT> <FLOAT> <FLOAT> <FLOAT> <FLOAT> <FLOAT> <UINTEGER> <FLOAT> <FLOAT> EOL <bezierbody> ENDSEGS EOL =>
            layout.AddBezier(<>),
};

bezierbody: BezierBody = {
    () => BezierBody::new(),
    <e:bezierbodyelt> <b:bezierbody> => BezierBody::Append(e,b),
};

bezierbodyelt: BezierBodyElement = {
    <trackbodyelt> => BezierBodyElement::MakeTrackEnd(<>),
    C <UINTEGER> <FLOAT> <FLOAT> <FLOAT> <FLOAT> <FLOAT> <FLOAT> EOL =>
            BezierBodyElement::Curve1(<>),
    C <UINTEGER> <UINTEGER> <FLOAT> <FLOAT> <FLOAT> <FLOAT> <FLOAT> <FLOAT> <FLOAT> EOL =>
            BezierBodyElement::Curve2(<>),
    S <UINTEGER> <FLOAT> <FLOAT> <FLOAT> <FLOAT> <FLOAT> EOL =>
            BezierBodyElement::Straight1(<>),
    S <UINTEGER> <UINTEGER> <FLOAT> <FLOAT> <FLOAT> <FLOAT> <FLOAT> <FLOAT> <FLOAT> EOL =>
            BezierBodyElement::Straight2(<>),
};


straight: () = {
    STRAIGHT <UINTEGER> <UINTEGER> <UINTEGER> <UINTEGER> <UINTEGER> <scalename> <UINTEGER> <FLOAT> <FLOAT>
        EOL <trackbody> ENDSEGS EOL =>
		    layout.AddStraight(<>),
};

turnout: () = {
    TURNOUT <UINTEGER> <UINTEGER> <UINTEGER> <UINTEGER> <UINTEGER> <scalename> <UINTEGER>
        <FLOAT> <FLOAT> <UINTEGER> <FLOAT> <STRING>  EOL <adjopt> <pieropt> <turnoutbody> ENDSEGS EOL =>
		  layout.AddTurnout(<>),
};

turnoutbody: TurnoutBody = {
    () => TurnoutBody::new(),
    <e:turnoutbodyelt> <b:turnoutbody> 
        => TurnoutBody::AppendTurnoutBodyElement(e,b),
    <e:structbodyeltSubset> <b:turnoutbody>
        => TurnoutBody::AppendStructureBodyElement(e,b),
};

structbodyeltSubset: StructureBodyElement = {
         L <UINTEGER> <UINTEGER> <FLOAT> <FLOAT> <FLOAT> <UINTEGER> <FLOAT> 
                <FLOAT> <UINTEGER> EOL => StructureBodyElement::L(<>),
         M <UINTEGER> <UINTEGER>  <FLOAT> <FLOAT> <FLOAT> <UINTEGER> <FLOAT> 
                <FLOAT> <UINTEGER> <UINTEGER> EOL 
                => StructureBodyElement::M(<>),
         F <UINTEGER> <UINTEGER> <FLOAT> <UINTEGER> <UINTEGERorNULL> EOL 
            <fblock> => StructureBodyElement::F(<>),
         A <UINTEGER> <UINTEGER> <FLOAT> <FLOAT> <FLOAT> <FLOAT> <UINTEGER> 
            <FLOAT> <FLOAT>  EOL => StructureBodyElement::A(<>),
         B <UINTEGER> <UINTEGER> <FLOAT> <FLOAT> <FLOAT> <UINTEGER> <FLOAT> 
            <FLOAT> <UINTEGER> <UINTEGER> EOL => StructureBodyElement::B(<>),
         Q <UINTEGER> <UINTEGER> <FLOAT> <FLOAT> <FLOAT> <UINTEGER> <FLOAT> 
            <FLOAT> <UINTEGER> EOL => StructureBodyElement::Q(<>),
         G <UINTEGER> <UINTEGER> <FLOAT> <FLOAT> <FLOAT> <FLOAT> <UINTEGER> 
            EOL => StructureBodyElement::G(<>),
         Y <UINTEGER> <UINTEGER> <FLOAT> <UINTEGER> <UINTEGER> EOL <fblock>
            => StructureBodyElement::Y(<>),
         Z <UINTEGER> <FLOAT> <FLOAT> <FLOAT> <UINTEGER> <FLOAT> <STRING> EOL
            => StructureBodyElement::Z(<>),
         H <UINTEGER> <UINTEGER> <FLOAT> <FLOAT> <FLOAT> <FLOAT> <FLOAT> 
            <FLOAT> <FLOAT> <FLOAT> EOL SUBSEGS EOL <bzlsegments> SUBSEND EOL
            => StructureBodyElement::H(<>),
};

turnoutbodyelt: TurnoutBodyElement = {
    <trackbodyelt> => TurnoutBodyElement::MakeTurnoutEnd(<>),
    D <FLOAT> <FLOAT> EOL => TurnoutBodyElement::D(<>),
    P <STRING> <intlist> EOL => TurnoutBodyElement::P(<>),
    S <UINTEGER> <FLOAT> <FLOAT> <FLOAT> <FLOAT> <FLOAT> EOL =>
        TurnoutBodyElement::S1(<>),
    S <UINTEGER> <UINTEGER> <FLOAT> <FLOAT> <FLOAT> <FLOAT> <FLOAT> <FLOAT> <FLOAT> EOL
        => TurnoutBodyElement::S2(<>),
    C <UINTEGER> <FLOAT> <FLOAT> <FLOAT> <FLOAT> <FLOAT> <FLOAT> EOL =>
        TurnoutBodyElement::C1(<>),
    C <UINTEGER> <UINTEGER> <FLOAT> <FLOAT> <FLOAT> <FLOAT> <FLOAT> <FLOAT> <FLOAT> EOL
        => TurnoutBodyElement::C2(<>),
    J <UINTEGER> <FLOAT> <FLOAT> <FLOAT> <FLOAT> <FLOAT> <FLOAT> <FLOAT> <FLOAT> <UINTEGER> EOL
        => TurnoutBodyElement::J1(<>),
    J <UINTEGER> <UINTEGER> <FLOAT> <FLOAT> <FLOAT> <FLOAT> <FLOAT> <FLOAT> <FLOAT> <FLOAT> <FLOAT> <UINTEGER> EOL
        => TurnoutBodyElement::J2(<>),
    
};

intlist: IntegerList = {
    () => IntegerList::new(),
    <b:intlist> <e:UINTEGER> => IntegerList::Append(e,b),
};

turntable: () = {
     TURNTABLE <UINTEGER> <UINTEGER> <UINTEGER> <UINTEGER> <UINTEGER> 
                <scalename> <UINTEGER> <FLOAT> <FLOAT> <UINTEGER> <FLOAT> 
                <integerornull> EOL <trackbody> ENDSEGS EOL
                    => layout.AddTurntable(<>),
};

integerornull: Option<u32> = {
    () => None,
    <UINTEGER> => Some(<>),
};

joint: () = {
    //      index     layer      width      0          0          scale
    JOINT <UINTEGER> <UINTEGER> <UINTEGER> <UINTEGER> <UINTEGER> <scalename>
    //      flags     l0       l1     R       flip     negate    S-curve 
          <UINTEGER> <FLOAT> <FLOAT> <FLOAT> <UINTEGER> <UINTEGER> <UINTEGER>
    //       x       y       0         angle   desc-x  desc-y  
          <FLOAT> <FLOAT>  <UINTEGER> <FLOAT> <FLOAT>  <FLOAT> EOL
          <trackbody> ENDSEGS EOL =>
            layout.AddJoint(<>),
};

car: () = {
    //    inx        scale     "Title"   options     type      length  width
    CAR <UINTEGER> <scalename> <STRING> <UINTEGER> <UINTEGER> <FLOAT> <FLOAT>
    //      0    truck-center-offset*1000 truck-center  coupled-length
        <UINTEGER> <UINTEGER>               <FLOAT>         <FLOAT> 
    //     color puchaseprice  currentprice  condition   purchdate 
        <UINTEGER> <FLOAT>        <FLOAT>    <UINTEGER> <UINTEGER> 
    //   servdate   pad1      pad2        pad3        pad4       pad5
        <UINTEGER> <UINTEGER> <UINTEGER> <UINTEGER> <UINTEGER> <UINTEGER> 
    //     pad6     "notes"
        <UINTEGER> <STRING> <caronlayout> => layout.AddCar(<>),
};

caronlayout: Option<CarAux> = {
    EOL => None,
    // carIndex  layer     pos.x   pos.y   angle 
    <UINTEGER> <UINTEGER> <FLOAT> <FLOAT> <FLOAT> EOL <trackbody> ENDSEGS EOL 
        => Some(CarAux(<>)),
};

note: () = {
    //     index      layer       0           0      start-x start-y
    NOTE <UINTEGER> <UINTEGER> <UINTEGER> <UINTEGER> <FLOAT> <FLOAT>
    //      length     type     "text1"  "text2" 
         <UINTEGER> <UINTEGER> <STRING> <optstring> EOL =>
         layout.AddNote(<>),
};

optstring: Option<String> = {
    () => None,
    <STRING> => Some(<>),
};

text: () = {
    TEXT <UINTEGER> <UINTEGER> <UINTEGER> <UINTEGER> <UINTEGER> <FLOAT> 
         <FLOAT> <UINTEGER> <STRING> <UINTEGER> EOL =>
        layout.AddText(<>),
};

block: () = {
    //     index      name     script       tracklist
    BLOCK <UINTEGER> <STRING> <STRING> EOL <intlist> ENDBLOCK EOL
        => layout.AddBlock(<>),
};

switchmotor: () = {
    //	        index      turnout#    name     normal   reverse pointsense
    SWITCHMOTOR <UINTEGER> <UINTEGER> <STRING> <STRING> <STRING> <STRING> EOL
        => layout.AddSwitchMotor(<>),
};

signal: () = {
    //     index        layer     scale         visible    X      Y        A 
    SIGNAL <UINTEGER> <UINTEGER> <scalename> <UINTEGER> <FLOAT> <FLOAT> <FLOAT>
    //       numheads  name          aspectlist
            <UINTEGER> <STRING> EOL <aspectlist>  ENDSIGNAL EOL
            => layout.AddSignal(<>),
};

aspectlist: AspectList = {
    () => AspectList::new(),
    <b:aspectlist> ASPECT <a:STRING> <s:STRING> EOL
        => AspectList::AddAspect(b,a,s), 
};

sensor: () = {
    //        index    layer      scale       visible     X       Y    
    SENSOR <UINTEGER> <UINTEGER> <scalename> <UINTEGER> <FLOAT> <FLOAT>
    //         name   script
            <STRING> <STRING> EOL => layout.AddSensor(<>),
};

control: () = {
    // CONTROL index    layer       scale       visible start-x  start-y 
    CONTROL <UINTEGER> <UINTEGER> <scalename> <UINTEGER> <FLOAT> <FLOAT>
    //  name    on-script off-script
       <STRING> <STRING>  <STRING> EOL =>  layout.AddControl(<>),
};


STRING: String = {
<l:r#""(\\\\|\\"|[^"\\])*""#> => l.StringValue(),
};

UINTEGER: u32 = {
    <u:r"[0-9]+"> => u.U32Value(),
};

FLOAT: f64 = {
    <f:r"[+-]?[0-9]+\.[0-9]+"> => f.F64Value(),
};

EOL: () = {
    "\n",
};

DOT: () = {
    ".",
};

STRINGTOEOL: String = {
    <s:r"[^\n]*"> => s.StringValue(),
};

A: () = {
    "A",
};
ADJUSTABLE: () = {
    "ADJUSTABLE",
};
ASPECT: () = {
    "ASPECT",
};
B: () = {
    "B",
};
BEZIER: () = {
    "BEZIER",
};
BLOCK: () = {
    "BLOCK",
};
BZRLIN: () = {
    "BZRLIN",
};
C: () = {
    "C",
};
CAR: () = {
    "CAR",
};
CONTROL: () = {
    "CONTROL",
};
CORNU: () = {
    "CORNU",
};
CURRENT: () = {
    "CURRENT",
};
CURVE: () = {
    "CURVE",
};
D: () = {
    "D",
};
DRAW: () = {
    "DRAW",
};
E: () = {
    "E",
};
ENDBLOCK: () = {
    "END$BLOCK",
};
ENDSEGS: () = {
    "END$SEGS",
};
ENDSIGNAL: () = {
    "END$SIGNAL",
};
ENDTRACKS: () = {
    "END$TRACKS",
};
F: () = {
    "F",
};
G: () = {
    "G",
};
H: () = {
    "H",
};
HO: () = {
    "HO",
};
J: () = {
    "J",
};
JOINT: () = {
    "JOINT",
};
L: () = {
    "L",
};
LAYERS: () = {
    "LAYERS",
};
M: () = {
    "M",
};
MAIN: () = {
    "MAIN",
};
MAPSCALE: () = {
    "MAPSCALE",
};
N: () = {
    "N",
    };
NOTE: () = {
    "NOTE",
};
O: () = {
    "O",
};
P: () = {
    "P",
};
PIER: () = {
    "PIER",
};
Q: () = {
    "Q",
};
ROOMSIZE: () = {
    "ROOMSIZE",
};
S: () = {
    "S",
};
SCALE: () = {
    "SCALE",
};
SENSOR: () = {
    "SENSOR",
};
SIGNAL: () = {
    "SIGNAL",
};
STRAIGHT: () = {
    "STRAIGHT",
};
STRUCTURE: () = {
    "STRUCTURE",
};
SUBSEGS: () = {
    "SUBSEGS",
};
SUBSEND: () = {
    "SUBSEND",
};
SWITCHMOTOR: () = {
    "SWITCHMOTOR",
};
T: () = {
    "T",
};
TEXT: () = {
    "TEXT",
};
TITLE: () = {
    "TITLE",
};
TRK: () = {
    "TRK",
};
TURNOUT: () = {
    "TURNOUT",
};
TURNTABLE: () = {
    "TURNTABLE",
};
VERSION: () = {
    "VERSION",
};
W: () = {
    "W",
};
X: () = {
    "X",
};
Y: () = {
    "Y",
};
Z: () = {
    "Z",
};





extern {
    type Location = FileLocation;
    type Error = LexicalError;
    
    enum Tok {
        "" => Tok::NULL,
        "\n" => Tok::EOL,
        "." => Tok::DOT,
        r"[^\n]*" => Tok::STRINGTOEOL(_s),
        r#""(\\\\|\\"|[^"\\])*""# => Tok::STRING(_s),
        r"[0-9]+" => Tok::UINTEGER(_u),
        r"[+-]?[0-9]+\.[0-9]+" => Tok::FLOAT(_f),
        "A" => Tok::A,
        "ADJUSTABLE" => Tok::ADJUSTABLE,
        "ASPECT" => Tok::ASPECT,
        "B" => Tok::B,
        "BEZIER" => Tok::BEZIER,
        "BLOCK" => Tok::BLOCK,
        "BZRLIN" => Tok::BZRLIN,
        "C" => Tok::C,
        "CAR" => Tok::CAR,
        "CONTROL" => Tok::CONTROL,
        "CORNU" => Tok::CORNU,
        "CURRENT" => Tok::CURRENT,
        "CURVE" => Tok::CURVE,
        "D" => Tok::D,
        "DRAW" => Tok::DRAW,
        "E" => Tok::E,
        "END$BLOCK" => Tok::ENDBLOCK,
        "END$SEGS" => Tok::ENDSEGS,
        "END$SIGNAL" => Tok::ENDSIGNAL,
        "END$TRACKS" => Tok::ENDTRACKS,
        "F" => Tok::F,
        "G" => Tok::G,
        "H" => Tok::H,
        "HO" => Tok::HO,
        "J" => Tok::J,
        "JOINT" => Tok::JOINT,
        "L" => Tok::L,
        "LAYERS" => Tok::LAYERS,
        "M" => Tok::M,
        "MAIN" => Tok::MAIN,
        "MAPSCALE" => Tok::MAPSCALE,
        "N" => Tok::N,
        "NOTE" => Tok::NOTE,
        "O" => Tok::O,
        "P" => Tok::P,
        "PIER" => Tok::PIER,
        "Q" => Tok::Q,
        "ROOMSIZE" => Tok::ROOMSIZE,
        "S" => Tok::S,
        "SCALE" => Tok::SCALE,
        "SENSOR" => Tok::SENSOR,
        "SIGNAL" => Tok::SIGNAL,
        "STRAIGHT" => Tok::STRAIGHT,
        "STRUCTURE" => Tok::STRUCTURE,
        "SUBSEGS" => Tok::SUBSEGS,
        "SUBSEND" => Tok::SUBSEND,
        "SWITCHMOTOR" => Tok::SWITCHMOTOR,
        "T" => Tok::T,
        "TEXT" => Tok::TEXT,
        "TITLE" => Tok::TITLE,
        "TRK" => Tok::TRK,
        "TURNOUT" => Tok::TURNOUT,
        "TURNTABLE" => Tok::TURNTABLE,
        "VERSION" => Tok::VERSION,
        "W" => Tok::W,
        "X" => Tok::X,
        "Y" => Tok::Y,
        "Z" => Tok::Z,
    }
}