v8::internal::Differencer Class Reference

Collaboration diagram for v8::internal::Differencer:

Classes
class	ResultWriter

Public Member Functions
	Differencer (Comparator::Input *input)
	~Differencer ()
void	Initialize ()
void	FillTable ()
void	SaveResult (Comparator::Output *chunk_writer)

Private Types
enum	Direction {   EQ = 0 , SKIP1 , SKIP2 , SKIP_ANY ,   MAX_DIRECTION_FLAG_VALUE = SKIP_ANY }

Private Member Functions
int	CompareUpToTail (int pos1, int pos2)
int &	get_cell (int i1, int i2)
void	set_value4_and_dir (int i1, int i2, int value4, Direction dir)
int	get_value4 (int i1, int i2)
Direction	get_direction (int i1, int i2)
void	StaticAssertHolder ()

Private Attributes
Comparator::Input *	input_
int *	buffer_
int	len1_
int	len2_

Static Private Attributes
static const int	kDirectionSizeBits = 2
static const int	kDirectionMask = (1 << kDirectionSizeBits) - 1
static const int	kEmptyCellValue = ~0u << kDirectionSizeBits

Detailed Description

Definition at line 39 of file liveedit.cc.

Member Enumeration Documentation

Direction

enum v8::internal::Differencer::Direction

private

Enumerator
EQ
SKIP1
SKIP2
SKIP_ANY
MAX_DIRECTION_FLAG_VALUE

Definition at line 109 of file liveedit.cc.

                 {
    EQ = 0,
    SKIP1,
    SKIP2,
    SKIP_ANY,
 
    MAX_DIRECTION_FLAG_VALUE = SKIP_ANY
  };

Constructor & Destructor Documentation

Differencer()

v8::internal::Differencer::Differencer ( Comparator::Input *  input )

inlineexplicit

Definition at line 41 of file liveedit.cc.

      : input_(input), len1_(input->GetLength1()), len2_(input->GetLength2()) {
    buffer_ = NewArray<int>(len1_ * len2_);
  }

References buffer_, len1_, and len2_.

~Differencer()

v8::internal::Differencer::~Differencer ( )

inline

Definition at line 45 of file liveedit.cc.

                 {
    DeleteArray(buffer_);
  }

References buffer_, and v8::internal::DeleteArray().

Here is the call graph for this function:

Member Function Documentation

CompareUpToTail()

int v8::internal::Differencer::CompareUpToTail ( int  pos1, int  pos2  )

inlineprivate

Definition at line 120 of file liveedit.cc.

                                          {
    if (pos1 < len1_) {
      if (pos2 < len2_) {
        int cached_res = get_value4(pos1, pos2);
        if (cached_res == kEmptyCellValue) {
          Direction dir;
          int res;
          if (input_->Equals(pos1, pos2)) {
            res = CompareUpToTail(pos1 + 1, pos2 + 1);
            dir = EQ;
          } else {
            int res1 = CompareUpToTail(pos1 + 1, pos2) +
                (1 << kDirectionSizeBits);
            int res2 = CompareUpToTail(pos1, pos2 + 1) +
                (1 << kDirectionSizeBits);
            if (res1 == res2) {
              res = res1;
              dir = SKIP_ANY;
            } else if (res1 < res2) {
              res = res1;
              dir = SKIP1;
            } else {
              res = res2;
              dir = SKIP2;
            }
          }
          set_value4_and_dir(pos1, pos2, res, dir);
          cached_res = res;
        }
        return cached_res;
      } else {
        return (len1_ - pos1) << kDirectionSizeBits;
      }
    } else {
      return (len2_ - pos2) << kDirectionSizeBits;
    }
  }

References EQ, v8::internal::Comparator::Input::Equals(), get_value4(), input_, kDirectionSizeBits, kEmptyCellValue, len1_, len2_, set_value4_and_dir(), SKIP1, SKIP2, and SKIP_ANY.

Referenced by FillTable().

Here is the call graph for this function:

Here is the caller graph for this function:

FillTable()

void v8::internal::Differencer::FillTable ( )

inline

Definition at line 58 of file liveedit.cc.

                   {
    CompareUpToTail(0, 0);
  }

References CompareUpToTail().

Referenced by v8::internal::Comparator::CalculateDifference().

Here is the call graph for this function:

Here is the caller graph for this function:

get_cell()

int& v8::internal::Differencer::get_cell ( int  i1, int  i2  )

inlineprivate

Definition at line 158 of file liveedit.cc.

                                       {
    return buffer_[i1 + i2 * len1_];
  }

References buffer_, and len1_.

Referenced by get_direction(), get_value4(), and set_value4_and_dir().

Here is the caller graph for this function:

get_direction()

Direction v8::internal::Differencer::get_direction ( int  i1, int  i2  )

inlineprivate

Definition at line 171 of file liveedit.cc.

                                          {
    return static_cast<Direction>(get_cell(i1, i2) & kDirectionMask);
  }

References get_cell(), and kDirectionMask.

Referenced by SaveResult().

Here is the call graph for this function:

Here is the caller graph for this function:

get_value4()

int v8::internal::Differencer::get_value4 ( int  i1, int  i2  )

inlineprivate

Definition at line 168 of file liveedit.cc.

                                 {
    return get_cell(i1, i2) & (kMaxUInt32 ^ kDirectionMask);
  }

References get_cell(), kDirectionMask, and v8::internal::kMaxUInt32.

Referenced by CompareUpToTail().

Here is the call graph for this function:

Here is the caller graph for this function:

Initialize()

void v8::internal::Differencer::Initialize ( )

inline

Definition at line 49 of file liveedit.cc.

                    {
    int array_size = len1_ * len2_;
    for (int i = 0; i < array_size; i++) {
      buffer_[i] = kEmptyCellValue;
    }
  }

References buffer_, kEmptyCellValue, len1_, and len2_.

Referenced by v8::internal::Comparator::CalculateDifference().

Here is the caller graph for this function:

SaveResult()

void v8::internal::Differencer::SaveResult ( Comparator::Output *  chunk_writer )

inline

Definition at line 62 of file liveedit.cc.

                                                  {
    ResultWriter writer(chunk_writer);
 
    int pos1 = 0;
    int pos2 = 0;
    while (true) {
      if (pos1 < len1_) {
        if (pos2 < len2_) {
          Direction dir = get_direction(pos1, pos2);
          switch (dir) {
            case EQ:
              writer.eq();
              pos1++;
              pos2++;
              break;
            case SKIP1:
              writer.skip1(1);
              pos1++;
              break;
            case SKIP2:
            case SKIP_ANY:
              writer.skip2(1);
              pos2++;
              break;
            default:
              UNREACHABLE();
          }
        } else {
          writer.skip1(len1_ - pos1);
          break;
        }
      } else {
        if (len2_ != pos2) {
          writer.skip2(len2_ - pos2);
        }
        break;
      }
    }
    writer.close();
  }

References v8::internal::Differencer::ResultWriter::close(), EQ, v8::internal::Differencer::ResultWriter::eq(), get_direction(), len1_, len2_, SKIP1, v8::internal::Differencer::ResultWriter::skip1(), SKIP2, v8::internal::Differencer::ResultWriter::skip2(), SKIP_ANY, and UNREACHABLE.

Referenced by v8::internal::Comparator::CalculateDifference().

Here is the call graph for this function:

Here is the caller graph for this function:

set_value4_and_dir()

void v8::internal::Differencer::set_value4_and_dir ( int  i1, int  i2, int  value4, Direction  dir  )

inlineprivate

Definition at line 163 of file liveedit.cc.

                                                                     {
    DCHECK((value4 & kDirectionMask) == 0);
    get_cell(i1, i2) = value4 | dir;
  }

References DCHECK, get_cell(), and kDirectionMask.

Referenced by CompareUpToTail().

Here is the call graph for this function:

Here is the caller graph for this function:

StaticAssertHolder()

void v8::internal::Differencer::StaticAssertHolder ( )

inlineprivate

Definition at line 181 of file liveedit.cc.

                            {
    STATIC_ASSERT(MAX_DIRECTION_FLAG_VALUE < (1 << kDirectionSizeBits));
  }

References kDirectionSizeBits, MAX_DIRECTION_FLAG_VALUE, and v8::internal::STATIC_ASSERT().

Here is the call graph for this function:

Member Data Documentation

buffer_

int* v8::internal::Differencer::buffer_

private

Definition at line 105 of file liveedit.cc.

Referenced by Differencer(), get_cell(), Initialize(), and ~Differencer().

input_

Comparator::Input* v8::internal::Differencer::input_

private

Definition at line 104 of file liveedit.cc.

Referenced by CompareUpToTail().

kDirectionMask

const int v8::internal::Differencer::kDirectionMask = (1 << kDirectionSizeBits) - 1

staticprivate

Definition at line 176 of file liveedit.cc.

Referenced by get_direction(), get_value4(), and set_value4_and_dir().

kDirectionSizeBits

const int v8::internal::Differencer::kDirectionSizeBits = 2

staticprivate

Definition at line 175 of file liveedit.cc.

Referenced by CompareUpToTail(), and StaticAssertHolder().

kEmptyCellValue

const int v8::internal::Differencer::kEmptyCellValue = ~0u << kDirectionSizeBits

staticprivate

Definition at line 177 of file liveedit.cc.

Referenced by CompareUpToTail(), and Initialize().

len1_

int v8::internal::Differencer::len1_

private

Definition at line 106 of file liveedit.cc.

Referenced by CompareUpToTail(), Differencer(), get_cell(), Initialize(), and SaveResult().

len2_

int v8::internal::Differencer::len2_

private

Definition at line 107 of file liveedit.cc.

Referenced by CompareUpToTail(), Differencer(), Initialize(), and SaveResult().

---

The documentation for this class was generated from the following file:

• /mnt/V8SourceCode/src/liveedit.cc