a rough ohm parse script for nandeck

nde.ohm

NDE   {
	Script = (Statement | AnyDirective)*
    
    spaceNoNL = ~"\n" "\x00".."\x20"
    spacesNoNL = spaceNoNL*
    delim = spacesNoNL ( ",") spacesNoNL
  
  // imported from ES5
  lineTerminator = "\n" | "\r" | "\u2028" | "\u2029"
  lineTerminatorSequence = "\n" | "\r" ~"\n" | "\u2028" | "\u2029" | "\r\n"
  comment = ";" (~lineTerminator any)*

  decimalDigit = "0".."9"
  nonZeroDigit = "1".."9"

  // For semantics on how string literals are constructed, see section 7.8.4
  stringLiteral = "\"" doubleStringCharacter* "\""
                | "'" singleStringCharacter* "'"
  doubleStringCharacter = ~("\"" | "\\" | lineTerminator) any -- nonEscaped
                        | "\\" escapeSequence                             -- escaped
                        | lineContinuation                                -- lineContinuation
  singleStringCharacter = ~("'" | "\\" | lineTerminator) any -- nonEscaped
                        | "\\" escapeSequence                            -- escaped
                        | lineContinuation                               -- lineContinuation
  lineContinuation = "\\" lineTerminatorSequence
  escapeSequence = unicodeEscapeSequence
                 | characterEscapeSequence  // Must come last.
  characterEscapeSequence = singleEscapeCharacter
                          | nonEscapeCharacter
  singleEscapeCharacter = "'" | "\"" | "\\" | "b" | "f" | "n" | "r" | "t" | "v"
  nonEscapeCharacter = ~(escapeCharacter | lineTerminator) any
  escapeCharacter = singleEscapeCharacter | decimalDigit | "x" | "u"
  
  unicodeEscapeSequence = "u" hexDigit hexDigit hexDigit hexDigit
  
  withIn =
  
  literal =
  
  PrimaryExpression = identifier
  					| Length
                    | number
  					| label
                    | stringLiteral
                    | "{" Expression<withIn> "}" -- evalExpr
                    | "(" Expression<withIn> ")"  -- parenExpr
  
  top = caseInsensitive<"T">
  center =  caseInsensitive<"C">
  bottom = caseInsensitive<"B">
  left= caseInsensitive<"L">
  right = caseInsensitive<"R">
  
  frameVerticalFlags = (top | center | bottom)
  frameHorizontalFlags = (left | center|  right)
  FrameAlignment = #(frameVerticalFlags frameHorizontalFlags) "," AdditiveExpression "," AdditiveExpression
  
  wide = caseInsensitive<"W">
  tall = caseInsensitive<"H">
  
  FrameVerticalWide = #(frameVerticalFlags wide) "," AdditiveExpression
  
  FrameHorizontalTall = #(tall frameHorizontalFlags) "," AdditiveExpression
  
  position = caseInsensitive<"P">
  
  framePositionFlags = position frameVerticalFlags frameHorizontalFlags
  
  FramePosition = framePositionFlags ("," framePositionFlags)?
  
  sub = caseInsensitive<"S">
  
  SubFrame = (#((top | bottom) sub) | #(sub (left | right))) "," AdditiveExpression
  
  rightAngleFrame = tall (top | bottom) (left | right)
  
  isoscelesFrame = top (((top |bottom) (left | center | right)) | (center (left | right)))
  
  FrameMemberExpression = "<" identifier ","
  (FrameAlignment | FrameVerticalWide | FrameHorizontalTall | FramePosition | SubFrame | rightAngleFrame | isoscelesFrame)
  ">"
  
  frameGroupExpression = "<" digit* ("?" | "~" | "!" | "/" | "°" | "µ")* identifier "*>"
  
  frameBoxExpression = "<"
   identifier
  (
    (digit+ ("-" | "_" | ".") digit+)
    // this is incomplete
  )
  ">"
  
  MemberExpression = frameGroupExpression
  | FrameMemberExpression
  | PrimaryExpression

 CallExpression = PrimaryExpression Arguments
 
 Arguments = "(" ListOf<AssignmentExpression<withIn>, ","> ")"

  PostfixExpression = PrimaryExpression #(spacesNoNL "++")  -- postIncrement
                    | PrimaryExpression #(spacesNoNL "--")  -- postDecrement
                    | PrimaryExpression

  UnaryExpression =  "++"   UnaryExpression  -- preIncrement
                  | "--"   UnaryExpression  -- preDecrement
                  | "+"    UnaryExpression  -- unaryPlus
                  | "-"    UnaryExpression  -- unaryMinus
                  | "~"    UnaryExpression  -- bnot
                  | "!"    UnaryExpression  -- lnot
                  | "="   UnaryExpression  --conditionalIdent
                  | PostfixExpression

  MultiplicativeExpression = MultiplicativeExpression "*" UnaryExpression -- mul
                           | MultiplicativeExpression "/" UnaryExpression -- div
                           | MultiplicativeExpression "%" UnaryExpression -- mod
                           | UnaryExpression

  AdditiveExpression = AdditiveExpression "+" MultiplicativeExpression -- add
                     | AdditiveExpression "-" MultiplicativeExpression -- sub
                     | MultiplicativeExpression
    ShiftExpression = ShiftExpression "<<" AdditiveExpression  -- lsl
                  | ShiftExpression ">>>" AdditiveExpression -- lsr
                  | ShiftExpression ">>" AdditiveExpression  -- asr
                  | AdditiveExpression

  RelationalExpression<guardIn>
    = RelationalExpression<guardIn> "<" ShiftExpression           -- lt
    | RelationalExpression<guardIn> ">" ShiftExpression           -- gt
    | RelationalExpression<guardIn> "<=" ShiftExpression          -- le
    | RelationalExpression<guardIn> ">=" ShiftExpression          -- ge
    | RelationalExpression<guardIn> "instanceof" ShiftExpression  -- instanceOfExp
    | RelationalExpression<guardIn> guardIn "in" ShiftExpression  -- inExp
    | ShiftExpression

  EqualityExpression<guardIn>
    = EqualityExpression<guardIn> "==" RelationalExpression<guardIn>  -- equal
    | EqualityExpression<guardIn> "!=" RelationalExpression<guardIn>  -- notEqual
    | EqualityExpression<guardIn> "===" RelationalExpression<guardIn> -- eq
    | EqualityExpression<guardIn> "!==" RelationalExpression<guardIn> -- notEq
    | RelationalExpression<guardIn>

  BitwiseANDExpression<guardIn>
    = BitwiseANDExpression<guardIn> "&" EqualityExpression<guardIn> -- band
    | EqualityExpression<guardIn>

  BitwiseXORExpression<guardIn>
    = BitwiseXORExpression<guardIn> "^" BitwiseANDExpression<guardIn> -- bxor
    | BitwiseANDExpression<guardIn>

  BitwiseORExpression<guardIn>
    = BitwiseORExpression<guardIn> "|" BitwiseXORExpression<guardIn> -- bor
    | BitwiseXORExpression<guardIn>

  LogicalANDExpression<guardIn>
    = LogicalANDExpression<guardIn> "&&" BitwiseORExpression<guardIn> -- land
    | BitwiseORExpression<guardIn>

  LogicalORExpression<guardIn>
    = LogicalORExpression<guardIn> "||" LogicalANDExpression<guardIn> -- lor
    | LogicalANDExpression<guardIn>

  ConditionalExpression<guardIn>
    = LogicalORExpression<guardIn> "?" AssignmentExpression<withIn> ":" AssignmentExpression<guardIn> -- conditional
    | LogicalORExpression<guardIn>

  AssignmentExpression<guardIn>
    = PrimaryExpression assignmentOperator AssignmentExpression<guardIn> -- assignment
    | ConditionalExpression<guardIn>
  
  Expression<guardIn> (an expression)
    = Expression<guardIn> "," AssignmentExpression<guardIn> -- commaExp
    | AssignmentExpression<guardIn>
  // end ES5 import
  
  assignmentOperator = "=" | ">>>=" | "<<=" | ">>="
                     | "*=" | "/=" | "%=" | "+=" | "-=" | "&=" | "^=" | "|="
  
  	FrameParameters = NumericValue "," NumericValue "," NumericValue "," NumericValue
    frameIdentifier = "<" identifier ">"
    FrameDeclaration = frameIdentifier "=" ( FrameParameters | MemberExpression)
        
    LabelArguments = "=" (FrameMemberExpression | Length | RangeValue | number | stringLiteral | colorLiteral | CallExpression )
    
    ConditionalLabelDeclaration = conditionalLabelIdentifier LabelArguments
    ArrangedLabelDeclaration = (labelArrangementFlags labelLimitFlags? label digit+) LabelArguments
    SlicedLabelDeclaration = labelLimitFlags label LabelArguments
    NaturalLabelDeclaration = label LabelArguments
    
    LabelDeclaration = ConditionalLabelDeclaration | ArrangedLabelDeclaration | SlicedLabelDeclaration | NaturalLabelDeclaration
    
    labelArrangementFlags = (("C" | "P" | "E") "R"?)
    labelLimitFlags = (("T" | "K") digit+)
    conditionalLabelIdentifier = label "%" label
    
    label = "[" identifier "]"
    
    AnyDirective = Directive<identifier>
    
    Directive<name> = name "=" ListOf<(gradientLiteral | AdditiveExpression | MultiplicativeExpression | MemberExpression | frameIdentifier | Length | RangeValue | number | stringLiteral | identifier | colorLiteral | ""), delim>
    EmptyDirective<name> = name spacesNoNL "="
    identifier
     = ~lineTerminator letter alnum*
     
    stringName = alnum*
    
    comparator = "==" | "<" | ">"
    operator = "+" | "-" | "/" | "*"

   	NumericValue = Length | number | label
    
    ExpressionEval = "{" (number | expression | operator)* "}"
    expression = "(" ")"
    
    RangeLiteral = "\"" ListOf<(RangeValue | number), spaceNoNL> "\""
    Range = (number | label) "-" (number | ExpressionEval | label)
    RangeIter=number "#" (number | ExpressionEval)
    RangeValue= Range | RangeLiteral | RangeIter | ExpressionEval
	Length = (number | ExpressionEval) ("cm" | "mm" | "inch" | "%%" | "%")
    
    gradientLiteral = (colorLiteral | label) (colorLiteral | label) "@" digit+
	colorLiteral = "#" hexDigit hexDigit hexDigit hexDigit hexDigit hexDigit
	number  (a number)
      = digit* "." digit+  -- fract
      | digit+             -- whole
      
      
    layerKeyword = caseInsensitive<"layer">
    frameKeyword = caseInsensitive<"frame">
    linkKeyword = caseInsensitive<"link">
    sequenceKeyword = caseInsensitive<"sequence">
    forKeyword = caseInsensitive<"for">
    nextKeyword = caseInsensitive<"next">
    selectKeyword = caseInsensitive<"select">
    caseKeyword = caseInsensitive<"case">
    caseElseKeyword = caseInsensitive<"caseelse">
    sectionKeyword = caseInsensitive<"section">
    macroKeyword = caseInsensitive<"macro">
    endKeyword<name> = caseInsensitive<"end"> name
    
    endLayer = endKeyword<layerKeyword>
    
    BlockStatement<name> = (Directive<name>|name) StatementList endKeyword<name>
    
    IdentifierDirective<name> = EmptyDirective<name>spacesNoNL identifier
    
    LayerStatement = BlockStatement<layerKeyword>
    FrameStatement = BlockStatement<frameKeyword>
    ForStatement = EmptyDirective<forKeyword> spacesNoNL identifier delim NumericValue delim NumericValue
    (~nextKeyword Statement)
    nextKeyword
    
    linkStatementEntry = listOf<alnum*, delim>
    endLink = endKeyword<linkKeyword>
    LinkBlock = EmptyDirective<linkKeyword> lineTerminator listOf<~endLink linkStatementEntry, lineTerminator> lineTerminator endLink
    LinkStatement = (LinkBlock | Directive<linkKeyword>)
    
    endSequence = endKeyword<sequenceKeyword>
    SequenceStatement = IdentifierDirective<sequenceKeyword> (~endSequence identifier)* endSequence
    
    CaseDirective = EmptyDirective<caseKeyword> spacesNoNL (comparator)? NumericValue
    CaseBlock = CaseDirective StatementList
    
    CaseElseBlock=  caseElseKeyword StatementList
    SelectStatement = EmptyDirective<selectKeyword> label CaseBlock* CaseElseBlock endKeyword<selectKeyword>
    
    on = caseInsensitive<"on">
    off = caseInsensitive<"off">
    
    SectionStatement = EmptyDirective<sectionKeyword>spacesNoNL identifier delim (on | off) (delim ("N" | "O"))?
    StatementList
    endKeyword<sectionKeyword>
    
    parameter = "(" identifier ")"
    ParameterizedRange = (NumericValue | parameter) "-" (NumericValue | parameter)
    ParameterizedRangeValue = ParameterizedRange | RangeLiteral | RangeIter | ExpressionEval
    ParameterizedDirective<name> = EmptyDirective<name> spacesNoNL ListOf<( ParameterizedRangeValue | parameter | Length | number | stringLiteral | identifier | colorLiteral), delim>
    AnyParameterizedDirective = ParameterizedDirective<identifier>
    
    MacroStatement = EmptyDirective<macroKeyword> spacesNoNL
    identifier delim
    listOf<parameter, delim>
    (AnyParameterizedDirective | Statement)* // only allow parameters inside macros
    
    Declaration = LabelDeclaration
    	| FrameDeclaration
    
    Statement = LayerStatement
    	| FrameStatement
        | ForStatement
    	| LinkStatement
    	| SequenceStatement
        | SelectStatement
        | SectionStatement
        | MacroStatement
        | Declaration
        | ~CaseDirective ~caseElseKeyword AnyDirective
        | comment
    
    StatementList = Statement*
}