int main(int argc, const char **argv) {
// CommonOptionsParser constructor will parse arguments and create
// a CompilationDatabase.
clang::tooling::CommonOptionsParser OptionsParser(argc, argv, SampleToolCategory);
// retrive CompilationDatabase and the list of input file paths, hand
// to the tool constructor -> create a ClangTool and run FrontendAction
// over the code
clang::tooling::ClangTool Tool(OptionsParser.getCompilations(), OptionsParser.getSourcePathList());
// ClangTool needs a new FrontendAction for each translation unit
int result = Tool.run(clang::tooling::newFrontendActionFactory<PGAction>().get());
}
TEST(ClangToolTest, InjectDiagnosticConsumerInBuildASTs) {
FixedCompilationDatabase Compilations("/", std::vector<std::string>());
ClangTool Tool(Compilations, std::vector<std::string>(1, "/a.cc"));
Tool.mapVirtualFile("/a.cc", "int x = undeclared;");
TestDiagnosticConsumer Consumer;
Tool.setDiagnosticConsumer(&Consumer);
std::vector<std::unique_ptr<ASTUnit>> ASTs;
Tool.buildASTs(ASTs);
EXPECT_EQ(1u, ASTs.size());
EXPECT_EQ(1u, Consumer.NumDiagnosticsSeen);
}
TEST(ClangToolTest, InjectDiagnosticConsumer) {
FixedCompilationDatabase Compilations("/", std::vector<std::string>());
ClangTool Tool(Compilations, std::vector<std::string>(1, "/a.cc"));
Tool.mapVirtualFile("/a.cc", "int x = undeclared;");
TestDiagnosticConsumer Consumer;
Tool.setDiagnosticConsumer(&Consumer);
std::unique_ptr<FrontendActionFactory> Action(
newFrontendActionFactory<SyntaxOnlyAction>());
Tool.run(Action.get());
EXPECT_EQ(1u, Consumer.NumDiagnosticsSeen);
}
/*
* Main @TestNeed
*/
int main(int argc, const char **argv){
CommonOptionsParser OptionsParser(argc, argv, MyToolCategory);
//Create an ClangTool instance to run a FrontendAction over a set of files
ClangTool Tool(OptionsParser.getCompilations(),
OptionsParser.getSourcePathList());
//tool::MyFactory Factory;
GlobalVarChecker gvc;
MatchFinder finder;
finder.addMatcher(VarDeclMatcher, &gvc);
Tool.run(newFrontendActionFactory(&finder));
return 0;
}
int main(int argc, const char **argv)
{
CommonOptionsParser OptionsParser(argc, argv, MyToolCategory);
ClangTool Tool(OptionsParser.getCompilations(),
OptionsParser.getSourcePathList());
//tooling::MyFactory Factory;
ParmPrinter Printer;
MatchFinder Finder;
Finder.addMatcher(funcMatcher, &Printer);
Tool.run(newFrontendActionFactory(&Finder));
return 0;
}
TEST(ClangToolTest, BuildASTs) {
FixedCompilationDatabase Compilations("/", std::vector<std::string>());
std::vector<std::string> Sources;
Sources.push_back("/a.cc");
Sources.push_back("/b.cc");
ClangTool Tool(Compilations, Sources);
Tool.mapVirtualFile("/a.cc", "void a() {}");
Tool.mapVirtualFile("/b.cc", "void b() {}");
std::vector<std::unique_ptr<ASTUnit>> ASTs;
EXPECT_EQ(0, Tool.buildASTs(ASTs));
EXPECT_EQ(2u, ASTs.size());
}
// Main function
int main(int argc, const char **argv) {
clang::tooling::CommonOptionsParser OptionsParser(argc, argv, SuperastCPPCategory);
clang::tooling::ClangTool Tool(OptionsParser.getCompilations(),
OptionsParser.getSourcePathList());
// Run the recursive visitor
int returnValue = Tool.run(
clang::tooling::newFrontendActionFactory<SuperastCPPAction>().get());
// Dump the json to stdin
dumpJsonDocument(std::cout, document);
// Return
return returnValue;
}
//Main @TestNeed
int main(int argc, const char **argv){
CommonOptionsParser OptionsParser(argc, argv, MyToolCategory);
ClangTool Tool(OptionsParser.getCompilations(),
OptionsParser.getSourcePathList());
CallExprChecker cec;
MatchFinder finder;
finder.addMatcher(mallocMatcher, &cec);
finder.addMatcher(freeMatcher, &cec);
finder.addMatcher(reallocMatcher, &cec);
finder.addMatcher(memcpyAryMatcher, &cec);
finder.addMatcher(memcpyPtrMatcher, &cec);
finder.addMatcher(memcmpAryMatcher, &cec);
finder.addMatcher(memcmpPtrMatcher, &cec);
Tool.run(newFrontendActionFactory(&finder));
return 0;
}
int main(int argc, const char **argv)
{
//CommonOptionsParser constructor will parse arguments and create a
//CompilationDatabase. In case of error it will terminate the program.
CommonOptionsParser OptionsParser(argc, argv, MyToolCategory);
//once we have a CompilationDatabase, we can create a ClangTool and run our
//FrontendAction over some code.
ClangTool Tool(OptionsParser.getCompilations(),
OptionsParser.getSourcePathList());
//tooling::MyFactory Factory;
FunctionPrinter Printer;
MatchFinder Finder;
Finder.addMatcher(funcMatcher, &Printer);
Tool.run(newFrontendActionFactory(&Finder));
return 0;
}
int main( int argc, const char* argv[] )
{
invocation = argv[ 0 ];
if( argc < 3 )
{
return Usage();
}
// files
std::vector< std::string > files;
auto arg = &argv[ 1 ];
for( auto count = 1; count < argc && strcmp( "--", *arg ) != 0; ++count, ++arg )
{
files.push_back( *arg );
}
if( files.size() < 1 )
{
return Usage();
}
// compilation options
auto options = FixedCompilationDatabase::loadFromCommandLine( argc, argv );
if( options == nullptr )
{
llvm::errs() << "Failed to load compilation database\n";
return Usage();
}
// run tool
ClangTool Tool( *options, files );
return Tool.run( newFrontendActionFactory< ReflectFrontendAction >().get() );
}
TEST(newFrontendActionFactory, InjectsSourceFileCallbacks) {
VerifyEndCallback EndCallback;
FixedCompilationDatabase Compilations("/", std::vector<std::string>());
std::vector<std::string> Sources;
Sources.push_back("/a.cc");
Sources.push_back("/b.cc");
ClangTool Tool(Compilations, Sources);
Tool.mapVirtualFile("/a.cc", "void a() {}");
Tool.mapVirtualFile("/b.cc", "void b() {}");
std::unique_ptr<FrontendActionFactory> Action(
newFrontendActionFactory(&EndCallback, &EndCallback));
Tool.run(Action.get());
EXPECT_TRUE(EndCallback.Matched);
EXPECT_EQ(2u, EndCallback.BeginCalled);
EXPECT_EQ(2u, EndCallback.EndCalled);
}
void Listener::onFrame( const Leap::Controller& controller )
{
lock_guard<mutex> lock( *mMutex );
if ( !mNewFrame ) {
const Leap::Frame& controllerFrame = controller.frame();
const Leap::HandList& hands = controllerFrame.hands();
HandMap handMap;
for ( const Leap::Hand& hand : hands ) {
FingerMap fingerMap;
ToolMap toolMap;
const Leap::PointableList& pointables = hand.pointables();
for ( const Leap::Pointable& pt : pointables ) {
if ( pt.isValid() ) {
Pointable pointable( pt );
if ( pt.isFinger() ) {
fingerMap[ pt.id() ] = Finger( pointable );
} else if ( pt.isTool() ) {
toolMap[ pt.id() ] = Tool( pointable );
}
}
}
float rotAngle = (float)hand.rotationAngle( mFirstFrame.mFrame );
Vec3f rotAxis = toVec3f( hand.rotationAxis( mFirstFrame.mFrame ) );
Matrix44f rotMatrix = toMatrix44f( hand.rotationMatrix( mFirstFrame.mFrame ) );
float scale = (float)hand.scaleFactor( mFirstFrame.mFrame );
Vec3f translation = toVec3f( hand.translation( mFirstFrame.mFrame ) );
handMap[ hand.id() ] = Hand( hand, fingerMap, toolMap, rotAngle, rotAxis,
rotMatrix, scale, translation );
}
mFrame = Frame( controllerFrame, handMap );
if ( !mFirstFrameReceived ) {
mFirstFrame = Frame( controllerFrame, handMap );
mFirstFrameReceived = true;
}
mNewFrame = true;
}
}
int main(int argc, const char **argv){
CommonOptionsParser OptionsParser(argc, argv, MyToolCategory);
//Create an ClangTool instance to run a FrontendAction over a set of files
ClangTool Tool(OptionsParser.getCompilations(),
OptionsParser.getSourcePathList());
//tooling::MyFactory Factory;
FloatChecker fc;
IntChecker ic;
StringChecker sc;
MatchFinder finder;
finder.addMatcher(FloatLiteralMatcher , &fc);
finder.addMatcher(IntLiteralMatcher , &ic);
finder.addMatcher(StringLiteralMatcher , &sc);
Tool.run(newFrontendActionFactory(&finder));
llvm::outs() << "Avoid magic number : " << count << "\n";
return 0;
}
ClangTidyStats
runClangTidy(std::unique_ptr<ClangTidyOptionsProvider> OptionsProvider,
const tooling::CompilationDatabase &Compilations,
ArrayRef<std::string> InputFiles,
std::vector<ClangTidyError> *Errors, ProfileData *Profile) {
ClangTool Tool(Compilations, InputFiles);
clang::tidy::ClangTidyContext Context(std::move(OptionsProvider));
if (Profile)
Context.setCheckProfileData(Profile);
ClangTidyDiagnosticConsumer DiagConsumer(Context);
Tool.setDiagnosticConsumer(&DiagConsumer);
class ActionFactory : public FrontendActionFactory {
public:
ActionFactory(ClangTidyContext &Context) : ConsumerFactory(Context) {}
FrontendAction *create() override { return new Action(&ConsumerFactory); }
private:
class Action : public ASTFrontendAction {
public:
Action(ClangTidyASTConsumerFactory *Factory) : Factory(Factory) {}
std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &Compiler,
StringRef File) override {
return Factory->CreateASTConsumer(Compiler, File);
}
private:
ClangTidyASTConsumerFactory *Factory;
};
ClangTidyASTConsumerFactory ConsumerFactory;
};
ActionFactory Factory(Context);
Tool.run(&Factory);
*Errors = Context.getErrors();
return Context.getStats();
}
ClangTidyStats runClangTidy(ClangTidyOptionsProvider *OptionsProvider,
const tooling::CompilationDatabase &Compilations,
ArrayRef<std::string> InputFiles,
std::vector<ClangTidyError> *Errors) {
ClangTool Tool(Compilations, InputFiles);
clang::tidy::ClangTidyContext Context(OptionsProvider);
ClangTidyDiagnosticConsumer DiagConsumer(Context);
Tool.setDiagnosticConsumer(&DiagConsumer);
class ActionFactory : public FrontendActionFactory {
public:
ActionFactory(ClangTidyASTConsumerFactory *ConsumerFactory)
: ConsumerFactory(ConsumerFactory) {}
FrontendAction *create() override {
return new Action(ConsumerFactory);
}
private:
class Action : public ASTFrontendAction {
public:
Action(ClangTidyASTConsumerFactory *Factory) : Factory(Factory) {}
ASTConsumer *CreateASTConsumer(CompilerInstance &Compiler,
StringRef File) override {
return Factory->CreateASTConsumer(Compiler, File);
}
private:
ClangTidyASTConsumerFactory *Factory;
};
ClangTidyASTConsumerFactory *ConsumerFactory;
};
Tool.run(new ActionFactory(new ClangTidyASTConsumerFactory(Context)));
*Errors = Context.getErrors();
return Context.getStats();
}
TEST(ClangToolTest, ArgumentAdjusters) {
FixedCompilationDatabase Compilations("/", std::vector<std::string>());
ClangTool Tool(Compilations, std::vector<std::string>(1, "/a.cc"));
Tool.mapVirtualFile("/a.cc", "void a() {}");
std::unique_ptr<FrontendActionFactory> Action(
newFrontendActionFactory<SyntaxOnlyAction>());
bool Found = false;
bool Ran = false;
Tool.appendArgumentsAdjuster(new CheckSyntaxOnlyAdjuster(Found, Ran));
Tool.run(Action.get());
EXPECT_TRUE(Ran);
EXPECT_TRUE(Found);
Ran = Found = false;
Tool.clearArgumentsAdjusters();
Tool.appendArgumentsAdjuster(new CheckSyntaxOnlyAdjuster(Found, Ran));
Tool.appendArgumentsAdjuster(new ClangSyntaxOnlyAdjuster());
Tool.run(Action.get());
EXPECT_TRUE(Ran);
EXPECT_FALSE(Found);
}
Tool
WorkspaceMoveTool::to_tool()
{
return Tool(impl);
}
Tool
TileMapPaintTool::to_tool()
{
return Tool(impl);
}
XMLElementParser& pushElement(const XMLElement& element)
{
if(string_equal(element.name(), "var"))
{
Tools::iterator i = m_tools.insert(Tools::value_type(element.attribute("name"), Tool())).first;
m_tool = new ToolXMLConstructor((*i).second);
return *m_tool;
}
else if(string_equal(element.name(), "build"))
{
m_project.push_back(Project::value_type(element.attribute("name"), Build()));
m_build = new BuildXMLConstructor(m_project.back().second);
return *m_build;
}
else
{
ERROR_MESSAGE("parse error: invalid element");
return *this;
}
}
llvm::Error AllTUsToolExecutor::execute(
llvm::ArrayRef<
std::pair<std::unique_ptr<FrontendActionFactory>, ArgumentsAdjuster>>
Actions) {
if (Actions.empty())
return make_string_error("No action to execute.");
if (Actions.size() != 1)
return make_string_error(
"Only support executing exactly 1 action at this point.");
std::string ErrorMsg;
std::mutex TUMutex;
auto AppendError = [&](llvm::Twine Err) {
std::unique_lock<std::mutex> LockGuard(TUMutex);
ErrorMsg += Err.str();
};
auto Log = [&](llvm::Twine Msg) {
std::unique_lock<std::mutex> LockGuard(TUMutex);
llvm::errs() << Msg.str() << "\n";
};
std::vector<std::string> Files;
llvm::Regex RegexFilter(Filter);
for (const auto& File : Compilations.getAllFiles()) {
if (RegexFilter.match(File))
Files.push_back(File);
}
// Add a counter to track the progress.
const std::string TotalNumStr = std::to_string(Files.size());
unsigned Counter = 0;
auto Count = [&]() {
std::unique_lock<std::mutex> LockGuard(TUMutex);
return ++Counter;
};
auto &Action = Actions.front();
{
llvm::ThreadPool Pool(ThreadCount == 0 ? llvm::hardware_concurrency()
: ThreadCount);
llvm::SmallString<128> InitialWorkingDir;
if (auto EC = llvm::sys::fs::current_path(InitialWorkingDir)) {
InitialWorkingDir = "";
llvm::errs() << "Error while getting current working directory: "
<< EC.message() << "\n";
}
for (std::string File : Files) {
Pool.async(
[&](std::string Path) {
Log("[" + std::to_string(Count()) + "/" + TotalNumStr +
"] Processing file " + Path);
ClangTool Tool(Compilations, {Path});
Tool.appendArgumentsAdjuster(Action.second);
Tool.appendArgumentsAdjuster(getDefaultArgumentsAdjusters());
for (const auto &FileAndContent : OverlayFiles)
Tool.mapVirtualFile(FileAndContent.first(),
FileAndContent.second);
// Do not restore working dir from multiple threads to avoid races.
Tool.setRestoreWorkingDir(false);
if (Tool.run(Action.first.get()))
AppendError(llvm::Twine("Failed to run action on ") + Path +
"\n");
},
File);
}
// Make sure all tasks have finished before resetting the working directory.
Pool.wait();
if (!InitialWorkingDir.empty()) {
if (auto EC = llvm::sys::fs::set_current_path(InitialWorkingDir))
llvm::errs() << "Error while restoring working directory: "
<< EC.message() << "\n";
}
}
if (!ErrorMsg.empty())
return make_string_error(ErrorMsg);
return llvm::Error::success();
}
BOOL CLLKBgReady::OnInitDialog()
{
CDialog::OnInitDialog();
CLLKCLIApp* pApp = (CLLKCLIApp*)AfxGetApp();
pApp->m_pSockThd->SetHwnd(m_hWnd);
pApp->m_pSockThd->readyMsg=m_hWnd;
m_bmpBgReady.LoadBitmap(IDB_READY_BG);
m_bmpBgTmp.LoadBitmap(IDB_READY_BG);
m_bmpBgReady3.LoadBitmap(IDB_READY_BG);
m_bmpReadyPlayer.LoadBitmap(IDB_READY_PLAYER);
m_bmpTool.LoadBitmap(IDB_GAME_TOOL);
m_bmpBgReady2.LoadBitmap(IDB_READY_BG2);
m_bmpBgReady.GetBitmap(&m_infoBmpBgReady);
m_bmpReadyPlayer.GetBitmap(&m_infoBmpReadyPlayer);
m_bmpTool.GetBitmap(&m_infoBmpTool);
m_bmpBgReady2.GetBitmap(&m_infoBmpBgReady2);
CDC *pDC = GetDC();
m_dcMem.CreateCompatibleDC(pDC);
m_dcBuf.CreateCompatibleDC(pDC);
m_dcMem.SelectObject(&m_bmpBgReady);
RECT rc;
GetWindowRect(&rc);//得到窗口信息
int cyCaption = GetSystemMetrics(SM_CYCAPTION);//菜单高度
MoveWindow(rc.left,rc.top,m_infoBmpBgReady.bmWidth,m_infoBmpBgReady.bmHeight+cyCaption);//调整窗口大小
isReady=false;
int n=5;
Tool(n);//显示道具
//ShowName(chaNum,true);//显示昵称
SetTimer(1,500,NULL);
//SetTimer(2,500,NULL);
StartButton.LoadBitmaps(IDB_GAME_START,IDB_GAME_START_DOWN,0,0);
StartButton.SubclassDlgItem(IDC_START,this);
StartButton.SizeToContent();
TestButton.LoadBitmaps(IDB_GAME_TEST,IDB_GAME_TEST_DOWN,0,0);
TestButton.SubclassDlgItem(IDC_TEST,this);
TestButton.SizeToContent();
CloseButton.LoadBitmaps(IDB_GAME_CLOSE,IDB_GAME_CLOSE_DOWN,0,0);
CloseButton.SubclassDlgItem(IDC_CANCEL,this);
CloseButton.SizeToContent();
//请求用户信息
sockaddr_in remotAddr;
remotAddr.sin_family = AF_INET;
remotAddr.sin_addr.S_un.S_addr = inet_addr(pApp->ip);
remotAddr.sin_port = htons(pApp->port);
CString buf;
buf.Format("7 %d",c_uid);
CSocket *pSock = pApp->m_pSockThd->GetSock();
int res;
res = sendto(pSock->m_hSocket,buf.GetBuffer(buf.GetLength()),buf.GetLength(),0,(SOCKADDR*)&remotAddr,sizeof(SOCKADDR));
return TRUE; // return TRUE unless you set the focus to a control
// EXCEPTION: OCX Property Pages should return FALSE
}
