reginaldojunior /
winners
| Conditions | 102 |
| Paths | > 20000 |
| Total Lines | 458 |
| Code Lines | 289 |
| Lines | 80 |
| Ratio | 17.47 % |
| Changes | 0 | ||
Small methods make your code easier to understand, in particular if combined with a good name. Besides, if your method is small, finding a good name is usually much easier.
For example, if you find yourself adding comments to a method's body, this is usually a good sign to extract the commented part to a new method, and use the comment as a starting point when coming up with a good name for this new method.
Commonly applied refactorings include:
If many parameters/temporary variables are present:
| 1 | <?php |
||
| 156 | private function _parseToTokens() { |
||
| 157 | // No attempt is made to verify formulas; assumes formulas are derived from Excel, where |
||
| 158 | // they can only exist if valid; stack overflows/underflows sunk as nulls without exceptions. |
||
| 159 | |||
| 160 | // Check if the formula has a valid starting = |
||
| 161 | $formulaLength = strlen($this->_formula); |
||
| 162 | if ($formulaLength < 2 || $this->_formula{0} != '=') return; |
||
| 163 | |||
| 164 | // Helper variables |
||
| 165 | $tokens1 = $tokens2 = $stack = array(); |
||
| 166 | $inString = $inPath = $inRange = $inError = false; |
||
| 167 | $token = $previousToken = $nextToken = null; |
||
| 168 | |||
| 169 | $index = 1; |
||
| 170 | $value = ''; |
||
| 171 | |||
| 172 | $ERRORS = array("#NULL!", "#DIV/0!", "#VALUE!", "#REF!", "#NAME?", "#NUM!", "#N/A"); |
||
| 173 | $COMPARATORS_MULTI = array(">=", "<=", "<>"); |
||
| 174 | |||
| 175 | while ($index < $formulaLength) { |
||
| 176 | // state-dependent character evaluation (order is important) |
||
| 177 | |||
| 178 | // double-quoted strings |
||
| 179 | // embeds are doubled |
||
| 180 | // end marks token |
||
| 181 | if ($inString) { |
||
| 182 | if ($this->_formula{$index} == PHPExcel_Calculation_FormulaParser::QUOTE_DOUBLE) { |
||
| 183 | if ((($index + 2) <= $formulaLength) && ($this->_formula{$index + 1} == PHPExcel_Calculation_FormulaParser::QUOTE_DOUBLE)) { |
||
| 184 | $value .= PHPExcel_Calculation_FormulaParser::QUOTE_DOUBLE; |
||
| 185 | ++$index; |
||
| 186 | } else { |
||
| 187 | $inString = false; |
||
| 188 | $tokens1[] = new PHPExcel_Calculation_FormulaToken($value, PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_OPERAND, PHPExcel_Calculation_FormulaToken::TOKEN_SUBTYPE_TEXT); |
||
| 189 | $value = ""; |
||
| 190 | } |
||
| 191 | } else { |
||
| 192 | $value .= $this->_formula{$index}; |
||
| 193 | } |
||
| 194 | ++$index; |
||
| 195 | continue; |
||
| 196 | } |
||
| 197 | |||
| 198 | // single-quoted strings (links) |
||
| 199 | // embeds are double |
||
| 200 | // end does not mark a token |
||
| 201 | if ($inPath) { |
||
| 202 | if ($this->_formula{$index} == PHPExcel_Calculation_FormulaParser::QUOTE_SINGLE) { |
||
| 203 | if ((($index + 2) <= $formulaLength) && ($this->_formula{$index + 1} == PHPExcel_Calculation_FormulaParser::QUOTE_SINGLE)) { |
||
| 204 | $value .= PHPExcel_Calculation_FormulaParser::QUOTE_SINGLE; |
||
| 205 | ++$index; |
||
| 206 | } else { |
||
| 207 | $inPath = false; |
||
| 208 | } |
||
| 209 | } else { |
||
| 210 | $value .= $this->_formula{$index}; |
||
| 211 | } |
||
| 212 | ++$index; |
||
| 213 | continue; |
||
| 214 | } |
||
| 215 | |||
| 216 | // bracked strings (R1C1 range index or linked workbook name) |
||
| 217 | // no embeds (changed to "()" by Excel) |
||
| 218 | // end does not mark a token |
||
| 219 | if ($inRange) { |
||
| 220 | if ($this->_formula{$index} == PHPExcel_Calculation_FormulaParser::BRACKET_CLOSE) { |
||
| 221 | $inRange = false; |
||
| 222 | } |
||
| 223 | $value .= $this->_formula{$index}; |
||
| 224 | ++$index; |
||
| 225 | continue; |
||
| 226 | } |
||
| 227 | |||
| 228 | // error values |
||
| 229 | // end marks a token, determined from absolute list of values |
||
| 230 | if ($inError) { |
||
| 231 | $value .= $this->_formula{$index}; |
||
| 232 | ++$index; |
||
| 233 | if (in_array($value, $ERRORS)) { |
||
| 234 | $inError = false; |
||
| 235 | $tokens1[] = new PHPExcel_Calculation_FormulaToken($value, PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_OPERAND, PHPExcel_Calculation_FormulaToken::TOKEN_SUBTYPE_ERROR); |
||
| 236 | $value = ""; |
||
| 237 | } |
||
| 238 | continue; |
||
| 239 | } |
||
| 240 | |||
| 241 | // scientific notation check |
||
| 242 | if (strpos(PHPExcel_Calculation_FormulaParser::OPERATORS_SN, $this->_formula{$index}) !== false) { |
||
| 243 | if (strlen($value) > 1) { |
||
| 244 | if (preg_match("/^[1-9]{1}(\.[0-9]+)?E{1}$/", $this->_formula{$index}) != 0) { |
||
| 245 | $value .= $this->_formula{$index}; |
||
| 246 | ++$index; |
||
| 247 | continue; |
||
| 248 | } |
||
| 249 | } |
||
| 250 | } |
||
| 251 | |||
| 252 | // independent character evaluation (order not important) |
||
| 253 | |||
| 254 | // establish state-dependent character evaluations |
||
| 255 | View Code Duplication | if ($this->_formula{$index} == PHPExcel_Calculation_FormulaParser::QUOTE_DOUBLE) { |
|
| 256 | if (strlen($value > 0)) { // unexpected |
||
| 257 | $tokens1[] = new PHPExcel_Calculation_FormulaToken($value, PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_UNKNOWN); |
||
| 258 | $value = ""; |
||
| 259 | } |
||
| 260 | $inString = true; |
||
| 261 | ++$index; |
||
| 262 | continue; |
||
| 263 | } |
||
| 264 | |||
| 265 | View Code Duplication | if ($this->_formula{$index} == PHPExcel_Calculation_FormulaParser::QUOTE_SINGLE) { |
|
| 266 | if (strlen($value) > 0) { // unexpected |
||
| 267 | $tokens1[] = new PHPExcel_Calculation_FormulaToken($value, PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_UNKNOWN); |
||
| 268 | $value = ""; |
||
| 269 | } |
||
| 270 | $inPath = true; |
||
| 271 | ++$index; |
||
| 272 | continue; |
||
| 273 | } |
||
| 274 | |||
| 275 | if ($this->_formula{$index} == PHPExcel_Calculation_FormulaParser::BRACKET_OPEN) { |
||
| 276 | $inRange = true; |
||
| 277 | $value .= PHPExcel_Calculation_FormulaParser::BRACKET_OPEN; |
||
| 278 | ++$index; |
||
| 279 | continue; |
||
| 280 | } |
||
| 281 | |||
| 282 | View Code Duplication | if ($this->_formula{$index} == PHPExcel_Calculation_FormulaParser::ERROR_START) { |
|
| 283 | if (strlen($value) > 0) { // unexpected |
||
| 284 | $tokens1[] = new PHPExcel_Calculation_FormulaToken($value, PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_UNKNOWN); |
||
| 285 | $value = ""; |
||
| 286 | } |
||
| 287 | $inError = true; |
||
| 288 | $value .= PHPExcel_Calculation_FormulaParser::ERROR_START; |
||
| 289 | ++$index; |
||
| 290 | continue; |
||
| 291 | } |
||
| 292 | |||
| 293 | // mark start and end of arrays and array rows |
||
| 294 | if ($this->_formula{$index} == PHPExcel_Calculation_FormulaParser::BRACE_OPEN) { |
||
| 295 | if (strlen($value) > 0) { // unexpected |
||
| 296 | $tokens1[] = new PHPExcel_Calculation_FormulaToken($value, PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_UNKNOWN); |
||
| 297 | $value = ""; |
||
| 298 | } |
||
| 299 | |||
| 300 | $tmp = new PHPExcel_Calculation_FormulaToken("ARRAY", PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_FUNCTION, PHPExcel_Calculation_FormulaToken::TOKEN_SUBTYPE_START); |
||
| 301 | $tokens1[] = $tmp; |
||
| 302 | $stack[] = clone $tmp; |
||
| 303 | |||
| 304 | $tmp = new PHPExcel_Calculation_FormulaToken("ARRAYROW", PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_FUNCTION, PHPExcel_Calculation_FormulaToken::TOKEN_SUBTYPE_START); |
||
| 305 | $tokens1[] = $tmp; |
||
| 306 | $stack[] = clone $tmp; |
||
| 307 | |||
| 308 | ++$index; |
||
| 309 | continue; |
||
| 310 | } |
||
| 311 | |||
| 312 | if ($this->_formula{$index} == PHPExcel_Calculation_FormulaParser::SEMICOLON) { |
||
| 313 | if (strlen($value) > 0) { |
||
| 314 | $tokens1[] = new PHPExcel_Calculation_FormulaToken($value, PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_OPERAND); |
||
| 315 | $value = ""; |
||
| 316 | } |
||
| 317 | |||
| 318 | $tmp = array_pop($stack); |
||
| 319 | $tmp->setValue(""); |
||
| 320 | $tmp->setTokenSubType(PHPExcel_Calculation_FormulaToken::TOKEN_SUBTYPE_STOP); |
||
| 321 | $tokens1[] = $tmp; |
||
| 322 | |||
| 323 | $tmp = new PHPExcel_Calculation_FormulaToken(",", PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_ARGUMENT); |
||
| 324 | $tokens1[] = $tmp; |
||
| 325 | |||
| 326 | $tmp = new PHPExcel_Calculation_FormulaToken("ARRAYROW", PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_FUNCTION, PHPExcel_Calculation_FormulaToken::TOKEN_SUBTYPE_START); |
||
| 327 | $tokens1[] = $tmp; |
||
| 328 | $stack[] = clone $tmp; |
||
| 329 | |||
| 330 | ++$index; |
||
| 331 | continue; |
||
| 332 | } |
||
| 333 | |||
| 334 | if ($this->_formula{$index} == PHPExcel_Calculation_FormulaParser::BRACE_CLOSE) { |
||
| 335 | if (strlen($value) > 0) { |
||
| 336 | $tokens1[] = new PHPExcel_Calculation_FormulaToken($value, PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_OPERAND); |
||
| 337 | $value = ""; |
||
| 338 | } |
||
| 339 | |||
| 340 | $tmp = array_pop($stack); |
||
| 341 | $tmp->setValue(""); |
||
| 342 | $tmp->setTokenSubType(PHPExcel_Calculation_FormulaToken::TOKEN_SUBTYPE_STOP); |
||
| 343 | $tokens1[] = $tmp; |
||
| 344 | |||
| 345 | $tmp = array_pop($stack); |
||
| 346 | $tmp->setValue(""); |
||
| 347 | $tmp->setTokenSubType(PHPExcel_Calculation_FormulaToken::TOKEN_SUBTYPE_STOP); |
||
| 348 | $tokens1[] = $tmp; |
||
| 349 | |||
| 350 | ++$index; |
||
| 351 | continue; |
||
| 352 | } |
||
| 353 | |||
| 354 | // trim white-space |
||
| 355 | if ($this->_formula{$index} == PHPExcel_Calculation_FormulaParser::WHITESPACE) { |
||
| 356 | if (strlen($value) > 0) { |
||
| 357 | $tokens1[] = new PHPExcel_Calculation_FormulaToken($value, PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_OPERAND); |
||
| 358 | $value = ""; |
||
| 359 | } |
||
| 360 | $tokens1[] = new PHPExcel_Calculation_FormulaToken("", PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_WHITESPACE); |
||
| 361 | ++$index; |
||
| 362 | while (($this->_formula{$index} == PHPExcel_Calculation_FormulaParser::WHITESPACE) && ($index < $formulaLength)) { |
||
| 363 | ++$index; |
||
| 364 | } |
||
| 365 | continue; |
||
| 366 | } |
||
| 367 | |||
| 368 | // multi-character comparators |
||
| 369 | if (($index + 2) <= $formulaLength) { |
||
| 370 | if (in_array(substr($this->_formula, $index, 2), $COMPARATORS_MULTI)) { |
||
| 371 | if (strlen($value) > 0) { |
||
| 372 | $tokens1[] = new PHPExcel_Calculation_FormulaToken($value, PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_OPERAND); |
||
| 373 | $value = ""; |
||
| 374 | } |
||
| 375 | $tokens1[] = new PHPExcel_Calculation_FormulaToken(substr($this->_formula, $index, 2), PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_OPERATORINFIX, PHPExcel_Calculation_FormulaToken::TOKEN_SUBTYPE_LOGICAL); |
||
| 376 | $index += 2; |
||
| 377 | continue; |
||
| 378 | } |
||
| 379 | } |
||
| 380 | |||
| 381 | // standard infix operators |
||
| 382 | View Code Duplication | if (strpos(PHPExcel_Calculation_FormulaParser::OPERATORS_INFIX, $this->_formula{$index}) !== false) { |
|
| 383 | if (strlen($value) > 0) { |
||
| 384 | $tokens1[] =new PHPExcel_Calculation_FormulaToken($value, PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_OPERAND); |
||
| 385 | $value = ""; |
||
| 386 | } |
||
| 387 | $tokens1[] = new PHPExcel_Calculation_FormulaToken($this->_formula{$index}, PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_OPERATORINFIX); |
||
| 388 | ++$index; |
||
| 389 | continue; |
||
| 390 | } |
||
| 391 | |||
| 392 | // standard postfix operators (only one) |
||
| 393 | View Code Duplication | if (strpos(PHPExcel_Calculation_FormulaParser::OPERATORS_POSTFIX, $this->_formula{$index}) !== false) { |
|
| 394 | if (strlen($value) > 0) { |
||
| 395 | $tokens1[] = new PHPExcel_Calculation_FormulaToken($value, PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_OPERAND); |
||
| 396 | $value = ""; |
||
| 397 | } |
||
| 398 | $tokens1[] = new PHPExcel_Calculation_FormulaToken($this->_formula{$index}, PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_OPERATORPOSTFIX); |
||
| 399 | ++$index; |
||
| 400 | continue; |
||
| 401 | } |
||
| 402 | |||
| 403 | // start subexpression or function |
||
| 404 | if ($this->_formula{$index} == PHPExcel_Calculation_FormulaParser::PAREN_OPEN) { |
||
| 405 | if (strlen($value) > 0) { |
||
| 406 | $tmp = new PHPExcel_Calculation_FormulaToken($value, PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_FUNCTION, PHPExcel_Calculation_FormulaToken::TOKEN_SUBTYPE_START); |
||
| 407 | $tokens1[] = $tmp; |
||
| 408 | $stack[] = clone $tmp; |
||
| 409 | $value = ""; |
||
| 410 | } else { |
||
| 411 | $tmp = new PHPExcel_Calculation_FormulaToken("", PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_SUBEXPRESSION, PHPExcel_Calculation_FormulaToken::TOKEN_SUBTYPE_START); |
||
| 412 | $tokens1[] = $tmp; |
||
| 413 | $stack[] = clone $tmp; |
||
| 414 | } |
||
| 415 | ++$index; |
||
| 416 | continue; |
||
| 417 | } |
||
| 418 | |||
| 419 | // function, subexpression, or array parameters, or operand unions |
||
| 420 | if ($this->_formula{$index} == PHPExcel_Calculation_FormulaParser::COMMA) { |
||
| 421 | if (strlen($value) > 0) { |
||
| 422 | $tokens1[] = new PHPExcel_Calculation_FormulaToken($value, PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_OPERAND); |
||
| 423 | $value = ""; |
||
| 424 | } |
||
| 425 | |||
| 426 | $tmp = array_pop($stack); |
||
| 427 | $tmp->setValue(""); |
||
| 428 | $tmp->setTokenSubType(PHPExcel_Calculation_FormulaToken::TOKEN_SUBTYPE_STOP); |
||
| 429 | $stack[] = $tmp; |
||
| 430 | |||
| 431 | if ($tmp->getTokenType() == PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_FUNCTION) { |
||
| 432 | $tokens1[] = new PHPExcel_Calculation_FormulaToken(",", PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_OPERATORINFIX, PHPExcel_Calculation_FormulaToken::TOKEN_SUBTYPE_UNION); |
||
| 433 | } else { |
||
| 434 | $tokens1[] = new PHPExcel_Calculation_FormulaToken(",", PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_ARGUMENT); |
||
| 435 | } |
||
| 436 | ++$index; |
||
| 437 | continue; |
||
| 438 | } |
||
| 439 | |||
| 440 | // stop subexpression |
||
| 441 | if ($this->_formula{$index} == PHPExcel_Calculation_FormulaParser::PAREN_CLOSE) { |
||
| 442 | if (strlen($value) > 0) { |
||
| 443 | $tokens1[] = new PHPExcel_Calculation_FormulaToken($value, PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_OPERAND); |
||
| 444 | $value = ""; |
||
| 445 | } |
||
| 446 | |||
| 447 | $tmp = array_pop($stack); |
||
| 448 | $tmp->setValue(""); |
||
| 449 | $tmp->setTokenSubType(PHPExcel_Calculation_FormulaToken::TOKEN_SUBTYPE_STOP); |
||
| 450 | $tokens1[] = $tmp; |
||
| 451 | |||
| 452 | ++$index; |
||
| 453 | continue; |
||
| 454 | } |
||
| 455 | |||
| 456 | // token accumulation |
||
| 457 | $value .= $this->_formula{$index}; |
||
| 458 | ++$index; |
||
| 459 | } |
||
| 460 | |||
| 461 | // dump remaining accumulation |
||
| 462 | if (strlen($value) > 0) { |
||
| 463 | $tokens1[] = new PHPExcel_Calculation_FormulaToken($value, PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_OPERAND); |
||
| 464 | } |
||
| 465 | |||
| 466 | // move tokenList to new set, excluding unnecessary white-space tokens and converting necessary ones to intersections |
||
| 467 | $tokenCount = count($tokens1); |
||
| 468 | for ($i = 0; $i < $tokenCount; ++$i) { |
||
| 469 | $token = $tokens1[$i]; |
||
| 470 | if (isset($tokens1[$i - 1])) { |
||
| 471 | $previousToken = $tokens1[$i - 1]; |
||
| 472 | } else { |
||
| 473 | $previousToken = null; |
||
| 474 | } |
||
| 475 | if (isset($tokens1[$i + 1])) { |
||
| 476 | $nextToken = $tokens1[$i + 1]; |
||
| 477 | } else { |
||
| 478 | $nextToken = null; |
||
| 479 | } |
||
| 480 | |||
| 481 | if (is_null($token)) { |
||
| 482 | continue; |
||
| 483 | } |
||
| 484 | |||
| 485 | if ($token->getTokenType() != PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_WHITESPACE) { |
||
| 486 | $tokens2[] = $token; |
||
| 487 | continue; |
||
| 488 | } |
||
| 489 | |||
| 490 | if (is_null($previousToken)) { |
||
| 491 | continue; |
||
| 492 | } |
||
| 493 | |||
| 494 | View Code Duplication | if (! ( |
|
| 495 | (($previousToken->getTokenType() == PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_FUNCTION) && ($previousToken->getTokenSubType() == PHPExcel_Calculation_FormulaToken::TOKEN_SUBTYPE_STOP)) || |
||
| 496 | (($previousToken->getTokenType() == PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_SUBEXPRESSION) && ($previousToken->getTokenSubType() == PHPExcel_Calculation_FormulaToken::TOKEN_SUBTYPE_STOP)) || |
||
| 497 | ($previousToken->getTokenType() == PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_OPERAND) |
||
| 498 | ) ) { |
||
| 499 | continue; |
||
| 500 | } |
||
| 501 | |||
| 502 | if (is_null($nextToken)) { |
||
| 503 | continue; |
||
| 504 | } |
||
| 505 | |||
| 506 | View Code Duplication | if (! ( |
|
| 507 | (($nextToken->getTokenType() == PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_FUNCTION) && ($nextToken->getTokenSubType() == PHPExcel_Calculation_FormulaToken::TOKEN_SUBTYPE_START)) || |
||
| 508 | (($nextToken->getTokenType() == PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_SUBEXPRESSION) && ($nextToken->getTokenSubType() == PHPExcel_Calculation_FormulaToken::TOKEN_SUBTYPE_START)) || |
||
| 509 | ($nextToken->getTokenType() == PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_OPERAND) |
||
| 510 | ) ) { |
||
| 511 | continue; |
||
| 512 | } |
||
| 513 | |||
| 514 | $tokens2[] = new PHPExcel_Calculation_FormulaToken($value, PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_OPERATORINFIX, PHPExcel_Calculation_FormulaToken::TOKEN_SUBTYPE_INTERSECTION); |
||
| 515 | } |
||
| 516 | |||
| 517 | // move tokens to final list, switching infix "-" operators to prefix when appropriate, switching infix "+" operators |
||
| 518 | // to noop when appropriate, identifying operand and infix-operator subtypes, and pulling "@" from function names |
||
| 519 | $this->_tokens = array(); |
||
| 520 | |||
| 521 | $tokenCount = count($tokens2); |
||
| 522 | for ($i = 0; $i < $tokenCount; ++$i) { |
||
| 523 | $token = $tokens2[$i]; |
||
| 524 | if (isset($tokens2[$i - 1])) { |
||
| 525 | $previousToken = $tokens2[$i - 1]; |
||
| 526 | } else { |
||
| 527 | $previousToken = null; |
||
| 528 | } |
||
| 529 | if (isset($tokens2[$i + 1])) { |
||
| 530 | $nextToken = $tokens2[$i + 1]; |
||
| 531 | } else { |
||
| 532 | $nextToken = null; |
||
| 533 | } |
||
| 534 | |||
| 535 | if (is_null($token)) { |
||
| 536 | continue; |
||
| 537 | } |
||
| 538 | |||
| 539 | if ($token->getTokenType() == PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_OPERATORINFIX && $token->getValue() == "-") { |
||
| 540 | if ($i == 0) { |
||
| 541 | $token->setTokenType(PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_OPERATORPREFIX); |
||
| 542 | View Code Duplication | } else if ( |
|
| 543 | (($previousToken->getTokenType() == PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_FUNCTION) && ($previousToken->getTokenSubType() == PHPExcel_Calculation_FormulaToken::TOKEN_SUBTYPE_STOP)) || |
||
| 544 | (($previousToken->getTokenType() == PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_SUBEXPRESSION) && ($previousToken->getTokenSubType() == PHPExcel_Calculation_FormulaToken::TOKEN_SUBTYPE_STOP)) || |
||
| 545 | ($previousToken->getTokenType() == PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_OPERATORPOSTFIX) || |
||
| 546 | ($previousToken->getTokenType() == PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_OPERAND) |
||
| 547 | ) { |
||
| 548 | $token->setTokenSubType(PHPExcel_Calculation_FormulaToken::TOKEN_SUBTYPE_MATH); |
||
| 549 | } else { |
||
| 550 | $token->setTokenType(PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_OPERATORPREFIX); |
||
| 551 | } |
||
| 552 | |||
| 553 | $this->_tokens[] = $token; |
||
| 554 | continue; |
||
| 555 | } |
||
| 556 | |||
| 557 | if ($token->getTokenType() == PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_OPERATORINFIX && $token->getValue() == "+") { |
||
| 558 | if ($i == 0) { |
||
| 559 | continue; |
||
| 560 | View Code Duplication | } else if ( |
|
| 561 | (($previousToken->getTokenType() == PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_FUNCTION) && ($previousToken->getTokenSubType() == PHPExcel_Calculation_FormulaToken::TOKEN_SUBTYPE_STOP)) || |
||
| 562 | (($previousToken->getTokenType() == PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_SUBEXPRESSION) && ($previousToken->getTokenSubType() == PHPExcel_Calculation_FormulaToken::TOKEN_SUBTYPE_STOP)) || |
||
| 563 | ($previousToken->getTokenType() == PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_OPERATORPOSTFIX) || |
||
| 564 | ($previousToken->getTokenType() == PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_OPERAND) |
||
| 565 | ) { |
||
| 566 | $token->setTokenSubType(PHPExcel_Calculation_FormulaToken::TOKEN_SUBTYPE_MATH); |
||
| 567 | } else { |
||
| 568 | continue; |
||
| 569 | } |
||
| 570 | |||
| 571 | $this->_tokens[] = $token; |
||
| 572 | continue; |
||
| 573 | } |
||
| 574 | |||
| 575 | if ($token->getTokenType() == PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_OPERATORINFIX && $token->getTokenSubType() == PHPExcel_Calculation_FormulaToken::TOKEN_SUBTYPE_NOTHING) { |
||
| 576 | if (strpos("<>=", substr($token->getValue(), 0, 1)) !== false) { |
||
| 577 | $token->setTokenSubType(PHPExcel_Calculation_FormulaToken::TOKEN_SUBTYPE_LOGICAL); |
||
| 578 | } else if ($token->getValue() == "&") { |
||
| 579 | $token->setTokenSubType(PHPExcel_Calculation_FormulaToken::TOKEN_SUBTYPE_CONCATENATION); |
||
| 580 | } else { |
||
| 581 | $token->setTokenSubType(PHPExcel_Calculation_FormulaToken::TOKEN_SUBTYPE_MATH); |
||
| 582 | } |
||
| 583 | |||
| 584 | $this->_tokens[] = $token; |
||
| 585 | continue; |
||
| 586 | } |
||
| 587 | |||
| 588 | if ($token->getTokenType() == PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_OPERAND && $token->getTokenSubType() == PHPExcel_Calculation_FormulaToken::TOKEN_SUBTYPE_NOTHING) { |
||
| 589 | if (!is_numeric($token->getValue())) { |
||
| 590 | if (strtoupper($token->getValue()) == "TRUE" || strtoupper($token->getValue() == "FALSE")) { |
||
| 591 | $token->setTokenSubType(PHPExcel_Calculation_FormulaToken::TOKEN_SUBTYPE_LOGICAL); |
||
| 592 | } else { |
||
| 593 | $token->setTokenSubType(PHPExcel_Calculation_FormulaToken::TOKEN_SUBTYPE_RANGE); |
||
| 594 | } |
||
| 595 | } else { |
||
| 596 | $token->setTokenSubType(PHPExcel_Calculation_FormulaToken::TOKEN_SUBTYPE_NUMBER); |
||
| 597 | } |
||
| 598 | |||
| 599 | $this->_tokens[] = $token; |
||
| 600 | continue; |
||
| 601 | } |
||
| 602 | |||
| 603 | if ($token->getTokenType() == PHPExcel_Calculation_FormulaToken::TOKEN_TYPE_FUNCTION) { |
||
| 604 | if (strlen($token->getValue() > 0)) { |
||
| 605 | if (substr($token->getValue(), 0, 1) == "@") { |
||
| 606 | $token->setValue(substr($token->getValue(), 1)); |
||
| 607 | } |
||
| 608 | } |
||
| 609 | } |
||
| 610 | |||
| 611 | $this->_tokens[] = $token; |
||
| 612 | } |
||
| 613 | } |
||
| 614 | } |
||
| 615 |
