Merge branch 'master' into cnttp

# Conflicts:
#	include/ctll/parser.hpp
#	include/ctre/literals.hpp
#	tests/generating.cpp
#	tests/matching2.cpp
#	tests/simple.cpp

Author: Hana Dusíková

.travis.yml

@@ -41,12 +41,14 @@ matrix:
 
   - os: osx
     osx_image: xcode10
-    
+
 before_install:
   - |
      if [[ (-x $(which brew)) ]]; then
        brew update
-       brew install pcre2 re2 boost
+       brew install boost || brew upgrade boost
+       brew install pcre2 || brew upgrade pcre2
+       brew install re2 || brew upgrade re2
      else
        sudo add-apt-repository -y ppa:sergey-dryabzhinsky/packages
        sudo apt-get update -qq

Makefile

@@ -42,7 +42,7 @@ benchmark-clean:
 clean:
 	rm -f $(TRUE_TARGETS) $(OBJECTS) $(DEPEDENCY_FILES) mtent12.txt mtent12.zip
 
-grammar: include/ctre/pcre.hpp include/ctre/simple.hpp
+grammar: include/ctre/pcre.hpp
 
 regrammar: 
 	@rm -f include/ctre/pcre.hpp
@@ -65,7 +65,3 @@ compare: mtent12.txt
 	$(CXX) $(CXXFLAGS) -MMD -march=native -DPATTERN="\"(${PATTERN})\"" -c tests/benchmark-range/measurement.cpp -o tests/benchmark-range/measurement.o
 	$(CXX) tests/benchmark-range/measurement.o -lboost_regex -lpcre2-8 -lre2 -o tests/benchmark-range/measurement
 	tests/benchmark-range/measurement all mtent12.txt ${REPEAT}
-
-#include/ctre/simple.hpp: include/ctre/simple.gram
-#	@echo "LL1q $<"
-#	@$(DESATOMAT) --ll --q --input=include/ctre/simple.gram --output=include/ctre/ --generator=cpp_ctll_v2  --cfg:fname=simple.hpp --cfg:namespace=ctre --cfg:guard=CTRE__SIMPLE__HPP --cfg:grammar_name=simple

NOTES.md

@@ -12,7 +12,6 @@
 * atomic groups
 * comments
 * options/modes
-* lookahead
 * subroutines
 * conditional patterns
 * callouts

README.md

@@ -20,6 +20,35 @@ ctre::match<"REGEX">(subject); // C++20
 * `std::string`-like object (`std::string_view` or your own string if it's providing `begin`/`end` functions with forward iterators)
 * pair of forward iterators
 
+## Supported compilers
+
+* clang 5.0+ (template UDL, C++17 syntax)
+* gcc 7.2+ (template UDL, C++17 syntax)
+* gcc 9.0+ (C++17 & C++20 cNTTP syntax)
+* MSVC 15.8.8+ (C++17 syntax only)
+
+#### Template UDL syntax
+
+Compiler must support N3599 extension (as GNU extension in gcc and clang).
+
+#### C++17 syntax
+
+You can provide pattern as a `constexpr ctll::basic_fixed_string` variable.
+
+```c++
+static constexpr auto pattern = ctll::basic_fixed_string{ "h.*" };
+
+constexpr auto match(std::string_view sv) noexcept {
+	return ctre::re<pattern>().match(sv);
+}
+```
+
+(this is tested in MSVC 15.8.8)
+
+#### C++20 syntax
+
+Currently only compiler which supports cNTTP syntax `ctre::match<PATTERN>(subject)` is GCC 9+.
+
 ## Examples
 
 #### Extracting number from input
@@ -94,25 +123,3 @@ for (auto match: ctre::range(input,"[0-9]++"_ctre)) {
 	std::cout << std::string_view{match} << "\n";
 }
 ```
-
-## Supported compilers
-
-* clang 5.0+
-* gcc 7.2+
-* MSVC 15.8.8+ (experimental, without string_literal support)
-
-Compiler must support N3599 extension (as GNU extension in gcc and clang) or C++20 class NTTP (P0732).
-
-### MSVC
-
-Because current MSVC doesn't support custom templated string literals or NTTP, you need to use workaround:
-
-```c++
-static constexpr inline auto pattern = ctll::basic_fixed_string{ "h.*" };
-
-constexpr auto match(std::string_view sv) noexcept {
-	return ctre::re<pattern>().match(sv);
-}
-```
-
-(this is tested in MSVC 15.8.8)

include/ctre/actions/backreference.inc.hpp

@@ -2,28 +2,28 @@
 #define CTRE__ACTIONS__BACKREFERENCE__HPP
 
 // backreference with name
-template <auto... Str, auto V, typename... Ts, size_t Counter> static constexpr auto apply(pcre::make_back_reference, ctll::term<V>, pcre_context<ctll::list<id<Str...>, Ts...>, pcre_parameters<Counter>> subject) {	
-	return pcre_context{ctll::push_front(back_reference_with_name<id<Str...>>(), ctll::list<Ts...>()), subject};
+template <auto... Str, auto V, typename... Ts, size_t Counter> static constexpr auto apply(pcre::make_back_reference, ctll::term<V>, pcre_context<ctll::list<id<Str...>, Ts...>, pcre_parameters<Counter>>) {	
+	return pcre_context{ctll::push_front(back_reference_with_name<id<Str...>>(), ctll::list<Ts...>()), pcre_parameters<Counter>()};
 }
 
 // with just a number
-template <auto V, size_t Id, typename... Ts, size_t Counter> static constexpr auto apply(pcre::make_back_reference, ctll::term<V>, pcre_context<ctll::list<number<Id>, Ts...>, pcre_parameters<Counter>> subject) {
+template <auto V, size_t Id, typename... Ts, size_t Counter> static constexpr auto apply(pcre::make_back_reference, ctll::term<V>, pcre_context<ctll::list<number<Id>, Ts...>, pcre_parameters<Counter>>) {
 	// if we are looking outside of existing list of Ids ... reject input during parsing
 	if constexpr (Counter < Id) {
 		return ctll::reject{};
 	} else {
-		return pcre_context{ctll::push_front(back_reference<Id>(), ctll::list<Ts...>()), subject};
+		return pcre_context{ctll::push_front(back_reference<Id>(), ctll::list<Ts...>()), pcre_parameters<Counter>()};
 	}
 }
 
 // relative backreference
-template <auto V, size_t Id, typename... Ts, size_t Counter> static constexpr auto apply(pcre::make_relative_back_reference, ctll::term<V>, [[maybe_unused]] pcre_context<ctll::list<number<Id>, Ts...>, pcre_parameters<Counter>> subject) {	
+template <auto V, size_t Id, typename... Ts, size_t Counter> static constexpr auto apply(pcre::make_relative_back_reference, ctll::term<V>, [[maybe_unused]] pcre_context<ctll::list<number<Id>, Ts...>, pcre_parameters<Counter>>) {	
 	// if we are looking outside of existing list of Ids ... reject input during parsing
 	if constexpr (Counter < Id) {
 		return ctll::reject{};
 	} else {
 		constexpr size_t absolute_id = (Counter + 1) - Id;
-		return pcre_context{ctll::push_front(back_reference<absolute_id>(), ctll::list<Ts...>()), subject};
+		return pcre_context{ctll::push_front(back_reference<absolute_id>(), ctll::list<Ts...>()), pcre_parameters<Counter>()};
 	}
 }
 

include/ctre/actions/look.inc.hpp

@@ -0,0 +1,34 @@
+#ifndef CTRE__ACTIONS__LOOKAHEAD__HPP
+#define CTRE__ACTIONS__LOOKAHEAD__HPP
+
+// lookahead positive start
+template <auto V, typename... Ts, size_t Counter> static constexpr auto apply(pcre::start_lookahead_positive, ctll::term<V>, pcre_context<ctll::list<Ts...>, pcre_parameters<Counter>>) {
+	return pcre_context{ctll::list<look_start<lookahead_positive<>>, Ts...>(), pcre_parameters<Counter>()};
+}
+
+// lookahead positive end
+template <auto V, typename Look, typename... Ts, size_t Counter> static constexpr auto apply(pcre::look_finish, ctll::term<V>, pcre_context<ctll::list<Look, look_start<lookahead_positive<>>, Ts...>, pcre_parameters<Counter>>) {
+	return pcre_context{ctll::list<lookahead_positive<Look>, Ts...>(), pcre_parameters<Counter>()};
+}
+
+// lookahead positive end (sequence)
+template <auto V, typename... Look, typename... Ts, size_t Counter> static constexpr auto apply(pcre::look_finish, ctll::term<V>, pcre_context<ctll::list<ctre::sequence<Look...>, look_start<lookahead_positive<>>, Ts...>, pcre_parameters<Counter>>) {
+	return pcre_context{ctll::list<lookahead_positive<Look...>, Ts...>(), pcre_parameters<Counter>()};
+}
+
+// lookahead negative start
+template <auto V, typename... Ts, size_t Counter> static constexpr auto apply(pcre::start_lookahead_negative, ctll::term<V>, pcre_context<ctll::list<Ts...>, pcre_parameters<Counter>>) {
+	return pcre_context{ctll::list<look_start<lookahead_negative<>>, Ts...>(), pcre_parameters<Counter>()};
+}
+
+// lookahead negative end
+template <auto V, typename Look, typename... Ts, size_t Counter> static constexpr auto apply(pcre::look_finish, ctll::term<V>, pcre_context<ctll::list<Look, look_start<lookahead_negative<>>, Ts...>, pcre_parameters<Counter>>) {
+	return pcre_context{ctll::list<lookahead_negative<Look>, Ts...>(), pcre_parameters<Counter>()};
+}
+
+// lookahead negative end (sequence)
+template <auto V, typename... Look, typename... Ts, size_t Counter> static constexpr auto apply(pcre::look_finish, ctll::term<V>, pcre_context<ctll::list<ctre::sequence<Look...>, look_start<lookahead_negative<>>, Ts...>, pcre_parameters<Counter>>) {
+	return pcre_context{ctll::list<lookahead_negative<Look...>, Ts...>(), pcre_parameters<Counter>()};
+}
+
+#endif

include/ctre/atoms.hpp

@@ -10,6 +10,7 @@ struct accept { };
 struct start_mark { };
 struct end_mark { };
 struct end_cycle_mark { };
+struct end_lookahead_mark { };
 template <size_t Id> struct numeric_mark { };
 
 // actual AST of regexp
@@ -39,10 +40,14 @@ template <size_t Index, typename Name, typename... Content> struct capture_with_
 
 template <size_t Index> struct back_reference { };
 template <typename Name> struct back_reference_with_name { };
- 
+
+template <typename Type> struct look_start { };
+
+template <typename... Content> struct lookahead_positive { };
+template <typename... Content> struct lookahead_negative { };
 
 struct assert_begin { };
- struct assert_end { };
+struct assert_end { };
 
 }
 

include/ctre/evaluation.hpp

@@ -145,7 +145,6 @@ constexpr CTRE_FORCE_INLINE R evaluate(const Iterator begin, Iterator current, c
 	} else {
 		return evaluate(begin, current, end, captures, ctll::list<HeadContent, Tail...>());
 	}
-	
 }
 
 // matching empty in patterns
@@ -361,6 +360,34 @@ constexpr CTRE_FORCE_INLINE R evaluate(const Iterator begin, Iterator current, c
 	return not_matched;
 }
 
+// end of lookahead
+template <typename R, typename Iterator, typename EndIterator, typename... Tail> 
+constexpr CTRE_FORCE_INLINE R evaluate(const Iterator, Iterator, const EndIterator, R captures, ctll::list<end_lookahead_mark>) noexcept {
+	return captures.matched();
+}
+
+// lookahead positive
+template <typename R, typename Iterator, typename EndIterator, typename... Content, typename... Tail> 
+constexpr CTRE_FORCE_INLINE R evaluate(const Iterator begin, Iterator current, const EndIterator end, R captures, ctll::list<lookahead_positive<Content...>, Tail...>) noexcept {
+	
+	if (auto lookahead_result = evaluate(begin, current, end, captures, ctll::list<sequence<Content...>, end_lookahead_mark>())) {
+		captures = lookahead_result.unmatch();
+		return evaluate(begin, current, end, captures, ctll::list<Tail...>());
+	} else {
+		return not_matched;
+	}
+}
+
+// lookahead negative
+template <typename R, typename Iterator, typename EndIterator, typename... Content, typename... Tail> 
+constexpr CTRE_FORCE_INLINE R evaluate(const Iterator begin, Iterator current, const EndIterator end, R captures, ctll::list<lookahead_negative<Content...>, Tail...>) noexcept {
+	
+	if (auto lookahead_result = evaluate(begin, current, end, captures, ctll::list<sequence<Content...>, end_lookahead_mark>())) {
+		return not_matched;
+	} else {
+		return evaluate(begin, current, end, captures, ctll::list<Tail...>());
+	}
+}
 
 }
 

include/ctre/find_captures.hpp

@@ -98,7 +98,14 @@ template <size_t A, size_t B, typename... Content, typename... Tail, typename Ou
 
 
 
+template <typename... Content, typename... Tail, typename Output> constexpr auto find_captures(ctll::list<lookahead_positive<Content...>, Tail...>, Output output) noexcept {
+	return find_captures(ctll::list<Content..., Tail...>(), output);
+}
+
 
+template <typename... Content, typename... Tail, typename Output> constexpr auto find_captures(ctll::list<lookahead_negative<Content...>, Tail...>, Output output) noexcept {
+	return find_captures(ctll::list<Content..., Tail...>(), output);
+}
 
 
 

include/ctre/functions.hpp

@@ -3,7 +3,6 @@
 
 #include "../ctll.hpp"
 #include "pcre_actions.hpp"
-#include "simple.hpp"
 #include "evaluation.hpp"
 #include "wrapper.hpp"
 #include "id.hpp"