codysnider / tt-rss

Passed

Push — master ( 0b9e3e...5a5c41 )

by Cody

created 2019-12-20 19:22 UTC

Status

Category

Toggle Patches

lib/phpqrcode/qrbitstream.php 3 patches

Indentation +120 added lines, -120 removed lines patch added patch discarded remove patch

		@@ -25,156 +25,156 @@
		block discarded – undo
25	25	* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
26	26	*/
27	27
28		- class QRbitstream {
	28	+ class QRbitstream {
29	29
30		- public $data = array();
	30	+ public $data = array();
31	31
32		- //----------------------------------------------------------------------
33		- public function size()
34		- {
35		- return count($this->data);
36		- }
	32	+ //----------------------------------------------------------------------
	33	+ public function size()
	34	+ {
	35	+ return count($this->data);
	36	+ }
37	37
38		- //----------------------------------------------------------------------
39		- public function allocate($setLength)
40		- {
41		- $this->data = array_fill(0, $setLength, 0);
42		- return 0;
43		- }
	38	+ //----------------------------------------------------------------------
	39	+ public function allocate($setLength)
	40	+ {
	41	+ $this->data = array_fill(0, $setLength, 0);
	42	+ return 0;
	43	+ }
44	44
45		- //----------------------------------------------------------------------
46		- public static function newFromNum($bits, $num)
47		- {
48		- $bstream = new QRbitstream();
49		- $bstream->allocate($bits);
	45	+ //----------------------------------------------------------------------
	46	+ public static function newFromNum($bits, $num)
	47	+ {
	48	+ $bstream = new QRbitstream();
	49	+ $bstream->allocate($bits);
50	50
51		- $mask = 1 << ($bits - 1);
52		- for($i=0; $i<$bits; $i++) {
53		- if($num & $mask) {
54		- $bstream->data[$i] = 1;
55		- } else {
56		- $bstream->data[$i] = 0;
57		- }
58		- $mask = $mask >> 1;
59		- }
	51	+ $mask = 1 << ($bits - 1);
	52	+ for($i=0; $i<$bits; $i++) {
	53	+ if($num & $mask) {
	54	+ $bstream->data[$i] = 1;
	55	+ } else {
	56	+ $bstream->data[$i] = 0;
	57	+ }
	58	+ $mask = $mask >> 1;
	59	+ }
60	60
61		- return $bstream;
62		- }
	61	+ return $bstream;
	62	+ }
63	63
64		- //----------------------------------------------------------------------
65		- public static function newFromBytes($size, $data)
66		- {
67		- $bstream = new QRbitstream();
68		- $bstream->allocate($size * 8);
69		- $p=0;
	64	+ //----------------------------------------------------------------------
	65	+ public static function newFromBytes($size, $data)
	66	+ {
	67	+ $bstream = new QRbitstream();
	68	+ $bstream->allocate($size * 8);
	69	+ $p=0;
70	70
71		- for($i=0; $i<$size; $i++) {
72		- $mask = 0x80;
73		- for($j=0; $j<8; $j++) {
74		- if($data[$i] & $mask) {
75		- $bstream->data[$p] = 1;
76		- } else {
77		- $bstream->data[$p] = 0;
78		- }
79		- $p++;
80		- $mask = $mask >> 1;
81		- }
82		- }
	71	+ for($i=0; $i<$size; $i++) {
	72	+ $mask = 0x80;
	73	+ for($j=0; $j<8; $j++) {
	74	+ if($data[$i] & $mask) {
	75	+ $bstream->data[$p] = 1;
	76	+ } else {
	77	+ $bstream->data[$p] = 0;
	78	+ }
	79	+ $p++;
	80	+ $mask = $mask >> 1;
	81	+ }
	82	+ }
83	83
84		- return $bstream;
85		- }
	84	+ return $bstream;
	85	+ }
86	86
87		- //----------------------------------------------------------------------
88		- public function append(QRbitstream $arg)
89		- {
90		- if (is_null($arg)) {
91		- return -1;
92		- }
	87	+ //----------------------------------------------------------------------
	88	+ public function append(QRbitstream $arg)
	89	+ {
	90	+ if (is_null($arg)) {
	91	+ return -1;
	92	+ }
93	93
94		- if($arg->size() == 0) {
95		- return 0;
96		- }
	94	+ if($arg->size() == 0) {
	95	+ return 0;
	96	+ }
97	97
98		- if($this->size() == 0) {
99		- $this->data = $arg->data;
100		- return 0;
101		- }
	98	+ if($this->size() == 0) {
	99	+ $this->data = $arg->data;
	100	+ return 0;
	101	+ }
102	102
103		- $this->data = array_values(array_merge($this->data, $arg->data));
	103	+ $this->data = array_values(array_merge($this->data, $arg->data));
104	104
105		- return 0;
106		- }
	105	+ return 0;
	106	+ }
107	107
108		- //----------------------------------------------------------------------
109		- public function appendNum($bits, $num)
110		- {
111		- if ($bits == 0)
112		- return 0;
	108	+ //----------------------------------------------------------------------
	109	+ public function appendNum($bits, $num)
	110	+ {
	111	+ if ($bits == 0)
	112	+ return 0;
113	113
114		- $b = QRbitstream::newFromNum($bits, $num);
	114	+ $b = QRbitstream::newFromNum($bits, $num);
115	115
116		- if(is_null($b))
117		- return -1;
	116	+ if(is_null($b))
	117	+ return -1;
118	118
119		- $ret = $this->append($b);
120		- unset($b);
	119	+ $ret = $this->append($b);
	120	+ unset($b);
121	121
122		- return $ret;
123		- }
	122	+ return $ret;
	123	+ }
124	124
125		- //----------------------------------------------------------------------
126		- public function appendBytes($size, $data)
127		- {
128		- if ($size == 0)
129		- return 0;
	125	+ //----------------------------------------------------------------------
	126	+ public function appendBytes($size, $data)
	127	+ {
	128	+ if ($size == 0)
	129	+ return 0;
130	130
131		- $b = QRbitstream::newFromBytes($size, $data);
	131	+ $b = QRbitstream::newFromBytes($size, $data);
132	132
133		- if(is_null($b))
134		- return -1;
	133	+ if(is_null($b))
	134	+ return -1;
135	135
136		- $ret = $this->append($b);
137		- unset($b);
	136	+ $ret = $this->append($b);
	137	+ unset($b);
138	138
139		- return $ret;
140		- }
	139	+ return $ret;
	140	+ }
141	141
142		- //----------------------------------------------------------------------
143		- public function toByte()
144		- {
	142	+ //----------------------------------------------------------------------
	143	+ public function toByte()
	144	+ {
145	145
146		- $size = $this->size();
	146	+ $size = $this->size();
147	147
148		- if($size == 0) {
149		- return array();
150		- }
	148	+ if($size == 0) {
	149	+ return array();
	150	+ }
151	151
152		- $data = array_fill(0, (int)(($size + 7) / 8), 0);
153		- $bytes = (int)($size / 8);
	152	+ $data = array_fill(0, (int)(($size + 7) / 8), 0);
	153	+ $bytes = (int)($size / 8);
154	154
155		- $p = 0;
	155	+ $p = 0;
156	156
157		- for($i=0; $i<$bytes; $i++) {
158		- $v = 0;
159		- for($j=0; $j<8; $j++) {
160		- $v = $v << 1;
161		- $v \|= $this->data[$p];
162		- $p++;
163		- }
164		- $data[$i] = $v;
165		- }
	157	+ for($i=0; $i<$bytes; $i++) {
	158	+ $v = 0;
	159	+ for($j=0; $j<8; $j++) {
	160	+ $v = $v << 1;
	161	+ $v \|= $this->data[$p];
	162	+ $p++;
	163	+ }
	164	+ $data[$i] = $v;
	165	+ }
166	166
167		- if($size & 7) {
168		- $v = 0;
169		- for($j=0; $j<($size & 7); $j++) {
170		- $v = $v << 1;
171		- $v \|= $this->data[$p];
172		- $p++;
173		- }
174		- $data[$bytes] = $v;
175		- }
	167	+ if($size & 7) {
	168	+ $v = 0;
	169	+ for($j=0; $j<($size & 7); $j++) {
	170	+ $v = $v << 1;
	171	+ $v \|= $this->data[$p];
	172	+ $p++;
	173	+ }
	174	+ $data[$bytes] = $v;
	175	+ }
176	176
177		- return $data;
178		- }
	177	+ return $data;
	178	+ }
179	179
180		- }
	180	+ }

Please login to merge, or discard this patch.

Spacing +17 added lines, -17 removed lines patch added patch discarded remove patch

		@@ -49,8 +49,8 @@ discard block
		block discarded – undo
49	49	$bstream->allocate($bits);
50	50
51	51	$mask = 1 << ($bits - 1);
52		- for($i=0; $i<$bits; $i++) {
53		- if($num & $mask) {
	52	+ for ($i = 0; $i < $bits; $i++) {
	53	+ if ($num & $mask) {
54	54	$bstream->data[$i] = 1;
55	55	} else {
56	56	$bstream->data[$i] = 0;
		@@ -66,12 +66,12 @@ discard block
		block discarded – undo
66	66	{
67	67	$bstream = new QRbitstream();
68	68	$bstream->allocate($size * 8);
69		- $p=0;
	69	+ $p = 0;
70	70
71		- for($i=0; $i<$size; $i++) {
	71	+ for ($i = 0; $i < $size; $i++) {
72	72	$mask = 0x80;
73		- for($j=0; $j<8; $j++) {
74		- if($data[$i] & $mask) {
	73	+ for ($j = 0; $j < 8; $j++) {
	74	+ if ($data[$i] & $mask) {
75	75	$bstream->data[$p] = 1;
76	76	} else {
77	77	$bstream->data[$p] = 0;
		@@ -91,11 +91,11 @@ discard block
		block discarded – undo
91	91	return -1;
92	92	}
93	93
94		- if($arg->size() == 0) {
	94	+ if ($arg->size() == 0) {
95	95	return 0;
96	96	}
97	97
98		- if($this->size() == 0) {
	98	+ if ($this->size() == 0) {
99	99	$this->data = $arg->data;
100	100	return 0;
101	101	}
		@@ -113,7 +113,7 @@ discard block
		block discarded – undo
113	113
114	114	$b = QRbitstream::newFromNum($bits, $num);
115	115
116		- if(is_null($b))
	116	+ if (is_null($b))
117	117	return -1;
118	118
119	119	$ret = $this->append($b);
		@@ -130,7 +130,7 @@ discard block
		block discarded – undo
130	130
131	131	$b = QRbitstream::newFromBytes($size, $data);
132	132
133		- if(is_null($b))
	133	+ if (is_null($b))
134	134	return -1;
135	135
136	136	$ret = $this->append($b);
		@@ -145,18 +145,18 @@ discard block
		block discarded – undo
145	145
146	146	$size = $this->size();
147	147
148		- if($size == 0) {
	148	+ if ($size == 0) {
149	149	return array();
150	150	}
151	151
152		- $data = array_fill(0, (int)(($size + 7) / 8), 0);
153		- $bytes = (int)($size / 8);
	152	+ $data = array_fill(0, (int) (($size + 7) / 8), 0);
	153	+ $bytes = (int) ($size / 8);
154	154
155	155	$p = 0;
156	156
157		- for($i=0; $i<$bytes; $i++) {
	157	+ for ($i = 0; $i < $bytes; $i++) {
158	158	$v = 0;
159		- for($j=0; $j<8; $j++) {
	159	+ for ($j = 0; $j < 8; $j++) {
160	160	$v = $v << 1;
161	161	$v \|= $this->data[$p];
162	162	$p++;
		@@ -164,9 +164,9 @@ discard block
		block discarded – undo
164	164	$data[$i] = $v;
165	165	}
166	166
167		- if($size & 7) {
	167	+ if ($size & 7) {
168	168	$v = 0;
169		- for($j=0; $j<($size & 7); $j++) {
	169	+ for ($j = 0; $j < ($size & 7); $j++) {
170	170	$v = $v << 1;
171	171	$v \|= $this->data[$p];
172	172	$p++;

Please login to merge, or discard this patch.

Braces +12 added lines, -8 removed lines patch added patch discarded remove patch

		@@ -108,13 +108,15 @@ discard block
		block discarded – undo
108	108	//----------------------------------------------------------------------
109	109	public function appendNum($bits, $num)
110	110	{
111		- if ($bits == 0)
112		- return 0;
	111	+ if ($bits == 0) {
	112	+ return 0;
	113	+ }
113	114
114	115	$b = QRbitstream::newFromNum($bits, $num);
115	116
116		- if(is_null($b))
117		- return -1;
	117	+ if(is_null($b)) {
	118	+ return -1;
	119	+ }
118	120
119	121	$ret = $this->append($b);
120	122	unset($b);
		@@ -125,13 +127,15 @@ discard block
		block discarded – undo
125	127	//----------------------------------------------------------------------
126	128	public function appendBytes($size, $data)
127	129	{
128		- if ($size == 0)
129		- return 0;
	130	+ if ($size == 0) {
	131	+ return 0;
	132	+ }
130	133
131	134	$b = QRbitstream::newFromBytes($size, $data);
132	135
133		- if(is_null($b))
134		- return -1;
	136	+ if(is_null($b)) {
	137	+ return -1;
	138	+ }
135	139
136	140	$ret = $this->append($b);
137	141	unset($b);

Please login to merge, or discard this patch.

lib/phpqrcode/qrsplit.php 4 patches

Indentation +229 added lines, -229 removed lines patch added patch discarded remove patch

@@ -30,282 +30,282 @@
 block discarded – undo
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  */
-    class QRsplit {
+	class QRsplit {
 
-        public $dataStr = '';
-        public $input;
-        public $modeHint;
+		public $dataStr = '';
+		public $input;
+		public $modeHint;
 
-        //----------------------------------------------------------------------
-        public function __construct($dataStr, $input, $modeHint) 
-        {
-            $this->dataStr  = $dataStr;
-            $this->input    = $input;
-            $this->modeHint = $modeHint;
-        }
+		//----------------------------------------------------------------------
+		public function __construct($dataStr, $input, $modeHint) 
+		{
+			$this->dataStr  = $dataStr;
+			$this->input    = $input;
+			$this->modeHint = $modeHint;
+		}
         
-        //----------------------------------------------------------------------
-        public static function isdigitat($str, $pos)
-        {    
-            if ($pos >= strlen($str))
-                return false;
+		//----------------------------------------------------------------------
+		public static function isdigitat($str, $pos)
+		{    
+			if ($pos >= strlen($str))
+				return false;
             
-            return ((ord($str[$pos]) >= ord('0'))&&(ord($str[$pos]) <= ord('9')));
-        }
+			return ((ord($str[$pos]) >= ord('0'))&&(ord($str[$pos]) <= ord('9')));
+		}
         
-        //----------------------------------------------------------------------
-        public static function isalnumat($str, $pos)
-        {
-            if ($pos >= strlen($str))
-                return false;
+		//----------------------------------------------------------------------
+		public static function isalnumat($str, $pos)
+		{
+			if ($pos >= strlen($str))
+				return false;
                 
-            return (QRinput::lookAnTable(ord($str[$pos])) >= 0);
-        }
+			return (QRinput::lookAnTable(ord($str[$pos])) >= 0);
+		}
 
-        //----------------------------------------------------------------------
-        public function identifyMode($pos)
-        {
-            if ($pos >= strlen($this->dataStr)) 
-                return QR_MODE_NUL;
+		//----------------------------------------------------------------------
+		public function identifyMode($pos)
+		{
+			if ($pos >= strlen($this->dataStr)) 
+				return QR_MODE_NUL;
                 
-            $c = $this->dataStr[$pos];
+			$c = $this->dataStr[$pos];
             
-            if(self::isdigitat($this->dataStr, $pos)) {
-                return QR_MODE_NUM;
-            } else if(self::isalnumat($this->dataStr, $pos)) {
-                return QR_MODE_AN;
-            } else if($this->modeHint == QR_MODE_KANJI) {
+			if(self::isdigitat($this->dataStr, $pos)) {
+				return QR_MODE_NUM;
+			} else if(self::isalnumat($this->dataStr, $pos)) {
+				return QR_MODE_AN;
+			} else if($this->modeHint == QR_MODE_KANJI) {
             
-                if ($pos+1 < strlen($this->dataStr)) 
-                {
-                    $d = $this->dataStr[$pos+1];
-                    $word = (ord($c) << 8) | ord($d);
-                    if(($word >= 0x8140 && $word <= 0x9ffc) || ($word >= 0xe040 && $word <= 0xebbf)) {
-                        return QR_MODE_KANJI;
-                    }
-                }
-            }
+				if ($pos+1 < strlen($this->dataStr)) 
+				{
+					$d = $this->dataStr[$pos+1];
+					$word = (ord($c) << 8) | ord($d);
+					if(($word >= 0x8140 && $word <= 0x9ffc) || ($word >= 0xe040 && $word <= 0xebbf)) {
+						return QR_MODE_KANJI;
+					}
+				}
+			}
 
-            return QR_MODE_8;
-        } 
+			return QR_MODE_8;
+		} 
         
-        //----------------------------------------------------------------------
-        public function eatNum()
-        {
-            $ln = QRspec::lengthIndicator(QR_MODE_NUM, $this->input->getVersion());
+		//----------------------------------------------------------------------
+		public function eatNum()
+		{
+			$ln = QRspec::lengthIndicator(QR_MODE_NUM, $this->input->getVersion());
 
-            $p = 0;
-            while(self::isdigitat($this->dataStr, $p)) {
-                $p++;
-            }
+			$p = 0;
+			while(self::isdigitat($this->dataStr, $p)) {
+				$p++;
+			}
             
-            $run = $p;
-            $mode = $this->identifyMode($p);
+			$run = $p;
+			$mode = $this->identifyMode($p);
             
-            if($mode == QR_MODE_8) {
-                $dif = QRinput::estimateBitsModeNum($run) + 4 + $ln
-                     + QRinput::estimateBitsMode8(1)         // + 4 + l8
-                     - QRinput::estimateBitsMode8($run + 1); // - 4 - l8
-                if($dif > 0) {
-                    return $this->eat8();
-                }
-            }
-            if($mode == QR_MODE_AN) {
-                $dif = QRinput::estimateBitsModeNum($run) + 4 + $ln
-                     + QRinput::estimateBitsModeAn(1)        // + 4 + la
-                     - QRinput::estimateBitsModeAn($run + 1);// - 4 - la
-                if($dif > 0) {
-                    return $this->eatAn();
-                }
-            }
+			if($mode == QR_MODE_8) {
+				$dif = QRinput::estimateBitsModeNum($run) + 4 + $ln
+					 + QRinput::estimateBitsMode8(1)         // + 4 + l8
+					 - QRinput::estimateBitsMode8($run + 1); // - 4 - l8
+				if($dif > 0) {
+					return $this->eat8();
+				}
+			}
+			if($mode == QR_MODE_AN) {
+				$dif = QRinput::estimateBitsModeNum($run) + 4 + $ln
+					 + QRinput::estimateBitsModeAn(1)        // + 4 + la
+					 - QRinput::estimateBitsModeAn($run + 1);// - 4 - la
+				if($dif > 0) {
+					return $this->eatAn();
+				}
+			}
             
-            $ret = $this->input->append(QR_MODE_NUM, $run, str_split($this->dataStr));
-            if($ret < 0)
-                return -1;
+			$ret = $this->input->append(QR_MODE_NUM, $run, str_split($this->dataStr));
+			if($ret < 0)
+				return -1;
 
-            return $run;
-        }
+			return $run;
+		}
         
-        //----------------------------------------------------------------------
-        public function eatAn()
-        {
-            $la = QRspec::lengthIndicator(QR_MODE_AN,  $this->input->getVersion());
-            $ln = QRspec::lengthIndicator(QR_MODE_NUM, $this->input->getVersion());
+		//----------------------------------------------------------------------
+		public function eatAn()
+		{
+			$la = QRspec::lengthIndicator(QR_MODE_AN,  $this->input->getVersion());
+			$ln = QRspec::lengthIndicator(QR_MODE_NUM, $this->input->getVersion());
 
-            $p = 0;
+			$p = 0;
             
-            while(self::isalnumat($this->dataStr, $p)) {
-                if(self::isdigitat($this->dataStr, $p)) {
-                    $q = $p;
-                    while(self::isdigitat($this->dataStr, $q)) {
-                        $q++;
-                    }
+			while(self::isalnumat($this->dataStr, $p)) {
+				if(self::isdigitat($this->dataStr, $p)) {
+					$q = $p;
+					while(self::isdigitat($this->dataStr, $q)) {
+						$q++;
+					}
                     
-                    $dif = QRinput::estimateBitsModeAn($p) // + 4 + la
-                         + QRinput::estimateBitsModeNum($q - $p) + 4 + $ln
-                         - QRinput::estimateBitsModeAn($q); // - 4 - la
+					$dif = QRinput::estimateBitsModeAn($p) // + 4 + la
+						 + QRinput::estimateBitsModeNum($q - $p) + 4 + $ln
+						 - QRinput::estimateBitsModeAn($q); // - 4 - la
                          
-                    if($dif < 0) {
-                        break;
-                    } else {
-                        $p = $q;
-                    }
-                } else {
-                    $p++;
-                }
-            }
+					if($dif < 0) {
+						break;
+					} else {
+						$p = $q;
+					}
+				} else {
+					$p++;
+				}
+			}
 
-            $run = $p;
+			$run = $p;
 
-            if(!self::isalnumat($this->dataStr, $p)) {
-                $dif = QRinput::estimateBitsModeAn($run) + 4 + $la
-                     + QRinput::estimateBitsMode8(1) // + 4 + l8
-                      - QRinput::estimateBitsMode8($run + 1); // - 4 - l8
-                if($dif > 0) {
-                    return $this->eat8();
-                }
-            }
+			if(!self::isalnumat($this->dataStr, $p)) {
+				$dif = QRinput::estimateBitsModeAn($run) + 4 + $la
+					 + QRinput::estimateBitsMode8(1) // + 4 + l8
+					  - QRinput::estimateBitsMode8($run + 1); // - 4 - l8
+				if($dif > 0) {
+					return $this->eat8();
+				}
+			}
 
-            $ret = $this->input->append(QR_MODE_AN, $run, str_split($this->dataStr));
-            if($ret < 0)
-                return -1;
+			$ret = $this->input->append(QR_MODE_AN, $run, str_split($this->dataStr));
+			if($ret < 0)
+				return -1;
 
-            return $run;
-        }
+			return $run;
+		}
         
-        //----------------------------------------------------------------------
-        public function eatKanji()
-        {
-            $p = 0;
+		//----------------------------------------------------------------------
+		public function eatKanji()
+		{
+			$p = 0;
             
-            while($this->identifyMode($p) == QR_MODE_KANJI) {
-                $p += 2;
-            }
+			while($this->identifyMode($p) == QR_MODE_KANJI) {
+				$p += 2;
+			}
             
-            $ret = $this->input->append(QR_MODE_KANJI, $p, str_split($this->dataStr));
-            if($ret < 0)
-                return -1;
+			$ret = $this->input->append(QR_MODE_KANJI, $p, str_split($this->dataStr));
+			if($ret < 0)
+				return -1;
 
-            return $ret;
-        }
+			return $ret;
+		}
 
-        //----------------------------------------------------------------------
-        public function eat8()
-        {
-            $la = QRspec::lengthIndicator(QR_MODE_AN, $this->input->getVersion());
-            $ln = QRspec::lengthIndicator(QR_MODE_NUM, $this->input->getVersion());
+		//----------------------------------------------------------------------
+		public function eat8()
+		{
+			$la = QRspec::lengthIndicator(QR_MODE_AN, $this->input->getVersion());
+			$ln = QRspec::lengthIndicator(QR_MODE_NUM, $this->input->getVersion());
 
-            $p = 1;
-            $dataStrLen = strlen($this->dataStr);
+			$p = 1;
+			$dataStrLen = strlen($this->dataStr);
             
-            while($p < $dataStrLen) {
+			while($p < $dataStrLen) {
                 
-                $mode = $this->identifyMode($p);
-                if($mode == QR_MODE_KANJI) {
-                    break;
-                }
-                if($mode == QR_MODE_NUM) {
-                    $q = $p;
-                    while(self::isdigitat($this->dataStr, $q)) {
-                        $q++;
-                    }
-                    $dif = QRinput::estimateBitsMode8($p) // + 4 + l8
-                         + QRinput::estimateBitsModeNum($q - $p) + 4 + $ln
-                         - QRinput::estimateBitsMode8($q); // - 4 - l8
-                    if($dif < 0) {
-                        break;
-                    } else {
-                        $p = $q;
-                    }
-                } else if($mode == QR_MODE_AN) {
-                    $q = $p;
-                    while(self::isalnumat($this->dataStr, $q)) {
-                        $q++;
-                    }
-                    $dif = QRinput::estimateBitsMode8($p)  // + 4 + l8
-                         + QRinput::estimateBitsModeAn($q - $p) + 4 + $la
-                         - QRinput::estimateBitsMode8($q); // - 4 - l8
-                    if($dif < 0) {
-                        break;
-                    } else {
-                        $p = $q;
-                    }
-                } else {
-                    $p++;
-                }
-            }
+				$mode = $this->identifyMode($p);
+				if($mode == QR_MODE_KANJI) {
+					break;
+				}
+				if($mode == QR_MODE_NUM) {
+					$q = $p;
+					while(self::isdigitat($this->dataStr, $q)) {
+						$q++;
+					}
+					$dif = QRinput::estimateBitsMode8($p) // + 4 + l8
+						 + QRinput::estimateBitsModeNum($q - $p) + 4 + $ln
+						 - QRinput::estimateBitsMode8($q); // - 4 - l8
+					if($dif < 0) {
+						break;
+					} else {
+						$p = $q;
+					}
+				} else if($mode == QR_MODE_AN) {
+					$q = $p;
+					while(self::isalnumat($this->dataStr, $q)) {
+						$q++;
+					}
+					$dif = QRinput::estimateBitsMode8($p)  // + 4 + l8
+						 + QRinput::estimateBitsModeAn($q - $p) + 4 + $la
+						 - QRinput::estimateBitsMode8($q); // - 4 - l8
+					if($dif < 0) {
+						break;
+					} else {
+						$p = $q;
+					}
+				} else {
+					$p++;
+				}
+			}
 
-            $run = $p;
-            $ret = $this->input->append(QR_MODE_8, $run, str_split($this->dataStr));
+			$run = $p;
+			$ret = $this->input->append(QR_MODE_8, $run, str_split($this->dataStr));
             
-            if($ret < 0)
-                return -1;
+			if($ret < 0)
+				return -1;
 
-            return $run;
-        }
+			return $run;
+		}
 
-        //----------------------------------------------------------------------
-        public function splitString()
-        {
-            while (strlen($this->dataStr) > 0)
-            {
-                if($this->dataStr == '')
-                    return 0;
+		//----------------------------------------------------------------------
+		public function splitString()
+		{
+			while (strlen($this->dataStr) > 0)
+			{
+				if($this->dataStr == '')
+					return 0;
 
-                $mode = $this->identifyMode(0);
+				$mode = $this->identifyMode(0);
                 
-                switch ($mode) {
-                    case QR_MODE_NUM: $length = $this->eatNum(); break;
-                    case QR_MODE_AN:  $length = $this->eatAn(); break;
-                    case QR_MODE_KANJI:
-                        if ($this->modeHint == QR_MODE_KANJI)
-                                $length = $this->eatKanji();
-                        else    $length = $this->eat8();
-                        break;
-                    default: $length = $this->eat8(); break;
+				switch ($mode) {
+					case QR_MODE_NUM: $length = $this->eatNum(); break;
+					case QR_MODE_AN:  $length = $this->eatAn(); break;
+					case QR_MODE_KANJI:
+						if ($this->modeHint == QR_MODE_KANJI)
+								$length = $this->eatKanji();
+						else    $length = $this->eat8();
+						break;
+					default: $length = $this->eat8(); break;
                 
-                }
+				}
 
-                if($length == 0) return 0;
-                if($length < 0)  return -1;
+				if($length == 0) return 0;
+				if($length < 0)  return -1;
                 
-                $this->dataStr = substr($this->dataStr, $length);
-            }
-        }
+				$this->dataStr = substr($this->dataStr, $length);
+			}
+		}
 
-        //----------------------------------------------------------------------
-        public function toUpper()
-        {
-            $stringLen = strlen($this->dataStr);
-            $p = 0;
+		//----------------------------------------------------------------------
+		public function toUpper()
+		{
+			$stringLen = strlen($this->dataStr);
+			$p = 0;
             
-            while ($p<$stringLen) {
-                $mode = self::identifyMode(substr($this->dataStr, $p));
-                if($mode == QR_MODE_KANJI) {
-                    $p += 2;
-                } else {
-                    if (ord($this->dataStr[$p]) >= ord('a') && ord($this->dataStr[$p]) <= ord('z')) {
-                        $this->dataStr[$p] = chr(ord($this->dataStr[$p]) - 32);
-                    }
-                    $p++;
-                }
-            }
+			while ($p<$stringLen) {
+				$mode = self::identifyMode(substr($this->dataStr, $p));
+				if($mode == QR_MODE_KANJI) {
+					$p += 2;
+				} else {
+					if (ord($this->dataStr[$p]) >= ord('a') && ord($this->dataStr[$p]) <= ord('z')) {
+						$this->dataStr[$p] = chr(ord($this->dataStr[$p]) - 32);
+					}
+					$p++;
+				}
+			}
 
-            return $this->dataStr;
-        }
+			return $this->dataStr;
+		}
 
-        //----------------------------------------------------------------------
-        public static function splitStringToQRinput($string, QRinput $input, $modeHint, $casesensitive = true)
-        {
-            if(is_null($string) || $string == '\0' || $string == '') {
-                throw new Exception('empty string!!!');
-            }
+		//----------------------------------------------------------------------
+		public static function splitStringToQRinput($string, QRinput $input, $modeHint, $casesensitive = true)
+		{
+			if(is_null($string) || $string == '\0' || $string == '') {
+				throw new Exception('empty string!!!');
+			}
 
-            $split = new QRsplit($string, $input, $modeHint);
+			$split = new QRsplit($string, $input, $modeHint);
             
-            if(!$casesensitive)
-                $split->toUpper();
+			if(!$casesensitive)
+				$split->toUpper();
                 
-            return $split->splitString();
-        }
-    }
+			return $split->splitString();
+		}
+	}

Please login to merge, or discard this patch.

Switch Indentation +8 added lines, -8 removed lines patch added patch discarded remove patch

@@ -255,14 +255,14 @@
 block discarded – undo
                 $mode = $this->identifyMode(0);
                 
                 switch ($mode) {
-                    case QR_MODE_NUM: $length = $this->eatNum(); break;
-                    case QR_MODE_AN:  $length = $this->eatAn(); break;
-                    case QR_MODE_KANJI:
-                        if ($this->modeHint == QR_MODE_KANJI)
-                                $length = $this->eatKanji();
-                        else    $length = $this->eat8();
-                        break;
-                    default: $length = $this->eat8(); break;
+                case QR_MODE_NUM: $length = $this->eatNum(); break;
+                case QR_MODE_AN:  $length = $this->eatAn(); break;
+                case QR_MODE_KANJI:
+                    if ($this->modeHint == QR_MODE_KANJI)
+                            $length = $this->eatKanji();
+                    else    $length = $this->eat8();
+                    break;
+                default: $length = $this->eat8(); break;
                 
                 }
 

Please login to merge, or discard this patch.

Spacing +40 added lines, -40 removed lines patch added patch discarded remove patch

@@ -50,7 +50,7 @@  discard block
 block discarded – undo
             if ($pos >= strlen($str))
                 return false;
             
-            return ((ord($str[$pos]) >= ord('0'))&&(ord($str[$pos]) <= ord('9')));
+            return ((ord($str[$pos]) >= ord('0')) && (ord($str[$pos]) <= ord('9')));
         }
         
         //----------------------------------------------------------------------
@@ -70,17 +70,17 @@  discard block
 block discarded – undo
                 
             $c = $this->dataStr[$pos];
             
-            if(self::isdigitat($this->dataStr, $pos)) {
+            if (self::isdigitat($this->dataStr, $pos)) {
                 return QR_MODE_NUM;
-            } else if(self::isalnumat($this->dataStr, $pos)) {
+            } else if (self::isalnumat($this->dataStr, $pos)) {
                 return QR_MODE_AN;
-            } else if($this->modeHint == QR_MODE_KANJI) {
+            } else if ($this->modeHint == QR_MODE_KANJI) {
             
-                if ($pos+1 < strlen($this->dataStr)) 
+                if ($pos + 1 < strlen($this->dataStr)) 
                 {
-                    $d = $this->dataStr[$pos+1];
+                    $d = $this->dataStr[$pos + 1];
                     $word = (ord($c) << 8) | ord($d);
-                    if(($word >= 0x8140 && $word <= 0x9ffc) || ($word >= 0xe040 && $word <= 0xebbf)) {
+                    if (($word >= 0x8140 && $word <= 0x9ffc) || ($word >= 0xe040 && $word <= 0xebbf)) {
                         return QR_MODE_KANJI;
                     }
                 }
@@ -95,32 +95,32 @@  discard block
 block discarded – undo
             $ln = QRspec::lengthIndicator(QR_MODE_NUM, $this->input->getVersion());
 
             $p = 0;
-            while(self::isdigitat($this->dataStr, $p)) {
+            while (self::isdigitat($this->dataStr, $p)) {
                 $p++;
             }
             
             $run = $p;
             $mode = $this->identifyMode($p);
             
-            if($mode == QR_MODE_8) {
+            if ($mode == QR_MODE_8) {
                 $dif = QRinput::estimateBitsModeNum($run) + 4 + $ln
                      + QRinput::estimateBitsMode8(1)         // + 4 + l8
                      - QRinput::estimateBitsMode8($run + 1); // - 4 - l8
-                if($dif > 0) {
+                if ($dif > 0) {
                     return $this->eat8();
                 }
             }
-            if($mode == QR_MODE_AN) {
+            if ($mode == QR_MODE_AN) {
                 $dif = QRinput::estimateBitsModeNum($run) + 4 + $ln
                      + QRinput::estimateBitsModeAn(1)        // + 4 + la
-                     - QRinput::estimateBitsModeAn($run + 1);// - 4 - la
-                if($dif > 0) {
+                     - QRinput::estimateBitsModeAn($run + 1); // - 4 - la
+                if ($dif > 0) {
                     return $this->eatAn();
                 }
             }
             
             $ret = $this->input->append(QR_MODE_NUM, $run, str_split($this->dataStr));
-            if($ret < 0)
+            if ($ret < 0)
                 return -1;
 
             return $run;
@@ -129,15 +129,15 @@  discard block
 block discarded – undo
         //----------------------------------------------------------------------
         public function eatAn()
         {
-            $la = QRspec::lengthIndicator(QR_MODE_AN,  $this->input->getVersion());
+            $la = QRspec::lengthIndicator(QR_MODE_AN, $this->input->getVersion());
             $ln = QRspec::lengthIndicator(QR_MODE_NUM, $this->input->getVersion());
 
             $p = 0;
             
-            while(self::isalnumat($this->dataStr, $p)) {
-                if(self::isdigitat($this->dataStr, $p)) {
+            while (self::isalnumat($this->dataStr, $p)) {
+                if (self::isdigitat($this->dataStr, $p)) {
                     $q = $p;
-                    while(self::isdigitat($this->dataStr, $q)) {
+                    while (self::isdigitat($this->dataStr, $q)) {
                         $q++;
                     }
                     
@@ -145,7 +145,7 @@  discard block
 block discarded – undo
                          + QRinput::estimateBitsModeNum($q - $p) + 4 + $ln
                          - QRinput::estimateBitsModeAn($q); // - 4 - la
                          
-                    if($dif < 0) {
+                    if ($dif < 0) {
                         break;
                     } else {
                         $p = $q;
@@ -157,17 +157,17 @@  discard block
 block discarded – undo
 
             $run = $p;
 
-            if(!self::isalnumat($this->dataStr, $p)) {
+            if (!self::isalnumat($this->dataStr, $p)) {
                 $dif = QRinput::estimateBitsModeAn($run) + 4 + $la
                      + QRinput::estimateBitsMode8(1) // + 4 + l8
                       - QRinput::estimateBitsMode8($run + 1); // - 4 - l8
-                if($dif > 0) {
+                if ($dif > 0) {
                     return $this->eat8();
                 }
             }
 
             $ret = $this->input->append(QR_MODE_AN, $run, str_split($this->dataStr));
-            if($ret < 0)
+            if ($ret < 0)
                 return -1;
 
             return $run;
@@ -178,12 +178,12 @@  discard block
 block discarded – undo
         {
             $p = 0;
             
-            while($this->identifyMode($p) == QR_MODE_KANJI) {
+            while ($this->identifyMode($p) == QR_MODE_KANJI) {
                 $p += 2;
             }
             
             $ret = $this->input->append(QR_MODE_KANJI, $p, str_split($this->dataStr));
-            if($ret < 0)
+            if ($ret < 0)
                 return -1;
 
             return $ret;
@@ -198,34 +198,34 @@  discard block
 block discarded – undo
             $p = 1;
             $dataStrLen = strlen($this->dataStr);
             
-            while($p < $dataStrLen) {
+            while ($p < $dataStrLen) {
                 
                 $mode = $this->identifyMode($p);
-                if($mode == QR_MODE_KANJI) {
+                if ($mode == QR_MODE_KANJI) {
                     break;
                 }
-                if($mode == QR_MODE_NUM) {
+                if ($mode == QR_MODE_NUM) {
                     $q = $p;
-                    while(self::isdigitat($this->dataStr, $q)) {
+                    while (self::isdigitat($this->dataStr, $q)) {
                         $q++;
                     }
                     $dif = QRinput::estimateBitsMode8($p) // + 4 + l8
                          + QRinput::estimateBitsModeNum($q - $p) + 4 + $ln
                          - QRinput::estimateBitsMode8($q); // - 4 - l8
-                    if($dif < 0) {
+                    if ($dif < 0) {
                         break;
                     } else {
                         $p = $q;
                     }
-                } else if($mode == QR_MODE_AN) {
+                } else if ($mode == QR_MODE_AN) {
                     $q = $p;
-                    while(self::isalnumat($this->dataStr, $q)) {
+                    while (self::isalnumat($this->dataStr, $q)) {
                         $q++;
                     }
                     $dif = QRinput::estimateBitsMode8($p)  // + 4 + l8
                          + QRinput::estimateBitsModeAn($q - $p) + 4 + $la
                          - QRinput::estimateBitsMode8($q); // - 4 - l8
-                    if($dif < 0) {
+                    if ($dif < 0) {
                         break;
                     } else {
                         $p = $q;
@@ -238,7 +238,7 @@  discard block
 block discarded – undo
             $run = $p;
             $ret = $this->input->append(QR_MODE_8, $run, str_split($this->dataStr));
             
-            if($ret < 0)
+            if ($ret < 0)
                 return -1;
 
             return $run;
@@ -249,7 +249,7 @@  discard block
 block discarded – undo
         {
             while (strlen($this->dataStr) > 0)
             {
-                if($this->dataStr == '')
+                if ($this->dataStr == '')
                     return 0;
 
                 $mode = $this->identifyMode(0);
@@ -266,8 +266,8 @@  discard block
 block discarded – undo
                 
                 }
 
-                if($length == 0) return 0;
-                if($length < 0)  return -1;
+                if ($length == 0) return 0;
+                if ($length < 0)  return -1;
                 
                 $this->dataStr = substr($this->dataStr, $length);
             }
@@ -279,9 +279,9 @@  discard block
 block discarded – undo
             $stringLen = strlen($this->dataStr);
             $p = 0;
             
-            while ($p<$stringLen) {
+            while ($p < $stringLen) {
                 $mode = self::identifyMode(substr($this->dataStr, $p));
-                if($mode == QR_MODE_KANJI) {
+                if ($mode == QR_MODE_KANJI) {
                     $p += 2;
                 } else {
                     if (ord($this->dataStr[$p]) >= ord('a') && ord($this->dataStr[$p]) <= ord('z')) {
@@ -297,13 +297,13 @@  discard block
 block discarded – undo
         //----------------------------------------------------------------------
         public static function splitStringToQRinput($string, QRinput $input, $modeHint, $casesensitive = true)
         {
-            if(is_null($string) || $string == '\0' || $string == '') {
+            if (is_null($string) || $string == '\0' || $string == '') {
                 throw new Exception('empty string!!!');
             }
 
             $split = new QRsplit($string, $input, $modeHint);
             
-            if(!$casesensitive)
+            if (!$casesensitive)
                 $split->toUpper();
                 
             return $split->splitString();

Please login to merge, or discard this patch.

Braces +38 added lines, -23 removed lines patch added patch discarded remove patch

@@ -47,8 +47,9 @@  discard block
 block discarded – undo
         //----------------------------------------------------------------------
         public static function isdigitat($str, $pos)
         {    
-            if ($pos >= strlen($str))
-                return false;
+            if ($pos >= strlen($str)) {
+                            return false;
+            }
             
             return ((ord($str[$pos]) >= ord('0'))&&(ord($str[$pos]) <= ord('9')));
         }
@@ -56,8 +57,9 @@  discard block
 block discarded – undo
         //----------------------------------------------------------------------
         public static function isalnumat($str, $pos)
         {
-            if ($pos >= strlen($str))
-                return false;
+            if ($pos >= strlen($str)) {
+                            return false;
+            }
                 
             return (QRinput::lookAnTable(ord($str[$pos])) >= 0);
         }
@@ -65,8 +67,9 @@  discard block
 block discarded – undo
         //----------------------------------------------------------------------
         public function identifyMode($pos)
         {
-            if ($pos >= strlen($this->dataStr)) 
-                return QR_MODE_NUL;
+            if ($pos >= strlen($this->dataStr)) {
+                            return QR_MODE_NUL;
+            }
                 
             $c = $this->dataStr[$pos];
             
@@ -120,8 +123,9 @@  discard block
 block discarded – undo
             }
             
             $ret = $this->input->append(QR_MODE_NUM, $run, str_split($this->dataStr));
-            if($ret < 0)
-                return -1;
+            if($ret < 0) {
+                            return -1;
+            }
 
             return $run;
         }
@@ -167,8 +171,9 @@  discard block
 block discarded – undo
             }
 
             $ret = $this->input->append(QR_MODE_AN, $run, str_split($this->dataStr));
-            if($ret < 0)
-                return -1;
+            if($ret < 0) {
+                            return -1;
+            }
 
             return $run;
         }
@@ -183,8 +188,9 @@  discard block
 block discarded – undo
             }
             
             $ret = $this->input->append(QR_MODE_KANJI, $p, str_split($this->dataStr));
-            if($ret < 0)
-                return -1;
+            if($ret < 0) {
+                            return -1;
+            }
 
             return $ret;
         }
@@ -238,8 +244,9 @@  discard block
 block discarded – undo
             $run = $p;
             $ret = $this->input->append(QR_MODE_8, $run, str_split($this->dataStr));
             
-            if($ret < 0)
-                return -1;
+            if($ret < 0) {
+                            return -1;
+            }
 
             return $run;
         }
@@ -249,8 +256,9 @@  discard block
 block discarded – undo
         {
             while (strlen($this->dataStr) > 0)
             {
-                if($this->dataStr == '')
-                    return 0;
+                if($this->dataStr == '') {
+                                    return 0;
+                }
 
                 $mode = $this->identifyMode(0);
                 
@@ -258,16 +266,22 @@  discard block
 block discarded – undo
                     case QR_MODE_NUM: $length = $this->eatNum(); break;
                     case QR_MODE_AN:  $length = $this->eatAn(); break;
                     case QR_MODE_KANJI:
-                        if ($this->modeHint == QR_MODE_KANJI)
-                                $length = $this->eatKanji();
-                        else    $length = $this->eat8();
+                        if ($this->modeHint == QR_MODE_KANJI) {
+                                                        $length = $this->eatKanji();
+                        } else {
+                        	$length = $this->eat8();
+                        }
                         break;
                     default: $length = $this->eat8(); break;
                 
                 }
 
-                if($length == 0) return 0;
-                if($length < 0)  return -1;
+                if($length == 0) {
+                	return 0;
+                }
+                if($length < 0) {
+                	return -1;
+                }
                 
                 $this->dataStr = substr($this->dataStr, $length);
             }
@@ -303,8 +317,9 @@  discard block
 block discarded – undo
 
             $split = new QRsplit($string, $input, $modeHint);
             
-            if(!$casesensitive)
-                $split->toUpper();
+            if(!$casesensitive) {
+                            $split->toUpper();
+            }
                 
             return $split->splitString();
         }

Please login to merge, or discard this patch.

lib/phpqrcode/qrinput.php 4 patches

Indentation +619 added lines, -619 removed lines patch added patch discarded remove patch

@@ -25,705 +25,705 @@
 block discarded – undo
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  */
  
-    define('STRUCTURE_HEADER_BITS',  20);
-    define('MAX_STRUCTURED_SYMBOLS', 16);
+	define('STRUCTURE_HEADER_BITS',  20);
+	define('MAX_STRUCTURED_SYMBOLS', 16);
 
-    class QRinputItem {
+	class QRinputItem {
     
-        public $mode;
-        public $size;
-        public $data;
-        public $bstream;
-
-        public function __construct($mode, $size, $data, $bstream = null) 
-        {
-            $setData = array_slice($data, 0, $size);
+		public $mode;
+		public $size;
+		public $data;
+		public $bstream;
+
+		public function __construct($mode, $size, $data, $bstream = null) 
+		{
+			$setData = array_slice($data, 0, $size);
             
-            if (count($setData) < $size) {
-                $setData = array_merge($setData, array_fill(0,$size-count($setData),0));
-            }
-        
-            if(!QRinput::check($mode, $size, $setData)) {
-                throw new Exception('Error m:'.$mode.',s:'.$size.',d:'.join(',',$setData));
-                return null;
-            }
+			if (count($setData) < $size) {
+				$setData = array_merge($setData, array_fill(0,$size-count($setData),0));
+			}
+        
+			if(!QRinput::check($mode, $size, $setData)) {
+				throw new Exception('Error m:'.$mode.',s:'.$size.',d:'.join(',',$setData));
+				return null;
+			}
             
-            $this->mode = $mode;
-            $this->size = $size;
-            $this->data = $setData;
-            $this->bstream = $bstream;
-        }
-        
-        //----------------------------------------------------------------------
-        public function encodeModeNum($version)
-        {
-            try {
+			$this->mode = $mode;
+			$this->size = $size;
+			$this->data = $setData;
+			$this->bstream = $bstream;
+		}
+        
+		//----------------------------------------------------------------------
+		public function encodeModeNum($version)
+		{
+			try {
             
-                $words = (int)($this->size / 3);
-                $bs = new QRbitstream();
+				$words = (int)($this->size / 3);
+				$bs = new QRbitstream();
                 
-                $val = 0x1;
-                $bs->appendNum(4, $val);
-                $bs->appendNum(QRspec::lengthIndicator(QR_MODE_NUM, $version), $this->size);
-
-                for($i=0; $i<$words; $i++) {
-                    $val  = (ord($this->data[$i*3  ]) - ord('0')) * 100;
-                    $val += (ord($this->data[$i*3+1]) - ord('0')) * 10;
-                    $val += (ord($this->data[$i*3+2]) - ord('0'));
-                    $bs->appendNum(10, $val);
-                }
-
-                if($this->size - $words * 3 == 1) {
-                    $val = ord($this->data[$words*3]) - ord('0');
-                    $bs->appendNum(4, $val);
-                } else if($this->size - $words * 3 == 2) {
-                    $val  = (ord($this->data[$words*3  ]) - ord('0')) * 10;
-                    $val += (ord($this->data[$words*3+1]) - ord('0'));
-                    $bs->appendNum(7, $val);
-                }
-
-                $this->bstream = $bs;
-                return 0;
+				$val = 0x1;
+				$bs->appendNum(4, $val);
+				$bs->appendNum(QRspec::lengthIndicator(QR_MODE_NUM, $version), $this->size);
+
+				for($i=0; $i<$words; $i++) {
+					$val  = (ord($this->data[$i*3  ]) - ord('0')) * 100;
+					$val += (ord($this->data[$i*3+1]) - ord('0')) * 10;
+					$val += (ord($this->data[$i*3+2]) - ord('0'));
+					$bs->appendNum(10, $val);
+				}
+
+				if($this->size - $words * 3 == 1) {
+					$val = ord($this->data[$words*3]) - ord('0');
+					$bs->appendNum(4, $val);
+				} else if($this->size - $words * 3 == 2) {
+					$val  = (ord($this->data[$words*3  ]) - ord('0')) * 10;
+					$val += (ord($this->data[$words*3+1]) - ord('0'));
+					$bs->appendNum(7, $val);
+				}
+
+				$this->bstream = $bs;
+				return 0;
                 
-            } catch (Exception $e) {
-                return -1;
-            }
-        }
-        
-        //----------------------------------------------------------------------
-        public function encodeModeAn($version)
-        {
-            try {
-                $words = (int)($this->size / 2);
-                $bs = new QRbitstream();
+			} catch (Exception $e) {
+				return -1;
+			}
+		}
+        
+		//----------------------------------------------------------------------
+		public function encodeModeAn($version)
+		{
+			try {
+				$words = (int)($this->size / 2);
+				$bs = new QRbitstream();
                 
-                $bs->appendNum(4, 0x02);
-                $bs->appendNum(QRspec::lengthIndicator(QR_MODE_AN, $version), $this->size);
+				$bs->appendNum(4, 0x02);
+				$bs->appendNum(QRspec::lengthIndicator(QR_MODE_AN, $version), $this->size);
 
-                for($i=0; $i<$words; $i++) {
-                    $val  = (int)QRinput::lookAnTable(ord($this->data[$i*2  ])) * 45;
-                    $val += (int)QRinput::lookAnTable(ord($this->data[$i*2+1]));
+				for($i=0; $i<$words; $i++) {
+					$val  = (int)QRinput::lookAnTable(ord($this->data[$i*2  ])) * 45;
+					$val += (int)QRinput::lookAnTable(ord($this->data[$i*2+1]));
 
-                    $bs->appendNum(11, $val);
-                }
+					$bs->appendNum(11, $val);
+				}
 
-                if($this->size & 1) {
-                    $val = QRinput::lookAnTable(ord($this->data[$words * 2]));
-                    $bs->appendNum(6, $val);
-                }
+				if($this->size & 1) {
+					$val = QRinput::lookAnTable(ord($this->data[$words * 2]));
+					$bs->appendNum(6, $val);
+				}
         
-                $this->bstream = $bs;
-                return 0;
+				$this->bstream = $bs;
+				return 0;
             
-            } catch (Exception $e) {
-                return -1;
-            }
-        }
-        
-        //----------------------------------------------------------------------
-        public function encodeMode8($version)
-        {
-            try {
-                $bs = new QRbitstream();
-
-                $bs->appendNum(4, 0x4);
-                $bs->appendNum(QRspec::lengthIndicator(QR_MODE_8, $version), $this->size);
-
-                for($i=0; $i<$this->size; $i++) {
-                    $bs->appendNum(8, ord($this->data[$i]));
-                }
-
-                $this->bstream = $bs;
-                return 0;
+			} catch (Exception $e) {
+				return -1;
+			}
+		}
+        
+		//----------------------------------------------------------------------
+		public function encodeMode8($version)
+		{
+			try {
+				$bs = new QRbitstream();
+
+				$bs->appendNum(4, 0x4);
+				$bs->appendNum(QRspec::lengthIndicator(QR_MODE_8, $version), $this->size);
+
+				for($i=0; $i<$this->size; $i++) {
+					$bs->appendNum(8, ord($this->data[$i]));
+				}
+
+				$this->bstream = $bs;
+				return 0;
             
-            } catch (Exception $e) {
-                return -1;
-            }
-        }
+			} catch (Exception $e) {
+				return -1;
+			}
+		}
         
-        //----------------------------------------------------------------------
-        public function encodeModeKanji($version)
-        {
-            try {
+		//----------------------------------------------------------------------
+		public function encodeModeKanji($version)
+		{
+			try {
 
-                $bs = new QRbitrtream();
+				$bs = new QRbitrtream();
                 
-                $bs->appendNum(4, 0x8);
-                $bs->appendNum(QRspec::lengthIndicator(QR_MODE_KANJI, $version), (int)($this->size / 2));
-
-                for($i=0; $i<$this->size; $i+=2) {
-                    $val = (ord($this->data[$i]) << 8) | ord($this->data[$i+1]);
-                    if($val <= 0x9ffc) {
-                        $val -= 0x8140;
-                    } else {
-                        $val -= 0xc140;
-                    }
+				$bs->appendNum(4, 0x8);
+				$bs->appendNum(QRspec::lengthIndicator(QR_MODE_KANJI, $version), (int)($this->size / 2));
+
+				for($i=0; $i<$this->size; $i+=2) {
+					$val = (ord($this->data[$i]) << 8) | ord($this->data[$i+1]);
+					if($val <= 0x9ffc) {
+						$val -= 0x8140;
+					} else {
+						$val -= 0xc140;
+					}
                     
-                    $h = ($val >> 8) * 0xc0;
-                    $val = ($val & 0xff) + $h;
+					$h = ($val >> 8) * 0xc0;
+					$val = ($val & 0xff) + $h;
 
-                    $bs->appendNum(13, $val);
-                }
+					$bs->appendNum(13, $val);
+				}
 
-                $this->bstream = $bs;
-                return 0;
+				$this->bstream = $bs;
+				return 0;
             
-            } catch (Exception $e) {
-                return -1;
-            }
-        }
-
-        //----------------------------------------------------------------------
-        public function encodeModeStructure()
-        {
-            try {
-                $bs =  new QRbitstream();
+			} catch (Exception $e) {
+				return -1;
+			}
+		}
+
+		//----------------------------------------------------------------------
+		public function encodeModeStructure()
+		{
+			try {
+				$bs =  new QRbitstream();
                 
-                $bs->appendNum(4, 0x03);
-                $bs->appendNum(4, ord($this->data[1]) - 1);
-                $bs->appendNum(4, ord($this->data[0]) - 1);
-                $bs->appendNum(8, ord($this->data[2]));
+				$bs->appendNum(4, 0x03);
+				$bs->appendNum(4, ord($this->data[1]) - 1);
+				$bs->appendNum(4, ord($this->data[0]) - 1);
+				$bs->appendNum(8, ord($this->data[2]));
 
-                $this->bstream = $bs;
-                return 0;
+				$this->bstream = $bs;
+				return 0;
             
-            } catch (Exception $e) {
-                return -1;
-            }
-        }
-        
-        //----------------------------------------------------------------------
-        public function estimateBitStreamSizeOfEntry($version)
-        {
-            $bits = 0;
-
-            if($version == 0) 
-                $version = 1;
-
-            switch($this->mode) {
-                case QR_MODE_NUM:        $bits = QRinput::estimateBitsModeNum($this->size);    break;
-                case QR_MODE_AN:        $bits = QRinput::estimateBitsModeAn($this->size);    break;
-                case QR_MODE_8:            $bits = QRinput::estimateBitsMode8($this->size);    break;
-                case QR_MODE_KANJI:        $bits = QRinput::estimateBitsModeKanji($this->size);break;
-                case QR_MODE_STRUCTURE:    return STRUCTURE_HEADER_BITS;            
-                default:
-                    return 0;
-            }
-
-            $l = QRspec::lengthIndicator($this->mode, $version);
-            $m = 1 << $l;
-            $num = (int)(($this->size + $m - 1) / $m);
-
-            $bits += $num * (4 + $l);
-
-            return $bits;
-        }
-        
-        //----------------------------------------------------------------------
-        public function encodeBitStream($version)
-        {
-            try {
+			} catch (Exception $e) {
+				return -1;
+			}
+		}
+        
+		//----------------------------------------------------------------------
+		public function estimateBitStreamSizeOfEntry($version)
+		{
+			$bits = 0;
+
+			if($version == 0) 
+				$version = 1;
+
+			switch($this->mode) {
+				case QR_MODE_NUM:        $bits = QRinput::estimateBitsModeNum($this->size);    break;
+				case QR_MODE_AN:        $bits = QRinput::estimateBitsModeAn($this->size);    break;
+				case QR_MODE_8:            $bits = QRinput::estimateBitsMode8($this->size);    break;
+				case QR_MODE_KANJI:        $bits = QRinput::estimateBitsModeKanji($this->size);break;
+				case QR_MODE_STRUCTURE:    return STRUCTURE_HEADER_BITS;            
+				default:
+					return 0;
+			}
+
+			$l = QRspec::lengthIndicator($this->mode, $version);
+			$m = 1 << $l;
+			$num = (int)(($this->size + $m - 1) / $m);
+
+			$bits += $num * (4 + $l);
+
+			return $bits;
+		}
+        
+		//----------------------------------------------------------------------
+		public function encodeBitStream($version)
+		{
+			try {
             
-                unset($this->bstream);
-                $words = QRspec::maximumWords($this->mode, $version);
+				unset($this->bstream);
+				$words = QRspec::maximumWords($this->mode, $version);
                 
-                if($this->size > $words) {
+				if($this->size > $words) {
                 
-                    $st1 = new QRinputItem($this->mode, $words, $this->data);
-                    $st2 = new QRinputItem($this->mode, $this->size - $words, array_slice($this->data, $words));
+					$st1 = new QRinputItem($this->mode, $words, $this->data);
+					$st2 = new QRinputItem($this->mode, $this->size - $words, array_slice($this->data, $words));
 
-                    $st1->encodeBitStream($version);
-                    $st2->encodeBitStream($version);
+					$st1->encodeBitStream($version);
+					$st2->encodeBitStream($version);
                     
-                    $this->bstream = new QRbitstream();
-                    $this->bstream->append($st1->bstream);
-                    $this->bstream->append($st2->bstream);
+					$this->bstream = new QRbitstream();
+					$this->bstream->append($st1->bstream);
+					$this->bstream->append($st2->bstream);
                     
-                    unset($st1);
-                    unset($st2);
+					unset($st1);
+					unset($st2);
                     
-                } else {
+				} else {
                     
-                    $ret = 0;
+					$ret = 0;
                     
-                    switch($this->mode) {
-                        case QR_MODE_NUM:        $ret = $this->encodeModeNum($version);    break;
-                        case QR_MODE_AN:        $ret = $this->encodeModeAn($version);    break;
-                        case QR_MODE_8:            $ret = $this->encodeMode8($version);    break;
-                        case QR_MODE_KANJI:        $ret = $this->encodeModeKanji($version);break;
-                        case QR_MODE_STRUCTURE:    $ret = $this->encodeModeStructure();    break;
+					switch($this->mode) {
+						case QR_MODE_NUM:        $ret = $this->encodeModeNum($version);    break;
+						case QR_MODE_AN:        $ret = $this->encodeModeAn($version);    break;
+						case QR_MODE_8:            $ret = $this->encodeMode8($version);    break;
+						case QR_MODE_KANJI:        $ret = $this->encodeModeKanji($version);break;
+						case QR_MODE_STRUCTURE:    $ret = $this->encodeModeStructure();    break;
                         
-                        default:
-                            break;
-                    }
+						default:
+							break;
+					}
                     
-                    if($ret < 0)
-                        return -1;
-                }
+					if($ret < 0)
+						return -1;
+				}
 
-                return $this->bstream->size();
+				return $this->bstream->size();
             
-            } catch (Exception $e) {
-                return -1;
-            }
-        }
-    };
+			} catch (Exception $e) {
+				return -1;
+			}
+		}
+	};
     
-    //##########################################################################
+	//##########################################################################
 
-    class QRinput {
+	class QRinput {
 
-        public $items;
+		public $items;
         
-        private $version;
-        private $level;
+		private $version;
+		private $level;
         
-        //----------------------------------------------------------------------
-        public function __construct($version = 0, $level = QR_ECLEVEL_L)
-        {
-            if ($version < 0 || $version > QRSPEC_VERSION_MAX || $level > QR_ECLEVEL_H) {
-                throw new Exception('Invalid version no');
-                return NULL;
-            }
+		//----------------------------------------------------------------------
+		public function __construct($version = 0, $level = QR_ECLEVEL_L)
+		{
+			if ($version < 0 || $version > QRSPEC_VERSION_MAX || $level > QR_ECLEVEL_H) {
+				throw new Exception('Invalid version no');
+				return NULL;
+			}
             
-            $this->version = $version;
-            $this->level = $level;
-        }
-        
-        //----------------------------------------------------------------------
-        public function getVersion()
-        {
-            return $this->version;
-        }
-        
-        //----------------------------------------------------------------------
-        public function setVersion($version)
-        {
-            if($version < 0 || $version > QRSPEC_VERSION_MAX) {
-                throw new Exception('Invalid version no');
-                return -1;
-            }
-
-            $this->version = $version;
-
-            return 0;
-        }
-        
-        //----------------------------------------------------------------------
-        public function getErrorCorrectionLevel()
-        {
-            return $this->level;
-        }
-
-        //----------------------------------------------------------------------
-        public function setErrorCorrectionLevel($level)
-        {
-            if($level > QR_ECLEVEL_H) {
-                throw new Exception('Invalid ECLEVEL');
-                return -1;
-            }
-
-            $this->level = $level;
-
-            return 0;
-        }
-        
-        //----------------------------------------------------------------------
-        public function appendEntry(QRinputItem $entry)
-        {
-            $this->items[] = $entry;
-        }
-        
-        //----------------------------------------------------------------------
-        public function append($mode, $size, $data)
-        {
-            try {
-                $entry = new QRinputItem($mode, $size, $data);
-                $this->items[] = $entry;
-                return 0;
-            } catch (Exception $e) {
-                return -1;
-            }
-        }
-        
-        //----------------------------------------------------------------------
-        
-        public function insertStructuredAppendHeader($size, $index, $parity)
-        {
-            if( $size > MAX_STRUCTURED_SYMBOLS ) {
-                throw new Exception('insertStructuredAppendHeader wrong size');
-            }
+			$this->version = $version;
+			$this->level = $level;
+		}
+        
+		//----------------------------------------------------------------------
+		public function getVersion()
+		{
+			return $this->version;
+		}
+        
+		//----------------------------------------------------------------------
+		public function setVersion($version)
+		{
+			if($version < 0 || $version > QRSPEC_VERSION_MAX) {
+				throw new Exception('Invalid version no');
+				return -1;
+			}
+
+			$this->version = $version;
+
+			return 0;
+		}
+        
+		//----------------------------------------------------------------------
+		public function getErrorCorrectionLevel()
+		{
+			return $this->level;
+		}
+
+		//----------------------------------------------------------------------
+		public function setErrorCorrectionLevel($level)
+		{
+			if($level > QR_ECLEVEL_H) {
+				throw new Exception('Invalid ECLEVEL');
+				return -1;
+			}
+
+			$this->level = $level;
+
+			return 0;
+		}
+        
+		//----------------------------------------------------------------------
+		public function appendEntry(QRinputItem $entry)
+		{
+			$this->items[] = $entry;
+		}
+        
+		//----------------------------------------------------------------------
+		public function append($mode, $size, $data)
+		{
+			try {
+				$entry = new QRinputItem($mode, $size, $data);
+				$this->items[] = $entry;
+				return 0;
+			} catch (Exception $e) {
+				return -1;
+			}
+		}
+        
+		//----------------------------------------------------------------------
+        
+		public function insertStructuredAppendHeader($size, $index, $parity)
+		{
+			if( $size > MAX_STRUCTURED_SYMBOLS ) {
+				throw new Exception('insertStructuredAppendHeader wrong size');
+			}
             
-            if( $index <= 0 || $index > MAX_STRUCTURED_SYMBOLS ) {
-                throw new Exception('insertStructuredAppendHeader wrong index');
-            }
+			if( $index <= 0 || $index > MAX_STRUCTURED_SYMBOLS ) {
+				throw new Exception('insertStructuredAppendHeader wrong index');
+			}
 
-            $buf = array($size, $index, $parity);
+			$buf = array($size, $index, $parity);
             
-            try {
-                $entry = new QRinputItem(QR_MODE_STRUCTURE, 3, buf);
-                array_unshift($this->items, $entry);
-                return 0;
-            } catch (Exception $e) {
-                return -1;
-            }
-        }
-
-        //----------------------------------------------------------------------
-        public function calcParity()
-        {
-            $parity = 0;
+			try {
+				$entry = new QRinputItem(QR_MODE_STRUCTURE, 3, buf);
+				array_unshift($this->items, $entry);
+				return 0;
+			} catch (Exception $e) {
+				return -1;
+			}
+		}
+
+		//----------------------------------------------------------------------
+		public function calcParity()
+		{
+			$parity = 0;
             
-            foreach($this->items as $item) {
-                if($item->mode != QR_MODE_STRUCTURE) {
-                    for($i=$item->size-1; $i>=0; $i--) {
-                        $parity ^= $item->data[$i];
-                    }
-                }
-            }
-
-            return $parity;
-        }
-        
-        //----------------------------------------------------------------------
-        public static function checkModeNum($size, $data)
-        {
-            for($i=0; $i<$size; $i++) {
-                if((ord($data[$i]) < ord('0')) || (ord($data[$i]) > ord('9'))){
-                    return false;
-                }
-            }
-
-            return true;
-        }
-
-        //----------------------------------------------------------------------
-        public static function estimateBitsModeNum($size)
-        {
-            $w = (int)$size / 3;
-            $bits = $w * 10;
+			foreach($this->items as $item) {
+				if($item->mode != QR_MODE_STRUCTURE) {
+					for($i=$item->size-1; $i>=0; $i--) {
+						$parity ^= $item->data[$i];
+					}
+				}
+			}
+
+			return $parity;
+		}
+        
+		//----------------------------------------------------------------------
+		public static function checkModeNum($size, $data)
+		{
+			for($i=0; $i<$size; $i++) {
+				if((ord($data[$i]) < ord('0')) || (ord($data[$i]) > ord('9'))){
+					return false;
+				}
+			}
+
+			return true;
+		}
+
+		//----------------------------------------------------------------------
+		public static function estimateBitsModeNum($size)
+		{
+			$w = (int)$size / 3;
+			$bits = $w * 10;
             
-            switch($size - $w * 3) {
-                case 1:
-                    $bits += 4;
-                    break;
-                case 2:
-                    $bits += 7;
-                    break;
-                default:
-                    break;
-            }
-
-            return $bits;
-        }
-        
-        //----------------------------------------------------------------------
-        public static $anTable = array(
-            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-            36, -1, -1, -1, 37, 38, -1, -1, -1, -1, 39, 40, -1, 41, 42, 43,
-             0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 44, -1, -1, -1, -1, -1,
-            -1, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
-            25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, -1, -1, -1, -1, -1,
-            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
-        );
-        
-        //----------------------------------------------------------------------
-        public static function lookAnTable($c)
-        {
-            return (($c > 127)?-1:self::$anTable[$c]);
-        }
-        
-        //----------------------------------------------------------------------
-        public static function checkModeAn($size, $data)
-        {
-            for($i=0; $i<$size; $i++) {
-                if (self::lookAnTable(ord($data[$i])) == -1) {
-                    return false;
-                }
-            }
-
-            return true;
-        }
-        
-        //----------------------------------------------------------------------
-        public static function estimateBitsModeAn($size)
-        {
-            $w = (int)($size / 2);
-            $bits = $w * 11;
+			switch($size - $w * 3) {
+				case 1:
+					$bits += 4;
+					break;
+				case 2:
+					$bits += 7;
+					break;
+				default:
+					break;
+			}
+
+			return $bits;
+		}
+        
+		//----------------------------------------------------------------------
+		public static $anTable = array(
+			-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+			-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+			36, -1, -1, -1, 37, 38, -1, -1, -1, -1, 39, 40, -1, 41, 42, 43,
+			 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 44, -1, -1, -1, -1, -1,
+			-1, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
+			25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, -1, -1, -1, -1, -1,
+			-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+			-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
+		);
+        
+		//----------------------------------------------------------------------
+		public static function lookAnTable($c)
+		{
+			return (($c > 127)?-1:self::$anTable[$c]);
+		}
+        
+		//----------------------------------------------------------------------
+		public static function checkModeAn($size, $data)
+		{
+			for($i=0; $i<$size; $i++) {
+				if (self::lookAnTable(ord($data[$i])) == -1) {
+					return false;
+				}
+			}
+
+			return true;
+		}
+        
+		//----------------------------------------------------------------------
+		public static function estimateBitsModeAn($size)
+		{
+			$w = (int)($size / 2);
+			$bits = $w * 11;
             
-            if($size & 1) {
-                $bits += 6;
-            }
+			if($size & 1) {
+				$bits += 6;
+			}
 
-            return $bits;
-        }
+			return $bits;
+		}
     
-        //----------------------------------------------------------------------
-        public static function estimateBitsMode8($size)
-        {
-            return $size * 8;
-        }
-        
-        //----------------------------------------------------------------------
-        public function estimateBitsModeKanji($size)
-        {
-            return (int)(($size / 2) * 13);
-        }
-        
-        //----------------------------------------------------------------------
-        public static function checkModeKanji($size, $data)
-        {
-            if($size & 1)
-                return false;
-
-            for($i=0; $i<$size; $i+=2) {
-                $val = (ord($data[$i]) << 8) | ord($data[$i+1]);
-                if( $val < 0x8140 
-                || ($val > 0x9ffc && $val < 0xe040) 
-                || $val > 0xebbf) {
-                    return false;
-                }
-            }
-
-            return true;
-        }
-
-        /***********************************************************************
+		//----------------------------------------------------------------------
+		public static function estimateBitsMode8($size)
+		{
+			return $size * 8;
+		}
+        
+		//----------------------------------------------------------------------
+		public function estimateBitsModeKanji($size)
+		{
+			return (int)(($size / 2) * 13);
+		}
+        
+		//----------------------------------------------------------------------
+		public static function checkModeKanji($size, $data)
+		{
+			if($size & 1)
+				return false;
+
+			for($i=0; $i<$size; $i+=2) {
+				$val = (ord($data[$i]) << 8) | ord($data[$i+1]);
+				if( $val < 0x8140 
+				|| ($val > 0x9ffc && $val < 0xe040) 
+				|| $val > 0xebbf) {
+					return false;
+				}
+			}
+
+			return true;
+		}
+
+		/***********************************************************************
          * Validation
          **********************************************************************/
 
-        public static function check($mode, $size, $data)
-        {
-            if($size <= 0) 
-                return false;
-
-            switch($mode) {
-                case QR_MODE_NUM:       return self::checkModeNum($size, $data);   break;
-                case QR_MODE_AN:        return self::checkModeAn($size, $data);    break;
-                case QR_MODE_KANJI:     return self::checkModeKanji($size, $data); break;
-                case QR_MODE_8:         return true; break;
-                case QR_MODE_STRUCTURE: return true; break;
+		public static function check($mode, $size, $data)
+		{
+			if($size <= 0) 
+				return false;
+
+			switch($mode) {
+				case QR_MODE_NUM:       return self::checkModeNum($size, $data);   break;
+				case QR_MODE_AN:        return self::checkModeAn($size, $data);    break;
+				case QR_MODE_KANJI:     return self::checkModeKanji($size, $data); break;
+				case QR_MODE_8:         return true; break;
+				case QR_MODE_STRUCTURE: return true; break;
                 
-                default:
-                    break;
-            }
-
-            return false;
-        }
-        
-        
-        //----------------------------------------------------------------------
-        public function estimateBitStreamSize($version)
-        {
-            $bits = 0;
-
-            foreach($this->items as $item) {
-                $bits += $item->estimateBitStreamSizeOfEntry($version);
-            }
-
-            return $bits;
-        }
-        
-        //----------------------------------------------------------------------
-        public function estimateVersion()
-        {
-            $version = 0;
-            $prev = 0;
-            do {
-                $prev = $version;
-                $bits = $this->estimateBitStreamSize($prev);
-                $version = QRspec::getMinimumVersion((int)(($bits + 7) / 8), $this->level);
-                if ($version < 0) {
-                    return -1;
-                }
-            } while ($version > $prev);
-
-            return $version;
-        }
-        
-        //----------------------------------------------------------------------
-        public static function lengthOfCode($mode, $version, $bits)
-        {
-            $payload = $bits - 4 - QRspec::lengthIndicator($mode, $version);
-            switch($mode) {
-                case QR_MODE_NUM:
-                    $chunks = (int)($payload / 10);
-                    $remain = $payload - $chunks * 10;
-                    $size = $chunks * 3;
-                    if($remain >= 7) {
-                        $size += 2;
-                    } else if($remain >= 4) {
-                        $size += 1;
-                    }
-                    break;
-                case QR_MODE_AN:
-                    $chunks = (int)($payload / 11);
-                    $remain = $payload - $chunks * 11;
-                    $size = $chunks * 2;
-                    if($remain >= 6) 
-                        $size++;
-                    break;
-                case QR_MODE_8:
-                    $size = (int)($payload / 8);
-                    break;
-                case QR_MODE_KANJI:
-                    $size = (int)(($payload / 13) * 2);
-                    break;
-                case QR_MODE_STRUCTURE:
-                    $size = (int)($payload / 8);
-                    break;
-                default:
-                    $size = 0;
-                    break;
-            }
+				default:
+					break;
+			}
+
+			return false;
+		}
+        
+        
+		//----------------------------------------------------------------------
+		public function estimateBitStreamSize($version)
+		{
+			$bits = 0;
+
+			foreach($this->items as $item) {
+				$bits += $item->estimateBitStreamSizeOfEntry($version);
+			}
+
+			return $bits;
+		}
+        
+		//----------------------------------------------------------------------
+		public function estimateVersion()
+		{
+			$version = 0;
+			$prev = 0;
+			do {
+				$prev = $version;
+				$bits = $this->estimateBitStreamSize($prev);
+				$version = QRspec::getMinimumVersion((int)(($bits + 7) / 8), $this->level);
+				if ($version < 0) {
+					return -1;
+				}
+			} while ($version > $prev);
+
+			return $version;
+		}
+        
+		//----------------------------------------------------------------------
+		public static function lengthOfCode($mode, $version, $bits)
+		{
+			$payload = $bits - 4 - QRspec::lengthIndicator($mode, $version);
+			switch($mode) {
+				case QR_MODE_NUM:
+					$chunks = (int)($payload / 10);
+					$remain = $payload - $chunks * 10;
+					$size = $chunks * 3;
+					if($remain >= 7) {
+						$size += 2;
+					} else if($remain >= 4) {
+						$size += 1;
+					}
+					break;
+				case QR_MODE_AN:
+					$chunks = (int)($payload / 11);
+					$remain = $payload - $chunks * 11;
+					$size = $chunks * 2;
+					if($remain >= 6) 
+						$size++;
+					break;
+				case QR_MODE_8:
+					$size = (int)($payload / 8);
+					break;
+				case QR_MODE_KANJI:
+					$size = (int)(($payload / 13) * 2);
+					break;
+				case QR_MODE_STRUCTURE:
+					$size = (int)($payload / 8);
+					break;
+				default:
+					$size = 0;
+					break;
+			}
             
-            $maxsize = QRspec::maximumWords($mode, $version);
-            if($size < 0) $size = 0;
-            if($size > $maxsize) $size = $maxsize;
+			$maxsize = QRspec::maximumWords($mode, $version);
+			if($size < 0) $size = 0;
+			if($size > $maxsize) $size = $maxsize;
 
-            return $size;
-        }
+			return $size;
+		}
         
-        //----------------------------------------------------------------------
-        public function createBitStream()
-        {
-            $total = 0;
+		//----------------------------------------------------------------------
+		public function createBitStream()
+		{
+			$total = 0;
 
-            foreach($this->items as $item) {
-                $bits = $item->encodeBitStream($this->version);
+			foreach($this->items as $item) {
+				$bits = $item->encodeBitStream($this->version);
                 
-                if($bits < 0) 
-                    return -1;
+				if($bits < 0) 
+					return -1;
                     
-                $total += $bits;
-            }
-
-            return $total;
-        }
-        
-        //----------------------------------------------------------------------
-        public function convertData()
-        {
-            $ver = $this->estimateVersion();
-            if($ver > $this->getVersion()) {
-                $this->setVersion($ver);
-            }
-
-            for(;;) {
-                $bits = $this->createBitStream();
+				$total += $bits;
+			}
+
+			return $total;
+		}
+        
+		//----------------------------------------------------------------------
+		public function convertData()
+		{
+			$ver = $this->estimateVersion();
+			if($ver > $this->getVersion()) {
+				$this->setVersion($ver);
+			}
+
+			for(;;) {
+				$bits = $this->createBitStream();
                 
-                if($bits < 0) 
-                    return -1;
+				if($bits < 0) 
+					return -1;
                     
-                $ver = QRspec::getMinimumVersion((int)(($bits + 7) / 8), $this->level);
-                if($ver < 0) {
-                    throw new Exception('WRONG VERSION');
-                    return -1;
-                } else if($ver > $this->getVersion()) {
-                    $this->setVersion($ver);
-                } else {
-                    break;
-                }
-            }
-
-            return 0;
-        }
-        
-        //----------------------------------------------------------------------
-        public function appendPaddingBit(&$bstream)
-        {
-            $bits = $bstream->size();
-            $maxwords = QRspec::getDataLength($this->version, $this->level);
-            $maxbits = $maxwords * 8;
-
-            if ($maxbits == $bits) {
-                return 0;
-            }
-
-            if ($maxbits - $bits < 5) {
-                return $bstream->appendNum($maxbits - $bits, 0);
-            }
-
-            $bits += 4;
-            $words = (int)(($bits + 7) / 8);
-
-            $padding = new QRbitstream();
-            $ret = $padding->appendNum($words * 8 - $bits + 4, 0);
+				$ver = QRspec::getMinimumVersion((int)(($bits + 7) / 8), $this->level);
+				if($ver < 0) {
+					throw new Exception('WRONG VERSION');
+					return -1;
+				} else if($ver > $this->getVersion()) {
+					$this->setVersion($ver);
+				} else {
+					break;
+				}
+			}
+
+			return 0;
+		}
+        
+		//----------------------------------------------------------------------
+		public function appendPaddingBit(&$bstream)
+		{
+			$bits = $bstream->size();
+			$maxwords = QRspec::getDataLength($this->version, $this->level);
+			$maxbits = $maxwords * 8;
+
+			if ($maxbits == $bits) {
+				return 0;
+			}
+
+			if ($maxbits - $bits < 5) {
+				return $bstream->appendNum($maxbits - $bits, 0);
+			}
+
+			$bits += 4;
+			$words = (int)(($bits + 7) / 8);
+
+			$padding = new QRbitstream();
+			$ret = $padding->appendNum($words * 8 - $bits + 4, 0);
             
-            if($ret < 0) 
-                return $ret;
+			if($ret < 0) 
+				return $ret;
 
-            $padlen = $maxwords - $words;
+			$padlen = $maxwords - $words;
             
-            if($padlen > 0) {
+			if($padlen > 0) {
                 
-                $padbuf = array();
-                for($i=0; $i<$padlen; $i++) {
-                    $padbuf[$i] = ($i&1)?0x11:0xec;
-                }
+				$padbuf = array();
+				for($i=0; $i<$padlen; $i++) {
+					$padbuf[$i] = ($i&1)?0x11:0xec;
+				}
                 
-                $ret = $padding->appendBytes($padlen, $padbuf);
+				$ret = $padding->appendBytes($padlen, $padbuf);
                 
-                if($ret < 0)
-                    return $ret;
+				if($ret < 0)
+					return $ret;
                 
-            }
+			}
 
-            $ret = $bstream->append($padding);
+			$ret = $bstream->append($padding);
             
-            return $ret;
-        }
+			return $ret;
+		}
 
-        //----------------------------------------------------------------------
-        public function mergeBitStream()
-        {
-            if($this->convertData() < 0) {
-                return null;
-            }
+		//----------------------------------------------------------------------
+		public function mergeBitStream()
+		{
+			if($this->convertData() < 0) {
+				return null;
+			}
 
-            $bstream = new QRbitstream();
+			$bstream = new QRbitstream();
             
-            foreach($this->items as $item) {
-                $ret = $bstream->append($item->bstream);
-                if($ret < 0) {
-                    return null;
-                }
-            }
+			foreach($this->items as $item) {
+				$ret = $bstream->append($item->bstream);
+				if($ret < 0) {
+					return null;
+				}
+			}
 
-            return $bstream;
-        }
+			return $bstream;
+		}
 
-        //----------------------------------------------------------------------
-        public function getBitStream()
-        {
+		//----------------------------------------------------------------------
+		public function getBitStream()
+		{
 
-            $bstream = $this->mergeBitStream();
+			$bstream = $this->mergeBitStream();
             
-            if($bstream == null) {
-                return null;
-            }
+			if($bstream == null) {
+				return null;
+			}
             
-            $ret = $this->appendPaddingBit($bstream);
-            if($ret < 0) {
-                return null;
-            }
-
-            return $bstream;
-        }
-        
-        //----------------------------------------------------------------------
-        public function getByteStream()
-        {
-            $bstream = $this->getBitStream();
-            if($bstream == null) {
-                return null;
-            }
+			$ret = $this->appendPaddingBit($bstream);
+			if($ret < 0) {
+				return null;
+			}
+
+			return $bstream;
+		}
+        
+		//----------------------------------------------------------------------
+		public function getByteStream()
+		{
+			$bstream = $this->getBitStream();
+			if($bstream == null) {
+				return null;
+			}
             
-            return $bstream->toByte();
-        }
-    }
+			return $bstream->toByte();
+		}
+	}
         
         
-    
\ No newline at end of file
+	
\ No newline at end of file

Please login to merge, or discard this patch.

Switch Indentation +58 added lines, -58 removed lines patch added patch discarded remove patch

@@ -201,13 +201,13 @@  discard block
 block discarded – undo
                 $version = 1;
 
             switch($this->mode) {
-                case QR_MODE_NUM:        $bits = QRinput::estimateBitsModeNum($this->size);    break;
-                case QR_MODE_AN:        $bits = QRinput::estimateBitsModeAn($this->size);    break;
-                case QR_MODE_8:            $bits = QRinput::estimateBitsMode8($this->size);    break;
-                case QR_MODE_KANJI:        $bits = QRinput::estimateBitsModeKanji($this->size);break;
-                case QR_MODE_STRUCTURE:    return STRUCTURE_HEADER_BITS;            
-                default:
-                    return 0;
+            case QR_MODE_NUM:        $bits = QRinput::estimateBitsModeNum($this->size);    break;
+            case QR_MODE_AN:        $bits = QRinput::estimateBitsModeAn($this->size);    break;
+            case QR_MODE_8:            $bits = QRinput::estimateBitsMode8($this->size);    break;
+            case QR_MODE_KANJI:        $bits = QRinput::estimateBitsModeKanji($this->size);break;
+            case QR_MODE_STRUCTURE:    return STRUCTURE_HEADER_BITS;            
+            default:
+                return 0;
             }
 
             $l = QRspec::lengthIndicator($this->mode, $version);
@@ -247,14 +247,14 @@  discard block
 block discarded – undo
                     $ret = 0;
                     
                     switch($this->mode) {
-                        case QR_MODE_NUM:        $ret = $this->encodeModeNum($version);    break;
-                        case QR_MODE_AN:        $ret = $this->encodeModeAn($version);    break;
-                        case QR_MODE_8:            $ret = $this->encodeMode8($version);    break;
-                        case QR_MODE_KANJI:        $ret = $this->encodeModeKanji($version);break;
-                        case QR_MODE_STRUCTURE:    $ret = $this->encodeModeStructure();    break;
+                    case QR_MODE_NUM:        $ret = $this->encodeModeNum($version);    break;
+                    case QR_MODE_AN:        $ret = $this->encodeModeAn($version);    break;
+                    case QR_MODE_8:            $ret = $this->encodeMode8($version);    break;
+                    case QR_MODE_KANJI:        $ret = $this->encodeModeKanji($version);break;
+                    case QR_MODE_STRUCTURE:    $ret = $this->encodeModeStructure();    break;
                         
-                        default:
-                            break;
+                    default:
+                        break;
                     }
                     
                     if($ret < 0)
@@ -404,14 +404,14 @@  discard block
 block discarded – undo
             $bits = $w * 10;
             
             switch($size - $w * 3) {
-                case 1:
-                    $bits += 4;
-                    break;
-                case 2:
-                    $bits += 7;
-                    break;
-                default:
-                    break;
+            case 1:
+                $bits += 4;
+                break;
+            case 2:
+                $bits += 7;
+                break;
+            default:
+                break;
             }
 
             return $bits;
@@ -500,14 +500,14 @@  discard block
 block discarded – undo
                 return false;
 
             switch($mode) {
-                case QR_MODE_NUM:       return self::checkModeNum($size, $data);   break;
-                case QR_MODE_AN:        return self::checkModeAn($size, $data);    break;
-                case QR_MODE_KANJI:     return self::checkModeKanji($size, $data); break;
-                case QR_MODE_8:         return true; break;
-                case QR_MODE_STRUCTURE: return true; break;
+            case QR_MODE_NUM:       return self::checkModeNum($size, $data);   break;
+            case QR_MODE_AN:        return self::checkModeAn($size, $data);    break;
+            case QR_MODE_KANJI:     return self::checkModeKanji($size, $data); break;
+            case QR_MODE_8:         return true; break;
+            case QR_MODE_STRUCTURE: return true; break;
                 
-                default:
-                    break;
+            default:
+                break;
             }
 
             return false;
@@ -548,35 +548,35 @@  discard block
 block discarded – undo
         {
             $payload = $bits - 4 - QRspec::lengthIndicator($mode, $version);
             switch($mode) {
-                case QR_MODE_NUM:
-                    $chunks = (int)($payload / 10);
-                    $remain = $payload - $chunks * 10;
-                    $size = $chunks * 3;
-                    if($remain >= 7) {
-                        $size += 2;
-                    } else if($remain >= 4) {
-                        $size += 1;
-                    }
-                    break;
-                case QR_MODE_AN:
-                    $chunks = (int)($payload / 11);
-                    $remain = $payload - $chunks * 11;
-                    $size = $chunks * 2;
-                    if($remain >= 6) 
-                        $size++;
-                    break;
-                case QR_MODE_8:
-                    $size = (int)($payload / 8);
-                    break;
-                case QR_MODE_KANJI:
-                    $size = (int)(($payload / 13) * 2);
-                    break;
-                case QR_MODE_STRUCTURE:
-                    $size = (int)($payload / 8);
-                    break;
-                default:
-                    $size = 0;
-                    break;
+            case QR_MODE_NUM:
+                $chunks = (int)($payload / 10);
+                $remain = $payload - $chunks * 10;
+                $size = $chunks * 3;
+                if($remain >= 7) {
+                    $size += 2;
+                } else if($remain >= 4) {
+                    $size += 1;
+                }
+                break;
+            case QR_MODE_AN:
+                $chunks = (int)($payload / 11);
+                $remain = $payload - $chunks * 11;
+                $size = $chunks * 2;
+                if($remain >= 6) 
+                    $size++;
+                break;
+            case QR_MODE_8:
+                $size = (int)($payload / 8);
+                break;
+            case QR_MODE_KANJI:
+                $size = (int)(($payload / 13) * 2);
+                break;
+            case QR_MODE_STRUCTURE:
+                $size = (int)($payload / 8);
+                break;
+            default:
+                $size = 0;
+                break;
             }
             
             $maxsize = QRspec::maximumWords($mode, $version);

Please login to merge, or discard this patch.

Spacing +98 added lines, -98 removed lines patch added patch discarded remove patch

@@ -25,7 +25,7 @@  discard block
 block discarded – undo
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  */
  
-    define('STRUCTURE_HEADER_BITS',  20);
+    define('STRUCTURE_HEADER_BITS', 20);
     define('MAX_STRUCTURED_SYMBOLS', 16);
 
     class QRinputItem {
@@ -40,11 +40,11 @@  discard block
 block discarded – undo
             $setData = array_slice($data, 0, $size);
             
             if (count($setData) < $size) {
-                $setData = array_merge($setData, array_fill(0,$size-count($setData),0));
+                $setData = array_merge($setData, array_fill(0, $size - count($setData), 0));
             }
         
-            if(!QRinput::check($mode, $size, $setData)) {
-                throw new Exception('Error m:'.$mode.',s:'.$size.',d:'.join(',',$setData));
+            if (!QRinput::check($mode, $size, $setData)) {
+                throw new Exception('Error m:'.$mode.',s:'.$size.',d:'.join(',', $setData));
                 return null;
             }
             
@@ -59,26 +59,26 @@  discard block
 block discarded – undo
         {
             try {
             
-                $words = (int)($this->size / 3);
+                $words = (int) ($this->size / 3);
                 $bs = new QRbitstream();
                 
                 $val = 0x1;
                 $bs->appendNum(4, $val);
                 $bs->appendNum(QRspec::lengthIndicator(QR_MODE_NUM, $version), $this->size);
 
-                for($i=0; $i<$words; $i++) {
-                    $val  = (ord($this->data[$i*3  ]) - ord('0')) * 100;
-                    $val += (ord($this->data[$i*3+1]) - ord('0')) * 10;
-                    $val += (ord($this->data[$i*3+2]) - ord('0'));
+                for ($i = 0; $i < $words; $i++) {
+                    $val  = (ord($this->data[$i * 3]) - ord('0')) * 100;
+                    $val += (ord($this->data[$i * 3 + 1]) - ord('0')) * 10;
+                    $val += (ord($this->data[$i * 3 + 2]) - ord('0'));
                     $bs->appendNum(10, $val);
                 }
 
-                if($this->size - $words * 3 == 1) {
-                    $val = ord($this->data[$words*3]) - ord('0');
+                if ($this->size - $words * 3 == 1) {
+                    $val = ord($this->data[$words * 3]) - ord('0');
                     $bs->appendNum(4, $val);
-                } else if($this->size - $words * 3 == 2) {
-                    $val  = (ord($this->data[$words*3  ]) - ord('0')) * 10;
-                    $val += (ord($this->data[$words*3+1]) - ord('0'));
+                } else if ($this->size - $words * 3 == 2) {
+                    $val  = (ord($this->data[$words * 3]) - ord('0')) * 10;
+                    $val += (ord($this->data[$words * 3 + 1]) - ord('0'));
                     $bs->appendNum(7, $val);
                 }
 
@@ -94,20 +94,20 @@  discard block
 block discarded – undo
         public function encodeModeAn($version)
         {
             try {
-                $words = (int)($this->size / 2);
+                $words = (int) ($this->size / 2);
                 $bs = new QRbitstream();
                 
                 $bs->appendNum(4, 0x02);
                 $bs->appendNum(QRspec::lengthIndicator(QR_MODE_AN, $version), $this->size);
 
-                for($i=0; $i<$words; $i++) {
-                    $val  = (int)QRinput::lookAnTable(ord($this->data[$i*2  ])) * 45;
-                    $val += (int)QRinput::lookAnTable(ord($this->data[$i*2+1]));
+                for ($i = 0; $i < $words; $i++) {
+                    $val  = (int) QRinput::lookAnTable(ord($this->data[$i * 2])) * 45;
+                    $val += (int) QRinput::lookAnTable(ord($this->data[$i * 2 + 1]));
 
                     $bs->appendNum(11, $val);
                 }
 
-                if($this->size & 1) {
+                if ($this->size & 1) {
                     $val = QRinput::lookAnTable(ord($this->data[$words * 2]));
                     $bs->appendNum(6, $val);
                 }
@@ -129,7 +129,7 @@  discard block
 block discarded – undo
                 $bs->appendNum(4, 0x4);
                 $bs->appendNum(QRspec::lengthIndicator(QR_MODE_8, $version), $this->size);
 
-                for($i=0; $i<$this->size; $i++) {
+                for ($i = 0; $i < $this->size; $i++) {
                     $bs->appendNum(8, ord($this->data[$i]));
                 }
 
@@ -149,11 +149,11 @@  discard block
 block discarded – undo
                 $bs = new QRbitrtream();
                 
                 $bs->appendNum(4, 0x8);
-                $bs->appendNum(QRspec::lengthIndicator(QR_MODE_KANJI, $version), (int)($this->size / 2));
+                $bs->appendNum(QRspec::lengthIndicator(QR_MODE_KANJI, $version), (int) ($this->size / 2));
 
-                for($i=0; $i<$this->size; $i+=2) {
-                    $val = (ord($this->data[$i]) << 8) | ord($this->data[$i+1]);
-                    if($val <= 0x9ffc) {
+                for ($i = 0; $i < $this->size; $i += 2) {
+                    $val = (ord($this->data[$i]) << 8) | ord($this->data[$i + 1]);
+                    if ($val <= 0x9ffc) {
                         $val -= 0x8140;
                     } else {
                         $val -= 0xc140;
@@ -177,7 +177,7 @@  discard block
 block discarded – undo
         public function encodeModeStructure()
         {
             try {
-                $bs =  new QRbitstream();
+                $bs = new QRbitstream();
                 
                 $bs->appendNum(4, 0x03);
                 $bs->appendNum(4, ord($this->data[1]) - 1);
@@ -197,14 +197,14 @@  discard block
 block discarded – undo
         {
             $bits = 0;
 
-            if($version == 0) 
+            if ($version == 0) 
                 $version = 1;
 
-            switch($this->mode) {
-                case QR_MODE_NUM:        $bits = QRinput::estimateBitsModeNum($this->size);    break;
-                case QR_MODE_AN:        $bits = QRinput::estimateBitsModeAn($this->size);    break;
-                case QR_MODE_8:            $bits = QRinput::estimateBitsMode8($this->size);    break;
-                case QR_MODE_KANJI:        $bits = QRinput::estimateBitsModeKanji($this->size);break;
+            switch ($this->mode) {
+                case QR_MODE_NUM:        $bits = QRinput::estimateBitsModeNum($this->size); break;
+                case QR_MODE_AN:        $bits = QRinput::estimateBitsModeAn($this->size); break;
+                case QR_MODE_8:            $bits = QRinput::estimateBitsMode8($this->size); break;
+                case QR_MODE_KANJI:        $bits = QRinput::estimateBitsModeKanji($this->size); break;
                 case QR_MODE_STRUCTURE:    return STRUCTURE_HEADER_BITS;            
                 default:
                     return 0;
@@ -212,7 +212,7 @@  discard block
 block discarded – undo
 
             $l = QRspec::lengthIndicator($this->mode, $version);
             $m = 1 << $l;
-            $num = (int)(($this->size + $m - 1) / $m);
+            $num = (int) (($this->size + $m - 1) / $m);
 
             $bits += $num * (4 + $l);
 
@@ -227,7 +227,7 @@  discard block
 block discarded – undo
                 unset($this->bstream);
                 $words = QRspec::maximumWords($this->mode, $version);
                 
-                if($this->size > $words) {
+                if ($this->size > $words) {
                 
                     $st1 = new QRinputItem($this->mode, $words, $this->data);
                     $st2 = new QRinputItem($this->mode, $this->size - $words, array_slice($this->data, $words));
@@ -246,18 +246,18 @@  discard block
 block discarded – undo
                     
                     $ret = 0;
                     
-                    switch($this->mode) {
-                        case QR_MODE_NUM:        $ret = $this->encodeModeNum($version);    break;
-                        case QR_MODE_AN:        $ret = $this->encodeModeAn($version);    break;
-                        case QR_MODE_8:            $ret = $this->encodeMode8($version);    break;
-                        case QR_MODE_KANJI:        $ret = $this->encodeModeKanji($version);break;
-                        case QR_MODE_STRUCTURE:    $ret = $this->encodeModeStructure();    break;
+                    switch ($this->mode) {
+                        case QR_MODE_NUM:        $ret = $this->encodeModeNum($version); break;
+                        case QR_MODE_AN:        $ret = $this->encodeModeAn($version); break;
+                        case QR_MODE_8:            $ret = $this->encodeMode8($version); break;
+                        case QR_MODE_KANJI:        $ret = $this->encodeModeKanji($version); break;
+                        case QR_MODE_STRUCTURE:    $ret = $this->encodeModeStructure(); break;
                         
                         default:
                             break;
                     }
                     
-                    if($ret < 0)
+                    if ($ret < 0)
                         return -1;
                 }
 
@@ -299,7 +299,7 @@  discard block
 block discarded – undo
         //----------------------------------------------------------------------
         public function setVersion($version)
         {
-            if($version < 0 || $version > QRSPEC_VERSION_MAX) {
+            if ($version < 0 || $version > QRSPEC_VERSION_MAX) {
                 throw new Exception('Invalid version no');
                 return -1;
             }
@@ -318,7 +318,7 @@  discard block
 block discarded – undo
         //----------------------------------------------------------------------
         public function setErrorCorrectionLevel($level)
         {
-            if($level > QR_ECLEVEL_H) {
+            if ($level > QR_ECLEVEL_H) {
                 throw new Exception('Invalid ECLEVEL');
                 return -1;
             }
@@ -350,11 +350,11 @@  discard block
 block discarded – undo
         
         public function insertStructuredAppendHeader($size, $index, $parity)
         {
-            if( $size > MAX_STRUCTURED_SYMBOLS ) {
+            if ($size > MAX_STRUCTURED_SYMBOLS) {
                 throw new Exception('insertStructuredAppendHeader wrong size');
             }
             
-            if( $index <= 0 || $index > MAX_STRUCTURED_SYMBOLS ) {
+            if ($index <= 0 || $index > MAX_STRUCTURED_SYMBOLS) {
                 throw new Exception('insertStructuredAppendHeader wrong index');
             }
 
@@ -374,9 +374,9 @@  discard block
 block discarded – undo
         {
             $parity = 0;
             
-            foreach($this->items as $item) {
-                if($item->mode != QR_MODE_STRUCTURE) {
-                    for($i=$item->size-1; $i>=0; $i--) {
+            foreach ($this->items as $item) {
+                if ($item->mode != QR_MODE_STRUCTURE) {
+                    for ($i = $item->size - 1; $i >= 0; $i--) {
                         $parity ^= $item->data[$i];
                     }
                 }
@@ -388,8 +388,8 @@  discard block
 block discarded – undo
         //----------------------------------------------------------------------
         public static function checkModeNum($size, $data)
         {
-            for($i=0; $i<$size; $i++) {
-                if((ord($data[$i]) < ord('0')) || (ord($data[$i]) > ord('9'))){
+            for ($i = 0; $i < $size; $i++) {
+                if ((ord($data[$i]) < ord('0')) || (ord($data[$i]) > ord('9'))) {
                     return false;
                 }
             }
@@ -400,10 +400,10 @@  discard block
 block discarded – undo
         //----------------------------------------------------------------------
         public static function estimateBitsModeNum($size)
         {
-            $w = (int)$size / 3;
+            $w = (int) $size / 3;
             $bits = $w * 10;
             
-            switch($size - $w * 3) {
+            switch ($size - $w * 3) {
                 case 1:
                     $bits += 4;
                     break;
@@ -422,7 +422,7 @@  discard block
 block discarded – undo
             -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
             -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
             36, -1, -1, -1, 37, 38, -1, -1, -1, -1, 39, 40, -1, 41, 42, 43,
-             0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 44, -1, -1, -1, -1, -1,
+             0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 44, -1, -1, -1, -1, -1,
             -1, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
             25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, -1, -1, -1, -1, -1,
             -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
@@ -432,13 +432,13 @@  discard block
 block discarded – undo
         //----------------------------------------------------------------------
         public static function lookAnTable($c)
         {
-            return (($c > 127)?-1:self::$anTable[$c]);
+            return (($c > 127) ?-1 : self::$anTable[$c]);
         }
         
         //----------------------------------------------------------------------
         public static function checkModeAn($size, $data)
         {
-            for($i=0; $i<$size; $i++) {
+            for ($i = 0; $i < $size; $i++) {
                 if (self::lookAnTable(ord($data[$i])) == -1) {
                     return false;
                 }
@@ -450,10 +450,10 @@  discard block
 block discarded – undo
         //----------------------------------------------------------------------
         public static function estimateBitsModeAn($size)
         {
-            $w = (int)($size / 2);
+            $w = (int) ($size / 2);
             $bits = $w * 11;
             
-            if($size & 1) {
+            if ($size & 1) {
                 $bits += 6;
             }
 
@@ -469,18 +469,18 @@  discard block
 block discarded – undo
         //----------------------------------------------------------------------
         public function estimateBitsModeKanji($size)
         {
-            return (int)(($size / 2) * 13);
+            return (int) (($size / 2) * 13);
         }
         
         //----------------------------------------------------------------------
         public static function checkModeKanji($size, $data)
         {
-            if($size & 1)
+            if ($size & 1)
                 return false;
 
-            for($i=0; $i<$size; $i+=2) {
-                $val = (ord($data[$i]) << 8) | ord($data[$i+1]);
-                if( $val < 0x8140 
+            for ($i = 0; $i < $size; $i += 2) {
+                $val = (ord($data[$i]) << 8) | ord($data[$i + 1]);
+                if ($val < 0x8140 
                 || ($val > 0x9ffc && $val < 0xe040) 
                 || $val > 0xebbf) {
                     return false;
@@ -496,12 +496,12 @@  discard block
 block discarded – undo
 
         public static function check($mode, $size, $data)
         {
-            if($size <= 0) 
+            if ($size <= 0) 
                 return false;
 
-            switch($mode) {
-                case QR_MODE_NUM:       return self::checkModeNum($size, $data);   break;
-                case QR_MODE_AN:        return self::checkModeAn($size, $data);    break;
+            switch ($mode) {
+                case QR_MODE_NUM:       return self::checkModeNum($size, $data); break;
+                case QR_MODE_AN:        return self::checkModeAn($size, $data); break;
                 case QR_MODE_KANJI:     return self::checkModeKanji($size, $data); break;
                 case QR_MODE_8:         return true; break;
                 case QR_MODE_STRUCTURE: return true; break;
@@ -519,7 +519,7 @@  discard block
 block discarded – undo
         {
             $bits = 0;
 
-            foreach($this->items as $item) {
+            foreach ($this->items as $item) {
                 $bits += $item->estimateBitStreamSizeOfEntry($version);
             }
 
@@ -534,7 +534,7 @@  discard block
 block discarded – undo
             do {
                 $prev = $version;
                 $bits = $this->estimateBitStreamSize($prev);
-                $version = QRspec::getMinimumVersion((int)(($bits + 7) / 8), $this->level);
+                $version = QRspec::getMinimumVersion((int) (($bits + 7) / 8), $this->level);
                 if ($version < 0) {
                     return -1;
                 }
@@ -547,32 +547,32 @@  discard block
 block discarded – undo
         public static function lengthOfCode($mode, $version, $bits)
         {
             $payload = $bits - 4 - QRspec::lengthIndicator($mode, $version);
-            switch($mode) {
+            switch ($mode) {
                 case QR_MODE_NUM:
-                    $chunks = (int)($payload / 10);
+                    $chunks = (int) ($payload / 10);
                     $remain = $payload - $chunks * 10;
                     $size = $chunks * 3;
-                    if($remain >= 7) {
+                    if ($remain >= 7) {
                         $size += 2;
-                    } else if($remain >= 4) {
+                    } else if ($remain >= 4) {
                         $size += 1;
                     }
                     break;
                 case QR_MODE_AN:
-                    $chunks = (int)($payload / 11);
+                    $chunks = (int) ($payload / 11);
                     $remain = $payload - $chunks * 11;
                     $size = $chunks * 2;
-                    if($remain >= 6) 
+                    if ($remain >= 6) 
                         $size++;
                     break;
                 case QR_MODE_8:
-                    $size = (int)($payload / 8);
+                    $size = (int) ($payload / 8);
                     break;
                 case QR_MODE_KANJI:
-                    $size = (int)(($payload / 13) * 2);
+                    $size = (int) (($payload / 13) * 2);
                     break;
                 case QR_MODE_STRUCTURE:
-                    $size = (int)($payload / 8);
+                    $size = (int) ($payload / 8);
                     break;
                 default:
                     $size = 0;
@@ -580,8 +580,8 @@  discard block
 block discarded – undo
             }
             
             $maxsize = QRspec::maximumWords($mode, $version);
-            if($size < 0) $size = 0;
-            if($size > $maxsize) $size = $maxsize;
+            if ($size < 0) $size = 0;
+            if ($size > $maxsize) $size = $maxsize;
 
             return $size;
         }
@@ -591,10 +591,10 @@  discard block
 block discarded – undo
         {
             $total = 0;
 
-            foreach($this->items as $item) {
+            foreach ($this->items as $item) {
                 $bits = $item->encodeBitStream($this->version);
                 
-                if($bits < 0) 
+                if ($bits < 0) 
                     return -1;
                     
                 $total += $bits;
@@ -607,21 +607,21 @@  discard block
 block discarded – undo
         public function convertData()
         {
             $ver = $this->estimateVersion();
-            if($ver > $this->getVersion()) {
+            if ($ver > $this->getVersion()) {
                 $this->setVersion($ver);
             }
 
-            for(;;) {
+            for (;;) {
                 $bits = $this->createBitStream();
                 
-                if($bits < 0) 
+                if ($bits < 0) 
                     return -1;
                     
-                $ver = QRspec::getMinimumVersion((int)(($bits + 7) / 8), $this->level);
-                if($ver < 0) {
+                $ver = QRspec::getMinimumVersion((int) (($bits + 7) / 8), $this->level);
+                if ($ver < 0) {
                     throw new Exception('WRONG VERSION');
                     return -1;
-                } else if($ver > $this->getVersion()) {
+                } else if ($ver > $this->getVersion()) {
                     $this->setVersion($ver);
                 } else {
                     break;
@@ -647,26 +647,26 @@  discard block
 block discarded – undo
             }
 
             $bits += 4;
-            $words = (int)(($bits + 7) / 8);
+            $words = (int) (($bits + 7) / 8);
 
             $padding = new QRbitstream();
             $ret = $padding->appendNum($words * 8 - $bits + 4, 0);
             
-            if($ret < 0) 
+            if ($ret < 0) 
                 return $ret;
 
             $padlen = $maxwords - $words;
             
-            if($padlen > 0) {
+            if ($padlen > 0) {
                 
                 $padbuf = array();
-                for($i=0; $i<$padlen; $i++) {
-                    $padbuf[$i] = ($i&1)?0x11:0xec;
+                for ($i = 0; $i < $padlen; $i++) {
+                    $padbuf[$i] = ($i & 1) ? 0x11 : 0xec;
                 }
                 
                 $ret = $padding->appendBytes($padlen, $padbuf);
                 
-                if($ret < 0)
+                if ($ret < 0)
                     return $ret;
                 
             }
@@ -679,15 +679,15 @@  discard block
 block discarded – undo
         //----------------------------------------------------------------------
         public function mergeBitStream()
         {
-            if($this->convertData() < 0) {
+            if ($this->convertData() < 0) {
                 return null;
             }
 
             $bstream = new QRbitstream();
             
-            foreach($this->items as $item) {
+            foreach ($this->items as $item) {
                 $ret = $bstream->append($item->bstream);
-                if($ret < 0) {
+                if ($ret < 0) {
                     return null;
                 }
             }
@@ -701,12 +701,12 @@  discard block
 block discarded – undo
 
             $bstream = $this->mergeBitStream();
             
-            if($bstream == null) {
+            if ($bstream == null) {
                 return null;
             }
             
             $ret = $this->appendPaddingBit($bstream);
-            if($ret < 0) {
+            if ($ret < 0) {
                 return null;
             }
 
@@ -717,7 +717,7 @@  discard block
 block discarded – undo
         public function getByteStream()
         {
             $bstream = $this->getBitStream();
-            if($bstream == null) {
+            if ($bstream == null) {
                 return null;
             }
             

Please login to merge, or discard this patch.

Braces +33 added lines, -20 removed lines patch added patch discarded remove patch

@@ -197,8 +197,9 @@  discard block
 block discarded – undo
         {
             $bits = 0;
 
-            if($version == 0) 
-                $version = 1;
+            if($version == 0) {
+                            $version = 1;
+            }
 
             switch($this->mode) {
                 case QR_MODE_NUM:        $bits = QRinput::estimateBitsModeNum($this->size);    break;
@@ -257,8 +258,9 @@  discard block
 block discarded – undo
                             break;
                     }
                     
-                    if($ret < 0)
-                        return -1;
+                    if($ret < 0) {
+                                            return -1;
+                    }
                 }
 
                 return $this->bstream->size();
@@ -475,8 +477,9 @@  discard block
 block discarded – undo
         //----------------------------------------------------------------------
         public static function checkModeKanji($size, $data)
         {
-            if($size & 1)
-                return false;
+            if($size & 1) {
+                            return false;
+            }
 
             for($i=0; $i<$size; $i+=2) {
                 $val = (ord($data[$i]) << 8) | ord($data[$i+1]);
@@ -496,8 +499,9 @@  discard block
 block discarded – undo
 
         public static function check($mode, $size, $data)
         {
-            if($size <= 0) 
-                return false;
+            if($size <= 0) {
+                            return false;
+            }
 
             switch($mode) {
                 case QR_MODE_NUM:       return self::checkModeNum($size, $data);   break;
@@ -562,8 +566,9 @@  discard block
 block discarded – undo
                     $chunks = (int)($payload / 11);
                     $remain = $payload - $chunks * 11;
                     $size = $chunks * 2;
-                    if($remain >= 6) 
-                        $size++;
+                    if($remain >= 6) {
+                                            $size++;
+                    }
                     break;
                 case QR_MODE_8:
                     $size = (int)($payload / 8);
@@ -580,8 +585,12 @@  discard block
 block discarded – undo
             }
             
             $maxsize = QRspec::maximumWords($mode, $version);
-            if($size < 0) $size = 0;
-            if($size > $maxsize) $size = $maxsize;
+            if($size < 0) {
+            	$size = 0;
+            }
+            if($size > $maxsize) {
+            	$size = $maxsize;
+            }
 
             return $size;
         }
@@ -594,8 +603,9 @@  discard block
 block discarded – undo
             foreach($this->items as $item) {
                 $bits = $item->encodeBitStream($this->version);
                 
-                if($bits < 0) 
-                    return -1;
+                if($bits < 0) {
+                                    return -1;
+                }
                     
                 $total += $bits;
             }
@@ -614,8 +624,9 @@  discard block
 block discarded – undo
             for(;;) {
                 $bits = $this->createBitStream();
                 
-                if($bits < 0) 
-                    return -1;
+                if($bits < 0) {
+                                    return -1;
+                }
                     
                 $ver = QRspec::getMinimumVersion((int)(($bits + 7) / 8), $this->level);
                 if($ver < 0) {
@@ -652,8 +663,9 @@  discard block
 block discarded – undo
             $padding = new QRbitstream();
             $ret = $padding->appendNum($words * 8 - $bits + 4, 0);
             
-            if($ret < 0) 
-                return $ret;
+            if($ret < 0) {
+                            return $ret;
+            }
 
             $padlen = $maxwords - $words;
             
@@ -666,8 +678,9 @@  discard block
 block discarded – undo
                 
                 $ret = $padding->appendBytes($padlen, $padbuf);
                 
-                if($ret < 0)
-                    return $ret;
+                if($ret < 0) {
+                                    return $ret;
+                }
                 
             }
 

Please login to merge, or discard this patch.

lib/phpqrcode/bindings/tcpdf/qrcode.php 3 patches

Indentation +24 added lines, -24 removed lines patch added patch discarded remove patch

@@ -173,29 +173,29 @@  discard block
 block discarded – undo
 	/**
 	 * Maximum matrix size for maximum version (version 40 is 177*177 matrix).
 	 */
-    define('QRSPEC_WIDTH_MAX', 177);
+	define('QRSPEC_WIDTH_MAX', 177);
 
 	// -----------------------------------------------------
 
 	/**
 	 * Matrix index to get width from $capacity array.
 	 */
-    define('QRCAP_WIDTH',    0);
+	define('QRCAP_WIDTH',    0);
 
-    /**
+	/**
 	 * Matrix index to get number of words from $capacity array.
 	 */
-    define('QRCAP_WORDS',    1);
+	define('QRCAP_WORDS',    1);
 
-    /**
+	/**
 	 * Matrix index to get remainder from $capacity array.
 	 */
-    define('QRCAP_REMINDER', 2);
+	define('QRCAP_REMINDER', 2);
 
-    /**
+	/**
 	 * Matrix index to get error correction level from $capacity array.
 	 */
-    define('QRCAP_EC',       3);
+	define('QRCAP_EC',       3);
 
 	// -----------------------------------------------------
 
@@ -204,33 +204,33 @@  discard block
 block discarded – undo
 	/**
 	 * Number of header bits for structured mode
 	 */
-    define('STRUCTURE_HEADER_BITS',  20);
+	define('STRUCTURE_HEADER_BITS',  20);
 
-    /**
+	/**
 	 * Max number of symbols for structured mode
 	 */
-    define('MAX_STRUCTURED_SYMBOLS', 16);
+	define('MAX_STRUCTURED_SYMBOLS', 16);
 
 	// -----------------------------------------------------
 
-    // Masks
+	// Masks
 
-    /**
+	/**
 	 * Down point base value for case 1 mask pattern (concatenation of same color in a line or a column)
 	 */
-    define('N1',  3);
+	define('N1',  3);
 
-    /**
+	/**
 	 * Down point base value for case 2 mask pattern (module block of same color)
 	 */
 	define('N2',  3);
 
-    /**
+	/**
 	 * Down point base value for case 3 mask pattern (1:1:3:1:1(dark:bright:dark:bright:dark)pattern in a line or a column)
 	 */
 	define('N3', 40);
 
-    /**
+	/**
 	 * Down point base value for case 4 mask pattern (ration of dark modules in whole)
 	 */
 	define('N4', 10);
@@ -264,12 +264,12 @@  discard block
 block discarded – undo
 
 	// for compaibility with PHP4
 	if (!function_exists('str_split')) {
-    	/**
-    	 * Convert a string to an array (needed for PHP4 compatibility)
-    	 * @param string $string The input string.
-    	 * @param int $split_length Maximum length of the chunk.
-    	 * @return  If the optional split_length  parameter is specified, the returned array will be broken down into chunks with each being split_length  in length, otherwise each chunk will be one character in length. FALSE is returned if split_length is less than 1. If the split_length length exceeds the length of string , the entire string is returned as the first (and only) array element.
-    	 */
+		/**
+		 * Convert a string to an array (needed for PHP4 compatibility)
+		 * @param string $string The input string.
+		 * @param int $split_length Maximum length of the chunk.
+		 * @return  If the optional split_length  parameter is specified, the returned array will be broken down into chunks with each being split_length  in length, otherwise each chunk will be one character in length. FALSE is returned if split_length is less than 1. If the split_length length exceeds the length of string , the entire string is returned as the first (and only) array element.
+		 */
 		function str_split($string, $split_length=1) {
 			if ((strlen($string) > $split_length) OR (!$split_length)) {
 				do {
@@ -2622,7 +2622,7 @@  discard block
 block discarded – undo
 		}
 
 		/**
-		* Return block number 1
+		 * Return block number 1
 		 * @param array $spec
 		 * @return int value
 		 */

Please login to merge, or discard this patch.

Switch Indentation +128 added lines, -128 removed lines patch added patch discarded remove patch

@@ -1461,26 +1461,26 @@  discard block
 block discarded – undo
 				}
 				$mode = $this->identifyMode(0);
 				switch ($mode) {
-					case QR_MODE_NM: {
-						$length = $this->eatNum();
-						break;
-					}
-					case QR_MODE_AN: {
-						$length = $this->eatAn();
-						break;
-					}
-					case QR_MODE_KJ: {
-						if ($this->hint == QR_MODE_KJ) {
-							$length = $this->eatKanji();
-						} else {
-							$length = $this->eat8();
-						}
-						break;
-					}
-					default: {
+				case QR_MODE_NM: {
+					$length = $this->eatNum();
+					break;
+				}
+				case QR_MODE_AN: {
+					$length = $this->eatAn();
+					break;
+				}
+				case QR_MODE_KJ: {
+					if ($this->hint == QR_MODE_KJ) {
+						$length = $this->eatKanji();
+					} else {
 						$length = $this->eat8();
-						break;
 					}
+					break;
+				}
+				default: {
+					$length = $this->eat8();
+					break;
+				}
 				}
 				if ($length == 0) {
 					return 0;
@@ -1665,29 +1665,29 @@  discard block
 block discarded – undo
 				$inputitem['bstream'] = $this->appendBitstream($inputitem['bstream'], $st2['bstream']);
 			} else {
 				switch($inputitem['mode']) {
-					case QR_MODE_NM: {
-						$inputitem = $this->encodeModeNum($inputitem, $version);
-						break;
-					}
-					case QR_MODE_AN: {
-						$inputitem = $this->encodeModeAn($inputitem, $version);
-						break;
-					}
-					case QR_MODE_8B: {
-						$inputitem = $this->encodeMode8($inputitem, $version);
-						break;
-					}
-					case QR_MODE_KJ: {
-						$inputitem = $this->encodeModeKanji($inputitem, $version);
-						break;
-					}
-					case QR_MODE_ST: {
-						$inputitem = $this->encodeModeStructure($inputitem);
-						break;
-					}
-					default: {
-						break;
-					}
+				case QR_MODE_NM: {
+					$inputitem = $this->encodeModeNum($inputitem, $version);
+					break;
+				}
+				case QR_MODE_AN: {
+					$inputitem = $this->encodeModeAn($inputitem, $version);
+					break;
+				}
+				case QR_MODE_8B: {
+					$inputitem = $this->encodeMode8($inputitem, $version);
+					break;
+				}
+				case QR_MODE_KJ: {
+					$inputitem = $this->encodeModeKanji($inputitem, $version);
+					break;
+				}
+				case QR_MODE_ST: {
+					$inputitem = $this->encodeModeStructure($inputitem);
+					break;
+				}
+				default: {
+					break;
+				}
 				}
 			}
 			return $inputitem;
@@ -1774,17 +1774,17 @@  discard block
 block discarded – undo
 			$w = (int)$size / 3;
 			$bits = $w * 10;
 			switch($size - $w * 3) {
-				case 1: {
-					$bits += 4;
-					break;
-				}
-				case 2: {
-					$bits += 7;
-					break;
-				}
-				default: {
-					break;
-				}
+			case 1: {
+				$bits += 4;
+				break;
+			}
+			case 2: {
+				$bits += 7;
+				break;
+			}
+			default: {
+				break;
+			}
 			}
 			return $bits;
 		}
@@ -1876,24 +1876,24 @@  discard block
 block discarded – undo
 				return false;
 			}
 			switch($mode) {
-				case QR_MODE_NM: {
-					return $this->checkModeNum($size, $data);
-				}
-				case QR_MODE_AN: {
-					return $this->checkModeAn($size, $data);
-				}
-				case QR_MODE_KJ: {
-					return $this->checkModeKanji($size, $data);
-				}
-				case QR_MODE_8B: {
-					return true;
-				}
-				case QR_MODE_ST: {
-					return true;
-				}
-				default: {
-					break;
-				}
+			case QR_MODE_NM: {
+				return $this->checkModeNum($size, $data);
+			}
+			case QR_MODE_AN: {
+				return $this->checkModeAn($size, $data);
+			}
+			case QR_MODE_KJ: {
+				return $this->checkModeKanji($size, $data);
+			}
+			case QR_MODE_8B: {
+				return true;
+			}
+			case QR_MODE_ST: {
+				return true;
+			}
+			default: {
+				break;
+			}
 			}
 			return false;
 		}
@@ -1911,28 +1911,28 @@  discard block
 block discarded – undo
 			}
 			foreach ($items as $item) {
 				switch($item['mode']) {
-					case QR_MODE_NM: {
-						$bits = $this->estimateBitsModeNum($item['size']);
-						break;
-					}
-					case QR_MODE_AN: {
-						$bits = $this->estimateBitsModeAn($item['size']);
-						break;
-					}
-					case QR_MODE_8B: {
-						$bits = $this->estimateBitsMode8($item['size']);
-						break;
-					}
-					case QR_MODE_KJ: {
-						$bits = $this->estimateBitsModeKanji($item['size']);
-						break;
-					}
-					case QR_MODE_ST: {
-						return STRUCTURE_HEADER_BITS;
-					}
-					default: {
-						return 0;
-					}
+				case QR_MODE_NM: {
+					$bits = $this->estimateBitsModeNum($item['size']);
+					break;
+				}
+				case QR_MODE_AN: {
+					$bits = $this->estimateBitsModeAn($item['size']);
+					break;
+				}
+				case QR_MODE_8B: {
+					$bits = $this->estimateBitsMode8($item['size']);
+					break;
+				}
+				case QR_MODE_KJ: {
+					$bits = $this->estimateBitsModeKanji($item['size']);
+					break;
+				}
+				case QR_MODE_ST: {
+					return STRUCTURE_HEADER_BITS;
+				}
+				default: {
+					return 0;
+				}
 				}
 				$l = $this->lengthIndicator($item['mode'], $version);
 				$m = 1 << $l;
@@ -1971,42 +1971,42 @@  discard block
 block discarded – undo
 		 protected function lengthOfCode($mode, $version, $bits) {
 			$payload = $bits - 4 - $this->lengthIndicator($mode, $version);
 			switch($mode) {
-				case QR_MODE_NM: {
-					$chunks = (int)($payload / 10);
-					$remain = $payload - $chunks * 10;
-					$size = $chunks * 3;
-					if ($remain >= 7) {
-						$size += 2;
-					} elseif ($remain >= 4) {
-						$size += 1;
-					}
-					break;
-				}
-				case QR_MODE_AN: {
-					$chunks = (int)($payload / 11);
-					$remain = $payload - $chunks * 11;
-					$size = $chunks * 2;
-					if ($remain >= 6) {
-						++$size;
-					}
-					break;
-				}
-				case QR_MODE_8B: {
-					$size = (int)($payload / 8);
-					break;
-				}
-				case QR_MODE_KJ: {
-					$size = (int)(($payload / 13) * 2);
-					break;
-				}
-				case QR_MODE_ST: {
-					$size = (int)($payload / 8);
-					break;
-				}
-				default: {
-					$size = 0;
-					break;
-				}
+			case QR_MODE_NM: {
+				$chunks = (int)($payload / 10);
+				$remain = $payload - $chunks * 10;
+				$size = $chunks * 3;
+				if ($remain >= 7) {
+					$size += 2;
+				} elseif ($remain >= 4) {
+					$size += 1;
+				}
+				break;
+			}
+			case QR_MODE_AN: {
+				$chunks = (int)($payload / 11);
+				$remain = $payload - $chunks * 11;
+				$size = $chunks * 2;
+				if ($remain >= 6) {
+					++$size;
+				}
+				break;
+			}
+			case QR_MODE_8B: {
+				$size = (int)($payload / 8);
+				break;
+			}
+			case QR_MODE_KJ: {
+				$size = (int)(($payload / 13) * 2);
+				break;
+			}
+			case QR_MODE_ST: {
+				$size = (int)($payload / 8);
+				break;
+			}
+			default: {
+				$size = 0;
+				break;
+			}
 			}
 			$maxsize = $this->maximumWords($mode, $version);
 			if ($size < 0) {

Please login to merge, or discard this patch.

Spacing +262 added lines, -262 removed lines patch added patch discarded remove patch

@@ -180,12 +180,12 @@  discard block
 block discarded – undo
 	/**
 	 * Matrix index to get width from $capacity array.
 	 */
-    define('QRCAP_WIDTH',    0);
+    define('QRCAP_WIDTH', 0);
 
     /**
 	 * Matrix index to get number of words from $capacity array.
 	 */
-    define('QRCAP_WORDS',    1);
+    define('QRCAP_WORDS', 1);
 
     /**
 	 * Matrix index to get remainder from $capacity array.
@@ -195,7 +195,7 @@  discard block
 block discarded – undo
     /**
 	 * Matrix index to get error correction level from $capacity array.
 	 */
-    define('QRCAP_EC',       3);
+    define('QRCAP_EC', 3);
 
 	// -----------------------------------------------------
 
@@ -204,7 +204,7 @@  discard block
 block discarded – undo
 	/**
 	 * Number of header bits for structured mode
 	 */
-    define('STRUCTURE_HEADER_BITS',  20);
+    define('STRUCTURE_HEADER_BITS', 20);
 
     /**
 	 * Max number of symbols for structured mode
@@ -218,12 +218,12 @@  discard block
 block discarded – undo
     /**
 	 * Down point base value for case 1 mask pattern (concatenation of same color in a line or a column)
 	 */
-    define('N1',  3);
+    define('N1', 3);
 
     /**
 	 * Down point base value for case 2 mask pattern (module block of same color)
 	 */
-	define('N2',  3);
+	define('N2', 3);
 
     /**
 	 * Down point base value for case 3 mask pattern (1:1:3:1:1(dark:bright:dark:bright:dark)pattern in a line or a column)
@@ -270,7 +270,7 @@  discard block
 block discarded – undo
     	 * @param int $split_length Maximum length of the chunk.
     	 * @return  If the optional split_length  parameter is specified, the returned array will be broken down into chunks with each being split_length  in length, otherwise each chunk will be one character in length. FALSE is returned if split_length is less than 1. If the split_length length exceeds the length of string , the entire string is returned as the first (and only) array element.
     	 */
-		function str_split($string, $split_length=1) {
+		function str_split($string, $split_length = 1) {
 			if ((strlen($string) > $split_length) OR (!$split_length)) {
 				do {
 					$c = strlen($string);
@@ -481,7 +481,7 @@  discard block
 block discarded – undo
 			-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, //
 			-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, //
 			36, -1, -1, -1, 37, 38, -1, -1, -1, -1, 39, 40, -1, 41, 42, 43, //
-			 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 44, -1, -1, -1, -1, -1, //
+			 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 44, -1, -1, -1, -1, -1, //
 			-1, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, //
 			25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, -1, -1, -1, -1, -1, //
 			-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, //
@@ -494,47 +494,47 @@  discard block
 block discarded – undo
 		 * @access protected
 		 */
 		protected $capacity = array(
-			array(  0,    0, 0, array(   0,    0,    0,    0)), //
-			array( 21,   26, 0, array(   7,   10,   13,   17)), //  1
-			array( 25,   44, 7, array(  10,   16,   22,   28)), //
-			array( 29,   70, 7, array(  15,   26,   36,   44)), //
-			array( 33,  100, 7, array(  20,   36,   52,   64)), //
-			array( 37,  134, 7, array(  26,   48,   72,   88)), //  5
-			array( 41,  172, 7, array(  36,   64,   96,  112)), //
-			array( 45,  196, 0, array(  40,   72,  108,  130)), //
-			array( 49,  242, 0, array(  48,   88,  132,  156)), //
-			array( 53,  292, 0, array(  60,  110,  160,  192)), //
-			array( 57,  346, 0, array(  72,  130,  192,  224)), // 10
-			array( 61,  404, 0, array(  80,  150,  224,  264)), //
-			array( 65,  466, 0, array(  96,  176,  260,  308)), //
-			array( 69,  532, 0, array( 104,  198,  288,  352)), //
-			array( 73,  581, 3, array( 120,  216,  320,  384)), //
-			array( 77,  655, 3, array( 132,  240,  360,  432)), // 15
-			array( 81,  733, 3, array( 144,  280,  408,  480)), //
-			array( 85,  815, 3, array( 168,  308,  448,  532)), //
-			array( 89,  901, 3, array( 180,  338,  504,  588)), //
-			array( 93,  991, 3, array( 196,  364,  546,  650)), //
-			array( 97, 1085, 3, array( 224,  416,  600,  700)), // 20
-			array(101, 1156, 4, array( 224,  442,  644,  750)), //
-			array(105, 1258, 4, array( 252,  476,  690,  816)), //
-			array(109, 1364, 4, array( 270,  504,  750,  900)), //
-			array(113, 1474, 4, array( 300,  560,  810,  960)), //
-			array(117, 1588, 4, array( 312,  588,  870, 1050)), // 25
-			array(121, 1706, 4, array( 336,  644,  952, 1110)), //
-			array(125, 1828, 4, array( 360,  700, 1020, 1200)), //
-			array(129, 1921, 3, array( 390,  728, 1050, 1260)), //
-			array(133, 2051, 3, array( 420,  784, 1140, 1350)), //
-			array(137, 2185, 3, array( 450,  812, 1200, 1440)), // 30
-			array(141, 2323, 3, array( 480,  868, 1290, 1530)), //
-			array(145, 2465, 3, array( 510,  924, 1350, 1620)), //
-			array(149, 2611, 3, array( 540,  980, 1440, 1710)), //
-			array(153, 2761, 3, array( 570, 1036, 1530, 1800)), //
-			array(157, 2876, 0, array( 570, 1064, 1590, 1890)), // 35
-			array(161, 3034, 0, array( 600, 1120, 1680, 1980)), //
-			array(165, 3196, 0, array( 630, 1204, 1770, 2100)), //
-			array(169, 3362, 0, array( 660, 1260, 1860, 2220)), //
-			array(173, 3532, 0, array( 720, 1316, 1950, 2310)), //
-			array(177, 3706, 0, array( 750, 1372, 2040, 2430))  // 40
+			array(0, 0, 0, array(0, 0, 0, 0)), //
+			array(21, 26, 0, array(7, 10, 13, 17)), //  1
+			array(25, 44, 7, array(10, 16, 22, 28)), //
+			array(29, 70, 7, array(15, 26, 36, 44)), //
+			array(33, 100, 7, array(20, 36, 52, 64)), //
+			array(37, 134, 7, array(26, 48, 72, 88)), //  5
+			array(41, 172, 7, array(36, 64, 96, 112)), //
+			array(45, 196, 0, array(40, 72, 108, 130)), //
+			array(49, 242, 0, array(48, 88, 132, 156)), //
+			array(53, 292, 0, array(60, 110, 160, 192)), //
+			array(57, 346, 0, array(72, 130, 192, 224)), // 10
+			array(61, 404, 0, array(80, 150, 224, 264)), //
+			array(65, 466, 0, array(96, 176, 260, 308)), //
+			array(69, 532, 0, array(104, 198, 288, 352)), //
+			array(73, 581, 3, array(120, 216, 320, 384)), //
+			array(77, 655, 3, array(132, 240, 360, 432)), // 15
+			array(81, 733, 3, array(144, 280, 408, 480)), //
+			array(85, 815, 3, array(168, 308, 448, 532)), //
+			array(89, 901, 3, array(180, 338, 504, 588)), //
+			array(93, 991, 3, array(196, 364, 546, 650)), //
+			array(97, 1085, 3, array(224, 416, 600, 700)), // 20
+			array(101, 1156, 4, array(224, 442, 644, 750)), //
+			array(105, 1258, 4, array(252, 476, 690, 816)), //
+			array(109, 1364, 4, array(270, 504, 750, 900)), //
+			array(113, 1474, 4, array(300, 560, 810, 960)), //
+			array(117, 1588, 4, array(312, 588, 870, 1050)), // 25
+			array(121, 1706, 4, array(336, 644, 952, 1110)), //
+			array(125, 1828, 4, array(360, 700, 1020, 1200)), //
+			array(129, 1921, 3, array(390, 728, 1050, 1260)), //
+			array(133, 2051, 3, array(420, 784, 1140, 1350)), //
+			array(137, 2185, 3, array(450, 812, 1200, 1440)), // 30
+			array(141, 2323, 3, array(480, 868, 1290, 1530)), //
+			array(145, 2465, 3, array(510, 924, 1350, 1620)), //
+			array(149, 2611, 3, array(540, 980, 1440, 1710)), //
+			array(153, 2761, 3, array(570, 1036, 1530, 1800)), //
+			array(157, 2876, 0, array(570, 1064, 1590, 1890)), // 35
+			array(161, 3034, 0, array(600, 1120, 1680, 1980)), //
+			array(165, 3196, 0, array(630, 1204, 1770, 2100)), //
+			array(169, 3362, 0, array(660, 1260, 1860, 2220)), //
+			array(173, 3532, 0, array(720, 1316, 1950, 2310)), //
+			array(177, 3706, 0, array(750, 1372, 2040, 2430))  // 40
 		);
 
 		/**
@@ -543,9 +543,9 @@  discard block
 block discarded – undo
 		 */
 		protected $lengthTableBits = array(
 			array(10, 12, 14),
-			array( 9, 11, 13),
-			array( 8, 16, 16),
-			array( 8, 10, 12)
+			array(9, 11, 13),
+			array(8, 16, 16),
+			array(8, 10, 12)
 		);
 
 		/**
@@ -554,47 +554,47 @@  discard block
 block discarded – undo
 		 * @access protected
 		 */
 		protected $eccTable = array(
-			array(array( 0,  0), array( 0,  0), array( 0,  0), array( 0,  0)), //
-			array(array( 1,  0), array( 1,  0), array( 1,  0), array( 1,  0)), //  1
-			array(array( 1,  0), array( 1,  0), array( 1,  0), array( 1,  0)), //
-			array(array( 1,  0), array( 1,  0), array( 2,  0), array( 2,  0)), //
-			array(array( 1,  0), array( 2,  0), array( 2,  0), array( 4,  0)), //
-			array(array( 1,  0), array( 2,  0), array( 2,  2), array( 2,  2)), //  5
-			array(array( 2,  0), array( 4,  0), array( 4,  0), array( 4,  0)), //
-			array(array( 2,  0), array( 4,  0), array( 2,  4), array( 4,  1)), //
-			array(array( 2,  0), array( 2,  2), array( 4,  2), array( 4,  2)), //
-			array(array( 2,  0), array( 3,  2), array( 4,  4), array( 4,  4)), //
-			array(array( 2,  2), array( 4,  1), array( 6,  2), array( 6,  2)), // 10
-			array(array( 4,  0), array( 1,  4), array( 4,  4), array( 3,  8)), //
-			array(array( 2,  2), array( 6,  2), array( 4,  6), array( 7,  4)), //
-			array(array( 4,  0), array( 8,  1), array( 8,  4), array(12,  4)), //
-			array(array( 3,  1), array( 4,  5), array(11,  5), array(11,  5)), //
-			array(array( 5,  1), array( 5,  5), array( 5,  7), array(11,  7)), // 15
-			array(array( 5,  1), array( 7,  3), array(15,  2), array( 3, 13)), //
-			array(array( 1,  5), array(10,  1), array( 1, 15), array( 2, 17)), //
-			array(array( 5,  1), array( 9,  4), array(17,  1), array( 2, 19)), //
-			array(array( 3,  4), array( 3, 11), array(17,  4), array( 9, 16)), //
-			array(array( 3,  5), array( 3, 13), array(15,  5), array(15, 10)), // 20
-			array(array( 4,  4), array(17,  0), array(17,  6), array(19,  6)), //
-			array(array( 2,  7), array(17,  0), array( 7, 16), array(34,  0)), //
-			array(array( 4,  5), array( 4, 14), array(11, 14), array(16, 14)), //
-			array(array( 6,  4), array( 6, 14), array(11, 16), array(30,  2)), //
-			array(array( 8,  4), array( 8, 13), array( 7, 22), array(22, 13)), // 25
-			array(array(10,  2), array(19,  4), array(28,  6), array(33,  4)), //
-			array(array( 8,  4), array(22,  3), array( 8, 26), array(12, 28)), //
-			array(array( 3, 10), array( 3, 23), array( 4, 31), array(11, 31)), //
-			array(array( 7,  7), array(21,  7), array( 1, 37), array(19, 26)), //
-			array(array( 5, 10), array(19, 10), array(15, 25), array(23, 25)), // 30
-			array(array(13,  3), array( 2, 29), array(42,  1), array(23, 28)), //
-			array(array(17,  0), array(10, 23), array(10, 35), array(19, 35)), //
-			array(array(17,  1), array(14, 21), array(29, 19), array(11, 46)), //
-			array(array(13,  6), array(14, 23), array(44,  7), array(59,  1)), //
-			array(array(12,  7), array(12, 26), array(39, 14), array(22, 41)), // 35
-			array(array( 6, 14), array( 6, 34), array(46, 10), array( 2, 64)), //
-			array(array(17,  4), array(29, 14), array(49, 10), array(24, 46)), //
-			array(array( 4, 18), array(13, 32), array(48, 14), array(42, 32)), //
-			array(array(20,  4), array(40,  7), array(43, 22), array(10, 67)), //
-			array(array(19,  6), array(18, 31), array(34, 34), array(20, 61))  // 40
+			array(array(0, 0), array(0, 0), array(0, 0), array(0, 0)), //
+			array(array(1, 0), array(1, 0), array(1, 0), array(1, 0)), //  1
+			array(array(1, 0), array(1, 0), array(1, 0), array(1, 0)), //
+			array(array(1, 0), array(1, 0), array(2, 0), array(2, 0)), //
+			array(array(1, 0), array(2, 0), array(2, 0), array(4, 0)), //
+			array(array(1, 0), array(2, 0), array(2, 2), array(2, 2)), //  5
+			array(array(2, 0), array(4, 0), array(4, 0), array(4, 0)), //
+			array(array(2, 0), array(4, 0), array(2, 4), array(4, 1)), //
+			array(array(2, 0), array(2, 2), array(4, 2), array(4, 2)), //
+			array(array(2, 0), array(3, 2), array(4, 4), array(4, 4)), //
+			array(array(2, 2), array(4, 1), array(6, 2), array(6, 2)), // 10
+			array(array(4, 0), array(1, 4), array(4, 4), array(3, 8)), //
+			array(array(2, 2), array(6, 2), array(4, 6), array(7, 4)), //
+			array(array(4, 0), array(8, 1), array(8, 4), array(12, 4)), //
+			array(array(3, 1), array(4, 5), array(11, 5), array(11, 5)), //
+			array(array(5, 1), array(5, 5), array(5, 7), array(11, 7)), // 15
+			array(array(5, 1), array(7, 3), array(15, 2), array(3, 13)), //
+			array(array(1, 5), array(10, 1), array(1, 15), array(2, 17)), //
+			array(array(5, 1), array(9, 4), array(17, 1), array(2, 19)), //
+			array(array(3, 4), array(3, 11), array(17, 4), array(9, 16)), //
+			array(array(3, 5), array(3, 13), array(15, 5), array(15, 10)), // 20
+			array(array(4, 4), array(17, 0), array(17, 6), array(19, 6)), //
+			array(array(2, 7), array(17, 0), array(7, 16), array(34, 0)), //
+			array(array(4, 5), array(4, 14), array(11, 14), array(16, 14)), //
+			array(array(6, 4), array(6, 14), array(11, 16), array(30, 2)), //
+			array(array(8, 4), array(8, 13), array(7, 22), array(22, 13)), // 25
+			array(array(10, 2), array(19, 4), array(28, 6), array(33, 4)), //
+			array(array(8, 4), array(22, 3), array(8, 26), array(12, 28)), //
+			array(array(3, 10), array(3, 23), array(4, 31), array(11, 31)), //
+			array(array(7, 7), array(21, 7), array(1, 37), array(19, 26)), //
+			array(array(5, 10), array(19, 10), array(15, 25), array(23, 25)), // 30
+			array(array(13, 3), array(2, 29), array(42, 1), array(23, 28)), //
+			array(array(17, 0), array(10, 23), array(10, 35), array(19, 35)), //
+			array(array(17, 1), array(14, 21), array(29, 19), array(11, 46)), //
+			array(array(13, 6), array(14, 23), array(44, 7), array(59, 1)), //
+			array(array(12, 7), array(12, 26), array(39, 14), array(22, 41)), // 35
+			array(array(6, 14), array(6, 34), array(46, 10), array(2, 64)), //
+			array(array(17, 4), array(29, 14), array(49, 10), array(24, 46)), //
+			array(array(4, 18), array(13, 32), array(48, 14), array(42, 32)), //
+			array(array(20, 4), array(40, 7), array(43, 22), array(10, 67)), //
+			array(array(19, 6), array(18, 31), array(34, 34), array(20, 61))  // 40
 		);
 
 		/**
@@ -604,9 +604,9 @@  discard block
 block discarded – undo
 		 * @access protected
 		 */
 		protected $alignmentPattern = array(
-			array( 0,  0),
-			array( 0,  0), array(18,  0), array(22,  0), array(26,  0), array(30,  0), //  1- 5
-			array(34,  0), array(22, 38), array(24, 42), array(26, 46), array(28, 50), //  6-10
+			array(0, 0),
+			array(0, 0), array(18, 0), array(22, 0), array(26, 0), array(30, 0), //  1- 5
+			array(34, 0), array(22, 38), array(24, 42), array(26, 46), array(28, 50), //  6-10
 			array(30, 54), array(32, 58), array(34, 62), array(26, 46), array(26, 48), // 11-15
 			array(26, 50), array(30, 54), array(30, 56), array(30, 58), array(34, 62), // 16-20
 			array(28, 50), array(26, 50), array(30, 54), array(28, 54), array(32, 58), // 21-25
@@ -679,7 +679,7 @@  discard block
 block discarded – undo
 			foreach ($qrTab as $line) {
 				$arrAdd = array();
 				foreach (str_split($line) as $char) {
-					$arrAdd[] = ($char=='1')?1:0;
+					$arrAdd[] = ($char == '1') ? 1 : 0;
 				}
 				$barcode_array['bcode'][] = $arrAdd;
 			}
@@ -704,8 +704,8 @@  discard block
 block discarded – undo
 			$len = count($frame);
 			// the frame is square (width = height)
 			foreach ($frame as &$frameLine) {
-				for ($i=0; $i<$len; $i++) {
-					$frameLine[$i] = (ord($frameLine[$i])&1)?'1':'0';
+				for ($i = 0; $i < $len; $i++) {
+					$frameLine[$i] = (ord($frameLine[$i]) & 1) ? '1' : '0';
 				}
 			}
 			return $frame;
@@ -755,10 +755,10 @@  discard block
 block discarded – undo
 			$this->dir = -1;
 			$this->bit = -1;
 			// inteleaved data and ecc codes
-			for ($i=0; $i < ($this->dataLength + $this->eccLength); $i++) {
+			for ($i = 0; $i < ($this->dataLength + $this->eccLength); $i++) {
 				$code = $this->getCode();
 				$bit = 0x80;
-				for ($j=0; $j<8; $j++) {
+				for ($j = 0; $j < 8; $j++) {
 					$addr = $this->getNextPosition();
 					$this->setFrameAt($addr, 0x02 | (($bit & $code) != 0));
 					$bit = $bit >> 1;
@@ -766,7 +766,7 @@  discard block
 block discarded – undo
 			}
 			// remainder bits
 			$j = $this->getRemainder($this->version);
-			for ($i=0; $i<$j; $i++) {
+			for ($i = 0; $i < $j; $i++) {
 				$addr = $this->getNextPosition();
 				$this->setFrameAt($addr, 0x02);
 			}
@@ -856,7 +856,7 @@  discard block
 block discarded – undo
 				}
 				$this->x = $x;
 				$this->y = $y;
-			} while(ord($this->frame[$y][$x]) & 0x80);
+			} while (ord($this->frame[$y][$x]) & 0x80);
 			return array('x'=>$x, 'y'=>$y);
 		}
 
@@ -877,7 +877,7 @@  discard block
 block discarded – undo
 			$dataPos = 0;
 			$eccPos = 0;
 			$endfor = $this->rsBlockNum1($spec);
-			for ($i=0; $i < $endfor; ++$i) {
+			for ($i = 0; $i < $endfor; ++$i) {
 				$ecc = array_slice($this->ecccode, $eccPos);
 				$this->rsblocks[$blockNo] = array();
 				$this->rsblocks[$blockNo]['dataLength'] = $dl;
@@ -885,7 +885,7 @@  discard block
 block discarded – undo
 				$this->rsblocks[$blockNo]['eccLength'] = $el;
 				$ecc = $this->encode_rs_char($rs, $this->rsblocks[$blockNo]['data'], $ecc);
 				$this->rsblocks[$blockNo]['ecc'] = $ecc;
-				$this->ecccode = array_merge(array_slice($this->ecccode,0, $eccPos), $ecc);
+				$this->ecccode = array_merge(array_slice($this->ecccode, 0, $eccPos), $ecc);
 				$dataPos += $dl;
 				$eccPos += $el;
 				$blockNo++;
@@ -900,7 +900,7 @@  discard block
 block discarded – undo
 				return -1;
 			}
 			$endfor = $this->rsBlockNum2($spec);
-			for ($i=0; $i < $endfor; ++$i) {
+			for ($i = 0; $i < $endfor; ++$i) {
 				$ecc = array_slice($this->ecccode, $eccPos);
 				$this->rsblocks[$blockNo] = array();
 				$this->rsblocks[$blockNo]['dataLength'] = $dl;
@@ -953,8 +953,8 @@  discard block
 block discarded – undo
 		 */
 		 protected function writeFormatInformation($width, &$frame, $mask, $level) {
 			$blacks = 0;
-			$format =  $this->getFormatInfo($mask, $level);
-			for ($i=0; $i<8; ++$i) {
+			$format = $this->getFormatInfo($mask, $level);
+			for ($i = 0; $i < 8; ++$i) {
 				if ($format & 1) {
 					$blacks += 2;
 					$v = 0x85;
@@ -969,7 +969,7 @@  discard block
 block discarded – undo
 				}
 				$format = $format >> 1;
 			}
-			for ($i=0; $i<7; ++$i) {
+			for ($i = 0; $i < 7; ++$i) {
 			if ($format & 1) {
 				$blacks += 2;
 				$v = 0x85;
@@ -1034,7 +1034,7 @@  discard block
 block discarded – undo
 		 * @return int mask
 		 */
 		 protected function mask4($x, $y) {
-			return (((int)($y / 2)) + ((int)($x / 3))) & 1;
+			return (((int) ($y / 2)) + ((int) ($x / 3))) & 1;
 		}
 
 		/**
@@ -1076,13 +1076,13 @@  discard block
 block discarded – undo
 		 */
 		protected function generateMaskNo($maskNo, $width, $frame) {
 			$bitMask = array_fill(0, $width, array_fill(0, $width, 0));
-			for ($y=0; $y<$width; ++$y) {
-				for ($x=0; $x<$width; ++$x) {
+			for ($y = 0; $y < $width; ++$y) {
+				for ($x = 0; $x < $width; ++$x) {
 					if (ord($frame[$y][$x]) & 0x80) {
 						$bitMask[$y][$x] = 0;
 					} else {
 						$maskFunc = call_user_func(array($this, 'mask'.$maskNo), $x, $y);
-						$bitMask[$y][$x] = ($maskFunc == 0)?1:0;
+						$bitMask[$y][$x] = ($maskFunc == 0) ? 1 : 0;
 					}
 				}
 			}
@@ -1098,7 +1098,7 @@  discard block
 block discarded – undo
 		 * @param boolean $maskGenOnly
 		 * @return int b
 		 */
-		 protected function makeMaskNo($maskNo, $width, $s, &$d, $maskGenOnly=false) {
+		 protected function makeMaskNo($maskNo, $width, $s, &$d, $maskGenOnly = false) {
 			$b = 0;
 			$bitMask = array();
 			$bitMask = $this->generateMaskNo($maskNo, $width, $s);
@@ -1106,12 +1106,12 @@  discard block
 block discarded – undo
 				return;
 			}
 			$d = $s;
-			for ($y=0; $y<$width; ++$y) {
-				for ($x=0; $x<$width; ++$x) {
+			for ($y = 0; $y < $width; ++$y) {
+				for ($x = 0; $x < $width; ++$x) {
 					if ($bitMask[$y][$x] == 1) {
-						$d[$y][$x] = chr(ord($s[$y][$x]) ^ (int)$bitMask[$y][$x]);
+						$d[$y][$x] = chr(ord($s[$y][$x]) ^ (int) $bitMask[$y][$x]);
 					}
-					$b += (int)(ord($d[$y][$x]) & 1);
+					$b += (int) (ord($d[$y][$x]) & 1);
 				}
 			}
 			return $b;
@@ -1139,20 +1139,20 @@  discard block
 block discarded – undo
 		 */
 		 protected function calcN1N3($length) {
 			$demerit = 0;
-			for ($i=0; $i<$length; ++$i) {
+			for ($i = 0; $i < $length; ++$i) {
 				if ($this->runLength[$i] >= 5) {
 					$demerit += (N1 + ($this->runLength[$i] - 5));
 				}
 				if ($i & 1) {
-					if (($i >= 3) AND ($i < ($length-2)) AND ($this->runLength[$i] % 3 == 0)) {
-						$fact = (int)($this->runLength[$i] / 3);
-						if (($this->runLength[$i-2] == $fact)
-							AND ($this->runLength[$i-1] == $fact)
-							AND ($this->runLength[$i+1] == $fact)
-							AND ($this->runLength[$i+2] == $fact)) {
-							if (($this->runLength[$i-3] < 0) OR ($this->runLength[$i-3] >= (4 * $fact))) {
+					if (($i >= 3) AND ($i < ($length - 2)) AND ($this->runLength[$i] % 3 == 0)) {
+						$fact = (int) ($this->runLength[$i] / 3);
+						if (($this->runLength[$i - 2] == $fact)
+							AND ($this->runLength[$i - 1] == $fact)
+							AND ($this->runLength[$i + 1] == $fact)
+							AND ($this->runLength[$i + 2] == $fact)) {
+							if (($this->runLength[$i - 3] < 0) OR ($this->runLength[$i - 3] >= (4 * $fact))) {
 								$demerit += N3;
-							} elseif ((($i+3) >= $length) OR ($this->runLength[$i+3] >= (4 * $fact))) {
+							} elseif ((($i + 3) >= $length) OR ($this->runLength[$i + 3] >= (4 * $fact))) {
 								$demerit += N3;
 							}
 						}
@@ -1171,17 +1171,17 @@  discard block
 block discarded – undo
 		 protected function evaluateSymbol($width, $frame) {
 			$head = 0;
 			$demerit = 0;
-			for ($y=0; $y<$width; ++$y) {
+			for ($y = 0; $y < $width; ++$y) {
 				$head = 0;
 				$this->runLength[0] = 1;
 				$frameY = $frame[$y];
 				if ($y > 0) {
-					$frameYM = $frame[$y-1];
+					$frameYM = $frame[$y - 1];
 				}
-				for ($x=0; $x<$width; ++$x) {
+				for ($x = 0; $x < $width; ++$x) {
 					if (($x > 0) AND ($y > 0)) {
-						$b22 = ord($frameY[$x]) & ord($frameY[$x-1]) & ord($frameYM[$x]) & ord($frameYM[$x-1]);
-						$w22 = ord($frameY[$x]) | ord($frameY[$x-1]) | ord($frameYM[$x]) | ord($frameYM[$x-1]);
+						$b22 = ord($frameY[$x]) & ord($frameY[$x - 1]) & ord($frameYM[$x]) & ord($frameYM[$x - 1]);
+						$w22 = ord($frameY[$x]) | ord($frameY[$x - 1]) | ord($frameYM[$x]) | ord($frameYM[$x - 1]);
 						if (($b22 | ($w22 ^ 1)) & 1) {
 							$demerit += N2;
 						}
@@ -1191,7 +1191,7 @@  discard block
 block discarded – undo
 						$head = 1;
 						$this->runLength[$head] = 1;
 					} elseif ($x > 0) {
-						if ((ord($frameY[$x]) ^ ord($frameY[$x-1])) & 1) {
+						if ((ord($frameY[$x]) ^ ord($frameY[$x - 1])) & 1) {
 							$head++;
 							$this->runLength[$head] = 1;
 						} else {
@@ -1199,18 +1199,18 @@  discard block
 block discarded – undo
 						}
 					}
 				}
-				$demerit += $this->calcN1N3($head+1);
+				$demerit += $this->calcN1N3($head + 1);
 			}
-			for ($x=0; $x<$width; ++$x) {
+			for ($x = 0; $x < $width; ++$x) {
 				$head = 0;
 				$this->runLength[0] = 1;
-				for ($y=0; $y<$width; ++$y) {
+				for ($y = 0; $y < $width; ++$y) {
 					if (($y == 0) AND (ord($frame[$y][$x]) & 1)) {
 						$this->runLength[0] = -1;
 						$head = 1;
 						$this->runLength[$head] = 1;
 					} elseif ($y > 0) {
-						if ((ord($frame[$y][$x]) ^ ord($frame[$y-1][$x])) & 1) {
+						if ((ord($frame[$y][$x]) ^ ord($frame[$y - 1][$x])) & 1) {
 							$head++;
 							$this->runLength[$head] = 1;
 						} else {
@@ -1218,7 +1218,7 @@  discard block
 block discarded – undo
 						}
 					}
 				}
-				$demerit += $this->calcN1N3($head+1);
+				$demerit += $this->calcN1N3($head + 1);
 			}
 			return $demerit;
 		}
@@ -1237,8 +1237,8 @@  discard block
 block discarded – undo
 			$checked_masks = array(0, 1, 2, 3, 4, 5, 6, 7);
 			if (QR_FIND_FROM_RANDOM !== false) {
 				$howManuOut = 8 - (QR_FIND_FROM_RANDOM % 9);
-				for ($i = 0; $i <  $howManuOut; ++$i) {
-					$remPos = rand (0, count($checked_masks)-1);
+				for ($i = 0; $i < $howManuOut; ++$i) {
+					$remPos = rand(0, count($checked_masks) - 1);
 					unset($checked_masks[$remPos]);
 					$checked_masks = array_values($checked_masks);
 				}
@@ -1250,8 +1250,8 @@  discard block
 block discarded – undo
 				$blacks = 0;
 				$blacks  = $this->makeMaskNo($i, $width, $frame, $mask);
 				$blacks += $this->writeFormatInformation($width, $mask, $i, $level);
-				$blacks  = (int)(100 * $blacks / ($width * $width));
-				$demerit = (int)((int)(abs($blacks - 50) / 5) * N4);
+				$blacks  = (int) (100 * $blacks / ($width * $width));
+				$demerit = (int) ((int) (abs($blacks - 50) / 5) * N4);
 				$demerit += $this->evaluateSymbol($width, $mask);
 				if ($demerit < $minDemerit) {
 					$minDemerit = $demerit;
@@ -1276,7 +1276,7 @@  discard block
 block discarded – undo
 			if ($pos >= strlen($str)) {
 				return false;
 			}
-			return ((ord($str[$pos]) >= ord('0'))&&(ord($str[$pos]) <= ord('9')));
+			return ((ord($str[$pos]) >= ord('0')) && (ord($str[$pos]) <= ord('9')));
 		}
 
 		/**
@@ -1307,8 +1307,8 @@  discard block
 block discarded – undo
 			} elseif ($this->isalnumat($this->dataStr, $pos)) {
 				return QR_MODE_AN;
 			} elseif ($this->hint == QR_MODE_KJ) {
-				if ($pos+1 < strlen($this->dataStr)) {
-					$d = $this->dataStr[$pos+1];
+				if ($pos + 1 < strlen($this->dataStr)) {
+					$d = $this->dataStr[$pos + 1];
 					$word = (ord($c) << 8) | ord($d);
 					if (($word >= 0x8140 && $word <= 0x9ffc) OR ($word >= 0xe040 && $word <= 0xebbf)) {
 						return QR_MODE_KJ;
@@ -1325,7 +1325,7 @@  discard block
 block discarded – undo
 		 protected function eatNum() {
 			$ln = $this->lengthIndicator(QR_MODE_NM, $this->version);
 			$p = 0;
-			while($this->isdigitat($this->dataStr, $p)) {
+			while ($this->isdigitat($this->dataStr, $p)) {
 				$p++;
 			}
 			$run = $p;
@@ -1341,7 +1341,7 @@  discard block
 block discarded – undo
 			if ($mode == QR_MODE_AN) {
 				$dif = $this->estimateBitsModeNum($run) + 4 + $ln
 				+ $this->estimateBitsModeAn(1)        // + 4 + la
-				- $this->estimateBitsModeAn($run + 1);// - 4 - la
+				- $this->estimateBitsModeAn($run + 1); // - 4 - la
 				if ($dif > 0) {
 					return $this->eatAn();
 				}
@@ -1355,13 +1355,13 @@  discard block
 block discarded – undo
 		 * @return int run
 		 */
 		 protected function eatAn() {
-			$la = $this->lengthIndicator(QR_MODE_AN,  $this->version);
+			$la = $this->lengthIndicator(QR_MODE_AN, $this->version);
 			$ln = $this->lengthIndicator(QR_MODE_NM, $this->version);
 			$p = 0;
-			while($this->isalnumat($this->dataStr, $p)) {
+			while ($this->isalnumat($this->dataStr, $p)) {
 				if ($this->isdigitat($this->dataStr, $p)) {
 					$q = $p;
-					while($this->isdigitat($this->dataStr, $q)) {
+					while ($this->isdigitat($this->dataStr, $q)) {
 						$q++;
 					}
 					$dif = $this->estimateBitsModeAn($p) // + 4 + la
@@ -1395,7 +1395,7 @@  discard block
 block discarded – undo
 		 */
 		 protected function eatKanji() {
 			$p = 0;
-			while($this->identifyMode($p) == QR_MODE_KJ) {
+			while ($this->identifyMode($p) == QR_MODE_KJ) {
 				$p += 2;
 			}
 			$this->items = $this->appendNewInputItem($this->items, QR_MODE_KJ, $p, str_split($this->dataStr));
@@ -1411,14 +1411,14 @@  discard block
 block discarded – undo
 			$ln = $this->lengthIndicator(QR_MODE_NM, $this->version);
 			$p = 1;
 			$dataStrLen = strlen($this->dataStr);
-			while($p < $dataStrLen) {
+			while ($p < $dataStrLen) {
 				$mode = $this->identifyMode($p);
 				if ($mode == QR_MODE_KJ) {
 					break;
 				}
 				if ($mode == QR_MODE_NM) {
 					$q = $p;
-					while($this->isdigitat($this->dataStr, $q)) {
+					while ($this->isdigitat($this->dataStr, $q)) {
 						$q++;
 					}
 					$dif = $this->estimateBitsMode8($p) // + 4 + l8
@@ -1431,7 +1431,7 @@  discard block
 block discarded – undo
 					}
 				} elseif ($mode == QR_MODE_AN) {
 					$q = $p;
-					while($this->isalnumat($this->dataStr, $q)) {
+					while ($this->isalnumat($this->dataStr, $q)) {
 						$q++;
 					}
 					$dif = $this->estimateBitsMode8($p)  // + 4 + l8
@@ -1524,7 +1524,7 @@  discard block
 block discarded – undo
 		 * @param array $bstream
 		 * @return array input item
 		 */
-		 protected function newInputItem($mode, $size, $data, $bstream=null) {
+		 protected function newInputItem($mode, $size, $data, $bstream = null) {
 			$setData = array_slice($data, 0, $size);
 			if (count($setData) < $size) {
 				$setData = array_merge($setData, array_fill(0, ($size - count($setData)), 0));
@@ -1547,23 +1547,23 @@  discard block
 block discarded – undo
 		 * @return array input item
 		 */
 		 protected function encodeModeNum($inputitem, $version) {
-			$words = (int)($inputitem['size'] / 3);
+			$words = (int) ($inputitem['size'] / 3);
 			$inputitem['bstream'] = array();
 			$val = 0x1;
 			$inputitem['bstream'] = $this->appendNum($inputitem['bstream'], 4, $val);
 			$inputitem['bstream'] = $this->appendNum($inputitem['bstream'], $this->lengthIndicator(QR_MODE_NM, $version), $inputitem['size']);
-			for ($i=0; $i < $words; ++$i) {
-				$val  = (ord($inputitem['data'][$i*3  ]) - ord('0')) * 100;
-				$val += (ord($inputitem['data'][$i*3+1]) - ord('0')) * 10;
-				$val += (ord($inputitem['data'][$i*3+2]) - ord('0'));
+			for ($i = 0; $i < $words; ++$i) {
+				$val  = (ord($inputitem['data'][$i * 3]) - ord('0')) * 100;
+				$val += (ord($inputitem['data'][$i * 3 + 1]) - ord('0')) * 10;
+				$val += (ord($inputitem['data'][$i * 3 + 2]) - ord('0'));
 				$inputitem['bstream'] = $this->appendNum($inputitem['bstream'], 10, $val);
 			}
 			if ($inputitem['size'] - $words * 3 == 1) {
-				$val = ord($inputitem['data'][$words*3]) - ord('0');
+				$val = ord($inputitem['data'][$words * 3]) - ord('0');
 				$inputitem['bstream'] = $this->appendNum($inputitem['bstream'], 4, $val);
 			} elseif (($inputitem['size'] - ($words * 3)) == 2) {
-				$val  = (ord($inputitem['data'][$words*3  ]) - ord('0')) * 10;
-				$val += (ord($inputitem['data'][$words*3+1]) - ord('0'));
+				$val  = (ord($inputitem['data'][$words * 3]) - ord('0')) * 10;
+				$val += (ord($inputitem['data'][$words * 3 + 1]) - ord('0'));
 				$inputitem['bstream'] = $this->appendNum($inputitem['bstream'], 7, $val);
 			}
 			return $inputitem;
@@ -1576,13 +1576,13 @@  discard block
 block discarded – undo
 		 * @return array input item
 		 */
 		 protected function encodeModeAn($inputitem, $version) {
-			$words = (int)($inputitem['size'] / 2);
+			$words = (int) ($inputitem['size'] / 2);
 			$inputitem['bstream'] = array();
 			$inputitem['bstream'] = $this->appendNum($inputitem['bstream'], 4, 0x02);
 			$inputitem['bstream'] = $this->appendNum(v, $this->lengthIndicator(QR_MODE_AN, $version), $inputitem['size']);
-			for ($i=0; $i < $words; ++$i) {
-				$val  = (int)$this->lookAnTable(ord($inputitem['data'][$i*2  ])) * 45;
-				$val += (int)$this->lookAnTable(ord($inputitem['data'][$i*2+1]));
+			for ($i = 0; $i < $words; ++$i) {
+				$val  = (int) $this->lookAnTable(ord($inputitem['data'][$i * 2])) * 45;
+				$val += (int) $this->lookAnTable(ord($inputitem['data'][$i * 2 + 1]));
 				$inputitem['bstream'] = $this->appendNum($inputitem['bstream'], 11, $val);
 			}
 			if ($inputitem['size'] & 1) {
@@ -1602,7 +1602,7 @@  discard block
 block discarded – undo
 			$inputitem['bstream'] = array();
 			$inputitem['bstream'] = $this->appendNum($inputitem['bstream'], 4, 0x4);
 			$inputitem['bstream'] = $this->appendNum($inputitem['bstream'], $this->lengthIndicator(QR_MODE_8B, $version), $inputitem['size']);
-			for ($i=0; $i < $inputitem['size']; ++$i) {
+			for ($i = 0; $i < $inputitem['size']; ++$i) {
 				$inputitem['bstream'] = $this->appendNum($inputitem['bstream'], 8, ord($inputitem['data'][$i]));
 			}
 			return $inputitem;
@@ -1617,9 +1617,9 @@  discard block
 block discarded – undo
 		 protected function encodeModeKanji($inputitem, $version) {
 			$inputitem['bstream'] = array();
 			$inputitem['bstream'] = $this->appendNum($inputitem['bstream'], 4, 0x8);
-			$inputitem['bstream'] = $this->appendNum($inputitem['bstream'], $this->lengthIndicator(QR_MODE_KJ, $version), (int)($inputitem['size'] / 2));
-			for ($i=0; $i<$inputitem['size']; $i+=2) {
-				$val = (ord($inputitem['data'][$i]) << 8) | ord($inputitem['data'][$i+1]);
+			$inputitem['bstream'] = $this->appendNum($inputitem['bstream'], $this->lengthIndicator(QR_MODE_KJ, $version), (int) ($inputitem['size'] / 2));
+			for ($i = 0; $i < $inputitem['size']; $i += 2) {
+				$val = (ord($inputitem['data'][$i]) << 8) | ord($inputitem['data'][$i + 1]);
 				if ($val <= 0x9ffc) {
 					$val -= 0x8140;
 				} else {
@@ -1664,7 +1664,7 @@  discard block
 block discarded – undo
 				$inputitem['bstream'] = $this->appendBitstream($inputitem['bstream'], $st1['bstream']);
 				$inputitem['bstream'] = $this->appendBitstream($inputitem['bstream'], $st2['bstream']);
 			} else {
-				switch($inputitem['mode']) {
+				switch ($inputitem['mode']) {
 					case QR_MODE_NM: {
 						$inputitem = $this->encodeModeNum($inputitem, $version);
 						break;
@@ -1742,7 +1742,7 @@  discard block
 block discarded – undo
 			$parity = 0;
 			foreach ($items as $item) {
 				if ($item['mode'] != QR_MODE_ST) {
-					for ($i=$item['size']-1; $i>=0; --$i) {
+					for ($i = $item['size'] - 1; $i >= 0; --$i) {
 						$parity ^= $item['data'][$i];
 					}
 				}
@@ -1757,8 +1757,8 @@  discard block
 block discarded – undo
 		 * @return boolean true or false
 		 */
 		 protected function checkModeNum($size, $data) {
-			for ($i=0; $i<$size; ++$i) {
-				if ((ord($data[$i]) < ord('0')) OR (ord($data[$i]) > ord('9'))){
+			for ($i = 0; $i < $size; ++$i) {
+				if ((ord($data[$i]) < ord('0')) OR (ord($data[$i]) > ord('9'))) {
 					return false;
 				}
 			}
@@ -1771,9 +1771,9 @@  discard block
 block discarded – undo
 		 * @return int number of bits
 		 */
 		 protected function estimateBitsModeNum($size) {
-			$w = (int)$size / 3;
+			$w = (int) $size / 3;
 			$bits = $w * 10;
-			switch($size - $w * 3) {
+			switch ($size - $w * 3) {
 				case 1: {
 					$bits += 4;
 					break;
@@ -1795,7 +1795,7 @@  discard block
 block discarded – undo
 		 * @return value
 		 */
 		protected function lookAnTable($c) {
-			return (($c > 127)?-1:$this->anTable[$c]);
+			return (($c > 127) ?-1 : $this->anTable[$c]);
 		}
 
 		/**
@@ -1805,7 +1805,7 @@  discard block
 block discarded – undo
 		 * @return boolean true or false
 		 */
 		 protected function checkModeAn($size, $data) {
-			for ($i=0; $i<$size; ++$i) {
+			for ($i = 0; $i < $size; ++$i) {
 				if ($this->lookAnTable(ord($data[$i])) == -1) {
 					return false;
 				}
@@ -1819,7 +1819,7 @@  discard block
 block discarded – undo
 		 * @return int number of bits
 		 */
 		 protected function estimateBitsModeAn($size) {
-			$w = (int)($size / 2);
+			$w = (int) ($size / 2);
 			$bits = $w * 11;
 			if ($size & 1) {
 				$bits += 6;
@@ -1842,7 +1842,7 @@  discard block
 block discarded – undo
 		 * @return int number of bits
 		 */
 		 protected function estimateBitsModeKanji($size) {
-			return (int)(($size / 2) * 13);
+			return (int) (($size / 2) * 13);
 		}
 
 		/**
@@ -1855,8 +1855,8 @@  discard block
 block discarded – undo
 			if ($size & 1) {
 				return false;
 			}
-			for ($i=0; $i<$size; $i+=2) {
-				$val = (ord($data[$i]) << 8) | ord($data[$i+1]);
+			for ($i = 0; $i < $size; $i += 2) {
+				$val = (ord($data[$i]) << 8) | ord($data[$i + 1]);
 				if (($val < 0x8140) OR (($val > 0x9ffc) AND ($val < 0xe040)) OR ($val > 0xebbf)) {
 					return false;
 				}
@@ -1875,7 +1875,7 @@  discard block
 block discarded – undo
 			if ($size <= 0) {
 				return false;
 			}
-			switch($mode) {
+			switch ($mode) {
 				case QR_MODE_NM: {
 					return $this->checkModeNum($size, $data);
 				}
@@ -1910,7 +1910,7 @@  discard block
 block discarded – undo
 				$version = 1;
 			}
 			foreach ($items as $item) {
-				switch($item['mode']) {
+				switch ($item['mode']) {
 					case QR_MODE_NM: {
 						$bits = $this->estimateBitsModeNum($item['size']);
 						break;
@@ -1936,7 +1936,7 @@  discard block
 block discarded – undo
 				}
 				$l = $this->lengthIndicator($item['mode'], $version);
 				$m = 1 << $l;
-				$num = (int)(($item['size'] + $m - 1) / $m);
+				$num = (int) (($item['size'] + $m - 1) / $m);
 				$bits += $num * (4 + $l);
 			}
 			return $bits;
@@ -1953,7 +1953,7 @@  discard block
 block discarded – undo
 			do {
 				$prev = $version;
 				$bits = $this->estimateBitStreamSize($items, $prev);
-				$version = $this->getMinimumVersion((int)(($bits + 7) / 8), $this->level);
+				$version = $this->getMinimumVersion((int) (($bits + 7) / 8), $this->level);
 				if ($version < 0) {
 					return -1;
 				}
@@ -1970,9 +1970,9 @@  discard block
 block discarded – undo
 		 */
 		 protected function lengthOfCode($mode, $version, $bits) {
 			$payload = $bits - 4 - $this->lengthIndicator($mode, $version);
-			switch($mode) {
+			switch ($mode) {
 				case QR_MODE_NM: {
-					$chunks = (int)($payload / 10);
+					$chunks = (int) ($payload / 10);
 					$remain = $payload - $chunks * 10;
 					$size = $chunks * 3;
 					if ($remain >= 7) {
@@ -1983,7 +1983,7 @@  discard block
 block discarded – undo
 					break;
 				}
 				case QR_MODE_AN: {
-					$chunks = (int)($payload / 11);
+					$chunks = (int) ($payload / 11);
 					$remain = $payload - $chunks * 11;
 					$size = $chunks * 2;
 					if ($remain >= 6) {
@@ -1992,15 +1992,15 @@  discard block
 block discarded – undo
 					break;
 				}
 				case QR_MODE_8B: {
-					$size = (int)($payload / 8);
+					$size = (int) ($payload / 8);
 					break;
 				}
 				case QR_MODE_KJ: {
-					$size = (int)(($payload / 13) * 2);
+					$size = (int) (($payload / 13) * 2);
 					break;
 				}
 				case QR_MODE_ST: {
-					$size = (int)($payload / 8);
+					$size = (int) ($payload / 8);
 					break;
 				}
 				default: {
@@ -2050,7 +2050,7 @@  discard block
 block discarded – undo
 				if ($bits < 0) {
 					return -1;
 				}
-				$ver = $this->getMinimumVersion((int)(($bits + 7) / 8), $this->level);
+				$ver = $this->getMinimumVersion((int) (($bits + 7) / 8), $this->level);
 				if ($ver < 0) {
 					return -1;
 				} elseif ($ver > $this->version) {
@@ -2078,14 +2078,14 @@  discard block
 block discarded – undo
 				return $this->appendNum($bstream, $maxbits - $bits, 0);
 			}
 			$bits += 4;
-			$words = (int)(($bits + 7) / 8);
+			$words = (int) (($bits + 7) / 8);
 			$padding = array();
 			$padding = $this->appendNum($padding, $words * 8 - $bits + 4, 0);
 			$padlen = $maxwords - $words;
 			if ($padlen > 0) {
 				$padbuf = array();
-				for ($i=0; $i<$padlen; ++$i) {
-					$padbuf[$i] = ($i&1)?0x11:0xec;
+				for ($i = 0; $i < $padlen; ++$i) {
+					$padbuf[$i] = ($i & 1) ? 0x11 : 0xec;
 				}
 				$padding = $this->appendBytes($padding, $padlen, $padbuf);
 			}
@@ -2148,7 +2148,7 @@  discard block
 block discarded – undo
 		 protected function newFromNum($bits, $num) {
 			$bstream = $this->allocate($bits);
 			$mask = 1 << ($bits - 1);
-			for ($i=0; $i<$bits; ++$i) {
+			for ($i = 0; $i < $bits; ++$i) {
 				if ($num & $mask) {
 					$bstream[$i] = 1;
 				} else {
@@ -2167,10 +2167,10 @@  discard block
 block discarded – undo
 		 */
 		 protected function newFromBytes($size, $data) {
 			$bstream = $this->allocate($size * 8);
-			$p=0;
-			for ($i=0; $i<$size; ++$i) {
+			$p = 0;
+			for ($i = 0; $i < $size; ++$i) {
 				$mask = 0x80;
-				for ($j=0; $j<8; ++$j) {
+				for ($j = 0; $j < 8; ++$j) {
 					if ($data[$i] & $mask) {
 						$bstream[$p] = 1;
 					} else {
@@ -2239,12 +2239,12 @@  discard block
 block discarded – undo
 			if ($size == 0) {
 				return array();
 			}
-			$data = array_fill(0, (int)(($size + 7) / 8), 0);
-			$bytes = (int)($size / 8);
+			$data = array_fill(0, (int) (($size + 7) / 8), 0);
+			$bytes = (int) ($size / 8);
 			$p = 0;
-			for ($i=0; $i<$bytes; $i++) {
+			for ($i = 0; $i < $bytes; $i++) {
 				$v = 0;
-				for ($j=0; $j<8; $j++) {
+				for ($j = 0; $j < 8; $j++) {
 					$v = $v << 1;
 					$v |= $bstream[$p];
 					$p++;
@@ -2253,7 +2253,7 @@  discard block
 block discarded – undo
 			}
 			if ($size & 7) {
 				$v = 0;
-				for ($j=0; $j<($size & 7); $j++) {
+				for ($j = 0; $j < ($size & 7); $j++) {
 					$v = $v << 1;
 					$v |= $bstream[$p];
 					$p++;
@@ -2276,8 +2276,8 @@  discard block
 block discarded – undo
 		 * @param int $replLen length of the repl string
 		 * @return array srctab
 		 */
-		 protected function qrstrset($srctab, $x, $y, $repl, $replLen=false) {
-			$srctab[$y] = substr_replace($srctab[$y], ($replLen !== false)?substr($repl,0,$replLen):$repl, $x, ($replLen !== false)?$replLen:strlen($repl));
+		 protected function qrstrset($srctab, $x, $y, $repl, $replLen = false) {
+			$srctab[$y] = substr_replace($srctab[$y], ($replLen !== false) ?substr($repl, 0, $replLen) : $repl, $x, ($replLen !== false) ? $replLen : strlen($repl));
 			return $srctab;
 		}
 
@@ -2297,7 +2297,7 @@  discard block
 block discarded – undo
 		 * @param int $level error correction level
 		 * @return int ECC size (bytes)
 		 */
-		protected function getECCLength($version, $level){
+		protected function getECCLength($version, $level) {
 			return $this->capacity[$version][QRCAP_EC][$level];
 		}
 
@@ -2326,8 +2326,8 @@  discard block
 block discarded – undo
 		 * @return int version number
 		 */
 		protected function getMinimumVersion($size, $level) {
-			for ($i=1; $i <= QRSPEC_VERSION_MAX; ++$i) {
-				$words  = $this->capacity[$i][QRCAP_WORDS] - $this->capacity[$i][QRCAP_EC][$level];
+			for ($i = 1; $i <= QRSPEC_VERSION_MAX; ++$i) {
+				$words = $this->capacity[$i][QRCAP_WORDS] - $this->capacity[$i][QRCAP_EC][$level];
 				if ($words >= $size) {
 					return $i;
 				}
@@ -2397,14 +2397,14 @@  discard block
 block discarded – undo
 			$ecc = $this->getECCLength($version, $level);
 			if ($b2 == 0) {
 				$spec[0] = $b1;
-				$spec[1] = (int)($data / $b1);
-				$spec[2] = (int)($ecc / $b1);
+				$spec[1] = (int) ($data / $b1);
+				$spec[2] = (int) ($ecc / $b1);
 				$spec[3] = 0;
 				$spec[4] = 0;
 			} else {
 				$spec[0] = $b1;
-				$spec[1] = (int)($data / ($b1 + $b2));
-				$spec[2] = (int)($ecc  / ($b1 + $b2));
+				$spec[1] = (int) ($data / ($b1 + $b2));
+				$spec[2] = (int) ($ecc / ($b1 + $b2));
 				$spec[3] = $b2;
 				$spec[4] = $spec[1] + 1;
 			}
@@ -2429,8 +2429,8 @@  discard block
 block discarded – undo
 				);
 			$yStart = $oy - 2;
 			$xStart = $ox - 2;
-			for ($y=0; $y < 5; $y++) {
-				$frame = $this->qrstrset($frame, $xStart, $yStart+$y, $finder[$y]);
+			for ($y = 0; $y < 5; $y++) {
+				$frame = $this->qrstrset($frame, $xStart, $yStart + $y, $finder[$y]);
 			}
 			return $frame;
 		}
@@ -2450,7 +2450,7 @@  discard block
 block discarded – undo
 			if ($d < 0) {
 				$w = 2;
 			} else {
-				$w = (int)(($width - $this->alignmentPattern[$version][0]) / $d + 2);
+				$w = (int) (($width - $this->alignmentPattern[$version][0]) / $d + 2);
 			}
 			if ($w * $w - 3 == 1) {
 				$x = $this->alignmentPattern[$version][0];
@@ -2460,15 +2460,15 @@  discard block
 block discarded – undo
 			}
 			$cx = $this->alignmentPattern[$version][0];
 			$wo = $w - 1;
-			for ($x=1; $x < $wo; ++$x) {
+			for ($x = 1; $x < $wo; ++$x) {
 				$frame = $this->putAlignmentMarker($frame, 6, $cx);
-				$frame = $this->putAlignmentMarker($frame, $cx,  6);
+				$frame = $this->putAlignmentMarker($frame, $cx, 6);
 				$cx += $d;
 			}
 			$cy = $this->alignmentPattern[$version][0];
-			for ($y=0; $y < $wo; ++$y) {
+			for ($y = 0; $y < $wo; ++$y) {
 				$cx = $this->alignmentPattern[$version][0];
-				for ($x=0; $x < $wo; ++$x) {
+				for ($x = 0; $x < $wo; ++$x) {
 					$frame = $this->putAlignmentMarker($frame, $cx, $cy);
 					$cx += $d;
 				}
@@ -2523,7 +2523,7 @@  discard block
 block discarded – undo
 			"\xc1\xc0\xc0\xc0\xc0\xc0\xc1",
 			"\xc1\xc1\xc1\xc1\xc1\xc1\xc1"
 			);
-			for ($y=0; $y < 7; $y++) {
+			for ($y = 0; $y < 7; $y++) {
 				$frame = $this->qrstrset($frame, $ox, ($oy + $y), $finder[$y]);
 			}
 			return $frame;
@@ -2536,7 +2536,7 @@  discard block
 block discarded – undo
 		 */
 		protected function createFrame($version) {
 			$width = $this->capacity[$version][QRCAP_WIDTH];
-			$frameLine = str_repeat ("\0", $width);
+			$frameLine = str_repeat("\0", $width);
 			$frame = array_fill(0, $width, $frameLine);
 			// Finder pattern
 			$frame = $this->putFinderPattern($frame, 0, 0);
@@ -2544,7 +2544,7 @@  discard block
 block discarded – undo
 			$frame = $this->putFinderPattern($frame, 0, $width - 7);
 			// Separator
 			$yOffset = $width - 7;
-			for ($y=0; $y < 7; ++$y) {
+			for ($y = 0; $y < 7; ++$y) {
 				$frame[$y][7] = "\xc0";
 				$frame[$y][$width - 8] = "\xc0";
 				$frame[$yOffset][7] = "\xc0";
@@ -2552,22 +2552,22 @@  discard block
 block discarded – undo
 			}
 			$setPattern = str_repeat("\xc0", 8);
 			$frame = $this->qrstrset($frame, 0, 7, $setPattern);
-			$frame = $this->qrstrset($frame, $width-8, 7, $setPattern);
+			$frame = $this->qrstrset($frame, $width - 8, 7, $setPattern);
 			$frame = $this->qrstrset($frame, 0, $width - 8, $setPattern);
 			// Format info
 			$setPattern = str_repeat("\x84", 9);
 			$frame = $this->qrstrset($frame, 0, 8, $setPattern);
 			$frame = $this->qrstrset($frame, $width - 8, 8, $setPattern, 8);
 			$yOffset = $width - 8;
-			for ($y=0; $y < 8; ++$y,++$yOffset) {
+			for ($y = 0; $y < 8; ++$y, ++$yOffset) {
 				$frame[$y][8] = "\x84";
 				$frame[$yOffset][8] = "\x84";
 			}
 			// Timing pattern
 			$wo = $width - 15;
-			for ($i=1; $i < $wo; ++$i) {
-				$frame[6][7+$i] = chr(0x90 | ($i & 1));
-				$frame[7+$i][6] = chr(0x90 | ($i & 1));
+			for ($i = 1; $i < $wo; ++$i) {
+				$frame[6][7 + $i] = chr(0x90 | ($i & 1));
+				$frame[7 + $i][6] = chr(0x90 | ($i & 1));
 			}
 			// Alignment pattern
 			$frame = $this->putAlignmentPattern($version, $frame, $width);
@@ -2575,16 +2575,16 @@  discard block
 block discarded – undo
 			if ($version >= 7) {
 				$vinf = $this->getVersionPattern($version);
 				$v = $vinf;
-				for ($x=0; $x<6; ++$x) {
-					for ($y=0; $y<3; ++$y) {
-						$frame[($width - 11)+$y][$x] = chr(0x88 | ($v & 1));
+				for ($x = 0; $x < 6; ++$x) {
+					for ($y = 0; $y < 3; ++$y) {
+						$frame[($width - 11) + $y][$x] = chr(0x88 | ($v & 1));
 						$v = $v >> 1;
 					}
 				}
 				$v = $vinf;
-				for ($y=0; $y<6; ++$y) {
-					for ($x=0; $x<3; ++$x) {
-						$frame[$y][$x+($width - 11)] = chr(0x88 | ($v & 1));
+				for ($y = 0; $y < 6; ++$y) {
+					for ($x = 0; $x < 3; ++$x) {
+						$frame[$y][$x + ($width - 11)] = chr(0x88 | ($v & 1));
 						$v = $v >> 1;
 					}
 				}
@@ -2755,16 +2755,16 @@  discard block
 block discarded – undo
 			if (($symsize < 0) OR ($symsize > 8)) {
 				return $rs;
 			}
-			if (($fcr < 0) OR ($fcr >= (1<<$symsize))) {
+			if (($fcr < 0) OR ($fcr >= (1 << $symsize))) {
 				return $rs;
 			}
-			if (($prim <= 0) OR ($prim >= (1<<$symsize))) {
+			if (($prim <= 0) OR ($prim >= (1 << $symsize))) {
 				return $rs;
 			}
-			if (($nroots < 0) OR ($nroots >= (1<<$symsize))) {
+			if (($nroots < 0) OR ($nroots >= (1 << $symsize))) {
 				return $rs;
 			}
-			if (($pad < 0) OR ($pad >= ((1<<$symsize) -1 - $nroots))) {
+			if (($pad < 0) OR ($pad >= ((1 << $symsize) - 1 - $nroots))) {
 				return $rs;
 			}
 			$rs = array();
@@ -2774,13 +2774,13 @@  discard block
 block discarded – undo
 			$rs['alpha_to'] = array_fill(0, ($rs['nn'] + 1), 0);
 			$rs['index_of'] = array_fill(0, ($rs['nn'] + 1), 0);
 			// PHP style macro replacement ;)
-			$NN =& $rs['nn'];
-			$A0 =& $NN;
+			$NN = & $rs['nn'];
+			$A0 = & $NN;
 			// Generate Galois field lookup tables
 			$rs['index_of'][0] = $A0; // log(zero) = -inf
 			$rs['alpha_to'][$A0] = 0; // alpha**-inf = 0
 			$sr = 1;
-			for ($i=0; $i<$rs['nn']; ++$i) {
+			for ($i = 0; $i < $rs['nn']; ++$i) {
 				$rs['index_of'][$sr] = $i;
 				$rs['alpha_to'][$i] = $sr;
 				$sr <<= 1;
@@ -2800,21 +2800,21 @@  discard block
 block discarded – undo
 			$rs['nroots'] = $nroots;
 			$rs['gfpoly'] = $gfpoly;
 			// Find prim-th root of 1, used in decoding
-			for ($iprim=1; ($iprim % $prim) != 0; $iprim += $rs['nn']) {
+			for ($iprim = 1; ($iprim % $prim) != 0; $iprim += $rs['nn']) {
 				; // intentional empty-body loop!
 			}
-			$rs['iprim'] = (int)($iprim / $prim);
+			$rs['iprim'] = (int) ($iprim / $prim);
 			$rs['genpoly'][0] = 1;
 
 
-			for ($i = 0,$root=$fcr*$prim; $i < $nroots; $i++, $root += $prim) {
-				$rs['genpoly'][$i+1] = 1;
+			for ($i = 0, $root = $fcr * $prim; $i < $nroots; $i++, $root += $prim) {
+				$rs['genpoly'][$i + 1] = 1;
 				// Multiply rs->genpoly[] by  @**(root + x)
 				for ($j = $i; $j > 0; --$j) {
 					if ($rs['genpoly'][$j] != 0) {
-						$rs['genpoly'][$j] = $rs['genpoly'][$j-1] ^ $rs['alpha_to'][$this->modnn($rs, $rs['index_of'][$rs['genpoly'][$j]] + $root)];
+						$rs['genpoly'][$j] = $rs['genpoly'][$j - 1] ^ $rs['alpha_to'][$this->modnn($rs, $rs['index_of'][$rs['genpoly'][$j]] + $root)];
 					} else {
-						$rs['genpoly'][$j] = $rs['genpoly'][$j-1];
+						$rs['genpoly'][$j] = $rs['genpoly'][$j - 1];
 					}
 				}
 				// rs->genpoly[0] can never be zero
@@ -2835,26 +2835,26 @@  discard block
 block discarded – undo
 		 * @return parity array
 		 */
 		 protected function encode_rs_char($rs, $data, $parity) {
-			$MM       =& $rs['mm']; // bits per symbol
-			$NN       =& $rs['nn']; // the total number of symbols in a RS block
-			$ALPHA_TO =& $rs['alpha_to']; // the address of an array of NN elements to convert Galois field elements in index (log) form to polynomial form
-			$INDEX_OF =& $rs['index_of']; // the address of an array of NN elements to convert Galois field elements in polynomial form to index (log) form
-			$GENPOLY  =& $rs['genpoly']; // an array of NROOTS+1 elements containing the generator polynomial in index form
-			$NROOTS   =& $rs['nroots']; // the number of roots in the RS code generator polynomial, which is the same as the number of parity symbols in a block
-			$FCR      =& $rs['fcr']; // first consecutive root, index form
-			$PRIM     =& $rs['prim']; // primitive element, index form
-			$IPRIM    =& $rs['iprim']; // prim-th root of 1, index form
-			$PAD      =& $rs['pad']; // the number of pad symbols in a block
-			$A0       =& $NN;
+			$MM       = & $rs['mm']; // bits per symbol
+			$NN       = & $rs['nn']; // the total number of symbols in a RS block
+			$ALPHA_TO = & $rs['alpha_to']; // the address of an array of NN elements to convert Galois field elements in index (log) form to polynomial form
+			$INDEX_OF = & $rs['index_of']; // the address of an array of NN elements to convert Galois field elements in polynomial form to index (log) form
+			$GENPOLY  = & $rs['genpoly']; // an array of NROOTS+1 elements containing the generator polynomial in index form
+			$NROOTS   = & $rs['nroots']; // the number of roots in the RS code generator polynomial, which is the same as the number of parity symbols in a block
+			$FCR      = & $rs['fcr']; // first consecutive root, index form
+			$PRIM     = & $rs['prim']; // primitive element, index form
+			$IPRIM    = & $rs['iprim']; // prim-th root of 1, index form
+			$PAD      = & $rs['pad']; // the number of pad symbols in a block
+			$A0       = & $NN;
 			$parity = array_fill(0, $NROOTS, 0);
-			for ($i=0; $i < ($NN - $NROOTS - $PAD); $i++) {
+			for ($i = 0; $i < ($NN - $NROOTS - $PAD); $i++) {
 				$feedback = $INDEX_OF[$data[$i] ^ $parity[0]];
 				if ($feedback != $A0) {
 					// feedback term is non-zero
 					// This line is unnecessary when GENPOLY[NROOTS] is unity, as it must
 					// always be for the polynomials constructed by init_rs()
 					$feedback = $this->modnn($rs, $NN - $GENPOLY[$NROOTS] + $feedback);
-					for ($j=1; $j < $NROOTS; ++$j) {
+					for ($j = 1; $j < $NROOTS; ++$j) {
 					$parity[$j] ^= $ALPHA_TO[$this->modnn($rs, $feedback + $GENPOLY[($NROOTS - $j)])];
 					}
 				}

Please login to merge, or discard this patch.

lib/phpqrcode/qrencode.php 4 patches

Indentation +381 added lines, -381 removed lines patch added patch discarded remove patch

@@ -25,478 +25,478 @@
 block discarded – undo
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  */
  
-    class QRrsblock {
-        public $dataLength;
-        public $data = array();
-        public $eccLength;
-        public $ecc = array();
+	class QRrsblock {
+		public $dataLength;
+		public $data = array();
+		public $eccLength;
+		public $ecc = array();
         
-        public function __construct($dl, $data, $el, &$ecc, QRrsItem $rs)
-        {
-            $rs->encode_rs_char($data, $ecc);
+		public function __construct($dl, $data, $el, &$ecc, QRrsItem $rs)
+		{
+			$rs->encode_rs_char($data, $ecc);
         
-            $this->dataLength = $dl;
-            $this->data = $data;
-            $this->eccLength = $el;
-            $this->ecc = $ecc;
-        }
-    };
+			$this->dataLength = $dl;
+			$this->data = $data;
+			$this->eccLength = $el;
+			$this->ecc = $ecc;
+		}
+	};
     
-    //##########################################################################
+	//##########################################################################
 
-    class QRrawcode {
-        public $version;
-        public $datacode = array();
-        public $ecccode = array();
-        public $blocks;
-        public $rsblocks = array(); //of RSblock
-        public $count;
-        public $dataLength;
-        public $eccLength;
-        public $b1;
+	class QRrawcode {
+		public $version;
+		public $datacode = array();
+		public $ecccode = array();
+		public $blocks;
+		public $rsblocks = array(); //of RSblock
+		public $count;
+		public $dataLength;
+		public $eccLength;
+		public $b1;
         
-        //----------------------------------------------------------------------
-        public function __construct(QRinput $input)
-        {
-            $spec = array(0,0,0,0,0);
+		//----------------------------------------------------------------------
+		public function __construct(QRinput $input)
+		{
+			$spec = array(0,0,0,0,0);
             
-            $this->datacode = $input->getByteStream();
-            if(is_null($this->datacode)) {
-                throw new Exception('null imput string');
-            }
+			$this->datacode = $input->getByteStream();
+			if(is_null($this->datacode)) {
+				throw new Exception('null imput string');
+			}
 
-            QRspec::getEccSpec($input->getVersion(), $input->getErrorCorrectionLevel(), $spec);
+			QRspec::getEccSpec($input->getVersion(), $input->getErrorCorrectionLevel(), $spec);
 
-            $this->version = $input->getVersion();
-            $this->b1 = QRspec::rsBlockNum1($spec);
-            $this->dataLength = QRspec::rsDataLength($spec);
-            $this->eccLength = QRspec::rsEccLength($spec);
-            $this->ecccode = array_fill(0, $this->eccLength, 0);
-            $this->blocks = QRspec::rsBlockNum($spec);
+			$this->version = $input->getVersion();
+			$this->b1 = QRspec::rsBlockNum1($spec);
+			$this->dataLength = QRspec::rsDataLength($spec);
+			$this->eccLength = QRspec::rsEccLength($spec);
+			$this->ecccode = array_fill(0, $this->eccLength, 0);
+			$this->blocks = QRspec::rsBlockNum($spec);
             
-            $ret = $this->init($spec);
-            if($ret < 0) {
-                throw new Exception('block alloc error');
-                return null;
-            }
+			$ret = $this->init($spec);
+			if($ret < 0) {
+				throw new Exception('block alloc error');
+				return null;
+			}
 
-            $this->count = 0;
-        }
+			$this->count = 0;
+		}
         
-        //----------------------------------------------------------------------
-        public function init(array $spec)
-        {
-            $dl = QRspec::rsDataCodes1($spec);
-            $el = QRspec::rsEccCodes1($spec);
-            $rs = QRrs::init_rs(8, 0x11d, 0, 1, $el, 255 - $dl - $el);
+		//----------------------------------------------------------------------
+		public function init(array $spec)
+		{
+			$dl = QRspec::rsDataCodes1($spec);
+			$el = QRspec::rsEccCodes1($spec);
+			$rs = QRrs::init_rs(8, 0x11d, 0, 1, $el, 255 - $dl - $el);
             
 
-            $blockNo = 0;
-            $dataPos = 0;
-            $eccPos = 0;
-            for($i=0; $i<QRspec::rsBlockNum1($spec); $i++) {
-                $ecc = array_slice($this->ecccode,$eccPos);
-                $this->rsblocks[$blockNo] = new QRrsblock($dl, array_slice($this->datacode, $dataPos), $el,  $ecc, $rs);
-                $this->ecccode = array_merge(array_slice($this->ecccode,0, $eccPos), $ecc);
+			$blockNo = 0;
+			$dataPos = 0;
+			$eccPos = 0;
+			for($i=0; $i<QRspec::rsBlockNum1($spec); $i++) {
+				$ecc = array_slice($this->ecccode,$eccPos);
+				$this->rsblocks[$blockNo] = new QRrsblock($dl, array_slice($this->datacode, $dataPos), $el,  $ecc, $rs);
+				$this->ecccode = array_merge(array_slice($this->ecccode,0, $eccPos), $ecc);
                 
-                $dataPos += $dl;
-                $eccPos += $el;
-                $blockNo++;
-            }
+				$dataPos += $dl;
+				$eccPos += $el;
+				$blockNo++;
+			}
 
-            if(QRspec::rsBlockNum2($spec) == 0)
-                return 0;
+			if(QRspec::rsBlockNum2($spec) == 0)
+				return 0;
 
-            $dl = QRspec::rsDataCodes2($spec);
-            $el = QRspec::rsEccCodes2($spec);
-            $rs = QRrs::init_rs(8, 0x11d, 0, 1, $el, 255 - $dl - $el);
+			$dl = QRspec::rsDataCodes2($spec);
+			$el = QRspec::rsEccCodes2($spec);
+			$rs = QRrs::init_rs(8, 0x11d, 0, 1, $el, 255 - $dl - $el);
             
-            if($rs == NULL) return -1;
+			if($rs == NULL) return -1;
             
-            for($i=0; $i<QRspec::rsBlockNum2($spec); $i++) {
-                $ecc = array_slice($this->ecccode,$eccPos);
-                $this->rsblocks[$blockNo] = new QRrsblock($dl, array_slice($this->datacode, $dataPos), $el, $ecc, $rs);
-                $this->ecccode = array_merge(array_slice($this->ecccode,0, $eccPos), $ecc);
+			for($i=0; $i<QRspec::rsBlockNum2($spec); $i++) {
+				$ecc = array_slice($this->ecccode,$eccPos);
+				$this->rsblocks[$blockNo] = new QRrsblock($dl, array_slice($this->datacode, $dataPos), $el, $ecc, $rs);
+				$this->ecccode = array_merge(array_slice($this->ecccode,0, $eccPos), $ecc);
                 
-                $dataPos += $dl;
-                $eccPos += $el;
-                $blockNo++;
-            }
+				$dataPos += $dl;
+				$eccPos += $el;
+				$blockNo++;
+			}
 
-            return 0;
-        }
+			return 0;
+		}
         
-        //----------------------------------------------------------------------
-        public function getCode()
-        {
-            $ret = 0;
+		//----------------------------------------------------------------------
+		public function getCode()
+		{
+			$ret = 0;
 
-            if($this->count < $this->dataLength) {
-                $row = $this->count % $this->blocks;
-                $col = $this->count / $this->blocks;
-                if($col >= $this->rsblocks[0]->dataLength) {
-                    $row += $this->b1;
-                }
-                $ret = $this->rsblocks[$row]->data[$col];
-            } else if($this->count < $this->dataLength + $this->eccLength) {
-                $row = ($this->count - $this->dataLength) % $this->blocks;
-                $col = ($this->count - $this->dataLength) / $this->blocks;
-                $ret = $this->rsblocks[$row]->ecc[$col];
-            } else {
-                return 0;
-            }
-            $this->count++;
+			if($this->count < $this->dataLength) {
+				$row = $this->count % $this->blocks;
+				$col = $this->count / $this->blocks;
+				if($col >= $this->rsblocks[0]->dataLength) {
+					$row += $this->b1;
+				}
+				$ret = $this->rsblocks[$row]->data[$col];
+			} else if($this->count < $this->dataLength + $this->eccLength) {
+				$row = ($this->count - $this->dataLength) % $this->blocks;
+				$col = ($this->count - $this->dataLength) / $this->blocks;
+				$ret = $this->rsblocks[$row]->ecc[$col];
+			} else {
+				return 0;
+			}
+			$this->count++;
             
-            return $ret;
-        }
-    }
+			return $ret;
+		}
+	}
 
-    //##########################################################################
+	//##########################################################################
     
-    class QRcode {
+	class QRcode {
     
-        public $version;
-        public $width;
-        public $data; 
+		public $version;
+		public $width;
+		public $data; 
         
-        //----------------------------------------------------------------------
-        public function encodeMask(QRinput $input, $mask)
-        {
-            if($input->getVersion() < 0 || $input->getVersion() > QRSPEC_VERSION_MAX) {
-                throw new Exception('wrong version');
-            }
-            if($input->getErrorCorrectionLevel() > QR_ECLEVEL_H) {
-                throw new Exception('wrong level');
-            }
+		//----------------------------------------------------------------------
+		public function encodeMask(QRinput $input, $mask)
+		{
+			if($input->getVersion() < 0 || $input->getVersion() > QRSPEC_VERSION_MAX) {
+				throw new Exception('wrong version');
+			}
+			if($input->getErrorCorrectionLevel() > QR_ECLEVEL_H) {
+				throw new Exception('wrong level');
+			}
 
-            $raw = new QRrawcode($input);
+			$raw = new QRrawcode($input);
             
-            QRtools::markTime('after_raw');
+			QRtools::markTime('after_raw');
             
-            $version = $raw->version;
-            $width = QRspec::getWidth($version);
-            $frame = QRspec::newFrame($version);
+			$version = $raw->version;
+			$width = QRspec::getWidth($version);
+			$frame = QRspec::newFrame($version);
             
-            $filler = new FrameFiller($width, $frame);
-            if(is_null($filler)) {
-                return NULL;
-            }
+			$filler = new FrameFiller($width, $frame);
+			if(is_null($filler)) {
+				return NULL;
+			}
 
-            // inteleaved data and ecc codes
-            for($i=0; $i<$raw->dataLength + $raw->eccLength; $i++) {
-                $code = $raw->getCode();
-                $bit = 0x80;
-                for($j=0; $j<8; $j++) {
-                    $addr = $filler->next();
-                    $filler->setFrameAt($addr, 0x02 | (($bit & $code) != 0));
-                    $bit = $bit >> 1;
-                }
-            }
+			// inteleaved data and ecc codes
+			for($i=0; $i<$raw->dataLength + $raw->eccLength; $i++) {
+				$code = $raw->getCode();
+				$bit = 0x80;
+				for($j=0; $j<8; $j++) {
+					$addr = $filler->next();
+					$filler->setFrameAt($addr, 0x02 | (($bit & $code) != 0));
+					$bit = $bit >> 1;
+				}
+			}
             
-            QRtools::markTime('after_filler');
+			QRtools::markTime('after_filler');
             
-            unset($raw);
+			unset($raw);
             
-            // remainder bits
-            $j = QRspec::getRemainder($version);
-            for($i=0; $i<$j; $i++) {
-                $addr = $filler->next();
-                $filler->setFrameAt($addr, 0x02);
-            }
+			// remainder bits
+			$j = QRspec::getRemainder($version);
+			for($i=0; $i<$j; $i++) {
+				$addr = $filler->next();
+				$filler->setFrameAt($addr, 0x02);
+			}
             
-            $frame = $filler->frame;
-            unset($filler);
+			$frame = $filler->frame;
+			unset($filler);
             
             
-            // masking
-            $maskObj = new QRmask();
-            if($mask < 0) {
+			// masking
+			$maskObj = new QRmask();
+			if($mask < 0) {
             
-                if (QR_FIND_BEST_MASK) {
-                    $masked = $maskObj->mask($width, $frame, $input->getErrorCorrectionLevel());
-                } else {
-                    $masked = $maskObj->makeMask($width, $frame, (intval(QR_DEFAULT_MASK) % 8), $input->getErrorCorrectionLevel());
-                }
-            } else {
-                $masked = $maskObj->makeMask($width, $frame, $mask, $input->getErrorCorrectionLevel());
-            }
+				if (QR_FIND_BEST_MASK) {
+					$masked = $maskObj->mask($width, $frame, $input->getErrorCorrectionLevel());
+				} else {
+					$masked = $maskObj->makeMask($width, $frame, (intval(QR_DEFAULT_MASK) % 8), $input->getErrorCorrectionLevel());
+				}
+			} else {
+				$masked = $maskObj->makeMask($width, $frame, $mask, $input->getErrorCorrectionLevel());
+			}
             
-            if($masked == NULL) {
-                return NULL;
-            }
+			if($masked == NULL) {
+				return NULL;
+			}
             
-            QRtools::markTime('after_mask');
+			QRtools::markTime('after_mask');
             
-            $this->version = $version;
-            $this->width = $width;
-            $this->data = $masked;
+			$this->version = $version;
+			$this->width = $width;
+			$this->data = $masked;
             
-            return $this;
-        }
+			return $this;
+		}
     
-        //----------------------------------------------------------------------
-        public function encodeInput(QRinput $input)
-        {
-            return $this->encodeMask($input, -1);
-        }
+		//----------------------------------------------------------------------
+		public function encodeInput(QRinput $input)
+		{
+			return $this->encodeMask($input, -1);
+		}
         
-        //----------------------------------------------------------------------
-        public function encodeString8bit($string, $version, $level)
-        {
-            if(string == NULL) {
-                throw new Exception('empty string!');
-                return NULL;
-            }
+		//----------------------------------------------------------------------
+		public function encodeString8bit($string, $version, $level)
+		{
+			if(string == NULL) {
+				throw new Exception('empty string!');
+				return NULL;
+			}
 
-            $input = new QRinput($version, $level);
-            if($input == NULL) return NULL;
+			$input = new QRinput($version, $level);
+			if($input == NULL) return NULL;
 
-            $ret = $input->append($input, QR_MODE_8, strlen($string), str_split($string));
-            if($ret < 0) {
-                unset($input);
-                return NULL;
-            }
-            return $this->encodeInput($input);
-        }
+			$ret = $input->append($input, QR_MODE_8, strlen($string), str_split($string));
+			if($ret < 0) {
+				unset($input);
+				return NULL;
+			}
+			return $this->encodeInput($input);
+		}
 
-        //----------------------------------------------------------------------
-        public function encodeString($string, $version, $level, $hint, $casesensitive)
-        {
+		//----------------------------------------------------------------------
+		public function encodeString($string, $version, $level, $hint, $casesensitive)
+		{
 
-            if($hint != QR_MODE_8 && $hint != QR_MODE_KANJI) {
-                throw new Exception('bad hint');
-                return NULL;
-            }
+			if($hint != QR_MODE_8 && $hint != QR_MODE_KANJI) {
+				throw new Exception('bad hint');
+				return NULL;
+			}
 
-            $input = new QRinput($version, $level);
-            if($input == NULL) return NULL;
+			$input = new QRinput($version, $level);
+			if($input == NULL) return NULL;
 
-            $ret = QRsplit::splitStringToQRinput($string, $input, $hint, $casesensitive);
-            if($ret < 0) {
-                return NULL;
-            }
+			$ret = QRsplit::splitStringToQRinput($string, $input, $hint, $casesensitive);
+			if($ret < 0) {
+				return NULL;
+			}
 
-            return $this->encodeInput($input);
-        }
+			return $this->encodeInput($input);
+		}
         
-        //----------------------------------------------------------------------
-        public static function png($text, $outfile = false, $level = QR_ECLEVEL_L, $size = 3, $margin = 4, $saveandprint=false) 
-        {
-            $enc = QRencode::factory($level, $size, $margin);
-            return $enc->encodePNG($text, $outfile, $saveandprint=false);
-        }
+		//----------------------------------------------------------------------
+		public static function png($text, $outfile = false, $level = QR_ECLEVEL_L, $size = 3, $margin = 4, $saveandprint=false) 
+		{
+			$enc = QRencode::factory($level, $size, $margin);
+			return $enc->encodePNG($text, $outfile, $saveandprint=false);
+		}
 
-        //----------------------------------------------------------------------
-        public static function text($text, $outfile = false, $level = QR_ECLEVEL_L, $size = 3, $margin = 4) 
-        {
-            $enc = QRencode::factory($level, $size, $margin);
-            return $enc->encode($text, $outfile);
-        }
+		//----------------------------------------------------------------------
+		public static function text($text, $outfile = false, $level = QR_ECLEVEL_L, $size = 3, $margin = 4) 
+		{
+			$enc = QRencode::factory($level, $size, $margin);
+			return $enc->encode($text, $outfile);
+		}
 
-        //----------------------------------------------------------------------
-        public static function raw($text, $outfile = false, $level = QR_ECLEVEL_L, $size = 3, $margin = 4) 
-        {
-            $enc = QRencode::factory($level, $size, $margin);
-            return $enc->encodeRAW($text, $outfile);
-        }
-    }
+		//----------------------------------------------------------------------
+		public static function raw($text, $outfile = false, $level = QR_ECLEVEL_L, $size = 3, $margin = 4) 
+		{
+			$enc = QRencode::factory($level, $size, $margin);
+			return $enc->encodeRAW($text, $outfile);
+		}
+	}
     
-    //##########################################################################
+	//##########################################################################
     
-    class FrameFiller {
+	class FrameFiller {
     
-        public $width;
-        public $frame;
-        public $x;
-        public $y;
-        public $dir;
-        public $bit;
+		public $width;
+		public $frame;
+		public $x;
+		public $y;
+		public $dir;
+		public $bit;
         
-        //----------------------------------------------------------------------
-        public function __construct($width, &$frame)
-        {
-            $this->width = $width;
-            $this->frame = $frame;
-            $this->x = $width - 1;
-            $this->y = $width - 1;
-            $this->dir = -1;
-            $this->bit = -1;
-        }
+		//----------------------------------------------------------------------
+		public function __construct($width, &$frame)
+		{
+			$this->width = $width;
+			$this->frame = $frame;
+			$this->x = $width - 1;
+			$this->y = $width - 1;
+			$this->dir = -1;
+			$this->bit = -1;
+		}
         
-        //----------------------------------------------------------------------
-        public function setFrameAt($at, $val)
-        {
-            $this->frame[$at['y']][$at['x']] = chr($val);
-        }
+		//----------------------------------------------------------------------
+		public function setFrameAt($at, $val)
+		{
+			$this->frame[$at['y']][$at['x']] = chr($val);
+		}
         
-        //----------------------------------------------------------------------
-        public function getFrameAt($at)
-        {
-            return ord($this->frame[$at['y']][$at['x']]);
-        }
+		//----------------------------------------------------------------------
+		public function getFrameAt($at)
+		{
+			return ord($this->frame[$at['y']][$at['x']]);
+		}
         
-        //----------------------------------------------------------------------
-        public function next()
-        {
-            do {
+		//----------------------------------------------------------------------
+		public function next()
+		{
+			do {
             
-                if($this->bit == -1) {
-                    $this->bit = 0;
-                    return array('x'=>$this->x, 'y'=>$this->y);
-                }
+				if($this->bit == -1) {
+					$this->bit = 0;
+					return array('x'=>$this->x, 'y'=>$this->y);
+				}
 
-                $x = $this->x;
-                $y = $this->y;
-                $w = $this->width;
+				$x = $this->x;
+				$y = $this->y;
+				$w = $this->width;
 
-                if($this->bit == 0) {
-                    $x--;
-                    $this->bit++;
-                } else {
-                    $x++;
-                    $y += $this->dir;
-                    $this->bit--;
-                }
+				if($this->bit == 0) {
+					$x--;
+					$this->bit++;
+				} else {
+					$x++;
+					$y += $this->dir;
+					$this->bit--;
+				}
 
-                if($this->dir < 0) {
-                    if($y < 0) {
-                        $y = 0;
-                        $x -= 2;
-                        $this->dir = 1;
-                        if($x == 6) {
-                            $x--;
-                            $y = 9;
-                        }
-                    }
-                } else {
-                    if($y == $w) {
-                        $y = $w - 1;
-                        $x -= 2;
-                        $this->dir = -1;
-                        if($x == 6) {
-                            $x--;
-                            $y -= 8;
-                        }
-                    }
-                }
-                if($x < 0 || $y < 0) return null;
+				if($this->dir < 0) {
+					if($y < 0) {
+						$y = 0;
+						$x -= 2;
+						$this->dir = 1;
+						if($x == 6) {
+							$x--;
+							$y = 9;
+						}
+					}
+				} else {
+					if($y == $w) {
+						$y = $w - 1;
+						$x -= 2;
+						$this->dir = -1;
+						if($x == 6) {
+							$x--;
+							$y -= 8;
+						}
+					}
+				}
+				if($x < 0 || $y < 0) return null;
 
-                $this->x = $x;
-                $this->y = $y;
+				$this->x = $x;
+				$this->y = $y;
 
-            } while(ord($this->frame[$y][$x]) & 0x80);
+			} while(ord($this->frame[$y][$x]) & 0x80);
                         
-            return array('x'=>$x, 'y'=>$y);
-        }
+			return array('x'=>$x, 'y'=>$y);
+		}
         
-    } ;
+	} ;
     
-    //##########################################################################    
+	//##########################################################################    
     
-    class QRencode {
+	class QRencode {
     
-        public $casesensitive = true;
-        public $eightbit = false;
+		public $casesensitive = true;
+		public $eightbit = false;
         
-        public $version = 0;
-        public $size = 3;
-        public $margin = 4;
+		public $version = 0;
+		public $size = 3;
+		public $margin = 4;
         
-        public $structured = 0; // not supported yet
+		public $structured = 0; // not supported yet
         
-        public $level = QR_ECLEVEL_L;
-        public $hint = QR_MODE_8;
+		public $level = QR_ECLEVEL_L;
+		public $hint = QR_MODE_8;
         
-        //----------------------------------------------------------------------
-        public static function factory($level = QR_ECLEVEL_L, $size = 3, $margin = 4)
-        {
-            $enc = new QRencode();
-            $enc->size = $size;
-            $enc->margin = $margin;
+		//----------------------------------------------------------------------
+		public static function factory($level = QR_ECLEVEL_L, $size = 3, $margin = 4)
+		{
+			$enc = new QRencode();
+			$enc->size = $size;
+			$enc->margin = $margin;
             
-            switch ($level.'') {
-                case '0':
-                case '1':
-                case '2':
-                case '3':
-                        $enc->level = $level;
-                    break;
-                case 'l':
-                case 'L':
-                        $enc->level = QR_ECLEVEL_L;
-                    break;
-                case 'm':
-                case 'M':
-                        $enc->level = QR_ECLEVEL_M;
-                    break;
-                case 'q':
-                case 'Q':
-                        $enc->level = QR_ECLEVEL_Q;
-                    break;
-                case 'h':
-                case 'H':
-                        $enc->level = QR_ECLEVEL_H;
-                    break;
-            }
+			switch ($level.'') {
+				case '0':
+				case '1':
+				case '2':
+				case '3':
+						$enc->level = $level;
+					break;
+				case 'l':
+				case 'L':
+						$enc->level = QR_ECLEVEL_L;
+					break;
+				case 'm':
+				case 'M':
+						$enc->level = QR_ECLEVEL_M;
+					break;
+				case 'q':
+				case 'Q':
+						$enc->level = QR_ECLEVEL_Q;
+					break;
+				case 'h':
+				case 'H':
+						$enc->level = QR_ECLEVEL_H;
+					break;
+			}
             
-            return $enc;
-        }
+			return $enc;
+		}
         
-        //----------------------------------------------------------------------
-        public function encodeRAW($intext, $outfile = false) 
-        {
-            $code = new QRcode();
+		//----------------------------------------------------------------------
+		public function encodeRAW($intext, $outfile = false) 
+		{
+			$code = new QRcode();
 
-            if($this->eightbit) {
-                $code->encodeString8bit($intext, $this->version, $this->level);
-            } else {
-                $code->encodeString($intext, $this->version, $this->level, $this->hint, $this->casesensitive);
-            }
+			if($this->eightbit) {
+				$code->encodeString8bit($intext, $this->version, $this->level);
+			} else {
+				$code->encodeString($intext, $this->version, $this->level, $this->hint, $this->casesensitive);
+			}
             
-            return $code->data;
-        }
+			return $code->data;
+		}
 
-        //----------------------------------------------------------------------
-        public function encode($intext, $outfile = false) 
-        {
-            $code = new QRcode();
+		//----------------------------------------------------------------------
+		public function encode($intext, $outfile = false) 
+		{
+			$code = new QRcode();
 
-            if($this->eightbit) {
-                $code->encodeString8bit($intext, $this->version, $this->level);
-            } else {
-                $code->encodeString($intext, $this->version, $this->level, $this->hint, $this->casesensitive);
-            }
+			if($this->eightbit) {
+				$code->encodeString8bit($intext, $this->version, $this->level);
+			} else {
+				$code->encodeString($intext, $this->version, $this->level, $this->hint, $this->casesensitive);
+			}
             
-            QRtools::markTime('after_encode');
+			QRtools::markTime('after_encode');
             
-            if ($outfile!== false) {
-                file_put_contents($outfile, join("\n", QRtools::binarize($code->data)));
-            } else {
-                return QRtools::binarize($code->data);
-            }
-        }
+			if ($outfile!== false) {
+				file_put_contents($outfile, join("\n", QRtools::binarize($code->data)));
+			} else {
+				return QRtools::binarize($code->data);
+			}
+		}
         
-        //----------------------------------------------------------------------
-        public function encodePNG($intext, $outfile = false,$saveandprint=false) 
-        {
-            try {
+		//----------------------------------------------------------------------
+		public function encodePNG($intext, $outfile = false,$saveandprint=false) 
+		{
+			try {
             
-                ob_start();
-                $tab = $this->encode($intext);
-                $err = ob_get_contents();
-                ob_end_clean();
+				ob_start();
+				$tab = $this->encode($intext);
+				$err = ob_get_contents();
+				ob_end_clean();
                 
-                if ($err != '')
-                    QRtools::log($outfile, $err);
+				if ($err != '')
+					QRtools::log($outfile, $err);
                 
-                $maxSize = (int)(QR_PNG_MAXIMUM_SIZE / (count($tab)+2*$this->margin));
+				$maxSize = (int)(QR_PNG_MAXIMUM_SIZE / (count($tab)+2*$this->margin));
                 
-                QRimage::png($tab, $outfile, min(max(1, $this->size), $maxSize), $this->margin,$saveandprint);
+				QRimage::png($tab, $outfile, min(max(1, $this->size), $maxSize), $this->margin,$saveandprint);
             
-            } catch (Exception $e) {
+			} catch (Exception $e) {
             
-                QRtools::log($outfile, $e->getMessage());
+				QRtools::log($outfile, $e->getMessage());
             
-            }
-        }
-    }
+			}
+		}
+	}

Please login to merge, or discard this patch.

Switch Indentation +22 added lines, -22 removed lines patch added patch discarded remove patch

@@ -415,28 +415,28 @@
 block discarded – undo
             $enc->margin = $margin;
             
             switch ($level.'') {
-                case '0':
-                case '1':
-                case '2':
-                case '3':
-                        $enc->level = $level;
-                    break;
-                case 'l':
-                case 'L':
-                        $enc->level = QR_ECLEVEL_L;
-                    break;
-                case 'm':
-                case 'M':
-                        $enc->level = QR_ECLEVEL_M;
-                    break;
-                case 'q':
-                case 'Q':
-                        $enc->level = QR_ECLEVEL_Q;
-                    break;
-                case 'h':
-                case 'H':
-                        $enc->level = QR_ECLEVEL_H;
-                    break;
+            case '0':
+            case '1':
+            case '2':
+            case '3':
+                    $enc->level = $level;
+                break;
+            case 'l':
+            case 'L':
+                    $enc->level = QR_ECLEVEL_L;
+                break;
+            case 'm':
+            case 'M':
+                    $enc->level = QR_ECLEVEL_M;
+                break;
+            case 'q':
+            case 'Q':
+                    $enc->level = QR_ECLEVEL_Q;
+                break;
+            case 'h':
+            case 'H':
+                    $enc->level = QR_ECLEVEL_H;
+                break;
             }
             
             return $enc;

Please login to merge, or discard this patch.

Spacing +46 added lines, -46 removed lines patch added patch discarded remove patch

@@ -58,10 +58,10 @@  discard block
 block discarded – undo
         //----------------------------------------------------------------------
         public function __construct(QRinput $input)
         {
-            $spec = array(0,0,0,0,0);
+            $spec = array(0, 0, 0, 0, 0);
             
             $this->datacode = $input->getByteStream();
-            if(is_null($this->datacode)) {
+            if (is_null($this->datacode)) {
                 throw new Exception('null imput string');
             }
 
@@ -75,7 +75,7 @@  discard block
 block discarded – undo
             $this->blocks = QRspec::rsBlockNum($spec);
             
             $ret = $this->init($spec);
-            if($ret < 0) {
+            if ($ret < 0) {
                 throw new Exception('block alloc error');
                 return null;
             }
@@ -94,29 +94,29 @@  discard block
 block discarded – undo
             $blockNo = 0;
             $dataPos = 0;
             $eccPos = 0;
-            for($i=0; $i<QRspec::rsBlockNum1($spec); $i++) {
-                $ecc = array_slice($this->ecccode,$eccPos);
-                $this->rsblocks[$blockNo] = new QRrsblock($dl, array_slice($this->datacode, $dataPos), $el,  $ecc, $rs);
-                $this->ecccode = array_merge(array_slice($this->ecccode,0, $eccPos), $ecc);
+            for ($i = 0; $i < QRspec::rsBlockNum1($spec); $i++) {
+                $ecc = array_slice($this->ecccode, $eccPos);
+                $this->rsblocks[$blockNo] = new QRrsblock($dl, array_slice($this->datacode, $dataPos), $el, $ecc, $rs);
+                $this->ecccode = array_merge(array_slice($this->ecccode, 0, $eccPos), $ecc);
                 
                 $dataPos += $dl;
                 $eccPos += $el;
                 $blockNo++;
             }
 
-            if(QRspec::rsBlockNum2($spec) == 0)
+            if (QRspec::rsBlockNum2($spec) == 0)
                 return 0;
 
             $dl = QRspec::rsDataCodes2($spec);
             $el = QRspec::rsEccCodes2($spec);
             $rs = QRrs::init_rs(8, 0x11d, 0, 1, $el, 255 - $dl - $el);
             
-            if($rs == NULL) return -1;
+            if ($rs == NULL) return -1;
             
-            for($i=0; $i<QRspec::rsBlockNum2($spec); $i++) {
-                $ecc = array_slice($this->ecccode,$eccPos);
+            for ($i = 0; $i < QRspec::rsBlockNum2($spec); $i++) {
+                $ecc = array_slice($this->ecccode, $eccPos);
                 $this->rsblocks[$blockNo] = new QRrsblock($dl, array_slice($this->datacode, $dataPos), $el, $ecc, $rs);
-                $this->ecccode = array_merge(array_slice($this->ecccode,0, $eccPos), $ecc);
+                $this->ecccode = array_merge(array_slice($this->ecccode, 0, $eccPos), $ecc);
                 
                 $dataPos += $dl;
                 $eccPos += $el;
@@ -131,14 +131,14 @@  discard block
 block discarded – undo
         {
             $ret = 0;
 
-            if($this->count < $this->dataLength) {
+            if ($this->count < $this->dataLength) {
                 $row = $this->count % $this->blocks;
                 $col = $this->count / $this->blocks;
-                if($col >= $this->rsblocks[0]->dataLength) {
+                if ($col >= $this->rsblocks[0]->dataLength) {
                     $row += $this->b1;
                 }
                 $ret = $this->rsblocks[$row]->data[$col];
-            } else if($this->count < $this->dataLength + $this->eccLength) {
+            } else if ($this->count < $this->dataLength + $this->eccLength) {
                 $row = ($this->count - $this->dataLength) % $this->blocks;
                 $col = ($this->count - $this->dataLength) / $this->blocks;
                 $ret = $this->rsblocks[$row]->ecc[$col];
@@ -162,10 +162,10 @@  discard block
 block discarded – undo
         //----------------------------------------------------------------------
         public function encodeMask(QRinput $input, $mask)
         {
-            if($input->getVersion() < 0 || $input->getVersion() > QRSPEC_VERSION_MAX) {
+            if ($input->getVersion() < 0 || $input->getVersion() > QRSPEC_VERSION_MAX) {
                 throw new Exception('wrong version');
             }
-            if($input->getErrorCorrectionLevel() > QR_ECLEVEL_H) {
+            if ($input->getErrorCorrectionLevel() > QR_ECLEVEL_H) {
                 throw new Exception('wrong level');
             }
 
@@ -178,15 +178,15 @@  discard block
 block discarded – undo
             $frame = QRspec::newFrame($version);
             
             $filler = new FrameFiller($width, $frame);
-            if(is_null($filler)) {
+            if (is_null($filler)) {
                 return NULL;
             }
 
             // inteleaved data and ecc codes
-            for($i=0; $i<$raw->dataLength + $raw->eccLength; $i++) {
+            for ($i = 0; $i < $raw->dataLength + $raw->eccLength; $i++) {
                 $code = $raw->getCode();
                 $bit = 0x80;
-                for($j=0; $j<8; $j++) {
+                for ($j = 0; $j < 8; $j++) {
                     $addr = $filler->next();
                     $filler->setFrameAt($addr, 0x02 | (($bit & $code) != 0));
                     $bit = $bit >> 1;
@@ -199,7 +199,7 @@  discard block
 block discarded – undo
             
             // remainder bits
             $j = QRspec::getRemainder($version);
-            for($i=0; $i<$j; $i++) {
+            for ($i = 0; $i < $j; $i++) {
                 $addr = $filler->next();
                 $filler->setFrameAt($addr, 0x02);
             }
@@ -210,7 +210,7 @@  discard block
 block discarded – undo
             
             // masking
             $maskObj = new QRmask();
-            if($mask < 0) {
+            if ($mask < 0) {
             
                 if (QR_FIND_BEST_MASK) {
                     $masked = $maskObj->mask($width, $frame, $input->getErrorCorrectionLevel());
@@ -221,7 +221,7 @@  discard block
 block discarded – undo
                 $masked = $maskObj->makeMask($width, $frame, $mask, $input->getErrorCorrectionLevel());
             }
             
-            if($masked == NULL) {
+            if ($masked == NULL) {
                 return NULL;
             }
             
@@ -243,16 +243,16 @@  discard block
 block discarded – undo
         //----------------------------------------------------------------------
         public function encodeString8bit($string, $version, $level)
         {
-            if(string == NULL) {
+            if (string == NULL) {
                 throw new Exception('empty string!');
                 return NULL;
             }
 
             $input = new QRinput($version, $level);
-            if($input == NULL) return NULL;
+            if ($input == NULL) return NULL;
 
             $ret = $input->append($input, QR_MODE_8, strlen($string), str_split($string));
-            if($ret < 0) {
+            if ($ret < 0) {
                 unset($input);
                 return NULL;
             }
@@ -263,16 +263,16 @@  discard block
 block discarded – undo
         public function encodeString($string, $version, $level, $hint, $casesensitive)
         {
 
-            if($hint != QR_MODE_8 && $hint != QR_MODE_KANJI) {
+            if ($hint != QR_MODE_8 && $hint != QR_MODE_KANJI) {
                 throw new Exception('bad hint');
                 return NULL;
             }
 
             $input = new QRinput($version, $level);
-            if($input == NULL) return NULL;
+            if ($input == NULL) return NULL;
 
             $ret = QRsplit::splitStringToQRinput($string, $input, $hint, $casesensitive);
-            if($ret < 0) {
+            if ($ret < 0) {
                 return NULL;
             }
 
@@ -280,10 +280,10 @@  discard block
 block discarded – undo
         }
         
         //----------------------------------------------------------------------
-        public static function png($text, $outfile = false, $level = QR_ECLEVEL_L, $size = 3, $margin = 4, $saveandprint=false) 
+        public static function png($text, $outfile = false, $level = QR_ECLEVEL_L, $size = 3, $margin = 4, $saveandprint = false) 
         {
             $enc = QRencode::factory($level, $size, $margin);
-            return $enc->encodePNG($text, $outfile, $saveandprint=false);
+            return $enc->encodePNG($text, $outfile, $saveandprint = false);
         }
 
         //----------------------------------------------------------------------
@@ -340,7 +340,7 @@  discard block
 block discarded – undo
         {
             do {
             
-                if($this->bit == -1) {
+                if ($this->bit == -1) {
                     $this->bit = 0;
                     return array('x'=>$this->x, 'y'=>$this->y);
                 }
@@ -349,7 +349,7 @@  discard block
 block discarded – undo
                 $y = $this->y;
                 $w = $this->width;
 
-                if($this->bit == 0) {
+                if ($this->bit == 0) {
                     $x--;
                     $this->bit++;
                 } else {
@@ -358,33 +358,33 @@  discard block
 block discarded – undo
                     $this->bit--;
                 }
 
-                if($this->dir < 0) {
-                    if($y < 0) {
+                if ($this->dir < 0) {
+                    if ($y < 0) {
                         $y = 0;
                         $x -= 2;
                         $this->dir = 1;
-                        if($x == 6) {
+                        if ($x == 6) {
                             $x--;
                             $y = 9;
                         }
                     }
                 } else {
-                    if($y == $w) {
+                    if ($y == $w) {
                         $y = $w - 1;
                         $x -= 2;
                         $this->dir = -1;
-                        if($x == 6) {
+                        if ($x == 6) {
                             $x--;
                             $y -= 8;
                         }
                     }
                 }
-                if($x < 0 || $y < 0) return null;
+                if ($x < 0 || $y < 0) return null;
 
                 $this->x = $x;
                 $this->y = $y;
 
-            } while(ord($this->frame[$y][$x]) & 0x80);
+            } while (ord($this->frame[$y][$x]) & 0x80);
                         
             return array('x'=>$x, 'y'=>$y);
         }
@@ -447,7 +447,7 @@  discard block
 block discarded – undo
         {
             $code = new QRcode();
 
-            if($this->eightbit) {
+            if ($this->eightbit) {
                 $code->encodeString8bit($intext, $this->version, $this->level);
             } else {
                 $code->encodeString($intext, $this->version, $this->level, $this->hint, $this->casesensitive);
@@ -461,7 +461,7 @@  discard block
 block discarded – undo
         {
             $code = new QRcode();
 
-            if($this->eightbit) {
+            if ($this->eightbit) {
                 $code->encodeString8bit($intext, $this->version, $this->level);
             } else {
                 $code->encodeString($intext, $this->version, $this->level, $this->hint, $this->casesensitive);
@@ -469,7 +469,7 @@  discard block
 block discarded – undo
             
             QRtools::markTime('after_encode');
             
-            if ($outfile!== false) {
+            if ($outfile !== false) {
                 file_put_contents($outfile, join("\n", QRtools::binarize($code->data)));
             } else {
                 return QRtools::binarize($code->data);
@@ -477,7 +477,7 @@  discard block
 block discarded – undo
         }
         
         //----------------------------------------------------------------------
-        public function encodePNG($intext, $outfile = false,$saveandprint=false) 
+        public function encodePNG($intext, $outfile = false, $saveandprint = false) 
         {
             try {
             
@@ -489,9 +489,9 @@  discard block
 block discarded – undo
                 if ($err != '')
                     QRtools::log($outfile, $err);
                 
-                $maxSize = (int)(QR_PNG_MAXIMUM_SIZE / (count($tab)+2*$this->margin));
+                $maxSize = (int) (QR_PNG_MAXIMUM_SIZE / (count($tab) + 2 * $this->margin));
                 
-                QRimage::png($tab, $outfile, min(max(1, $this->size), $maxSize), $this->margin,$saveandprint);
+                QRimage::png($tab, $outfile, min(max(1, $this->size), $maxSize), $this->margin, $saveandprint);
             
             } catch (Exception $e) {
             

Please login to merge, or discard this patch.

Braces +18 added lines, -8 removed lines patch added patch discarded remove patch

@@ -104,14 +104,17 @@  discard block
 block discarded – undo
                 $blockNo++;
             }
 
-            if(QRspec::rsBlockNum2($spec) == 0)
-                return 0;
+            if(QRspec::rsBlockNum2($spec) == 0) {
+                            return 0;
+            }
 
             $dl = QRspec::rsDataCodes2($spec);
             $el = QRspec::rsEccCodes2($spec);
             $rs = QRrs::init_rs(8, 0x11d, 0, 1, $el, 255 - $dl - $el);
             
-            if($rs == NULL) return -1;
+            if($rs == NULL) {
+            	return -1;
+            }
             
             for($i=0; $i<QRspec::rsBlockNum2($spec); $i++) {
                 $ecc = array_slice($this->ecccode,$eccPos);
@@ -249,7 +252,9 @@  discard block
 block discarded – undo
             }
 
             $input = new QRinput($version, $level);
-            if($input == NULL) return NULL;
+            if($input == NULL) {
+            	return NULL;
+            }
 
             $ret = $input->append($input, QR_MODE_8, strlen($string), str_split($string));
             if($ret < 0) {
@@ -269,7 +274,9 @@  discard block
 block discarded – undo
             }
 
             $input = new QRinput($version, $level);
-            if($input == NULL) return NULL;
+            if($input == NULL) {
+            	return NULL;
+            }
 
             $ret = QRsplit::splitStringToQRinput($string, $input, $hint, $casesensitive);
             if($ret < 0) {
@@ -379,7 +386,9 @@  discard block
 block discarded – undo
                         }
                     }
                 }
-                if($x < 0 || $y < 0) return null;
+                if($x < 0 || $y < 0) {
+                	return null;
+                }
 
                 $this->x = $x;
                 $this->y = $y;
@@ -486,8 +495,9 @@  discard block
 block discarded – undo
                 $err = ob_get_contents();
                 ob_end_clean();
                 
-                if ($err != '')
-                    QRtools::log($outfile, $err);
+                if ($err != '') {
+                                    QRtools::log($outfile, $err);
+                }
                 
                 $maxSize = (int)(QR_PNG_MAXIMUM_SIZE / (count($tab)+2*$this->margin));
                 

Please login to merge, or discard this patch.

lib/phpqrcode/qrrscode.php 3 patches

Indentation +146 added lines, -146 removed lines patch added patch discarded remove patch

@@ -28,183 +28,183 @@
 block discarded – undo
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  */
  
-    class QRrsItem {
+	class QRrsItem {
     
-        public $mm;                  // Bits per symbol 
-        public $nn;                  // Symbols per block (= (1<<mm)-1) 
-        public $alpha_to = array();  // log lookup table 
-        public $index_of = array();  // Antilog lookup table 
-        public $genpoly = array();   // Generator polynomial 
-        public $nroots;              // Number of generator roots = number of parity symbols 
-        public $fcr;                 // First consecutive root, index form 
-        public $prim;                // Primitive element, index form 
-        public $iprim;               // prim-th root of 1, index form 
-        public $pad;                 // Padding bytes in shortened block 
-        public $gfpoly;
+		public $mm;                  // Bits per symbol 
+		public $nn;                  // Symbols per block (= (1<<mm)-1) 
+		public $alpha_to = array();  // log lookup table 
+		public $index_of = array();  // Antilog lookup table 
+		public $genpoly = array();   // Generator polynomial 
+		public $nroots;              // Number of generator roots = number of parity symbols 
+		public $fcr;                 // First consecutive root, index form 
+		public $prim;                // Primitive element, index form 
+		public $iprim;               // prim-th root of 1, index form 
+		public $pad;                 // Padding bytes in shortened block 
+		public $gfpoly;
     
-        //----------------------------------------------------------------------
-        public function modnn($x)
-        {
-            while ($x >= $this->nn) {
-                $x -= $this->nn;
-                $x = ($x >> $this->mm) + ($x & $this->nn);
-            }
+		//----------------------------------------------------------------------
+		public function modnn($x)
+		{
+			while ($x >= $this->nn) {
+				$x -= $this->nn;
+				$x = ($x >> $this->mm) + ($x & $this->nn);
+			}
             
-            return $x;
-        }
+			return $x;
+		}
         
-        //----------------------------------------------------------------------
-        public static function init_rs_char($symsize, $gfpoly, $fcr, $prim, $nroots, $pad)
-        {
-            // Common code for intializing a Reed-Solomon control block (char or int symbols)
-            // Copyright 2004 Phil Karn, KA9Q
-            // May be used under the terms of the GNU Lesser General Public License (LGPL)
+		//----------------------------------------------------------------------
+		public static function init_rs_char($symsize, $gfpoly, $fcr, $prim, $nroots, $pad)
+		{
+			// Common code for intializing a Reed-Solomon control block (char or int symbols)
+			// Copyright 2004 Phil Karn, KA9Q
+			// May be used under the terms of the GNU Lesser General Public License (LGPL)
 
-            $rs = null;
+			$rs = null;
             
-            // Check parameter ranges
-            if($symsize < 0 || $symsize > 8)                     return $rs;
-            if($fcr < 0 || $fcr >= (1<<$symsize))                return $rs;
-            if($prim <= 0 || $prim >= (1<<$symsize))             return $rs;
-            if($nroots < 0 || $nroots >= (1<<$symsize))          return $rs; // Can't have more roots than symbol values!
-            if($pad < 0 || $pad >= ((1<<$symsize) -1 - $nroots)) return $rs; // Too much padding
+			// Check parameter ranges
+			if($symsize < 0 || $symsize > 8)                     return $rs;
+			if($fcr < 0 || $fcr >= (1<<$symsize))                return $rs;
+			if($prim <= 0 || $prim >= (1<<$symsize))             return $rs;
+			if($nroots < 0 || $nroots >= (1<<$symsize))          return $rs; // Can't have more roots than symbol values!
+			if($pad < 0 || $pad >= ((1<<$symsize) -1 - $nroots)) return $rs; // Too much padding
 
-            $rs = new QRrsItem();
-            $rs->mm = $symsize;
-            $rs->nn = (1<<$symsize)-1;
-            $rs->pad = $pad;
+			$rs = new QRrsItem();
+			$rs->mm = $symsize;
+			$rs->nn = (1<<$symsize)-1;
+			$rs->pad = $pad;
 
-            $rs->alpha_to = array_fill(0, $rs->nn+1, 0);
-            $rs->index_of = array_fill(0, $rs->nn+1, 0);
+			$rs->alpha_to = array_fill(0, $rs->nn+1, 0);
+			$rs->index_of = array_fill(0, $rs->nn+1, 0);
           
-            // PHP style macro replacement ;)
-            $NN =& $rs->nn;
-            $A0 =& $NN;
+			// PHP style macro replacement ;)
+			$NN =& $rs->nn;
+			$A0 =& $NN;
             
-            // Generate Galois field lookup tables
-            $rs->index_of[0] = $A0; // log(zero) = -inf
-            $rs->alpha_to[$A0] = 0; // alpha**-inf = 0
-            $sr = 1;
+			// Generate Galois field lookup tables
+			$rs->index_of[0] = $A0; // log(zero) = -inf
+			$rs->alpha_to[$A0] = 0; // alpha**-inf = 0
+			$sr = 1;
           
-            for($i=0; $i<$rs->nn; $i++) {
-                $rs->index_of[$sr] = $i;
-                $rs->alpha_to[$i] = $sr;
-                $sr <<= 1;
-                if($sr & (1<<$symsize)) {
-                    $sr ^= $gfpoly;
-                }
-                $sr &= $rs->nn;
-            }
+			for($i=0; $i<$rs->nn; $i++) {
+				$rs->index_of[$sr] = $i;
+				$rs->alpha_to[$i] = $sr;
+				$sr <<= 1;
+				if($sr & (1<<$symsize)) {
+					$sr ^= $gfpoly;
+				}
+				$sr &= $rs->nn;
+			}
             
-            if($sr != 1){
-                // field generator polynomial is not primitive!
-                $rs = NULL;
-                return $rs;
-            }
+			if($sr != 1){
+				// field generator polynomial is not primitive!
+				$rs = NULL;
+				return $rs;
+			}
 
-            /* Form RS code generator polynomial from its roots */
-            $rs->genpoly = array_fill(0, $nroots+1, 0);
+			/* Form RS code generator polynomial from its roots */
+			$rs->genpoly = array_fill(0, $nroots+1, 0);
         
-            $rs->fcr = $fcr;
-            $rs->prim = $prim;
-            $rs->nroots = $nroots;
-            $rs->gfpoly = $gfpoly;
+			$rs->fcr = $fcr;
+			$rs->prim = $prim;
+			$rs->nroots = $nroots;
+			$rs->gfpoly = $gfpoly;
 
-            /* Find prim-th root of 1, used in decoding */
-            for($iprim=1;($iprim % $prim) != 0;$iprim += $rs->nn)
-            ; // intentional empty-body loop!
+			/* Find prim-th root of 1, used in decoding */
+			for($iprim=1;($iprim % $prim) != 0;$iprim += $rs->nn)
+			; // intentional empty-body loop!
             
-            $rs->iprim = (int)($iprim / $prim);
-            $rs->genpoly[0] = 1;
+			$rs->iprim = (int)($iprim / $prim);
+			$rs->genpoly[0] = 1;
             
-            for ($i = 0,$root=$fcr*$prim; $i < $nroots; $i++, $root += $prim) {
-                $rs->genpoly[$i+1] = 1;
+			for ($i = 0,$root=$fcr*$prim; $i < $nroots; $i++, $root += $prim) {
+				$rs->genpoly[$i+1] = 1;
 
-                // Multiply rs->genpoly[] by  @**(root + x)
-                for ($j = $i; $j > 0; $j--) {
-                    if ($rs->genpoly[$j] != 0) {
-                        $rs->genpoly[$j] = $rs->genpoly[$j-1] ^ $rs->alpha_to[$rs->modnn($rs->index_of[$rs->genpoly[$j]] + $root)];
-                    } else {
-                        $rs->genpoly[$j] = $rs->genpoly[$j-1];
-                    }
-                }
-                // rs->genpoly[0] can never be zero
-                $rs->genpoly[0] = $rs->alpha_to[$rs->modnn($rs->index_of[$rs->genpoly[0]] + $root)];
-            }
+				// Multiply rs->genpoly[] by  @**(root + x)
+				for ($j = $i; $j > 0; $j--) {
+					if ($rs->genpoly[$j] != 0) {
+						$rs->genpoly[$j] = $rs->genpoly[$j-1] ^ $rs->alpha_to[$rs->modnn($rs->index_of[$rs->genpoly[$j]] + $root)];
+					} else {
+						$rs->genpoly[$j] = $rs->genpoly[$j-1];
+					}
+				}
+				// rs->genpoly[0] can never be zero
+				$rs->genpoly[0] = $rs->alpha_to[$rs->modnn($rs->index_of[$rs->genpoly[0]] + $root)];
+			}
             
-            // convert rs->genpoly[] to index form for quicker encoding
-            for ($i = 0; $i <= $nroots; $i++)
-                $rs->genpoly[$i] = $rs->index_of[$rs->genpoly[$i]];
+			// convert rs->genpoly[] to index form for quicker encoding
+			for ($i = 0; $i <= $nroots; $i++)
+				$rs->genpoly[$i] = $rs->index_of[$rs->genpoly[$i]];
 
-            return $rs;
-        }
+			return $rs;
+		}
         
-        //----------------------------------------------------------------------
-        public function encode_rs_char($data, &$parity)
-        {
-            $MM       =& $this->mm;
-            $NN       =& $this->nn;
-            $ALPHA_TO =& $this->alpha_to;
-            $INDEX_OF =& $this->index_of;
-            $GENPOLY  =& $this->genpoly;
-            $NROOTS   =& $this->nroots;
-            $FCR      =& $this->fcr;
-            $PRIM     =& $this->prim;
-            $IPRIM    =& $this->iprim;
-            $PAD      =& $this->pad;
-            $A0       =& $NN;
+		//----------------------------------------------------------------------
+		public function encode_rs_char($data, &$parity)
+		{
+			$MM       =& $this->mm;
+			$NN       =& $this->nn;
+			$ALPHA_TO =& $this->alpha_to;
+			$INDEX_OF =& $this->index_of;
+			$GENPOLY  =& $this->genpoly;
+			$NROOTS   =& $this->nroots;
+			$FCR      =& $this->fcr;
+			$PRIM     =& $this->prim;
+			$IPRIM    =& $this->iprim;
+			$PAD      =& $this->pad;
+			$A0       =& $NN;
 
-            $parity = array_fill(0, $NROOTS, 0);
+			$parity = array_fill(0, $NROOTS, 0);
 
-            for($i=0; $i< ($NN-$NROOTS-$PAD); $i++) {
+			for($i=0; $i< ($NN-$NROOTS-$PAD); $i++) {
                 
-                $feedback = $INDEX_OF[$data[$i] ^ $parity[0]];
-                if($feedback != $A0) {      
-                    // feedback term is non-zero
+				$feedback = $INDEX_OF[$data[$i] ^ $parity[0]];
+				if($feedback != $A0) {      
+					// feedback term is non-zero
             
-                    // This line is unnecessary when GENPOLY[NROOTS] is unity, as it must
-                    // always be for the polynomials constructed by init_rs()
-                    $feedback = $this->modnn($NN - $GENPOLY[$NROOTS] + $feedback);
+					// This line is unnecessary when GENPOLY[NROOTS] is unity, as it must
+					// always be for the polynomials constructed by init_rs()
+					$feedback = $this->modnn($NN - $GENPOLY[$NROOTS] + $feedback);
             
-                    for($j=1;$j<$NROOTS;$j++) {
-                        $parity[$j] ^= $ALPHA_TO[$this->modnn($feedback + $GENPOLY[$NROOTS-$j])];
-                    }
-                }
+					for($j=1;$j<$NROOTS;$j++) {
+						$parity[$j] ^= $ALPHA_TO[$this->modnn($feedback + $GENPOLY[$NROOTS-$j])];
+					}
+				}
                 
-                // Shift 
-                array_shift($parity);
-                if($feedback != $A0) {
-                    array_push($parity, $ALPHA_TO[$this->modnn($feedback + $GENPOLY[0])]);
-                } else {
-                    array_push($parity, 0);
-                }
-            }
-        }
-    }
+				// Shift 
+				array_shift($parity);
+				if($feedback != $A0) {
+					array_push($parity, $ALPHA_TO[$this->modnn($feedback + $GENPOLY[0])]);
+				} else {
+					array_push($parity, 0);
+				}
+			}
+		}
+	}
     
-    //##########################################################################
+	//##########################################################################
     
-    class QRrs {
+	class QRrs {
     
-        public static $items = array();
+		public static $items = array();
         
-        //----------------------------------------------------------------------
-        public static function init_rs($symsize, $gfpoly, $fcr, $prim, $nroots, $pad)
-        {
-            foreach(self::$items as $rs) {
-                if($rs->pad != $pad)       continue;
-                if($rs->nroots != $nroots) continue;
-                if($rs->mm != $symsize)    continue;
-                if($rs->gfpoly != $gfpoly) continue;
-                if($rs->fcr != $fcr)       continue;
-                if($rs->prim != $prim)     continue;
+		//----------------------------------------------------------------------
+		public static function init_rs($symsize, $gfpoly, $fcr, $prim, $nroots, $pad)
+		{
+			foreach(self::$items as $rs) {
+				if($rs->pad != $pad)       continue;
+				if($rs->nroots != $nroots) continue;
+				if($rs->mm != $symsize)    continue;
+				if($rs->gfpoly != $gfpoly) continue;
+				if($rs->fcr != $fcr)       continue;
+				if($rs->prim != $prim)     continue;
 
-                return $rs;
-            }
+				return $rs;
+			}
 
-            $rs = QRrsItem::init_rs_char($symsize, $gfpoly, $fcr, $prim, $nroots, $pad);
-            array_unshift(self::$items, $rs);
+			$rs = QRrsItem::init_rs_char($symsize, $gfpoly, $fcr, $prim, $nroots, $pad);
+			array_unshift(self::$items, $rs);
 
-            return $rs;
-        }
-    }
\ No newline at end of file
+			return $rs;
+		}
+	}
\ No newline at end of file

Please login to merge, or discard this patch.

Spacing +53 added lines, -53 removed lines patch added patch discarded remove patch

@@ -30,16 +30,16 @@  discard block
 block discarded – undo
  
     class QRrsItem {
     
-        public $mm;                  // Bits per symbol 
-        public $nn;                  // Symbols per block (= (1<<mm)-1) 
-        public $alpha_to = array();  // log lookup table 
-        public $index_of = array();  // Antilog lookup table 
-        public $genpoly = array();   // Generator polynomial 
-        public $nroots;              // Number of generator roots = number of parity symbols 
-        public $fcr;                 // First consecutive root, index form 
-        public $prim;                // Primitive element, index form 
-        public $iprim;               // prim-th root of 1, index form 
-        public $pad;                 // Padding bytes in shortened block 
+        public $mm; // Bits per symbol 
+        public $nn; // Symbols per block (= (1<<mm)-1) 
+        public $alpha_to = array(); // log lookup table 
+        public $index_of = array(); // Antilog lookup table 
+        public $genpoly = array(); // Generator polynomial 
+        public $nroots; // Number of generator roots = number of parity symbols 
+        public $fcr; // First consecutive root, index form 
+        public $prim; // Primitive element, index form 
+        public $iprim; // prim-th root of 1, index form 
+        public $pad; // Padding bytes in shortened block 
         public $gfpoly;
     
         //----------------------------------------------------------------------
@@ -63,47 +63,47 @@  discard block
 block discarded – undo
             $rs = null;
             
             // Check parameter ranges
-            if($symsize < 0 || $symsize > 8)                     return $rs;
-            if($fcr < 0 || $fcr >= (1<<$symsize))                return $rs;
-            if($prim <= 0 || $prim >= (1<<$symsize))             return $rs;
-            if($nroots < 0 || $nroots >= (1<<$symsize))          return $rs; // Can't have more roots than symbol values!
-            if($pad < 0 || $pad >= ((1<<$symsize) -1 - $nroots)) return $rs; // Too much padding
+            if ($symsize < 0 || $symsize > 8)                     return $rs;
+            if ($fcr < 0 || $fcr >= (1 << $symsize))                return $rs;
+            if ($prim <= 0 || $prim >= (1 << $symsize))             return $rs;
+            if ($nroots < 0 || $nroots >= (1 << $symsize))          return $rs; // Can't have more roots than symbol values!
+            if ($pad < 0 || $pad >= ((1 << $symsize) - 1 - $nroots)) return $rs; // Too much padding
 
             $rs = new QRrsItem();
             $rs->mm = $symsize;
-            $rs->nn = (1<<$symsize)-1;
+            $rs->nn = (1 << $symsize) - 1;
             $rs->pad = $pad;
 
-            $rs->alpha_to = array_fill(0, $rs->nn+1, 0);
-            $rs->index_of = array_fill(0, $rs->nn+1, 0);
+            $rs->alpha_to = array_fill(0, $rs->nn + 1, 0);
+            $rs->index_of = array_fill(0, $rs->nn + 1, 0);
           
             // PHP style macro replacement ;)
-            $NN =& $rs->nn;
-            $A0 =& $NN;
+            $NN = & $rs->nn;
+            $A0 = & $NN;
             
             // Generate Galois field lookup tables
             $rs->index_of[0] = $A0; // log(zero) = -inf
             $rs->alpha_to[$A0] = 0; // alpha**-inf = 0
             $sr = 1;
           
-            for($i=0; $i<$rs->nn; $i++) {
+            for ($i = 0; $i < $rs->nn; $i++) {
                 $rs->index_of[$sr] = $i;
                 $rs->alpha_to[$i] = $sr;
                 $sr <<= 1;
-                if($sr & (1<<$symsize)) {
+                if ($sr & (1 << $symsize)) {
                     $sr ^= $gfpoly;
                 }
                 $sr &= $rs->nn;
             }
             
-            if($sr != 1){
+            if ($sr != 1) {
                 // field generator polynomial is not primitive!
                 $rs = NULL;
                 return $rs;
             }
 
             /* Form RS code generator polynomial from its roots */
-            $rs->genpoly = array_fill(0, $nroots+1, 0);
+            $rs->genpoly = array_fill(0, $nroots + 1, 0);
         
             $rs->fcr = $fcr;
             $rs->prim = $prim;
@@ -111,21 +111,21 @@  discard block
 block discarded – undo
             $rs->gfpoly = $gfpoly;
 
             /* Find prim-th root of 1, used in decoding */
-            for($iprim=1;($iprim % $prim) != 0;$iprim += $rs->nn)
+            for ($iprim = 1; ($iprim % $prim) != 0; $iprim += $rs->nn)
             ; // intentional empty-body loop!
             
-            $rs->iprim = (int)($iprim / $prim);
+            $rs->iprim = (int) ($iprim / $prim);
             $rs->genpoly[0] = 1;
             
-            for ($i = 0,$root=$fcr*$prim; $i < $nroots; $i++, $root += $prim) {
-                $rs->genpoly[$i+1] = 1;
+            for ($i = 0, $root = $fcr * $prim; $i < $nroots; $i++, $root += $prim) {
+                $rs->genpoly[$i + 1] = 1;
 
                 // Multiply rs->genpoly[] by  @**(root + x)
                 for ($j = $i; $j > 0; $j--) {
                     if ($rs->genpoly[$j] != 0) {
-                        $rs->genpoly[$j] = $rs->genpoly[$j-1] ^ $rs->alpha_to[$rs->modnn($rs->index_of[$rs->genpoly[$j]] + $root)];
+                        $rs->genpoly[$j] = $rs->genpoly[$j - 1] ^ $rs->alpha_to[$rs->modnn($rs->index_of[$rs->genpoly[$j]] + $root)];
                     } else {
-                        $rs->genpoly[$j] = $rs->genpoly[$j-1];
+                        $rs->genpoly[$j] = $rs->genpoly[$j - 1];
                     }
                 }
                 // rs->genpoly[0] can never be zero
@@ -142,38 +142,38 @@  discard block
 block discarded – undo
         //----------------------------------------------------------------------
         public function encode_rs_char($data, &$parity)
         {
-            $MM       =& $this->mm;
-            $NN       =& $this->nn;
-            $ALPHA_TO =& $this->alpha_to;
-            $INDEX_OF =& $this->index_of;
-            $GENPOLY  =& $this->genpoly;
-            $NROOTS   =& $this->nroots;
-            $FCR      =& $this->fcr;
-            $PRIM     =& $this->prim;
-            $IPRIM    =& $this->iprim;
-            $PAD      =& $this->pad;
-            $A0       =& $NN;
+            $MM       = & $this->mm;
+            $NN       = & $this->nn;
+            $ALPHA_TO = & $this->alpha_to;
+            $INDEX_OF = & $this->index_of;
+            $GENPOLY  = & $this->genpoly;
+            $NROOTS   = & $this->nroots;
+            $FCR      = & $this->fcr;
+            $PRIM     = & $this->prim;
+            $IPRIM    = & $this->iprim;
+            $PAD      = & $this->pad;
+            $A0       = & $NN;
 
             $parity = array_fill(0, $NROOTS, 0);
 
-            for($i=0; $i< ($NN-$NROOTS-$PAD); $i++) {
+            for ($i = 0; $i < ($NN - $NROOTS - $PAD); $i++) {
                 
                 $feedback = $INDEX_OF[$data[$i] ^ $parity[0]];
-                if($feedback != $A0) {      
+                if ($feedback != $A0) {      
                     // feedback term is non-zero
             
                     // This line is unnecessary when GENPOLY[NROOTS] is unity, as it must
                     // always be for the polynomials constructed by init_rs()
                     $feedback = $this->modnn($NN - $GENPOLY[$NROOTS] + $feedback);
             
-                    for($j=1;$j<$NROOTS;$j++) {
-                        $parity[$j] ^= $ALPHA_TO[$this->modnn($feedback + $GENPOLY[$NROOTS-$j])];
+                    for ($j = 1; $j < $NROOTS; $j++) {
+                        $parity[$j] ^= $ALPHA_TO[$this->modnn($feedback + $GENPOLY[$NROOTS - $j])];
                     }
                 }
                 
                 // Shift 
                 array_shift($parity);
-                if($feedback != $A0) {
+                if ($feedback != $A0) {
                     array_push($parity, $ALPHA_TO[$this->modnn($feedback + $GENPOLY[0])]);
                 } else {
                     array_push($parity, 0);
@@ -191,13 +191,13 @@  discard block
 block discarded – undo
         //----------------------------------------------------------------------
         public static function init_rs($symsize, $gfpoly, $fcr, $prim, $nroots, $pad)
         {
-            foreach(self::$items as $rs) {
-                if($rs->pad != $pad)       continue;
-                if($rs->nroots != $nroots) continue;
-                if($rs->mm != $symsize)    continue;
-                if($rs->gfpoly != $gfpoly) continue;
-                if($rs->fcr != $fcr)       continue;
-                if($rs->prim != $prim)     continue;
+            foreach (self::$items as $rs) {
+                if ($rs->pad != $pad)       continue;
+                if ($rs->nroots != $nroots) continue;
+                if ($rs->mm != $symsize)    continue;
+                if ($rs->gfpoly != $gfpoly) continue;
+                if ($rs->fcr != $fcr)       continue;
+                if ($rs->prim != $prim)     continue;
 
                 return $rs;
             }

Please login to merge, or discard this patch.

Braces +38 added lines, -13 removed lines patch added patch discarded remove patch

@@ -63,11 +63,23 @@  discard block
 block discarded – undo
             $rs = null;
             
             // Check parameter ranges
-            if($symsize < 0 || $symsize > 8)                     return $rs;
-            if($fcr < 0 || $fcr >= (1<<$symsize))                return $rs;
-            if($prim <= 0 || $prim >= (1<<$symsize))             return $rs;
-            if($nroots < 0 || $nroots >= (1<<$symsize))          return $rs; // Can't have more roots than symbol values!
-            if($pad < 0 || $pad >= ((1<<$symsize) -1 - $nroots)) return $rs; // Too much padding
+            if($symsize < 0 || $symsize > 8) {
+            	return $rs;
+            }
+            if($fcr < 0 || $fcr >= (1<<$symsize)) {
+            	return $rs;
+            }
+            if($prim <= 0 || $prim >= (1<<$symsize)) {
+            	return $rs;
+            }
+            if($nroots < 0 || $nroots >= (1<<$symsize)) {
+            	return $rs;
+            }
+            // Can't have more roots than symbol values!
+            if($pad < 0 || $pad >= ((1<<$symsize) -1 - $nroots)) {
+            	return $rs;
+            }
+            // Too much padding
 
             $rs = new QRrsItem();
             $rs->mm = $symsize;
@@ -133,8 +145,9 @@  discard block
 block discarded – undo
             }
             
             // convert rs->genpoly[] to index form for quicker encoding
-            for ($i = 0; $i <= $nroots; $i++)
-                $rs->genpoly[$i] = $rs->index_of[$rs->genpoly[$i]];
+            for ($i = 0; $i <= $nroots; $i++) {
+                            $rs->genpoly[$i] = $rs->index_of[$rs->genpoly[$i]];
+            }
 
             return $rs;
         }
@@ -192,12 +205,24 @@  discard block
 block discarded – undo
         public static function init_rs($symsize, $gfpoly, $fcr, $prim, $nroots, $pad)
         {
             foreach(self::$items as $rs) {
-                if($rs->pad != $pad)       continue;
-                if($rs->nroots != $nroots) continue;
-                if($rs->mm != $symsize)    continue;
-                if($rs->gfpoly != $gfpoly) continue;
-                if($rs->fcr != $fcr)       continue;
-                if($rs->prim != $prim)     continue;
+                if($rs->pad != $pad) {
+                	continue;
+                }
+                if($rs->nroots != $nroots) {
+                	continue;
+                }
+                if($rs->mm != $symsize) {
+                	continue;
+                }
+                if($rs->gfpoly != $gfpoly) {
+                	continue;
+                }
+                if($rs->fcr != $fcr) {
+                	continue;
+                }
+                if($rs->prim != $prim) {
+                	continue;
+                }
 
                 return $rs;
             }

Please login to merge, or discard this patch.

lib/phpqrcode/qrspec.php 3 patches

Indentation +484 added lines, -484 removed lines patch added patch discarded remove patch

		@@ -31,497 +31,497 @@ discard block
		block discarded – undo
31	31	* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
32	32	*/
33	33
34		- define('QRSPEC_VERSION_MAX', 40);
35		- define('QRSPEC_WIDTH_MAX', 177);
	34	+ define('QRSPEC_VERSION_MAX', 40);
	35	+ define('QRSPEC_WIDTH_MAX', 177);
36	36
37		- define('QRCAP_WIDTH', 0);
38		- define('QRCAP_WORDS', 1);
39		- define('QRCAP_REMINDER', 2);
40		- define('QRCAP_EC', 3);
	37	+ define('QRCAP_WIDTH', 0);
	38	+ define('QRCAP_WORDS', 1);
	39	+ define('QRCAP_REMINDER', 2);
	40	+ define('QRCAP_EC', 3);
41	41
42		- class QRspec {
	42	+ class QRspec {
43	43
44		- public static $capacity = array(
45		- array( 0, 0, 0, array( 0, 0, 0, 0)),
46		- array( 21, 26, 0, array( 7, 10, 13, 17)), // 1
47		- array( 25, 44, 7, array( 10, 16, 22, 28)),
48		- array( 29, 70, 7, array( 15, 26, 36, 44)),
49		- array( 33, 100, 7, array( 20, 36, 52, 64)),
50		- array( 37, 134, 7, array( 26, 48, 72, 88)), // 5
51		- array( 41, 172, 7, array( 36, 64, 96, 112)),
52		- array( 45, 196, 0, array( 40, 72, 108, 130)),
53		- array( 49, 242, 0, array( 48, 88, 132, 156)),
54		- array( 53, 292, 0, array( 60, 110, 160, 192)),
55		- array( 57, 346, 0, array( 72, 130, 192, 224)), //10
56		- array( 61, 404, 0, array( 80, 150, 224, 264)),
57		- array( 65, 466, 0, array( 96, 176, 260, 308)),
58		- array( 69, 532, 0, array( 104, 198, 288, 352)),
59		- array( 73, 581, 3, array( 120, 216, 320, 384)),
60		- array( 77, 655, 3, array( 132, 240, 360, 432)), //15
61		- array( 81, 733, 3, array( 144, 280, 408, 480)),
62		- array( 85, 815, 3, array( 168, 308, 448, 532)),
63		- array( 89, 901, 3, array( 180, 338, 504, 588)),
64		- array( 93, 991, 3, array( 196, 364, 546, 650)),
65		- array( 97, 1085, 3, array( 224, 416, 600, 700)), //20
66		- array(101, 1156, 4, array( 224, 442, 644, 750)),
67		- array(105, 1258, 4, array( 252, 476, 690, 816)),
68		- array(109, 1364, 4, array( 270, 504, 750, 900)),
69		- array(113, 1474, 4, array( 300, 560, 810, 960)),
70		- array(117, 1588, 4, array( 312, 588, 870, 1050)), //25
71		- array(121, 1706, 4, array( 336, 644, 952, 1110)),
72		- array(125, 1828, 4, array( 360, 700, 1020, 1200)),
73		- array(129, 1921, 3, array( 390, 728, 1050, 1260)),
74		- array(133, 2051, 3, array( 420, 784, 1140, 1350)),
75		- array(137, 2185, 3, array( 450, 812, 1200, 1440)), //30
76		- array(141, 2323, 3, array( 480, 868, 1290, 1530)),
77		- array(145, 2465, 3, array( 510, 924, 1350, 1620)),
78		- array(149, 2611, 3, array( 540, 980, 1440, 1710)),
79		- array(153, 2761, 3, array( 570, 1036, 1530, 1800)),
80		- array(157, 2876, 0, array( 570, 1064, 1590, 1890)), //35
81		- array(161, 3034, 0, array( 600, 1120, 1680, 1980)),
82		- array(165, 3196, 0, array( 630, 1204, 1770, 2100)),
83		- array(169, 3362, 0, array( 660, 1260, 1860, 2220)),
84		- array(173, 3532, 0, array( 720, 1316, 1950, 2310)),
85		- array(177, 3706, 0, array( 750, 1372, 2040, 2430)) //40
86		- );
	44	+ public static $capacity = array(
	45	+ array( 0, 0, 0, array( 0, 0, 0, 0)),
	46	+ array( 21, 26, 0, array( 7, 10, 13, 17)), // 1
	47	+ array( 25, 44, 7, array( 10, 16, 22, 28)),
	48	+ array( 29, 70, 7, array( 15, 26, 36, 44)),
	49	+ array( 33, 100, 7, array( 20, 36, 52, 64)),
	50	+ array( 37, 134, 7, array( 26, 48, 72, 88)), // 5
	51	+ array( 41, 172, 7, array( 36, 64, 96, 112)),
	52	+ array( 45, 196, 0, array( 40, 72, 108, 130)),
	53	+ array( 49, 242, 0, array( 48, 88, 132, 156)),
	54	+ array( 53, 292, 0, array( 60, 110, 160, 192)),
	55	+ array( 57, 346, 0, array( 72, 130, 192, 224)), //10
	56	+ array( 61, 404, 0, array( 80, 150, 224, 264)),
	57	+ array( 65, 466, 0, array( 96, 176, 260, 308)),
	58	+ array( 69, 532, 0, array( 104, 198, 288, 352)),
	59	+ array( 73, 581, 3, array( 120, 216, 320, 384)),
	60	+ array( 77, 655, 3, array( 132, 240, 360, 432)), //15
	61	+ array( 81, 733, 3, array( 144, 280, 408, 480)),
	62	+ array( 85, 815, 3, array( 168, 308, 448, 532)),
	63	+ array( 89, 901, 3, array( 180, 338, 504, 588)),
	64	+ array( 93, 991, 3, array( 196, 364, 546, 650)),
	65	+ array( 97, 1085, 3, array( 224, 416, 600, 700)), //20
	66	+ array(101, 1156, 4, array( 224, 442, 644, 750)),
	67	+ array(105, 1258, 4, array( 252, 476, 690, 816)),
	68	+ array(109, 1364, 4, array( 270, 504, 750, 900)),
	69	+ array(113, 1474, 4, array( 300, 560, 810, 960)),
	70	+ array(117, 1588, 4, array( 312, 588, 870, 1050)), //25
	71	+ array(121, 1706, 4, array( 336, 644, 952, 1110)),
	72	+ array(125, 1828, 4, array( 360, 700, 1020, 1200)),
	73	+ array(129, 1921, 3, array( 390, 728, 1050, 1260)),
	74	+ array(133, 2051, 3, array( 420, 784, 1140, 1350)),
	75	+ array(137, 2185, 3, array( 450, 812, 1200, 1440)), //30
	76	+ array(141, 2323, 3, array( 480, 868, 1290, 1530)),
	77	+ array(145, 2465, 3, array( 510, 924, 1350, 1620)),
	78	+ array(149, 2611, 3, array( 540, 980, 1440, 1710)),
	79	+ array(153, 2761, 3, array( 570, 1036, 1530, 1800)),
	80	+ array(157, 2876, 0, array( 570, 1064, 1590, 1890)), //35
	81	+ array(161, 3034, 0, array( 600, 1120, 1680, 1980)),
	82	+ array(165, 3196, 0, array( 630, 1204, 1770, 2100)),
	83	+ array(169, 3362, 0, array( 660, 1260, 1860, 2220)),
	84	+ array(173, 3532, 0, array( 720, 1316, 1950, 2310)),
	85	+ array(177, 3706, 0, array( 750, 1372, 2040, 2430)) //40
	86	+ );
87	87
88		- //----------------------------------------------------------------------
89		- public static function getDataLength($version, $level)
90		- {
91		- return self::$capacity[$version][QRCAP_WORDS] - self::$capacity[$version][QRCAP_EC][$level];
92		- }
	88	+ //----------------------------------------------------------------------
	89	+ public static function getDataLength($version, $level)
	90	+ {
	91	+ return self::$capacity[$version][QRCAP_WORDS] - self::$capacity[$version][QRCAP_EC][$level];
	92	+ }
93	93
94		- //----------------------------------------------------------------------
95		- public static function getECCLength($version, $level)
96		- {
97		- return self::$capacity[$version][QRCAP_EC][$level];
98		- }
	94	+ //----------------------------------------------------------------------
	95	+ public static function getECCLength($version, $level)
	96	+ {
	97	+ return self::$capacity[$version][QRCAP_EC][$level];
	98	+ }
99	99
100		- //----------------------------------------------------------------------
101		- public static function getWidth($version)
102		- {
103		- return self::$capacity[$version][QRCAP_WIDTH];
104		- }
	100	+ //----------------------------------------------------------------------
	101	+ public static function getWidth($version)
	102	+ {
	103	+ return self::$capacity[$version][QRCAP_WIDTH];
	104	+ }
105	105
106		- //----------------------------------------------------------------------
107		- public static function getRemainder($version)
108		- {
109		- return self::$capacity[$version][QRCAP_REMINDER];
110		- }
	106	+ //----------------------------------------------------------------------
	107	+ public static function getRemainder($version)
	108	+ {
	109	+ return self::$capacity[$version][QRCAP_REMINDER];
	110	+ }
111	111
112		- //----------------------------------------------------------------------
113		- public static function getMinimumVersion($size, $level)
114		- {
115		-
116		- for($i=1; $i<= QRSPEC_VERSION_MAX; $i++) {
117		- $words = self::$capacity[$i][QRCAP_WORDS] - self::$capacity[$i][QRCAP_EC][$level];
118		- if($words >= $size)
119		- return $i;
120		- }
121		-
122		- return -1;
123		- }
	112	+ //----------------------------------------------------------------------
	113	+ public static function getMinimumVersion($size, $level)
	114	+ {
	115	+
	116	+ for($i=1; $i<= QRSPEC_VERSION_MAX; $i++) {
	117	+ $words = self::$capacity[$i][QRCAP_WORDS] - self::$capacity[$i][QRCAP_EC][$level];
	118	+ if($words >= $size)
	119	+ return $i;
	120	+ }
	121	+
	122	+ return -1;
	123	+ }
124	124
125		- //######################################################################
	125	+ //######################################################################
126	126
127		- public static $lengthTableBits = array(
128		- array(10, 12, 14),
129		- array( 9, 11, 13),
130		- array( 8, 16, 16),
131		- array( 8, 10, 12)
132		- );
	127	+ public static $lengthTableBits = array(
	128	+ array(10, 12, 14),
	129	+ array( 9, 11, 13),
	130	+ array( 8, 16, 16),
	131	+ array( 8, 10, 12)
	132	+ );
133	133
134		- //----------------------------------------------------------------------
135		- public static function lengthIndicator($mode, $version)
136		- {
137		- if ($mode == QR_MODE_STRUCTURE)
138		- return 0;
	134	+ //----------------------------------------------------------------------
	135	+ public static function lengthIndicator($mode, $version)
	136	+ {
	137	+ if ($mode == QR_MODE_STRUCTURE)
	138	+ return 0;
139	139
140		- if ($version <= 9) {
141		- $l = 0;
142		- } else if ($version <= 26) {
143		- $l = 1;
144		- } else {
145		- $l = 2;
146		- }
147		-
148		- return self::$lengthTableBits[$mode][$l];
149		- }
	140	+ if ($version <= 9) {
	141	+ $l = 0;
	142	+ } else if ($version <= 26) {
	143	+ $l = 1;
	144	+ } else {
	145	+ $l = 2;
	146	+ }
	147	+
	148	+ return self::$lengthTableBits[$mode][$l];
	149	+ }
150	150
151		- //----------------------------------------------------------------------
152		- public static function maximumWords($mode, $version)
153		- {
154		- if($mode == QR_MODE_STRUCTURE)
155		- return 3;
	151	+ //----------------------------------------------------------------------
	152	+ public static function maximumWords($mode, $version)
	153	+ {
	154	+ if($mode == QR_MODE_STRUCTURE)
	155	+ return 3;
156	156
157		- if($version <= 9) {
158		- $l = 0;
159		- } else if($version <= 26) {
160		- $l = 1;
161		- } else {
162		- $l = 2;
163		- }
164		-
165		- $bits = self::$lengthTableBits[$mode][$l];
166		- $words = (1 << $bits) - 1;
	157	+ if($version <= 9) {
	158	+ $l = 0;
	159	+ } else if($version <= 26) {
	160	+ $l = 1;
	161	+ } else {
	162	+ $l = 2;
	163	+ }
	164	+
	165	+ $bits = self::$lengthTableBits[$mode][$l];
	166	+ $words = (1 << $bits) - 1;
167	167
168		- if($mode == QR_MODE_KANJI) {
169		- $words *= 2; // the number of bytes is required
170		- }
171		-
172		- return $words;
173		- }
174		-
175		- // Error correction code -----------------------------------------------
176		- // Table of the error correction code (Reed-Solomon block)
177		- // See Table 12-16 (pp.30-36), JIS X0510:2004.
178		-
179		- public static $eccTable = array(
180		- array(array( 0, 0), array( 0, 0), array( 0, 0), array( 0, 0)),
181		- array(array( 1, 0), array( 1, 0), array( 1, 0), array( 1, 0)), // 1
182		- array(array( 1, 0), array( 1, 0), array( 1, 0), array( 1, 0)),
183		- array(array( 1, 0), array( 1, 0), array( 2, 0), array( 2, 0)),
184		- array(array( 1, 0), array( 2, 0), array( 2, 0), array( 4, 0)),
185		- array(array( 1, 0), array( 2, 0), array( 2, 2), array( 2, 2)), // 5
186		- array(array( 2, 0), array( 4, 0), array( 4, 0), array( 4, 0)),
187		- array(array( 2, 0), array( 4, 0), array( 2, 4), array( 4, 1)),
188		- array(array( 2, 0), array( 2, 2), array( 4, 2), array( 4, 2)),
189		- array(array( 2, 0), array( 3, 2), array( 4, 4), array( 4, 4)),
190		- array(array( 2, 2), array( 4, 1), array( 6, 2), array( 6, 2)), //10
191		- array(array( 4, 0), array( 1, 4), array( 4, 4), array( 3, 8)),
192		- array(array( 2, 2), array( 6, 2), array( 4, 6), array( 7, 4)),
193		- array(array( 4, 0), array( 8, 1), array( 8, 4), array(12, 4)),
194		- array(array( 3, 1), array( 4, 5), array(11, 5), array(11, 5)),
195		- array(array( 5, 1), array( 5, 5), array( 5, 7), array(11, 7)), //15
196		- array(array( 5, 1), array( 7, 3), array(15, 2), array( 3, 13)),
197		- array(array( 1, 5), array(10, 1), array( 1, 15), array( 2, 17)),
198		- array(array( 5, 1), array( 9, 4), array(17, 1), array( 2, 19)),
199		- array(array( 3, 4), array( 3, 11), array(17, 4), array( 9, 16)),
200		- array(array( 3, 5), array( 3, 13), array(15, 5), array(15, 10)), //20
201		- array(array( 4, 4), array(17, 0), array(17, 6), array(19, 6)),
202		- array(array( 2, 7), array(17, 0), array( 7, 16), array(34, 0)),
203		- array(array( 4, 5), array( 4, 14), array(11, 14), array(16, 14)),
204		- array(array( 6, 4), array( 6, 14), array(11, 16), array(30, 2)),
205		- array(array( 8, 4), array( 8, 13), array( 7, 22), array(22, 13)), //25
206		- array(array(10, 2), array(19, 4), array(28, 6), array(33, 4)),
207		- array(array( 8, 4), array(22, 3), array( 8, 26), array(12, 28)),
208		- array(array( 3, 10), array( 3, 23), array( 4, 31), array(11, 31)),
209		- array(array( 7, 7), array(21, 7), array( 1, 37), array(19, 26)),
210		- array(array( 5, 10), array(19, 10), array(15, 25), array(23, 25)), //30
211		- array(array(13, 3), array( 2, 29), array(42, 1), array(23, 28)),
212		- array(array(17, 0), array(10, 23), array(10, 35), array(19, 35)),
213		- array(array(17, 1), array(14, 21), array(29, 19), array(11, 46)),
214		- array(array(13, 6), array(14, 23), array(44, 7), array(59, 1)),
215		- array(array(12, 7), array(12, 26), array(39, 14), array(22, 41)), //35
216		- array(array( 6, 14), array( 6, 34), array(46, 10), array( 2, 64)),
217		- array(array(17, 4), array(29, 14), array(49, 10), array(24, 46)),
218		- array(array( 4, 18), array(13, 32), array(48, 14), array(42, 32)),
219		- array(array(20, 4), array(40, 7), array(43, 22), array(10, 67)),
220		- array(array(19, 6), array(18, 31), array(34, 34), array(20, 61)),//40
221		- );
222		-
223		- //----------------------------------------------------------------------
224		- // CACHEABLE!!!
	168	+ if($mode == QR_MODE_KANJI) {
	169	+ $words *= 2; // the number of bytes is required
	170	+ }
	171	+
	172	+ return $words;
	173	+ }
	174	+
	175	+ // Error correction code -----------------------------------------------
	176	+ // Table of the error correction code (Reed-Solomon block)
	177	+ // See Table 12-16 (pp.30-36), JIS X0510:2004.
	178	+
	179	+ public static $eccTable = array(
	180	+ array(array( 0, 0), array( 0, 0), array( 0, 0), array( 0, 0)),
	181	+ array(array( 1, 0), array( 1, 0), array( 1, 0), array( 1, 0)), // 1
	182	+ array(array( 1, 0), array( 1, 0), array( 1, 0), array( 1, 0)),
	183	+ array(array( 1, 0), array( 1, 0), array( 2, 0), array( 2, 0)),
	184	+ array(array( 1, 0), array( 2, 0), array( 2, 0), array( 4, 0)),
	185	+ array(array( 1, 0), array( 2, 0), array( 2, 2), array( 2, 2)), // 5
	186	+ array(array( 2, 0), array( 4, 0), array( 4, 0), array( 4, 0)),
	187	+ array(array( 2, 0), array( 4, 0), array( 2, 4), array( 4, 1)),
	188	+ array(array( 2, 0), array( 2, 2), array( 4, 2), array( 4, 2)),
	189	+ array(array( 2, 0), array( 3, 2), array( 4, 4), array( 4, 4)),
	190	+ array(array( 2, 2), array( 4, 1), array( 6, 2), array( 6, 2)), //10
	191	+ array(array( 4, 0), array( 1, 4), array( 4, 4), array( 3, 8)),
	192	+ array(array( 2, 2), array( 6, 2), array( 4, 6), array( 7, 4)),
	193	+ array(array( 4, 0), array( 8, 1), array( 8, 4), array(12, 4)),
	194	+ array(array( 3, 1), array( 4, 5), array(11, 5), array(11, 5)),
	195	+ array(array( 5, 1), array( 5, 5), array( 5, 7), array(11, 7)), //15
	196	+ array(array( 5, 1), array( 7, 3), array(15, 2), array( 3, 13)),
	197	+ array(array( 1, 5), array(10, 1), array( 1, 15), array( 2, 17)),
	198	+ array(array( 5, 1), array( 9, 4), array(17, 1), array( 2, 19)),
	199	+ array(array( 3, 4), array( 3, 11), array(17, 4), array( 9, 16)),
	200	+ array(array( 3, 5), array( 3, 13), array(15, 5), array(15, 10)), //20
	201	+ array(array( 4, 4), array(17, 0), array(17, 6), array(19, 6)),
	202	+ array(array( 2, 7), array(17, 0), array( 7, 16), array(34, 0)),
	203	+ array(array( 4, 5), array( 4, 14), array(11, 14), array(16, 14)),
	204	+ array(array( 6, 4), array( 6, 14), array(11, 16), array(30, 2)),
	205	+ array(array( 8, 4), array( 8, 13), array( 7, 22), array(22, 13)), //25
	206	+ array(array(10, 2), array(19, 4), array(28, 6), array(33, 4)),
	207	+ array(array( 8, 4), array(22, 3), array( 8, 26), array(12, 28)),
	208	+ array(array( 3, 10), array( 3, 23), array( 4, 31), array(11, 31)),
	209	+ array(array( 7, 7), array(21, 7), array( 1, 37), array(19, 26)),
	210	+ array(array( 5, 10), array(19, 10), array(15, 25), array(23, 25)), //30
	211	+ array(array(13, 3), array( 2, 29), array(42, 1), array(23, 28)),
	212	+ array(array(17, 0), array(10, 23), array(10, 35), array(19, 35)),
	213	+ array(array(17, 1), array(14, 21), array(29, 19), array(11, 46)),
	214	+ array(array(13, 6), array(14, 23), array(44, 7), array(59, 1)),
	215	+ array(array(12, 7), array(12, 26), array(39, 14), array(22, 41)), //35
	216	+ array(array( 6, 14), array( 6, 34), array(46, 10), array( 2, 64)),
	217	+ array(array(17, 4), array(29, 14), array(49, 10), array(24, 46)),
	218	+ array(array( 4, 18), array(13, 32), array(48, 14), array(42, 32)),
	219	+ array(array(20, 4), array(40, 7), array(43, 22), array(10, 67)),
	220	+ array(array(19, 6), array(18, 31), array(34, 34), array(20, 61)),//40
	221	+ );
	222	+
	223	+ //----------------------------------------------------------------------
	224	+ // CACHEABLE!!!
225	225
226		- public static function getEccSpec($version, $level, array &$spec)
227		- {
228		- if (count($spec) < 5) {
229		- $spec = array(0,0,0,0,0);
230		- }
231		-
232		- $b1 = self::$eccTable[$version][$level][0];
233		- $b2 = self::$eccTable[$version][$level][1];
234		- $data = self::getDataLength($version, $level);
235		- $ecc = self::getECCLength($version, $level);
236		-
237		- if($b2 == 0) {
238		- $spec[0] = $b1;
239		- $spec[1] = (int)($data / $b1);
240		- $spec[2] = (int)($ecc / $b1);
241		- $spec[3] = 0;
242		- $spec[4] = 0;
243		- } else {
244		- $spec[0] = $b1;
245		- $spec[1] = (int)($data / ($b1 + $b2));
246		- $spec[2] = (int)($ecc / ($b1 + $b2));
247		- $spec[3] = $b2;
248		- $spec[4] = $spec[1] + 1;
249		- }
250		- }
251		-
252		- // Alignment pattern ---------------------------------------------------
253		-
254		- // Positions of alignment patterns.
255		- // This array includes only the second and the third position of the
256		- // alignment patterns. Rest of them can be calculated from the distance
257		- // between them.
	226	+ public static function getEccSpec($version, $level, array &$spec)
	227	+ {
	228	+ if (count($spec) < 5) {
	229	+ $spec = array(0,0,0,0,0);
	230	+ }
	231	+
	232	+ $b1 = self::$eccTable[$version][$level][0];
	233	+ $b2 = self::$eccTable[$version][$level][1];
	234	+ $data = self::getDataLength($version, $level);
	235	+ $ecc = self::getECCLength($version, $level);
	236	+
	237	+ if($b2 == 0) {
	238	+ $spec[0] = $b1;
	239	+ $spec[1] = (int)($data / $b1);
	240	+ $spec[2] = (int)($ecc / $b1);
	241	+ $spec[3] = 0;
	242	+ $spec[4] = 0;
	243	+ } else {
	244	+ $spec[0] = $b1;
	245	+ $spec[1] = (int)($data / ($b1 + $b2));
	246	+ $spec[2] = (int)($ecc / ($b1 + $b2));
	247	+ $spec[3] = $b2;
	248	+ $spec[4] = $spec[1] + 1;
	249	+ }
	250	+ }
	251	+
	252	+ // Alignment pattern ---------------------------------------------------
	253	+
	254	+ // Positions of alignment patterns.
	255	+ // This array includes only the second and the third position of the
	256	+ // alignment patterns. Rest of them can be calculated from the distance
	257	+ // between them.
258	258
259		- // See Table 1 in Appendix E (pp.71) of JIS X0510:2004.
	259	+ // See Table 1 in Appendix E (pp.71) of JIS X0510:2004.
260	260
261		- public static $alignmentPattern = array(
262		- array( 0, 0),
263		- array( 0, 0), array(18, 0), array(22, 0), array(26, 0), array(30, 0), // 1- 5
264		- array(34, 0), array(22, 38), array(24, 42), array(26, 46), array(28, 50), // 6-10
265		- array(30, 54), array(32, 58), array(34, 62), array(26, 46), array(26, 48), //11-15
266		- array(26, 50), array(30, 54), array(30, 56), array(30, 58), array(34, 62), //16-20
267		- array(28, 50), array(26, 50), array(30, 54), array(28, 54), array(32, 58), //21-25
268		- array(30, 58), array(34, 62), array(26, 50), array(30, 54), array(26, 52), //26-30
269		- array(30, 56), array(34, 60), array(30, 58), array(34, 62), array(30, 54), //31-35
270		- array(24, 50), array(28, 54), array(32, 58), array(26, 54), array(30, 58), //35-40
271		- );
	261	+ public static $alignmentPattern = array(
	262	+ array( 0, 0),
	263	+ array( 0, 0), array(18, 0), array(22, 0), array(26, 0), array(30, 0), // 1- 5
	264	+ array(34, 0), array(22, 38), array(24, 42), array(26, 46), array(28, 50), // 6-10
	265	+ array(30, 54), array(32, 58), array(34, 62), array(26, 46), array(26, 48), //11-15
	266	+ array(26, 50), array(30, 54), array(30, 56), array(30, 58), array(34, 62), //16-20
	267	+ array(28, 50), array(26, 50), array(30, 54), array(28, 54), array(32, 58), //21-25
	268	+ array(30, 58), array(34, 62), array(26, 50), array(30, 54), array(26, 52), //26-30
	269	+ array(30, 56), array(34, 60), array(30, 58), array(34, 62), array(30, 54), //31-35
	270	+ array(24, 50), array(28, 54), array(32, 58), array(26, 54), array(30, 58), //35-40
	271	+ );
272	272
273	273
274		- /** --------------------------------------------------------------------
275		- * Put an alignment marker.
276		- * @param frame
277		- * @param width
278		- * @param ox,oy center coordinate of the pattern
279		- */
280		- public static function putAlignmentMarker(array &$frame, $ox, $oy)
281		- {
282		- $finder = array(
283		- "\xa1\xa1\xa1\xa1\xa1",
284		- "\xa1\xa0\xa0\xa0\xa1",
285		- "\xa1\xa0\xa1\xa0\xa1",
286		- "\xa1\xa0\xa0\xa0\xa1",
287		- "\xa1\xa1\xa1\xa1\xa1"
288		- );
	274	+ /** --------------------------------------------------------------------
	275	+ * Put an alignment marker.
	276	+ * @param frame
	277	+ * @param width
	278	+ * @param ox,oy center coordinate of the pattern
	279	+ */
	280	+ public static function putAlignmentMarker(array &$frame, $ox, $oy)
	281	+ {
	282	+ $finder = array(
	283	+ "\xa1\xa1\xa1\xa1\xa1",
	284	+ "\xa1\xa0\xa0\xa0\xa1",
	285	+ "\xa1\xa0\xa1\xa0\xa1",
	286	+ "\xa1\xa0\xa0\xa0\xa1",
	287	+ "\xa1\xa1\xa1\xa1\xa1"
	288	+ );
289	289
290		- $yStart = $oy-2;
291		- $xStart = $ox-2;
	290	+ $yStart = $oy-2;
	291	+ $xStart = $ox-2;
292	292
293		- for($y=0; $y<5; $y++) {
294		- QRstr::set($frame, $xStart, $yStart+$y, $finder[$y]);
295		- }
296		- }
297		-
298		- //----------------------------------------------------------------------
299		- public static function putAlignmentPattern($version, &$frame, $width)
300		- {
301		- if($version < 2)
302		- return;
303		-
304		- $d = self::$alignmentPattern[$version][1] - self::$alignmentPattern[$version][0];
305		- if($d < 0) {
306		- $w = 2;
307		- } else {
308		- $w = (int)(($width - self::$alignmentPattern[$version][0]) / $d + 2);
309		- }
310		-
311		- if($w * $w - 3 == 1) {
312		- $x = self::$alignmentPattern[$version][0];
313		- $y = self::$alignmentPattern[$version][0];
314		- self::putAlignmentMarker($frame, $x, $y);
315		- return;
316		- }
317		-
318		- $cx = self::$alignmentPattern[$version][0];
319		- for($x=1; $x<$w - 1; $x++) {
320		- self::putAlignmentMarker($frame, 6, $cx);
321		- self::putAlignmentMarker($frame, $cx, 6);
322		- $cx += $d;
323		- }
324		-
325		- $cy = self::$alignmentPattern[$version][0];
326		- for($y=0; $y<$w-1; $y++) {
327		- $cx = self::$alignmentPattern[$version][0];
328		- for($x=0; $x<$w-1; $x++) {
329		- self::putAlignmentMarker($frame, $cx, $cy);
330		- $cx += $d;
331		- }
332		- $cy += $d;
333		- }
334		- }
335		-
336		- // Version information pattern -----------------------------------------
	293	+ for($y=0; $y<5; $y++) {
	294	+ QRstr::set($frame, $xStart, $yStart+$y, $finder[$y]);
	295	+ }
	296	+ }
	297	+
	298	+ //----------------------------------------------------------------------
	299	+ public static function putAlignmentPattern($version, &$frame, $width)
	300	+ {
	301	+ if($version < 2)
	302	+ return;
	303	+
	304	+ $d = self::$alignmentPattern[$version][1] - self::$alignmentPattern[$version][0];
	305	+ if($d < 0) {
	306	+ $w = 2;
	307	+ } else {
	308	+ $w = (int)(($width - self::$alignmentPattern[$version][0]) / $d + 2);
	309	+ }
	310	+
	311	+ if($w * $w - 3 == 1) {
	312	+ $x = self::$alignmentPattern[$version][0];
	313	+ $y = self::$alignmentPattern[$version][0];
	314	+ self::putAlignmentMarker($frame, $x, $y);
	315	+ return;
	316	+ }
	317	+
	318	+ $cx = self::$alignmentPattern[$version][0];
	319	+ for($x=1; $x<$w - 1; $x++) {
	320	+ self::putAlignmentMarker($frame, 6, $cx);
	321	+ self::putAlignmentMarker($frame, $cx, 6);
	322	+ $cx += $d;
	323	+ }
	324	+
	325	+ $cy = self::$alignmentPattern[$version][0];
	326	+ for($y=0; $y<$w-1; $y++) {
	327	+ $cx = self::$alignmentPattern[$version][0];
	328	+ for($x=0; $x<$w-1; $x++) {
	329	+ self::putAlignmentMarker($frame, $cx, $cy);
	330	+ $cx += $d;
	331	+ }
	332	+ $cy += $d;
	333	+ }
	334	+ }
	335	+
	336	+ // Version information pattern -----------------------------------------
337	337
338	338	// Version information pattern (BCH coded).
339		- // See Table 1 in Appendix D (pp.68) of JIS X0510:2004.
	339	+ // See Table 1 in Appendix D (pp.68) of JIS X0510:2004.
340	340
341	341	// size: [QRSPEC_VERSION_MAX - 6]
342	342
343		- public static $versionPattern = array(
344		- 0x07c94, 0x085bc, 0x09a99, 0x0a4d3, 0x0bbf6, 0x0c762, 0x0d847, 0x0e60d,
345		- 0x0f928, 0x10b78, 0x1145d, 0x12a17, 0x13532, 0x149a6, 0x15683, 0x168c9,
346		- 0x177ec, 0x18ec4, 0x191e1, 0x1afab, 0x1b08e, 0x1cc1a, 0x1d33f, 0x1ed75,
347		- 0x1f250, 0x209d5, 0x216f0, 0x228ba, 0x2379f, 0x24b0b, 0x2542e, 0x26a64,
348		- 0x27541, 0x28c69
349		- );
350		-
351		- //----------------------------------------------------------------------
352		- public static function getVersionPattern($version)
353		- {
354		- if($version < 7 \|\| $version > QRSPEC_VERSION_MAX)
355		- return 0;
356		-
357		- return self::$versionPattern[$version -7];
358		- }
359		-
360		- // Format information --------------------------------------------------
361		- // See calcFormatInfo in tests/test_qrspec.c (orginal qrencode c lib)
	343	+ public static $versionPattern = array(
	344	+ 0x07c94, 0x085bc, 0x09a99, 0x0a4d3, 0x0bbf6, 0x0c762, 0x0d847, 0x0e60d,
	345	+ 0x0f928, 0x10b78, 0x1145d, 0x12a17, 0x13532, 0x149a6, 0x15683, 0x168c9,
	346	+ 0x177ec, 0x18ec4, 0x191e1, 0x1afab, 0x1b08e, 0x1cc1a, 0x1d33f, 0x1ed75,
	347	+ 0x1f250, 0x209d5, 0x216f0, 0x228ba, 0x2379f, 0x24b0b, 0x2542e, 0x26a64,
	348	+ 0x27541, 0x28c69
	349	+ );
	350	+
	351	+ //----------------------------------------------------------------------
	352	+ public static function getVersionPattern($version)
	353	+ {
	354	+ if($version < 7 \|\| $version > QRSPEC_VERSION_MAX)
	355	+ return 0;
	356	+
	357	+ return self::$versionPattern[$version -7];
	358	+ }
	359	+
	360	+ // Format information --------------------------------------------------
	361	+ // See calcFormatInfo in tests/test_qrspec.c (orginal qrencode c lib)
362	362
363		- public static $formatInfo = array(
364		- array(0x77c4, 0x72f3, 0x7daa, 0x789d, 0x662f, 0x6318, 0x6c41, 0x6976),
365		- array(0x5412, 0x5125, 0x5e7c, 0x5b4b, 0x45f9, 0x40ce, 0x4f97, 0x4aa0),
366		- array(0x355f, 0x3068, 0x3f31, 0x3a06, 0x24b4, 0x2183, 0x2eda, 0x2bed),
367		- array(0x1689, 0x13be, 0x1ce7, 0x19d0, 0x0762, 0x0255, 0x0d0c, 0x083b)
368		- );
369		-
370		- public static function getFormatInfo($mask, $level)
371		- {
372		- if($mask < 0 \|\| $mask > 7)
373		- return 0;
	363	+ public static $formatInfo = array(
	364	+ array(0x77c4, 0x72f3, 0x7daa, 0x789d, 0x662f, 0x6318, 0x6c41, 0x6976),
	365	+ array(0x5412, 0x5125, 0x5e7c, 0x5b4b, 0x45f9, 0x40ce, 0x4f97, 0x4aa0),
	366	+ array(0x355f, 0x3068, 0x3f31, 0x3a06, 0x24b4, 0x2183, 0x2eda, 0x2bed),
	367	+ array(0x1689, 0x13be, 0x1ce7, 0x19d0, 0x0762, 0x0255, 0x0d0c, 0x083b)
	368	+ );
	369	+
	370	+ public static function getFormatInfo($mask, $level)
	371	+ {
	372	+ if($mask < 0 \|\| $mask > 7)
	373	+ return 0;
374	374
375		- if($level < 0 \|\| $level > 3)
376		- return 0;
	375	+ if($level < 0 \|\| $level > 3)
	376	+ return 0;
377	377
378		- return self::$formatInfo[$level][$mask];
379		- }
	378	+ return self::$formatInfo[$level][$mask];
	379	+ }
380	380
381		- // Frame ---------------------------------------------------------------
382		- // Cache of initial frames.
	381	+ // Frame ---------------------------------------------------------------
	382	+ // Cache of initial frames.
383	383
384		- public static $frames = array();
385		-
386		- /** --------------------------------------------------------------------
387		- * Put a finder pattern.
388		- * @param frame
389		- * @param width
390		- * @param ox,oy upper-left coordinate of the pattern
391		- */
392		- public static function putFinderPattern(&$frame, $ox, $oy)
393		- {
394		- $finder = array(
395		- "\xc1\xc1\xc1\xc1\xc1\xc1\xc1",
396		- "\xc1\xc0\xc0\xc0\xc0\xc0\xc1",
397		- "\xc1\xc0\xc1\xc1\xc1\xc0\xc1",
398		- "\xc1\xc0\xc1\xc1\xc1\xc0\xc1",
399		- "\xc1\xc0\xc1\xc1\xc1\xc0\xc1",
400		- "\xc1\xc0\xc0\xc0\xc0\xc0\xc1",
401		- "\xc1\xc1\xc1\xc1\xc1\xc1\xc1"
402		- );
	384	+ public static $frames = array();
	385	+
	386	+ /** --------------------------------------------------------------------
	387	+ * Put a finder pattern.
	388	+ * @param frame
	389	+ * @param width
	390	+ * @param ox,oy upper-left coordinate of the pattern
	391	+ */
	392	+ public static function putFinderPattern(&$frame, $ox, $oy)
	393	+ {
	394	+ $finder = array(
	395	+ "\xc1\xc1\xc1\xc1\xc1\xc1\xc1",
	396	+ "\xc1\xc0\xc0\xc0\xc0\xc0\xc1",
	397	+ "\xc1\xc0\xc1\xc1\xc1\xc0\xc1",
	398	+ "\xc1\xc0\xc1\xc1\xc1\xc0\xc1",
	399	+ "\xc1\xc0\xc1\xc1\xc1\xc0\xc1",
	400	+ "\xc1\xc0\xc0\xc0\xc0\xc0\xc1",
	401	+ "\xc1\xc1\xc1\xc1\xc1\xc1\xc1"
	402	+ );
403	403
404		- for($y=0; $y<7; $y++) {
405		- QRstr::set($frame, $ox, $oy+$y, $finder[$y]);
406		- }
407		- }
408		-
409		- //----------------------------------------------------------------------
410		- public static function createFrame($version)
411		- {
412		- $width = self::$capacity[$version][QRCAP_WIDTH];
413		- $frameLine = str_repeat ("\0", $width);
414		- $frame = array_fill(0, $width, $frameLine);
415		-
416		- // Finder pattern
417		- self::putFinderPattern($frame, 0, 0);
418		- self::putFinderPattern($frame, $width - 7, 0);
419		- self::putFinderPattern($frame, 0, $width - 7);
	404	+ for($y=0; $y<7; $y++) {
	405	+ QRstr::set($frame, $ox, $oy+$y, $finder[$y]);
	406	+ }
	407	+ }
	408	+
	409	+ //----------------------------------------------------------------------
	410	+ public static function createFrame($version)
	411	+ {
	412	+ $width = self::$capacity[$version][QRCAP_WIDTH];
	413	+ $frameLine = str_repeat ("\0", $width);
	414	+ $frame = array_fill(0, $width, $frameLine);
	415	+
	416	+ // Finder pattern
	417	+ self::putFinderPattern($frame, 0, 0);
	418	+ self::putFinderPattern($frame, $width - 7, 0);
	419	+ self::putFinderPattern($frame, 0, $width - 7);
420	420
421		- // Separator
422		- $yOffset = $width - 7;
	421	+ // Separator
	422	+ $yOffset = $width - 7;
423	423
424		- for($y=0; $y<7; $y++) {
425		- $frame[$y][7] = "\xc0";
426		- $frame[$y][$width - 8] = "\xc0";
427		- $frame[$yOffset][7] = "\xc0";
428		- $yOffset++;
429		- }
	424	+ for($y=0; $y<7; $y++) {
	425	+ $frame[$y][7] = "\xc0";
	426	+ $frame[$y][$width - 8] = "\xc0";
	427	+ $frame[$yOffset][7] = "\xc0";
	428	+ $yOffset++;
	429	+ }
430	430
431		- $setPattern = str_repeat("\xc0", 8);
	431	+ $setPattern = str_repeat("\xc0", 8);
432	432
433		- QRstr::set($frame, 0, 7, $setPattern);
434		- QRstr::set($frame, $width-8, 7, $setPattern);
435		- QRstr::set($frame, 0, $width - 8, $setPattern);
	433	+ QRstr::set($frame, 0, 7, $setPattern);
	434	+ QRstr::set($frame, $width-8, 7, $setPattern);
	435	+ QRstr::set($frame, 0, $width - 8, $setPattern);
436	436
437		- // Format info
438		- $setPattern = str_repeat("\x84", 9);
439		- QRstr::set($frame, 0, 8, $setPattern);
440		- QRstr::set($frame, $width - 8, 8, $setPattern, 8);
	437	+ // Format info
	438	+ $setPattern = str_repeat("\x84", 9);
	439	+ QRstr::set($frame, 0, 8, $setPattern);
	440	+ QRstr::set($frame, $width - 8, 8, $setPattern, 8);
441	441
442		- $yOffset = $width - 8;
	442	+ $yOffset = $width - 8;
443	443
444		- for($y=0; $y<8; $y++,$yOffset++) {
445		- $frame[$y][8] = "\x84";
446		- $frame[$yOffset][8] = "\x84";
447		- }
	444	+ for($y=0; $y<8; $y++,$yOffset++) {
	445	+ $frame[$y][8] = "\x84";
	446	+ $frame[$yOffset][8] = "\x84";
	447	+ }
448	448
449		- // Timing pattern
	449	+ // Timing pattern
450	450
451		- for($i=1; $i<$width-15; $i++) {
452		- $frame[6][7+$i] = chr(0x90 \| ($i & 1));
453		- $frame[7+$i][6] = chr(0x90 \| ($i & 1));
454		- }
	451	+ for($i=1; $i<$width-15; $i++) {
	452	+ $frame[6][7+$i] = chr(0x90 \| ($i & 1));
	453	+ $frame[7+$i][6] = chr(0x90 \| ($i & 1));
	454	+ }
455	455
456		- // Alignment pattern
457		- self::putAlignmentPattern($version, $frame, $width);
	456	+ // Alignment pattern
	457	+ self::putAlignmentPattern($version, $frame, $width);
458	458
459		- // Version information
460		- if($version >= 7) {
461		- $vinf = self::getVersionPattern($version);
	459	+ // Version information
	460	+ if($version >= 7) {
	461	+ $vinf = self::getVersionPattern($version);
462	462
463		- $v = $vinf;
	463	+ $v = $vinf;
464	464
465		- for($x=0; $x<6; $x++) {
466		- for($y=0; $y<3; $y++) {
467		- $frame[($width - 11)+$y][$x] = chr(0x88 \| ($v & 1));
468		- $v = $v >> 1;
469		- }
470		- }
471		-
472		- $v = $vinf;
473		- for($y=0; $y<6; $y++) {
474		- for($x=0; $x<3; $x++) {
475		- $frame[$y][$x+($width - 11)] = chr(0x88 \| ($v & 1));
476		- $v = $v >> 1;
477		- }
478		- }
479		- }
	465	+ for($x=0; $x<6; $x++) {
	466	+ for($y=0; $y<3; $y++) {
	467	+ $frame[($width - 11)+$y][$x] = chr(0x88 \| ($v & 1));
	468	+ $v = $v >> 1;
	469	+ }
	470	+ }
	471	+
	472	+ $v = $vinf;
	473	+ for($y=0; $y<6; $y++) {
	474	+ for($x=0; $x<3; $x++) {
	475	+ $frame[$y][$x+($width - 11)] = chr(0x88 \| ($v & 1));
	476	+ $v = $v >> 1;
	477	+ }
	478	+ }
	479	+ }
480	480
481		- // and a little bit...
482		- $frame[$width - 8][8] = "\x81";
	481	+ // and a little bit...
	482	+ $frame[$width - 8][8] = "\x81";
483	483
484		- return $frame;
485		- }
	484	+ return $frame;
	485	+ }
486	486
487		- //----------------------------------------------------------------------
488		- public static function debug($frame, $binary_mode = false)
489		- {
490		- if ($binary_mode) {
	487	+ //----------------------------------------------------------------------
	488	+ public static function debug($frame, $binary_mode = false)
	489	+ {
	490	+ if ($binary_mode) {
491	491
492		- foreach ($frame as &$frameLine) {
493		- $frameLine = join('<span class="m">  </span>', explode('0', $frameLine));
494		- $frameLine = join('██', explode('1', $frameLine));
495		- }
	492	+ foreach ($frame as &$frameLine) {
	493	+ $frameLine = join('<span class="m">  </span>', explode('0', $frameLine));
	494	+ $frameLine = join('██', explode('1', $frameLine));
	495	+ }
496	496
497		- ?>
	497	+ ?>
498	498	<style>
499	499	.m { background-color: white; }
500	500	</style>
501	501	<?php
502		- echo '<pre><tt><br/ ><br/ ><br/ >        ';
503		- echo join("<br/ >        ", $frame);
504		- echo '</tt></pre><br/ ><br/ ><br/ ><br/ ><br/ ><br/ >';
	502	+ echo '<pre><tt><br/ ><br/ ><br/ >        ';
	503	+ echo join("<br/ >        ", $frame);
	504	+ echo '</tt></pre><br/ ><br/ ><br/ ><br/ ><br/ ><br/ >';
505	505
506		- } else {
	506	+ } else {
507	507
508		- foreach ($frame as &$frameLine) {
509		- $frameLine = join('<span class="m"> </span>', explode("\xc0", $frameLine));
510		- $frameLine = join('<span class="m">▒</span>', explode("\xc1", $frameLine));
511		- $frameLine = join('<span class="p"> </span>', explode("\xa0", $frameLine));
512		- $frameLine = join('<span class="p">▒</span>', explode("\xa1", $frameLine));
513		- $frameLine = join('<span class="s">◇</span>', explode("\x84", $frameLine)); //format 0
514		- $frameLine = join('<span class="s">◆</span>', explode("\x85", $frameLine)); //format 1
515		- $frameLine = join('<span class="x">☢</span>', explode("\x81", $frameLine)); //special bit
516		- $frameLine = join('<span class="c"> </span>', explode("\x90", $frameLine)); //clock 0
517		- $frameLine = join('<span class="c">◷</span>', explode("\x91", $frameLine)); //clock 1
518		- $frameLine = join('<span class="f"> </span>', explode("\x88", $frameLine)); //version
519		- $frameLine = join('<span class="f">▒</span>', explode("\x89", $frameLine)); //version
520		- $frameLine = join('♦', explode("\x01", $frameLine));
521		- $frameLine = join('⋅', explode("\0", $frameLine));
522		- }
	508	+ foreach ($frame as &$frameLine) {
	509	+ $frameLine = join('<span class="m"> </span>', explode("\xc0", $frameLine));
	510	+ $frameLine = join('<span class="m">▒</span>', explode("\xc1", $frameLine));
	511	+ $frameLine = join('<span class="p"> </span>', explode("\xa0", $frameLine));
	512	+ $frameLine = join('<span class="p">▒</span>', explode("\xa1", $frameLine));
	513	+ $frameLine = join('<span class="s">◇</span>', explode("\x84", $frameLine)); //format 0
	514	+ $frameLine = join('<span class="s">◆</span>', explode("\x85", $frameLine)); //format 1
	515	+ $frameLine = join('<span class="x">☢</span>', explode("\x81", $frameLine)); //special bit
	516	+ $frameLine = join('<span class="c"> </span>', explode("\x90", $frameLine)); //clock 0
	517	+ $frameLine = join('<span class="c">◷</span>', explode("\x91", $frameLine)); //clock 1
	518	+ $frameLine = join('<span class="f"> </span>', explode("\x88", $frameLine)); //version
	519	+ $frameLine = join('<span class="f">▒</span>', explode("\x89", $frameLine)); //version
	520	+ $frameLine = join('♦', explode("\x01", $frameLine));
	521	+ $frameLine = join('⋅', explode("\0", $frameLine));
	522	+ }
523	523
524		- ?>
	524	+ ?>
525	525	<style>
526	526	.p { background-color: yellow; }
527	527	.m { background-color: #00FF00; }
		@@ -531,62 +531,62 @@ discard block
		block discarded – undo
531	531	.f { background-color: gold; }
532	532	</style>
533	533	<?php
534		- echo "<pre><tt>";
535		- echo join("<br/ >", $frame);
536		- echo "</tt></pre>";
	534	+ echo "<pre><tt>";
	535	+ echo join("<br/ >", $frame);
	536	+ echo "</tt></pre>";
537	537
538		- }
539		- }
540		-
541		- //----------------------------------------------------------------------
542		- public static function serial($frame)
543		- {
544		- return gzcompress(join("\n", $frame), 9);
545		- }
	538	+ }
	539	+ }
	540	+
	541	+ //----------------------------------------------------------------------
	542	+ public static function serial($frame)
	543	+ {
	544	+ return gzcompress(join("\n", $frame), 9);
	545	+ }
546	546
547		- //----------------------------------------------------------------------
548		- public static function unserial($code)
549		- {
550		- return explode("\n", gzuncompress($code));
551		- }
	547	+ //----------------------------------------------------------------------
	548	+ public static function unserial($code)
	549	+ {
	550	+ return explode("\n", gzuncompress($code));
	551	+ }
552	552
553		- //----------------------------------------------------------------------
554		- public static function newFrame($version)
555		- {
556		- if($version < 1 \|\| $version > QRSPEC_VERSION_MAX)
557		- return null;
	553	+ //----------------------------------------------------------------------
	554	+ public static function newFrame($version)
	555	+ {
	556	+ if($version < 1 \|\| $version > QRSPEC_VERSION_MAX)
	557	+ return null;
558	558
559		- if(!isset(self::$frames[$version])) {
	559	+ if(!isset(self::$frames[$version])) {
560	560
561		- $fileName = QR_CACHE_DIR.'frame_'.$version.'.dat';
	561	+ $fileName = QR_CACHE_DIR.'frame_'.$version.'.dat';
562	562
563		- if (QR_CACHEABLE) {
564		- if (file_exists($fileName)) {
565		- self::$frames[$version] = self::unserial(file_get_contents($fileName));
566		- } else {
567		- self::$frames[$version] = self::createFrame($version);
568		- file_put_contents($fileName, self::serial(self::$frames[$version]));
569		- }
570		- } else {
571		- self::$frames[$version] = self::createFrame($version);
572		- }
573		- }
	563	+ if (QR_CACHEABLE) {
	564	+ if (file_exists($fileName)) {
	565	+ self::$frames[$version] = self::unserial(file_get_contents($fileName));
	566	+ } else {
	567	+ self::$frames[$version] = self::createFrame($version);
	568	+ file_put_contents($fileName, self::serial(self::$frames[$version]));
	569	+ }
	570	+ } else {
	571	+ self::$frames[$version] = self::createFrame($version);
	572	+ }
	573	+ }
574	574
575		- if(is_null(self::$frames[$version]))
576		- return null;
577		-
578		- return self::$frames[$version];
579		- }
580		-
581		- //----------------------------------------------------------------------
582		- public static function rsBlockNum($spec) { return $spec[0] + $spec[3]; }
583		- public static function rsBlockNum1($spec) { return $spec[0]; }
584		- public static function rsDataCodes1($spec) { return $spec[1]; }
585		- public static function rsEccCodes1($spec) { return $spec[2]; }
586		- public static function rsBlockNum2($spec) { return $spec[3]; }
587		- public static function rsDataCodes2($spec) { return $spec[4]; }
588		- public static function rsEccCodes2($spec) { return $spec[2]; }
589		- public static function rsDataLength($spec) { return ($spec[0] * $spec[1]) + ($spec[3] * $spec[4]); }
590		- public static function rsEccLength($spec) { return ($spec[0] + $spec[3]) * $spec[2]; }
	575	+ if(is_null(self::$frames[$version]))
	576	+ return null;
	577	+
	578	+ return self::$frames[$version];
	579	+ }
	580	+
	581	+ //----------------------------------------------------------------------
	582	+ public static function rsBlockNum($spec) { return $spec[0] + $spec[3]; }
	583	+ public static function rsBlockNum1($spec) { return $spec[0]; }
	584	+ public static function rsDataCodes1($spec) { return $spec[1]; }
	585	+ public static function rsEccCodes1($spec) { return $spec[2]; }
	586	+ public static function rsBlockNum2($spec) { return $spec[3]; }
	587	+ public static function rsDataCodes2($spec) { return $spec[4]; }
	588	+ public static function rsEccCodes2($spec) { return $spec[2]; }
	589	+ public static function rsDataLength($spec) { return ($spec[0] * $spec[1]) + ($spec[3] * $spec[4]); }
	590	+ public static function rsEccLength($spec) { return ($spec[0] + $spec[3]) * $spec[2]; }
591	591
592		- }
593	592	\ No newline at end of file
	593	+ }
594	594	\ No newline at end of file

Please login to merge, or discard this patch.

Spacing +154 added lines, -154 removed lines patch added patch discarded remove patch

		@@ -32,57 +32,57 @@ discard block
		block discarded – undo
32	32	*/
33	33
34	34	define('QRSPEC_VERSION_MAX', 40);
35		- define('QRSPEC_WIDTH_MAX', 177);
	35	+ define('QRSPEC_WIDTH_MAX', 177);
36	36
37		- define('QRCAP_WIDTH', 0);
38		- define('QRCAP_WORDS', 1);
39		- define('QRCAP_REMINDER', 2);
40		- define('QRCAP_EC', 3);
	37	+ define('QRCAP_WIDTH', 0);
	38	+ define('QRCAP_WORDS', 1);
	39	+ define('QRCAP_REMINDER', 2);
	40	+ define('QRCAP_EC', 3);
41	41
42	42	class QRspec {
43	43
44	44	public static $capacity = array(
45		- array( 0, 0, 0, array( 0, 0, 0, 0)),
46		- array( 21, 26, 0, array( 7, 10, 13, 17)), // 1
47		- array( 25, 44, 7, array( 10, 16, 22, 28)),
48		- array( 29, 70, 7, array( 15, 26, 36, 44)),
49		- array( 33, 100, 7, array( 20, 36, 52, 64)),
50		- array( 37, 134, 7, array( 26, 48, 72, 88)), // 5
51		- array( 41, 172, 7, array( 36, 64, 96, 112)),
52		- array( 45, 196, 0, array( 40, 72, 108, 130)),
53		- array( 49, 242, 0, array( 48, 88, 132, 156)),
54		- array( 53, 292, 0, array( 60, 110, 160, 192)),
55		- array( 57, 346, 0, array( 72, 130, 192, 224)), //10
56		- array( 61, 404, 0, array( 80, 150, 224, 264)),
57		- array( 65, 466, 0, array( 96, 176, 260, 308)),
58		- array( 69, 532, 0, array( 104, 198, 288, 352)),
59		- array( 73, 581, 3, array( 120, 216, 320, 384)),
60		- array( 77, 655, 3, array( 132, 240, 360, 432)), //15
61		- array( 81, 733, 3, array( 144, 280, 408, 480)),
62		- array( 85, 815, 3, array( 168, 308, 448, 532)),
63		- array( 89, 901, 3, array( 180, 338, 504, 588)),
64		- array( 93, 991, 3, array( 196, 364, 546, 650)),
65		- array( 97, 1085, 3, array( 224, 416, 600, 700)), //20
66		- array(101, 1156, 4, array( 224, 442, 644, 750)),
67		- array(105, 1258, 4, array( 252, 476, 690, 816)),
68		- array(109, 1364, 4, array( 270, 504, 750, 900)),
69		- array(113, 1474, 4, array( 300, 560, 810, 960)),
70		- array(117, 1588, 4, array( 312, 588, 870, 1050)), //25
71		- array(121, 1706, 4, array( 336, 644, 952, 1110)),
72		- array(125, 1828, 4, array( 360, 700, 1020, 1200)),
73		- array(129, 1921, 3, array( 390, 728, 1050, 1260)),
74		- array(133, 2051, 3, array( 420, 784, 1140, 1350)),
75		- array(137, 2185, 3, array( 450, 812, 1200, 1440)), //30
76		- array(141, 2323, 3, array( 480, 868, 1290, 1530)),
77		- array(145, 2465, 3, array( 510, 924, 1350, 1620)),
78		- array(149, 2611, 3, array( 540, 980, 1440, 1710)),
79		- array(153, 2761, 3, array( 570, 1036, 1530, 1800)),
80		- array(157, 2876, 0, array( 570, 1064, 1590, 1890)), //35
81		- array(161, 3034, 0, array( 600, 1120, 1680, 1980)),
82		- array(165, 3196, 0, array( 630, 1204, 1770, 2100)),
83		- array(169, 3362, 0, array( 660, 1260, 1860, 2220)),
84		- array(173, 3532, 0, array( 720, 1316, 1950, 2310)),
85		- array(177, 3706, 0, array( 750, 1372, 2040, 2430)) //40
	45	+ array(0, 0, 0, array(0, 0, 0, 0)),
	46	+ array(21, 26, 0, array(7, 10, 13, 17)), // 1
	47	+ array(25, 44, 7, array(10, 16, 22, 28)),
	48	+ array(29, 70, 7, array(15, 26, 36, 44)),
	49	+ array(33, 100, 7, array(20, 36, 52, 64)),
	50	+ array(37, 134, 7, array(26, 48, 72, 88)), // 5
	51	+ array(41, 172, 7, array(36, 64, 96, 112)),
	52	+ array(45, 196, 0, array(40, 72, 108, 130)),
	53	+ array(49, 242, 0, array(48, 88, 132, 156)),
	54	+ array(53, 292, 0, array(60, 110, 160, 192)),
	55	+ array(57, 346, 0, array(72, 130, 192, 224)), //10
	56	+ array(61, 404, 0, array(80, 150, 224, 264)),
	57	+ array(65, 466, 0, array(96, 176, 260, 308)),
	58	+ array(69, 532, 0, array(104, 198, 288, 352)),
	59	+ array(73, 581, 3, array(120, 216, 320, 384)),
	60	+ array(77, 655, 3, array(132, 240, 360, 432)), //15
	61	+ array(81, 733, 3, array(144, 280, 408, 480)),
	62	+ array(85, 815, 3, array(168, 308, 448, 532)),
	63	+ array(89, 901, 3, array(180, 338, 504, 588)),
	64	+ array(93, 991, 3, array(196, 364, 546, 650)),
	65	+ array(97, 1085, 3, array(224, 416, 600, 700)), //20
	66	+ array(101, 1156, 4, array(224, 442, 644, 750)),
	67	+ array(105, 1258, 4, array(252, 476, 690, 816)),
	68	+ array(109, 1364, 4, array(270, 504, 750, 900)),
	69	+ array(113, 1474, 4, array(300, 560, 810, 960)),
	70	+ array(117, 1588, 4, array(312, 588, 870, 1050)), //25
	71	+ array(121, 1706, 4, array(336, 644, 952, 1110)),
	72	+ array(125, 1828, 4, array(360, 700, 1020, 1200)),
	73	+ array(129, 1921, 3, array(390, 728, 1050, 1260)),
	74	+ array(133, 2051, 3, array(420, 784, 1140, 1350)),
	75	+ array(137, 2185, 3, array(450, 812, 1200, 1440)), //30
	76	+ array(141, 2323, 3, array(480, 868, 1290, 1530)),
	77	+ array(145, 2465, 3, array(510, 924, 1350, 1620)),
	78	+ array(149, 2611, 3, array(540, 980, 1440, 1710)),
	79	+ array(153, 2761, 3, array(570, 1036, 1530, 1800)),
	80	+ array(157, 2876, 0, array(570, 1064, 1590, 1890)), //35
	81	+ array(161, 3034, 0, array(600, 1120, 1680, 1980)),
	82	+ array(165, 3196, 0, array(630, 1204, 1770, 2100)),
	83	+ array(169, 3362, 0, array(660, 1260, 1860, 2220)),
	84	+ array(173, 3532, 0, array(720, 1316, 1950, 2310)),
	85	+ array(177, 3706, 0, array(750, 1372, 2040, 2430)) //40
86	86	);
87	87
88	88	//----------------------------------------------------------------------
		@@ -113,9 +113,9 @@ discard block
		block discarded – undo
113	113	public static function getMinimumVersion($size, $level)
114	114	{
115	115
116		- for($i=1; $i<= QRSPEC_VERSION_MAX; $i++) {
117		- $words = self::$capacity[$i][QRCAP_WORDS] - self::$capacity[$i][QRCAP_EC][$level];
118		- if($words >= $size)
	116	+ for ($i = 1; $i <= QRSPEC_VERSION_MAX; $i++) {
	117	+ $words = self::$capacity[$i][QRCAP_WORDS] - self::$capacity[$i][QRCAP_EC][$level];
	118	+ if ($words >= $size)
119	119	return $i;
120	120	}
121	121
		@@ -126,9 +126,9 @@ discard block
		block discarded – undo
126	126
127	127	public static $lengthTableBits = array(
128	128	array(10, 12, 14),
129		- array( 9, 11, 13),
130		- array( 8, 16, 16),
131		- array( 8, 10, 12)
	129	+ array(9, 11, 13),
	130	+ array(8, 16, 16),
	131	+ array(8, 10, 12)
132	132	);
133	133
134	134	//----------------------------------------------------------------------
		@@ -151,12 +151,12 @@ discard block
		block discarded – undo
151	151	//----------------------------------------------------------------------
152	152	public static function maximumWords($mode, $version)
153	153	{
154		- if($mode == QR_MODE_STRUCTURE)
	154	+ if ($mode == QR_MODE_STRUCTURE)
155	155	return 3;
156	156
157		- if($version <= 9) {
	157	+ if ($version <= 9) {
158	158	$l = 0;
159		- } else if($version <= 26) {
	159	+ } else if ($version <= 26) {
160	160	$l = 1;
161	161	} else {
162	162	$l = 2;
		@@ -165,7 +165,7 @@ discard block
		block discarded – undo
165	165	$bits = self::$lengthTableBits[$mode][$l];
166	166	$words = (1 << $bits) - 1;
167	167
168		- if($mode == QR_MODE_KANJI) {
	168	+ if ($mode == QR_MODE_KANJI) {
169	169	$words *= 2; // the number of bytes is required
170	170	}
171	171
		@@ -177,47 +177,47 @@ discard block
		block discarded – undo
177	177	// See Table 12-16 (pp.30-36), JIS X0510:2004.
178	178
179	179	public static $eccTable = array(
180		- array(array( 0, 0), array( 0, 0), array( 0, 0), array( 0, 0)),
181		- array(array( 1, 0), array( 1, 0), array( 1, 0), array( 1, 0)), // 1
182		- array(array( 1, 0), array( 1, 0), array( 1, 0), array( 1, 0)),
183		- array(array( 1, 0), array( 1, 0), array( 2, 0), array( 2, 0)),
184		- array(array( 1, 0), array( 2, 0), array( 2, 0), array( 4, 0)),
185		- array(array( 1, 0), array( 2, 0), array( 2, 2), array( 2, 2)), // 5
186		- array(array( 2, 0), array( 4, 0), array( 4, 0), array( 4, 0)),
187		- array(array( 2, 0), array( 4, 0), array( 2, 4), array( 4, 1)),
188		- array(array( 2, 0), array( 2, 2), array( 4, 2), array( 4, 2)),
189		- array(array( 2, 0), array( 3, 2), array( 4, 4), array( 4, 4)),
190		- array(array( 2, 2), array( 4, 1), array( 6, 2), array( 6, 2)), //10
191		- array(array( 4, 0), array( 1, 4), array( 4, 4), array( 3, 8)),
192		- array(array( 2, 2), array( 6, 2), array( 4, 6), array( 7, 4)),
193		- array(array( 4, 0), array( 8, 1), array( 8, 4), array(12, 4)),
194		- array(array( 3, 1), array( 4, 5), array(11, 5), array(11, 5)),
195		- array(array( 5, 1), array( 5, 5), array( 5, 7), array(11, 7)), //15
196		- array(array( 5, 1), array( 7, 3), array(15, 2), array( 3, 13)),
197		- array(array( 1, 5), array(10, 1), array( 1, 15), array( 2, 17)),
198		- array(array( 5, 1), array( 9, 4), array(17, 1), array( 2, 19)),
199		- array(array( 3, 4), array( 3, 11), array(17, 4), array( 9, 16)),
200		- array(array( 3, 5), array( 3, 13), array(15, 5), array(15, 10)), //20
201		- array(array( 4, 4), array(17, 0), array(17, 6), array(19, 6)),
202		- array(array( 2, 7), array(17, 0), array( 7, 16), array(34, 0)),
203		- array(array( 4, 5), array( 4, 14), array(11, 14), array(16, 14)),
204		- array(array( 6, 4), array( 6, 14), array(11, 16), array(30, 2)),
205		- array(array( 8, 4), array( 8, 13), array( 7, 22), array(22, 13)), //25
206		- array(array(10, 2), array(19, 4), array(28, 6), array(33, 4)),
207		- array(array( 8, 4), array(22, 3), array( 8, 26), array(12, 28)),
208		- array(array( 3, 10), array( 3, 23), array( 4, 31), array(11, 31)),
209		- array(array( 7, 7), array(21, 7), array( 1, 37), array(19, 26)),
210		- array(array( 5, 10), array(19, 10), array(15, 25), array(23, 25)), //30
211		- array(array(13, 3), array( 2, 29), array(42, 1), array(23, 28)),
212		- array(array(17, 0), array(10, 23), array(10, 35), array(19, 35)),
213		- array(array(17, 1), array(14, 21), array(29, 19), array(11, 46)),
214		- array(array(13, 6), array(14, 23), array(44, 7), array(59, 1)),
215		- array(array(12, 7), array(12, 26), array(39, 14), array(22, 41)), //35
216		- array(array( 6, 14), array( 6, 34), array(46, 10), array( 2, 64)),
217		- array(array(17, 4), array(29, 14), array(49, 10), array(24, 46)),
218		- array(array( 4, 18), array(13, 32), array(48, 14), array(42, 32)),
219		- array(array(20, 4), array(40, 7), array(43, 22), array(10, 67)),
220		- array(array(19, 6), array(18, 31), array(34, 34), array(20, 61)),//40
	180	+ array(array(0, 0), array(0, 0), array(0, 0), array(0, 0)),
	181	+ array(array(1, 0), array(1, 0), array(1, 0), array(1, 0)), // 1
	182	+ array(array(1, 0), array(1, 0), array(1, 0), array(1, 0)),
	183	+ array(array(1, 0), array(1, 0), array(2, 0), array(2, 0)),
	184	+ array(array(1, 0), array(2, 0), array(2, 0), array(4, 0)),
	185	+ array(array(1, 0), array(2, 0), array(2, 2), array(2, 2)), // 5
	186	+ array(array(2, 0), array(4, 0), array(4, 0), array(4, 0)),
	187	+ array(array(2, 0), array(4, 0), array(2, 4), array(4, 1)),
	188	+ array(array(2, 0), array(2, 2), array(4, 2), array(4, 2)),
	189	+ array(array(2, 0), array(3, 2), array(4, 4), array(4, 4)),
	190	+ array(array(2, 2), array(4, 1), array(6, 2), array(6, 2)), //10
	191	+ array(array(4, 0), array(1, 4), array(4, 4), array(3, 8)),
	192	+ array(array(2, 2), array(6, 2), array(4, 6), array(7, 4)),
	193	+ array(array(4, 0), array(8, 1), array(8, 4), array(12, 4)),
	194	+ array(array(3, 1), array(4, 5), array(11, 5), array(11, 5)),
	195	+ array(array(5, 1), array(5, 5), array(5, 7), array(11, 7)), //15
	196	+ array(array(5, 1), array(7, 3), array(15, 2), array(3, 13)),
	197	+ array(array(1, 5), array(10, 1), array(1, 15), array(2, 17)),
	198	+ array(array(5, 1), array(9, 4), array(17, 1), array(2, 19)),
	199	+ array(array(3, 4), array(3, 11), array(17, 4), array(9, 16)),
	200	+ array(array(3, 5), array(3, 13), array(15, 5), array(15, 10)), //20
	201	+ array(array(4, 4), array(17, 0), array(17, 6), array(19, 6)),
	202	+ array(array(2, 7), array(17, 0), array(7, 16), array(34, 0)),
	203	+ array(array(4, 5), array(4, 14), array(11, 14), array(16, 14)),
	204	+ array(array(6, 4), array(6, 14), array(11, 16), array(30, 2)),
	205	+ array(array(8, 4), array(8, 13), array(7, 22), array(22, 13)), //25
	206	+ array(array(10, 2), array(19, 4), array(28, 6), array(33, 4)),
	207	+ array(array(8, 4), array(22, 3), array(8, 26), array(12, 28)),
	208	+ array(array(3, 10), array(3, 23), array(4, 31), array(11, 31)),
	209	+ array(array(7, 7), array(21, 7), array(1, 37), array(19, 26)),
	210	+ array(array(5, 10), array(19, 10), array(15, 25), array(23, 25)), //30
	211	+ array(array(13, 3), array(2, 29), array(42, 1), array(23, 28)),
	212	+ array(array(17, 0), array(10, 23), array(10, 35), array(19, 35)),
	213	+ array(array(17, 1), array(14, 21), array(29, 19), array(11, 46)),
	214	+ array(array(13, 6), array(14, 23), array(44, 7), array(59, 1)),
	215	+ array(array(12, 7), array(12, 26), array(39, 14), array(22, 41)), //35
	216	+ array(array(6, 14), array(6, 34), array(46, 10), array(2, 64)),
	217	+ array(array(17, 4), array(29, 14), array(49, 10), array(24, 46)),
	218	+ array(array(4, 18), array(13, 32), array(48, 14), array(42, 32)),
	219	+ array(array(20, 4), array(40, 7), array(43, 22), array(10, 67)),
	220	+ array(array(19, 6), array(18, 31), array(34, 34), array(20, 61)), //40
221	221	);
222	222
223	223	//----------------------------------------------------------------------
		@@ -226,7 +226,7 @@ discard block
		block discarded – undo
226	226	public static function getEccSpec($version, $level, array &$spec)
227	227	{
228	228	if (count($spec) < 5) {
229		- $spec = array(0,0,0,0,0);
	229	+ $spec = array(0, 0, 0, 0, 0);
230	230	}
231	231
232	232	$b1 = self::$eccTable[$version][$level][0];
		@@ -234,16 +234,16 @@ discard block
		block discarded – undo
234	234	$data = self::getDataLength($version, $level);
235	235	$ecc = self::getECCLength($version, $level);
236	236
237		- if($b2 == 0) {
	237	+ if ($b2 == 0) {
238	238	$spec[0] = $b1;
239		- $spec[1] = (int)($data / $b1);
240		- $spec[2] = (int)($ecc / $b1);
	239	+ $spec[1] = (int) ($data / $b1);
	240	+ $spec[2] = (int) ($ecc / $b1);
241	241	$spec[3] = 0;
242	242	$spec[4] = 0;
243	243	} else {
244	244	$spec[0] = $b1;
245		- $spec[1] = (int)($data / ($b1 + $b2));
246		- $spec[2] = (int)($ecc / ($b1 + $b2));
	245	+ $spec[1] = (int) ($data / ($b1 + $b2));
	246	+ $spec[2] = (int) ($ecc / ($b1 + $b2));
247	247	$spec[3] = $b2;
248	248	$spec[4] = $spec[1] + 1;
249	249	}
		@@ -259,9 +259,9 @@ discard block
		block discarded – undo
259	259	// See Table 1 in Appendix E (pp.71) of JIS X0510:2004.
260	260
261	261	public static $alignmentPattern = array(
262		- array( 0, 0),
263		- array( 0, 0), array(18, 0), array(22, 0), array(26, 0), array(30, 0), // 1- 5
264		- array(34, 0), array(22, 38), array(24, 42), array(26, 46), array(28, 50), // 6-10
	262	+ array(0, 0),
	263	+ array(0, 0), array(18, 0), array(22, 0), array(26, 0), array(30, 0), // 1- 5
	264	+ array(34, 0), array(22, 38), array(24, 42), array(26, 46), array(28, 50), // 6-10
265	265	array(30, 54), array(32, 58), array(34, 62), array(26, 46), array(26, 48), //11-15
266	266	array(26, 50), array(30, 54), array(30, 56), array(30, 58), array(34, 62), //16-20
267	267	array(28, 50), array(26, 50), array(30, 54), array(28, 54), array(32, 58), //21-25
		@@ -287,28 +287,28 @@ discard block
		block discarded – undo
287	287	"\xa1\xa1\xa1\xa1\xa1"
288	288	);
289	289
290		- $yStart = $oy-2;
291		- $xStart = $ox-2;
	290	+ $yStart = $oy - 2;
	291	+ $xStart = $ox - 2;
292	292
293		- for($y=0; $y<5; $y++) {
294		- QRstr::set($frame, $xStart, $yStart+$y, $finder[$y]);
	293	+ for ($y = 0; $y < 5; $y++) {
	294	+ QRstr::set($frame, $xStart, $yStart + $y, $finder[$y]);
295	295	}
296	296	}
297	297
298	298	//----------------------------------------------------------------------
299	299	public static function putAlignmentPattern($version, &$frame, $width)
300	300	{
301		- if($version < 2)
	301	+ if ($version < 2)
302	302	return;
303	303
304	304	$d = self::$alignmentPattern[$version][1] - self::$alignmentPattern[$version][0];
305		- if($d < 0) {
	305	+ if ($d < 0) {
306	306	$w = 2;
307	307	} else {
308		- $w = (int)(($width - self::$alignmentPattern[$version][0]) / $d + 2);
	308	+ $w = (int) (($width - self::$alignmentPattern[$version][0]) / $d + 2);
309	309	}
310	310
311		- if($w * $w - 3 == 1) {
	311	+ if ($w * $w - 3 == 1) {
312	312	$x = self::$alignmentPattern[$version][0];
313	313	$y = self::$alignmentPattern[$version][0];
314	314	self::putAlignmentMarker($frame, $x, $y);
		@@ -316,16 +316,16 @@ discard block
		block discarded – undo
316	316	}
317	317
318	318	$cx = self::$alignmentPattern[$version][0];
319		- for($x=1; $x<$w - 1; $x++) {
	319	+ for ($x = 1; $x < $w - 1; $x++) {
320	320	self::putAlignmentMarker($frame, 6, $cx);
321		- self::putAlignmentMarker($frame, $cx, 6);
	321	+ self::putAlignmentMarker($frame, $cx, 6);
322	322	$cx += $d;
323	323	}
324	324
325	325	$cy = self::$alignmentPattern[$version][0];
326		- for($y=0; $y<$w-1; $y++) {
	326	+ for ($y = 0; $y < $w - 1; $y++) {
327	327	$cx = self::$alignmentPattern[$version][0];
328		- for($x=0; $x<$w-1; $x++) {
	328	+ for ($x = 0; $x < $w - 1; $x++) {
329	329	self::putAlignmentMarker($frame, $cx, $cy);
330	330	$cx += $d;
331	331	}
		@@ -351,10 +351,10 @@ discard block
		block discarded – undo
351	351	//----------------------------------------------------------------------
352	352	public static function getVersionPattern($version)
353	353	{
354		- if($version < 7 \|\| $version > QRSPEC_VERSION_MAX)
	354	+ if ($version < 7 \|\| $version > QRSPEC_VERSION_MAX)
355	355	return 0;
356	356
357		- return self::$versionPattern[$version -7];
	357	+ return self::$versionPattern[$version - 7];
358	358	}
359	359
360	360	// Format information --------------------------------------------------
		@@ -369,10 +369,10 @@ discard block
		block discarded – undo
369	369
370	370	public static function getFormatInfo($mask, $level)
371	371	{
372		- if($mask < 0 \|\| $mask > 7)
	372	+ if ($mask < 0 \|\| $mask > 7)
373	373	return 0;
374	374
375		- if($level < 0 \|\| $level > 3)
	375	+ if ($level < 0 \|\| $level > 3)
376	376	return 0;
377	377
378	378	return self::$formatInfo[$level][$mask];
		@@ -401,8 +401,8 @@ discard block
		block discarded – undo
401	401	"\xc1\xc1\xc1\xc1\xc1\xc1\xc1"
402	402	);
403	403
404		- for($y=0; $y<7; $y++) {
405		- QRstr::set($frame, $ox, $oy+$y, $finder[$y]);
	404	+ for ($y = 0; $y < 7; $y++) {
	405	+ QRstr::set($frame, $ox, $oy + $y, $finder[$y]);
406	406	}
407	407	}
408	408
		@@ -410,7 +410,7 @@ discard block
		block discarded – undo
410	410	public static function createFrame($version)
411	411	{
412	412	$width = self::$capacity[$version][QRCAP_WIDTH];
413		- $frameLine = str_repeat ("\0", $width);
	413	+ $frameLine = str_repeat("\0", $width);
414	414	$frame = array_fill(0, $width, $frameLine);
415	415
416	416	// Finder pattern
		@@ -421,7 +421,7 @@ discard block
		block discarded – undo
421	421	// Separator
422	422	$yOffset = $width - 7;
423	423
424		- for($y=0; $y<7; $y++) {
	424	+ for ($y = 0; $y < 7; $y++) {
425	425	$frame[$y][7] = "\xc0";
426	426	$frame[$y][$width - 8] = "\xc0";
427	427	$frame[$yOffset][7] = "\xc0";
		@@ -431,7 +431,7 @@ discard block
		block discarded – undo
431	431	$setPattern = str_repeat("\xc0", 8);
432	432
433	433	QRstr::set($frame, 0, 7, $setPattern);
434		- QRstr::set($frame, $width-8, 7, $setPattern);
	434	+ QRstr::set($frame, $width - 8, 7, $setPattern);
435	435	QRstr::set($frame, 0, $width - 8, $setPattern);
436	436
437	437	// Format info
		@@ -441,38 +441,38 @@ discard block
		block discarded – undo
441	441
442	442	$yOffset = $width - 8;
443	443
444		- for($y=0; $y<8; $y++,$yOffset++) {
	444	+ for ($y = 0; $y < 8; $y++, $yOffset++) {
445	445	$frame[$y][8] = "\x84";
446	446	$frame[$yOffset][8] = "\x84";
447	447	}
448	448
449	449	// Timing pattern
450	450
451		- for($i=1; $i<$width-15; $i++) {
452		- $frame[6][7+$i] = chr(0x90 \| ($i & 1));
453		- $frame[7+$i][6] = chr(0x90 \| ($i & 1));
	451	+ for ($i = 1; $i < $width - 15; $i++) {
	452	+ $frame[6][7 + $i] = chr(0x90 \| ($i & 1));
	453	+ $frame[7 + $i][6] = chr(0x90 \| ($i & 1));
454	454	}
455	455
456	456	// Alignment pattern
457	457	self::putAlignmentPattern($version, $frame, $width);
458	458
459	459	// Version information
460		- if($version >= 7) {
	460	+ if ($version >= 7) {
461	461	$vinf = self::getVersionPattern($version);
462	462
463	463	$v = $vinf;
464	464
465		- for($x=0; $x<6; $x++) {
466		- for($y=0; $y<3; $y++) {
467		- $frame[($width - 11)+$y][$x] = chr(0x88 \| ($v & 1));
	465	+ for ($x = 0; $x < 6; $x++) {
	466	+ for ($y = 0; $y < 3; $y++) {
	467	+ $frame[($width - 11) + $y][$x] = chr(0x88 \| ($v & 1));
468	468	$v = $v >> 1;
469	469	}
470	470	}
471	471
472	472	$v = $vinf;
473		- for($y=0; $y<6; $y++) {
474		- for($x=0; $x<3; $x++) {
475		- $frame[$y][$x+($width - 11)] = chr(0x88 \| ($v & 1));
	473	+ for ($y = 0; $y < 6; $y++) {
	474	+ for ($x = 0; $x < 3; $x++) {
	475	+ $frame[$y][$x + ($width - 11)] = chr(0x88 \| ($v & 1));
476	476	$v = $v >> 1;
477	477	}
478	478	}
		@@ -506,16 +506,16 @@ discard block
		block discarded – undo
506	506	} else {
507	507
508	508	foreach ($frame as &$frameLine) {
509		- $frameLine = join('<span class="m"> </span>', explode("\xc0", $frameLine));
	509	+ $frameLine = join('<span class="m"> </span>', explode("\xc0", $frameLine));
510	510	$frameLine = join('<span class="m">▒</span>', explode("\xc1", $frameLine));
511		- $frameLine = join('<span class="p"> </span>', explode("\xa0", $frameLine));
	511	+ $frameLine = join('<span class="p"> </span>', explode("\xa0", $frameLine));
512	512	$frameLine = join('<span class="p">▒</span>', explode("\xa1", $frameLine));
513	513	$frameLine = join('<span class="s">◇</span>', explode("\x84", $frameLine)); //format 0
514	514	$frameLine = join('<span class="s">◆</span>', explode("\x85", $frameLine)); //format 1
515	515	$frameLine = join('<span class="x">☢</span>', explode("\x81", $frameLine)); //special bit
516		- $frameLine = join('<span class="c"> </span>', explode("\x90", $frameLine)); //clock 0
	516	+ $frameLine = join('<span class="c"> </span>', explode("\x90", $frameLine)); //clock 0
517	517	$frameLine = join('<span class="c">◷</span>', explode("\x91", $frameLine)); //clock 1
518		- $frameLine = join('<span class="f"> </span>', explode("\x88", $frameLine)); //version
	518	+ $frameLine = join('<span class="f"> </span>', explode("\x88", $frameLine)); //version
519	519	$frameLine = join('<span class="f">▒</span>', explode("\x89", $frameLine)); //version
520	520	$frameLine = join('♦', explode("\x01", $frameLine));
521	521	$frameLine = join('⋅', explode("\0", $frameLine));
		@@ -553,10 +553,10 @@ discard block
		block discarded – undo
553	553	//----------------------------------------------------------------------
554	554	public static function newFrame($version)
555	555	{
556		- if($version < 1 \|\| $version > QRSPEC_VERSION_MAX)
	556	+ if ($version < 1 \|\| $version > QRSPEC_VERSION_MAX)
557	557	return null;
558	558
559		- if(!isset(self::$frames[$version])) {
	559	+ if (!isset(self::$frames[$version])) {
560	560
561	561	$fileName = QR_CACHE_DIR.'frame_'.$version.'.dat';
562	562
		@@ -572,21 +572,21 @@ discard block
		block discarded – undo
572	572	}
573	573	}
574	574
575		- if(is_null(self::$frames[$version]))
	575	+ if (is_null(self::$frames[$version]))
576	576	return null;
577	577
578	578	return self::$frames[$version];
579	579	}
580	580
581	581	//----------------------------------------------------------------------
582		- public static function rsBlockNum($spec) { return $spec[0] + $spec[3]; }
583		- public static function rsBlockNum1($spec) { return $spec[0]; }
584		- public static function rsDataCodes1($spec) { return $spec[1]; }
585		- public static function rsEccCodes1($spec) { return $spec[2]; }
586		- public static function rsBlockNum2($spec) { return $spec[3]; }
587		- public static function rsDataCodes2($spec) { return $spec[4]; }
588		- public static function rsEccCodes2($spec) { return $spec[2]; }
589		- public static function rsDataLength($spec) { return ($spec[0] * $spec[1]) + ($spec[3] * $spec[4]); }
590		- public static function rsEccLength($spec) { return ($spec[0] + $spec[3]) * $spec[2]; }
	582	+ public static function rsBlockNum($spec) { return $spec[0] + $spec[3]; }
	583	+ public static function rsBlockNum1($spec) { return $spec[0]; }
	584	+ public static function rsDataCodes1($spec) { return $spec[1]; }
	585	+ public static function rsEccCodes1($spec) { return $spec[2]; }
	586	+ public static function rsBlockNum2($spec) { return $spec[3]; }
	587	+ public static function rsDataCodes2($spec) { return $spec[4]; }
	588	+ public static function rsEccCodes2($spec) { return $spec[2]; }
	589	+ public static function rsDataLength($spec) { return ($spec[0] * $spec[1]) + ($spec[3] * $spec[4]); }
	590	+ public static function rsEccLength($spec) { return ($spec[0] + $spec[3]) * $spec[2]; }
591	591
592	592	}
593	593	\ No newline at end of file

Please login to merge, or discard this patch.

Braces +27 added lines, -18 removed lines patch added patch discarded remove patch

@@ -115,8 +115,9 @@  discard block
 block discarded – undo
 
             for($i=1; $i<= QRSPEC_VERSION_MAX; $i++) {
                 $words  = self::$capacity[$i][QRCAP_WORDS] - self::$capacity[$i][QRCAP_EC][$level];
-                if($words >= $size) 
-                    return $i;
+                if($words >= $size) {
+                                    return $i;
+                }
             }
 
             return -1;
@@ -134,8 +135,9 @@  discard block
 block discarded – undo
         //----------------------------------------------------------------------
         public static function lengthIndicator($mode, $version)
         {
-            if ($mode == QR_MODE_STRUCTURE)
-                return 0;
+            if ($mode == QR_MODE_STRUCTURE) {
+                            return 0;
+            }
                 
             if ($version <= 9) {
                 $l = 0;
@@ -151,8 +153,9 @@  discard block
 block discarded – undo
         //----------------------------------------------------------------------
         public static function maximumWords($mode, $version)
         {
-            if($mode == QR_MODE_STRUCTURE) 
-                return 3;
+            if($mode == QR_MODE_STRUCTURE) {
+                            return 3;
+            }
                 
             if($version <= 9) {
                 $l = 0;
@@ -298,8 +301,9 @@  discard block
 block discarded – undo
         //----------------------------------------------------------------------
         public static function putAlignmentPattern($version, &$frame, $width)
         {
-            if($version < 2)
-                return;
+            if($version < 2) {
+                            return;
+            }
 
             $d = self::$alignmentPattern[$version][1] - self::$alignmentPattern[$version][0];
             if($d < 0) {
@@ -351,8 +355,9 @@  discard block
 block discarded – undo
         //----------------------------------------------------------------------
         public static function getVersionPattern($version)
         {
-            if($version < 7 || $version > QRSPEC_VERSION_MAX)
-                return 0;
+            if($version < 7 || $version > QRSPEC_VERSION_MAX) {
+                            return 0;
+            }
 
             return self::$versionPattern[$version -7];
         }
@@ -369,11 +374,13 @@  discard block
 block discarded – undo
 
         public static function getFormatInfo($mask, $level)
         {
-            if($mask < 0 || $mask > 7)
-                return 0;
+            if($mask < 0 || $mask > 7) {
+                            return 0;
+            }
                 
-            if($level < 0 || $level > 3)
-                return 0;                
+            if($level < 0 || $level > 3) {
+                            return 0;
+            }
 
             return self::$formatInfo[$level][$mask];
         }
@@ -553,8 +560,9 @@  discard block
 block discarded – undo
         //----------------------------------------------------------------------
         public static function newFrame($version)
         {
-            if($version < 1 || $version > QRSPEC_VERSION_MAX) 
-                return null;
+            if($version < 1 || $version > QRSPEC_VERSION_MAX) {
+                            return null;
+            }
 
             if(!isset(self::$frames[$version])) {
                 
@@ -572,8 +580,9 @@  discard block
 block discarded – undo
                 }
             }
             
-            if(is_null(self::$frames[$version]))
-                return null;
+            if(is_null(self::$frames[$version])) {
+                            return null;
+            }
 
             return self::$frames[$version];
         }

Please login to merge, or discard this patch.

lib/phpqrcode/phpqrcode.php 4 patches

Indentation +2646 added lines, -2646 removed lines patch added patch discarded remove patch

@@ -114,15 +114,15 @@  discard block
 block discarded – undo
  * Config file, tuned-up for merged verion
  */
      
-    define('QR_CACHEABLE', false);       // use cache - more disk reads but less CPU power, masks and format templates are stored there
-    define('QR_CACHE_DIR', false);       // used when QR_CACHEABLE === true
-    define('QR_LOG_DIR', false);         // default error logs dir   
+	define('QR_CACHEABLE', false);       // use cache - more disk reads but less CPU power, masks and format templates are stored there
+	define('QR_CACHE_DIR', false);       // used when QR_CACHEABLE === true
+	define('QR_LOG_DIR', false);         // default error logs dir   
     
-    define('QR_FIND_BEST_MASK', true);                                                          // if true, estimates best mask (spec. default, but extremally slow; set to false to significant performance boost but (propably) worst quality code
-    define('QR_FIND_FROM_RANDOM', 2);                                                       // if false, checks all masks available, otherwise value tells count of masks need to be checked, mask id are got randomly
-    define('QR_DEFAULT_MASK', 2);                                                               // when QR_FIND_BEST_MASK === false
+	define('QR_FIND_BEST_MASK', true);                                                          // if true, estimates best mask (spec. default, but extremally slow; set to false to significant performance boost but (propably) worst quality code
+	define('QR_FIND_FROM_RANDOM', 2);                                                       // if false, checks all masks available, otherwise value tells count of masks need to be checked, mask id are got randomly
+	define('QR_DEFAULT_MASK', 2);                                                               // when QR_FIND_BEST_MASK === false
                                                   
-    define('QR_PNG_MAXIMUM_SIZE',  1024);                                                       // maximum allowed png image width (in pixels), tune to make sure GD and PHP can handle such big images
+	define('QR_PNG_MAXIMUM_SIZE',  1024);                                                       // maximum allowed png image width (in pixels), tune to make sure GD and PHP can handle such big images
                                                   
 
 
@@ -155,153 +155,153 @@  discard block
 block discarded – undo
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
-    class QRtools {
+	class QRtools {
     
-        //----------------------------------------------------------------------
-        public static function binarize($frame)
-        {
-            $len = count($frame);
-            foreach ($frame as &$frameLine) {
+		//----------------------------------------------------------------------
+		public static function binarize($frame)
+		{
+			$len = count($frame);
+			foreach ($frame as &$frameLine) {
                 
-                for($i=0; $i<$len; $i++) {
-                    $frameLine[$i] = (ord($frameLine[$i])&1)?'1':'0';
-                }
-            }
+				for($i=0; $i<$len; $i++) {
+					$frameLine[$i] = (ord($frameLine[$i])&1)?'1':'0';
+				}
+			}
             
-            return $frame;
-        }
+			return $frame;
+		}
         
-        //----------------------------------------------------------------------
-        public static function tcpdfBarcodeArray($code, $mode = 'QR,L', $tcPdfVersion = '4.5.037')
-        {
-            $barcode_array = array();
+		//----------------------------------------------------------------------
+		public static function tcpdfBarcodeArray($code, $mode = 'QR,L', $tcPdfVersion = '4.5.037')
+		{
+			$barcode_array = array();
             
-            if (!is_array($mode))
-                $mode = explode(',', $mode);
+			if (!is_array($mode))
+				$mode = explode(',', $mode);
                 
-            $eccLevel = 'L';
+			$eccLevel = 'L';
                 
-            if (count($mode) > 1) {
-                $eccLevel = $mode[1];
-            }
+			if (count($mode) > 1) {
+				$eccLevel = $mode[1];
+			}
                 
-            $qrTab = QRcode::text($code, false, $eccLevel);
-            $size = count($qrTab);
+			$qrTab = QRcode::text($code, false, $eccLevel);
+			$size = count($qrTab);
                 
-            $barcode_array['num_rows'] = $size;
-            $barcode_array['num_cols'] = $size;
-            $barcode_array['bcode'] = array();
+			$barcode_array['num_rows'] = $size;
+			$barcode_array['num_cols'] = $size;
+			$barcode_array['bcode'] = array();
                 
-            foreach ($qrTab as $line) {
-                $arrAdd = array();
-                foreach(str_split($line) as $char)
-                    $arrAdd[] = ($char=='1')?1:0;
-                $barcode_array['bcode'][] = $arrAdd;
-            }
+			foreach ($qrTab as $line) {
+				$arrAdd = array();
+				foreach(str_split($line) as $char)
+					$arrAdd[] = ($char=='1')?1:0;
+				$barcode_array['bcode'][] = $arrAdd;
+			}
                     
-            return $barcode_array;
-        }
-        
-        //----------------------------------------------------------------------
-        public static function clearCache()
-        {
-            self::$frames = array();
-        }
-        
-        //----------------------------------------------------------------------
-        public static function buildCache()
-        {
+			return $barcode_array;
+		}
+        
+		//----------------------------------------------------------------------
+		public static function clearCache()
+		{
+			self::$frames = array();
+		}
+        
+		//----------------------------------------------------------------------
+		public static function buildCache()
+		{
 			QRtools::markTime('before_build_cache');
 			
 			$mask = new QRmask();
-            for ($a=1; $a <= QRSPEC_VERSION_MAX; $a++) {
-                $frame = QRspec::newFrame($a);
-                if (QR_IMAGE) {
-                    $fileName = QR_CACHE_DIR.'frame_'.$a.'.png';
-                    QRimage::png(self::binarize($frame), $fileName, 1, 0);
-                }
+			for ($a=1; $a <= QRSPEC_VERSION_MAX; $a++) {
+				$frame = QRspec::newFrame($a);
+				if (QR_IMAGE) {
+					$fileName = QR_CACHE_DIR.'frame_'.$a.'.png';
+					QRimage::png(self::binarize($frame), $fileName, 1, 0);
+				}
 				
 				$width = count($frame);
 				$bitMask = array_fill(0, $width, array_fill(0, $width, 0));
 				for ($maskNo=0; $maskNo<8; $maskNo++)
 					$mask->makeMaskNo($maskNo, $width, $frame, $bitMask, true);
-            }
+			}
 			
 			QRtools::markTime('after_build_cache');
-        }
-
-        //----------------------------------------------------------------------
-        public static function log($outfile, $err)
-        {
-            if (QR_LOG_DIR !== false) {
-                if ($err != '') {
-                    if ($outfile !== false) {
-                        file_put_contents(QR_LOG_DIR.basename($outfile).'-errors.txt', date('Y-m-d H:i:s').': '.$err, FILE_APPEND);
-                    } else {
-                        file_put_contents(QR_LOG_DIR.'errors.txt', date('Y-m-d H:i:s').': '.$err, FILE_APPEND);
-                    }
-                }    
-            }
-        }
-        
-        //----------------------------------------------------------------------
-        public static function dumpMask($frame) 
-        {
-            $width = count($frame);
-            for($y=0;$y<$width;$y++) {
-                for($x=0;$x<$width;$x++) {
-                    echo ord($frame[$y][$x]).',';
-                }
-            }
-        }
-        
-        //----------------------------------------------------------------------
-        public static function markTime($markerId)
-        {
-            list($usec, $sec) = explode(" ", microtime());
-            $time = ((float)$usec + (float)$sec);
-            
-            if (!isset($GLOBALS['qr_time_bench']))
-                $GLOBALS['qr_time_bench'] = array();
-            
-            $GLOBALS['qr_time_bench'][$markerId] = $time;
-        }
-        
-        //----------------------------------------------------------------------
-        public static function timeBenchmark()
-        {
-            self::markTime('finish');
-        
-            $lastTime = 0;
-            $startTime = 0;
-            $p = 0;
-
-            echo '<table cellpadding="3" cellspacing="1">
+		}
+
+		//----------------------------------------------------------------------
+		public static function log($outfile, $err)
+		{
+			if (QR_LOG_DIR !== false) {
+				if ($err != '') {
+					if ($outfile !== false) {
+						file_put_contents(QR_LOG_DIR.basename($outfile).'-errors.txt', date('Y-m-d H:i:s').': '.$err, FILE_APPEND);
+					} else {
+						file_put_contents(QR_LOG_DIR.'errors.txt', date('Y-m-d H:i:s').': '.$err, FILE_APPEND);
+					}
+				}    
+			}
+		}
+        
+		//----------------------------------------------------------------------
+		public static function dumpMask($frame) 
+		{
+			$width = count($frame);
+			for($y=0;$y<$width;$y++) {
+				for($x=0;$x<$width;$x++) {
+					echo ord($frame[$y][$x]).',';
+				}
+			}
+		}
+        
+		//----------------------------------------------------------------------
+		public static function markTime($markerId)
+		{
+			list($usec, $sec) = explode(" ", microtime());
+			$time = ((float)$usec + (float)$sec);
+            
+			if (!isset($GLOBALS['qr_time_bench']))
+				$GLOBALS['qr_time_bench'] = array();
+            
+			$GLOBALS['qr_time_bench'][$markerId] = $time;
+		}
+        
+		//----------------------------------------------------------------------
+		public static function timeBenchmark()
+		{
+			self::markTime('finish');
+        
+			$lastTime = 0;
+			$startTime = 0;
+			$p = 0;
+
+			echo '<table cellpadding="3" cellspacing="1">
                     <thead><tr style="border-bottom:1px solid silver"><td colspan="2" style="text-align:center">BENCHMARK</td></tr></thead>
                     <tbody>';
 
-            foreach($GLOBALS['qr_time_bench'] as $markerId=>$thisTime) {
-                if ($p > 0) {
-                    echo '<tr><th style="text-align:right">till '.$markerId.': </th><td>'.number_format($thisTime-$lastTime, 6).'s</td></tr>';
-                } else {
-                    $startTime = $thisTime;
-                }
+			foreach($GLOBALS['qr_time_bench'] as $markerId=>$thisTime) {
+				if ($p > 0) {
+					echo '<tr><th style="text-align:right">till '.$markerId.': </th><td>'.number_format($thisTime-$lastTime, 6).'s</td></tr>';
+				} else {
+					$startTime = $thisTime;
+				}
                 
-                $p++;
-                $lastTime = $thisTime;
-            }
+				$p++;
+				$lastTime = $thisTime;
+			}
             
-            echo '</tbody><tfoot>
+			echo '</tbody><tfoot>
                 <tr style="border-top:2px solid black"><th style="text-align:right">TOTAL: </th><td>'.number_format($lastTime-$startTime, 6).'s</td></tr>
             </tfoot>
             </table>';
-        }
+		}
         
-    }
+	}
     
-    //##########################################################################
+	//##########################################################################
     
-    QRtools::markTime('start');
+	QRtools::markTime('start');
     
 
 
@@ -343,497 +343,497 @@  discard block
 block discarded – undo
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  */
  
-    define('QRSPEC_VERSION_MAX', 40);
-    define('QRSPEC_WIDTH_MAX',   177);
+	define('QRSPEC_VERSION_MAX', 40);
+	define('QRSPEC_WIDTH_MAX',   177);
 
-    define('QRCAP_WIDTH',        0);
-    define('QRCAP_WORDS',        1);
-    define('QRCAP_REMINDER',     2);
-    define('QRCAP_EC',           3);
+	define('QRCAP_WIDTH',        0);
+	define('QRCAP_WORDS',        1);
+	define('QRCAP_REMINDER',     2);
+	define('QRCAP_EC',           3);
 
-    class QRspec {
+	class QRspec {
     
-        public static $capacity = array(
-            array(  0,    0, 0, array(   0,    0,    0,    0)),
-            array( 21,   26, 0, array(   7,   10,   13,   17)), // 1
-            array( 25,   44, 7, array(  10,   16,   22,   28)),
-            array( 29,   70, 7, array(  15,   26,   36,   44)),
-            array( 33,  100, 7, array(  20,   36,   52,   64)),
-            array( 37,  134, 7, array(  26,   48,   72,   88)), // 5
-            array( 41,  172, 7, array(  36,   64,   96,  112)),
-            array( 45,  196, 0, array(  40,   72,  108,  130)),
-            array( 49,  242, 0, array(  48,   88,  132,  156)),
-            array( 53,  292, 0, array(  60,  110,  160,  192)),
-            array( 57,  346, 0, array(  72,  130,  192,  224)), //10
-            array( 61,  404, 0, array(  80,  150,  224,  264)),
-            array( 65,  466, 0, array(  96,  176,  260,  308)),
-            array( 69,  532, 0, array( 104,  198,  288,  352)),
-            array( 73,  581, 3, array( 120,  216,  320,  384)),
-            array( 77,  655, 3, array( 132,  240,  360,  432)), //15
-            array( 81,  733, 3, array( 144,  280,  408,  480)),
-            array( 85,  815, 3, array( 168,  308,  448,  532)),
-            array( 89,  901, 3, array( 180,  338,  504,  588)),
-            array( 93,  991, 3, array( 196,  364,  546,  650)),
-            array( 97, 1085, 3, array( 224,  416,  600,  700)), //20
-            array(101, 1156, 4, array( 224,  442,  644,  750)),
-            array(105, 1258, 4, array( 252,  476,  690,  816)),
-            array(109, 1364, 4, array( 270,  504,  750,  900)),
-            array(113, 1474, 4, array( 300,  560,  810,  960)),
-            array(117, 1588, 4, array( 312,  588,  870, 1050)), //25
-            array(121, 1706, 4, array( 336,  644,  952, 1110)),
-            array(125, 1828, 4, array( 360,  700, 1020, 1200)),
-            array(129, 1921, 3, array( 390,  728, 1050, 1260)),
-            array(133, 2051, 3, array( 420,  784, 1140, 1350)),
-            array(137, 2185, 3, array( 450,  812, 1200, 1440)), //30
-            array(141, 2323, 3, array( 480,  868, 1290, 1530)),
-            array(145, 2465, 3, array( 510,  924, 1350, 1620)),
-            array(149, 2611, 3, array( 540,  980, 1440, 1710)),
-            array(153, 2761, 3, array( 570, 1036, 1530, 1800)),
-            array(157, 2876, 0, array( 570, 1064, 1590, 1890)), //35
-            array(161, 3034, 0, array( 600, 1120, 1680, 1980)),
-            array(165, 3196, 0, array( 630, 1204, 1770, 2100)),
-            array(169, 3362, 0, array( 660, 1260, 1860, 2220)),
-            array(173, 3532, 0, array( 720, 1316, 1950, 2310)),
-            array(177, 3706, 0, array( 750, 1372, 2040, 2430)) //40
-        );
-        
-        //----------------------------------------------------------------------
-        public static function getDataLength($version, $level)
-        {
-            return self::$capacity[$version][QRCAP_WORDS] - self::$capacity[$version][QRCAP_EC][$level];
-        }
-        
-        //----------------------------------------------------------------------
-        public static function getECCLength($version, $level)
-        {
-            return self::$capacity[$version][QRCAP_EC][$level];
-        }
-        
-        //----------------------------------------------------------------------
-        public static function getWidth($version)
-        {
-            return self::$capacity[$version][QRCAP_WIDTH];
-        }
-        
-        //----------------------------------------------------------------------
-        public static function getRemainder($version)
-        {
-            return self::$capacity[$version][QRCAP_REMINDER];
-        }
-        
-        //----------------------------------------------------------------------
-        public static function getMinimumVersion($size, $level)
-        {
-
-            for($i=1; $i<= QRSPEC_VERSION_MAX; $i++) {
-                $words  = self::$capacity[$i][QRCAP_WORDS] - self::$capacity[$i][QRCAP_EC][$level];
-                if($words >= $size) 
-                    return $i;
-            }
-
-            return -1;
-        }
+		public static $capacity = array(
+			array(  0,    0, 0, array(   0,    0,    0,    0)),
+			array( 21,   26, 0, array(   7,   10,   13,   17)), // 1
+			array( 25,   44, 7, array(  10,   16,   22,   28)),
+			array( 29,   70, 7, array(  15,   26,   36,   44)),
+			array( 33,  100, 7, array(  20,   36,   52,   64)),
+			array( 37,  134, 7, array(  26,   48,   72,   88)), // 5
+			array( 41,  172, 7, array(  36,   64,   96,  112)),
+			array( 45,  196, 0, array(  40,   72,  108,  130)),
+			array( 49,  242, 0, array(  48,   88,  132,  156)),
+			array( 53,  292, 0, array(  60,  110,  160,  192)),
+			array( 57,  346, 0, array(  72,  130,  192,  224)), //10
+			array( 61,  404, 0, array(  80,  150,  224,  264)),
+			array( 65,  466, 0, array(  96,  176,  260,  308)),
+			array( 69,  532, 0, array( 104,  198,  288,  352)),
+			array( 73,  581, 3, array( 120,  216,  320,  384)),
+			array( 77,  655, 3, array( 132,  240,  360,  432)), //15
+			array( 81,  733, 3, array( 144,  280,  408,  480)),
+			array( 85,  815, 3, array( 168,  308,  448,  532)),
+			array( 89,  901, 3, array( 180,  338,  504,  588)),
+			array( 93,  991, 3, array( 196,  364,  546,  650)),
+			array( 97, 1085, 3, array( 224,  416,  600,  700)), //20
+			array(101, 1156, 4, array( 224,  442,  644,  750)),
+			array(105, 1258, 4, array( 252,  476,  690,  816)),
+			array(109, 1364, 4, array( 270,  504,  750,  900)),
+			array(113, 1474, 4, array( 300,  560,  810,  960)),
+			array(117, 1588, 4, array( 312,  588,  870, 1050)), //25
+			array(121, 1706, 4, array( 336,  644,  952, 1110)),
+			array(125, 1828, 4, array( 360,  700, 1020, 1200)),
+			array(129, 1921, 3, array( 390,  728, 1050, 1260)),
+			array(133, 2051, 3, array( 420,  784, 1140, 1350)),
+			array(137, 2185, 3, array( 450,  812, 1200, 1440)), //30
+			array(141, 2323, 3, array( 480,  868, 1290, 1530)),
+			array(145, 2465, 3, array( 510,  924, 1350, 1620)),
+			array(149, 2611, 3, array( 540,  980, 1440, 1710)),
+			array(153, 2761, 3, array( 570, 1036, 1530, 1800)),
+			array(157, 2876, 0, array( 570, 1064, 1590, 1890)), //35
+			array(161, 3034, 0, array( 600, 1120, 1680, 1980)),
+			array(165, 3196, 0, array( 630, 1204, 1770, 2100)),
+			array(169, 3362, 0, array( 660, 1260, 1860, 2220)),
+			array(173, 3532, 0, array( 720, 1316, 1950, 2310)),
+			array(177, 3706, 0, array( 750, 1372, 2040, 2430)) //40
+		);
+        
+		//----------------------------------------------------------------------
+		public static function getDataLength($version, $level)
+		{
+			return self::$capacity[$version][QRCAP_WORDS] - self::$capacity[$version][QRCAP_EC][$level];
+		}
+        
+		//----------------------------------------------------------------------
+		public static function getECCLength($version, $level)
+		{
+			return self::$capacity[$version][QRCAP_EC][$level];
+		}
+        
+		//----------------------------------------------------------------------
+		public static function getWidth($version)
+		{
+			return self::$capacity[$version][QRCAP_WIDTH];
+		}
+        
+		//----------------------------------------------------------------------
+		public static function getRemainder($version)
+		{
+			return self::$capacity[$version][QRCAP_REMINDER];
+		}
+        
+		//----------------------------------------------------------------------
+		public static function getMinimumVersion($size, $level)
+		{
+
+			for($i=1; $i<= QRSPEC_VERSION_MAX; $i++) {
+				$words  = self::$capacity[$i][QRCAP_WORDS] - self::$capacity[$i][QRCAP_EC][$level];
+				if($words >= $size) 
+					return $i;
+			}
+
+			return -1;
+		}
     
-        //######################################################################
-        
-        public static $lengthTableBits = array(
-            array(10, 12, 14),
-            array( 9, 11, 13),
-            array( 8, 16, 16),
-            array( 8, 10, 12)
-        );
-        
-        //----------------------------------------------------------------------
-        public static function lengthIndicator($mode, $version)
-        {
-            if ($mode == QR_MODE_STRUCTURE)
-                return 0;
+		//######################################################################
+        
+		public static $lengthTableBits = array(
+			array(10, 12, 14),
+			array( 9, 11, 13),
+			array( 8, 16, 16),
+			array( 8, 10, 12)
+		);
+        
+		//----------------------------------------------------------------------
+		public static function lengthIndicator($mode, $version)
+		{
+			if ($mode == QR_MODE_STRUCTURE)
+				return 0;
                 
-            if ($version <= 9) {
-                $l = 0;
-            } else if ($version <= 26) {
-                $l = 1;
-            } else {
-                $l = 2;
-            }
-
-            return self::$lengthTableBits[$mode][$l];
-        }
-        
-        //----------------------------------------------------------------------
-        public static function maximumWords($mode, $version)
-        {
-            if($mode == QR_MODE_STRUCTURE) 
-                return 3;
+			if ($version <= 9) {
+				$l = 0;
+			} else if ($version <= 26) {
+				$l = 1;
+			} else {
+				$l = 2;
+			}
+
+			return self::$lengthTableBits[$mode][$l];
+		}
+        
+		//----------------------------------------------------------------------
+		public static function maximumWords($mode, $version)
+		{
+			if($mode == QR_MODE_STRUCTURE) 
+				return 3;
                 
-            if($version <= 9) {
-                $l = 0;
-            } else if($version <= 26) {
-                $l = 1;
-            } else {
-                $l = 2;
-            }
-
-            $bits = self::$lengthTableBits[$mode][$l];
-            $words = (1 << $bits) - 1;
-            
-            if($mode == QR_MODE_KANJI) {
-                $words *= 2; // the number of bytes is required
-            }
-
-            return $words;
-        }
-
-        // Error correction code -----------------------------------------------
-        // Table of the error correction code (Reed-Solomon block)
-        // See Table 12-16 (pp.30-36), JIS X0510:2004.
-
-        public static $eccTable = array(
-            array(array( 0,  0), array( 0,  0), array( 0,  0), array( 0,  0)),
-            array(array( 1,  0), array( 1,  0), array( 1,  0), array( 1,  0)), // 1
-            array(array( 1,  0), array( 1,  0), array( 1,  0), array( 1,  0)),
-            array(array( 1,  0), array( 1,  0), array( 2,  0), array( 2,  0)),
-            array(array( 1,  0), array( 2,  0), array( 2,  0), array( 4,  0)),
-            array(array( 1,  0), array( 2,  0), array( 2,  2), array( 2,  2)), // 5
-            array(array( 2,  0), array( 4,  0), array( 4,  0), array( 4,  0)),
-            array(array( 2,  0), array( 4,  0), array( 2,  4), array( 4,  1)),
-            array(array( 2,  0), array( 2,  2), array( 4,  2), array( 4,  2)),
-            array(array( 2,  0), array( 3,  2), array( 4,  4), array( 4,  4)),
-            array(array( 2,  2), array( 4,  1), array( 6,  2), array( 6,  2)), //10
-            array(array( 4,  0), array( 1,  4), array( 4,  4), array( 3,  8)),
-            array(array( 2,  2), array( 6,  2), array( 4,  6), array( 7,  4)),
-            array(array( 4,  0), array( 8,  1), array( 8,  4), array(12,  4)),
-            array(array( 3,  1), array( 4,  5), array(11,  5), array(11,  5)),
-            array(array( 5,  1), array( 5,  5), array( 5,  7), array(11,  7)), //15
-            array(array( 5,  1), array( 7,  3), array(15,  2), array( 3, 13)),
-            array(array( 1,  5), array(10,  1), array( 1, 15), array( 2, 17)),
-            array(array( 5,  1), array( 9,  4), array(17,  1), array( 2, 19)),
-            array(array( 3,  4), array( 3, 11), array(17,  4), array( 9, 16)),
-            array(array( 3,  5), array( 3, 13), array(15,  5), array(15, 10)), //20
-            array(array( 4,  4), array(17,  0), array(17,  6), array(19,  6)),
-            array(array( 2,  7), array(17,  0), array( 7, 16), array(34,  0)),
-            array(array( 4,  5), array( 4, 14), array(11, 14), array(16, 14)),
-            array(array( 6,  4), array( 6, 14), array(11, 16), array(30,  2)),
-            array(array( 8,  4), array( 8, 13), array( 7, 22), array(22, 13)), //25
-            array(array(10,  2), array(19,  4), array(28,  6), array(33,  4)),
-            array(array( 8,  4), array(22,  3), array( 8, 26), array(12, 28)),
-            array(array( 3, 10), array( 3, 23), array( 4, 31), array(11, 31)),
-            array(array( 7,  7), array(21,  7), array( 1, 37), array(19, 26)),
-            array(array( 5, 10), array(19, 10), array(15, 25), array(23, 25)), //30
-            array(array(13,  3), array( 2, 29), array(42,  1), array(23, 28)),
-            array(array(17,  0), array(10, 23), array(10, 35), array(19, 35)),
-            array(array(17,  1), array(14, 21), array(29, 19), array(11, 46)),
-            array(array(13,  6), array(14, 23), array(44,  7), array(59,  1)),
-            array(array(12,  7), array(12, 26), array(39, 14), array(22, 41)), //35
-            array(array( 6, 14), array( 6, 34), array(46, 10), array( 2, 64)),
-            array(array(17,  4), array(29, 14), array(49, 10), array(24, 46)),
-            array(array( 4, 18), array(13, 32), array(48, 14), array(42, 32)),
-            array(array(20,  4), array(40,  7), array(43, 22), array(10, 67)),
-            array(array(19,  6), array(18, 31), array(34, 34), array(20, 61)),//40
-        );                                                                       
-
-        //----------------------------------------------------------------------
-        // CACHEABLE!!!
-        
-        public static function getEccSpec($version, $level, array &$spec)
-        {
-            if (count($spec) < 5) {
-                $spec = array(0,0,0,0,0);
-            }
-
-            $b1   = self::$eccTable[$version][$level][0];
-            $b2   = self::$eccTable[$version][$level][1];
-            $data = self::getDataLength($version, $level);
-            $ecc  = self::getECCLength($version, $level);
-
-            if($b2 == 0) {
-                $spec[0] = $b1;
-                $spec[1] = (int)($data / $b1);
-                $spec[2] = (int)($ecc / $b1);
-                $spec[3] = 0; 
-                $spec[4] = 0;
-            } else {
-                $spec[0] = $b1;
-                $spec[1] = (int)($data / ($b1 + $b2));
-                $spec[2] = (int)($ecc  / ($b1 + $b2));
-                $spec[3] = $b2;
-                $spec[4] = $spec[1] + 1;
-            }
-        }
-
-        // Alignment pattern ---------------------------------------------------
-
-        // Positions of alignment patterns.
-        // This array includes only the second and the third position of the 
-        // alignment patterns. Rest of them can be calculated from the distance 
-        // between them.
+			if($version <= 9) {
+				$l = 0;
+			} else if($version <= 26) {
+				$l = 1;
+			} else {
+				$l = 2;
+			}
+
+			$bits = self::$lengthTableBits[$mode][$l];
+			$words = (1 << $bits) - 1;
+            
+			if($mode == QR_MODE_KANJI) {
+				$words *= 2; // the number of bytes is required
+			}
+
+			return $words;
+		}
+
+		// Error correction code -----------------------------------------------
+		// Table of the error correction code (Reed-Solomon block)
+		// See Table 12-16 (pp.30-36), JIS X0510:2004.
+
+		public static $eccTable = array(
+			array(array( 0,  0), array( 0,  0), array( 0,  0), array( 0,  0)),
+			array(array( 1,  0), array( 1,  0), array( 1,  0), array( 1,  0)), // 1
+			array(array( 1,  0), array( 1,  0), array( 1,  0), array( 1,  0)),
+			array(array( 1,  0), array( 1,  0), array( 2,  0), array( 2,  0)),
+			array(array( 1,  0), array( 2,  0), array( 2,  0), array( 4,  0)),
+			array(array( 1,  0), array( 2,  0), array( 2,  2), array( 2,  2)), // 5
+			array(array( 2,  0), array( 4,  0), array( 4,  0), array( 4,  0)),
+			array(array( 2,  0), array( 4,  0), array( 2,  4), array( 4,  1)),
+			array(array( 2,  0), array( 2,  2), array( 4,  2), array( 4,  2)),
+			array(array( 2,  0), array( 3,  2), array( 4,  4), array( 4,  4)),
+			array(array( 2,  2), array( 4,  1), array( 6,  2), array( 6,  2)), //10
+			array(array( 4,  0), array( 1,  4), array( 4,  4), array( 3,  8)),
+			array(array( 2,  2), array( 6,  2), array( 4,  6), array( 7,  4)),
+			array(array( 4,  0), array( 8,  1), array( 8,  4), array(12,  4)),
+			array(array( 3,  1), array( 4,  5), array(11,  5), array(11,  5)),
+			array(array( 5,  1), array( 5,  5), array( 5,  7), array(11,  7)), //15
+			array(array( 5,  1), array( 7,  3), array(15,  2), array( 3, 13)),
+			array(array( 1,  5), array(10,  1), array( 1, 15), array( 2, 17)),
+			array(array( 5,  1), array( 9,  4), array(17,  1), array( 2, 19)),
+			array(array( 3,  4), array( 3, 11), array(17,  4), array( 9, 16)),
+			array(array( 3,  5), array( 3, 13), array(15,  5), array(15, 10)), //20
+			array(array( 4,  4), array(17,  0), array(17,  6), array(19,  6)),
+			array(array( 2,  7), array(17,  0), array( 7, 16), array(34,  0)),
+			array(array( 4,  5), array( 4, 14), array(11, 14), array(16, 14)),
+			array(array( 6,  4), array( 6, 14), array(11, 16), array(30,  2)),
+			array(array( 8,  4), array( 8, 13), array( 7, 22), array(22, 13)), //25
+			array(array(10,  2), array(19,  4), array(28,  6), array(33,  4)),
+			array(array( 8,  4), array(22,  3), array( 8, 26), array(12, 28)),
+			array(array( 3, 10), array( 3, 23), array( 4, 31), array(11, 31)),
+			array(array( 7,  7), array(21,  7), array( 1, 37), array(19, 26)),
+			array(array( 5, 10), array(19, 10), array(15, 25), array(23, 25)), //30
+			array(array(13,  3), array( 2, 29), array(42,  1), array(23, 28)),
+			array(array(17,  0), array(10, 23), array(10, 35), array(19, 35)),
+			array(array(17,  1), array(14, 21), array(29, 19), array(11, 46)),
+			array(array(13,  6), array(14, 23), array(44,  7), array(59,  1)),
+			array(array(12,  7), array(12, 26), array(39, 14), array(22, 41)), //35
+			array(array( 6, 14), array( 6, 34), array(46, 10), array( 2, 64)),
+			array(array(17,  4), array(29, 14), array(49, 10), array(24, 46)),
+			array(array( 4, 18), array(13, 32), array(48, 14), array(42, 32)),
+			array(array(20,  4), array(40,  7), array(43, 22), array(10, 67)),
+			array(array(19,  6), array(18, 31), array(34, 34), array(20, 61)),//40
+		);                                                                       
+
+		//----------------------------------------------------------------------
+		// CACHEABLE!!!
+        
+		public static function getEccSpec($version, $level, array &$spec)
+		{
+			if (count($spec) < 5) {
+				$spec = array(0,0,0,0,0);
+			}
+
+			$b1   = self::$eccTable[$version][$level][0];
+			$b2   = self::$eccTable[$version][$level][1];
+			$data = self::getDataLength($version, $level);
+			$ecc  = self::getECCLength($version, $level);
+
+			if($b2 == 0) {
+				$spec[0] = $b1;
+				$spec[1] = (int)($data / $b1);
+				$spec[2] = (int)($ecc / $b1);
+				$spec[3] = 0; 
+				$spec[4] = 0;
+			} else {
+				$spec[0] = $b1;
+				$spec[1] = (int)($data / ($b1 + $b2));
+				$spec[2] = (int)($ecc  / ($b1 + $b2));
+				$spec[3] = $b2;
+				$spec[4] = $spec[1] + 1;
+			}
+		}
+
+		// Alignment pattern ---------------------------------------------------
+
+		// Positions of alignment patterns.
+		// This array includes only the second and the third position of the 
+		// alignment patterns. Rest of them can be calculated from the distance 
+		// between them.
          
-        // See Table 1 in Appendix E (pp.71) of JIS X0510:2004.
+		// See Table 1 in Appendix E (pp.71) of JIS X0510:2004.
          
-        public static $alignmentPattern = array(      
-            array( 0,  0),
-            array( 0,  0), array(18,  0), array(22,  0), array(26,  0), array(30,  0), // 1- 5
-            array(34,  0), array(22, 38), array(24, 42), array(26, 46), array(28, 50), // 6-10
-            array(30, 54), array(32, 58), array(34, 62), array(26, 46), array(26, 48), //11-15
-            array(26, 50), array(30, 54), array(30, 56), array(30, 58), array(34, 62), //16-20
-            array(28, 50), array(26, 50), array(30, 54), array(28, 54), array(32, 58), //21-25
-            array(30, 58), array(34, 62), array(26, 50), array(30, 54), array(26, 52), //26-30
-            array(30, 56), array(34, 60), array(30, 58), array(34, 62), array(30, 54), //31-35
-            array(24, 50), array(28, 54), array(32, 58), array(26, 54), array(30, 58), //35-40
-        );                                                                                  
-
-        
-        /** --------------------------------------------------------------------
-         * Put an alignment marker.
-         * @param frame
-         * @param width
-         * @param ox,oy center coordinate of the pattern
-         */
-        public static function putAlignmentMarker(array &$frame, $ox, $oy)
-        {
-            $finder = array(
-                "\xa1\xa1\xa1\xa1\xa1",
-                "\xa1\xa0\xa0\xa0\xa1",
-                "\xa1\xa0\xa1\xa0\xa1",
-                "\xa1\xa0\xa0\xa0\xa1",
-                "\xa1\xa1\xa1\xa1\xa1"
-            );                        
-            
-            $yStart = $oy-2;         
-            $xStart = $ox-2;
-            
-            for($y=0; $y<5; $y++) {
-                QRstr::set($frame, $xStart, $yStart+$y, $finder[$y]);
-            }
-        }
-
-        //----------------------------------------------------------------------
-        public static function putAlignmentPattern($version, &$frame, $width)
-        {
-            if($version < 2)
-                return;
-
-            $d = self::$alignmentPattern[$version][1] - self::$alignmentPattern[$version][0];
-            if($d < 0) {
-                $w = 2;
-            } else {
-                $w = (int)(($width - self::$alignmentPattern[$version][0]) / $d + 2);
-            }
-
-            if($w * $w - 3 == 1) {
-                $x = self::$alignmentPattern[$version][0];
-                $y = self::$alignmentPattern[$version][0];
-                self::putAlignmentMarker($frame, $x, $y);
-                return;
-            }
-
-            $cx = self::$alignmentPattern[$version][0];
-            for($x=1; $x<$w - 1; $x++) {
-                self::putAlignmentMarker($frame, 6, $cx);
-                self::putAlignmentMarker($frame, $cx,  6);
-                $cx += $d;
-            }
-
-            $cy = self::$alignmentPattern[$version][0];
-            for($y=0; $y<$w-1; $y++) {
-                $cx = self::$alignmentPattern[$version][0];
-                for($x=0; $x<$w-1; $x++) {
-                    self::putAlignmentMarker($frame, $cx, $cy);
-                    $cx += $d;
-                }
-                $cy += $d;
-            }
-        }
-
-        // Version information pattern -----------------------------------------
+		public static $alignmentPattern = array(      
+			array( 0,  0),
+			array( 0,  0), array(18,  0), array(22,  0), array(26,  0), array(30,  0), // 1- 5
+			array(34,  0), array(22, 38), array(24, 42), array(26, 46), array(28, 50), // 6-10
+			array(30, 54), array(32, 58), array(34, 62), array(26, 46), array(26, 48), //11-15
+			array(26, 50), array(30, 54), array(30, 56), array(30, 58), array(34, 62), //16-20
+			array(28, 50), array(26, 50), array(30, 54), array(28, 54), array(32, 58), //21-25
+			array(30, 58), array(34, 62), array(26, 50), array(30, 54), array(26, 52), //26-30
+			array(30, 56), array(34, 60), array(30, 58), array(34, 62), array(30, 54), //31-35
+			array(24, 50), array(28, 54), array(32, 58), array(26, 54), array(30, 58), //35-40
+		);                                                                                  
+
+        
+		/** --------------------------------------------------------------------
+		 * Put an alignment marker.
+		 * @param frame
+		 * @param width
+		 * @param ox,oy center coordinate of the pattern
+		 */
+		public static function putAlignmentMarker(array &$frame, $ox, $oy)
+		{
+			$finder = array(
+				"\xa1\xa1\xa1\xa1\xa1",
+				"\xa1\xa0\xa0\xa0\xa1",
+				"\xa1\xa0\xa1\xa0\xa1",
+				"\xa1\xa0\xa0\xa0\xa1",
+				"\xa1\xa1\xa1\xa1\xa1"
+			);                        
+            
+			$yStart = $oy-2;         
+			$xStart = $ox-2;
+            
+			for($y=0; $y<5; $y++) {
+				QRstr::set($frame, $xStart, $yStart+$y, $finder[$y]);
+			}
+		}
+
+		//----------------------------------------------------------------------
+		public static function putAlignmentPattern($version, &$frame, $width)
+		{
+			if($version < 2)
+				return;
+
+			$d = self::$alignmentPattern[$version][1] - self::$alignmentPattern[$version][0];
+			if($d < 0) {
+				$w = 2;
+			} else {
+				$w = (int)(($width - self::$alignmentPattern[$version][0]) / $d + 2);
+			}
+
+			if($w * $w - 3 == 1) {
+				$x = self::$alignmentPattern[$version][0];
+				$y = self::$alignmentPattern[$version][0];
+				self::putAlignmentMarker($frame, $x, $y);
+				return;
+			}
+
+			$cx = self::$alignmentPattern[$version][0];
+			for($x=1; $x<$w - 1; $x++) {
+				self::putAlignmentMarker($frame, 6, $cx);
+				self::putAlignmentMarker($frame, $cx,  6);
+				$cx += $d;
+			}
+
+			$cy = self::$alignmentPattern[$version][0];
+			for($y=0; $y<$w-1; $y++) {
+				$cx = self::$alignmentPattern[$version][0];
+				for($x=0; $x<$w-1; $x++) {
+					self::putAlignmentMarker($frame, $cx, $cy);
+					$cx += $d;
+				}
+				$cy += $d;
+			}
+		}
+
+		// Version information pattern -----------------------------------------
 
 		// Version information pattern (BCH coded).
-        // See Table 1 in Appendix D (pp.68) of JIS X0510:2004.
+		// See Table 1 in Appendix D (pp.68) of JIS X0510:2004.
         
 		// size: [QRSPEC_VERSION_MAX - 6]
 		
-        public static $versionPattern = array(
-            0x07c94, 0x085bc, 0x09a99, 0x0a4d3, 0x0bbf6, 0x0c762, 0x0d847, 0x0e60d,
-            0x0f928, 0x10b78, 0x1145d, 0x12a17, 0x13532, 0x149a6, 0x15683, 0x168c9,
-            0x177ec, 0x18ec4, 0x191e1, 0x1afab, 0x1b08e, 0x1cc1a, 0x1d33f, 0x1ed75,
-            0x1f250, 0x209d5, 0x216f0, 0x228ba, 0x2379f, 0x24b0b, 0x2542e, 0x26a64,
-            0x27541, 0x28c69
-        );
-
-        //----------------------------------------------------------------------
-        public static function getVersionPattern($version)
-        {
-            if($version < 7 || $version > QRSPEC_VERSION_MAX)
-                return 0;
-
-            return self::$versionPattern[$version -7];
-        }
-
-        // Format information --------------------------------------------------
-        // See calcFormatInfo in tests/test_qrspec.c (orginal qrencode c lib)
-        
-        public static $formatInfo = array(
-            array(0x77c4, 0x72f3, 0x7daa, 0x789d, 0x662f, 0x6318, 0x6c41, 0x6976),
-            array(0x5412, 0x5125, 0x5e7c, 0x5b4b, 0x45f9, 0x40ce, 0x4f97, 0x4aa0),
-            array(0x355f, 0x3068, 0x3f31, 0x3a06, 0x24b4, 0x2183, 0x2eda, 0x2bed),
-            array(0x1689, 0x13be, 0x1ce7, 0x19d0, 0x0762, 0x0255, 0x0d0c, 0x083b)
-        );
-
-        public static function getFormatInfo($mask, $level)
-        {
-            if($mask < 0 || $mask > 7)
-                return 0;
+		public static $versionPattern = array(
+			0x07c94, 0x085bc, 0x09a99, 0x0a4d3, 0x0bbf6, 0x0c762, 0x0d847, 0x0e60d,
+			0x0f928, 0x10b78, 0x1145d, 0x12a17, 0x13532, 0x149a6, 0x15683, 0x168c9,
+			0x177ec, 0x18ec4, 0x191e1, 0x1afab, 0x1b08e, 0x1cc1a, 0x1d33f, 0x1ed75,
+			0x1f250, 0x209d5, 0x216f0, 0x228ba, 0x2379f, 0x24b0b, 0x2542e, 0x26a64,
+			0x27541, 0x28c69
+		);
+
+		//----------------------------------------------------------------------
+		public static function getVersionPattern($version)
+		{
+			if($version < 7 || $version > QRSPEC_VERSION_MAX)
+				return 0;
+
+			return self::$versionPattern[$version -7];
+		}
+
+		// Format information --------------------------------------------------
+		// See calcFormatInfo in tests/test_qrspec.c (orginal qrencode c lib)
+        
+		public static $formatInfo = array(
+			array(0x77c4, 0x72f3, 0x7daa, 0x789d, 0x662f, 0x6318, 0x6c41, 0x6976),
+			array(0x5412, 0x5125, 0x5e7c, 0x5b4b, 0x45f9, 0x40ce, 0x4f97, 0x4aa0),
+			array(0x355f, 0x3068, 0x3f31, 0x3a06, 0x24b4, 0x2183, 0x2eda, 0x2bed),
+			array(0x1689, 0x13be, 0x1ce7, 0x19d0, 0x0762, 0x0255, 0x0d0c, 0x083b)
+		);
+
+		public static function getFormatInfo($mask, $level)
+		{
+			if($mask < 0 || $mask > 7)
+				return 0;
                 
-            if($level < 0 || $level > 3)
-                return 0;                
+			if($level < 0 || $level > 3)
+				return 0;                
 
-            return self::$formatInfo[$level][$mask];
-        }
+			return self::$formatInfo[$level][$mask];
+		}
 
-        // Frame ---------------------------------------------------------------
-        // Cache of initial frames.
+		// Frame ---------------------------------------------------------------
+		// Cache of initial frames.
          
-        public static $frames = array();
-
-        /** --------------------------------------------------------------------
-         * Put a finder pattern.
-         * @param frame
-         * @param width
-         * @param ox,oy upper-left coordinate of the pattern
-         */
-        public static function putFinderPattern(&$frame, $ox, $oy)
-        {
-            $finder = array(
-                "\xc1\xc1\xc1\xc1\xc1\xc1\xc1",
-                "\xc1\xc0\xc0\xc0\xc0\xc0\xc1",
-                "\xc1\xc0\xc1\xc1\xc1\xc0\xc1",
-                "\xc1\xc0\xc1\xc1\xc1\xc0\xc1",
-                "\xc1\xc0\xc1\xc1\xc1\xc0\xc1",
-                "\xc1\xc0\xc0\xc0\xc0\xc0\xc1",
-                "\xc1\xc1\xc1\xc1\xc1\xc1\xc1"
-            );                            
-            
-            for($y=0; $y<7; $y++) {
-                QRstr::set($frame, $ox, $oy+$y, $finder[$y]);
-            }
-        }
-
-        //----------------------------------------------------------------------
-        public static function createFrame($version)
-        {
-            $width = self::$capacity[$version][QRCAP_WIDTH];
-            $frameLine = str_repeat ("\0", $width);
-            $frame = array_fill(0, $width, $frameLine);
-
-            // Finder pattern
-            self::putFinderPattern($frame, 0, 0);
-            self::putFinderPattern($frame, $width - 7, 0);
-            self::putFinderPattern($frame, 0, $width - 7);
-            
-            // Separator
-            $yOffset = $width - 7;
-            
-            for($y=0; $y<7; $y++) {
-                $frame[$y][7] = "\xc0";
-                $frame[$y][$width - 8] = "\xc0";
-                $frame[$yOffset][7] = "\xc0";
-                $yOffset++;
-            }
-            
-            $setPattern = str_repeat("\xc0", 8);
-            
-            QRstr::set($frame, 0, 7, $setPattern);
-            QRstr::set($frame, $width-8, 7, $setPattern);
-            QRstr::set($frame, 0, $width - 8, $setPattern);
-        
-            // Format info
-            $setPattern = str_repeat("\x84", 9);
-            QRstr::set($frame, 0, 8, $setPattern);
-            QRstr::set($frame, $width - 8, 8, $setPattern, 8);
-            
-            $yOffset = $width - 8;
-
-            for($y=0; $y<8; $y++,$yOffset++) {
-                $frame[$y][8] = "\x84";
-                $frame[$yOffset][8] = "\x84";
-            }
-
-            // Timing pattern  
-            
-            for($i=1; $i<$width-15; $i++) {
-                $frame[6][7+$i] = chr(0x90 | ($i & 1));
-                $frame[7+$i][6] = chr(0x90 | ($i & 1));
-            }
-            
-            // Alignment pattern  
-            self::putAlignmentPattern($version, $frame, $width);
-            
-            // Version information 
-            if($version >= 7) {
-                $vinf = self::getVersionPattern($version);
-
-                $v = $vinf;
+		public static $frames = array();
+
+		/** --------------------------------------------------------------------
+		 * Put a finder pattern.
+		 * @param frame
+		 * @param width
+		 * @param ox,oy upper-left coordinate of the pattern
+		 */
+		public static function putFinderPattern(&$frame, $ox, $oy)
+		{
+			$finder = array(
+				"\xc1\xc1\xc1\xc1\xc1\xc1\xc1",
+				"\xc1\xc0\xc0\xc0\xc0\xc0\xc1",
+				"\xc1\xc0\xc1\xc1\xc1\xc0\xc1",
+				"\xc1\xc0\xc1\xc1\xc1\xc0\xc1",
+				"\xc1\xc0\xc1\xc1\xc1\xc0\xc1",
+				"\xc1\xc0\xc0\xc0\xc0\xc0\xc1",
+				"\xc1\xc1\xc1\xc1\xc1\xc1\xc1"
+			);                            
+            
+			for($y=0; $y<7; $y++) {
+				QRstr::set($frame, $ox, $oy+$y, $finder[$y]);
+			}
+		}
+
+		//----------------------------------------------------------------------
+		public static function createFrame($version)
+		{
+			$width = self::$capacity[$version][QRCAP_WIDTH];
+			$frameLine = str_repeat ("\0", $width);
+			$frame = array_fill(0, $width, $frameLine);
+
+			// Finder pattern
+			self::putFinderPattern($frame, 0, 0);
+			self::putFinderPattern($frame, $width - 7, 0);
+			self::putFinderPattern($frame, 0, $width - 7);
+            
+			// Separator
+			$yOffset = $width - 7;
+            
+			for($y=0; $y<7; $y++) {
+				$frame[$y][7] = "\xc0";
+				$frame[$y][$width - 8] = "\xc0";
+				$frame[$yOffset][7] = "\xc0";
+				$yOffset++;
+			}
+            
+			$setPattern = str_repeat("\xc0", 8);
+            
+			QRstr::set($frame, 0, 7, $setPattern);
+			QRstr::set($frame, $width-8, 7, $setPattern);
+			QRstr::set($frame, 0, $width - 8, $setPattern);
+        
+			// Format info
+			$setPattern = str_repeat("\x84", 9);
+			QRstr::set($frame, 0, 8, $setPattern);
+			QRstr::set($frame, $width - 8, 8, $setPattern, 8);
+            
+			$yOffset = $width - 8;
+
+			for($y=0; $y<8; $y++,$yOffset++) {
+				$frame[$y][8] = "\x84";
+				$frame[$yOffset][8] = "\x84";
+			}
+
+			// Timing pattern  
+            
+			for($i=1; $i<$width-15; $i++) {
+				$frame[6][7+$i] = chr(0x90 | ($i & 1));
+				$frame[7+$i][6] = chr(0x90 | ($i & 1));
+			}
+            
+			// Alignment pattern  
+			self::putAlignmentPattern($version, $frame, $width);
+            
+			// Version information 
+			if($version >= 7) {
+				$vinf = self::getVersionPattern($version);
+
+				$v = $vinf;
                 
-                for($x=0; $x<6; $x++) {
-                    for($y=0; $y<3; $y++) {
-                        $frame[($width - 11)+$y][$x] = chr(0x88 | ($v & 1));
-                        $v = $v >> 1;
-                    }
-                }
-
-                $v = $vinf;
-                for($y=0; $y<6; $y++) {
-                    for($x=0; $x<3; $x++) {
-                        $frame[$y][$x+($width - 11)] = chr(0x88 | ($v & 1));
-                        $v = $v >> 1;
-                    }
-                }
-            }
+				for($x=0; $x<6; $x++) {
+					for($y=0; $y<3; $y++) {
+						$frame[($width - 11)+$y][$x] = chr(0x88 | ($v & 1));
+						$v = $v >> 1;
+					}
+				}
+
+				$v = $vinf;
+				for($y=0; $y<6; $y++) {
+					for($x=0; $x<3; $x++) {
+						$frame[$y][$x+($width - 11)] = chr(0x88 | ($v & 1));
+						$v = $v >> 1;
+					}
+				}
+			}
     
-            // and a little bit...  
-            $frame[$width - 8][8] = "\x81";
+			// and a little bit...  
+			$frame[$width - 8][8] = "\x81";
             
-            return $frame;
-        }
+			return $frame;
+		}
 
-        //----------------------------------------------------------------------
-        public static function debug($frame, $binary_mode = false)
-        {
-            if ($binary_mode) {
-            
-                    foreach ($frame as &$frameLine) {
-                        $frameLine = join('<span class="m">&nbsp;&nbsp;</span>', explode('0', $frameLine));
-                        $frameLine = join('&#9608;&#9608;', explode('1', $frameLine));
-                    }
+		//----------------------------------------------------------------------
+		public static function debug($frame, $binary_mode = false)
+		{
+			if ($binary_mode) {
+            
+					foreach ($frame as &$frameLine) {
+						$frameLine = join('<span class="m">&nbsp;&nbsp;</span>', explode('0', $frameLine));
+						$frameLine = join('&#9608;&#9608;', explode('1', $frameLine));
+					}
                     
-                    ?>
+					?>
                 <style>
                     .m { background-color: white; }
                 </style>
                 <?php
-                    echo '<pre><tt><br/ ><br/ ><br/ >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;';
-                    echo join("<br/ >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;", $frame);
-                    echo '</tt></pre><br/ ><br/ ><br/ ><br/ ><br/ ><br/ >';
-            
-            } else {
-            
-                foreach ($frame as &$frameLine) {
-                    $frameLine = join('<span class="m">&nbsp;</span>',  explode("\xc0", $frameLine));
-                    $frameLine = join('<span class="m">&#9618;</span>', explode("\xc1", $frameLine));
-                    $frameLine = join('<span class="p">&nbsp;</span>',  explode("\xa0", $frameLine));
-                    $frameLine = join('<span class="p">&#9618;</span>', explode("\xa1", $frameLine));
-                    $frameLine = join('<span class="s">&#9671;</span>', explode("\x84", $frameLine)); //format 0
-                    $frameLine = join('<span class="s">&#9670;</span>', explode("\x85", $frameLine)); //format 1
-                    $frameLine = join('<span class="x">&#9762;</span>', explode("\x81", $frameLine)); //special bit
-                    $frameLine = join('<span class="c">&nbsp;</span>',  explode("\x90", $frameLine)); //clock 0
-                    $frameLine = join('<span class="c">&#9719;</span>', explode("\x91", $frameLine)); //clock 1
-                    $frameLine = join('<span class="f">&nbsp;</span>',  explode("\x88", $frameLine)); //version
-                    $frameLine = join('<span class="f">&#9618;</span>', explode("\x89", $frameLine)); //version
-                    $frameLine = join('&#9830;', explode("\x01", $frameLine));
-                    $frameLine = join('&#8901;', explode("\0", $frameLine));
-                }
+					echo '<pre><tt><br/ ><br/ ><br/ >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;';
+					echo join("<br/ >&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;", $frame);
+					echo '</tt></pre><br/ ><br/ ><br/ ><br/ ><br/ ><br/ >';
+            
+			} else {
+            
+				foreach ($frame as &$frameLine) {
+					$frameLine = join('<span class="m">&nbsp;</span>',  explode("\xc0", $frameLine));
+					$frameLine = join('<span class="m">&#9618;</span>', explode("\xc1", $frameLine));
+					$frameLine = join('<span class="p">&nbsp;</span>',  explode("\xa0", $frameLine));
+					$frameLine = join('<span class="p">&#9618;</span>', explode("\xa1", $frameLine));
+					$frameLine = join('<span class="s">&#9671;</span>', explode("\x84", $frameLine)); //format 0
+					$frameLine = join('<span class="s">&#9670;</span>', explode("\x85", $frameLine)); //format 1
+					$frameLine = join('<span class="x">&#9762;</span>', explode("\x81", $frameLine)); //special bit
+					$frameLine = join('<span class="c">&nbsp;</span>',  explode("\x90", $frameLine)); //clock 0
+					$frameLine = join('<span class="c">&#9719;</span>', explode("\x91", $frameLine)); //clock 1
+					$frameLine = join('<span class="f">&nbsp;</span>',  explode("\x88", $frameLine)); //version
+					$frameLine = join('<span class="f">&#9618;</span>', explode("\x89", $frameLine)); //version
+					$frameLine = join('&#9830;', explode("\x01", $frameLine));
+					$frameLine = join('&#8901;', explode("\0", $frameLine));
+				}
                 
-                ?>
+				?>
                 <style>
                     .p { background-color: yellow; }
                     .m { background-color: #00FF00; }
@@ -843,65 +843,65 @@  discard block
 block discarded – undo
                     .f { background-color: gold; }
                 </style>
                 <?php
-                echo "<pre><tt>";
-                echo join("<br/ >", $frame);
-                echo "</tt></pre>";
-            
-            }
-        }
-
-        //----------------------------------------------------------------------
-        public static function serial($frame)
-        {
-            return gzcompress(join("\n", $frame), 9);
-        }
-        
-        //----------------------------------------------------------------------
-        public static function unserial($code)
-        {
-            return explode("\n", gzuncompress($code));
-        }
-        
-        //----------------------------------------------------------------------
-        public static function newFrame($version)
-        {
-            if($version < 1 || $version > QRSPEC_VERSION_MAX) 
-                return null;
-
-            if(!isset(self::$frames[$version])) {
+				echo "<pre><tt>";
+				echo join("<br/ >", $frame);
+				echo "</tt></pre>";
+            
+			}
+		}
+
+		//----------------------------------------------------------------------
+		public static function serial($frame)
+		{
+			return gzcompress(join("\n", $frame), 9);
+		}
+        
+		//----------------------------------------------------------------------
+		public static function unserial($code)
+		{
+			return explode("\n", gzuncompress($code));
+		}
+        
+		//----------------------------------------------------------------------
+		public static function newFrame($version)
+		{
+			if($version < 1 || $version > QRSPEC_VERSION_MAX) 
+				return null;
+
+			if(!isset(self::$frames[$version])) {
                 
-                $fileName = QR_CACHE_DIR.'frame_'.$version.'.dat';
+				$fileName = QR_CACHE_DIR.'frame_'.$version.'.dat';
                 
-                if (QR_CACHEABLE) {
-                    if (file_exists($fileName)) {
-                        self::$frames[$version] = self::unserial(file_get_contents($fileName));
-                    } else {
-                        self::$frames[$version] = self::createFrame($version);
-                        file_put_contents($fileName, self::serial(self::$frames[$version]));
-                    }
-                } else {
-                    self::$frames[$version] = self::createFrame($version);
-                }
-            }
-            
-            if(is_null(self::$frames[$version]))
-                return null;
-
-            return self::$frames[$version];
-        }
-
-        //----------------------------------------------------------------------
-        public static function rsBlockNum($spec)     { return $spec[0] + $spec[3]; }
-        public static function rsBlockNum1($spec)    { return $spec[0]; }
-        public static function rsDataCodes1($spec)   { return $spec[1]; }
-        public static function rsEccCodes1($spec)    { return $spec[2]; }
-        public static function rsBlockNum2($spec)    { return $spec[3]; }
-        public static function rsDataCodes2($spec)   { return $spec[4]; }
-        public static function rsEccCodes2($spec)    { return $spec[2]; }
-        public static function rsDataLength($spec)   { return ($spec[0] * $spec[1]) + ($spec[3] * $spec[4]);    }
-        public static function rsEccLength($spec)    { return ($spec[0] + $spec[3]) * $spec[2]; }
-        
-    }
+				if (QR_CACHEABLE) {
+					if (file_exists($fileName)) {
+						self::$frames[$version] = self::unserial(file_get_contents($fileName));
+					} else {
+						self::$frames[$version] = self::createFrame($version);
+						file_put_contents($fileName, self::serial(self::$frames[$version]));
+					}
+				} else {
+					self::$frames[$version] = self::createFrame($version);
+				}
+			}
+            
+			if(is_null(self::$frames[$version]))
+				return null;
+
+			return self::$frames[$version];
+		}
+
+		//----------------------------------------------------------------------
+		public static function rsBlockNum($spec)     { return $spec[0] + $spec[3]; }
+		public static function rsBlockNum1($spec)    { return $spec[0]; }
+		public static function rsDataCodes1($spec)   { return $spec[1]; }
+		public static function rsEccCodes1($spec)    { return $spec[2]; }
+		public static function rsBlockNum2($spec)    { return $spec[3]; }
+		public static function rsDataCodes2($spec)   { return $spec[4]; }
+		public static function rsEccCodes2($spec)    { return $spec[2]; }
+		public static function rsDataLength($spec)   { return ($spec[0] * $spec[1]) + ($spec[3] * $spec[4]);    }
+		public static function rsEccLength($spec)    { return ($spec[0] + $spec[3]) * $spec[2]; }
+        
+	}
 
 
 
@@ -933,77 +933,77 @@  discard block
 block discarded – undo
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  */
  
-    define('QR_IMAGE', true);
+	define('QR_IMAGE', true);
 
-    class QRimage {
+	class QRimage {
     
-        //----------------------------------------------------------------------
-        public static function png($frame, $filename = false, $pixelPerPoint = 4, $outerFrame = 4,$saveandprint=FALSE) 
-        {
-            $image = self::image($frame, $pixelPerPoint, $outerFrame);
-            
-            if ($filename === false) {
-                Header("Content-type: image/png");
-                ImagePng($image);
-            } else {
-                if($saveandprint===TRUE){
-                    ImagePng($image, $filename);
-                    header("Content-type: image/png");
-                    ImagePng($image);
-                }else{
-                    ImagePng($image, $filename);
-                }
-            }
-            
-            ImageDestroy($image);
-        }
+		//----------------------------------------------------------------------
+		public static function png($frame, $filename = false, $pixelPerPoint = 4, $outerFrame = 4,$saveandprint=FALSE) 
+		{
+			$image = self::image($frame, $pixelPerPoint, $outerFrame);
+            
+			if ($filename === false) {
+				Header("Content-type: image/png");
+				ImagePng($image);
+			} else {
+				if($saveandprint===TRUE){
+					ImagePng($image, $filename);
+					header("Content-type: image/png");
+					ImagePng($image);
+				}else{
+					ImagePng($image, $filename);
+				}
+			}
+            
+			ImageDestroy($image);
+		}
     
-        //----------------------------------------------------------------------
-        public static function jpg($frame, $filename = false, $pixelPerPoint = 8, $outerFrame = 4, $q = 85) 
-        {
-            $image = self::image($frame, $pixelPerPoint, $outerFrame);
-            
-            if ($filename === false) {
-                Header("Content-type: image/jpeg");
-                ImageJpeg($image, null, $q);
-            } else {
-                ImageJpeg($image, $filename, $q);            
-            }
-            
-            ImageDestroy($image);
-        }
+		//----------------------------------------------------------------------
+		public static function jpg($frame, $filename = false, $pixelPerPoint = 8, $outerFrame = 4, $q = 85) 
+		{
+			$image = self::image($frame, $pixelPerPoint, $outerFrame);
+            
+			if ($filename === false) {
+				Header("Content-type: image/jpeg");
+				ImageJpeg($image, null, $q);
+			} else {
+				ImageJpeg($image, $filename, $q);            
+			}
+            
+			ImageDestroy($image);
+		}
     
-        //----------------------------------------------------------------------
-        private static function image($frame, $pixelPerPoint = 4, $outerFrame = 4) 
-        {
-            $h = count($frame);
-            $w = strlen($frame[0]);
+		//----------------------------------------------------------------------
+		private static function image($frame, $pixelPerPoint = 4, $outerFrame = 4) 
+		{
+			$h = count($frame);
+			$w = strlen($frame[0]);
             
-            $imgW = $w + 2*$outerFrame;
-            $imgH = $h + 2*$outerFrame;
+			$imgW = $w + 2*$outerFrame;
+			$imgH = $h + 2*$outerFrame;
             
-            $base_image =ImageCreate($imgW, $imgH);
+			$base_image =ImageCreate($imgW, $imgH);
             
-            $col[0] = ImageColorAllocate($base_image,255,255,255);
-            $col[1] = ImageColorAllocate($base_image,0,0,0);
+			$col[0] = ImageColorAllocate($base_image,255,255,255);
+			$col[1] = ImageColorAllocate($base_image,0,0,0);
 
-            imagefill($base_image, 0, 0, $col[0]);
+			imagefill($base_image, 0, 0, $col[0]);
 
-            for($y=0; $y<$h; $y++) {
-                for($x=0; $x<$w; $x++) {
-                    if ($frame[$y][$x] == '1') {
-                        ImageSetPixel($base_image,$x+$outerFrame,$y+$outerFrame,$col[1]); 
-                    }
-                }
-            }
+			for($y=0; $y<$h; $y++) {
+				for($x=0; $x<$w; $x++) {
+					if ($frame[$y][$x] == '1') {
+						ImageSetPixel($base_image,$x+$outerFrame,$y+$outerFrame,$col[1]); 
+					}
+				}
+			}
             
-            $target_image =ImageCreate($imgW * $pixelPerPoint, $imgH * $pixelPerPoint);
-            ImageCopyResized($target_image, $base_image, 0, 0, 0, 0, $imgW * $pixelPerPoint, $imgH * $pixelPerPoint, $imgW, $imgH);
-            ImageDestroy($base_image);
+			$target_image =ImageCreate($imgW * $pixelPerPoint, $imgH * $pixelPerPoint);
+			ImageCopyResized($target_image, $base_image, 0, 0, 0, 0, $imgW * $pixelPerPoint, $imgH * $pixelPerPoint, $imgW, $imgH);
+			ImageDestroy($base_image);
             
-            return $target_image;
-        }
-    }
+			return $target_image;
+		}
+	}
 
 
 
@@ -1038,705 +1038,705 @@  discard block
 block discarded – undo
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  */
  
-    define('STRUCTURE_HEADER_BITS',  20);
-    define('MAX_STRUCTURED_SYMBOLS', 16);
+	define('STRUCTURE_HEADER_BITS',  20);
+	define('MAX_STRUCTURED_SYMBOLS', 16);
 
-    class QRinputItem {
+	class QRinputItem {
     
-        public $mode;
-        public $size;
-        public $data;
-        public $bstream;
-
-        public function __construct($mode, $size, $data, $bstream = null) 
-        {
-            $setData = array_slice($data, 0, $size);
-            
-            if (count($setData) < $size) {
-                $setData = array_merge($setData, array_fill(0,$size-count($setData),0));
-            }
-        
-            if(!QRinput::check($mode, $size, $setData)) {
-                throw new Exception('Error m:'.$mode.',s:'.$size.',d:'.join(',',$setData));
-                return null;
-            }
-            
-            $this->mode = $mode;
-            $this->size = $size;
-            $this->data = $setData;
-            $this->bstream = $bstream;
-        }
-        
-        //----------------------------------------------------------------------
-        public function encodeModeNum($version)
-        {
-            try {
-            
-                $words = (int)($this->size / 3);
-                $bs = new QRbitstream();
+		public $mode;
+		public $size;
+		public $data;
+		public $bstream;
+
+		public function __construct($mode, $size, $data, $bstream = null) 
+		{
+			$setData = array_slice($data, 0, $size);
+            
+			if (count($setData) < $size) {
+				$setData = array_merge($setData, array_fill(0,$size-count($setData),0));
+			}
+        
+			if(!QRinput::check($mode, $size, $setData)) {
+				throw new Exception('Error m:'.$mode.',s:'.$size.',d:'.join(',',$setData));
+				return null;
+			}
+            
+			$this->mode = $mode;
+			$this->size = $size;
+			$this->data = $setData;
+			$this->bstream = $bstream;
+		}
+        
+		//----------------------------------------------------------------------
+		public function encodeModeNum($version)
+		{
+			try {
+            
+				$words = (int)($this->size / 3);
+				$bs = new QRbitstream();
                 
-                $val = 0x1;
-                $bs->appendNum(4, $val);
-                $bs->appendNum(QRspec::lengthIndicator(QR_MODE_NUM, $version), $this->size);
-
-                for($i=0; $i<$words; $i++) {
-                    $val  = (ord($this->data[$i*3  ]) - ord('0')) * 100;
-                    $val += (ord($this->data[$i*3+1]) - ord('0')) * 10;
-                    $val += (ord($this->data[$i*3+2]) - ord('0'));
-                    $bs->appendNum(10, $val);
-                }
-
-                if($this->size - $words * 3 == 1) {
-                    $val = ord($this->data[$words*3]) - ord('0');
-                    $bs->appendNum(4, $val);
-                } else if($this->size - $words * 3 == 2) {
-                    $val  = (ord($this->data[$words*3  ]) - ord('0')) * 10;
-                    $val += (ord($this->data[$words*3+1]) - ord('0'));
-                    $bs->appendNum(7, $val);
-                }
-
-                $this->bstream = $bs;
-                return 0;
+				$val = 0x1;
+				$bs->appendNum(4, $val);
+				$bs->appendNum(QRspec::lengthIndicator(QR_MODE_NUM, $version), $this->size);
+
+				for($i=0; $i<$words; $i++) {
+					$val  = (ord($this->data[$i*3  ]) - ord('0')) * 100;
+					$val += (ord($this->data[$i*3+1]) - ord('0')) * 10;
+					$val += (ord($this->data[$i*3+2]) - ord('0'));
+					$bs->appendNum(10, $val);
+				}
+
+				if($this->size - $words * 3 == 1) {
+					$val = ord($this->data[$words*3]) - ord('0');
+					$bs->appendNum(4, $val);
+				} else if($this->size - $words * 3 == 2) {
+					$val  = (ord($this->data[$words*3  ]) - ord('0')) * 10;
+					$val += (ord($this->data[$words*3+1]) - ord('0'));
+					$bs->appendNum(7, $val);
+				}
+
+				$this->bstream = $bs;
+				return 0;
                 
-            } catch (Exception $e) {
-                return -1;
-            }
-        }
-        
-        //----------------------------------------------------------------------
-        public function encodeModeAn($version)
-        {
-            try {
-                $words = (int)($this->size / 2);
-                $bs = new QRbitstream();
+			} catch (Exception $e) {
+				return -1;
+			}
+		}
+        
+		//----------------------------------------------------------------------
+		public function encodeModeAn($version)
+		{
+			try {
+				$words = (int)($this->size / 2);
+				$bs = new QRbitstream();
                 
-                $bs->appendNum(4, 0x02);
-                $bs->appendNum(QRspec::lengthIndicator(QR_MODE_AN, $version), $this->size);
+				$bs->appendNum(4, 0x02);
+				$bs->appendNum(QRspec::lengthIndicator(QR_MODE_AN, $version), $this->size);
 
-                for($i=0; $i<$words; $i++) {
-                    $val  = (int)QRinput::lookAnTable(ord($this->data[$i*2  ])) * 45;
-                    $val += (int)QRinput::lookAnTable(ord($this->data[$i*2+1]));
+				for($i=0; $i<$words; $i++) {
+					$val  = (int)QRinput::lookAnTable(ord($this->data[$i*2  ])) * 45;
+					$val += (int)QRinput::lookAnTable(ord($this->data[$i*2+1]));
 
-                    $bs->appendNum(11, $val);
-                }
+					$bs->appendNum(11, $val);
+				}
 
-                if($this->size & 1) {
-                    $val = QRinput::lookAnTable(ord($this->data[$words * 2]));
-                    $bs->appendNum(6, $val);
-                }
+				if($this->size & 1) {
+					$val = QRinput::lookAnTable(ord($this->data[$words * 2]));
+					$bs->appendNum(6, $val);
+				}
         
-                $this->bstream = $bs;
-                return 0;
+				$this->bstream = $bs;
+				return 0;
             
-            } catch (Exception $e) {
-                return -1;
-            }
-        }
+			} catch (Exception $e) {
+				return -1;
+			}
+		}
         
-        //----------------------------------------------------------------------
-        public function encodeMode8($version)
-        {
-            try {
-                $bs = new QRbitstream();
+		//----------------------------------------------------------------------
+		public function encodeMode8($version)
+		{
+			try {
+				$bs = new QRbitstream();
 
-                $bs->appendNum(4, 0x4);
-                $bs->appendNum(QRspec::lengthIndicator(QR_MODE_8, $version), $this->size);
+				$bs->appendNum(4, 0x4);
+				$bs->appendNum(QRspec::lengthIndicator(QR_MODE_8, $version), $this->size);
 
-                for($i=0; $i<$this->size; $i++) {
-                    $bs->appendNum(8, ord($this->data[$i]));
-                }
+				for($i=0; $i<$this->size; $i++) {
+					$bs->appendNum(8, ord($this->data[$i]));
+				}
 
-                $this->bstream = $bs;
-                return 0;
+				$this->bstream = $bs;
+				return 0;
             
-            } catch (Exception $e) {
-                return -1;
-            }
-        }
+			} catch (Exception $e) {
+				return -1;
+			}
+		}
         
-        //----------------------------------------------------------------------
-        public function encodeModeKanji($version)
-        {
-            try {
+		//----------------------------------------------------------------------
+		public function encodeModeKanji($version)
+		{
+			try {
 
-                $bs = new QRbitrtream();
+				$bs = new QRbitrtream();
                 
-                $bs->appendNum(4, 0x8);
-                $bs->appendNum(QRspec::lengthIndicator(QR_MODE_KANJI, $version), (int)($this->size / 2));
-
-                for($i=0; $i<$this->size; $i+=2) {
-                    $val = (ord($this->data[$i]) << 8) | ord($this->data[$i+1]);
-                    if($val <= 0x9ffc) {
-                        $val -= 0x8140;
-                    } else {
-                        $val -= 0xc140;
-                    }
+				$bs->appendNum(4, 0x8);
+				$bs->appendNum(QRspec::lengthIndicator(QR_MODE_KANJI, $version), (int)($this->size / 2));
+
+				for($i=0; $i<$this->size; $i+=2) {
+					$val = (ord($this->data[$i]) << 8) | ord($this->data[$i+1]);
+					if($val <= 0x9ffc) {
+						$val -= 0x8140;
+					} else {
+						$val -= 0xc140;
+					}
                     
-                    $h = ($val >> 8) * 0xc0;
-                    $val = ($val & 0xff) + $h;
+					$h = ($val >> 8) * 0xc0;
+					$val = ($val & 0xff) + $h;
 
-                    $bs->appendNum(13, $val);
-                }
+					$bs->appendNum(13, $val);
+				}
 
-                $this->bstream = $bs;
-                return 0;
+				$this->bstream = $bs;
+				return 0;
             
-            } catch (Exception $e) {
-                return -1;
-            }
-        }
+			} catch (Exception $e) {
+				return -1;
+			}
+		}
 
-        //----------------------------------------------------------------------
-        public function encodeModeStructure()
-        {
-            try {
-                $bs =  new QRbitstream();
+		//----------------------------------------------------------------------
+		public function encodeModeStructure()
+		{
+			try {
+				$bs =  new QRbitstream();
                 
-                $bs->appendNum(4, 0x03);
-                $bs->appendNum(4, ord($this->data[1]) - 1);
-                $bs->appendNum(4, ord($this->data[0]) - 1);
-                $bs->appendNum(8, ord($this->data[2]));
-
-                $this->bstream = $bs;
-                return 0;
-            
-            } catch (Exception $e) {
-                return -1;
-            }
-        }
-        
-        //----------------------------------------------------------------------
-        public function estimateBitStreamSizeOfEntry($version)
-        {
-            $bits = 0;
-
-            if($version == 0) 
-                $version = 1;
-
-            switch($this->mode) {
-                case QR_MODE_NUM:        $bits = QRinput::estimateBitsModeNum($this->size);    break;
-                case QR_MODE_AN:        $bits = QRinput::estimateBitsModeAn($this->size);    break;
-                case QR_MODE_8:            $bits = QRinput::estimateBitsMode8($this->size);    break;
-                case QR_MODE_KANJI:        $bits = QRinput::estimateBitsModeKanji($this->size);break;
-                case QR_MODE_STRUCTURE:    return STRUCTURE_HEADER_BITS;            
-                default:
-                    return 0;
-            }
-
-            $l = QRspec::lengthIndicator($this->mode, $version);
-            $m = 1 << $l;
-            $num = (int)(($this->size + $m - 1) / $m);
-
-            $bits += $num * (4 + $l);
-
-            return $bits;
-        }
-        
-        //----------------------------------------------------------------------
-        public function encodeBitStream($version)
-        {
-            try {
-            
-                unset($this->bstream);
-                $words = QRspec::maximumWords($this->mode, $version);
+				$bs->appendNum(4, 0x03);
+				$bs->appendNum(4, ord($this->data[1]) - 1);
+				$bs->appendNum(4, ord($this->data[0]) - 1);
+				$bs->appendNum(8, ord($this->data[2]));
+
+				$this->bstream = $bs;
+				return 0;
+            
+			} catch (Exception $e) {
+				return -1;
+			}
+		}
+        
+		//----------------------------------------------------------------------
+		public function estimateBitStreamSizeOfEntry($version)
+		{
+			$bits = 0;
+
+			if($version == 0) 
+				$version = 1;
+
+			switch($this->mode) {
+				case QR_MODE_NUM:        $bits = QRinput::estimateBitsModeNum($this->size);    break;
+				case QR_MODE_AN:        $bits = QRinput::estimateBitsModeAn($this->size);    break;
+				case QR_MODE_8:            $bits = QRinput::estimateBitsMode8($this->size);    break;
+				case QR_MODE_KANJI:        $bits = QRinput::estimateBitsModeKanji($this->size);break;
+				case QR_MODE_STRUCTURE:    return STRUCTURE_HEADER_BITS;            
+				default:
+					return 0;
+			}
+
+			$l = QRspec::lengthIndicator($this->mode, $version);
+			$m = 1 << $l;
+			$num = (int)(($this->size + $m - 1) / $m);
+
+			$bits += $num * (4 + $l);
+
+			return $bits;
+		}
+        
+		//----------------------------------------------------------------------
+		public function encodeBitStream($version)
+		{
+			try {
+            
+				unset($this->bstream);
+				$words = QRspec::maximumWords($this->mode, $version);
                 
-                if($this->size > $words) {
+				if($this->size > $words) {
                 
-                    $st1 = new QRinputItem($this->mode, $words, $this->data);
-                    $st2 = new QRinputItem($this->mode, $this->size - $words, array_slice($this->data, $words));
+					$st1 = new QRinputItem($this->mode, $words, $this->data);
+					$st2 = new QRinputItem($this->mode, $this->size - $words, array_slice($this->data, $words));
 
-                    $st1->encodeBitStream($version);
-                    $st2->encodeBitStream($version);
+					$st1->encodeBitStream($version);
+					$st2->encodeBitStream($version);
                     
-                    $this->bstream = new QRbitstream();
-                    $this->bstream->append($st1->bstream);
-                    $this->bstream->append($st2->bstream);
+					$this->bstream = new QRbitstream();
+					$this->bstream->append($st1->bstream);
+					$this->bstream->append($st2->bstream);
                     
-                    unset($st1);
-                    unset($st2);
+					unset($st1);
+					unset($st2);
                     
-                } else {
+				} else {
                     
-                    $ret = 0;
+					$ret = 0;
                     
-                    switch($this->mode) {
-                        case QR_MODE_NUM:        $ret = $this->encodeModeNum($version);    break;
-                        case QR_MODE_AN:        $ret = $this->encodeModeAn($version);    break;
-                        case QR_MODE_8:            $ret = $this->encodeMode8($version);    break;
-                        case QR_MODE_KANJI:        $ret = $this->encodeModeKanji($version);break;
-                        case QR_MODE_STRUCTURE:    $ret = $this->encodeModeStructure();    break;
+					switch($this->mode) {
+						case QR_MODE_NUM:        $ret = $this->encodeModeNum($version);    break;
+						case QR_MODE_AN:        $ret = $this->encodeModeAn($version);    break;
+						case QR_MODE_8:            $ret = $this->encodeMode8($version);    break;
+						case QR_MODE_KANJI:        $ret = $this->encodeModeKanji($version);break;
+						case QR_MODE_STRUCTURE:    $ret = $this->encodeModeStructure();    break;
                         
-                        default:
-                            break;
-                    }
+						default:
+							break;
+					}
                     
-                    if($ret < 0)
-                        return -1;
-                }
+					if($ret < 0)
+						return -1;
+				}
 
-                return $this->bstream->size();
+				return $this->bstream->size();
             
-            } catch (Exception $e) {
-                return -1;
-            }
-        }
-    };
+			} catch (Exception $e) {
+				return -1;
+			}
+		}
+	};
     
-    //##########################################################################
-
-    class QRinput {
-
-        public $items;
-        
-        private $version;
-        private $level;
-        
-        //----------------------------------------------------------------------
-        public function __construct($version = 0, $level = QR_ECLEVEL_L)
-        {
-            if ($version < 0 || $version > QRSPEC_VERSION_MAX || $level > QR_ECLEVEL_H) {
-                throw new Exception('Invalid version no');
-                return NULL;
-            }
-            
-            $this->version = $version;
-            $this->level = $level;
-        }
-        
-        //----------------------------------------------------------------------
-        public function getVersion()
-        {
-            return $this->version;
-        }
-        
-        //----------------------------------------------------------------------
-        public function setVersion($version)
-        {
-            if($version < 0 || $version > QRSPEC_VERSION_MAX) {
-                throw new Exception('Invalid version no');
-                return -1;
-            }
-
-            $this->version = $version;
-
-            return 0;
-        }
-        
-        //----------------------------------------------------------------------
-        public function getErrorCorrectionLevel()
-        {
-            return $this->level;
-        }
-
-        //----------------------------------------------------------------------
-        public function setErrorCorrectionLevel($level)
-        {
-            if($level > QR_ECLEVEL_H) {
-                throw new Exception('Invalid ECLEVEL');
-                return -1;
-            }
-
-            $this->level = $level;
-
-            return 0;
-        }
-        
-        //----------------------------------------------------------------------
-        public function appendEntry(QRinputItem $entry)
-        {
-            $this->items[] = $entry;
-        }
-        
-        //----------------------------------------------------------------------
-        public function append($mode, $size, $data)
-        {
-            try {
-                $entry = new QRinputItem($mode, $size, $data);
-                $this->items[] = $entry;
-                return 0;
-            } catch (Exception $e) {
-                return -1;
-            }
-        }
-        
-        //----------------------------------------------------------------------
-        
-        public function insertStructuredAppendHeader($size, $index, $parity)
-        {
-            if( $size > MAX_STRUCTURED_SYMBOLS ) {
-                throw new Exception('insertStructuredAppendHeader wrong size');
-            }
-            
-            if( $index <= 0 || $index > MAX_STRUCTURED_SYMBOLS ) {
-                throw new Exception('insertStructuredAppendHeader wrong index');
-            }
-
-            $buf = array($size, $index, $parity);
-            
-            try {
-                $entry = new QRinputItem(QR_MODE_STRUCTURE, 3, buf);
-                array_unshift($this->items, $entry);
-                return 0;
-            } catch (Exception $e) {
-                return -1;
-            }
-        }
-
-        //----------------------------------------------------------------------
-        public function calcParity()
-        {
-            $parity = 0;
-            
-            foreach($this->items as $item) {
-                if($item->mode != QR_MODE_STRUCTURE) {
-                    for($i=$item->size-1; $i>=0; $i--) {
-                        $parity ^= $item->data[$i];
-                    }
-                }
-            }
-
-            return $parity;
-        }
-        
-        //----------------------------------------------------------------------
-        public static function checkModeNum($size, $data)
-        {
-            for($i=0; $i<$size; $i++) {
-                if((ord($data[$i]) < ord('0')) || (ord($data[$i]) > ord('9'))){
-                    return false;
-                }
-            }
-
-            return true;
-        }
-
-        //----------------------------------------------------------------------
-        public static function estimateBitsModeNum($size)
-        {
-            $w = (int)$size / 3;
-            $bits = $w * 10;
-            
-            switch($size - $w * 3) {
-                case 1:
-                    $bits += 4;
-                    break;
-                case 2:
-                    $bits += 7;
-                    break;
-                default:
-                    break;
-            }
-
-            return $bits;
-        }
-        
-        //----------------------------------------------------------------------
-        public static $anTable = array(
-            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-            36, -1, -1, -1, 37, 38, -1, -1, -1, -1, 39, 40, -1, 41, 42, 43,
-             0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 44, -1, -1, -1, -1, -1,
-            -1, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
-            25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, -1, -1, -1, -1, -1,
-            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-            -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
-        );
-        
-        //----------------------------------------------------------------------
-        public static function lookAnTable($c)
-        {
-            return (($c > 127)?-1:self::$anTable[$c]);
-        }
-        
-        //----------------------------------------------------------------------
-        public static function checkModeAn($size, $data)
-        {
-            for($i=0; $i<$size; $i++) {
-                if (self::lookAnTable(ord($data[$i])) == -1) {
-                    return false;
-                }
-            }
-
-            return true;
-        }
-        
-        //----------------------------------------------------------------------
-        public static function estimateBitsModeAn($size)
-        {
-            $w = (int)($size / 2);
-            $bits = $w * 11;
-            
-            if($size & 1) {
-                $bits += 6;
-            }
-
-            return $bits;
-        }
+	//##########################################################################
+
+	class QRinput {
+
+		public $items;
+        
+		private $version;
+		private $level;
+        
+		//----------------------------------------------------------------------
+		public function __construct($version = 0, $level = QR_ECLEVEL_L)
+		{
+			if ($version < 0 || $version > QRSPEC_VERSION_MAX || $level > QR_ECLEVEL_H) {
+				throw new Exception('Invalid version no');
+				return NULL;
+			}
+            
+			$this->version = $version;
+			$this->level = $level;
+		}
+        
+		//----------------------------------------------------------------------
+		public function getVersion()
+		{
+			return $this->version;
+		}
+        
+		//----------------------------------------------------------------------
+		public function setVersion($version)
+		{
+			if($version < 0 || $version > QRSPEC_VERSION_MAX) {
+				throw new Exception('Invalid version no');
+				return -1;
+			}
+
+			$this->version = $version;
+
+			return 0;
+		}
+        
+		//----------------------------------------------------------------------
+		public function getErrorCorrectionLevel()
+		{
+			return $this->level;
+		}
+
+		//----------------------------------------------------------------------
+		public function setErrorCorrectionLevel($level)
+		{
+			if($level > QR_ECLEVEL_H) {
+				throw new Exception('Invalid ECLEVEL');
+				return -1;
+			}
+
+			$this->level = $level;
+
+			return 0;
+		}
+        
+		//----------------------------------------------------------------------
+		public function appendEntry(QRinputItem $entry)
+		{
+			$this->items[] = $entry;
+		}
+        
+		//----------------------------------------------------------------------
+		public function append($mode, $size, $data)
+		{
+			try {
+				$entry = new QRinputItem($mode, $size, $data);
+				$this->items[] = $entry;
+				return 0;
+			} catch (Exception $e) {
+				return -1;
+			}
+		}
+        
+		//----------------------------------------------------------------------
+        
+		public function insertStructuredAppendHeader($size, $index, $parity)
+		{
+			if( $size > MAX_STRUCTURED_SYMBOLS ) {
+				throw new Exception('insertStructuredAppendHeader wrong size');
+			}
+            
+			if( $index <= 0 || $index > MAX_STRUCTURED_SYMBOLS ) {
+				throw new Exception('insertStructuredAppendHeader wrong index');
+			}
+
+			$buf = array($size, $index, $parity);
+            
+			try {
+				$entry = new QRinputItem(QR_MODE_STRUCTURE, 3, buf);
+				array_unshift($this->items, $entry);
+				return 0;
+			} catch (Exception $e) {
+				return -1;
+			}
+		}
+
+		//----------------------------------------------------------------------
+		public function calcParity()
+		{
+			$parity = 0;
+            
+			foreach($this->items as $item) {
+				if($item->mode != QR_MODE_STRUCTURE) {
+					for($i=$item->size-1; $i>=0; $i--) {
+						$parity ^= $item->data[$i];
+					}
+				}
+			}
+
+			return $parity;
+		}
+        
+		//----------------------------------------------------------------------
+		public static function checkModeNum($size, $data)
+		{
+			for($i=0; $i<$size; $i++) {
+				if((ord($data[$i]) < ord('0')) || (ord($data[$i]) > ord('9'))){
+					return false;
+				}
+			}
+
+			return true;
+		}
+
+		//----------------------------------------------------------------------
+		public static function estimateBitsModeNum($size)
+		{
+			$w = (int)$size / 3;
+			$bits = $w * 10;
+            
+			switch($size - $w * 3) {
+				case 1:
+					$bits += 4;
+					break;
+				case 2:
+					$bits += 7;
+					break;
+				default:
+					break;
+			}
+
+			return $bits;
+		}
+        
+		//----------------------------------------------------------------------
+		public static $anTable = array(
+			-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+			-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+			36, -1, -1, -1, 37, 38, -1, -1, -1, -1, 39, 40, -1, 41, 42, 43,
+			 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 44, -1, -1, -1, -1, -1,
+			-1, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
+			25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, -1, -1, -1, -1, -1,
+			-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
+			-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
+		);
+        
+		//----------------------------------------------------------------------
+		public static function lookAnTable($c)
+		{
+			return (($c > 127)?-1:self::$anTable[$c]);
+		}
+        
+		//----------------------------------------------------------------------
+		public static function checkModeAn($size, $data)
+		{
+			for($i=0; $i<$size; $i++) {
+				if (self::lookAnTable(ord($data[$i])) == -1) {
+					return false;
+				}
+			}
+
+			return true;
+		}
+        
+		//----------------------------------------------------------------------
+		public static function estimateBitsModeAn($size)
+		{
+			$w = (int)($size / 2);
+			$bits = $w * 11;
+            
+			if($size & 1) {
+				$bits += 6;
+			}
+
+			return $bits;
+		}
     
-        //----------------------------------------------------------------------
-        public static function estimateBitsMode8($size)
-        {
-            return $size * 8;
-        }
-        
-        //----------------------------------------------------------------------
-        public function estimateBitsModeKanji($size)
-        {
-            return (int)(($size / 2) * 13);
-        }
-        
-        //----------------------------------------------------------------------
-        public static function checkModeKanji($size, $data)
-        {
-            if($size & 1)
-                return false;
-
-            for($i=0; $i<$size; $i+=2) {
-                $val = (ord($data[$i]) << 8) | ord($data[$i+1]);
-                if( $val < 0x8140 
-                || ($val > 0x9ffc && $val < 0xe040) 
-                || $val > 0xebbf) {
-                    return false;
-                }
-            }
-
-            return true;
-        }
-
-        /***********************************************************************
+		//----------------------------------------------------------------------
+		public static function estimateBitsMode8($size)
+		{
+			return $size * 8;
+		}
+        
+		//----------------------------------------------------------------------
+		public function estimateBitsModeKanji($size)
+		{
+			return (int)(($size / 2) * 13);
+		}
+        
+		//----------------------------------------------------------------------
+		public static function checkModeKanji($size, $data)
+		{
+			if($size & 1)
+				return false;
+
+			for($i=0; $i<$size; $i+=2) {
+				$val = (ord($data[$i]) << 8) | ord($data[$i+1]);
+				if( $val < 0x8140 
+				|| ($val > 0x9ffc && $val < 0xe040) 
+				|| $val > 0xebbf) {
+					return false;
+				}
+			}
+
+			return true;
+		}
+
+		/***********************************************************************
          * Validation
          **********************************************************************/
 
-        public static function check($mode, $size, $data)
-        {
-            if($size <= 0) 
-                return false;
-
-            switch($mode) {
-                case QR_MODE_NUM:       return self::checkModeNum($size, $data);   break;
-                case QR_MODE_AN:        return self::checkModeAn($size, $data);    break;
-                case QR_MODE_KANJI:     return self::checkModeKanji($size, $data); break;
-                case QR_MODE_8:         return true; break;
-                case QR_MODE_STRUCTURE: return true; break;
+		public static function check($mode, $size, $data)
+		{
+			if($size <= 0) 
+				return false;
+
+			switch($mode) {
+				case QR_MODE_NUM:       return self::checkModeNum($size, $data);   break;
+				case QR_MODE_AN:        return self::checkModeAn($size, $data);    break;
+				case QR_MODE_KANJI:     return self::checkModeKanji($size, $data); break;
+				case QR_MODE_8:         return true; break;
+				case QR_MODE_STRUCTURE: return true; break;
                 
-                default:
-                    break;
-            }
-
-            return false;
-        }
-        
-        
-        //----------------------------------------------------------------------
-        public function estimateBitStreamSize($version)
-        {
-            $bits = 0;
-
-            foreach($this->items as $item) {
-                $bits += $item->estimateBitStreamSizeOfEntry($version);
-            }
-
-            return $bits;
-        }
-        
-        //----------------------------------------------------------------------
-        public function estimateVersion()
-        {
-            $version = 0;
-            $prev = 0;
-            do {
-                $prev = $version;
-                $bits = $this->estimateBitStreamSize($prev);
-                $version = QRspec::getMinimumVersion((int)(($bits + 7) / 8), $this->level);
-                if ($version < 0) {
-                    return -1;
-                }
-            } while ($version > $prev);
-
-            return $version;
-        }
-        
-        //----------------------------------------------------------------------
-        public static function lengthOfCode($mode, $version, $bits)
-        {
-            $payload = $bits - 4 - QRspec::lengthIndicator($mode, $version);
-            switch($mode) {
-                case QR_MODE_NUM:
-                    $chunks = (int)($payload / 10);
-                    $remain = $payload - $chunks * 10;
-                    $size = $chunks * 3;
-                    if($remain >= 7) {
-                        $size += 2;
-                    } else if($remain >= 4) {
-                        $size += 1;
-                    }
-                    break;
-                case QR_MODE_AN:
-                    $chunks = (int)($payload / 11);
-                    $remain = $payload - $chunks * 11;
-                    $size = $chunks * 2;
-                    if($remain >= 6) 
-                        $size++;
-                    break;
-                case QR_MODE_8:
-                    $size = (int)($payload / 8);
-                    break;
-                case QR_MODE_KANJI:
-                    $size = (int)(($payload / 13) * 2);
-                    break;
-                case QR_MODE_STRUCTURE:
-                    $size = (int)($payload / 8);
-                    break;
-                default:
-                    $size = 0;
-                    break;
-            }
-            
-            $maxsize = QRspec::maximumWords($mode, $version);
-            if($size < 0) $size = 0;
-            if($size > $maxsize) $size = $maxsize;
-
-            return $size;
-        }
-        
-        //----------------------------------------------------------------------
-        public function createBitStream()
-        {
-            $total = 0;
-
-            foreach($this->items as $item) {
-                $bits = $item->encodeBitStream($this->version);
+				default:
+					break;
+			}
+
+			return false;
+		}
+        
+        
+		//----------------------------------------------------------------------
+		public function estimateBitStreamSize($version)
+		{
+			$bits = 0;
+
+			foreach($this->items as $item) {
+				$bits += $item->estimateBitStreamSizeOfEntry($version);
+			}
+
+			return $bits;
+		}
+        
+		//----------------------------------------------------------------------
+		public function estimateVersion()
+		{
+			$version = 0;
+			$prev = 0;
+			do {
+				$prev = $version;
+				$bits = $this->estimateBitStreamSize($prev);
+				$version = QRspec::getMinimumVersion((int)(($bits + 7) / 8), $this->level);
+				if ($version < 0) {
+					return -1;
+				}
+			} while ($version > $prev);
+
+			return $version;
+		}
+        
+		//----------------------------------------------------------------------
+		public static function lengthOfCode($mode, $version, $bits)
+		{
+			$payload = $bits - 4 - QRspec::lengthIndicator($mode, $version);
+			switch($mode) {
+				case QR_MODE_NUM:
+					$chunks = (int)($payload / 10);
+					$remain = $payload - $chunks * 10;
+					$size = $chunks * 3;
+					if($remain >= 7) {
+						$size += 2;
+					} else if($remain >= 4) {
+						$size += 1;
+					}
+					break;
+				case QR_MODE_AN:
+					$chunks = (int)($payload / 11);
+					$remain = $payload - $chunks * 11;
+					$size = $chunks * 2;
+					if($remain >= 6) 
+						$size++;
+					break;
+				case QR_MODE_8:
+					$size = (int)($payload / 8);
+					break;
+				case QR_MODE_KANJI:
+					$size = (int)(($payload / 13) * 2);
+					break;
+				case QR_MODE_STRUCTURE:
+					$size = (int)($payload / 8);
+					break;
+				default:
+					$size = 0;
+					break;
+			}
+            
+			$maxsize = QRspec::maximumWords($mode, $version);
+			if($size < 0) $size = 0;
+			if($size > $maxsize) $size = $maxsize;
+
+			return $size;
+		}
+        
+		//----------------------------------------------------------------------
+		public function createBitStream()
+		{
+			$total = 0;
+
+			foreach($this->items as $item) {
+				$bits = $item->encodeBitStream($this->version);
                 
-                if($bits < 0) 
-                    return -1;
+				if($bits < 0) 
+					return -1;
                     
-                $total += $bits;
-            }
-
-            return $total;
-        }
-        
-        //----------------------------------------------------------------------
-        public function convertData()
-        {
-            $ver = $this->estimateVersion();
-            if($ver > $this->getVersion()) {
-                $this->setVersion($ver);
-            }
-
-            for(;;) {
-                $bits = $this->createBitStream();
+				$total += $bits;
+			}
+
+			return $total;
+		}
+        
+		//----------------------------------------------------------------------
+		public function convertData()
+		{
+			$ver = $this->estimateVersion();
+			if($ver > $this->getVersion()) {
+				$this->setVersion($ver);
+			}
+
+			for(;;) {
+				$bits = $this->createBitStream();
                 
-                if($bits < 0) 
-                    return -1;
+				if($bits < 0) 
+					return -1;
                     
-                $ver = QRspec::getMinimumVersion((int)(($bits + 7) / 8), $this->level);
-                if($ver < 0) {
-                    throw new Exception('WRONG VERSION');
-                    return -1;
-                } else if($ver > $this->getVersion()) {
-                    $this->setVersion($ver);
-                } else {
-                    break;
-                }
-            }
-
-            return 0;
-        }
-        
-        //----------------------------------------------------------------------
-        public function appendPaddingBit(&$bstream)
-        {
-            $bits = $bstream->size();
-            $maxwords = QRspec::getDataLength($this->version, $this->level);
-            $maxbits = $maxwords * 8;
-
-            if ($maxbits == $bits) {
-                return 0;
-            }
-
-            if ($maxbits - $bits < 5) {
-                return $bstream->appendNum($maxbits - $bits, 0);
-            }
-
-            $bits += 4;
-            $words = (int)(($bits + 7) / 8);
-
-            $padding = new QRbitstream();
-            $ret = $padding->appendNum($words * 8 - $bits + 4, 0);
-            
-            if($ret < 0) 
-                return $ret;
-
-            $padlen = $maxwords - $words;
-            
-            if($padlen > 0) {
+				$ver = QRspec::getMinimumVersion((int)(($bits + 7) / 8), $this->level);
+				if($ver < 0) {
+					throw new Exception('WRONG VERSION');
+					return -1;
+				} else if($ver > $this->getVersion()) {
+					$this->setVersion($ver);
+				} else {
+					break;
+				}
+			}
+
+			return 0;
+		}
+        
+		//----------------------------------------------------------------------
+		public function appendPaddingBit(&$bstream)
+		{
+			$bits = $bstream->size();
+			$maxwords = QRspec::getDataLength($this->version, $this->level);
+			$maxbits = $maxwords * 8;
+
+			if ($maxbits == $bits) {
+				return 0;
+			}
+
+			if ($maxbits - $bits < 5) {
+				return $bstream->appendNum($maxbits - $bits, 0);
+			}
+
+			$bits += 4;
+			$words = (int)(($bits + 7) / 8);
+
+			$padding = new QRbitstream();
+			$ret = $padding->appendNum($words * 8 - $bits + 4, 0);
+            
+			if($ret < 0) 
+				return $ret;
+
+			$padlen = $maxwords - $words;
+            
+			if($padlen > 0) {
                 
-                $padbuf = array();
-                for($i=0; $i<$padlen; $i++) {
-                    $padbuf[$i] = ($i&1)?0x11:0xec;
-                }
+				$padbuf = array();
+				for($i=0; $i<$padlen; $i++) {
+					$padbuf[$i] = ($i&1)?0x11:0xec;
+				}
                 
-                $ret = $padding->appendBytes($padlen, $padbuf);
+				$ret = $padding->appendBytes($padlen, $padbuf);
                 
-                if($ret < 0)
-                    return $ret;
+				if($ret < 0)
+					return $ret;
                 
-            }
+			}
 
-            $ret = $bstream->append($padding);
+			$ret = $bstream->append($padding);
             
-            return $ret;
-        }
-
-        //----------------------------------------------------------------------
-        public function mergeBitStream()
-        {
-            if($this->convertData() < 0) {
-                return null;
-            }
-
-            $bstream = new QRbitstream();
-            
-            foreach($this->items as $item) {
-                $ret = $bstream->append($item->bstream);
-                if($ret < 0) {
-                    return null;
-                }
-            }
+			return $ret;
+		}
 
-            return $bstream;
-        }
+		//----------------------------------------------------------------------
+		public function mergeBitStream()
+		{
+			if($this->convertData() < 0) {
+				return null;
+			}
+
+			$bstream = new QRbitstream();
+            
+			foreach($this->items as $item) {
+				$ret = $bstream->append($item->bstream);
+				if($ret < 0) {
+					return null;
+				}
+			}
+
+			return $bstream;
+		}
 
-        //----------------------------------------------------------------------
-        public function getBitStream()
-        {
+		//----------------------------------------------------------------------
+		public function getBitStream()
+		{
 
-            $bstream = $this->mergeBitStream();
+			$bstream = $this->mergeBitStream();
             
-            if($bstream == null) {
-                return null;
-            }
+			if($bstream == null) {
+				return null;
+			}
             
-            $ret = $this->appendPaddingBit($bstream);
-            if($ret < 0) {
-                return null;
-            }
+			$ret = $this->appendPaddingBit($bstream);
+			if($ret < 0) {
+				return null;
+			}
 
-            return $bstream;
-        }
+			return $bstream;
+		}
         
-        //----------------------------------------------------------------------
-        public function getByteStream()
-        {
-            $bstream = $this->getBitStream();
-            if($bstream == null) {
-                return null;
-            }
-            
-            return $bstream->toByte();
-        }
-    }
+		//----------------------------------------------------------------------
+		public function getByteStream()
+		{
+			$bstream = $this->getBitStream();
+			if($bstream == null) {
+				return null;
+			}
+            
+			return $bstream->toByte();
+		}
+	}
         
         
     
@@ -1774,159 +1774,159 @@  discard block
 block discarded – undo
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  */
      
-    class QRbitstream {
+	class QRbitstream {
     
-        public $data = array();
-        
-        //----------------------------------------------------------------------
-        public function size()
-        {
-            return count($this->data);
-        }
-        
-        //----------------------------------------------------------------------
-        public function allocate($setLength)
-        {
-            $this->data = array_fill(0, $setLength, 0);
-            return 0;
-        }
+		public $data = array();
+        
+		//----------------------------------------------------------------------
+		public function size()
+		{
+			return count($this->data);
+		}
+        
+		//----------------------------------------------------------------------
+		public function allocate($setLength)
+		{
+			$this->data = array_fill(0, $setLength, 0);
+			return 0;
+		}
     
-        //----------------------------------------------------------------------
-        public static function newFromNum($bits, $num)
-        {
-            $bstream = new QRbitstream();
-            $bstream->allocate($bits);
-            
-            $mask = 1 << ($bits - 1);
-            for($i=0; $i<$bits; $i++) {
-                if($num & $mask) {
-                    $bstream->data[$i] = 1;
-                } else {
-                    $bstream->data[$i] = 0;
-                }
-                $mask = $mask >> 1;
-            }
-
-            return $bstream;
-        }
-        
-        //----------------------------------------------------------------------
-        public static function newFromBytes($size, $data)
-        {
-            $bstream = new QRbitstream();
-            $bstream->allocate($size * 8);
-            $p=0;
-
-            for($i=0; $i<$size; $i++) {
-                $mask = 0x80;
-                for($j=0; $j<8; $j++) {
-                    if($data[$i] & $mask) {
-                        $bstream->data[$p] = 1;
-                    } else {
-                        $bstream->data[$p] = 0;
-                    }
-                    $p++;
-                    $mask = $mask >> 1;
-                }
-            }
-
-            return $bstream;
-        }
-        
-        //----------------------------------------------------------------------
-        public function append(QRbitstream $arg)
-        {
-            if (is_null($arg)) {
-                return -1;
-            }
-            
-            if($arg->size() == 0) {
-                return 0;
-            }
-            
-            if($this->size() == 0) {
-                $this->data = $arg->data;
-                return 0;
-            }
-            
-            $this->data = array_values(array_merge($this->data, $arg->data));
-
-            return 0;
-        }
-        
-        //----------------------------------------------------------------------
-        public function appendNum($bits, $num)
-        {
-            if ($bits == 0) 
-                return 0;
-
-            $b = QRbitstream::newFromNum($bits, $num);
-            
-            if(is_null($b))
-                return -1;
-
-            $ret = $this->append($b);
-            unset($b);
-
-            return $ret;
-        }
-
-        //----------------------------------------------------------------------
-        public function appendBytes($size, $data)
-        {
-            if ($size == 0) 
-                return 0;
-
-            $b = QRbitstream::newFromBytes($size, $data);
-            
-            if(is_null($b))
-                return -1;
-
-            $ret = $this->append($b);
-            unset($b);
-
-            return $ret;
-        }
-        
-        //----------------------------------------------------------------------
-        public function toByte()
-        {
-        
-            $size = $this->size();
-
-            if($size == 0) {
-                return array();
-            }
-            
-            $data = array_fill(0, (int)(($size + 7) / 8), 0);
-            $bytes = (int)($size / 8);
+		//----------------------------------------------------------------------
+		public static function newFromNum($bits, $num)
+		{
+			$bstream = new QRbitstream();
+			$bstream->allocate($bits);
+            
+			$mask = 1 << ($bits - 1);
+			for($i=0; $i<$bits; $i++) {
+				if($num & $mask) {
+					$bstream->data[$i] = 1;
+				} else {
+					$bstream->data[$i] = 0;
+				}
+				$mask = $mask >> 1;
+			}
+
+			return $bstream;
+		}
+        
+		//----------------------------------------------------------------------
+		public static function newFromBytes($size, $data)
+		{
+			$bstream = new QRbitstream();
+			$bstream->allocate($size * 8);
+			$p=0;
+
+			for($i=0; $i<$size; $i++) {
+				$mask = 0x80;
+				for($j=0; $j<8; $j++) {
+					if($data[$i] & $mask) {
+						$bstream->data[$p] = 1;
+					} else {
+						$bstream->data[$p] = 0;
+					}
+					$p++;
+					$mask = $mask >> 1;
+				}
+			}
+
+			return $bstream;
+		}
+        
+		//----------------------------------------------------------------------
+		public function append(QRbitstream $arg)
+		{
+			if (is_null($arg)) {
+				return -1;
+			}
+            
+			if($arg->size() == 0) {
+				return 0;
+			}
+            
+			if($this->size() == 0) {
+				$this->data = $arg->data;
+				return 0;
+			}
+            
+			$this->data = array_values(array_merge($this->data, $arg->data));
 
-            $p = 0;
+			return 0;
+		}
+        
+		//----------------------------------------------------------------------
+		public function appendNum($bits, $num)
+		{
+			if ($bits == 0) 
+				return 0;
+
+			$b = QRbitstream::newFromNum($bits, $num);
             
-            for($i=0; $i<$bytes; $i++) {
-                $v = 0;
-                for($j=0; $j<8; $j++) {
-                    $v = $v << 1;
-                    $v |= $this->data[$p];
-                    $p++;
-                }
-                $data[$i] = $v;
-            }
+			if(is_null($b))
+				return -1;
+
+			$ret = $this->append($b);
+			unset($b);
+
+			return $ret;
+		}
+
+		//----------------------------------------------------------------------
+		public function appendBytes($size, $data)
+		{
+			if ($size == 0) 
+				return 0;
+
+			$b = QRbitstream::newFromBytes($size, $data);
             
-            if($size & 7) {
-                $v = 0;
-                for($j=0; $j<($size & 7); $j++) {
-                    $v = $v << 1;
-                    $v |= $this->data[$p];
-                    $p++;
-                }
-                $data[$bytes] = $v;
-            }
+			if(is_null($b))
+				return -1;
 
-            return $data;
-        }
+			$ret = $this->append($b);
+			unset($b);
 
-    }
+			return $ret;
+		}
+        
+		//----------------------------------------------------------------------
+		public function toByte()
+		{
+        
+			$size = $this->size();
+
+			if($size == 0) {
+				return array();
+			}
+            
+			$data = array_fill(0, (int)(($size + 7) / 8), 0);
+			$bytes = (int)($size / 8);
+
+			$p = 0;
+            
+			for($i=0; $i<$bytes; $i++) {
+				$v = 0;
+				for($j=0; $j<8; $j++) {
+					$v = $v << 1;
+					$v |= $this->data[$p];
+					$p++;
+				}
+				$data[$i] = $v;
+			}
+            
+			if($size & 7) {
+				$v = 0;
+				for($j=0; $j<($size & 7); $j++) {
+					$v = $v << 1;
+					$v |= $this->data[$p];
+					$p++;
+				}
+				$data[$bytes] = $v;
+			}
+
+			return $data;
+		}
+
+	}
 
 
 
@@ -1967,285 +1967,285 @@  discard block
 block discarded – undo
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  */
-    class QRsplit {
-
-        public $dataStr = '';
-        public $input;
-        public $modeHint;
-
-        //----------------------------------------------------------------------
-        public function __construct($dataStr, $input, $modeHint) 
-        {
-            $this->dataStr  = $dataStr;
-            $this->input    = $input;
-            $this->modeHint = $modeHint;
-        }
-        
-        //----------------------------------------------------------------------
-        public static function isdigitat($str, $pos)
-        {    
-            if ($pos >= strlen($str))
-                return false;
-            
-            return ((ord($str[$pos]) >= ord('0'))&&(ord($str[$pos]) <= ord('9')));
-        }
-        
-        //----------------------------------------------------------------------
-        public static function isalnumat($str, $pos)
-        {
-            if ($pos >= strlen($str))
-                return false;
+	class QRsplit {
+
+		public $dataStr = '';
+		public $input;
+		public $modeHint;
+
+		//----------------------------------------------------------------------
+		public function __construct($dataStr, $input, $modeHint) 
+		{
+			$this->dataStr  = $dataStr;
+			$this->input    = $input;
+			$this->modeHint = $modeHint;
+		}
+        
+		//----------------------------------------------------------------------
+		public static function isdigitat($str, $pos)
+		{    
+			if ($pos >= strlen($str))
+				return false;
+            
+			return ((ord($str[$pos]) >= ord('0'))&&(ord($str[$pos]) <= ord('9')));
+		}
+        
+		//----------------------------------------------------------------------
+		public static function isalnumat($str, $pos)
+		{
+			if ($pos >= strlen($str))
+				return false;
                 
-            return (QRinput::lookAnTable(ord($str[$pos])) >= 0);
-        }
-
-        //----------------------------------------------------------------------
-        public function identifyMode($pos)
-        {
-            if ($pos >= strlen($this->dataStr)) 
-                return QR_MODE_NUL;
+			return (QRinput::lookAnTable(ord($str[$pos])) >= 0);
+		}
+
+		//----------------------------------------------------------------------
+		public function identifyMode($pos)
+		{
+			if ($pos >= strlen($this->dataStr)) 
+				return QR_MODE_NUL;
                 
-            $c = $this->dataStr[$pos];
-            
-            if(self::isdigitat($this->dataStr, $pos)) {
-                return QR_MODE_NUM;
-            } else if(self::isalnumat($this->dataStr, $pos)) {
-                return QR_MODE_AN;
-            } else if($this->modeHint == QR_MODE_KANJI) {
-            
-                if ($pos+1 < strlen($this->dataStr)) 
-                {
-                    $d = $this->dataStr[$pos+1];
-                    $word = (ord($c) << 8) | ord($d);
-                    if(($word >= 0x8140 && $word <= 0x9ffc) || ($word >= 0xe040 && $word <= 0xebbf)) {
-                        return QR_MODE_KANJI;
-                    }
-                }
-            }
-
-            return QR_MODE_8;
-        } 
-        
-        //----------------------------------------------------------------------
-        public function eatNum()
-        {
-            $ln = QRspec::lengthIndicator(QR_MODE_NUM, $this->input->getVersion());
-
-            $p = 0;
-            while(self::isdigitat($this->dataStr, $p)) {
-                $p++;
-            }
-            
-            $run = $p;
-            $mode = $this->identifyMode($p);
-            
-            if($mode == QR_MODE_8) {
-                $dif = QRinput::estimateBitsModeNum($run) + 4 + $ln
-                     + QRinput::estimateBitsMode8(1)         // + 4 + l8
-                     - QRinput::estimateBitsMode8($run + 1); // - 4 - l8
-                if($dif > 0) {
-                    return $this->eat8();
-                }
-            }
-            if($mode == QR_MODE_AN) {
-                $dif = QRinput::estimateBitsModeNum($run) + 4 + $ln
-                     + QRinput::estimateBitsModeAn(1)        // + 4 + la
-                     - QRinput::estimateBitsModeAn($run + 1);// - 4 - la
-                if($dif > 0) {
-                    return $this->eatAn();
-                }
-            }
-            
-            $ret = $this->input->append(QR_MODE_NUM, $run, str_split($this->dataStr));
-            if($ret < 0)
-                return -1;
-
-            return $run;
-        }
-        
-        //----------------------------------------------------------------------
-        public function eatAn()
-        {
-            $la = QRspec::lengthIndicator(QR_MODE_AN,  $this->input->getVersion());
-            $ln = QRspec::lengthIndicator(QR_MODE_NUM, $this->input->getVersion());
-
-            $p = 0;
-            
-            while(self::isalnumat($this->dataStr, $p)) {
-                if(self::isdigitat($this->dataStr, $p)) {
-                    $q = $p;
-                    while(self::isdigitat($this->dataStr, $q)) {
-                        $q++;
-                    }
+			$c = $this->dataStr[$pos];
+            
+			if(self::isdigitat($this->dataStr, $pos)) {
+				return QR_MODE_NUM;
+			} else if(self::isalnumat($this->dataStr, $pos)) {
+				return QR_MODE_AN;
+			} else if($this->modeHint == QR_MODE_KANJI) {
+            
+				if ($pos+1 < strlen($this->dataStr)) 
+				{
+					$d = $this->dataStr[$pos+1];
+					$word = (ord($c) << 8) | ord($d);
+					if(($word >= 0x8140 && $word <= 0x9ffc) || ($word >= 0xe040 && $word <= 0xebbf)) {
+						return QR_MODE_KANJI;
+					}
+				}
+			}
+
+			return QR_MODE_8;
+		} 
+        
+		//----------------------------------------------------------------------
+		public function eatNum()
+		{
+			$ln = QRspec::lengthIndicator(QR_MODE_NUM, $this->input->getVersion());
+
+			$p = 0;
+			while(self::isdigitat($this->dataStr, $p)) {
+				$p++;
+			}
+            
+			$run = $p;
+			$mode = $this->identifyMode($p);
+            
+			if($mode == QR_MODE_8) {
+				$dif = QRinput::estimateBitsModeNum($run) + 4 + $ln
+					 + QRinput::estimateBitsMode8(1)         // + 4 + l8
+					 - QRinput::estimateBitsMode8($run + 1); // - 4 - l8
+				if($dif > 0) {
+					return $this->eat8();
+				}
+			}
+			if($mode == QR_MODE_AN) {
+				$dif = QRinput::estimateBitsModeNum($run) + 4 + $ln
+					 + QRinput::estimateBitsModeAn(1)        // + 4 + la
+					 - QRinput::estimateBitsModeAn($run + 1);// - 4 - la
+				if($dif > 0) {
+					return $this->eatAn();
+				}
+			}
+            
+			$ret = $this->input->append(QR_MODE_NUM, $run, str_split($this->dataStr));
+			if($ret < 0)
+				return -1;
+
+			return $run;
+		}
+        
+		//----------------------------------------------------------------------
+		public function eatAn()
+		{
+			$la = QRspec::lengthIndicator(QR_MODE_AN,  $this->input->getVersion());
+			$ln = QRspec::lengthIndicator(QR_MODE_NUM, $this->input->getVersion());
+
+			$p = 0;
+            
+			while(self::isalnumat($this->dataStr, $p)) {
+				if(self::isdigitat($this->dataStr, $p)) {
+					$q = $p;
+					while(self::isdigitat($this->dataStr, $q)) {
+						$q++;
+					}
                     
-                    $dif = QRinput::estimateBitsModeAn($p) // + 4 + la
-                         + QRinput::estimateBitsModeNum($q - $p) + 4 + $ln
-                         - QRinput::estimateBitsModeAn($q); // - 4 - la
+					$dif = QRinput::estimateBitsModeAn($p) // + 4 + la
+						 + QRinput::estimateBitsModeNum($q - $p) + 4 + $ln
+						 - QRinput::estimateBitsModeAn($q); // - 4 - la
                          
-                    if($dif < 0) {
-                        break;
-                    } else {
-                        $p = $q;
-                    }
-                } else {
-                    $p++;
-                }
-            }
-
-            $run = $p;
-
-            if(!self::isalnumat($this->dataStr, $p)) {
-                $dif = QRinput::estimateBitsModeAn($run) + 4 + $la
-                     + QRinput::estimateBitsMode8(1) // + 4 + l8
-                      - QRinput::estimateBitsMode8($run + 1); // - 4 - l8
-                if($dif > 0) {
-                    return $this->eat8();
-                }
-            }
-
-            $ret = $this->input->append(QR_MODE_AN, $run, str_split($this->dataStr));
-            if($ret < 0)
-                return -1;
-
-            return $run;
-        }
-        
-        //----------------------------------------------------------------------
-        public function eatKanji()
-        {
-            $p = 0;
-            
-            while($this->identifyMode($p) == QR_MODE_KANJI) {
-                $p += 2;
-            }
-            
-            $ret = $this->input->append(QR_MODE_KANJI, $p, str_split($this->dataStr));
-            if($ret < 0)
-                return -1;
-
-            return $run;
-        }
-
-        //----------------------------------------------------------------------
-        public function eat8()
-        {
-            $la = QRspec::lengthIndicator(QR_MODE_AN, $this->input->getVersion());
-            $ln = QRspec::lengthIndicator(QR_MODE_NUM, $this->input->getVersion());
-
-            $p = 1;
-            $dataStrLen = strlen($this->dataStr);
-            
-            while($p < $dataStrLen) {
+					if($dif < 0) {
+						break;
+					} else {
+						$p = $q;
+					}
+				} else {
+					$p++;
+				}
+			}
+
+			$run = $p;
+
+			if(!self::isalnumat($this->dataStr, $p)) {
+				$dif = QRinput::estimateBitsModeAn($run) + 4 + $la
+					 + QRinput::estimateBitsMode8(1) // + 4 + l8
+					  - QRinput::estimateBitsMode8($run + 1); // - 4 - l8
+				if($dif > 0) {
+					return $this->eat8();
+				}
+			}
+
+			$ret = $this->input->append(QR_MODE_AN, $run, str_split($this->dataStr));
+			if($ret < 0)
+				return -1;
+
+			return $run;
+		}
+        
+		//----------------------------------------------------------------------
+		public function eatKanji()
+		{
+			$p = 0;
+            
+			while($this->identifyMode($p) == QR_MODE_KANJI) {
+				$p += 2;
+			}
+            
+			$ret = $this->input->append(QR_MODE_KANJI, $p, str_split($this->dataStr));
+			if($ret < 0)
+				return -1;
+
+			return $run;
+		}
+
+		//----------------------------------------------------------------------
+		public function eat8()
+		{
+			$la = QRspec::lengthIndicator(QR_MODE_AN, $this->input->getVersion());
+			$ln = QRspec::lengthIndicator(QR_MODE_NUM, $this->input->getVersion());
+
+			$p = 1;
+			$dataStrLen = strlen($this->dataStr);
+            
+			while($p < $dataStrLen) {
                 
-                $mode = $this->identifyMode($p);
-                if($mode == QR_MODE_KANJI) {
-                    break;
-                }
-                if($mode == QR_MODE_NUM) {
-                    $q = $p;
-                    while(self::isdigitat($this->dataStr, $q)) {
-                        $q++;
-                    }
-                    $dif = QRinput::estimateBitsMode8($p) // + 4 + l8
-                         + QRinput::estimateBitsModeNum($q - $p) + 4 + $ln
-                         - QRinput::estimateBitsMode8($q); // - 4 - l8
-                    if($dif < 0) {
-                        break;
-                    } else {
-                        $p = $q;
-                    }
-                } else if($mode == QR_MODE_AN) {
-                    $q = $p;
-                    while(self::isalnumat($this->dataStr, $q)) {
-                        $q++;
-                    }
-                    $dif = QRinput::estimateBitsMode8($p)  // + 4 + l8
-                         + QRinput::estimateBitsModeAn($q - $p) + 4 + $la
-                         - QRinput::estimateBitsMode8($q); // - 4 - l8
-                    if($dif < 0) {
-                        break;
-                    } else {
-                        $p = $q;
-                    }
-                } else {
-                    $p++;
-                }
-            }
-
-            $run = $p;
-            $ret = $this->input->append(QR_MODE_8, $run, str_split($this->dataStr));
-            
-            if($ret < 0)
-                return -1;
-
-            return $run;
-        }
-
-        //----------------------------------------------------------------------
-        public function splitString()
-        {
-            while (strlen($this->dataStr) > 0)
-            {
-                if($this->dataStr == '')
-                    return 0;
-
-                $mode = $this->identifyMode(0);
+				$mode = $this->identifyMode($p);
+				if($mode == QR_MODE_KANJI) {
+					break;
+				}
+				if($mode == QR_MODE_NUM) {
+					$q = $p;
+					while(self::isdigitat($this->dataStr, $q)) {
+						$q++;
+					}
+					$dif = QRinput::estimateBitsMode8($p) // + 4 + l8
+						 + QRinput::estimateBitsModeNum($q - $p) + 4 + $ln
+						 - QRinput::estimateBitsMode8($q); // - 4 - l8
+					if($dif < 0) {
+						break;
+					} else {
+						$p = $q;
+					}
+				} else if($mode == QR_MODE_AN) {
+					$q = $p;
+					while(self::isalnumat($this->dataStr, $q)) {
+						$q++;
+					}
+					$dif = QRinput::estimateBitsMode8($p)  // + 4 + l8
+						 + QRinput::estimateBitsModeAn($q - $p) + 4 + $la
+						 - QRinput::estimateBitsMode8($q); // - 4 - l8
+					if($dif < 0) {
+						break;
+					} else {
+						$p = $q;
+					}
+				} else {
+					$p++;
+				}
+			}
+
+			$run = $p;
+			$ret = $this->input->append(QR_MODE_8, $run, str_split($this->dataStr));
+            
+			if($ret < 0)
+				return -1;
+
+			return $run;
+		}
+
+		//----------------------------------------------------------------------
+		public function splitString()
+		{
+			while (strlen($this->dataStr) > 0)
+			{
+				if($this->dataStr == '')
+					return 0;
+
+				$mode = $this->identifyMode(0);
                 
-                switch ($mode) {
-                    case QR_MODE_NUM: $length = $this->eatNum(); break;
-                    case QR_MODE_AN:  $length = $this->eatAn(); break;
-                    case QR_MODE_KANJI:
-                        if ($this->modeHint == QR_MODE_KANJI)
-                                $length = $this->eatKanji();
-                        else    $length = $this->eat8();
-                        break;
-                    default: $length = $this->eat8(); break;
+				switch ($mode) {
+					case QR_MODE_NUM: $length = $this->eatNum(); break;
+					case QR_MODE_AN:  $length = $this->eatAn(); break;
+					case QR_MODE_KANJI:
+						if ($this->modeHint == QR_MODE_KANJI)
+								$length = $this->eatKanji();
+						else    $length = $this->eat8();
+						break;
+					default: $length = $this->eat8(); break;
                 
-                }
+				}
 
-                if($length == 0) return 0;
-                if($length < 0)  return -1;
+				if($length == 0) return 0;
+				if($length < 0)  return -1;
                 
-                $this->dataStr = substr($this->dataStr, $length);
-            }
-        }
-
-        //----------------------------------------------------------------------
-        public function toUpper()
-        {
-            $stringLen = strlen($this->dataStr);
-            $p = 0;
-            
-            while ($p<$stringLen) {
-                $mode = self::identifyMode(substr($this->dataStr, $p));
-                if($mode == QR_MODE_KANJI) {
-                    $p += 2;
-                } else {
-                    if (ord($this->dataStr[$p]) >= ord('a') && ord($this->dataStr[$p]) <= ord('z')) {
-                        $this->dataStr[$p] = chr(ord($this->dataStr[$p]) - 32);
-                    }
-                    $p++;
-                }
-            }
-
-            return $this->dataStr;
-        }
-
-        //----------------------------------------------------------------------
-        public static function splitStringToQRinput($string, QRinput $input, $modeHint, $casesensitive = true)
-        {
-            if(is_null($string) || $string == '\0' || $string == '') {
-                throw new Exception('empty string!!!');
-            }
-
-            $split = new QRsplit($string, $input, $modeHint);
-            
-            if(!$casesensitive)
-                $split->toUpper();
+				$this->dataStr = substr($this->dataStr, $length);
+			}
+		}
+
+		//----------------------------------------------------------------------
+		public function toUpper()
+		{
+			$stringLen = strlen($this->dataStr);
+			$p = 0;
+            
+			while ($p<$stringLen) {
+				$mode = self::identifyMode(substr($this->dataStr, $p));
+				if($mode == QR_MODE_KANJI) {
+					$p += 2;
+				} else {
+					if (ord($this->dataStr[$p]) >= ord('a') && ord($this->dataStr[$p]) <= ord('z')) {
+						$this->dataStr[$p] = chr(ord($this->dataStr[$p]) - 32);
+					}
+					$p++;
+				}
+			}
+
+			return $this->dataStr;
+		}
+
+		//----------------------------------------------------------------------
+		public static function splitStringToQRinput($string, QRinput $input, $modeHint, $casesensitive = true)
+		{
+			if(is_null($string) || $string == '\0' || $string == '') {
+				throw new Exception('empty string!!!');
+			}
+
+			$split = new QRsplit($string, $input, $modeHint);
+            
+			if(!$casesensitive)
+				$split->toUpper();
                 
-            return $split->splitString();
-        }
-    }
+			return $split->splitString();
+		}
+	}
 
 
 
@@ -2283,186 +2283,186 @@  discard block
 block discarded – undo
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  */
  
-    class QRrsItem {
+	class QRrsItem {
     
-        public $mm;                  // Bits per symbol 
-        public $nn;                  // Symbols per block (= (1<<mm)-1) 
-        public $alpha_to = array();  // log lookup table 
-        public $index_of = array();  // Antilog lookup table 
-        public $genpoly = array();   // Generator polynomial 
-        public $nroots;              // Number of generator roots = number of parity symbols 
-        public $fcr;                 // First consecutive root, index form 
-        public $prim;                // Primitive element, index form 
-        public $iprim;               // prim-th root of 1, index form 
-        public $pad;                 // Padding bytes in shortened block 
-        public $gfpoly;
+		public $mm;                  // Bits per symbol 
+		public $nn;                  // Symbols per block (= (1<<mm)-1) 
+		public $alpha_to = array();  // log lookup table 
+		public $index_of = array();  // Antilog lookup table 
+		public $genpoly = array();   // Generator polynomial 
+		public $nroots;              // Number of generator roots = number of parity symbols 
+		public $fcr;                 // First consecutive root, index form 
+		public $prim;                // Primitive element, index form 
+		public $iprim;               // prim-th root of 1, index form 
+		public $pad;                 // Padding bytes in shortened block 
+		public $gfpoly;
     
-        //----------------------------------------------------------------------
-        public function modnn($x)
-        {
-            while ($x >= $this->nn) {
-                $x -= $this->nn;
-                $x = ($x >> $this->mm) + ($x & $this->nn);
-            }
-            
-            return $x;
-        }
-        
-        //----------------------------------------------------------------------
-        public static function init_rs_char($symsize, $gfpoly, $fcr, $prim, $nroots, $pad)
-        {
-            // Common code for intializing a Reed-Solomon control block (char or int symbols)
-            // Copyright 2004 Phil Karn, KA9Q
-            // May be used under the terms of the GNU Lesser General Public License (LGPL)
-
-            $rs = null;
-            
-            // Check parameter ranges
-            if($symsize < 0 || $symsize > 8)                     return $rs;
-            if($fcr < 0 || $fcr >= (1<<$symsize))                return $rs;
-            if($prim <= 0 || $prim >= (1<<$symsize))             return $rs;
-            if($nroots < 0 || $nroots >= (1<<$symsize))          return $rs; // Can't have more roots than symbol values!
-            if($pad < 0 || $pad >= ((1<<$symsize) -1 - $nroots)) return $rs; // Too much padding
-
-            $rs = new QRrsItem();
-            $rs->mm = $symsize;
-            $rs->nn = (1<<$symsize)-1;
-            $rs->pad = $pad;
-
-            $rs->alpha_to = array_fill(0, $rs->nn+1, 0);
-            $rs->index_of = array_fill(0, $rs->nn+1, 0);
+		//----------------------------------------------------------------------
+		public function modnn($x)
+		{
+			while ($x >= $this->nn) {
+				$x -= $this->nn;
+				$x = ($x >> $this->mm) + ($x & $this->nn);
+			}
+            
+			return $x;
+		}
+        
+		//----------------------------------------------------------------------
+		public static function init_rs_char($symsize, $gfpoly, $fcr, $prim, $nroots, $pad)
+		{
+			// Common code for intializing a Reed-Solomon control block (char or int symbols)
+			// Copyright 2004 Phil Karn, KA9Q
+			// May be used under the terms of the GNU Lesser General Public License (LGPL)
+
+			$rs = null;
+            
+			// Check parameter ranges
+			if($symsize < 0 || $symsize > 8)                     return $rs;
+			if($fcr < 0 || $fcr >= (1<<$symsize))                return $rs;
+			if($prim <= 0 || $prim >= (1<<$symsize))             return $rs;
+			if($nroots < 0 || $nroots >= (1<<$symsize))          return $rs; // Can't have more roots than symbol values!
+			if($pad < 0 || $pad >= ((1<<$symsize) -1 - $nroots)) return $rs; // Too much padding
+
+			$rs = new QRrsItem();
+			$rs->mm = $symsize;
+			$rs->nn = (1<<$symsize)-1;
+			$rs->pad = $pad;
+
+			$rs->alpha_to = array_fill(0, $rs->nn+1, 0);
+			$rs->index_of = array_fill(0, $rs->nn+1, 0);
           
-            // PHP style macro replacement ;)
-            $NN =& $rs->nn;
-            $A0 =& $NN;
-            
-            // Generate Galois field lookup tables
-            $rs->index_of[0] = $A0; // log(zero) = -inf
-            $rs->alpha_to[$A0] = 0; // alpha**-inf = 0
-            $sr = 1;
+			// PHP style macro replacement ;)
+			$NN =& $rs->nn;
+			$A0 =& $NN;
+            
+			// Generate Galois field lookup tables
+			$rs->index_of[0] = $A0; // log(zero) = -inf
+			$rs->alpha_to[$A0] = 0; // alpha**-inf = 0
+			$sr = 1;
           
-            for($i=0; $i<$rs->nn; $i++) {
-                $rs->index_of[$sr] = $i;
-                $rs->alpha_to[$i] = $sr;
-                $sr <<= 1;
-                if($sr & (1<<$symsize)) {
-                    $sr ^= $gfpoly;
-                }
-                $sr &= $rs->nn;
-            }
-            
-            if($sr != 1){
-                // field generator polynomial is not primitive!
-                $rs = NULL;
-                return $rs;
-            }
-
-            /* Form RS code generator polynomial from its roots */
-            $rs->genpoly = array_fill(0, $nroots+1, 0);
-        
-            $rs->fcr = $fcr;
-            $rs->prim = $prim;
-            $rs->nroots = $nroots;
-            $rs->gfpoly = $gfpoly;
-
-            /* Find prim-th root of 1, used in decoding */
-            for($iprim=1;($iprim % $prim) != 0;$iprim += $rs->nn)
-            ; // intentional empty-body loop!
-            
-            $rs->iprim = (int)($iprim / $prim);
-            $rs->genpoly[0] = 1;
-            
-            for ($i = 0,$root=$fcr*$prim; $i < $nroots; $i++, $root += $prim) {
-                $rs->genpoly[$i+1] = 1;
-
-                // Multiply rs->genpoly[] by  @**(root + x)
-                for ($j = $i; $j > 0; $j--) {
-                    if ($rs->genpoly[$j] != 0) {
-                        $rs->genpoly[$j] = $rs->genpoly[$j-1] ^ $rs->alpha_to[$rs->modnn($rs->index_of[$rs->genpoly[$j]] + $root)];
-                    } else {
-                        $rs->genpoly[$j] = $rs->genpoly[$j-1];
-                    }
-                }
-                // rs->genpoly[0] can never be zero
-                $rs->genpoly[0] = $rs->alpha_to[$rs->modnn($rs->index_of[$rs->genpoly[0]] + $root)];
-            }
-            
-            // convert rs->genpoly[] to index form for quicker encoding
-            for ($i = 0; $i <= $nroots; $i++)
-                $rs->genpoly[$i] = $rs->index_of[$rs->genpoly[$i]];
-
-            return $rs;
-        }
-        
-        //----------------------------------------------------------------------
-        public function encode_rs_char($data, &$parity)
-        {
-            $MM       =& $this->mm;
-            $NN       =& $this->nn;
-            $ALPHA_TO =& $this->alpha_to;
-            $INDEX_OF =& $this->index_of;
-            $GENPOLY  =& $this->genpoly;
-            $NROOTS   =& $this->nroots;
-            $FCR      =& $this->fcr;
-            $PRIM     =& $this->prim;
-            $IPRIM    =& $this->iprim;
-            $PAD      =& $this->pad;
-            $A0       =& $NN;
-
-            $parity = array_fill(0, $NROOTS, 0);
-
-            for($i=0; $i< ($NN-$NROOTS-$PAD); $i++) {
+			for($i=0; $i<$rs->nn; $i++) {
+				$rs->index_of[$sr] = $i;
+				$rs->alpha_to[$i] = $sr;
+				$sr <<= 1;
+				if($sr & (1<<$symsize)) {
+					$sr ^= $gfpoly;
+				}
+				$sr &= $rs->nn;
+			}
+            
+			if($sr != 1){
+				// field generator polynomial is not primitive!
+				$rs = NULL;
+				return $rs;
+			}
+
+			/* Form RS code generator polynomial from its roots */
+			$rs->genpoly = array_fill(0, $nroots+1, 0);
+        
+			$rs->fcr = $fcr;
+			$rs->prim = $prim;
+			$rs->nroots = $nroots;
+			$rs->gfpoly = $gfpoly;
+
+			/* Find prim-th root of 1, used in decoding */
+			for($iprim=1;($iprim % $prim) != 0;$iprim += $rs->nn)
+			; // intentional empty-body loop!
+            
+			$rs->iprim = (int)($iprim / $prim);
+			$rs->genpoly[0] = 1;
+            
+			for ($i = 0,$root=$fcr*$prim; $i < $nroots; $i++, $root += $prim) {
+				$rs->genpoly[$i+1] = 1;
+
+				// Multiply rs->genpoly[] by  @**(root + x)
+				for ($j = $i; $j > 0; $j--) {
+					if ($rs->genpoly[$j] != 0) {
+						$rs->genpoly[$j] = $rs->genpoly[$j-1] ^ $rs->alpha_to[$rs->modnn($rs->index_of[$rs->genpoly[$j]] + $root)];
+					} else {
+						$rs->genpoly[$j] = $rs->genpoly[$j-1];
+					}
+				}
+				// rs->genpoly[0] can never be zero
+				$rs->genpoly[0] = $rs->alpha_to[$rs->modnn($rs->index_of[$rs->genpoly[0]] + $root)];
+			}
+            
+			// convert rs->genpoly[] to index form for quicker encoding
+			for ($i = 0; $i <= $nroots; $i++)
+				$rs->genpoly[$i] = $rs->index_of[$rs->genpoly[$i]];
+
+			return $rs;
+		}
+        
+		//----------------------------------------------------------------------
+		public function encode_rs_char($data, &$parity)
+		{
+			$MM       =& $this->mm;
+			$NN       =& $this->nn;
+			$ALPHA_TO =& $this->alpha_to;
+			$INDEX_OF =& $this->index_of;
+			$GENPOLY  =& $this->genpoly;
+			$NROOTS   =& $this->nroots;
+			$FCR      =& $this->fcr;
+			$PRIM     =& $this->prim;
+			$IPRIM    =& $this->iprim;
+			$PAD      =& $this->pad;
+			$A0       =& $NN;
+
+			$parity = array_fill(0, $NROOTS, 0);
+
+			for($i=0; $i< ($NN-$NROOTS-$PAD); $i++) {
                 
-                $feedback = $INDEX_OF[$data[$i] ^ $parity[0]];
-                if($feedback != $A0) {      
-                    // feedback term is non-zero
-            
-                    // This line is unnecessary when GENPOLY[NROOTS] is unity, as it must
-                    // always be for the polynomials constructed by init_rs()
-                    $feedback = $this->modnn($NN - $GENPOLY[$NROOTS] + $feedback);
-            
-                    for($j=1;$j<$NROOTS;$j++) {
-                        $parity[$j] ^= $ALPHA_TO[$this->modnn($feedback + $GENPOLY[$NROOTS-$j])];
-                    }
-                }
+				$feedback = $INDEX_OF[$data[$i] ^ $parity[0]];
+				if($feedback != $A0) {      
+					// feedback term is non-zero
+            
+					// This line is unnecessary when GENPOLY[NROOTS] is unity, as it must
+					// always be for the polynomials constructed by init_rs()
+					$feedback = $this->modnn($NN - $GENPOLY[$NROOTS] + $feedback);
+            
+					for($j=1;$j<$NROOTS;$j++) {
+						$parity[$j] ^= $ALPHA_TO[$this->modnn($feedback + $GENPOLY[$NROOTS-$j])];
+					}
+				}
                 
-                // Shift 
-                array_shift($parity);
-                if($feedback != $A0) {
-                    array_push($parity, $ALPHA_TO[$this->modnn($feedback + $GENPOLY[0])]);
-                } else {
-                    array_push($parity, 0);
-                }
-            }
-        }
-    }
+				// Shift 
+				array_shift($parity);
+				if($feedback != $A0) {
+					array_push($parity, $ALPHA_TO[$this->modnn($feedback + $GENPOLY[0])]);
+				} else {
+					array_push($parity, 0);
+				}
+			}
+		}
+	}
     
-    //##########################################################################
+	//##########################################################################
     
-    class QRrs {
+	class QRrs {
     
-        public static $items = array();
+		public static $items = array();
         
-        //----------------------------------------------------------------------
-        public static function init_rs($symsize, $gfpoly, $fcr, $prim, $nroots, $pad)
-        {
-            foreach(self::$items as $rs) {
-                if($rs->pad != $pad)       continue;
-                if($rs->nroots != $nroots) continue;
-                if($rs->mm != $symsize)    continue;
-                if($rs->gfpoly != $gfpoly) continue;
-                if($rs->fcr != $fcr)       continue;
-                if($rs->prim != $prim)     continue;
-
-                return $rs;
-            }
-
-            $rs = QRrsItem::init_rs_char($symsize, $gfpoly, $fcr, $prim, $nroots, $pad);
-            array_unshift(self::$items, $rs);
-
-            return $rs;
-        }
-    }
+		//----------------------------------------------------------------------
+		public static function init_rs($symsize, $gfpoly, $fcr, $prim, $nroots, $pad)
+		{
+			foreach(self::$items as $rs) {
+				if($rs->pad != $pad)       continue;
+				if($rs->nroots != $nroots) continue;
+				if($rs->mm != $symsize)    continue;
+				if($rs->gfpoly != $gfpoly) continue;
+				if($rs->fcr != $fcr)       continue;
+				if($rs->prim != $prim)     continue;
+
+				return $rs;
+			}
+
+			$rs = QRrsItem::init_rs_char($symsize, $gfpoly, $fcr, $prim, $nroots, $pad);
+			array_unshift(self::$items, $rs);
+
+			return $rs;
+		}
+	}
 
 
 
@@ -2508,296 +2508,296 @@  discard block
 block discarded – undo
 		
 		//----------------------------------------------------------------------
 		public function __construct() 
-        {
-            $this->runLength = array_fill(0, QRSPEC_WIDTH_MAX + 1, 0);
-        }
-        
-        //----------------------------------------------------------------------
-        public function writeFormatInformation($width, &$frame, $mask, $level)
-        {
-            $blacks = 0;
-            $format =  QRspec::getFormatInfo($mask, $level);
-
-            for($i=0; $i<8; $i++) {
-                if($format & 1) {
-                    $blacks += 2;
-                    $v = 0x85;
-                } else {
-                    $v = 0x84;
-                }
+		{
+			$this->runLength = array_fill(0, QRSPEC_WIDTH_MAX + 1, 0);
+		}
+        
+		//----------------------------------------------------------------------
+		public function writeFormatInformation($width, &$frame, $mask, $level)
+		{
+			$blacks = 0;
+			$format =  QRspec::getFormatInfo($mask, $level);
+
+			for($i=0; $i<8; $i++) {
+				if($format & 1) {
+					$blacks += 2;
+					$v = 0x85;
+				} else {
+					$v = 0x84;
+				}
                 
-                $frame[8][$width - 1 - $i] = chr($v);
-                if($i < 6) {
-                    $frame[$i][8] = chr($v);
-                } else {
-                    $frame[$i + 1][8] = chr($v);
-                }
-                $format = $format >> 1;
-            }
-            
-            for($i=0; $i<7; $i++) {
-                if($format & 1) {
-                    $blacks += 2;
-                    $v = 0x85;
-                } else {
-                    $v = 0x84;
-                }
+				$frame[8][$width - 1 - $i] = chr($v);
+				if($i < 6) {
+					$frame[$i][8] = chr($v);
+				} else {
+					$frame[$i + 1][8] = chr($v);
+				}
+				$format = $format >> 1;
+			}
+            
+			for($i=0; $i<7; $i++) {
+				if($format & 1) {
+					$blacks += 2;
+					$v = 0x85;
+				} else {
+					$v = 0x84;
+				}
                 
-                $frame[$width - 7 + $i][8] = chr($v);
-                if($i == 0) {
-                    $frame[8][7] = chr($v);
-                } else {
-                    $frame[8][6 - $i] = chr($v);
-                }
+				$frame[$width - 7 + $i][8] = chr($v);
+				if($i == 0) {
+					$frame[8][7] = chr($v);
+				} else {
+					$frame[8][6 - $i] = chr($v);
+				}
                 
-                $format = $format >> 1;
-            }
-
-            return $blacks;
-        }
-        
-        //----------------------------------------------------------------------
-        public function mask0($x, $y) { return ($x+$y)&1;                       }
-        public function mask1($x, $y) { return ($y&1);                          }
-        public function mask2($x, $y) { return ($x%3);                          }
-        public function mask3($x, $y) { return ($x+$y)%3;                       }
-        public function mask4($x, $y) { return (((int)($y/2))+((int)($x/3)))&1; }
-        public function mask5($x, $y) { return (($x*$y)&1)+($x*$y)%3;           }
-        public function mask6($x, $y) { return ((($x*$y)&1)+($x*$y)%3)&1;       }
-        public function mask7($x, $y) { return ((($x*$y)%3)+(($x+$y)&1))&1;     }
-        
-        //----------------------------------------------------------------------
-        private function generateMaskNo($maskNo, $width, $frame)
-        {
-            $bitMask = array_fill(0, $width, array_fill(0, $width, 0));
-            
-            for($y=0; $y<$width; $y++) {
-                for($x=0; $x<$width; $x++) {
-                    if(ord($frame[$y][$x]) & 0x80) {
-                        $bitMask[$y][$x] = 0;
-                    } else {
-                        $maskFunc = call_user_func(array($this, 'mask'.$maskNo), $x, $y);
-                        $bitMask[$y][$x] = ($maskFunc == 0)?1:0;
-                    }
+				$format = $format >> 1;
+			}
+
+			return $blacks;
+		}
+        
+		//----------------------------------------------------------------------
+		public function mask0($x, $y) { return ($x+$y)&1;                       }
+		public function mask1($x, $y) { return ($y&1);                          }
+		public function mask2($x, $y) { return ($x%3);                          }
+		public function mask3($x, $y) { return ($x+$y)%3;                       }
+		public function mask4($x, $y) { return (((int)($y/2))+((int)($x/3)))&1; }
+		public function mask5($x, $y) { return (($x*$y)&1)+($x*$y)%3;           }
+		public function mask6($x, $y) { return ((($x*$y)&1)+($x*$y)%3)&1;       }
+		public function mask7($x, $y) { return ((($x*$y)%3)+(($x+$y)&1))&1;     }
+        
+		//----------------------------------------------------------------------
+		private function generateMaskNo($maskNo, $width, $frame)
+		{
+			$bitMask = array_fill(0, $width, array_fill(0, $width, 0));
+            
+			for($y=0; $y<$width; $y++) {
+				for($x=0; $x<$width; $x++) {
+					if(ord($frame[$y][$x]) & 0x80) {
+						$bitMask[$y][$x] = 0;
+					} else {
+						$maskFunc = call_user_func(array($this, 'mask'.$maskNo), $x, $y);
+						$bitMask[$y][$x] = ($maskFunc == 0)?1:0;
+					}
                     
-                }
-            }
+				}
+			}
             
-            return $bitMask;
-        }
+			return $bitMask;
+		}
         
-        //----------------------------------------------------------------------
-        public static function serial($bitFrame)
-        {
-            $codeArr = array();
+		//----------------------------------------------------------------------
+		public static function serial($bitFrame)
+		{
+			$codeArr = array();
             
-            foreach ($bitFrame as $line)
-                $codeArr[] = join('', $line);
+			foreach ($bitFrame as $line)
+				$codeArr[] = join('', $line);
                 
-            return gzcompress(join("\n", $codeArr), 9);
-        }
-        
-        //----------------------------------------------------------------------
-        public static function unserial($code)
-        {
-            $codeArr = array();
-            
-            $codeLines = explode("\n", gzuncompress($code));
-            foreach ($codeLines as $line)
-                $codeArr[] = str_split($line);
-            
-            return $codeArr;
-        }
-        
-        //----------------------------------------------------------------------
-        public function makeMaskNo($maskNo, $width, $s, &$d, $maskGenOnly = false) 
-        {
-            $b = 0;
-            $bitMask = array();
-            
-            $fileName = QR_CACHE_DIR.'mask_'.$maskNo.DIRECTORY_SEPARATOR.'mask_'.$width.'_'.$maskNo.'.dat';
-
-            if (QR_CACHEABLE) {
-                if (file_exists($fileName)) {
-                    $bitMask = self::unserial(file_get_contents($fileName));
-                } else {
-                    $bitMask = $this->generateMaskNo($maskNo, $width, $s);
-                    if (!file_exists(QR_CACHE_DIR.'mask_'.$maskNo))
-                        mkdir(QR_CACHE_DIR.'mask_'.$maskNo);
-                    file_put_contents($fileName, self::serial($bitMask));
-                }
-            } else {
-                $bitMask = $this->generateMaskNo($maskNo, $width, $s);
-            }
-
-            if ($maskGenOnly)
-                return;
+			return gzcompress(join("\n", $codeArr), 9);
+		}
+        
+		//----------------------------------------------------------------------
+		public static function unserial($code)
+		{
+			$codeArr = array();
+            
+			$codeLines = explode("\n", gzuncompress($code));
+			foreach ($codeLines as $line)
+				$codeArr[] = str_split($line);
+            
+			return $codeArr;
+		}
+        
+		//----------------------------------------------------------------------
+		public function makeMaskNo($maskNo, $width, $s, &$d, $maskGenOnly = false) 
+		{
+			$b = 0;
+			$bitMask = array();
+            
+			$fileName = QR_CACHE_DIR.'mask_'.$maskNo.DIRECTORY_SEPARATOR.'mask_'.$width.'_'.$maskNo.'.dat';
+
+			if (QR_CACHEABLE) {
+				if (file_exists($fileName)) {
+					$bitMask = self::unserial(file_get_contents($fileName));
+				} else {
+					$bitMask = $this->generateMaskNo($maskNo, $width, $s);
+					if (!file_exists(QR_CACHE_DIR.'mask_'.$maskNo))
+						mkdir(QR_CACHE_DIR.'mask_'.$maskNo);
+					file_put_contents($fileName, self::serial($bitMask));
+				}
+			} else {
+				$bitMask = $this->generateMaskNo($maskNo, $width, $s);
+			}
+
+			if ($maskGenOnly)
+				return;
                 
-            $d = $s;
-
-            for($y=0; $y<$width; $y++) {
-                for($x=0; $x<$width; $x++) {
-                    if($bitMask[$y][$x] == 1) {
-                        $d[$y][$x] = chr(ord($s[$y][$x]) ^ (int)$bitMask[$y][$x]);
-                    }
-                    $b += (int)(ord($d[$y][$x]) & 1);
-                }
-            }
-
-            return $b;
-        }
-        
-        //----------------------------------------------------------------------
-        public function makeMask($width, $frame, $maskNo, $level)
-        {
-            $masked = array_fill(0, $width, str_repeat("\0", $width));
-            $this->makeMaskNo($maskNo, $width, $frame, $masked);
-            $this->writeFormatInformation($width, $masked, $maskNo, $level);
+			$d = $s;
+
+			for($y=0; $y<$width; $y++) {
+				for($x=0; $x<$width; $x++) {
+					if($bitMask[$y][$x] == 1) {
+						$d[$y][$x] = chr(ord($s[$y][$x]) ^ (int)$bitMask[$y][$x]);
+					}
+					$b += (int)(ord($d[$y][$x]) & 1);
+				}
+			}
+
+			return $b;
+		}
+        
+		//----------------------------------------------------------------------
+		public function makeMask($width, $frame, $maskNo, $level)
+		{
+			$masked = array_fill(0, $width, str_repeat("\0", $width));
+			$this->makeMaskNo($maskNo, $width, $frame, $masked);
+			$this->writeFormatInformation($width, $masked, $maskNo, $level);
        
-            return $masked;
-        }
+			return $masked;
+		}
         
-        //----------------------------------------------------------------------
-        public function calcN1N3($length)
-        {
-            $demerit = 0;
+		//----------------------------------------------------------------------
+		public function calcN1N3($length)
+		{
+			$demerit = 0;
 
-            for($i=0; $i<$length; $i++) {
+			for($i=0; $i<$length; $i++) {
                 
-                if($this->runLength[$i] >= 5) {
-                    $demerit += (N1 + ($this->runLength[$i] - 5));
-                }
-                if($i & 1) {
-                    if(($i >= 3) && ($i < ($length-2)) && ($this->runLength[$i] % 3 == 0)) {
-                        $fact = (int)($this->runLength[$i] / 3);
-                        if(($this->runLength[$i-2] == $fact) &&
-                           ($this->runLength[$i-1] == $fact) &&
-                           ($this->runLength[$i+1] == $fact) &&
-                           ($this->runLength[$i+2] == $fact)) {
-                            if(($this->runLength[$i-3] < 0) || ($this->runLength[$i-3] >= (4 * $fact))) {
-                                $demerit += N3;
-                            } else if((($i+3) >= $length) || ($this->runLength[$i+3] >= (4 * $fact))) {
-                                $demerit += N3;
-                            }
-                        }
-                    }
-                }
-            }
-            return $demerit;
-        }
-        
-        //----------------------------------------------------------------------
-        public function evaluateSymbol($width, $frame)
-        {
-            $head = 0;
-            $demerit = 0;
-
-            for($y=0; $y<$width; $y++) {
-                $head = 0;
-                $this->runLength[0] = 1;
+				if($this->runLength[$i] >= 5) {
+					$demerit += (N1 + ($this->runLength[$i] - 5));
+				}
+				if($i & 1) {
+					if(($i >= 3) && ($i < ($length-2)) && ($this->runLength[$i] % 3 == 0)) {
+						$fact = (int)($this->runLength[$i] / 3);
+						if(($this->runLength[$i-2] == $fact) &&
+						   ($this->runLength[$i-1] == $fact) &&
+						   ($this->runLength[$i+1] == $fact) &&
+						   ($this->runLength[$i+2] == $fact)) {
+							if(($this->runLength[$i-3] < 0) || ($this->runLength[$i-3] >= (4 * $fact))) {
+								$demerit += N3;
+							} else if((($i+3) >= $length) || ($this->runLength[$i+3] >= (4 * $fact))) {
+								$demerit += N3;
+							}
+						}
+					}
+				}
+			}
+			return $demerit;
+		}
+        
+		//----------------------------------------------------------------------
+		public function evaluateSymbol($width, $frame)
+		{
+			$head = 0;
+			$demerit = 0;
+
+			for($y=0; $y<$width; $y++) {
+				$head = 0;
+				$this->runLength[0] = 1;
                 
-                $frameY = $frame[$y];
+				$frameY = $frame[$y];
                 
-                if ($y>0)
-                    $frameYM = $frame[$y-1];
+				if ($y>0)
+					$frameYM = $frame[$y-1];
                 
-                for($x=0; $x<$width; $x++) {
-                    if(($x > 0) && ($y > 0)) {
-                        $b22 = ord($frameY[$x]) & ord($frameY[$x-1]) & ord($frameYM[$x]) & ord($frameYM[$x-1]);
-                        $w22 = ord($frameY[$x]) | ord($frameY[$x-1]) | ord($frameYM[$x]) | ord($frameYM[$x-1]);
+				for($x=0; $x<$width; $x++) {
+					if(($x > 0) && ($y > 0)) {
+						$b22 = ord($frameY[$x]) & ord($frameY[$x-1]) & ord($frameYM[$x]) & ord($frameYM[$x-1]);
+						$w22 = ord($frameY[$x]) | ord($frameY[$x-1]) | ord($frameYM[$x]) | ord($frameYM[$x-1]);
                         
-                        if(($b22 | ($w22 ^ 1))&1) {                                                                     
-                            $demerit += N2;
-                        }
-                    }
-                    if(($x == 0) && (ord($frameY[$x]) & 1)) {
-                        $this->runLength[0] = -1;
-                        $head = 1;
-                        $this->runLength[$head] = 1;
-                    } else if($x > 0) {
-                        if((ord($frameY[$x]) ^ ord($frameY[$x-1])) & 1) {
-                            $head++;
-                            $this->runLength[$head] = 1;
-                        } else {
-                            $this->runLength[$head]++;
-                        }
-                    }
-                }
+						if(($b22 | ($w22 ^ 1))&1) {                                                                     
+							$demerit += N2;
+						}
+					}
+					if(($x == 0) && (ord($frameY[$x]) & 1)) {
+						$this->runLength[0] = -1;
+						$head = 1;
+						$this->runLength[$head] = 1;
+					} else if($x > 0) {
+						if((ord($frameY[$x]) ^ ord($frameY[$x-1])) & 1) {
+							$head++;
+							$this->runLength[$head] = 1;
+						} else {
+							$this->runLength[$head]++;
+						}
+					}
+				}
     
-                $demerit += $this->calcN1N3($head+1);
-            }
+				$demerit += $this->calcN1N3($head+1);
+			}
 
-            for($x=0; $x<$width; $x++) {
-                $head = 0;
-                $this->runLength[0] = 1;
+			for($x=0; $x<$width; $x++) {
+				$head = 0;
+				$this->runLength[0] = 1;
                 
-                for($y=0; $y<$width; $y++) {
-                    if($y == 0 && (ord($frame[$y][$x]) & 1)) {
-                        $this->runLength[0] = -1;
-                        $head = 1;
-                        $this->runLength[$head] = 1;
-                    } else if($y > 0) {
-                        if((ord($frame[$y][$x]) ^ ord($frame[$y-1][$x])) & 1) {
-                            $head++;
-                            $this->runLength[$head] = 1;
-                        } else {
-                            $this->runLength[$head]++;
-                        }
-                    }
-                }
-            
-                $demerit += $this->calcN1N3($head+1);
-            }
-
-            return $demerit;
-        }
-        
-        
-        //----------------------------------------------------------------------
-        public function mask($width, $frame, $level)
-        {
-            $minDemerit = PHP_INT_MAX;
-            $bestMaskNum = 0;
-            $bestMask = array();
-            
-            $checked_masks = array(0,1,2,3,4,5,6,7);
-            
-            if (QR_FIND_FROM_RANDOM !== false) {
-            
-                $howManuOut = 8-(QR_FIND_FROM_RANDOM % 9);
-                for ($i = 0; $i <  $howManuOut; $i++) {
-                    $remPos = rand (0, count($checked_masks)-1);
-                    unset($checked_masks[$remPos]);
-                    $checked_masks = array_values($checked_masks);
-                }
-            
-            }
-            
-            $bestMask = $frame;
+				for($y=0; $y<$width; $y++) {
+					if($y == 0 && (ord($frame[$y][$x]) & 1)) {
+						$this->runLength[0] = -1;
+						$head = 1;
+						$this->runLength[$head] = 1;
+					} else if($y > 0) {
+						if((ord($frame[$y][$x]) ^ ord($frame[$y-1][$x])) & 1) {
+							$head++;
+							$this->runLength[$head] = 1;
+						} else {
+							$this->runLength[$head]++;
+						}
+					}
+				}
+            
+				$demerit += $this->calcN1N3($head+1);
+			}
+
+			return $demerit;
+		}
+        
+        
+		//----------------------------------------------------------------------
+		public function mask($width, $frame, $level)
+		{
+			$minDemerit = PHP_INT_MAX;
+			$bestMaskNum = 0;
+			$bestMask = array();
+            
+			$checked_masks = array(0,1,2,3,4,5,6,7);
+            
+			if (QR_FIND_FROM_RANDOM !== false) {
+            
+				$howManuOut = 8-(QR_FIND_FROM_RANDOM % 9);
+				for ($i = 0; $i <  $howManuOut; $i++) {
+					$remPos = rand (0, count($checked_masks)-1);
+					unset($checked_masks[$remPos]);
+					$checked_masks = array_values($checked_masks);
+				}
+            
+			}
+            
+			$bestMask = $frame;
              
-            foreach($checked_masks as $i) {
-                $mask = array_fill(0, $width, str_repeat("\0", $width));
-
-                $demerit = 0;
-                $blacks = 0;
-                $blacks  = $this->makeMaskNo($i, $width, $frame, $mask);
-                $blacks += $this->writeFormatInformation($width, $mask, $i, $level);
-                $blacks  = (int)(100 * $blacks / ($width * $width));
-                $demerit = (int)((int)(abs($blacks - 50) / 5) * N4);
-                $demerit += $this->evaluateSymbol($width, $mask);
+			foreach($checked_masks as $i) {
+				$mask = array_fill(0, $width, str_repeat("\0", $width));
+
+				$demerit = 0;
+				$blacks = 0;
+				$blacks  = $this->makeMaskNo($i, $width, $frame, $mask);
+				$blacks += $this->writeFormatInformation($width, $mask, $i, $level);
+				$blacks  = (int)(100 * $blacks / ($width * $width));
+				$demerit = (int)((int)(abs($blacks - 50) / 5) * N4);
+				$demerit += $this->evaluateSymbol($width, $mask);
                 
-                if($demerit < $minDemerit) {
-                    $minDemerit = $demerit;
-                    $bestMask = $mask;
-                    $bestMaskNum = $i;
-                }
-            }
-            
-            return $bestMask;
-        }
+				if($demerit < $minDemerit) {
+					$minDemerit = $demerit;
+					$bestMask = $mask;
+					$bestMaskNum = $i;
+				}
+			}
+            
+			return $bestMask;
+		}
         
-        //----------------------------------------------------------------------
-    }
+		//----------------------------------------------------------------------
+	}
 
 
 
@@ -2833,480 +2833,480 @@  discard block
 block discarded – undo
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  */
  
-    class QRrsblock {
-        public $dataLength;
-        public $data = array();
-        public $eccLength;
-        public $ecc = array();
-        
-        public function __construct($dl, $data, $el, &$ecc, QRrsItem $rs)
-        {
-            $rs->encode_rs_char($data, $ecc);
-        
-            $this->dataLength = $dl;
-            $this->data = $data;
-            $this->eccLength = $el;
-            $this->ecc = $ecc;
-        }
-    };
+	class QRrsblock {
+		public $dataLength;
+		public $data = array();
+		public $eccLength;
+		public $ecc = array();
+        
+		public function __construct($dl, $data, $el, &$ecc, QRrsItem $rs)
+		{
+			$rs->encode_rs_char($data, $ecc);
+        
+			$this->dataLength = $dl;
+			$this->data = $data;
+			$this->eccLength = $el;
+			$this->ecc = $ecc;
+		}
+	};
     
-    //##########################################################################
-
-    class QRrawcode {
-        public $version;
-        public $datacode = array();
-        public $ecccode = array();
-        public $blocks;
-        public $rsblocks = array(); //of RSblock
-        public $count;
-        public $dataLength;
-        public $eccLength;
-        public $b1;
-        
-        //----------------------------------------------------------------------
-        public function __construct(QRinput $input)
-        {
-            $spec = array(0,0,0,0,0);
-            
-            $this->datacode = $input->getByteStream();
-            if(is_null($this->datacode)) {
-                throw new Exception('null imput string');
-            }
-
-            QRspec::getEccSpec($input->getVersion(), $input->getErrorCorrectionLevel(), $spec);
-
-            $this->version = $input->getVersion();
-            $this->b1 = QRspec::rsBlockNum1($spec);
-            $this->dataLength = QRspec::rsDataLength($spec);
-            $this->eccLength = QRspec::rsEccLength($spec);
-            $this->ecccode = array_fill(0, $this->eccLength, 0);
-            $this->blocks = QRspec::rsBlockNum($spec);
-            
-            $ret = $this->init($spec);
-            if($ret < 0) {
-                throw new Exception('block alloc error');
-                return null;
-            }
-
-            $this->count = 0;
-        }
-        
-        //----------------------------------------------------------------------
-        public function init(array $spec)
-        {
-            $dl = QRspec::rsDataCodes1($spec);
-            $el = QRspec::rsEccCodes1($spec);
-            $rs = QRrs::init_rs(8, 0x11d, 0, 1, $el, 255 - $dl - $el);
-            
-
-            $blockNo = 0;
-            $dataPos = 0;
-            $eccPos = 0;
-            for($i=0; $i<QRspec::rsBlockNum1($spec); $i++) {
-                $ecc = array_slice($this->ecccode,$eccPos);
-                $this->rsblocks[$blockNo] = new QRrsblock($dl, array_slice($this->datacode, $dataPos), $el,  $ecc, $rs);
-                $this->ecccode = array_merge(array_slice($this->ecccode,0, $eccPos), $ecc);
+	//##########################################################################
+
+	class QRrawcode {
+		public $version;
+		public $datacode = array();
+		public $ecccode = array();
+		public $blocks;
+		public $rsblocks = array(); //of RSblock
+		public $count;
+		public $dataLength;
+		public $eccLength;
+		public $b1;
+        
+		//----------------------------------------------------------------------
+		public function __construct(QRinput $input)
+		{
+			$spec = array(0,0,0,0,0);
+            
+			$this->datacode = $input->getByteStream();
+			if(is_null($this->datacode)) {
+				throw new Exception('null imput string');
+			}
+
+			QRspec::getEccSpec($input->getVersion(), $input->getErrorCorrectionLevel(), $spec);
+
+			$this->version = $input->getVersion();
+			$this->b1 = QRspec::rsBlockNum1($spec);
+			$this->dataLength = QRspec::rsDataLength($spec);
+			$this->eccLength = QRspec::rsEccLength($spec);
+			$this->ecccode = array_fill(0, $this->eccLength, 0);
+			$this->blocks = QRspec::rsBlockNum($spec);
+            
+			$ret = $this->init($spec);
+			if($ret < 0) {
+				throw new Exception('block alloc error');
+				return null;
+			}
+
+			$this->count = 0;
+		}
+        
+		//----------------------------------------------------------------------
+		public function init(array $spec)
+		{
+			$dl = QRspec::rsDataCodes1($spec);
+			$el = QRspec::rsEccCodes1($spec);
+			$rs = QRrs::init_rs(8, 0x11d, 0, 1, $el, 255 - $dl - $el);
+            
+
+			$blockNo = 0;
+			$dataPos = 0;
+			$eccPos = 0;
+			for($i=0; $i<QRspec::rsBlockNum1($spec); $i++) {
+				$ecc = array_slice($this->ecccode,$eccPos);
+				$this->rsblocks[$blockNo] = new QRrsblock($dl, array_slice($this->datacode, $dataPos), $el,  $ecc, $rs);
+				$this->ecccode = array_merge(array_slice($this->ecccode,0, $eccPos), $ecc);
                 
-                $dataPos += $dl;
-                $eccPos += $el;
-                $blockNo++;
-            }
+				$dataPos += $dl;
+				$eccPos += $el;
+				$blockNo++;
+			}
 
-            if(QRspec::rsBlockNum2($spec) == 0)
-                return 0;
+			if(QRspec::rsBlockNum2($spec) == 0)
+				return 0;
 
-            $dl = QRspec::rsDataCodes2($spec);
-            $el = QRspec::rsEccCodes2($spec);
-            $rs = QRrs::init_rs(8, 0x11d, 0, 1, $el, 255 - $dl - $el);
+			$dl = QRspec::rsDataCodes2($spec);
+			$el = QRspec::rsEccCodes2($spec);
+			$rs = QRrs::init_rs(8, 0x11d, 0, 1, $el, 255 - $dl - $el);
             
-            if($rs == NULL) return -1;
+			if($rs == NULL) return -1;
             
-            for($i=0; $i<QRspec::rsBlockNum2($spec); $i++) {
-                $ecc = array_slice($this->ecccode,$eccPos);
-                $this->rsblocks[$blockNo] = new QRrsblock($dl, array_slice($this->datacode, $dataPos), $el, $ecc, $rs);
-                $this->ecccode = array_merge(array_slice($this->ecccode,0, $eccPos), $ecc);
+			for($i=0; $i<QRspec::rsBlockNum2($spec); $i++) {
+				$ecc = array_slice($this->ecccode,$eccPos);
+				$this->rsblocks[$blockNo] = new QRrsblock($dl, array_slice($this->datacode, $dataPos), $el, $ecc, $rs);
+				$this->ecccode = array_merge(array_slice($this->ecccode,0, $eccPos), $ecc);
                 
-                $dataPos += $dl;
-                $eccPos += $el;
-                $blockNo++;
-            }
-
-            return 0;
-        }
-        
-        //----------------------------------------------------------------------
-        public function getCode()
-        {
-            $ret = 0;
-
-            if($this->count < $this->dataLength) {
-                $row = $this->count % $this->blocks;
-                $col = $this->count / $this->blocks;
-                if($col >= $this->rsblocks[0]->dataLength) {
-                    $row += $this->b1;
-                }
-                $ret = $this->rsblocks[$row]->data[$col];
-            } else if($this->count < $this->dataLength + $this->eccLength) {
-                $row = ($this->count - $this->dataLength) % $this->blocks;
-                $col = ($this->count - $this->dataLength) / $this->blocks;
-                $ret = $this->rsblocks[$row]->ecc[$col];
-            } else {
-                return 0;
-            }
-            $this->count++;
-            
-            return $ret;
-        }
-    }
-
-    //##########################################################################
+				$dataPos += $dl;
+				$eccPos += $el;
+				$blockNo++;
+			}
+
+			return 0;
+		}
+        
+		//----------------------------------------------------------------------
+		public function getCode()
+		{
+			$ret = 0;
+
+			if($this->count < $this->dataLength) {
+				$row = $this->count % $this->blocks;
+				$col = $this->count / $this->blocks;
+				if($col >= $this->rsblocks[0]->dataLength) {
+					$row += $this->b1;
+				}
+				$ret = $this->rsblocks[$row]->data[$col];
+			} else if($this->count < $this->dataLength + $this->eccLength) {
+				$row = ($this->count - $this->dataLength) % $this->blocks;
+				$col = ($this->count - $this->dataLength) / $this->blocks;
+				$ret = $this->rsblocks[$row]->ecc[$col];
+			} else {
+				return 0;
+			}
+			$this->count++;
+            
+			return $ret;
+		}
+	}
+
+	//##########################################################################
     
-    class QRcode {
+	class QRcode {
     
-        public $version;
-        public $width;
-        public $data; 
-        
-        //----------------------------------------------------------------------
-        public function encodeMask(QRinput $input, $mask)
-        {
-            if($input->getVersion() < 0 || $input->getVersion() > QRSPEC_VERSION_MAX) {
-                throw new Exception('wrong version');
-            }
-            if($input->getErrorCorrectionLevel() > QR_ECLEVEL_H) {
-                throw new Exception('wrong level');
-            }
-
-            $raw = new QRrawcode($input);
-            
-            QRtools::markTime('after_raw');
-            
-            $version = $raw->version;
-            $width = QRspec::getWidth($version);
-            $frame = QRspec::newFrame($version);
-            
-            $filler = new FrameFiller($width, $frame);
-            if(is_null($filler)) {
-                return NULL;
-            }
-
-            // inteleaved data and ecc codes
-            for($i=0; $i<$raw->dataLength + $raw->eccLength; $i++) {
-                $code = $raw->getCode();
-                $bit = 0x80;
-                for($j=0; $j<8; $j++) {
-                    $addr = $filler->next();
-                    $filler->setFrameAt($addr, 0x02 | (($bit & $code) != 0));
-                    $bit = $bit >> 1;
-                }
-            }
-            
-            QRtools::markTime('after_filler');
-            
-            unset($raw);
-            
-            // remainder bits
-            $j = QRspec::getRemainder($version);
-            for($i=0; $i<$j; $i++) {
-                $addr = $filler->next();
-                $filler->setFrameAt($addr, 0x02);
-            }
-            
-            $frame = $filler->frame;
-            unset($filler);
-            
-            
-            // masking
-            $maskObj = new QRmask();
-            if($mask < 0) {
-            
-                if (QR_FIND_BEST_MASK) {
-                    $masked = $maskObj->mask($width, $frame, $input->getErrorCorrectionLevel());
-                } else {
-                    $masked = $maskObj->makeMask($width, $frame, (intval(QR_DEFAULT_MASK) % 8), $input->getErrorCorrectionLevel());
-                }
-            } else {
-                $masked = $maskObj->makeMask($width, $frame, $mask, $input->getErrorCorrectionLevel());
-            }
-            
-            if($masked == NULL) {
-                return NULL;
-            }
-            
-            QRtools::markTime('after_mask');
-            
-            $this->version = $version;
-            $this->width = $width;
-            $this->data = $masked;
-            
-            return $this;
-        }
+		public $version;
+		public $width;
+		public $data; 
+        
+		//----------------------------------------------------------------------
+		public function encodeMask(QRinput $input, $mask)
+		{
+			if($input->getVersion() < 0 || $input->getVersion() > QRSPEC_VERSION_MAX) {
+				throw new Exception('wrong version');
+			}
+			if($input->getErrorCorrectionLevel() > QR_ECLEVEL_H) {
+				throw new Exception('wrong level');
+			}
+
+			$raw = new QRrawcode($input);
+            
+			QRtools::markTime('after_raw');
+            
+			$version = $raw->version;
+			$width = QRspec::getWidth($version);
+			$frame = QRspec::newFrame($version);
+            
+			$filler = new FrameFiller($width, $frame);
+			if(is_null($filler)) {
+				return NULL;
+			}
+
+			// inteleaved data and ecc codes
+			for($i=0; $i<$raw->dataLength + $raw->eccLength; $i++) {
+				$code = $raw->getCode();
+				$bit = 0x80;
+				for($j=0; $j<8; $j++) {
+					$addr = $filler->next();
+					$filler->setFrameAt($addr, 0x02 | (($bit & $code) != 0));
+					$bit = $bit >> 1;
+				}
+			}
+            
+			QRtools::markTime('after_filler');
+            
+			unset($raw);
+            
+			// remainder bits
+			$j = QRspec::getRemainder($version);
+			for($i=0; $i<$j; $i++) {
+				$addr = $filler->next();
+				$filler->setFrameAt($addr, 0x02);
+			}
+            
+			$frame = $filler->frame;
+			unset($filler);
+            
+            
+			// masking
+			$maskObj = new QRmask();
+			if($mask < 0) {
+            
+				if (QR_FIND_BEST_MASK) {
+					$masked = $maskObj->mask($width, $frame, $input->getErrorCorrectionLevel());
+				} else {
+					$masked = $maskObj->makeMask($width, $frame, (intval(QR_DEFAULT_MASK) % 8), $input->getErrorCorrectionLevel());
+				}
+			} else {
+				$masked = $maskObj->makeMask($width, $frame, $mask, $input->getErrorCorrectionLevel());
+			}
+            
+			if($masked == NULL) {
+				return NULL;
+			}
+            
+			QRtools::markTime('after_mask');
+            
+			$this->version = $version;
+			$this->width = $width;
+			$this->data = $masked;
+            
+			return $this;
+		}
     
-        //----------------------------------------------------------------------
-        public function encodeInput(QRinput $input)
-        {
-            return $this->encodeMask($input, -1);
-        }
-        
-        //----------------------------------------------------------------------
-        public function encodeString8bit($string, $version, $level)
-        {
-            if(string == NULL) {
-                throw new Exception('empty string!');
-                return NULL;
-            }
-
-            $input = new QRinput($version, $level);
-            if($input == NULL) return NULL;
-
-            $ret = $input->append(QR_MODE_8, strlen($string), str_split($string));
-            if($ret < 0) {
-                unset($input);
-                return NULL;
-            }
-            return $this->encodeInput($input);
-        }
-
-        //----------------------------------------------------------------------
-        public function encodeString($string, $version, $level, $hint, $casesensitive)
-        {
-
-            if($hint != QR_MODE_8 && $hint != QR_MODE_KANJI) {
-                throw new Exception('bad hint');
-                return NULL;
-            }
-
-            $input = new QRinput($version, $level);
-            if($input == NULL) return NULL;
-
-            $ret = QRsplit::splitStringToQRinput($string, $input, $hint, $casesensitive);
-            if($ret < 0) {
-                return NULL;
-            }
-
-            return $this->encodeInput($input);
-        }
-        
-        //----------------------------------------------------------------------
-        public static function png($text, $outfile = false, $level = QR_ECLEVEL_L, $size = 3, $margin = 4, $saveandprint=false) 
-        {
-            $enc = QRencode::factory($level, $size, $margin);
-            return $enc->encodePNG($text, $outfile, $saveandprint=false);
-        }
-
-        //----------------------------------------------------------------------
-        public static function text($text, $outfile = false, $level = QR_ECLEVEL_L, $size = 3, $margin = 4) 
-        {
-            $enc = QRencode::factory($level, $size, $margin);
-            return $enc->encode($text, $outfile);
-        }
-
-        //----------------------------------------------------------------------
-        public static function raw($text, $outfile = false, $level = QR_ECLEVEL_L, $size = 3, $margin = 4) 
-        {
-            $enc = QRencode::factory($level, $size, $margin);
-            return $enc->encodeRAW($text, $outfile);
-        }
-    }
+		//----------------------------------------------------------------------
+		public function encodeInput(QRinput $input)
+		{
+			return $this->encodeMask($input, -1);
+		}
+        
+		//----------------------------------------------------------------------
+		public function encodeString8bit($string, $version, $level)
+		{
+			if(string == NULL) {
+				throw new Exception('empty string!');
+				return NULL;
+			}
+
+			$input = new QRinput($version, $level);
+			if($input == NULL) return NULL;
+
+			$ret = $input->append(QR_MODE_8, strlen($string), str_split($string));
+			if($ret < 0) {
+				unset($input);
+				return NULL;
+			}
+			return $this->encodeInput($input);
+		}
+
+		//----------------------------------------------------------------------
+		public function encodeString($string, $version, $level, $hint, $casesensitive)
+		{
+
+			if($hint != QR_MODE_8 && $hint != QR_MODE_KANJI) {
+				throw new Exception('bad hint');
+				return NULL;
+			}
+
+			$input = new QRinput($version, $level);
+			if($input == NULL) return NULL;
+
+			$ret = QRsplit::splitStringToQRinput($string, $input, $hint, $casesensitive);
+			if($ret < 0) {
+				return NULL;
+			}
+
+			return $this->encodeInput($input);
+		}
+        
+		//----------------------------------------------------------------------
+		public static function png($text, $outfile = false, $level = QR_ECLEVEL_L, $size = 3, $margin = 4, $saveandprint=false) 
+		{
+			$enc = QRencode::factory($level, $size, $margin);
+			return $enc->encodePNG($text, $outfile, $saveandprint=false);
+		}
+
+		//----------------------------------------------------------------------
+		public static function text($text, $outfile = false, $level = QR_ECLEVEL_L, $size = 3, $margin = 4) 
+		{
+			$enc = QRencode::factory($level, $size, $margin);
+			return $enc->encode($text, $outfile);
+		}
+
+		//----------------------------------------------------------------------
+		public static function raw($text, $outfile = false, $level = QR_ECLEVEL_L, $size = 3, $margin = 4) 
+		{
+			$enc = QRencode::factory($level, $size, $margin);
+			return $enc->encodeRAW($text, $outfile);
+		}
+	}
     
-    //##########################################################################
+	//##########################################################################
     
-    class FrameFiller {
+	class FrameFiller {
     
-        public $width;
-        public $frame;
-        public $x;
-        public $y;
-        public $dir;
-        public $bit;
-        
-        //----------------------------------------------------------------------
-        public function __construct($width, &$frame)
-        {
-            $this->width = $width;
-            $this->frame = $frame;
-            $this->x = $width - 1;
-            $this->y = $width - 1;
-            $this->dir = -1;
-            $this->bit = -1;
-        }
-        
-        //----------------------------------------------------------------------
-        public function setFrameAt($at, $val)
-        {
-            $this->frame[$at['y']][$at['x']] = chr($val);
-        }
-        
-        //----------------------------------------------------------------------
-        public function getFrameAt($at)
-        {
-            return ord($this->frame[$at['y']][$at['x']]);
-        }
-        
-        //----------------------------------------------------------------------
-        public function next()
-        {
-            do {
-            
-                if($this->bit == -1) {
-                    $this->bit = 0;
-                    return array('x'=>$this->x, 'y'=>$this->y);
-                }
-
-                $x = $this->x;
-                $y = $this->y;
-                $w = $this->width;
-
-                if($this->bit == 0) {
-                    $x--;
-                    $this->bit++;
-                } else {
-                    $x++;
-                    $y += $this->dir;
-                    $this->bit--;
-                }
-
-                if($this->dir < 0) {
-                    if($y < 0) {
-                        $y = 0;
-                        $x -= 2;
-                        $this->dir = 1;
-                        if($x == 6) {
-                            $x--;
-                            $y = 9;
-                        }
-                    }
-                } else {
-                    if($y == $w) {
-                        $y = $w - 1;
-                        $x -= 2;
-                        $this->dir = -1;
-                        if($x == 6) {
-                            $x--;
-                            $y -= 8;
-                        }
-                    }
-                }
-                if($x < 0 || $y < 0) return null;
-
-                $this->x = $x;
-                $this->y = $y;
-
-            } while(ord($this->frame[$y][$x]) & 0x80);
+		public $width;
+		public $frame;
+		public $x;
+		public $y;
+		public $dir;
+		public $bit;
+        
+		//----------------------------------------------------------------------
+		public function __construct($width, &$frame)
+		{
+			$this->width = $width;
+			$this->frame = $frame;
+			$this->x = $width - 1;
+			$this->y = $width - 1;
+			$this->dir = -1;
+			$this->bit = -1;
+		}
+        
+		//----------------------------------------------------------------------
+		public function setFrameAt($at, $val)
+		{
+			$this->frame[$at['y']][$at['x']] = chr($val);
+		}
+        
+		//----------------------------------------------------------------------
+		public function getFrameAt($at)
+		{
+			return ord($this->frame[$at['y']][$at['x']]);
+		}
+        
+		//----------------------------------------------------------------------
+		public function next()
+		{
+			do {
+            
+				if($this->bit == -1) {
+					$this->bit = 0;
+					return array('x'=>$this->x, 'y'=>$this->y);
+				}
+
+				$x = $this->x;
+				$y = $this->y;
+				$w = $this->width;
+
+				if($this->bit == 0) {
+					$x--;
+					$this->bit++;
+				} else {
+					$x++;
+					$y += $this->dir;
+					$this->bit--;
+				}
+
+				if($this->dir < 0) {
+					if($y < 0) {
+						$y = 0;
+						$x -= 2;
+						$this->dir = 1;
+						if($x == 6) {
+							$x--;
+							$y = 9;
+						}
+					}
+				} else {
+					if($y == $w) {
+						$y = $w - 1;
+						$x -= 2;
+						$this->dir = -1;
+						if($x == 6) {
+							$x--;
+							$y -= 8;
+						}
+					}
+				}
+				if($x < 0 || $y < 0) return null;
+
+				$this->x = $x;
+				$this->y = $y;
+
+			} while(ord($this->frame[$y][$x]) & 0x80);
                         
-            return array('x'=>$x, 'y'=>$y);
-        }
+			return array('x'=>$x, 'y'=>$y);
+		}
         
-    } ;
+	} ;
     
-    //##########################################################################    
+	//##########################################################################    
     
-    class QRencode {
+	class QRencode {
     
-        public $casesensitive = true;
-        public $eightbit = false;
-        
-        public $version = 0;
-        public $size = 3;
-        public $margin = 4;
-        
-        public $structured = 0; // not supported yet
-        
-        public $level = QR_ECLEVEL_L;
-        public $hint = QR_MODE_8;
-        
-        //----------------------------------------------------------------------
-        public static function factory($level = QR_ECLEVEL_L, $size = 3, $margin = 4)
-        {
-            $enc = new QRencode();
-            $enc->size = $size;
-            $enc->margin = $margin;
-            
-            switch ($level.'') {
-                case '0':
-                case '1':
-                case '2':
-                case '3':
-                        $enc->level = $level;
-                    break;
-                case 'l':
-                case 'L':
-                        $enc->level = QR_ECLEVEL_L;
-                    break;
-                case 'm':
-                case 'M':
-                        $enc->level = QR_ECLEVEL_M;
-                    break;
-                case 'q':
-                case 'Q':
-                        $enc->level = QR_ECLEVEL_Q;
-                    break;
-                case 'h':
-                case 'H':
-                        $enc->level = QR_ECLEVEL_H;
-                    break;
-            }
-            
-            return $enc;
-        }
-        
-        //----------------------------------------------------------------------
-        public function encodeRAW($intext, $outfile = false) 
-        {
-            $code = new QRcode();
-
-            if($this->eightbit) {
-                $code->encodeString8bit($intext, $this->version, $this->level);
-            } else {
-                $code->encodeString($intext, $this->version, $this->level, $this->hint, $this->casesensitive);
-            }
-            
-            return $code->data;
-        }
-
-        //----------------------------------------------------------------------
-        public function encode($intext, $outfile = false) 
-        {
-            $code = new QRcode();
-
-            if($this->eightbit) {
-                $code->encodeString8bit($intext, $this->version, $this->level);
-            } else {
-                $code->encodeString($intext, $this->version, $this->level, $this->hint, $this->casesensitive);
-            }
-            
-            QRtools::markTime('after_encode');
-            
-            if ($outfile!== false) {
-                file_put_contents($outfile, join("\n", QRtools::binarize($code->data)));
-            } else {
-                return QRtools::binarize($code->data);
-            }
-        }
-        
-        //----------------------------------------------------------------------
-        public function encodePNG($intext, $outfile = false,$saveandprint=false) 
-        {
-            try {
-            
-                ob_start();
-                $tab = $this->encode($intext);
-                $err = ob_get_contents();
-                ob_end_clean();
+		public $casesensitive = true;
+		public $eightbit = false;
+        
+		public $version = 0;
+		public $size = 3;
+		public $margin = 4;
+        
+		public $structured = 0; // not supported yet
+        
+		public $level = QR_ECLEVEL_L;
+		public $hint = QR_MODE_8;
+        
+		//----------------------------------------------------------------------
+		public static function factory($level = QR_ECLEVEL_L, $size = 3, $margin = 4)
+		{
+			$enc = new QRencode();
+			$enc->size = $size;
+			$enc->margin = $margin;
+            
+			switch ($level.'') {
+				case '0':
+				case '1':
+				case '2':
+				case '3':
+						$enc->level = $level;
+					break;
+				case 'l':
+				case 'L':
+						$enc->level = QR_ECLEVEL_L;
+					break;
+				case 'm':
+				case 'M':
+						$enc->level = QR_ECLEVEL_M;
+					break;
+				case 'q':
+				case 'Q':
+						$enc->level = QR_ECLEVEL_Q;
+					break;
+				case 'h':
+				case 'H':
+						$enc->level = QR_ECLEVEL_H;
+					break;
+			}
+            
+			return $enc;
+		}
+        
+		//----------------------------------------------------------------------
+		public function encodeRAW($intext, $outfile = false) 
+		{
+			$code = new QRcode();
+
+			if($this->eightbit) {
+				$code->encodeString8bit($intext, $this->version, $this->level);
+			} else {
+				$code->encodeString($intext, $this->version, $this->level, $this->hint, $this->casesensitive);
+			}
+            
+			return $code->data;
+		}
+
+		//----------------------------------------------------------------------
+		public function encode($intext, $outfile = false) 
+		{
+			$code = new QRcode();
+
+			if($this->eightbit) {
+				$code->encodeString8bit($intext, $this->version, $this->level);
+			} else {
+				$code->encodeString($intext, $this->version, $this->level, $this->hint, $this->casesensitive);
+			}
+            
+			QRtools::markTime('after_encode');
+            
+			if ($outfile!== false) {
+				file_put_contents($outfile, join("\n", QRtools::binarize($code->data)));
+			} else {
+				return QRtools::binarize($code->data);
+			}
+		}
+        
+		//----------------------------------------------------------------------
+		public function encodePNG($intext, $outfile = false,$saveandprint=false) 
+		{
+			try {
+            
+				ob_start();
+				$tab = $this->encode($intext);
+				$err = ob_get_contents();
+				ob_end_clean();
                 
-                if ($err != '')
-                    QRtools::log($outfile, $err);
+				if ($err != '')
+					QRtools::log($outfile, $err);
                 
-                $maxSize = (int)(QR_PNG_MAXIMUM_SIZE / (count($tab)+2*$this->margin));
+				$maxSize = (int)(QR_PNG_MAXIMUM_SIZE / (count($tab)+2*$this->margin));
                 
-                QRimage::png($tab, $outfile, min(max(1, $this->size), $maxSize), $this->margin,$saveandprint);
+				QRimage::png($tab, $outfile, min(max(1, $this->size), $maxSize), $this->margin,$saveandprint);
             
-            } catch (Exception $e) {
+			} catch (Exception $e) {
             
-                QRtools::log($outfile, $e->getMessage());
+				QRtools::log($outfile, $e->getMessage());
             
-            }
-        }
-    }
+			}
+		}
+	}
 
 

Please login to merge, or discard this patch.

Switch Indentation +88 added lines, -88 removed lines patch added patch discarded remove patch

@@ -1214,13 +1214,13 @@  discard block
 block discarded – undo
                 $version = 1;
 
             switch($this->mode) {
-                case QR_MODE_NUM:        $bits = QRinput::estimateBitsModeNum($this->size);    break;
-                case QR_MODE_AN:        $bits = QRinput::estimateBitsModeAn($this->size);    break;
-                case QR_MODE_8:            $bits = QRinput::estimateBitsMode8($this->size);    break;
-                case QR_MODE_KANJI:        $bits = QRinput::estimateBitsModeKanji($this->size);break;
-                case QR_MODE_STRUCTURE:    return STRUCTURE_HEADER_BITS;            
-                default:
-                    return 0;
+            case QR_MODE_NUM:        $bits = QRinput::estimateBitsModeNum($this->size);    break;
+            case QR_MODE_AN:        $bits = QRinput::estimateBitsModeAn($this->size);    break;
+            case QR_MODE_8:            $bits = QRinput::estimateBitsMode8($this->size);    break;
+            case QR_MODE_KANJI:        $bits = QRinput::estimateBitsModeKanji($this->size);break;
+            case QR_MODE_STRUCTURE:    return STRUCTURE_HEADER_BITS;            
+            default:
+                return 0;
             }
 
             $l = QRspec::lengthIndicator($this->mode, $version);
@@ -1260,14 +1260,14 @@  discard block
 block discarded – undo
                     $ret = 0;
                     
                     switch($this->mode) {
-                        case QR_MODE_NUM:        $ret = $this->encodeModeNum($version);    break;
-                        case QR_MODE_AN:        $ret = $this->encodeModeAn($version);    break;
-                        case QR_MODE_8:            $ret = $this->encodeMode8($version);    break;
-                        case QR_MODE_KANJI:        $ret = $this->encodeModeKanji($version);break;
-                        case QR_MODE_STRUCTURE:    $ret = $this->encodeModeStructure();    break;
+                    case QR_MODE_NUM:        $ret = $this->encodeModeNum($version);    break;
+                    case QR_MODE_AN:        $ret = $this->encodeModeAn($version);    break;
+                    case QR_MODE_8:            $ret = $this->encodeMode8($version);    break;
+                    case QR_MODE_KANJI:        $ret = $this->encodeModeKanji($version);break;
+                    case QR_MODE_STRUCTURE:    $ret = $this->encodeModeStructure();    break;
                         
-                        default:
-                            break;
+                    default:
+                        break;
                     }
                     
                     if($ret < 0)
@@ -1417,14 +1417,14 @@  discard block
 block discarded – undo
             $bits = $w * 10;
             
             switch($size - $w * 3) {
-                case 1:
-                    $bits += 4;
-                    break;
-                case 2:
-                    $bits += 7;
-                    break;
-                default:
-                    break;
+            case 1:
+                $bits += 4;
+                break;
+            case 2:
+                $bits += 7;
+                break;
+            default:
+                break;
             }
 
             return $bits;
@@ -1513,14 +1513,14 @@  discard block
 block discarded – undo
                 return false;
 
             switch($mode) {
-                case QR_MODE_NUM:       return self::checkModeNum($size, $data);   break;
-                case QR_MODE_AN:        return self::checkModeAn($size, $data);    break;
-                case QR_MODE_KANJI:     return self::checkModeKanji($size, $data); break;
-                case QR_MODE_8:         return true; break;
-                case QR_MODE_STRUCTURE: return true; break;
+            case QR_MODE_NUM:       return self::checkModeNum($size, $data);   break;
+            case QR_MODE_AN:        return self::checkModeAn($size, $data);    break;
+            case QR_MODE_KANJI:     return self::checkModeKanji($size, $data); break;
+            case QR_MODE_8:         return true; break;
+            case QR_MODE_STRUCTURE: return true; break;
                 
-                default:
-                    break;
+            default:
+                break;
             }
 
             return false;
@@ -1561,35 +1561,35 @@  discard block
 block discarded – undo
         {
             $payload = $bits - 4 - QRspec::lengthIndicator($mode, $version);
             switch($mode) {
-                case QR_MODE_NUM:
-                    $chunks = (int)($payload / 10);
-                    $remain = $payload - $chunks * 10;
-                    $size = $chunks * 3;
-                    if($remain >= 7) {
-                        $size += 2;
-                    } else if($remain >= 4) {
-                        $size += 1;
-                    }
-                    break;
-                case QR_MODE_AN:
-                    $chunks = (int)($payload / 11);
-                    $remain = $payload - $chunks * 11;
-                    $size = $chunks * 2;
-                    if($remain >= 6) 
-                        $size++;
-                    break;
-                case QR_MODE_8:
-                    $size = (int)($payload / 8);
-                    break;
-                case QR_MODE_KANJI:
-                    $size = (int)(($payload / 13) * 2);
-                    break;
-                case QR_MODE_STRUCTURE:
-                    $size = (int)($payload / 8);
-                    break;
-                default:
-                    $size = 0;
-                    break;
+            case QR_MODE_NUM:
+                $chunks = (int)($payload / 10);
+                $remain = $payload - $chunks * 10;
+                $size = $chunks * 3;
+                if($remain >= 7) {
+                    $size += 2;
+                } else if($remain >= 4) {
+                    $size += 1;
+                }
+                break;
+            case QR_MODE_AN:
+                $chunks = (int)($payload / 11);
+                $remain = $payload - $chunks * 11;
+                $size = $chunks * 2;
+                if($remain >= 6) 
+                    $size++;
+                break;
+            case QR_MODE_8:
+                $size = (int)($payload / 8);
+                break;
+            case QR_MODE_KANJI:
+                $size = (int)(($payload / 13) * 2);
+                break;
+            case QR_MODE_STRUCTURE:
+                $size = (int)($payload / 8);
+                break;
+            default:
+                $size = 0;
+                break;
             }
             
             $maxsize = QRspec::maximumWords($mode, $version);
@@ -2192,14 +2192,14 @@  discard block
 block discarded – undo
                 $mode = $this->identifyMode(0);
                 
                 switch ($mode) {
-                    case QR_MODE_NUM: $length = $this->eatNum(); break;
-                    case QR_MODE_AN:  $length = $this->eatAn(); break;
-                    case QR_MODE_KANJI:
-                        if ($this->modeHint == QR_MODE_KANJI)
-                                $length = $this->eatKanji();
-                        else    $length = $this->eat8();
-                        break;
-                    default: $length = $this->eat8(); break;
+                case QR_MODE_NUM: $length = $this->eatNum(); break;
+                case QR_MODE_AN:  $length = $this->eatAn(); break;
+                case QR_MODE_KANJI:
+                    if ($this->modeHint == QR_MODE_KANJI)
+                            $length = $this->eatKanji();
+                    else    $length = $this->eat8();
+                    break;
+                default: $length = $this->eat8(); break;
                 
                 }
 
@@ -3223,28 +3223,28 @@  discard block
 block discarded – undo
             $enc->margin = $margin;
             
             switch ($level.'') {
-                case '0':
-                case '1':
-                case '2':
-                case '3':
-                        $enc->level = $level;
-                    break;
-                case 'l':
-                case 'L':
-                        $enc->level = QR_ECLEVEL_L;
-                    break;
-                case 'm':
-                case 'M':
-                        $enc->level = QR_ECLEVEL_M;
-                    break;
-                case 'q':
-                case 'Q':
-                        $enc->level = QR_ECLEVEL_Q;
-                    break;
-                case 'h':
-                case 'H':
-                        $enc->level = QR_ECLEVEL_H;
-                    break;
+            case '0':
+            case '1':
+            case '2':
+            case '3':
+                    $enc->level = $level;
+                break;
+            case 'l':
+            case 'L':
+                    $enc->level = QR_ECLEVEL_L;
+                break;
+            case 'm':
+            case 'M':
+                    $enc->level = QR_ECLEVEL_M;
+                break;
+            case 'q':
+            case 'Q':
+                    $enc->level = QR_ECLEVEL_Q;
+                break;
+            case 'h':
+            case 'H':
+                    $enc->level = QR_ECLEVEL_H;
+                break;
             }
             
             return $enc;

Please login to merge, or discard this patch.

Spacing +502 added lines, -502 removed lines patch added patch discarded remove patch

@@ -93,11 +93,11 @@  discard block
 block discarded – undo
 	// Supported output formats
 	
 	define('QR_FORMAT_TEXT', 0);
-	define('QR_FORMAT_PNG',  1);
+	define('QR_FORMAT_PNG', 1);
 	
 	class qrstr {
 		public static function set(&$srctab, $x, $y, $repl, $replLen = false) {
-			$srctab[$y] = substr_replace($srctab[$y], ($replLen !== false)?substr($repl,0,$replLen):$repl, $x, ($replLen !== false)?$replLen:strlen($repl));
+			$srctab[$y] = substr_replace($srctab[$y], ($replLen !== false) ?substr($repl, 0, $replLen) : $repl, $x, ($replLen !== false) ? $replLen : strlen($repl));
 		}
 	}	
 
@@ -114,15 +114,15 @@  discard block
 block discarded – undo
  * Config file, tuned-up for merged verion
  */
      
-    define('QR_CACHEABLE', false);       // use cache - more disk reads but less CPU power, masks and format templates are stored there
-    define('QR_CACHE_DIR', false);       // used when QR_CACHEABLE === true
-    define('QR_LOG_DIR', false);         // default error logs dir   
+    define('QR_CACHEABLE', false); // use cache - more disk reads but less CPU power, masks and format templates are stored there
+    define('QR_CACHE_DIR', false); // used when QR_CACHEABLE === true
+    define('QR_LOG_DIR', false); // default error logs dir   
     
-    define('QR_FIND_BEST_MASK', true);                                                          // if true, estimates best mask (spec. default, but extremally slow; set to false to significant performance boost but (propably) worst quality code
-    define('QR_FIND_FROM_RANDOM', 2);                                                       // if false, checks all masks available, otherwise value tells count of masks need to be checked, mask id are got randomly
-    define('QR_DEFAULT_MASK', 2);                                                               // when QR_FIND_BEST_MASK === false
+    define('QR_FIND_BEST_MASK', true); // if true, estimates best mask (spec. default, but extremally slow; set to false to significant performance boost but (propably) worst quality code
+    define('QR_FIND_FROM_RANDOM', 2); // if false, checks all masks available, otherwise value tells count of masks need to be checked, mask id are got randomly
+    define('QR_DEFAULT_MASK', 2); // when QR_FIND_BEST_MASK === false
                                                   
-    define('QR_PNG_MAXIMUM_SIZE',  1024);                                                       // maximum allowed png image width (in pixels), tune to make sure GD and PHP can handle such big images
+    define('QR_PNG_MAXIMUM_SIZE', 1024); // maximum allowed png image width (in pixels), tune to make sure GD and PHP can handle such big images
                                                   
 
 
@@ -163,8 +163,8 @@  discard block
 block discarded – undo
             $len = count($frame);
             foreach ($frame as &$frameLine) {
                 
-                for($i=0; $i<$len; $i++) {
-                    $frameLine[$i] = (ord($frameLine[$i])&1)?'1':'0';
+                for ($i = 0; $i < $len; $i++) {
+                    $frameLine[$i] = (ord($frameLine[$i]) & 1) ? '1' : '0';
                 }
             }
             
@@ -194,8 +194,8 @@  discard block
 block discarded – undo
                 
             foreach ($qrTab as $line) {
                 $arrAdd = array();
-                foreach(str_split($line) as $char)
-                    $arrAdd[] = ($char=='1')?1:0;
+                foreach (str_split($line) as $char)
+                    $arrAdd[] = ($char == '1') ? 1 : 0;
                 $barcode_array['bcode'][] = $arrAdd;
             }
                     
@@ -214,7 +214,7 @@  discard block
 block discarded – undo
 			QRtools::markTime('before_build_cache');
 			
 			$mask = new QRmask();
-            for ($a=1; $a <= QRSPEC_VERSION_MAX; $a++) {
+            for ($a = 1; $a <= QRSPEC_VERSION_MAX; $a++) {
                 $frame = QRspec::newFrame($a);
                 if (QR_IMAGE) {
                     $fileName = QR_CACHE_DIR.'frame_'.$a.'.png';
@@ -223,7 +223,7 @@  discard block
 block discarded – undo
 				
 				$width = count($frame);
 				$bitMask = array_fill(0, $width, array_fill(0, $width, 0));
-				for ($maskNo=0; $maskNo<8; $maskNo++)
+				for ($maskNo = 0; $maskNo < 8; $maskNo++)
 					$mask->makeMaskNo($maskNo, $width, $frame, $bitMask, true);
             }
 			
@@ -248,8 +248,8 @@  discard block
 block discarded – undo
         public static function dumpMask($frame) 
         {
             $width = count($frame);
-            for($y=0;$y<$width;$y++) {
-                for($x=0;$x<$width;$x++) {
+            for ($y = 0; $y < $width; $y++) {
+                for ($x = 0; $x < $width; $x++) {
                     echo ord($frame[$y][$x]).',';
                 }
             }
@@ -259,7 +259,7 @@  discard block
 block discarded – undo
         public static function markTime($markerId)
         {
             list($usec, $sec) = explode(" ", microtime());
-            $time = ((float)$usec + (float)$sec);
+            $time = ((float) $usec + (float) $sec);
             
             if (!isset($GLOBALS['qr_time_bench']))
                 $GLOBALS['qr_time_bench'] = array();
@@ -280,9 +280,9 @@  discard block
 block discarded – undo
                     <thead><tr style="border-bottom:1px solid silver"><td colspan="2" style="text-align:center">BENCHMARK</td></tr></thead>
                     <tbody>';
 
-            foreach($GLOBALS['qr_time_bench'] as $markerId=>$thisTime) {
+            foreach ($GLOBALS['qr_time_bench'] as $markerId=>$thisTime) {
                 if ($p > 0) {
-                    echo '<tr><th style="text-align:right">till '.$markerId.': </th><td>'.number_format($thisTime-$lastTime, 6).'s</td></tr>';
+                    echo '<tr><th style="text-align:right">till '.$markerId.': </th><td>'.number_format($thisTime - $lastTime, 6).'s</td></tr>';
                 } else {
                     $startTime = $thisTime;
                 }
@@ -292,7 +292,7 @@  discard block
 block discarded – undo
             }
             
             echo '</tbody><tfoot>
-                <tr style="border-top:2px solid black"><th style="text-align:right">TOTAL: </th><td>'.number_format($lastTime-$startTime, 6).'s</td></tr>
+                <tr style="border-top:2px solid black"><th style="text-align:right">TOTAL: </th><td>'.number_format($lastTime - $startTime, 6).'s</td></tr>
             </tfoot>
             </table>';
         }
@@ -344,57 +344,57 @@  discard block
 block discarded – undo
  */
  
     define('QRSPEC_VERSION_MAX', 40);
-    define('QRSPEC_WIDTH_MAX',   177);
+    define('QRSPEC_WIDTH_MAX', 177);
 
-    define('QRCAP_WIDTH',        0);
-    define('QRCAP_WORDS',        1);
-    define('QRCAP_REMINDER',     2);
-    define('QRCAP_EC',           3);
+    define('QRCAP_WIDTH', 0);
+    define('QRCAP_WORDS', 1);
+    define('QRCAP_REMINDER', 2);
+    define('QRCAP_EC', 3);
 
     class QRspec {
     
         public static $capacity = array(
-            array(  0,    0, 0, array(   0,    0,    0,    0)),
-            array( 21,   26, 0, array(   7,   10,   13,   17)), // 1
-            array( 25,   44, 7, array(  10,   16,   22,   28)),
-            array( 29,   70, 7, array(  15,   26,   36,   44)),
-            array( 33,  100, 7, array(  20,   36,   52,   64)),
-            array( 37,  134, 7, array(  26,   48,   72,   88)), // 5
-            array( 41,  172, 7, array(  36,   64,   96,  112)),
-            array( 45,  196, 0, array(  40,   72,  108,  130)),
-            array( 49,  242, 0, array(  48,   88,  132,  156)),
-            array( 53,  292, 0, array(  60,  110,  160,  192)),
-            array( 57,  346, 0, array(  72,  130,  192,  224)), //10
-            array( 61,  404, 0, array(  80,  150,  224,  264)),
-            array( 65,  466, 0, array(  96,  176,  260,  308)),
-            array( 69,  532, 0, array( 104,  198,  288,  352)),
-            array( 73,  581, 3, array( 120,  216,  320,  384)),
-            array( 77,  655, 3, array( 132,  240,  360,  432)), //15
-            array( 81,  733, 3, array( 144,  280,  408,  480)),
-            array( 85,  815, 3, array( 168,  308,  448,  532)),
-            array( 89,  901, 3, array( 180,  338,  504,  588)),
-            array( 93,  991, 3, array( 196,  364,  546,  650)),
-            array( 97, 1085, 3, array( 224,  416,  600,  700)), //20
-            array(101, 1156, 4, array( 224,  442,  644,  750)),
-            array(105, 1258, 4, array( 252,  476,  690,  816)),
-            array(109, 1364, 4, array( 270,  504,  750,  900)),
-            array(113, 1474, 4, array( 300,  560,  810,  960)),
-            array(117, 1588, 4, array( 312,  588,  870, 1050)), //25
-            array(121, 1706, 4, array( 336,  644,  952, 1110)),
-            array(125, 1828, 4, array( 360,  700, 1020, 1200)),
-            array(129, 1921, 3, array( 390,  728, 1050, 1260)),
-            array(133, 2051, 3, array( 420,  784, 1140, 1350)),
-            array(137, 2185, 3, array( 450,  812, 1200, 1440)), //30
-            array(141, 2323, 3, array( 480,  868, 1290, 1530)),
-            array(145, 2465, 3, array( 510,  924, 1350, 1620)),
-            array(149, 2611, 3, array( 540,  980, 1440, 1710)),
-            array(153, 2761, 3, array( 570, 1036, 1530, 1800)),
-            array(157, 2876, 0, array( 570, 1064, 1590, 1890)), //35
-            array(161, 3034, 0, array( 600, 1120, 1680, 1980)),
-            array(165, 3196, 0, array( 630, 1204, 1770, 2100)),
-            array(169, 3362, 0, array( 660, 1260, 1860, 2220)),
-            array(173, 3532, 0, array( 720, 1316, 1950, 2310)),
-            array(177, 3706, 0, array( 750, 1372, 2040, 2430)) //40
+            array(0, 0, 0, array(0, 0, 0, 0)),
+            array(21, 26, 0, array(7, 10, 13, 17)), // 1
+            array(25, 44, 7, array(10, 16, 22, 28)),
+            array(29, 70, 7, array(15, 26, 36, 44)),
+            array(33, 100, 7, array(20, 36, 52, 64)),
+            array(37, 134, 7, array(26, 48, 72, 88)), // 5
+            array(41, 172, 7, array(36, 64, 96, 112)),
+            array(45, 196, 0, array(40, 72, 108, 130)),
+            array(49, 242, 0, array(48, 88, 132, 156)),
+            array(53, 292, 0, array(60, 110, 160, 192)),
+            array(57, 346, 0, array(72, 130, 192, 224)), //10
+            array(61, 404, 0, array(80, 150, 224, 264)),
+            array(65, 466, 0, array(96, 176, 260, 308)),
+            array(69, 532, 0, array(104, 198, 288, 352)),
+            array(73, 581, 3, array(120, 216, 320, 384)),
+            array(77, 655, 3, array(132, 240, 360, 432)), //15
+            array(81, 733, 3, array(144, 280, 408, 480)),
+            array(85, 815, 3, array(168, 308, 448, 532)),
+            array(89, 901, 3, array(180, 338, 504, 588)),
+            array(93, 991, 3, array(196, 364, 546, 650)),
+            array(97, 1085, 3, array(224, 416, 600, 700)), //20
+            array(101, 1156, 4, array(224, 442, 644, 750)),
+            array(105, 1258, 4, array(252, 476, 690, 816)),
+            array(109, 1364, 4, array(270, 504, 750, 900)),
+            array(113, 1474, 4, array(300, 560, 810, 960)),
+            array(117, 1588, 4, array(312, 588, 870, 1050)), //25
+            array(121, 1706, 4, array(336, 644, 952, 1110)),
+            array(125, 1828, 4, array(360, 700, 1020, 1200)),
+            array(129, 1921, 3, array(390, 728, 1050, 1260)),
+            array(133, 2051, 3, array(420, 784, 1140, 1350)),
+            array(137, 2185, 3, array(450, 812, 1200, 1440)), //30
+            array(141, 2323, 3, array(480, 868, 1290, 1530)),
+            array(145, 2465, 3, array(510, 924, 1350, 1620)),
+            array(149, 2611, 3, array(540, 980, 1440, 1710)),
+            array(153, 2761, 3, array(570, 1036, 1530, 1800)),
+            array(157, 2876, 0, array(570, 1064, 1590, 1890)), //35
+            array(161, 3034, 0, array(600, 1120, 1680, 1980)),
+            array(165, 3196, 0, array(630, 1204, 1770, 2100)),
+            array(169, 3362, 0, array(660, 1260, 1860, 2220)),
+            array(173, 3532, 0, array(720, 1316, 1950, 2310)),
+            array(177, 3706, 0, array(750, 1372, 2040, 2430)) //40
         );
         
         //----------------------------------------------------------------------
@@ -425,9 +425,9 @@  discard block
 block discarded – undo
         public static function getMinimumVersion($size, $level)
         {
 
-            for($i=1; $i<= QRSPEC_VERSION_MAX; $i++) {
-                $words  = self::$capacity[$i][QRCAP_WORDS] - self::$capacity[$i][QRCAP_EC][$level];
-                if($words >= $size) 
+            for ($i = 1; $i <= QRSPEC_VERSION_MAX; $i++) {
+                $words = self::$capacity[$i][QRCAP_WORDS] - self::$capacity[$i][QRCAP_EC][$level];
+                if ($words >= $size) 
                     return $i;
             }
 
@@ -438,9 +438,9 @@  discard block
 block discarded – undo
         
         public static $lengthTableBits = array(
             array(10, 12, 14),
-            array( 9, 11, 13),
-            array( 8, 16, 16),
-            array( 8, 10, 12)
+            array(9, 11, 13),
+            array(8, 16, 16),
+            array(8, 10, 12)
         );
         
         //----------------------------------------------------------------------
@@ -463,12 +463,12 @@  discard block
 block discarded – undo
         //----------------------------------------------------------------------
         public static function maximumWords($mode, $version)
         {
-            if($mode == QR_MODE_STRUCTURE) 
+            if ($mode == QR_MODE_STRUCTURE) 
                 return 3;
                 
-            if($version <= 9) {
+            if ($version <= 9) {
                 $l = 0;
-            } else if($version <= 26) {
+            } else if ($version <= 26) {
                 $l = 1;
             } else {
                 $l = 2;
@@ -477,7 +477,7 @@  discard block
 block discarded – undo
             $bits = self::$lengthTableBits[$mode][$l];
             $words = (1 << $bits) - 1;
             
-            if($mode == QR_MODE_KANJI) {
+            if ($mode == QR_MODE_KANJI) {
                 $words *= 2; // the number of bytes is required
             }
 
@@ -489,47 +489,47 @@  discard block
 block discarded – undo
         // See Table 12-16 (pp.30-36), JIS X0510:2004.
 
         public static $eccTable = array(
-            array(array( 0,  0), array( 0,  0), array( 0,  0), array( 0,  0)),
-            array(array( 1,  0), array( 1,  0), array( 1,  0), array( 1,  0)), // 1
-            array(array( 1,  0), array( 1,  0), array( 1,  0), array( 1,  0)),
-            array(array( 1,  0), array( 1,  0), array( 2,  0), array( 2,  0)),
-            array(array( 1,  0), array( 2,  0), array( 2,  0), array( 4,  0)),
-            array(array( 1,  0), array( 2,  0), array( 2,  2), array( 2,  2)), // 5
-            array(array( 2,  0), array( 4,  0), array( 4,  0), array( 4,  0)),
-            array(array( 2,  0), array( 4,  0), array( 2,  4), array( 4,  1)),
-            array(array( 2,  0), array( 2,  2), array( 4,  2), array( 4,  2)),
-            array(array( 2,  0), array( 3,  2), array( 4,  4), array( 4,  4)),
-            array(array( 2,  2), array( 4,  1), array( 6,  2), array( 6,  2)), //10
-            array(array( 4,  0), array( 1,  4), array( 4,  4), array( 3,  8)),
-            array(array( 2,  2), array( 6,  2), array( 4,  6), array( 7,  4)),
-            array(array( 4,  0), array( 8,  1), array( 8,  4), array(12,  4)),
-            array(array( 3,  1), array( 4,  5), array(11,  5), array(11,  5)),
-            array(array( 5,  1), array( 5,  5), array( 5,  7), array(11,  7)), //15
-            array(array( 5,  1), array( 7,  3), array(15,  2), array( 3, 13)),
-            array(array( 1,  5), array(10,  1), array( 1, 15), array( 2, 17)),
-            array(array( 5,  1), array( 9,  4), array(17,  1), array( 2, 19)),
-            array(array( 3,  4), array( 3, 11), array(17,  4), array( 9, 16)),
-            array(array( 3,  5), array( 3, 13), array(15,  5), array(15, 10)), //20
-            array(array( 4,  4), array(17,  0), array(17,  6), array(19,  6)),
-            array(array( 2,  7), array(17,  0), array( 7, 16), array(34,  0)),
-            array(array( 4,  5), array( 4, 14), array(11, 14), array(16, 14)),
-            array(array( 6,  4), array( 6, 14), array(11, 16), array(30,  2)),
-            array(array( 8,  4), array( 8, 13), array( 7, 22), array(22, 13)), //25
-            array(array(10,  2), array(19,  4), array(28,  6), array(33,  4)),
-            array(array( 8,  4), array(22,  3), array( 8, 26), array(12, 28)),
-            array(array( 3, 10), array( 3, 23), array( 4, 31), array(11, 31)),
-            array(array( 7,  7), array(21,  7), array( 1, 37), array(19, 26)),
-            array(array( 5, 10), array(19, 10), array(15, 25), array(23, 25)), //30
-            array(array(13,  3), array( 2, 29), array(42,  1), array(23, 28)),
-            array(array(17,  0), array(10, 23), array(10, 35), array(19, 35)),
-            array(array(17,  1), array(14, 21), array(29, 19), array(11, 46)),
-            array(array(13,  6), array(14, 23), array(44,  7), array(59,  1)),
-            array(array(12,  7), array(12, 26), array(39, 14), array(22, 41)), //35
-            array(array( 6, 14), array( 6, 34), array(46, 10), array( 2, 64)),
-            array(array(17,  4), array(29, 14), array(49, 10), array(24, 46)),
-            array(array( 4, 18), array(13, 32), array(48, 14), array(42, 32)),
-            array(array(20,  4), array(40,  7), array(43, 22), array(10, 67)),
-            array(array(19,  6), array(18, 31), array(34, 34), array(20, 61)),//40
+            array(array(0, 0), array(0, 0), array(0, 0), array(0, 0)),
+            array(array(1, 0), array(1, 0), array(1, 0), array(1, 0)), // 1
+            array(array(1, 0), array(1, 0), array(1, 0), array(1, 0)),
+            array(array(1, 0), array(1, 0), array(2, 0), array(2, 0)),
+            array(array(1, 0), array(2, 0), array(2, 0), array(4, 0)),
+            array(array(1, 0), array(2, 0), array(2, 2), array(2, 2)), // 5
+            array(array(2, 0), array(4, 0), array(4, 0), array(4, 0)),
+            array(array(2, 0), array(4, 0), array(2, 4), array(4, 1)),
+            array(array(2, 0), array(2, 2), array(4, 2), array(4, 2)),
+            array(array(2, 0), array(3, 2), array(4, 4), array(4, 4)),
+            array(array(2, 2), array(4, 1), array(6, 2), array(6, 2)), //10
+            array(array(4, 0), array(1, 4), array(4, 4), array(3, 8)),
+            array(array(2, 2), array(6, 2), array(4, 6), array(7, 4)),
+            array(array(4, 0), array(8, 1), array(8, 4), array(12, 4)),
+            array(array(3, 1), array(4, 5), array(11, 5), array(11, 5)),
+            array(array(5, 1), array(5, 5), array(5, 7), array(11, 7)), //15
+            array(array(5, 1), array(7, 3), array(15, 2), array(3, 13)),
+            array(array(1, 5), array(10, 1), array(1, 15), array(2, 17)),
+            array(array(5, 1), array(9, 4), array(17, 1), array(2, 19)),
+            array(array(3, 4), array(3, 11), array(17, 4), array(9, 16)),
+            array(array(3, 5), array(3, 13), array(15, 5), array(15, 10)), //20
+            array(array(4, 4), array(17, 0), array(17, 6), array(19, 6)),
+            array(array(2, 7), array(17, 0), array(7, 16), array(34, 0)),
+            array(array(4, 5), array(4, 14), array(11, 14), array(16, 14)),
+            array(array(6, 4), array(6, 14), array(11, 16), array(30, 2)),
+            array(array(8, 4), array(8, 13), array(7, 22), array(22, 13)), //25
+            array(array(10, 2), array(19, 4), array(28, 6), array(33, 4)),
+            array(array(8, 4), array(22, 3), array(8, 26), array(12, 28)),
+            array(array(3, 10), array(3, 23), array(4, 31), array(11, 31)),
+            array(array(7, 7), array(21, 7), array(1, 37), array(19, 26)),
+            array(array(5, 10), array(19, 10), array(15, 25), array(23, 25)), //30
+            array(array(13, 3), array(2, 29), array(42, 1), array(23, 28)),
+            array(array(17, 0), array(10, 23), array(10, 35), array(19, 35)),
+            array(array(17, 1), array(14, 21), array(29, 19), array(11, 46)),
+            array(array(13, 6), array(14, 23), array(44, 7), array(59, 1)),
+            array(array(12, 7), array(12, 26), array(39, 14), array(22, 41)), //35
+            array(array(6, 14), array(6, 34), array(46, 10), array(2, 64)),
+            array(array(17, 4), array(29, 14), array(49, 10), array(24, 46)),
+            array(array(4, 18), array(13, 32), array(48, 14), array(42, 32)),
+            array(array(20, 4), array(40, 7), array(43, 22), array(10, 67)),
+            array(array(19, 6), array(18, 31), array(34, 34), array(20, 61)), //40
         );                                                                       
 
         //----------------------------------------------------------------------
@@ -538,7 +538,7 @@  discard block
 block discarded – undo
         public static function getEccSpec($version, $level, array &$spec)
         {
             if (count($spec) < 5) {
-                $spec = array(0,0,0,0,0);
+                $spec = array(0, 0, 0, 0, 0);
             }
 
             $b1   = self::$eccTable[$version][$level][0];
@@ -546,16 +546,16 @@  discard block
 block discarded – undo
             $data = self::getDataLength($version, $level);
             $ecc  = self::getECCLength($version, $level);
 
-            if($b2 == 0) {
+            if ($b2 == 0) {
                 $spec[0] = $b1;
-                $spec[1] = (int)($data / $b1);
-                $spec[2] = (int)($ecc / $b1);
+                $spec[1] = (int) ($data / $b1);
+                $spec[2] = (int) ($ecc / $b1);
                 $spec[3] = 0; 
                 $spec[4] = 0;
             } else {
                 $spec[0] = $b1;
-                $spec[1] = (int)($data / ($b1 + $b2));
-                $spec[2] = (int)($ecc  / ($b1 + $b2));
+                $spec[1] = (int) ($data / ($b1 + $b2));
+                $spec[2] = (int) ($ecc / ($b1 + $b2));
                 $spec[3] = $b2;
                 $spec[4] = $spec[1] + 1;
             }
@@ -571,9 +571,9 @@  discard block
 block discarded – undo
         // See Table 1 in Appendix E (pp.71) of JIS X0510:2004.
          
         public static $alignmentPattern = array(      
-            array( 0,  0),
-            array( 0,  0), array(18,  0), array(22,  0), array(26,  0), array(30,  0), // 1- 5
-            array(34,  0), array(22, 38), array(24, 42), array(26, 46), array(28, 50), // 6-10
+            array(0, 0),
+            array(0, 0), array(18, 0), array(22, 0), array(26, 0), array(30, 0), // 1- 5
+            array(34, 0), array(22, 38), array(24, 42), array(26, 46), array(28, 50), // 6-10
             array(30, 54), array(32, 58), array(34, 62), array(26, 46), array(26, 48), //11-15
             array(26, 50), array(30, 54), array(30, 56), array(30, 58), array(34, 62), //16-20
             array(28, 50), array(26, 50), array(30, 54), array(28, 54), array(32, 58), //21-25
@@ -599,28 +599,28 @@  discard block
 block discarded – undo
                 "\xa1\xa1\xa1\xa1\xa1"
             );                        
             
-            $yStart = $oy-2;         
-            $xStart = $ox-2;
+            $yStart = $oy - 2;         
+            $xStart = $ox - 2;
             
-            for($y=0; $y<5; $y++) {
-                QRstr::set($frame, $xStart, $yStart+$y, $finder[$y]);
+            for ($y = 0; $y < 5; $y++) {
+                QRstr::set($frame, $xStart, $yStart + $y, $finder[$y]);
             }
         }
 
         //----------------------------------------------------------------------
         public static function putAlignmentPattern($version, &$frame, $width)
         {
-            if($version < 2)
+            if ($version < 2)
                 return;
 
             $d = self::$alignmentPattern[$version][1] - self::$alignmentPattern[$version][0];
-            if($d < 0) {
+            if ($d < 0) {
                 $w = 2;
             } else {
-                $w = (int)(($width - self::$alignmentPattern[$version][0]) / $d + 2);
+                $w = (int) (($width - self::$alignmentPattern[$version][0]) / $d + 2);
             }
 
-            if($w * $w - 3 == 1) {
+            if ($w * $w - 3 == 1) {
                 $x = self::$alignmentPattern[$version][0];
                 $y = self::$alignmentPattern[$version][0];
                 self::putAlignmentMarker($frame, $x, $y);
@@ -628,16 +628,16 @@  discard block
 block discarded – undo
             }
 
             $cx = self::$alignmentPattern[$version][0];
-            for($x=1; $x<$w - 1; $x++) {
+            for ($x = 1; $x < $w - 1; $x++) {
                 self::putAlignmentMarker($frame, 6, $cx);
-                self::putAlignmentMarker($frame, $cx,  6);
+                self::putAlignmentMarker($frame, $cx, 6);
                 $cx += $d;
             }
 
             $cy = self::$alignmentPattern[$version][0];
-            for($y=0; $y<$w-1; $y++) {
+            for ($y = 0; $y < $w - 1; $y++) {
                 $cx = self::$alignmentPattern[$version][0];
-                for($x=0; $x<$w-1; $x++) {
+                for ($x = 0; $x < $w - 1; $x++) {
                     self::putAlignmentMarker($frame, $cx, $cy);
                     $cx += $d;
                 }
@@ -663,10 +663,10 @@  discard block
 block discarded – undo
         //----------------------------------------------------------------------
         public static function getVersionPattern($version)
         {
-            if($version < 7 || $version > QRSPEC_VERSION_MAX)
+            if ($version < 7 || $version > QRSPEC_VERSION_MAX)
                 return 0;
 
-            return self::$versionPattern[$version -7];
+            return self::$versionPattern[$version - 7];
         }
 
         // Format information --------------------------------------------------
@@ -681,10 +681,10 @@  discard block
 block discarded – undo
 
         public static function getFormatInfo($mask, $level)
         {
-            if($mask < 0 || $mask > 7)
+            if ($mask < 0 || $mask > 7)
                 return 0;
                 
-            if($level < 0 || $level > 3)
+            if ($level < 0 || $level > 3)
                 return 0;                
 
             return self::$formatInfo[$level][$mask];
@@ -713,8 +713,8 @@  discard block
 block discarded – undo
                 "\xc1\xc1\xc1\xc1\xc1\xc1\xc1"
             );                            
             
-            for($y=0; $y<7; $y++) {
-                QRstr::set($frame, $ox, $oy+$y, $finder[$y]);
+            for ($y = 0; $y < 7; $y++) {
+                QRstr::set($frame, $ox, $oy + $y, $finder[$y]);
             }
         }
 
@@ -722,7 +722,7 @@  discard block
 block discarded – undo
         public static function createFrame($version)
         {
             $width = self::$capacity[$version][QRCAP_WIDTH];
-            $frameLine = str_repeat ("\0", $width);
+            $frameLine = str_repeat("\0", $width);
             $frame = array_fill(0, $width, $frameLine);
 
             // Finder pattern
@@ -733,7 +733,7 @@  discard block
 block discarded – undo
             // Separator
             $yOffset = $width - 7;
             
-            for($y=0; $y<7; $y++) {
+            for ($y = 0; $y < 7; $y++) {
                 $frame[$y][7] = "\xc0";
                 $frame[$y][$width - 8] = "\xc0";
                 $frame[$yOffset][7] = "\xc0";
@@ -743,7 +743,7 @@  discard block
 block discarded – undo
             $setPattern = str_repeat("\xc0", 8);
             
             QRstr::set($frame, 0, 7, $setPattern);
-            QRstr::set($frame, $width-8, 7, $setPattern);
+            QRstr::set($frame, $width - 8, 7, $setPattern);
             QRstr::set($frame, 0, $width - 8, $setPattern);
         
             // Format info
@@ -753,38 +753,38 @@  discard block
 block discarded – undo
             
             $yOffset = $width - 8;
 
-            for($y=0; $y<8; $y++,$yOffset++) {
+            for ($y = 0; $y < 8; $y++, $yOffset++) {
                 $frame[$y][8] = "\x84";
                 $frame[$yOffset][8] = "\x84";
             }
 
             // Timing pattern  
             
-            for($i=1; $i<$width-15; $i++) {
-                $frame[6][7+$i] = chr(0x90 | ($i & 1));
-                $frame[7+$i][6] = chr(0x90 | ($i & 1));
+            for ($i = 1; $i < $width - 15; $i++) {
+                $frame[6][7 + $i] = chr(0x90 | ($i & 1));
+                $frame[7 + $i][6] = chr(0x90 | ($i & 1));
             }
             
             // Alignment pattern  
             self::putAlignmentPattern($version, $frame, $width);
             
             // Version information 
-            if($version >= 7) {
+            if ($version >= 7) {
                 $vinf = self::getVersionPattern($version);
 
                 $v = $vinf;
                 
-                for($x=0; $x<6; $x++) {
-                    for($y=0; $y<3; $y++) {
-                        $frame[($width - 11)+$y][$x] = chr(0x88 | ($v & 1));
+                for ($x = 0; $x < 6; $x++) {
+                    for ($y = 0; $y < 3; $y++) {
+                        $frame[($width - 11) + $y][$x] = chr(0x88 | ($v & 1));
                         $v = $v >> 1;
                     }
                 }
 
                 $v = $vinf;
-                for($y=0; $y<6; $y++) {
-                    for($x=0; $x<3; $x++) {
-                        $frame[$y][$x+($width - 11)] = chr(0x88 | ($v & 1));
+                for ($y = 0; $y < 6; $y++) {
+                    for ($x = 0; $x < 3; $x++) {
+                        $frame[$y][$x + ($width - 11)] = chr(0x88 | ($v & 1));
                         $v = $v >> 1;
                     }
                 }
@@ -818,16 +818,16 @@  discard block
 block discarded – undo
             } else {
             
                 foreach ($frame as &$frameLine) {
-                    $frameLine = join('<span class="m">&nbsp;</span>',  explode("\xc0", $frameLine));
+                    $frameLine = join('<span class="m">&nbsp;</span>', explode("\xc0", $frameLine));
                     $frameLine = join('<span class="m">&#9618;</span>', explode("\xc1", $frameLine));
-                    $frameLine = join('<span class="p">&nbsp;</span>',  explode("\xa0", $frameLine));
+                    $frameLine = join('<span class="p">&nbsp;</span>', explode("\xa0", $frameLine));
                     $frameLine = join('<span class="p">&#9618;</span>', explode("\xa1", $frameLine));
                     $frameLine = join('<span class="s">&#9671;</span>', explode("\x84", $frameLine)); //format 0
                     $frameLine = join('<span class="s">&#9670;</span>', explode("\x85", $frameLine)); //format 1
                     $frameLine = join('<span class="x">&#9762;</span>', explode("\x81", $frameLine)); //special bit
-                    $frameLine = join('<span class="c">&nbsp;</span>',  explode("\x90", $frameLine)); //clock 0
+                    $frameLine = join('<span class="c">&nbsp;</span>', explode("\x90", $frameLine)); //clock 0
                     $frameLine = join('<span class="c">&#9719;</span>', explode("\x91", $frameLine)); //clock 1
-                    $frameLine = join('<span class="f">&nbsp;</span>',  explode("\x88", $frameLine)); //version
+                    $frameLine = join('<span class="f">&nbsp;</span>', explode("\x88", $frameLine)); //version
                     $frameLine = join('<span class="f">&#9618;</span>', explode("\x89", $frameLine)); //version
                     $frameLine = join('&#9830;', explode("\x01", $frameLine));
                     $frameLine = join('&#8901;', explode("\0", $frameLine));
@@ -865,10 +865,10 @@  discard block
 block discarded – undo
         //----------------------------------------------------------------------
         public static function newFrame($version)
         {
-            if($version < 1 || $version > QRSPEC_VERSION_MAX) 
+            if ($version < 1 || $version > QRSPEC_VERSION_MAX) 
                 return null;
 
-            if(!isset(self::$frames[$version])) {
+            if (!isset(self::$frames[$version])) {
                 
                 $fileName = QR_CACHE_DIR.'frame_'.$version.'.dat';
                 
@@ -884,22 +884,22 @@  discard block
 block discarded – undo
                 }
             }
             
-            if(is_null(self::$frames[$version]))
+            if (is_null(self::$frames[$version]))
                 return null;
 
             return self::$frames[$version];
         }
 
         //----------------------------------------------------------------------
-        public static function rsBlockNum($spec)     { return $spec[0] + $spec[3]; }
-        public static function rsBlockNum1($spec)    { return $spec[0]; }
-        public static function rsDataCodes1($spec)   { return $spec[1]; }
-        public static function rsEccCodes1($spec)    { return $spec[2]; }
-        public static function rsBlockNum2($spec)    { return $spec[3]; }
-        public static function rsDataCodes2($spec)   { return $spec[4]; }
-        public static function rsEccCodes2($spec)    { return $spec[2]; }
-        public static function rsDataLength($spec)   { return ($spec[0] * $spec[1]) + ($spec[3] * $spec[4]);    }
-        public static function rsEccLength($spec)    { return ($spec[0] + $spec[3]) * $spec[2]; }
+        public static function rsBlockNum($spec) { return $spec[0] + $spec[3]; }
+        public static function rsBlockNum1($spec) { return $spec[0]; }
+        public static function rsDataCodes1($spec) { return $spec[1]; }
+        public static function rsEccCodes1($spec) { return $spec[2]; }
+        public static function rsBlockNum2($spec) { return $spec[3]; }
+        public static function rsDataCodes2($spec) { return $spec[4]; }
+        public static function rsEccCodes2($spec) { return $spec[2]; }
+        public static function rsDataLength($spec) { return ($spec[0] * $spec[1]) + ($spec[3] * $spec[4]); }
+        public static function rsEccLength($spec) { return ($spec[0] + $spec[3]) * $spec[2]; }
         
     }
 
@@ -938,7 +938,7 @@  discard block
 block discarded – undo
     class QRimage {
     
         //----------------------------------------------------------------------
-        public static function png($frame, $filename = false, $pixelPerPoint = 4, $outerFrame = 4,$saveandprint=FALSE) 
+        public static function png($frame, $filename = false, $pixelPerPoint = 4, $outerFrame = 4, $saveandprint = FALSE) 
         {
             $image = self::image($frame, $pixelPerPoint, $outerFrame);
             
@@ -946,11 +946,11 @@  discard block
 block discarded – undo
                 Header("Content-type: image/png");
                 ImagePng($image);
             } else {
-                if($saveandprint===TRUE){
+                if ($saveandprint === TRUE) {
                     ImagePng($image, $filename);
                     header("Content-type: image/png");
                     ImagePng($image);
-                }else{
+                } else {
                     ImagePng($image, $filename);
                 }
             }
@@ -979,25 +979,25 @@  discard block
 block discarded – undo
             $h = count($frame);
             $w = strlen($frame[0]);
             
-            $imgW = $w + 2*$outerFrame;
-            $imgH = $h + 2*$outerFrame;
+            $imgW = $w + 2 * $outerFrame;
+            $imgH = $h + 2 * $outerFrame;
             
-            $base_image =ImageCreate($imgW, $imgH);
+            $base_image = ImageCreate($imgW, $imgH);
             
-            $col[0] = ImageColorAllocate($base_image,255,255,255);
-            $col[1] = ImageColorAllocate($base_image,0,0,0);
+            $col[0] = ImageColorAllocate($base_image, 255, 255, 255);
+            $col[1] = ImageColorAllocate($base_image, 0, 0, 0);
 
             imagefill($base_image, 0, 0, $col[0]);
 
-            for($y=0; $y<$h; $y++) {
-                for($x=0; $x<$w; $x++) {
+            for ($y = 0; $y < $h; $y++) {
+                for ($x = 0; $x < $w; $x++) {
                     if ($frame[$y][$x] == '1') {
-                        ImageSetPixel($base_image,$x+$outerFrame,$y+$outerFrame,$col[1]); 
+                        ImageSetPixel($base_image, $x + $outerFrame, $y + $outerFrame, $col[1]); 
                     }
                 }
             }
             
-            $target_image =ImageCreate($imgW * $pixelPerPoint, $imgH * $pixelPerPoint);
+            $target_image = ImageCreate($imgW * $pixelPerPoint, $imgH * $pixelPerPoint);
             ImageCopyResized($target_image, $base_image, 0, 0, 0, 0, $imgW * $pixelPerPoint, $imgH * $pixelPerPoint, $imgW, $imgH);
             ImageDestroy($base_image);
             
@@ -1038,7 +1038,7 @@  discard block
 block discarded – undo
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  */
  
-    define('STRUCTURE_HEADER_BITS',  20);
+    define('STRUCTURE_HEADER_BITS', 20);
     define('MAX_STRUCTURED_SYMBOLS', 16);
 
     class QRinputItem {
@@ -1053,11 +1053,11 @@  discard block
 block discarded – undo
             $setData = array_slice($data, 0, $size);
             
             if (count($setData) < $size) {
-                $setData = array_merge($setData, array_fill(0,$size-count($setData),0));
+                $setData = array_merge($setData, array_fill(0, $size - count($setData), 0));
             }
         
-            if(!QRinput::check($mode, $size, $setData)) {
-                throw new Exception('Error m:'.$mode.',s:'.$size.',d:'.join(',',$setData));
+            if (!QRinput::check($mode, $size, $setData)) {
+                throw new Exception('Error m:'.$mode.',s:'.$size.',d:'.join(',', $setData));
                 return null;
             }
             
@@ -1072,26 +1072,26 @@  discard block
 block discarded – undo
         {
             try {
             
-                $words = (int)($this->size / 3);
+                $words = (int) ($this->size / 3);
                 $bs = new QRbitstream();
                 
                 $val = 0x1;
                 $bs->appendNum(4, $val);
                 $bs->appendNum(QRspec::lengthIndicator(QR_MODE_NUM, $version), $this->size);
 
-                for($i=0; $i<$words; $i++) {
-                    $val  = (ord($this->data[$i*3  ]) - ord('0')) * 100;
-                    $val += (ord($this->data[$i*3+1]) - ord('0')) * 10;
-                    $val += (ord($this->data[$i*3+2]) - ord('0'));
+                for ($i = 0; $i < $words; $i++) {
+                    $val  = (ord($this->data[$i * 3]) - ord('0')) * 100;
+                    $val += (ord($this->data[$i * 3 + 1]) - ord('0')) * 10;
+                    $val += (ord($this->data[$i * 3 + 2]) - ord('0'));
                     $bs->appendNum(10, $val);
                 }
 
-                if($this->size - $words * 3 == 1) {
-                    $val = ord($this->data[$words*3]) - ord('0');
+                if ($this->size - $words * 3 == 1) {
+                    $val = ord($this->data[$words * 3]) - ord('0');
                     $bs->appendNum(4, $val);
-                } else if($this->size - $words * 3 == 2) {
-                    $val  = (ord($this->data[$words*3  ]) - ord('0')) * 10;
-                    $val += (ord($this->data[$words*3+1]) - ord('0'));
+                } else if ($this->size - $words * 3 == 2) {
+                    $val  = (ord($this->data[$words * 3]) - ord('0')) * 10;
+                    $val += (ord($this->data[$words * 3 + 1]) - ord('0'));
                     $bs->appendNum(7, $val);
                 }
 
@@ -1107,20 +1107,20 @@  discard block
 block discarded – undo
         public function encodeModeAn($version)
         {
             try {
-                $words = (int)($this->size / 2);
+                $words = (int) ($this->size / 2);
                 $bs = new QRbitstream();
                 
                 $bs->appendNum(4, 0x02);
                 $bs->appendNum(QRspec::lengthIndicator(QR_MODE_AN, $version), $this->size);
 
-                for($i=0; $i<$words; $i++) {
-                    $val  = (int)QRinput::lookAnTable(ord($this->data[$i*2  ])) * 45;
-                    $val += (int)QRinput::lookAnTable(ord($this->data[$i*2+1]));
+                for ($i = 0; $i < $words; $i++) {
+                    $val  = (int) QRinput::lookAnTable(ord($this->data[$i * 2])) * 45;
+                    $val += (int) QRinput::lookAnTable(ord($this->data[$i * 2 + 1]));
 
                     $bs->appendNum(11, $val);
                 }
 
-                if($this->size & 1) {
+                if ($this->size & 1) {
                     $val = QRinput::lookAnTable(ord($this->data[$words * 2]));
                     $bs->appendNum(6, $val);
                 }
@@ -1142,7 +1142,7 @@  discard block
 block discarded – undo
                 $bs->appendNum(4, 0x4);
                 $bs->appendNum(QRspec::lengthIndicator(QR_MODE_8, $version), $this->size);
 
-                for($i=0; $i<$this->size; $i++) {
+                for ($i = 0; $i < $this->size; $i++) {
                     $bs->appendNum(8, ord($this->data[$i]));
                 }
 
@@ -1162,11 +1162,11 @@  discard block
 block discarded – undo
                 $bs = new QRbitrtream();
                 
                 $bs->appendNum(4, 0x8);
-                $bs->appendNum(QRspec::lengthIndicator(QR_MODE_KANJI, $version), (int)($this->size / 2));
+                $bs->appendNum(QRspec::lengthIndicator(QR_MODE_KANJI, $version), (int) ($this->size / 2));
 
-                for($i=0; $i<$this->size; $i+=2) {
-                    $val = (ord($this->data[$i]) << 8) | ord($this->data[$i+1]);
-                    if($val <= 0x9ffc) {
+                for ($i = 0; $i < $this->size; $i += 2) {
+                    $val = (ord($this->data[$i]) << 8) | ord($this->data[$i + 1]);
+                    if ($val <= 0x9ffc) {
                         $val -= 0x8140;
                     } else {
                         $val -= 0xc140;
@@ -1190,7 +1190,7 @@  discard block
 block discarded – undo
         public function encodeModeStructure()
         {
             try {
-                $bs =  new QRbitstream();
+                $bs = new QRbitstream();
                 
                 $bs->appendNum(4, 0x03);
                 $bs->appendNum(4, ord($this->data[1]) - 1);
@@ -1210,14 +1210,14 @@  discard block
 block discarded – undo
         {
             $bits = 0;
 
-            if($version == 0) 
+            if ($version == 0) 
                 $version = 1;
 
-            switch($this->mode) {
-                case QR_MODE_NUM:        $bits = QRinput::estimateBitsModeNum($this->size);    break;
-                case QR_MODE_AN:        $bits = QRinput::estimateBitsModeAn($this->size);    break;
-                case QR_MODE_8:            $bits = QRinput::estimateBitsMode8($this->size);    break;
-                case QR_MODE_KANJI:        $bits = QRinput::estimateBitsModeKanji($this->size);break;
+            switch ($this->mode) {
+                case QR_MODE_NUM:        $bits = QRinput::estimateBitsModeNum($this->size); break;
+                case QR_MODE_AN:        $bits = QRinput::estimateBitsModeAn($this->size); break;
+                case QR_MODE_8:            $bits = QRinput::estimateBitsMode8($this->size); break;
+                case QR_MODE_KANJI:        $bits = QRinput::estimateBitsModeKanji($this->size); break;
                 case QR_MODE_STRUCTURE:    return STRUCTURE_HEADER_BITS;            
                 default:
                     return 0;
@@ -1225,7 +1225,7 @@  discard block
 block discarded – undo
 
             $l = QRspec::lengthIndicator($this->mode, $version);
             $m = 1 << $l;
-            $num = (int)(($this->size + $m - 1) / $m);
+            $num = (int) (($this->size + $m - 1) / $m);
 
             $bits += $num * (4 + $l);
 
@@ -1240,7 +1240,7 @@  discard block
 block discarded – undo
                 unset($this->bstream);
                 $words = QRspec::maximumWords($this->mode, $version);
                 
-                if($this->size > $words) {
+                if ($this->size > $words) {
                 
                     $st1 = new QRinputItem($this->mode, $words, $this->data);
                     $st2 = new QRinputItem($this->mode, $this->size - $words, array_slice($this->data, $words));
@@ -1259,18 +1259,18 @@  discard block
 block discarded – undo
                     
                     $ret = 0;
                     
-                    switch($this->mode) {
-                        case QR_MODE_NUM:        $ret = $this->encodeModeNum($version);    break;
-                        case QR_MODE_AN:        $ret = $this->encodeModeAn($version);    break;
-                        case QR_MODE_8:            $ret = $this->encodeMode8($version);    break;
-                        case QR_MODE_KANJI:        $ret = $this->encodeModeKanji($version);break;
-                        case QR_MODE_STRUCTURE:    $ret = $this->encodeModeStructure();    break;
+                    switch ($this->mode) {
+                        case QR_MODE_NUM:        $ret = $this->encodeModeNum($version); break;
+                        case QR_MODE_AN:        $ret = $this->encodeModeAn($version); break;
+                        case QR_MODE_8:            $ret = $this->encodeMode8($version); break;
+                        case QR_MODE_KANJI:        $ret = $this->encodeModeKanji($version); break;
+                        case QR_MODE_STRUCTURE:    $ret = $this->encodeModeStructure(); break;
                         
                         default:
                             break;
                     }
                     
-                    if($ret < 0)
+                    if ($ret < 0)
                         return -1;
                 }
 
@@ -1312,7 +1312,7 @@  discard block
 block discarded – undo
         //----------------------------------------------------------------------
         public function setVersion($version)
         {
-            if($version < 0 || $version > QRSPEC_VERSION_MAX) {
+            if ($version < 0 || $version > QRSPEC_VERSION_MAX) {
                 throw new Exception('Invalid version no');
                 return -1;
             }
@@ -1331,7 +1331,7 @@  discard block
 block discarded – undo
         //----------------------------------------------------------------------
         public function setErrorCorrectionLevel($level)
         {
-            if($level > QR_ECLEVEL_H) {
+            if ($level > QR_ECLEVEL_H) {
                 throw new Exception('Invalid ECLEVEL');
                 return -1;
             }
@@ -1363,11 +1363,11 @@  discard block
 block discarded – undo
         
         public function insertStructuredAppendHeader($size, $index, $parity)
         {
-            if( $size > MAX_STRUCTURED_SYMBOLS ) {
+            if ($size > MAX_STRUCTURED_SYMBOLS) {
                 throw new Exception('insertStructuredAppendHeader wrong size');
             }
             
-            if( $index <= 0 || $index > MAX_STRUCTURED_SYMBOLS ) {
+            if ($index <= 0 || $index > MAX_STRUCTURED_SYMBOLS) {
                 throw new Exception('insertStructuredAppendHeader wrong index');
             }
 
@@ -1387,9 +1387,9 @@  discard block
 block discarded – undo
         {
             $parity = 0;
             
-            foreach($this->items as $item) {
-                if($item->mode != QR_MODE_STRUCTURE) {
-                    for($i=$item->size-1; $i>=0; $i--) {
+            foreach ($this->items as $item) {
+                if ($item->mode != QR_MODE_STRUCTURE) {
+                    for ($i = $item->size - 1; $i >= 0; $i--) {
                         $parity ^= $item->data[$i];
                     }
                 }
@@ -1401,8 +1401,8 @@  discard block
 block discarded – undo
         //----------------------------------------------------------------------
         public static function checkModeNum($size, $data)
         {
-            for($i=0; $i<$size; $i++) {
-                if((ord($data[$i]) < ord('0')) || (ord($data[$i]) > ord('9'))){
+            for ($i = 0; $i < $size; $i++) {
+                if ((ord($data[$i]) < ord('0')) || (ord($data[$i]) > ord('9'))) {
                     return false;
                 }
             }
@@ -1413,10 +1413,10 @@  discard block
 block discarded – undo
         //----------------------------------------------------------------------
         public static function estimateBitsModeNum($size)
         {
-            $w = (int)$size / 3;
+            $w = (int) $size / 3;
             $bits = $w * 10;
             
-            switch($size - $w * 3) {
+            switch ($size - $w * 3) {
                 case 1:
                     $bits += 4;
                     break;
@@ -1435,7 +1435,7 @@  discard block
 block discarded – undo
             -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
             -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
             36, -1, -1, -1, 37, 38, -1, -1, -1, -1, 39, 40, -1, 41, 42, 43,
-             0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 44, -1, -1, -1, -1, -1,
+             0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 44, -1, -1, -1, -1, -1,
             -1, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
             25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, -1, -1, -1, -1, -1,
             -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
@@ -1445,13 +1445,13 @@  discard block
 block discarded – undo
         //----------------------------------------------------------------------
         public static function lookAnTable($c)
         {
-            return (($c > 127)?-1:self::$anTable[$c]);
+            return (($c > 127) ?-1 : self::$anTable[$c]);
         }
         
         //----------------------------------------------------------------------
         public static function checkModeAn($size, $data)
         {
-            for($i=0; $i<$size; $i++) {
+            for ($i = 0; $i < $size; $i++) {
                 if (self::lookAnTable(ord($data[$i])) == -1) {
                     return false;
                 }
@@ -1463,10 +1463,10 @@  discard block
 block discarded – undo
         //----------------------------------------------------------------------
         public static function estimateBitsModeAn($size)
         {
-            $w = (int)($size / 2);
+            $w = (int) ($size / 2);
             $bits = $w * 11;
             
-            if($size & 1) {
+            if ($size & 1) {
                 $bits += 6;
             }
 
@@ -1482,18 +1482,18 @@  discard block
 block discarded – undo
         //----------------------------------------------------------------------
         public function estimateBitsModeKanji($size)
         {
-            return (int)(($size / 2) * 13);
+            return (int) (($size / 2) * 13);
         }
         
         //----------------------------------------------------------------------
         public static function checkModeKanji($size, $data)
         {
-            if($size & 1)
+            if ($size & 1)
                 return false;
 
-            for($i=0; $i<$size; $i+=2) {
-                $val = (ord($data[$i]) << 8) | ord($data[$i+1]);
-                if( $val < 0x8140 
+            for ($i = 0; $i < $size; $i += 2) {
+                $val = (ord($data[$i]) << 8) | ord($data[$i + 1]);
+                if ($val < 0x8140 
                 || ($val > 0x9ffc && $val < 0xe040) 
                 || $val > 0xebbf) {
                     return false;
@@ -1509,12 +1509,12 @@  discard block
 block discarded – undo
 
         public static function check($mode, $size, $data)
         {
-            if($size <= 0) 
+            if ($size <= 0) 
                 return false;
 
-            switch($mode) {
-                case QR_MODE_NUM:       return self::checkModeNum($size, $data);   break;
-                case QR_MODE_AN:        return self::checkModeAn($size, $data);    break;
+            switch ($mode) {
+                case QR_MODE_NUM:       return self::checkModeNum($size, $data); break;
+                case QR_MODE_AN:        return self::checkModeAn($size, $data); break;
                 case QR_MODE_KANJI:     return self::checkModeKanji($size, $data); break;
                 case QR_MODE_8:         return true; break;
                 case QR_MODE_STRUCTURE: return true; break;
@@ -1532,7 +1532,7 @@  discard block
 block discarded – undo
         {
             $bits = 0;
 
-            foreach($this->items as $item) {
+            foreach ($this->items as $item) {
                 $bits += $item->estimateBitStreamSizeOfEntry($version);
             }
 
@@ -1547,7 +1547,7 @@  discard block
 block discarded – undo
             do {
                 $prev = $version;
                 $bits = $this->estimateBitStreamSize($prev);
-                $version = QRspec::getMinimumVersion((int)(($bits + 7) / 8), $this->level);
+                $version = QRspec::getMinimumVersion((int) (($bits + 7) / 8), $this->level);
                 if ($version < 0) {
                     return -1;
                 }
@@ -1560,32 +1560,32 @@  discard block
 block discarded – undo
         public static function lengthOfCode($mode, $version, $bits)
         {
             $payload = $bits - 4 - QRspec::lengthIndicator($mode, $version);
-            switch($mode) {
+            switch ($mode) {
                 case QR_MODE_NUM:
-                    $chunks = (int)($payload / 10);
+                    $chunks = (int) ($payload / 10);
                     $remain = $payload - $chunks * 10;
                     $size = $chunks * 3;
-                    if($remain >= 7) {
+                    if ($remain >= 7) {
                         $size += 2;
-                    } else if($remain >= 4) {
+                    } else if ($remain >= 4) {
                         $size += 1;
                     }
                     break;
                 case QR_MODE_AN:
-                    $chunks = (int)($payload / 11);
+                    $chunks = (int) ($payload / 11);
                     $remain = $payload - $chunks * 11;
                     $size = $chunks * 2;
-                    if($remain >= 6) 
+                    if ($remain >= 6) 
                         $size++;
                     break;
                 case QR_MODE_8:
-                    $size = (int)($payload / 8);
+                    $size = (int) ($payload / 8);
                     break;
                 case QR_MODE_KANJI:
-                    $size = (int)(($payload / 13) * 2);
+                    $size = (int) (($payload / 13) * 2);
                     break;
                 case QR_MODE_STRUCTURE:
-                    $size = (int)($payload / 8);
+                    $size = (int) ($payload / 8);
                     break;
                 default:
                     $size = 0;
@@ -1593,8 +1593,8 @@  discard block
 block discarded – undo
             }
             
             $maxsize = QRspec::maximumWords($mode, $version);
-            if($size < 0) $size = 0;
-            if($size > $maxsize) $size = $maxsize;
+            if ($size < 0) $size = 0;
+            if ($size > $maxsize) $size = $maxsize;
 
             return $size;
         }
@@ -1604,10 +1604,10 @@  discard block
 block discarded – undo
         {
             $total = 0;
 
-            foreach($this->items as $item) {
+            foreach ($this->items as $item) {
                 $bits = $item->encodeBitStream($this->version);
                 
-                if($bits < 0) 
+                if ($bits < 0) 
                     return -1;
                     
                 $total += $bits;
@@ -1620,21 +1620,21 @@  discard block
 block discarded – undo
         public function convertData()
         {
             $ver = $this->estimateVersion();
-            if($ver > $this->getVersion()) {
+            if ($ver > $this->getVersion()) {
                 $this->setVersion($ver);
             }
 
-            for(;;) {
+            for (;;) {
                 $bits = $this->createBitStream();
                 
-                if($bits < 0) 
+                if ($bits < 0) 
                     return -1;
                     
-                $ver = QRspec::getMinimumVersion((int)(($bits + 7) / 8), $this->level);
-                if($ver < 0) {
+                $ver = QRspec::getMinimumVersion((int) (($bits + 7) / 8), $this->level);
+                if ($ver < 0) {
                     throw new Exception('WRONG VERSION');
                     return -1;
-                } else if($ver > $this->getVersion()) {
+                } else if ($ver > $this->getVersion()) {
                     $this->setVersion($ver);
                 } else {
                     break;
@@ -1660,26 +1660,26 @@  discard block
 block discarded – undo
             }
 
             $bits += 4;
-            $words = (int)(($bits + 7) / 8);
+            $words = (int) (($bits + 7) / 8);
 
             $padding = new QRbitstream();
             $ret = $padding->appendNum($words * 8 - $bits + 4, 0);
             
-            if($ret < 0) 
+            if ($ret < 0) 
                 return $ret;
 
             $padlen = $maxwords - $words;
             
-            if($padlen > 0) {
+            if ($padlen > 0) {
                 
                 $padbuf = array();
-                for($i=0; $i<$padlen; $i++) {
-                    $padbuf[$i] = ($i&1)?0x11:0xec;
+                for ($i = 0; $i < $padlen; $i++) {
+                    $padbuf[$i] = ($i & 1) ? 0x11 : 0xec;
                 }
                 
                 $ret = $padding->appendBytes($padlen, $padbuf);
                 
-                if($ret < 0)
+                if ($ret < 0)
                     return $ret;
                 
             }
@@ -1692,15 +1692,15 @@  discard block
 block discarded – undo
         //----------------------------------------------------------------------
         public function mergeBitStream()
         {
-            if($this->convertData() < 0) {
+            if ($this->convertData() < 0) {
                 return null;
             }
 
             $bstream = new QRbitstream();
             
-            foreach($this->items as $item) {
+            foreach ($this->items as $item) {
                 $ret = $bstream->append($item->bstream);
-                if($ret < 0) {
+                if ($ret < 0) {
                     return null;
                 }
             }
@@ -1714,12 +1714,12 @@  discard block
 block discarded – undo
 
             $bstream = $this->mergeBitStream();
             
-            if($bstream == null) {
+            if ($bstream == null) {
                 return null;
             }
             
             $ret = $this->appendPaddingBit($bstream);
-            if($ret < 0) {
+            if ($ret < 0) {
                 return null;
             }
 
@@ -1730,7 +1730,7 @@  discard block
 block discarded – undo
         public function getByteStream()
         {
             $bstream = $this->getBitStream();
-            if($bstream == null) {
+            if ($bstream == null) {
                 return null;
             }
             
@@ -1798,8 +1798,8 @@  discard block
 block discarded – undo
             $bstream->allocate($bits);
             
             $mask = 1 << ($bits - 1);
-            for($i=0; $i<$bits; $i++) {
-                if($num & $mask) {
+            for ($i = 0; $i < $bits; $i++) {
+                if ($num & $mask) {
                     $bstream->data[$i] = 1;
                 } else {
                     $bstream->data[$i] = 0;
@@ -1815,12 +1815,12 @@  discard block
 block discarded – undo
         {
             $bstream = new QRbitstream();
             $bstream->allocate($size * 8);
-            $p=0;
+            $p = 0;
 
-            for($i=0; $i<$size; $i++) {
+            for ($i = 0; $i < $size; $i++) {
                 $mask = 0x80;
-                for($j=0; $j<8; $j++) {
-                    if($data[$i] & $mask) {
+                for ($j = 0; $j < 8; $j++) {
+                    if ($data[$i] & $mask) {
                         $bstream->data[$p] = 1;
                     } else {
                         $bstream->data[$p] = 0;
@@ -1840,11 +1840,11 @@  discard block
 block discarded – undo
                 return -1;
             }
             
-            if($arg->size() == 0) {
+            if ($arg->size() == 0) {
                 return 0;
             }
             
-            if($this->size() == 0) {
+            if ($this->size() == 0) {
                 $this->data = $arg->data;
                 return 0;
             }
@@ -1862,7 +1862,7 @@  discard block
 block discarded – undo
 
             $b = QRbitstream::newFromNum($bits, $num);
             
-            if(is_null($b))
+            if (is_null($b))
                 return -1;
 
             $ret = $this->append($b);
@@ -1879,7 +1879,7 @@  discard block
 block discarded – undo
 
             $b = QRbitstream::newFromBytes($size, $data);
             
-            if(is_null($b))
+            if (is_null($b))
                 return -1;
 
             $ret = $this->append($b);
@@ -1894,18 +1894,18 @@  discard block
 block discarded – undo
         
             $size = $this->size();
 
-            if($size == 0) {
+            if ($size == 0) {
                 return array();
             }
             
-            $data = array_fill(0, (int)(($size + 7) / 8), 0);
-            $bytes = (int)($size / 8);
+            $data = array_fill(0, (int) (($size + 7) / 8), 0);
+            $bytes = (int) ($size / 8);
 
             $p = 0;
             
-            for($i=0; $i<$bytes; $i++) {
+            for ($i = 0; $i < $bytes; $i++) {
                 $v = 0;
-                for($j=0; $j<8; $j++) {
+                for ($j = 0; $j < 8; $j++) {
                     $v = $v << 1;
                     $v |= $this->data[$p];
                     $p++;
@@ -1913,9 +1913,9 @@  discard block
 block discarded – undo
                 $data[$i] = $v;
             }
             
-            if($size & 7) {
+            if ($size & 7) {
                 $v = 0;
-                for($j=0; $j<($size & 7); $j++) {
+                for ($j = 0; $j < ($size & 7); $j++) {
                     $v = $v << 1;
                     $v |= $this->data[$p];
                     $p++;
@@ -1987,7 +1987,7 @@  discard block
 block discarded – undo
             if ($pos >= strlen($str))
                 return false;
             
-            return ((ord($str[$pos]) >= ord('0'))&&(ord($str[$pos]) <= ord('9')));
+            return ((ord($str[$pos]) >= ord('0')) && (ord($str[$pos]) <= ord('9')));
         }
         
         //----------------------------------------------------------------------
@@ -2007,17 +2007,17 @@  discard block
 block discarded – undo
                 
             $c = $this->dataStr[$pos];
             
-            if(self::isdigitat($this->dataStr, $pos)) {
+            if (self::isdigitat($this->dataStr, $pos)) {
                 return QR_MODE_NUM;
-            } else if(self::isalnumat($this->dataStr, $pos)) {
+            } else if (self::isalnumat($this->dataStr, $pos)) {
                 return QR_MODE_AN;
-            } else if($this->modeHint == QR_MODE_KANJI) {
+            } else if ($this->modeHint == QR_MODE_KANJI) {
             
-                if ($pos+1 < strlen($this->dataStr)) 
+                if ($pos + 1 < strlen($this->dataStr)) 
                 {
-                    $d = $this->dataStr[$pos+1];
+                    $d = $this->dataStr[$pos + 1];
                     $word = (ord($c) << 8) | ord($d);
-                    if(($word >= 0x8140 && $word <= 0x9ffc) || ($word >= 0xe040 && $word <= 0xebbf)) {
+                    if (($word >= 0x8140 && $word <= 0x9ffc) || ($word >= 0xe040 && $word <= 0xebbf)) {
                         return QR_MODE_KANJI;
                     }
                 }
@@ -2032,32 +2032,32 @@  discard block
 block discarded – undo
             $ln = QRspec::lengthIndicator(QR_MODE_NUM, $this->input->getVersion());
 
             $p = 0;
-            while(self::isdigitat($this->dataStr, $p)) {
+            while (self::isdigitat($this->dataStr, $p)) {
                 $p++;
             }
             
             $run = $p;
             $mode = $this->identifyMode($p);
             
-            if($mode == QR_MODE_8) {
+            if ($mode == QR_MODE_8) {
                 $dif = QRinput::estimateBitsModeNum($run) + 4 + $ln
                      + QRinput::estimateBitsMode8(1)         // + 4 + l8
                      - QRinput::estimateBitsMode8($run + 1); // - 4 - l8
-                if($dif > 0) {
+                if ($dif > 0) {
                     return $this->eat8();
                 }
             }
-            if($mode == QR_MODE_AN) {
+            if ($mode == QR_MODE_AN) {
                 $dif = QRinput::estimateBitsModeNum($run) + 4 + $ln
                      + QRinput::estimateBitsModeAn(1)        // + 4 + la
-                     - QRinput::estimateBitsModeAn($run + 1);// - 4 - la
-                if($dif > 0) {
+                     - QRinput::estimateBitsModeAn($run + 1); // - 4 - la
+                if ($dif > 0) {
                     return $this->eatAn();
                 }
             }
             
             $ret = $this->input->append(QR_MODE_NUM, $run, str_split($this->dataStr));
-            if($ret < 0)
+            if ($ret < 0)
                 return -1;
 
             return $run;
@@ -2066,15 +2066,15 @@  discard block
 block discarded – undo
         //----------------------------------------------------------------------
         public function eatAn()
         {
-            $la = QRspec::lengthIndicator(QR_MODE_AN,  $this->input->getVersion());
+            $la = QRspec::lengthIndicator(QR_MODE_AN, $this->input->getVersion());
             $ln = QRspec::lengthIndicator(QR_MODE_NUM, $this->input->getVersion());
 
             $p = 0;
             
-            while(self::isalnumat($this->dataStr, $p)) {
-                if(self::isdigitat($this->dataStr, $p)) {
+            while (self::isalnumat($this->dataStr, $p)) {
+                if (self::isdigitat($this->dataStr, $p)) {
                     $q = $p;
-                    while(self::isdigitat($this->dataStr, $q)) {
+                    while (self::isdigitat($this->dataStr, $q)) {
                         $q++;
                     }
                     
@@ -2082,7 +2082,7 @@  discard block
 block discarded – undo
                          + QRinput::estimateBitsModeNum($q - $p) + 4 + $ln
                          - QRinput::estimateBitsModeAn($q); // - 4 - la
                          
-                    if($dif < 0) {
+                    if ($dif < 0) {
                         break;
                     } else {
                         $p = $q;
@@ -2094,17 +2094,17 @@  discard block
 block discarded – undo
 
             $run = $p;
 
-            if(!self::isalnumat($this->dataStr, $p)) {
+            if (!self::isalnumat($this->dataStr, $p)) {
                 $dif = QRinput::estimateBitsModeAn($run) + 4 + $la
                      + QRinput::estimateBitsMode8(1) // + 4 + l8
                       - QRinput::estimateBitsMode8($run + 1); // - 4 - l8
-                if($dif > 0) {
+                if ($dif > 0) {
                     return $this->eat8();
                 }
             }
 
             $ret = $this->input->append(QR_MODE_AN, $run, str_split($this->dataStr));
-            if($ret < 0)
+            if ($ret < 0)
                 return -1;
 
             return $run;
@@ -2115,12 +2115,12 @@  discard block
 block discarded – undo
         {
             $p = 0;
             
-            while($this->identifyMode($p) == QR_MODE_KANJI) {
+            while ($this->identifyMode($p) == QR_MODE_KANJI) {
                 $p += 2;
             }
             
             $ret = $this->input->append(QR_MODE_KANJI, $p, str_split($this->dataStr));
-            if($ret < 0)
+            if ($ret < 0)
                 return -1;
 
             return $run;
@@ -2135,34 +2135,34 @@  discard block
 block discarded – undo
             $p = 1;
             $dataStrLen = strlen($this->dataStr);
             
-            while($p < $dataStrLen) {
+            while ($p < $dataStrLen) {
                 
                 $mode = $this->identifyMode($p);
-                if($mode == QR_MODE_KANJI) {
+                if ($mode == QR_MODE_KANJI) {
                     break;
                 }
-                if($mode == QR_MODE_NUM) {
+                if ($mode == QR_MODE_NUM) {
                     $q = $p;
-                    while(self::isdigitat($this->dataStr, $q)) {
+                    while (self::isdigitat($this->dataStr, $q)) {
                         $q++;
                     }
                     $dif = QRinput::estimateBitsMode8($p) // + 4 + l8
                          + QRinput::estimateBitsModeNum($q - $p) + 4 + $ln
                          - QRinput::estimateBitsMode8($q); // - 4 - l8
-                    if($dif < 0) {
+                    if ($dif < 0) {
                         break;
                     } else {
                         $p = $q;
                     }
-                } else if($mode == QR_MODE_AN) {
+                } else if ($mode == QR_MODE_AN) {
                     $q = $p;
-                    while(self::isalnumat($this->dataStr, $q)) {
+                    while (self::isalnumat($this->dataStr, $q)) {
                         $q++;
                     }
                     $dif = QRinput::estimateBitsMode8($p)  // + 4 + l8
                          + QRinput::estimateBitsModeAn($q - $p) + 4 + $la
                          - QRinput::estimateBitsMode8($q); // - 4 - l8
-                    if($dif < 0) {
+                    if ($dif < 0) {
                         break;
                     } else {
                         $p = $q;
@@ -2175,7 +2175,7 @@  discard block
 block discarded – undo
             $run = $p;
             $ret = $this->input->append(QR_MODE_8, $run, str_split($this->dataStr));
             
-            if($ret < 0)
+            if ($ret < 0)
                 return -1;
 
             return $run;
@@ -2186,7 +2186,7 @@  discard block
 block discarded – undo
         {
             while (strlen($this->dataStr) > 0)
             {
-                if($this->dataStr == '')
+                if ($this->dataStr == '')
                     return 0;
 
                 $mode = $this->identifyMode(0);
@@ -2203,8 +2203,8 @@  discard block
 block discarded – undo
                 
                 }
 
-                if($length == 0) return 0;
-                if($length < 0)  return -1;
+                if ($length == 0) return 0;
+                if ($length < 0)  return -1;
                 
                 $this->dataStr = substr($this->dataStr, $length);
             }
@@ -2216,9 +2216,9 @@  discard block
 block discarded – undo
             $stringLen = strlen($this->dataStr);
             $p = 0;
             
-            while ($p<$stringLen) {
+            while ($p < $stringLen) {
                 $mode = self::identifyMode(substr($this->dataStr, $p));
-                if($mode == QR_MODE_KANJI) {
+                if ($mode == QR_MODE_KANJI) {
                     $p += 2;
                 } else {
                     if (ord($this->dataStr[$p]) >= ord('a') && ord($this->dataStr[$p]) <= ord('z')) {
@@ -2234,13 +2234,13 @@  discard block
 block discarded – undo
         //----------------------------------------------------------------------
         public static function splitStringToQRinput($string, QRinput $input, $modeHint, $casesensitive = true)
         {
-            if(is_null($string) || $string == '\0' || $string == '') {
+            if (is_null($string) || $string == '\0' || $string == '') {
                 throw new Exception('empty string!!!');
             }
 
             $split = new QRsplit($string, $input, $modeHint);
             
-            if(!$casesensitive)
+            if (!$casesensitive)
                 $split->toUpper();
                 
             return $split->splitString();
@@ -2285,16 +2285,16 @@  discard block
 block discarded – undo
  
     class QRrsItem {
     
-        public $mm;                  // Bits per symbol 
-        public $nn;                  // Symbols per block (= (1<<mm)-1) 
-        public $alpha_to = array();  // log lookup table 
-        public $index_of = array();  // Antilog lookup table 
-        public $genpoly = array();   // Generator polynomial 
-        public $nroots;              // Number of generator roots = number of parity symbols 
-        public $fcr;                 // First consecutive root, index form 
-        public $prim;                // Primitive element, index form 
-        public $iprim;               // prim-th root of 1, index form 
-        public $pad;                 // Padding bytes in shortened block 
+        public $mm; // Bits per symbol 
+        public $nn; // Symbols per block (= (1<<mm)-1) 
+        public $alpha_to = array(); // log lookup table 
+        public $index_of = array(); // Antilog lookup table 
+        public $genpoly = array(); // Generator polynomial 
+        public $nroots; // Number of generator roots = number of parity symbols 
+        public $fcr; // First consecutive root, index form 
+        public $prim; // Primitive element, index form 
+        public $iprim; // prim-th root of 1, index form 
+        public $pad; // Padding bytes in shortened block 
         public $gfpoly;
     
         //----------------------------------------------------------------------
@@ -2318,47 +2318,47 @@  discard block
 block discarded – undo
             $rs = null;
             
             // Check parameter ranges
-            if($symsize < 0 || $symsize > 8)                     return $rs;
-            if($fcr < 0 || $fcr >= (1<<$symsize))                return $rs;
-            if($prim <= 0 || $prim >= (1<<$symsize))             return $rs;
-            if($nroots < 0 || $nroots >= (1<<$symsize))          return $rs; // Can't have more roots than symbol values!
-            if($pad < 0 || $pad >= ((1<<$symsize) -1 - $nroots)) return $rs; // Too much padding
+            if ($symsize < 0 || $symsize > 8)                     return $rs;
+            if ($fcr < 0 || $fcr >= (1 << $symsize))                return $rs;
+            if ($prim <= 0 || $prim >= (1 << $symsize))             return $rs;
+            if ($nroots < 0 || $nroots >= (1 << $symsize))          return $rs; // Can't have more roots than symbol values!
+            if ($pad < 0 || $pad >= ((1 << $symsize) - 1 - $nroots)) return $rs; // Too much padding
 
             $rs = new QRrsItem();
             $rs->mm = $symsize;
-            $rs->nn = (1<<$symsize)-1;
+            $rs->nn = (1 << $symsize) - 1;
             $rs->pad = $pad;
 
-            $rs->alpha_to = array_fill(0, $rs->nn+1, 0);
-            $rs->index_of = array_fill(0, $rs->nn+1, 0);
+            $rs->alpha_to = array_fill(0, $rs->nn + 1, 0);
+            $rs->index_of = array_fill(0, $rs->nn + 1, 0);
           
             // PHP style macro replacement ;)
-            $NN =& $rs->nn;
-            $A0 =& $NN;
+            $NN = & $rs->nn;
+            $A0 = & $NN;
             
             // Generate Galois field lookup tables
             $rs->index_of[0] = $A0; // log(zero) = -inf
             $rs->alpha_to[$A0] = 0; // alpha**-inf = 0
             $sr = 1;
           
-            for($i=0; $i<$rs->nn; $i++) {
+            for ($i = 0; $i < $rs->nn; $i++) {
                 $rs->index_of[$sr] = $i;
                 $rs->alpha_to[$i] = $sr;
                 $sr <<= 1;
-                if($sr & (1<<$symsize)) {
+                if ($sr & (1 << $symsize)) {
                     $sr ^= $gfpoly;
                 }
                 $sr &= $rs->nn;
             }
             
-            if($sr != 1){
+            if ($sr != 1) {
                 // field generator polynomial is not primitive!
                 $rs = NULL;
                 return $rs;
             }
 
             /* Form RS code generator polynomial from its roots */
-            $rs->genpoly = array_fill(0, $nroots+1, 0);
+            $rs->genpoly = array_fill(0, $nroots + 1, 0);
         
             $rs->fcr = $fcr;
             $rs->prim = $prim;
@@ -2366,21 +2366,21 @@  discard block
 block discarded – undo
             $rs->gfpoly = $gfpoly;
 
             /* Find prim-th root of 1, used in decoding */
-            for($iprim=1;($iprim % $prim) != 0;$iprim += $rs->nn)
+            for ($iprim = 1; ($iprim % $prim) != 0; $iprim += $rs->nn)
             ; // intentional empty-body loop!
             
-            $rs->iprim = (int)($iprim / $prim);
+            $rs->iprim = (int) ($iprim / $prim);
             $rs->genpoly[0] = 1;
             
-            for ($i = 0,$root=$fcr*$prim; $i < $nroots; $i++, $root += $prim) {
-                $rs->genpoly[$i+1] = 1;
+            for ($i = 0, $root = $fcr * $prim; $i < $nroots; $i++, $root += $prim) {
+                $rs->genpoly[$i + 1] = 1;
 
                 // Multiply rs->genpoly[] by  @**(root + x)
                 for ($j = $i; $j > 0; $j--) {
                     if ($rs->genpoly[$j] != 0) {
-                        $rs->genpoly[$j] = $rs->genpoly[$j-1] ^ $rs->alpha_to[$rs->modnn($rs->index_of[$rs->genpoly[$j]] + $root)];
+                        $rs->genpoly[$j] = $rs->genpoly[$j - 1] ^ $rs->alpha_to[$rs->modnn($rs->index_of[$rs->genpoly[$j]] + $root)];
                     } else {
-                        $rs->genpoly[$j] = $rs->genpoly[$j-1];
+                        $rs->genpoly[$j] = $rs->genpoly[$j - 1];
                     }
                 }
                 // rs->genpoly[0] can never be zero
@@ -2397,38 +2397,38 @@  discard block
 block discarded – undo
         //----------------------------------------------------------------------
         public function encode_rs_char($data, &$parity)
         {
-            $MM       =& $this->mm;
-            $NN       =& $this->nn;
-            $ALPHA_TO =& $this->alpha_to;
-            $INDEX_OF =& $this->index_of;
-            $GENPOLY  =& $this->genpoly;
-            $NROOTS   =& $this->nroots;
-            $FCR      =& $this->fcr;
-            $PRIM     =& $this->prim;
-            $IPRIM    =& $this->iprim;
-            $PAD      =& $this->pad;
-            $A0       =& $NN;
+            $MM       = & $this->mm;
+            $NN       = & $this->nn;
+            $ALPHA_TO = & $this->alpha_to;
+            $INDEX_OF = & $this->index_of;
+            $GENPOLY  = & $this->genpoly;
+            $NROOTS   = & $this->nroots;
+            $FCR      = & $this->fcr;
+            $PRIM     = & $this->prim;
+            $IPRIM    = & $this->iprim;
+            $PAD      = & $this->pad;
+            $A0       = & $NN;
 
             $parity = array_fill(0, $NROOTS, 0);
 
-            for($i=0; $i< ($NN-$NROOTS-$PAD); $i++) {
+            for ($i = 0; $i < ($NN - $NROOTS - $PAD); $i++) {
                 
                 $feedback = $INDEX_OF[$data[$i] ^ $parity[0]];
-                if($feedback != $A0) {      
+                if ($feedback != $A0) {      
                     // feedback term is non-zero
             
                     // This line is unnecessary when GENPOLY[NROOTS] is unity, as it must
                     // always be for the polynomials constructed by init_rs()
                     $feedback = $this->modnn($NN - $GENPOLY[$NROOTS] + $feedback);
             
-                    for($j=1;$j<$NROOTS;$j++) {
-                        $parity[$j] ^= $ALPHA_TO[$this->modnn($feedback + $GENPOLY[$NROOTS-$j])];
+                    for ($j = 1; $j < $NROOTS; $j++) {
+                        $parity[$j] ^= $ALPHA_TO[$this->modnn($feedback + $GENPOLY[$NROOTS - $j])];
                     }
                 }
                 
                 // Shift 
                 array_shift($parity);
-                if($feedback != $A0) {
+                if ($feedback != $A0) {
                     array_push($parity, $ALPHA_TO[$this->modnn($feedback + $GENPOLY[0])]);
                 } else {
                     array_push($parity, 0);
@@ -2446,13 +2446,13 @@  discard block
 block discarded – undo
         //----------------------------------------------------------------------
         public static function init_rs($symsize, $gfpoly, $fcr, $prim, $nroots, $pad)
         {
-            foreach(self::$items as $rs) {
-                if($rs->pad != $pad)       continue;
-                if($rs->nroots != $nroots) continue;
-                if($rs->mm != $symsize)    continue;
-                if($rs->gfpoly != $gfpoly) continue;
-                if($rs->fcr != $fcr)       continue;
-                if($rs->prim != $prim)     continue;
+            foreach (self::$items as $rs) {
+                if ($rs->pad != $pad)       continue;
+                if ($rs->nroots != $nroots) continue;
+                if ($rs->mm != $symsize)    continue;
+                if ($rs->gfpoly != $gfpoly) continue;
+                if ($rs->fcr != $fcr)       continue;
+                if ($rs->prim != $prim)     continue;
 
                 return $rs;
             }
@@ -2516,10 +2516,10 @@  discard block
 block discarded – undo
         public function writeFormatInformation($width, &$frame, $mask, $level)
         {
             $blacks = 0;
-            $format =  QRspec::getFormatInfo($mask, $level);
+            $format = QRspec::getFormatInfo($mask, $level);
 
-            for($i=0; $i<8; $i++) {
-                if($format & 1) {
+            for ($i = 0; $i < 8; $i++) {
+                if ($format & 1) {
                     $blacks += 2;
                     $v = 0x85;
                 } else {
@@ -2527,7 +2527,7 @@  discard block
 block discarded – undo
                 }
                 
                 $frame[8][$width - 1 - $i] = chr($v);
-                if($i < 6) {
+                if ($i < 6) {
                     $frame[$i][8] = chr($v);
                 } else {
                     $frame[$i + 1][8] = chr($v);
@@ -2535,8 +2535,8 @@  discard block
 block discarded – undo
                 $format = $format >> 1;
             }
             
-            for($i=0; $i<7; $i++) {
-                if($format & 1) {
+            for ($i = 0; $i < 7; $i++) {
+                if ($format & 1) {
                     $blacks += 2;
                     $v = 0x85;
                 } else {
@@ -2544,7 +2544,7 @@  discard block
 block discarded – undo
                 }
                 
                 $frame[$width - 7 + $i][8] = chr($v);
-                if($i == 0) {
+                if ($i == 0) {
                     $frame[8][7] = chr($v);
                 } else {
                     $frame[8][6 - $i] = chr($v);
@@ -2557,27 +2557,27 @@  discard block
 block discarded – undo
         }
         
         //----------------------------------------------------------------------
-        public function mask0($x, $y) { return ($x+$y)&1;                       }
-        public function mask1($x, $y) { return ($y&1);                          }
-        public function mask2($x, $y) { return ($x%3);                          }
-        public function mask3($x, $y) { return ($x+$y)%3;                       }
-        public function mask4($x, $y) { return (((int)($y/2))+((int)($x/3)))&1; }
-        public function mask5($x, $y) { return (($x*$y)&1)+($x*$y)%3;           }
-        public function mask6($x, $y) { return ((($x*$y)&1)+($x*$y)%3)&1;       }
-        public function mask7($x, $y) { return ((($x*$y)%3)+(($x+$y)&1))&1;     }
+        public function mask0($x, $y) { return ($x + $y) & 1; }
+        public function mask1($x, $y) { return ($y & 1); }
+        public function mask2($x, $y) { return ($x % 3); }
+        public function mask3($x, $y) { return ($x + $y) % 3; }
+        public function mask4($x, $y) { return (((int) ($y / 2)) + ((int) ($x / 3))) & 1; }
+        public function mask5($x, $y) { return (($x * $y) & 1) + ($x * $y) % 3; }
+        public function mask6($x, $y) { return ((($x * $y) & 1) + ($x * $y) % 3) & 1; }
+        public function mask7($x, $y) { return ((($x * $y) % 3) + (($x + $y) & 1)) & 1; }
         
         //----------------------------------------------------------------------
         private function generateMaskNo($maskNo, $width, $frame)
         {
             $bitMask = array_fill(0, $width, array_fill(0, $width, 0));
             
-            for($y=0; $y<$width; $y++) {
-                for($x=0; $x<$width; $x++) {
-                    if(ord($frame[$y][$x]) & 0x80) {
+            for ($y = 0; $y < $width; $y++) {
+                for ($x = 0; $x < $width; $x++) {
+                    if (ord($frame[$y][$x]) & 0x80) {
                         $bitMask[$y][$x] = 0;
                     } else {
                         $maskFunc = call_user_func(array($this, 'mask'.$maskNo), $x, $y);
-                        $bitMask[$y][$x] = ($maskFunc == 0)?1:0;
+                        $bitMask[$y][$x] = ($maskFunc == 0) ? 1 : 0;
                     }
                     
                 }
@@ -2635,12 +2635,12 @@  discard block
 block discarded – undo
                 
             $d = $s;
 
-            for($y=0; $y<$width; $y++) {
-                for($x=0; $x<$width; $x++) {
-                    if($bitMask[$y][$x] == 1) {
-                        $d[$y][$x] = chr(ord($s[$y][$x]) ^ (int)$bitMask[$y][$x]);
+            for ($y = 0; $y < $width; $y++) {
+                for ($x = 0; $x < $width; $x++) {
+                    if ($bitMask[$y][$x] == 1) {
+                        $d[$y][$x] = chr(ord($s[$y][$x]) ^ (int) $bitMask[$y][$x]);
                     }
-                    $b += (int)(ord($d[$y][$x]) & 1);
+                    $b += (int) (ord($d[$y][$x]) & 1);
                 }
             }
 
@@ -2662,21 +2662,21 @@  discard block
 block discarded – undo
         {
             $demerit = 0;
 
-            for($i=0; $i<$length; $i++) {
+            for ($i = 0; $i < $length; $i++) {
                 
-                if($this->runLength[$i] >= 5) {
+                if ($this->runLength[$i] >= 5) {
                     $demerit += (N1 + ($this->runLength[$i] - 5));
                 }
-                if($i & 1) {
-                    if(($i >= 3) && ($i < ($length-2)) && ($this->runLength[$i] % 3 == 0)) {
-                        $fact = (int)($this->runLength[$i] / 3);
-                        if(($this->runLength[$i-2] == $fact) &&
-                           ($this->runLength[$i-1] == $fact) &&
-                           ($this->runLength[$i+1] == $fact) &&
-                           ($this->runLength[$i+2] == $fact)) {
-                            if(($this->runLength[$i-3] < 0) || ($this->runLength[$i-3] >= (4 * $fact))) {
+                if ($i & 1) {
+                    if (($i >= 3) && ($i < ($length - 2)) && ($this->runLength[$i] % 3 == 0)) {
+                        $fact = (int) ($this->runLength[$i] / 3);
+                        if (($this->runLength[$i - 2] == $fact) &&
+                           ($this->runLength[$i - 1] == $fact) &&
+                           ($this->runLength[$i + 1] == $fact) &&
+                           ($this->runLength[$i + 2] == $fact)) {
+                            if (($this->runLength[$i - 3] < 0) || ($this->runLength[$i - 3] >= (4 * $fact))) {
                                 $demerit += N3;
-                            } else if((($i+3) >= $length) || ($this->runLength[$i+3] >= (4 * $fact))) {
+                            } else if ((($i + 3) >= $length) || ($this->runLength[$i + 3] >= (4 * $fact))) {
                                 $demerit += N3;
                             }
                         }
@@ -2692,30 +2692,30 @@  discard block
 block discarded – undo
             $head = 0;
             $demerit = 0;
 
-            for($y=0; $y<$width; $y++) {
+            for ($y = 0; $y < $width; $y++) {
                 $head = 0;
                 $this->runLength[0] = 1;
                 
                 $frameY = $frame[$y];
                 
-                if ($y>0)
-                    $frameYM = $frame[$y-1];
+                if ($y > 0)
+                    $frameYM = $frame[$y - 1];
                 
-                for($x=0; $x<$width; $x++) {
-                    if(($x > 0) && ($y > 0)) {
-                        $b22 = ord($frameY[$x]) & ord($frameY[$x-1]) & ord($frameYM[$x]) & ord($frameYM[$x-1]);
-                        $w22 = ord($frameY[$x]) | ord($frameY[$x-1]) | ord($frameYM[$x]) | ord($frameYM[$x-1]);
+                for ($x = 0; $x < $width; $x++) {
+                    if (($x > 0) && ($y > 0)) {
+                        $b22 = ord($frameY[$x]) & ord($frameY[$x - 1]) & ord($frameYM[$x]) & ord($frameYM[$x - 1]);
+                        $w22 = ord($frameY[$x]) | ord($frameY[$x - 1]) | ord($frameYM[$x]) | ord($frameYM[$x - 1]);
                         
-                        if(($b22 | ($w22 ^ 1))&1) {                                                                     
+                        if (($b22 | ($w22 ^ 1)) & 1) {                                                                     
                             $demerit += N2;
                         }
                     }
-                    if(($x == 0) && (ord($frameY[$x]) & 1)) {
+                    if (($x == 0) && (ord($frameY[$x]) & 1)) {
                         $this->runLength[0] = -1;
                         $head = 1;
                         $this->runLength[$head] = 1;
-                    } else if($x > 0) {
-                        if((ord($frameY[$x]) ^ ord($frameY[$x-1])) & 1) {
+                    } else if ($x > 0) {
+                        if ((ord($frameY[$x]) ^ ord($frameY[$x - 1])) & 1) {
                             $head++;
                             $this->runLength[$head] = 1;
                         } else {
@@ -2724,20 +2724,20 @@  discard block
 block discarded – undo
                     }
                 }
     
-                $demerit += $this->calcN1N3($head+1);
+                $demerit += $this->calcN1N3($head + 1);
             }
 
-            for($x=0; $x<$width; $x++) {
+            for ($x = 0; $x < $width; $x++) {
                 $head = 0;
                 $this->runLength[0] = 1;
                 
-                for($y=0; $y<$width; $y++) {
-                    if($y == 0 && (ord($frame[$y][$x]) & 1)) {
+                for ($y = 0; $y < $width; $y++) {
+                    if ($y == 0 && (ord($frame[$y][$x]) & 1)) {
                         $this->runLength[0] = -1;
                         $head = 1;
                         $this->runLength[$head] = 1;
-                    } else if($y > 0) {
-                        if((ord($frame[$y][$x]) ^ ord($frame[$y-1][$x])) & 1) {
+                    } else if ($y > 0) {
+                        if ((ord($frame[$y][$x]) ^ ord($frame[$y - 1][$x])) & 1) {
                             $head++;
                             $this->runLength[$head] = 1;
                         } else {
@@ -2746,7 +2746,7 @@  discard block
 block discarded – undo
                     }
                 }
             
-                $demerit += $this->calcN1N3($head+1);
+                $demerit += $this->calcN1N3($head + 1);
             }
 
             return $demerit;
@@ -2760,13 +2760,13 @@  discard block
 block discarded – undo
             $bestMaskNum = 0;
             $bestMask = array();
             
-            $checked_masks = array(0,1,2,3,4,5,6,7);
+            $checked_masks = array(0, 1, 2, 3, 4, 5, 6, 7);
             
             if (QR_FIND_FROM_RANDOM !== false) {
             
-                $howManuOut = 8-(QR_FIND_FROM_RANDOM % 9);
-                for ($i = 0; $i <  $howManuOut; $i++) {
-                    $remPos = rand (0, count($checked_masks)-1);
+                $howManuOut = 8 - (QR_FIND_FROM_RANDOM % 9);
+                for ($i = 0; $i < $howManuOut; $i++) {
+                    $remPos = rand(0, count($checked_masks) - 1);
                     unset($checked_masks[$remPos]);
                     $checked_masks = array_values($checked_masks);
                 }
@@ -2775,18 +2775,18 @@  discard block
 block discarded – undo
             
             $bestMask = $frame;
              
-            foreach($checked_masks as $i) {
+            foreach ($checked_masks as $i) {
                 $mask = array_fill(0, $width, str_repeat("\0", $width));
 
                 $demerit = 0;
                 $blacks = 0;
                 $blacks  = $this->makeMaskNo($i, $width, $frame, $mask);
                 $blacks += $this->writeFormatInformation($width, $mask, $i, $level);
-                $blacks  = (int)(100 * $blacks / ($width * $width));
-                $demerit = (int)((int)(abs($blacks - 50) / 5) * N4);
+                $blacks  = (int) (100 * $blacks / ($width * $width));
+                $demerit = (int) ((int) (abs($blacks - 50) / 5) * N4);
                 $demerit += $this->evaluateSymbol($width, $mask);
                 
-                if($demerit < $minDemerit) {
+                if ($demerit < $minDemerit) {
                     $minDemerit = $demerit;
                     $bestMask = $mask;
                     $bestMaskNum = $i;
@@ -2866,10 +2866,10 @@  discard block
 block discarded – undo
         //----------------------------------------------------------------------
         public function __construct(QRinput $input)
         {
-            $spec = array(0,0,0,0,0);
+            $spec = array(0, 0, 0, 0, 0);
             
             $this->datacode = $input->getByteStream();
-            if(is_null($this->datacode)) {
+            if (is_null($this->datacode)) {
                 throw new Exception('null imput string');
             }
 
@@ -2883,7 +2883,7 @@  discard block
 block discarded – undo
             $this->blocks = QRspec::rsBlockNum($spec);
             
             $ret = $this->init($spec);
-            if($ret < 0) {
+            if ($ret < 0) {
                 throw new Exception('block alloc error');
                 return null;
             }
@@ -2902,29 +2902,29 @@  discard block
 block discarded – undo
             $blockNo = 0;
             $dataPos = 0;
             $eccPos = 0;
-            for($i=0; $i<QRspec::rsBlockNum1($spec); $i++) {
-                $ecc = array_slice($this->ecccode,$eccPos);
-                $this->rsblocks[$blockNo] = new QRrsblock($dl, array_slice($this->datacode, $dataPos), $el,  $ecc, $rs);
-                $this->ecccode = array_merge(array_slice($this->ecccode,0, $eccPos), $ecc);
+            for ($i = 0; $i < QRspec::rsBlockNum1($spec); $i++) {
+                $ecc = array_slice($this->ecccode, $eccPos);
+                $this->rsblocks[$blockNo] = new QRrsblock($dl, array_slice($this->datacode, $dataPos), $el, $ecc, $rs);
+                $this->ecccode = array_merge(array_slice($this->ecccode, 0, $eccPos), $ecc);
                 
                 $dataPos += $dl;
                 $eccPos += $el;
                 $blockNo++;
             }
 
-            if(QRspec::rsBlockNum2($spec) == 0)
+            if (QRspec::rsBlockNum2($spec) == 0)
                 return 0;
 
             $dl = QRspec::rsDataCodes2($spec);
             $el = QRspec::rsEccCodes2($spec);
             $rs = QRrs::init_rs(8, 0x11d, 0, 1, $el, 255 - $dl - $el);
             
-            if($rs == NULL) return -1;
+            if ($rs == NULL) return -1;
             
-            for($i=0; $i<QRspec::rsBlockNum2($spec); $i++) {
-                $ecc = array_slice($this->ecccode,$eccPos);
+            for ($i = 0; $i < QRspec::rsBlockNum2($spec); $i++) {
+                $ecc = array_slice($this->ecccode, $eccPos);
                 $this->rsblocks[$blockNo] = new QRrsblock($dl, array_slice($this->datacode, $dataPos), $el, $ecc, $rs);
-                $this->ecccode = array_merge(array_slice($this->ecccode,0, $eccPos), $ecc);
+                $this->ecccode = array_merge(array_slice($this->ecccode, 0, $eccPos), $ecc);
                 
                 $dataPos += $dl;
                 $eccPos += $el;
@@ -2939,14 +2939,14 @@  discard block
 block discarded – undo
         {
             $ret = 0;
 
-            if($this->count < $this->dataLength) {
+            if ($this->count < $this->dataLength) {
                 $row = $this->count % $this->blocks;
                 $col = $this->count / $this->blocks;
-                if($col >= $this->rsblocks[0]->dataLength) {
+                if ($col >= $this->rsblocks[0]->dataLength) {
                     $row += $this->b1;
                 }
                 $ret = $this->rsblocks[$row]->data[$col];
-            } else if($this->count < $this->dataLength + $this->eccLength) {
+            } else if ($this->count < $this->dataLength + $this->eccLength) {
                 $row = ($this->count - $this->dataLength) % $this->blocks;
                 $col = ($this->count - $this->dataLength) / $this->blocks;
                 $ret = $this->rsblocks[$row]->ecc[$col];
@@ -2970,10 +2970,10 @@  discard block
 block discarded – undo
         //----------------------------------------------------------------------
         public function encodeMask(QRinput $input, $mask)
         {
-            if($input->getVersion() < 0 || $input->getVersion() > QRSPEC_VERSION_MAX) {
+            if ($input->getVersion() < 0 || $input->getVersion() > QRSPEC_VERSION_MAX) {
                 throw new Exception('wrong version');
             }
-            if($input->getErrorCorrectionLevel() > QR_ECLEVEL_H) {
+            if ($input->getErrorCorrectionLevel() > QR_ECLEVEL_H) {
                 throw new Exception('wrong level');
             }
 
@@ -2986,15 +2986,15 @@  discard block
 block discarded – undo
             $frame = QRspec::newFrame($version);
             
             $filler = new FrameFiller($width, $frame);
-            if(is_null($filler)) {
+            if (is_null($filler)) {
                 return NULL;
             }
 
             // inteleaved data and ecc codes
-            for($i=0; $i<$raw->dataLength + $raw->eccLength; $i++) {
+            for ($i = 0; $i < $raw->dataLength + $raw->eccLength; $i++) {
                 $code = $raw->getCode();
                 $bit = 0x80;
-                for($j=0; $j<8; $j++) {
+                for ($j = 0; $j < 8; $j++) {
                     $addr = $filler->next();
                     $filler->setFrameAt($addr, 0x02 | (($bit & $code) != 0));
                     $bit = $bit >> 1;
@@ -3007,7 +3007,7 @@  discard block
 block discarded – undo
             
             // remainder bits
             $j = QRspec::getRemainder($version);
-            for($i=0; $i<$j; $i++) {
+            for ($i = 0; $i < $j; $i++) {
                 $addr = $filler->next();
                 $filler->setFrameAt($addr, 0x02);
             }
@@ -3018,7 +3018,7 @@  discard block
 block discarded – undo
             
             // masking
             $maskObj = new QRmask();
-            if($mask < 0) {
+            if ($mask < 0) {
             
                 if (QR_FIND_BEST_MASK) {
                     $masked = $maskObj->mask($width, $frame, $input->getErrorCorrectionLevel());
@@ -3029,7 +3029,7 @@  discard block
 block discarded – undo
                 $masked = $maskObj->makeMask($width, $frame, $mask, $input->getErrorCorrectionLevel());
             }
             
-            if($masked == NULL) {
+            if ($masked == NULL) {
                 return NULL;
             }
             
@@ -3051,16 +3051,16 @@  discard block
 block discarded – undo
         //----------------------------------------------------------------------
         public function encodeString8bit($string, $version, $level)
         {
-            if(string == NULL) {
+            if (string == NULL) {
                 throw new Exception('empty string!');
                 return NULL;
             }
 
             $input = new QRinput($version, $level);
-            if($input == NULL) return NULL;
+            if ($input == NULL) return NULL;
 
             $ret = $input->append(QR_MODE_8, strlen($string), str_split($string));
-            if($ret < 0) {
+            if ($ret < 0) {
                 unset($input);
                 return NULL;
             }
@@ -3071,16 +3071,16 @@  discard block
 block discarded – undo
         public function encodeString($string, $version, $level, $hint, $casesensitive)
         {
 
-            if($hint != QR_MODE_8 && $hint != QR_MODE_KANJI) {
+            if ($hint != QR_MODE_8 && $hint != QR_MODE_KANJI) {
                 throw new Exception('bad hint');
                 return NULL;
             }
 
             $input = new QRinput($version, $level);
-            if($input == NULL) return NULL;
+            if ($input == NULL) return NULL;
 
             $ret = QRsplit::splitStringToQRinput($string, $input, $hint, $casesensitive);
-            if($ret < 0) {
+            if ($ret < 0) {
                 return NULL;
             }
 
@@ -3088,10 +3088,10 @@  discard block
 block discarded – undo
         }
         
         //----------------------------------------------------------------------
-        public static function png($text, $outfile = false, $level = QR_ECLEVEL_L, $size = 3, $margin = 4, $saveandprint=false) 
+        public static function png($text, $outfile = false, $level = QR_ECLEVEL_L, $size = 3, $margin = 4, $saveandprint = false) 
         {
             $enc = QRencode::factory($level, $size, $margin);
-            return $enc->encodePNG($text, $outfile, $saveandprint=false);
+            return $enc->encodePNG($text, $outfile, $saveandprint = false);
         }
 
         //----------------------------------------------------------------------
@@ -3148,7 +3148,7 @@  discard block
 block discarded – undo
         {
             do {
             
-                if($this->bit == -1) {
+                if ($this->bit == -1) {
                     $this->bit = 0;
                     return array('x'=>$this->x, 'y'=>$this->y);
                 }
@@ -3157,7 +3157,7 @@  discard block
 block discarded – undo
                 $y = $this->y;
                 $w = $this->width;
 
-                if($this->bit == 0) {
+                if ($this->bit == 0) {
                     $x--;
                     $this->bit++;
                 } else {
@@ -3166,33 +3166,33 @@  discard block
 block discarded – undo
                     $this->bit--;
                 }
 
-                if($this->dir < 0) {
-                    if($y < 0) {
+                if ($this->dir < 0) {
+                    if ($y < 0) {
                         $y = 0;
                         $x -= 2;
                         $this->dir = 1;
-                        if($x == 6) {
+                        if ($x == 6) {
                             $x--;
                             $y = 9;
                         }
                     }
                 } else {
-                    if($y == $w) {
+                    if ($y == $w) {
                         $y = $w - 1;
                         $x -= 2;
                         $this->dir = -1;
-                        if($x == 6) {
+                        if ($x == 6) {
                             $x--;
                             $y -= 8;
                         }
                     }
                 }
-                if($x < 0 || $y < 0) return null;
+                if ($x < 0 || $y < 0) return null;
 
                 $this->x = $x;
                 $this->y = $y;
 
-            } while(ord($this->frame[$y][$x]) & 0x80);
+            } while (ord($this->frame[$y][$x]) & 0x80);
                         
             return array('x'=>$x, 'y'=>$y);
         }
@@ -3255,7 +3255,7 @@  discard block
 block discarded – undo
         {
             $code = new QRcode();
 
-            if($this->eightbit) {
+            if ($this->eightbit) {
                 $code->encodeString8bit($intext, $this->version, $this->level);
             } else {
                 $code->encodeString($intext, $this->version, $this->level, $this->hint, $this->casesensitive);
@@ -3269,7 +3269,7 @@  discard block
 block discarded – undo
         {
             $code = new QRcode();
 
-            if($this->eightbit) {
+            if ($this->eightbit) {
                 $code->encodeString8bit($intext, $this->version, $this->level);
             } else {
                 $code->encodeString($intext, $this->version, $this->level, $this->hint, $this->casesensitive);
@@ -3277,7 +3277,7 @@  discard block
 block discarded – undo
             
             QRtools::markTime('after_encode');
             
-            if ($outfile!== false) {
+            if ($outfile !== false) {
                 file_put_contents($outfile, join("\n", QRtools::binarize($code->data)));
             } else {
                 return QRtools::binarize($code->data);
@@ -3285,7 +3285,7 @@  discard block
 block discarded – undo
         }
         
         //----------------------------------------------------------------------
-        public function encodePNG($intext, $outfile = false,$saveandprint=false) 
+        public function encodePNG($intext, $outfile = false, $saveandprint = false) 
         {
             try {
             
@@ -3297,9 +3297,9 @@  discard block
 block discarded – undo
                 if ($err != '')
                     QRtools::log($outfile, $err);
                 
-                $maxSize = (int)(QR_PNG_MAXIMUM_SIZE / (count($tab)+2*$this->margin));
+                $maxSize = (int) (QR_PNG_MAXIMUM_SIZE / (count($tab) + 2 * $this->margin));
                 
-                QRimage::png($tab, $outfile, min(max(1, $this->size), $maxSize), $this->margin,$saveandprint);
+                QRimage::png($tab, $outfile, min(max(1, $this->size), $maxSize), $this->margin, $saveandprint);
             
             } catch (Exception $e) {
             

Please login to merge, or discard this patch.

Braces +194 added lines, -109 removed lines patch added patch discarded remove patch

@@ -176,8 +176,9 @@  discard block
 block discarded – undo
         {
             $barcode_array = array();
             
-            if (!is_array($mode))
-                $mode = explode(',', $mode);
+            if (!is_array($mode)) {
+                            $mode = explode(',', $mode);
+            }
                 
             $eccLevel = 'L';
                 
@@ -194,8 +195,9 @@  discard block
 block discarded – undo
                 
             foreach ($qrTab as $line) {
                 $arrAdd = array();
-                foreach(str_split($line) as $char)
-                    $arrAdd[] = ($char=='1')?1:0;
+                foreach(str_split($line) as $char) {
+                                    $arrAdd[] = ($char=='1')?1:0;
+                }
                 $barcode_array['bcode'][] = $arrAdd;
             }
                     
@@ -223,8 +225,9 @@  discard block
 block discarded – undo
 				
 				$width = count($frame);
 				$bitMask = array_fill(0, $width, array_fill(0, $width, 0));
-				for ($maskNo=0; $maskNo<8; $maskNo++)
-					$mask->makeMaskNo($maskNo, $width, $frame, $bitMask, true);
+				for ($maskNo=0; $maskNo<8; $maskNo++) {
+									$mask->makeMaskNo($maskNo, $width, $frame, $bitMask, true);
+				}
             }
 			
 			QRtools::markTime('after_build_cache');
@@ -261,8 +264,9 @@  discard block
 block discarded – undo
             list($usec, $sec) = explode(" ", microtime());
             $time = ((float)$usec + (float)$sec);
             
-            if (!isset($GLOBALS['qr_time_bench']))
-                $GLOBALS['qr_time_bench'] = array();
+            if (!isset($GLOBALS['qr_time_bench'])) {
+                            $GLOBALS['qr_time_bench'] = array();
+            }
             
             $GLOBALS['qr_time_bench'][$markerId] = $time;
         }
@@ -427,8 +431,9 @@  discard block
 block discarded – undo
 
             for($i=1; $i<= QRSPEC_VERSION_MAX; $i++) {
                 $words  = self::$capacity[$i][QRCAP_WORDS] - self::$capacity[$i][QRCAP_EC][$level];
-                if($words >= $size) 
-                    return $i;
+                if($words >= $size) {
+                                    return $i;
+                }
             }
 
             return -1;
@@ -446,8 +451,9 @@  discard block
 block discarded – undo
         //----------------------------------------------------------------------
         public static function lengthIndicator($mode, $version)
         {
-            if ($mode == QR_MODE_STRUCTURE)
-                return 0;
+            if ($mode == QR_MODE_STRUCTURE) {
+                            return 0;
+            }
                 
             if ($version <= 9) {
                 $l = 0;
@@ -463,8 +469,9 @@  discard block
 block discarded – undo
         //----------------------------------------------------------------------
         public static function maximumWords($mode, $version)
         {
-            if($mode == QR_MODE_STRUCTURE) 
-                return 3;
+            if($mode == QR_MODE_STRUCTURE) {
+                            return 3;
+            }
                 
             if($version <= 9) {
                 $l = 0;
@@ -610,8 +617,9 @@  discard block
 block discarded – undo
         //----------------------------------------------------------------------
         public static function putAlignmentPattern($version, &$frame, $width)
         {
-            if($version < 2)
-                return;
+            if($version < 2) {
+                            return;
+            }
 
             $d = self::$alignmentPattern[$version][1] - self::$alignmentPattern[$version][0];
             if($d < 0) {
@@ -663,8 +671,9 @@  discard block
 block discarded – undo
         //----------------------------------------------------------------------
         public static function getVersionPattern($version)
         {
-            if($version < 7 || $version > QRSPEC_VERSION_MAX)
-                return 0;
+            if($version < 7 || $version > QRSPEC_VERSION_MAX) {
+                            return 0;
+            }
 
             return self::$versionPattern[$version -7];
         }
@@ -681,11 +690,13 @@  discard block
 block discarded – undo
 
         public static function getFormatInfo($mask, $level)
         {
-            if($mask < 0 || $mask > 7)
-                return 0;
+            if($mask < 0 || $mask > 7) {
+                            return 0;
+            }
                 
-            if($level < 0 || $level > 3)
-                return 0;                
+            if($level < 0 || $level > 3) {
+                            return 0;
+            }
 
             return self::$formatInfo[$level][$mask];
         }
@@ -865,8 +876,9 @@  discard block
 block discarded – undo
         //----------------------------------------------------------------------
         public static function newFrame($version)
         {
-            if($version < 1 || $version > QRSPEC_VERSION_MAX) 
-                return null;
+            if($version < 1 || $version > QRSPEC_VERSION_MAX) {
+                            return null;
+            }
 
             if(!isset(self::$frames[$version])) {
                 
@@ -884,8 +896,9 @@  discard block
 block discarded – undo
                 }
             }
             
-            if(is_null(self::$frames[$version]))
-                return null;
+            if(is_null(self::$frames[$version])) {
+                            return null;
+            }
 
             return self::$frames[$version];
         }
@@ -950,7 +963,7 @@  discard block
 block discarded – undo
                     ImagePng($image, $filename);
                     header("Content-type: image/png");
                     ImagePng($image);
-                }else{
+                } else{
                     ImagePng($image, $filename);
                 }
             }
@@ -1210,8 +1223,9 @@  discard block
 block discarded – undo
         {
             $bits = 0;
 
-            if($version == 0) 
-                $version = 1;
+            if($version == 0) {
+                            $version = 1;
+            }
 
             switch($this->mode) {
                 case QR_MODE_NUM:        $bits = QRinput::estimateBitsModeNum($this->size);    break;
@@ -1270,8 +1284,9 @@  discard block
 block discarded – undo
                             break;
                     }
                     
-                    if($ret < 0)
-                        return -1;
+                    if($ret < 0) {
+                                            return -1;
+                    }
                 }
 
                 return $this->bstream->size();
@@ -1488,8 +1503,9 @@  discard block
 block discarded – undo
         //----------------------------------------------------------------------
         public static function checkModeKanji($size, $data)
         {
-            if($size & 1)
-                return false;
+            if($size & 1) {
+                            return false;
+            }
 
             for($i=0; $i<$size; $i+=2) {
                 $val = (ord($data[$i]) << 8) | ord($data[$i+1]);
@@ -1509,8 +1525,9 @@  discard block
 block discarded – undo
 
         public static function check($mode, $size, $data)
         {
-            if($size <= 0) 
-                return false;
+            if($size <= 0) {
+                            return false;
+            }
 
             switch($mode) {
                 case QR_MODE_NUM:       return self::checkModeNum($size, $data);   break;
@@ -1575,8 +1592,9 @@  discard block
 block discarded – undo
                     $chunks = (int)($payload / 11);
                     $remain = $payload - $chunks * 11;
                     $size = $chunks * 2;
-                    if($remain >= 6) 
-                        $size++;
+                    if($remain >= 6) {
+                                            $size++;
+                    }
                     break;
                 case QR_MODE_8:
                     $size = (int)($payload / 8);
@@ -1593,8 +1611,12 @@  discard block
 block discarded – undo
             }
             
             $maxsize = QRspec::maximumWords($mode, $version);
-            if($size < 0) $size = 0;
-            if($size > $maxsize) $size = $maxsize;
+            if($size < 0) {
+            	$size = 0;
+            }
+            if($size > $maxsize) {
+            	$size = $maxsize;
+            }
 
             return $size;
         }
@@ -1607,8 +1629,9 @@  discard block
 block discarded – undo
             foreach($this->items as $item) {
                 $bits = $item->encodeBitStream($this->version);
                 
-                if($bits < 0) 
-                    return -1;
+                if($bits < 0) {
+                                    return -1;
+                }
                     
                 $total += $bits;
             }
@@ -1627,8 +1650,9 @@  discard block
 block discarded – undo
             for(;;) {
                 $bits = $this->createBitStream();
                 
-                if($bits < 0) 
-                    return -1;
+                if($bits < 0) {
+                                    return -1;
+                }
                     
                 $ver = QRspec::getMinimumVersion((int)(($bits + 7) / 8), $this->level);
                 if($ver < 0) {
@@ -1665,8 +1689,9 @@  discard block
 block discarded – undo
             $padding = new QRbitstream();
             $ret = $padding->appendNum($words * 8 - $bits + 4, 0);
             
-            if($ret < 0) 
-                return $ret;
+            if($ret < 0) {
+                            return $ret;
+            }
 
             $padlen = $maxwords - $words;
             
@@ -1679,8 +1704,9 @@  discard block
 block discarded – undo
                 
                 $ret = $padding->appendBytes($padlen, $padbuf);
                 
-                if($ret < 0)
-                    return $ret;
+                if($ret < 0) {
+                                    return $ret;
+                }
                 
             }
 
@@ -1857,13 +1883,15 @@  discard block
 block discarded – undo
         //----------------------------------------------------------------------
         public function appendNum($bits, $num)
         {
-            if ($bits == 0) 
-                return 0;
+            if ($bits == 0) {
+                            return 0;
+            }
 
             $b = QRbitstream::newFromNum($bits, $num);
             
-            if(is_null($b))
-                return -1;
+            if(is_null($b)) {
+                            return -1;
+            }
 
             $ret = $this->append($b);
             unset($b);
@@ -1874,13 +1902,15 @@  discard block
 block discarded – undo
         //----------------------------------------------------------------------
         public function appendBytes($size, $data)
         {
-            if ($size == 0) 
-                return 0;
+            if ($size == 0) {
+                            return 0;
+            }
 
             $b = QRbitstream::newFromBytes($size, $data);
             
-            if(is_null($b))
-                return -1;
+            if(is_null($b)) {
+                            return -1;
+            }
 
             $ret = $this->append($b);
             unset($b);
@@ -1984,8 +2014,9 @@  discard block
 block discarded – undo
         //----------------------------------------------------------------------
         public static function isdigitat($str, $pos)
         {    
-            if ($pos >= strlen($str))
-                return false;
+            if ($pos >= strlen($str)) {
+                            return false;
+            }
             
             return ((ord($str[$pos]) >= ord('0'))&&(ord($str[$pos]) <= ord('9')));
         }
@@ -1993,8 +2024,9 @@  discard block
 block discarded – undo
         //----------------------------------------------------------------------
         public static function isalnumat($str, $pos)
         {
-            if ($pos >= strlen($str))
-                return false;
+            if ($pos >= strlen($str)) {
+                            return false;
+            }
                 
             return (QRinput::lookAnTable(ord($str[$pos])) >= 0);
         }
@@ -2002,8 +2034,9 @@  discard block
 block discarded – undo
         //----------------------------------------------------------------------
         public function identifyMode($pos)
         {
-            if ($pos >= strlen($this->dataStr)) 
-                return QR_MODE_NUL;
+            if ($pos >= strlen($this->dataStr)) {
+                            return QR_MODE_NUL;
+            }
                 
             $c = $this->dataStr[$pos];
             
@@ -2057,8 +2090,9 @@  discard block
 block discarded – undo
             }
             
             $ret = $this->input->append(QR_MODE_NUM, $run, str_split($this->dataStr));
-            if($ret < 0)
-                return -1;
+            if($ret < 0) {
+                            return -1;
+            }
 
             return $run;
         }
@@ -2104,8 +2138,9 @@  discard block
 block discarded – undo
             }
 
             $ret = $this->input->append(QR_MODE_AN, $run, str_split($this->dataStr));
-            if($ret < 0)
-                return -1;
+            if($ret < 0) {
+                            return -1;
+            }
 
             return $run;
         }
@@ -2120,8 +2155,9 @@  discard block
 block discarded – undo
             }
             
             $ret = $this->input->append(QR_MODE_KANJI, $p, str_split($this->dataStr));
-            if($ret < 0)
-                return -1;
+            if($ret < 0) {
+                            return -1;
+            }
 
             return $run;
         }
@@ -2175,8 +2211,9 @@  discard block
 block discarded – undo
             $run = $p;
             $ret = $this->input->append(QR_MODE_8, $run, str_split($this->dataStr));
             
-            if($ret < 0)
-                return -1;
+            if($ret < 0) {
+                            return -1;
+            }
 
             return $run;
         }
@@ -2186,8 +2223,9 @@  discard block
 block discarded – undo
         {
             while (strlen($this->dataStr) > 0)
             {
-                if($this->dataStr == '')
-                    return 0;
+                if($this->dataStr == '') {
+                                    return 0;
+                }
 
                 $mode = $this->identifyMode(0);
                 
@@ -2195,16 +2233,22 @@  discard block
 block discarded – undo
                     case QR_MODE_NUM: $length = $this->eatNum(); break;
                     case QR_MODE_AN:  $length = $this->eatAn(); break;
                     case QR_MODE_KANJI:
-                        if ($this->modeHint == QR_MODE_KANJI)
-                                $length = $this->eatKanji();
-                        else    $length = $this->eat8();
+                        if ($this->modeHint == QR_MODE_KANJI) {
+                                                        $length = $this->eatKanji();
+                        } else {
+                        	$length = $this->eat8();
+                        }
                         break;
                     default: $length = $this->eat8(); break;
                 
                 }
 
-                if($length == 0) return 0;
-                if($length < 0)  return -1;
+                if($length == 0) {
+                	return 0;
+                }
+                if($length < 0) {
+                	return -1;
+                }
                 
                 $this->dataStr = substr($this->dataStr, $length);
             }
@@ -2240,8 +2284,9 @@  discard block
 block discarded – undo
 
             $split = new QRsplit($string, $input, $modeHint);
             
-            if(!$casesensitive)
-                $split->toUpper();
+            if(!$casesensitive) {
+                            $split->toUpper();
+            }
                 
             return $split->splitString();
         }
@@ -2318,11 +2363,23 @@  discard block
 block discarded – undo
             $rs = null;
             
             // Check parameter ranges
-            if($symsize < 0 || $symsize > 8)                     return $rs;
-            if($fcr < 0 || $fcr >= (1<<$symsize))                return $rs;
-            if($prim <= 0 || $prim >= (1<<$symsize))             return $rs;
-            if($nroots < 0 || $nroots >= (1<<$symsize))          return $rs; // Can't have more roots than symbol values!
-            if($pad < 0 || $pad >= ((1<<$symsize) -1 - $nroots)) return $rs; // Too much padding
+            if($symsize < 0 || $symsize > 8) {
+            	return $rs;
+            }
+            if($fcr < 0 || $fcr >= (1<<$symsize)) {
+            	return $rs;
+            }
+            if($prim <= 0 || $prim >= (1<<$symsize)) {
+            	return $rs;
+            }
+            if($nroots < 0 || $nroots >= (1<<$symsize)) {
+            	return $rs;
+            }
+            // Can't have more roots than symbol values!
+            if($pad < 0 || $pad >= ((1<<$symsize) -1 - $nroots)) {
+            	return $rs;
+            }
+            // Too much padding
 
             $rs = new QRrsItem();
             $rs->mm = $symsize;
@@ -2388,8 +2445,9 @@  discard block
 block discarded – undo
             }
             
             // convert rs->genpoly[] to index form for quicker encoding
-            for ($i = 0; $i <= $nroots; $i++)
-                $rs->genpoly[$i] = $rs->index_of[$rs->genpoly[$i]];
+            for ($i = 0; $i <= $nroots; $i++) {
+                            $rs->genpoly[$i] = $rs->index_of[$rs->genpoly[$i]];
+            }
 
             return $rs;
         }
@@ -2447,12 +2505,24 @@  discard block
 block discarded – undo
         public static function init_rs($symsize, $gfpoly, $fcr, $prim, $nroots, $pad)
         {
             foreach(self::$items as $rs) {
-                if($rs->pad != $pad)       continue;
-                if($rs->nroots != $nroots) continue;
-                if($rs->mm != $symsize)    continue;
-                if($rs->gfpoly != $gfpoly) continue;
-                if($rs->fcr != $fcr)       continue;
-                if($rs->prim != $prim)     continue;
+                if($rs->pad != $pad) {
+                	continue;
+                }
+                if($rs->nroots != $nroots) {
+                	continue;
+                }
+                if($rs->mm != $symsize) {
+                	continue;
+                }
+                if($rs->gfpoly != $gfpoly) {
+                	continue;
+                }
+                if($rs->fcr != $fcr) {
+                	continue;
+                }
+                if($rs->prim != $prim) {
+                	continue;
+                }
 
                 return $rs;
             }
@@ -2591,8 +2661,9 @@  discard block
 block discarded – undo
         {
             $codeArr = array();
             
-            foreach ($bitFrame as $line)
-                $codeArr[] = join('', $line);
+            foreach ($bitFrame as $line) {
+                            $codeArr[] = join('', $line);
+            }
                 
             return gzcompress(join("\n", $codeArr), 9);
         }
@@ -2603,8 +2674,9 @@  discard block
 block discarded – undo
             $codeArr = array();
             
             $codeLines = explode("\n", gzuncompress($code));
-            foreach ($codeLines as $line)
-                $codeArr[] = str_split($line);
+            foreach ($codeLines as $line) {
+                            $codeArr[] = str_split($line);
+            }
             
             return $codeArr;
         }
@@ -2622,16 +2694,18 @@  discard block
 block discarded – undo
                     $bitMask = self::unserial(file_get_contents($fileName));
                 } else {
                     $bitMask = $this->generateMaskNo($maskNo, $width, $s);
-                    if (!file_exists(QR_CACHE_DIR.'mask_'.$maskNo))
-                        mkdir(QR_CACHE_DIR.'mask_'.$maskNo);
+                    if (!file_exists(QR_CACHE_DIR.'mask_'.$maskNo)) {
+                                            mkdir(QR_CACHE_DIR.'mask_'.$maskNo);
+                    }
                     file_put_contents($fileName, self::serial($bitMask));
                 }
             } else {
                 $bitMask = $this->generateMaskNo($maskNo, $width, $s);
             }
 
-            if ($maskGenOnly)
-                return;
+            if ($maskGenOnly) {
+                            return;
+            }
                 
             $d = $s;
 
@@ -2698,8 +2772,9 @@  discard block
 block discarded – undo
                 
                 $frameY = $frame[$y];
                 
-                if ($y>0)
-                    $frameYM = $frame[$y-1];
+                if ($y>0) {
+                                    $frameYM = $frame[$y-1];
+                }
                 
                 for($x=0; $x<$width; $x++) {
                     if(($x > 0) && ($y > 0)) {
@@ -2912,14 +2987,17 @@  discard block
 block discarded – undo
                 $blockNo++;
             }
 
-            if(QRspec::rsBlockNum2($spec) == 0)
-                return 0;
+            if(QRspec::rsBlockNum2($spec) == 0) {
+                            return 0;
+            }
 
             $dl = QRspec::rsDataCodes2($spec);
             $el = QRspec::rsEccCodes2($spec);
             $rs = QRrs::init_rs(8, 0x11d, 0, 1, $el, 255 - $dl - $el);
             
-            if($rs == NULL) return -1;
+            if($rs == NULL) {
+            	return -1;
+            }
             
             for($i=0; $i<QRspec::rsBlockNum2($spec); $i++) {
                 $ecc = array_slice($this->ecccode,$eccPos);
@@ -3057,7 +3135,9 @@  discard block
 block discarded – undo
             }
 
             $input = new QRinput($version, $level);
-            if($input == NULL) return NULL;
+            if($input == NULL) {
+            	return NULL;
+            }
 
             $ret = $input->append(QR_MODE_8, strlen($string), str_split($string));
             if($ret < 0) {
@@ -3077,7 +3157,9 @@  discard block
 block discarded – undo
             }
 
             $input = new QRinput($version, $level);
-            if($input == NULL) return NULL;
+            if($input == NULL) {
+            	return NULL;
+            }
 
             $ret = QRsplit::splitStringToQRinput($string, $input, $hint, $casesensitive);
             if($ret < 0) {
@@ -3187,7 +3269,9 @@  discard block
 block discarded – undo
                         }
                     }
                 }
-                if($x < 0 || $y < 0) return null;
+                if($x < 0 || $y < 0) {
+                	return null;
+                }
 
                 $this->x = $x;
                 $this->y = $y;
@@ -3294,8 +3378,9 @@  discard block
 block discarded – undo
                 $err = ob_get_contents();
                 ob_end_clean();
                 
-                if ($err != '')
-                    QRtools::log($outfile, $err);
+                if ($err != '') {
+                                    QRtools::log($outfile, $err);
+                }
                 
                 $maxSize = (int)(QR_PNG_MAXIMUM_SIZE / (count($tab)+2*$this->margin));
                 

Please login to merge, or discard this patch.

lib/phpqrcode/qrmask.php 3 patches

Indentation +237 added lines, -237 removed lines patch added patch discarded remove patch

		@@ -36,293 +36,293 @@
		block discarded – undo
36	36
37	37	//----------------------------------------------------------------------
38	38	public function __construct()
39		- {
40		- $this->runLength = array_fill(0, QRSPEC_WIDTH_MAX + 1, 0);
41		- }
	39	+ {
	40	+ $this->runLength = array_fill(0, QRSPEC_WIDTH_MAX + 1, 0);
	41	+ }
42	42
43		- //----------------------------------------------------------------------
44		- public function writeFormatInformation($width, &$frame, $mask, $level)
45		- {
46		- $blacks = 0;
47		- $format = QRspec::getFormatInfo($mask, $level);
	43	+ //----------------------------------------------------------------------
	44	+ public function writeFormatInformation($width, &$frame, $mask, $level)
	45	+ {
	46	+ $blacks = 0;
	47	+ $format = QRspec::getFormatInfo($mask, $level);
48	48
49		- for($i=0; $i<8; $i++) {
50		- if($format & 1) {
51		- $blacks += 2;
52		- $v = 0x85;
53		- } else {
54		- $v = 0x84;
55		- }
	49	+ for($i=0; $i<8; $i++) {
	50	+ if($format & 1) {
	51	+ $blacks += 2;
	52	+ $v = 0x85;
	53	+ } else {
	54	+ $v = 0x84;
	55	+ }
56	56
57		- $frame[8][$width - 1 - $i] = chr($v);
58		- if($i < 6) {
59		- $frame[$i][8] = chr($v);
60		- } else {
61		- $frame[$i + 1][8] = chr($v);
62		- }
63		- $format = $format >> 1;
64		- }
	57	+ $frame[8][$width - 1 - $i] = chr($v);
	58	+ if($i < 6) {
	59	+ $frame[$i][8] = chr($v);
	60	+ } else {
	61	+ $frame[$i + 1][8] = chr($v);
	62	+ }
	63	+ $format = $format >> 1;
	64	+ }
65	65
66		- for($i=0; $i<7; $i++) {
67		- if($format & 1) {
68		- $blacks += 2;
69		- $v = 0x85;
70		- } else {
71		- $v = 0x84;
72		- }
	66	+ for($i=0; $i<7; $i++) {
	67	+ if($format & 1) {
	68	+ $blacks += 2;
	69	+ $v = 0x85;
	70	+ } else {
	71	+ $v = 0x84;
	72	+ }
73	73
74		- $frame[$width - 7 + $i][8] = chr($v);
75		- if($i == 0) {
76		- $frame[8][7] = chr($v);
77		- } else {
78		- $frame[8][6 - $i] = chr($v);
79		- }
	74	+ $frame[$width - 7 + $i][8] = chr($v);
	75	+ if($i == 0) {
	76	+ $frame[8][7] = chr($v);
	77	+ } else {
	78	+ $frame[8][6 - $i] = chr($v);
	79	+ }
80	80
81		- $format = $format >> 1;
82		- }
	81	+ $format = $format >> 1;
	82	+ }
83	83
84		- return $blacks;
85		- }
	84	+ return $blacks;
	85	+ }
86	86
87		- //----------------------------------------------------------------------
88		- public function mask0($x, $y) { return ($x+$y)&1; }
89		- public function mask1($x, $y) { return ($y&1); }
90		- public function mask2($x, $y) { return ($x%3); }
91		- public function mask3($x, $y) { return ($x+$y)%3; }
92		- public function mask4($x, $y) { return (((int)($y/2))+((int)($x/3)))&1; }
93		- public function mask5($x, $y) { return (($x$y)&1)+($x$y)%3; }
94		- public function mask6($x, $y) { return ((($x$y)&1)+($x$y)%3)&1; }
95		- public function mask7($x, $y) { return ((($x*$y)%3)+(($x+$y)&1))&1; }
	87	+ //----------------------------------------------------------------------
	88	+ public function mask0($x, $y) { return ($x+$y)&1; }
	89	+ public function mask1($x, $y) { return ($y&1); }
	90	+ public function mask2($x, $y) { return ($x%3); }
	91	+ public function mask3($x, $y) { return ($x+$y)%3; }
	92	+ public function mask4($x, $y) { return (((int)($y/2))+((int)($x/3)))&1; }
	93	+ public function mask5($x, $y) { return (($x$y)&1)+($x$y)%3; }
	94	+ public function mask6($x, $y) { return ((($x$y)&1)+($x$y)%3)&1; }
	95	+ public function mask7($x, $y) { return ((($x*$y)%3)+(($x+$y)&1))&1; }
96	96
97		- //----------------------------------------------------------------------
98		- private function generateMaskNo($maskNo, $width, $frame)
99		- {
100		- $bitMask = array_fill(0, $width, array_fill(0, $width, 0));
	97	+ //----------------------------------------------------------------------
	98	+ private function generateMaskNo($maskNo, $width, $frame)
	99	+ {
	100	+ $bitMask = array_fill(0, $width, array_fill(0, $width, 0));
101	101
102		- for($y=0; $y<$width; $y++) {
103		- for($x=0; $x<$width; $x++) {
104		- if(ord($frame[$y][$x]) & 0x80) {
105		- $bitMask[$y][$x] = 0;
106		- } else {
107		- $maskFunc = call_user_func(array($this, 'mask'.$maskNo), $x, $y);
108		- $bitMask[$y][$x] = ($maskFunc == 0)?1:0;
109		- }
	102	+ for($y=0; $y<$width; $y++) {
	103	+ for($x=0; $x<$width; $x++) {
	104	+ if(ord($frame[$y][$x]) & 0x80) {
	105	+ $bitMask[$y][$x] = 0;
	106	+ } else {
	107	+ $maskFunc = call_user_func(array($this, 'mask'.$maskNo), $x, $y);
	108	+ $bitMask[$y][$x] = ($maskFunc == 0)?1:0;
	109	+ }
110	110
111		- }
112		- }
	111	+ }
	112	+ }
113	113
114		- return $bitMask;
115		- }
	114	+ return $bitMask;
	115	+ }
116	116
117		- //----------------------------------------------------------------------
118		- public static function serial($bitFrame)
119		- {
120		- $codeArr = array();
	117	+ //----------------------------------------------------------------------
	118	+ public static function serial($bitFrame)
	119	+ {
	120	+ $codeArr = array();
121	121
122		- foreach ($bitFrame as $line)
123		- $codeArr[] = join('', $line);
	122	+ foreach ($bitFrame as $line)
	123	+ $codeArr[] = join('', $line);
124	124
125		- return gzcompress(join("\n", $codeArr), 9);
126		- }
	125	+ return gzcompress(join("\n", $codeArr), 9);
	126	+ }
127	127
128		- //----------------------------------------------------------------------
129		- public static function unserial($code)
130		- {
131		- $codeArr = array();
	128	+ //----------------------------------------------------------------------
	129	+ public static function unserial($code)
	130	+ {
	131	+ $codeArr = array();
132	132
133		- $codeLines = explode("\n", gzuncompress($code));
134		- foreach ($codeLines as $line)
135		- $codeArr[] = str_split($line);
	133	+ $codeLines = explode("\n", gzuncompress($code));
	134	+ foreach ($codeLines as $line)
	135	+ $codeArr[] = str_split($line);
136	136
137		- return $codeArr;
138		- }
	137	+ return $codeArr;
	138	+ }
139	139
140		- //----------------------------------------------------------------------
141		- public function makeMaskNo($maskNo, $width, $s, &$d, $maskGenOnly = false)
142		- {
143		- $b = 0;
144		- $bitMask = array();
	140	+ //----------------------------------------------------------------------
	141	+ public function makeMaskNo($maskNo, $width, $s, &$d, $maskGenOnly = false)
	142	+ {
	143	+ $b = 0;
	144	+ $bitMask = array();
145	145
146		- $fileName = QR_CACHE_DIR.'mask_'.$maskNo.DIRECTORY_SEPARATOR.'mask_'.$width.'_'.$maskNo.'.dat';
	146	+ $fileName = QR_CACHE_DIR.'mask_'.$maskNo.DIRECTORY_SEPARATOR.'mask_'.$width.'_'.$maskNo.'.dat';
147	147
148		- if (QR_CACHEABLE) {
149		- if (file_exists($fileName)) {
150		- $bitMask = self::unserial(file_get_contents($fileName));
151		- } else {
152		- $bitMask = $this->generateMaskNo($maskNo, $width, $s);
153		- if (!file_exists(QR_CACHE_DIR.'mask_'.$maskNo))
154		- mkdir(QR_CACHE_DIR.'mask_'.$maskNo);
155		- file_put_contents($fileName, self::serial($bitMask));
156		- }
157		- } else {
158		- $bitMask = $this->generateMaskNo($maskNo, $width, $s);
159		- }
	148	+ if (QR_CACHEABLE) {
	149	+ if (file_exists($fileName)) {
	150	+ $bitMask = self::unserial(file_get_contents($fileName));
	151	+ } else {
	152	+ $bitMask = $this->generateMaskNo($maskNo, $width, $s);
	153	+ if (!file_exists(QR_CACHE_DIR.'mask_'.$maskNo))
	154	+ mkdir(QR_CACHE_DIR.'mask_'.$maskNo);
	155	+ file_put_contents($fileName, self::serial($bitMask));
	156	+ }
	157	+ } else {
	158	+ $bitMask = $this->generateMaskNo($maskNo, $width, $s);
	159	+ }
160	160
161		- if ($maskGenOnly)
162		- return;
	161	+ if ($maskGenOnly)
	162	+ return;
163	163
164		- $d = $s;
	164	+ $d = $s;
165	165
166		- for($y=0; $y<$width; $y++) {
167		- for($x=0; $x<$width; $x++) {
168		- if($bitMask[$y][$x] == 1) {
169		- $d[$y][$x] = chr(ord($s[$y][$x]) ^ (int)$bitMask[$y][$x]);
170		- }
171		- $b += (int)(ord($d[$y][$x]) & 1);
172		- }
173		- }
	166	+ for($y=0; $y<$width; $y++) {
	167	+ for($x=0; $x<$width; $x++) {
	168	+ if($bitMask[$y][$x] == 1) {
	169	+ $d[$y][$x] = chr(ord($s[$y][$x]) ^ (int)$bitMask[$y][$x]);
	170	+ }
	171	+ $b += (int)(ord($d[$y][$x]) & 1);
	172	+ }
	173	+ }
174	174
175		- return $b;
176		- }
	175	+ return $b;
	176	+ }
177	177
178		- //----------------------------------------------------------------------
179		- public function makeMask($width, $frame, $maskNo, $level)
180		- {
181		- $masked = array_fill(0, $width, str_repeat("\0", $width));
182		- $this->makeMaskNo($maskNo, $width, $frame, $masked);
183		- $this->writeFormatInformation($width, $masked, $maskNo, $level);
	178	+ //----------------------------------------------------------------------
	179	+ public function makeMask($width, $frame, $maskNo, $level)
	180	+ {
	181	+ $masked = array_fill(0, $width, str_repeat("\0", $width));
	182	+ $this->makeMaskNo($maskNo, $width, $frame, $masked);
	183	+ $this->writeFormatInformation($width, $masked, $maskNo, $level);
184	184
185		- return $masked;
186		- }
	185	+ return $masked;
	186	+ }
187	187
188		- //----------------------------------------------------------------------
189		- public function calcN1N3($length)
190		- {
191		- $demerit = 0;
	188	+ //----------------------------------------------------------------------
	189	+ public function calcN1N3($length)
	190	+ {
	191	+ $demerit = 0;
192	192
193		- for($i=0; $i<$length; $i++) {
	193	+ for($i=0; $i<$length; $i++) {
194	194
195		- if($this->runLength[$i] >= 5) {
196		- $demerit += (N1 + ($this->runLength[$i] - 5));
197		- }
198		- if($i & 1) {
199		- if(($i >= 3) && ($i < ($length-2)) && ($this->runLength[$i] % 3 == 0)) {
200		- $fact = (int)($this->runLength[$i] / 3);
201		- if(($this->runLength[$i-2] == $fact) &&
202		- ($this->runLength[$i-1] == $fact) &&
203		- ($this->runLength[$i+1] == $fact) &&
204		- ($this->runLength[$i+2] == $fact)) {
205		- if(($this->runLength[$i-3] < 0) \|\| ($this->runLength[$i-3] >= (4 * $fact))) {
206		- $demerit += N3;
207		- } else if((($i+3) >= $length) \|\| ($this->runLength[$i+3] >= (4 * $fact))) {
208		- $demerit += N3;
209		- }
210		- }
211		- }
212		- }
213		- }
214		- return $demerit;
215		- }
	195	+ if($this->runLength[$i] >= 5) {
	196	+ $demerit += (N1 + ($this->runLength[$i] - 5));
	197	+ }
	198	+ if($i & 1) {
	199	+ if(($i >= 3) && ($i < ($length-2)) && ($this->runLength[$i] % 3 == 0)) {
	200	+ $fact = (int)($this->runLength[$i] / 3);
	201	+ if(($this->runLength[$i-2] == $fact) &&
	202	+ ($this->runLength[$i-1] == $fact) &&
	203	+ ($this->runLength[$i+1] == $fact) &&
	204	+ ($this->runLength[$i+2] == $fact)) {
	205	+ if(($this->runLength[$i-3] < 0) \|\| ($this->runLength[$i-3] >= (4 * $fact))) {
	206	+ $demerit += N3;
	207	+ } else if((($i+3) >= $length) \|\| ($this->runLength[$i+3] >= (4 * $fact))) {
	208	+ $demerit += N3;
	209	+ }
	210	+ }
	211	+ }
	212	+ }
	213	+ }
	214	+ return $demerit;
	215	+ }
216	216
217		- //----------------------------------------------------------------------
218		- public function evaluateSymbol($width, $frame)
219		- {
220		- $head = 0;
221		- $demerit = 0;
	217	+ //----------------------------------------------------------------------
	218	+ public function evaluateSymbol($width, $frame)
	219	+ {
	220	+ $head = 0;
	221	+ $demerit = 0;
222	222
223		- for($y=0; $y<$width; $y++) {
224		- $head = 0;
225		- $this->runLength[0] = 1;
	223	+ for($y=0; $y<$width; $y++) {
	224	+ $head = 0;
	225	+ $this->runLength[0] = 1;
226	226
227		- $frameY = $frame[$y];
	227	+ $frameY = $frame[$y];
228	228
229		- if ($y>0)
230		- $frameYM = $frame[$y-1];
	229	+ if ($y>0)
	230	+ $frameYM = $frame[$y-1];
231	231
232		- for($x=0; $x<$width; $x++) {
233		- if(($x > 0) && ($y > 0)) {
234		- $b22 = ord($frameY[$x]) & ord($frameY[$x-1]) & ord($frameYM[$x]) & ord($frameYM[$x-1]);
235		- $w22 = ord($frameY[$x]) \| ord($frameY[$x-1]) \| ord($frameYM[$x]) \| ord($frameYM[$x-1]);
	232	+ for($x=0; $x<$width; $x++) {
	233	+ if(($x > 0) && ($y > 0)) {
	234	+ $b22 = ord($frameY[$x]) & ord($frameY[$x-1]) & ord($frameYM[$x]) & ord($frameYM[$x-1]);
	235	+ $w22 = ord($frameY[$x]) \| ord($frameY[$x-1]) \| ord($frameYM[$x]) \| ord($frameYM[$x-1]);
236	236
237		- if(($b22 \| ($w22 ^ 1))&1) {
238		- $demerit += N2;
239		- }
240		- }
241		- if(($x == 0) && (ord($frameY[$x]) & 1)) {
242		- $this->runLength[0] = -1;
243		- $head = 1;
244		- $this->runLength[$head] = 1;
245		- } else if($x > 0) {
246		- if((ord($frameY[$x]) ^ ord($frameY[$x-1])) & 1) {
247		- $head++;
248		- $this->runLength[$head] = 1;
249		- } else {
250		- $this->runLength[$head]++;
251		- }
252		- }
253		- }
	237	+ if(($b22 \| ($w22 ^ 1))&1) {
	238	+ $demerit += N2;
	239	+ }
	240	+ }
	241	+ if(($x == 0) && (ord($frameY[$x]) & 1)) {
	242	+ $this->runLength[0] = -1;
	243	+ $head = 1;
	244	+ $this->runLength[$head] = 1;
	245	+ } else if($x > 0) {
	246	+ if((ord($frameY[$x]) ^ ord($frameY[$x-1])) & 1) {
	247	+ $head++;
	248	+ $this->runLength[$head] = 1;
	249	+ } else {
	250	+ $this->runLength[$head]++;
	251	+ }
	252	+ }
	253	+ }
254	254
255		- $demerit += $this->calcN1N3($head+1);
256		- }
	255	+ $demerit += $this->calcN1N3($head+1);
	256	+ }
257	257
258		- for($x=0; $x<$width; $x++) {
259		- $head = 0;
260		- $this->runLength[0] = 1;
	258	+ for($x=0; $x<$width; $x++) {
	259	+ $head = 0;
	260	+ $this->runLength[0] = 1;
261	261
262		- for($y=0; $y<$width; $y++) {
263		- if($y == 0 && (ord($frame[$y][$x]) & 1)) {
264		- $this->runLength[0] = -1;
265		- $head = 1;
266		- $this->runLength[$head] = 1;
267		- } else if($y > 0) {
268		- if((ord($frame[$y][$x]) ^ ord($frame[$y-1][$x])) & 1) {
269		- $head++;
270		- $this->runLength[$head] = 1;
271		- } else {
272		- $this->runLength[$head]++;
273		- }
274		- }
275		- }
	262	+ for($y=0; $y<$width; $y++) {
	263	+ if($y == 0 && (ord($frame[$y][$x]) & 1)) {
	264	+ $this->runLength[0] = -1;
	265	+ $head = 1;
	266	+ $this->runLength[$head] = 1;
	267	+ } else if($y > 0) {
	268	+ if((ord($frame[$y][$x]) ^ ord($frame[$y-1][$x])) & 1) {
	269	+ $head++;
	270	+ $this->runLength[$head] = 1;
	271	+ } else {
	272	+ $this->runLength[$head]++;
	273	+ }
	274	+ }
	275	+ }
276	276
277		- $demerit += $this->calcN1N3($head+1);
278		- }
	277	+ $demerit += $this->calcN1N3($head+1);
	278	+ }
279	279
280		- return $demerit;
281		- }
	280	+ return $demerit;
	281	+ }
282	282
283	283
284		- //----------------------------------------------------------------------
285		- public function mask($width, $frame, $level)
286		- {
287		- $minDemerit = PHP_INT_MAX;
288		- $bestMaskNum = 0;
289		- $bestMask = array();
	284	+ //----------------------------------------------------------------------
	285	+ public function mask($width, $frame, $level)
	286	+ {
	287	+ $minDemerit = PHP_INT_MAX;
	288	+ $bestMaskNum = 0;
	289	+ $bestMask = array();
290	290
291		- $checked_masks = array(0,1,2,3,4,5,6,7);
	291	+ $checked_masks = array(0,1,2,3,4,5,6,7);
292	292
293		- if (QR_FIND_FROM_RANDOM !== false) {
	293	+ if (QR_FIND_FROM_RANDOM !== false) {
294	294
295		- $howManuOut = 8-(QR_FIND_FROM_RANDOM % 9);
296		- for ($i = 0; $i < $howManuOut; $i++) {
297		- $remPos = rand (0, count($checked_masks)-1);
298		- unset($checked_masks[$remPos]);
299		- $checked_masks = array_values($checked_masks);
300		- }
	295	+ $howManuOut = 8-(QR_FIND_FROM_RANDOM % 9);
	296	+ for ($i = 0; $i < $howManuOut; $i++) {
	297	+ $remPos = rand (0, count($checked_masks)-1);
	298	+ unset($checked_masks[$remPos]);
	299	+ $checked_masks = array_values($checked_masks);
	300	+ }
301	301
302		- }
	302	+ }
303	303
304		- $bestMask = $frame;
	304	+ $bestMask = $frame;
305	305
306		- foreach($checked_masks as $i) {
307		- $mask = array_fill(0, $width, str_repeat("\0", $width));
	306	+ foreach($checked_masks as $i) {
	307	+ $mask = array_fill(0, $width, str_repeat("\0", $width));
308	308
309		- $demerit = 0;
310		- $blacks = 0;
311		- $blacks = $this->makeMaskNo($i, $width, $frame, $mask);
312		- $blacks += $this->writeFormatInformation($width, $mask, $i, $level);
313		- $blacks = (int)(100 * $blacks / ($width * $width));
314		- $demerit = (int)((int)(abs($blacks - 50) / 5) * N4);
315		- $demerit += $this->evaluateSymbol($width, $mask);
	309	+ $demerit = 0;
	310	+ $blacks = 0;
	311	+ $blacks = $this->makeMaskNo($i, $width, $frame, $mask);
	312	+ $blacks += $this->writeFormatInformation($width, $mask, $i, $level);
	313	+ $blacks = (int)(100 * $blacks / ($width * $width));
	314	+ $demerit = (int)((int)(abs($blacks - 50) / 5) * N4);
	315	+ $demerit += $this->evaluateSymbol($width, $mask);
316	316
317		- if($demerit < $minDemerit) {
318		- $minDemerit = $demerit;
319		- $bestMask = $mask;
320		- $bestMaskNum = $i;
321		- }
322		- }
	317	+ if($demerit < $minDemerit) {
	318	+ $minDemerit = $demerit;
	319	+ $bestMask = $mask;
	320	+ $bestMaskNum = $i;
	321	+ }
	322	+ }
323	323
324		- return $bestMask;
325		- }
	324	+ return $bestMask;
	325	+ }
326	326
327		- //----------------------------------------------------------------------
328		- }
	327	+ //----------------------------------------------------------------------
	328	+ }

Please login to merge, or discard this patch.

Spacing +61 added lines, -61 removed lines patch added patch discarded remove patch

		@@ -44,10 +44,10 @@ discard block
		block discarded – undo
44	44	public function writeFormatInformation($width, &$frame, $mask, $level)
45	45	{
46	46	$blacks = 0;
47		- $format = QRspec::getFormatInfo($mask, $level);
	47	+ $format = QRspec::getFormatInfo($mask, $level);
48	48
49		- for($i=0; $i<8; $i++) {
50		- if($format & 1) {
	49	+ for ($i = 0; $i < 8; $i++) {
	50	+ if ($format & 1) {
51	51	$blacks += 2;
52	52	$v = 0x85;
53	53	} else {
		@@ -55,7 +55,7 @@ discard block
		block discarded – undo
55	55	}
56	56
57	57	$frame[8][$width - 1 - $i] = chr($v);
58		- if($i < 6) {
	58	+ if ($i < 6) {
59	59	$frame[$i][8] = chr($v);
60	60	} else {
61	61	$frame[$i + 1][8] = chr($v);
		@@ -63,8 +63,8 @@ discard block
		block discarded – undo
63	63	$format = $format >> 1;
64	64	}
65	65
66		- for($i=0; $i<7; $i++) {
67		- if($format & 1) {
	66	+ for ($i = 0; $i < 7; $i++) {
	67	+ if ($format & 1) {
68	68	$blacks += 2;
69	69	$v = 0x85;
70	70	} else {
		@@ -72,7 +72,7 @@ discard block
		block discarded – undo
72	72	}
73	73
74	74	$frame[$width - 7 + $i][8] = chr($v);
75		- if($i == 0) {
	75	+ if ($i == 0) {
76	76	$frame[8][7] = chr($v);
77	77	} else {
78	78	$frame[8][6 - $i] = chr($v);
		@@ -85,27 +85,27 @@ discard block
		block discarded – undo
85	85	}
86	86
87	87	//----------------------------------------------------------------------
88		- public function mask0($x, $y) { return ($x+$y)&1; }
89		- public function mask1($x, $y) { return ($y&1); }
90		- public function mask2($x, $y) { return ($x%3); }
91		- public function mask3($x, $y) { return ($x+$y)%3; }
92		- public function mask4($x, $y) { return (((int)($y/2))+((int)($x/3)))&1; }
93		- public function mask5($x, $y) { return (($x$y)&1)+($x$y)%3; }
94		- public function mask6($x, $y) { return ((($x$y)&1)+($x$y)%3)&1; }
95		- public function mask7($x, $y) { return ((($x*$y)%3)+(($x+$y)&1))&1; }
	88	+ public function mask0($x, $y) { return ($x + $y) & 1; }
	89	+ public function mask1($x, $y) { return ($y & 1); }
	90	+ public function mask2($x, $y) { return ($x % 3); }
	91	+ public function mask3($x, $y) { return ($x + $y) % 3; }
	92	+ public function mask4($x, $y) { return (((int) ($y / 2)) + ((int) ($x / 3))) & 1; }
	93	+ public function mask5($x, $y) { return (($x * $y) & 1) + ($x * $y) % 3; }
	94	+ public function mask6($x, $y) { return ((($x * $y) & 1) + ($x * $y) % 3) & 1; }
	95	+ public function mask7($x, $y) { return ((($x * $y) % 3) + (($x + $y) & 1)) & 1; }
96	96
97	97	//----------------------------------------------------------------------
98	98	private function generateMaskNo($maskNo, $width, $frame)
99	99	{
100	100	$bitMask = array_fill(0, $width, array_fill(0, $width, 0));
101	101
102		- for($y=0; $y<$width; $y++) {
103		- for($x=0; $x<$width; $x++) {
104		- if(ord($frame[$y][$x]) & 0x80) {
	102	+ for ($y = 0; $y < $width; $y++) {
	103	+ for ($x = 0; $x < $width; $x++) {
	104	+ if (ord($frame[$y][$x]) & 0x80) {
105	105	$bitMask[$y][$x] = 0;
106	106	} else {
107	107	$maskFunc = call_user_func(array($this, 'mask'.$maskNo), $x, $y);
108		- $bitMask[$y][$x] = ($maskFunc == 0)?1:0;
	108	+ $bitMask[$y][$x] = ($maskFunc == 0) ? 1 : 0;
109	109	}
110	110
111	111	}
		@@ -163,12 +163,12 @@ discard block
		block discarded – undo
163	163
164	164	$d = $s;
165	165
166		- for($y=0; $y<$width; $y++) {
167		- for($x=0; $x<$width; $x++) {
168		- if($bitMask[$y][$x] == 1) {
169		- $d[$y][$x] = chr(ord($s[$y][$x]) ^ (int)$bitMask[$y][$x]);
	166	+ for ($y = 0; $y < $width; $y++) {
	167	+ for ($x = 0; $x < $width; $x++) {
	168	+ if ($bitMask[$y][$x] == 1) {
	169	+ $d[$y][$x] = chr(ord($s[$y][$x]) ^ (int) $bitMask[$y][$x]);
170	170	}
171		- $b += (int)(ord($d[$y][$x]) & 1);
	171	+ $b += (int) (ord($d[$y][$x]) & 1);
172	172	}
173	173	}
174	174
		@@ -190,21 +190,21 @@ discard block
		block discarded – undo
190	190	{
191	191	$demerit = 0;
192	192
193		- for($i=0; $i<$length; $i++) {
	193	+ for ($i = 0; $i < $length; $i++) {
194	194
195		- if($this->runLength[$i] >= 5) {
	195	+ if ($this->runLength[$i] >= 5) {
196	196	$demerit += (N1 + ($this->runLength[$i] - 5));
197	197	}
198		- if($i & 1) {
199		- if(($i >= 3) && ($i < ($length-2)) && ($this->runLength[$i] % 3 == 0)) {
200		- $fact = (int)($this->runLength[$i] / 3);
201		- if(($this->runLength[$i-2] == $fact) &&
202		- ($this->runLength[$i-1] == $fact) &&
203		- ($this->runLength[$i+1] == $fact) &&
204		- ($this->runLength[$i+2] == $fact)) {
205		- if(($this->runLength[$i-3] < 0) \|\| ($this->runLength[$i-3] >= (4 * $fact))) {
	198	+ if ($i & 1) {
	199	+ if (($i >= 3) && ($i < ($length - 2)) && ($this->runLength[$i] % 3 == 0)) {
	200	+ $fact = (int) ($this->runLength[$i] / 3);
	201	+ if (($this->runLength[$i - 2] == $fact) &&
	202	+ ($this->runLength[$i - 1] == $fact) &&
	203	+ ($this->runLength[$i + 1] == $fact) &&
	204	+ ($this->runLength[$i + 2] == $fact)) {
	205	+ if (($this->runLength[$i - 3] < 0) \|\| ($this->runLength[$i - 3] >= (4 * $fact))) {
206	206	$demerit += N3;
207		- } else if((($i+3) >= $length) \|\| ($this->runLength[$i+3] >= (4 * $fact))) {
	207	+ } else if ((($i + 3) >= $length) \|\| ($this->runLength[$i + 3] >= (4 * $fact))) {
208	208	$demerit += N3;
209	209	}
210	210	}
		@@ -220,30 +220,30 @@ discard block
		block discarded – undo
220	220	$head = 0;
221	221	$demerit = 0;
222	222
223		- for($y=0; $y<$width; $y++) {
	223	+ for ($y = 0; $y < $width; $y++) {
224	224	$head = 0;
225	225	$this->runLength[0] = 1;
226	226
227	227	$frameY = $frame[$y];
228	228
229		- if ($y>0)
230		- $frameYM = $frame[$y-1];
	229	+ if ($y > 0)
	230	+ $frameYM = $frame[$y - 1];
231	231
232		- for($x=0; $x<$width; $x++) {
233		- if(($x > 0) && ($y > 0)) {
234		- $b22 = ord($frameY[$x]) & ord($frameY[$x-1]) & ord($frameYM[$x]) & ord($frameYM[$x-1]);
235		- $w22 = ord($frameY[$x]) \| ord($frameY[$x-1]) \| ord($frameYM[$x]) \| ord($frameYM[$x-1]);
	232	+ for ($x = 0; $x < $width; $x++) {
	233	+ if (($x > 0) && ($y > 0)) {
	234	+ $b22 = ord($frameY[$x]) & ord($frameY[$x - 1]) & ord($frameYM[$x]) & ord($frameYM[$x - 1]);
	235	+ $w22 = ord($frameY[$x]) \| ord($frameY[$x - 1]) \| ord($frameYM[$x]) \| ord($frameYM[$x - 1]);
236	236
237		- if(($b22 \| ($w22 ^ 1))&1) {
	237	+ if (($b22 \| ($w22 ^ 1)) & 1) {
238	238	$demerit += N2;
239	239	}
240	240	}
241		- if(($x == 0) && (ord($frameY[$x]) & 1)) {
	241	+ if (($x == 0) && (ord($frameY[$x]) & 1)) {
242	242	$this->runLength[0] = -1;
243	243	$head = 1;
244	244	$this->runLength[$head] = 1;
245		- } else if($x > 0) {
246		- if((ord($frameY[$x]) ^ ord($frameY[$x-1])) & 1) {
	245	+ } else if ($x > 0) {
	246	+ if ((ord($frameY[$x]) ^ ord($frameY[$x - 1])) & 1) {
247	247	$head++;
248	248	$this->runLength[$head] = 1;
249	249	} else {
		@@ -252,20 +252,20 @@ discard block
		block discarded – undo
252	252	}
253	253	}
254	254
255		- $demerit += $this->calcN1N3($head+1);
	255	+ $demerit += $this->calcN1N3($head + 1);
256	256	}
257	257
258		- for($x=0; $x<$width; $x++) {
	258	+ for ($x = 0; $x < $width; $x++) {
259	259	$head = 0;
260	260	$this->runLength[0] = 1;
261	261
262		- for($y=0; $y<$width; $y++) {
263		- if($y == 0 && (ord($frame[$y][$x]) & 1)) {
	262	+ for ($y = 0; $y < $width; $y++) {
	263	+ if ($y == 0 && (ord($frame[$y][$x]) & 1)) {
264	264	$this->runLength[0] = -1;
265	265	$head = 1;
266	266	$this->runLength[$head] = 1;
267		- } else if($y > 0) {
268		- if((ord($frame[$y][$x]) ^ ord($frame[$y-1][$x])) & 1) {
	267	+ } else if ($y > 0) {
	268	+ if ((ord($frame[$y][$x]) ^ ord($frame[$y - 1][$x])) & 1) {
269	269	$head++;
270	270	$this->runLength[$head] = 1;
271	271	} else {
		@@ -274,7 +274,7 @@ discard block
		block discarded – undo
274	274	}
275	275	}
276	276
277		- $demerit += $this->calcN1N3($head+1);
	277	+ $demerit += $this->calcN1N3($head + 1);
278	278	}
279	279
280	280	return $demerit;
		@@ -288,13 +288,13 @@ discard block
		block discarded – undo
288	288	$bestMaskNum = 0;
289	289	$bestMask = array();
290	290
291		- $checked_masks = array(0,1,2,3,4,5,6,7);
	291	+ $checked_masks = array(0, 1, 2, 3, 4, 5, 6, 7);
292	292
293	293	if (QR_FIND_FROM_RANDOM !== false) {
294	294
295		- $howManuOut = 8-(QR_FIND_FROM_RANDOM % 9);
296		- for ($i = 0; $i < $howManuOut; $i++) {
297		- $remPos = rand (0, count($checked_masks)-1);
	295	+ $howManuOut = 8 - (QR_FIND_FROM_RANDOM % 9);
	296	+ for ($i = 0; $i < $howManuOut; $i++) {
	297	+ $remPos = rand(0, count($checked_masks) - 1);
298	298	unset($checked_masks[$remPos]);
299	299	$checked_masks = array_values($checked_masks);
300	300	}
		@@ -303,18 +303,18 @@ discard block
		block discarded – undo
303	303
304	304	$bestMask = $frame;
305	305
306		- foreach($checked_masks as $i) {
	306	+ foreach ($checked_masks as $i) {
307	307	$mask = array_fill(0, $width, str_repeat("\0", $width));
308	308
309	309	$demerit = 0;
310	310	$blacks = 0;
311	311	$blacks = $this->makeMaskNo($i, $width, $frame, $mask);
312	312	$blacks += $this->writeFormatInformation($width, $mask, $i, $level);
313		- $blacks = (int)(100 * $blacks / ($width * $width));
314		- $demerit = (int)((int)(abs($blacks - 50) / 5) * N4);
	313	+ $blacks = (int) (100 * $blacks / ($width * $width));
	314	+ $demerit = (int) ((int) (abs($blacks - 50) / 5) * N4);
315	315	$demerit += $this->evaluateSymbol($width, $mask);
316	316
317		- if($demerit < $minDemerit) {
	317	+ if ($demerit < $minDemerit) {
318	318	$minDemerit = $demerit;
319	319	$bestMask = $mask;
320	320	$bestMaskNum = $i;

Please login to merge, or discard this patch.

Braces +15 added lines, -10 removed lines patch added patch discarded remove patch

@@ -119,8 +119,9 @@  discard block
 block discarded – undo
         {
             $codeArr = array();
             
-            foreach ($bitFrame as $line)
-                $codeArr[] = join('', $line);
+            foreach ($bitFrame as $line) {
+                            $codeArr[] = join('', $line);
+            }
                 
             return gzcompress(join("\n", $codeArr), 9);
         }
@@ -131,8 +132,9 @@  discard block
 block discarded – undo
             $codeArr = array();
             
             $codeLines = explode("\n", gzuncompress($code));
-            foreach ($codeLines as $line)
-                $codeArr[] = str_split($line);
+            foreach ($codeLines as $line) {
+                            $codeArr[] = str_split($line);
+            }
             
             return $codeArr;
         }
@@ -150,16 +152,18 @@  discard block
 block discarded – undo
                     $bitMask = self::unserial(file_get_contents($fileName));
                 } else {
                     $bitMask = $this->generateMaskNo($maskNo, $width, $s);
-                    if (!file_exists(QR_CACHE_DIR.'mask_'.$maskNo))
-                        mkdir(QR_CACHE_DIR.'mask_'.$maskNo);
+                    if (!file_exists(QR_CACHE_DIR.'mask_'.$maskNo)) {
+                                            mkdir(QR_CACHE_DIR.'mask_'.$maskNo);
+                    }
                     file_put_contents($fileName, self::serial($bitMask));
                 }
             } else {
                 $bitMask = $this->generateMaskNo($maskNo, $width, $s);
             }
 
-            if ($maskGenOnly)
-                return;
+            if ($maskGenOnly) {
+                            return;
+            }
                 
             $d = $s;
 
@@ -226,8 +230,9 @@  discard block
 block discarded – undo
                 
                 $frameY = $frame[$y];
                 
-                if ($y>0)
-                    $frameYM = $frame[$y-1];
+                if ($y>0) {
+                                    $frameYM = $frame[$y-1];
+                }
                 
                 for($x=0; $x<$width; $x++) {
                     if(($x > 0) && ($y > 0)) {

Please login to merge, or discard this patch.