{
        // Original HoMM 3 bitmap fonts
        // Stored in H3Bitmap.lod with fnt extension
        // Warning: Do not change number of entries in this list
        "bitmap" :
        [
                "BIGFONT",  // 25px, Mostly used for window titles
                "CALLI10R", // 17px, Unused in VCMI
                "CREDITS",  // 31px, Used for credits menu
                "HISCORE",  // 25px, Unused in VCMI
                "MEDFONT",  // 20px, Some titles
                "SMALFONT", // 16px, Most of the messages
                "TIMES08R", // 15px, Used to display amounts on creature card 
                "TINY",     // 11px, Some text
                "VERD10B"   // 16px, Unused in VCMI
        ],
        // Chinese fonts, this list contains mapping to appropriate H3 fonts
        "bitmapHan" :
        {
                "BIGFONT" : { "name" : "hzk24_GBK", "size" : 24 },
                "CALLI10R": { "name" : "hzk10_GBK", "size" : 10 },
                "CREDITS" : { "name" : "hzk24_GBK", "size" : 24 },
                "HISCORE" : { "name" : "hzk12_GBK", "size" : 12 },
                "MEDFONT" : { "name" : "hzk12_GBK", "size" : 12 },
                "SMALFONT": { "name" : "hzk12_GBK", "size" : 12 },
                "TIMES08R": { "name" : "hzk10_GBK", "size" : 10 },
                "TINY"    : { "name" : "hzk10_GBK", "size" : 10 },
                "VERD10B" : { "name" : "hzk10_GBK", "size" : 10 }
        },
        // True type replacements
        // Should be in format:
        // <replaced bitmap font name, case-sensetive> : <true type font description>
        // "file" - file to load font from, must be in data/ directory
        // "size" - point size of font
        // "style" - italic and\or bold, indicates font style
        // "blend" - if set to true, font will be antialiased
        "trueType":
        {
                //"BIGFONT"  : { "file" : "LiberationSerif-Bold.ttf", "size" : 22, "blend" : true},
                //"CALLI10R" : { "file" : "Georgia.ttf",       "size" : 10},
                //"CREDITS"  : { "file" : "LiberationSerif-Bold.ttf", "size" : 28},
                //"HISCORE"  : { "file" : "Georgia.ttf",       "size" : 13},
                //"MEDFONT"  : { "file" : "LiberationSerif-Bold.ttf", "size" : 16}, // breaks messages (from map events)
                //"SMALFONT" : { "file" : "LiberationSerif-Regular.ttf",       "size" : 13, "blend" : true},
                //"TIMES08R" : { "file" : "LiberationSerif-Regular.ttf", "size" :  11, "blend" : true},
                //"TINY"     : { "file" : "LiberationSerif-Regular.ttf",       "size" : 11, "blend" : true},
                //"VERD10B"  : { "file" : "Georgia.ttf",       "size" : 13}
        }
}

#include <iostream>
#include <exception>
using namespace std;
void myprintf(const char*s)
{
	if (s == nullptr) return;
	while (*s)
	{
		if (*s == '%' && *++s != '%' ) //elegant!!!
		{
			throw runtime_error("invalid format: missing argument");
		}
		cout << *s++;
	}
}
template <typename T, typename... Args>
void myprintf(const char*s, T value, Args... args)
{
	while (s && *s)
	{
		if (*s == '%' && *++s != '%')
		{
			cout << value;
			return myprintf(++s, args...);
		}
		cout << *s++;
	}
	throw runtime_error("extra argument is provided to print");
}
int main()
{
	myprintf("first is int %s, second is str %s, third is double %d, fourth is pointer %p", "first string",
			23, 5.66, NULL);
	return 0;
}

class Base
{
protected:
        Base() = default;
        virtual ~Base()  = default;
public:
        Base(const Base& other) = delete;
};
class Derived : public Base
{
public:
        Derived(){cout << __PRETTY_FUNCTION__ << endl;}
        virtual ~Derived(){cout << __PRETTY_FUNCTION__ << endl;}
  //void operator delete(void* ptr){cout << __PRETTY_FUNCTION__ << endl;}//你并不需要重载不过知道重载的形式很有益的 
};
int main()
{
        Base* ptr = new Derived{};
        delete dynamic_cast<Derived*>(ptr);
  //delete ptr;//这里默认调用的是global的delete operator，她只是使用其基本类型Base的destructor，内部再去层层调用子类的  
        return 0;
}

int countThree(int n)
{
        int result=0;
        do
        {
                if (n % 10 == 3)
                {
                        result ++;
                }
                n = n/10;
        }
        while (n > 0);
        return result;
}
int main()
{
        int total = 0;
        for (int i = 1; i <= 707829217; i+= 2)
        {
                total += countThree(i);
                cout <<".";
        }
        cout << endl << total << endl;
        return 0;
}

        for (int i = 2; i <=707829217; i++)
        {
                if (707829217%i == 0)
                {
                        cout << i << " * " << 707829217/i << endl;
                        break;
                }
        }

 # Parse command line options
for x in $(cat /proc/cmdline); do
        case $x in
        init=*)
                init=${x#init=}
                ;;
        root=*)
                ROOT=${x#root=}
                case $ROOT in
                LABEL=*)
                        ROOT="${ROOT#LABEL=}"
                        # support any / in LABEL= path (escape to \x2f)
                        case "${ROOT}" in
                        */*)
                        if command -v sed >/dev/null 2>&1; then
                                ROOT="$(echo ${ROOT} | sed 's,/,\\x2f,g')"
                        else
                                if [ "${ROOT}" != "${ROOT#/}" ]; then
                                        ROOT="\x2f${ROOT#/}"
                                fi
                                if [ "${ROOT}" != "${ROOT%/}" ]; then
                                        ROOT="${ROOT%/}\x2f"
                                fi
                                IFS='/'
                                newroot=
                                for s in $ROOT; do
                                        newroot="${newroot:+${newroot}\\x2f}${s}"
                                done
                                unset IFS
                                ROOT="${newroot}"
                        fi
                        esac
                        ROOT="/dev/disk/by-label/${ROOT}"
                        ;;
                UUID=*)
                        ROOT="/dev/disk/by-uuid/${ROOT#UUID=}"
                        ;;
                /dev/nfs)
                        [ -z "${BOOT}" ] && BOOT=nfs
                        ;;
                esac
                ;;
        rootflags=*)
                ROOTFLAGS="-o ${x#rootflags=}"
                ;;
        rootfstype=*)
                ROOTFSTYPE="${x#rootfstype=}"
                ;;
        rootdelay=*)
                ROOTDELAY="${x#rootdelay=}"
                case ${ROOTDELAY} in
                *[![:digit:].]*)
                        ROOTDELAY=
                        ;;
                esac
                ;;
        resumedelay=*)
                RESUMEDELAY="${x#resumedelay=}"
                ;;
        loop=*)
                LOOP="${x#loop=}"
                ;;
        loopflags=*)
                LOOPFLAGS="-o ${x#loopflags=}"
                ;;
        loopfstype=*)
                LOOPFSTYPE="${x#loopfstype=}"
                ;;
        cryptopts=*)
                cryptopts="${x#cryptopts=}"
                ;;
        nfsroot=*)
                NFSROOT="${x#nfsroot=}"
                ;;
        netboot=*)
                NETBOOT="${x#netboot=}"
                ;;
        ip=*)
                IP="${x#ip=}"
                ;;
        boot=*)
                BOOT=${x#boot=}
                ;;
        ubi.mtd=*)
                UBIMTD=${x#ubi.mtd=}
                ;;
        resume=*)
                RESUME="${x#resume=}"
                ;;
        resume_offset=*)
                resume_offset="${x#resume_offset=}"
                ;;
        noresume)
                noresume=y
                ;;
        panic=*)
                panic="${x#panic=}"
                case ${panic} in
                *[![:digit:].]*)
                        panic=
                        ;;
                esac
                ;;
        quiet)
                quiet=y
                ;;
        ro)
                readonly=y
                ;;
        rw)
                readonly=n
                ;;
        debug)
                debug=y
                quiet=n
                exec >/run/initramfs/initramfs.debug 2>&1
                set -x
                ;;
        debug=*)
                debug=y
                quiet=n
                set -x
                ;;
        break=*)
                break=${x#break=}
                ;;
        break)
                break=premount
                ;;
        blacklist=*)
                blacklist=${x#blacklist=}
                ;;
        netconsole=*)
                netconsole=${x#netconsole=}
                ;;
        BOOTIF=*)
                BOOTIF=${x#BOOTIF=}
                ;;
        hwaddr=*)
                BOOTIF=${x#BOOTIF=}
                ;;
        recovery)
                recovery=y
                ;;
        esac
done

#include <iostream>
#include <exception>
using namespace std;
class ParentEx: exception
{
public:
	string m_name;
	ParentEx()
	{
		m_name = "parent";
	}
};
class ChildEx : public ParentEx
{
public:
	string m_strWhat;
	ChildEx()
	{
		m_name ="child";
	}
};
void addMore(ParentEx& ex)
{
	ex.m_name += "added";
	throw ex;
}
int main()
{
	try
	{
		ChildEx ex;
		addMore(ex);
	}
	catch (ParentEx& parent)
	{
		cout << "parent name:"<< parent.m_name << endl;
	}
	catch (ChildEx& child)
	{
		cout << "child name:" << child.m_name << endl;
	}
	return 0;
}

1. include的头文件是什么
2. 是处于哪一个名字空间
3. 需要链接的动态库是什么
4. 其中的主要类是什么，如何创建，如何显示以便验证
5. 主要的方法是什么，如何应用，其中的算法如何等等

1. 你只需要include <boost/filesystem.hpp>这个是非常的方便因为这个头文件包含了你需要的所有其他头文件，这种门户设计很贴切。
2. 其中的using namespace boost::filesystem;很贴切，只不过其中和std的有些冲突，因此建议不要在using namespace std;了。
3. 其中最基本的类是path，这个可以看作是一个字符串的包裹，可以直接显示字符串，它可以被另外两个最主要的类来使用，一个是file_status这个包裹了文件的各种特性，另一个是directory_entry，后者包含了前者因为directory不过是一种特殊的文件，前者是后者这个类似于container的元素而已，那么主要的操作都是围绕着后者的，比如有一个directory_iterator接受path可以遍历其中的所有文件，iterator的边界采用default constructor，比如

   
           for (directory_iterator it(current_path()); it != directory_iterator(); it ++)
           {
                   std::cout << *it << std::endl;
           }

4. directory_iterator是一个类似平面的iterator，另一个recursive_directory_iterator更加的好用，它基本上是一个深度优先的遍历算法，它有depth和level我还不知道具体是什么，不过猜想是可以控制遍历的深度，同时好像constructor里还可以附带其他选项，因此原本在winapi里一个相当复杂的遍历回调函数编程的模式变成了一个简单的循环。此外还有很多的方便的函数比如判断文件类型的等等。

1. 头文件是boost/regex.hpp，这个包含了需要使用的几乎所有头文件，比如regex_match.hpp，regex_split.hpp等等
2. namespace倒是简单，就是boost，同时你需要动态库boost_regex
3. 这里有一个插曲就是如何编译libboost，比如我要编译静态库regex来debug看看为什么throw exception，那么以下就是一个样板：
   1. ./bootstrap.sh --prefix=<where you want to install libboost> --with-libraries=regex
   2. ./b2 install link=static threading=single variant=debug
4. 具体的使用其实还是有不少的部分的，最简单的是regex_split的使用，你几乎可立刻就明白怎么使用。比如你只是使用默认的delimiter，那么你只需要使用back_inserter来帮助存储你的结果。vector<string> vect; regex_split(back_inserter(vect),str);
5. regex_search似乎也比较好理解，关键是你要定义好你的regex，比如我就是需要寻找一个个字串那么regex ex("\\w+");我们可以实现类似regex_split的功能，这个小技巧就是使用最最重要的result_match，其中如果使用string就是smatch，使用char*就是cmatch，而所谓的result_match就是包装了结果和指针的复杂的类，我目前发现这个result[0]可以直接使用作为full match，而result[0].second实际上是Interator，我们可以用result[0].second operator->()返回当前搜索停止的指针。

   void searchTest()
   {
           const string str = "this is a sentence of many words.";
           regex ex("\\w+");
           smatch what;
           string::const_iterator start = str.begin(), end = str.end();
           while (regex_search(start, end, what, ex))
           {
                   cout << what[0] << endl;
                   cout << "second:" << what[0].second.operator ->() << endl;
                   start = what[0].second;
           }
   }

6. 我似乎始终对于regex_match有误解，比如我碰到了boost抛出的错误：The complexity of matching the regular expression exceeded predefined bounds. Try refactoring the regular expression to make each choice made by the state machine unambiguous. This exception is thrown to prevent "eternal" matches that take an indefinite period time to locate.造成这个错误的是这么个定义regex ex("(\\w+\\s?)+");我的猜想是google中说的挂号内外都有+号就是问题。以下regex ex("((\\w|\\s)+)\\.");虽然也可以match实际上非常的宽泛。

   
   void matchTest()
   {
           const string str = "this is a sentence of many words.";
           //regex ex("((\\w|\\s)+)\\.");
           regex ex("((\\w+\\s?)+)\\.");
           smatch what;
           if (regex_match(str, what, ex))
           {
                   cout << what[0] << endl;
           }
   }

#include <iostream>
#include <boost/bind.hpp>
#include <boost/function.hpp>
using namespace std;
using namespace boost;
void asyncRead(boost::function<void(int, int)> handler)
{
	handler(3, 4);
}
class Client
{
public:
	Client(){;}
	void Start()
	{
		mem_fun(&Client::Foo)(this);
		bind1st(mem_fun(&Client::MyHandler), this)(78);
		boost::function<void (int)> fun1(bind(&Client::MyHandler, this, _1));
		fun1(100);
		bind(&Client::MyHandler, this, 24)();
		bind(&Client::MyHandler, this, _1)(29);
		boost::function<void(int, int)> fun2(bind(&Client::MyHandler2, this, _1, _2));
		asyncRead(fun2);
		asyncRead(bind(&Client::MyHandler2, this, _1, _2));
	}
	void MyHandler(int errCode)
	{
		cout << "errCode:" << errCode << endl;
	}
	void MyHandler2(int err, int number)
	{
		cout << "***err:" << err << endl
				<< "number:" << number << "***"<< endl;
	}
	void Foo()
	{
		cout << "Foo" << endl;
	}
};
int main()
{
	Client client;
	client.Start();
	return 0;
}

Foo
errCode:78
errCode:100
errCode:24
errCode:29
***err:3
number:4***
***err:3
number:4***

#include <iostream>
#include <istream>
#include <ostream>
#include <string>
#include <boost/asio.hpp>
#include <boost/bind.hpp>
using boost::asio::ip::tcp;
class client
{
public:
	client(boost::asio::io_service& io_service, const std::string& host,
			const std::string& port,
			const std::string& path) :
			resolver_(io_service), socket_(io_service)
	{
		// Form the request. We specify the "Connection: close" header so that the
		// server will close the socket after transmitting the response. This will
		// allow us to treat all data up until the EOF as the content.
		std::ostream request_stream(&request_);
		request_stream << "GET " << path << " HTTP/1.0\r\n";
		request_stream << "Host: " << host << "\r\n";
		request_stream << "Accept: */*\r\n";
		request_stream << "Connection: close\r\n\r\n";
		// Start an asynchronous resolve to translate the server and service names
		// into a list of endpoints.
		tcp::resolver::query query(host, port);
		resolver_.async_resolve(query,
				boost::bind(&client::handle_resolve, this,
						boost::asio::placeholders::error,
						boost::asio::placeholders::iterator));
	}
private:
	void handle_resolve(const boost::system::error_code& err,
			tcp::resolver::iterator endpoint_iterator)
	{
		if (!err)
		{
			// Attempt a connection to the first endpoint in the list. Each endpoint
			// will be tried until we successfully establish a connection.
			tcp::endpoint endpoint = *endpoint_iterator;
			socket_.async_connect(endpoint,
					boost::bind(&client::handle_connect, this,
							boost::asio::placeholders::error,
							++endpoint_iterator));
		}
		else
		{
			std::cout << "Error: " << err.message() << "\n";
		}
	}
	void handle_connect(const boost::system::error_code& err,
			tcp::resolver::iterator endpoint_iterator)
	{
		if (!err)
		{
			// The connection was successful. Send the request.
			boost::asio::async_write(socket_, request_,
					boost::bind(&client::handle_write_request, this,
							boost::asio::placeholders::error));
		}
		else if (endpoint_iterator != tcp::resolver::iterator())
		{
			// The connection failed. Try the next endpoint in the list.
			socket_.close();
			tcp::endpoint endpoint = *endpoint_iterator;
			socket_.async_connect(endpoint,
					boost::bind(&client::handle_connect, this,
							boost::asio::placeholders::error,
							++endpoint_iterator));
		}
		else
		{
			std::cout << "Error: " << err.message() << "\n";
		}
	}
	void handle_write_request(const boost::system::error_code& err)
	{
		if (!err)
		{
			// Read the response status line.
			boost::asio::async_read_until(socket_, response_, "\r\n",
					boost::bind(&client::handle_read_status_line, this,
							boost::asio::placeholders::error));
		}
		else
		{
			std::cout << "Error: " << err.message() << "\n";
		}
	}
	void handle_read_status_line(const boost::system::error_code& err)
	{
		if (!err)
		{
			// Check that response is OK.
			std::istream response_stream(&response_);
			std::string http_version;
			response_stream >> http_version;
			unsigned int status_code;
			response_stream >> status_code;
			std::string status_message;
			std::getline(response_stream, status_message);
			if (!response_stream || http_version.substr(0, 5) != "HTTP/")
			{
				std::cout << "Invalid response\n";
				return;
			}
			if (status_code != 200)
			{
				std::cout << "Response returned with status code ";
				std::cout << status_code << "\n";
				return;
			}
			// Read the response headers, which are terminated by a blank line.
			boost::asio::async_read_until(socket_, response_, "\r\n\r\n",
					boost::bind(&client::handle_read_headers, this,
							boost::asio::placeholders::error));
		}
		else
		{
			std::cout << "Error: " << err << "\n";
		}
	}
	void handle_read_headers(const boost::system::error_code& err)
	{
		if (!err)
		{
			// Process the response headers.
			std::istream response_stream(&response_);
			std::string header;
			while (std::getline(response_stream, header) && header != "\r")
				std::cout << header << "\n";
			std::cout << "\n";
			// Write whatever content we already have to output.
			if (response_.size() > 0)
				std::cout << &response_;
			// Start reading remaining data until EOF.
			boost::asio::async_read(socket_, response_,
					boost::asio::transfer_at_least(1),
					boost::bind(&client::handle_read_content, this,
							boost::asio::placeholders::error,
							boost::asio::placeholders::bytes_transferred));
		}
		else
		{
			std::cout << "Error: " << err << "\n";
		}
	}
	void handle_read_content(const boost::system::error_code& err, std::size_t byte_read)
	{
		if (!err)
		{
			// Write all of the data that has been read so far.
			std::cout << &response_;
			// Continue reading remaining data until EOF.
			boost::asio::async_read(socket_, response_,
					boost::asio::transfer_at_least(1),
					boost::bind(&client::handle_read_content, this,
							boost::asio::placeholders::error,
							boost::asio::placeholders::bytes_transferred));
		}
		else if (err != boost::asio::error::eof)
		{
			std::cout << "Error: " << err << "\n";
		}
	}
	tcp::resolver resolver_;
	tcp::socket socket_;
	boost::asio::streambuf request_;
	boost::asio::streambuf response_;
};
int main(int argc, char* argv[])
{
	try
	{
		if (argc != 4)
		{
			std::cout << "Usage: async_client <server> <port> <path>\n";
			std::cout << "Example:\n";
			std::cout << "  async_client www.boost.org 8080 /LICENSE_1_0.txt\n";
			return 1;
		}
		boost::asio::io_service io_service;
		client c(io_service, argv[1], argv[2], argv[3]);
		io_service.run();
	}
	catch (std::exception& e)
	{
		std::cout << "Exception: " << e.what() << "\n";
	}
	return 0;
}

#include <iostream>
#include <boost/filesystem.hpp>
#include <boost/algorithm/string.hpp>
using namespace std;
using namespace boost::filesystem;
using namespace boost::algorithm;
int main(int argc, char** argv)
{
        if (argc != 2)
        {
                cout << "usage: " << argv[0] << " <path>" << endl; 
                return -1;
        }
        path p(argv[1]);
        for (directory_iterator it = directory_iterator(path(argv[1])); it != directory_iterator(); it ++)
        {
                if (is_regular(it->path()))
                {
                        if (it->path().has_extension() && iequals(it->path().extension().string(), ".zip"))
                        {
                                string strCmd = "unzip -o ";
                                strCmd += it->path().string();
                                strCmd += " -d /home/nick/Downloads/game";
                                system(strCmd.c_str());
                        }
                }
        }
        return 0;
}

IPv6 Stateless Address Autoconfiguration

A host performs several steps to autoconfigure its interfaces in IPv6. The autoconfiguration process creates a link-local address. The autoconfiguration process verifies its uniqueness on a link. The process also determines which information should be autoconfigured, addresses, other information, or both. The process determines if the addresses should be obtained through the stateless mechanism, the stateful mechanism, or both mechanisms. This section describes the process for generating a link-local address. This section also describes the process for generating site-local and global addresses by stateless address autoconfiguration. Finally, this section describes the procedure for duplicate address detection.

Stateless Autoconfiguration Requirements

IPv6 defines mechanisms for both stateful address and stateless address autoconfiguration. Stateless autoconfiguration requires no manual configuration of hosts, minimal (if any) configuration of routers, and no additional servers. The stateless mechanism enables a host to generate its own addresses. The stateless mechanism uses local information as well as non-local information that is advertised by routers to generate the addresses. Routers advertise prefixes that identify the subnet or subnets that are associated with a link. Hosts generate an interface identifier that uniquely identifies an interface on a subnet. An address is formed by combining the prefix and the interface identifier. In the absence of routers, a host can generate only link-local addresses. However, link-local addresses are only sufficient for allowing communication among nodes that are attached to the same link.

Stateful Autoconfiguration Model

In the stateful autoconfiguration model, hosts obtain interface addresses or configuration information and parameters from a server. Servers maintain a database that checks which addresses have been assigned to which hosts. The stateful autoconfiguration protocol allows hosts to obtain addresses and other configuration information from a server. Stateless and stateful autoconfiguration complement each other. For example, a host can use stateless autoconfiguration to configure its own addresses, but use stateful autoconfiguration to obtain other information.

When to Use Stateless and Stateful Approaches

The stateless approach is used when a site is not concerned with the exact addresses that hosts use. However, the addresses must be unique. The addresses must also be properly routable. The stateful approach is used when a site requires more precise control over exact address assignments. Stateful and stateless address autoconfiguration can be used simultaneously. The site administrator specifies which type of autoconfiguration to use through the setting of appropriate fields in router advertisement messages.

IPv6 addresses are leased to an interface for a fixed, possibly infinite, length of time. Each address has an associated lifetime that indicates how long the address is bound to an interface. When a lifetime expires, the binding, and address, become invalid and the address can be reassigned to another interface elsewhere. To handle the expiration of address bindings gracefully, an address experiences two distinct phases while the address is assigned to an interface. Initially, an address is preferred, meaning that its use in arbitrary communication is unrestricted. Later, an address becomes deprecated in anticipation that its current interface binding becomes invalid. When the address is in a deprecated state, the use of the address is discouraged, but not strictly forbidden. New communication, for example, the opening of a new TCP connection, should use a preferred address when possible. A deprecated address should be used only by applications that have been using the address. Applications that cannot switch to another address without a service disruption can use a deprecated address.

Duplicate Address Detection Algorithm

To ensure that all configured addresses are likely to be unique on a particular link, nodes run a duplicate address detection algorithm on addresses. The nodes must run the algorithm before assigning the addresses to an interface. The duplicate address detection algorithm is performed on all addresses.

The autoconfiguration process that is specified in this document applies only to hosts and not routers. Because host autoconfiguration uses information that is advertised by routers, routers need to be configured by some other means. However, routers probably generate link-local addresses by using the mechanism that is described in this document. In addition, routers are expected to pass successfully the duplicate address detection procedure on all addresses prior to assigning the address to an interface.

Autoconfiguration Process

This section provides an overview of the typical steps that are performed by an interface during autoconfiguration. Autoconfiguration is performed only on multicast-capable links. Autoconfiguration begins when a multicast-capable interface is enabled, for example, during system startup. Nodes, both hosts and routers, begin the autoconfiguration process by generating a link-local address for the interface. A link-local address is formed by appending the interface's identifier to the well-known link-local prefix.

A node must attempt to verify that a tentative link-local address is not already in use by another node on the link. After verification, the link-local address can be assigned to an interface. Specifically, the node sends a neighbor solicitation message that contains the tentative address as the target. If another node is already using that address, the node returns a neighbor advertisement saying that the node is using that address. If another node is also attempting to use the same address, the node also sends a neighbor solicitation for the target. The number of neighbor solicitation transmissions or retransmissions, and the delay between consecutive solicitations, are link specific. These parameters can be set by system management.

If a node determines that its tentative link-local address is not unique, autoconfiguration stops and manual configuration of the interface is required. To simplify recovery in this instance, an administrator can supply an alternate interface identifier that overrides the default identifier. Then, the autoconfiguration mechanism can be applied by using the new, presumably unique, interface identifier. Alternatively, link-local and other addresses need to be configured manually.

After a node determines that its tentative link-local address is unique, the node assigns the address to the interface. At this point, the node has IP-level connectivity with neighboring nodes. The remaining autoconfiguration steps are performed only by hosts.

Obtaining Router Advertisement

The next phase of autoconfiguration involves obtaining a router advertisement or determining that no routers are present. If routers are present, the routers send router advertisements that specify what type of autoconfiguration a host should perform. If no routers are present, stateful autoconfiguration is invoked.

Routers send router advertisements periodically. However, the delay between successive advertisements is generally longer than a host that performs autoconfiguration can wait. To obtain an advertisement quickly, a host sends one or more router solicitations to the all-routers multicast group. Router advertisements contain two flags that indicate what type of stateful autoconfiguration (if any) should be performed. A managed address configuration flag indicates whether hosts should use stateful autoconfiguration to obtain addresses. An other stateful configuration flag indicates whether hosts should use stateful autoconfiguration to obtain additional information, excluding addresses.

Prefix Information

Router advertisements also contain zero or more prefix information options that contain information that stateless address autoconfiguration uses to generate site-local and global addresses. The stateless address and stateful address autoconfiguration fields in router advertisements are processed independently. A host can use both stateful address and stateless address autoconfiguration simultaneously. One option field that contains prefix information, the autonomous address-configuration flag, indicates whether the option even applies to stateless autoconfiguration. If the option field does apply, additional option fields contain a subnet prefix with lifetime values. These values indicate how long addresses that are created from the prefix remain preferred and valid.

Because routers generate router advertisements periodically, hosts continually receive new advertisements. Hosts process the information that is contained in each advertisement as described previously. Hosts add to the information. Hosts also refresh the information that is received in previous advertisements.

Address Uniqueness

For safety, all addresses must be tested for uniqueness prior to their assignment to an interface. The situation is different for addresses that are created through stateless autoconfiguration. The uniqueness of an address is determined primarily by the portion of the address that is formed from an interface identifier. Thus, if a node has already verified the uniqueness of a link-local address, additional addresses need not be tested individually. The addresses must be created from the same interface identifier. In contrast, all addresses that are obtained manually should be tested individually for uniqueness. The same is true for addresses that are obtained by stateful address autoconfiguration. Some sites believe that the overhead of performing duplicate address detection outweighs its benefits. For these sites, the use of duplicate address detection can be disabled by setting a per-interface configuration flag.

To accelerate the autoconfiguration process, a host can generate its link-local address, and verify its uniqueness, while the host waits for a router advertisement. A router might delay a response to a router solicitation for a few seconds. Consequently, the total time necessary to complete autoconfiguration can be significantly longer if the two steps are done serially.

• MTV: Do you wanna date my avatar?

• MTV: game on!v

• MTV: I don't wanna in the school

1. 始计篇

   孙子曰：兵者，国之大事，死生之地，存亡之道，不可不察也。 　　

   故经之以五事，校之以计，而索其情：一曰道，二曰天，三曰地，四曰将、五曰法。道者，令民与上同意也，故可以与之死，可以与之生，而不畏危。天者，阴阳，寒暑、时制也。地者，远近、险易、广狭、死生也。将者，智、信、仁、勇、严也。法者，曲制、官道、主用也。凡此五者，将莫不闻，知之者胜，不知者不胜。故校之以计，而索其情，曰：主孰有道？将孰有能？天地孰得？法令孰行？兵众孰强？士卒孰练？赏罚孰明？吾以此知胜负矣。 　　

   将听吾计，用之必胜，留之；将不听吾计，用之必败，去之。计利以听，乃为之势，以佐其外。势者，因利而制权也。 　　

   兵者，诡道也。故能而示之不能，用而示之不用，近而示之远，远而示之近；利而诱之，乱而取之，实而备之，强而避之，怒而挠之，卑而骄之，佚而劳之，亲而离之。攻其无备，出其不意。此兵家之胜，不可先传也。 　　

   夫未战而庙算胜者，得算多也；未战而庙算不胜者，得算少也。多算胜，少算不胜，而况于无算乎？吾以此观之，胜负见矣。

2. 作战篇

   孙子曰：凡用兵之法，驰车千驷，革车千乘，带甲十万，千里馈粮，则内外之费，宾客之用，胶漆之材，车甲之奉，日费千金，然后十万之师举矣。 　　

   其用战也胜，久则钝兵挫锐，攻城则力屈，久暴师则国用不足。夫钝兵挫锐，屈力殚货，则诸侯乘其弊而起，虽有智者，不能善其后矣。故兵闻拙速，未睹巧之久也。夫兵久而国利者，未之有也。故不尽知用兵之害者，则不能尽知用兵之利也。 　　

   善用兵者，役不再籍，粮不三载；取用于国，因粮于敌，故军食可足也。国之贫于师者远输，远输则百姓贫。近于师者贵卖，贵卖则百姓财竭，财竭则急于丘役。力屈、财殚，中原内虚于家。百姓之费，十去其七；公家之费，破车罢马，甲胄矢弩。戟楯蔽橹，丘牛大车，十去其六。 　　

   故智将务食于敌。食敌一钟，当吾二十钟；芑秆一石，当吾二十石。 　　

   故杀敌者，怒也；取敌之利者，货也。故车战，得车十乘已上，赏其先得者，而更其旌旗，车杂而乘之，卒善而养之，是谓胜敌而益强。 　　

   故兵贵胜，不贵久。故知兵之将，生民之司命，国家安危之主也。

3. 谋攻篇

   孙子曰：夫用兵之法，全国为上，破国次之，全军为上，破军次之；全旅为上，破旅次之；全卒为上，破卒次之；全伍为上，破伍次之。是故百战百胜，非善之善者也；不战而屈人之兵，善之善者也。 　　

   故上兵伐谋，其次伐交，其次伐兵，其下攻城。攻城之法为不得已。修橹轒辒，具器械，三月而后成，距堙，又三月而后已。将不胜其忿而蚁附之，杀士三分之一而城不拔者，此攻之灾也。 　　

   故善用兵者，屈人之兵而非战也，拔人之城而非攻也，毁人之国而非久也，必以全争于天下。故兵不顿而利可全，此谋攻之法也。 　　

   故用兵之法，十则围之，五则攻之，倍则分之，敌则能战之，少则能逃之，不若则能避之。故小敌之坚，大敌之擒也。 　　

   夫将者，国之辅也。辅周，则国必强；辅隙，则国必弱。 　　

   故君之所以患于军者三：不知军之不可以进而谓之进，不知军之不可以退而谓之退，是谓“縻军”；不知三军之事，而同三军之政者，则军士惑矣；不知三军之权，而同三军之任，则军士疑矣。三军既惑且疑，则诸侯之难至矣，是谓“乱军引胜”。 　　

   故知胜有五：知可以战与不可以战者胜，识众寡之用者胜，上下同欲者胜，以虞待不虞者胜，将能而君不御者胜。此五者，知胜之道也。 　　

   故曰：知彼知己者，百战不殆；不知彼而知己，一胜一负，不知彼，不知己，每战必殆。

4. 军形篇

   孙子曰：昔之善战者，先为不可胜，以待敌之可胜。不可胜在己，可胜在敌。故善战者，能为不可胜，不能使敌之可胜。故曰：胜可知，而不可为。 　　

   不可胜者，守也；可胜者，攻也。守则不足，攻则有余（竹简为：守则有余，攻则不足）。善守者，藏于九地之下，善攻者，动于九天之上，故能自保而全胜也。 　　

   见胜不过众人之所知，非善之善者也；战胜而天下曰善，非善之善者也。故举秋毫不为多力，见日月不为明目，闻雷霆不为聪耳。古之所谓善战者，胜于易胜者也。故善战者之胜也，无智名，无勇功。故其战胜不忒，不忒者，其所措必胜，胜已败者也。故善战者，立于不败之地，而不失敌之败也。是故胜兵先胜而后求战，败兵先战而后求胜。善用兵者，修道而保法，故能为胜败之政。 　　

   兵法：一曰度，二曰量，三曰数，四曰称，五曰胜。地生度，度生量，量生数，数生称，称生胜。故胜兵若以镒称铢，败兵若以铢称镒。胜者之战民也，若决积水于千仞之溪者，形也。

5. 兵势篇

   孙子曰：凡治众如治寡，分数是也；斗众如斗寡，形名是也；三军之众，可使必受敌而无败者，奇正是也；兵之所加，如以碫投卵者，虚实是也。 　　

   凡战者，以正合，以奇胜。故善出奇者，无穷如天地，不竭如江海。终而复始，日月是也。死而更生，四时是也。声不过五，五声之变，不可胜听也；色不过五，五色之变，不可胜观也；味不过五，五味之变，不可胜尝也；战势不过奇正，奇正之变，不可胜穷也。奇正相生，如循环之无端，孰能穷之哉！ 　　

   激水之疾，至于漂石者，势也；鸷鸟之疾，至于毁折者，节也。故善战者，其势险，其节短。势如扩弩，节如发机。纷纷纭纭，斗乱而不可乱；浑浑沌沌，形圆而不可败。乱生于治，怯生于勇，弱生于强。治乱，数也；勇怯，势也；强弱，形也。 　　

   故善动敌者，形之，敌必从之；予之，敌必取之。以利动之，以卒待之。故善战者，求之于势，不责于人故能择人而任势。任势者，其战人也，如转木石。木石之性，安则静，危则动，方则止，圆则行。 　　

   故善战人之势，如转圆石于千仞之山者，势也。

6. 虚实篇

   孙子曰：凡先处战地而待敌者佚，后处战地而趋战者劳，故善战者，致人而不致于人。能使敌人自至者，利之也；能使敌人不得至者，害之也，故敌佚能劳之，饱能饥之，安能动之。出其所不趋，趋其所不意。行千里而不劳者，行于无人之地也。 　　

   攻而必取者，攻其所不守也；守而必固者，守其所不攻也。故善攻者，敌不知其所守；善守者，敌不知其所攻。微乎微乎，至于无形。神乎神乎，至于无声，故能为敌之司命。进而不可御者，冲其虚也；退而不可追者，速而不可及也。故我欲战，敌虽高垒深沟，不得不与我战者，攻其所必救也；我不欲战，画地而守之，敌不得与我战者，乖其所之也。 　　

   故形人而我无形，则我专而敌分。我专为一，敌分为十，是以十攻其一也，则我众而敌寡；能以众击寡者，则吾之所与战者，约矣。吾所与战之地不可知，不可知，则敌所备者多；敌所备者多，则吾所与战者，寡矣。 　　

   故备前则后寡，备后则前寡，备左则右寡，备右则左寡，无所不备，则无所不寡。寡者，备人者也；众者，使人备己者也。 　　

   故知战之地，知战之日，则可千里而会战。不知战地，不知战日，则左不能救右，右不能救左，前不能救后，后不能救前，而况远者数十里，近者数里乎？ 　　

   以吾度之，越人之兵虽多，亦奚益于胜败哉？故曰：胜可为也。敌虽众，可使无斗。故策之而知得失之计，作之而知动静之理，形之而知死生之地，角之而知有余不足之处。故形兵之极，至于无形。无形，则深间不能窥，智者不能谋。因形而错胜于众，众不能知；人皆知我所以胜之形，而莫知吾所以制胜之形。故其战胜不复，而应形于无穷。 　　

   夫兵形象水，水之形，避高而趋下，兵之形，避实而击虚。水因地而制流，兵因敌而制胜。故兵无常势，水无常形，能因敌变化而取胜者，谓之神。 　　

   故五行无常胜，四时无常位，日有短长，月有死生。

7. 军争篇

   孙子曰：凡用兵之法，将受命于君，合军聚众，交和而舍，莫难于军争。军争之难者，以迂为直，以患为利。 　　

   故迂其途，而诱之以利，后人发，先人至，此知迂直之计者也。军争为利，军争为危。举军而争利则不及，委军而争利则辎重捐。是故卷甲而趋，日夜不处，倍道兼行，百里而争利，则擒三将军，劲者先，疲者后，其法十一而至；五十里而争利，则蹶上将军，其法半至；三十里而争利，则三分之二至。是故军无辎重则亡，无粮食则亡，无委积则亡。故不知诸侯之谋者，不能豫交；不知山林、险阻、沮泽之形者，不能行军；不用乡导者，不能得地利。故兵以诈立，以利动，以分和为变者也。故其疾如风，其徐如林，侵掠如火，不动如山，难知如阴，动如雷震。掠乡分众，廓地分利，悬权而动。先知迂直之计者胜，此军争之法也。　 　　

   《军政》曰：“言不相闻，故为之金鼓；视不相见，故为之旌旗。”夫金鼓旌旗者，所以一民之耳目也。民既专一，则勇者不得独进，怯者不得独退，此用众之法也。故夜战多金鼓，昼战多旌旗，所以变人之耳目也。　 　　

   三军可夺气，将军可夺心。是故朝气锐，昼气惰，暮气归。善用兵者，避其锐气，击其惰归，此治气者也。以治待乱，以静待哗，此治心者也。以近待远，以佚待劳，以饱待饥，此治力者也。无邀正正之旗，勿击堂堂之阵，此治变者也。 　　

   故用兵之法，高陵勿向，背丘勿逆，佯北勿从，锐卒勿攻，饵兵勿食，归师勿遏，围师遗阙，穷寇勿迫，此用兵之法也。

8. 九变篇

   孙子曰：凡用兵之法，将受命于君，合军聚众。圮地无舍，衢地交合，绝地无留，围地则谋，死地则战，途有所不由，军有所不击，城有所不攻，地有所不争，君命有所不受。　 　　

   故将通于九变之利者，知用兵矣；将不通九变之利，虽知地形，不能得地之利矣；治兵不知九变之术，虽知五利，不能得人之用矣。 　　

   是故智者之虑，必杂于利害，杂于利而务可信也，杂于害而患可解也。是故屈诸侯者以害，役诸侯者以业，趋诸侯者以利。故用兵之法，无恃其不来，恃吾有以待之；无恃其不攻，恃吾有所不可攻也。 　　

   故将有五危，必死可杀，必生可虏，忿速可侮，廉洁可辱，爱民可烦。凡此五者，将之过也，用兵之灾也。覆军杀将，必以五危，不可不察也。

9. 行军篇

   孙子曰：凡处军相敌：绝山依谷，视生处高，战隆无登，此处山之军也。绝水必远水；客绝水而来，勿迎之于水内，令半济而击之，利；欲战者，无附于水而迎客；视生处高，无迎水流，此处水上之军也。绝斥泽，惟亟去无留；若交军于斥泽之中，必依水草而背众树，此处斥泽之军也。平陆处易，而右背高，前死后生，此处平陆之军也。凡此四军之利，黄帝之所以胜四帝也。 　　

   凡军好高而恶下，贵阳而贱阴，养生而处实，军无百疾，是谓必胜。丘陵堤防，必处其阳，而右背之。此兵之利，地之助也。 　　

   上雨，水沫至，欲涉者，待其定也。 　　

   凡地有绝涧、天井、天牢、天罗、天陷、天隙，必亟去之，勿近也。吾远之，敌近之；吾迎之，敌背之。 　　

   军行有险阻、潢井、葭苇、山林、蘙荟者，必谨覆索之，此伏奸之所处也。 　　

   敌近而静者，恃其险也；远而挑战者，欲人之进也；其所居易者，利也。 　　

   众树动者，来也；众草多障者，疑也；鸟起者，伏也；兽骇者，覆也；尘高而锐者，车来也；卑而广者，徒来也；散而条达者，樵采也；少而往来者，营军也。 　　

   辞卑而益备者，进也；辞强而进驱者，退也；轻车先出居其侧者，陈也；无约而请和者，谋也；奔走而陈兵车者，期也；半进半退者，诱也。 　　

   杖而立者，饥也；汲而先饮者，渴也；见利而不进者，劳也；鸟集者，虚也；夜呼者，恐也；军扰者，将不重也；旌旗动者，乱也；吏怒者，倦也；粟马肉食，军无悬缻，不返其舍者，穷寇也；谆谆翕翕，徐与人言者，失众也；数赏者，窘也；数罚者，困也；先暴而后畏其众者，不精之至也；来委谢者，欲休息也。兵怒而相迎，久而不合，又不相去，必谨察之。 　　

   兵非益多也，惟无武进，足以并力、料敌、取人而已。夫惟无虑而易敌者，必擒于人。 　　

   卒未亲附而罚之，则不服，不服则难用也。卒已亲附而罚不行，则不可用也。故令之以文，齐之以武，是谓必取。令素行以教其民，则民服；令不素行以教其民，则民不服。令素行者，与众相得也。

10. 地形篇

    孙子曰：地形有通者，有挂者，有支者，有隘者，有险者，有远者。我可以往，彼可以来，曰通；通形者，先居高阳，利粮道，以战则利。可以往，难以返，曰挂；挂形者，敌无备，出而胜之；敌若有备，出而不胜，难以返，不利。我出而不利，彼出而不利，曰支；支形者，敌虽利我，我无出也；引而去之，令敌半出而击之，利。隘形者，我先居之，必盈之以待敌；若敌先居之，盈而勿从，不盈而从之。险形者，我先居之，必居高阳以待敌；若敌先居之，引而去之，勿从也。远形者，势均，难以挑战，战而不利。凡此六者，地之道也；将之至任，不可不察也。 　　

    故兵有走者，有弛者，有陷者，有崩者，有乱者，有北者。凡此六者，非天之灾，将之过也。夫势均，以一击十，曰走；卒强吏弱，曰弛，吏强卒弱，曰陷；大吏怒而不服，遇敌怼而自战，将不知其能，曰崩；将弱不严，教道不明，吏卒无常，陈兵纵横，曰乱；将不能料敌，以少合众，以弱击强，兵无选锋，曰北。凡此六者，败之道也；将之至任，不可不察也。 　　

    夫地形者，兵之助也。料敌制胜，计险厄远近，上将之道也。知此而用战者必胜，不知此而用战者必败。 　　

    故战道必胜，主曰无战，必战可也；战道不胜，主曰必战，无战可也。故进不求名，退不避罪，唯人是保，而利合于主，国之宝也。 　　

    视卒如婴儿，故可与之赴深溪；视卒如爱子，故可与之俱死。厚而不能使，爱而不能令，乱而不能治，譬若骄子，不可用也。 　　

    知吾卒之可以击，而不知敌之不可击，胜之半也；知敌之可击，而不知吾卒之不可以击，胜之半也；知敌之可击，知吾卒之可以击，而不知地形之不可以战，胜之半也。故知兵者，动而不迷，举而不穷。故曰：知彼知己，胜乃不殆；知天知地，胜乃不穷。

11. 九地篇

    孙子曰：用兵之法，有散地，有轻地，有争地，有交地，有衢地，有重地，有圮地，有围地，有死地。诸侯自战其地，为散地。入人之地不深者，为轻地。我得则利，彼得亦利者，为争地。我可以往，彼可以来者，为交地。诸侯之地三属，先至而得天下之众者，为衢地。入人之地深，背城邑多者，为重地。行山林、险阻、沮泽，凡难行之道者，为圮地。所由入者隘，所从归者迂，彼寡可以击吾之众者，为围地。疾战则存，不疾战则亡者，为死地。是故散地则无战，轻地则无止，争地则无攻，交地则无绝，衢地则合交，重地则掠，圮地则行，围地则谋，死地则战。 　　

    所谓古之善用兵者，能使敌人前后不相及，众寡不相恃，贵贱不相救，上下不相收，卒离而不集，兵合而不齐。合于利而动，不合于利而止。敢问：“敌众整而将来，待之若何？”曰：“先夺其所爱，则听矣。” 　　

    兵之情主速，乘人之不及，由不虞之道，攻其所不戒也。 　　

    凡为客之道：深入则专，主人不克；掠于饶野，三军足食；谨养而勿劳，并气积力，运兵计谋，为不可测。投之无所往，死且不北，死焉不得，士人尽力。兵士甚陷则不惧，无所往则固。深入则拘，不得已则斗。是故其兵不修而戒，不求而得，不约而亲，不令而信，禁祥去疑，至死无所之。吾士无余财，非恶货也；无余命，非恶寿也。令发之日，士卒坐者涕沾襟。偃卧者涕交颐。投之无所往者，诸、刿之勇也。 　　

    故善用兵者，譬如率然；率然者，常山之蛇也。击其首则尾至，击其尾则首至，击其中则首尾俱至。敢问：“兵可使如率然乎？”曰：“可。”夫吴人与越人相恶也，当其同舟而济，遇风，其相救也如左右手。是故方马埋轮，未足恃也；齐勇若一，政之道也；刚柔皆得，地之理也。故善用兵者，携手若使一人，不得已也。 　　

    将军之事：静以幽，正以治。能愚士卒之耳目，使之无知。易其事，革其谋，使人无识；易其居，迂其途，使人不得虑。帅与之期，如登高而去其梯；帅与之深入诸侯之地，而发其机，焚舟破釜，若驱群羊，驱而往，驱而来，莫知所之。聚三军之众，投之于险，此谓将军之事也。九地之变，屈伸之利，人情之理，不可不察。 　　

    凡为客之道：深则专，浅则散。去国越境而师者，绝地也；四达者，衢地也；入深者，重地也；入浅者，轻地也；背固前隘者，围地也；无所往者，死地也。 　　

    是故散地，吾将一其志；轻地，吾将使之属；争地，吾将趋其后；交地，吾将谨其守；衢地，吾将固其结；重地，吾将继其食；圮地，吾将进其涂；围地，“吾将塞其阙；死地，吾将示之以不活。 　　

    故兵之情，围则御，不得已则斗，过则从。是故不知诸侯之谋者，不能预交；不知山林、险阻、沮泽之形者，不能行军；不用乡导者，不能得地利。四五者，不知一，非霸王之兵也。夫霸王之兵，伐大国，则其众不得聚；威加于敌，则其交不得合。是故不争天下之交，不养天下之权，信己之私，威加于敌，故其城可拔，其国可隳。施无法之赏，悬无政之令，犯三军之众，若使一人。犯之以事，勿告以言；犯之以利，勿告以害。 　　

    投之亡地然后存，陷之死地然后生。夫众陷于害，然后能为胜败。 　　

    故为兵之事，在于顺详敌之意，并敌一向，千里杀将，此谓巧能成事者也。 　　

    是故政举之日，夷关折符，无通其使；厉于廊庙之上，以诛其事。敌人开阖，必亟入之。先其所爱，微与之期。践墨随敌，以决战事。是故始如处女，敌人开户，后如脱兔，敌不及拒。

12. 火攻篇

    孙子曰：凡火攻有五：一曰火人，二曰火积，三曰火辎，四曰火库，五曰火队。行火必有因，烟火必素具。发火有时，起火有日。时者，天之燥也；日者，月在箕、壁、翼、轸也。凡此四宿者，风起之日也。 　　

    凡火攻，必因五火之变而应之。火发于内，则早应之于外。火发兵静者，待而勿攻，极其火力，可从而从之，不可从而止。火可发于外，无待于内，以时发之。火发上风，无攻下风。昼风久，夜风止。凡军必知有五火之变，以数守之。 　　

    故以火佐攻者明，以水佐攻者强。水可以绝，不可以夺。夫战胜攻取，而不修其功者凶，命曰费留。故曰：明主虑之，良将修之。非利不动，非得不用，非危不战。主不可以怒而兴师，将不可以愠而致战；合于利而动，不合于利而止。怒可以复喜，愠可以复悦；亡国不可以复存，死者不可以复生。故明君慎之，良将警之，此安国全军之道也。

13. 用间篇

    孙子曰：凡兴师十万，出征千里，百姓之费，公家之奉，日费千金；内外骚动，怠于道路，不得操事者，七十万家。相守数年，以争一日之胜，而爱爵禄百金，不知敌之情者，不仁之至也，非人之将也，非主之佐也，非胜之主也。故明君贤将，所以动而胜人，成功出于众者，先知也。先知者，不可取于鬼神，不可象于事，不可验于度，必取于人，知敌之情者也。 　　

    故用间有五：有因间，有内间，有反间，有死间，有生间。五间俱起，莫知其道，是谓神纪，人君之宝也。因间者，因其乡人而用之。内间者，因其官人而用之。反间者，因其敌间而用之。死间者，为诳事于外，令吾间知之，而传于敌间也。生间者，反报也。 　　

    故三军之事，莫亲于间，赏莫厚于间，事莫密于间。非圣智不能用间，非仁义不能使间，非微妙不能得间之实。微哉！微哉！无所不用间也。间事未发，而先闻者，间与所告者皆死。（莫亲于间：指没有比间谍更应成为亲信了。赏莫厚于间：指没有比间谍更应该得到丰富的奖赏了。事莫密于间：没有经间谍的事更应该保守机密了。间事未发：用间之事还没有开始进行。间与所告者皆死：间谍和告知用间之事的人都要处死。） 　　

    凡军之所欲击，城之所欲攻，人之所欲杀，必先知其守将，左右，谒者，门者，舍人之姓名，令吾间必索知之。 　　

    必索敌人之间来间我者，因而利之，导而舍之，故反间可得而用也。因是而知之，故乡间、内间可得而使也；因是而知之，故死间为诳事，可使告敌。因是而知之，故生间可使如期。五间之事，主必知之，知之必在于反间，故反间不可不厚也。 　　

    昔殷之兴也，伊挚在夏；周之兴也，吕牙在殷。故惟明君贤将，能以上智为间者，必成大功。此兵之要，三军之所恃而动也。

1. 100部最好的科幻电影之一

2. 100部最好的科幻电影之二

3. 100部最好的科幻电影之三

4. 100部最好的科幻电影之四

//============================================================================
// Name        : numberTest.cpp
// Author      : 
#include <iostream>
using namespace std;
int main()
{
	unsigned int result = 414;
	int number = 3;
	bool bPreviousSmaller = (1.0+result/1000.0)*(1.0+result/1000.0) < 2.0;
	while (number < 10)
	{
		double value = 1;
		for (int i = 0; i < number; i ++)
		{
			value*=10;
		}
		double temp = (1.0+result/value)*(1.0+result/value);
		cout << "value:"<<value<< "\tnumber:"<<number << "\tresult:" <<  result << "\ttemp:" << temp<< endl;
		if (temp < 2.0)
		{
			bPreviousSmaller = true;
			result ++;
		}
		else
		{
			if (bPreviousSmaller)
			{
				bPreviousSmaller = false;
				number ++;
				result *=10;
			}
			else
			{
				result--;
			}
		}
	}
	cout << result << endl;
	return 0;
}

#include <iostream>
#include <boost/regex.hpp>
using namespace std;
int main()
{
        string strInput = "( CPU_0 ) / ( Channel_F ) / ( Channel_F Dimm_1 )";
        boost::regex expression("\\( CPU_([0-9]) \\) / \\( Channel_([A-Z]) \\) / \\( Channel_([A-Z]) Dimm_([0-9]) \\)");
        boost::cmatch what;
        string str;
        if (boost::regex_match(strInput.c_str(), what, expression))
        {
                str = "CPU";
                str += string(what[1].first, what[1].second);
                str += "_";
                str += string(what[2].first, what[2].second);
                str += string(what[4].first, what[4].second);
                cout << str >> endl;
        }
        return 0;
}

#include <iostream>
#include <fstream>
#include <boost/regex.hpp>
#include <boost/filesystem.hpp>
#include <map>
#include <string>
using namespace std;
struct MimeExt
{
	string strDescription;
	string strMime;
	string strExt;
	operator string() const
	{
		return strDescription + ";" + strMime + ";" + strExt;
	}
};
typedef map<string, MimeExt> MimeExtMap;
int mimeExt(MimeExtMap& mapExt)
{
	ifstream in("/home/nick/workspace/magicTest/src/mimeExt.txt");
	if (in.is_open())
	{
		string str;
		while (std::getline(in, str))
		{
			boost::regex ex("\\s*([\\w|\\+|/|#|\\.|\\-]+(?:\\s+[\\w|\\+|#|\\-|/|\\.]+)*)"
					"\\s+([\\w][-|\\w]*/[\\w][\\.|\\+|\\-|\\w]*)"
					"\\s+([\\w|\\*]+)\\s*");
			boost::cmatch what;
			if (boost::regex_match(str.c_str(), what, ex, boost::match_default))
			{
				MimeExt mime;
				mime.strDescription = string(what[1].first, what[1].second);
				mime.strMime = string(what[2].first, what[2].second);
				mime.strExt = ".";
				mime.strExt += string(what[3].first, what[3].second);
				mapExt.insert(make_pair(mime.strMime, mime));
				MimeExtMap::iterator it = mapExt.find(mime.strMime);
				if (it == mapExt.end())
				{
					mapExt.insert(it, make_pair(mime.strMime, mime));
				}
			}
		}
		in.close();
	}
	return 0;
}
int extMime(MimeExtMap& mapExt)
{
	ifstream in("/home/nick/workspace/magicTest/src/extMime.txt");
	if (in.is_open())
	{
		string str;
		while (std::getline(in, str))
		{
			boost::regex ex("\\s*([\\w](?:[:|\\&|\\w|\\+|/|#|\\.|\\-|\\(|\\)|\\s|'])+[\\w|\\)|\\+])"
					"\\s+([\\w][-|\\w]*/[\\w][\\.|\\+|\\-|\\w|,]*)"
					"\\s*(N/A|[\\.][\\w|\\-]+)[,]?"
					"\\s+([\\(|\\)|\\&|/|\\-|\\+|'|\\.|\\:|\\w|\\s]*)");
			boost::cmatch what;
			if (boost::regex_match(str.c_str(), what, ex, boost::match_default))
			{
				MimeExt mime;
				mime.strDescription = string(what[1].first, what[1].second);
				mime.strMime = string(what[2].first, what[2].second);
				mime.strExt = string(what[3].first, what[3].second);
				MimeExtMap::iterator it = mapExt.find(mime.strMime);
				if (it == mapExt.end())
				{
					mapExt.insert(it, make_pair(mime.strMime, mime));
				}
			}
		}
		in.close();
	}
	return 0;
}
int main()
{
	MimeExtMap mapExt;
	mimeExt(mapExt);
	extMime(mapExt);
	for (MimeExtMap::const_iterator it = mapExt.begin(); it != mapExt.end(); it++)
	{
		cout << it->first << ":\t";
		cout << it->second.operator string() << endl;
	}
}

.[\*^$

// e1 is a case sensitive POSIX-Basic expression:
boost::regex e1(my_expression, boost::regex::basic);
// e2 a case insensitive POSIX-Basic expression:
boost::regex e2(my_expression, boost::regex::basic|boost::regex::icase);

An atom can also be repeated with a bounded repeat:

a\{n\} Matches 'a' repeated exactly n times.

a\{n,\} Matches 'a' repeated n or more times.

a\{n,m\} Matches 'a' repeated between n and m times inclusive.

For example:

^a{2,3}$请注意这里没有使用escape，但是不要误解不需要啊！

正确的应该是：^a\{2,3\}$

Will match either of:

aa
aaa

But neither of:

a
aaaa

#include <iostream>
#include <boost/regex.hpp>
using namespace std;
using namespace boost;
int main()
{
        string array[]={
                        "", "a", "aa", "aaa", "aaaa", "aaaaa"
        };

  regex ex("^a\\{2,3\\}$", regex::basic|regex::icase);

        cmatch what;
        for (size_t i = 0; i < sizeof(array)/sizeof(array[0]); i ++)
        {
                if (regex_match(array[i].c_str(), what, ex, match_partial))
                {
                        cout << what[0] << endl;
                }
        }
        return 0;
}

int main()
{
        string array[]={ "abcd", "efg", "def", "ddef", "abcdef", "aabc", "abc", "ABC", "DEF"};
        regex ex("abc\ndef", regex::grep|regex::icase);//grep的意思本来就是basic|newline_alt
        cmatch what;
        for (size_t i = 0; i < sizeof(array)/sizeof(array[0]); i ++)
        {
                if (regex_match(array[i].c_str(), what, ex, match_default))
                {
                        cout << what[0] << endl;
                }
        }
        return 0;
}

1. .正常情况下除了NULL和newline字符外都可以。
2. ^和$依旧是一行的开始和结束
3. ()是所谓marked subsection，就是说可以使用\n来refer的。
4. 相应的如果你不想产生marked subsection，你可以使用(?:)
5. *重复任意次；+重复至少一次；?重复至多一次；{}可以指定重复次数或者重复次数范围：{n}是n次；{n,}至少n次；{n,m}重复次数在n到m之间；但是要注意{}必须是在符合重复次数时候才作为特殊字符，否则就是普通字符，这一点和[]是类似的，[不会单独成为特殊字符。
6. 不贪心的重复，这一点很重要，因为正常情况下重复总是选择尽可能多的可能性来重复，如果在其后加了一个？的话就限制了重复的“贪心”：*?;+?;??;{n,}?;{n,m}?

1. 在ls文件名的时候如果其中有数字我想按照数字大小来排序，那么这么简单的问题不是使用-v吗？我一直以为这个是verbose的意思？当然不是，是natural sort，或者说version sort。
2. 另一个通常的问题是我要输出文件名需要单引号：--quoting-style=shell。
3. 而且我需要把这些文件写到一个文件里并且在每个文件名前面加上"filename"这样的格式：ls --quoting-style=shell -v 古畑任三郎\ 完结篇\ EP01\ 第一 晚\ 今、甦る死\ _SD_*_.flv | while read line; do echo "file $line" >> list.txt; done
4. 我究竟为什么要这样做呢？因为我需要手动merge使用ffmpeg这些文件：ffmpeg -f concat -safe -1 -y -i list.txt -c copy -hide_banner 古畑任三郎\ 完结篇\ EP01\ 第一晚\ 今、甦る死\ _SD.flve
5. 我为什么要手动merge这些文件呢？因为我使用ykdl来下载youku的视频，直接编译似乎有困难，我就是用官方的下载：
   • sudo apt-get install ffmpeg mpv python3-pip
   • pip3 install ykdl --upgrade --user
   • add ~/.local/bin to your PATH

Possessive Quantifiers

The topic on repetition operators or quantifiers explains the difference between greedy and lazy repetition. Greediness and laziness determine the order in which the regex engine tries the possible permutations of the regex pattern. A greedy quantifier first tries to repeat the token as many times as possible, and gradually gives up matches as the engine backtracks to find an overall match. A lazy quantifier first repeats the token as few times as required, and gradually expands the match as the engine backtracks through the regex to find an overall match.

Because greediness and laziness change the order in which permutations are tried, they can change the overall regex match. However, they do not change the fact that the regex engine will backtrack to try all possible permutations of the regular expression in case no match can be found.

Possessive quantifiers are a way to prevent the regex engine from trying all permutations. This is primarily useful for performance reasons. You can also use possessive quantifiers to eliminate certain matches.

Of the regex flavors discussed in this tutorial, possessive quantifiers are supported by JGsoft, Java, and PCRE. That includes languages with regex support based on PCRE such as PHP, Delphi, and R. Ruby supports possessive quantifiers starting with Ruby 1.9, Perl supports them starting with Perl 5.10, and Boost starting with Boost 1.42.

How Possessive Quantifiers Work

Like a greedy quantifier, a possessive quantifier repeats the token as many times as possible. Unlike a greedy quantifier, it does not give up matches as the engine backtracks. With a possessive quantifier, the deal is all or nothing. You can make a quantifier possessive by placing an extra + after it. * is greedy, *? is lazy, and *+ is possessive. ++, ?+ and {n,m}+ are all possessive as well.

Let's see what happens if we try to match "[^"]*+" against "abc". The " matches the ". [^"] matches a, b and c as it is repeated by the star. The final " then matches the final " and we found an overall match. In this case, the end result is the same, whether we use a greedy or possessive quantifier. There is a slight performance increase though, because the possessive quantifier doesn't have to remember any backtracking positions.

The performance increase can be significant in situations where the regex fails. If the subject is "abc (no closing quote), the above matching process happens in the same way, except that the second " fails. When using a possessive quantifier, there are no steps to backtrack to. The regular expression does not have any alternation or non-possessive quantifiers that can give up part of their match to try a different permutation of the regular expression. So the match attempt fails immediately when the second " fails.

Had we used "[^"]*" with a greedy quantifier instead, the engine would have backtracked. After the " failed at the end of the string, the [^"]* would give up one match, leaving it with ab. The " would then fail to match c. [^"]* backtracks to just a, and " fails to match b. Finally, [^"]* backtracks to match zero characters, and " fails a. Only at this point have all backtracking positions been exhausted, and does the engine give up the match attempt. Essentially, this regex performs as many needless steps as there are characters following the unmatched opening quote.

When Possessive Quantifiers Matter

The main practical benefit of possessive quantifiers is to speed up your regular expression. In particular, possessive quantifiers allow your regex to fail faster. In the above example, when the closing quote fails to match, we know the regular expression couldn't possibly have skipped over a quote. So there's no need to backtrack and check for the quote. We make the regex engine aware of this by making the quantifier possessive. In fact, some engines, including the JGsoft engine, detect that [^"]* and " are mutually exclusive when compiling your regular expression, and automatically make the star possessive.

Now, linear backtracking like a regex with a single quantifier does is pretty fast. It's unlikely you'll notice the speed difference. However, when you're nesting quantifiers, a possessive quantifier may save your day. Nesting quantifiers means that you have one or more repeated tokens inside a group, and the group is also repeated. That's when catastrophic backtracking often rears its ugly head. In such cases, you'll depend on possessive quantifiers and/or atomic grouping to save the day.

Possessive Quantifiers Can Change The Match Result

Using possessive quantifiers can change the result of a match attempt. Since no backtracking is done, and matches that would require a greedy quantifier to backtrack will not be found with a possessive quantifier. For example, ".*" matches "abc" in "abc"x, but ".*+" does not match this string at all.

In both regular expressions, the first " matches the first " in the string. The repeated dot then matches the remainder of the string abc"x. The second " then fails to match at the end of the string.

Now, the paths of the two regular expressions diverge. The possessive dot-star wants it all. No backtracking is done. Since the " failed, there are no permutations left to try, and the overall match attempt fails. The greedy dot-star, while initially grabbing everything, is willing to give back. It will backtrack one character at a time. Backtracking to abc", " fails to match x. Backtracking to abc, " matches ". An overall match "abc" is found.

Essentially, the lesson here is that when using possessive quantifiers, you need to make sure that whatever you're applying the possessive quantifier to should not be able to match what should follow it. The problem in the above example is that the dot also matches the closing quote. This prevents us from using a possessive quantifier. The negated character class in the previous section cannot match the closing quote, so we can make it possessive.

Using Atomic Grouping Instead of Possessive Quantifiers

Technically, possessive quantifiers are a notational convenience to place an atomic group around a single quantifier. All regex flavors that support possessive quantifiers also support atomic grouping. But not all regex flavors that support atomic grouping support possessive quantifiers. With those flavors, you can achieve the exact same results using an atomic group.

Basically, instead of X*+, write (?>X*). It is important to notice that both the quantified token X and the quantifier are inside the atomic group. Even if X is a group, you still need to put an extra atomic group around it to achieve the same effect. (?:a|b)*+ is equivalent to (?>(?:a|b)*) but not to (?>a|b)*. The latter is a valid regular expression, but it won't have the same effect when used as part of a larger regular expression.

To illustrate, (?:a|b)*+b and (?>(?:a|b)*)b both fail to match b. a|b matches the b. The star is satisfied, and the fact that it's possessive or the atomic group will cause the star to forget all its backtracking positions. The second b in the regex has nothing left to match, and the overall match attempt fails.

In the regex (?>a|b)*b, the atomic group forces the alternation to give up its backtracking positions. This means that if an a is matched, it won't come back to try b if the rest of the regex fails. Since the star is outside of the group, it is a normal, greedy star. When the second b fails, the greedy star backtracks to zero iterations. Then, the second b matches the b in the subject string.

int main()
{
        string str="\"abc\"x";
        regex ex("\".+\"");
        cmatch what;
        if (regex_match(str.c_str(), what, ex, match_partial))
        {
                cout << what[0] <<  endl;
        }
        return 0;
}

Character Classes that are Always Supported

The following character class names are always supported by Boost.Regex:

Character classes that are supported by Unicode Regular Expressions

The following character classes are only supported by Unicode Regular Expressions: that is those that use the u32regex type.  The names used are the same as those from Chapter 4 of the Unicode standard.

ls *.mkv | while read line; do ffmpeg -y -i "$line" "${line%%*(.mkv)}.mp4" < /dev/null ; done

而更加的详细解释在这里：while read line; do ffmpeg -i $line ${line%%*(.mkv)}.mp4 < /dev/null ; done < <(find . -name '*.mkv')

1. 首先安装必要的库：

   sudo aptitude install libx264-dev libsdl1.2-dev libv4l-dev libass-dev libbluray-dev libmp3blame-dev libopencore-amrnb-dev libopencore-amrwb-dev libopenjp2-7-dev libtheora-dev libxvidcore-dev

2. 这里的configure很重要，不但需要mp3的库，我更想避免安装我自己编译的版本防止和官方版本冲突，所以，我使用了静态编译不需要安装：

   ./configure --enable-gpl --enable-version3 --enable-nonfree --enable-postproc  --enable-libmp3lame --enable-libopencore-amrnb --enable-libopencore-amrwb --enable-libtheora --enable-libvorbis --enable-libx264 --enable-libxvid --disable-shared --enable-static --enable-libass --enable-libbluray --enable-libopenjpeg   --enable-libfreetype --enable-libfontconfig --enable-gmp --enable-librsvg --enable-libtesseract --enable-ffmpeg --enable-ffplay --enable-ffprobe

3. 这个小循环：

   for var in `ls *.m4v`; do name=`echo ${var}|grep -Eoi "^.*[^.]{5}"`; ~/Downloads/ffmpeg-git/ffmpeg -i ./${var} -c:a:0 libmp3lame -b 48000 -vn -sn mp3/${name}.mp3 ; done

//============================================================================
// Name        : htmlTest.cpp
// Author      : 
// Version     :
// Copyright   : Your copyright notice
// Description : Hello World in C++, Ansi-style
//============================================================================

#include <iostream>
#include <fstream>
#include <boost/regex.hpp>
using namespace std;
using namespace boost;
int main()
{
	ifstream in("/BigDisk/diabloforum/public_html/2019.htm");
	ofstream out("/tmp/2019.htm");
	if (in.is_open() && out.is_open())
	{
		regex ex("<hr><p  style=\"color:red;\">([\\W]+月[\\W]+日)等待变化等待机会</p>");
		cmatch what;
		string str;
		char buffer[20480];
		while (in.getline(buffer, 20480))
		{
			if (regex_match(buffer, what, ex))
			{
				cout << "****************************"<<buffer <<"**************************" << endl;
				string strDate = string(what[1].first, what[1].second);
				cout << strDate << endl;
				string strNew = "<a id=\"";
				strNew += strDate;
				strNew += "\">";
				strNew+= buffer;
				strNew+="</a>";
				cout << strNew << endl;
				out << strNew << endl;
			}
			else
			{
				out << buffer << endl;
			}
		}
	}
	return 0;
}

nick@nick-HP-Laptop-AMD:/sys/devices$ cat ./pci0000:00/0000:00:01.5/0000:04:00.0/nvme/nvme0/nvme0n1/nvme0n1p5/size | numfmt --to=iec
746M

[root@centos76-nick run]# dd if=/dev/zero of=bigfile.bin bs=1M count=100K 
102400+0 records in
102400+0 records out
107374182400 bytes (107 GB) copied, 36.6604 s, 2.9 GB/s
[root@centos76-nick run]# 

textview text {
   background-color: white;
}
scrollbar {
   background-color: white;
}

@import url("gtk-main.css");

#include <iostream>

#include <boost/regex.hpp>

#include <boost/filesystem.hpp>

using 
namespace std;

using 
namespace boost;


int main()
{
	string str;
	filesystem::load_string_file(filesystem::path("/BigDisk/diabloforum/public_html/2017.htm"), str);
	ofstream out("/tmp/2017.htm");
	string::const_iterator start = str.begin(), end = str.end();

	regex ex("(<p style=\"margin-bottom: 0in\">).+?(</p>)");
	match_results<string::const_iterator> what;
	
	while (regex_search(start, end, what, ex))
	{
		
	if (start != what[0].first)
		{
			out << string(start, what[0].first);
		}

//		cout << "*******************************" << endl;
		string strRemain = string(what[1].second, what[2].first);

//		cout << strRemain << endl;
		out << strRemain;
		start = what[0].second;
	}
	
if (start!=end)
	{
		out << string(start, end)<< endl;
	}
	
return 0;
}

1 前言

自从诞生以来，Linux 就被不断完善和普及，目前它已经成为主流通用操作系统之一，使用得非常广泛，它与 Windows、UNIX 一起占据了操作系统领域几乎所有的市场份额。特别是在高性能计算领域，Linux 已经成为一个占主导地位的操作系统，在2005年6月全球TOP500 计算机中，有 301 台部署的是 Linux 操作系统。因此，研究和使用 Linux 已经成为开发者的不可回避的问题了。

下面我们介绍一下 Linux 内核中文件 Cache 管理的机制。本文以 2.6 系列内核为基准，主要讲述工作原理、数据结构和算法，不涉及具体代码。

2 操作系统和文件 Cache 管理

操 作系统是计算机上最重要的系统软件，它负责管理各种物理资源，并向应用程序提供各种抽象接口以便其使用这些物理资源。从应用程序的角度看，操作系统提供了 一个统一的虚拟机，在该虚拟机中没有各种机器的具体细节，只有进程、文件、地址空间以及进程间通信等逻辑概念。这种抽象虚拟机使得应用程序的开发变得相对 容易：开发者只需与虚拟机中的各种逻辑对象交互，而不需要了解各种机器的具体细节。此外，这些抽象的逻辑对象使得操作系统能够很容易隔离并保护各个应用程 序。

对于存储设备上的数据，操作系统向应用程序提供的逻辑概念就是"文件"。应用程序要存储或访问数据时，只需读或者写"文件"的一维地址空间即可， 而这个地址空间与存储设备上存储块之间的对应关系则由操作系统维护。

在Linux操作系统中，当应用程序需要读取文件中的数据时，操作系统先分配一些内存，将数据从存储设备读入到这些内存中，然后再将数据分发给应用程序；当需要往文件 中写数据时，操作系统先分配内存接收用户数据，然后再将数据从内存写到磁盘上。文件 Cache 管理指的就是对这些由操作系统分配，并用来存储文件数据的内存的管理。 Cache 管理的优劣通过两个指标衡量：一是 Cache 命中率，Cache 命中时数据可以直接从内存中获取，不再需要访问低速外设，因而可以显著提高性能；二是有效 Cache 的比率，有效 Cache 是指真正会被访问到的 Cache 项，如果有效 Cache 的比率偏低，则相当部分磁盘带宽会被浪费到读取无用 Cache 上，而且无用 Cache 会间接导致系统内存紧张，最后可能会严重影响性能。

下面分别介绍文件 Cache 管理在 Linux 操作系统中的地位和作用、Linux 中文件 Cache相关的数据结构、Linux 中文件 Cache 的预读和替换、 Linux 中文件 Cache 相关 API 及其实现。

2 文件 Cache 的地位和作用

文件 Cache 是文件数据在内存中的副本，因此文件 Cache 管理与内存管理系统和文件系统都相关：一方面文件 Cache 作为物理内存的一部分，需要参与物理内存的分配回收过程，另一方面文件 Cache 中的数据来源于存储设备上的文件，需要通过文件系统与存储设备进行读写交互。从操作系统的角度考虑，文件 Cache 可以看做是内存管理系统与文件系统之间的联系纽带。因此，文件 Cache 管理是操作系统的一个重要组成部分，它的性能直接影响着文件系统和内存管理系统的性能。

图1描述了 Linux 操作系统中文件Cache 管理与内存管理以及文件系统的关系示意图。从图中可以看到，在 Linux 中，具体文件系统，如 ext2/ext3、jfs、ntfs 等，负责在文件 Cache和存储设备之间交换数据，位于具体文件系统之上的虚拟文件系统VFS负责在应用程序和文件 Cache 之间通过 read/write 等接口交换数据，而内存管理系统负责文件 Cache 的分配和回收，同时虚拟内存管理系统(VMM)则允许应用程序和文件 Cache 之间通过 memory map的方式交换数据。可见，在 Linux 系统中，文件 Cache 是内存管理系统、文件系统以及应用程序之间的一个联系枢纽。

3 文件 Cache 相关数据结构

在Linux 的实现中，文件 Cache 分为两个层面，一是 Page Cache，另一个 Buffer Cache，每一个 Page Cache 包含若干 Buffer Cache。内存管理系统和 VFS 只与 Page Cache 交互，内存管理系统负责维护每项 Page Cache 的分配和回收，同时在使用 memory map 方式访问时负责建立映射；VFS 负责 Page Cache 与用户空间的数据交换。而具体文件系统则一般只与 Buffer Cache 交互，它们负责在外围存储设备和 Buffer Cache 之间交换数据。Page Cache、Buffer Cache、文件以及磁盘之间的关系如图 2 所示，Page 结构和 buffer_head 数据结构的关系如图 3 所示。在上述两个图中，假定了 Page 的大小是 4K，磁盘块的大小是 1K。本文所讲述的，主要是指对 Page Cache 的管理。

在 Linux 内核中，文件的每个数据块最多只能对应一个 Page Cache 项，它通过两个数据结构来管理这些 Cache 项，一个是 radix tree，另一个是双向链表。Radix tree 是一种搜索树，Linux 内核利用这个数据结构来通过文件内偏移快速定位 Cache 项，图 4 是 radix tree的一个示意图，该 radix tree 的分叉为4(22)，树高为4，用来快速定位8位文件内偏移。Linux(2.6.7) 内核中的分叉为 64(26)，树高为 6(64位系统)或者 11(32位系统)，用来快速定位 32 位或者 64 位偏移，radix tree 中的每一个叶子节点指向文件内相应偏移所对应的Cache项。

另一个数据结构是双向链表，Linux内核为每一片物理内存区域(zone)维护active_list和inactive_list两个双向链表，这两个 list主要用来实现物理内存的回收。这两个链表上除了文件Cache之外，还包括其它匿名(Anonymous)内存，如进程堆栈等。

4 文件Cache的预读和替换

Linux内核中文件预读算法的具体过程是这样的：对于每个文件的第一个读请求，系统读入所请求的页面并读入紧随其后的少数几个页面(不少于一个页面，通常是三个页 面)，这时的预读称为同步预读。对于第二次读请求，如果所读页面不在Cache中，即不在前次预读的group中，则表明文件访问不是顺序访问，系统继续 采用同步预读；如果所读页面在Cache中，则表明前次预读命中，操作系统把预读group扩大一倍，并让底层文件系统读入group中剩下尚不在 Cache中的文件数据块，这时的预读称为异步预读。无论第二次读请求是否命中，系统都要更新当前预读group的大小。此外，系统中定义了一个 window，它包括前一次预读的group和本次预读的group。任何接下来的读请求都会处于两种情况之一：第一种情况是所请求的页面处于预读 window中，这时继续进行异步预读并更新相应的window和group；第二种情况是所请求的页面处于预读window之外，这时系统就要进行同步 预读并重置相应的window和group。图5是Linux内核预读机制的一个示意图，其中a是某次读操作之前的情况，b是读操作所请求页面不在 window中的情况，而c是读操作所请求页面在window中的情况。

Linux内核中文件Cache替换的具体过程是这样的：刚刚分配 的Cache项链入到inactive_list头部，并将其状态设置为active，当内存不够需要回收Cache时，系统首先从尾部开始反向扫描 active_list并将状态不是referenced的项链入到inactive_list的头部，然后系统反向扫描inactive_list，如 果所扫描的项的处于合适的状态就回收该项，直到回收了足够数目的Cache项。Cache替换算法如图6的算法描述伪码所示。

图6 Linux的Cache替换算法描述

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47

Mark_Accessed(b) {         if b.state==(UNACTIVE && UNREFERENCE)                  b.state = REFERENCE                  else if b.state == (UNACTIVE && REFERENCE) {                   b.state = (ACTIVE && UNREFERENCE)                            Add X to tail of active_list                   } else if b.state == (ACTIVE && UNREFERENCE)                     b.state = (ACTIVE && REFERENCE) } Reclaim() {                      if active_list not empty and scan_num<MAX_SCAN1                 {                        X = head of active_list                            if (X.state & REFERENCE) == 0                                Add X to tail of inactive_list                            else {                      X.state &=  ~REFERENCE Move X to tail of active_list                                      }                            scan_num++                      }                      scan_num = 0                      if inactive_list not emptry and scan_num <                 MAX_SCAN2 {                            X = head of inactive_list                            if (X.state & REFERENCE) == 0                                return X                            else {                    X.state = ACTIVE | UNREFERENCE Move X to tail of active_list                                      }                            scan_num++                      }                      return NULL } Access(b){                      if b is not in cache {                        if slot X free                        put b into X                        else {                        X=Reclaim()                        put b into X                            }                        Add X to tail of inactive_list                      }                      Mark_Accessed(X) }

5 文件Cache相关API及其实现

Linux 内核中与文件Cache操作相关的API有很多，按其使用方式可以分成两类：一类是以拷贝方式操作的相关接口， 如read/write/sendfile等，其中sendfile在2.6系列的内核中已经不再支持；另一类是以地址映射方式操作的相关接口，如 mmap等。

第一种类型的API在不同文件的Cache之间或者Cache与应用程序所提供的用户空间buffer之间拷贝数据，其实现原理如图7所示。

第二种类型的API将Cache项映射到用户空间，使得应用程序可以像使用内存指针一样访问文件，Memory map访问Cache的方式在内核中是采用请求页面机制实现的， 其工作过程如图8所示。

首 先，应用程序调用mmap（图中1），陷入到内核中后调用do_mmap_pgoff（图中2）。该函数从应用程序的地址空间中分配一段区域作为映射的内 存地址，并使用一个VMA（vm_area_struct）结构代表该区域，之后就返回到应用程序（图中3）。当应用程序访问mmap所返回的地址指针时 （图中4），由于虚实映射尚未建立，会触发缺页中断（图中5）。之后系统会调用缺页中断处理函数（图中6），在缺页中断处理函数中，内核通过相应区域的 VMA结构判断出该区域属于文件映射，于是调用具体文件系统的接口读入相应的Page Cache项（图中7、8、9），并填写相应的虚实映射表。经过这些步骤之后，应用程序就可以正常访问相应的内存区域了。

6 小结

文件Cache管理是Linux操作系统的一个重要组成部分，同时也是研究领域一个很热门的研究方向。目前，Linux内核在这个方面的工作集中在开发更有效的Cache 替换算法上，如LIRS(其变种ClockPro)、ARC等。相关信息可见 http://linux-mm.org/AdvancedPageReplacement。

    .global blob
    .global blob_size
    .section .rodata
blob:
    .incbin "blob.bin"
1:
blob_size:
    .int 1b - blob

==Damage Calculation==
=== Heroes III ===
The total damage inflicted in an attack is calculated after the following formula:

$Total\; Damage=Base\; Damage*(1+a+b+c+...)*(1-q)*(1-r)*(1-s)*...$
, where:

*$Base\; Damage$is the damage displayed for every unit in its stats (e.g. 40-50 for a Black dragon). For a stack of creatures it is calculated as such:
**If there are less than 10 creatures in a stack, then a random integer is chosen from the damage range for each creature, and these numbers are added up.
**If there are more than 10 creatures in a stack, 10 random integers are chosen from the damage range of the creature type and are added up. The result is multiplied by n/10, where n is the number of creatures in the stack, and rounded down.
The probability that the resulting base damage will be in the lowest/highest 25% is (approximately):
*$a$,$b$,$c$,... are damage bonuses
*$q$,$r$,$s$,... are damage reductions (both as decimal numbers)

====Damage Bonuses====


	
Situation
Bonus


	
Attacker's Attack Skill > Defender's Defense Skill
	
0.05 * (A - D), (capped at 3)


	
Attacker is a shooter
Archery Skill bonus, additive with artifact bonuses if Archery skill present


	
Attacker is a Ballista, does double damage
1


	
Attacking hero has Archery specialty
0.05 * Hero level * Archery bonus

	
Attacking hero has Offense Skill
Offense skill bonus

	
Attacking hero has Offense specialty
0.05 * Hero level * Offense bonus

	
Attacker gets Luck
1

	
Attacker is a Cavalier/Champion
0.05 * hexes traveled

	
Attacker is an opposite Elemental type
1

	
Attacker 'hates' the Defender
0.5

	
Dread knight's double damage
1

	
Bless specialty Hero, Bless is cast
0.03 * Hero level / Unit level



====Damage Reductions====

Situation
Reduction

	
Defender's Defense > Attacker's Attack
0.025 * (D – A), up to a maximum of 0.7


	
Defending hero has Armorer
Armorer skill bonus


	
Defending hero has specialty Armorer
0.05 * Hero level *Armorer bonus, additive with base Armorer bonus


	
Defender has Shield spell applied
Shield spell bonus


	
Attacker is a shooter, Basic Air Shield is cast
0.25


	
Attacker is a shooter with range, wall or melee penalty, or Advanced Air Shield is cast
0.5

	
Attacking a petrified unit
0.5

	
Attacker is Psychic Elemental, defender is immune to Mind spells
0.5

	
Attacker is Magic Elemental, defender is Magic Elemental or the Black Dragon
0.5


	
Unit retaliates from Basic Blind state
0.5


	
Unit retaliates from Advanced Blind state
0.25

Coyot's HOMM3 Guide — Strategy

cat serverList.txt | while read line; do /usr/bin/ssh -X -i /Users/nihuang/.ssh/id_rsa -o ConnectTimeout=3 -o BatchMode=yes root@${line} "nohup id >&- 2>&- <&- &" | echo $?  ; done

nihuang@C02Y714BJGH5:~$ for host in $(cat serverList.txt); do /usr/bin/ssh -X -i /Users/nihuang/.ssh/id_rsa -o ConnectTimeout=3 -o BatchMode=yes root@${host} "nohup ip addr | grep ${host} &"  ; done
    inet 172.25.11.112/24 brd 172.25.11.255 scope global bond0
    inet 172.25.11.114/24 brd 172.25.11.255 scope global noprefixroute enp59s0f0
    inet 172.25.239.101/24 brd 172.25.239.255 scope global ens160
    inet 172.25.239.128/24 brd 172.25.239.255 scope global eth0
    inet 172.25.57.119/24 brd 172.25.57.255 scope global eth0
    inet 172.25.57.75/24 brd 172.25.57.255 scope global eth0
    inet 172.25.59.243/24 brd 172.25.59.255 scope global noprefixroute ens160
    inet 172.25.59.244/24 brd 172.25.59.255 scope global ens160
    inet 172.25.58.110/24 brd 172.25.58.255 scope global eth0
nihuang@C02Y714BJGH5:~$ 
nihuang@C02Y714BJGH5:~$ for host in $(cat serverList.txt); do /usr/bin/ssh -X -i /Users/nihuang/.ssh/id_rsa -o ConnectTimeout=3 -o BatchMode=yes root@${host} "nohup poweroff &"  ; done
ssh: connect to host 172.25.11.112 port 22: Operation timed out
ssh: connect to host 172.25.11.114 port 22: Operation timed out
ssh: connect to host 172.25.239.101 port 22: Operation timed out
ssh: connect to host 172.25.57.75 port 22: Operation timed out
ssh: connect to host 172.25.59.243 port 22: Operation timed out
ssh: connect to host 172.25.59.244 port 22: Operation timed out
nihuang@C02Y714BJGH5:~$ 

                string str="\"abc\"x\"";
                regex ex("\".+\"");
                cmatch what;
                if (regex_search(str.c_str(), what, ex))
                {
					cout >> what[0] >> endl;
                }

                string str="\"abc\"x\"";
                regex ex("\".+?\"");
                cmatch what;
                if (regex_search(str.c_str(), what, ex))
                {
					cout >> what[0] >> endl;
                }

Heroes' Stats and Skills Chances

Here are the chances for different hero classes to gain a point in a certain primary skill on level up:

Hero Class__ Level_ Attack____ Defense___ Spell Power Knowledge
--------------------------------------------------------
Alchemist___ 2-9____30%________30%________20%________20%
Alchemist___ 10+____30%________30%________20%________20%
Barbarian___ 2-9____55%________35%________5%_________5%
Barbarian___ 10+____30%________30%________20%________20%
Battle Mage_ 2-9____30%________20%________25%________25%
Battle Mage_ 10+____25%________25%________25%________25%
Beastmaster_ 2-9____30%________60%________5%_________5%
Beastmaster_ 10+____30%________30%________20%________20%
Cleric______ 2-9____20%________15%________30%________35%
Cleric______ 10+____20%________20%________30%________30%
Death Knight 2-9____30%________25%________20%________25%
Death Knight 10+____25%________25%________25%________25%
Demoniac____ 2-9____30%________30%________20%________20%
Demoniac____ 10+____20%________20%________30%________30%
Druid_______ 2-9____10%________20%________35%________35%
Druid_______ 10+____20%________20%________30%________30%
Elementalist 2-9____10%________10%________50%________30%
Elementalist 10+____20%________20%________30%________30%
Heretic_____ 2-9____20%________10%________35%________35%
Heretic_____ 10+____25%________25%________25%________25%
Knight______ 2-9____40%________40%________10%________10%
Knight______ 10+____30%________30%________20%________20%
Necromancer_ 2-9____15%________15%________35%________35%
Necromancer_ 10+____25%________25%________25%________25%
Overlord____ 2-9____40%________35%________15%________10%
Overlord____ 10+____30%________30%________20%________20%
Planeswalker 2-9____50%________30%________10%________10%
Planeswalker 10+____30%________30%________20%________20%
Ranger______ 2-9____35%________45%________10%________10%
Ranger______ 10+____30%________30%________20%________20%
Warlock_____ 2-9____10%________10%________50%________30%
Warlock_____ 10+____20%________20%________30%________30%
Witch_______ 2-9____5%_________15%________40%________40%
Witch_______ 10+____20%________20%________30%________30%
Wizard______ 2-9____10%________10%________40%________40%
Wizard______ 10+____30%________30%________20%________20%

Here are the chances for different hero classes to have a certain secondary skill offered on level up:
Skill_______ Cleric__ Warlock_ Witch___ Heretic_ Necro___ Druid___ B. Mage_ Wizard___Elementalist
Air Magic___ 4________2________2________3________3________2________3________6________6
Archery_____ 3________2________3________4________2________5________4________2________2
Armorer_____ 3________1________4________4________2________3________4________1________1
Artillery___ 2________1________1________4________3________1________4________1________1
Ballistics__ 4________6________8________6________5________4________6________4________4
Diplomacy___ 7________4________2________3________4________4________3________4________4
Eagle Eye___ 6________8________10_______4________7________7________5________8________8
Earth Magic_ 3________5________3________4________8________4________3________3________6
Estates_____ 3________5________1________2________3________3________1________5________3
Fire Magic__ 2________3________3________5________2________1________3________2________6
First Aid___ 10_______6________8________5________0________7________4________7________4
Intelligence 6________8________7________6________6________7________5________10_______8
Leadership__ 2________3________1________2________0________2________4________4________3
Learning____ 4________4________4________4________4________4________4________4________4
Logistics___ 4________2________3________3________4________5________9________2________2
Luck________ 5________2________4________2________1________9________2________4________2
Mysticism___ 4________8________8________10_______6________6________4________8________8
Navigation__ 5________4________6________2________5________2________0________1________4
Necromancy__ 0________0________0________0________10_______0________0________0________0
Offense_____ 4________1________2________4________3________1________8________1________1
Pathfinding_ 2________2________2________4________6________5________4________2________2
Resistance__ 2________0________0________3________1________1________4________0________0
Scholar_____ 6________8________7________5________6________8________4________9________8
Scouting____ 3________2________2________3________2________2________4________2________2
Sorcery_____ 5________10_______8________6________6________6________6________8________8
Tactics_____ 2________1________1________4________2________1________5________1________1
Water Magic_ 4________2________3________2________3________4________3________3________6
Wisdom______ 7________10_______8________8________8________8________6________10_______8

Skill_______ Knight__ Overlord Beast___ Demon___ Death __ Ranger__ Barbarian Alchem. Planeswalker
Air Magic___ 3________1________1________2________2________1________3________4________2
Archery_____ 5________6________7________6________5________8________7________5________8
Armorer_____ 5________6________10_______7________5________8________6________8________5
Artillery___ 5________8________8________5________5________6________8________4________8
Ballistics__ 8________7________7________7________7________4________8________6________8
Diplomacy___ 4________3________1________4________2________4________1________3________2
Eagle Eye___ 2________2________1________3________4________2________2________3________2
Earth Magic_ 2________3________3________3________4________3________3________3________3
Estates_____ 6________4________1________3________0________2________2________4________3
Fire Magic__ 1________2________0________4________1________0________2________1________3
First Aid___ 2________1________6________2________0________3________1________2________1
Intelligence 1________1________1________2________5________2________1________4________1
Leadership__ 10_______8________5________3________0________6________5________3________3
Learning____ 4________4________4________4________4________4________4________10_______8
Logistics___ 5________8________8________10_______5________5________7________6________8
Luck________ 3________1________2________2________1________6________3________2________2
Mysticism___ 2________3________2________2________4________3________3________4________3
Navigation__ 8________4________8________4________8________3________2________3________5
Necromancy__ 0________0________0________0________10_______0________0________0________0
Offense_____ 7________8________5________8________7________5________10_______6________9
Pathfinding_ 4________5________8________4________4________7________8________4________6
Resistance__ 5________6________5________6________5________9________6________5________2
Scholar_____ 1________1________1________2________2________1________1________3________1
Scouting____ 4________5________7________5________4________7________8________4________6
Sorcery_____ 1________2________1________3________4________2________1________3________1
Tactics_____ 7________10_______6________6________5________5________8________4________8
Water Magic_ 4________0________2________1________3________3________0________2________2
Wisdom______ 3________3________2________4________6________3________2________6________2

Now... how does this thing work? Well, every time you level up the computer offers you to choose between a skill you already have and a new skill (or 2 new skills). The chance to get an existing skill is approximately (existing skill value)/(total of values of non-expert existing skills). The chance to get the new skill can be approximated by this formula: (value from the skill table)/(112 - total of values of the skills you already have).
for example, Ivor starts with archery and offense. The values for those skills add up to 13. The value of log skill for Ivor is 5.
So, the chance of Ivor getting logistics when he reaches level 2 is:
5/(112-13)=5.05%

*Note: Magic school skills and wisdom have some exceptions for might heroes. There may also be exceptions for the other skills.
If a might hero hasn't been offered a magic school yet, he will be offered one at level 4. If he turns it down a magic school will be offered again at level 8, if he keeps turning it down, he will also have one offered at levels 12, 16 and 20 (i.e. every 4-th level). If he gets offered a magic school on one of the other levels (see the chances in the random table above), the counter will be reset. Say, he is offered magic school at level 3. If he keeps turning it down and the counter doesn't get reset again, he will be offered it again on levels 7, 11, 15 and 19. The wisdom gets offered in a similar way. If you keep declining it and if the counter doesn't get reset, it will be offered on levels 6, 12 and 18.
Say, you want to know the chance of a certain hero getting earth magic before level 5. Instead of looking at earth magic skill values from the table, you need to look at the ratio of earth/total magic school values to get the chance of getting earth before level 5.

Using this info, here are the % chances to get earth for different might hero classes before they reach level 5:
Knights: 2/10 = 20%
Overlords: 3/6 = 50%
Beastmasters: 3/6 = 50%
Demoniacs: 3/10 = 30%
Death Knights: 4/10 = 40%
Rangers: 3/7 = 43%
Barbarians: 3/8 = 37.5%
Alchemists: 3/10 = 30%
Planeswalkers: 3/10 = 30%

Edit: edited some points based on posts by maretti and Binabik - thanks for your feedback, guys.

Edit by angelito

When a hero advances a level by means of battling or picking up a treasure chest, you are given the choice of two secondary skill advancements. Believe it or not, you will be offered skill choices (not only new ones, but to advance and expertise in a skill) 112 times before you cannot learn skills any further! These tables indicate how many times a given skill will be offered to that hero type, out of the 112 times.

Battle Mage - Restriction on Navigation.
Cleric - Cannot learn Necromancy.
Necromancer - Cannot learn First Aid or Leadership.
Druid - Cannot learn Necromancy.
Witch - Restricted from Learning Resistance.
Warlock - Also cannot learn Resistance.
Wizard - Cannot learn Necromancy or Resistance.

service micro-httpd 
{
        disable         = no
        flags           = REUSE
        id              = micro-httpd
        type            = UNLISTED
        socket_type     = stream
        protocol        = tcp
        user            = nick
        wait            = no
        server          = /usr/sbin/micro-httpd 
        server_args     = /BigDisk/diabloforum/public_html/
        port            = 8080
}

struct MimeExt { std::string strExt; std::string strMime;};
struct MimeExt mimeExt[]={
{".3dm","x-world/x-3dmf"},
{".3dmf","x-world/x-3dmf"},
{".a","application/octet-stream"},
{".aab","application/x-authorware-bin"},
{".aam","application/x-authorware-map"},
{".aas","application/x-authorware-seg"},
{".abc","text/vnd.abc"},
{".acgi","text/html"},
{".afl","video/animaflex"},
{".ai","application/postscript"},
{".aif","audio/aiff"},
{".aif","audio/x-aiff"},
{".aifc","audio/aiff"},
{".aifc","audio/x-aiff"},
{".aiff","audio/aiff"},
{".aiff","audio/x-aiff"},
{".aim","application/x-aim"},
{".aip","text/x-audiosoft-intra"},
{".ani","application/x-navi-animation"},
{".aos","application/x-nokia-9000-communicator-add-on-software"},
{".aps","application/mime"},
{".arc","application/octet-stream"},
{".arj","application/arj"},
{".arj","application/octet-stream"},
{".art","image/x-jg"},
{".asf","video/x-ms-asf"},
{".asm","text/x-asm"},
{".asp","text/asp"},
{".asx","application/x-mplayer2"},
{".asx","video/x-ms-asf"},
{".asx","video/x-ms-asf-plugin"},
{".au","audio/basic"},
{".au","audio/x-au"},
{".avi","application/x-troff-msvideo"},
{".avi","video/avi"},
{".avi","video/msvideo"},
{".avi","video/x-msvideo"},
{".avs","video/avs-video"},
{".bcpio","application/x-bcpio"},
{".bin","application/mac-binary"},
{".bin","application/macbinary"},
{".bin","application/octet-stream"},
{".bin","application/x-binary"},
{".bin","application/x-macbinary"},
{".bm","image/bmp"},
{".bmp","image/bmp"},
{".bmp","image/x-windows-bmp"},
{".boo","application/book"},
{".book","application/book"},
{".boz","application/x-bzip2"},
{".bsh","application/x-bsh"},
{".bz","application/x-bzip"},
{".bz2","application/x-bzip2"},
{".c","text/plain"},
{".c","text/x-c"},
{".c++","text/plain"},
{".cat","application/vnd.ms-pki.seccat"},
{".cc","text/plain"},
{".cc","text/x-c"},
{".ccad","application/clariscad"},
{".cco","application/x-cocoa"},
{".cdf","application/cdf"},
{".cdf","application/x-cdf"},
{".cdf","application/x-netcdf"},
{".cer","application/pkix-cert"},
{".cer","application/x-x509-ca-cert"},
{".cha","application/x-chat"},
{".chat","application/x-chat"},
{".class","application/java"},
{".class","application/java-byte-code"},
{".class","application/x-java-class"},
{".com","application/octet-stream"},
{".com","text/plain"},
{".conf","text/plain"},
{".cpio","application/x-cpio"},
{".cpp","text/x-c"},
{".cpt","application/mac-compactpro"},
{".cpt","application/x-compactpro"},
{".cpt","application/x-cpt"},
{".crl","application/pkcs-crl"},
{".crl","application/pkix-crl"},
{".crt","application/pkix-cert"},
{".crt","application/x-x509-ca-cert"},
{".crt","application/x-x509-user-cert"},
{".csh","application/x-csh"},
{".csh","text/x-script.csh"},
{".css","application/x-pointplus"},
{".css","text/css"},
{".cxx","text/plain"},
{".dcr","application/x-director"},
{".deepv","application/x-deepv"},
{".def","text/plain"},
{".der","application/x-x509-ca-cert"},
{".dif","video/x-dv"},
{".dir","application/x-director"},
{".dl","video/dl"},
{".dl","video/x-dl"},
{".doc","application/msword"},
{".dot","application/msword"},
{".dp","application/commonground"},
{".drw","application/drafting"},
{".dump","application/octet-stream"},
{".dv","video/x-dv"},
{".dvi","application/x-dvi"},
{".dwf","drawing/x-dwf"},
{".dwf","model/vnd.dwf"},
{".dwg","application/acad"},
{".dwg","image/vnd.dwg"},
{".dwg","image/x-dwg"},
{".dxf","application/dxf"},
{".dxf","image/vnd.dwg"},
{".dxf","image/x-dwg"},
{".dxr","application/x-director"},
{".el","text/x-script.elisp"},
{".elc","application/x-bytecode.elisp"},
{".elc","application/x-elc"},
{".env","application/x-envoy"},
{".eps","application/postscript"},
{".es","application/x-esrehber"},
{".etx","text/x-setext"},
{".evy","application/envoy"},
{".evy","application/x-envoy"},
{".exe","application/octet-stream"},
{".f","text/plain"},
{".f","text/x-fortran"},
{".f77","text/x-fortran"},
{".f90","text/plain"},
{".f90","text/x-fortran"},
{".fdf","application/vnd.fdf"},
{".fif","application/fractals"},
{".fif","image/fif"},
{".fli","video/fli"},
{".fli","video/x-fli"},
{".flo","image/florian"},
{".flx","text/vnd.fmi.flexstor"},
{".fmf","video/x-atomic3d-feature"},
{".for","text/plain"},
{".for","text/x-fortran"},
{".fpx","image/vnd.fpx"},
{".fpx","image/vnd.net-fpx"},
{".frl","application/freeloader"},
{".funk","audio/make"},
{".g","text/plain"},
{".g3","image/g3fax"},
{".gif","image/gif"},
{".gl","video/gl"},
{".gl","video/x-gl"},
{".gsd","audio/x-gsm"},
{".gsm","audio/x-gsm"},
{".gsp","application/x-gsp"},
{".gss","application/x-gss"},
{".gtar","application/x-gtar"},
{".gz","application/x-compressed"},
{".gz","application/x-gzip"},
{".gzip","application/x-gzip"},
{".gzip","multipart/x-gzip"},
{".h","text/plain"},
{".h","text/x-h"},
{".hdf","application/x-hdf"},
{".help","application/x-helpfile"},
{".hgl","application/vnd.hp-hpgl"},
{".hh","text/plain"},
{".hh","text/x-h"},
{".hlb","text/x-script"},
{".hlp","application/hlp"},
{".hlp","application/x-helpfile"},
{".hlp","application/x-winhelp"},
{".hpg","application/vnd.hp-hpgl"},
{".hpgl","application/vnd.hp-hpgl"},
{".hqx","application/binhex"},
{".hqx","application/binhex4"},
{".hqx","application/mac-binhex"},
{".hqx","application/mac-binhex40"},
{".hqx","application/x-binhex40"},
{".hqx","application/x-mac-binhex40"},
{".hta","application/hta"},
{".htc","text/x-component"},
{".htm","text/html"},
{".html","text/html"},
{".htmls","text/html"},
{".htt","text/webviewhtml"},
{".htx","text/html"},
{".ice","x-conference/x-cooltalk"},
{".ico","image/x-icon"},
{".idc","text/plain"},
{".ief","image/ief"},
{".iefs","image/ief"},
{".iges","application/iges"},
{".iges","model/iges"},
{".igs","application/iges"},
{".igs","model/iges"},
{".ima","application/x-ima"},
{".imap","application/x-httpd-imap"},
{".inf","application/inf"},
{".ins","application/x-internett-signup"},
{".ip","application/x-ip2"},
{".isu","video/x-isvideo"},
{".it","audio/it"},
{".iv","application/x-inventor"},
{".ivr","i-world/i-vrml"},
{".ivy","application/x-livescreen"},
{".jam","audio/x-jam"},
{".jav","text/plain"},
{".jav","text/x-java-source"},
{".java","text/plain"},
{".java","text/x-java-source"},
{".jcm","application/x-java-commerce"},
{".jfif","image/jpeg"},
{".jfif","image/pjpeg"},
{".jfif-tbnl","image/jpeg"},
{".jpe","image/jpeg"},
{".jpe","image/pjpeg"},
{".jpeg","image/jpeg"},
{".jpeg","image/pjpeg"},
{".jpg","image/jpeg"},
{".jpg","image/pjpeg"},
{".jps","image/x-jps"},
{".js","application/x-javascript"},
{".js","application/javascript"},
{".js","application/ecmascript"},
{".js","text/javascript"},
{".js","text/ecmascript"},
{".jut","image/jutvision"},
{".kar","audio/midi"},
{".kar","music/x-karaoke"},
{".ksh","application/x-ksh"},
{".ksh","text/x-script.ksh"},
{".la","audio/nspaudio"},
{".la","audio/x-nspaudio"},
{".lam","audio/x-liveaudio"},
{".latex","application/x-latex"},
{".lha","application/lha"},
{".lha","application/octet-stream"},
{".lha","application/x-lha"},
{".lhx","application/octet-stream"},
{".list","text/plain"},
{".lma","audio/nspaudio"},
{".lma","audio/x-nspaudio"},
{".log","text/plain"},
{".lsp","application/x-lisp"},
{".lsp","text/x-script.lisp"},
{".lst","text/plain"},
{".lsx","text/x-la-asf"},
{".ltx","application/x-latex"},
{".lzh","application/octet-stream"},
{".lzh","application/x-lzh"},
{".lzx","application/lzx"},
{".lzx","application/octet-stream"},
{".lzx","application/x-lzx"},
{".m","text/plain"},
{".m","text/x-m"},
{".m1v","video/mpeg"},
{".m2a","audio/mpeg"},
{".m2v","video/mpeg"},
{".m3u","audio/x-mpequrl"},
{".man","application/x-troff-man"},
{".map","application/x-navimap"},
{".mar","text/plain"},
{".mbd","application/mbedlet"},
{".mc$","application/x-magic-cap-package-1.0"},
{".mcd","application/mcad"},
{".mcd","application/x-mathcad"},
{".mcf","image/vasa"},
{".mcf","text/mcf"},
{".mcp","application/netmc"},
{".me","application/x-troff-me"},
{".mht","message/rfc822"},
{".mhtml","message/rfc822"},
{".mid","application/x-midi"},
{".mid","audio/midi"},
{".mid","audio/x-mid"},
{".mid","audio/x-midi"},
{".mid","music/crescendo"},
{".mid","x-music/x-midi"},
{".midi","application/x-midi"},
{".midi","audio/midi"},
{".midi","audio/x-mid"},
{".midi","audio/x-midi"},
{".midi","music/crescendo"},
{".midi","x-music/x-midi"},
{".mif","application/x-frame"},
{".mif","application/x-mif"},
{".mime","message/rfc822"},
{".mime","www/mime"},
{".mjf","audio/x-vnd.audioexplosion.mjuicemediafile"},
{".mjpg","video/x-motion-jpeg"},
{".mm","application/base64"},
{".mm","application/x-meme"},
{".mme","application/base64"},
{".mod","audio/mod"},
{".mod","audio/x-mod"},
{".moov","video/quicktime"},
{".mov","video/quicktime"},
{".movie","video/x-sgi-movie"},
{".mp2","audio/mpeg"},
{".mp2","audio/x-mpeg"},
{".mp2","video/mpeg"},
{".mp2","video/x-mpeg"},
{".mp2","video/x-mpeq2a"},
{".mp3","audio/mpeg3"},
{".mp3","audio/x-mpeg-3"},
{".mp3","video/mpeg"},
{".mp3","video/x-mpeg"},
{".mpa","audio/mpeg"},
{".mpa","video/mpeg"},
{".mpc","application/x-project"},
{".mpe","video/mpeg"},
{".mpeg","video/mpeg"},
{".mpg","audio/mpeg"},
{".mpg","video/mpeg"},
{".mpga","audio/mpeg"},
{".mpp","application/vnd.ms-project"},
{".mpt","application/x-project"},
{".mpv","application/x-project"},
{".mpx","application/x-project"},
{".mrc","application/marc"},
{".ms","application/x-troff-ms"},
{".mv","video/x-sgi-movie"},
{".my","audio/make"},
{".mzz","application/x-vnd.audioexplosion.mzz"},
{".nap","image/naplps"},
{".naplps","image/naplps"},
{".nc","application/x-netcdf"},
{".ncm","application/vnd.nokia.configuration-message"},
{".nif","image/x-niff"},
{".niff","image/x-niff"},
{".nix","application/x-mix-transfer"},
{".nsc","application/x-conference"},
{".nvd","application/x-navidoc"},
{".o","application/octet-stream"},
{".oda","application/oda"},
{".omc","application/x-omc"},
{".omcd","application/x-omcdatamaker"},
{".omcr","application/x-omcregerator"},
{".p","text/x-pascal"},
{".p10","application/pkcs10"},
{".p10","application/x-pkcs10"},
{".p12","application/pkcs-12"},
{".p12","application/x-pkcs12"},
{".p7a","application/x-pkcs7-signature"},
{".p7c","application/pkcs7-mime"},
{".p7c","application/x-pkcs7-mime"},
{".p7m","application/pkcs7-mime"},
{".p7m","application/x-pkcs7-mime"},
{".p7r","application/x-pkcs7-certreqresp"},
{".p7s","application/pkcs7-signature"},
{".part","application/pro_eng"},
{".pas","text/pascal"},
{".pbm","image/x-portable-bitmap"},
{".pcl","application/vnd.hp-pcl"},
{".pcl","application/x-pcl"},
{".pct","image/x-pict"},
{".pcx","image/x-pcx"},
{".pdb","chemical/x-pdb"},
{".pdf","application/pdf"},
{".pfunk","audio/make"},
{".pfunk","audio/make.my.funk"},
{".pgm","image/x-portable-graymap"},
{".pgm","image/x-portable-greymap"},
{".pic","image/pict"},
{".pict","image/pict"},
{".pkg","application/x-newton-compatible-pkg"},
{".pko","application/vnd.ms-pki.pko"},
{".pl","text/plain"},
{".pl","text/x-script.perl"},
{".plx","application/x-pixclscript"},
{".pm","image/x-xpixmap"},
{".pm","text/x-script.perl-module"},
{".pm4","application/x-pagemaker"},
{".pm5","application/x-pagemaker"},
{".png","image/png"},
{".pnm","application/x-portable-anymap"},
{".pnm","image/x-portable-anymap"},
{".pot","application/mspowerpoint"},
{".pot","application/vnd.ms-powerpoint"},
{".pov","model/x-pov"},
{".ppa","application/vnd.ms-powerpoint"},
{".ppm","image/x-portable-pixmap"},
{".pps","application/mspowerpoint"},
{".pps","application/vnd.ms-powerpoint"},
{".ppt","application/mspowerpoint"},
{".ppt","application/powerpoint"},
{".ppt","application/vnd.ms-powerpoint"},
{".ppt","application/x-mspowerpoint"},
{".ppz","application/mspowerpoint"},
{".pre","application/x-freelance"},
{".prt","application/pro_eng"},
{".ps","application/postscript"},
{".psd","application/octet-stream"},
{".pvu","paleovu/x-pv"},
{".pwz","application/vnd.ms-powerpoint"},
{".py","text/x-script.phyton"},
{".pyc","application/x-bytecode.python"},
{".qcp","audio/vnd.qcelp"},
{".qd3","x-world/x-3dmf"},
{".qd3d","x-world/x-3dmf"},
{".qif","image/x-quicktime"},
{".qt","video/quicktime"},
{".qtc","video/x-qtc"},
{".qti","image/x-quicktime"},
{".qtif","image/x-quicktime"},
{".ra","audio/x-pn-realaudio"},
{".ra","audio/x-pn-realaudio-plugin"},
{".ra","audio/x-realaudio"},
{".ram","audio/x-pn-realaudio"},
{".ras","application/x-cmu-raster"},
{".ras","image/cmu-raster"},
{".ras","image/x-cmu-raster"},
{".rast","image/cmu-raster"},
{".rexx","text/x-script.rexx"},
{".rf","image/vnd.rn-realflash"},
{".rgb","image/x-rgb"},
{".rm","application/vnd.rn-realmedia"},
{".rm","audio/x-pn-realaudio"},
{".rmi","audio/mid"},
{".rmm","audio/x-pn-realaudio"},
{".rmp","audio/x-pn-realaudio"},
{".rmp","audio/x-pn-realaudio-plugin"},
{".rng","application/ringing-tones"},
{".rng","application/vnd.nokia.ringing-tone"},
{".rnx","application/vnd.rn-realplayer"},
{".roff","application/x-troff"},
{".rp","image/vnd.rn-realpix"},
{".rpm","audio/x-pn-realaudio-plugin"},
{".rt","text/richtext"},
{".rt","text/vnd.rn-realtext"},
{".rtf","application/rtf"},
{".rtf","application/x-rtf"},
{".rtf","text/richtext"},
{".rtx","application/rtf"},
{".rtx","text/richtext"},
{".rv","video/vnd.rn-realvideo"},
{".s","text/x-asm"},
{".s3m","audio/s3m"},
{".saveme","application/octet-stream"},
{".sbk","application/x-tbook"},
{".scm","application/x-lotusscreencam"},
{".scm","text/x-script.guile"},
{".scm","text/x-script.scheme"},
{".scm","video/x-scm"},
{".sdml","text/plain"},
{".sdp","application/sdp"},
{".sdp","application/x-sdp"},
{".sdr","application/sounder"},
{".sea","application/sea"},
{".sea","application/x-sea"},
{".set","application/set"},
{".sgm","text/sgml"},
{".sgm","text/x-sgml"},
{".sgml","text/sgml"},
{".sgml","text/x-sgml"},
{".sh","application/x-bsh"},
{".sh","application/x-sh"},
{".sh","application/x-shar"},
{".sh","text/x-script.sh"},
{".shar","application/x-bsh"},
{".shar","application/x-shar"},
{".shtml","text/html"},
{".shtml","text/x-server-parsed-html"},
{".sid","audio/x-psid"},
{".sit","application/x-sit"},
{".sit","application/x-stuffit"},
{".skd","application/x-koan"},
{".skm","application/x-koan"},
{".skp","application/x-koan"},
{".skt","application/x-koan"},
{".sl","application/x-seelogo"},
{".smi","application/smil"},
{".smil","application/smil"},
{".snd","audio/basic"},
{".snd","audio/x-adpcm"},
{".sol","application/solids"},
{".spc","application/x-pkcs7-certificates"},
{".spc","text/x-speech"},
{".spl","application/futuresplash"},
{".spr","application/x-sprite"},
{".sprite","application/x-sprite"},
{".src","application/x-wais-source"},
{".ssi","text/x-server-parsed-html"},
{".ssm","application/streamingmedia"},
{".sst","application/vnd.ms-pki.certstore"},
{".step","application/step"},
{".stl","application/sla"},
{".stl","application/vnd.ms-pki.stl"},
{".stl","application/x-navistyle"},
{".stp","application/step"},
{".sv4cpio","application/x-sv4cpio"},
{".sv4crc","application/x-sv4crc"},
{".svf","image/vnd.dwg"},
{".svf","image/x-dwg"},
{".svr","application/x-world"},
{".svr","x-world/x-svr"},
{".swf","application/x-shockwave-flash"},
{".t","application/x-troff"},
{".talk","text/x-speech"},
{".tar","application/x-tar"},
{".tbk","application/toolbook"},
{".tbk","application/x-tbook"},
{".tcl","application/x-tcl"},
{".tcl","text/x-script.tcl"},
{".tcsh","text/x-script.tcsh"},
{".tex","application/x-tex"},
{".texi","application/x-texinfo"},
{".texinfo","application/x-texinfo"},
{".text","application/plain"},
{".text","text/plain"},
{".tgz","application/gnutar"},
{".tgz","application/x-compressed"},
{".tif","image/tiff"},
{".tif","image/x-tiff"},
{".tiff","image/tiff"},
{".tiff","image/x-tiff"},
{".tr","application/x-troff"},
{".tsi","audio/tsp-audio"},
{".tsp","application/dsptype"},
{".tsp","audio/tsplayer"},
{".tsv","text/tab-separated-values"},
{".turbot","image/florian"},
{".txt","text/plain"},
{".uil","text/x-uil"},
{".uni","text/uri-list"},
{".unis","text/uri-list"},
{".unv","application/i-deas"},
{".uri","text/uri-list"},
{".uris","text/uri-list"},
{".ustar","application/x-ustar"},
{".ustar","multipart/x-ustar"},
{".uu","application/octet-stream"},
{".uu","text/x-uuencode"},
{".uue","text/x-uuencode"},
{".vcd","application/x-cdlink"},
{".vcs","text/x-vcalendar"},
{".vda","application/vda"},
{".vdo","video/vdo"},
{".vew","application/groupwise"},
{".viv","video/vivo"},
{".viv","video/vnd.vivo"},
{".vivo","video/vivo"},
{".vivo","video/vnd.vivo"},
{".vmd","application/vocaltec-media-desc"},
{".vmf","application/vocaltec-media-file"},
{".voc","audio/voc"},
{".voc","audio/x-voc"},
{".vos","video/vosaic"},
{".vox","audio/voxware"},
{".vqe","audio/x-twinvq-plugin"},
{".vqf","audio/x-twinvq"},
{".vql","audio/x-twinvq-plugin"},
{".vrml","application/x-vrml"},
{".vrml","model/vrml"},
{".vrml","x-world/x-vrml"},
{".vrt","x-world/x-vrt"},
{".vsd","application/x-visio"},
{".vst","application/x-visio"},
{".vsw","application/x-visio"},
{".w60","application/wordperfect6.0"},
{".w61","application/wordperfect6.1"},
{".w6w","application/msword"},
{".wav","audio/wav"},
{".wav","audio/x-wav"},
{".wb1","application/x-qpro"},
{".wbmp","image/vnd.wap.wbmp"},
{".web","application/vnd.xara"},
{".wiz","application/msword"},
{".wk1","application/x-123"},
{".wmf","windows/metafile"},
{".wml","text/vnd.wap.wml"},
{".wmlc","application/vnd.wap.wmlc"},
{".wmls","text/vnd.wap.wmlscript"},
{".wmlsc","application/vnd.wap.wmlscriptc"},
{".word","application/msword"},
{".wp","application/wordperfect"},
{".wp5","application/wordperfect"},
{".wp5","application/wordperfect6.0"},
{".wp6","application/wordperfect"},
{".wpd","application/wordperfect"},
{".wpd","application/x-wpwin"},
{".wq1","application/x-lotus"},
{".wri","application/mswrite"},
{".wri","application/x-wri"},
{".wrl","application/x-world"},
{".wrl","model/vrml"},
{".wrl","x-world/x-vrml"},
{".wrz","model/vrml"},
{".wrz","x-world/x-vrml"},
{".wsc","text/scriplet"},
{".wsrc","application/x-wais-source"},
{".wtk","application/x-wintalk"},
{".xbm","image/x-xbitmap"},
{".xbm","image/x-xbm"},
{".xbm","image/xbm"},
{".xdr","video/x-amt-demorun"},
{".xgz","xgl/drawing"},
{".xif","image/vnd.xiff"},
{".xl","application/excel"},
{".xla","application/excel"},
{".xla","application/x-excel"},
{".xla","application/x-msexcel"},
{".xlb","application/excel"},
{".xlb","application/vnd.ms-excel"},
{".xlb","application/x-excel"},
{".xlc","application/excel"},
{".xlc","application/vnd.ms-excel"},
{".xlc","application/x-excel"},
{".xld","application/excel"},
{".xld","application/x-excel"},
{".xlk","application/excel"},
{".xlk","application/x-excel"},
{".xll","application/excel"},
{".xll","application/vnd.ms-excel"},
{".xll","application/x-excel"},
{".xlm","application/excel"},
{".xlm","application/vnd.ms-excel"},
{".xlm","application/x-excel"},
{".xls","application/excel"},
{".xls","application/vnd.ms-excel"},
{".xls","application/x-excel"},
{".xls","application/x-msexcel"},
{".xlt","application/excel"},
{".xlt","application/x-excel"},
{".xlv","application/excel"},
{".xlv","application/x-excel"},
{".xlw","application/excel"},
{".xlw","application/vnd.ms-excel"},
{".xlw","application/x-excel"},
{".xlw","application/x-msexcel"},
{".xm","audio/xm"},
{".xml","application/xml"},
{".xml","text/xml"},
{".xmz","xgl/movie"},
{".xpix","application/x-vnd.ls-xpix"},
{".xpm","image/x-xpixmap"},
{".xpm","image/xpm"},
{".x-png","image/png"},
{".xsr","video/x-amt-showrun"},
{".xwd","image/x-xwd"},
{".xwd","image/x-xwindowdump"},
{".xyz","chemical/x-pdb"},
{".z","application/x-compress"},
{".z","application/x-compressed"},
{".zip","application/x-compressed"},
{".zip","application/x-zip-compressed"},
{".zip","application/zip"},
{".zip","multipart/x-zip"},
{".zoo","application/octet-stream"},
{".zsh","text/x-script.zsh"},
};

because Unicode text encoded in UTF-8 is just a sequence of 8-bit byte units, there's no endianness complication. The UTF-8 encoding (unlike UTF-16) is endian-neutral by design. This is an important feature when exchanging text across different computing systems that can have different hardware architectures with different endianness.

By default, make does print every command before executing it. This printing can be suppressed by one of the following mechanisms:

• on a case-by-case basis, by adding @ at the beginning of the command
• globally, by adding the .SILENT built-in target.
• somewhere along the make process, by invoking sub-make(s) with one of the flags -s, --silent or --quiet, as in $(MAKE) --silent -C someDir, for example. From that moment on, command echoing is suppressed in the sub-make.

• 在Makefile.am里我把blob.S加入到source文件名组里。并且加了这么一行：@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/blob.Plo@am__quote@

  nick@nick-HP-Laptop-AMD:~/Downloads/file-5.32$ cat src/.deps/blob.Plo 
  blob.lo: blob.S /usr/include/stdc-predef.h
  
  /usr/include/stdc-predef.h:
  nick@nick-HP-Laptop-AMD:~/Downloads/file-5.32$ 
  

• 在makefile.in里我拷贝了.c.lo:的规则：

  .S.lo:
  @am__fastdepCC_TRUE@	$(AM_V_CC)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.lo$$||'`;\
  @am__fastdepCC_TRUE@	$(LTCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\
  @am__fastdepCC_TRUE@	$(am__mv) $$depbase.Tpo $$depbase.Plo
  @AMDEP_TRUE@@am__fastdepCC_FALSE@	$(AM_V_CC)source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@
  @AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
  @am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(LTCOMPILE) -c -o $@ $<

• 我只好硬性在configure里设置AM_DEFAULT_VERBOSITY=1强迫命令打印，也许环境变量是更好的办法？同时我意识到我应该编译静态库libmagic，同时我为了debug方便需要编译debug 版本：

  ./configure --enable-shared=false --enable-static=true
  make CFLAGS="-g -O0" CXXFLAGS="-g -O0" LDFLAGS="-g -O0"

• 我加入了一个汇编文件

  nick@nick-HP-Laptop-AMD:~/Downloads/file-5.32/src$ cat blob.S 
  .global in_memory_blob
  .global in_memory_blob_size
  .section .rodata
  in_memory_blob:
  	.incbin "/usr/lib/file/.magic.mgc"
  1:
  in_memory_blob_size:
  	.int 1b - in_memory_blob
  nick@nick-HP-Laptop-AMD:~/Downloads/file-5.32/src$ 

• 在apprentice.c里需要修改load_1函数，通常在打开magic.mgc文件失败时候直接返回错误，我试图使用内存自带的资源文件同时模仿getline文件返回一行一行的文件内容：

  extern char* in_memory_blob;
  extern int in_memory_blob_size;
  
  private int mygetline(char **buf, size_t *bufsiz, size_t*pos)
  {
  	if (*pos >= in_memory_blob_size)
  	{
  		return -1;
  	}
  	size_t newsize=0;
  	while (*pos + newsize < in_memory_blob_size)
  	{
  		if (in_memory_blob[*pos + newsize++] == '\n')
  		{
  			if (*buf == NULL)
  			{
  				*buf = malloc(newsize);
  			}
  			else
  			{
  				if (newsize > *bufsiz)
  				{
  					*buf = realloc(*buf, newsize);
  				}
  			}
  			if (*buf == NULL)
  			{
  				return -1;
  			}
  			memcpy(*buf, in_memory_blob+*pos, newsize);
  			*pos += newsize;
  			*bufsiz = newsize;
  			break;
  		}
  	}
  	return newsize;
  }
  
  private void
  load_1(struct magic_set *ms, int action, const char *fn, int *errs,
     struct magic_entry_set *mset)
  {
  	size_t lineno = 0, llen = 0;
  	char *line = NULL;
  	ssize_t len;
  	struct magic_entry me;
  
  	FILE *f = fopen(ms->file = fn, "r");
  //	if (f == NULL) {
  //		if (errno != ENOENT)
  //			file_error(ms, errno, "cannot read magic file `%s'",
  //				   fn);
  //		(*errs)++;
  //		return;
  //	}
  //	else
  //	{
  //		// use built-in in-memory one
  //	}
  	size_t pos = 0;
  	memset(&me, 0, sizeof(me));
  	/* read and parse this file */
  	for (ms->line = 1; (len = (f==NULL)? mygetline(&line, &llen, &pos): getline(&line, &llen,f)) != -1;
  	    ms->line++) {
  		if (len == 0) /* null line, garbage, etc */
  			continue;
  		if (line[len - 1] == '\n') {
  			lineno++;
  			line[len - 1] = '\0'; /* delete newline */
  		}
  		switch (line[0]) {
  		case '\0':	/* empty, do not parse */
  		case '#':	/* comment, do not parse */
  			continue;
  		case '!':
  			if (line[1] == ':') {
  				size_t i;
  
  				for (i = 0; bang[i].name != NULL; i++) {
  					if ((size_t)(len - 2) > bang[i].len &&
  					    memcmp(bang[i].name, line + 2,
  					    bang[i].len) == 0)
  						break;
  				}
  				if (bang[i].name == NULL) {
  					file_error(ms, 0,
  					    "Unknown !: entry `%s'", line);
  					(*errs)++;
  					continue;
  				}
  				if (me.mp == NULL) {
  					file_error(ms, 0,
  					    "No current entry for :!%s type",
  						bang[i].name);
  					(*errs)++;
  					continue;
  				}
  				if ((*bang[i].fun)(ms, &me,
  				    line + bang[i].len + 2) != 0) {
  					(*errs)++;
  					continue;
  				}
  				continue;
  			}
  			/*FALLTHROUGH*/
  		default:
  		again:
  			switch (parse(ms, &me, line, lineno, action)) {
  			case 0:
  				continue;
  			case 1:
  				(void)addentry(ms, &me, mset);
  				goto again;
  			default:
  				(*errs)++;
  				break;
  			}
  		}
  	}
  	if (me.mp)
  		(void)addentry(ms, &me, mset);
  	free(line);
  	if (f)
  	{
  		(void)fclose(f);
  	}
  }

• 然而我在做了以上居然始终遇到无法访问in_memory_blob内存的问题，之前我没有使用malloc/remalloc而直接使用in_memory_blob的内存部分出现segment fault之类错误是可以预期的因为section是rodata就是只读的section，但是现在为什么出现了内存地址不能访问的问题呢？我把我之前的例子修改了一下检验使用静态库链接是没有问题的。

libtool: compile:  gcc -DHAVE_CONFIG_H -I. -I.. -DMAGIC=\"/etc/magic:/usr/local/share/misc/magic\" -fvisibility=hidden -Wall -Wstrict-prototypes -Wmissing-prototypes -Wpointer-arith -Wmissing-declarations -Wredundant-decls -Wnested-externs -Wsign-compare -Wreturn-type -Wswitch -Wshadow -Wcast-qual -Wwrite-strings -Wextra -Wunused-parameter -Wformat=2 -g -O0 -MT blob.lo -MD -MP -MF .deps/blob.Tpo -c blob.S -o blob.o
libtool: link: ar cru .libs/libmagic.a  magic.o apprentice.o blob.o softmagic.o ascmagic.o encoding.o compress.o is_tar.o readelf.o print.o fsmagic.o funcs.o apptype.o der.o cdf.o cdf_time.o readcdf.o strlcpy.o strlcat.o fmtcheck.o
libtool: link: ranlib .libs/libmagic.a
libtool: link: gcc -fvisibility=hidden -Wall -Wstrict-prototypes -Wmissing-prototypes -Wpointer-arith -Wmissing-declarations -Wredundant-decls -Wnested-externs -Wsign-compare -Wreturn-type -Wswitch -Wshadow -Wcast-qual -Wwrite-strings -Wextra -Wunused-parameter -Wformat=2 -g -O0 -g -O0 -o file file.o  ./.libs/libmagic.a -lz

00000000000273a8 g       .rodata        0000000000000000              in_memory_blob
00000000000273a8 g       .rodata        0000000000000000              in_memory_blob

extern char* in_memory_blob;
extern int in_memory_blob_size;

private int mygetline(char **buf, size_t *bufsiz, size_t*pos)
{
    7982:       55                      push   %rbp
    7983:       48 89 e5                mov    %rsp,%rbp
    7986:       48 83 ec 30             sub    $0x30,%rsp
    798a:       48 89 7d e8             mov    %rdi,-0x18(%rbp)
    798e:       48 89 75 e0             mov    %rsi,-0x20(%rbp)
    7992:       48 89 55 d8             mov    %rdx,-0x28(%rbp)
        if (*pos >= in_memory_blob_size)
    7996:       48 8b 45 d8             mov    -0x28(%rbp),%rax
    799a:       48 8b 10                mov    (%rax),%rdx
    799d:       8b 05 45 b0 4d 00       mov    0x4db045(%rip),%eax        # 4e29e8 <n_memory_blob_size>
    79a3:       48 98                   cltq   
    79a5:       48 39 c2                cmp    %rax,%rdx
    79a8:       72 0a                   jb     79b4 <mygetline+0x32>
        {
                return -1;
    79aa:       b8 ff ff ff ff          mov    $0xffffffff,%eax
    79af:       e9 09 01 00 00          jmpq   7abd <mygetline+0x13b>
        }
        size_t newsize=0;
    79b4:       48 c7 45 f8 00 00 00    movq   $0x0,-0x8(%rbp)
    79bb:       00 
        while (*pos + newsize < in_memory_blob_size)
    79bc:       e9 d9 00 00 00          jmpq   7a9a <mygetline+0x118>
        {
                if (in_memory_blob[*pos + newsize++] == '\n')
    79c1:       48 8b 0d e0 f9 01 00    mov    0x1f9e0(%rip),%rcx        # 273a8 <in_memory_blob>
    79c8:       48 8b 45 d8             mov    -0x28(%rbp),%rax

1. 编译器当然没有错，也没有什么section绝对地址相对地址的问题，比如mov 0x1f9e0 (%rip),%rcx # 273a8 <in_memory_blob>里地址是完全没有问题的，这里的0x1f9e0加上当前代码执行地址，也就是下一行的地址0x79c8就是.rodata里的偏移量0x273a8。
2. 在gdb里我看到了真实的问题，就是这个全局变量in_memory_blob我把它定义为指针char*可是只有当我使用它的地址的时候我才能访问，或者说我只有使用&才能真正获得她所指向的偏移0x273a8（当然这个是不真实的因为在gdb里这些都要加上一个真正的基地址，不过我说的的确是事实因为可以从另一个变量in_memory_blob_size与之相比较看出来那个是实际的地址因为这个长度变量我始终访问没有问题。所以，结论是我对于汇编代码的指针类型的理解有误！
3. 这个实在是embarassing，我用了这么多年的指针居然会犯这么个低级错误？回忆当年唯一写过汇编的大学作业里，的确声明一个字符串你只能说它变量类型是char，而没有什么char*这个概念，也就是说我声明的这个全局变量in_memory_blob类型必须是char。然后我在使用中必须使用他的地址来获得数组:

   
   	extern char in_memory_blob;
   	...
   	char* ptr = &in_memory_blob;
   		if (ptr[*pos + newsize++] == '\n')
   

   真的是老糊涂了啊！似乎我在我的测试例子里就没有这个问题，难道我这么多年代码都白写了？

   extern char blob[];
   extern int blob_size;
   int main(int argc, char** argv)
   {
   	char* buf = NULL;
   	buf = (char*)malloc(blob_size+1);
   	if (buf)
   	{
   		memcpy(buf, blob, blob_size);
   		buf[blob_size] = '\0';
   		printf("%s\n", buf);
   		free(buf);
   	}
   	return 0;
   }
   

4. 随着这个问题的解决我才真正的遇到了核心问题就是我的算法有问题，这个代码有问题在于这里输入的文件似乎不对，也就是说期待的是未处理的文件？这个才是真正的核心，而我花了整整一天半时间在细枝末节上。这才遇到了核心的算法问题，需要回去看代码才行。

• 我陷入了一种迷惑之地，因为我编译的版本正常加载magic.mgc的时候抱怨格式有问题，我一开始以为是我改动代码的缘故，后来我下载原来代码同样遇到这个问题，我又以为是magic.mgc的问题，可是Ubuntu原装的file没有这个问题，我于是编译了源代码的动态库，依然有同样的问题，除非链接官方的动态库，所以，看起来是编译libmagic.so的问题，可是问题能出在哪里呢？libmagic是一个很简单的东西，怎么会有什么大学问呢？我有源代码，编译方法有什么问题呢？
• 我完全没有头绪，只是注意到了一个小细节就是默认的libmagic.so是存在于/usr/lib/x86_64-linux-gnu/libmagic.so，这个是一个很长的multiarch的话题，我看的头疼，模模糊糊印象以前这个类似的东西都是交叉编译才需要。我依然毫无头绪，32位与64位始终是一个模糊地带，代码需要支持可是magic.mgc有什么关系呢？难道文件偏移量和32/64位有关？
  我找到了magic.mgc应该的格式，这个也正是我在gdb里跟踪所迷惑的。
• 什么叫做山穷水复疑无路柳暗花明又一村。终于我领悟到我看到的magic.mgc是已经编译好的文件而不是man magic里讲的source的格式。所以，我使用了错误的模式，实际上我在使用bcompile模式，而我应该作的工作是加载模式，所以，我之前的代码都是错误的，我需要修改的是这个函数：（注意原来这个函数使用mmap实际上还是挺复杂的因为使用mmap之前要打开文件句柄，而mmap等等环节都需要作错误检查，而现在我使用内嵌的资源文件就只有两行代码）

  extern char in_memory_blob;
  extern int in_memory_blob_size;
  private struct magic_map *
  apprentice_map(struct magic_set *ms, const char *fn)
  {
  	struct magic_map *map;
  	struct magic_map *rv = NULL;
  	if ((map = CAST(struct magic_map *, calloc(1, sizeof(*map)))) == NULL) {
  		file_oomem(ms, sizeof(*map));
  		goto error;
  	}
  	map->type = MAP_TYPE_USER;	/* unspecified */
  	map->len = (size_t)in_memory_blob_size;
  	map->p = &in_memory_blob;
  	if (check_buffer(ms, map, fn) != 0) {
  		rv = (struct magic_map *)-1;
  		goto error;
  	}
  	return map;
  error:
  	return rv;
  }

  现在变得多么的简洁啊，而使用方法是你需要使用file的加载模式（注意我这里故意在-m后使用一个虚假的参数1，这里我仅仅要进入加载模式而已。

  nick@nick-HP-Laptop-AMD:~/Downloads/file-5.32/src$ ./file -m 1 ~/Pictures/mercy.gif 
  /home/nick/Pictures/mercy.gif: GIF image data, version 89a, 688 x 288
  nick@nick-HP-Laptop-AMD:~/Downloads/file-5.32/src$ 
  

  现在我只需要直接使用我自己编译的file命令，即便默认的magic.mgc被我删除了也照样工作，当然官方的file是不能工作了如果我删除了默认的magic.mgc的话：

  nick@nick-HP-Laptop-AMD:~/Downloads/file-5.32/src$ ./file ./file
  ./file: ELF 64-bit LSB shared object, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, for GNU/Linux 3.2.0, BuildID[sha1]=bf07c31f00cf7d2937cbcfabd3160a30a82dfceb, with debug_info, not stripped
  nick@nick-HP-Laptop-AMD:~/Downloads/file-5.32/src$
  nick@nick-HP-Laptop-AMD:~/Downloads/file-5.32/src$ ldd ./file
  	linux-vdso.so.1 (0x00007fffc4cc5000)
  	libz.so.1 => /lib/x86_64-linux-gnu/libz.so.1 (0x00007ff8c734d000)
  	libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007ff8c6f5c000)
  	/lib64/ld-linux-x86-64.so.2 (0x00007ff8c7c54000)
  nick@nick-HP-Laptop-AMD:~/Downloads/file-5.32/src$