Parse and compute the error types expression

@return int the parsed expression
@throws \InvalidArgumentException
357612
public function parse(): int
    {
        // convert constants to ints
        $this->expression = $this->convertErrorConstants($this->expression);
        $this->expression = str_replace(
            [',', ' '],
            ['.', ''],
            $this->expression
        );

        return $this->compute($this->expression);
    }
893799
protected function getExceptionCode()
    {
        $exception = $this->getException();

        $code = $exception->getCode();
        if ($exception instanceof \ErrorException) {
            // ErrorExceptions wrap the php-error types within the 'severity' property
            $code = Misc::translateErrorCode($exception->getSeverity());
        }

        return (string) $code;
    }
1347309
protected function buildErrorData()
    {
        if (is_null($this->errorCode)) {
            return null;
        }

        $data = [
            'code' => $this->errorCode,
            'message' => $this->message ?: $this->resolveMessage()
        ];

        return array_merge($data, $this->data);
    }
834294
public function parse()
    {
        $types = $this->getGenerator()
            ->getSoapClient()
            ->getSoapClient()
            ->getSoapClient()
            ->__getTypes();
        foreach ($types as $type) {
            $this->parseType($type);
        }
    }
127253
public static function parse($expression)
    {
        if (trim($expression) === '') {
            throw new InvalidArgumentException('Console command definition is empty.');
        }

        preg_match('/[^\s]+/', $expression, $matches);

        if (isset($matches[0])) {
            $name = $matches[0];
        } else {
            throw new InvalidArgumentException('Unable to determine command name from signature.');
        }

        preg_match_all('/\{\s*(.*?)\s*\}/', $expression, $matches);

        $tokens = isset($matches[1]) ? $matches[1] : [];

        if (count($tokens)) {
            return array_merge([$name], static::parameters($tokens));
        }

        return [$name, [], []];
    }
181379
public function getValidationErrors()
    {
        $errors = $this->errors;

        if (isset($this->validator)) {
            $validator_errors = $this->validator->getErrors();
            $errors = array_merge($errors, $validator_errors);
        }

        return $errors;
    }
1034704
public function errors(): ParamErrors
    {
        if (null === $this->errors) {
            $this->errors = new ParamErrors();
        }

        return $this->errors;
    }
163810
public function check()
    {
        if ($this->valueChanged && $this->readonly) {
            return array('read_only', $this->printName());
        }

        if (null === $this->value || '' === $this->value) {
            if ($this->required) {
                return array('value_required', $this->printName());
            }
        } else {
            // Expressions régulière
            if ($this->regex) {
                if (!preg_match('/'.$this->regex.'/mUsi', $this->value)) {
                    return array('bad_format', $this->printName());
                }
            }

            // Longueur minimum et maximum
            if ($this->minlength && strlen($this->value) < $this->minlength) {
                return array('at_least', $this->printName(), $this->minlength);
            }

            if ($this->maxlength && strlen($this->value) > $this->maxlength) {
                return array('not_more', $this->printName(), $this->maxlength);
            }
        }

        // Custom constraints
        foreach ($this->constraints as $constraint) {
            $error = $constraint($this->value);
            if ($error) {
                return $error;
            }
        }
    }
159709
public function parse()
    {
        $error = (string) $this->data;
        $exceptionClass = $this->getExceptionClass($error);
        return new $exceptionClass($error);
    }
40927
public function parse()
    {
        $where = [];

        foreach ($this->where as $key => $val) {
            if ($val instanceof Expression) {
                $where[] = [$key, 'exp', $val];
            } elseif (is_null($val)) {
                $where[] = [$key, 'NULL', ''];
            } elseif (is_array($val)) {
                $where[] = $this->parseItem($key, $val);
            } else {
                $where[] = [$key, '=', $val];
            }
        }

        return $this->enclose ? [$where] : $where;
    }
528205
public function errno() : Int
    {
        if( ! is_resource($this->init) )
        {
            throw new InvalidArgumentException(NULL, '$this->init');
        }

        return curl_errno($this->init);
    }
72415
protected function checkValue(): void
    {
        if (!ctype_digit($this->value) && !is_numeric($this->value) && !empty($this->value)) {
            throw new InvalidArgumentException('NumericParser: Value must be of type numeric');
        }
    }
461487
final public function error()	{
      if ($this->resultset) {
         $pdo_error        = $this->resultset->errorInfo();
         $error['code']    = @$pdo_error[1] ? $pdo_error[0].'/'.$pdo_error[1] : $pdo_error[0];
         $error['message'] =  $pdo_error[2];
      }
      else {
         $error['code']    = '00000';
         $error['message'] = 'ERROR: No hay conexión a la base de datos';
      }

      return $error;
   }
249174
public function error() {
		$errors = array();

		foreach (func_get_args() as $msg) {
			if (is_array($msg)) {
				$errors = array_merge($errors, $msg);
			} else {
				$errors[] = $msg;
			}
		}
		
		return count($errors) ? $errors : array(self::ERROR_UNKNOWN);
	}
221075
static function Parse($string) {
        $result = null;
        if (!self::TryParse($string, $result)) {
            throw new \InvalidArgumentException("'$string' could not be converted to a number");
        }
        return $result;
    }
256420
public function parse($input, $allowedTokenType = null)
    {
        if (null !== $allowedTokenType && !is_integer($allowedTokenType)) {
            throw new \InvalidArgumentException('Allowed operator must be an integer.');
        }

        $this->allowedTokenType = $allowedTokenType ?: Lexer::T_ALL;
        $this->supportedTokenType = $this->expressionBuilder->getSupportedTokenType();

        try {
            $this->lexer->setInput($input);
            $this->lexer->moveNext();

            return $this->getExpression();
        } catch (LexerException $exception) {
            throw new InvalidExpressionException($input, '', 0, $exception);
        } catch (ParserException $exception) {
            throw new InvalidExpressionException($input, '', 0, $exception);
        }
    }
951023
protected function parse()
    {
        // Try to parse and fail on any exception ...
        try {
            $this->getFlags()->parse();

            // Extract parsed arguments
            $this
                ->longs($this->getFlags()->longs())
                ->shorts($this->getFlags()->shorts())
                ->arguments($this->getFlags()->args());
        } catch (InvalidFlagParamException $e) {
            $this->showHelp($e->getMessage());
        } catch (InvalidFlagTypeException $e) {
            $this->showHelp($e->getMessage());
        }

        return $this;
    }