BitWasp\Bitcoin\Script\Parser\Parser

Complexity

Total Complexity

29

Size/Duplication

Total Lines	213
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Test Coverage

Coverage

89.41%

Importance

Changes	1
Bugs	0	Features	0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	8	1
A	getPosition()	0	4	1
A	unpackSize()	0	11	2
A	validateSize()	0	5	2
D	doNext()	0	34	9
A	rewind()	0	4	1
A	current()	0	10	2
A	key()	0	4	1
A	next()	0	10	2
A	valid()	0	4	2
A	parse()	0	21	4
A	getHumanReadable()	0	15	2

<?php

namespace BitWasp\Bitcoin\Script\Parser;

use BitWasp\Bitcoin\Bitcoin;
use BitWasp\Bitcoin\Script\Opcodes;
use BitWasp\Bitcoin\Script\Parser\Operation;
use BitWasp\Bitcoin\Math\Math;
use BitWasp\Bitcoin\Script\ScriptInterface;
use BitWasp\Buffertools\Buffer;

class Parser implements \Iterator
{
    /**
     * @var int
     */
    private $position = 0;

    /**
     * @var int
     */
    private $end = 0;

    /**
     * @var int
     */
    private $execPtr = 0;

    /**
     * @var string
     */
    private $data = '';

    /**
     * @var Operation[]
     */
    private $array = array();

    /**
     * ScriptParser constructor.
     * @param Math $math
     * @param ScriptInterface $script
     */
    public function __construct(Math $math, ScriptInterface $script)

The parameter $math is not used and could be removed.

    {
        $this->math = Bitcoin::getMath();

The property math does not exist. Did you maybe forget to declare it?

        $buffer = $script->getBuffer();
        $this->data = $buffer->getBinary();
        $this->end = $buffer->getSize();

It seems like $buffer->getSize() can also be of type string. However, the property $end is declared as type integer. Maybe add an additional type check?

        $this->script = $script;

The property script does not exist. Did you maybe forget to declare it?

    }

    /**
     * @return int
     */
    public function getPosition()
    {
        return $this->position;
    }

    /**
     * @param string $packFormat
     * @param integer $strSize
     * @return array|bool
     */
    private function unpackSize($packFormat, $strSize)
    {
        if ($this->end - $this->position < $strSize) {
            return false;
        }
        $size = unpack($packFormat, substr($this->data, $this->position, $strSize));
        $size = $size[1];
        $this->position += $strSize;

        return $size;
    }

    /**
     * @param int $size
     * @return bool
     */
    private function validateSize($size)
    {
        $pdif = ($this->end - $this->position);
        return ! ($pdif < 0 || $pdif < $size);
    }

    /**
     * @param int $ptr
     * @return Operation
     */
    private function doNext($ptr)
    {
        if ($this->math->cmp($this->position, $this->end) >= 0) {
            throw new \RuntimeException('Position exceeds end of script!');
        }

        $opCode = ord($this->data[$this->position++]);
        $pushData = null;

        if ($opCode === Opcodes::OP_0) {
            $pushData = new Buffer('', 0);
        } elseif ($opCode <= Opcodes::OP_PUSHDATA4) {
            if ($opCode < Opcodes::OP_PUSHDATA1) {
                $size = $opCode;
            } else if ($opCode === Opcodes::OP_PUSHDATA1) {
                $size = $this->unpackSize('C', 1);
            } else if ($opCode === Opcodes::OP_PUSHDATA2) {
                $size = $this->unpackSize('v', 2);
            } else {
                $size = $this->unpackSize('V', 4);
            }

            if ($size === false || $this->validateSize($size) === false) {
                throw new \RuntimeException('Failed to unpack data from Script');
            }

            $pushData = new Buffer(substr($this->data, $this->position, $size), $size, $this->math);
            $this->position += $size;
        }

        $this->array[$ptr] = $result = new Operation($opCode, $pushData);

        return $result;
    }

    /**
     *
     */
    public function rewind()
    {
        $this->execPtr = 0;
    }

    /**
     * @return Operation
     */
    public function current()
    {
        if (isset($this->array[$this->execPtr])) {
            $exec = $this->array[$this->execPtr];
        } else {
            $exec = $this->doNext($this->execPtr);
        }

        return $exec;
    }

    /**
     * @return int
     */
    public function key()
    {
        return $this->execPtr;
    }

    /**
     * @return Operation
     */
    public function next()
    {
        $ptr = $this->execPtr;
        if (isset($this->array[$ptr])) {
            $this->execPtr++;
            return $this->array[$ptr];
        }

        return null;
    }

    /**
     * @return bool
     */
    public function valid()
    {
        return isset($this->array[$this->execPtr]) || $this->position < $this->end;
    }

    /**
     * returns a mix of Buffer objects and strings
     *
     * @return Buffer[]|string[]
     */
    public function parse()
    {
        $data = array();

        $it = $this;
        foreach ($it as $exec) {
            $opCode = $exec->getOp();
            if ($opCode == 0) {
                $push = Buffer::hex('00', 1, $this->math);
            } elseif ($opCode <= 78) {
                $push = $exec->getData();
            } else {
                // None of these are pushdatas, so just an opcode
                $push = $this->script->getOpcodes()->getOp($opCode);
            }

            $data[] = $push;
        }

        return $data;
    }

    /**
     * @return string
     */
    public function getHumanReadable()
    {
        $parse = $this->parse();

        $array = array_map(
            function ($value) {
                return ($value instanceof Buffer)
                    ? $value->getHex()
                    : $value;
            },
            $parse
        );

        return implode(' ', $array);
    }
}