Link GitHub Actions, less Java, more PHP type code

GenieTim · GenieTim · commit fbe920635163 · 2022-07-05T12:33:21.000+02:00
diff --git a/README.md b/README.md
@@ -1,4 +1,8 @@
 # QR code decoder / reader for PHP
+
+[![Tests](https://github.com/khanamiryan/php-qrcode-detector-decoder/actions/workflows/tests.yml/badge.svg)](https://github.com/khanamiryan/php-qrcode-detector-decoder/actions/workflows/tests.yml)
+[![Static Tests](https://github.com/khanamiryan/php-qrcode-detector-decoder/actions/workflows/static_tests.yml/badge.svg)](https://github.com/khanamiryan/php-qrcode-detector-decoder/actions/workflows/static_tests.yml)
+
 This is a PHP library to detect and decode QR-codes.<br />This is first and only QR code reader that works without extensions.<br />
 Ported from [ZXing library](https://github.com/zxing/zxing)
 
diff --git a/lib/Qrcode/Decoder/BitMatrixParser.php b/lib/Qrcode/Decoder/BitMatrixParser.php
@@ -42,7 +42,7 @@ public function __construct($bitMatrix)
 	{
 		$dimension = $bitMatrix->getHeight();
 		if ($dimension < 21 || ($dimension & 0x03) != 1) {
-			throw FormatException::getFormatInstance();
+			throw new FormatException();
 		}
 		$this->bitMatrix = $bitMatrix;
 	}
@@ -108,7 +108,7 @@ public function readCodewords()
 			$readingUp ^= true; // readingUp = !readingUp; // switch directions
 		}
 		if ($resultOffset != $version->getTotalCodewords()) {
-			throw FormatException::getFormatInstance();
+			throw new FormatException();
 		}
 
 		return $result;
@@ -156,7 +156,7 @@ public function readFormatInformation()
 		if ($parsedFormatInfo != null) {
 			return $parsedFormatInfo;
 		}
-		throw FormatException::getFormatInstance();
+		throw new FormatException();
 	}
 
 	/**
@@ -221,7 +221,7 @@ public function readVersion()
 
 			return $theParsedVersion;
 		}
-		throw FormatException::getFormatInstance("both version information locations cannot be parsed as the valid encoding of version information");
+		throw new FormatException("both version information locations cannot be parsed as the valid encoding of version information");
 	}
 
 	/**
diff --git a/lib/Qrcode/Decoder/DecodedBitStreamParser.php b/lib/Qrcode/Decoder/DecodedBitStreamParser.php
@@ -77,7 +77,7 @@ public static function decode(
 						$fc1InEffect = true;
 					} elseif ($mode == Mode::$STRUCTURED_APPEND) {
 						if ($bits->available() < 16) {
-							throw FormatException::getFormatInstance("Bits available < 16");
+							throw new FormatException("Bits available < 16");
 						}
 						// sequence number and parity is added later to the result metadata
 						// Read next 8 bits (symbol sequence #) and 8 bits (parity data), then continue
@@ -88,7 +88,7 @@ public static function decode(
 						$value = self::parseECIValue($bits);
 						$currentCharacterSetECI = CharacterSetECI::getCharacterSetECIByValue($value);
 						if ($currentCharacterSetECI == null) {
-							throw FormatException::getFormatInstance("Current character set ECI is null");
+							throw new FormatException("Current character set ECI is null");
 						}
 					} else {
 						// First handle Hanzi mode which does not start with character count
@@ -112,15 +112,15 @@ public static function decode(
 							} elseif ($mode == Mode::$KANJI) {
 								self::decodeKanjiSegment($bits, $result, $count);
 							} else {
-								throw FormatException::getFormatInstance("Unknown mode $mode to decode");
+								throw new FormatException("Unknown mode $mode to decode");
 							}
 						}
 					}
 				}
 			} while ($mode != Mode::$TERMINATOR);
 		} catch (\InvalidArgumentException $e) {
 			// from readBits() calls
-			throw FormatException::getFormatInstance("Invalid argument exception when formatting: " . $e->getMessage());
+			throw new FormatException("Invalid argument exception when formatting: " . $e->getMessage());
 		}
 
 		return new DecoderResult(
@@ -152,7 +152,7 @@ private static function parseECIValue(BitSource $bits): int
 
 			return (($firstByte & 0x1F) << 16) | $secondThirdBytes;
 		}
-		throw FormatException::getFormatInstance("ECI Value parsing failed.");
+		throw new FormatException("ECI Value parsing failed.");
 	}
 
 	/**
@@ -167,7 +167,7 @@ private static function decodeHanziSegment(
 	): void {
 		// Don't crash trying to read more bits than we have available.
 		if ($count * 13 > $bits->available()) {
-			throw FormatException::getFormatInstance("Trying to read more bits than we have available");
+			throw new FormatException("Trying to read more bits than we have available");
 		}
 
 		// Each character will require 2 bytes. Read the characters as 2-byte pairs
@@ -202,11 +202,11 @@ private static function decodeNumericSegment(
 		while ($count >= 3) {
 			// Each 10 bits encodes three digits
 			if ($bits->available() < 10) {
-				throw FormatException::getFormatInstance("Not enough bits available");
+				throw new FormatException("Not enough bits available");
 			}
 			$threeDigitsBits = $bits->readBits(10);
 			if ($threeDigitsBits >= 1000) {
-				throw FormatException::getFormatInstance("Too many three digit bits");
+				throw new FormatException("Too many three digit bits");
 			}
 			$result .= (self::toAlphaNumericChar($threeDigitsBits / 100));
 			$result .= (self::toAlphaNumericChar(($threeDigitsBits / 10) % 10));
@@ -216,22 +216,22 @@ private static function decodeNumericSegment(
 		if ($count == 2) {
 			// Two digits left over to read, encoded in 7 bits
 			if ($bits->available() < 7) {
-				throw FormatException::getFormatInstance("Two digits left over to read, encoded in 7 bits, but only " . $bits->available() . ' bits available');
+				throw new FormatException("Two digits left over to read, encoded in 7 bits, but only " . $bits->available() . ' bits available');
 			}
 			$twoDigitsBits = $bits->readBits(7);
 			if ($twoDigitsBits >= 100) {
-				throw FormatException::getFormatInstance("Too many bits: $twoDigitsBits expected < 100");
+				throw new FormatException("Too many bits: $twoDigitsBits expected < 100");
 			}
 			$result .= (self::toAlphaNumericChar($twoDigitsBits / 10));
 			$result .= (self::toAlphaNumericChar($twoDigitsBits % 10));
 		} elseif ($count == 1) {
 			// One digit left over to read
 			if ($bits->available() < 4) {
-				throw FormatException::getFormatInstance("One digit left to read, but < 4 bits available");
+				throw new FormatException("One digit left to read, but < 4 bits available");
 			}
 			$digitBits = $bits->readBits(4);
 			if ($digitBits >= 10) {
-				throw FormatException::getFormatInstance("Too many bits: $digitBits expected < 10");
+				throw new FormatException("Too many bits: $digitBits expected < 10");
 			}
 			$result .= (self::toAlphaNumericChar($digitBits));
 		}
@@ -243,10 +243,10 @@ private static function decodeNumericSegment(
 	private static function toAlphaNumericChar(int|float $value)
 	{
 		if ($value >= count(self::$ALPHANUMERIC_CHARS)) {
-			throw FormatException::getFormatInstance("$value has too many alphanumeric chars");
+			throw new FormatException("$value has too many alphanumeric chars");
 		}
 
-		return self::$ALPHANUMERIC_CHARS[$value];
+		return self::$ALPHANUMERIC_CHARS[(int)round($value)];
 	}
 
 	private static function decodeAlphanumericSegment(
@@ -259,7 +259,7 @@ private static function decodeAlphanumericSegment(
 		$start = strlen((string) $result);
 		while ($count > 1) {
 			if ($bits->available() < 11) {
-				throw FormatException::getFormatInstance("Not enough bits available to read two expected characters");
+				throw new FormatException("Not enough bits available to read two expected characters");
 			}
 			$nextTwoCharsBits = $bits->readBits(11);
 			$result .= (self::toAlphaNumericChar($nextTwoCharsBits / 45));
@@ -269,7 +269,7 @@ private static function decodeAlphanumericSegment(
 		if ($count == 1) {
 			// special case: one character left
 			if ($bits->available() < 6) {
-				throw FormatException::getFormatInstance("Not enough bits available to read one expected character");
+				throw new FormatException("Not enough bits available to read one expected character");
 			}
 			$result .= self::toAlphaNumericChar($bits->readBits(6));
 		}
@@ -300,7 +300,7 @@ private static function decodeByteSegment(
 	): void {
 		// Don't crash trying to read more bits than we have available.
 		if (8 * $count > $bits->available()) {
-			throw FormatException::getFormatInstance("Trying to read more bits than we have available");
+			throw new FormatException("Trying to read more bits than we have available");
 		}
 
 		$readBytes = fill_array(0, $count, 0);
@@ -337,7 +337,7 @@ private static function decodeKanjiSegment(
 	): void {
 		// Don't crash trying to read more bits than we have available.
 		if ($count * 13 > $bits->available()) {
-			throw FormatException::getFormatInstance("Trying to read more bits than we have available");
+			throw new FormatException("Trying to read more bits than we have available");
 		}
 
 		// Each character will require 2 bytes. Read the characters as 2-byte pairs
diff --git a/lib/Qrcode/Decoder/Version.php b/lib/Qrcode/Decoder/Version.php
@@ -100,12 +100,12 @@ public function getECBlocksForLevel(ErrorCorrectionLevel $ecLevel)
 	public static function getProvisionalVersionForDimension($dimension)
 	{
 		if ($dimension % 4 != 1) {
-			throw FormatException::getFormatInstance();
+			throw new FormatException();
 		}
 		try {
 			return self::getVersionForNumber(($dimension - 17) / 4);
 		} catch (\InvalidArgumentException) {
-			throw FormatException::getFormatInstance();
+			throw new FormatException();
 		}
 	}
 

Original file line number	Diff line number	Diff line change
`@@ -42,7 +42,7 @@ public function __construct($bitMatrix)`
`42`	`42`	`{`
`43`	`43`	`$dimension = $bitMatrix->getHeight();`
`44`	`44`	`if ($dimension < 21 \|\| ($dimension & 0x03) != 1) {`
`45`		`- throw FormatException::getFormatInstance();`
	`45`	`+ throw new FormatException();`
`46`	`46`	`}`
`47`	`47`	`$this->bitMatrix = $bitMatrix;`
`48`	`48`	`}`
`@@ -108,7 +108,7 @@ public function readCodewords()`
`108`	`108`	`$readingUp ^= true; // readingUp = !readingUp; // switch directions`
`109`	`109`	`}`
`110`	`110`	`if ($resultOffset != $version->getTotalCodewords()) {`
`111`		`- throw FormatException::getFormatInstance();`
	`111`	`+ throw new FormatException();`
`112`	`112`	`}`
`113`	`113`
`114`	`114`	`return $result;`
`@@ -156,7 +156,7 @@ public function readFormatInformation()`
`156`	`156`	`if ($parsedFormatInfo != null) {`
`157`	`157`	`return $parsedFormatInfo;`
`158`	`158`	`}`
`159`		`- throw FormatException::getFormatInstance();`
	`159`	`+ throw new FormatException();`
`160`	`160`	`}`
`161`	`161`
`162`	`162`	`/**`
`@@ -221,7 +221,7 @@ public function readVersion()`
`221`	`221`
`222`	`222`	`return $theParsedVersion;`
`223`	`223`	`}`
`224`		`- throw FormatException::getFormatInstance("both version information locations cannot be parsed as the valid encoding of version information");`
	`224`	`+ throw new FormatException("both version information locations cannot be parsed as the valid encoding of version information");`
`225`	`225`	`}`
`226`	`226`
`227`	`227`	`/**`
Original file line number	Diff line number	Diff line change
`@@ -77,7 +77,7 @@ public static function decode(`
`77`	`77`	`$fc1InEffect = true;`
`78`	`78`	`} elseif ($mode == Mode::$STRUCTURED_APPEND) {`
`79`	`79`	`if ($bits->available() < 16) {`
`80`		`- throw FormatException::getFormatInstance("Bits available < 16");`
	`80`	`+ throw new FormatException("Bits available < 16");`
`81`	`81`	`}`
`82`	`82`	`// sequence number and parity is added later to the result metadata`
`83`	`83`	`// Read next 8 bits (symbol sequence #) and 8 bits (parity data), then continue`
`@@ -88,7 +88,7 @@ public static function decode(`
`88`	`88`	`$value = self::parseECIValue($bits);`
`89`	`89`	`$currentCharacterSetECI = CharacterSetECI::getCharacterSetECIByValue($value);`
`90`	`90`	`if ($currentCharacterSetECI == null) {`
`91`		`- throw FormatException::getFormatInstance("Current character set ECI is null");`
	`91`	`+ throw new FormatException("Current character set ECI is null");`
`92`	`92`	`}`
`93`	`93`	`} else {`
`94`	`94`	`// First handle Hanzi mode which does not start with character count`
`@@ -112,15 +112,15 @@ public static function decode(`
`112`	`112`	`} elseif ($mode == Mode::$KANJI) {`
`113`	`113`	`self::decodeKanjiSegment($bits, $result, $count);`
`114`	`114`	`} else {`
`115`		`- throw FormatException::getFormatInstance("Unknown mode $mode to decode");`
	`115`	`+ throw new FormatException("Unknown mode $mode to decode");`
`116`	`116`	`}`
`117`	`117`	`}`
`118`	`118`	`}`
`119`	`119`	`}`
`120`	`120`	`} while ($mode != Mode::$TERMINATOR);`
`121`	`121`	`} catch (\InvalidArgumentException $e) {`
`122`	`122`	`// from readBits() calls`
`123`		`- throw FormatException::getFormatInstance("Invalid argument exception when formatting: " . $e->getMessage());`
	`123`	`+ throw new FormatException("Invalid argument exception when formatting: " . $e->getMessage());`
`124`	`124`	`}`
`125`	`125`
`126`	`126`	`return new DecoderResult(`
`@@ -152,7 +152,7 @@ private static function parseECIValue(BitSource $bits): int`
`152`	`152`
`153`	`153`	`return (($firstByte & 0x1F) << 16) \| $secondThirdBytes;`
`154`	`154`	`}`
`155`		`- throw FormatException::getFormatInstance("ECI Value parsing failed.");`
	`155`	`+ throw new FormatException("ECI Value parsing failed.");`
`156`	`156`	`}`
`157`	`157`
`158`	`158`	`/**`
`@@ -167,7 +167,7 @@ private static function decodeHanziSegment(`
`167`	`167`	`): void {`
`168`	`168`	`// Don't crash trying to read more bits than we have available.`
`169`	`169`	`if ($count * 13 > $bits->available()) {`
`170`		`- throw FormatException::getFormatInstance("Trying to read more bits than we have available");`
	`170`	`+ throw new FormatException("Trying to read more bits than we have available");`
`171`	`171`	`}`
`172`	`172`
`173`	`173`	`// Each character will require 2 bytes. Read the characters as 2-byte pairs`
`@@ -202,11 +202,11 @@ private static function decodeNumericSegment(`
`202`	`202`	`while ($count >= 3) {`
`203`	`203`	`// Each 10 bits encodes three digits`
`204`	`204`	`if ($bits->available() < 10) {`
`205`		`- throw FormatException::getFormatInstance("Not enough bits available");`
	`205`	`+ throw new FormatException("Not enough bits available");`
`206`	`206`	`}`
`207`	`207`	`$threeDigitsBits = $bits->readBits(10);`
`208`	`208`	`if ($threeDigitsBits >= 1000) {`
`209`		`- throw FormatException::getFormatInstance("Too many three digit bits");`
	`209`	`+ throw new FormatException("Too many three digit bits");`
`210`	`210`	`}`
`211`	`211`	`$result .= (self::toAlphaNumericChar($threeDigitsBits / 100));`
`212`	`212`	`$result .= (self::toAlphaNumericChar(($threeDigitsBits / 10) % 10));`
`@@ -216,22 +216,22 @@ private static function decodeNumericSegment(`
`216`	`216`	`if ($count == 2) {`
`217`	`217`	`// Two digits left over to read, encoded in 7 bits`
`218`	`218`	`if ($bits->available() < 7) {`
`219`		`- throw FormatException::getFormatInstance("Two digits left over to read, encoded in 7 bits, but only " . $bits->available() . ' bits available');`
	`219`	`+ throw new FormatException("Two digits left over to read, encoded in 7 bits, but only " . $bits->available() . ' bits available');`
`220`	`220`	`}`
`221`	`221`	`$twoDigitsBits = $bits->readBits(7);`
`222`	`222`	`if ($twoDigitsBits >= 100) {`
`223`		`- throw FormatException::getFormatInstance("Too many bits: $twoDigitsBits expected < 100");`
	`223`	`+ throw new FormatException("Too many bits: $twoDigitsBits expected < 100");`
`224`	`224`	`}`
`225`	`225`	`$result .= (self::toAlphaNumericChar($twoDigitsBits / 10));`
`226`	`226`	`$result .= (self::toAlphaNumericChar($twoDigitsBits % 10));`
`227`	`227`	`} elseif ($count == 1) {`
`228`	`228`	`// One digit left over to read`
`229`	`229`	`if ($bits->available() < 4) {`
`230`		`- throw FormatException::getFormatInstance("One digit left to read, but < 4 bits available");`
	`230`	`+ throw new FormatException("One digit left to read, but < 4 bits available");`
`231`	`231`	`}`
`232`	`232`	`$digitBits = $bits->readBits(4);`
`233`	`233`	`if ($digitBits >= 10) {`
`234`		`- throw FormatException::getFormatInstance("Too many bits: $digitBits expected < 10");`
	`234`	`+ throw new FormatException("Too many bits: $digitBits expected < 10");`
`235`	`235`	`}`
`236`	`236`	`$result .= (self::toAlphaNumericChar($digitBits));`
`237`	`237`	`}`
`@@ -243,10 +243,10 @@ private static function decodeNumericSegment(`
`243`	`243`	`private static function toAlphaNumericChar(int\|float $value)`
`244`	`244`	`{`
`245`	`245`	`if ($value >= count(self::$ALPHANUMERIC_CHARS)) {`
`246`		`- throw FormatException::getFormatInstance("$value has too many alphanumeric chars");`
	`246`	`+ throw new FormatException("$value has too many alphanumeric chars");`
`247`	`247`	`}`
`248`	`248`
`249`		`- return self::$ALPHANUMERIC_CHARS[$value];`
	`249`	`+ return self::$ALPHANUMERIC_CHARS[(int)round($value)];`
`250`	`250`	`}`
`251`	`251`
`252`	`252`	`private static function decodeAlphanumericSegment(`
`@@ -259,7 +259,7 @@ private static function decodeAlphanumericSegment(`
`259`	`259`	`$start = strlen((string) $result);`
`260`	`260`	`while ($count > 1) {`
`261`	`261`	`if ($bits->available() < 11) {`
`262`		`- throw FormatException::getFormatInstance("Not enough bits available to read two expected characters");`
	`262`	`+ throw new FormatException("Not enough bits available to read two expected characters");`
`263`	`263`	`}`
`264`	`264`	`$nextTwoCharsBits = $bits->readBits(11);`
`265`	`265`	`$result .= (self::toAlphaNumericChar($nextTwoCharsBits / 45));`
`@@ -269,7 +269,7 @@ private static function decodeAlphanumericSegment(`
`269`	`269`	`if ($count == 1) {`
`270`	`270`	`// special case: one character left`
`271`	`271`	`if ($bits->available() < 6) {`
`272`		`- throw FormatException::getFormatInstance("Not enough bits available to read one expected character");`
	`272`	`+ throw new FormatException("Not enough bits available to read one expected character");`
`273`	`273`	`}`
`274`	`274`	`$result .= self::toAlphaNumericChar($bits->readBits(6));`
`275`	`275`	`}`
`@@ -300,7 +300,7 @@ private static function decodeByteSegment(`
`300`	`300`	`): void {`
`301`	`301`	`// Don't crash trying to read more bits than we have available.`
`302`	`302`	`if (8 * $count > $bits->available()) {`
`303`		`- throw FormatException::getFormatInstance("Trying to read more bits than we have available");`
	`303`	`+ throw new FormatException("Trying to read more bits than we have available");`
`304`	`304`	`}`
`305`	`305`
`306`	`306`	`$readBytes = fill_array(0, $count, 0);`
`@@ -337,7 +337,7 @@ private static function decodeKanjiSegment(`
`337`	`337`	`): void {`
`338`	`338`	`// Don't crash trying to read more bits than we have available.`
`339`	`339`	`if ($count * 13 > $bits->available()) {`
`340`		`- throw FormatException::getFormatInstance("Trying to read more bits than we have available");`
	`340`	`+ throw new FormatException("Trying to read more bits than we have available");`
`341`	`341`	`}`
`342`	`342`
`343`	`343`	`// Each character will require 2 bytes. Read the characters as 2-byte pairs`
Original file line number	Diff line number	Diff line change
`@@ -100,12 +100,12 @@ public function getECBlocksForLevel(ErrorCorrectionLevel $ecLevel)`
`100`	`100`	`public static function getProvisionalVersionForDimension($dimension)`
`101`	`101`	`{`
`102`	`102`	`if ($dimension % 4 != 1) {`
`103`		`- throw FormatException::getFormatInstance();`
	`103`	`+ throw new FormatException();`
`104`	`104`	`}`
`105`	`105`	`try {`
`106`	`106`	`return self::getVersionForNumber(($dimension - 17) / 4);`
`107`	`107`	`} catch (\InvalidArgumentException) {`
`108`		`- throw FormatException::getFormatInstance();`
	`108`	`+ throw new FormatException();`
`109`	`109`	`}`
`110`	`110`	`}`
`111`	`111`