#792 Change the syntax error exception definition to include position in error line.

yruslan · yruslan · commit 45ef3a23fdca · 2025-11-04T09:06:11.000+01:00
diff --git a/cobol-parser/src/main/scala/za/co/absa/cobrix/cobol/parser/antlr/ANTLRParser.scala b/cobol-parser/src/main/scala/za/co/absa/cobrix/cobol/parser/antlr/ANTLRParser.scala
@@ -29,13 +29,14 @@ import za.co.absa.cobrix.cobol.parser.policies.StringTrimmingPolicy.StringTrimmi
 import java.nio.charset.Charset
 
 
-class ThrowErrorStrategy() extends DefaultErrorStrategy {
+class ThrowErrorStrategy(posAdjustment: Int) extends DefaultErrorStrategy {
   override def recover(recognizer: Parser, e: RecognitionException): Unit = {
     throw new SyntaxErrorException(
       e.getOffendingToken.getLine,
-      "",
+      Option(e.getOffendingToken.getCharPositionInLine + posAdjustment),
+      None,
       "Invalid input " + getTokenErrorDisplay(e.getOffendingToken) + " at position " + e.getOffendingToken.getLine
-      + ":" + (e.getOffendingToken.getCharPositionInLine + 6)
+      + ":" + (e.getOffendingToken.getCharPositionInLine + posAdjustment)
     )
   }
 
@@ -65,8 +66,9 @@ object ANTLRParser extends Logging {
             isUtf16BigEndian: Boolean,
             floatingPointFormat: FloatingPointFormat,
             fieldCodePageMap: Map[String, String]): CopybookAST = {
-    val visitor = new ParserVisitor(enc, stringTrimmingPolicy, isDisplayAlwaysString, ebcdicCodePage, asciiCharset, isUtf16BigEndian, floatingPointFormat, strictSignOverpunch, improvedNullDetection, strictIntegralPrecision, decodeBinaryAsHex, fieldCodePageMap)
+    val visitor = new ParserVisitor(enc, stringTrimmingPolicy, commentPolicy, isDisplayAlwaysString, ebcdicCodePage, asciiCharset, isUtf16BigEndian, floatingPointFormat, strictSignOverpunch, improvedNullDetection, strictIntegralPrecision, decodeBinaryAsHex, fieldCodePageMap)
 
+    val adjPos = if (commentPolicy.truncateComments) commentPolicy.commentsUpToChar else 0
     val strippedContents = filterSpecialCharacters(copyBookContents).split("\\r?\\n").map(
       line =>
         truncateComments(line, commentPolicy)
@@ -81,7 +83,7 @@ object ANTLRParser extends Logging {
     val parser = new copybookParser(tokens)
     parser.removeErrorListeners()
     parser.addErrorListener(new LogErrorListener(logger))
-    parser.setErrorHandler(new ThrowErrorStrategy())
+    parser.setErrorHandler(new ThrowErrorStrategy(adjPos))
 
     visitor.visitMain(parser.main())
     visitor.ast
diff --git a/cobol-parser/src/main/scala/za/co/absa/cobrix/cobol/parser/antlr/ParserVisitor.scala b/cobol-parser/src/main/scala/za/co/absa/cobrix/cobol/parser/antlr/ParserVisitor.scala
@@ -28,6 +28,7 @@ import za.co.absa.cobrix.cobol.parser.decoders.FloatingPointFormat.FloatingPoint
 import za.co.absa.cobrix.cobol.parser.encoding.codepage.CodePage
 import za.co.absa.cobrix.cobol.parser.encoding._
 import za.co.absa.cobrix.cobol.parser.exceptions.SyntaxErrorException
+import za.co.absa.cobrix.cobol.parser.policies.CommentPolicy
 import za.co.absa.cobrix.cobol.parser.policies.StringTrimmingPolicy.StringTrimmingPolicy
 import za.co.absa.cobrix.cobol.parser.position.{Left, Position, Right}
 
@@ -41,6 +42,7 @@ sealed trait Expr
 
 class ParserVisitor(enc: Encoding,
                     stringTrimmingPolicy: StringTrimmingPolicy,
+                    commentPolicy: CommentPolicy,
                     isDisplayAlwaysString: Boolean,
                     ebcdicCodePage: CodePage,
                     asciiCharset: Charset,
@@ -158,19 +160,19 @@ class ParserVisitor(enc: Encoding,
           pic.value match {
             case dec: Decimal =>
               if (dec.compact.isDefined && !dec.compact.contains(usageVal))
-                throw  new SyntaxErrorException(ctx.start.getLine, "", s"Field USAGE (${dec.compact.get}) doesn't match group's USAGE ($usageVal).")
+                throw  new SyntaxErrorException(ctx.start.getLine, Option(ctx.start.getCharPositionInLine), None, s"Field USAGE (${dec.compact.get}) doesn't match group's USAGE ($usageVal).")
               dec.copy(compact=usage)
             case int: Integral =>
               if (int.compact.isDefined && !int.compact.contains(usageVal))
-                throw  new SyntaxErrorException(ctx.start.getLine, "", s"Field USAGE (${int.compact.get}) doesn't match group's USAGE ($usageVal).")
+                throw  new SyntaxErrorException(ctx.start.getLine, Option(ctx.start.getCharPositionInLine), None, s"Field USAGE (${int.compact.get}) doesn't match group's USAGE ($usageVal).")
               int.copy(compact=usage)
             case x: AlphaNumeric if usageVal == COMP3U() =>
               Integral(x.pic, x.length*2, None, false, None, Some(COMP3U()), None, x.originalPic)
             case x: AlphaNumeric if usageVal == COMP1() || usageVal == COMP4() =>
               val enc = if (decodeBinaryAsHex) HEX else RAW
               x.copy(compact=usage, enc=Some(enc))
             case x: AlphaNumeric =>
-              throw new SyntaxErrorException(ctx.start.getLine, "", s"Field USAGE $usageVal is not supported with this PIC: ${x.pic}. The field should be numeric.")
+              throw new SyntaxErrorException(ctx.start.getLine, Option(ctx.start.getCharPositionInLine), None, s"Field USAGE $usageVal is not supported with this PIC: ${x.pic}. The field should be numeric.")
           }
         )
     }
@@ -226,7 +228,7 @@ class ParserVisitor(enc: Encoding,
       case None => addLevel(section)
       case Some(s) if s > section => addLevel(section)
       case _ =>
-        throw new SyntaxErrorException(levels.top.el.children.last.lineNumber, levels.top.el.children.last.name,
+        throw new SyntaxErrorException(levels.top.el.children.last.lineNumber, None, Option(levels.top.el.children.last.name),
           s"The field is a leaf element and cannot contain nested fields.")
     }
 
@@ -556,35 +558,37 @@ class ParserVisitor(enc: Encoding,
   }
 
   def checkBounds(ctx: ParserRuleContext, expr: PicExpr): PicExpr = {
+    val adjustPos = if (commentPolicy.truncateComments) commentPolicy.commentsUpToChar + 1 else 1
+    val pos = Option(ctx.stop.getCharPositionInLine + adjustPos)
     expr.value match {
       case x: Decimal =>
         if (x.isSignSeparate && x.compact.isDefined)
-          throw new SyntaxErrorException(ctx.start.getLine, getIdentifier(ctx.parent),
+          throw new SyntaxErrorException(ctx.start.getLine, None, Option(getIdentifier(ctx.parent)),
             s"SIGN SEPARATE clause is not supported for ${x.compact.get}. It is only supported for DISPLAY formatted fields.")
         if(x.scale > Constants.maxDecimalScale)
-          throw new SyntaxErrorException(ctx.start.getLine, getIdentifier(ctx.parent),
+          throw new SyntaxErrorException(ctx.start.getLine, pos, Option(getIdentifier(ctx.parent)),
             s"Decimal numbers with scale bigger than ${Constants.maxDecimalScale} are not supported.")
         if(x.precision > Constants.maxDecimalPrecision)
-          throw new SyntaxErrorException(ctx.start.getLine, getIdentifier(ctx.parent),
+          throw new SyntaxErrorException(ctx.start.getLine, pos, Option(getIdentifier(ctx.parent)),
             s"Decimal numbers with precision bigger than ${Constants.maxDecimalPrecision} are not supported.")
         if (x.compact.isDefined && x.explicitDecimal)
-          throw new SyntaxErrorException(ctx.start.getLine, getIdentifier(ctx.parent),
+          throw new SyntaxErrorException(ctx.start.getLine, pos, Option(getIdentifier(ctx.parent)),
             s"Explicit decimal point in 'PIC ${expr.value.originalPic.get}' is not supported for ${x.compact.get}. It is only supported for DISPLAY formatted fields.")
       case x: Integral =>
         if (x.isSignSeparate && x.compact.isDefined) {
-          throw new SyntaxErrorException(ctx.start.getLine, getIdentifier(ctx.parent),
+          throw new SyntaxErrorException(ctx.start.getLine, None, Option(getIdentifier(ctx.parent)),
             s"SIGN SEPARATE clause is not supported for ${x.compact.get}. It is only supported for DISPLAY formatted fields.")
         }
         if (x.precision > Constants.maxBinIntPrecision && x.compact.contains(COMP4())) {
-          throw new SyntaxErrorException(ctx.start.getLine, getIdentifier(ctx.parent),
+          throw new SyntaxErrorException(ctx.start.getLine, pos, Option(getIdentifier(ctx.parent)),
             s"BINARY-encoded integers with precision bigger than ${Constants.maxBinIntPrecision} are not supported.")
         }
         if (x.precision < 1 || x.precision >= Constants.maxFieldLength)
-          throw new SyntaxErrorException(ctx.start.getLine, getIdentifier(ctx.parent),
+          throw new SyntaxErrorException(ctx.start.getLine, pos, Option(getIdentifier(ctx.parent)),
             s"Incorrect field size of ${x.precision} for PIC ${expr.value.originalPic.get}. Supported size is in range from 1 to ${Constants.maxFieldLength}.")
       case x: AlphaNumeric =>
         if (x.length < 1 || x.length >= Constants.maxFieldLength)
-          throw new SyntaxErrorException(ctx.start.getLine, getIdentifier(ctx.parent),
+          throw new SyntaxErrorException(ctx.start.getLine, pos, Option(getIdentifier(ctx.parent)),
             s"Incorrect field size of ${x.length} for PIC ${expr.value.originalPic.get}. Supported size is in range from 1 to ${Constants.maxFieldLength}.")
     }
     expr
diff --git a/cobol-parser/src/main/scala/za/co/absa/cobrix/cobol/parser/asttransform/BinaryPropertiesAdder.scala b/cobol-parser/src/main/scala/za/co/absa/cobrix/cobol/parser/asttransform/BinaryPropertiesAdder.scala
@@ -53,10 +53,10 @@ class BinaryPropertiesAdder extends AstTransformer {
           redefinedNames.clear()
         case Some(redefines) =>
           if (i == 0) {
-            throw new SyntaxErrorException(child.lineNumber, child.name, s"The first field of a group cannot use REDEFINES keyword.")
+            throw new SyntaxErrorException(child.lineNumber, None, Option(child.name), s"The first field of a group cannot use REDEFINES keyword.")
           }
           if (!redefinedNames.contains(redefines.toUpperCase)) {
-            throw new SyntaxErrorException(child.lineNumber, child.name, s"The field ${child.name} redefines $redefines, which is not part if the redefined fields block.")
+            throw new SyntaxErrorException(child.lineNumber, None, Option(child.name), s"The field ${child.name} redefines $redefines, which is not part if the redefined fields block.")
           }
           newChildren(i - 1) = newChildren(i - 1).withUpdatedIsRedefined(newIsRedefined = true)
       }
diff --git a/cobol-parser/src/main/scala/za/co/absa/cobrix/cobol/parser/exceptions/SyntaxErrorException.scala b/cobol-parser/src/main/scala/za/co/absa/cobrix/cobol/parser/exceptions/SyntaxErrorException.scala
@@ -16,15 +16,26 @@
 
 package za.co.absa.cobrix.cobol.parser.exceptions
 
-class SyntaxErrorException(val lineNumber: Int, val field: String, val msg: String)
-  extends Exception(SyntaxErrorException.constructErrorMessage(lineNumber, field, msg)) {
+class SyntaxErrorException(val lineNumber: Int, val posOpt: Option[Int], val fieldOpt: Option[String], val msg: String)
+  extends Exception(SyntaxErrorException.constructErrorMessage(lineNumber, posOpt, fieldOpt, msg)) {
 }
 
 object SyntaxErrorException {
-  private def constructErrorMessage(lineNumber: Int, field: String, msg: String): String = {
-    val atLine = if (lineNumber > 0) s" at line $lineNumber"
-    val atField = if (field.nonEmpty) s", field $field" else ""
+  private def constructErrorMessage(lineNumber: Int, pos: Option[Int], fieldOpt: Option[String], msg: String): String = {
+    val atLine = if (lineNumber > 0) {
+      pos match {
+        case Some(p) => s" at line $lineNumber:$p"
+        case None => s" at line $lineNumber"
+      }
+    }
+    else
+      ""
+
+    val atField = fieldOpt match {
+      case Some(f) => s", field $f"
+      case None => ""
+    }
 
     s"Syntax error in the copybook$atLine$atField: $msg"
   }
-}
+}
diff --git a/cobol-parser/src/test/scala/za/co/absa/cobrix/cobol/parser/decoders/StringDecodersSpec.scala b/cobol-parser/src/test/scala/za/co/absa/cobrix/cobol/parser/decoders/StringDecodersSpec.scala
@@ -260,7 +260,7 @@ class StringDecodersSpec extends AnyWordSpec {
           0xAA, 0xAB, 0xAC, 0xAD, 0x8C, 0x8E, 0x80, 0xB6, 0xB3, 0xB5, 0xB7, 0xB1, 0xB0, 0xB4, 0x76, 0xA0,
           0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, 0xC8, 0xC9, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7,
           0xD8, 0xD9, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, 0xE8, 0xE9, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6,
-          0xF7, 0xF8, 0xF9, 0x4A, 0x5A, 0x25, 0x0D,
+          0xF7, 0xF8, 0xF9, 0x4A, 0x5A, 0x25, 0x0D
         ).map(_.toByte)
 
         val enc = new CodePage1025
diff --git a/cobol-parser/src/test/scala/za/co/absa/cobrix/cobol/parser/parse/DataSizeSpec.scala b/cobol-parser/src/test/scala/za/co/absa/cobrix/cobol/parser/parse/DataSizeSpec.scala
@@ -25,7 +25,7 @@ import za.co.absa.cobrix.cobol.parser.ast.{Group, Primitive}
 import za.co.absa.cobrix.cobol.parser.decoders.FloatingPointFormat
 import za.co.absa.cobrix.cobol.parser.encoding.ASCII
 import za.co.absa.cobrix.cobol.parser.encoding.codepage.CodePage
-import za.co.absa.cobrix.cobol.parser.policies.StringTrimmingPolicy
+import za.co.absa.cobrix.cobol.parser.policies.{CommentPolicy, StringTrimmingPolicy}
 
 import java.nio.charset.StandardCharsets
 
@@ -35,6 +35,7 @@ class DataSizeSpec extends AnyFunSuite {
   private def parse(pic: String): Primitive = {
     val visitor = new ParserVisitor(ASCII,
       StringTrimmingPolicy.TrimNone,
+      CommentPolicy(),
       isDisplayAlwaysString = false,
       CodePage.getCodePageByName("common"),
       StandardCharsets.US_ASCII,
@@ -55,7 +56,7 @@ class DataSizeSpec extends AnyFunSuite {
     val parser = new copybookParser(tokens)
     parser.removeErrorListeners()
     parser.addErrorListener(new LogErrorListener(logger))
-    parser.setErrorHandler(new ThrowErrorStrategy())
+    parser.setErrorHandler(new ThrowErrorStrategy(6))
     visitor.visit(parser.main())
     visitor.ast.children.head.asInstanceOf[Group].children.head.asInstanceOf[Primitive]
   }
diff --git a/cobol-parser/src/test/scala/za/co/absa/cobrix/cobol/parser/parse/PicValidationSpec.scala b/cobol-parser/src/test/scala/za/co/absa/cobrix/cobol/parser/parse/PicValidationSpec.scala
@@ -26,7 +26,7 @@ import za.co.absa.cobrix.cobol.parser.decoders.FloatingPointFormat
 import za.co.absa.cobrix.cobol.parser.encoding.ASCII
 import za.co.absa.cobrix.cobol.parser.encoding.codepage.CodePage
 import za.co.absa.cobrix.cobol.parser.exceptions.SyntaxErrorException
-import za.co.absa.cobrix.cobol.parser.policies.StringTrimmingPolicy
+import za.co.absa.cobrix.cobol.parser.policies.{CommentPolicy, StringTrimmingPolicy}
 
 class PicValidationSpec extends AnyFunSuite {
   private val logger: Logger = LoggerFactory.getLogger(this.getClass)
@@ -35,6 +35,7 @@ class PicValidationSpec extends AnyFunSuite {
 
     val visitor = new ParserVisitor(ASCII,
       StringTrimmingPolicy.TrimNone,
+      CommentPolicy(),
       isDisplayAlwaysString = false,
       CodePage.getCodePageByName("common"),
       StandardCharsets.UTF_8,
@@ -55,7 +56,7 @@ class PicValidationSpec extends AnyFunSuite {
     val parser = new copybookParser(tokens)
     parser.removeErrorListeners()
     parser.addErrorListener(new LogErrorListener(logger))
-    parser.setErrorHandler(new ThrowErrorStrategy())
+    parser.setErrorHandler(new ThrowErrorStrategy(6))
     visitor.visit(parser.main())
   }
 
diff --git a/cobol-parser/src/test/scala/za/co/absa/cobrix/cobol/parser/parse/SyntaxErrorsSpec.scala b/cobol-parser/src/test/scala/za/co/absa/cobrix/cobol/parser/parse/SyntaxErrorsSpec.scala
@@ -41,6 +41,8 @@ class SyntaxErrorsSpec extends AnyFunSuite {
     }
 
     assert(syntaxErrorException.lineNumber == 5)
+    assert(syntaxErrorException.posOpt.isEmpty)
+    assert(syntaxErrorException.fieldOpt.contains("GRP_FIELD"))
     assert(syntaxErrorException.msg.contains("The field is a leaf element"))
   }
 
@@ -57,6 +59,8 @@ class SyntaxErrorsSpec extends AnyFunSuite {
     }
 
     assert(syntaxErrorException.lineNumber == 4)
+    assert(syntaxErrorException.posOpt.isEmpty)
+    assert(syntaxErrorException.fieldOpt.contains("SUB_FLD2"))
     assert(syntaxErrorException.msg.contains("The field SUB_FLD2 redefines SUB_FLD1, which is not part if the redefined fields block"))
   }
 
@@ -70,6 +74,8 @@ class SyntaxErrorsSpec extends AnyFunSuite {
       CopybookParser.parseTree(copyBookContents)
     }
     assert(syntaxErrorException.lineNumber == 2)
+    assert(syntaxErrorException.posOpt.contains(36))
+    assert(syntaxErrorException.fieldOpt.contains("FIELD"))
     assert(syntaxErrorException.msg.contains("Decimal numbers with precision bigger"))
   }
 
@@ -83,6 +89,8 @@ class SyntaxErrorsSpec extends AnyFunSuite {
       CopybookParser.parseTree(copyBookContents)
     }
     assert(syntaxErrorException.lineNumber == 2)
+    assert(syntaxErrorException.posOpt.contains(36))
+    assert(syntaxErrorException.fieldOpt.contains("FIELD"))
     assert(syntaxErrorException.msg.contains("Decimal numbers with scale bigger"))
   }
 
@@ -95,7 +103,10 @@ class SyntaxErrorsSpec extends AnyFunSuite {
     val syntaxErrorException = intercept[SyntaxErrorException] {
       CopybookParser.parseTree(copyBookContents)
     }
+
     assert(syntaxErrorException.lineNumber == 2)
+    assert(syntaxErrorException.posOpt.contains(8))
+    assert(syntaxErrorException.fieldOpt.isEmpty)
     assert(syntaxErrorException.msg.contains("Invalid input '/' at position 2:8"))
   }
 
@@ -110,6 +121,8 @@ class SyntaxErrorsSpec extends AnyFunSuite {
       CopybookParser.parseTree(copyBookContents)
     }
     assert(syntaxErrorException.lineNumber == 2)
+    assert(syntaxErrorException.posOpt.isEmpty)
+    assert(syntaxErrorException.fieldOpt.contains("FIELD"))
     assert(syntaxErrorException.msg.contains("SIGN SEPARATE clause is not supported for COMP-3"))
   }
 
@@ -123,6 +136,8 @@ class SyntaxErrorsSpec extends AnyFunSuite {
       CopybookParser.parseTree(copyBookContents)
     }
     assert(syntaxErrorException.lineNumber == 2)
+    assert(syntaxErrorException.posOpt.contains(38))
+    assert(syntaxErrorException.fieldOpt.contains("FIELD"))
     assert(syntaxErrorException.msg.contains("Explicit decimal point in 'PIC 9(8).9(9)' is not supported for COMP-3."))
   }
 
@@ -148,6 +163,8 @@ class SyntaxErrorsSpec extends AnyFunSuite {
       CopybookParser.parseTree(copyBookContents)
     }
     assert(syntaxErrorException.lineNumber == 2)
+    assert(syntaxErrorException.posOpt.contains(32))
+    assert(syntaxErrorException.fieldOpt.isEmpty)
     assert(syntaxErrorException.msg.contains("Invalid input"))
     assert(syntaxErrorException.msg.contains("at position 2:32"))
   }
@@ -162,6 +179,8 @@ class SyntaxErrorsSpec extends AnyFunSuite {
       CopybookParser.parseTree(copyBookContents)
     }
     assert(syntaxErrorException.lineNumber == 2)
+    assert(syntaxErrorException.posOpt.contains(29))
+    assert(syntaxErrorException.fieldOpt.isEmpty)
     assert(syntaxErrorException.msg.contains("Invalid input '(' at position 2:29"))
   }
 

Original file line number	Diff line number	Diff line change
`@@ -53,10 +53,10 @@ class BinaryPropertiesAdder extends AstTransformer {`
`53`	`53`	`redefinedNames.clear()`
`54`	`54`	`case Some(redefines) =>`
`55`	`55`	`if (i == 0) {`
`56`		`- throw new SyntaxErrorException(child.lineNumber, child.name, s"The first field of a group cannot use REDEFINES keyword.")`
	`56`	`+ throw new SyntaxErrorException(child.lineNumber, None, Option(child.name), s"The first field of a group cannot use REDEFINES keyword.")`
`57`	`57`	`}`
`58`	`58`	`if (!redefinedNames.contains(redefines.toUpperCase)) {`
`59`		`- throw new SyntaxErrorException(child.lineNumber, child.name, s"The field ${child.name} redefines $redefines, which is not part if the redefined fields block.")`
	`59`	`+ throw new SyntaxErrorException(child.lineNumber, None, Option(child.name), s"The field ${child.name} redefines $redefines, which is not part if the redefined fields block.")`
`60`	`60`	`}`
`61`	`61`	`newChildren(i - 1) = newChildren(i - 1).withUpdatedIsRedefined(newIsRedefined = true)`
`62`	`62`	`}`
Original file line number	Diff line number	Diff line change
`@@ -41,6 +41,8 @@ class SyntaxErrorsSpec extends AnyFunSuite {`
`41`	`41`	`}`
`42`	`42`
`43`	`43`	`assert(syntaxErrorException.lineNumber == 5)`
	`44`	`+ assert(syntaxErrorException.posOpt.isEmpty)`
	`45`	`+ assert(syntaxErrorException.fieldOpt.contains("GRP_FIELD"))`
`44`	`46`	`assert(syntaxErrorException.msg.contains("The field is a leaf element"))`
`45`	`47`	`}`
`46`	`48`
`@@ -57,6 +59,8 @@ class SyntaxErrorsSpec extends AnyFunSuite {`
`57`	`59`	`}`
`58`	`60`
`59`	`61`	`assert(syntaxErrorException.lineNumber == 4)`
	`62`	`+ assert(syntaxErrorException.posOpt.isEmpty)`
	`63`	`+ assert(syntaxErrorException.fieldOpt.contains("SUB_FLD2"))`
`60`	`64`	`assert(syntaxErrorException.msg.contains("The field SUB_FLD2 redefines SUB_FLD1, which is not part if the redefined fields block"))`
`61`	`65`	`}`
`62`	`66`
`@@ -70,6 +74,8 @@ class SyntaxErrorsSpec extends AnyFunSuite {`
`70`	`74`	`CopybookParser.parseTree(copyBookContents)`
`71`	`75`	`}`
`72`	`76`	`assert(syntaxErrorException.lineNumber == 2)`
	`77`	`+ assert(syntaxErrorException.posOpt.contains(36))`
	`78`	`+ assert(syntaxErrorException.fieldOpt.contains("FIELD"))`
`73`	`79`	`assert(syntaxErrorException.msg.contains("Decimal numbers with precision bigger"))`
`74`	`80`	`}`
`75`	`81`
`@@ -83,6 +89,8 @@ class SyntaxErrorsSpec extends AnyFunSuite {`
`83`	`89`	`CopybookParser.parseTree(copyBookContents)`
`84`	`90`	`}`
`85`	`91`	`assert(syntaxErrorException.lineNumber == 2)`
	`92`	`+ assert(syntaxErrorException.posOpt.contains(36))`
	`93`	`+ assert(syntaxErrorException.fieldOpt.contains("FIELD"))`
`86`	`94`	`assert(syntaxErrorException.msg.contains("Decimal numbers with scale bigger"))`
`87`	`95`	`}`
`88`	`96`
`@@ -95,7 +103,10 @@ class SyntaxErrorsSpec extends AnyFunSuite {`
`95`	`103`	`val syntaxErrorException = intercept[SyntaxErrorException] {`
`96`	`104`	`CopybookParser.parseTree(copyBookContents)`
`97`	`105`	`}`
	`106`	`+`
`98`	`107`	`assert(syntaxErrorException.lineNumber == 2)`
	`108`	`+ assert(syntaxErrorException.posOpt.contains(8))`
	`109`	`+ assert(syntaxErrorException.fieldOpt.isEmpty)`
`99`	`110`	`assert(syntaxErrorException.msg.contains("Invalid input '/' at position 2:8"))`
`100`	`111`	`}`
`101`	`112`
`@@ -110,6 +121,8 @@ class SyntaxErrorsSpec extends AnyFunSuite {`
`110`	`121`	`CopybookParser.parseTree(copyBookContents)`
`111`	`122`	`}`
`112`	`123`	`assert(syntaxErrorException.lineNumber == 2)`
	`124`	`+ assert(syntaxErrorException.posOpt.isEmpty)`
	`125`	`+ assert(syntaxErrorException.fieldOpt.contains("FIELD"))`
`113`	`126`	`assert(syntaxErrorException.msg.contains("SIGN SEPARATE clause is not supported for COMP-3"))`
`114`	`127`	`}`
`115`	`128`
`@@ -123,6 +136,8 @@ class SyntaxErrorsSpec extends AnyFunSuite {`
`123`	`136`	`CopybookParser.parseTree(copyBookContents)`
`124`	`137`	`}`
`125`	`138`	`assert(syntaxErrorException.lineNumber == 2)`
	`139`	`+ assert(syntaxErrorException.posOpt.contains(38))`
	`140`	`+ assert(syntaxErrorException.fieldOpt.contains("FIELD"))`
`126`	`141`	`assert(syntaxErrorException.msg.contains("Explicit decimal point in 'PIC 9(8).9(9)' is not supported for COMP-3."))`
`127`	`142`	`}`
`128`	`143`
`@@ -148,6 +163,8 @@ class SyntaxErrorsSpec extends AnyFunSuite {`
`148`	`163`	`CopybookParser.parseTree(copyBookContents)`
`149`	`164`	`}`
`150`	`165`	`assert(syntaxErrorException.lineNumber == 2)`
	`166`	`+ assert(syntaxErrorException.posOpt.contains(32))`
	`167`	`+ assert(syntaxErrorException.fieldOpt.isEmpty)`
`151`	`168`	`assert(syntaxErrorException.msg.contains("Invalid input"))`
`152`	`169`	`assert(syntaxErrorException.msg.contains("at position 2:32"))`
`153`	`170`	`}`
`@@ -162,6 +179,8 @@ class SyntaxErrorsSpec extends AnyFunSuite {`
`162`	`179`	`CopybookParser.parseTree(copyBookContents)`
`163`	`180`	`}`
`164`	`181`	`assert(syntaxErrorException.lineNumber == 2)`
	`182`	`+ assert(syntaxErrorException.posOpt.contains(29))`
	`183`	`+ assert(syntaxErrorException.fieldOpt.isEmpty)`
`165`	`184`	`assert(syntaxErrorException.msg.contains("Invalid input '(' at position 2:29"))`
`166`	`185`	`}`
`167`	`186`