我的征尘是星辰大海。。。

The dirt and dust from my pilgrimage forms oceans of stars...

-------当记忆的篇章变得零碎，当追忆的图片变得模糊，我们只能求助于数字存储的永恒的回忆

作者:黄教授

一月一日等待变化等待机会

using cplusplus_type=std::optional<std::tuple<int, string, std::variant<string, std::pair<string,string>>>>;
auto print=[](const pair<int, cplusplus_type>&cplusplusYear)
	{
		const cplusplus_type&cplusplus=cplusplusYear.second;
		cout<<setw(6)<<left<<quoted(to_string(cplusplusYear.first))<<":";
		if (cplusplus)
		{
			auto t=cplusplus.value();
			auto v=get<2>(t);
			cout<<setw(6)<<left<<get<0>(t)<<setw(25)<<left<<quoted(get<1>(t))<<setw(15)<<left;
			switch (v.index())
			{
			case 0:
				cout<<get<0>(v);
				break;
			case 1:
				{
					const auto& p=get<1>(v);
					cout<<p.first+","+p.second;
				}
				break;
			}
			cout<<endl;
		}
		else
		{
			cout<<setw(6)<<left<<"N/A"<<setw(25)<<left<<"N/A"<<setw(15)<<left<<"N/A"<<endl;
		}
	};
auto ask=[](int year)
	{
		cplusplus_type cplusplus;
		switch (year)
		{
		case 1998:
			cplusplus=make_tuple(year, "ISO/IEC 14882:1998",
					variant<string, pair<string,string>>(in_place_type<string>, "C++98"));
			break;
		case 2003:
			cplusplus=make_tuple(year, "ISO/IEC 14882:2003",
					variant<string, pair<string,string>>(in_place_index<0>, "C++03"));
			break;
		case 2011:
			cplusplus=make_tuple(year, "ISO/IEC 14882:2011",
					variant<string, pair<string,string>>(in_place_type<pair<string,string>>,
					make_pair("C++11", "C++0x")));
			break;
		case 2014:
		{
			variant<string, pair<string,string>> v(in_place_type<pair<string,string>>,
					pair<string, string>(piecewise_construct, forward_as_tuple("C++14"),
							forward_as_tuple("C++1y")));
			cplusplus=tuple(year, "ISO/IEC 14882:2014", v);
			break;
		}
		case 2017:
		{
			variant<string, pair<string,string>> v;
			cplusplus=tuple(year, "ISO/IEC 14882:2017",
					v.emplace<1>(pair<string,string>(piecewise_construct, forward_as_tuple("C++17"),
							forward_as_tuple("C++1z"))));
			break;
		}
		case 2020:
			cplusplus=tuple(year, "ISO/IEC 14882:2020",
					variant<string, pair<string,string>>(in_place_type<pair<string,string>>,
						pair<string,string>(piecewise_construct, forward_as_tuple("C++20"),
						forward_as_tuple("C++2a"))));
			break;
		}
		return make_pair(year, cplusplus);
	};
for (int y=1998; y<2021; y++)
{
	print(ask(y));
}

结果是这样子的

"1998":1998  "ISO/IEC 14882:1998"     C++98          
"1999":N/A   N/A                      N/A            
"2000":N/A   N/A                      N/A            
"2001":N/A   N/A                      N/A            
"2002":N/A   N/A                      N/A            
"2003":2003  "ISO/IEC 14882:2003"     C++03          
"2004":N/A   N/A                      N/A            
"2005":N/A   N/A                      N/A            
"2006":N/A   N/A                      N/A            
"2007":N/A   N/A                      N/A            
"2008":N/A   N/A                      N/A            
"2009":N/A   N/A                      N/A            
"2010":N/A   N/A                      N/A            
"2011":2011  "ISO/IEC 14882:2011"     C++11,C++0x    
"2012":N/A   N/A                      N/A            
"2013":N/A   N/A                      N/A            
"2014":2014  "ISO/IEC 14882:2014"     C++14,C++1y    
"2015":N/A   N/A                      N/A            
"2016":N/A   N/A                      N/A            
"2017":2017  "ISO/IEC 14882:2017"     C++17,C++1z    
"2018":N/A   N/A                      N/A            
"2019":N/A   N/A                      N/A            
"2020":2020  "ISO/IEC 14882:2020"     C++20,C++2a

一月五日等待变化等待机会

可是“阿三”总是说内存泄漏，我感觉有些难以捉摸。这个是运行结果看样子dlist实现的没有错啊？

一月九日等待变化等待机会

constexpr int Row=8, Col=8, Stride=Row;
	valarray<int> ary(Row*Col);
	auto verifyRow=[&ary]()
		{
			for (int r=0; r<Row; r++)
			{
				if (valarray<int>(ary[slice(r*Stride, Row, 1)]).sum()>1)
				{
					cout<<"row failed:" <<r<<endl;
					return false;
				}
			}
			return true;
		};
	auto verifyCol=[&ary]()
		{
			for (int c=0; c<Col; c++)
			{
				if (valarray<int>(ary[slice(c, Col, Stride)]).sum()>1)
				{
					cout<<"col failed:"<<c<<endl;
					return false;
				}
			}
			return true;
		};
	auto verifyDiagnon=[&ary]()
		{
			for (int r=0; r<Row; r++)
			{
				if (valarray<int>(ary[slice(r*Stride, Row-r, Stride+1)]).sum()>1 ||
						valarray<int>(ary[slice(Col-1+r*Stride, Row-r, Stride-1)]).sum()>1)
				{
					cout<<"verify diagnon row failed:"<<r<<endl;
					return false;
				}
			}
			for (int c=0; c<Col; c++)
			{
				if (valarray<int>(ary[slice(c, Col-c, Stride+1)]).sum()>1||
						valarray<int>(ary[slice(c, c, Stride-1)]).sum()>1)
				{
					cout<<"verify diagnon col failed:"<<c<<endl;
					return false;
				}
			}
			return true;
		};
	auto verifyPos=[&ary](int index)
		{
			int row=index/Stride, col=index%Stride;
			if (valarray<int>(ary[slice(col, Row, Stride)]).sum()>1 ||
					valarray<int>(ary[slice(row*Stride, Col, 1)]).sum()>1)
			{
				return false;
			}
			int d1=min(row+1, col+1);
			int d2=min(row+1, Col-col);
			int d3=min(Row-row, col+1);
			int d4=min(Row-row, Col-col);
			if (valarray<int>(ary[slice(index, d1, -(Stride+1))]).sum()>1||
					valarray<int>(ary[slice(index, d2, -(Stride-1))]).sum()>1||
					valarray<int>(ary[slice(index, d3, (Stride-1))]).sum()>1 ||
					valarray<int>(ary[slice(index, d4, (Stride+1))]).sum()>1
					)
			{
				return false;
			}
			return true;
		};

auto print=[&ary]()
		{
			for (int r=0; r<Row; r++)
			{
				for (int c=0; c<Col; c++)
				{
					cout<<setw(3)<<ary[r*Stride+c];
				}
				cout<<endl;
			}
		};
	vector<int> v{1,4,7,5,3,6,2,0};
	for (size_t i=0; i<v.size(); i++)
	{
		ary[i*Stride+v[i]]=1;
	}
	print();
	if (verifyRow()&&verifyCol()&&verifyDiagnon())
	{
		cout<<"successful!"<<endl;
	}
	else
	{
		for (int i=0; i<Row*Col; i++)
		{
			if (ary[i]>0)
			{
				if (!verifyPos(i))
				{
					cout<<"pos:["<<i<<"] failed!"<<endl;
				}
			}
		}
	}

二月九日等待变化等待机会

void test358()
{
	set<string> setDeclare, setDefine;
	ifstream in{"/home/nick/Documents/grammar/grammar.bnf"};
	string str{istreambuf_iterator<char>{in}, istreambuf_iterator<char>{}};
	boost::regex ex(R"regex(
		(?<declare>[\w-]+):\n
 		(?<define>(?s:.+?))
		;\n
		)regex", boost::regex::perl| boost::regex::no_mod_s | boost::regex::mod_x | boost::regex::optimize);
	for (auto it=boost::sregex_iterator{str.begin(), str.end(), ex}; it!=boost::sregex_iterator{}; it++)
	{
		boost::smatch match=*it;
		string strDeclare=match["declare"].str();
		if (auto [ptr, succeed]=setDeclare.insert(strDeclare); !succeed)
		{
			cout<<"unexpected error:"<<strDeclare<<" repeated declared!"<<endl;
			return;
		}
		string strDefine=match["define"].str();
		cout<<strDeclare<<" := ";

boost::regex exLine(R"regex(
			(?<comment>[\s]*\#.+\n) (*SKIP)(*FAIL) 
			|(?<notcomment>[\s]*[^\#].+\n)
		)regex", boost::regex::perl| boost::regex::no_mod_s | boost::regex::mod_x | boost::regex::optimize);
		for (auto itLine=boost::sregex_iterator{strDefine.begin(), strDefine.end(), exLine};
				itLine!=boost::sregex_iterator{}; itLine++)
		{
			string strLine=itLine->str();
			cout<<strLine<<endl;
			boost::regex exTerm(R"regex(
					
				(?<char>('[^']')|('\\['\\]')) 
				| (?<string>"[^"\s]+")
				| (?<term>[\w_-]+)
				| (?<option>(?<opt>\[)((?&char)|(?&string)|(?&term))\])

)regex", boost::regex::perl| boost::regex::no_mod_s | boost::regex::mod_x | boost::regex::optimize);
			for (auto itTerm=boost::sregex_iterator{strLine.begin(), strLine.end(), exTerm};
					itTerm!=boost::sregex_iterator{}; itTerm++)
			{
				boost::smatch matchTerm=*itTerm;
				auto subOption=matchTerm["option"];
				auto subTerm=matchTerm["term"];
				if (subOption.matched)
				{
					string strOption=subOption.str();
					cout<<"[option]:"<<endl<<strOption<<endl;
					boost::regex exOption(R"regex(			
						 \[(?<term>[\w_-]+)\]
					)regex", boost::regex::perl| boost::regex::no_mod_s | boost::regex::mod_x | boost::regex::optimize);
					boost::smatch matchOption;
					if (boost::regex_match(strOption, matchOption, exOption))
					{
						string strT=matchOption["term"].str();
						cout<<"[matchOption-term]:"<<strT<<endl;
						setDefine.insert(strT);
					}
				}
				if (subTerm.matched)
				{
					setDefine.insert(subTerm.str());
				}
				continue;
				cout<<"======================"<<endl<<matchTerm.str()<<endl
						<<"======================"<<endl;
			}
		}
		cout<<"---------------------------------"<<endl;
	}
	for (auto s:setDefine)
	{
		if (!setDeclare.contains(s))
		{
			cout<<s<<" is not declared!"<<endl;
		}
	}
}

三月十六日等待变化等待机会

#include <iostream>
#include "glimits.h"
#include "auto-host.h"
#include "system.h"
#include "ansidecl.h"
#include "libiberty.h"
#include "cpplib.h"
#include "coretypes.h"
#include "incpath.h"
#include "diagnostic.h"

using namespace std;
static size_t round_alloc_size (size_t s){
  return s;
}
bool cb_diagnostic (cpp_reader *, enum cpp_diagnostic_level errtype,
	       enum cpp_warning_reason, rich_location *richloc,
	       const char *msg, va_list *ap){
		  return true;
}
void cb_include (cpp_reader * parse_in, location_t loc, const unsigned char * dirName,
		   const char * fname, int angle_brackets, const cpp_token **ptoken){
	cout<<"loc:"<<loc<<endl<<"dirname:"<<dirName<<endl<<"fname:"<<fname<<endl<<"angle_bracket:"<<angle_brackets<<endl;
	cpp_warning_with_line(parse_in, CPP_W_NONE, loc, 0, "warning from nick");
}
int main(){
	diagnostic_initialize (global_dc, 0);
	line_maps* line_table = XCNEW (class line_maps);
	linemap_init (line_table, 0);
	line_table->reallocator = xrealloc;
	line_table->round_alloc_size = round_alloc_size;
	cpp_reader* parse_in=cpp_create_reader(CLK_CXX2A, nullptr, line_table);
	if (parse_in){
		char*path=strdup("/tmp");
		add_path(path, INC_QUOTE, 1, 1);
		register_include_chains(parse_in, nullptr, nullptr, nullptr, 1, 1, 1);
		const char* ptr=cpp_read_main_file(parse_in, "/tmp/test.c");
		if (ptr){
			cpp_init_builtins(parse_in, 1);
			cout<<"successful!"<<ptr<<endl;
			cpp_callbacks*pCallback=cpp_get_callbacks(parse_in);
			pCallback->include=cb_include;
			pCallback->diagnostic=cb_diagnostic;
			cpp_set_callbacks(parse_in, pCallback);
			const cpp_token*token=nullptr;	
			FILE*output=fopen("/tmp/output.txt", "w+b");
			token=cpp_get_token(parse_in);
			while (token && token->type!=CPP_EOF){	
				cpp_output_token(token, output);
				token=cpp_get_token(parse_in);
			}
			fclose(output);
		}
	}
	return 0;
}

四月十日等待变化等待机会

#include "gcc-plugin.h"
#include <stdlib.h>
#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "tree.h"
#include "tree-pass.h"
#include "intl.h"
#include "toplev.h"
#include "plugin.h"
#include "diagnostic.h"
#include "cpplib.h"
#include <iostream>
#include <sstream>
	
using namespace std;
int plugin_is_GPL_compatible;
void handle_finish(void*gcc_data, void*user_data)
{
	stringstream * pss=(stringstream*)user_data;
	warning(0, G_("nick-test: final: %s"), pss->str().c_str());
}
stringstream ss;
void include_cb (cpp_reader *cpp, location_t loc, const unsigned char * dname,
		   const char * fname, int num, const cpp_token **pptoken)
{
	ss<<"location:"<<loc<<endl<<"dname:"<<dname<<endl<<"fname:"<<fname<<endl<<"num:"<<num<<endl;
}
extern cpp_reader *parse_in;
int plugin_init (struct plugin_name_args *plugin_info, struct plugin_gcc_version *version)
{  
	const char *plugin_name = plugin_info->base_name;
  cpp_callbacks* cb=cpp_get_callbacks(parse_in);
  cb->include=include_cb;
  register_callback (plugin_name, PLUGIN_FINISH, handle_finish, &ss);
  return 0;
}

编译参数：: 这个Plugin其实相对简单，要注意需要指明编译器plugin的头文件所在地，比如假定你使用默认的gcc/g++使用这个参数来获得-I的参数 g++ -print-file-name=plugin; 因为是编译为动态库所以-fPIC
链接的参数: 仅仅是指示要编译成动态库也就是-shared

六月二十六日等待变化等待机会

// helper for output
template <size_t...Indexes>
ostream&operator <<(ostream&os, index_sequence<Indexes...>seq);

template <typename ...Ts>
ostream&operator <<(ostream&os, tuple<Ts...> tp){
	[&os,tp]<size_t...Indexes>(index_sequence<Indexes...>s){
		os<<"{";
		((os<<(Indexes==0?"":",")<<get<Indexes>(tp)),...);
		os<<"}";
	}(make_index_sequence<sizeof...(Ts)>{});
	return os;
}
template <size_t...Indexes>
ostream&operator <<(ostream&os, index_sequence<Indexes...>seq){
	[&os]<size_t...Ints, typename...Ts>(index_sequence<Ints...>s, tuple<Ts...>tp){
			os<<"{";
			((os<<(Ints==0?"":",")<<get<Ints>(tp)),...);
			os<<"}";
	}(make_index_sequence<sizeof...(Indexes)>{}, make_tuple(Indexes...));
	return os;
}
// helper for manipulate sequence
template<size_t Index, size_t Counter, size_t Size, size_t Head, size_t...Tail, size_t...Indexes>
auto sequence_split_impl(index_sequence<Head,Tail...>seq, index_sequence<Indexes...>result){
	if constexpr(Counter==Size-1){
		if constexpr (Counter==Index){
			return index_sequence<Indexes...>{};
		}else{
			return index_sequence<Indexes..., Head>{};
		}
	}else if constexpr (Counter==Index){
		return sequence_split_impl<Index, Counter+1, Size>(index_sequence<Tail...>{},
				index_sequence<Indexes...>{});
	}else{
		return sequence_split_impl<Index, Counter+1, Size>(index_sequence<Tail...>{},
				index_sequence<Indexes..., Head>{});
	}
}
template<size_t Index, size_t...Indexes>
auto sequence_split(index_sequence<Indexes...>seq){
	return sequence_split_impl<Index, 0, sizeof...(Indexes)>(seq, index_sequence<>{});
}

template<size_t Index, size_t Head, size_t...Tail>
constexpr size_t sequence_get(index_sequence<Head, Tail...>seq) requires (Index<1+sizeof...(Tail))
{
	if constexpr (Index==0){
		return Head;
	}else{
		return sequence_get<Index-1>(index_sequence<Tail...>{});
	}
}
template<size_t Head, typename...Ts>
auto sequence_combine(tuple<Ts...>tp){
	return [tp]<size_t...Indexes>(index_sequence<Indexes...>seq){
		return make_tuple([tp]<size_t...Seq>(index_sequence<Seq...>s){
			return index_sequence<Head, Seq...>{};
		}(get<Indexes>(tp))...);
	}(make_index_sequence<sizeof...(Ts)>{});
}
// actual recursion of permutation
template<size_t Previous, size_t Head, size_t...Tail>
auto permutation_impl(index_sequence<Previous>prev, index_sequence<Head, Tail...>seq){
	if constexpr(sizeof...(Tail)==1){
		return sequence_combine<Previous>(make_tuple(index_sequence<Head, Tail...>{}, index_sequence<Tail..., Head>{}));
	}else{
		return []<size_t...Indexes>(index_sequence<Indexes...>s){
			return sequence_combine<Previous>(
					tuple_cat(
						permutation_impl(index_sequence<sequence_get<Indexes>(index_sequence<Head,Tail...>{})>{},
							sequence_split<Indexes>(index_sequence<Head,Tail...>{}))...));
		}(make_index_sequence<sizeof...(Tail)+1>{});
	}
}
template<size_t...Seq>
auto permutation(index_sequence<Seq...>seq){
	if constexpr (sizeof...(Seq)==2){
		return []<size_t Head, size_t Tail>(index_sequence<Head, Tail>s){
			return make_tuple(index_sequence<Head,Tail>{}, index_sequence<Tail,Head>{});
		}(seq);
	}else if constexpr(sizeof...(Seq)==1){
		return make_tuple(seq);
	}else{
		return [seq]<size_t...Indexes>(index_sequence<Indexes...>s){
			return tuple_cat(permutation_impl(index_sequence<sequence_get<Indexes>(seq)>{},
					sequence_split<Indexes>(seq))...);
		}(make_index_sequence<sizeof...(Seq)>{});
	}
}
//testing
cout<<permutation(index_sequence<1,6,4,5>{})<<endl;
//result
{{1,6,4,5},{1,6,5,4},{1,4,6,5},{1,4,5,6},{1,5,6,4},{1,5,4,6},{6,1,4,5},{6,1,5,4},{6,4,1,5},{6,4,5,1},{6,5,1,4},{6,5,4,1},{4,1,6,5},{4,1,5,6},{4,6,1,5},{4,6,5,1},{4,5,1,6},{4,5,6,1},{5,1,6,4},{5,1,4,6},{5,6,1,4},{5,6,4,1},{5,4,1,6},{5,4,6,1}}

六月三十日等待变化等待机会

template <size_t...Indexes>
ostream&operator <<(ostream&os, index_sequence<Indexes...>seq){
	[&os]<size_t...Ints, typename...Ts>(index_sequence<Ints...>s, tuple<Ts...>tp){
			os<<"{";
			((os<<(Ints==0?"":",")<<get<Ints>(tp)),...);
			os<<"}";
	}(make_index_sequence<sizeof...(Indexes)>{}, make_tuple(Indexes...));
	return os;
}
template<class...> struct cat;
template<> struct cat<> { using type = index_sequence<>; };
template<typename Head, typename...Tail>
struct cat<Head, Tail...>{
	template<size_t...Ts, size_t...Te>
	static index_sequence<Ts..., Te...> f(index_sequence<Ts...>s, index_sequence<Te...>e);
	using type=decltype(f(Head{}, typename cat<Tail...>::type{}));
};
struct Max{
	size_t i;
	constexpr Max operator*(Max m){
		return i>m.i?Max{i}:Max{m.i};
	}
};
template<bool value>
struct if_{
	template<size_t I> using maybe=index_sequence<I>;
};
template<>
struct if_<false>{
	template<size_t I> using maybe=index_sequence<>;
};
template<class...>
struct SortedAndFilteredImpl;
template<>
struct SortedAndFilteredImpl<index_sequence<>>{
	using type=index_sequence<>;
};
template<size_t...Ints>
struct SortedAndFilteredImpl<index_sequence<Ints...>>{
	static constexpr size_t biggest=(Max{Ints}*...).i;
	using bigger_ones=typename cat<typename if_<Ints==biggest>::template maybe<Ints> ...>::type;
	using smaller_ones=typename cat<typename if_<Ints!=biggest>::template maybe<Ints>...>::type;
	using type=typename cat<
			bigger_ones,
			typename SortedAndFilteredImpl<smaller_ones>::type
		>::type;
};
template<typename...Seq>
struct SortedAndFiltered{
	using type=SortedAndFilteredImpl<typename cat<Seq...>::type>::type;
};
cout<<SortedAndFiltered<index_sequence<1,2,3>, index_sequence<0,100>, index_sequence<44,33,22>>::type{}<<endl;

结果是这样子{100,44,33,22,3,2,1,0}

九月十六日等待变化等待机会

基本上是把ParseAST的之前部分代码拷贝一下，后面加上拷贝来的ASTConsumer的代码来打引，因为引入libFrontend.a实在是不划算，太大了。用到的静态库有

clangParse
LLVMMCParser
LLVMFrontendOpenMP
clangSema
LLVMAnalysis
clangEdit
clangLex
clangSerialization
clangLex
LLVMProfileData
clangAST
clangBasic
clangAnalysis
LLVMMC
LLVMCore
LLVMRemarks
LLVMBitstreamReader
LLVMBinaryFormat
LLVMSupport
LLVMOption
gtest_main
gtest
pthread

其中gtest不是必须的。

#include "clang/Lex/Lexer.h"
#include "clang/Basic/Builtins.h"
#include "clang/Basic/Diagnostic.h"
#include "clang/Basic/DiagnosticOptions.h"
#include "clang/Basic/FileManager.h"
#include "clang/Basic/LangOptions.h"
#include "clang/Basic/SourceLocation.h"
#include "clang/Basic/SourceManager.h"
#include "clang/Basic/TargetInfo.h"
#include "clang/Basic/TargetOptions.h"
#include "clang/Basic/TokenKinds.h"
#include "clang/Lex/HeaderSearch.h"
#include "clang/Lex/HeaderSearchOptions.h"
#include "clang/Lex/MacroArgs.h"
#include "clang/Lex/MacroInfo.h"
#include "clang/Lex/ModuleLoader.h"
#include "clang/Lex/Preprocessor.h"
#include "clang/Lex/PreprocessorOptions.h"
#include "clang/Parse/Parser.h"
#include "clang/AST/ASTContext.h"
#include "clang/Parse/ParseAST.h"
#include "clang/AST/ASTConsumer.h"
#include "clang/Frontend/TextDiagnosticBuffer.h"
#include "llvm/Support/Host.h"
#include "clang/Frontend/ASTConsumers.h"
#include "clang/AST/AST.h"
#include "clang/AST/ASTConsumer.h"
#include "clang/AST/ASTContext.h"
#include "clang/AST/PrettyPrinter.h"
#include "clang/AST/RecordLayout.h"
#include "clang/AST/RecursiveASTVisitor.h"
#include "clang/Basic/Diagnostic.h"
#include "clang/Basic/SourceManager.h"
#include "llvm/Support/Path.h"
#include "llvm/Support/Timer.h"
#include "llvm/Support/raw_ostream.h"
//#include "clang/Tooling/Tooling.h"
#include <iostream>
#include <vector>
using namespace clang;
using namespace std;
namespace
{
  class ASTPrinter : public ASTConsumer,
                     public RecursiveASTVisitor<ASTPrinter> {
    typedef RecursiveASTVisitor<ASTPrinter> base;

public:
    enum Kind { DumpFull, Dump, Print, None };
    ASTPrinter(std::unique_ptr<raw_ostream> Out, Kind K,
               ASTDumpOutputFormat Format, StringRef FilterString,
               bool DumpLookups = false, bool DumpDeclTypes = false)
        : Out(Out ? *Out : llvm::outs()), OwnedOut(std::move(Out)),
          OutputKind(K), OutputFormat(Format), FilterString(FilterString),
          DumpLookups(DumpLookups), DumpDeclTypes(DumpDeclTypes) {}

void HandleTranslationUnit(ASTContext &Context) override {
      TranslationUnitDecl *D = Context.getTranslationUnitDecl();

if (FilterString.empty())
        return print(D);

TraverseDecl(D);
    }

bool shouldWalkTypesOfTypeLocs() const { return false; }

bool TraverseDecl(Decl *D) {
      if (D && filterMatches(D)) {
        bool ShowColors = Out.has_colors();
        if (ShowColors)
          Out.changeColor(raw_ostream::BLUE);
        Out << (OutputKind != Print ? "Dumping " : "Printing ") << getName(D)
            << ":\n";
        if (ShowColors)
          Out.resetColor();
        print(D);
        Out << "\n";
        // Don't traverse child nodes to avoid output duplication.
        return true;
      }
      return base::TraverseDecl(D);
    }

private:
    std::string getName(Decl *D) {
      if (isa<NamedDecl>(D))
        return cast<NamedDecl>(D)->getQualifiedNameAsString();
      return "";
    }
    bool filterMatches(Decl *D) {
      return getName(D).find(FilterString) != std::string::npos;
    }
    void print(Decl *D) {
      if (DumpLookups) {
        if (DeclContext *DC = dyn_cast<DeclContext>(D)) {
          if (DC == DC->getPrimaryContext())
            DC->dumpLookups(Out, OutputKind != None, OutputKind == DumpFull);
          else
            Out << "Lookup map is in primary DeclContext "
                << DC->getPrimaryContext() << "\n";
        } else
          Out << "Not a DeclContext\n";
      } else if (OutputKind == Print) {
        PrintingPolicy Policy(D->getASTContext().getLangOpts());
        D->print(Out, Policy, /*Indentation=*/0, /*PrintInstantiation=*/true);
      } else if (OutputKind != None) {
        D->dump(Out, OutputKind == DumpFull, OutputFormat);
      }

if (DumpDeclTypes) {
        Decl *InnerD = D;
        if (auto *TD = dyn_cast<TemplateDecl>(D))
          InnerD = TD->getTemplatedDecl();

// FIXME: Support OutputFormat in type dumping.
        // FIXME: Support combining -ast-dump-decl-types with -ast-dump-lookups.
        if (auto *VD = dyn_cast<ValueDecl>(InnerD))
          VD->getType().dump(Out, VD->getASTContext());
        if (auto *TD = dyn_cast<TypeDecl>(InnerD))
          TD->getTypeForDecl()->dump(Out, TD->getASTContext());
      }
    }

raw_ostream &Out;
    std::unique_ptr<raw_ostream> OwnedOut;

/// How to output individual declarations.
    Kind OutputKind;

/// What format should the output take?
    ASTDumpOutputFormat OutputFormat;

/// Which declarations or DeclContexts to display.
    std::string FilterString;

/// Whether the primary output is lookup results or declarations. Individual
    /// results will be output with a format determined by OutputKind. This is
    /// incompatible with OutputKind == Print.
    bool DumpLookups;

/// Whether to dump the type for each declaration dumped.
    bool DumpDeclTypes;
  };

class ASTDeclNodeLister : public ASTConsumer,
                     public RecursiveASTVisitor<ASTDeclNodeLister> {
  public:
    ASTDeclNodeLister(raw_ostream *Out = nullptr)
        : Out(Out ? *Out : llvm::outs()) {}

void HandleTranslationUnit(ASTContext &Context) override {
      TraverseDecl(Context.getTranslationUnitDecl());
    }

bool shouldWalkTypesOfTypeLocs() const { return false; }

bool VisitNamedDecl(NamedDecl *D) {
      D->printQualifiedName(Out);
      Out << '\n';
      return true;
    }

private:
    raw_ostream &Out;
  };
} // end anonymous namespace

std::unique_ptr<ASTConsumer>
clang::CreateASTPrinter(std::unique_ptr<raw_ostream> Out,
                        StringRef FilterString) {
  return std::make_unique<ASTPrinter>(std::move(Out), ASTPrinter::Print,
                                       ADOF_Default, FilterString);
}

std::unique_ptr<ASTConsumer>
clang::CreateASTDumper(std::unique_ptr<raw_ostream> Out, StringRef FilterString,
                       bool DumpDecls, bool Deserialize, bool DumpLookups,
                       bool DumpDeclTypes, ASTDumpOutputFormat Format) {
  assert((DumpDecls || Deserialize || DumpLookups) && "nothing to dump");
  return std::make_unique<ASTPrinter>(
      std::move(Out),
      Deserialize ? ASTPrinter::DumpFull
                  : DumpDecls ? ASTPrinter::Dump : ASTPrinter::None,
      Format, FilterString, DumpLookups, DumpDeclTypes);
}

std::unique_ptr<ASTConsumer> clang::CreateASTDeclNodeLister() {
  return std::make_unique<ASTDeclNodeLister>(nullptr);
}
//===----------------------------------------------------------------------===//
/// ASTViewer - AST Visualization

namespace {
  class ASTViewer : public ASTConsumer {
    ASTContext *Context;
  public:
    void Initialize(ASTContext &Context) override {
      this->Context = &Context;
    }

bool HandleTopLevelDecl(DeclGroupRef D) override {
      for (DeclGroupRef::iterator I = D.begin(), E = D.end(); I != E; ++I)
        HandleTopLevelSingleDecl(*I);
      return true;
    }

void HandleTopLevelSingleDecl(Decl *D);
  };
}

void ASTViewer::HandleTopLevelSingleDecl(Decl *D) {
  if (isa<FunctionDecl>(D) || isa<ObjCMethodDecl>(D)) {
    D->print(llvm::errs());

if (Stmt *Body = D->getBody()) {
      llvm::errs() << '\n';
      Body->viewAST();
      llvm::errs() << '\n';
    }
  }
}

std::unique_ptr<ASTConsumer> clang::CreateASTViewer() {
  return std::make_unique<ASTViewer>();
}

struct TestDiagnosticConsumer : public DiagnosticConsumer {};
int main()
{
	LangOptions Lopt;
	IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
	IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions();
	DiagnosticsEngine Diags(DiagID, &*DiagOpts, new TestDiagnosticConsumer);
	FileSystemOptions FSopt;
	FileManager Fmgr(FSopt);
	auto Fref=Fmgr.getFileRef("/home/nick/eclipse-2021/clangTest/src/clangTest.cpp");
	SourceManager SrcMgr(Diags, Fmgr);
	SrcMgr.setMainFileID(SrcMgr.createFileID(*Fref, SourceLocation(), SrcMgr::C_User));

auto TargetOpts=std::make_shared<TargetOptions>();
	TargetOpts->Triple = llvm::sys::getDefaultTargetTriple();

TargetInfo* TgtInfo =TargetInfo::CreateTargetInfo(Diags, TargetOpts);
	HeaderSearch Hsrch(std::make_shared<HeaderSearchOptions>(), SrcMgr, Diags,
			LangOptions(), nullptr);
			//TargetInfo::CreateTargetInfo(Diags, TargetOpts));
	TrivialModuleLoader Mloader;
	Preprocessor PP(std::make_shared<PreprocessorOptions>(),
		Diags, Lopt,
		SrcMgr,
		Hsrch,
		Mloader,
		nullptr, false);
	PP.Initialize(*TgtInfo, nullptr);
	IdentifierTable Idtble;
	SelectorTable SelTbl;
	Builtin::Context BuiltinInfo;
	ASTContext ASTctx(Lopt, SrcMgr, Idtble, SelTbl, BuiltinInfo);
	ASTctx.InitBuiltinTypes(*TgtInfo);

std::string strFilter;
	std::unique_ptr<ASTConsumer> Consumer=CreateASTDumper(nullptr, strFilter, true, true, true, true, ADOF_JSON);
	Sema S(PP, ASTctx, *Consumer);
	ParseAST(S, true, false);
}

十月二十一日等待变化等待机会

#include <iostream>
#include <string>
#include <fstream>
#include <sstream>
#include <regex>
#include <map>
#include <set>
#include <vector>
#include <queue>

using namespace std;

typedef vector<string> Line;
typedef vector<Line> Lines;
typedef map<string, Lines> Rules;

void print(const Rules& rules)
{
	for (auto m: rules)
	{
		cout<<"ruleName:"<<m.first<<":"<<endl;

for (auto r: m.second)
		{
			cout<<"\t";
			for (auto s: r)
			{
				cout<<s<<"\t";
			}
			cout<<endl;
		}
	}
}

void work(const Rules& rules, Rules& newRules)
{
	set<string> que;
	que.insert("translation-unit");
	int counter=0;
	while (!que.empty())
	{
		counter++;
		if (counter%10==0)
		{
			cout<<"que size:"<<que.size()<<endl;
		}
		auto it=que.begin();
		string str=*it;
		que.erase(que.begin());
		if (rules.contains(str) && !newRules.contains(str))
		{
			Lines lines=rules.at(str);

newRules.insert(make_pair(str,lines));
			cout<<"new node:"<<str<<" is added"<<endl;

for (auto l: lines)
			{
				for (auto s:l)
				{
					if (rules.contains(s) && !que.contains(s) && !newRules.contains(s))
					{
						cout<<"queue add new item:"<<s<<endl;
						que.insert(s);
					}
				}
			}
		}
	}
	cout<<"now print newRules"<<endl;
	print(newRules);
	if (newRules != rules)
	{
		for (auto r: rules)
		{
			if (!newRules.contains(r.first))
			{
				cout<<"new rules removed rule:"<<r.first<<endl;
			}
		}
	}
}

ofstream tmpout("/mnt/sda2/Shared/llvm-dev/tmp.txt");
void printLine(const Line& line)
{
	for (auto s:line)
	{
		tmpout<<s<<" ";
	}
	tmpout<<endl;
}
void printLine(ostream& os, const Line& line, size_t pos)
{
	for (size_t i=0; i<line.size(); i++)
	{
		if (i==pos)
		{
			os<<"\"{"<<line[i]<<"}\" ";
		}
		else
		{
			os<<line[i]<<" ";
		}
	}
	tmpout<<endl;
}

set< std::pair<Line, size_t>> expandedLines;

void expand(const Rules& rules, const Line& line, size_t pos)
{
	if (line.size()>20)
	{
		cout<<"exceed limit:"<<line[pos]<<endl;
		printLine(cout, line, pos);
		return;
	}
	if (expandedLines.contains(make_pair(line, pos)))
	{
		return;
	}
	if (pos>0 && line[pos]==line[pos-1])
	{
		return;
	}
	expandedLines.insert(make_pair(line, pos));
	printLine(tmpout, line, pos);

if (rules.contains(line[pos]))
	{
		auto lines=rules.at(line[pos]);
		for (auto l:lines)
		{
			Line newLine(line.begin(), line.begin()+pos);
			for (auto s:l)
			{
				newLine.push_back(s);
			}
			for (size_t i=pos+1; i<line.size(); i++)
			{
				newLine.push_back(line[i]);
			}
			bool bExpanded=false;
			for (size_t i=0; i<l.size(); i++)
			{
				if (rules.contains(l[i]))
				{
					// check if repeating
					bool bRepeating=false;
					if (pos >= i && pos-i+l.size() <= line.size())
					{
						size_t j=0;
						for (j=0; j<l.size(); j++)
						{
							if (line[pos-i+j] != l[j])
							{
								break;
							}
						}
						bRepeating=j==l.size();
						if (bRepeating)
						{
							//cout<<"found repeating:"<<l[i]<<endl;
						}
					}
					if (!bRepeating)
					{
						expand(rules, newLine, pos+i);
						bExpanded=true;
					}
				}
			}
			if (!bExpanded)
			{
				//printLine(newLine);
			}
		}
	}
}

void create(Rules& rules)
{
	ifstream in("/home/nick/Documents/c++/bnf.txt");
	Lines lines;
	string ruleName;
	string str;
	int counter=0;
	while (getline(in, str))
	{
		if (str[0]!='\t' && str[str.size()-1]==':')
		{
			cout<<"new rule:" <<str<<endl;
			if (!lines.empty())
			{
				rules.insert(make_pair(ruleName, lines));
			}
			ruleName=str.substr(0, str.size()-1);
			counter++;
			lines.clear();
		}
		else
		{
			string strToken;
			stringstream ss(str);
			Line line;
			while (ss>>strToken)
			{
				if (strToken=="C++0x")
				{
					continue;
				}

if (strToken.size()>4 && strToken.substr(strToken.size()-3, 3)=="opt")
				{
					cout<<"opt Token:"<<strToken<<endl;
					line.push_back(strToken.substr(0, strToken.size()-3));
				}
				else
				{
					cout<<"token:"<<strToken<<endl;
					line.push_back(strToken);
				}
			}
			lines.push_back(line);
		}
	}
	cout<<"total::"<<counter<<endl;
}
int main(int argc, char** argv)
{
	string strStart="translation-unit";
	if (argc!=2)
	{
		cout<<"usage:"<<argv[0] <<" [non-terminal] i.e. default is: translation-unit"<<endl;
	}
	else
	{
		strStart=argv[1];
	}
	Rules rules, newRules;
	create(rules);
	print(rules);
	work(rules, newRules);
	if (newRules.contains(strStart))
	{
		Line line(1, strStart);
		expand(newRules, line, 0);
	}
	return 0;
}

十一月二十九日等待变化等待机会

这个是参考学习大侠的范例。

struct IPv4{
	uint32_t addr=0;
};
void print(const IPv4& ip){
	cout<<(ip.addr>>24&0xFF)<<"."<<(ip.addr>>16&0xFF)<<"."<<(ip.addr>>8&0xFF)<<"."<<(ip.addr&0xFF)<<endl;
}
consteval IPv4 operator ""_ipv4(const char*ptr, unsigned long length){
	IPv4 result;
	unsigned int pos=0, prev=0;
	int counter=0;
	unsigned short n=0;
	while (pos<length){
		if (ptr[pos]>='0' && ptr[pos]<='9'){
			n=n*10 + ptr[pos] - '0';
		}else if (ptr[pos]=='.'){
			if (pos==0||(prev>0&&pos-prev<2)){
				throw "empty group";
			}else{
				prev=pos;
				counter++;
				if (n>255){
					throw "address invalid";
				}
				result.addr=(result.addr<<8)|n;
				n=0;
			}
		}else{
			throw "non digit";
		}
		pos++;
	}
	if (counter!=3){
		throw "invalid group";
	}else{
		if (pos-prev<2){
			throw "empty group";
		}else{
			if (n>255){
				throw "address invalid";
			}
			result.addr=(result.addr<<8)|n;
		}
	}
	return result;
}
void test(){
	try{
		IPv4 ip="192.255.02.00"_ipv4;
		print(ip);
	}
	catch (const char* msg){
		cout<<msg<<endl;
	}
}

十二月十二日等待变化等待机会

这个是在大侠的代码上加的一点点改进以便返回纯粹的literal的肉

%{
#include <iostream>
#include <string>
using namespace std;
void yyerror(const string& str);
#define STRING_LITERAL 257
%}
%option	noyywrap
%x 				C_RAW_STRING
dchar_seq		[^()\\[:space:]]{0,16}
%%
		size_t delim_len;
R["]{dchar_seq}[(]    { delim_len = yyleng - 3;
                        yymore();
                        BEGIN(C_RAW_STRING);
                      }
R["]{dchar_seq}       { yyerror("Invalid raw string opener"); }
   /* Rules for other tokens omitted */
[[:space:]]+          ;                /* Ignore whitespace */
.                     return *yytext;  /* Fallback rule */
<C_RAW_STRING>{
   [^"]+              yymore();
   ["]                { if (yytext[yyleng - (delim_len + 2)] == ')' &&
                            memcmp(yytext + yyleng - (delim_len + 1),
                                   yytext + 2, delim_len) == 0) {
                           BEGIN(INITIAL);
                           yytext=yytext+delim_len + 3;
                           yyleng=yyleng-delim_len-3-delim_len-2;
                           return STRING_LITERAL;
                         }
                         else yymore();
                       }
   <<EOF>>             { yyerror("Unterminated raw string");
                         BEGIN(INITIAL);
                         return 0;
                       }
}
%%
void yyerror(const string& str){
	cout<<"error:"<<str<<endl;
}
int main(int argc, char**argv){
	extern FILE *yyin;
	if (argc==2){
		yyin=fopen(argv[1], "r");
		if (yyin){
			int token=0;
			while (token=yylex()){
				if (token==STRING_LITERAL){			
					string str(yytext, yyleng);
					cout<<"found literal:"<<"line_number:"<<yylineno<<";\t"
						<<"yyleng:"<<yyleng<<"\t:"<<str<<endl;
				}				
			}
		}
	}
}

string-literal

%{
#include <iostream>
#include <string>
using namespace std;
void yyerror(const string& str);

#define ORDINARY_STRING_LITERAL 257
#define WIDE_STRING_LITERAL 	258
#define U8_STRING_LITERAL  		259
#define U16_STRING_LITERAL		260
#define U32_STRING_LITERAL		261
%}
%option	noyywrap
schar_seq		[^"\\\n]*
%%	
[L]["]{schar_seq}*["]		{yytext=yytext+2; yyleng=yyleng-3; return WIDE_STRING_LITERAL;}	
[u][8]["]{schar_seq}*["]	{yytext=yytext+3; yyleng=yyleng-4; return U8_STRING_LITERAL;}	
[u]["]{schar_seq}*["]		{yytext=yytext+2; yyleng=yyleng-3; return U16_STRING_LITERAL;}	
[U]["]{schar_seq}*["]		{yytext=yytext+2; yyleng=yyleng-3; return U32_STRING_LITERAL;}
["]{schar_seq}*["]			{yytext=yytext+1; yyleng=yyleng-2; return ORDINARY_STRING_LITERAL;}
[[:space:]]+          ;                /* Ignore whitespace */
.                     ; /*return *yytext;*/  /* Fallback rule */
%%
void yyerror(const string& str){
	cout<<"error:"<<str<<endl;
}
int main(int argc, char**argv){
	extern FILE *yyin;
	if (argc==2){
		yyin=fopen(argv[1], "r");
		if (yyin){
			int token=0;
			while (token=yylex()){
				switch (token)
				{
				case ORDINARY_STRING_LITERAL:
					cout<<"\nORDINARY_STRING_LITERAL\t"; 		
					break;
				case WIDE_STRING_LITERAL:
					cout<<"\nWIDE_STRING_LITERAL\t";
					break;
				case U8_STRING_LITERAL:
					cout<<"\nU8_STRING_LITERAL\t";
					break;
				case U16_STRING_LITERAL:
					cout<<"\nU16_STRING_LITERAL\t";
					break;
				case U32_STRING_LITERAL:
					cout<<"\nU32_STRING_LITERAL\t";
					break;
				default:
					cout<<"unexpected error\t";
					break;
				}	
				string str(yytext, yyleng);
				cout<<":\n"<<"line_number:"<<yylineno<<";\t"
					<<"yyleng:"<<yyleng<<"\t:["<<str<<"]"<<endl;							
			}
		}
	}
}

十二月十四日等待变化等待机会

partially inspired by this project

%{
#include <iostream>
#include <string>
using namespace std;
void yyerror(const string& str);
#define SYSTEM_HEADER  		259
#define USER_HEADER 	 	260
%}
%option	noyywrap
%option yylineno
%x  incl
%x  system
%x  user
%%
#include               		{BEGIN(incl);  }
<incl>[[:space:]]*[<]       	{BEGIN(system);}
<incl>[[:space:]]*["]       	{BEGIN(user);}    
<system>[^\n>]+> 	{ BEGIN(INITIAL); yyleng=yyleng-1;return SYSTEM_HEADER;}
<user>[^\n"]+\"  	{ BEGIN(INITIAL); yyleng--;return USER_HEADER;}
<system>[\n]		{ BEGIN(INITIAL); yyerror("invalid system include"); }
<user>[\n]			{ BEGIN(INITIAL); yyerror("invalid user include");  }
[[:space:]]+          ;                /* Ignore whitespace */
.                     ; /*return *yytext;*/  /* Fallback rule */
%%
void yyerror(const string& str){
	cout<<"error:"<<str<<endl;
}
int main(int argc, char**argv){
	extern FILE *yyin;
	if (argc==2){
		yyin=fopen(argv[1], "r");
		if (yyin){
			int token=0;
			while (token=yylex()){				
				string str(yytext, yyleng);				
				cout<<"\tline_number:"<<yylineno<<";\t"
					<<"yyleng:"<<yyleng<<"\t:["<<str<<"]"<<endl;							
			}
		}
	}
}