From b1cc2ae4ded5bd7138f183f2dcdbde627dc610c3 Mon Sep 17 00:00:00 2001 From: s1mple <100117933+S1mpleBug@users.noreply.github.com> Date: Wed, 2 Mar 2022 02:27:56 +0800 Subject: [PATCH] Add files via upload --- Acceptor.cc | 72 +++ Acceptor.h | 32 + Buffer.cc | 70 +++ Buffer.h | 106 ++++ CMakeLists.txt | 14 + Callbacks.h | 18 + Channel.cc | 101 ++++ Channel.h | 81 +++ CurrentThread.cc | 14 + CurrentThread.h | 20 + DefaultPoller.cc | 16 + EPollPoller.cc | 147 +++++ EPollPoller.h | 41 ++ EventLoop.cc | 213 +++++++ EventLoop.h | 69 +++ EventLoopThread.cc | 58 ++ EventLoopThread.h | 33 ++ EventLoopThreadPool.cc | 68 +++ EventLoopThreadPool.h | 41 ++ InetAddress.cc | 43 ++ InetAddress.h | 26 + Logger.cc | 42 ++ Logger.h | 76 +++ Poller.cc | 13 + Poller.h | 39 ++ Socket.cc | 72 +++ Socket.h | 31 + TcpConnection.cc | 260 ++++++++ TcpConnection.h | 101 ++++ TcpServer.cc | 116 ++++ TcpServer.h | 75 +++ Thread.cc | 60 ++ Thread.h | 39 ++ Timestamp.cc | 36 ++ Timestamp.h | 16 + build/CMakeCache.txt | 316 ++++++++++ build/CMakeFiles/3.5.1/CMakeCCompiler.cmake | 67 +++ build/CMakeFiles/3.5.1/CMakeCXXCompiler.cmake | 68 +++ .../3.5.1/CMakeDetermineCompilerABI_C.bin | Bin 0 -> 8640 bytes .../3.5.1/CMakeDetermineCompilerABI_CXX.bin | Bin 0 -> 8656 bytes build/CMakeFiles/3.5.1/CMakeSystem.cmake | 15 + .../3.5.1/CompilerIdC/CMakeCCompilerId.c | 544 +++++++++++++++++ build/CMakeFiles/3.5.1/CompilerIdC/a.out | Bin 0 -> 8800 bytes .../CompilerIdCXX/CMakeCXXCompilerId.cpp | 533 +++++++++++++++++ build/CMakeFiles/3.5.1/CompilerIdCXX/a.out | Bin 0 -> 8808 bytes .../CMakeDirectoryInformation.cmake | 16 + build/CMakeFiles/CMakeOutput.log | 554 ++++++++++++++++++ build/CMakeFiles/Makefile.cmake | 115 ++++ build/CMakeFiles/Makefile2 | 108 ++++ build/CMakeFiles/TargetDirectories.txt | 3 + build/CMakeFiles/cmake.check_cache | 1 + build/CMakeFiles/feature_tests.bin | Bin 0 -> 12696 bytes build/CMakeFiles/feature_tests.c | 34 ++ build/CMakeFiles/feature_tests.cxx | 405 +++++++++++++ build/CMakeFiles/mymuduo.dir/Acceptor.o | Bin 0 -> 211160 bytes build/CMakeFiles/mymuduo.dir/Buffer.o | Bin 0 -> 160896 bytes build/CMakeFiles/mymuduo.dir/CXX.includecache | 386 ++++++++++++ build/CMakeFiles/mymuduo.dir/Channel.o | Bin 0 -> 235280 bytes build/CMakeFiles/mymuduo.dir/CurrentThread.o | Bin 0 -> 14320 bytes build/CMakeFiles/mymuduo.dir/DefaultPoller.o | Bin 0 -> 34512 bytes build/CMakeFiles/mymuduo.dir/DependInfo.cmake | 36 ++ build/CMakeFiles/mymuduo.dir/EPollPoller.o | Bin 0 -> 484168 bytes build/CMakeFiles/mymuduo.dir/EventLoop.o | Bin 0 -> 524288 bytes .../CMakeFiles/mymuduo.dir/EventLoopThread.o | Bin 0 -> 292168 bytes .../mymuduo.dir/EventLoopThreadPool.o | Bin 0 -> 372928 bytes build/CMakeFiles/mymuduo.dir/InetAddress.o | Bin 0 -> 71552 bytes build/CMakeFiles/mymuduo.dir/Logger.o | Bin 0 -> 80752 bytes build/CMakeFiles/mymuduo.dir/Poller.o | Bin 0 -> 247816 bytes build/CMakeFiles/mymuduo.dir/Socket.o | Bin 0 -> 81480 bytes build/CMakeFiles/mymuduo.dir/TcpConnection.o | Bin 0 -> 908448 bytes build/CMakeFiles/mymuduo.dir/TcpServer.o | Bin 0 -> 1244216 bytes build/CMakeFiles/mymuduo.dir/Thread.o | Bin 0 -> 241136 bytes build/CMakeFiles/mymuduo.dir/Timestamp.o | Bin 0 -> 77192 bytes build/CMakeFiles/mymuduo.dir/build.make | 545 +++++++++++++++++ .../CMakeFiles/mymuduo.dir/cmake_clean.cmake | 26 + build/CMakeFiles/mymuduo.dir/depend.internal | 120 ++++ build/CMakeFiles/mymuduo.dir/depend.make | 120 ++++ build/CMakeFiles/mymuduo.dir/flags.make | 10 + build/CMakeFiles/mymuduo.dir/link.txt | 1 + build/CMakeFiles/mymuduo.dir/progress.make | 19 + build/CMakeFiles/progress.marks | 1 + build/Makefile | 454 ++++++++++++++ build/cmake_install.cmake | 44 ++ build/compile_commands.json | 87 +++ lib/libmymuduo.so | Bin 0 -> 2542952 bytes noncopyable.h | 15 + 86 files changed, 6902 insertions(+) create mode 100644 Acceptor.cc create mode 100644 Acceptor.h create mode 100644 Buffer.cc create mode 100644 Buffer.h create mode 100644 CMakeLists.txt create mode 100644 Callbacks.h create mode 100644 Channel.cc create mode 100644 Channel.h create mode 100644 CurrentThread.cc create mode 100644 CurrentThread.h create mode 100644 DefaultPoller.cc create mode 100644 EPollPoller.cc create mode 100644 EPollPoller.h create mode 100644 EventLoop.cc create mode 100644 EventLoop.h create mode 100644 EventLoopThread.cc create mode 100644 EventLoopThread.h create mode 100644 EventLoopThreadPool.cc create mode 100644 EventLoopThreadPool.h create mode 100644 InetAddress.cc create mode 100644 InetAddress.h create mode 100644 Logger.cc create mode 100644 Logger.h create mode 100644 Poller.cc create mode 100644 Poller.h create mode 100644 Socket.cc create mode 100644 Socket.h create mode 100644 TcpConnection.cc create mode 100644 TcpConnection.h create mode 100644 TcpServer.cc create mode 100644 TcpServer.h create mode 100644 Thread.cc create mode 100644 Thread.h create mode 100644 Timestamp.cc create mode 100644 Timestamp.h create mode 100644 build/CMakeCache.txt create mode 100644 build/CMakeFiles/3.5.1/CMakeCCompiler.cmake create mode 100644 build/CMakeFiles/3.5.1/CMakeCXXCompiler.cmake create mode 100644 build/CMakeFiles/3.5.1/CMakeDetermineCompilerABI_C.bin create mode 100644 build/CMakeFiles/3.5.1/CMakeDetermineCompilerABI_CXX.bin create mode 100644 build/CMakeFiles/3.5.1/CMakeSystem.cmake create mode 100644 build/CMakeFiles/3.5.1/CompilerIdC/CMakeCCompilerId.c create mode 100644 build/CMakeFiles/3.5.1/CompilerIdC/a.out create mode 100644 build/CMakeFiles/3.5.1/CompilerIdCXX/CMakeCXXCompilerId.cpp create mode 100644 build/CMakeFiles/3.5.1/CompilerIdCXX/a.out create mode 100644 build/CMakeFiles/CMakeDirectoryInformation.cmake create mode 100644 build/CMakeFiles/CMakeOutput.log create mode 100644 build/CMakeFiles/Makefile.cmake create mode 100644 build/CMakeFiles/Makefile2 create mode 100644 build/CMakeFiles/TargetDirectories.txt create mode 100644 build/CMakeFiles/cmake.check_cache create mode 100644 build/CMakeFiles/feature_tests.bin create mode 100644 build/CMakeFiles/feature_tests.c create mode 100644 build/CMakeFiles/feature_tests.cxx create mode 100644 build/CMakeFiles/mymuduo.dir/Acceptor.o create mode 100644 build/CMakeFiles/mymuduo.dir/Buffer.o create mode 100644 build/CMakeFiles/mymuduo.dir/CXX.includecache create mode 100644 build/CMakeFiles/mymuduo.dir/Channel.o create mode 100644 build/CMakeFiles/mymuduo.dir/CurrentThread.o create mode 100644 build/CMakeFiles/mymuduo.dir/DefaultPoller.o create mode 100644 build/CMakeFiles/mymuduo.dir/DependInfo.cmake create mode 100644 build/CMakeFiles/mymuduo.dir/EPollPoller.o create mode 100644 build/CMakeFiles/mymuduo.dir/EventLoop.o create mode 100644 build/CMakeFiles/mymuduo.dir/EventLoopThread.o create mode 100644 build/CMakeFiles/mymuduo.dir/EventLoopThreadPool.o create mode 100644 build/CMakeFiles/mymuduo.dir/InetAddress.o create mode 100644 build/CMakeFiles/mymuduo.dir/Logger.o create mode 100644 build/CMakeFiles/mymuduo.dir/Poller.o create mode 100644 build/CMakeFiles/mymuduo.dir/Socket.o create mode 100644 build/CMakeFiles/mymuduo.dir/TcpConnection.o create mode 100644 build/CMakeFiles/mymuduo.dir/TcpServer.o create mode 100644 build/CMakeFiles/mymuduo.dir/Thread.o create mode 100644 build/CMakeFiles/mymuduo.dir/Timestamp.o create mode 100644 build/CMakeFiles/mymuduo.dir/build.make create mode 100644 build/CMakeFiles/mymuduo.dir/cmake_clean.cmake create mode 100644 build/CMakeFiles/mymuduo.dir/depend.internal create mode 100644 build/CMakeFiles/mymuduo.dir/depend.make create mode 100644 build/CMakeFiles/mymuduo.dir/flags.make create mode 100644 build/CMakeFiles/mymuduo.dir/link.txt create mode 100644 build/CMakeFiles/mymuduo.dir/progress.make create mode 100644 build/CMakeFiles/progress.marks create mode 100644 build/Makefile create mode 100644 build/cmake_install.cmake create mode 100644 build/compile_commands.json create mode 100644 lib/libmymuduo.so create mode 100644 noncopyable.h diff --git a/Acceptor.cc b/Acceptor.cc new file mode 100644 index 0000000..3dc7a85 --- /dev/null +++ b/Acceptor.cc @@ -0,0 +1,72 @@ +#include +#include +#include +#include + +#include "Acceptor.h" +#include "Logger.h" +#include "InetAddress.h" + +static int createNonblocking() +{ + int sockfd = ::socket(AF_INET, SOCK_STREAM | SOCK_NONBLOCK | SOCK_CLOEXEC, IPPROTO_TCP); + if (sockfd < 0) + { + LOG_FATAL("%s:%s:%d listen socket create err:%d\n", __FILE__, __FUNCTION__, __LINE__, errno); + } + return sockfd; +} + +Acceptor::Acceptor(EventLoop *loop, const InetAddress &listenAddr, bool reuseport) + : loop_(loop) + , acceptSocket_(createNonblocking()) + , acceptChannel_(loop, acceptSocket_.fd()) + , listenning_(false) +{ + acceptSocket_.setReuseAddr(true); + acceptSocket_.setReusePort(true); + acceptSocket_.bindAddress(listenAddr); + + // TcpServer::start() => Acceptor.listen() 如果有新用户连接 要执行一个回调(accept => connfd => 打包成Channel => 唤醒subloop) + // baseloop监听到有事件发生 => acceptChannel_(listenfd) => 执行该回调函数 + acceptChannel_.setReadCallback(std::bind(&Acceptor::handleRead, this)); +} + +Acceptor::~Acceptor() +{ + acceptChannel_.disableAll(); // 把从Poller中感兴趣的事件删除掉 + acceptChannel_.remove(); // 调用EventLoop->removeChannel => Poller->removeChannel 把Poller的ChannelMap对应的部分删除 +} + +void Acceptor::listen() +{ + listenning_ = true; + acceptSocket_.listen(); // listen + acceptChannel_.enableReading(); // acceptChannel_注册至Poller !重要 +} + +// listenfd有事件发生了，就是有新用户连接了 +void Acceptor::handleRead() +{ + InetAddress peerAddr; + int connfd = acceptSocket_.accept(&peerAddr); + if (connfd >= 0) + { + if (NewConnectionCallback_) + { + NewConnectionCallback_(connfd, peerAddr); // 轮询找到subLoop 唤醒并分发当前的新客户端的Channel + } + else + { + ::close(connfd); + } + } + else + { + LOG_ERROR("%s:%s:%d accept err:%d\n", __FILE__, __FUNCTION__, __LINE__, errno); + if (errno == EMFILE) + { + LOG_ERROR("%s:%s:%d sockfd reached limit\n", __FILE__, __FUNCTION__, __LINE__); + } + } +} \ No newline at end of file diff --git a/Acceptor.h b/Acceptor.h new file mode 100644 index 0000000..c88d1cc --- /dev/null +++ b/Acceptor.h @@ -0,0 +1,32 @@ +#pragma once + +#include + +#include "noncopyable.h" +#include "Socket.h" +#include "Channel.h" + +class EventLoop; +class InetAddress; + +class Acceptor : noncopyable +{ +public: + using NewConnectionCallback = std::function; + + Acceptor(EventLoop *loop, const InetAddress &listenAddr, bool reuseport); + ~Acceptor(); + + void setNewConnectionCallback(const NewConnectionCallback &cb) { NewConnectionCallback_ = cb; } + + bool listenning() const { return listenning_; } + void listen(); +private: + void handleRead(); + + EventLoop *loop_; // Acceptor用的就是用户定义的那个baseLoop 也称作mainLoop + Socket acceptSocket_; + Channel acceptChannel_; + NewConnectionCallback NewConnectionCallback_; + bool listenning_; +}; \ No newline at end of file diff --git a/Buffer.cc b/Buffer.cc new file mode 100644 index 0000000..145f7e1 --- /dev/null +++ b/Buffer.cc @@ -0,0 +1,70 @@ +#include +#include +#include + +#include "Buffer.h" + +/** + * 从fd上读取数据 Poller工作在LT模式 + * Buffer缓冲区是有大小的！ 但是从fd上读取数据的时候 却不知道tcp数据的最终大小 + * + * @description: 从socket读到缓冲区的方法是使用readv先读至buffer_， + * Buffer_空间如果不够会读入到栈上65536个字节大小的空间，然后以append的 + * 方式追加入buffer_。既考虑了避免系统调用带来开销，又不影响数据的接收。 + **/ +ssize_t Buffer::readFd(int fd, int *saveErrno) +{ + // 栈额外空间，用于从套接字往出读时，当buffer_暂时不够用时暂存数据，待buffer_重新分配足够空间后，在把数据交换给buffer_。 + char extrabuf[65536] = {0}; // 栈上内存空间 65536/1024 = 64KB + + /* + struct iovec { + ptr_t iov_base; // iov_base指向的缓冲区存放的是readv所接收的数据或是writev将要发送的数据 + size_t iov_len; // iov_len在各种情况下分别确定了接收的最大长度以及实际写入的长度 + }; + */ + + // 使用iovec分配两个连续的缓冲区 + struct iovec vec[2]; + const size_t writable = writableBytes(); // 这是Buffer底层缓冲区剩余的可写空间大小 不一定能完全存储从fd读出的数据 + + // 第一块缓冲区，指向可写空间 + vec[0].iov_base = begin() + writerIndex_; + vec[0].iov_len = writable; + // 第二块缓冲区，指向栈空间 + vec[1].iov_base = extrabuf; + vec[1].iov_len = sizeof extrabuf; + + // when there is enough space in this buffer, don't read into extrabuf. + // when extrabuf is used, we read 128k-1 bytes at most. + // 这里之所以说最多128k-1字节，是因为若writable为64k-1，那么需要两个缓冲区 第一个64k-1 第二个64k 所以做多128k-1 + // 如果第一个缓冲区>=64k 那就只采用一个缓冲区 而不使用栈空间extrabuf[65536]的内容 + const int iovcnt = (writable < sizeof extrabuf) ? 2 : 1; + const ssize_t n = ::readv(fd, vec, iovcnt); + + if (n < 0) + { + *saveErrno = errno; + } + else if (n <= writable) // Buffer的可写缓冲区已经够存储读出来的数据了 + { + writerIndex_ += n; + } + else // extrabuf里面也写入了n-writable长度的数据 + { + writerIndex_ = buffer_.size(); + append(extrabuf, n - writable); // 对buffer_扩容 并将extrabuf存储的另一部分数据追加至buffer_ + } +} + +// inputBuffer_.readFd表示将对端数据读到inputBuffer_中，移动writerIndex_指针 +// outputBuffer_.writeFd标示将数据写入到outputBuffer_中，从readerIndex_开始，可以写readableBytes()个字节 +ssize_t Buffer::writeFd(int fd, int *saveErrno) +{ + ssize_t n = ::write(fd, peek(), readableBytes()); + if (n < 0) + { + *saveErrno = errno; + } + return n; +} \ No newline at end of file diff --git a/Buffer.h b/Buffer.h new file mode 100644 index 0000000..3b3030d --- /dev/null +++ b/Buffer.h @@ -0,0 +1,106 @@ +#pragma once + +#include +#include +#include +#include + +// 网络库底层的缓冲区类型定义 +class Buffer +{ +public: + static const size_t kCheapPrepend = 8; + static const size_t kInitialSize = 1024; + + explicit Buffer(size_t initalSize = kInitialSize) + : buffer_(kCheapPrepend + initalSize) + , readerIndex_(kCheapPrepend) + , writerIndex_(kCheapPrepend) + { + } + + size_t readableBytes() const { return writerIndex_ - readerIndex_; } + size_t writableBytes() const { return buffer_.size() - writerIndex_; } + size_t prependableBytes() const { return readerIndex_; } + + // 返回缓冲区中可读数据的起始地址 + const char *peek() const { return begin() + readerIndex_; } + void retrieve(size_t len) + { + if (len < readableBytes()) + { + readerIndex_ += len; // 说明应用只读取了可读缓冲区数据的一部分，就是len长度 还剩下readerIndex+=len到writerIndex_的数据未读 + } + else // len == readableBytes() + { + retrieveAll(); + } + } + void retrieveAll() + { + readerIndex_ = kCheapPrepend; + writerIndex_ = kCheapPrepend; + } + + // 把onMessage函数上报的Buffer数据 转成string类型的数据返回 + std::string retrieveAllAsString() { return retrieveAsString(readableBytes()); } + std::string retrieveAsString(size_t len) + { + std::string result(peek(), len); + retrieve(len); // 上面一句把缓冲区中可读的数据已经读取出来 这里肯定要对缓冲区进行复位操作 + return result; + } + + // buffer_.size - writerIndex_ + void ensureWritableBytes(size_t len) + { + if (writableBytes() < len) + { + makeSpace(len); // 扩容 + } + } + + // 把[data, data+len]内存上的数据添加到writable缓冲区当中 + void append(const char *data, size_t len) + { + ensureWritableBytes(len); + std::copy(data, data+len, beginWrite()); + writerIndex_ += len; + } + char *beginWrite() { return begin() + writerIndex_; } + const char *beginWrite() const { return begin() + writerIndex_; } + + // 从fd上读取数据 + ssize_t readFd(int fd, int *saveErrno); + // 通过fd发送数据 + ssize_t writeFd(int fd, int *saveErrno); + +private: + // vector底层数组首元素的地址 也就是数组的起始地址 + char *begin() { return &*buffer_.begin(); } + const char *begin() const { return &*buffer_.begin(); } + + void makeSpace(size_t len) + { + /** + * | kCheapPrepend |xxx|reader | writer | // xxx标示reader中已读的部分 + * | kCheapPrepend | len | + **/ + if (writableBytes() + prependableBytes() < len + kCheapPrepend) // 也就是说 len > xxx + writer的部分 + { + buffer_.resize(writerIndex_ + len); + } + else // 这里说明 len <= xxx + writer 把reader搬到从xxx开始 使得xxx后面是一段连续空间 + { + size_t readable = readableBytes(); // readable = reader的长度 + std::copy(begin()+readerIndex_, begin()+writerIndex_, // 把这一部分数据拷贝到begin+kCheapPrepend起始处 + begin()+kCheapPrepend); + readerIndex_ = kCheapPrepend; + writerIndex_ = readerIndex_+readable; + } + } + + std::vector buffer_; + size_t readerIndex_; + size_t writerIndex_; +}; \ No newline at end of file diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 0000000..9248ec7 --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,14 @@ +cmake_minimum_required(VERSION 2.5) +project(mymuduo) + +# mymuduo最终编译成so动态库 设置动态库的路径 放置项目根目录的lib文件夹下面 +set(LIBRARY_OUTPUT_PATH ${PROJECT_SOURCE_DIR}/lib) + +# 设置调试信息 以及启动C++11语言标准 +set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g -std=c++11") + +# 定义参与编译的源代码文件 +aux_source_directory(. SRC_LIST) + +# 编译动态库 +add_library(mymuduo SHARED ${SRC_LIST}) \ No newline at end of file diff --git a/Callbacks.h b/Callbacks.h new file mode 100644 index 0000000..0306254 --- /dev/null +++ b/Callbacks.h @@ -0,0 +1,18 @@ +#pragma once + +#include +#include + +class Buffer; +class TcpConnection; +class Timestamp; + +using TcpConnectionPtr = std::shared_ptr; +using ConnectionCallback = std::function; +using CloseCallback = std::function; +using WriteCompleteCallback = std::function; +using HighWaterMarkCallback = std::function; + +using MessageCallback = std::function; \ No newline at end of file diff --git a/Channel.cc b/Channel.cc new file mode 100644 index 0000000..08ff156 --- /dev/null +++ b/Channel.cc @@ -0,0 +1,101 @@ +#include + +#include "Channel.h" +#include "EventLoop.h" +#include "Logger.h" + +const int Channel::kNoneEvent = 0; +const int Channel::kReadEvent = EPOLLIN | EPOLLPRI; +const int Channel::kWriteEvent = EPOLLOUT; + +// EventLoop: ChannelList Poller +Channel::Channel(EventLoop *loop, int fd) + : loop_(loop) + , fd_(fd) + , events_(0) + , revents_(0) + , index_(-1) + , tied_(false) +{ +} + +Channel::~Channel() {} + +// channel的tie方法什么时候调用过? TcpConnection => channel +/** + * TcpConnection中注册了Chnanel对应的回调函数，传入的回调函数均为TcpConnection + * 对象的成员方法，因此可以说明一点就是：Channel的结束一定早于TcpConnection对象！ + * 此处用tie去解决TcoConnection和Channel的生命周期时长问题，从而保证了Channel对 + * 象能够在TcpConnection销毁前销毁。 + **/ +void Channel::tie(const std::shared_ptr &obj) +{ + tie_ = obj; + tied_ = true; +} + +/** + * 当改变channel所表示的fd的events事件后，update负责再poller里面更改fd相应的事件epoll_ctl + **/ +void Channel::update() +{ + // 通过channel所属的eventloop，调用poller的相应方法，注册fd的events事件 + loop_->updateChannel(this); +} + +// 在channel所属的EventLoop中把当前的channel删除掉 +void Channel::remove() +{ + loop_->removeChannel(this); +} + +void Channel::handleEvent(Timestamp receiveTime) +{ + if (tied_) + { + std::shared_ptr guard = tie_.lock(); + if (guard) + { + handleEventWithGuard(receiveTime); + } + // 如果提升失败了 就不做任何处理 说明Channel的TcpConnection对象已经不存在了 + } + else + { + handleEventWithGuard(receiveTime); + } +} + +void Channel::handleEventWithGuard(Timestamp receiveTime) +{ + LOG_INFO("channel handleEvent revents:%d\n", revents_); + // 关闭 + if ((revents_ & EPOLLHUP) && !(revents_ & EPOLLIN)) // 当TcpConnection对应Channel 通过shutdown 关闭写端 epoll触发EPOLLHUP + { + if (closeCallback_) + { + closeCallback_(); + } + } + // 错误 + if (revents_ & EPOLLERR) + { + errorCallback_(); + } + // 读 + if (revents_ & (EPOLLIN | EPOLLPRI)) + { + if (readCallback_) + { + readCallback_(receiveTime); + } + } + // 写 + if (revents_ & EPOLLOUT) + { + if (writeCallback_) + { + writeCallback_(); + } + } +} \ No newline at end of file diff --git a/Channel.h b/Channel.h new file mode 100644 index 0000000..a105e30 --- /dev/null +++ b/Channel.h @@ -0,0 +1,81 @@ +#pragma once + +#include +#include + +#include "noncopyable.h" +#include "Timestamp.h" + +class EventLoop; + +/** + * 理清楚 EventLoop、Channel、Poller之间的关系 Reactor模型上对应多路事件分发器 + * Channel理解为通道 封装了sockfd和其感兴趣的event 如EPOLLIN、EPOLLOUT事件 还绑定了poller返回的具体事件 + **/ +class Channel : noncopyable +{ +public: + using EventCallback = std::function; // muduo仍使用typedef + using ReadEventCallback = std::function; + + Channel(EventLoop *loop, int fd); + ~Channel(); + + // fd得到Poller通知以后 处理事件 + void handleEvent(Timestamp receiveTime); + + // 设置回调函数对象 + void setReadCallback(ReadEventCallback cb) { readCallback_ = std::move(cb); } + void setWriteCallback(EventCallback cb) { writeCallback_ = std::move(cb); } + void setCloseCallback(EventCallback cb) { closeCallback_ = std::move(cb); } + void setErrorCallback(EventCallback cb) { errorCallback_ = std::move(cb); } + + // 防止当channel被手动remove掉 channel还在执行回调操作 + void tie(const std::shared_ptr &); + + int fd() const { return fd_; } + int events() const { return events_; } + void set_revents(int revt) { revents_ = revt; } + + // 设置fd相应的事件状态 相当于epoll_ctl add delete + void enableReading() { events_ |= kReadEvent; update(); } + void disableReading() { events_ &= ~kReadEvent; update(); } + void enableWriting() { events_ |= kWriteEvent; update(); } + void disableWriting() { events_ &= ~kWriteEvent; update(); } + void disableAll() { events_ = kNoneEvent; update(); } + + // 返回fd当前的事件状态 + bool isNoneEvent() const { return events_ == kNoneEvent; } + bool isWriting() const { return events_ & kWriteEvent; } + bool isReading() const { return events_ & kReadEvent; } + + int index() { return index_; } + void set_index(int idx) { index_ = idx; } + + // one loop per thread + EventLoop *ownerLoop() { return loop_; } + void remove(); +private: + + void update(); + void handleEventWithGuard(Timestamp receiveTime); + + static const int kNoneEvent; + static const int kReadEvent; + static const int kWriteEvent; + + EventLoop *loop_; // 事件循环 + const int fd_; // fd，Poller监听的对象 + int events_; // 注册fd感兴趣的事件 + int revents_; // Poller返回的具体发生的事件 + int index_; + + std::weak_ptr tie_; + bool tied_; + + // 因为channel通道里可获知fd最终发生的具体的事件events，所以它负责调用具体事件的回调操作 + ReadEventCallback readCallback_; + EventCallback writeCallback_; + EventCallback closeCallback_; + EventCallback errorCallback_; +}; \ No newline at end of file diff --git a/CurrentThread.cc b/CurrentThread.cc new file mode 100644 index 0000000..e28ed74 --- /dev/null +++ b/CurrentThread.cc @@ -0,0 +1,14 @@ +#include "CurrentThread.h" + +namespace CurrentThread +{ + __thread int t_cachedTid = 0; + + void cacheTid() + { + if (t_cachedTid == 0) + { + t_cachedTid = static_cast(::syscall(SYS_gettid)); + } + } +} \ No newline at end of file diff --git a/CurrentThread.h b/CurrentThread.h new file mode 100644 index 0000000..5742447 --- /dev/null +++ b/CurrentThread.h @@ -0,0 +1,20 @@ +#pragma once + +#include +#include + +namespace CurrentThread +{ + extern __thread int t_cachedTid; // 保存tid缓存 因为系统调用非常耗时 拿到tid后将其保存 + + void cacheTid(); + + inline int tid() // 内联函数只在当前文件中起作用 + { + if (__builtin_expect(t_cachedTid == 0, 0)) // __builtin_expect 是一种底层优化 此语句意思是如果还未获取tid 进入if 通过cacheTid()系统调用获取tid + { + cacheTid(); + } + return t_cachedTid; + } +} \ No newline at end of file diff --git a/DefaultPoller.cc b/DefaultPoller.cc new file mode 100644 index 0000000..d15d38c --- /dev/null +++ b/DefaultPoller.cc @@ -0,0 +1,16 @@ +#include + +#include "Poller.h" +#include "EPollPoller.h" + +Poller *Poller::newDefaultPoller(EventLoop *loop) +{ + if (::getenv("MUDUO_USE_POLL")) + { + return nullptr; // 生成poll的实例 + } + else + { + return new EPollPoller(loop); // 生成epoll的实例 + } +} \ No newline at end of file diff --git a/EPollPoller.cc b/EPollPoller.cc new file mode 100644 index 0000000..29f9477 --- /dev/null +++ b/EPollPoller.cc @@ -0,0 +1,147 @@ +#include +#include +#include + +#include "EPollPoller.h" +#include "Logger.h" +#include "Channel.h" + +const int kNew = -1; // 某个channel还没添加至Poller // channel的成员index_初始化为-1 +const int kAdded = 1; // 某个channel已经添加至Poller +const int kDeleted = 2; // 某个channel已经从Poller删除 + +EPollPoller::EPollPoller(EventLoop *loop) + : Poller(loop) + , epollfd_(epoll_create1(EPOLL_CLOEXEC)) + , events_(kInitEventListSize) // vector(16) +{ + if (epollfd_ < 0) + { + LOG_FATAL("epoll_create error:%d \n", errno); + } +} + +EPollPoller::~EPollPoller() +{ + ::close(epollfd_); +} + + +Timestamp EPollPoller::poll(int timeoutMs, ChannelList *activeChannels) +{ + // 由于频繁调用poll 实际上应该用LOG_DEBUG输出日志更为合理 当遇到并发场景 关闭DEBUG日志提升效率 + LOG_INFO("func=%s => fd total count:%lu\n", __FUNCTION__, channels_.size()); + + int numEvents = ::epoll_wait(epollfd_, &*events_.begin(), static_cast(events_.size()), timeoutMs); + int saveErrno = errno; + Timestamp now(Timestamp::now()); + + if (numEvents > 0) + { + LOG_INFO("%d events happend\n", numEvents); // LOG_DEBUG最合理 + fillActiveChannels(numEvents, activeChannels); + if (numEvents == events_.size()) // 扩容操作 + { + events_.resize(events_.size() * 2); + } + } + else if (numEvents == 0) + { + LOG_DEBUG("%s timeout!\n", __FUNCTION__); + } + else + { + if (saveErrno != EINTR) + { + errno = saveErrno; + LOG_ERROR("EPollPoller::poll() error!"); + } + } + return now; +} + +// channel update remove => EventLoop updateChannel removeChannel => Poller updateChannel removeChannel +void EPollPoller::updateChannel(Channel *channel) +{ + const int index = channel->index(); + LOG_INFO("func=%s => fd=%d events=%d index=%d\n", __FUNCTION__, channel->fd(), channel->events(), index); + + if (index == kNew || index == kDeleted) + { + if (index == kNew) + { + int fd = channel->fd(); + channels_[fd] = channel; + } + else // index == kDeleted + { + } + channel->set_index(kAdded); + update(EPOLL_CTL_ADD, channel); + } + else // channel已经在Poller中注册过了 + { + int fd = channel->fd(); + if (channel->isNoneEvent()) + { + update(EPOLL_CTL_DEL, channel); + channel->set_index(kDeleted); + } + else + { + update(EPOLL_CTL_MOD, channel); + } + } +} + +// 从Poller中删除channel +void EPollPoller::removeChannel(Channel *channel) +{ + int fd = channel->fd(); + channels_.erase(fd); + + LOG_INFO("func=%s => fd=%d\n", __FUNCTION__, fd); + + int index = channel->index(); + if (index == kAdded) + { + update(EPOLL_CTL_DEL, channel); + } + channel->set_index(kNew); +} + +// 填写活跃的连接 +void EPollPoller::fillActiveChannels(int numEvents, ChannelList *activeChannels) const +{ + for (int i = 0; i < numEvents; ++i) + { + Channel *channel = static_cast(events_[i].data.ptr); + channel->set_revents(events_[i].events); + activeChannels->push_back(channel); // EventLoop就拿到了它的Poller给它返回的所有发生事件的channel列表了 + } +} + +// 更新channel通道 其实就是调用epoll_ctl add/mod/del +void EPollPoller::update(int operation, Channel *channel) +{ + epoll_event event; + ::memset(&event, 0, sizeof event); + + int fd = channel->fd(); + + event.events = channel->events(); + event.data.ptr = channel; + event.data.fd = fd; + + if (::epoll_ctl(epollfd_, operation, fd, &event) < 0) + { + if (operation == EPOLL_CTL_DEL) + { + LOG_ERROR("epoll_ctl del error:%d\n", errno); + } + else + { + LOG_FATAL("epoll_ctl add/mod error:%d\n", errno); + } + } +} \ No newline at end of file diff --git a/EPollPoller.h b/EPollPoller.h new file mode 100644 index 0000000..f0cbd9c --- /dev/null +++ b/EPollPoller.h @@ -0,0 +1,41 @@ +#pragma once + +#include +#include + +#include "Poller.h" +#include "Timestamp.h" + +/** + * epoll的使用: + * 1. epoll_create + * 2. epoll_ctl (add, mod, del) + * 3. epoll_wait + **/ + +class Channel; + +class EPollPoller : public Poller +{ +public: + EPollPoller(EventLoop *loop); + ~EPollPoller() override; + + // 重写基类Poller的抽象方法 + Timestamp poll(int timeoutMs, ChannelList *activeChannels) override; + void updateChannel(Channel *channel) override; + void removeChannel(Channel *channel) override; + +private: + static const int kInitEventListSize = 16; + + // 填写活跃的连接 + void fillActiveChannels(int numEvents, ChannelList *activeChannels) const; + // 更新channel通道 其实就是调用epoll_ctl + void update(int operation, Channel *channel); + + using EventList = std::vector; // C++中可以省略struct 直接写epoll_event + + int epollfd_; // epoll_create创建返回的fd保存在epollfd_中 + EventList events_; // 用于存放epoll_wait返回的所有发生的事件的文件描述符事件集 +}; \ No newline at end of file diff --git a/EventLoop.cc b/EventLoop.cc new file mode 100644 index 0000000..55fbcf4 --- /dev/null +++ b/EventLoop.cc @@ -0,0 +1,213 @@ +#include +#include +#include +#include +#include + +#include "EventLoop.h" +#include "Logger.h" +#include "Channel.h" +#include "Poller.h" + +// 防止一个线程创建多个EventLoop +__thread EventLoop *t_loopInThisThread = nullptr; + +// 定义默认的Poller IO复用接口的超时时间 +const int kPollTimeMs = 10000; // 10000毫秒 = 10秒钟 + + +/* 创建线程之后主线程和子线程谁先运行是不确定的。 + * 通过一个eventfd在线程之间传递数据的好处是多个线程无需上锁就可以实现同步。 + * eventfd支持的最低内核版本为Linux 2.6.27,在2.6.26及之前的版本也可以使用eventfd，但是flags必须设置为0。 + * 函数原型： + * #include + * int eventfd(unsigned int initval, int flags); + * 参数说明： + * initval,初始化计数器的值。 + * flags, EFD_NONBLOCK,设置socket为非阻塞。 + * EFD_CLOEXEC，执行fork的时候，在父进程中的描述符会自动关闭，子进程中的描述符保留。 + * 场景： + * eventfd可以用于同一个进程之中的线程之间的通信。 + * eventfd还可以用于同亲缘关系的进程之间的通信。 + * eventfd用于不同亲缘关系的进程之间通信的话需要把eventfd放在几个进程共享的共享内存中（没有测试过）。 + */ +// 创建wakeupfd 用来notify唤醒subReactor处理新来的channel +int createEventfd() +{ + int evtfd = ::eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC); + if (evtfd < 0) + { + LOG_FATAL("eventfd error:%d\n", errno); + } + return evtfd; +} + + +EventLoop::EventLoop() + : looping_(false) + , quit_(false) + , callingPendingFunctors_(false) + , threadId_(CurrentThread::tid()) + , poller_(Poller::newDefaultPoller(this)) + , wakeupFd_(createEventfd()) + , wakeupChannel_(new Channel(this, wakeupFd_)) +{ + LOG_DEBUG("EventLoop created %p in thread %d\n", this, threadId_); + if (t_loopInThisThread) + { + LOG_FATAL("Another EventLoop %p exists in this thread %d\n", t_loopInThisThread, threadId_); + } + else + { + t_loopInThisThread = this; + } + + // 设置wakeupfd的事件类型以及发生事件后的回调操作 + wakeupChannel_->setReadCallback(std::bind(&EventLoop::handleRead, this)); + // 每一个EventLoop都将监听wakeupChannel_的EPOLL读事件了 + wakeupChannel_->enableReading(); +} +EventLoop::~EventLoop() +{ + wakeupChannel_->disableAll(); // 给Channel移除所有感兴趣的事件 + wakeupChannel_->remove(); // 把Channel从EventLoop上删除掉 + ::close(wakeupFd_); + t_loopInThisThread = nullptr; +} + +// 开启事件循环 +void EventLoop::loop() +{ + looping_ = true; + quit_ = false; + + LOG_INFO("EventLoop %p start looping\n", this); + + while(!quit_) + { + activeChannels_.clear(); + pollRetureTime_ = poller_->poll(kPollTimeMs, &activeChannels_); + for(Channel *channel : activeChannels_) + { + // Poller监听哪些channel发生了事件 然后上报给EventLoop 通知channel处理相应的事件 + channel->handleEvent(pollRetureTime_); + } + // 执行当前EventLoop事件循环需要处理的回调操作 + /** + * 对于线程数>=2的情况： + * IO线程 mainLoop(mainReactor)主要工作：accept接收连接 => 将accept返回的fd打包为 => Channel + * 因为mainLoop只做连接操作 已连接用户的打包好的Channel得分发给subLoop(subReactor) + * + * mainLoop事先注册一个回调cb（该回调需要subLoop执行，但是subLoop还在poller_->poll处阻塞） mainLoop通过wakeup将subLoop唤醒 + **/ + doPendingFunctors(); + } + LOG_INFO("EventLoop %p stop looping.\n", this); +} + +// 退出事件循环 +/** + * 1. 如果loop在自己的线程中调用quit成功了，说明当前线程已经执行完毕了loop()函数的poller_->poll并退出 + * 2. 如果不是当前EventLoop所属线程中调用quit退出EventLoop，需要唤醒EventLoop所属线程的epoll_wait + * + * 比如在一个subloop(worker)中调用mainloop(IO)的quit时，需要唤醒mainloop(IO)的poller_->poll，让其执行完loop()函数 + * + * ！！！！！！！！！！！！！！！ 注意： 正常情况下 mainLoop负责请求连接 将回调写入subLoop中，通过生产者消费者模型即可实现线程安全的队列 + * ！！！！！！！！！！！！！！！ 但是 muduo 通过wakeup() 采用eventfd创建的wakeupFd_ notify 使得mainLoop和subLoop之间能够进行通信 + **/ +void EventLoop::quit() +{ + quit_ = true; + + if (!isInLoopThread()) + { + wakeup(); + } +} + +// 在当前loop中执行cb +void EventLoop::runInLoop(Functor cb) +{ + if (isInLoopThread()) // 当前EventLoop中执行回调 + { + cb(); + } + else // 在非当前EventLoop线程中执行cb，就需要唤醒EventLoop所在线程执行cb + { + queueInLoop(cb); + } +} + +// 把cb放入队列中 唤醒loop所在的线程 执行cb +void EventLoop::queueInLoop(Functor cb) +{ + { + std::unique_lock lock(mutex_); + pendingFunctors_.emplace_back(cb); + } + + // 唤醒相应的需要执行上面回调操作的loop的线程 + /** + * || callingPendingFunctors的意思是：当前loop正在执行回调中，但是loop的pendingFunctors_中又加入了新的回调 + * 需要通过wakeup写事件，让loop()下一次poller_->poll()不再阻塞（阻塞的话会影响我前一次新加入的回调的执行），然后转而继续执行回调 + **/ + if (!isInLoopThread() || callingPendingFunctors_) + { + wakeup(); // 唤醒loop所在线程 + } +} + +void EventLoop::handleRead() +{ + uint64_t one = 1; + ssize_t n = read(wakeupFd_, &one, sizeof one); + if (n != sizeof one) + { + LOG_ERROR("EventLoop::handleRead() reads %lu bytes instead of 8", n); + } +} + +// 用来唤醒loop所在线程 向wakeupFd_写一个数据 wakeupChannel就发生读事件 当前loop线程就会被唤醒 +void EventLoop::wakeup() +{ + uint64_t one = 1; + ssize_t n = write(wakeupFd_, &one, sizeof one); + if (n != sizeof one) + { + LOG_ERROR("EventLoop::wakeup() writes %lu bytes instead of 8\n", n); + } +} + +// EventLoop的方法 => Poller的方法 +void EventLoop::updateChannel(Channel *channel) +{ + poller_->updateChannel(channel); +} + +void EventLoop::removeChannel(Channel *channel) +{ + poller_->removeChannel(channel); +} + +bool EventLoop::hasChannel(Channel *channel) +{ + return poller_->hasChannel(channel); +} + +void EventLoop::doPendingFunctors() +{ + std::vector functors; + callingPendingFunctors_ = true; + + { + std::unique_lock lock(mutex_); + functors.swap(pendingFunctors_); + } + + for(const Functor &functor : functors) + { + functor(); // 执行当前loop需要执行的回调操作 + } + + callingPendingFunctors_ = false; +} diff --git a/EventLoop.h b/EventLoop.h new file mode 100644 index 0000000..e5f46cf --- /dev/null +++ b/EventLoop.h @@ -0,0 +1,69 @@ +#pragma once + +#include +#include +#include +#include +#include + +#include "noncopyable.h" +#include "Timestamp.h" +#include "CurrentThread.h" + +class Channel; +class Poller; + +// 事件循环类 主要包含了两个大模块 Channel Poller(epoll的抽象) +class EventLoop : noncopyable +{ +public: + using Functor = std::function; + + EventLoop(); + ~EventLoop(); + + // 开启事件循环 + void loop(); + // 退出事件循环 + void quit(); + + Timestamp pollReturnTime() const { pollRetureTime_; } + + // 在当前loop中执行 + void runInLoop(Functor cb); + // 把cb放入队列中 唤醒loop所在的线程 执行cb + void queueInLoop(Functor cb); + + // 用来唤醒loop所在的线程的 + void wakeup(); + + // EventLoop的方法 => Poller的方法 + void updateChannel(Channel *channel); + void removeChannel(Channel *channel); + bool hasChannel(Channel *channel); + + // 判断EventLoop对象是否在自己的线程里 + bool isInLoopThread() const { return threadId_ == CurrentThread::tid(); } // threadId_为EventLoop创建时的线程id CurrentThread::tid()为当前线程id +private: + void handleRead(); // 处理wake up + void doPendingFunctors(); // 执行回调 + + using ChannelList = std::vector; + + std::atomic_bool looping_; // 原子操作 底层通过CAS实现 + std::atomic_bool quit_; // 标识退出loop循环 + + const pid_t threadId_; // 记录当前EventLoop所在的线程id + + Timestamp pollRetureTime_; // Poller返回发生事件的Channels的时间点 + std::unique_ptr poller_; + + int wakeupFd_; // 主要作用：当mainLoop获取一个新用户的Channel，通过轮询算法选择一个subLoop 通过该成员唤醒subLoop处理Channel + std::unique_ptr wakeupChannel_; + + ChannelList activeChannels_; + + std::atomic_bool callingPendingFunctors_; // 标识当前loop是否有需要执行的回调操作 + std::vector pendingFunctors_; // 存储loop需要执行的所有回调操作 + std::mutex mutex_; // 互斥锁 用来保护上面vector容器的线程安全操作 +}; \ No newline at end of file diff --git a/EventLoopThread.cc b/EventLoopThread.cc new file mode 100644 index 0000000..b29cc63 --- /dev/null +++ b/EventLoopThread.cc @@ -0,0 +1,58 @@ +#include "EventLoopThread.h" +#include "EventLoop.h" + +EventLoopThread::EventLoopThread(const ThreadInitCallback &cb, + const std::string &name) + : loop_(nullptr) + , exiting_(false) + , thread_(std::bind(&EventLoopThread::threadFunc, this), name) + , mutex_() + , cond_() + , callback_(cb) +{ +} +EventLoopThread::~EventLoopThread() +{ + exiting_ = true; + if (loop_ != nullptr) + { + loop_->quit(); + thread_.join(); + } +} + +EventLoop *EventLoopThread::startLoop() +{ + thread_.start(); // 启用底层线程Thread类对象thread_中通过start()创建的线程 + + EventLoop *loop = nullptr; + { + std::unique_lock lock(mutex_); + while(loop_ == nullptr) + { + cond_.wait(lock); + } + loop = loop_; + } + return loop; +} + +// 下面这个方法 是在单独的新线程里运行的 +void EventLoopThread::threadFunc() +{ + EventLoop loop; // 创建一个独立的EventLoop对象 和上面的线程是一一对应的 级one loop per thread + + if (callback_) + { + callback_(&loop); + } + + { + std::unique_lock lock(mutex_); + loop_ = &loop; + cond_.notify_one(); + } + loop.loop(); // 执行EventLoop的loop() 开启了底层的Poller的poll() + std::unique_lock lock(mutex_); + loop_ = nullptr; +} \ No newline at end of file diff --git a/EventLoopThread.h b/EventLoopThread.h new file mode 100644 index 0000000..88d3eee --- /dev/null +++ b/EventLoopThread.h @@ -0,0 +1,33 @@ +#pragma once + +#include +#include +#include +#include + +#include "noncopyable.h" +#include "Thread.h" + +class EventLoop; + +class EventLoopThread : noncopyable +{ +public: + using ThreadInitCallback = std::function; + + EventLoopThread(const ThreadInitCallback &cb = ThreadInitCallback(), + const std::string &name = std::string()); + ~EventLoopThread(); + + EventLoop *startLoop(); + +private: + void threadFunc(); + + EventLoop *loop_; + bool exiting_; + Thread thread_; + std::mutex mutex_; // 互斥锁 + std::condition_variable cond_; // 条件变量 + ThreadInitCallback callback_; +}; \ No newline at end of file diff --git a/EventLoopThreadPool.cc b/EventLoopThreadPool.cc new file mode 100644 index 0000000..7f1b856 --- /dev/null +++ b/EventLoopThreadPool.cc @@ -0,0 +1,68 @@ +#include + +#include "EventLoopThreadPool.h" +#include "EventLoopThread.h" + +EventLoopThreadPool::EventLoopThreadPool(EventLoop *baseLoop, const std::string &nameArg) + : baseLoop_(baseLoop) + , name_(nameArg) + , started_(false) + , numThreads_(0) + , next_(0) +{ + +} +EventLoopThreadPool::~EventLoopThreadPool() +{ + // Don't delete loop, it's stack variable +} + +void EventLoopThreadPool::start(const ThreadInitCallback &cb) +{ + started_ = true; + + for(int i = 0; i < numThreads_; ++i) + { + char buf[name_.size() + 32]; + snprintf(buf, sizeof buf, "%s%d", name_.c_str(), i); + EventLoopThread *t = new EventLoopThread(cb, buf); + threads_.push_back(std::unique_ptr(t)); + loops_.push_back(t->startLoop()); // 底层创建线程 绑定一个新的EventLoop 并返回该loop的地址 + } + + // 整个服务端只有一个线程运行baseLoop + if(numThreads_ == 0 && cb) + { + cb(baseLoop_); + } +} + +// 如果工作在多线程中，baseLoop_(mainLoop)会默认以轮询的方式分配Channel给subLoop +EventLoop *EventLoopThreadPool::getNextLoop() +{ + EventLoop *loop = baseLoop_; // 如果只设置一个线程 也就是只有一个mainReactor 无subReactor 那么轮询只有一个线程 getNextLoop()每次都返回当前的baseLoop_ + + if(!loops_.empty()) // 通过轮询获取下一个处理事件的loop + { + loop = loops_[next_]; + ++next_; + if(next_ >= loops_.size()) + { + next_ = 0; + } + } + + return loop; +} + +std::vector EventLoopThreadPool::getAllLoops() +{ + if(loops_.empty()) + { + return std::vector(1, baseLoop_); + } + else + { + return loops_; + } +} \ No newline at end of file diff --git a/EventLoopThreadPool.h b/EventLoopThreadPool.h new file mode 100644 index 0000000..53a34c2 --- /dev/null +++ b/EventLoopThreadPool.h @@ -0,0 +1,41 @@ +#pragma once + +#include +#include +#include +#include + +#include "noncopyable.h" + +class EventLoop; +class EventLoopThread; + +class EventLoopThreadPool : noncopyable +{ +public: + using ThreadInitCallback = std::function; + + EventLoopThreadPool(EventLoop *baseLoop, const std::string &nameArg); + ~EventLoopThreadPool(); + + void setThreadNum(int numThreads) { numThreads_ = numThreads; } + + void start(const ThreadInitCallback &cb = ThreadInitCallback()); + + // 如果工作在多线程中，baseLoop_(mainLoop)会默认以轮询的方式分配Channel给subLoop + EventLoop *getNextLoop(); + + std::vector getAllLoops(); + + bool started() const { return started_; } + const std::string name() const { return name_; } + +private: + EventLoop *baseLoop_; // 用户使用muduo创建的loop 如果线程数为1 那直接使用用户创建的loop 否则创建多EventLoop + std::string name_; + bool started_; + int numThreads_; + int next_; // 轮询的下标 + std::vector> threads_; + std::vector loops_; +}; \ No newline at end of file diff --git a/InetAddress.cc b/InetAddress.cc new file mode 100644 index 0000000..61297f9 --- /dev/null +++ b/InetAddress.cc @@ -0,0 +1,43 @@ +#include +#include + +#include "InetAddress.h" + +InetAddress::InetAddress(uint16_t port, std::string ip) +{ + bzero(&addr_, sizeof addr_); + addr_.sin_family = AF_INET; + addr_.sin_port = htons(port); // 本地字节序转为网络字节序 + addr_.sin_addr.s_addr = inet_addr(ip.c_str()); +} + +std::string InetAddress::toIp() const +{ + // addr_ + char buf[64] = {0}; + ::inet_ntop(AF_INET, &addr_.sin_addr, buf, sizeof buf); + return buf; +} + +std::string InetAddress::toIpPort() const +{ + // ip:port + char buf[64] = {0}; + ::inet_ntop(AF_INET, &addr_.sin_addr, buf, sizeof buf); + size_t end = strlen(buf); + uint16_t port = ntohs(addr_.sin_port); + sprintf(buf + end, ":%u", port); + return buf; +} + +uint16_t InetAddress::toPort() const +{ + return ntohs(addr_.sin_port); +} + +// #include +// int main() +// { +// InetAddress addr(8080); +// std::cout << addr.toIpPort() << std::endl; +// } \ No newline at end of file diff --git a/InetAddress.h b/InetAddress.h new file mode 100644 index 0000000..3703d0a --- /dev/null +++ b/InetAddress.h @@ -0,0 +1,26 @@ +#pragma once + +#include +#include +#include + +// 封装socket地址类型 +class InetAddress +{ +public: + explicit InetAddress(uint16_t port = 0, std::string ip = "127.0.0.1"); + explicit InetAddress(const sockaddr_in &addr) + : addr_(addr) + { + } + + std::string toIp() const; + std::string toIpPort() const; + uint16_t toPort() const; + + const sockaddr_in *getSockAddr() const { return &addr_; } + void setSockAddr(const sockaddr_in &addr) { addr_ = addr; } + +private: + sockaddr_in addr_; +}; \ No newline at end of file diff --git a/Logger.cc b/Logger.cc new file mode 100644 index 0000000..abf2cea --- /dev/null +++ b/Logger.cc @@ -0,0 +1,42 @@ +#include + +#include "Logger.h" +#include "Timestamp.h" + +// 获取日志唯一的实例对象 单例 +Logger &Logger::instance() +{ + static Logger logger; + return logger; +} + +// 设置日志级别 +void Logger::setLogLevel(int level) +{ + logLevel_ = level; +} + +// 写日志 [级别信息] time : msg +void Logger::log(std::string msg) +{ + switch (logLevel_) + { + case INFO: + std::cout << "[INFO]"; + break; + case ERROR: + std::cout << "[ERRIR]"; + break; + case FATAL: + std::cout << "[FATAL]"; + break; + case DEBUG: + std::cout << "[DEBUG]"; + break; + default: + break; + } + + // 打印时间和msg + std::cout << Timestamp::now().toString() << " : " << msg << std::endl; +} \ No newline at end of file diff --git a/Logger.h b/Logger.h new file mode 100644 index 0000000..53f3416 --- /dev/null +++ b/Logger.h @@ -0,0 +1,76 @@ +#pragma once + +#include + +#include "noncopyable.h" + +// LOG_INFO("%s %d", arg1, arg2) +#define LOG_INFO(logmsgFormat, ...) \ + do \ + { \ + Logger &logger = Logger::instance(); \ + logger.setLogLevel(INFO); \ + char buf[1024] = {0}; \ + snprintf(buf, 1024, logmsgFormat, ##__VA_ARGS__); \ + logger.log(buf); \ + } while (0) + +#define LOG_ERROR(logmsgFormat, ...) \ + do \ + { \ + Logger &logger = Logger::instance(); \ + logger.setLogLevel(ERROR); \ + char buf[1024] = {0}; \ + snprintf(buf, 1024, logmsgFormat, ##__VA_ARGS__); \ + logger.log(buf); \ + } while (0) + +#define LOG_FATAL(logmsgFormat, ...) \ + do \ + { \ + Logger &logger = Logger::instance(); \ + logger.setLogLevel(FATAL); \ + char buf[1024] = {0}; \ + snprintf(buf, 1024, logmsgFormat, ##__VA_ARGS__); \ + logger.log(buf); \ + exit(-1); \ + } while (0) + +#ifdef MUDEBUG +#define LOG_DEBUG(logmsgFormat, ...) \ + do \ + { \ + Logger &logger = Logger::instance(); \ + logger.setLogLevel(DEBUG); \ + char buf[1024] = {0}; \ + snprintf(buf, 1024, logmsgFormat, ##__VA_ARGS__); \ + logger.log(buf); \ + } while (0) +#else +#define LOG_DEBUG(logmsgFormat, ...) +#endif + +// 定义日志的级别 INFO ERROR FATAL DEBUG +enum LogLevel +{ + INFO, // 普通信息 + ERROR, // 错误信息 + FATAL, // core dump信息 + DEBUG, // 调试信息 +}; + +// 输出一个日志类 + +class Logger : noncopyable +{ +public: + // 获取日志唯一的实例对象 单例 + static Logger &instance(); + // 设置日志级别 + void setLogLevel(int level); + // 写日志 + void log(std::string msg); + +private: + int logLevel_; +}; \ No newline at end of file diff --git a/Poller.cc b/Poller.cc new file mode 100644 index 0000000..e5e60ef --- /dev/null +++ b/Poller.cc @@ -0,0 +1,13 @@ +#include "Poller.h" +#include "Channel.h" + +Poller::Poller(EventLoop *loop) + : ownerLoop_(loop) +{ +} + +bool Poller::hasChannel(Channel *channel) const +{ + auto it = channels_.find(channel->fd()); + return it != channels_.end() && it->second == channel; +} \ No newline at end of file diff --git a/Poller.h b/Poller.h new file mode 100644 index 0000000..803ef61 --- /dev/null +++ b/Poller.h @@ -0,0 +1,39 @@ +#pragma once + +#include +#include + +#include "noncopyable.h" +#include "Timestamp.h" + +class Channel; +class EventLoop; + +// muduo库中多路事件分发器的核心IO复用模块 +class Poller +{ +public: + using ChannelList = std::vector; + + Poller(EventLoop *loop); + virtual ~Poller() = default; + + // 给所有IO复用保留统一的接口 + virtual Timestamp poll(int timeoutMs, ChannelList *activeChannels) = 0; + virtual void updateChannel(Channel *channel) = 0; + virtual void removeChannel(Channel *channel) = 0; + + // 判断参数channel是否在当前的Poller当中 + bool hasChannel(Channel *channel) const; + + // EventLoop可以通过该接口获取默认的IO复用的具体实现 + static Poller *newDefaultPoller(EventLoop *loop); + +protected: + // map的key:sockfd value:sockfd所属的channel通道类型 + using ChannelMap = std::unordered_map; + ChannelMap channels_; + +private: + EventLoop *ownerLoop_; // 定义Poller所属的事件循环EventLoop +}; \ No newline at end of file diff --git a/Socket.cc b/Socket.cc new file mode 100644 index 0000000..bfd859e --- /dev/null +++ b/Socket.cc @@ -0,0 +1,72 @@ +#include +#include +#include +#include +#include + +#include "Socket.h" +#include "Logger.h" +#include "InetAddress.h" + +Socket::~Socket() +{ + ::close(sockfd_); +} + +void Socket::bindAddress(const InetAddress &localaddr) +{ + if (0 != ::bind(sockfd_, (sockaddr *)localaddr.getSockAddr(), sizeof(sockaddr_in))) + { + LOG_FATAL("bind sockfd:%d fail\n", sockfd_); + } +} + +void Socket::listen() +{ + if (0 != ::listen(sockfd_, 1024)) + { + LOG_FATAL("listen sockfd:%d fail\n", sockfd_); + } +} + +int Socket::accept(InetAddress *peeraddr) +{ + sockaddr_in addr; + socklen_t len; + ::memset(&addr, 0, sizeof addr); + int connfd = ::accept(sockfd_, (sockaddr *)&addr, &len); + if (connfd >= 0) + { + peeraddr->setSockAddr(addr); + } + return connfd; +} + +void Socket::shutdownWrite() +{ + if (::shutdown(sockfd_, SHUT_WR) < 0) + { + LOG_ERROR("shutdownWrite error"); + } +} + +void Socket::setTcpNoDelay(bool on) +{ + int optval = on ? 1 : 0; + ::setsockopt(sockfd_, IPPROTO_TCP, TCP_NODELAY, &optval, sizeof optval); // TCP_NODELAY包含头文件 +} +void Socket::setReuseAddr(bool on) +{ + int optval = on ? 1 : 0; + ::setsockopt(sockfd_, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof optval); // TCP_NODELAY包含头文件 +} +void Socket::setReusePort(bool on) +{ + int optval = on ? 1 : 0; + ::setsockopt(sockfd_, SOL_SOCKET, SO_REUSEPORT, &optval, sizeof optval); // TCP_NODELAY包含头文件 +} +void Socket::setKeepAlive(bool on) +{ + int optval = on ? 1 : 0; + ::setsockopt(sockfd_, SOL_SOCKET, SO_KEEPALIVE, &optval, sizeof optval); // TCP_NODELAY包含头文件 +} \ No newline at end of file diff --git a/Socket.h b/Socket.h new file mode 100644 index 0000000..958e914 --- /dev/null +++ b/Socket.h @@ -0,0 +1,31 @@ +#pragma once + +#include "noncopyable.h" + +class InetAddress; + +// 封装socket fd +class Socket : noncopyable +{ +public: + explicit Socket(int sockfd) + : sockfd_(sockfd) + { + } + ~Socket(); + + int fd() const { return sockfd_; } + void bindAddress(const InetAddress &localaddr); + void listen(); + int accept(InetAddress *peeraddr); + + void shutdownWrite(); + + void setTcpNoDelay(bool on); + void setReuseAddr(bool on); + void setReusePort(bool on); + void setKeepAlive(bool on); + +private: + const int sockfd_; +}; diff --git a/TcpConnection.cc b/TcpConnection.cc new file mode 100644 index 0000000..18e8da9 --- /dev/null +++ b/TcpConnection.cc @@ -0,0 +1,260 @@ +#include +#include +#include +#include +#include +#include +#include + +#include "TcpConnection.h" +#include "Logger.h" +#include "Socket.h" +#include "Channel.h" +#include "EventLoop.h" + +static EventLoop *CheckLoopNotNull(EventLoop *loop) +{ + if (loop == nullptr) + { + LOG_FATAL("%s:%s:%d mainLoop is null!\n", __FILE__, __FUNCTION__, __LINE__); + } + return loop; +} + +TcpConnection::TcpConnection(EventLoop *loop, + const std::string &nameArg, + int sockfd, + const InetAddress &localAddr, + const InetAddress &peerAddr) + : loop_(CheckLoopNotNull(loop)) + , name_(nameArg) + , state_(kConnecting) + , reading_(true) + , socket_(new Socket(sockfd)) + , channel_(new Channel(loop, sockfd)) + , localAddr_(localAddr) + , peerAddr_(peerAddr) + , highWaterMark_(64*1024*1024) // 64M +{ + // 下面给channel设置相应的回调函数 poller给channel通知感兴趣的事件发生了 channel会回调相应的回调函数 + channel_->setReadCallback( + std::bind(&TcpConnection::handleRead, this, std::placeholders::_1)); + channel_->setWriteCallback( + std::bind(&TcpConnection::handleWrite, this)); + channel_->setCloseCallback( + std::bind(&TcpConnection::handleClose, this)); + channel_->setErrorCallback( + std::bind(&TcpConnection::handleError, this)); + + LOG_INFO("TcpConnection::ctor[%s] at fd=%d\n", name_.c_str(), sockfd); + socket_->setKeepAlive(true); +} + +TcpConnection::~TcpConnection() +{ + LOG_INFO("TcpConnection::dtor[%s] at fd=%d state=%d\n", name_.c_str(), channel_->fd(), (int)state_); +} + +void TcpConnection::send(const std::string &buf) +{ + if (state_ == kConnected) + { + if (loop_->isInLoopThread()) // 这种是对于单个reactor的情况 用户调用conn->send时 loop_即为当前线程 + { + sendInLoop(buf.c_str(), buf.size()); + } + else + { + loop_->runInLoop(std::bind(&TcpConnection::sendInLoop, this, buf.c_str(), buf.size())); + } + } +} + +/** + * 发送数据 应用写的快 而内核发送数据慢 需要把待发送数据写入缓冲区，而且设置了水位回调 + **/ +void TcpConnection::sendInLoop(const void *data, size_t len) +{ + ssize_t nwrote = 0; + size_t remaining = len; + bool faultError = false; + + if (state_ == kDisconnected) // 之前调用过该connection的shutdown 不能再进行发送了 + { + LOG_ERROR("disconnected, give up writing"); + } + + // 表示channel_第一次开始写数据或者缓冲区没有待发送数据 + if (!channel_->isWriting() && outputBuffer_.readableBytes() == 0) + { + nwrote = ::write(channel_->fd(), data, len); + if (nwrote >= 0) + { + remaining = len - nwrote; + if (remaining == 0 && writeCompleteCallback_) + { + // 既然在这里数据全部发送完成，就不用再给channel设置epollout事件了 + loop_->queueInLoop(std::bind(writeCompleteCallback_, shared_from_this())); + } + } + else // nwrote < 0 + { + nwrote = 0; + if (errno != EWOULDBLOCK) // EWOULDBLOCK表示非阻塞情况下没有数据后的正常返回 等同于EAGAIN + { + LOG_ERROR("TcpConnection::sendInLoop"); + if (errno == EPIPE || errno == ECONNRESET) // SIGPIPE RESET + { + faultError = true; + } + } + } + } + /** + * 说明当前这一次write并没有把数据全部发送出去 剩余的数据需要保存到缓冲区当中 + * 然后给channel注册EPOLLOUT事件，Poller发现tcp的发送缓冲区有空间后会通知 + * 相应的sock->channel，调用channel对应注册的writeCallback_回调方法， + * channel的writeCallback_实际上就是TcpConnection设置的handleWrite回调， + * 把发送缓冲区outputBuffer_的内容全部发送完成 + **/ + if (!faultError && remaining > 0) + { + // 目前发送缓冲区剩余的待发送的数据的长度 + size_t oldLen = outputBuffer_.readableBytes(); + if (oldLen + remaining >= highWaterMark_ + && oldLen < highWaterMark_ + && highWaterMarkCallback_) + { + loop_->queueInLoop(std::bind(highWaterMarkCallback_, shared_from_this(), oldLen+remaining)); + } + outputBuffer_.append((char *)data + nwrote, remaining); + if (!channel_->isWriting()) + { + channel_->enableWriting(); // 这里一定要注册channel的写事件 否则poller不会给channel通知epollout + } + } +} + +void TcpConnection::shutdown() +{ + if (state_ == kConnected) + { + setState(kDisconnecting); + loop_->runInLoop(std::bind(&TcpConnection::shutdownInLoop, this)); + } +} + +void TcpConnection::shutdownInLoop() +{ + if (!channel_->isWriting()) // 说明当前outputBuffer_的数据全部向外发送完成 + { + socket_->shutdownWrite(); + } +} + +// 连接建立 +void TcpConnection::connectEstablished() +{ + setState(kConnected); + channel_->tie(shared_from_this()); + channel_->enableReading(); // 向poller注册channel的EPOLLIN读事件 + + // 新连接建立 执行回调 + connectionCallback_(shared_from_this()); +} +// 连接销毁 +void TcpConnection::connectDestroyed() +{ + if (state_ == kConnected) + { + setState(kDisconnected); + channel_->disableAll(); // 把channel的所有感兴趣的事件从poller中删除掉 + connectionCallback_(shared_from_this()); + } + channel_->remove(); // 把channel从poller中删除掉 +} + +// 读是相对服务器而言的 当对端客户端有数据到达 服务器端检测到EPOLLIN 就会触发该fd上的回调 handleRead取读走对端发来的数据 +void TcpConnection::handleRead(Timestamp receiveTime) +{ + int savedErrno = 0; + ssize_t n = inputBuffer_.readFd(channel_->fd(), &savedErrno); + if (n > 0) // 有数据到达 + { + // 已建立连接的用户有可读事件发生了 调用用户传入的回调操作onMessage shared_from_this就是获取了TcpConnection的智能指针 + messageCallback_(shared_from_this(), &inputBuffer_, receiveTime); + } + else if (n == 0) // 客户端断开 + { + handleClose(); + } + else // 出错了 + { + errno = savedErrno; + LOG_ERROR("TcpConnection::handleRead"); + handleError(); + } +} + +void TcpConnection::handleWrite() +{ + if (channel_->isWriting()) + { + int savedErrno = 0; + ssize_t n = outputBuffer_.writeFd(channel_->fd(), &savedErrno); + if (n > 0) + { + outputBuffer_.retrieve(n); + if (outputBuffer_.readableBytes() == 0) + { + channel_->disableWriting(); + if (writeCompleteCallback_) + { + // TcpConnection对象在其所在的subloop中 向pendingFunctors_中加入回调 + loop_->queueInLoop( + std::bind(writeCompleteCallback_, shared_from_this()) + ); + } + if (state_ == kDisconnecting) + { + shutdownInLoop(); // 在当前所属的loop中把TcpConnection删除掉 + } + } + } + else + { + LOG_ERROR("TcpConnection::handleWrite"); + } + } + else + { + LOG_ERROR("TcpConnection fd=%d is down, no more writing", channel_->fd()); + } +} + +void TcpConnection::handleClose() +{ + LOG_INFO("TcpConnection::handleClose fd=%d state=%d\n", channel_->fd(), (int)state_); + setState(kDisconnected); + channel_->disableAll(); + + TcpConnectionPtr connPtr(shared_from_this()); + connectionCallback_(connPtr); // 执行连接关闭的回调 + closeCallback_(connPtr); // 执行关闭连接的回调 执行的是TcpServer::removeConnection回调方法 // must be the last line +} + +void TcpConnection::handleError() +{ + int optval; + socklen_t optlen = sizeof optval; + int err = 0; + if (::getsockopt(channel_->fd(), SOL_SOCKET, SO_ERROR, &optval, &optlen) < 0) + { + err = errno; + } + else + { + err = optval; + } + LOG_ERROR("TcpConnection::handleError name:%s - SO_ERROR:%d\n", name_.c_str(), err); +} \ No newline at end of file diff --git a/TcpConnection.h b/TcpConnection.h new file mode 100644 index 0000000..a653e52 --- /dev/null +++ b/TcpConnection.h @@ -0,0 +1,101 @@ +#pragma once + +#include +#include +#include + +#include "noncopyable.h" +#include "InetAddress.h" +#include "Callbacks.h" +#include "Buffer.h" +#include "Timestamp.h" + +class Channel; +class EventLoop; +class Socket; + +/** + * TcpServer => Acceptor => 有一个新用户连接，通过accept函数拿到connfd + * => TcpConnection设置回调 => 设置到Channel => Poller => Channel回调 + **/ + +class TcpConnection : noncopyable, public std::enable_shared_from_this +{ +public: + TcpConnection(EventLoop *loop, + const std::string &nameArg, + int sockfd, + const InetAddress &localAddr, + const InetAddress &peerAddr); + ~TcpConnection(); + + EventLoop *getLoop() const { return loop_; } + const std::string &name() const { return name_; } + const InetAddress &localAddress() const { return localAddr_; } + const InetAddress &peerAddress() const { return peerAddr_; } + + bool connected() const { return state_ == kConnected; } + + // 发送数据 + void send(const std::string &buf); + // 关闭连接 + void shutdown(); + + void setConnectionCallback(const ConnectionCallback &cb) + { connectionCallback_ = cb; } + void setMessageCallback(const MessageCallback &cb) + { messageCallback_ = cb; } + void setWriteCompleteCallback(const WriteCompleteCallback &cb) + { writeCompleteCallback_ = cb; } + void setCloseCallback(const CloseCallback &cb) + { closeCallback_ = cb; } + void setHighWaterMarkCallback(const HighWaterMarkCallback &cb, size_t highWaterMark) + { highWaterMarkCallback_ = cb; highWaterMark_ = highWaterMark; } + + // 连接建立 + void connectEstablished(); + // 连接销毁 + void connectDestroyed(); + +private: + enum StateE + { + kDisconnected, // 已经断开连接 + kConnecting, // 正在连接 + kConnected, // 已连接 + kDisconnecting // 正在断开连接 + }; + void setState(StateE state) { state_ = state; } + + void handleRead(Timestamp receiveTime); + void handleWrite(); + void handleClose(); + void handleError(); + + void sendInLoop(const void *data, size_t len); + void shutdownInLoop(); + + EventLoop *loop_; // 这里绝对不是baseLoop 因为TcpConnection都是subLoop里面管理的 + const std::string name_; + std::atomic_int state_; + bool reading_; + + // Socket Channel 这里和Acceptor类似 Acceptor => mainloop TcpConnection => subloop + std::unique_ptr socket_; + std::unique_ptr channel_; + + const InetAddress localAddr_; + const InetAddress peerAddr_; + + // 这些回调TcpServer也有 用户通过写入TcpServer注册 TcpServer再将注册的回调传递给TcpConnection TcpConnection再将回调注册到Channel中 + ConnectionCallback connectionCallback_; // 有新连接时的回调 + MessageCallback messageCallback_; // 有读写消息时的回调 + WriteCompleteCallback writeCompleteCallback_; // 消息发送完成以后的回调 + HighWaterMarkCallback highWaterMarkCallback_; + CloseCallback closeCallback_; + size_t highWaterMark_; + + // 数据缓冲区 + Buffer inputBuffer_; // 接收数据的缓冲区 + Buffer outputBuffer_; // 发送数据的缓冲区 用户send向outputBuffer_发 +}; \ No newline at end of file diff --git a/TcpServer.cc b/TcpServer.cc new file mode 100644 index 0000000..9927614 --- /dev/null +++ b/TcpServer.cc @@ -0,0 +1,116 @@ +#include +#include + +#include "TcpServer.h" +#include "Logger.h" +#include "TcpConnection.h" + +static EventLoop *CheckLoopNotNull(EventLoop *loop) +{ + if (loop == nullptr) + { + LOG_FATAL("%s:%s:%d mainLoop is null!\n", __FILE__, __FUNCTION__, __LINE__); + } + return loop; +} + +TcpServer::TcpServer(EventLoop *loop, + const InetAddress &listenAddr, + const std::string &nameArg, + Option option) + : loop_(CheckLoopNotNull(loop)) + , ipPort_(listenAddr.toIpPort()) + , name_(nameArg) + , acceptor_(new Acceptor(loop, listenAddr, option == kReusePort)) + , threadPool_(new EventLoopThreadPool(loop, name_)) + , connectionCallback_() + , messageCallback_() + , nextConnId_(1) +{ + // 当有新用户连接时，Acceptor类中绑定的acceptChannel_会有读事件发生，执行handleRead()调用TcpServer::newConnection回调 + acceptor_->setNewConnectionCallback( + std::bind(&TcpServer::newConnection, this, std::placeholders::_1, std::placeholders::_2)); +} + +TcpServer::~TcpServer() +{ + for(auto &item : connections_) + { + TcpConnectionPtr conn(item.second); + item.second.reset(); // 把原始的智能指针复位 让栈空间的TcpConnectionPtr conn指向该对象 当conn出了其作用域 即可释放智能指针指向的对象 + conn->getLoop()->runInLoop( + std::bind(&TcpConnection::connectDestroyed, conn)); + } +} + +// 设置底层subloop的个数 +void TcpServer::setThreadNum(int numThreads) +{ + threadPool_->setThreadNum(numThreads); +} + +// 开启服务器监听 +void TcpServer::start() +{ + if (started_++ == 0) // 防止一个TcpServer对象被start多次 + { + threadPool_->start(threadInitCallback_); // 启动底层的loop线程池 + loop_->runInLoop(std::bind(&Acceptor::listen, acceptor_.get())); + } +} + +// 有一个新用户连接，acceptor会执行这个回调操作，负责将mainLoop接收到的请求连接(acceptChannel_会有读事件发生)通过回调轮询分发给subLoop去处理 +void TcpServer::newConnection(int sockfd, const InetAddress &peerAddr) +{ + // 轮询算法 选择一个subLoop 来管理connfd对应的channel + EventLoop *ioLoop = threadPool_->getNextLoop(); + char buf[64] = {0}; + snprintf(buf, sizeof buf, "-%s#%d", ipPort_.c_str(), nextConnId_); + ++nextConnId_; // 这里没有设置为原子类是因为其只在mainloop中执行 不涉及线程安全问题 + std::string connName = name_ + buf; + + LOG_INFO("TcpServer::newConnection [%s] - new connection [%s] from %s\n", + name_.c_str(), connName.c_str(), peerAddr.toIpPort().c_str()); + + // 通过sockfd获取其绑定的本机的ip地址和端口信息 + sockaddr_in local; + ::memset(&local, 0, sizeof local); + socklen_t addrlen = sizeof local; + if(::getsockname(sockfd, (sockaddr *)&local, &addrlen) < 0) + { + LOG_ERROR("sockets::getLocalAddr"); + } + + InetAddress localAddr(local); + TcpConnectionPtr conn(new TcpConnection(ioLoop, + connName, + sockfd, + localAddr, + peerAddr)); + connections_[connName] = conn; + // 下面的回调都是用户设置给TcpServer => TcpConnection的，至于Channel绑定的则是TcpConnection设置的四个，handleRead,handleWrite... 这下面的回调用于handlexxx函数中 + conn->setConnectionCallback(connectionCallback_); + conn->setMessageCallback(messageCallback_); + conn->setWriteCompleteCallback(writeCompleteCallback_); + + // 设置了如何关闭连接的回调 + conn->setCloseCallback( + std::bind(&TcpServer::removeConnection, this, std::placeholders::_1)); + + ioLoop->runInLoop(std::bind(&TcpConnection::connectEstablished, conn)); +} + +void TcpServer::removeConnection(const TcpConnectionPtr &conn) +{ + loop_->runInLoop(std::bind(&TcpServer::removeConnectionInLoop, this, conn)); +} +void TcpServer::removeConnectionInLoop(const TcpConnectionPtr &conn) +{ + LOG_INFO("TcpServer::removeConnectionInLoop [%s] - connection %s\n", + name_.c_str(), conn->name().c_str()); + + connections_.erase(conn->name()); + EventLoop *ioLoop = conn->getLoop(); + ioLoop->queueInLoop( + std::bind(&TcpConnection::connectDestroyed, conn)); +} \ No newline at end of file diff --git a/TcpServer.h b/TcpServer.h new file mode 100644 index 0000000..65dcaed --- /dev/null +++ b/TcpServer.h @@ -0,0 +1,75 @@ +#pragma once + +/** + * 用户使用muduo编写服务器程序 + **/ + +#include +#include +#include +#include +#include + +#include "EventLoop.h" +#include "Acceptor.h" +#include "InetAddress.h" +#include "noncopyable.h" +#include "EventLoopThreadPool.h" +#include "Callbacks.h" + +// 对外的服务器编程使用的类 +class TcpServer +{ +public: + using ThreadInitCallback = std::function; + + enum Option + { + kNoReusePort, + kReusePort, + }; + + TcpServer(EventLoop *loop, + const InetAddress &listenAddr, + const std::string &nameArg, + Option option = kNoReusePort); + ~TcpServer(); + + void setThreadInitCallback(const ThreadInitCallback &cb) { threadInitCallback_ = cb; } + void setConnectionCallback(const ConnectionCallback &cb) { connectionCallback_ = cb; } + void setMessageCallback(const MessageCallback &cb) { messageCallback_ = cb; } + void setWriteCompleteCallback(const WriteCompleteCallback &cb) { writeCompleteCallback_ = cb; } + + // 设置底层subloop的个数 + void setThreadNum(int numThreads); + + // 开启服务器监听 + void start(); + +private: + void newConnection(int sockfd, const InetAddress &peerAddr); + void removeConnection(const TcpConnectionPtr &conn); + void removeConnectionInLoop(const TcpConnectionPtr &conn); + + using ConnectionMap = std::unordered_map; + + EventLoop *loop_; // baseloop 用户自定义的loop + + const std::string ipPort_; + const std::string name_; + + std::unique_ptr acceptor_; // 运行在mainloop 任务就是监听新连接事件 + + std::shared_ptr threadPool_; // one loop per thread + + ConnectionCallback connectionCallback_; //有新连接时的回调 + MessageCallback messageCallback_; // 有读写事件发生时的回调 + WriteCompleteCallback writeCompleteCallback_; // 消息发送完成后的回调 + + ThreadInitCallback threadInitCallback_; // loop线程初始化的回调 + + std::atomic_int started_; + + int nextConnId_; + ConnectionMap connections_; // 保存所有的连接 +}; \ No newline at end of file diff --git a/Thread.cc b/Thread.cc new file mode 100644 index 0000000..c840135 --- /dev/null +++ b/Thread.cc @@ -0,0 +1,60 @@ +#include "Thread.h" +#include "CurrentThread.h" + +#include + +std::atomic_int Thread::numCreated_(0); + +Thread::Thread(ThreadFunc func, const std::string &name) + : started_(false) + , joined_(false) + , tid_(0) + , func_(std::move(func)) + , name_(name) +{ + setDefaultName(); +} + +Thread::~Thread() +{ + if (started_ && !joined_) + { + thread_->detach(); // thread类提供了设置分离线程的方法 线程运行后自动销毁（非阻塞） + } +} + +void Thread::start() // 一个Thread对象 记录的就是一个新线程的详细信息 +{ + started_ = true; + sem_t sem; + sem_init(&sem, false, 0); // false指的是 不设置进程间共享 + // 开启线程 + thread_ = std::shared_ptr(new std::thread([&]()->void { + // 获取线程的tid值 + tid_ = CurrentThread::tid(); + sem_post(&sem); + // 开启一个新线程 专门执行该线程函数 + func_(); + })); + + // 这里必须等待获取上面新创建的线程的tid值 + sem_wait(&sem); +} + +// C++ std::thread 中join（）和detach（）的区别：https://blog.nowcoder.net/n/8fcd9bb6e2e94d9596cf0a45c8e5858a +void Thread::join() +{ + joined_ = true; + thread_->join(); +} + +void Thread::setDefaultName() +{ + int num = ++numCreated_; + if (name_.empty()) + { + char buf[32] = {0}; + snprintf(buf, sizeof buf, "Thread%d", num); + name_ = buf; + } +} \ No newline at end of file diff --git a/Thread.h b/Thread.h new file mode 100644 index 0000000..ada23c5 --- /dev/null +++ b/Thread.h @@ -0,0 +1,39 @@ +#pragma once + +#include +#include +#include +#include +#include +#include + +#include "noncopyable.h" + +class Thread : noncopyable +{ +public: + using ThreadFunc = std::function; + + explicit Thread(ThreadFunc, const std::string &name = std::string()); + ~Thread(); + + void start(); + void join(); + + bool started() { return started_; } + pid_t tid() const { return tid_; } + const std::string &name() const { return name_; } + + static int numCreated() { return numCreated_; } + +private: + void setDefaultName(); + + bool started_; + bool joined_; + std::shared_ptr thread_; + pid_t tid_; // 在线程创建时再绑定 + ThreadFunc func_; // 线程回调函数 + std::string name_; + static std::atomic_int numCreated_; +}; \ No newline at end of file diff --git a/Timestamp.cc b/Timestamp.cc new file mode 100644 index 0000000..676a3cb --- /dev/null +++ b/Timestamp.cc @@ -0,0 +1,36 @@ +#include + +#include "Timestamp.h" + +Timestamp::Timestamp() : microSecondsSinceEpoch_(0) +{ +} + +Timestamp::Timestamp(int64_t microSecondsSinceEpoch) + : microSecondsSinceEpoch_(microSecondsSinceEpoch) +{ +} + +Timestamp Timestamp::now() +{ + return Timestamp(time(NULL)); +} +std::string Timestamp::toString() const +{ + char buf[128] = {0}; + tm *tm_time = localtime(µSecondsSinceEpoch_); + snprintf(buf, 128, "%4d/%02d/%02d %02d:%02d:%02d", + tm_time->tm_year + 1900, + tm_time->tm_mon + 1, + tm_time->tm_mday, + tm_time->tm_hour, + tm_time->tm_min, + tm_time->tm_sec); + return buf; +} + +// #include +// int main() { +// std::cout << Timestamp::now().toString() << std::endl; +// return 0; +// } \ No newline at end of file diff --git a/Timestamp.h b/Timestamp.h new file mode 100644 index 0000000..463f38b --- /dev/null +++ b/Timestamp.h @@ -0,0 +1,16 @@ +#pragma once + +#include +#include + +class Timestamp +{ +public: + Timestamp(); + explicit Timestamp(int64_t microSecondsSinceEpoch); + static Timestamp now(); + std::string toString() const; + +private: + int64_t microSecondsSinceEpoch_; +}; \ No newline at end of file diff --git a/build/CMakeCache.txt b/build/CMakeCache.txt new file mode 100644 index 0000000..d018f88 --- /dev/null +++ b/build/CMakeCache.txt @@ -0,0 +1,316 @@ +# This is the CMakeCache file. +# For build in directory: /root/mymuduo/build +# It was generated by CMake: /usr/bin/cmake +# You can edit this file to change values found and used by cmake. +# If you do not want to change any of the values, simply exit the editor. +# If you do want to change a value, simply edit, save, and exit the editor. +# The syntax for the file is as follows: +# KEY:TYPE=VALUE +# KEY is the name of a variable in the cache. +# TYPE is a hint to GUIs for the type of VALUE, DO NOT EDIT TYPE!. +# VALUE is the current value for the KEY. + +######################## +# EXTERNAL cache entries +######################## + +//Path to a program. +CMAKE_AR:FILEPATH=/usr/bin/ar + +//For backwards compatibility, what version of CMake commands and +// syntax should this version of CMake try to support. +CMAKE_BACKWARDS_COMPATIBILITY:STRING=2.4 + +//No help, variable specified on the command line. +CMAKE_BUILD_TYPE:STRING=Debug + +//Enable/Disable color output during build. +CMAKE_COLOR_MAKEFILE:BOOL=ON + +//No help, variable specified on the command line. +CMAKE_CXX_COMPILER:FILEPATH=/usr/bin/x86_64-linux-gnu-g++-5 + +//Flags used by the compiler during all build types. +CMAKE_CXX_FLAGS:STRING= + +//Flags used by the compiler during debug builds. +CMAKE_CXX_FLAGS_DEBUG:STRING=-g + +//Flags used by the compiler during release builds for minimum +// size. +CMAKE_CXX_FLAGS_MINSIZEREL:STRING=-Os -DNDEBUG + +//Flags used by the compiler during release builds. +CMAKE_CXX_FLAGS_RELEASE:STRING=-O3 -DNDEBUG + +//Flags used by the compiler during release builds with debug info. +CMAKE_CXX_FLAGS_RELWITHDEBINFO:STRING=-O2 -g -DNDEBUG + +//No help, variable specified on the command line. +CMAKE_C_COMPILER:FILEPATH=/usr/bin/x86_64-linux-gnu-gcc-5 + +//Flags used by the compiler during all build types. +CMAKE_C_FLAGS:STRING= + +//Flags used by the compiler during debug builds. +CMAKE_C_FLAGS_DEBUG:STRING=-g + +//Flags used by the compiler during release builds for minimum +// size. +CMAKE_C_FLAGS_MINSIZEREL:STRING=-Os -DNDEBUG + +//Flags used by the compiler during release builds. +CMAKE_C_FLAGS_RELEASE:STRING=-O3 -DNDEBUG + +//Flags used by the compiler during release builds with debug info. +CMAKE_C_FLAGS_RELWITHDEBINFO:STRING=-O2 -g -DNDEBUG + +//Flags used by the linker. +CMAKE_EXE_LINKER_FLAGS:STRING= + +//Flags used by the linker during debug builds. +CMAKE_EXE_LINKER_FLAGS_DEBUG:STRING= + +//Flags used by the linker during release minsize builds. +CMAKE_EXE_LINKER_FLAGS_MINSIZEREL:STRING= + +//Flags used by the linker during release builds. +CMAKE_EXE_LINKER_FLAGS_RELEASE:STRING= + +//Flags used by the linker during Release with Debug Info builds. +CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO:STRING= + +//No help, variable specified on the command line. +CMAKE_EXPORT_COMPILE_COMMANDS:BOOL=TRUE + +//Install path prefix, prepended onto install directories. +CMAKE_INSTALL_PREFIX:PATH=/usr/local + +//Path to a program. +CMAKE_LINKER:FILEPATH=/usr/bin/ld + +//Path to a program. +CMAKE_MAKE_PROGRAM:FILEPATH=/usr/bin/make + +//Flags used by the linker during the creation of modules. +CMAKE_MODULE_LINKER_FLAGS:STRING= + +//Flags used by the linker during debug builds. +CMAKE_MODULE_LINKER_FLAGS_DEBUG:STRING= + +//Flags used by the linker during release minsize builds. +CMAKE_MODULE_LINKER_FLAGS_MINSIZEREL:STRING= + +//Flags used by the linker during release builds. +CMAKE_MODULE_LINKER_FLAGS_RELEASE:STRING= + +//Flags used by the linker during Release with Debug Info builds. +CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO:STRING= + +//Path to a program. +CMAKE_NM:FILEPATH=/usr/bin/nm + +//Path to a program. +CMAKE_OBJCOPY:FILEPATH=/usr/bin/objcopy + +//Path to a program. +CMAKE_OBJDUMP:FILEPATH=/usr/bin/objdump + +//Value Computed by CMake +CMAKE_PROJECT_NAME:STATIC=mymuduo + +//Path to a program. +CMAKE_RANLIB:FILEPATH=/usr/bin/ranlib + +//Flags used by the linker during the creation of dll's. +CMAKE_SHARED_LINKER_FLAGS:STRING= + +//Flags used by the linker during debug builds. +CMAKE_SHARED_LINKER_FLAGS_DEBUG:STRING= + +//Flags used by the linker during release minsize builds. +CMAKE_SHARED_LINKER_FLAGS_MINSIZEREL:STRING= + +//Flags used by the linker during release builds. +CMAKE_SHARED_LINKER_FLAGS_RELEASE:STRING= + +//Flags used by the linker during Release with Debug Info builds. +CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO:STRING= + +//If set, runtime paths are not added when installing shared libraries, +// but are added when building. +CMAKE_SKIP_INSTALL_RPATH:BOOL=NO + +//If set, runtime paths are not added when using shared libraries. +CMAKE_SKIP_RPATH:BOOL=NO + +//Flags used by the linker during the creation of static libraries. +CMAKE_STATIC_LINKER_FLAGS:STRING= + +//Flags used by the linker during debug builds. +CMAKE_STATIC_LINKER_FLAGS_DEBUG:STRING= + +//Flags used by the linker during release minsize builds. +CMAKE_STATIC_LINKER_FLAGS_MINSIZEREL:STRING= + +//Flags used by the linker during release builds. +CMAKE_STATIC_LINKER_FLAGS_RELEASE:STRING= + +//Flags used by the linker during Release with Debug Info builds. +CMAKE_STATIC_LINKER_FLAGS_RELWITHDEBINFO:STRING= + +//Path to a program. +CMAKE_STRIP:FILEPATH=/usr/bin/strip + +//If this value is on, makefiles will be generated without the +// .SILENT directive, and all commands will be echoed to the console +// during the make. This is useful for debugging only. With Visual +// Studio IDE projects all commands are done without /nologo. +CMAKE_VERBOSE_MAKEFILE:BOOL=FALSE + +//Single output directory for building all executables. +EXECUTABLE_OUTPUT_PATH:PATH= + +//Single output directory for building all libraries. +LIBRARY_OUTPUT_PATH:PATH= + +//Value Computed by CMake +mymuduo_BINARY_DIR:STATIC=/root/mymuduo/build + +//Dependencies for target +mymuduo_LIB_DEPENDS:STATIC= + +//Value Computed by CMake +mymuduo_SOURCE_DIR:STATIC=/root/mymuduo + + +######################## +# INTERNAL cache entries +######################## + +//ADVANCED property for variable: CMAKE_AR +CMAKE_AR-ADVANCED:INTERNAL=1 +//This is the directory where this CMakeCache.txt was created +CMAKE_CACHEFILE_DIR:INTERNAL=/root/mymuduo/build +//Major version of cmake used to create the current loaded cache +CMAKE_CACHE_MAJOR_VERSION:INTERNAL=3 +//Minor version of cmake used to create the current loaded cache +CMAKE_CACHE_MINOR_VERSION:INTERNAL=5 +//Patch version of cmake used to create the current loaded cache +CMAKE_CACHE_PATCH_VERSION:INTERNAL=1 +//ADVANCED property for variable: CMAKE_COLOR_MAKEFILE +CMAKE_COLOR_MAKEFILE-ADVANCED:INTERNAL=1 +//Path to CMake executable. +CMAKE_COMMAND:INTERNAL=/usr/bin/cmake +//Path to cpack program executable. +CMAKE_CPACK_COMMAND:INTERNAL=/usr/bin/cpack +//Path to ctest program executable. +CMAKE_CTEST_COMMAND:INTERNAL=/usr/bin/ctest +//ADVANCED property for variable: CMAKE_CXX_COMPILER +CMAKE_CXX_COMPILER-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_CXX_FLAGS +CMAKE_CXX_FLAGS-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_CXX_FLAGS_DEBUG +CMAKE_CXX_FLAGS_DEBUG-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_CXX_FLAGS_MINSIZEREL +CMAKE_CXX_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_CXX_FLAGS_RELEASE +CMAKE_CXX_FLAGS_RELEASE-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_CXX_FLAGS_RELWITHDEBINFO +CMAKE_CXX_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_C_COMPILER +CMAKE_C_COMPILER-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_C_FLAGS +CMAKE_C_FLAGS-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_C_FLAGS_DEBUG +CMAKE_C_FLAGS_DEBUG-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_C_FLAGS_MINSIZEREL +CMAKE_C_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_C_FLAGS_RELEASE +CMAKE_C_FLAGS_RELEASE-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_C_FLAGS_RELWITHDEBINFO +CMAKE_C_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1 +//Executable file format +CMAKE_EXECUTABLE_FORMAT:INTERNAL=ELF +//ADVANCED property for variable: CMAKE_EXE_LINKER_FLAGS +CMAKE_EXE_LINKER_FLAGS-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_EXE_LINKER_FLAGS_DEBUG +CMAKE_EXE_LINKER_FLAGS_DEBUG-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_EXE_LINKER_FLAGS_MINSIZEREL +CMAKE_EXE_LINKER_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_EXE_LINKER_FLAGS_RELEASE +CMAKE_EXE_LINKER_FLAGS_RELEASE-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO +CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_EXPORT_COMPILE_COMMANDS +CMAKE_EXPORT_COMPILE_COMMANDS-ADVANCED:INTERNAL=1 +//Name of external makefile project generator. +CMAKE_EXTRA_GENERATOR:INTERNAL= +//Name of generator. +CMAKE_GENERATOR:INTERNAL=Unix Makefiles +//Name of generator platform. +CMAKE_GENERATOR_PLATFORM:INTERNAL= +//Name of generator toolset. +CMAKE_GENERATOR_TOOLSET:INTERNAL= +//Source directory with the top level CMakeLists.txt file for this +// project +CMAKE_HOME_DIRECTORY:INTERNAL=/root/mymuduo +//Install .so files without execute permission. +CMAKE_INSTALL_SO_NO_EXE:INTERNAL=1 +//ADVANCED property for variable: CMAKE_LINKER +CMAKE_LINKER-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_MAKE_PROGRAM +CMAKE_MAKE_PROGRAM-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_MODULE_LINKER_FLAGS +CMAKE_MODULE_LINKER_FLAGS-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_MODULE_LINKER_FLAGS_DEBUG +CMAKE_MODULE_LINKER_FLAGS_DEBUG-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_MODULE_LINKER_FLAGS_MINSIZEREL +CMAKE_MODULE_LINKER_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_MODULE_LINKER_FLAGS_RELEASE +CMAKE_MODULE_LINKER_FLAGS_RELEASE-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO +CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_NM +CMAKE_NM-ADVANCED:INTERNAL=1 +//number of local generators +CMAKE_NUMBER_OF_MAKEFILES:INTERNAL=1 +//ADVANCED property for variable: CMAKE_OBJCOPY +CMAKE_OBJCOPY-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_OBJDUMP +CMAKE_OBJDUMP-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_RANLIB +CMAKE_RANLIB-ADVANCED:INTERNAL=1 +//Path to CMake installation. +CMAKE_ROOT:INTERNAL=/usr/share/cmake-3.5 +//ADVANCED property for variable: CMAKE_SHARED_LINKER_FLAGS +CMAKE_SHARED_LINKER_FLAGS-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_SHARED_LINKER_FLAGS_DEBUG +CMAKE_SHARED_LINKER_FLAGS_DEBUG-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_SHARED_LINKER_FLAGS_MINSIZEREL +CMAKE_SHARED_LINKER_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_SHARED_LINKER_FLAGS_RELEASE +CMAKE_SHARED_LINKER_FLAGS_RELEASE-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO +CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_SKIP_INSTALL_RPATH +CMAKE_SKIP_INSTALL_RPATH-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_SKIP_RPATH +CMAKE_SKIP_RPATH-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS +CMAKE_STATIC_LINKER_FLAGS-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS_DEBUG +CMAKE_STATIC_LINKER_FLAGS_DEBUG-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS_MINSIZEREL +CMAKE_STATIC_LINKER_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS_RELEASE +CMAKE_STATIC_LINKER_FLAGS_RELEASE-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS_RELWITHDEBINFO +CMAKE_STATIC_LINKER_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_STRIP +CMAKE_STRIP-ADVANCED:INTERNAL=1 +//uname command +CMAKE_UNAME:INTERNAL=/bin/uname +//ADVANCED property for variable: CMAKE_VERBOSE_MAKEFILE +CMAKE_VERBOSE_MAKEFILE-ADVANCED:INTERNAL=1 + diff --git a/build/CMakeFiles/3.5.1/CMakeCCompiler.cmake b/build/CMakeFiles/3.5.1/CMakeCCompiler.cmake new file mode 100644 index 0000000..fb6f9fe --- /dev/null +++ b/build/CMakeFiles/3.5.1/CMakeCCompiler.cmake @@ -0,0 +1,67 @@ +set(CMAKE_C_COMPILER "/usr/bin/x86_64-linux-gnu-gcc-5") +set(CMAKE_C_COMPILER_ARG1 "") +set(CMAKE_C_COMPILER_ID "GNU") +set(CMAKE_C_COMPILER_VERSION "5.4.0") +set(CMAKE_C_COMPILER_WRAPPER "") +set(CMAKE_C_STANDARD_COMPUTED_DEFAULT "11") +set(CMAKE_C_COMPILE_FEATURES "c_function_prototypes;c_restrict;c_variadic_macros;c_static_assert") +set(CMAKE_C90_COMPILE_FEATURES "c_function_prototypes") +set(CMAKE_C99_COMPILE_FEATURES "c_restrict;c_variadic_macros") +set(CMAKE_C11_COMPILE_FEATURES "c_static_assert") + +set(CMAKE_C_PLATFORM_ID "Linux") +set(CMAKE_C_SIMULATE_ID "") +set(CMAKE_C_SIMULATE_VERSION "") + +set(CMAKE_AR "/usr/bin/ar") +set(CMAKE_RANLIB "/usr/bin/ranlib") +set(CMAKE_LINKER "/usr/bin/ld") +set(CMAKE_COMPILER_IS_GNUCC 1) +set(CMAKE_C_COMPILER_LOADED 1) +set(CMAKE_C_COMPILER_WORKS TRUE) +set(CMAKE_C_ABI_COMPILED TRUE) +set(CMAKE_COMPILER_IS_MINGW ) +set(CMAKE_COMPILER_IS_CYGWIN ) +if(CMAKE_COMPILER_IS_CYGWIN) + set(CYGWIN 1) + set(UNIX 1) +endif() + +set(CMAKE_C_COMPILER_ENV_VAR "CC") + +if(CMAKE_COMPILER_IS_MINGW) + set(MINGW 1) +endif() +set(CMAKE_C_COMPILER_ID_RUN 1) +set(CMAKE_C_SOURCE_FILE_EXTENSIONS c;m) +set(CMAKE_C_IGNORE_EXTENSIONS h;H;o;O;obj;OBJ;def;DEF;rc;RC) +set(CMAKE_C_LINKER_PREFERENCE 10) + +# Save compiler ABI information. +set(CMAKE_C_SIZEOF_DATA_PTR "8") +set(CMAKE_C_COMPILER_ABI "ELF") +set(CMAKE_C_LIBRARY_ARCHITECTURE "x86_64-linux-gnu") + +if(CMAKE_C_SIZEOF_DATA_PTR) + set(CMAKE_SIZEOF_VOID_P "${CMAKE_C_SIZEOF_DATA_PTR}") +endif() + +if(CMAKE_C_COMPILER_ABI) + set(CMAKE_INTERNAL_PLATFORM_ABI "${CMAKE_C_COMPILER_ABI}") +endif() + +if(CMAKE_C_LIBRARY_ARCHITECTURE) + set(CMAKE_LIBRARY_ARCHITECTURE "x86_64-linux-gnu") +endif() + +set(CMAKE_C_CL_SHOWINCLUDES_PREFIX "") +if(CMAKE_C_CL_SHOWINCLUDES_PREFIX) + set(CMAKE_CL_SHOWINCLUDES_PREFIX "${CMAKE_C_CL_SHOWINCLUDES_PREFIX}") +endif() + + + + +set(CMAKE_C_IMPLICIT_LINK_LIBRARIES "c") +set(CMAKE_C_IMPLICIT_LINK_DIRECTORIES "/usr/lib/gcc/x86_64-linux-gnu/5;/usr/lib/x86_64-linux-gnu;/usr/lib;/lib/x86_64-linux-gnu;/lib") +set(CMAKE_C_IMPLICIT_LINK_FRAMEWORK_DIRECTORIES "") diff --git a/build/CMakeFiles/3.5.1/CMakeCXXCompiler.cmake b/build/CMakeFiles/3.5.1/CMakeCXXCompiler.cmake new file mode 100644 index 0000000..a3ebe85 --- /dev/null +++ b/build/CMakeFiles/3.5.1/CMakeCXXCompiler.cmake @@ -0,0 +1,68 @@ +set(CMAKE_CXX_COMPILER "/usr/bin/x86_64-linux-gnu-g++-5") +set(CMAKE_CXX_COMPILER_ARG1 "") +set(CMAKE_CXX_COMPILER_ID "GNU") +set(CMAKE_CXX_COMPILER_VERSION "5.4.0") +set(CMAKE_CXX_COMPILER_WRAPPER "") +set(CMAKE_CXX_STANDARD_COMPUTED_DEFAULT "98") +set(CMAKE_CXX_COMPILE_FEATURES "cxx_template_template_parameters;cxx_alias_templates;cxx_alignas;cxx_alignof;cxx_attributes;cxx_auto_type;cxx_constexpr;cxx_decltype;cxx_decltype_incomplete_return_types;cxx_default_function_template_args;cxx_defaulted_functions;cxx_defaulted_move_initializers;cxx_delegating_constructors;cxx_deleted_functions;cxx_enum_forward_declarations;cxx_explicit_conversions;cxx_extended_friend_declarations;cxx_extern_templates;cxx_final;cxx_func_identifier;cxx_generalized_initializers;cxx_inheriting_constructors;cxx_inline_namespaces;cxx_lambdas;cxx_local_type_template_args;cxx_long_long_type;cxx_noexcept;cxx_nonstatic_member_init;cxx_nullptr;cxx_override;cxx_range_for;cxx_raw_string_literals;cxx_reference_qualified_functions;cxx_right_angle_brackets;cxx_rvalue_references;cxx_sizeof_member;cxx_static_assert;cxx_strong_enums;cxx_thread_local;cxx_trailing_return_types;cxx_unicode_literals;cxx_uniform_initialization;cxx_unrestricted_unions;cxx_user_literals;cxx_variadic_macros;cxx_variadic_templates;cxx_aggregate_default_initializers;cxx_attribute_deprecated;cxx_binary_literals;cxx_contextual_conversions;cxx_decltype_auto;cxx_digit_separators;cxx_generic_lambdas;cxx_lambda_init_captures;cxx_relaxed_constexpr;cxx_return_type_deduction;cxx_variable_templates") +set(CMAKE_CXX98_COMPILE_FEATURES "cxx_template_template_parameters") +set(CMAKE_CXX11_COMPILE_FEATURES "cxx_alias_templates;cxx_alignas;cxx_alignof;cxx_attributes;cxx_auto_type;cxx_constexpr;cxx_decltype;cxx_decltype_incomplete_return_types;cxx_default_function_template_args;cxx_defaulted_functions;cxx_defaulted_move_initializers;cxx_delegating_constructors;cxx_deleted_functions;cxx_enum_forward_declarations;cxx_explicit_conversions;cxx_extended_friend_declarations;cxx_extern_templates;cxx_final;cxx_func_identifier;cxx_generalized_initializers;cxx_inheriting_constructors;cxx_inline_namespaces;cxx_lambdas;cxx_local_type_template_args;cxx_long_long_type;cxx_noexcept;cxx_nonstatic_member_init;cxx_nullptr;cxx_override;cxx_range_for;cxx_raw_string_literals;cxx_reference_qualified_functions;cxx_right_angle_brackets;cxx_rvalue_references;cxx_sizeof_member;cxx_static_assert;cxx_strong_enums;cxx_thread_local;cxx_trailing_return_types;cxx_unicode_literals;cxx_uniform_initialization;cxx_unrestricted_unions;cxx_user_literals;cxx_variadic_macros;cxx_variadic_templates") +set(CMAKE_CXX14_COMPILE_FEATURES "cxx_aggregate_default_initializers;cxx_attribute_deprecated;cxx_binary_literals;cxx_contextual_conversions;cxx_decltype_auto;cxx_digit_separators;cxx_generic_lambdas;cxx_lambda_init_captures;cxx_relaxed_constexpr;cxx_return_type_deduction;cxx_variable_templates") + +set(CMAKE_CXX_PLATFORM_ID "Linux") +set(CMAKE_CXX_SIMULATE_ID "") +set(CMAKE_CXX_SIMULATE_VERSION "") + +set(CMAKE_AR "/usr/bin/ar") +set(CMAKE_RANLIB "/usr/bin/ranlib") +set(CMAKE_LINKER "/usr/bin/ld") +set(CMAKE_COMPILER_IS_GNUCXX 1) +set(CMAKE_CXX_COMPILER_LOADED 1) +set(CMAKE_CXX_COMPILER_WORKS TRUE) +set(CMAKE_CXX_ABI_COMPILED TRUE) +set(CMAKE_COMPILER_IS_MINGW ) +set(CMAKE_COMPILER_IS_CYGWIN ) +if(CMAKE_COMPILER_IS_CYGWIN) + set(CYGWIN 1) + set(UNIX 1) +endif() + +set(CMAKE_CXX_COMPILER_ENV_VAR "CXX") + +if(CMAKE_COMPILER_IS_MINGW) + set(MINGW 1) +endif() +set(CMAKE_CXX_COMPILER_ID_RUN 1) +set(CMAKE_CXX_IGNORE_EXTENSIONS inl;h;hpp;HPP;H;o;O;obj;OBJ;def;DEF;rc;RC) +set(CMAKE_CXX_SOURCE_FILE_EXTENSIONS C;M;c++;cc;cpp;cxx;mm;CPP) +set(CMAKE_CXX_LINKER_PREFERENCE 30) +set(CMAKE_CXX_LINKER_PREFERENCE_PROPAGATES 1) + +# Save compiler ABI information. +set(CMAKE_CXX_SIZEOF_DATA_PTR "8") +set(CMAKE_CXX_COMPILER_ABI "ELF") +set(CMAKE_CXX_LIBRARY_ARCHITECTURE "x86_64-linux-gnu") + +if(CMAKE_CXX_SIZEOF_DATA_PTR) + set(CMAKE_SIZEOF_VOID_P "${CMAKE_CXX_SIZEOF_DATA_PTR}") +endif() + +if(CMAKE_CXX_COMPILER_ABI) + set(CMAKE_INTERNAL_PLATFORM_ABI "${CMAKE_CXX_COMPILER_ABI}") +endif() + +if(CMAKE_CXX_LIBRARY_ARCHITECTURE) + set(CMAKE_LIBRARY_ARCHITECTURE "x86_64-linux-gnu") +endif() + +set(CMAKE_CXX_CL_SHOWINCLUDES_PREFIX "") +if(CMAKE_CXX_CL_SHOWINCLUDES_PREFIX) + set(CMAKE_CL_SHOWINCLUDES_PREFIX "${CMAKE_CXX_CL_SHOWINCLUDES_PREFIX}") +endif() + + + + +set(CMAKE_CXX_IMPLICIT_LINK_LIBRARIES "stdc++;m;c") +set(CMAKE_CXX_IMPLICIT_LINK_DIRECTORIES "/usr/lib/gcc/x86_64-linux-gnu/5;/usr/lib/x86_64-linux-gnu;/usr/lib;/lib/x86_64-linux-gnu;/lib") +set(CMAKE_CXX_IMPLICIT_LINK_FRAMEWORK_DIRECTORIES "") diff --git a/build/CMakeFiles/3.5.1/CMakeDetermineCompilerABI_C.bin b/build/CMakeFiles/3.5.1/CMakeDetermineCompilerABI_C.bin new file mode 100644 index 0000000000000000000000000000000000000000..4e87d56e36ad8f7c9cc3768c49b5acfa7236baa5 GIT binary patch literal 8640 zcmeHNeQXrR6`#BF$2o@cL4cT#mQ4$-q4MVJ8pnWI_I$Qk6WdT@)3nsA&%U#L2NSgPWDZP+DM7UA?pg+C0rF)11n=1 zTh5lT5|7v=;Md@^fCi_=GbEQ;Fw|frY9UIjFPAitwd9Ls zmP(Q_g#*aLwt78W1=-6pBo)z)Dj|u7D)OoXuS)PpPKbt)r2b*w@Yf~$bvZTAP}fkf zCVtIHw8gaLiW$QEkZ?5Q)({5Wl672Tj3n{C1w3r$r%hgA*eU9})3{8D{*e?admtL= ztFLo3rjm<*z<;dHnBhUVgc@@8XTOzW?yDolpMwvEv7Bdgd&6=jCIS#mBDw<$ZBC zfh?tJ&=m(e`*GUUGsD2Vku-w| z(-;m$VubW3Q^r6f7GXwfSGy4kC&Gh~q!~_hwFjc{Shy?L7Y(yWY#?qVBYVQ}0V6bG zCYTWp1fFrmi-?-bNFXH7syI2iNIsxWEU+LY`UVC=kWQ# zXN*#%m`C`mQ9W3uk6m}`&lJB|rZD~KakF^xYaBe|K8>Y}W!9X6qRh%OaIILbK@RmH zEV_Cr18L<8pbs2G08`D4*7W%udiouG?4MIxx?0bU;|$Qxp2P{LpFNB7XYvog`*5IQ zc@tyD9)yN<>(w~l^s#A=p1!hc=`r+#&6(G80t+&i!1yTySsa2c|KQ); z!O0mHIMCBm`pL-+y5kM~{EWFU>#dx;RV)WTR{eXwQ3ma2sd?Q%oQy%kdfq6$K@==KK=N0J)OFAw)r-;^O@%B`k{*7@5Omu z@%p%<`8FXB=OMSD8QHGz@$i4!zs;Y{_`CgGZ3k9%lqk@-1Jx+Ewx(~jrZ2Ruy29_- z$xmF98)h;Y{plN~Qge~Uqb>bjTl!WLc*rbxTOT{^(AQo|y{C_zac}SOf6w3J-{Ch- zAIw$y0o-Tq4=nJOI|^n8W33%6o7d$%Hrss-J=i~v2m2!1VSj;uW2tLBzO#zq_tqzw z%wCXgXx|35Xey|4})Zl9`EzcMo;B)u4a#Nps3MP^=z^3@$DFx;J9f7+e@c$SA4c@<)6d}0+7qJ{?M+!B!_kryJCR&5Zp57z4AHsB>C78QJ<2k~oiY=YmO?*6?U?Lrs zdETE1VGpl3uG6?q3H^vDx7h#tE1hHInzo64%J{}WV4YIc-It1)DP@gXr~0bvQ(UWg zqNZN;)u}bLtE>X0)>l*StM{#yeaN~CW>tezlVP|=&g^+Pzt9CGrmcNZcD@wa7iZ^5 zAzqT5Plb3Xv%3#2n4NV03hm1n&4WVxp6q-n#Aly}u-wJwz`<6_H|2R3o6CA_@!a_= zpX6dT=Oi$2<(>Zu?dN6V3x)W6b{KY}a&obIv+=y@*07c$%?%gMzSL0rWS zzb|`E$>+H6X%f$CAwK(jjO8wybE<{YYLxSW&tVa}naLqm4%ayctR8avaeZ^b`S`GO zU(hq+mn2*jxV)}5asRpVG_40)IX-(l_Xt0xA!tUZD68+ z$eqUF6xcW*B5<%wL-TB!fSldrI^iLD-8b+1R$Z(cfllZfV)t z++}q68{3+(Y92@XoKZ6=7N=?X;jGUSRLhH}SwX(f6jWnsa`&(q>;q{gEICBENDP94 zBTS9O&9Dl0r`ik-3T-f!Qu|U72zN(9Ohs)dm>gniXm ziEuQC1d$twnoQ+!LKU*=U>sC4JPKDHt5g$l9)DEBLt;`5g}@1E7S)s;0Q{#+70_f#h?)*Xf zd;zl#$lzIn_|r}eG(4AZ!On>eW4sl!#D_NyPut+?f*qVY0K@D;A*F8I9( z6Ui4LpU>|V{9eJQ_Hq(jWc{ZSpWde;C{Q-Xh}DIYIf9{C@!#Z#D7hJVf7{C&c|1(;+*5=sp~h z>Zk8J)7U9Ua(hW9`99d>w?BKn5)~-uBrg$<Kib6@{bW^^GzhT?ee{PZGE%*NjmM+)-Uu%1oAOHXW literal 0 HcmV?d00001 diff --git a/build/CMakeFiles/3.5.1/CMakeDetermineCompilerABI_CXX.bin b/build/CMakeFiles/3.5.1/CMakeDetermineCompilerABI_CXX.bin new file mode 100644 index 0000000000000000000000000000000000000000..02597532eff5f5e939c78f5e7765bf1f4388740a GIT binary patch literal 8656 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 Y!jHxy-1BeRcI}^AY>24 & 0x00FF) +# define COMPILER_VERSION_MINOR HEX(__CODEGEARC_VERSION__>>16 & 0x00FF) +# define COMPILER_VERSION_PATCH DEC(__CODEGEARC_VERSION__ & 0xFFFF) + +#elif defined(__BORLANDC__) +# define COMPILER_ID "Borland" + /* __BORLANDC__ = 0xVRR */ +# define COMPILER_VERSION_MAJOR HEX(__BORLANDC__>>8) +# define COMPILER_VERSION_MINOR HEX(__BORLANDC__ & 0xFF) + +#elif defined(__WATCOMC__) && __WATCOMC__ < 1200 +# define COMPILER_ID "Watcom" + /* __WATCOMC__ = VVRR */ +# define COMPILER_VERSION_MAJOR DEC(__WATCOMC__ / 100) +# define COMPILER_VERSION_MINOR DEC((__WATCOMC__ / 10) % 10) +# if (__WATCOMC__ % 10) > 0 +# define COMPILER_VERSION_PATCH DEC(__WATCOMC__ % 10) +# endif + +#elif defined(__WATCOMC__) +# define COMPILER_ID "OpenWatcom" + /* __WATCOMC__ = VVRP + 1100 */ +# define COMPILER_VERSION_MAJOR DEC((__WATCOMC__ - 1100) / 100) +# define COMPILER_VERSION_MINOR DEC((__WATCOMC__ / 10) % 10) +# if (__WATCOMC__ % 10) > 0 +# define COMPILER_VERSION_PATCH DEC(__WATCOMC__ % 10) +# endif + +#elif defined(__SUNPRO_C) +# define COMPILER_ID "SunPro" +# if __SUNPRO_C >= 0x5100 + /* __SUNPRO_C = 0xVRRP */ +# define COMPILER_VERSION_MAJOR HEX(__SUNPRO_C>>12) +# define COMPILER_VERSION_MINOR HEX(__SUNPRO_C>>4 & 0xFF) +# define COMPILER_VERSION_PATCH HEX(__SUNPRO_C & 0xF) +# else + /* __SUNPRO_CC = 0xVRP */ +# define COMPILER_VERSION_MAJOR HEX(__SUNPRO_C>>8) +# define COMPILER_VERSION_MINOR HEX(__SUNPRO_C>>4 & 0xF) +# define COMPILER_VERSION_PATCH HEX(__SUNPRO_C & 0xF) +# endif + +#elif defined(__HP_cc) +# define COMPILER_ID "HP" + /* __HP_cc = VVRRPP */ +# define COMPILER_VERSION_MAJOR DEC(__HP_cc/10000) +# define COMPILER_VERSION_MINOR DEC(__HP_cc/100 % 100) +# define COMPILER_VERSION_PATCH DEC(__HP_cc % 100) + +#elif defined(__DECC) +# define COMPILER_ID "Compaq" + /* __DECC_VER = VVRRTPPPP */ +# define COMPILER_VERSION_MAJOR DEC(__DECC_VER/10000000) +# define COMPILER_VERSION_MINOR DEC(__DECC_VER/100000 % 100) +# define COMPILER_VERSION_PATCH DEC(__DECC_VER % 10000) + +#elif defined(__IBMC__) && defined(__COMPILER_VER__) +# define COMPILER_ID "zOS" + /* __IBMC__ = VRP */ +# define COMPILER_VERSION_MAJOR DEC(__IBMC__/100) +# define COMPILER_VERSION_MINOR DEC(__IBMC__/10 % 10) +# define COMPILER_VERSION_PATCH DEC(__IBMC__ % 10) + +#elif defined(__IBMC__) && !defined(__COMPILER_VER__) && __IBMC__ >= 800 +# define COMPILER_ID "XL" + /* __IBMC__ = VRP */ +# define COMPILER_VERSION_MAJOR DEC(__IBMC__/100) +# define COMPILER_VERSION_MINOR DEC(__IBMC__/10 % 10) +# define COMPILER_VERSION_PATCH DEC(__IBMC__ % 10) + +#elif defined(__IBMC__) && !defined(__COMPILER_VER__) && __IBMC__ < 800 +# define COMPILER_ID "VisualAge" + /* __IBMC__ = VRP */ +# define COMPILER_VERSION_MAJOR DEC(__IBMC__/100) +# define COMPILER_VERSION_MINOR DEC(__IBMC__/10 % 10) +# define COMPILER_VERSION_PATCH DEC(__IBMC__ % 10) + +#elif defined(__PGI) +# define COMPILER_ID "PGI" +# define COMPILER_VERSION_MAJOR DEC(__PGIC__) +# define COMPILER_VERSION_MINOR DEC(__PGIC_MINOR__) +# if defined(__PGIC_PATCHLEVEL__) +# define COMPILER_VERSION_PATCH DEC(__PGIC_PATCHLEVEL__) +# endif + +#elif defined(_CRAYC) +# define COMPILER_ID "Cray" +# define COMPILER_VERSION_MAJOR DEC(_RELEASE_MAJOR) +# define COMPILER_VERSION_MINOR DEC(_RELEASE_MINOR) + +#elif defined(__TI_COMPILER_VERSION__) +# define COMPILER_ID "TI" + /* __TI_COMPILER_VERSION__ = VVVRRRPPP */ +# define COMPILER_VERSION_MAJOR DEC(__TI_COMPILER_VERSION__/1000000) +# define COMPILER_VERSION_MINOR DEC(__TI_COMPILER_VERSION__/1000 % 1000) +# define COMPILER_VERSION_PATCH DEC(__TI_COMPILER_VERSION__ % 1000) + +#elif defined(__FUJITSU) || defined(__FCC_VERSION) || defined(__fcc_version) +# define COMPILER_ID "Fujitsu" + +#elif defined(__TINYC__) +# define COMPILER_ID "TinyCC" + +#elif defined(__SCO_VERSION__) +# define COMPILER_ID "SCO" + +#elif defined(__clang__) && defined(__apple_build_version__) +# define COMPILER_ID "AppleClang" +# if defined(_MSC_VER) +# define SIMULATE_ID "MSVC" +# endif +# define COMPILER_VERSION_MAJOR DEC(__clang_major__) +# define COMPILER_VERSION_MINOR DEC(__clang_minor__) +# define COMPILER_VERSION_PATCH DEC(__clang_patchlevel__) +# if defined(_MSC_VER) + /* _MSC_VER = VVRR */ +# define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100) +# define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100) +# endif +# define COMPILER_VERSION_TWEAK DEC(__apple_build_version__) + +#elif defined(__clang__) +# define COMPILER_ID "Clang" +# if defined(_MSC_VER) +# define SIMULATE_ID "MSVC" +# endif +# define COMPILER_VERSION_MAJOR DEC(__clang_major__) +# define COMPILER_VERSION_MINOR DEC(__clang_minor__) +# define COMPILER_VERSION_PATCH DEC(__clang_patchlevel__) +# if defined(_MSC_VER) + /* _MSC_VER = VVRR */ +# define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100) +# define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100) +# endif + +#elif defined(__GNUC__) +# define COMPILER_ID "GNU" +# define COMPILER_VERSION_MAJOR DEC(__GNUC__) +# if defined(__GNUC_MINOR__) +# define COMPILER_VERSION_MINOR DEC(__GNUC_MINOR__) +# endif +# if defined(__GNUC_PATCHLEVEL__) +# define COMPILER_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__) +# endif + +#elif defined(_MSC_VER) +# define COMPILER_ID "MSVC" + /* _MSC_VER = VVRR */ +# define COMPILER_VERSION_MAJOR DEC(_MSC_VER / 100) +# define COMPILER_VERSION_MINOR DEC(_MSC_VER % 100) +# if defined(_MSC_FULL_VER) +# if _MSC_VER >= 1400 + /* _MSC_FULL_VER = VVRRPPPPP */ +# define COMPILER_VERSION_PATCH DEC(_MSC_FULL_VER % 100000) +# else + /* _MSC_FULL_VER = VVRRPPPP */ +# define COMPILER_VERSION_PATCH DEC(_MSC_FULL_VER % 10000) +# endif +# endif +# if defined(_MSC_BUILD) +# define COMPILER_VERSION_TWEAK DEC(_MSC_BUILD) +# endif + +#elif defined(__VISUALDSPVERSION__) || defined(__ADSPBLACKFIN__) || defined(__ADSPTS__) || defined(__ADSP21000__) +# define COMPILER_ID "ADSP" +#if defined(__VISUALDSPVERSION__) + /* __VISUALDSPVERSION__ = 0xVVRRPP00 */ +# define COMPILER_VERSION_MAJOR HEX(__VISUALDSPVERSION__>>24) +# define COMPILER_VERSION_MINOR HEX(__VISUALDSPVERSION__>>16 & 0xFF) +# define COMPILER_VERSION_PATCH HEX(__VISUALDSPVERSION__>>8 & 0xFF) +#endif + +#elif defined(__IAR_SYSTEMS_ICC__ ) || defined(__IAR_SYSTEMS_ICC) +# define COMPILER_ID "IAR" + +#elif defined(__ARMCC_VERSION) +# define COMPILER_ID "ARMCC" +#if __ARMCC_VERSION >= 1000000 + /* __ARMCC_VERSION = VRRPPPP */ + # define COMPILER_VERSION_MAJOR DEC(__ARMCC_VERSION/1000000) + # define COMPILER_VERSION_MINOR DEC(__ARMCC_VERSION/10000 % 100) + # define COMPILER_VERSION_PATCH DEC(__ARMCC_VERSION % 10000) +#else + /* __ARMCC_VERSION = VRPPPP */ + # define COMPILER_VERSION_MAJOR DEC(__ARMCC_VERSION/100000) + # define COMPILER_VERSION_MINOR DEC(__ARMCC_VERSION/10000 % 10) + # define COMPILER_VERSION_PATCH DEC(__ARMCC_VERSION % 10000) +#endif + + +#elif defined(SDCC) +# define COMPILER_ID "SDCC" + /* SDCC = VRP */ +# define COMPILER_VERSION_MAJOR DEC(SDCC/100) +# define COMPILER_VERSION_MINOR DEC(SDCC/10 % 10) +# define COMPILER_VERSION_PATCH DEC(SDCC % 10) + +#elif defined(_SGI_COMPILER_VERSION) || defined(_COMPILER_VERSION) +# define COMPILER_ID "MIPSpro" +# if defined(_SGI_COMPILER_VERSION) + /* _SGI_COMPILER_VERSION = VRP */ +# define COMPILER_VERSION_MAJOR DEC(_SGI_COMPILER_VERSION/100) +# define COMPILER_VERSION_MINOR DEC(_SGI_COMPILER_VERSION/10 % 10) +# define COMPILER_VERSION_PATCH DEC(_SGI_COMPILER_VERSION % 10) +# else + /* _COMPILER_VERSION = VRP */ +# define COMPILER_VERSION_MAJOR DEC(_COMPILER_VERSION/100) +# define COMPILER_VERSION_MINOR DEC(_COMPILER_VERSION/10 % 10) +# define COMPILER_VERSION_PATCH DEC(_COMPILER_VERSION % 10) +# endif + + +/* These compilers are either not known or too old to define an + identification macro. Try to identify the platform and guess that + it is the native compiler. */ +#elif defined(__sgi) +# define COMPILER_ID "MIPSpro" + +#elif defined(__hpux) || defined(__hpua) +# define COMPILER_ID "HP" + +#else /* unknown compiler */ +# define COMPILER_ID "" +#endif + +/* Construct the string literal in pieces to prevent the source from + getting matched. Store it in a pointer rather than an array + because some compilers will just produce instructions to fill the + array rather than assigning a pointer to a static array. */ +char const* info_compiler = "INFO" ":" "compiler[" COMPILER_ID "]"; +#ifdef SIMULATE_ID +char const* info_simulate = "INFO" ":" "simulate[" SIMULATE_ID "]"; +#endif + +#ifdef __QNXNTO__ +char const* qnxnto = "INFO" ":" "qnxnto[]"; +#endif + +#if defined(__CRAYXE) || defined(__CRAYXC) +char const *info_cray = "INFO" ":" "compiler_wrapper[CrayPrgEnv]"; +#endif + +#define STRINGIFY_HELPER(X) #X +#define STRINGIFY(X) STRINGIFY_HELPER(X) + +/* Identify known platforms by name. */ +#if defined(__linux) || defined(__linux__) || defined(linux) +# define PLATFORM_ID "Linux" + +#elif defined(__CYGWIN__) +# define PLATFORM_ID "Cygwin" + +#elif defined(__MINGW32__) +# define PLATFORM_ID "MinGW" + +#elif defined(__APPLE__) +# define PLATFORM_ID "Darwin" + +#elif defined(_WIN32) || defined(__WIN32__) || defined(WIN32) +# define PLATFORM_ID "Windows" + +#elif defined(__FreeBSD__) || defined(__FreeBSD) +# define PLATFORM_ID "FreeBSD" + +#elif defined(__NetBSD__) || defined(__NetBSD) +# define PLATFORM_ID "NetBSD" + +#elif defined(__OpenBSD__) || defined(__OPENBSD) +# define PLATFORM_ID "OpenBSD" + +#elif defined(__sun) || defined(sun) +# define PLATFORM_ID "SunOS" + +#elif defined(_AIX) || defined(__AIX) || defined(__AIX__) || defined(__aix) || defined(__aix__) +# define PLATFORM_ID "AIX" + +#elif defined(__sgi) || defined(__sgi__) || defined(_SGI) +# define PLATFORM_ID "IRIX" + +#elif defined(__hpux) || defined(__hpux__) +# define PLATFORM_ID "HP-UX" + +#elif defined(__HAIKU__) +# define PLATFORM_ID "Haiku" + +#elif defined(__BeOS) || defined(__BEOS__) || defined(_BEOS) +# define PLATFORM_ID "BeOS" + +#elif defined(__QNX__) || defined(__QNXNTO__) +# define PLATFORM_ID "QNX" + +#elif defined(__tru64) || defined(_tru64) || defined(__TRU64__) +# define PLATFORM_ID "Tru64" + +#elif defined(__riscos) || defined(__riscos__) +# define PLATFORM_ID "RISCos" + +#elif defined(__sinix) || defined(__sinix__) || defined(__SINIX__) +# define PLATFORM_ID "SINIX" + +#elif defined(__UNIX_SV__) +# define PLATFORM_ID "UNIX_SV" + +#elif defined(__bsdos__) +# define PLATFORM_ID "BSDOS" + +#elif defined(_MPRAS) || defined(MPRAS) +# define PLATFORM_ID "MP-RAS" + +#elif defined(__osf) || defined(__osf__) +# define PLATFORM_ID "OSF1" + +#elif defined(_SCO_SV) || defined(SCO_SV) || defined(sco_sv) +# define PLATFORM_ID "SCO_SV" + +#elif defined(__ultrix) || defined(__ultrix__) || defined(_ULTRIX) +# define PLATFORM_ID "ULTRIX" + +#elif defined(__XENIX__) || defined(_XENIX) || defined(XENIX) +# define PLATFORM_ID "Xenix" + +#elif defined(__WATCOMC__) +# if defined(__LINUX__) +# define PLATFORM_ID "Linux" + +# elif defined(__DOS__) +# define PLATFORM_ID "DOS" + +# elif defined(__OS2__) +# define PLATFORM_ID "OS2" + +# elif defined(__WINDOWS__) +# define PLATFORM_ID "Windows3x" + +# else /* unknown platform */ +# define PLATFORM_ID "" +# endif + +#else /* unknown platform */ +# define PLATFORM_ID "" + +#endif + +/* For windows compilers MSVC and Intel we can determine + the architecture of the compiler being used. This is because + the compilers do not have flags that can change the architecture, + but rather depend on which compiler is being used +*/ +#if defined(_WIN32) && defined(_MSC_VER) +# if defined(_M_IA64) +# define ARCHITECTURE_ID "IA64" + +# elif defined(_M_X64) || defined(_M_AMD64) +# define ARCHITECTURE_ID "x64" + +# elif defined(_M_IX86) +# define ARCHITECTURE_ID "X86" + +# elif defined(_M_ARM) +# if _M_ARM == 4 +# define ARCHITECTURE_ID "ARMV4I" +# elif _M_ARM == 5 +# define ARCHITECTURE_ID "ARMV5I" +# else +# define ARCHITECTURE_ID "ARMV" STRINGIFY(_M_ARM) +# endif + +# elif defined(_M_MIPS) +# define ARCHITECTURE_ID "MIPS" + +# elif defined(_M_SH) +# define ARCHITECTURE_ID "SHx" + +# else /* unknown architecture */ +# define ARCHITECTURE_ID "" +# endif + +#elif defined(__WATCOMC__) +# if defined(_M_I86) +# define ARCHITECTURE_ID "I86" + +# elif defined(_M_IX86) +# define ARCHITECTURE_ID "X86" + +# else /* unknown architecture */ +# define ARCHITECTURE_ID "" +# endif + +#else +# define ARCHITECTURE_ID "" +#endif + +/* Convert integer to decimal digit literals. */ +#define DEC(n) \ + ('0' + (((n) / 10000000)%10)), \ + ('0' + (((n) / 1000000)%10)), \ + ('0' + (((n) / 100000)%10)), \ + ('0' + (((n) / 10000)%10)), \ + ('0' + (((n) / 1000)%10)), \ + ('0' + (((n) / 100)%10)), \ + ('0' + (((n) / 10)%10)), \ + ('0' + ((n) % 10)) + +/* Convert integer to hex digit literals. */ +#define HEX(n) \ + ('0' + ((n)>>28 & 0xF)), \ + ('0' + ((n)>>24 & 0xF)), \ + ('0' + ((n)>>20 & 0xF)), \ + ('0' + ((n)>>16 & 0xF)), \ + ('0' + ((n)>>12 & 0xF)), \ + ('0' + ((n)>>8 & 0xF)), \ + ('0' + ((n)>>4 & 0xF)), \ + ('0' + ((n) & 0xF)) + +/* Construct a string literal encoding the version number components. */ +#ifdef COMPILER_VERSION_MAJOR +char const info_version[] = { + 'I', 'N', 'F', 'O', ':', + 'c','o','m','p','i','l','e','r','_','v','e','r','s','i','o','n','[', + COMPILER_VERSION_MAJOR, +# ifdef COMPILER_VERSION_MINOR + '.', COMPILER_VERSION_MINOR, +# ifdef COMPILER_VERSION_PATCH + '.', COMPILER_VERSION_PATCH, +# ifdef COMPILER_VERSION_TWEAK + '.', COMPILER_VERSION_TWEAK, +# endif +# endif +# endif + ']','\0'}; +#endif + +/* Construct a string literal encoding the version number components. */ +#ifdef SIMULATE_VERSION_MAJOR +char const info_simulate_version[] = { + 'I', 'N', 'F', 'O', ':', + 's','i','m','u','l','a','t','e','_','v','e','r','s','i','o','n','[', + SIMULATE_VERSION_MAJOR, +# ifdef SIMULATE_VERSION_MINOR + '.', SIMULATE_VERSION_MINOR, +# ifdef SIMULATE_VERSION_PATCH + '.', SIMULATE_VERSION_PATCH, +# ifdef SIMULATE_VERSION_TWEAK + '.', SIMULATE_VERSION_TWEAK, +# endif +# endif +# endif + ']','\0'}; +#endif + +/* Construct the string literal in pieces to prevent the source from + getting matched. Store it in a pointer rather than an array + because some compilers will just produce instructions to fill the + array rather than assigning a pointer to a static array. */ +char const* info_platform = "INFO" ":" "platform[" PLATFORM_ID "]"; +char const* info_arch = "INFO" ":" "arch[" ARCHITECTURE_ID "]"; + + + + +const char* info_language_dialect_default = "INFO" ":" "dialect_default[" +#if !defined(__STDC_VERSION__) + "90" +#elif __STDC_VERSION__ >= 201000L + "11" +#elif __STDC_VERSION__ >= 199901L + "99" +#else +#endif +"]"; + +/*--------------------------------------------------------------------------*/ + +#ifdef ID_VOID_MAIN +void main() {} +#else +int main(int argc, char* argv[]) +{ + int require = 0; + require += info_compiler[argc]; + require += info_platform[argc]; + require += info_arch[argc]; +#ifdef COMPILER_VERSION_MAJOR + require += info_version[argc]; +#endif +#ifdef SIMULATE_ID + require += info_simulate[argc]; +#endif +#ifdef SIMULATE_VERSION_MAJOR + require += info_simulate_version[argc]; +#endif +#if defined(__CRAYXE) || defined(__CRAYXC) + require += info_cray[argc]; +#endif + require += info_language_dialect_default[argc]; + (void)argv; + return require; +} +#endif diff --git a/build/CMakeFiles/3.5.1/CompilerIdC/a.out b/build/CMakeFiles/3.5.1/CompilerIdC/a.out new file mode 100644 index 0000000000000000000000000000000000000000..0abd21ce8dad9af37207bc298c44d2eb9b0d82f7 GIT binary patch literal 8800 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 & 0x00FF) +# define COMPILER_VERSION_MINOR HEX(__CODEGEARC_VERSION__>>16 & 0x00FF) +# define COMPILER_VERSION_PATCH DEC(__CODEGEARC_VERSION__ & 0xFFFF) + +#elif defined(__BORLANDC__) +# define COMPILER_ID "Borland" + /* __BORLANDC__ = 0xVRR */ +# define COMPILER_VERSION_MAJOR HEX(__BORLANDC__>>8) +# define COMPILER_VERSION_MINOR HEX(__BORLANDC__ & 0xFF) + +#elif defined(__WATCOMC__) && __WATCOMC__ < 1200 +# define COMPILER_ID "Watcom" + /* __WATCOMC__ = VVRR */ +# define COMPILER_VERSION_MAJOR DEC(__WATCOMC__ / 100) +# define COMPILER_VERSION_MINOR DEC((__WATCOMC__ / 10) % 10) +# if (__WATCOMC__ % 10) > 0 +# define COMPILER_VERSION_PATCH DEC(__WATCOMC__ % 10) +# endif + +#elif defined(__WATCOMC__) +# define COMPILER_ID "OpenWatcom" + /* __WATCOMC__ = VVRP + 1100 */ +# define COMPILER_VERSION_MAJOR DEC((__WATCOMC__ - 1100) / 100) +# define COMPILER_VERSION_MINOR DEC((__WATCOMC__ / 10) % 10) +# if (__WATCOMC__ % 10) > 0 +# define COMPILER_VERSION_PATCH DEC(__WATCOMC__ % 10) +# endif + +#elif defined(__SUNPRO_CC) +# define COMPILER_ID "SunPro" +# if __SUNPRO_CC >= 0x5100 + /* __SUNPRO_CC = 0xVRRP */ +# define COMPILER_VERSION_MAJOR HEX(__SUNPRO_CC>>12) +# define COMPILER_VERSION_MINOR HEX(__SUNPRO_CC>>4 & 0xFF) +# define COMPILER_VERSION_PATCH HEX(__SUNPRO_CC & 0xF) +# else + /* __SUNPRO_CC = 0xVRP */ +# define COMPILER_VERSION_MAJOR HEX(__SUNPRO_CC>>8) +# define COMPILER_VERSION_MINOR HEX(__SUNPRO_CC>>4 & 0xF) +# define COMPILER_VERSION_PATCH HEX(__SUNPRO_CC & 0xF) +# endif + +#elif defined(__HP_aCC) +# define COMPILER_ID "HP" + /* __HP_aCC = VVRRPP */ +# define COMPILER_VERSION_MAJOR DEC(__HP_aCC/10000) +# define COMPILER_VERSION_MINOR DEC(__HP_aCC/100 % 100) +# define COMPILER_VERSION_PATCH DEC(__HP_aCC % 100) + +#elif defined(__DECCXX) +# define COMPILER_ID "Compaq" + /* __DECCXX_VER = VVRRTPPPP */ +# define COMPILER_VERSION_MAJOR DEC(__DECCXX_VER/10000000) +# define COMPILER_VERSION_MINOR DEC(__DECCXX_VER/100000 % 100) +# define COMPILER_VERSION_PATCH DEC(__DECCXX_VER % 10000) + +#elif defined(__IBMCPP__) && defined(__COMPILER_VER__) +# define COMPILER_ID "zOS" + /* __IBMCPP__ = VRP */ +# define COMPILER_VERSION_MAJOR DEC(__IBMCPP__/100) +# define COMPILER_VERSION_MINOR DEC(__IBMCPP__/10 % 10) +# define COMPILER_VERSION_PATCH DEC(__IBMCPP__ % 10) + +#elif defined(__IBMCPP__) && !defined(__COMPILER_VER__) && __IBMCPP__ >= 800 +# define COMPILER_ID "XL" + /* __IBMCPP__ = VRP */ +# define COMPILER_VERSION_MAJOR DEC(__IBMCPP__/100) +# define COMPILER_VERSION_MINOR DEC(__IBMCPP__/10 % 10) +# define COMPILER_VERSION_PATCH DEC(__IBMCPP__ % 10) + +#elif defined(__IBMCPP__) && !defined(__COMPILER_VER__) && __IBMCPP__ < 800 +# define COMPILER_ID "VisualAge" + /* __IBMCPP__ = VRP */ +# define COMPILER_VERSION_MAJOR DEC(__IBMCPP__/100) +# define COMPILER_VERSION_MINOR DEC(__IBMCPP__/10 % 10) +# define COMPILER_VERSION_PATCH DEC(__IBMCPP__ % 10) + +#elif defined(__PGI) +# define COMPILER_ID "PGI" +# define COMPILER_VERSION_MAJOR DEC(__PGIC__) +# define COMPILER_VERSION_MINOR DEC(__PGIC_MINOR__) +# if defined(__PGIC_PATCHLEVEL__) +# define COMPILER_VERSION_PATCH DEC(__PGIC_PATCHLEVEL__) +# endif + +#elif defined(_CRAYC) +# define COMPILER_ID "Cray" +# define COMPILER_VERSION_MAJOR DEC(_RELEASE_MAJOR) +# define COMPILER_VERSION_MINOR DEC(_RELEASE_MINOR) + +#elif defined(__TI_COMPILER_VERSION__) +# define COMPILER_ID "TI" + /* __TI_COMPILER_VERSION__ = VVVRRRPPP */ +# define COMPILER_VERSION_MAJOR DEC(__TI_COMPILER_VERSION__/1000000) +# define COMPILER_VERSION_MINOR DEC(__TI_COMPILER_VERSION__/1000 % 1000) +# define COMPILER_VERSION_PATCH DEC(__TI_COMPILER_VERSION__ % 1000) + +#elif defined(__FUJITSU) || defined(__FCC_VERSION) || defined(__fcc_version) +# define COMPILER_ID "Fujitsu" + +#elif defined(__SCO_VERSION__) +# define COMPILER_ID "SCO" + +#elif defined(__clang__) && defined(__apple_build_version__) +# define COMPILER_ID "AppleClang" +# if defined(_MSC_VER) +# define SIMULATE_ID "MSVC" +# endif +# define COMPILER_VERSION_MAJOR DEC(__clang_major__) +# define COMPILER_VERSION_MINOR DEC(__clang_minor__) +# define COMPILER_VERSION_PATCH DEC(__clang_patchlevel__) +# if defined(_MSC_VER) + /* _MSC_VER = VVRR */ +# define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100) +# define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100) +# endif +# define COMPILER_VERSION_TWEAK DEC(__apple_build_version__) + +#elif defined(__clang__) +# define COMPILER_ID "Clang" +# if defined(_MSC_VER) +# define SIMULATE_ID "MSVC" +# endif +# define COMPILER_VERSION_MAJOR DEC(__clang_major__) +# define COMPILER_VERSION_MINOR DEC(__clang_minor__) +# define COMPILER_VERSION_PATCH DEC(__clang_patchlevel__) +# if defined(_MSC_VER) + /* _MSC_VER = VVRR */ +# define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100) +# define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100) +# endif + +#elif defined(__GNUC__) +# define COMPILER_ID "GNU" +# define COMPILER_VERSION_MAJOR DEC(__GNUC__) +# if defined(__GNUC_MINOR__) +# define COMPILER_VERSION_MINOR DEC(__GNUC_MINOR__) +# endif +# if defined(__GNUC_PATCHLEVEL__) +# define COMPILER_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__) +# endif + +#elif defined(_MSC_VER) +# define COMPILER_ID "MSVC" + /* _MSC_VER = VVRR */ +# define COMPILER_VERSION_MAJOR DEC(_MSC_VER / 100) +# define COMPILER_VERSION_MINOR DEC(_MSC_VER % 100) +# if defined(_MSC_FULL_VER) +# if _MSC_VER >= 1400 + /* _MSC_FULL_VER = VVRRPPPPP */ +# define COMPILER_VERSION_PATCH DEC(_MSC_FULL_VER % 100000) +# else + /* _MSC_FULL_VER = VVRRPPPP */ +# define COMPILER_VERSION_PATCH DEC(_MSC_FULL_VER % 10000) +# endif +# endif +# if defined(_MSC_BUILD) +# define COMPILER_VERSION_TWEAK DEC(_MSC_BUILD) +# endif + +#elif defined(__VISUALDSPVERSION__) || defined(__ADSPBLACKFIN__) || defined(__ADSPTS__) || defined(__ADSP21000__) +# define COMPILER_ID "ADSP" +#if defined(__VISUALDSPVERSION__) + /* __VISUALDSPVERSION__ = 0xVVRRPP00 */ +# define COMPILER_VERSION_MAJOR HEX(__VISUALDSPVERSION__>>24) +# define COMPILER_VERSION_MINOR HEX(__VISUALDSPVERSION__>>16 & 0xFF) +# define COMPILER_VERSION_PATCH HEX(__VISUALDSPVERSION__>>8 & 0xFF) +#endif + +#elif defined(__IAR_SYSTEMS_ICC__ ) || defined(__IAR_SYSTEMS_ICC) +# define COMPILER_ID "IAR" + +#elif defined(__ARMCC_VERSION) +# define COMPILER_ID "ARMCC" +#if __ARMCC_VERSION >= 1000000 + /* __ARMCC_VERSION = VRRPPPP */ + # define COMPILER_VERSION_MAJOR DEC(__ARMCC_VERSION/1000000) + # define COMPILER_VERSION_MINOR DEC(__ARMCC_VERSION/10000 % 100) + # define COMPILER_VERSION_PATCH DEC(__ARMCC_VERSION % 10000) +#else + /* __ARMCC_VERSION = VRPPPP */ + # define COMPILER_VERSION_MAJOR DEC(__ARMCC_VERSION/100000) + # define COMPILER_VERSION_MINOR DEC(__ARMCC_VERSION/10000 % 10) + # define COMPILER_VERSION_PATCH DEC(__ARMCC_VERSION % 10000) +#endif + + +#elif defined(_SGI_COMPILER_VERSION) || defined(_COMPILER_VERSION) +# define COMPILER_ID "MIPSpro" +# if defined(_SGI_COMPILER_VERSION) + /* _SGI_COMPILER_VERSION = VRP */ +# define COMPILER_VERSION_MAJOR DEC(_SGI_COMPILER_VERSION/100) +# define COMPILER_VERSION_MINOR DEC(_SGI_COMPILER_VERSION/10 % 10) +# define COMPILER_VERSION_PATCH DEC(_SGI_COMPILER_VERSION % 10) +# else + /* _COMPILER_VERSION = VRP */ +# define COMPILER_VERSION_MAJOR DEC(_COMPILER_VERSION/100) +# define COMPILER_VERSION_MINOR DEC(_COMPILER_VERSION/10 % 10) +# define COMPILER_VERSION_PATCH DEC(_COMPILER_VERSION % 10) +# endif + + +/* These compilers are either not known or too old to define an + identification macro. Try to identify the platform and guess that + it is the native compiler. */ +#elif defined(__sgi) +# define COMPILER_ID "MIPSpro" + +#elif defined(__hpux) || defined(__hpua) +# define COMPILER_ID "HP" + +#else /* unknown compiler */ +# define COMPILER_ID "" +#endif + +/* Construct the string literal in pieces to prevent the source from + getting matched. Store it in a pointer rather than an array + because some compilers will just produce instructions to fill the + array rather than assigning a pointer to a static array. */ +char const* info_compiler = "INFO" ":" "compiler[" COMPILER_ID "]"; +#ifdef SIMULATE_ID +char const* info_simulate = "INFO" ":" "simulate[" SIMULATE_ID "]"; +#endif + +#ifdef __QNXNTO__ +char const* qnxnto = "INFO" ":" "qnxnto[]"; +#endif + +#if defined(__CRAYXE) || defined(__CRAYXC) +char const *info_cray = "INFO" ":" "compiler_wrapper[CrayPrgEnv]"; +#endif + +#define STRINGIFY_HELPER(X) #X +#define STRINGIFY(X) STRINGIFY_HELPER(X) + +/* Identify known platforms by name. */ +#if defined(__linux) || defined(__linux__) || defined(linux) +# define PLATFORM_ID "Linux" + +#elif defined(__CYGWIN__) +# define PLATFORM_ID "Cygwin" + +#elif defined(__MINGW32__) +# define PLATFORM_ID "MinGW" + +#elif defined(__APPLE__) +# define PLATFORM_ID "Darwin" + +#elif defined(_WIN32) || defined(__WIN32__) || defined(WIN32) +# define PLATFORM_ID "Windows" + +#elif defined(__FreeBSD__) || defined(__FreeBSD) +# define PLATFORM_ID "FreeBSD" + +#elif defined(__NetBSD__) || defined(__NetBSD) +# define PLATFORM_ID "NetBSD" + +#elif defined(__OpenBSD__) || defined(__OPENBSD) +# define PLATFORM_ID "OpenBSD" + +#elif defined(__sun) || defined(sun) +# define PLATFORM_ID "SunOS" + +#elif defined(_AIX) || defined(__AIX) || defined(__AIX__) || defined(__aix) || defined(__aix__) +# define PLATFORM_ID "AIX" + +#elif defined(__sgi) || defined(__sgi__) || defined(_SGI) +# define PLATFORM_ID "IRIX" + +#elif defined(__hpux) || defined(__hpux__) +# define PLATFORM_ID "HP-UX" + +#elif defined(__HAIKU__) +# define PLATFORM_ID "Haiku" + +#elif defined(__BeOS) || defined(__BEOS__) || defined(_BEOS) +# define PLATFORM_ID "BeOS" + +#elif defined(__QNX__) || defined(__QNXNTO__) +# define PLATFORM_ID "QNX" + +#elif defined(__tru64) || defined(_tru64) || defined(__TRU64__) +# define PLATFORM_ID "Tru64" + +#elif defined(__riscos) || defined(__riscos__) +# define PLATFORM_ID "RISCos" + +#elif defined(__sinix) || defined(__sinix__) || defined(__SINIX__) +# define PLATFORM_ID "SINIX" + +#elif defined(__UNIX_SV__) +# define PLATFORM_ID "UNIX_SV" + +#elif defined(__bsdos__) +# define PLATFORM_ID "BSDOS" + +#elif defined(_MPRAS) || defined(MPRAS) +# define PLATFORM_ID "MP-RAS" + +#elif defined(__osf) || defined(__osf__) +# define PLATFORM_ID "OSF1" + +#elif defined(_SCO_SV) || defined(SCO_SV) || defined(sco_sv) +# define PLATFORM_ID "SCO_SV" + +#elif defined(__ultrix) || defined(__ultrix__) || defined(_ULTRIX) +# define PLATFORM_ID "ULTRIX" + +#elif defined(__XENIX__) || defined(_XENIX) || defined(XENIX) +# define PLATFORM_ID "Xenix" + +#elif defined(__WATCOMC__) +# if defined(__LINUX__) +# define PLATFORM_ID "Linux" + +# elif defined(__DOS__) +# define PLATFORM_ID "DOS" + +# elif defined(__OS2__) +# define PLATFORM_ID "OS2" + +# elif defined(__WINDOWS__) +# define PLATFORM_ID "Windows3x" + +# else /* unknown platform */ +# define PLATFORM_ID "" +# endif + +#else /* unknown platform */ +# define PLATFORM_ID "" + +#endif + +/* For windows compilers MSVC and Intel we can determine + the architecture of the compiler being used. This is because + the compilers do not have flags that can change the architecture, + but rather depend on which compiler is being used +*/ +#if defined(_WIN32) && defined(_MSC_VER) +# if defined(_M_IA64) +# define ARCHITECTURE_ID "IA64" + +# elif defined(_M_X64) || defined(_M_AMD64) +# define ARCHITECTURE_ID "x64" + +# elif defined(_M_IX86) +# define ARCHITECTURE_ID "X86" + +# elif defined(_M_ARM) +# if _M_ARM == 4 +# define ARCHITECTURE_ID "ARMV4I" +# elif _M_ARM == 5 +# define ARCHITECTURE_ID "ARMV5I" +# else +# define ARCHITECTURE_ID "ARMV" STRINGIFY(_M_ARM) +# endif + +# elif defined(_M_MIPS) +# define ARCHITECTURE_ID "MIPS" + +# elif defined(_M_SH) +# define ARCHITECTURE_ID "SHx" + +# else /* unknown architecture */ +# define ARCHITECTURE_ID "" +# endif + +#elif defined(__WATCOMC__) +# if defined(_M_I86) +# define ARCHITECTURE_ID "I86" + +# elif defined(_M_IX86) +# define ARCHITECTURE_ID "X86" + +# else /* unknown architecture */ +# define ARCHITECTURE_ID "" +# endif + +#else +# define ARCHITECTURE_ID "" +#endif + +/* Convert integer to decimal digit literals. */ +#define DEC(n) \ + ('0' + (((n) / 10000000)%10)), \ + ('0' + (((n) / 1000000)%10)), \ + ('0' + (((n) / 100000)%10)), \ + ('0' + (((n) / 10000)%10)), \ + ('0' + (((n) / 1000)%10)), \ + ('0' + (((n) / 100)%10)), \ + ('0' + (((n) / 10)%10)), \ + ('0' + ((n) % 10)) + +/* Convert integer to hex digit literals. */ +#define HEX(n) \ + ('0' + ((n)>>28 & 0xF)), \ + ('0' + ((n)>>24 & 0xF)), \ + ('0' + ((n)>>20 & 0xF)), \ + ('0' + ((n)>>16 & 0xF)), \ + ('0' + ((n)>>12 & 0xF)), \ + ('0' + ((n)>>8 & 0xF)), \ + ('0' + ((n)>>4 & 0xF)), \ + ('0' + ((n) & 0xF)) + +/* Construct a string literal encoding the version number components. */ +#ifdef COMPILER_VERSION_MAJOR +char const info_version[] = { + 'I', 'N', 'F', 'O', ':', + 'c','o','m','p','i','l','e','r','_','v','e','r','s','i','o','n','[', + COMPILER_VERSION_MAJOR, +# ifdef COMPILER_VERSION_MINOR + '.', COMPILER_VERSION_MINOR, +# ifdef COMPILER_VERSION_PATCH + '.', COMPILER_VERSION_PATCH, +# ifdef COMPILER_VERSION_TWEAK + '.', COMPILER_VERSION_TWEAK, +# endif +# endif +# endif + ']','\0'}; +#endif + +/* Construct a string literal encoding the version number components. */ +#ifdef SIMULATE_VERSION_MAJOR +char const info_simulate_version[] = { + 'I', 'N', 'F', 'O', ':', + 's','i','m','u','l','a','t','e','_','v','e','r','s','i','o','n','[', + SIMULATE_VERSION_MAJOR, +# ifdef SIMULATE_VERSION_MINOR + '.', SIMULATE_VERSION_MINOR, +# ifdef SIMULATE_VERSION_PATCH + '.', SIMULATE_VERSION_PATCH, +# ifdef SIMULATE_VERSION_TWEAK + '.', SIMULATE_VERSION_TWEAK, +# endif +# endif +# endif + ']','\0'}; +#endif + +/* Construct the string literal in pieces to prevent the source from + getting matched. Store it in a pointer rather than an array + because some compilers will just produce instructions to fill the + array rather than assigning a pointer to a static array. */ +char const* info_platform = "INFO" ":" "platform[" PLATFORM_ID "]"; +char const* info_arch = "INFO" ":" "arch[" ARCHITECTURE_ID "]"; + + + + +const char* info_language_dialect_default = "INFO" ":" "dialect_default[" +#if __cplusplus >= 201402L + "14" +#elif __cplusplus >= 201103L + "11" +#else + "98" +#endif +"]"; + +/*--------------------------------------------------------------------------*/ + +int main(int argc, char* argv[]) +{ + int require = 0; + require += info_compiler[argc]; + require += info_platform[argc]; +#ifdef COMPILER_VERSION_MAJOR + require += info_version[argc]; +#endif +#ifdef SIMULATE_ID + require += info_simulate[argc]; +#endif +#ifdef SIMULATE_VERSION_MAJOR + require += info_simulate_version[argc]; +#endif +#if defined(__CRAYXE) || defined(__CRAYXC) + require += info_cray[argc]; +#endif + require += info_language_dialect_default[argc]; + (void)argv; + return require; +} diff --git a/build/CMakeFiles/3.5.1/CompilerIdCXX/a.out b/build/CMakeFiles/3.5.1/CompilerIdCXX/a.out new file mode 100644 index 0000000000000000000000000000000000000000..e52b547670e5014917a116b7273fbb1d63c20394 GIT binary patch literal 8808 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 literal 0 HcmV?d00001 diff --git a/build/CMakeFiles/CMakeDirectoryInformation.cmake b/build/CMakeFiles/CMakeDirectoryInformation.cmake new file mode 100644 index 0000000..c7ace7d --- /dev/null +++ b/build/CMakeFiles/CMakeDirectoryInformation.cmake @@ -0,0 +1,16 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 3.5 + +# Relative path conversion top directories. +set(CMAKE_RELATIVE_PATH_TOP_SOURCE "/root/mymuduo") +set(CMAKE_RELATIVE_PATH_TOP_BINARY "/root/mymuduo/build") + +# Force unix paths in dependencies. +set(CMAKE_FORCE_UNIX_PATHS 1) + + +# The C and CXX include file regular expressions for this directory. +set(CMAKE_C_INCLUDE_REGEX_SCAN "^.*$") +set(CMAKE_C_INCLUDE_REGEX_COMPLAIN "^$") +set(CMAKE_CXX_INCLUDE_REGEX_SCAN ${CMAKE_C_INCLUDE_REGEX_SCAN}) +set(CMAKE_CXX_INCLUDE_REGEX_COMPLAIN ${CMAKE_C_INCLUDE_REGEX_COMPLAIN}) diff --git a/build/CMakeFiles/CMakeOutput.log b/build/CMakeFiles/CMakeOutput.log new file mode 100644 index 0000000..535a285 --- /dev/null +++ b/build/CMakeFiles/CMakeOutput.log @@ -0,0 +1,554 @@ +The system is: Linux - 4.4.0-186-generic - x86_64 +Compiling the C compiler identification source file "CMakeCCompilerId.c" succeeded. +Compiler: /usr/bin/x86_64-linux-gnu-gcc-5 +Build flags: +Id flags: + +The output was: +0 + + +Compilation of the C compiler identification source "CMakeCCompilerId.c" produced "a.out" + +The C compiler identification is GNU, found in "/root/mymuduo/build/CMakeFiles/3.5.1/CompilerIdC/a.out" + +Compiling the CXX compiler identification source file "CMakeCXXCompilerId.cpp" succeeded. +Compiler: /usr/bin/x86_64-linux-gnu-g++-5 +Build flags: +Id flags: + +The output was: +0 + + +Compilation of the CXX compiler identification source "CMakeCXXCompilerId.cpp" produced "a.out" + +The CXX compiler identification is GNU, found in "/root/mymuduo/build/CMakeFiles/3.5.1/CompilerIdCXX/a.out" + +Determining if the C compiler works passed with the following output: +Change Dir: /root/mymuduo/build/CMakeFiles/CMakeTmp + +Run Build Command:"/usr/bin/make" "cmTC_3d395/fast" +/usr/bin/make -f CMakeFiles/cmTC_3d395.dir/build.make CMakeFiles/cmTC_3d395.dir/build +make[1]: Entering directory '/root/mymuduo/build/CMakeFiles/CMakeTmp' +Building C object CMakeFiles/cmTC_3d395.dir/testCCompiler.c.o +/usr/bin/x86_64-linux-gnu-gcc-5 -o CMakeFiles/cmTC_3d395.dir/testCCompiler.c.o -c /root/mymuduo/build/CMakeFiles/CMakeTmp/testCCompiler.c +Linking C executable cmTC_3d395 +/usr/bin/cmake -E cmake_link_script CMakeFiles/cmTC_3d395.dir/link.txt --verbose=1 +/usr/bin/x86_64-linux-gnu-gcc-5 CMakeFiles/cmTC_3d395.dir/testCCompiler.c.o -o cmTC_3d395 -rdynamic +make[1]: Leaving directory '/root/mymuduo/build/CMakeFiles/CMakeTmp' + + +Detecting C compiler ABI info compiled with the following output: +Change Dir: /root/mymuduo/build/CMakeFiles/CMakeTmp + +Run Build Command:"/usr/bin/make" "cmTC_37015/fast" +/usr/bin/make -f CMakeFiles/cmTC_37015.dir/build.make CMakeFiles/cmTC_37015.dir/build +make[1]: Entering directory '/root/mymuduo/build/CMakeFiles/CMakeTmp' +Building C object CMakeFiles/cmTC_37015.dir/CMakeCCompilerABI.c.o +/usr/bin/x86_64-linux-gnu-gcc-5 -o CMakeFiles/cmTC_37015.dir/CMakeCCompilerABI.c.o -c /usr/share/cmake-3.5/Modules/CMakeCCompilerABI.c +Linking C executable cmTC_37015 +/usr/bin/cmake -E cmake_link_script CMakeFiles/cmTC_37015.dir/link.txt --verbose=1 +/usr/bin/x86_64-linux-gnu-gcc-5 -v CMakeFiles/cmTC_37015.dir/CMakeCCompilerABI.c.o -o cmTC_37015 -rdynamic +Using built-in specs. +COLLECT_GCC=/usr/bin/x86_64-linux-gnu-gcc-5 +COLLECT_LTO_WRAPPER=/usr/lib/gcc/x86_64-linux-gnu/5/lto-wrapper +Target: x86_64-linux-gnu +Configured with: ../src/configure -v --with-pkgversion='Ubuntu 5.4.0-6ubuntu1~16.04.12' --with-bugurl=file:///usr/share/doc/gcc-5/README.Bugs --enable-languages=c,ada,c++,java,go,d,fortran,objc,obj-c++ --prefix=/usr --program-suffix=-5 --enable-shared --enable-linker-build-id --libexecdir=/usr/lib --without-included-gettext --enable-threads=posix --libdir=/usr/lib --enable-nls --with-sysroot=/ --enable-clocale=gnu --enable-libstdcxx-debug --enable-libstdcxx-time=yes --with-default-libstdcxx-abi=new --enable-gnu-unique-object --disable-vtable-verify --enable-libmpx --enable-plugin --with-system-zlib --disable-browser-plugin --enable-java-awt=gtk --enable-gtk-cairo --with-java-home=/usr/lib/jvm/java-1.5.0-gcj-5-amd64/jre --enable-java-home --with-jvm-root-dir=/usr/lib/jvm/java-1.5.0-gcj-5-amd64 --with-jvm-jar-dir=/usr/lib/jvm-exports/java-1.5.0-gcj-5-amd64 --with-arch-directory=amd64 --with-ecj-jar=/usr/share/java/eclipse-ecj.jar --enable-objc-gc --enable-multiarch --disable-werror --with-arch-32=i686 --with-abi=m64 --with-multilib-list=m32,m64,mx32 --enable-multilib --with-tune=generic --enable-checking=release --build=x86_64-linux-gnu --host=x86_64-linux-gnu --target=x86_64-linux-gnu +Thread model: posix +gcc version 5.4.0 20160609 (Ubuntu 5.4.0-6ubuntu1~16.04.12) +COMPILER_PATH=/usr/lib/gcc/x86_64-linux-gnu/5/:/usr/lib/gcc/x86_64-linux-gnu/5/:/usr/lib/gcc/x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/5/:/usr/lib/gcc/x86_64-linux-gnu/ +LIBRARY_PATH=/usr/lib/gcc/x86_64-linux-gnu/5/:/usr/lib/gcc/x86_64-linux-gnu/5/../../../x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/5/../../../../lib/:/lib/x86_64-linux-gnu/:/lib/../lib/:/usr/lib/x86_64-linux-gnu/:/usr/lib/../lib/:/usr/lib/gcc/x86_64-linux-gnu/5/../../../:/lib/:/usr/lib/ +COLLECT_GCC_OPTIONS='-v' '-o' 'cmTC_37015' '-rdynamic' '-mtune=generic' '-march=x86-64' + /usr/lib/gcc/x86_64-linux-gnu/5/collect2 -plugin /usr/lib/gcc/x86_64-linux-gnu/5/liblto_plugin.so -plugin-opt=/usr/lib/gcc/x86_64-linux-gnu/5/lto-wrapper -plugin-opt=-fresolution=/tmp/ccMPeWBj.res -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lc -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lgcc_s --sysroot=/ --build-id --eh-frame-hdr -m elf_x86_64 --hash-style=gnu --as-needed -export-dynamic -dynamic-linker /lib64/ld-linux-x86-64.so.2 -z relro -o cmTC_37015 /usr/lib/gcc/x86_64-linux-gnu/5/../../../x86_64-linux-gnu/crt1.o /usr/lib/gcc/x86_64-linux-gnu/5/../../../x86_64-linux-gnu/crti.o /usr/lib/gcc/x86_64-linux-gnu/5/crtbegin.o -L/usr/lib/gcc/x86_64-linux-gnu/5 -L/usr/lib/gcc/x86_64-linux-gnu/5/../../../x86_64-linux-gnu -L/usr/lib/gcc/x86_64-linux-gnu/5/../../../../lib -L/lib/x86_64-linux-gnu -L/lib/../lib -L/usr/lib/x86_64-linux-gnu -L/usr/lib/../lib -L/usr/lib/gcc/x86_64-linux-gnu/5/../../.. CMakeFiles/cmTC_37015.dir/CMakeCCompilerABI.c.o -lgcc --as-needed -lgcc_s --no-as-needed -lc -lgcc --as-needed -lgcc_s --no-as-needed /usr/lib/gcc/x86_64-linux-gnu/5/crtend.o /usr/lib/gcc/x86_64-linux-gnu/5/../../../x86_64-linux-gnu/crtn.o +make[1]: Leaving directory '/root/mymuduo/build/CMakeFiles/CMakeTmp' + + +Parsed C implicit link information from above output: + link line regex: [^( *|.*[/\])(ld|([^/\]+-)?ld|collect2)[^/\]*( |$)] + ignore line: [Change Dir: /root/mymuduo/build/CMakeFiles/CMakeTmp] + ignore line: [] + ignore line: [Run Build Command:"/usr/bin/make" "cmTC_37015/fast"] + ignore line: [/usr/bin/make -f CMakeFiles/cmTC_37015.dir/build.make CMakeFiles/cmTC_37015.dir/build] + ignore line: [make[1]: Entering directory '/root/mymuduo/build/CMakeFiles/CMakeTmp'] + ignore line: [Building C object CMakeFiles/cmTC_37015.dir/CMakeCCompilerABI.c.o] + ignore line: [/usr/bin/x86_64-linux-gnu-gcc-5 -o CMakeFiles/cmTC_37015.dir/CMakeCCompilerABI.c.o -c /usr/share/cmake-3.5/Modules/CMakeCCompilerABI.c] + ignore line: [Linking C executable cmTC_37015] + ignore line: [/usr/bin/cmake -E cmake_link_script CMakeFiles/cmTC_37015.dir/link.txt --verbose=1] + ignore line: [/usr/bin/x86_64-linux-gnu-gcc-5 -v CMakeFiles/cmTC_37015.dir/CMakeCCompilerABI.c.o -o cmTC_37015 -rdynamic ] + ignore line: [Using built-in specs.] + ignore line: [COLLECT_GCC=/usr/bin/x86_64-linux-gnu-gcc-5] + ignore line: [COLLECT_LTO_WRAPPER=/usr/lib/gcc/x86_64-linux-gnu/5/lto-wrapper] + ignore line: [Target: x86_64-linux-gnu] + ignore line: [Configured with: ../src/configure -v --with-pkgversion='Ubuntu 5.4.0-6ubuntu1~16.04.12' --with-bugurl=file:///usr/share/doc/gcc-5/README.Bugs --enable-languages=c,ada,c++,java,go,d,fortran,objc,obj-c++ --prefix=/usr --program-suffix=-5 --enable-shared --enable-linker-build-id --libexecdir=/usr/lib --without-included-gettext --enable-threads=posix --libdir=/usr/lib --enable-nls --with-sysroot=/ --enable-clocale=gnu --enable-libstdcxx-debug --enable-libstdcxx-time=yes --with-default-libstdcxx-abi=new --enable-gnu-unique-object --disable-vtable-verify --enable-libmpx --enable-plugin --with-system-zlib --disable-browser-plugin --enable-java-awt=gtk --enable-gtk-cairo --with-java-home=/usr/lib/jvm/java-1.5.0-gcj-5-amd64/jre --enable-java-home --with-jvm-root-dir=/usr/lib/jvm/java-1.5.0-gcj-5-amd64 --with-jvm-jar-dir=/usr/lib/jvm-exports/java-1.5.0-gcj-5-amd64 --with-arch-directory=amd64 --with-ecj-jar=/usr/share/java/eclipse-ecj.jar --enable-objc-gc --enable-multiarch --disable-werror --with-arch-32=i686 --with-abi=m64 --with-multilib-list=m32,m64,mx32 --enable-multilib --with-tune=generic --enable-checking=release --build=x86_64-linux-gnu --host=x86_64-linux-gnu --target=x86_64-linux-gnu] + ignore line: [Thread model: posix] + ignore line: [gcc version 5.4.0 20160609 (Ubuntu 5.4.0-6ubuntu1~16.04.12) ] + ignore line: [COMPILER_PATH=/usr/lib/gcc/x86_64-linux-gnu/5/:/usr/lib/gcc/x86_64-linux-gnu/5/:/usr/lib/gcc/x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/5/:/usr/lib/gcc/x86_64-linux-gnu/] + ignore line: [LIBRARY_PATH=/usr/lib/gcc/x86_64-linux-gnu/5/:/usr/lib/gcc/x86_64-linux-gnu/5/../../../x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/5/../../../../lib/:/lib/x86_64-linux-gnu/:/lib/../lib/:/usr/lib/x86_64-linux-gnu/:/usr/lib/../lib/:/usr/lib/gcc/x86_64-linux-gnu/5/../../../:/lib/:/usr/lib/] + ignore line: [COLLECT_GCC_OPTIONS='-v' '-o' 'cmTC_37015' '-rdynamic' '-mtune=generic' '-march=x86-64'] + link line: [ /usr/lib/gcc/x86_64-linux-gnu/5/collect2 -plugin /usr/lib/gcc/x86_64-linux-gnu/5/liblto_plugin.so -plugin-opt=/usr/lib/gcc/x86_64-linux-gnu/5/lto-wrapper -plugin-opt=-fresolution=/tmp/ccMPeWBj.res -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lc -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lgcc_s --sysroot=/ --build-id --eh-frame-hdr -m elf_x86_64 --hash-style=gnu --as-needed -export-dynamic -dynamic-linker /lib64/ld-linux-x86-64.so.2 -z relro -o cmTC_37015 /usr/lib/gcc/x86_64-linux-gnu/5/../../../x86_64-linux-gnu/crt1.o /usr/lib/gcc/x86_64-linux-gnu/5/../../../x86_64-linux-gnu/crti.o /usr/lib/gcc/x86_64-linux-gnu/5/crtbegin.o -L/usr/lib/gcc/x86_64-linux-gnu/5 -L/usr/lib/gcc/x86_64-linux-gnu/5/../../../x86_64-linux-gnu -L/usr/lib/gcc/x86_64-linux-gnu/5/../../../../lib -L/lib/x86_64-linux-gnu -L/lib/../lib -L/usr/lib/x86_64-linux-gnu -L/usr/lib/../lib -L/usr/lib/gcc/x86_64-linux-gnu/5/../../.. CMakeFiles/cmTC_37015.dir/CMakeCCompilerABI.c.o -lgcc --as-needed -lgcc_s --no-as-needed -lc -lgcc --as-needed -lgcc_s --no-as-needed /usr/lib/gcc/x86_64-linux-gnu/5/crtend.o /usr/lib/gcc/x86_64-linux-gnu/5/../../../x86_64-linux-gnu/crtn.o] + arg [/usr/lib/gcc/x86_64-linux-gnu/5/collect2] ==> ignore + arg [-plugin] ==> ignore + arg [/usr/lib/gcc/x86_64-linux-gnu/5/liblto_plugin.so] ==> ignore + arg [-plugin-opt=/usr/lib/gcc/x86_64-linux-gnu/5/lto-wrapper] ==> ignore + arg [-plugin-opt=-fresolution=/tmp/ccMPeWBj.res] ==> ignore + arg [-plugin-opt=-pass-through=-lgcc] ==> ignore + arg [-plugin-opt=-pass-through=-lgcc_s] ==> ignore + arg [-plugin-opt=-pass-through=-lc] ==> ignore + arg [-plugin-opt=-pass-through=-lgcc] ==> ignore + arg [-plugin-opt=-pass-through=-lgcc_s] ==> ignore + arg [--sysroot=/] ==> ignore + arg [--build-id] ==> ignore + arg [--eh-frame-hdr] ==> ignore + arg [-m] ==> ignore + arg [elf_x86_64] ==> ignore + arg [--hash-style=gnu] ==> ignore + arg [--as-needed] ==> ignore + arg [-export-dynamic] ==> ignore + arg [-dynamic-linker] ==> ignore + arg [/lib64/ld-linux-x86-64.so.2] ==> ignore + arg [-zrelro] ==> ignore + arg [-o] ==> ignore + arg [cmTC_37015] ==> ignore + arg [/usr/lib/gcc/x86_64-linux-gnu/5/../../../x86_64-linux-gnu/crt1.o] ==> ignore + arg [/usr/lib/gcc/x86_64-linux-gnu/5/../../../x86_64-linux-gnu/crti.o] ==> ignore + arg [/usr/lib/gcc/x86_64-linux-gnu/5/crtbegin.o] ==> ignore + arg [-L/usr/lib/gcc/x86_64-linux-gnu/5] ==> dir [/usr/lib/gcc/x86_64-linux-gnu/5] + arg [-L/usr/lib/gcc/x86_64-linux-gnu/5/../../../x86_64-linux-gnu] ==> dir [/usr/lib/gcc/x86_64-linux-gnu/5/../../../x86_64-linux-gnu] + arg [-L/usr/lib/gcc/x86_64-linux-gnu/5/../../../../lib] ==> dir [/usr/lib/gcc/x86_64-linux-gnu/5/../../../../lib] + arg [-L/lib/x86_64-linux-gnu] ==> dir [/lib/x86_64-linux-gnu] + arg [-L/lib/../lib] ==> dir [/lib/../lib] + arg [-L/usr/lib/x86_64-linux-gnu] ==> dir [/usr/lib/x86_64-linux-gnu] + arg [-L/usr/lib/../lib] ==> dir [/usr/lib/../lib] + arg [-L/usr/lib/gcc/x86_64-linux-gnu/5/../../..] ==> dir [/usr/lib/gcc/x86_64-linux-gnu/5/../../..] + arg [CMakeFiles/cmTC_37015.dir/CMakeCCompilerABI.c.o] ==> ignore + arg [-lgcc] ==> lib [gcc] + arg [--as-needed] ==> ignore + arg [-lgcc_s] ==> lib [gcc_s] + arg [--no-as-needed] ==> ignore + arg [-lc] ==> lib [c] + arg [-lgcc] ==> lib [gcc] + arg [--as-needed] ==> ignore + arg [-lgcc_s] ==> lib [gcc_s] + arg [--no-as-needed] ==> ignore + arg [/usr/lib/gcc/x86_64-linux-gnu/5/crtend.o] ==> ignore + arg [/usr/lib/gcc/x86_64-linux-gnu/5/../../../x86_64-linux-gnu/crtn.o] ==> ignore + remove lib [gcc] + remove lib [gcc_s] + remove lib [gcc] + remove lib [gcc_s] + collapse library dir [/usr/lib/gcc/x86_64-linux-gnu/5] ==> [/usr/lib/gcc/x86_64-linux-gnu/5] + collapse library dir [/usr/lib/gcc/x86_64-linux-gnu/5/../../../x86_64-linux-gnu] ==> [/usr/lib/x86_64-linux-gnu] + collapse library dir [/usr/lib/gcc/x86_64-linux-gnu/5/../../../../lib] ==> [/usr/lib] + collapse library dir [/lib/x86_64-linux-gnu] ==> [/lib/x86_64-linux-gnu] + collapse library dir [/lib/../lib] ==> [/lib] + collapse library dir [/usr/lib/x86_64-linux-gnu] ==> [/usr/lib/x86_64-linux-gnu] + collapse library dir [/usr/lib/../lib] ==> [/usr/lib] + collapse library dir [/usr/lib/gcc/x86_64-linux-gnu/5/../../..] ==> [/usr/lib] + implicit libs: [c] + implicit dirs: [/usr/lib/gcc/x86_64-linux-gnu/5;/usr/lib/x86_64-linux-gnu;/usr/lib;/lib/x86_64-linux-gnu;/lib] + implicit fwks: [] + + + + +Detecting C [-std=c11] compiler features compiled with the following output: +Change Dir: /root/mymuduo/build/CMakeFiles/CMakeTmp + +Run Build Command:"/usr/bin/make" "cmTC_f69d2/fast" +/usr/bin/make -f CMakeFiles/cmTC_f69d2.dir/build.make CMakeFiles/cmTC_f69d2.dir/build +make[1]: Entering directory '/root/mymuduo/build/CMakeFiles/CMakeTmp' +Building C object CMakeFiles/cmTC_f69d2.dir/feature_tests.c.o +/usr/bin/x86_64-linux-gnu-gcc-5 -std=c11 -o CMakeFiles/cmTC_f69d2.dir/feature_tests.c.o -c /root/mymuduo/build/CMakeFiles/feature_tests.c +Linking C executable cmTC_f69d2 +/usr/bin/cmake -E cmake_link_script CMakeFiles/cmTC_f69d2.dir/link.txt --verbose=1 +/usr/bin/x86_64-linux-gnu-gcc-5 CMakeFiles/cmTC_f69d2.dir/feature_tests.c.o -o cmTC_f69d2 -rdynamic +make[1]: Leaving directory '/root/mymuduo/build/CMakeFiles/CMakeTmp' + + + Feature record: C_FEATURE:1c_function_prototypes + Feature record: C_FEATURE:1c_restrict + Feature record: C_FEATURE:1c_static_assert + Feature record: C_FEATURE:1c_variadic_macros + + +Detecting C [-std=c99] compiler features compiled with the following output: +Change Dir: /root/mymuduo/build/CMakeFiles/CMakeTmp + +Run Build Command:"/usr/bin/make" "cmTC_d44fa/fast" +/usr/bin/make -f CMakeFiles/cmTC_d44fa.dir/build.make CMakeFiles/cmTC_d44fa.dir/build +make[1]: Entering directory '/root/mymuduo/build/CMakeFiles/CMakeTmp' +Building C object CMakeFiles/cmTC_d44fa.dir/feature_tests.c.o +/usr/bin/x86_64-linux-gnu-gcc-5 -std=c99 -o CMakeFiles/cmTC_d44fa.dir/feature_tests.c.o -c /root/mymuduo/build/CMakeFiles/feature_tests.c +Linking C executable cmTC_d44fa +/usr/bin/cmake -E cmake_link_script CMakeFiles/cmTC_d44fa.dir/link.txt --verbose=1 +/usr/bin/x86_64-linux-gnu-gcc-5 CMakeFiles/cmTC_d44fa.dir/feature_tests.c.o -o cmTC_d44fa -rdynamic +make[1]: Leaving directory '/root/mymuduo/build/CMakeFiles/CMakeTmp' + + + Feature record: C_FEATURE:1c_function_prototypes + Feature record: C_FEATURE:1c_restrict + Feature record: C_FEATURE:0c_static_assert + Feature record: C_FEATURE:1c_variadic_macros + + +Detecting C [-std=c90] compiler features compiled with the following output: +Change Dir: /root/mymuduo/build/CMakeFiles/CMakeTmp + +Run Build Command:"/usr/bin/make" "cmTC_dcbc3/fast" +/usr/bin/make -f CMakeFiles/cmTC_dcbc3.dir/build.make CMakeFiles/cmTC_dcbc3.dir/build +make[1]: Entering directory '/root/mymuduo/build/CMakeFiles/CMakeTmp' +Building C object CMakeFiles/cmTC_dcbc3.dir/feature_tests.c.o +/usr/bin/x86_64-linux-gnu-gcc-5 -std=c90 -o CMakeFiles/cmTC_dcbc3.dir/feature_tests.c.o -c /root/mymuduo/build/CMakeFiles/feature_tests.c +Linking C executable cmTC_dcbc3 +/usr/bin/cmake -E cmake_link_script CMakeFiles/cmTC_dcbc3.dir/link.txt --verbose=1 +/usr/bin/x86_64-linux-gnu-gcc-5 CMakeFiles/cmTC_dcbc3.dir/feature_tests.c.o -o cmTC_dcbc3 -rdynamic +make[1]: Leaving directory '/root/mymuduo/build/CMakeFiles/CMakeTmp' + + + Feature record: C_FEATURE:1c_function_prototypes + Feature record: C_FEATURE:0c_restrict + Feature record: C_FEATURE:0c_static_assert + Feature record: C_FEATURE:0c_variadic_macros +Determining if the CXX compiler works passed with the following output: +Change Dir: /root/mymuduo/build/CMakeFiles/CMakeTmp + +Run Build Command:"/usr/bin/make" "cmTC_c00b2/fast" +/usr/bin/make -f CMakeFiles/cmTC_c00b2.dir/build.make CMakeFiles/cmTC_c00b2.dir/build +make[1]: Entering directory '/root/mymuduo/build/CMakeFiles/CMakeTmp' +Building CXX object CMakeFiles/cmTC_c00b2.dir/testCXXCompiler.cxx.o +/usr/bin/x86_64-linux-gnu-g++-5 -o CMakeFiles/cmTC_c00b2.dir/testCXXCompiler.cxx.o -c /root/mymuduo/build/CMakeFiles/CMakeTmp/testCXXCompiler.cxx +Linking CXX executable cmTC_c00b2 +/usr/bin/cmake -E cmake_link_script CMakeFiles/cmTC_c00b2.dir/link.txt --verbose=1 +/usr/bin/x86_64-linux-gnu-g++-5 CMakeFiles/cmTC_c00b2.dir/testCXXCompiler.cxx.o -o cmTC_c00b2 -rdynamic +make[1]: Leaving directory '/root/mymuduo/build/CMakeFiles/CMakeTmp' + + +Detecting CXX compiler ABI info compiled with the following output: +Change Dir: /root/mymuduo/build/CMakeFiles/CMakeTmp + +Run Build Command:"/usr/bin/make" "cmTC_b6111/fast" +/usr/bin/make -f CMakeFiles/cmTC_b6111.dir/build.make CMakeFiles/cmTC_b6111.dir/build +make[1]: Entering directory '/root/mymuduo/build/CMakeFiles/CMakeTmp' +Building CXX object CMakeFiles/cmTC_b6111.dir/CMakeCXXCompilerABI.cpp.o +/usr/bin/x86_64-linux-gnu-g++-5 -o CMakeFiles/cmTC_b6111.dir/CMakeCXXCompilerABI.cpp.o -c /usr/share/cmake-3.5/Modules/CMakeCXXCompilerABI.cpp +Linking CXX executable cmTC_b6111 +/usr/bin/cmake -E cmake_link_script CMakeFiles/cmTC_b6111.dir/link.txt --verbose=1 +/usr/bin/x86_64-linux-gnu-g++-5 -v CMakeFiles/cmTC_b6111.dir/CMakeCXXCompilerABI.cpp.o -o cmTC_b6111 -rdynamic +Using built-in specs. +COLLECT_GCC=/usr/bin/x86_64-linux-gnu-g++-5 +COLLECT_LTO_WRAPPER=/usr/lib/gcc/x86_64-linux-gnu/5/lto-wrapper +Target: x86_64-linux-gnu +Configured with: ../src/configure -v --with-pkgversion='Ubuntu 5.4.0-6ubuntu1~16.04.12' --with-bugurl=file:///usr/share/doc/gcc-5/README.Bugs --enable-languages=c,ada,c++,java,go,d,fortran,objc,obj-c++ --prefix=/usr --program-suffix=-5 --enable-shared --enable-linker-build-id --libexecdir=/usr/lib --without-included-gettext --enable-threads=posix --libdir=/usr/lib --enable-nls --with-sysroot=/ --enable-clocale=gnu --enable-libstdcxx-debug --enable-libstdcxx-time=yes --with-default-libstdcxx-abi=new --enable-gnu-unique-object --disable-vtable-verify --enable-libmpx --enable-plugin --with-system-zlib --disable-browser-plugin --enable-java-awt=gtk --enable-gtk-cairo --with-java-home=/usr/lib/jvm/java-1.5.0-gcj-5-amd64/jre --enable-java-home --with-jvm-root-dir=/usr/lib/jvm/java-1.5.0-gcj-5-amd64 --with-jvm-jar-dir=/usr/lib/jvm-exports/java-1.5.0-gcj-5-amd64 --with-arch-directory=amd64 --with-ecj-jar=/usr/share/java/eclipse-ecj.jar --enable-objc-gc --enable-multiarch --disable-werror --with-arch-32=i686 --with-abi=m64 --with-multilib-list=m32,m64,mx32 --enable-multilib --with-tune=generic --enable-checking=release --build=x86_64-linux-gnu --host=x86_64-linux-gnu --target=x86_64-linux-gnu +Thread model: posix +gcc version 5.4.0 20160609 (Ubuntu 5.4.0-6ubuntu1~16.04.12) +COMPILER_PATH=/usr/lib/gcc/x86_64-linux-gnu/5/:/usr/lib/gcc/x86_64-linux-gnu/5/:/usr/lib/gcc/x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/5/:/usr/lib/gcc/x86_64-linux-gnu/ +LIBRARY_PATH=/usr/lib/gcc/x86_64-linux-gnu/5/:/usr/lib/gcc/x86_64-linux-gnu/5/../../../x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/5/../../../../lib/:/lib/x86_64-linux-gnu/:/lib/../lib/:/usr/lib/x86_64-linux-gnu/:/usr/lib/../lib/:/usr/lib/gcc/x86_64-linux-gnu/5/../../../:/lib/:/usr/lib/ +COLLECT_GCC_OPTIONS='-v' '-o' 'cmTC_b6111' '-rdynamic' '-shared-libgcc' '-mtune=generic' '-march=x86-64' + /usr/lib/gcc/x86_64-linux-gnu/5/collect2 -plugin /usr/lib/gcc/x86_64-linux-gnu/5/liblto_plugin.so -plugin-opt=/usr/lib/gcc/x86_64-linux-gnu/5/lto-wrapper -plugin-opt=-fresolution=/tmp/ccXgQTEP.res -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lc -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lgcc --sysroot=/ --build-id --eh-frame-hdr -m elf_x86_64 --hash-style=gnu --as-needed -export-dynamic -dynamic-linker /lib64/ld-linux-x86-64.so.2 -z relro -o cmTC_b6111 /usr/lib/gcc/x86_64-linux-gnu/5/../../../x86_64-linux-gnu/crt1.o /usr/lib/gcc/x86_64-linux-gnu/5/../../../x86_64-linux-gnu/crti.o /usr/lib/gcc/x86_64-linux-gnu/5/crtbegin.o -L/usr/lib/gcc/x86_64-linux-gnu/5 -L/usr/lib/gcc/x86_64-linux-gnu/5/../../../x86_64-linux-gnu -L/usr/lib/gcc/x86_64-linux-gnu/5/../../../../lib -L/lib/x86_64-linux-gnu -L/lib/../lib -L/usr/lib/x86_64-linux-gnu -L/usr/lib/../lib -L/usr/lib/gcc/x86_64-linux-gnu/5/../../.. CMakeFiles/cmTC_b6111.dir/CMakeCXXCompilerABI.cpp.o -lstdc++ -lm -lgcc_s -lgcc -lc -lgcc_s -lgcc /usr/lib/gcc/x86_64-linux-gnu/5/crtend.o /usr/lib/gcc/x86_64-linux-gnu/5/../../../x86_64-linux-gnu/crtn.o +make[1]: Leaving directory '/root/mymuduo/build/CMakeFiles/CMakeTmp' + + +Parsed CXX implicit link information from above output: + link line regex: [^( *|.*[/\])(ld|([^/\]+-)?ld|collect2)[^/\]*( |$)] + ignore line: [Change Dir: /root/mymuduo/build/CMakeFiles/CMakeTmp] + ignore line: [] + ignore line: [Run Build Command:"/usr/bin/make" "cmTC_b6111/fast"] + ignore line: [/usr/bin/make -f CMakeFiles/cmTC_b6111.dir/build.make CMakeFiles/cmTC_b6111.dir/build] + ignore line: [make[1]: Entering directory '/root/mymuduo/build/CMakeFiles/CMakeTmp'] + ignore line: [Building CXX object CMakeFiles/cmTC_b6111.dir/CMakeCXXCompilerABI.cpp.o] + ignore line: [/usr/bin/x86_64-linux-gnu-g++-5 -o CMakeFiles/cmTC_b6111.dir/CMakeCXXCompilerABI.cpp.o -c /usr/share/cmake-3.5/Modules/CMakeCXXCompilerABI.cpp] + ignore line: [Linking CXX executable cmTC_b6111] + ignore line: [/usr/bin/cmake -E cmake_link_script CMakeFiles/cmTC_b6111.dir/link.txt --verbose=1] + ignore line: [/usr/bin/x86_64-linux-gnu-g++-5 -v CMakeFiles/cmTC_b6111.dir/CMakeCXXCompilerABI.cpp.o -o cmTC_b6111 -rdynamic ] + ignore line: [Using built-in specs.] + ignore line: [COLLECT_GCC=/usr/bin/x86_64-linux-gnu-g++-5] + ignore line: [COLLECT_LTO_WRAPPER=/usr/lib/gcc/x86_64-linux-gnu/5/lto-wrapper] + ignore line: [Target: x86_64-linux-gnu] + ignore line: [Configured with: ../src/configure -v --with-pkgversion='Ubuntu 5.4.0-6ubuntu1~16.04.12' --with-bugurl=file:///usr/share/doc/gcc-5/README.Bugs --enable-languages=c,ada,c++,java,go,d,fortran,objc,obj-c++ --prefix=/usr --program-suffix=-5 --enable-shared --enable-linker-build-id --libexecdir=/usr/lib --without-included-gettext --enable-threads=posix --libdir=/usr/lib --enable-nls --with-sysroot=/ --enable-clocale=gnu --enable-libstdcxx-debug --enable-libstdcxx-time=yes --with-default-libstdcxx-abi=new --enable-gnu-unique-object --disable-vtable-verify --enable-libmpx --enable-plugin --with-system-zlib --disable-browser-plugin --enable-java-awt=gtk --enable-gtk-cairo --with-java-home=/usr/lib/jvm/java-1.5.0-gcj-5-amd64/jre --enable-java-home --with-jvm-root-dir=/usr/lib/jvm/java-1.5.0-gcj-5-amd64 --with-jvm-jar-dir=/usr/lib/jvm-exports/java-1.5.0-gcj-5-amd64 --with-arch-directory=amd64 --with-ecj-jar=/usr/share/java/eclipse-ecj.jar --enable-objc-gc --enable-multiarch --disable-werror --with-arch-32=i686 --with-abi=m64 --with-multilib-list=m32,m64,mx32 --enable-multilib --with-tune=generic --enable-checking=release --build=x86_64-linux-gnu --host=x86_64-linux-gnu --target=x86_64-linux-gnu] + ignore line: [Thread model: posix] + ignore line: [gcc version 5.4.0 20160609 (Ubuntu 5.4.0-6ubuntu1~16.04.12) ] + ignore line: [COMPILER_PATH=/usr/lib/gcc/x86_64-linux-gnu/5/:/usr/lib/gcc/x86_64-linux-gnu/5/:/usr/lib/gcc/x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/5/:/usr/lib/gcc/x86_64-linux-gnu/] + ignore line: [LIBRARY_PATH=/usr/lib/gcc/x86_64-linux-gnu/5/:/usr/lib/gcc/x86_64-linux-gnu/5/../../../x86_64-linux-gnu/:/usr/lib/gcc/x86_64-linux-gnu/5/../../../../lib/:/lib/x86_64-linux-gnu/:/lib/../lib/:/usr/lib/x86_64-linux-gnu/:/usr/lib/../lib/:/usr/lib/gcc/x86_64-linux-gnu/5/../../../:/lib/:/usr/lib/] + ignore line: [COLLECT_GCC_OPTIONS='-v' '-o' 'cmTC_b6111' '-rdynamic' '-shared-libgcc' '-mtune=generic' '-march=x86-64'] + link line: [ /usr/lib/gcc/x86_64-linux-gnu/5/collect2 -plugin /usr/lib/gcc/x86_64-linux-gnu/5/liblto_plugin.so -plugin-opt=/usr/lib/gcc/x86_64-linux-gnu/5/lto-wrapper -plugin-opt=-fresolution=/tmp/ccXgQTEP.res -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lc -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lgcc --sysroot=/ --build-id --eh-frame-hdr -m elf_x86_64 --hash-style=gnu --as-needed -export-dynamic -dynamic-linker /lib64/ld-linux-x86-64.so.2 -z relro -o cmTC_b6111 /usr/lib/gcc/x86_64-linux-gnu/5/../../../x86_64-linux-gnu/crt1.o /usr/lib/gcc/x86_64-linux-gnu/5/../../../x86_64-linux-gnu/crti.o /usr/lib/gcc/x86_64-linux-gnu/5/crtbegin.o -L/usr/lib/gcc/x86_64-linux-gnu/5 -L/usr/lib/gcc/x86_64-linux-gnu/5/../../../x86_64-linux-gnu -L/usr/lib/gcc/x86_64-linux-gnu/5/../../../../lib -L/lib/x86_64-linux-gnu -L/lib/../lib -L/usr/lib/x86_64-linux-gnu -L/usr/lib/../lib -L/usr/lib/gcc/x86_64-linux-gnu/5/../../.. CMakeFiles/cmTC_b6111.dir/CMakeCXXCompilerABI.cpp.o -lstdc++ -lm -lgcc_s -lgcc -lc -lgcc_s -lgcc /usr/lib/gcc/x86_64-linux-gnu/5/crtend.o /usr/lib/gcc/x86_64-linux-gnu/5/../../../x86_64-linux-gnu/crtn.o] + arg [/usr/lib/gcc/x86_64-linux-gnu/5/collect2] ==> ignore + arg [-plugin] ==> ignore + arg [/usr/lib/gcc/x86_64-linux-gnu/5/liblto_plugin.so] ==> ignore + arg [-plugin-opt=/usr/lib/gcc/x86_64-linux-gnu/5/lto-wrapper] ==> ignore + arg [-plugin-opt=-fresolution=/tmp/ccXgQTEP.res] ==> ignore + arg [-plugin-opt=-pass-through=-lgcc_s] ==> ignore + arg [-plugin-opt=-pass-through=-lgcc] ==> ignore + arg [-plugin-opt=-pass-through=-lc] ==> ignore + arg [-plugin-opt=-pass-through=-lgcc_s] ==> ignore + arg [-plugin-opt=-pass-through=-lgcc] ==> ignore + arg [--sysroot=/] ==> ignore + arg [--build-id] ==> ignore + arg [--eh-frame-hdr] ==> ignore + arg [-m] ==> ignore + arg [elf_x86_64] ==> ignore + arg [--hash-style=gnu] ==> ignore + arg [--as-needed] ==> ignore + arg [-export-dynamic] ==> ignore + arg [-dynamic-linker] ==> ignore + arg [/lib64/ld-linux-x86-64.so.2] ==> ignore + arg [-zrelro] ==> ignore + arg [-o] ==> ignore + arg [cmTC_b6111] ==> ignore + arg [/usr/lib/gcc/x86_64-linux-gnu/5/../../../x86_64-linux-gnu/crt1.o] ==> ignore + arg [/usr/lib/gcc/x86_64-linux-gnu/5/../../../x86_64-linux-gnu/crti.o] ==> ignore + arg [/usr/lib/gcc/x86_64-linux-gnu/5/crtbegin.o] ==> ignore + arg [-L/usr/lib/gcc/x86_64-linux-gnu/5] ==> dir [/usr/lib/gcc/x86_64-linux-gnu/5] + arg [-L/usr/lib/gcc/x86_64-linux-gnu/5/../../../x86_64-linux-gnu] ==> dir [/usr/lib/gcc/x86_64-linux-gnu/5/../../../x86_64-linux-gnu] + arg [-L/usr/lib/gcc/x86_64-linux-gnu/5/../../../../lib] ==> dir [/usr/lib/gcc/x86_64-linux-gnu/5/../../../../lib] + arg [-L/lib/x86_64-linux-gnu] ==> dir [/lib/x86_64-linux-gnu] + arg [-L/lib/../lib] ==> dir [/lib/../lib] + arg [-L/usr/lib/x86_64-linux-gnu] ==> dir [/usr/lib/x86_64-linux-gnu] + arg [-L/usr/lib/../lib] ==> dir [/usr/lib/../lib] + arg [-L/usr/lib/gcc/x86_64-linux-gnu/5/../../..] ==> dir [/usr/lib/gcc/x86_64-linux-gnu/5/../../..] + arg [CMakeFiles/cmTC_b6111.dir/CMakeCXXCompilerABI.cpp.o] ==> ignore + arg [-lstdc++] ==> lib [stdc++] + arg [-lm] ==> lib [m] + arg [-lgcc_s] ==> lib [gcc_s] + arg [-lgcc] ==> lib [gcc] + arg [-lc] ==> lib [c] + arg [-lgcc_s] ==> lib [gcc_s] + arg [-lgcc] ==> lib [gcc] + arg [/usr/lib/gcc/x86_64-linux-gnu/5/crtend.o] ==> ignore + arg [/usr/lib/gcc/x86_64-linux-gnu/5/../../../x86_64-linux-gnu/crtn.o] ==> ignore + remove lib [gcc_s] + remove lib [gcc] + remove lib [gcc_s] + remove lib [gcc] + collapse library dir [/usr/lib/gcc/x86_64-linux-gnu/5] ==> [/usr/lib/gcc/x86_64-linux-gnu/5] + collapse library dir [/usr/lib/gcc/x86_64-linux-gnu/5/../../../x86_64-linux-gnu] ==> [/usr/lib/x86_64-linux-gnu] + collapse library dir [/usr/lib/gcc/x86_64-linux-gnu/5/../../../../lib] ==> [/usr/lib] + collapse library dir [/lib/x86_64-linux-gnu] ==> [/lib/x86_64-linux-gnu] + collapse library dir [/lib/../lib] ==> [/lib] + collapse library dir [/usr/lib/x86_64-linux-gnu] ==> [/usr/lib/x86_64-linux-gnu] + collapse library dir [/usr/lib/../lib] ==> [/usr/lib] + collapse library dir [/usr/lib/gcc/x86_64-linux-gnu/5/../../..] ==> [/usr/lib] + implicit libs: [stdc++;m;c] + implicit dirs: [/usr/lib/gcc/x86_64-linux-gnu/5;/usr/lib/x86_64-linux-gnu;/usr/lib;/lib/x86_64-linux-gnu;/lib] + implicit fwks: [] + + + + +Detecting CXX [-std=c++14] compiler features compiled with the following output: +Change Dir: /root/mymuduo/build/CMakeFiles/CMakeTmp + +Run Build Command:"/usr/bin/make" "cmTC_3c43a/fast" +/usr/bin/make -f CMakeFiles/cmTC_3c43a.dir/build.make CMakeFiles/cmTC_3c43a.dir/build +make[1]: Entering directory '/root/mymuduo/build/CMakeFiles/CMakeTmp' +Building CXX object CMakeFiles/cmTC_3c43a.dir/feature_tests.cxx.o +/usr/bin/x86_64-linux-gnu-g++-5 -std=c++14 -o CMakeFiles/cmTC_3c43a.dir/feature_tests.cxx.o -c /root/mymuduo/build/CMakeFiles/feature_tests.cxx +Linking CXX executable cmTC_3c43a +/usr/bin/cmake -E cmake_link_script CMakeFiles/cmTC_3c43a.dir/link.txt --verbose=1 +/usr/bin/x86_64-linux-gnu-g++-5 CMakeFiles/cmTC_3c43a.dir/feature_tests.cxx.o -o cmTC_3c43a -rdynamic +make[1]: Leaving directory '/root/mymuduo/build/CMakeFiles/CMakeTmp' + + + Feature record: CXX_FEATURE:1cxx_aggregate_default_initializers + Feature record: CXX_FEATURE:1cxx_alias_templates + Feature record: CXX_FEATURE:1cxx_alignas + Feature record: CXX_FEATURE:1cxx_alignof + Feature record: CXX_FEATURE:1cxx_attributes + Feature record: CXX_FEATURE:1cxx_attribute_deprecated + Feature record: CXX_FEATURE:1cxx_auto_type + Feature record: CXX_FEATURE:1cxx_binary_literals + Feature record: CXX_FEATURE:1cxx_constexpr + Feature record: CXX_FEATURE:1cxx_contextual_conversions + Feature record: CXX_FEATURE:1cxx_decltype + Feature record: CXX_FEATURE:1cxx_decltype_auto + Feature record: CXX_FEATURE:1cxx_decltype_incomplete_return_types + Feature record: CXX_FEATURE:1cxx_default_function_template_args + Feature record: CXX_FEATURE:1cxx_defaulted_functions + Feature record: CXX_FEATURE:1cxx_defaulted_move_initializers + Feature record: CXX_FEATURE:1cxx_delegating_constructors + Feature record: CXX_FEATURE:1cxx_deleted_functions + Feature record: CXX_FEATURE:1cxx_digit_separators + Feature record: CXX_FEATURE:1cxx_enum_forward_declarations + Feature record: CXX_FEATURE:1cxx_explicit_conversions + Feature record: CXX_FEATURE:1cxx_extended_friend_declarations + Feature record: CXX_FEATURE:1cxx_extern_templates + Feature record: CXX_FEATURE:1cxx_final + Feature record: CXX_FEATURE:1cxx_func_identifier + Feature record: CXX_FEATURE:1cxx_generalized_initializers + Feature record: CXX_FEATURE:1cxx_generic_lambdas + Feature record: CXX_FEATURE:1cxx_inheriting_constructors + Feature record: CXX_FEATURE:1cxx_inline_namespaces + Feature record: CXX_FEATURE:1cxx_lambdas + Feature record: CXX_FEATURE:1cxx_lambda_init_captures + Feature record: CXX_FEATURE:1cxx_local_type_template_args + Feature record: CXX_FEATURE:1cxx_long_long_type + Feature record: CXX_FEATURE:1cxx_noexcept + Feature record: CXX_FEATURE:1cxx_nonstatic_member_init + Feature record: CXX_FEATURE:1cxx_nullptr + Feature record: CXX_FEATURE:1cxx_override + Feature record: CXX_FEATURE:1cxx_range_for + Feature record: CXX_FEATURE:1cxx_raw_string_literals + Feature record: CXX_FEATURE:1cxx_reference_qualified_functions + Feature record: CXX_FEATURE:1cxx_relaxed_constexpr + Feature record: CXX_FEATURE:1cxx_return_type_deduction + Feature record: CXX_FEATURE:1cxx_right_angle_brackets + Feature record: CXX_FEATURE:1cxx_rvalue_references + Feature record: CXX_FEATURE:1cxx_sizeof_member + Feature record: CXX_FEATURE:1cxx_static_assert + Feature record: CXX_FEATURE:1cxx_strong_enums + Feature record: CXX_FEATURE:1cxx_template_template_parameters + Feature record: CXX_FEATURE:1cxx_thread_local + Feature record: CXX_FEATURE:1cxx_trailing_return_types + Feature record: CXX_FEATURE:1cxx_unicode_literals + Feature record: CXX_FEATURE:1cxx_uniform_initialization + Feature record: CXX_FEATURE:1cxx_unrestricted_unions + Feature record: CXX_FEATURE:1cxx_user_literals + Feature record: CXX_FEATURE:1cxx_variable_templates + Feature record: CXX_FEATURE:1cxx_variadic_macros + Feature record: CXX_FEATURE:1cxx_variadic_templates + + +Detecting CXX [-std=c++11] compiler features compiled with the following output: +Change Dir: /root/mymuduo/build/CMakeFiles/CMakeTmp + +Run Build Command:"/usr/bin/make" "cmTC_9fa3c/fast" +/usr/bin/make -f CMakeFiles/cmTC_9fa3c.dir/build.make CMakeFiles/cmTC_9fa3c.dir/build +make[1]: Entering directory '/root/mymuduo/build/CMakeFiles/CMakeTmp' +Building CXX object CMakeFiles/cmTC_9fa3c.dir/feature_tests.cxx.o +/usr/bin/x86_64-linux-gnu-g++-5 -std=c++11 -o CMakeFiles/cmTC_9fa3c.dir/feature_tests.cxx.o -c /root/mymuduo/build/CMakeFiles/feature_tests.cxx +Linking CXX executable cmTC_9fa3c +/usr/bin/cmake -E cmake_link_script CMakeFiles/cmTC_9fa3c.dir/link.txt --verbose=1 +/usr/bin/x86_64-linux-gnu-g++-5 CMakeFiles/cmTC_9fa3c.dir/feature_tests.cxx.o -o cmTC_9fa3c -rdynamic +make[1]: Leaving directory '/root/mymuduo/build/CMakeFiles/CMakeTmp' + + + Feature record: CXX_FEATURE:0cxx_aggregate_default_initializers + Feature record: CXX_FEATURE:1cxx_alias_templates + Feature record: CXX_FEATURE:1cxx_alignas + Feature record: CXX_FEATURE:1cxx_alignof + Feature record: CXX_FEATURE:1cxx_attributes + Feature record: CXX_FEATURE:0cxx_attribute_deprecated + Feature record: CXX_FEATURE:1cxx_auto_type + Feature record: CXX_FEATURE:0cxx_binary_literals + Feature record: CXX_FEATURE:1cxx_constexpr + Feature record: CXX_FEATURE:0cxx_contextual_conversions + Feature record: CXX_FEATURE:1cxx_decltype + Feature record: CXX_FEATURE:0cxx_decltype_auto + Feature record: CXX_FEATURE:1cxx_decltype_incomplete_return_types + Feature record: CXX_FEATURE:1cxx_default_function_template_args + Feature record: CXX_FEATURE:1cxx_defaulted_functions + Feature record: CXX_FEATURE:1cxx_defaulted_move_initializers + Feature record: CXX_FEATURE:1cxx_delegating_constructors + Feature record: CXX_FEATURE:1cxx_deleted_functions + Feature record: CXX_FEATURE:0cxx_digit_separators + Feature record: CXX_FEATURE:1cxx_enum_forward_declarations + Feature record: CXX_FEATURE:1cxx_explicit_conversions + Feature record: CXX_FEATURE:1cxx_extended_friend_declarations + Feature record: CXX_FEATURE:1cxx_extern_templates + Feature record: CXX_FEATURE:1cxx_final + Feature record: CXX_FEATURE:1cxx_func_identifier + Feature record: CXX_FEATURE:1cxx_generalized_initializers + Feature record: CXX_FEATURE:0cxx_generic_lambdas + Feature record: CXX_FEATURE:1cxx_inheriting_constructors + Feature record: CXX_FEATURE:1cxx_inline_namespaces + Feature record: CXX_FEATURE:1cxx_lambdas + Feature record: CXX_FEATURE:0cxx_lambda_init_captures + Feature record: CXX_FEATURE:1cxx_local_type_template_args + Feature record: CXX_FEATURE:1cxx_long_long_type + Feature record: CXX_FEATURE:1cxx_noexcept + Feature record: CXX_FEATURE:1cxx_nonstatic_member_init + Feature record: CXX_FEATURE:1cxx_nullptr + Feature record: CXX_FEATURE:1cxx_override + Feature record: CXX_FEATURE:1cxx_range_for + Feature record: CXX_FEATURE:1cxx_raw_string_literals + Feature record: CXX_FEATURE:1cxx_reference_qualified_functions + Feature record: CXX_FEATURE:0cxx_relaxed_constexpr + Feature record: CXX_FEATURE:0cxx_return_type_deduction + Feature record: CXX_FEATURE:1cxx_right_angle_brackets + Feature record: CXX_FEATURE:1cxx_rvalue_references + Feature record: CXX_FEATURE:1cxx_sizeof_member + Feature record: CXX_FEATURE:1cxx_static_assert + Feature record: CXX_FEATURE:1cxx_strong_enums + Feature record: CXX_FEATURE:1cxx_template_template_parameters + Feature record: CXX_FEATURE:1cxx_thread_local + Feature record: CXX_FEATURE:1cxx_trailing_return_types + Feature record: CXX_FEATURE:1cxx_unicode_literals + Feature record: CXX_FEATURE:1cxx_uniform_initialization + Feature record: CXX_FEATURE:1cxx_unrestricted_unions + Feature record: CXX_FEATURE:1cxx_user_literals + Feature record: CXX_FEATURE:0cxx_variable_templates + Feature record: CXX_FEATURE:1cxx_variadic_macros + Feature record: CXX_FEATURE:1cxx_variadic_templates + + +Detecting CXX [-std=c++98] compiler features compiled with the following output: +Change Dir: /root/mymuduo/build/CMakeFiles/CMakeTmp + +Run Build Command:"/usr/bin/make" "cmTC_66416/fast" +/usr/bin/make -f CMakeFiles/cmTC_66416.dir/build.make CMakeFiles/cmTC_66416.dir/build +make[1]: Entering directory '/root/mymuduo/build/CMakeFiles/CMakeTmp' +Building CXX object CMakeFiles/cmTC_66416.dir/feature_tests.cxx.o +/usr/bin/x86_64-linux-gnu-g++-5 -std=c++98 -o CMakeFiles/cmTC_66416.dir/feature_tests.cxx.o -c /root/mymuduo/build/CMakeFiles/feature_tests.cxx +Linking CXX executable cmTC_66416 +/usr/bin/cmake -E cmake_link_script CMakeFiles/cmTC_66416.dir/link.txt --verbose=1 +/usr/bin/x86_64-linux-gnu-g++-5 CMakeFiles/cmTC_66416.dir/feature_tests.cxx.o -o cmTC_66416 -rdynamic +make[1]: Leaving directory '/root/mymuduo/build/CMakeFiles/CMakeTmp' + + + Feature record: CXX_FEATURE:0cxx_aggregate_default_initializers + Feature record: CXX_FEATURE:0cxx_alias_templates + Feature record: CXX_FEATURE:0cxx_alignas + Feature record: CXX_FEATURE:0cxx_alignof + Feature record: CXX_FEATURE:0cxx_attributes + Feature record: CXX_FEATURE:0cxx_attribute_deprecated + Feature record: CXX_FEATURE:0cxx_auto_type + Feature record: CXX_FEATURE:0cxx_binary_literals + Feature record: CXX_FEATURE:0cxx_constexpr + Feature record: CXX_FEATURE:0cxx_contextual_conversions + Feature record: CXX_FEATURE:0cxx_decltype + Feature record: CXX_FEATURE:0cxx_decltype_auto + Feature record: CXX_FEATURE:0cxx_decltype_incomplete_return_types + Feature record: CXX_FEATURE:0cxx_default_function_template_args + Feature record: CXX_FEATURE:0cxx_defaulted_functions + Feature record: CXX_FEATURE:0cxx_defaulted_move_initializers + Feature record: CXX_FEATURE:0cxx_delegating_constructors + Feature record: CXX_FEATURE:0cxx_deleted_functions + Feature record: CXX_FEATURE:0cxx_digit_separators + Feature record: CXX_FEATURE:0cxx_enum_forward_declarations + Feature record: CXX_FEATURE:0cxx_explicit_conversions + Feature record: CXX_FEATURE:0cxx_extended_friend_declarations + Feature record: CXX_FEATURE:0cxx_extern_templates + Feature record: CXX_FEATURE:0cxx_final + Feature record: CXX_FEATURE:0cxx_func_identifier + Feature record: CXX_FEATURE:0cxx_generalized_initializers + Feature record: CXX_FEATURE:0cxx_generic_lambdas + Feature record: CXX_FEATURE:0cxx_inheriting_constructors + Feature record: CXX_FEATURE:0cxx_inline_namespaces + Feature record: CXX_FEATURE:0cxx_lambdas + Feature record: CXX_FEATURE:0cxx_lambda_init_captures + Feature record: CXX_FEATURE:0cxx_local_type_template_args + Feature record: CXX_FEATURE:0cxx_long_long_type + Feature record: CXX_FEATURE:0cxx_noexcept + Feature record: CXX_FEATURE:0cxx_nonstatic_member_init + Feature record: CXX_FEATURE:0cxx_nullptr + Feature record: CXX_FEATURE:0cxx_override + Feature record: CXX_FEATURE:0cxx_range_for + Feature record: CXX_FEATURE:0cxx_raw_string_literals + Feature record: CXX_FEATURE:0cxx_reference_qualified_functions + Feature record: CXX_FEATURE:0cxx_relaxed_constexpr + Feature record: CXX_FEATURE:0cxx_return_type_deduction + Feature record: CXX_FEATURE:0cxx_right_angle_brackets + Feature record: CXX_FEATURE:0cxx_rvalue_references + Feature record: CXX_FEATURE:0cxx_sizeof_member + Feature record: CXX_FEATURE:0cxx_static_assert + Feature record: CXX_FEATURE:0cxx_strong_enums + Feature record: CXX_FEATURE:1cxx_template_template_parameters + Feature record: CXX_FEATURE:0cxx_thread_local + Feature record: CXX_FEATURE:0cxx_trailing_return_types + Feature record: CXX_FEATURE:0cxx_unicode_literals + Feature record: CXX_FEATURE:0cxx_uniform_initialization + Feature record: CXX_FEATURE:0cxx_unrestricted_unions + Feature record: CXX_FEATURE:0cxx_user_literals + Feature record: CXX_FEATURE:0cxx_variable_templates + Feature record: CXX_FEATURE:0cxx_variadic_macros + Feature record: CXX_FEATURE:0cxx_variadic_templates diff --git a/build/CMakeFiles/Makefile.cmake b/build/CMakeFiles/Makefile.cmake new file mode 100644 index 0000000..7aa5457 --- /dev/null +++ b/build/CMakeFiles/Makefile.cmake @@ -0,0 +1,115 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 3.5 + +# The generator used is: +set(CMAKE_DEPENDS_GENERATOR "Unix Makefiles") + +# The top level Makefile was generated from the following files: +set(CMAKE_MAKEFILE_DEPENDS + "CMakeCache.txt" + "../CMakeLists.txt" + "CMakeFiles/3.5.1/CMakeCCompiler.cmake" + "CMakeFiles/3.5.1/CMakeCXXCompiler.cmake" + "CMakeFiles/3.5.1/CMakeSystem.cmake" + "CMakeFiles/feature_tests.c" + "CMakeFiles/feature_tests.cxx" + "/usr/share/cmake-3.5/Modules/CMakeCCompiler.cmake.in" + "/usr/share/cmake-3.5/Modules/CMakeCCompilerABI.c" + "/usr/share/cmake-3.5/Modules/CMakeCInformation.cmake" + "/usr/share/cmake-3.5/Modules/CMakeCXXCompiler.cmake.in" + "/usr/share/cmake-3.5/Modules/CMakeCXXCompilerABI.cpp" + "/usr/share/cmake-3.5/Modules/CMakeCXXInformation.cmake" + "/usr/share/cmake-3.5/Modules/CMakeCommonLanguageInclude.cmake" + "/usr/share/cmake-3.5/Modules/CMakeCompilerIdDetection.cmake" + "/usr/share/cmake-3.5/Modules/CMakeDetermineCCompiler.cmake" + "/usr/share/cmake-3.5/Modules/CMakeDetermineCXXCompiler.cmake" + "/usr/share/cmake-3.5/Modules/CMakeDetermineCompileFeatures.cmake" + "/usr/share/cmake-3.5/Modules/CMakeDetermineCompiler.cmake" + "/usr/share/cmake-3.5/Modules/CMakeDetermineCompilerABI.cmake" + "/usr/share/cmake-3.5/Modules/CMakeDetermineCompilerId.cmake" + "/usr/share/cmake-3.5/Modules/CMakeDetermineSystem.cmake" + "/usr/share/cmake-3.5/Modules/CMakeFindBinUtils.cmake" + "/usr/share/cmake-3.5/Modules/CMakeGenericSystem.cmake" + "/usr/share/cmake-3.5/Modules/CMakeLanguageInformation.cmake" + "/usr/share/cmake-3.5/Modules/CMakeParseArguments.cmake" + "/usr/share/cmake-3.5/Modules/CMakeParseImplicitLinkInfo.cmake" + "/usr/share/cmake-3.5/Modules/CMakeSystem.cmake.in" + "/usr/share/cmake-3.5/Modules/CMakeSystemSpecificInformation.cmake" + "/usr/share/cmake-3.5/Modules/CMakeSystemSpecificInitialize.cmake" + "/usr/share/cmake-3.5/Modules/CMakeTestCCompiler.cmake" + "/usr/share/cmake-3.5/Modules/CMakeTestCXXCompiler.cmake" + "/usr/share/cmake-3.5/Modules/CMakeTestCompilerCommon.cmake" + "/usr/share/cmake-3.5/Modules/CMakeUnixFindMake.cmake" + "/usr/share/cmake-3.5/Modules/Compiler/ADSP-DetermineCompiler.cmake" + "/usr/share/cmake-3.5/Modules/Compiler/ARMCC-DetermineCompiler.cmake" + "/usr/share/cmake-3.5/Modules/Compiler/AppleClang-DetermineCompiler.cmake" + "/usr/share/cmake-3.5/Modules/Compiler/Borland-DetermineCompiler.cmake" + "/usr/share/cmake-3.5/Modules/Compiler/Clang-DetermineCompiler.cmake" + "/usr/share/cmake-3.5/Modules/Compiler/Clang-DetermineCompilerInternal.cmake" + "/usr/share/cmake-3.5/Modules/Compiler/Comeau-CXX-DetermineCompiler.cmake" + "/usr/share/cmake-3.5/Modules/Compiler/Compaq-C-DetermineCompiler.cmake" + "/usr/share/cmake-3.5/Modules/Compiler/Compaq-CXX-DetermineCompiler.cmake" + "/usr/share/cmake-3.5/Modules/Compiler/Cray-DetermineCompiler.cmake" + "/usr/share/cmake-3.5/Modules/Compiler/Embarcadero-DetermineCompiler.cmake" + "/usr/share/cmake-3.5/Modules/Compiler/Fujitsu-DetermineCompiler.cmake" + "/usr/share/cmake-3.5/Modules/Compiler/GHS-DetermineCompiler.cmake" + "/usr/share/cmake-3.5/Modules/Compiler/GNU-C-FeatureTests.cmake" + "/usr/share/cmake-3.5/Modules/Compiler/GNU-C.cmake" + "/usr/share/cmake-3.5/Modules/Compiler/GNU-CXX-FeatureTests.cmake" + "/usr/share/cmake-3.5/Modules/Compiler/GNU-CXX.cmake" + "/usr/share/cmake-3.5/Modules/Compiler/GNU-DetermineCompiler.cmake" + "/usr/share/cmake-3.5/Modules/Compiler/GNU.cmake" + "/usr/share/cmake-3.5/Modules/Compiler/HP-C-DetermineCompiler.cmake" + "/usr/share/cmake-3.5/Modules/Compiler/HP-CXX-DetermineCompiler.cmake" + "/usr/share/cmake-3.5/Modules/Compiler/IAR-DetermineCompiler.cmake" + "/usr/share/cmake-3.5/Modules/Compiler/IBMCPP-C-DetermineVersionInternal.cmake" + "/usr/share/cmake-3.5/Modules/Compiler/IBMCPP-CXX-DetermineVersionInternal.cmake" + "/usr/share/cmake-3.5/Modules/Compiler/Intel-DetermineCompiler.cmake" + "/usr/share/cmake-3.5/Modules/Compiler/MIPSpro-DetermineCompiler.cmake" + "/usr/share/cmake-3.5/Modules/Compiler/MSVC-DetermineCompiler.cmake" + "/usr/share/cmake-3.5/Modules/Compiler/OpenWatcom-DetermineCompiler.cmake" + "/usr/share/cmake-3.5/Modules/Compiler/PGI-DetermineCompiler.cmake" + "/usr/share/cmake-3.5/Modules/Compiler/PathScale-DetermineCompiler.cmake" + "/usr/share/cmake-3.5/Modules/Compiler/SCO-DetermineCompiler.cmake" + "/usr/share/cmake-3.5/Modules/Compiler/SDCC-C-DetermineCompiler.cmake" + "/usr/share/cmake-3.5/Modules/Compiler/SunPro-C-DetermineCompiler.cmake" + "/usr/share/cmake-3.5/Modules/Compiler/SunPro-CXX-DetermineCompiler.cmake" + "/usr/share/cmake-3.5/Modules/Compiler/TI-DetermineCompiler.cmake" + "/usr/share/cmake-3.5/Modules/Compiler/TinyCC-C-DetermineCompiler.cmake" + "/usr/share/cmake-3.5/Modules/Compiler/VisualAge-C-DetermineCompiler.cmake" + "/usr/share/cmake-3.5/Modules/Compiler/VisualAge-CXX-DetermineCompiler.cmake" + "/usr/share/cmake-3.5/Modules/Compiler/Watcom-DetermineCompiler.cmake" + "/usr/share/cmake-3.5/Modules/Compiler/XL-C-DetermineCompiler.cmake" + "/usr/share/cmake-3.5/Modules/Compiler/XL-CXX-DetermineCompiler.cmake" + "/usr/share/cmake-3.5/Modules/Compiler/zOS-C-DetermineCompiler.cmake" + "/usr/share/cmake-3.5/Modules/Compiler/zOS-CXX-DetermineCompiler.cmake" + "/usr/share/cmake-3.5/Modules/Internal/FeatureTesting.cmake" + "/usr/share/cmake-3.5/Modules/MultiArchCross.cmake" + "/usr/share/cmake-3.5/Modules/Platform/Linux-CXX.cmake" + "/usr/share/cmake-3.5/Modules/Platform/Linux-GNU-C.cmake" + "/usr/share/cmake-3.5/Modules/Platform/Linux-GNU-CXX.cmake" + "/usr/share/cmake-3.5/Modules/Platform/Linux-GNU.cmake" + "/usr/share/cmake-3.5/Modules/Platform/Linux.cmake" + "/usr/share/cmake-3.5/Modules/Platform/UnixPaths.cmake" + ) + +# The corresponding makefile is: +set(CMAKE_MAKEFILE_OUTPUTS + "Makefile" + "CMakeFiles/cmake.check_cache" + ) + +# Byproducts of CMake generate step: +set(CMAKE_MAKEFILE_PRODUCTS + "CMakeFiles/3.5.1/CMakeSystem.cmake" + "CMakeFiles/3.5.1/CMakeCCompiler.cmake" + "CMakeFiles/3.5.1/CMakeCXXCompiler.cmake" + "CMakeFiles/3.5.1/CMakeCCompiler.cmake" + "CMakeFiles/3.5.1/CMakeCXXCompiler.cmake" + "CMakeFiles/CMakeDirectoryInformation.cmake" + ) + +# Dependency information for all targets: +set(CMAKE_DEPEND_INFO_FILES + "CMakeFiles/mymuduo.dir/DependInfo.cmake" + ) diff --git a/build/CMakeFiles/Makefile2 b/build/CMakeFiles/Makefile2 new file mode 100644 index 0000000..87ec025 --- /dev/null +++ b/build/CMakeFiles/Makefile2 @@ -0,0 +1,108 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 3.5 + +# Default target executed when no arguments are given to make. +default_target: all + +.PHONY : default_target + +# The main recursive all target +all: + +.PHONY : all + +# The main recursive preinstall target +preinstall: + +.PHONY : preinstall + +#============================================================================= +# Special targets provided by cmake. + +# Disable implicit rules so canonical targets will work. +.SUFFIXES: + + +# Remove some rules from gmake that .SUFFIXES does not remove. +SUFFIXES = + +.SUFFIXES: .hpux_make_needs_suffix_list + + +# Suppress display of executed commands. +$(VERBOSE).SILENT: + + +# A target that is always out of date. +cmake_force: + +.PHONY : cmake_force + +#============================================================================= +# Set environment variables for the build. + +# The shell in which to execute make rules. +SHELL = /bin/sh + +# The CMake executable. +CMAKE_COMMAND = /usr/bin/cmake + +# The command to remove a file. +RM = /usr/bin/cmake -E remove -f + +# Escaping for special characters. +EQUALS = = + +# The top-level source directory on which CMake was run. +CMAKE_SOURCE_DIR = /root/mymuduo + +# The top-level build directory on which CMake was run. +CMAKE_BINARY_DIR = /root/mymuduo/build + +#============================================================================= +# Target rules for target CMakeFiles/mymuduo.dir + +# All Build rule for target. +CMakeFiles/mymuduo.dir/all: + $(MAKE) -f CMakeFiles/mymuduo.dir/build.make CMakeFiles/mymuduo.dir/depend + $(MAKE) -f CMakeFiles/mymuduo.dir/build.make CMakeFiles/mymuduo.dir/build + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --progress-dir=/root/mymuduo/build/CMakeFiles --progress-num=1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18 "Built target mymuduo" +.PHONY : CMakeFiles/mymuduo.dir/all + +# Include target in all. +all: CMakeFiles/mymuduo.dir/all + +.PHONY : all + +# Build rule for subdir invocation for target. +CMakeFiles/mymuduo.dir/rule: cmake_check_build_system + $(CMAKE_COMMAND) -E cmake_progress_start /root/mymuduo/build/CMakeFiles 18 + $(MAKE) -f CMakeFiles/Makefile2 CMakeFiles/mymuduo.dir/all + $(CMAKE_COMMAND) -E cmake_progress_start /root/mymuduo/build/CMakeFiles 0 +.PHONY : CMakeFiles/mymuduo.dir/rule + +# Convenience name for target. +mymuduo: CMakeFiles/mymuduo.dir/rule + +.PHONY : mymuduo + +# clean rule for target. +CMakeFiles/mymuduo.dir/clean: + $(MAKE) -f CMakeFiles/mymuduo.dir/build.make CMakeFiles/mymuduo.dir/clean +.PHONY : CMakeFiles/mymuduo.dir/clean + +# clean rule for target. +clean: CMakeFiles/mymuduo.dir/clean + +.PHONY : clean + +#============================================================================= +# Special targets to cleanup operation of make. + +# Special rule to run CMake to check the build system integrity. +# No rule that depends on this can have commands that come from listfiles +# because they might be regenerated. +cmake_check_build_system: + $(CMAKE_COMMAND) -H$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) --check-build-system CMakeFiles/Makefile.cmake 0 +.PHONY : cmake_check_build_system + diff --git a/build/CMakeFiles/TargetDirectories.txt b/build/CMakeFiles/TargetDirectories.txt new file mode 100644 index 0000000..dcde768 --- /dev/null +++ b/build/CMakeFiles/TargetDirectories.txt @@ -0,0 +1,3 @@ +/root/mymuduo/build/CMakeFiles/edit_cache.dir +/root/mymuduo/build/CMakeFiles/rebuild_cache.dir +/root/mymuduo/build/CMakeFiles/mymuduo.dir diff --git a/build/CMakeFiles/cmake.check_cache b/build/CMakeFiles/cmake.check_cache new file mode 100644 index 0000000..3dccd73 --- /dev/null +++ b/build/CMakeFiles/cmake.check_cache @@ -0,0 +1 @@ +# This file is generated by cmake for dependency checking of the CMakeCache.txt file diff --git a/build/CMakeFiles/feature_tests.bin b/build/CMakeFiles/feature_tests.bin new file mode 100644 index 0000000000000000000000000000000000000000..24939d193bbcef29063a395a70cc6c6ee560c767 GIT binary patch literal 12696 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 literal 0 HcmV?d00001 diff --git a/build/CMakeFiles/feature_tests.c b/build/CMakeFiles/feature_tests.c new file mode 100644 index 0000000..6590dde --- /dev/null +++ b/build/CMakeFiles/feature_tests.c @@ -0,0 +1,34 @@ + + const char features[] = {"\n" +"C_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 404 +"1" +#else +"0" +#endif +"c_function_prototypes\n" +"C_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 404 && defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L +"1" +#else +"0" +#endif +"c_restrict\n" +"C_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 406 && defined(__STDC_VERSION__) && __STDC_VERSION__ >= 201000L +"1" +#else +"0" +#endif +"c_static_assert\n" +"C_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 404 && defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L +"1" +#else +"0" +#endif +"c_variadic_macros\n" + +}; + +int main(int argc, char** argv) { (void)argv; return features[argc]; } diff --git a/build/CMakeFiles/feature_tests.cxx b/build/CMakeFiles/feature_tests.cxx new file mode 100644 index 0000000..b93418c --- /dev/null +++ b/build/CMakeFiles/feature_tests.cxx @@ -0,0 +1,405 @@ + + const char features[] = {"\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 500 && __cplusplus >= 201402L +"1" +#else +"0" +#endif +"cxx_aggregate_default_initializers\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 407 && __cplusplus >= 201103L +"1" +#else +"0" +#endif +"cxx_alias_templates\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 408 && __cplusplus >= 201103L +"1" +#else +"0" +#endif +"cxx_alignas\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 408 && __cplusplus >= 201103L +"1" +#else +"0" +#endif +"cxx_alignof\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 408 && __cplusplus >= 201103L +"1" +#else +"0" +#endif +"cxx_attributes\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 409 && __cplusplus > 201103L +"1" +#else +"0" +#endif +"cxx_attribute_deprecated\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 404 && (__cplusplus >= 201103L || (defined(__GXX_EXPERIMENTAL_CXX0X__) && __GXX_EXPERIMENTAL_CXX0X__)) +"1" +#else +"0" +#endif +"cxx_auto_type\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 409 && __cplusplus > 201103L +"1" +#else +"0" +#endif +"cxx_binary_literals\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 406 && (__cplusplus >= 201103L || (defined(__GXX_EXPERIMENTAL_CXX0X__) && __GXX_EXPERIMENTAL_CXX0X__)) +"1" +#else +"0" +#endif +"cxx_constexpr\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 409 && __cplusplus > 201103L +"1" +#else +"0" +#endif +"cxx_contextual_conversions\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 404 && (__cplusplus >= 201103L || (defined(__GXX_EXPERIMENTAL_CXX0X__) && __GXX_EXPERIMENTAL_CXX0X__)) +"1" +#else +"0" +#endif +"cxx_decltype\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 409 && __cplusplus > 201103L +"1" +#else +"0" +#endif +"cxx_decltype_auto\n" +"CXX_FEATURE:" +#if ((__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) >= 40801) && __cplusplus >= 201103L +"1" +#else +"0" +#endif +"cxx_decltype_incomplete_return_types\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 404 && (__cplusplus >= 201103L || (defined(__GXX_EXPERIMENTAL_CXX0X__) && __GXX_EXPERIMENTAL_CXX0X__)) +"1" +#else +"0" +#endif +"cxx_default_function_template_args\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 404 && (__cplusplus >= 201103L || (defined(__GXX_EXPERIMENTAL_CXX0X__) && __GXX_EXPERIMENTAL_CXX0X__)) +"1" +#else +"0" +#endif +"cxx_defaulted_functions\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 406 && (__cplusplus >= 201103L || (defined(__GXX_EXPERIMENTAL_CXX0X__) && __GXX_EXPERIMENTAL_CXX0X__)) +"1" +#else +"0" +#endif +"cxx_defaulted_move_initializers\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 407 && __cplusplus >= 201103L +"1" +#else +"0" +#endif +"cxx_delegating_constructors\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 404 && (__cplusplus >= 201103L || (defined(__GXX_EXPERIMENTAL_CXX0X__) && __GXX_EXPERIMENTAL_CXX0X__)) +"1" +#else +"0" +#endif +"cxx_deleted_functions\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 409 && __cplusplus > 201103L +"1" +#else +"0" +#endif +"cxx_digit_separators\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 406 && (__cplusplus >= 201103L || (defined(__GXX_EXPERIMENTAL_CXX0X__) && __GXX_EXPERIMENTAL_CXX0X__)) +"1" +#else +"0" +#endif +"cxx_enum_forward_declarations\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 405 && (__cplusplus >= 201103L || (defined(__GXX_EXPERIMENTAL_CXX0X__) && __GXX_EXPERIMENTAL_CXX0X__)) +"1" +#else +"0" +#endif +"cxx_explicit_conversions\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 407 && __cplusplus >= 201103L +"1" +#else +"0" +#endif +"cxx_extended_friend_declarations\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 404 && (__cplusplus >= 201103L || (defined(__GXX_EXPERIMENTAL_CXX0X__) && __GXX_EXPERIMENTAL_CXX0X__)) +"1" +#else +"0" +#endif +"cxx_extern_templates\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 407 && __cplusplus >= 201103L +"1" +#else +"0" +#endif +"cxx_final\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 404 && (__cplusplus >= 201103L || (defined(__GXX_EXPERIMENTAL_CXX0X__) && __GXX_EXPERIMENTAL_CXX0X__)) +"1" +#else +"0" +#endif +"cxx_func_identifier\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 404 && (__cplusplus >= 201103L || (defined(__GXX_EXPERIMENTAL_CXX0X__) && __GXX_EXPERIMENTAL_CXX0X__)) +"1" +#else +"0" +#endif +"cxx_generalized_initializers\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 409 && __cplusplus > 201103L +"1" +#else +"0" +#endif +"cxx_generic_lambdas\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 408 && __cplusplus >= 201103L +"1" +#else +"0" +#endif +"cxx_inheriting_constructors\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 404 && (__cplusplus >= 201103L || (defined(__GXX_EXPERIMENTAL_CXX0X__) && __GXX_EXPERIMENTAL_CXX0X__)) +"1" +#else +"0" +#endif +"cxx_inline_namespaces\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 405 && (__cplusplus >= 201103L || (defined(__GXX_EXPERIMENTAL_CXX0X__) && __GXX_EXPERIMENTAL_CXX0X__)) +"1" +#else +"0" +#endif +"cxx_lambdas\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 409 && __cplusplus > 201103L +"1" +#else +"0" +#endif +"cxx_lambda_init_captures\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 405 && (__cplusplus >= 201103L || (defined(__GXX_EXPERIMENTAL_CXX0X__) && __GXX_EXPERIMENTAL_CXX0X__)) +"1" +#else +"0" +#endif +"cxx_local_type_template_args\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 404 && (__cplusplus >= 201103L || (defined(__GXX_EXPERIMENTAL_CXX0X__) && __GXX_EXPERIMENTAL_CXX0X__)) +"1" +#else +"0" +#endif +"cxx_long_long_type\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 406 && (__cplusplus >= 201103L || (defined(__GXX_EXPERIMENTAL_CXX0X__) && __GXX_EXPERIMENTAL_CXX0X__)) +"1" +#else +"0" +#endif +"cxx_noexcept\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 407 && __cplusplus >= 201103L +"1" +#else +"0" +#endif +"cxx_nonstatic_member_init\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 406 && (__cplusplus >= 201103L || (defined(__GXX_EXPERIMENTAL_CXX0X__) && __GXX_EXPERIMENTAL_CXX0X__)) +"1" +#else +"0" +#endif +"cxx_nullptr\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 407 && __cplusplus >= 201103L +"1" +#else +"0" +#endif +"cxx_override\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 406 && (__cplusplus >= 201103L || (defined(__GXX_EXPERIMENTAL_CXX0X__) && __GXX_EXPERIMENTAL_CXX0X__)) +"1" +#else +"0" +#endif +"cxx_range_for\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 405 && (__cplusplus >= 201103L || (defined(__GXX_EXPERIMENTAL_CXX0X__) && __GXX_EXPERIMENTAL_CXX0X__)) +"1" +#else +"0" +#endif +"cxx_raw_string_literals\n" +"CXX_FEATURE:" +#if ((__GNUC__ * 10000 + __GNUC_MINOR__ * 100 + __GNUC_PATCHLEVEL__) >= 40801) && __cplusplus >= 201103L +"1" +#else +"0" +#endif +"cxx_reference_qualified_functions\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 500 && __cplusplus >= 201402L +"1" +#else +"0" +#endif +"cxx_relaxed_constexpr\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 409 && __cplusplus > 201103L +"1" +#else +"0" +#endif +"cxx_return_type_deduction\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 404 && (__cplusplus >= 201103L || (defined(__GXX_EXPERIMENTAL_CXX0X__) && __GXX_EXPERIMENTAL_CXX0X__)) +"1" +#else +"0" +#endif +"cxx_right_angle_brackets\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 404 && (__cplusplus >= 201103L || (defined(__GXX_EXPERIMENTAL_CXX0X__) && __GXX_EXPERIMENTAL_CXX0X__)) +"1" +#else +"0" +#endif +"cxx_rvalue_references\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 404 && (__cplusplus >= 201103L || (defined(__GXX_EXPERIMENTAL_CXX0X__) && __GXX_EXPERIMENTAL_CXX0X__)) +"1" +#else +"0" +#endif +"cxx_sizeof_member\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 404 && (__cplusplus >= 201103L || (defined(__GXX_EXPERIMENTAL_CXX0X__) && __GXX_EXPERIMENTAL_CXX0X__)) +"1" +#else +"0" +#endif +"cxx_static_assert\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 404 && (__cplusplus >= 201103L || (defined(__GXX_EXPERIMENTAL_CXX0X__) && __GXX_EXPERIMENTAL_CXX0X__)) +"1" +#else +"0" +#endif +"cxx_strong_enums\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 404 && __cplusplus +"1" +#else +"0" +#endif +"cxx_template_template_parameters\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 408 && __cplusplus >= 201103L +"1" +#else +"0" +#endif +"cxx_thread_local\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 404 && (__cplusplus >= 201103L || (defined(__GXX_EXPERIMENTAL_CXX0X__) && __GXX_EXPERIMENTAL_CXX0X__)) +"1" +#else +"0" +#endif +"cxx_trailing_return_types\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 404 && (__cplusplus >= 201103L || (defined(__GXX_EXPERIMENTAL_CXX0X__) && __GXX_EXPERIMENTAL_CXX0X__)) +"1" +#else +"0" +#endif +"cxx_unicode_literals\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 404 && (__cplusplus >= 201103L || (defined(__GXX_EXPERIMENTAL_CXX0X__) && __GXX_EXPERIMENTAL_CXX0X__)) +"1" +#else +"0" +#endif +"cxx_uniform_initialization\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 406 && (__cplusplus >= 201103L || (defined(__GXX_EXPERIMENTAL_CXX0X__) && __GXX_EXPERIMENTAL_CXX0X__)) +"1" +#else +"0" +#endif +"cxx_unrestricted_unions\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 407 && __cplusplus >= 201103L +"1" +#else +"0" +#endif +"cxx_user_literals\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 500 && __cplusplus >= 201402L +"1" +#else +"0" +#endif +"cxx_variable_templates\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 404 && (__cplusplus >= 201103L || (defined(__GXX_EXPERIMENTAL_CXX0X__) && __GXX_EXPERIMENTAL_CXX0X__)) +"1" +#else +"0" +#endif +"cxx_variadic_macros\n" +"CXX_FEATURE:" +#if (__GNUC__ * 100 + __GNUC_MINOR__) >= 404 && (__cplusplus >= 201103L || (defined(__GXX_EXPERIMENTAL_CXX0X__) && __GXX_EXPERIMENTAL_CXX0X__)) +"1" +#else +"0" +#endif +"cxx_variadic_templates\n" + +}; + +int main(int argc, char** argv) { (void)argv; return features[argc]; } diff --git a/build/CMakeFiles/mymuduo.dir/Acceptor.o b/build/CMakeFiles/mymuduo.dir/Acceptor.o new file mode 100644 index 0000000000000000000000000000000000000000..a53869e9029ab2a5e07b08d5648549c41e9b9cc7 GIT binary patch literal 211160 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 VVVEm^+fJ+hySe~dYJJk{{{nZ>!IJ<0 literal 0 HcmV?d00001 diff --git a/build/CMakeFiles/mymuduo.dir/Buffer.o b/build/CMakeFiles/mymuduo.dir/Buffer.o new file mode 100644 index 0000000000000000000000000000000000000000..2c3e1cc6d9fd21d16c414ede314165d670eda501 GIT binary patch literal 160896 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�Vn2Rs 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 literal 0 HcmV?d00001 diff --git a/build/CMakeFiles/mymuduo.dir/CXX.includecache b/build/CMakeFiles/mymuduo.dir/CXX.includecache new file mode 100644 index 0000000..e30d413 --- /dev/null +++ b/build/CMakeFiles/mymuduo.dir/CXX.includecache @@ -0,0 +1,386 @@ +#IncludeRegexLine: ^[ ]*#[ ]*(include|import)[ ]*[<"]([^">]+)([">]) + +#IncludeRegexScan: ^.*$ + +#IncludeRegexComplain: ^$ + +#IncludeRegexTransform: + +/root/mymuduo/Acceptor.cc +sys/types.h +- +sys/socket.h +- +errno.h +- +unistd.h +- +Acceptor.h +/root/mymuduo/Acceptor.h +Logger.h +/root/mymuduo/Logger.h +InetAddress.h +/root/mymuduo/InetAddress.h + +/root/mymuduo/Acceptor.h +functional +- +noncopyable.h +/root/mymuduo/noncopyable.h +Socket.h +/root/mymuduo/Socket.h +Channel.h +/root/mymuduo/Channel.h + +/root/mymuduo/Buffer.cc +errno.h +- +sys/uio.h +- +unistd.h +- +Buffer.h +/root/mymuduo/Buffer.h + +/root/mymuduo/Buffer.h +vector +- +string +- +algorithm +- +stddef.h +- + +/root/mymuduo/Callbacks.h +memory +- +functional +- + +/root/mymuduo/Channel.cc +sys/epoll.h +- +Channel.h +/root/mymuduo/Channel.h +EventLoop.h +/root/mymuduo/EventLoop.h +Logger.h +/root/mymuduo/Logger.h + +/root/mymuduo/Channel.h +functional +- +memory +- +noncopyable.h +/root/mymuduo/noncopyable.h +Timestamp.h +/root/mymuduo/Timestamp.h + +/root/mymuduo/CurrentThread.cc +CurrentThread.h +/root/mymuduo/CurrentThread.h + +/root/mymuduo/CurrentThread.h +unistd.h +- +sys/syscall.h +- + +/root/mymuduo/DefaultPoller.cc +stdlib.h +- +Poller.h +/root/mymuduo/Poller.h +EPollPoller.h +/root/mymuduo/EPollPoller.h + +/root/mymuduo/EPollPoller.cc +errno.h +- +unistd.h +- +string.h +- +EPollPoller.h +/root/mymuduo/EPollPoller.h +Logger.h +/root/mymuduo/Logger.h +Channel.h +/root/mymuduo/Channel.h + +/root/mymuduo/EPollPoller.h +vector +- +sys/epoll.h +- +Poller.h +/root/mymuduo/Poller.h +Timestamp.h +/root/mymuduo/Timestamp.h + +/root/mymuduo/EventLoop.cc +sys/eventfd.h +- +unistd.h +- +fcntl.h +- +errno.h +- +memory +- +EventLoop.h +/root/mymuduo/EventLoop.h +Logger.h +/root/mymuduo/Logger.h +Channel.h +/root/mymuduo/Channel.h +Poller.h +/root/mymuduo/Poller.h + +/root/mymuduo/EventLoop.h +functional +- +vector +- +atomic +- +memory +- +mutex +- +noncopyable.h +/root/mymuduo/noncopyable.h +Timestamp.h +/root/mymuduo/Timestamp.h +CurrentThread.h +/root/mymuduo/CurrentThread.h + +/root/mymuduo/EventLoopThread.cc +EventLoopThread.h +/root/mymuduo/EventLoopThread.h +EventLoop.h +/root/mymuduo/EventLoop.h + +/root/mymuduo/EventLoopThread.h +functional +- +mutex +- +condition_variable +- +string +- +noncopyable.h +/root/mymuduo/noncopyable.h +Thread.h +/root/mymuduo/Thread.h + +/root/mymuduo/EventLoopThreadPool.cc +memory +- +EventLoopThreadPool.h +/root/mymuduo/EventLoopThreadPool.h +EventLoopThread.h +/root/mymuduo/EventLoopThread.h + +/root/mymuduo/EventLoopThreadPool.h +functional +- +string +- +vector +- +memory +- +noncopyable.h +/root/mymuduo/noncopyable.h + +/root/mymuduo/InetAddress.cc +strings.h +- +string.h +- +InetAddress.h +/root/mymuduo/InetAddress.h + +/root/mymuduo/InetAddress.h +arpa/inet.h +- +netinet/in.h +- +string +- + +/root/mymuduo/Logger.cc +iostream +- +Logger.h +/root/mymuduo/Logger.h +Timestamp.h +/root/mymuduo/Timestamp.h + +/root/mymuduo/Logger.h +string +- +noncopyable.h +/root/mymuduo/noncopyable.h + +/root/mymuduo/Poller.cc +Poller.h +/root/mymuduo/Poller.h +Channel.h +/root/mymuduo/Channel.h + +/root/mymuduo/Poller.h +vector +- +unordered_map +- +noncopyable.h +/root/mymuduo/noncopyable.h +Timestamp.h +/root/mymuduo/Timestamp.h + +/root/mymuduo/Socket.cc +unistd.h +- +sys/types.h +- +sys/socket.h +- +string.h +- +netinet/tcp.h +- +Socket.h +/root/mymuduo/Socket.h +Logger.h +/root/mymuduo/Logger.h +InetAddress.h +/root/mymuduo/InetAddress.h + +/root/mymuduo/Socket.h +noncopyable.h +/root/mymuduo/noncopyable.h + +/root/mymuduo/TcpConnection.cc +functional +- +string +- +errno.h +- +sys/types.h +- +sys/socket.h +- +string.h +- +netinet/tcp.h +- +TcpConnection.h +/root/mymuduo/TcpConnection.h +Logger.h +/root/mymuduo/Logger.h +Socket.h +/root/mymuduo/Socket.h +Channel.h +/root/mymuduo/Channel.h +EventLoop.h +/root/mymuduo/EventLoop.h + +/root/mymuduo/TcpConnection.h +memory +- +string +- +atomic +- +noncopyable.h +/root/mymuduo/noncopyable.h +InetAddress.h +/root/mymuduo/InetAddress.h +Callbacks.h +/root/mymuduo/Callbacks.h +Buffer.h +/root/mymuduo/Buffer.h +Timestamp.h +/root/mymuduo/Timestamp.h + +/root/mymuduo/TcpServer.cc +functional +- +string.h +- +TcpServer.h +/root/mymuduo/TcpServer.h +Logger.h +/root/mymuduo/Logger.h +TcpConnection.h +/root/mymuduo/TcpConnection.h + +/root/mymuduo/TcpServer.h +functional +- +string +- +memory +- +atomic +- +unordered_map +- +EventLoop.h +/root/mymuduo/EventLoop.h +Acceptor.h +/root/mymuduo/Acceptor.h +InetAddress.h +/root/mymuduo/InetAddress.h +noncopyable.h +/root/mymuduo/noncopyable.h +EventLoopThreadPool.h +/root/mymuduo/EventLoopThreadPool.h +Callbacks.h +/root/mymuduo/Callbacks.h + +/root/mymuduo/Thread.cc +Thread.h +/root/mymuduo/Thread.h +CurrentThread.h +/root/mymuduo/CurrentThread.h +semaphore.h +- + +/root/mymuduo/Thread.h +functional +- +thread +- +memory +- +unistd.h +- +string +- +atomic +- +noncopyable.h +/root/mymuduo/noncopyable.h + +/root/mymuduo/Timestamp.cc +time.h +- +Timestamp.h +/root/mymuduo/Timestamp.h + +/root/mymuduo/Timestamp.h +iostream +- +string +- + +/root/mymuduo/noncopyable.h + diff --git a/build/CMakeFiles/mymuduo.dir/Channel.o b/build/CMakeFiles/mymuduo.dir/Channel.o new file mode 100644 index 0000000000000000000000000000000000000000..845eaadbcf39eca5d4a8b6aee0cbd1460e59bea3 GIT binary patch literal 235280 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 literal 0 HcmV?d00001 diff --git a/build/CMakeFiles/mymuduo.dir/CurrentThread.o b/build/CMakeFiles/mymuduo.dir/CurrentThread.o new file mode 100644 index 0000000000000000000000000000000000000000..9e8c501f1efb080cb8f69884d939827b4f74eaf8 GIT binary patch literal 14320 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 OJ1ZprC8k0X_5L3hmn$a# literal 0 HcmV?d00001 diff --git a/build/CMakeFiles/mymuduo.dir/DependInfo.cmake b/build/CMakeFiles/mymuduo.dir/DependInfo.cmake new file mode 100644 index 0000000..cbebf67 --- /dev/null +++ b/build/CMakeFiles/mymuduo.dir/DependInfo.cmake @@ -0,0 +1,36 @@ +# The set of languages for which implicit dependencies are needed: +set(CMAKE_DEPENDS_LANGUAGES + "CXX" + ) +# The set of files for implicit dependencies of each language: +set(CMAKE_DEPENDS_CHECK_CXX + "/root/mymuduo/Acceptor.cc" "/root/mymuduo/build/CMakeFiles/mymuduo.dir/Acceptor.o" + "/root/mymuduo/Buffer.cc" "/root/mymuduo/build/CMakeFiles/mymuduo.dir/Buffer.o" + "/root/mymuduo/Channel.cc" "/root/mymuduo/build/CMakeFiles/mymuduo.dir/Channel.o" + "/root/mymuduo/CurrentThread.cc" "/root/mymuduo/build/CMakeFiles/mymuduo.dir/CurrentThread.o" + "/root/mymuduo/DefaultPoller.cc" "/root/mymuduo/build/CMakeFiles/mymuduo.dir/DefaultPoller.o" + "/root/mymuduo/EPollPoller.cc" "/root/mymuduo/build/CMakeFiles/mymuduo.dir/EPollPoller.o" + "/root/mymuduo/EventLoop.cc" "/root/mymuduo/build/CMakeFiles/mymuduo.dir/EventLoop.o" + "/root/mymuduo/EventLoopThread.cc" "/root/mymuduo/build/CMakeFiles/mymuduo.dir/EventLoopThread.o" + "/root/mymuduo/EventLoopThreadPool.cc" "/root/mymuduo/build/CMakeFiles/mymuduo.dir/EventLoopThreadPool.o" + "/root/mymuduo/InetAddress.cc" "/root/mymuduo/build/CMakeFiles/mymuduo.dir/InetAddress.o" + "/root/mymuduo/Logger.cc" "/root/mymuduo/build/CMakeFiles/mymuduo.dir/Logger.o" + "/root/mymuduo/Poller.cc" "/root/mymuduo/build/CMakeFiles/mymuduo.dir/Poller.o" + "/root/mymuduo/Socket.cc" "/root/mymuduo/build/CMakeFiles/mymuduo.dir/Socket.o" + "/root/mymuduo/TcpConnection.cc" "/root/mymuduo/build/CMakeFiles/mymuduo.dir/TcpConnection.o" + "/root/mymuduo/TcpServer.cc" "/root/mymuduo/build/CMakeFiles/mymuduo.dir/TcpServer.o" + "/root/mymuduo/Thread.cc" "/root/mymuduo/build/CMakeFiles/mymuduo.dir/Thread.o" + "/root/mymuduo/Timestamp.cc" "/root/mymuduo/build/CMakeFiles/mymuduo.dir/Timestamp.o" + ) +set(CMAKE_CXX_COMPILER_ID "GNU") + +# The include file search paths: +set(CMAKE_CXX_TARGET_INCLUDE_PATH + ) + +# Targets to which this target links. +set(CMAKE_TARGET_LINKED_INFO_FILES + ) + +# Fortran module output directory. +set(CMAKE_Fortran_TARGET_MODULE_DIR "") diff --git a/build/CMakeFiles/mymuduo.dir/EPollPoller.o b/build/CMakeFiles/mymuduo.dir/EPollPoller.o new file mode 100644 index 0000000000000000000000000000000000000000..0496af24afc9463246f6a3ef7eddec2794eda8a2 GIT binary patch literal 484168 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 Ptxu=cdGf>`S%3czH;!`* literal 0 HcmV?d00001 diff --git a/build/CMakeFiles/mymuduo.dir/EventLoop.o b/build/CMakeFiles/mymuduo.dir/EventLoop.o new file mode 100644 index 0000000000000000000000000000000000000000..423e69e2ca9162f41457ccdbfa913163b4c30225 GIT binary patch literal 524288 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�T2Xl!+j%Z{iY-!3Q36ot89U_w@Mn+DOgKtg=e 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