code/trunk/pcre_scanner.cc

// Copyright (c) 2005, Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//     * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
//     * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// Author: Sanjay Ghemawat

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include <vector>
#include <assert.h>

#include "pcrecpp_internal.h"
#include "pcre_scanner.h"

using std::vector;

namespace pcrecpp {

Scanner::Scanner()
  : data_(),
    input_(data_),
    skip_(NULL),
    should_skip_(false),
    skip_repeat_(false),
    save_comments_(false),
    comments_(NULL),
    comments_offset_(0) {
}

Scanner::Scanner(const string& in)
  : data_(in),
    input_(data_),
    skip_(NULL),
    should_skip_(false),
    skip_repeat_(false),
    save_comments_(false),
    comments_(NULL),
    comments_offset_(0) {
}

Scanner::~Scanner() {
  delete skip_;
  delete comments_;
}

void Scanner::SetSkipExpression(const char* re) {
  delete skip_;
  if (re != NULL) {
    skip_ = new RE(re);
    should_skip_ = true;
    skip_repeat_ = true;
    ConsumeSkip();
  } else {
    skip_ = NULL;
    should_skip_ = false;
    skip_repeat_ = false;
  }
}

void Scanner::Skip(const char* re) {
  delete skip_;
  if (re != NULL) {
    skip_ = new RE(re);
    should_skip_ = true;
    skip_repeat_ = false;
    ConsumeSkip();
  } else {
    skip_ = NULL;
    should_skip_ = false;
    skip_repeat_ = false;
  }
}

void Scanner::DisableSkip() {
  assert(skip_ != NULL);
  should_skip_ = false;
}

void Scanner::EnableSkip() {
  assert(skip_ != NULL);
  should_skip_ = true;
  ConsumeSkip();
}

int Scanner::LineNumber() const {
  // TODO: Make it more efficient by keeping track of the last point
  // where we computed line numbers and counting newlines since then.
  // We could use std:count, but not all systems have it. :-(
  int count = 1;
  for (const char* p = data_.data(); p < input_.data(); ++p)
    if (*p == '\n')
      ++count;
  return count;
}

int Scanner::Offset() const {
  return (int)(input_.data() - data_.c_str());
}

bool Scanner::LookingAt(const RE& re) const {
  int consumed;
  return re.DoMatch(input_, RE::ANCHOR_START, &consumed, 0, 0);
}


bool Scanner::Consume(const RE& re,
                      const Arg& arg0,
                      const Arg& arg1,
                      const Arg& arg2) {
  const bool result = re.Consume(&input_, arg0, arg1, arg2);
  if (result && should_skip_) ConsumeSkip();
  return result;
}

// helper function to consume *skip_ and honour save_comments_
void Scanner::ConsumeSkip() {
  const char* start_data = input_.data();
  while (skip_->Consume(&input_)) {
    if (!skip_repeat_) {
      // Only one skip allowed.
      break;
    }
  }
  if (save_comments_) {
    if (comments_ == NULL) {
      comments_ = new vector<StringPiece>;
    }
    // already pointing one past end, so no need to +1
    int length = (int)(input_.data() - start_data);
    if (length > 0) {
      comments_->push_back(StringPiece(start_data, length));
    }
  }
}


void Scanner::GetComments(int start, int end, vector<StringPiece> *ranges) {
  // short circuit out if we've not yet initialized comments_
  // (e.g., when save_comments is false)
  if (!comments_) {
    return;
  }
  // TODO: if we guarantee that comments_ will contain StringPieces
  // that are ordered by their start, then we can do a binary search
  // for the first StringPiece at or past start and then scan for the
  // ones contained in the range, quit early (use equal_range or
  // lower_bound)
  for (vector<StringPiece>::const_iterator it = comments_->begin();
       it != comments_->end(); ++it) {
    if ((it->data() >= data_.c_str() + start &&
         it->data() + it->size() <= data_.c_str() + end)) {
      ranges->push_back(*it);
    }
  }
}


void Scanner::GetNextComments(vector<StringPiece> *ranges) {
  // short circuit out if we've not yet initialized comments_
  // (e.g., when save_comments is false)
  if (!comments_) {
    return;
  }
  for (vector<StringPiece>::const_iterator it =
         comments_->begin() + comments_offset_;
       it != comments_->end(); ++it) {
    ranges->push_back(*it);
    ++comments_offset_;
  }
}

}   // namespace pcrecpp
1	// Copyright (c) 2005, Google Inc.
2	// All rights reserved.
3	//
4	// Redistribution and use in source and binary forms, with or without
5	// modification, are permitted provided that the following conditions are
6	// met:
7	//
8	// * Redistributions of source code must retain the above copyright
9	// notice, this list of conditions and the following disclaimer.
10	// * Redistributions in binary form must reproduce the above
11	// copyright notice, this list of conditions and the following disclaimer
12	// in the documentation and/or other materials provided with the
13	// distribution.
14	// * Neither the name of Google Inc. nor the names of its
15	// contributors may be used to endorse or promote products derived from
16	// this software without specific prior written permission.
17	//
18	// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19	// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20	// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
21	// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
22	// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23	// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
24	// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25	// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26	// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27	// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28	// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29	//
30	// Author: Sanjay Ghemawat
31
32	#ifdef HAVE_CONFIG_H
33	#include "config.h"
34	#endif
35
36	#include <vector>
37	#include <assert.h>
38
39	#include "pcrecpp_internal.h"
40	#include "pcre_scanner.h"
41
42	using std::vector;
43
44	namespace pcrecpp {
45
46	Scanner::Scanner()
47	: data_(),
48	input_(data_),
49	skip_(NULL),
50	should_skip_(false),
51	skip_repeat_(false),
52	save_comments_(false),
53	comments_(NULL),
54	comments_offset_(0) {
55	}
56
57	Scanner::Scanner(const string& in)
58	: data_(in),
59	input_(data_),
60	skip_(NULL),
61	should_skip_(false),
62	skip_repeat_(false),
63	save_comments_(false),
64	comments_(NULL),
65	comments_offset_(0) {
66	}
67
68	Scanner::~Scanner() {
69	delete skip_;
70	delete comments_;
71	}
72
73	void Scanner::SetSkipExpression(const char* re) {
74	delete skip_;
75	if (re != NULL) {
76	skip_ = new RE(re);
77	should_skip_ = true;
78	skip_repeat_ = true;
79	ConsumeSkip();
80	} else {
81	skip_ = NULL;
82	should_skip_ = false;
83	skip_repeat_ = false;
84	}
85	}
86
87	void Scanner::Skip(const char* re) {
88	delete skip_;
89	if (re != NULL) {
90	skip_ = new RE(re);
91	should_skip_ = true;
92	skip_repeat_ = false;
93	ConsumeSkip();
94	} else {
95	skip_ = NULL;
96	should_skip_ = false;
97	skip_repeat_ = false;
98	}
99	}
100
101	void Scanner::DisableSkip() {
102	assert(skip_ != NULL);
103	should_skip_ = false;
104	}
105
106	void Scanner::EnableSkip() {
107	assert(skip_ != NULL);
108	should_skip_ = true;
109	ConsumeSkip();
110	}
111
112	int Scanner::LineNumber() const {
113	// TODO: Make it more efficient by keeping track of the last point
114	// where we computed line numbers and counting newlines since then.
115	// We could use std:count, but not all systems have it. :-(
116	int count = 1;
117	for (const char* p = data_.data(); p < input_.data(); ++p)
118	if (*p == '\n')
119	++count;
120	return count;
121	}
122
123	int Scanner::Offset() const {
124	return (int)(input_.data() - data_.c_str());
125	}
126
127	bool Scanner::LookingAt(const RE& re) const {
128	int consumed;
129	return re.DoMatch(input_, RE::ANCHOR_START, &consumed, 0, 0);
130	}
131
132
133	bool Scanner::Consume(const RE& re,
134	const Arg& arg0,
135	const Arg& arg1,
136	const Arg& arg2) {
137	const bool result = re.Consume(&input_, arg0, arg1, arg2);
138	if (result && should_skip_) ConsumeSkip();
139	return result;
140	}
141
142	// helper function to consume *skip_ and honour save_comments_
143	void Scanner::ConsumeSkip() {
144	const char* start_data = input_.data();
145	while (skip_->Consume(&input_)) {
146	if (!skip_repeat_) {
147	// Only one skip allowed.
148	break;
149	}
150	}
151	if (save_comments_) {
152	if (comments_ == NULL) {
153	comments_ = new vector<StringPiece>;
154	}
155	// already pointing one past end, so no need to +1
156	int length = (int)(input_.data() - start_data);
157	if (length > 0) {
158	comments_->push_back(StringPiece(start_data, length));
159	}
160	}
161	}
162
163
164	void Scanner::GetComments(int start, int end, vector<StringPiece> *ranges) {
165	// short circuit out if we've not yet initialized comments_
166	// (e.g., when save_comments is false)
167	if (!comments_) {
168	return;
169	}
170	// TODO: if we guarantee that comments_ will contain StringPieces
171	// that are ordered by their start, then we can do a binary search
172	// for the first StringPiece at or past start and then scan for the
173	// ones contained in the range, quit early (use equal_range or
174	// lower_bound)
175	for (vector<StringPiece>::const_iterator it = comments_->begin();
176	it != comments_->end(); ++it) {
177	if ((it->data() >= data_.c_str() + start &&
178	it->data() + it->size() <= data_.c_str() + end)) {
179	ranges->push_back(*it);
180	}
181	}
182	}
183
184
185	void Scanner::GetNextComments(vector<StringPiece> *ranges) {
186	// short circuit out if we've not yet initialized comments_
187	// (e.g., when save_comments is false)
188	if (!comments_) {
189	return;
190	}
191	for (vector<StringPiece>::const_iterator it =
192	comments_->begin() + comments_offset_;
193	it != comments_->end(); ++it) {
194	ranges->push_back(*it);
195	++comments_offset_;
196	}
197	}
198
199	} // namespace pcrecpp
Name	Value
svn:eol-style	native
svn:keywords	"Author Date Id Revision Url"