AlignedMixin

abstract def grammarContext: SchemaComponent

For unit testing, we want to create GrammarMixin objects that are not schema components.

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

val NYI: Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

lazy val contentStartAlignment: AlignmentMultipleOf

lazy val elementSpecifiedLengthApprox: LengthApprox

lazy val endingAlignmentApprox: AlignmentMultipleOf

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

final def getClass(): Class[_]

final lazy val hasNoSkipRegions: Boolean

def hashCode(): Int

final lazy val isDelimiterKnownToBeTextAligned: Boolean

final def isInstanceOf[T0]: Boolean

final lazy val isKnownToBeAligned: Boolean

true if we can statically determine that the start of this will be properly aligned by where the prior thing left us positioned.

lazy val isKnownToBeByteAlignedAndByteLength: Boolean

final lazy val isKnownToBeTextAligned: Boolean

True if alignment for a text feature of this Term (e.g., an initiator) is provably not needed, either because there is no requirement for such alignment, or we can prove that the required alignment is already established.

lazy val leadingSkipInBits: Int

final def mt: Gram

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def prod(prodName: String)(gram: ⇒ Gram): Gram

Use when production has no guard, but you want to name the production anyway (for debug visibility perhaps).

def prod(prodName: String, guard: Boolean = true, forWhat: ParserOrUnparser = BothParserAndUnparser)(gram: ⇒ Gram): Gram

Use when production has a guard predicate

final def synchronized[T0](arg0: ⇒ T0): T0

def toString(): String

lazy val trailingSkipApprox: LengthApprox

lazy val trailingSkipInBits: Int

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit