network arplab finished

This commit is contained in:
2025-11-17 22:22:52 +08:00
parent ecb6ef0a65
commit 8d9c3ed7f6
411 changed files with 42460 additions and 1 deletions

Binary file not shown.

Binary file not shown.

BIN
network/arp/ARP响应.png Executable file

Binary file not shown.

After

Width:  |  Height:  |  Size: 406 KiB

BIN
network/arp/cmake编译运行.png Executable file

Binary file not shown.

After

Width:  |  Height:  |  Size: 82 KiB

154
network/arp/labtemplate.typ Executable file
View File

@ -0,0 +1,154 @@
#let times = "Times LT Pro"
#let times = "Times New Roman"
#let song = (times, "FZShuSong-Z01")
#let hei = (times, "FZHei-B01")
#let kai = (times, "FZKai-Z03")
#let xbsong = (times, "FZXiaoBiaoSong-B05")
#let fsong = (times, "FangSong_GB2312")
#let code = (times, "DejaVu Sans Mono")
#let nudtlabpaper(title: "",
author: "",
id: "",
training_type:"",
grade: "",
major: "",
department: "",
advisor: "",
jobtitle: "",
lab: "",
date: "",
header_str: "",
body) = {
// Set the document's basic properties.
set document(author: author, title: title)
set page(
margin: (left: 30mm, right: 30mm, top: 30mm, bottom: 30mm),
)
// Title row.
v(158pt)
align(center)[
#block(text(weight: 700, size: 30pt, font: hei, tracking: 15pt, "计算机网络"))
]
align(center)[
#block(text(weight: 700, size: 30pt, font: song, tracking: 15pt, "本科实验报告"))
]
v(103pt)
pad(
left: 1em,
right: 1em,
grid(
columns: (80pt, 1fr),
rows: (17pt, auto),
text(weight: 700, size: 16pt, font: song, "实验名称:"),
align(center, text(weight: "regular", size: 16pt, font: song, title)),
text(""),
line(length: 100%)
)
// #block(text(weight: 700, 1.75em, title))
// underline(text(weight: 700, size: 16pt, font: song, title))
)
// Author information.
v(82.5pt)
grid(
columns: (0.25fr, 0.25fr, 0.25fr, 0.25fr),
rows: (15pt, 8pt, 15pt, 8pt, 15pt, 8pt, 15pt, 8pt, 15pt),
text(size: 14pt, font: song, tracking: 10pt, "学员姓名"),
align(center, text(size: 14pt, font: song, author)),
text(size: 14pt, font: song, tracking: 54pt, "学号"),
align(center, text(size: 14pt, font: times, id)),
text(""),
line(length: 100%),
text(""),
line(length: 100%),
text(size: 14pt, font: song, tracking: 9pt, "培养类型"),
align(center, text(size: 14pt, font: song, training_type)),
text(size: 14pt, font: song, tracking: 54pt, "年级"),
align(center, text(size: 14pt, font: times, grade)),
text(""),
line(length: 100%),
text(""),
line(length: 100%),
text(size: 14pt, font: song, tracking: 54pt, "专业"),
align(center, text(size: 14pt, font: song, major)),
text(size: 14pt, font: song, tracking: 9pt, "所属学院"),
align(center, text(size: 14pt, font: song, department)),
text(""),
line(length: 100%),
text(""),
line(length: 100%),
text(size: 14pt, font: song, tracking: 9pt, "指导教员"),
align(center, text(size: 14pt, font: song, advisor)),
text(size: 14pt, font: song, tracking: 54pt, "职称"),
align(center, text(size: 14pt, font: song, jobtitle)),
text(""),
line(length: 100%),
text(""),
line(length: 100%),
text(size: 14pt, font: song, tracking: 20pt, "实验室"),
align(center, text(size: 14pt, font: song, lab)),
text(size: 14pt, font: song, tracking: 9pt, "实验时间"),
align(center, text(size: 14pt, font: song, date)),
text(""),
line(length: 100%),
text(""),
line(length: 100%),
)
v(50.5pt)
align(center, text(font: hei, size: 15pt, "国防科技大学教育训练部制"))
pagebreak()
set page(
margin: (left: 30mm, right: 30mm, top: 30mm, bottom: 30mm),
numbering: "i",
number-align: center,
)
v(14pt)
align(center)[
#block(text(font: hei, size: 14pt, "《本科实验报告》填写说明"))
]
v(14pt)
text("")
par(first-line-indent: 2em, text(font: song, size: 12pt, "实验报告内容编排应符合以下要求:"))
par(first-line-indent: 2em, text(font: fsong, size: 12pt, "1采用A421cm×29.7cm白色复印纸单面黑字。上下左右各侧的页边距均为3cm缺省文档网格字号为小4号中文为宋体英文和阿拉伯数字为Times New Roman每页30行每行36字页脚距边界为2.5cm页码置于页脚、居中采用小5号阿拉伯数字从1开始连续编排封面不编页码。"))
par(first-line-indent: 2em, text(font: fsong, size: 12pt, "2报告正文最多可设四级标题字体均为黑体第一级标题字号为4号其余各级标题为小4号标题序号第一级用“一、”、“二、”……第二级用“”、“” ……第三级用“1.”、“2.” ……第四级用“1”、“2” ……,分别按序连续编排。"))
par(first-line-indent: 2em, text(font: fsong, size: 12pt, "3正文插图、表格中的文字字号均为5号。"))
pagebreak()
set page(
margin: (left: 30mm, right: 30mm, top: 30mm, bottom: 30mm),
numbering: "1",
number-align: center,
)
set heading(numbering: "1.1")
// set text(font: hei, lang: "zh")
show heading: it => box(width: 100%)[
#v(0.50em)
#set text(font: hei)
#counter(heading).display()
// #h(0.5em)
#it.body
]
// Main body.
set par(justify: true)
body
}
#let para(t) = par(first-line-indent: 2em, text(font: song, size: 10.5pt, t))

BIN
network/arp/main.pdf Executable file

Binary file not shown.

523
network/arp/main.txt Executable file
View File

@ -0,0 +1,523 @@
#set page(header: [
#set par(spacing: 6pt)
#align(center)[#text(size: 11pt)[《计算机网络》实验报告]]
#v(-0.3em)
#line(length: 100%, stroke: (thickness: 1pt))
],)
#show heading: it => box(width: 100%)[
#v(0.50em)
#set text(font: hei)
#it.body
]
// #outline(title: "目录",depth: 3, indent: 1em)
// #outline(
// title: [图目录],
// target: figure.where(kind: image),
// )
#show heading: it => box(width: 100%)[
#v(0.50em)
#set text(font: hei)
#counter(heading).display()
// #h(0.5em)
#it.body
]
#set enum(indent: 0.5em,body-indent: 0.5em,)
#pagebreak()
// Display inline code in a small box
// that retains the correct baseline.
#show raw.where(block: false): box.with(
fill: luma(240),
inset: (x: 3pt, y: 0pt),
outset: (y: 3pt),
radius: 2pt,
)
// Display block code in a larger block
// with more padding.
#show raw.where(block: true): it => block(
text(font: ("Consolas","FangSong_GB2312"), it),
fill: luma(240),
inset: 10pt,
radius: 4pt,
width: 100%,
)
= 实验目的与要求
== 实验目的
== 实验要求
= 实验内容
= 实验原理
= 实验环境
== 实验背景
== 实验设备
#para[
#align(center)[#table(
columns: (auto, auto,auto),
rows:(2em,2em,3em),
inset: 10pt,
align: horizon+center,
table.header(
[*设备名称*], [*设备型号*], [*设备数量*]
),
"交换机", "华为S5735", "2",
"PC", "联想启天M410
Windows 10", "4",
)]
另有网线若干控制线2条。
]
= 实验步骤
== 环境配置
=== 虚拟机网络配置
#para[
安装Windows 10虚拟机并配置物理机和虚拟机的IP地址使其能够互相访问
- 物理机网卡IP地址配置为`192.168.254.1/24`
- 虚拟机IP地址配置为`192.168.254.3/24`。
#figure(image("物理机虚拟机IP配置.png",format: "png",width: 90%,fit: "stretch"),caption: "物理机与虚拟机IP配置")
配置好之后,在两边的命令行中分别使用`ping`命令测试是否能够互相访问。同时在物理机上开启Wireshark以过滤条件`icmp`进行抓包查看IP地址是否正确
#figure(image("环境配置ping测试.png",format: "png",width: 100%,fit: "stretch"),caption: "环境配置ping通测试")<figure2>
从@figure2 中可以看到物理机和虚拟机之间可以互相访问且Wireshark抓包显示IP地址正确。
]
=== 使用CMake运行项目
#para[
CMake配置较为简单。首先在开发工具中安装对应版本CMake插件。其次在终端中进入项目根目录在此使用```shell mkdir build```命令新建`build`文件夹并进入该文件夹。接下来使用CMake工具生成对应的Makefile文件```shell cmake -G"MinGW Makefiles" ..```。
然后再运行```shell make```命令编译项目,最后使用```shell xnet.exe```命令即可运行项目:
#figure(image("cmake编译运行.png",format: "png",width: 70%,fit: "stretch"),caption: "CMake配置")
其中MinGW是一个Windows下的GNU编译器套件可以在Windows下编译出Linux下的可执行文件。```shell cmake -G"MinGW Makefiles" ..```命令的作用是配置使用MinGW编译器。
至此,环境配置结束。
]
== 实现ARP协议
#para[
代码已经实现了最基础的以太网协议实现了以太网帧的封装和解封装。接下来在此基础上继续实现ARP协议。
]
=== 定义相关数据结构
#para[
在`xnet_tiny.h`中定义IP地址长度以及数据结构
```c
#define XNET_IPV4_ADDR_SIZE 4 // IP地址长度
// IP地址
typedef union _xipaddr_t {
uint8_t array[XNET_IPV4_ADDR_SIZE]; // 以数据形式存储的ip
uint32_t addr; // 32位的ip地址
}xipaddr_t;
```
该数据结构定义了IP地址的数据结构包括了IP地址的数组形式和32位的IP地址。
然后定义MAC地址的长度以及ARP表项的结构体
```c
#define XNET_MAC_ADDR_SIZE 6 // MAC地址长度
// ARP表项
typedef struct _xarp_entry_t {
xipaddr_t ipaddr; // ip地址
uint8_t macaddr[XNET_MAC_ADDR_SIZE]; // mac地址
uint8_t state; // 状态位
uint16_t tmo; // 当前超时
uint8_t retry_cnt; // 当前重试次数
}xarp_entry_t;
```
该结构体定义了ARP表项的数据结构包括了IP地址、MAC地址、状态位、超时时间和重试次数。
定义ARP表项的最大数量
```c
#define XARP_CFG_ENTRY_SIZE 6 // ARP表大小
```
随后,在`xnet_tiny.c`中将ARP表定义为全局变量并定义一个表项指针方便后续代码编写
```c
static xarp_entry_t arp_table[XARP_CFG_ENTRY_SIZE]; // ARP表
static xarp_entry_t* arp_entry; // ARP表项指针
```
]
=== ARP表初始化
#para[
接下来编写ARP表的初始化函数。首先在`xnet_tiny.h`中定义ARP表项的第一个状态
```c
#define XARP_ENTRY_FREE 0 // ARP表项空闲
```
然后在`xnet_tiny.c`中定义初始化函数```c void xarp_init(void)```
```c
// ARP初始化
void xarp_init(void) {
for (arp_entry = arp_table;
arp_entry < XARP_CFG_ENTRY_SIZE * sizeof(xarp_entry_t) + arp_table;
arp_entry = arp_entry + sizeof(xarp_entry_t))
{
arp_entry->state = XARP_ENTRY_FREE; // 此处用到了上面定义的状态
}
arp_entry = arp_table;
}
```
初始化函数```c void xarp_init(void)```是一个循环。首先将前面定义的全局表项指针指向ARP表的第一个表项循环结束条件为指针指向的表项的地址超过ARP表的最后一个表项的地址。循环会遍历ARP表中的所有表项将表项状态初始化为`XARP_STATE_FREE`。最后,函数会将表项指针指向第一个表项,避免其他初始化过程中可能的指针越界问题。
最后,在协议栈的初始化函数中添加```c xarp_init()```
```c
void xnet_init (void) {
ethernet_init(); // 初始化以太网
xarp_init(); // *初始化ARP
}
```
]
=== 定义ARP报文
#para[
接下来编写无回报ARP报文的相关函数所以需要先定义ARP报文结构以及它所用到的相关结构。
首先在`xnet_tiny.h`中定义ARP报文中的几个字段。可以靠Wireshark抓包分析来获取这些字段的值下面是一个示例展示通过抓包来获取```c XNET_PROTOCOL_IP = 0x0800```
#figure(table(
columns: (auto),
rows:(auto,auto),
inset: 10pt,
align: horizon+center,
figure(image("抓一个arp分析结构.png",format: "png",fit:"stretch",width: 100%),),
figure(image("分析结构2.png",format: "png",fit:"stretch",width: 100%),),
stroke: none,
),caption: "通过抓包分析来获取字段值",kind: image)
代码编写如下:
```c
#define XARP_HW_ETHER 0x1 // 硬件类型:以太网
#define XARP_REQUEST 0x1 // OpcodeARP请求包
#define XARP_REPLY 0x2 // OpcodeARP响应包
typedef enum _xnet_protocol_t {
XNET_PROTOCOL_ARP = 0x0806, // ARP协议
XNET_PROTOCOL_IP = 0x0800, // IPv4协议
XNET_PROTOCOL_ICMP = 1, // ICMP协议
}xnet_protocol_t;
```
然后定义ARP报文的数据结构
```c
typedef struct _xarp_packet_t {
uint16_t hw_type, pro_type; // 硬件类型和协议类型
uint8_t hw_len, pro_len; // 硬件地址长 + 协议地址长
uint16_t opcode; // 请求/响应
uint8_t sender_mac[XNET_MAC_ADDR_SIZE]; // 发送包硬件地址
uint8_t sender_ip[XNET_IPV4_ADDR_SIZE]; // 发送包协议地址
uint8_t target_mac[XNET_MAC_ADDR_SIZE]; // 接收方硬件地址
uint8_t target_ip[XNET_IPV4_ADDR_SIZE]; // 接收方协议地址
}xarp_packet_t;
```
然后,使用前面定义的```c union xipaddr_t```结构,在`xnet_tiny.h`和`xnet_tiny.c`中定义ARP报文发送函数需要用到的IP地址、组播MAC地址
```c
// xnet_tiny.h
#define XNET_CFG_NETIF_IP {192, 168, 254, 2} // 本项目模拟出的网卡的IP
// xnet_tiny.c
static const xipaddr_t netif_ipaddr = XNET_CFG_NETIF_IP;
static const uint8_t ether_broadcast[] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
```
至此定义ARP报文的数据结构结束。
]
=== ARP报文发送函数
#para[
下面编写ARP报文发送函数```c xarp_make_request(const xipaddr_t * ipaddr)```。
```c
/**
* 产生一个ARP请求请求网络指定ip地址的机器发回一个ARP响应
* @param ipaddr 请求的IP地址
* @return 请求结果
*/
xnet_err_t xarp_make_request(const xipaddr_t * ipaddr) {
xarp_packet_t* arp_packet;
xnet_packet_t * packet = xnet_alloc_for_send(sizeof(xarp_packet_t));
arp_packet = (xarp_packet_t *)packet->data;
arp_packet->hw_type = swap_order16(XARP_HW_ETHER); // 设置硬件类型为以太网
arp_packet->pro_type = swap_order16(XNET_PROTOCOL_IP); // 设置协议类型为IP
arp_packet->hw_len = XNET_MAC_ADDR_SIZE; // 设置硬件地址长度
arp_packet->pro_len = XNET_IPV4_ADDR_SIZE; // 设置协议地址长度
arp_packet->opcode = swap_order16(XARP_REQUEST); // 设置操作码为ARP请求
// 复制发送方MAC地址
memcpy(arp_packet->sender_mac, netif_mac, XNET_MAC_ADDR_SIZE);
// 复制发送方IP地址
memcpy(arp_packet->sender_ip, netif_ipaddr.array, XNET_IPV4_ADDR_SIZE);
// 目标MAC地址清零
memset(arp_packet->target_mac, 0, XNET_MAC_ADDR_SIZE);
// 复制目标IP地址
memcpy(arp_packet->target_ip, ipaddr->array, XNET_IPV4_ADDR_SIZE);
// 通过以太网发送ARP请求
return ethernet_out_to(XNET_PROTOCOL_ARP, ether_broadcast, packet);
}
```
这个函数的主要功能是生成并发送一个ARP请求报文以请求指定IP地址即函数的输入```c const xipaddr_t * ipaddr```的机器返回其MAC地址。函数的具体步骤如下
1. 分配一个用于发送的ARP数据包```c arp_packet```并将其数据段设置为ARP报文结构。
2. 设置ARP报文的各个字段包括硬件类型`hw_type`、协议类型`pro_type`、硬件地址长度`hw_len`、协议地址长度`pro_len`、操作码`opcode`(设置为`XARP_REQUEST`)等。
3. 复制发送方即本项目模拟出的网卡的MAC地址和IP地址到ARP报文中。
4. 将目标MAC地址字段清零并复制目标IP地址到ARP报文中。
5. 最后通过以太网发送该ARP请求报文返回发送结果状态码
]
=== 启动时的ARP请求
#para[
在以太网协议的初始化函数```c static xnet_err_t ethernet_init(void)```中添加一个ARP请求
```c
/**
* 以太网初始化
* @return 初始化结果
*/
static xnet_err_t ethernet_init (void) {
xnet_err_t err = xnet_driver_open(netif_mac);
if (err < 0) return err;
return xarp_make_request(&netif_ipaddr); // 发送ARP请求
}
```
这样当协议栈初始化时会发送一个ARP请求。
下面用Wireshark抓包来验证ARP请求是否发送成功。首先重新编译项目其次开启Wireshark抓包最后启动程序
#figure(image("启动ARP2.png",format: "png",width: 100%,fit: "stretch"),caption: "启动时的ARP请求")<figure3>
从@figure3 中可以看到ARP请求发送成功说明编写至此的代码没有问题。
]
=== ARP报文接收函数
#para[
ARP报文接收函数主要功能是处理接收到的ARP报文包括解析报文、更新ARP表、发送ARP响应等。下面根据这些需求编写ARP报文接收函数```c void xarp_in(xnet_packet_t * packet)```
```c
/**
* 处理接收到的ARP包
* @param packet 输入的ARP包
*/
void xarp_in(xnet_packet_t * packet) {
// 检查包的大小是否符合ARP包的最小长度要求
if (packet->size >= sizeof(xarp_packet_t)) {
xarp_packet_t * arp_packet = (xarp_packet_t *) packet->data;
uint16_t opcode = swap_order16(arp_packet->opcode);
// 检查包的合法性,包括硬件类型、硬件地址长度、协议类型、协议地址长度和操作码
if ((swap_order16(arp_packet->hw_type) != XARP_HW_ETHER) ||
(arp_packet->hw_len != XNET_MAC_ADDR_SIZE) ||
(swap_order16(arp_packet->pro_type) != XNET_PROTOCOL_IP) ||
(arp_packet->pro_len != XNET_IPV4_ADDR_SIZE)
|| ((opcode != XARP_REQUEST) && (opcode != XARP_REPLY))) {
return;
}
// 只处理目标IP地址为自己的ARP请求或响应包
if (!xipaddr_is_equal_buf(&netif_ipaddr, arp_packet->target_ip)) {
return;
}
// 根据操作码进行处理
switch (swap_order16(arp_packet->opcode)) {
case XARP_REQUEST: // 处理ARP请求发送ARP响应并更新ARP表项
xarp_make_response(arp_packet);
update_arp_entry(arp_packet->sender_ip, arp_packet->sender_mac);
break;
case XARP_REPLY: // 处理ARP响应更新ARP表项
update_arp_entry(arp_packet->sender_ip, arp_packet->sender_mac);
break;
}
}
}
```
该函数主要功能是处理接收到的ARP包。首先进行简单的长度判断避免后续字段读取失败造成内存错误。随后检查包的合法性包括硬件类型、硬件地址长度、协议类型、协议地址长度和操作码。APR响应只要求机器处理目标IP地址为自己的ARP请求或响应包所以使用```c if (!xipaddr_is_equal_buf(&netif_ipaddr, arp_packet->target_ip))```来判断。最后根据操作码进行处理分别处理ARP请求和ARP响应
- ARP请求发送ARP响应```c xarp_make_response(...)```并更新ARP表项```c update_arp_entry(...)```
- ARP响应只需要更新ARP表项。
其中,用到的宏```c xipaddr_is_equal_buf()```函数用于比较两个IP地址是否相等实现如下
```c
// 比较IP地址是否相等
#define xipaddr_is_equal_buf(addr, buf) (memcmp(
(addr)->array,
(buf),
XNET_IPV4_ADDR_SIZE
)
== 0
)
```
然后,需要编写上面函数中调用的两个函数:```c xarp_make_response()```和```c update_arp_entry()```。
```c xarp_make_response()```函数主要功能是输入一个ARP请求包通过此包内的源信息生成对应的ARP响应并发送出去。具体代码如下
```c
/**
* 生成一个ARP响应
* @param arp_packet 接收到的ARP请求包
* @return 生成结果
*/
xnet_err_t xarp_make_response(xarp_packet_t * arp_packet) {
xarp_packet_t* response_packet;
xnet_packet_t * packet = xnet_alloc_for_send(sizeof(xarp_packet_t));
response_packet = (xarp_packet_t *)packet->data;
response_packet->hw_type = swap_order16(XARP_HW_ETHER); // 设置硬件类型为以太网
response_packet->pro_type = swap_order16(XNET_PROTOCOL_IP); // 设置协议类型为IP
response_packet->hw_len = XNET_MAC_ADDR_SIZE; // 设置硬件地址长度
response_packet->pro_len = XNET_IPV4_ADDR_SIZE; // 设置协议地址长度
response_packet->opcode = swap_order16(XARP_REPLY); // 设置操作码为ARP响应
// 复制目标MAC地址
memcpy(response_packet->target_mac, arp_packet->sender_mac, XNET_MAC_ADDR_SIZE);
// 复制目标IP地址
memcpy(response_packet->target_ip, arp_packet->sender_ip, XNET_IPV4_ADDR_SIZE);
// 复制发送方MAC地址
memcpy(response_packet->sender_mac, netif_mac, XNET_MAC_ADDR_SIZE);
// 复制发送方IP地址
memcpy(response_packet->sender_ip, netif_ipaddr.array, XNET_IPV4_ADDR_SIZE);
// 通过以太网发送ARP响应
return ethernet_out_to(XNET_PROTOCOL_ARP, ether_broadcast, packet);
}
```
可以发现此函数与前面的ARP请求函数```c xarp_make_request()```非常相似,只是操作码不同,此处为`XARP_REPLY`其他字段均从源ARP请求报文中获取并填入对应区域。
```c update_arp_entry()```函数主要功能是更新所有ARP表项附带一定的可视化功能。具体代码如下
```c
/**
* 更新ARP表项
* @param src_ip 源IP地址
* @param mac_addr 对应的mac地址
*/
static void update_arp_entry(uint8_t* src_ip, uint8_t* mac_addr) {
for (arp_entry = arp_table;
arp_entry < XARP_CFG_ENTRY_SIZE * sizeof(xarp_entry_t) + arp_table;
arp_entry = arp_entry + sizeof(xarp_entry_t))
{
// 检查ARP表项是否为空或者是否与给定的源IP地址匹配且状态不是有效的
if (arp_entry->state == XARP_ENTRY_FREE ||
( arp_entry->state == XARP_ENTRY_OK
&& xipaddr_is_equal_buf(&arp_entry->ipaddr, src_ip)
))
{
// 更新ARP表项中的IP地址和MAC地址
memcpy(arp_entry->ipaddr.array, src_ip, XNET_IPV4_ADDR_SIZE);
memcpy(arp_entry->macaddr, mac_addr, 6);
printf("learned☝🤓mac addr\n");
for (
int i = 0;
i < sizeof(mac_addr) / sizeof(mac_addr[0]);
++i)
{
printf("%02X%c",
mac_addr[i],
i < sizeof(mac_addr) / sizeof(mac_addr[0]) - 1 ? ':' : '\n'
);
}
// 设置ARP表项状态为有效
arp_entry->state = XARP_ENTRY_OK;
// 设置ARP表项的超时时间
arp_entry->tmo = XARP_CFG_ENTRY_OK_TMO;
// 设置ARP表项的重试次数
arp_entry->retry_cnt = XARP_CFG_MAX_RETRIES;
print_arp_table(); // 打印完整的ARP表
return; // 更新后退出函数
}
}
// 如果ARP表已满采用LRU策略替换最老的表项
arp_entry = arp_table; // 重置arp_entry指向表头
xarp_entry_t* oldest_entry = NULL;
uint32_t oldest_tmo = 0xFFFFFFFF;
for (arp_entry = arp_table;
arp_entry < XARP_CFG_ENTRY_SIZE * sizeof(xarp_entry_t) + arp_table;
arp_entry = arp_entry + sizeof(xarp_entry_t))
{
if (arp_entry->tmo < oldest_tmo) {
oldest_tmo = arp_entry->tmo;
oldest_entry = arp_entry;
}
}
if (oldest_entry != NULL) {
// 更新最老的ARP表项
memcpy(oldest_entry->ipaddr.array, src_ip, XNET_IPV4_ADDR_SIZE);
memcpy(oldest_entry->macaddr, mac_addr, 6);
printf("learned☝🤓mac addr\n");
for (int i = 0; i < sizeof(mac_addr) / sizeof(mac_addr[0]); ++i) {
printf("%02X%c", mac_addr[i], i < sizeof(mac_addr) / sizeof(mac_addr[0]) - 1 ? ':' : '\n');
}
// 设置ARP表项状态为有效
oldest_entry->state = XARP_ENTRY_OK;
// 设置ARP表项的超时时间
oldest_entry->tmo = XARP_CFG_ENTRY_OK_TMO;
// 设置ARP表项的重试次数
oldest_entry->retry_cnt = XARP_CFG_MAX_RETRIES;
print_arp_table(); // 打印完整的ARP表
}
}
```
这个函数很长。它主要功能是更新ARP表项。更新分为两种情况
- ARP表还有空闲表项
- ARP表已满采用LRU策略替换最老的表项
首先函数通过遍历ARP表中的所有表项检查表项是否为空或者是否与给定的源IP地址匹配且状态不是有效的。如果满足条件则更新ARP表项中的IP地址和MAC地址并设置表项状态为有效设置超时时间和重试次数最后会打印完整的ARP表。如果ARP表已满则采用LRU策略替换最老的表项。函数会遍历ARP表找到超时时间最小的表项并更新该表项的IP地址和MAC地址设置表项状态为有效设置超时时间和重试次数最后打印完整的ARP表。
用到的打印函数实现如下:
```c
/**
* 打印完整的ARP表
*/
void print_arp_table() {
printf("\n----ARP Table----\n");
for (arp_entry = arp_table; arp_entry < XARP_CFG_ENTRY_SIZE * sizeof(xarp_entry_t) + arp_table; arp_entry = arp_entry + sizeof(xarp_entry_t)) {
if (arp_entry->state != XARP_ENTRY_FREE) {
printf("IP: ");
for (int i = 0; i < XNET_IPV4_ADDR_SIZE; ++i) {
printf("%d%c",
arp_entry->ipaddr.array[i],
i < XNET_IPV4_ADDR_SIZE - 1 ? '.' : '\n'
);
}
printf("MAC: ");
for (int i = 0; i < 6; ++i) {
printf("%02X%c", arp_entry->macaddr[i], i < 5 ? ':' : '\n');
}
printf(
"State: %s\n",
arp_entry->state == XARP_ENTRY_FREE ? "FREE" :
arp_entry->state == XARP_ENTRY_RESOLVING ? "RESOLVING" : "OK"
);
}
}
printf("\n-----------------\n");
}
```
最后需要在以太网帧接收函数中添加ARP报文的处理
```c
/**
* 以太网数据帧输入输出
* @param packet 待处理的包
*/
static void ethernet_in (xnet_packet_t * packet) {
// 至少要比头部数据大
if (packet->size <= sizeof(xether_hdr_t)) {
return;
}
// 根据协议类型分发到不同的处理函数
xether_hdr_t* hdr = (xether_hdr_t*)packet->data;
switch (swap_order16(hdr->protocol)) {
case XNET_PROTOCOL_ARP:
// 移除以太网头部处理ARP协议
remove_header(packet, sizeof(xether_hdr_t));
xarp_in(packet);
break;
case XNET_PROTOCOL_IP: {
break;
}
}
}
```
其中,主要在```c case XNET_PROTOCOL_ARP```中添加了对ARP报文的处理。
在继续之前再次使用Wireshark检验这部分代码编写。重新编译后按照以下流程进行检验
- 开启Wireshark抓包
- 运行本程序;
- 在虚拟机上ping本程序以触发ARP请求
- 查看Wireshark抓包结果和程序输出。
#figure(image("ARP响应.png",format: "png",width: 100%,fit: "stretch"),caption: "ARP请求响应")<figure4>
从@figure4 中可以看到ARP响应都发送成功程序输出中也表明学习到了虚拟机的MAC地址说明代码编写正确。
]
=== ARP超时重传
= 实验总结
== 内容总结
== 心得感悟
#show heading: it => box(width: 100%)[
#v(0.50em)
#set text(font: hei)
// #counter(heading).display()
// #h(0.5em)
#it.body
]
#pagebreak()
#bibliography("ref.yml",full: true,title: "参考文献",style:"gb-7714-2015-numeric")

964
network/arp/main.typ Executable file
View File

@ -0,0 +1,964 @@
#import "labtemplate.typ": *
#show: nudtlabpaper.with(title: "TCP/IP 协议栈 ARP 协议实现实验",
author: "王李烜",
id: "202202001046",
training_type: "无军籍",
grade: "2022",
major: "网络工程",
department: "计算机学院",
advisor: "邱振宇",
jobtitle: "讲师",
lab: "305-505",
date: "2024.12.16",
header_str: "《计算机网络》实验报告",
)
#set page(header: [
#set par(spacing: 6pt)
#align(center)[#text(size: 11pt)[《计算机网络》实验报告]]
#v(-0.3em)
#line(length: 100%, stroke: (thickness: 1pt))
],)
#show heading: it => box(width: 100%)[
#v(0.50em)
#set text(font: hei)
#it.body
]
#outline(title: "目录",depth: 3, indent: 1em)
#pagebreak()
#outline(
title: [图目录],
target: figure.where(kind: image),
)
#show heading: it => box(width: 100%)[
#v(0.50em)
#set text(font: hei)
#counter(heading).display()
// #h(0.5em)
#it.body
]
#set enum(indent: 0.5em,body-indent: 0.5em,)
#pagebreak()
= 实验概要
== 实验内容
#para[
本次实验的主要内容 ARP 协议实现。本次实验包含基础任务和拓展任务两部分,
具体任务要求如下:
- 基础任务:编写程序,完善 TCP/IP 协议栈的 ARP 协议部分。围绕 ARP 的初始化、无回报 ARP 的生成、ARP 的输入处理,以及 ARP 的超时重新请 求几个部分完成。并且保证完成 ARP 协议的完整实现。#box(
text(font: ("Times LT Pro","FZXiaoBiaoSong-B05"),fill: luma(240), weight:"bold", "本实验中Completed!"),
fill:blue,
inset: (x: 3pt, y: 0pt),
outset: (y: 3pt),
radius: 2pt,)
- 拓展任务:拓展任务是可选任务,在基础任务实现的 ARP 协议实现基础上, 可选择性的完成如下任务:
+ ARP 多个表项的实现;#box(
text(font: ("Times LT Pro","FZXiaoBiaoSong-B05"),fill: luma(240), weight:"bold", "本实验中Completed!"),
fill:blue,
inset: (x: 3pt, y: 0pt),
outset: (y: 3pt),
radius: 2pt,)
+ IP 层的输入输出处理。#box(
text(font: ("Times LT Pro","FZXiaoBiaoSong-B05"),fill: luma(240), weight:"bold", "本实验中Completed!"),
fill:blue,
inset: (x: 3pt, y: 0pt),
outset: (y: 3pt),
radius: 2pt,)
]
== 实验要求
#para[
本实验的具体过程及对应要求如下:
- 实验开始前准备工作:在实验开始前,学员需要掌握 C语言 编程基础,理解 TCP/IP 协议栈的工作原理,尤其是 ARP 协议的功能和作用。同时,熟悉 MAC 地址与 IP 地址的转换原理,了解网络设备如何通过 ARP 请求与响应进行地址解析。
- 实验过程中:按照实验要求,完成 ARP 协议的实现。具体步骤包括:具体而言,构造 ARP 请求和响应报文,实现报文格式的编码与解析。发送 ARP请求构建并广播 ARP 请求,获取目标设备的 MAC 地址。处理 ARP 响应,在收到响应后,提取并记录目标 IP MAC 地址的映射。管理 ARP 缓存,设计缓存机制,存储 IP-MAC 映射,并实现超时处理机制。
- 实验结束后:总结 ARP 协议的实现过程,详细描述报文格式、缓存管理和通信流程,并根据实验要求撰写实验报告,分析实验结果。
]
== 实验目的
#para[
在现代网络环境中, ARP协议广泛应用于各种网络设备和系统如计算机、路由器和交换机等。深入理解ARP的工作原理有助于掌握网络设备之间的通信机制理解数据在网络中的传输过程。特别是对于网络工程和网络安全领域从协议层面了解ARP有助于识别和防范诸如ARP欺骗等网络攻击提高网络的安全防护能力。
通过本次实验学员将亲自动手实现ARP协议的核心功能包括ARP请求与响应的构建与解析、ARP缓存表的管理等。这不仅加深了对TCP/IP协议栈的理解也培养了实际编程和问题解决的能力。掌握ARP协议的实现对后续学习更复杂的网络协议如IP、ICMP、TCP和UDP以及从事网络相关工作都有重要的意义。
]
// Display inline code in a small box
// that retains the correct baseline.
#show raw.where(block: false): it => box(
text(font: ("Consolas","FangSong_GB2312"), it),
fill: luma(240),
inset: (x: 3pt, y: 0pt),
outset: (y: 3pt),
radius: 2pt,
)
// Display block code in a larger block
// with more padding.
#show raw.where(block: true): it => block(
text(font: ("Consolas","FangSong_GB2312"), it),
fill: luma(240),
inset: 10pt,
radius: 4pt,
width: 100%,
)
= 实验原理及方案
#para[
ARP地址解析协议 TCP/IP 协议族中用于将 IP 地址解析为 MAC 地址的重要协议。IP 通信依赖于数据链路层的硬件地址MAC 地址),而 ARP 负责动态地将网络层的 IP 地址转换为对应的数据链路层 MAC 地址从而实现设备间的通信。ARP 协议的实现主要包括发送 ARP 请求、接收并处理 ARP 响应、更新 ARP 缓存、以及缓存超时机制。
]
== ARP的初始化
#para[
在一个典型的局域网中,设备通过 IP 地址进行网络层通信,但 IP 地址并不能直接用于数据链路层传输。以太网等数据链路层协议使用 MAC 地址进行通信,因此,发送设备需要将目标 IP 地址解析为 MAC 地址才能发送数据帧。
如果该设备的 ARP 缓存中没有目标设备的 MAC 地址映射,它会广播 ARP 请求,询问网络上哪个设备持有特定的 IP 地址。ARP 请求是一个以太网层的广播包,发送到子网内所有设备,只有持有目标 IP 地址的设备才会进行响应。
ARP 初始化的过程是设备发现并解析网络中其他设备的关键步骤。ARP 请求包含源设备的 IP 地址和 MAC 地址,而目标设备通过 ARP 响应提供其对应的 MAC 地址。这个机制确保设备能够通过网络层IP 地址和链路层MAC 地址)之间建立正确的映射关系。
]
== 无回报 ARP 的生成
#para[
无回报 ARPGratuitous ARP又称为“主动 ARP”或“自愿 ARP”是一种特殊的 ARP 操作。与典型的 ARP 请求不同,无回报 ARP 并不是为了解析目标设备的 MAC 地址,而是设备主动向网络发送广播 ARP 包,通常用于更新网络中的 IP-MAC 映射关系、检测 IP 地址冲突等。
无回报 ARP 是设备主动广播自身的 IP 地址和 MAC 地址,不带有显式的 ARP 请求和响应互动。其主要目的是通知网络中其他设备更新其 ARP 缓存表中的信息。这种情况下,设备并不期待其他设备回应。它是单向广播的,通常被用于下列几种情况:
- 更新网络中的 ARP 表:当设备的 MAC 地址或 IP 地址发生变动时,可以主动发送无回报 ARP以便通知网络中其他设备更新其 ARP 缓存。
- IP 冲突检测:设备在启动时,通过发送无回报 ARP 来检测是否有其他设备占用了相同的 IP 地址。如果另一台设备使用了相同的 IP 地址,它会回应此 ARP 广播,从而帮助设备检测到 IP 冲突。
- 负载均衡器和高可用性系统:当系统切换主备设备时,备设备通常会发送无回报 ARP 来通知网络中的所有节点其 IP-MAC 映射已经改变,避免继续向已下线的设备发送数据。
无回报 ARP 的生成过程如下:
1. 生成 ARP 广播包:设备在确定需要广播自身 IP-MAC 映射时,会生成一个 ARP 广播包。该包包含设备自身的 IP 地址和 MAC 地址,并且目标硬件地址设置为全 0因为无回报 ARP 并不是请求对方设备的 MAC 地址,而是向网络中的所有设备广播自身的信息。
2. 设置操作码为 ARP 请求:尽管无回报 ARP 是主动广播,但它在帧结构中被标记为 ARP 请求(操作码为 1这使得网络中的其他设备会将其视为一种信息广播用于更新 ARP 缓存。
3. 发送广播ARP 广播包通过以太网层进行传输,目标 MAC 地址为 FF:FF:FF:FF:FF:FF即局域网内的所有设备都可以接收到此广播。
4. 网络中的设备处理:网络中所有收到此广播的设备会检查 ARP 包中的发送方 IP 地址和 MAC 地址,并将其更新到本地的 ARP 缓存表中。这样,即使该 IP 地址之前未出现在这些设备的 ARP 表中,它们也会记录并更新新的映射。
]
== ARP 的输入处理
#para[
ARP地址解析协议的输入处理指的是设备在接收到 ARP 请求或响应时,如何对该 ARP 报文进行解析和处理,并据此更新设备的 ARP 缓存或进一步采取必要的网络行为。ARP 输入处理的核心任务是解析报文,更新 ARP 缓存,并根据报文类型采取不同的操作。
在这部分有以下步骤:
- 接收 ARP 报文:设备通过网络接口接收到 ARP 报文,无论是广播还是单播形式。这些 ARP 报文可以是 ARP 请求、ARP 响应,或者是无回报 ARP。
- 解析 ARP 报文:设备对 ARP 报文进行解析,提取其中的关键信息。
- 检查报文有效性:设备检查 ARP 报文的有效性,包括检查硬件类型是否为以太网、协议类型是否为 IPv4、操作码是否为合法的请求或响应。如果报文不符合 ARP 协议规定,设备将丢弃该报文。
- 更新 ARP 缓存:根据 ARP 报文中的信息,设备更新自己的 ARP 缓存表。设备通常会把报文中的发送方 IP 地址和发送方 MAC 地址映射记录下来,以便将来进行快速的 IP MAC 地址解析。
- 据操作码进行处理:不同类型的 ARP 报文有不同的处理方式:
- 如果接收到的是 ARP 请求,设备需要检查目标 IP 地址是否与自身的 IP 地址匹配,如果匹配,则需要发送一个 ARP 响应包,告知请求设备自己的 MAC 地址。
- 如果接收到的是 ARP 响应,设备会根据响应包中的信息,更新或添加到 ARP 缓存表,并不再发送进一步的响应。
- 如果接收到的是无回报 ARP设备会将报文中的 IP-MAC 映射记录下来,以更新其 ARP 缓存。
]
== ARP 的超时重新请求机制
#para[
ARP地址解析协议的超时重新请求机制指的是设备在尝试解析某个 IP 地址到 MAC 地址时,若未能在设定的时间内收到响应,会采取的重发 ARP 请求的策略。这种机制旨在保证网络设备在通信中能够及时获取目标设备的 MAC 地址,并维持 ARP 缓存的准确性。
ARP 缓存存储的是 IP 地址与 MAC 地址之间的映射关系。在通信过程中,网络设备通常会先查询 ARP 缓存以查找目标设备的 MAC 地址。如果缓存中存在该 IP 地址的记录,设备会直接使用缓存中的 MAC 地址进行通信;如果没有找到相应记录,设备会发出 ARP 请求,广播请求目标 IP 地址对应的 MAC 地址。
如果设备在发送 ARP 请求后,未能在指定的时间内收到 ARP 响应,它会认为该 ARP 请求失败。这时,设备会重新发送 ARP 请求,通常会进行一定次数的重发,以确保能够成功解析目标设备的 MAC 地址。
]
= 实验环境
== 实验设备与软件
#para[
#align(center)[#table(
columns: (auto, auto),
rows:(auto,auto,auto),
inset: 10pt,
align: horizon+center,
table.header(
[*名称*], [*型号或版本*],
),
"物理机", "联想ThinkPad-Windows 10 22H4",
"虚拟机", "Virtual Box-Windows 10 22H4",
"Wireshark", "Wireshark 4.4.0",
"CMake", "CMake 3.31.3"
)]
]
= 实验步骤
== 环境配置
=== 虚拟机网络配置
#para[
安装Windows 10虚拟机并配置物理机和虚拟机的IP地址使其能够互相访问
- 物理机网卡IP地址配置为`192.168.254.1/24`
- 虚拟机IP地址配置为`192.168.254.3/24`
#figure(image("物理机虚拟机IP配置.png",format: "png",width: 90%,fit: "stretch"),caption: "物理机与虚拟机IP配置")
配置好之后,在两边的命令行中分别使用`ping`命令测试是否能够互相访问。同时在物理机上开启Wireshark以过滤条件`icmp`进行抓包查看IP地址是否正确
#figure(image("环境配置ping测试.png",format: "png",width: 90%,fit: "stretch"),caption: "环境配置ping通测试")<figure2>
@figure2 中可以看到物理机和虚拟机之间可以互相访问且Wireshark抓包显示IP地址正确。
]
=== 使用CMake运行项目
#para[
CMake配置较为简单。首先在开发工具中安装对应版本CMake插件。其次在终端中进入项目根目录在此使用```shell mkdir build```命令新建`build`文件夹并进入该文件夹。接下来使用CMake工具生成对应的Makefile文件```shell cmake -G"MinGW Makefiles" ..```
然后再运行```shell make```命令编译项目,最后使用```shell xnet.exe```命令即可运行项目:
#figure(image("cmake编译运行.png",format: "png",width: 76%,fit: "stretch"),caption: "CMake配置")
其中MinGW是一个Windows下的GNU编译器套件可以在Windows下编译出Linux下的可执行文件。```shell cmake -G"MinGW Makefiles" ..```命令的作用是配置使用MinGW编译器。
至此,环境配置结束。
]
== 实现ARP协议
#para[
代码已经实现了最基础的以太网协议实现了以太网帧的封装和解封装。接下来在此基础上继续实现ARP协议。
]
=== 相关数据结构<multiple_entry>
#para[
`xnet_tiny.h`中定义IP地址长度以及数据结构
```c
#define XNET_IPV4_ADDR_SIZE 4 // IP地址长度
// IP地址
typedef union _xipaddr_t {
uint8_t array[XNET_IPV4_ADDR_SIZE]; // 以数据形式存储的ip
uint32_t addr; // 32位的ip地址
}xipaddr_t;
```
该数据结构定义了IP地址的数据结构包括了IP地址的数组形式和32位的IP地址。
然后定义MAC地址的长度以及ARP表项的结构体
```c
#define XNET_MAC_ADDR_SIZE 6 // MAC地址长度
// ARP表项
typedef struct _xarp_entry_t {
xipaddr_t ipaddr; // ip地址
uint8_t macaddr[XNET_MAC_ADDR_SIZE]; // mac地址
uint8_t state; // 状态位
uint16_t tmo; // 当前超时
uint8_t retry_cnt; // 当前重试次数
}xarp_entry_t;
```
该结构体定义了ARP表项的数据结构包括了IP地址、MAC地址、状态位、超时时间和重试次数。
定义ARP表项的最大数量
```c
#define XARP_CFG_ENTRY_SIZE 8 // ARP表大小
```
随后,在`xnet_tiny.c`将ARP表定义为全局变量并定义一个表项指针方便后续代码编写
```c
static xarp_entry_t arp_table[XARP_CFG_ENTRY_SIZE]; // ARP表
static xarp_entry_t* arp_entry; // ARP表项指针
```
]
=== ARP表初始化<State1>
#para[
接下来编写ARP表的初始化函数。首先在`xnet_tiny.h`中定义ARP表项的第一个状态
```c
#define XARP_ENTRY_FREE 0 // ARP表项空闲
```
然后在`xnet_tiny.c`中定义初始化函数```c void xarp_init(void)```
```c
// ARP初始化
void xarp_init(void) {
for (arp_entry = arp_table;
arp_entry < XARP_CFG_ENTRY_SIZE * sizeof(xarp_entry_t) + arp_table;
arp_entry = arp_entry + sizeof(xarp_entry_t))
{
arp_entry->state = XARP_ENTRY_FREE; // 此处用到了上面定义的状态
}
arp_entry = arp_table;
}
```
初始化函数```c void xarp_init(void)```是一个循环。首先将前面定义的全局表项指针指向ARP表的第一个表项循环结束条件为指针指向的表项的地址超过ARP表的最后一个表项的地址。循环会遍历ARP表中的所有表项将表项状态初始化为`XARP_STATE_FREE`。最后,函数会将表项指针指向第一个表项,避免其他初始化过程中可能的指针越界问题。
最后,在协议栈的初始化函数中添加```c xarp_init()```
```c
void xnet_init (void) {
ethernet_init(); // 初始化以太网
xarp_init(); // *初始化ARP
}
```
]
=== ARP报文
#para[
接下来编写无回报ARP报文的相关函数所以需要先定义ARP报文结构以及它所用到的相关结构。
首先在`xnet_tiny.h`中定义ARP报文中的几个字段。可以靠Wireshark抓包分析来获取这些字段的值下面是一个示例展示通过抓包来获取```c XNET_PROTOCOL_IP = 0x0800```
#figure(table(
columns: (auto),
rows:(auto,auto),
inset: 10pt,
align: horizon+center,
figure(image("抓一个arp分析结构.png",format: "png",fit:"stretch",width: 100%),),
figure(image("分析结构2.png",format: "png",fit:"stretch",width: 100%),),
stroke: none,
),caption: "通过抓包分析来获取字段值",kind: image)
代码编写如下:
```c
#define XARP_HW_ETHER 0x1 // 硬件类型:以太网
#define XARP_REQUEST 0x1 // OpcodeARP请求包
#define XARP_REPLY 0x2 // OpcodeARP响应包
typedef enum _xnet_protocol_t {
XNET_PROTOCOL_ARP = 0x0806, // ARP协议
XNET_PROTOCOL_IP = 0x0800, // IPv4协议
XNET_PROTOCOL_ICMP = 1, // ICMP协议
}xnet_protocol_t;
```
然后定义ARP报文的数据结构
```c
typedef struct _xarp_packet_t {
uint16_t hw_type, pro_type; // 硬件类型和协议类型
uint8_t hw_len, pro_len; // 硬件地址长 + 协议地址长
uint16_t opcode; // 请求/响应
uint8_t sender_mac[XNET_MAC_ADDR_SIZE]; // 发送包硬件地址
uint8_t sender_ip[XNET_IPV4_ADDR_SIZE]; // 发送包协议地址
uint8_t target_mac[XNET_MAC_ADDR_SIZE]; // 接收方硬件地址
uint8_t target_ip[XNET_IPV4_ADDR_SIZE]; // 接收方协议地址
}xarp_packet_t;
```
然后,使用前面定义的```c union xipaddr_t```结构,在`xnet_tiny.h``xnet_tiny.c`中定义ARP报文发送函数需要用到的IP地址、组播MAC地址
```c
// xnet_tiny.h
#define XNET_CFG_NETIF_IP {192, 168, 254, 2} // 本项目模拟出的网卡的IP
// xnet_tiny.c
static const xipaddr_t netif_ipaddr = XNET_CFG_NETIF_IP;
static const uint8_t ether_broadcast[] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
```
至此定义ARP报文的数据结构结束。
]
=== ARP报文发送函数
#para[
下面编写ARP报文发送函数```c xarp_make_request(const xipaddr_t * ipaddr)```
```c
/**
* 产生一个ARP请求请求网络指定ip地址的机器发回一个ARP响应
* @param ipaddr 请求的IP地址
* @return 请求结果
*/
xnet_err_t xarp_make_request(const xipaddr_t * ipaddr) {
xarp_packet_t* arp_packet;
xnet_packet_t * packet = xnet_alloc_for_send(sizeof(xarp_packet_t));
arp_packet = (xarp_packet_t *)packet->data;
arp_packet->hw_type = swap_order16(XARP_HW_ETHER); // 设置硬件类型为以太网
arp_packet->pro_type = swap_order16(XNET_PROTOCOL_IP); // 设置协议类型为IP
arp_packet->hw_len = XNET_MAC_ADDR_SIZE; // 设置硬件地址长度
arp_packet->pro_len = XNET_IPV4_ADDR_SIZE; // 设置协议地址长度
arp_packet->opcode = swap_order16(XARP_REQUEST); // 设置操作码为ARP请求
// 复制发送方MAC地址
memcpy(arp_packet->sender_mac, netif_mac, XNET_MAC_ADDR_SIZE);
// 复制发送方IP地址
memcpy(arp_packet->sender_ip, netif_ipaddr.array, XNET_IPV4_ADDR_SIZE);
// 目标MAC地址清零
memset(arp_packet->target_mac, 0, XNET_MAC_ADDR_SIZE);
// 复制目标IP地址
memcpy(arp_packet->target_ip, ipaddr->array, XNET_IPV4_ADDR_SIZE);
// 通过以太网发送ARP请求
return ethernet_out_to(XNET_PROTOCOL_ARP, ether_broadcast, packet);
}
```
这个函数的主要功能是生成并发送一个ARP请求报文以请求指定IP地址即函数的输入```c const xipaddr_t * ipaddr```的机器返回其MAC地址。函数的具体步骤如下
1. 分配一个用于发送的ARP数据包```c arp_packet```并将其数据段设置为ARP报文结构。
2. 设置ARP报文的各个字段包括硬件类型`hw_type`、协议类型`pro_type`、硬件地址长度`hw_len`、协议地址长度`pro_len`、操作码`opcode`(设置为`XARP_REQUEST`)等。
3. 复制发送方即本项目模拟出的网卡的MAC地址和IP地址到ARP报文中。
4. 将目标MAC地址字段清零并复制目标IP地址到ARP报文中。
5. 最后通过以太网发送该ARP请求报文返回发送结果状态码
]
=== 启动时的ARP请求
#para[
在以太网协议的初始化函数```c static xnet_err_t ethernet_init(void)```中添加一个ARP请求
```c
/**
* 以太网初始化
* @return 初始化结果
*/
static xnet_err_t ethernet_init (void) {
xnet_err_t err = xnet_driver_open(netif_mac);
if (err < 0) return err;
return xarp_make_request(&netif_ipaddr); // 发送ARP请求
}
```
这样当协议栈初始化时会发送一个ARP请求。
下面用Wireshark抓包来验证ARP请求是否发送成功。首先重新编译项目其次开启Wireshark抓包最后启动程序
#figure(image("启动ARP2.png",format: "png",width: 100%,fit: "stretch"),caption: "启动时的ARP请求")<figure3>
@figure3 中可以看到ARP请求发送成功说明编写至此的代码没有问题。
]
=== ARP报文接收函数
#para[
ARP报文接收函数主要功能是处理接收到的ARP报文包括解析报文、更新ARP表、发送ARP响应等。下面根据这些需求编写ARP报文接收函数```c void xarp_in(xnet_packet_t * packet)```
```c
/**
* 处理接收到的ARP包
* @param packet 输入的ARP包
*/
void xarp_in(xnet_packet_t * packet) {
// 检查包的大小是否符合ARP包的最小长度要求
if (packet->size >= sizeof(xarp_packet_t)) {
xarp_packet_t * arp_packet = (xarp_packet_t *) packet->data;
uint16_t opcode = swap_order16(arp_packet->opcode);
// 检查包的合法性,包括硬件类型、硬件地址长度、协议类型、协议地址长度和操作码
if ((swap_order16(arp_packet->hw_type) != XARP_HW_ETHER) ||
(arp_packet->hw_len != XNET_MAC_ADDR_SIZE) ||
(swap_order16(arp_packet->pro_type) != XNET_PROTOCOL_IP) ||
(arp_packet->pro_len != XNET_IPV4_ADDR_SIZE)
|| ((opcode != XARP_REQUEST) && (opcode != XARP_REPLY))) {
return;
}
// 只处理目标IP地址为自己的ARP请求或响应包
if (!xipaddr_is_equal_buf(&netif_ipaddr, arp_packet->target_ip)) {
return;
}
// 根据操作码进行处理
switch (swap_order16(arp_packet->opcode)) {
case XARP_REQUEST: // 处理ARP请求发送ARP响应并更新ARP表项
xarp_make_response(arp_packet);
update_arp_entry(arp_packet->sender_ip, arp_packet->sender_mac);
break;
case XARP_REPLY: // 处理ARP响应更新ARP表项
update_arp_entry(arp_packet->sender_ip, arp_packet->sender_mac);
break;
}
}
}
```
该函数主要功能是处理接收到的ARP包。首先进行简单的长度判断避免后续字段读取失败造成内存错误。随后检查包的合法性包括硬件类型、硬件地址长度、协议类型、协议地址长度和操作码。APR响应只要求机器处理目标IP地址为自己的ARP请求或响应包所以使用```c if (!xipaddr_is_equal_buf(&netif_ipaddr, arp_packet->target_ip))```来判断。最后根据操作码进行处理分别处理ARP请求和ARP响应
- ARP请求发送ARP响应```c xarp_make_response(...)```并更新ARP表项```c update_arp_entry(...)```
- ARP响应只需要更新ARP表项。
其中,用到的宏```c xipaddr_is_equal_buf()```函数用于比较两个IP地址是否相等实现如下
```c
// 比较IP地址是否相等
#define xipaddr_is_equal_buf(addr, buf) (memcmp(
(addr)->array,
(buf),
XNET_IPV4_ADDR_SIZE
)
== 0
)
```
然后,需要编写上面函数中调用的两个函数:```c xarp_make_response()``````c update_arp_entry()```
```c xarp_make_response()```函数主要功能是输入一个ARP请求包通过此包内的源信息生成对应的ARP响应并发送出去。具体代码如下
```c
/**
* 生成一个ARP响应
* @param arp_packet 接收到的ARP请求包
* @return 生成结果
*/
xnet_err_t xarp_make_response(xarp_packet_t * arp_packet) {
xarp_packet_t* response_packet;
xnet_packet_t * packet = xnet_alloc_for_send(sizeof(xarp_packet_t));
response_packet = (xarp_packet_t *)packet->data;
response_packet->hw_type = swap_order16(XARP_HW_ETHER); // 设置硬件类型为以太网
response_packet->pro_type = swap_order16(XNET_PROTOCOL_IP); // 设置协议类型为IP
response_packet->hw_len = XNET_MAC_ADDR_SIZE; // 设置硬件地址长度
response_packet->pro_len = XNET_IPV4_ADDR_SIZE; // 设置协议地址长度
response_packet->opcode = swap_order16(XARP_REPLY); // 设置操作码为ARP响应
// 复制目标MAC地址
memcpy(response_packet->target_mac, arp_packet->sender_mac, XNET_MAC_ADDR_SIZE);
// 复制目标IP地址
memcpy(response_packet->target_ip, arp_packet->sender_ip, XNET_IPV4_ADDR_SIZE);
// 复制发送方MAC地址
memcpy(response_packet->sender_mac, netif_mac, XNET_MAC_ADDR_SIZE);
// 复制发送方IP地址
memcpy(response_packet->sender_ip, netif_ipaddr.array, XNET_IPV4_ADDR_SIZE);
// 通过以太网发送ARP响应
return ethernet_out_to(XNET_PROTOCOL_ARP, ether_broadcast, packet);
}
```
可以发现此函数与前面的ARP请求函数```c xarp_make_request()```非常相似,只是操作码不同,此处为`XARP_REPLY`其他字段均从源ARP请求报文中获取并填入对应区域。
```c update_arp_entry()```函数主要功能是更新所有ARP表项附带一定的可视化功能。具体代码如下
```c
/**
* 更新ARP表项
* @param src_ip 源IP地址
* @param mac_addr 对应的mac地址
*/
static void update_arp_entry(uint8_t* src_ip, uint8_t* mac_addr) {
for (arp_entry = arp_table;
arp_entry < XARP_CFG_ENTRY_SIZE * sizeof(xarp_entry_t) + arp_table;
arp_entry = arp_entry + sizeof(xarp_entry_t))
{
// 检查ARP表项是否为空或者是否与给定的源IP地址匹配且状态不是有效的
if (arp_entry->state == XARP_ENTRY_FREE ||
( arp_entry->state == XARP_ENTRY_OK
&& xipaddr_is_equal_buf(&arp_entry->ipaddr, src_ip)
))
{
// 更新ARP表项中的IP地址和MAC地址
memcpy(arp_entry->ipaddr.array, src_ip, XNET_IPV4_ADDR_SIZE);
memcpy(arp_entry->macaddr, mac_addr, 6);
printf("learned☝🤓mac addr\n");
for (
int i = 0;
i < sizeof(mac_addr) / sizeof(mac_addr[0]);
++i)
{
printf("%02X%c",
mac_addr[i],
i < sizeof(mac_addr) / sizeof(mac_addr[0]) - 1 ? ':' : '\n'
);
}
// 设置ARP表项状态为有效
arp_entry->state = XARP_ENTRY_OK;
// 设置ARP表项的超时时间
arp_entry->tmo = XARP_CFG_ENTRY_OK_TMO;
// 设置ARP表项的重试次数
arp_entry->retry_cnt = XARP_CFG_MAX_RETRIES;
print_arp_table(); // 打印完整的ARP表
return; // 更新后退出函数
}
}
// 如果ARP表已满采用LRU策略替换最老的表项
arp_entry = arp_table; // 重置arp_entry指向表头
xarp_entry_t* oldest_entry = NULL;
uint32_t oldest_tmo = 0xFFFFFFFF;
for (arp_entry = arp_table;
arp_entry < XARP_CFG_ENTRY_SIZE * sizeof(xarp_entry_t) + arp_table;
arp_entry = arp_entry + sizeof(xarp_entry_t))
{
if (arp_entry->tmo < oldest_tmo) {
oldest_tmo = arp_entry->tmo;
oldest_entry = arp_entry;
}
}
if (oldest_entry != NULL) {
// 更新最老的ARP表项
memcpy(oldest_entry->ipaddr.array, src_ip, XNET_IPV4_ADDR_SIZE);
memcpy(oldest_entry->macaddr, mac_addr, 6);
printf("learned☝🤓mac addr\n");
for (int i = 0; i < sizeof(mac_addr) / sizeof(mac_addr[0]); ++i){
printf("%02X%c", mac_addr[i],
i < sizeof(mac_addr) / sizeof(mac_addr[0]) - 1 ? ':' : '\n');
}
// 设置ARP表项状态为有效
oldest_entry->state = XARP_ENTRY_OK;
// 设置ARP表项的超时时间
oldest_entry->tmo = XARP_CFG_ENTRY_OK_TMO;
// 设置ARP表项的重试次数
oldest_entry->retry_cnt = XARP_CFG_MAX_RETRIES;
print_arp_table(); // 打印完整的ARP表
}
}
```
这个函数很长。它主要功能是更新ARP表项。更新分为两种情况
- ARP表还有空闲表项
- ARP表已满采用LRU策略替换最老的表项
首先函数通过遍历ARP表中的所有表项检查表项是否为空或者是否与给定的源IP地址匹配且状态不是有效的。如果满足条件则更新ARP表项中的IP地址和MAC地址并设置表项状态为有效设置超时时间和重试次数最后会打印完整的ARP表。如果ARP表已满则采用LRU策略替换最老的表项。函数会遍历ARP表找到超时时间最小的表项并更新该表项的IP地址和MAC地址设置表项状态为有效设置超时时间和重试次数最后打印完整的ARP表。
用到的打印函数实现如下:
```c
/**
* 打印完整的ARP表
*/
void print_arp_table() {
printf("\n----ARP Table----\n");
for (arp_entry = arp_table;
arp_entry < XARP_CFG_ENTRY_SIZE * sizeof(xarp_entry_t) + arp_table;
arp_entry = arp_entry + sizeof(xarp_entry_t))
{
if (arp_entry->state != XARP_ENTRY_FREE) {
printf("IP: ");
for (int i = 0; i < XNET_IPV4_ADDR_SIZE; ++i) {
printf("%d%c",
arp_entry->ipaddr.array[i],
i < XNET_IPV4_ADDR_SIZE - 1 ? '.' : '\n'
);
}
printf("MAC: ");
for (int i = 0; i < 6; ++i) {
printf("%02X%c", arp_entry->macaddr[i], i < 5 ? ':' : '\n');
}
printf(
"State: %s\n",
arp_entry->state == XARP_ENTRY_FREE ? "FREE" :
arp_entry->state == XARP_ENTRY_RESOLVING ? "RESOLVING" : "OK"
);
}
}
printf("\n-----------------\n");
}
```
最后需要在以太网帧接收函数中添加ARP报文的处理
```c
/**
* 以太网数据帧输入输出
* @param packet 待处理的包
*/
static void ethernet_in (xnet_packet_t * packet) {
// 至少要比头部数据大
if (packet->size <= sizeof(xether_hdr_t)) {
return;
}
// 根据协议类型分发到不同的处理函数
xether_hdr_t* hdr = (xether_hdr_t*)packet->data;
switch (swap_order16(hdr->protocol)) {
case XNET_PROTOCOL_ARP:
// 移除以太网头部处理ARP协议
remove_header(packet, sizeof(xether_hdr_t));
xarp_in(packet);
break;
case XNET_PROTOCOL_IP: {
break;
}
}
}
```
其中,主要在```c case XNET_PROTOCOL_ARP```中添加了对ARP报文的处理。
在继续之前再次使用Wireshark检验这部分代码编写。重新编译后按照以下流程进行检验
- 开启Wireshark抓包
- 运行本程序;
- 在虚拟机上ping本程序以触发ARP请求
- 查看Wireshark抓包结果和程序输出。
#figure(image("ARP响应.png",format: "png",width: 100%,fit: "stretch"),caption: "ARP请求响应")<figure4>
@figure4 中可以看到ARP响应都发送成功程序输出中也表明学习到了虚拟机的MAC地址说明代码编写正确。
]
=== ARP超时重传
#para[
首先需要定义ARP表项的其他两种状态#footnote[第一种状态已经在@State1 中定义过了。]解析成功、和正在解析即已发出重传的ARP请求报文但还未收到响应
```c
#define XARP_ENTRY_OK 1 // ARP表项解析成功
#define XARP_ENTRY_RESOLVING 2 // ARP表项正在解析
#define XARP_TIMER_PERIOD 1 // ARP扫描周期1s足够
```
然后需要定义超时时间和重试次数:
```c
#define XARP_CFG_ENTRY_OK_TMO (10) // ARP表项超时时间
#define XARP_CFG_ENTRY_PENDING_TMO (2) // ARP表项挂起超时时间
#define XARP_CFG_MAX_RETRIES 4 // ARP表挂起时重试查询次数
```
`xnet_tiny.c`中,`xarp_poll`函数负责定期检查ARP表项的状态并根据需要触发重传。具体实现如下
```c
/**
* 查询ARP表项是否超时超时则重新请求
*/
void xarp_poll(void) {
// 检查ARP定时器是否超时
if (xnet_check_tmo(&arp_timer, XARP_TIMER_PERIOD)) {
for ( arp_entry = arp_table;
arp_entry < XARP_CFG_ENTRY_SIZE * sizeof(xarp_entry_t) + arp_table;
arp_entry = arp_entry + sizeof(xarp_entry_t))
{
switch (arp_entry->state) {
case XARP_ENTRY_RESOLVING:
// 如果ARP表项正在解析中检查超时计数器
if (--arp_entry->tmo == 0) {
// 如果重试次数用完释放ARP表项
if (arp_entry->retry_cnt-- == 0) {
arp_entry->state = XARP_ENTRY_FREE;
}
else {
// 否则继续重试发送ARP请求
xarp_make_request(&arp_entry->ipaddr);
arp_entry->state = XARP_ENTRY_RESOLVING;
arp_entry->tmo = XARP_CFG_ENTRY_PENDING_TMO;
}
}
break;
case XARP_ENTRY_OK:
// 如果ARP表项有效检查超时计数器
if (--arp_entry->tmo == 0) {
// 超时后重新发送ARP请求
xarp_make_request(&arp_entry->ipaddr);
arp_entry->state = XARP_ENTRY_RESOLVING;
arp_entry->tmo = XARP_CFG_ENTRY_PENDING_TMO;
}
break;
}
}
}
}
```
该函数主要功能是定时检查ARP表项的状态具体步骤如下
1. 定时检查:```c xarp_poll()```函数会定期检查ARP表项的状态检查周期由`XARP_TIMER_PERIOD`定义1秒
2. 状态判断:
- 如果表项状态为`XARP_ENTRY_RESOLVING`正在解析中则检查超时计数器。如果超时且重试次数用完则释放该表项否则重新发送ARP请求并重置超时计数器。
- 如果表项状态为`XARP_ENTRY_OK`有效则检查超时计数器。如果超时则重新发送ARP请求并将表项状态设置为`XARP_ENTRY_RESOLVING`
3. 重传ARP请求通过调用`xarp_make_request`函数重新发送ARP请求以获取目标IP地址对应的MAC地址。
下面是用Wireshark抓包验证ARP超时重传的结果。重新编译后直接运行程序在虚拟机上ping本程序以触发ARP请求。本程序学习完成之后每秒钟会发送一次ARP请求。Wireshark抓包结果如下
#figure(image("十秒一个2.png",format: "png",width: 100%,fit: "stretch"),caption: "固定间隔的ARP超时重传")<figure5>
注意@figure5 中左侧的`Time`一列从上到下程序发出的ARP请求的时间依次增加10秒。这表明ARP请求每10秒钟发送一次在上面代码中的这一行定义过的ARP表项超时时间生效ARP请求重传成功。
```c
#define XARP_CFG_ENTRY_OK_TMO (10) // ARP表项超时时间
```
至此ARP协议的实现完成。
]
== 实现IP协议
#para[
以太网之上除了ARP协议还有IP协议。IP协议是网络层协议负责将数据包从源主机传输到目的主机。IP协议的数据包称为IP数据报包含了源IP地址和目的IP地址。
与前面通过抓包来获取ARP数据包的各字段值的方法类似IP数据包各字段值也可以通过抓包获取但更方便的做法是查询RFC文档#footnote[文档地址:#link("https://www.rfc-editor.org/rfc/rfc791")[RFC 791: Internet Protocol]]来获取此处不再展示。下面来实现IP协议。
]
=== 定义IP数据报
#para[
`xnet_tiny.h` 中定义IP数据报的结构体
```c
typedef struct _xip_hdr_t {
uint8_t hdr_len : 4; // 首部长, 4字节为单位
uint8_t version : 4; // 版本号
uint8_t tos; // 服务类型
uint16_t total_len; // 总长度
uint16_t id; // 标识符
uint16_t flags_fragment; // 标志与分段
uint8_t ttl; // 存活时间
uint8_t protocol; // 上层协议
uint16_t hdr_checksum; // 首部校验和
uint8_t src_ip[XNET_IPV4_ADDR_SIZE]; // 源IP
uint8_t dest_ip[XNET_IPV4_ADDR_SIZE]; // 目标IP
} xip_hdr_t;
```
该结构体定义了IP数据报的各个字段包括
- `hdr_len`IP头部的长度以4字节为单位。
- `version`IP版本号通常为IPv4值为4
- `tos`:服务类型,用于指定数据报的优先级。
- `total_len`IP数据报的总长度。
- `id`标识符用于标识IP数据报。
- `flags_fragment`标志和分段信息用于IP分片。
- `ttl`:生存时间,用于防止数据报在网络中无限循环。
- `protocol`上层协议类型如ICMP、TCP或UDP。
- `hdr_checksum`IP头部的校验和用于检测数据报是否损坏。
- `src_ip` `dest_ip`源IP地址和目标IP地址。
]
=== 实现IP输入
#para[
IP输入函数 `xip_in` 负责处理接收到的IP数据报。在 `xnet_tiny.c` 中实现该函数:
```c
void xip_in(xnet_packet_t * packet) {
xip_hdr_t* iphdr = (xip_hdr_t*)packet->data;
uint32_t total_size, header_size;
uint16_t pre_checksum;
xipaddr_t src_ip;
// 检查IP版本号是否为IPv4
if (iphdr->version != XNET_VERSION_IPV4) {
return;
}
// 检查头部长度和总长度是否符合要求
header_size = iphdr->hdr_len * 4;
total_size = swap_order16(iphdr->total_len);
if (
(header_size < sizeof(xip_hdr_t))
|| ((total_size < header_size)
|| (packet->size < total_size))
)
return;
// 校验头部的校验和是否正确
pre_checksum = iphdr->hdr_checksum;
iphdr->hdr_checksum = 0;
if (pre_checksum != checksum16((uint16_t*)iphdr, header_size, 0, 1)) {
return;
}
// 检查目标IP地址是否为本机IP
if (!xipaddr_is_equal_buf(&netif_ipaddr, iphdr->dest_ip)) {
return;
}
// 根据协议类型分发到不同的处理函数
xipaddr_from_buf(&src_ip, iphdr->src_ip);
switch(iphdr->protocol) {
case XNET_PROTOCOL_ICMP:
remove_header(packet, header_size);
xicmp_in(&src_ip, packet);
break;
default:
break;
}
}
```
函数逻辑、功能比较简单概括如下检查IP版本号是否为IPv4。然后验证IP头部的长度和总长度是否符合要求。再校验IP头部的校验和是否正确、检查目标IP地址是否为本机IP。最后根据上层协议类型如ICMP将数据报分发到相应的处理函数。
]
=== 实现IP输出
#para[
IP输出函数 `xip_out` 负责发送IP数据报。在 `xnet_tiny.c` 中,我们实现了该函数:
```c
xnet_err_t xip_out(xnet_protocol_t protocol, xipaddr_t* dest_ip, xnet_packet_t * packet)
{
static uint32_t ip_packet_id = 0; // 静态变量用于生成唯一的IP包ID
xip_hdr_t * iphdr;
add_header(packet, sizeof(xip_hdr_t)); // 添加IP头部
iphdr = (xip_hdr_t*)packet->data; // 获取IP头部指针
iphdr->version = XNET_VERSION_IPV4; // 设置IP版本号为IPv4
iphdr->hdr_len = sizeof(xip_hdr_t) / 4; // 设置IP头部长度
iphdr->tos = 0; // 设置服务类型
iphdr->total_len = swap_order16(packet->size); // 设置总长度
iphdr->id = swap_order16(ip_packet_id); // 设置包ID
iphdr->flags_fragment = 0; // 设置标志和片偏移
iphdr->ttl = XNET_IP_DEFAULT_TTL; // 设置生存时间
iphdr->protocol = protocol; // 设置上层协议类型
memcpy(iphdr->dest_ip, dest_ip->array, XNET_IPV4_ADDR_SIZE); // 设置目标IP地址
// 设置源IP地址
memcpy(iphdr->src_ip, netif_ipaddr.array, XNET_IPV4_ADDR_SIZE);
iphdr->hdr_checksum = 0; // 初始化校验和字段
// 计算并设置校验和
iphdr->hdr_checksum = checksum16((uint16_t *)iphdr, sizeof(xip_hdr_t), 0, 1);
ip_packet_id++; // 增加包ID
return ethernet_out(dest_ip, packet); // 通过以太网发送IP包
}
```
该函数的主要功能是:
1. 添加IP头部到数据报中。
2. 设置IP头部的各个字段包括版本号、头部长度、总长度、包ID、生存时间、上层协议类型、源IP地址和目标IP地址。
3. 计算并设置IP头部的校验和。
4. 通过以太网发送IP数据报。
]
== 实现ICMP协议
#para[
实现了ARP和IP协议之后下面来实现ICMP协议。ICMP协议是网络层协议用于在IP网络中传递控制消息。ICMP数据报的数据部分包含了ICMP报文的类型、代码和校验和等字段。实现ICMP的主要目的在于实现ping功能即实现ICMP的ping响应。
]
=== 定义ICMP数据报
#para[
ICMPInternet Control Message Protocol是网络层协议用于在IP网络中传递控制消息。在 `xnet_tiny.h` 我们定义了ICMP数据报的结构体
```c
typedef struct _xicmp_hdr_t {
uint8_t type; // 类型
uint8_t code; // 代码
uint16_t checksum; // ICMP报文的校验和
uint16_t id; // 标识符
uint16_t seq; // 序号
} xicmp_hdr_t;
```
该结构体定义了ICMP数据报的各个字段包括
- `type`ICMP消息类型例如回显请求`8`)和回显响应(`0`)。
- `code`ICMP消息代码用于进一步细分消息类型。
- `checksum`ICMP报文的校验和用于检测报文是否损坏。
- `id` `seq`:标识符和序号,用于匹配请求和响应。
此外我们还定义了ICMP消息类型的常量
```c
#define XICMP_CODE_ECHO_REQUEST 8 // 回显请求
#define XICMP_CODE_ECHO_REPLY 0 // 回显响应
```
]
=== 实现ICMP输入
#para[
ICMP输入函数 `xicmp_in` 负责处理接收到的ICMP数据报。在 `xnet_tiny.c` 中,我们实现了该函数:
```c
void xicmp_in(xipaddr_t *src_ip, xnet_packet_t * packet) {
xicmp_hdr_t* icmphdr = (xicmp_hdr_t *)packet->data; // 获取ICMP头部指针
if (
(packet->size >= sizeof(xicmp_hdr_t))
&& (icmphdr->type == XICMP_CODE_ECHO_REQUEST)
)
{
reply_icmp_request(icmphdr, src_ip, packet); // 如果是ECHO请求发送ECHO回复
}
}
```
该函数的主要功能是:
1. 检查接收到的ICMP数据报是否完整。
2. 如果ICMP消息类型为回显请求`XICMP_CODE_ECHO_REQUEST`),则调用 `reply_icmp_request` 函数发送回显响应。
]
=== 实现ICMP-ping响应
#para[
ICMP-ping响应函数 `reply_icmp_request` 负责生成并发送ICMP回显响应。在 `xnet_tiny.c` 中,我们实现了该函数:
```c
static xnet_err_t reply_icmp_request( xicmp_hdr_t * icmp_hdr,
xipaddr_t* src_ip,
xnet_packet_t * packet)
{
xicmp_hdr_t * replay_hdr;
xnet_packet_t * tx = xnet_alloc_for_send(packet->size);
replay_hdr = (xicmp_hdr_t *)tx->data; // 获取ICMP头部指针
replay_hdr->type = XICMP_CODE_ECHO_REPLY; // 设置ICMP类型为ECHO回复
replay_hdr->code = 0; // 设置代码为0
replay_hdr->id = icmp_hdr->id; // 复制ID
replay_hdr->seq = icmp_hdr->seq; // 复制序列号
replay_hdr->checksum = 0; // 初始化校验和字段
// 复制数据部分
memcpy(
((uint8_t *)replay_hdr)+ sizeof(xicmp_hdr_t),
((uint8_t *)icmp_hdr) + sizeof(xicmp_hdr_t),
packet->size - sizeof(xicmp_hdr_t)
);
// 计算校验和
replay_hdr->checksum = checksum16((uint16_t*)replay_hdr, tx->size, 0, 1);
return xip_out(XNET_PROTOCOL_ICMP, src_ip, tx); // 发送ICMP回复包
}
```
该函数的主要功能是:
1. 分配一个新的数据包用于发送ICMP回显响应。
2. 设置ICMP回显响应的各个字段包括类型、代码、ID、序列号和校验和。
3. 复制原始ICMP请求的数据部分到响应中。
4. 计算并设置ICMP回显响应的校验和。
5. 通过IP层发送ICMP回显响应。
通过该函数我们可以实现对ICMP-ping请求的响应从而支持基本的网络连通性测试。
下面进行测试。重新编译后,按照以下流程进行测试:
- 开启Wireshark抓包
- 运行本程序;
- 在虚拟机上ping本程序以触发ICMP-ping请求
- 在虚拟机上查看ping结果看是否ping通
- 查看Wireshark抓包结果见下页
#figure(image("ping通.png",format: "png",width: 100%,fit: "stretch"),caption: "ICMP-ping响应")<figure6>
@figure6 中可以看到ICMP-ping响应发送成功程序输出中也表明学习到了虚拟机的MAC地址说明代码编写正确。
]
== 关于多ARP表项
#para[
代码在定义相关数据结构时(见@multiple_entry 已经考虑到了多ARP表项的情况。在函数的具体实现中均是使用循环遍历整个ARP表来进行表项的操作。
@figure4@figure6 中的程序输出中均有2个表项对同一个ARP表项的不同状态。如果考虑再添加一台虚拟机则可以在输出中看到更多表项。但本次实验所用物理机内存有限无法同时运行2个虚拟机所以不再演示。
]
= 实验总结
== 内容总结
#para[
本次实验主要围绕ARP协议的实现展开通过编写程序完善了TCP/IP协议栈的ARP协议部分。实验内容包括ARP的初始化、无回报ARP的生成、ARP的输入处理以及ARP的超时重新请求机制。在基础任务中成功实现了ARP协议的核心功能包括ARP请求与响应的构建与解析、ARP缓存表的管理等。此外还完成了拓展任务实现了多个ARP表项的管理以及IP层的输入输出处理。
在实验过程中首先通过Wireshark抓包分析了ARP报文的结构并基于此定义了ARP报文的数据结构和相关函数。接着实现了ARP报文的发送与接收功能包括ARP请求的生成与广播、ARP响应的处理以及ARP缓存表的更新。通过定时器机制实现了ARP表项的超时重传功能确保了ARP缓存的准确性和及时性。
在完成ARP协议的基础上进一步实现了IP协议和ICMP协议。通过定义IP数据报和ICMP数据报的结构实现了IP层的输入输出功能并成功实现了ICMP的ping响应功能。实验结果表明ARP、IP和ICMP协议的功能均得到了正确实现能够有效支持网络设备之间的通信。
]
== 心得感悟
#para[
通过本次实验我深刻理解了ARP协议的工作原理及其在网络通信中的重要作用。ARP协议作为TCP/IP协议栈中的重要组成部分负责将IP地址解析为MAC地址是网络设备之间通信的基础。通过亲手实现ARP协议的核心功能我不仅加深了对ARP协议的理解还掌握了网络协议栈的实现方法。
在实验过程中我遇到了一些挑战例如如何正确解析ARP报文、如何管理ARP缓存表以及如何处理ARP超时重传等。通过查阅资料、分析抓包数据以及反复调试代码我逐步解决了这些问题并成功实现了ARP协议的功能。这让我认识到网络协议的实现不仅需要扎实的理论基础还需要细致的调试和问题解决能力。
此外通过实现IP和ICMP协议我进一步了解了网络层协议的工作原理。IP协议负责数据包的传输而ICMP协议则用于传递控制消息。通过实现ICMP的ping响应功能我掌握了ICMP协议的基本实现方法并理解了其在网络连通性测试中的应用。
总的来说本次实验让我对TCP/IP协议栈有了更深入的理解并提升了我的编程能力和网络协议分析能力。这些知识和技能对我今后学习更复杂的网络协议以及从事网络相关工作具有重要意义。
]
#show heading: it => box(width: 100%)[
#v(0.50em)
#set text(font: hei)
// #counter(heading).display()
// #h(0.5em)
#it.body
]
#pagebreak()
#bibliography("ref.yml",full: true,title: "参考文献",style:"gb-7714-2015-numeric")
/*
根据这个网站的格式示范https://github.com/typst/hayagriva/blob/main/docs/file-format.md
为这个网页生成.yml文件
https://blog.csdn.net/jxjdhdnd/article/details/138009187
*/

BIN
network/arp/ping通.png Executable file

Binary file not shown.

After

Width:  |  Height:  |  Size: 323 KiB

44
network/arp/ref.yml Executable file
View File

@ -0,0 +1,44 @@
cmake_tutorial_csdn:
type: Web
title: "【一学就会】C++编译工具链——基于VSCode的CMake、make与g++简单理解与应用示例"
author: "未知作者"
url:
value: "https://blog.csdn.net/weixin_46248871/article/details/137500744"
date: 2024-12-31
abstract: "本文详细介绍了CMake、make与g++的基本概念、优劣比较以及应用示例包括工具安装配置、CMake使用示例、g++使用教程等。"
cmake_detailed_tutorial_csdn:
type: Web
title: "cmake使用详细教程日常使用这一篇就足够了"
author: "李吱恩"
url:
value: "https://blog.csdn.net/iuu77/article/details/129229361"
date: 2023-11-28
abstract: "本文为博主原创文章提供了cmake的详细使用教程包括cmake安装、使用cmake配合程序编译的多种情况如单个源文件程序编译、多个源文件、头文件在不同文件夹等场景。"
rfc791_internet_protocol:
type: Web
title: "INTERNET PROTOCOL"
author: "Jon Postel"
url:
value: "https://www.rfc-editor.org/rfc/rfc791"
date: 1981-09
abstract: "RFC 791 定义了互联网协议IP这是TCP/IP协议栈中的核心协议之一负责在网络中传输数据包。文档详细介绍了IP协议的规范和操作。"
windows_network_commands_cnblogs:
type: Web
title: "windows网络命令ping、ipconfig、tracert、netstat、arp"
author: "刘玉坦"
url:
value: "https://www.cnblogs.com/liuyutan/p/13289747.html"
date: 2024-12-31
abstract: "本文介绍了Windows系统中常用的网络诊断命令包括ping、ipconfig、tracert、netstat和arp以及它们的使用场景和参数说明。"
bilibili_tcp_ip_stack:
type: Web
title: "c03.00 IP层的输入处理(2)"
author: "哔哩哔哩用户"
url:
value: "https://www.bilibili.com/video/BV1KL4y1P7vG"
date: 2024-12-31
abstract: "视频教程完全从0开始手写一个超轻量级的TCP/IP网络协议栈支持以太网、ARP、IP、UDP、TCP协议并实现了一个超小型的HTTP服务器。"

397
network/arp/tmp.md Executable file
View File

@ -0,0 +1,397 @@
### ARP超时重传
在ARP协议中如果某个ARP表项在一定时间内没有收到响应或者表项的状态变为无效系统会触发ARP超时重传机制。这一机制确保在网络中能够及时更新或重新获取目标设备的MAC地址。
#### 超时重传的实现
`xnet_tiny.c`中,`xarp_poll`函数负责定期检查ARP表项的状态并根据需要触发重传。具体实现如下
```c
/
* 查询ARP表项是否超时,超时则重新请求
*/
void xarp_poll(void) {
// 检查ARP定时器是否超时
if (xnet_check_tmo(&arp_timer, XARP_TIMER_PERIOD)) {
for (arp_entry = arp_table; arp_entry < XARP_CFG_ENTRY_SIZE * sizeof(xarp_entry_t) + arp_table; arp_entry = arp_entry + sizeof(xarp_entry_t)) {
switch (arp_entry->state) {
case XARP_ENTRY_RESOLVING:
// 如果ARP表项正在解析中检查超时计数器
if (--arp_entry->tmo == 0) {
// 如果重试次数用完释放ARP表项
if (arp_entry->retry_cnt-- == 0) {
arp_entry->state = XARP_ENTRY_FREE;
}
else {
// 否则继续重试发送ARP请求
xarp_make_request(&arp_entry->ipaddr);
arp_entry->state = XARP_ENTRY_RESOLVING;
arp_entry->tmo = XARP_CFG_ENTRY_PENDING_TMO;
}
}
break;
case XARP_ENTRY_OK:
// 如果ARP表项有效检查超时计数器
if (--arp_entry->tmo == 0) {
// 超时后重新发送ARP请求
xarp_make_request(&arp_entry->ipaddr);
arp_entry->state = XARP_ENTRY_RESOLVING;
arp_entry->tmo = XARP_CFG_ENTRY_PENDING_TMO;
}
break;
}
}
}
}
```
#### 超时重传的流程
1. 定时检查:`xarp_poll`函数会定期检查ARP表项的状态检查周期由`XARP_TIMER_PERIOD`定义默认为1秒
2. 状态判断:
- 如果表项状态为`XARP_ENTRY_RESOLVING`正在解析中则检查超时计数器。如果超时且重试次数用完则释放该表项否则重新发送ARP请求并重置超时计数器。
- 如果表项状态为`XARP_ENTRY_OK`有效则检查超时计数器。如果超时则重新发送ARP请求并将表项状态设置为`XARP_ENTRY_RESOLVING`
3. 重传ARP请求通过调用`xarp_make_request`函数重新发送ARP请求以获取目标IP地址对应的MAC地址。
#### 超时重传的意义
ARP超时重传机制确保了在网络中即使某些设备暂时不可达系统也能通过多次尝试获取其MAC地址。这种机制在网络环境不稳定或设备频繁上下线的情况下尤为重要能够有效避免因ARP表项失效导致的通信中断。
#### 实验验证
为了验证ARP超时重传机制的正确性可以通过以下步骤进行测试
1. 启动程序运行程序并确保ARP表项初始化完成。
2. 模拟超时在ARP表项超时后观察是否触发了重传机制。
3. 抓包分析使用Wireshark抓包工具查看是否在超时后重新发送了ARP请求。
通过以上步骤可以验证ARP超时重传机制是否按预期工作。
```typ
#figure(image("ARP超时重传.png",format: "png",width: 100%,fit: "stretch"),caption: "ARP超时重传抓包结果")<figure5>
```
@figure5 中可以看到ARP请求在超时后重新发送说明超时重传机制工作正常。
以下是 `=== 定义IP数据报``=== 实现IP输入``=== 实现IP输出` 部分的 Markdown 内容:
```markdown
=== 定义IP数据报
IP数据报是网络层协议的核心数据结构包含了源IP地址、目标IP地址以及上层协议类型等信息。在 `xnet_tiny.h`我们定义了IP数据报的结构体
```c
typedef struct _xip_hdr_t {
uint8_t hdr_len : 4; // 首部长, 4字节为单位
uint8_t version : 4; // 版本号
uint8_t tos; // 服务类型
uint16_t total_len; // 总长度
uint16_t id; // 标识符
uint16_t flags_fragment; // 标志与分段
uint8_t ttl; // 存活时间
uint8_t protocol; // 上层协议
uint16_t hdr_checksum; // 首部校验和
uint8_t src_ip[XNET_IPV4_ADDR_SIZE]; // 源IP
uint8_t dest_ip[XNET_IPV4_ADDR_SIZE]; // 目标IP
} xip_hdr_t;
```
该结构体定义了IP数据报的各个字段包括
- `hdr_len`IP头部的长度以4字节为单位。
- `version`IP版本号通常为IPv4值为4
- `tos`:服务类型,用于指定数据报的优先级。
- `total_len`IP数据报的总长度。
- `id`标识符用于标识IP数据报。
- `flags_fragment`标志和分段信息用于IP分片。
- `ttl`:生存时间,用于防止数据报在网络中无限循环。
- `protocol`上层协议类型如ICMP、TCP或UDP。
- `hdr_checksum`IP头部的校验和用于检测数据报是否损坏。
- `src_ip``dest_ip`源IP地址和目标IP地址。
=== 实现IP输入
IP输入函数 `xip_in` 负责处理接收到的IP数据报。在 `xnet_tiny.c` 中,我们实现了该函数:
```c
void xip_in(xnet_packet_t * packet) {
xip_hdr_t* iphdr = (xip_hdr_t*)packet->data;
uint32_t total_size, header_size;
uint16_t pre_checksum;
xipaddr_t src_ip;
// 检查IP版本号是否为IPv4
if (iphdr->version != XNET_VERSION_IPV4) {
return;
}
// 检查头部长度和总长度是否符合要求
header_size = iphdr->hdr_len * 4;
total_size = swap_order16(iphdr->total_len);
if ((header_size < sizeof(xip_hdr_t)) || ((total_size < header_size) || (packet->size < total_size))) {
return;
}
// 校验头部的校验和是否正确
pre_checksum = iphdr->hdr_checksum;
iphdr->hdr_checksum = 0;
if (pre_checksum != checksum16((uint16_t*)iphdr, header_size, 0, 1)) {
return;
}
// 检查目标IP地址是否为本机IP
if (!xipaddr_is_equal_buf(&netif_ipaddr, iphdr->dest_ip)) {
return;
}
// 根据协议类型分发到不同的处理函数
xipaddr_from_buf(&src_ip, iphdr->src_ip);
switch(iphdr->protocol) {
case XNET_PROTOCOL_ICMP:
remove_header(packet, header_size);
xicmp_in(&src_ip, packet);
break;
default:
break;
}
}
```
该函数的主要功能是:
1. 检查IP版本号是否为IPv4。
2. 检查IP头部的长度和总长度是否符合要求。
3. 校验IP头部的校验和是否正确。
4. 检查目标IP地址是否为本机IP。
5. 根据上层协议类型如ICMP将数据报分发到相应的处理函数。
=== 实现IP输出
IP输出函数 `xip_out` 负责发送IP数据报。在 `xnet_tiny.c` 中,我们实现了该函数:
```c
xnet_err_t xip_out(xnet_protocol_t protocol, xipaddr_t* dest_ip, xnet_packet_t * packet) {
static uint32_t ip_packet_id = 0; // 静态变量用于生成唯一的IP包ID
xip_hdr_t * iphdr;
add_header(packet, sizeof(xip_hdr_t)); // 添加IP头部
iphdr = (xip_hdr_t*)packet->data; // 获取IP头部指针
iphdr->version = XNET_VERSION_IPV4; // 设置IP版本号为IPv4
iphdr->hdr_len = sizeof(xip_hdr_t) / 4; // 设置IP头部长度
iphdr->tos = 0; // 设置服务类型
iphdr->total_len = swap_order16(packet->size); // 设置总长度
iphdr->id = swap_order16(ip_packet_id); // 设置包ID
iphdr->flags_fragment = 0; // 设置标志和片偏移
iphdr->ttl = XNET_IP_DEFAULT_TTL; // 设置生存时间
iphdr->protocol = protocol; // 设置上层协议类型
memcpy(iphdr->dest_ip, dest_ip->array, XNET_IPV4_ADDR_SIZE); // 设置目标IP地址
memcpy(iphdr->src_ip, netif_ipaddr.array, XNET_IPV4_ADDR_SIZE); // 设置源IP地址
iphdr->hdr_checksum = 0; // 初始化校验和字段
iphdr->hdr_checksum = checksum16((uint16_t *)iphdr, sizeof(xip_hdr_t), 0, 1); // 计算并设置校验和
ip_packet_id++; // 增加包ID
return ethernet_out(dest_ip, packet); // 通过以太网发送IP包
}
```
该函数的主要功能是:
1. 添加IP头部到数据报中。
2. 设置IP头部的各个字段包括版本号、头部长度、总长度、包ID、生存时间、上层协议类型、源IP地址和目标IP地址。
3. 计算并设置IP头部的校验和。
4. 通过以太网发送IP数据报。
```
### 说明:
1. 代码块:使用 ```c 插入代码块,并指定语言为 C。
2. 标题:使用 `===` 表示三级标题。
3. 段落直接编写文本内容Markdown 会自动处理段落格式。
将此内容插入到 `main.txt` 文件的适当位置即可。
以下是 `=== 定义ICMP数据报`、`=== 实现ICMP输入` 和 `=== 实现ICMP-ping响应` 部分的 Typst 代码:
```typ
=== 定义ICMP数据报
#para[
ICMPInternet Control Message Protocol是网络层协议用于在IP网络中传递控制消息。在 `xnet_tiny.h` 中我们定义了ICMP数据报的结构体
#raw(block: true, lang: "c")[
```c
typedef struct _xicmp_hdr_t {
uint8_t type; // 类型
uint8_t code; // 代码
uint16_t checksum; // ICMP报文的校验和
uint16_t id; // 标识符
uint16_t seq; // 序号
} xicmp_hdr_t;
```
]
该结构体定义了ICMP数据报的各个字段包括
- `type`ICMP消息类型例如回显请求`8`)和回显响应(`0`)。
- `code`ICMP消息代码用于进一步细分消息类型。
- `checksum`ICMP报文的校验和用于检测报文是否损坏。
- `id` 和 `seq`:标识符和序号,用于匹配请求和响应。
此外我们还定义了ICMP消息类型的常量
#raw(block: true, lang: "c")[
```c
#define XICMP_CODE_ECHO_REQUEST 8 // 回显请求
#define XICMP_CODE_ECHO_REPLY 0 // 回显响应
```
]
]
=== 实现ICMP输入
#para[
ICMP输入函数 `xicmp_in` 负责处理接收到的ICMP数据报。在 `xnet_tiny.c` 中,我们实现了该函数:
#raw(block: true, lang: "c")[
```c
void xicmp_in(xipaddr_t *src_ip, xnet_packet_t * packet) {
xicmp_hdr_t* icmphdr = (xicmp_hdr_t *)packet->data; // 获取ICMP头部指针
if ((packet->size >= sizeof(xicmp_hdr_t)) && (icmphdr->type == XICMP_CODE_ECHO_REQUEST)) {
reply_icmp_request(icmphdr, src_ip, packet); // 如果是ECHO请求发送ECHO回复
}
}
```
]
该函数的主要功能是:
1. 检查接收到的ICMP数据报是否完整。
2. 如果ICMP消息类型为回显请求`XICMP_CODE_ECHO_REQUEST`),则调用 `reply_icmp_request` 函数发送回显响应。
]
=== 实现ICMP-ping响应
#para[
ICMP-ping响应函数 `reply_icmp_request` 负责生成并发送ICMP回显响应。在 `xnet_tiny.c` 中,我们实现了该函数:
#raw(block: true, lang: "c")[
```c
static xnet_err_t reply_icmp_request(xicmp_hdr_t * icmp_hdr, xipaddr_t* src_ip, xnet_packet_t * packet) {
xicmp_hdr_t * replay_hdr;
xnet_packet_t * tx = xnet_alloc_for_send(packet->size);
replay_hdr = (xicmp_hdr_t *)tx->data; // 获取ICMP头部指针
replay_hdr->type = XICMP_CODE_ECHO_REPLY; // 设置ICMP类型为ECHO回复
replay_hdr->code = 0; // 设置代码为0
replay_hdr->id = icmp_hdr->id; // 复制ID
replay_hdr->seq = icmp_hdr->seq; // 复制序列号
replay_hdr->checksum = 0; // 初始化校验和字段
memcpy(((uint8_t *)replay_hdr) + sizeof(xicmp_hdr_t), ((uint8_t *)icmp_hdr) + sizeof(xicmp_hdr_t),
packet->size - sizeof(xicmp_hdr_t)); // 复制数据部分
replay_hdr->checksum = checksum16((uint16_t*)replay_hdr, tx->size, 0, 1); // 计算校验和
return xip_out(XNET_PROTOCOL_ICMP, src_ip, tx); // 发送ICMP回复包
}
```
]
该函数的主要功能是:
1. 分配一个新的数据包用于发送ICMP回显响应。
2. 设置ICMP回显响应的各个字段包括类型、代码、ID、序列号和校验和。
3. 复制原始ICMP请求的数据部分到响应中。
4. 计算并设置ICMP回显响应的校验和。
5. 通过IP层发送ICMP回显响应。
通过该函数我们可以实现对ICMP-ping请求的响应从而支持基本的网络连通性测试。
]
```
### 说明:
1. 代码块:使用 `#raw(block: true, lang: "c")` 插入代码块,并指定语言为 C。
2. 标题:使用 `===` 表示三级标题。
3. 段落:使用 `#para[]` 包裹段落内容。
将此代码插入到 `main.txt` 文件的适当位置即可。
6 实验原理及方案
ARP地址解析协议是 TCP/IP 协议族中用于将 IP 地址解析为 MAC 地址的重要协议。IP 通信依赖于数据链路层的硬件地址MAC 地址),而 ARP 负责动态地将网络层的 IP 地址转换为对应的数据链路层 MAC 地址从而实现设备间的通信。ARP 协议的实现主要包括发送 ARP 请求、接收并处理 ARP 响应、更新 ARP 缓存、以及缓存超时机制。
本次实验围绕 TCP/IP 协议栈的 ARP 协议的实现这一问题展开,要求学员在理解 ARP 协议原理的基础上,深入探究 ARP 的技术细节,动手实现 ARP 协议的 Python 程序。
### 1ARP 的初始化
在一个典型的局域网中,设备通过 IP 地址进行网络层通信,但 IP 地址并不能直接用于数据链路层传输。以太网等数据链路层协议使用 MAC 地址进行通信,因此,发送设备需要将目标 IP 地址解析为 MAC 地址才能发送数据帧。
如果该设备的 ARP 缓存中没有目标设备的 MAC 地址映射,它会广播 ARP 请求,询问网络上哪个设备持有特定的 IP 地址。ARP 请求是一个以太网层的广播包,发送到子网内所有设备,只有持有目标 IP 地址的设备才会进行响应。
ARP 初始化的过程是设备发现并解析网络中其他设备的关键步骤。ARP 请求包含源设备的 IP 地址和 MAC 地址,而目标设备通过 ARP 响应提供其对应的 MAC 地址。这个机制确保设备能够通过网络层IP 地址和链路层MAC 地址)之间建立正确的映射关系。
### 2无回报 ARP 的生成
无回报 ARPGratuitous ARP又称为“主动 ARP”或“自愿 ARP”是一种特殊的 ARP 操作。与典型的 ARP 请求不同,无回报 ARP 并不是为了解析目标设备的 MAC 地址,而是设备主动向网络发送广播 ARP 包,通常用于更新网络中的 IP-MAC 映射关系、检测 IP 地址冲突等。
无回报 ARP 是设备主动广播自身的 IP 地址和 MAC 地址,不带有显式的 ARP 请求和响应互动。其主要目的是通知网络中其他设备更新其 ARP 缓存表中的信息。这种情况下,设备并不期待其他设备回应。它是单向广播的,通常被用于下列几种情况:
- 更新网络中的 ARP 表:当设备的 MAC 地址或 IP 地址发生变动时,可以主动发送无回报 ARP以便通知网络中其他设备更新其 ARP 缓存。
- IP 冲突检测:设备在启动时,通过发送无回报 ARP 来检测是否有其他设备占用了相同的 IP 地址。如果另一台设备使用了相同的 IP 地址,它会回应此 ARP 广播,从而帮助设备检测到 IP 冲突。
- 负载均衡器和高可用性系统:当系统切换主备设备时,备设备通常会发送无回报 ARP 来通知网络中的所有节点其 IP-MAC 映射已经改变,避免继续向已下线的设备发送数据。
无回报 ARP 的生成过程如下:
1. 生成 ARP 广播包:设备在确定需要广播自身 IP-MAC 映射时,会生成一个 ARP 广播包。该包包含设备自身的 IP 地址和 MAC 地址,并且目标硬件地址设置为全 0因为无回报 ARP 并不是请求对方设备的 MAC 地址,而是向网络中的所有设备广播自身的信息。
2. 设置操作码为 ARP 请求:尽管无回报 ARP 是主动广播,但它在帧结构中被标记为 ARP 请求(操作码为 1这使得网络中的其他设备会将其视为一种信息广播用于更新 ARP 缓存。
3. 发送广播ARP 广播包通过以太网层进行传输,目标 MAC 地址为 FF:FF:FF:FF:FF:FF即局域网内的所有设备都可以接收到此广播。
4. 网络中的设备处理:网络中所有收到此广播的设备会检查 ARP 包中的发送方 IP 地址和 MAC 地址,并将其更新到本地的 ARP 缓存表中。这样,即使该 IP 地址之前未出现在这些设备的 ARP 表中,它们也会记录并更新新的映射。
### 3ARP 的输入处理
ARP地址解析协议的输入处理指的是设备在接收到 ARP 请求或响应时,如何对该 ARP 报文进行解析和处理,并据此更新设备的 ARP 缓存或进一步采取必要的网络行为。ARP 输入处理的核心任务是解析报文,更新 ARP 缓存,并根据报文类型采取不同的操作。
在这部分有以下步骤:
- 接收 ARP 报文:设备通过网络接口接收到 ARP 报文,无论是广播还是单播形式。这些 ARP 报文可以是 ARP 请求、ARP 响应,或者是无回报 ARP。
- 解析 ARP 报文:设备对 ARP 报文进行解析,提取其中的关键信息。
- 检查报文有效性:设备检查 ARP 报文的有效性,包括检查硬件类型是否为以太网、协议类型是否为 IPv4、操作码是否为合法的请求或响应。如果报文不符合 ARP 协议规定,设备将丢弃该报文。
- 更新 ARP 缓存:根据 ARP 报文中的信息,设备更新自己的 ARP 缓存表。设备通常会把报文中的发送方 IP 地址和发送方 MAC 地址映射记录下来,以便将来进行快速的 IP 到 MAC 地址解析。
- 据操作码进行处理:不同类型的 ARP 报文有不同的处理方式:
- 如果接收到的是 ARP 请求,设备需要检查目标 IP 地址是否与自身的 IP 地址匹配,如果匹配,则需要发送一个 ARP 响应包,告知请求设备自己的 MAC 地址。
- 如果接收到的是 ARP 响应,设备会根据响应包中的信息,更新或添加到 ARP 缓存表,并不再发送进一步的响应。
- 如果接收到的是无回报 ARP设备会将报文中的 IP-MAC 映射记录下来,以更新其 ARP 缓存。
### 4ARP 的超时重新请求机制
ARP地址解析协议的超时重新请求机制指的是设备在尝试解析某个 IP 地址到 MAC 地址时,若未能在设定的时间内收到响应,会采取的重发 ARP 请求的策略。这种机制旨在保证网络设备在通信中能够及时获取目标设备的 MAC 地址,并维持 ARP 缓存的准确性。
ARP 缓存存储的是 IP 地址与 MAC 地址之间的映射关系。在通信过程中,网络设备通常会先查询 ARP 缓存以查找目标设备的 MAC 地址。如果缓存中存在该 IP 地址的记录,设备会直接使用缓存中的 MAC 地址进行通信;如果没有找到相应记录,设备会发出 ARP 请求,广播请求目标 IP 地址对应的 MAC 地址。
如果设备在发送 ARP 请求后,未能在指定的时间内收到 ARP 响应,它会认为该 ARP 请求失败。这时,设备会重新发送 ARP 请求,通常会进行一定次数的重发,以确保能够成功解析目标设备的 MAC 地址。
步骤如下:
1. 发送 ARP 请求:当设备需要与一个目标 IP 地址进行通信时,它首先会查询 ARP 缓存表。如果缓存中没有该 IP 地址的对应条目,设备会发出一个 ARP 请求,以广播方式在本地网络中请求目标设备的 MAC 地址。
2. 等待响应:设备在发送 ARP 请求后,进入等待状态。在这个状态下,设备会等待目标设备的 ARP 响应,通常是几百毫秒到几秒的时间(具体取决于设备的实现和网络情况)。
3. 超时判断:如果在规定的时间内设备没有收到目标设备的 ARP 响应,它会触发超时事件,认为该请求失败。此时,设备进入重新请求机制,准备发出新的 ARP 请求。
4. 重发 ARP 请求:超时后,设备会重新发送 ARP 请求,再次请求目标 IP 地址的 MAC 地址。这个过程通常会重复数次,直到收到响应或者达到最大重试次数为止。设备之间的重试次数和重试间隔时间是预先设定的,例如,设备可能设置为重试 3 到 5 次,每次间隔 1 秒。
5. 处理无响应的情况:如果设备在多次重发后,依然没有收到 ARP 响应,它将放弃请求,并在上层协议(如 IP、TCP 或 UDP层上返回错误表明目标设备不可达。这通常会导致应用层超时或连接失败。设备可能会记录这一信息并在稍后再尝试通信时重新发起 ARP 请求。
6. ARP 缓存条目的超时:即使设备成功解析了目标设备的 MAC 地址ARP 缓存中的条目也并非永久有效。每个 ARP 条目都有一个生存时间TTL通常为几分钟到几十分钟。超过这个时间后如果该条目未被更新设备会将其删除。当设备再次需要该目标设备的 MAC 地址时,会重新发出 ARP 请求。
= 实验总结
== 内容总结
本次实验主要围绕ARP协议的实现展开通过编写程序完善了TCP/IP协议栈的ARP协议部分。实验内容包括ARP的初始化、无回报ARP的生成、ARP的输入处理以及ARP的超时重新请求机制。在基础任务中成功实现了ARP协议的核心功能包括ARP请求与响应的构建与解析、ARP缓存表的管理等。此外还完成了拓展任务实现了多个ARP表项的管理以及IP层的输入输出处理。
在实验过程中首先通过Wireshark抓包分析了ARP报文的结构并基于此定义了ARP报文的数据结构和相关函数。接着实现了ARP报文的发送与接收功能包括ARP请求的生成与广播、ARP响应的处理以及ARP缓存表的更新。通过定时器机制实现了ARP表项的超时重传功能确保了ARP缓存的准确性和及时性。
在完成ARP协议的基础上进一步实现了IP协议和ICMP协议。通过定义IP数据报和ICMP数据报的结构实现了IP层的输入输出功能并成功实现了ICMP的ping响应功能。实验结果表明ARP、IP和ICMP协议的功能均得到了正确实现能够有效支持网络设备之间的通信。
== 心得感悟
通过本次实验我深刻理解了ARP协议的工作原理及其在网络通信中的重要作用。ARP协议作为TCP/IP协议栈中的重要组成部分负责将IP地址解析为MAC地址是网络设备之间通信的基础。通过亲手实现ARP协议的核心功能我不仅加深了对ARP协议的理解还掌握了网络协议栈的实现方法。
在实验过程中我遇到了一些挑战例如如何正确解析ARP报文、如何管理ARP缓存表以及如何处理ARP超时重传等。通过查阅资料、分析抓包数据以及反复调试代码我逐步解决了这些问题并成功实现了ARP协议的功能。这让我认识到网络协议的实现不仅需要扎实的理论基础还需要细致的调试和问题解决能力。
此外通过实现IP和ICMP协议我进一步了解了网络层协议的工作原理。IP协议负责数据包的传输而ICMP协议则用于传递控制消息。通过实现ICMP的ping响应功能我掌握了ICMP协议的基本实现方法并理解了其在网络连通性测试中的应用。
总的来说本次实验让我对TCP/IP协议栈有了更深入的理解并提升了我的编程能力和网络协议分析能力。这些知识和技能对我今后学习更复杂的网络协议以及从事网络相关工作具有重要意义。

BIN
network/arp/一秒一个.png Executable file

Binary file not shown.

After

Width:  |  Height:  |  Size: 180 KiB

BIN
network/arp/分析结构2.png Executable file

Binary file not shown.

After

Width:  |  Height:  |  Size: 64 KiB

BIN
network/arp/十秒一个.png Executable file

Binary file not shown.

After

Width:  |  Height:  |  Size: 183 KiB

BIN
network/arp/十秒一个2.png Executable file

Binary file not shown.

After

Width:  |  Height:  |  Size: 163 KiB

BIN
network/arp/启动ARP.png Executable file

Binary file not shown.

After

Width:  |  Height:  |  Size: 173 KiB

BIN
network/arp/启动ARP2.png Executable file

Binary file not shown.

After

Width:  |  Height:  |  Size: 143 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 63 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 231 KiB

Binary file not shown.

After

Width:  |  Height:  |  Size: 402 KiB

61
network/check.md Normal file
View File

@ -0,0 +1,61 @@
以下是具体的验证步骤:
1. 环境准备
1. 配置 IP 地址:
* 确保你的物理机(运行你程序的主机)有一个网络接口的 IP 地址在 192.168.254.0/24 网段,例如 192.168.254.1。
* 设置一台虚拟机(如 VirtualBox 或 VMWare将其网络模式设置为“桥接模式”并桥接到你物理机上一步设置的网卡。
* 在虚拟机中,手动配置 IP 地址,使其与你的物理机在同一网段,例如 192.168.254.3。 █
2. 测试连通性: █
* 在物理机上 ping 虚拟机的 IP (ping 192.168.254.3)。 █
* 在虚拟机上 ping 物理机的 IP (ping 192.168.254.1)。 █
* 确保两者可以互相 ping 通。 █
3. 编译并准备运行: █
* 确保你的代码已经编译,并且可执行文件位于 start/xnet_tiny/build/xnet。 █
2. 验证 ARP 协议 ▀
ARP 协议负责将 IP 地址解析为 MAC 硬件地址。
1. 启动抓包: 在你的物理机上打开 Wireshark选择连接虚拟机的那个网络接口开始抓包。你可以使用过滤条件 arp 来只看 ARP 包。
2. 运行你的程序: 打开一个终端,进入 network 目录,然后运行你的可执行文件:
1 ./start/xnet_tiny/build/xnet
3. 验证无回报 ARP (Gratuitous ARP):
* 预期行为: 程序启动时,会立刻发送一个 ARP 请求来宣告自己的 IP 地址 (192.168.254.2)。
* 验证方法: 在 Wireshark 中,你应该能立刻看到一个源地址是你本机 MAC、内容为 "Who has 192.168.254.2? Tell 192.168.254.2" 的 ARP 包。
4. 验证 ARP 响应:
* 预期行为: 当其他设备请求你程序的 IP 地址时,你的程序应该回复其 MAC 地址。
* 验证方法: 在虚拟机中ping 你程序模拟的 IP 地址:
1 ping 192.168.254.2
* 在 Wireshark 中,你应该能看到:
1. 一个来自虚拟机的 ARP 请求:"Who has 192.168.254.2? Tell 192.168.254.3"。
2. 一个来自你程序的 ARP 响应:"192.168.254.2 is at [你的MAC地址]"。
* 同时,检查你程序的终端输出,看是否打印出了 "learned mac addr" 的信息,表示它学习到了虚拟机的 MAC 地址。
5. 验证 ARP 超时重传:
* 预期行为: 文档中设置的 ARP 缓存条目超时时间为 10 秒 (XARP_CFG_ENTRY_OK_TMO)。超时后,程序会重新发送 ARP 请求来确认对方是否还在。
* 验证方法: 完成上一步后,让你和虚拟机的程序都保持运行。在 Wireshark 中,你应该能观察到你的程序大约每隔 10 秒就会发送一个 ARP
请求到虚拟机的 IP (192.168.254.3)。
3. 验证 ICMP (Ping) 协议
ICMP 协议用于网络控制和诊断ping 就是基于 ICMP 的。
1. 启动抓包: 在 Wireshark 中,使用过滤条件 icmp。 ▄
2. 运行程序并 Ping: 保持你的 xnet 程序运行。在虚拟机中ping 你程序的 IP 地址: █
1 ping 192.168.254.2 █
3. 验证 ICMP 响应: █
* 预期行为: 你的程序应该能响应来自虚拟机的 ICMP Echo Request (ping 请求)。 █
* 验证方法: █
1. 在虚拟机的终端里,你应该能看到 ping 命令成功接收到回复,没有丢包。 █
2. 在 Wireshark 中,你应该能看到成对的 ICMP 包: █
* Echo (ping) request 从虚拟机 (192.168.254.3) 发往你的程序 (192.168.254.2)。
* Echo (ping) reply 从你的程序 (192.168.254.2) 回复给虚拟机 (192.168.254.3)。

View File

@ -0,0 +1,130 @@
# ARP及ICMP协议实现报告
本文档详细记录了在一个C语言网络协议栈项目中从零开始实现地址解析协议ARP和Internet控制报文协议ICMP的完整过程。项目基于一个为Windows环境设计的初始模板整个过程不仅包括了协议逻辑的实现还涉及了代码的Linux兼容性改造和整体架构的模块化重构。
## 1. 初始代码分析
项目开始于一个名为`start`的目录,其中包含一个简化的网络协议栈框架。
### 1.1. 项目结构勘探
首先,我们分析了`start`目录下的源代码,特别是`xnet_tiny/src`子目录。我们识别出以下几个核心文件:
- `xnet_tiny.h`: 定义了协议栈的基本数据结构,如以太网帧头`xether_hdr_t`和网络数据包`xnet_packet_t`
- `xnet_tiny.c`: 包含了协议栈的核心驱动逻辑,如`xnet_init()`(初始化)和`xnet_poll()`(轮询)。
- `app.c`: 项目的主入口,调用`xnet_init()``xnet_poll()`来启动和运行协议栈。
- `xnet_app/port_pcap.c`: 负责与`pcap`库交互,进行底层网络数据包的收发。
### 1.2. 关键实现点定位
`xnet_tiny.c`中,我们发现了`ethernet_in`函数,它负责处理接收到的以太网数据帧。函数内部的`switch`语句根据以太网帧头的协议类型字段来分发数据包:
```c
switch (swap_order16(hdr->protocol)) {
case XNET_PROTOCOL_ARP:
// 此处为空是ARP实现入口
break;
case XNET_PROTOCOL_IP: {
// 此处为空是IP及ICMP实现入口
break;
}
}
```
这两个`case`分支是空的这正是我们需要插入ARP和IP/ICMP处理逻辑的地方。
## 2. ARP协议实现
为了保持代码的模块化我们将ARP相关的逻辑实现在单独的文件中。
### 2.1. 创建ARP模块
我们创建了以下两个文件:
- `xarp.h`: 定义ARP协议包结构`xarp_packet_t`和ARP缓存条目`xarp_entry_t`,并声明了外部接口`xarp_init()``xarp_in()`
- `xarp.c`: 实现ARP的具体逻辑。
### 2.2. 实现ARP核心逻辑
`xarp.c`中,我们完成了以下工作:
1. **ARP缓存ARP Table**: 定义了一个静态数组`arp_table[]`作为ARP缓存用于存储IP地址到MAC地址的映射。
2. **`xarp_init()`**: 此函数在协议栈初始化时被调用负责清空ARP缓存中的所有条目。
3. **`xarp_in()`**: 这是处理ARP报文的核心。
- 当接收到一个ARP请求报文时检查其请求的目标IP地址是否为本机IP。如果是则构建一个ARP响应报文填入本机的MAC地址然后通过`ethernet_out_to()`函数发送出去。
- 无论是请求还是响应都会从报文中提取发送方的IP和MAC地址并更新到ARP缓存中`update_entry`函数)。
4. **`xarp_resolve()`**: 为了让上层协议如IP能够通过IP地址查询MAC地址我们添加了此函数。它会首先查询ARP缓存。如果找到匹配的条目则返回对应的MAC地址如果未找到则调用`send_arp_request()`广播一个ARP请求并返回`NULL`,由上层决定是否重试。
### 2.3. 集成到协议栈
我们将ARP模块集成到主协议栈中
1.`xnet_tiny.c`中包含了`xarp.h`
2.`xnet_init()`函数的末尾调用`xarp_init()`
3.`ethernet_in()``switch`语句中,为`XNET_PROTOCOL_ARP`添加了对`xarp_in(packet)`的调用。
为了让`xarp.c`能够调用`xnet_tiny.c`中的`ethernet_out_to`等函数,我们将这些函数的`static`关键字移除,并在`xnet_tiny.h`中添加了它们的声明,使其成为公共接口。
## 3. ICMP及IP层实现
与ARP类似我们为ICMP和IP创建了独立的模块。
### 3.1. 创建ICMP和IP模块
- `xicmp.h`: 定义了IP报头`xip_hdr_t`和ICMP报文结构`xicmp_packet_t`
- `xicmp.c`: 实现了`xicmp_in()`函数用于处理传入的ICMP报文。
- `xip.h` / `xip.c`: 创建了一个简单的IP输出模块核心是`xip_out()`函数用于发送IP包。
### 3.2. 实现ICMP Echo Reply
`xicmp_in()`是ICMP实现的核心其工作流程如下
1. **IP报头解析**: 首先剥离以太网头部解析IP报头。验证版本号、头部长度和头部校验和。
2. **目标IP检查**: 确认该IP包的目标地址是本机。
3. **ICMP报文处理**:
- 剥离IP头部解析ICMP报文。
- 检查ICMP类型是否为**Echo Request**Ping请求
- 如果是,则准备一个**Echo Reply**Ping应答报文。大部分数据如ID、序列号和数据负载可以直接从请求报文中复制。
- 将ICMP类型设置为`ICMP_TYPE_ECHO_REPLY`然后重新计算ICMP校验和。
4. **构建IP响应包**:
- 构建IP头部源和目的IP地址与收到的请求包相反。
- 重新计算IP头部校验和。
5. **发送响应**: 调用`xip_out()`函数将响应包发送出去。`xip_out`内部会使用`xarp_resolve`来查找下一跳的MAC地址。
### 3.3. 集成到协议栈
1.`xnet_tiny.c`中包含了`xicmp.h`
2.`ethernet_in()``switch`语句中,为`XNET_PROTOCOL_IP`添加了对`xicmp_in(packet)`的调用。
3.`xicmp.c`中,使用新创建的`xip_out()`函数来发送响应包,而不是直接调用底层的`ethernet_out_to()`,实现了更好的分层。
## 4. Linux兼容性改造与重构
原始代码是为Windows设计的为了在Linux上运行我们进行了以下关键修改
1. **修正`pcap_device.c`**:
- 该文件包含了大量`#if defined(WIN32)`的条件编译块,用于加载`npcap`动态库。
- 我们删除了所有Windows特定的代码`#pragma comment`, `GetSystemDirectory`, `MessageBox`等),只保留了`#else`分支下的标准`pcap`实现使其在Linux下能够直接编译通过。
2. **修正`port_pcap.c`**:
- 原始代码中的`my_mac_addr`数组长度为8字节这是错误的。我们将其修正为标准的6字节以太网MAC地址。
- 将硬编码的pcap设备IP地址从`192.168.254.1`修改为`192.168.254.2`与我们协议栈配置的IP保持一致。
3. **IP地址集中管理**:
- 最初本机IP地址在`xarp.c``xicmp.c`中都有硬编码定义。
- 我们将其移至`xnet_tiny.c`中定义,并在`xnet_tiny.h`中通过`extern`声明,实现了全局统一配置。
## 5. 编译与测试
完成编码后,即可进行编译测试:
1. **安装依赖**: 确保Linux系统上已安装`libpcap`的开发库(如`sudo apt install libpcap-dev`)。
2. **编译**:
- 进入`start/build`目录。
- 运行`cmake ..`来生成Makefile。
- 运行`make`进行编译。
3. **运行与测试**:
- 编译成功后,会在`build`目录下生成可执行文件`xnet.exe`
- 使用`sudo ./xnet.exe`运行需要root权限以访问网络接口
- 在另一台处于同一局域网的主机上,执行`ping 192.168.254.2`即可测试ICMP Echo功能。同时可以通过`tcpdump``Wireshark`抓包观察ARP请求和响应过程。
## 6. 总结
通过以上步骤我们成功地在一个基础网络框架上完整地实现了ARP和ICMP Echo功能。整个过程不仅加深了对网络协议底层工作原理的理解也锻炼了在现有代码基础上进行功能扩展、重构和跨平台移植的能力。最终的代码结构清晰模块化程度高易于理解和进一步扩展。

8
network/start/.idea/.gitignore generated vendored Normal file
View File

@ -0,0 +1,8 @@
# Default ignored files
/shelf/
/workspace.xml
# Editor-based HTTP Client requests
/httpRequests/
# Datasource local storage ignored files
/dataSources/
/dataSources.local.xml

49
network/start/.idea/deployment.xml generated Normal file
View File

@ -0,0 +1,49 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="PublishConfigData" remoteFilesAllowedToDisappearOnAutoupload="false">
<serverData>
<paths name="ubuntu@10.107.4.40:60602 password">
<serverdata>
<mappings>
<mapping local="$PROJECT_DIR$" web="/" />
</mappings>
</serverdata>
</paths>
<paths name="ubuntu@10.107.4.40:60602 password (2)">
<serverdata>
<mappings>
<mapping local="$PROJECT_DIR$" web="/" />
</mappings>
</serverdata>
</paths>
<paths name="ubuntu@10.107.4.40:60602 password (3)">
<serverdata>
<mappings>
<mapping local="$PROJECT_DIR$" web="/" />
</mappings>
</serverdata>
</paths>
<paths name="ubuntu@10.107.4.40:60602 password (4)">
<serverdata>
<mappings>
<mapping local="$PROJECT_DIR$" web="/" />
</mappings>
</serverdata>
</paths>
<paths name="ubuntu@10.107.4.40:60602 password (5)">
<serverdata>
<mappings>
<mapping local="$PROJECT_DIR$" web="/" />
</mappings>
</serverdata>
</paths>
<paths name="ubuntu@10.107.4.40:60602 password (6)">
<serverdata>
<mappings>
<mapping local="$PROJECT_DIR$" web="/" />
</mappings>
</serverdata>
</paths>
</serverData>
</component>
</project>

View File

@ -0,0 +1,25 @@
<component name="InspectionProjectProfileManager">
<profile version="1.0">
<option name="myName" value="Project Default" />
<inspection_tool class="PyPackageRequirementsInspection" enabled="true" level="WARNING" enabled_by_default="true">
<option name="ignoredPackages">
<value>
<list size="12">
<item index="0" class="java.lang.String" itemvalue="mkl-fft" />
<item index="1" class="java.lang.String" itemvalue="pandas" />
<item index="2" class="java.lang.String" itemvalue="tqdm" />
<item index="3" class="java.lang.String" itemvalue="GitPython" />
<item index="4" class="java.lang.String" itemvalue="zipp" />
<item index="5" class="java.lang.String" itemvalue="matplotlib" />
<item index="6" class="java.lang.String" itemvalue="llvmlite" />
<item index="7" class="java.lang.String" itemvalue="mkl-random" />
<item index="8" class="java.lang.String" itemvalue="torchvision" />
<item index="9" class="java.lang.String" itemvalue="importlib-metadata" />
<item index="10" class="java.lang.String" itemvalue="mkl-service" />
<item index="11" class="java.lang.String" itemvalue="torch" />
</list>
</value>
</option>
</inspection_tool>
</profile>
</component>

7
network/start/.idea/misc.xml generated Normal file
View File

@ -0,0 +1,7 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="CMakeWorkspace" PROJECT_DIR="$PROJECT_DIR$" />
<component name="JavaScriptSettings">
<option name="languageLevel" value="ES6" />
</component>
</project>

8
network/start/.idea/modules.xml generated Normal file
View File

@ -0,0 +1,8 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="ProjectModuleManager">
<modules>
<module fileurl="file://$PROJECT_DIR$/.idea/xnet-tiny.iml" filepath="$PROJECT_DIR$/.idea/xnet-tiny.iml" />
</modules>
</component>
</project>

6
network/start/.idea/vcs.xml generated Normal file
View File

@ -0,0 +1,6 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="VcsDirectoryMappings">
<mapping directory="$PROJECT_DIR$" vcs="Git" />
</component>
</project>

2
network/start/.idea/xnet-tiny.iml generated Normal file
View File

@ -0,0 +1,2 @@
<?xml version="1.0" encoding="UTF-8"?>
<module classpath="CMake" type="CPP_MODULE" version="4" />

View File

@ -0,0 +1 @@
{"requests":[{"kind":"cache","version":2},{"kind":"codemodel","version":2},{"kind":"toolchains","version":1},{"kind":"cmakeFiles","version":1}]}

File diff suppressed because it is too large Load Diff

View File

@ -0,0 +1,171 @@
{
"inputs" :
[
{
"path" : "CMakeLists.txt"
},
{
"isGenerated" : true,
"path" : "D:/c_work/start/build/CMakeFiles/3.30.3/CMakeSystem.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/cmake/share/cmake-3.30/Modules/CMakeSystemSpecificInitialize.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/cmake/share/cmake-3.30/Modules/Platform/Windows-Initialize.cmake"
},
{
"isGenerated" : true,
"path" : "D:/c_work/start/build/CMakeFiles/3.30.3/CMakeCCompiler.cmake"
},
{
"isGenerated" : true,
"path" : "D:/c_work/start/build/CMakeFiles/3.30.3/CMakeCXXCompiler.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/cmake/share/cmake-3.30/Modules/CMakeSystemSpecificInformation.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/cmake/share/cmake-3.30/Modules/CMakeGenericSystem.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/cmake/share/cmake-3.30/Modules/CMakeInitializeConfigs.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/cmake/share/cmake-3.30/Modules/Platform/Windows.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/cmake/share/cmake-3.30/Modules/Platform/WindowsPaths.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/cmake/share/cmake-3.30/Modules/CMakeCInformation.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/cmake/share/cmake-3.30/Modules/CMakeLanguageInformation.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/cmake/share/cmake-3.30/Modules/Compiler/GNU-C.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/cmake/share/cmake-3.30/Modules/Compiler/GNU.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/cmake/share/cmake-3.30/Modules/Compiler/CMakeCommonCompilerMacros.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/cmake/share/cmake-3.30/Modules/Platform/Windows-GNU-C.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/cmake/share/cmake-3.30/Modules/Platform/Windows-GNU.cmake"
},
{
"isGenerated" : true,
"path" : "D:/c_work/start/build/CMakeFiles/3.30.3/CMakeRCCompiler.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/cmake/share/cmake-3.30/Modules/CMakeRCInformation.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/cmake/share/cmake-3.30/Modules/Platform/Windows-windres.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/cmake/share/cmake-3.30/Modules/Platform/Windows-GNU-C-ABI.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/cmake/share/cmake-3.30/Modules/CMakeCommonLanguageInclude.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/cmake/share/cmake-3.30/Modules/CMakeCXXInformation.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/cmake/share/cmake-3.30/Modules/CMakeLanguageInformation.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/cmake/share/cmake-3.30/Modules/Compiler/GNU-CXX.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/cmake/share/cmake-3.30/Modules/Compiler/GNU.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/cmake/share/cmake-3.30/Modules/Platform/Windows-GNU-CXX.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/cmake/share/cmake-3.30/Modules/Platform/Windows-GNU.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/cmake/share/cmake-3.30/Modules/Platform/Windows-GNU-CXX-ABI.cmake"
},
{
"isCMake" : true,
"isExternal" : true,
"path" : "D:/cmake/share/cmake-3.30/Modules/CMakeCommonLanguageInclude.cmake"
},
{
"path" : "src/xnet_tiny/CMakeLists.txt"
},
{
"path" : "src/xnet_app/CMakeLists.txt"
}
],
"kind" : "cmakeFiles",
"paths" :
{
"build" : "D:/c_work/start/build",
"source" : "D:/c_work/start/xnet_tiny_c0101"
},
"version" :
{
"major" : 1,
"minor" : 1
}
}

View File

@ -0,0 +1,113 @@
{
"configurations" :
[
{
"directories" :
[
{
"build" : ".",
"childIndexes" :
[
1,
2
],
"jsonFile" : "directory-.-Debug-d0094a50bb2071803777.json",
"minimumCMakeVersion" :
{
"string" : "3.7"
},
"projectIndex" : 0,
"source" : ".",
"targetIndexes" :
[
0
]
},
{
"build" : "src/xnet_tiny",
"jsonFile" : "directory-src.xnet_tiny-Debug-4578e9ca0e0117847dde.json",
"minimumCMakeVersion" :
{
"string" : "3.7"
},
"parentIndex" : 0,
"projectIndex" : 0,
"source" : "src/xnet_tiny",
"targetIndexes" :
[
2
]
},
{
"build" : "src/xnet_app",
"jsonFile" : "directory-src.xnet_app-Debug-25a699856ccc8073c2c5.json",
"minimumCMakeVersion" :
{
"string" : "3.7"
},
"parentIndex" : 0,
"projectIndex" : 0,
"source" : "src/xnet_app",
"targetIndexes" :
[
1
]
}
],
"name" : "Debug",
"projects" :
[
{
"directoryIndexes" :
[
0,
1,
2
],
"name" : "xnet",
"targetIndexes" :
[
0,
1,
2
]
}
],
"targets" :
[
{
"directoryIndex" : 0,
"id" : "xnet::@6890427a1f51a3e7e1df",
"jsonFile" : "target-xnet-Debug-771d309b0cef52622588.json",
"name" : "xnet",
"projectIndex" : 0
},
{
"directoryIndex" : 2,
"id" : "xnet_app::@59b125fae35e6df3589a",
"jsonFile" : "target-xnet_app-Debug-b2ab4605d66a83b6a590.json",
"name" : "xnet_app",
"projectIndex" : 0
},
{
"directoryIndex" : 1,
"id" : "xnet_tiny::@746c93521a1b098f3dd3",
"jsonFile" : "target-xnet_tiny-Debug-a1849f5457373dbea433.json",
"name" : "xnet_tiny",
"projectIndex" : 0
}
]
}
],
"kind" : "codemodel",
"paths" :
{
"build" : "D:/c_work/start/build",
"source" : "D:/c_work/start/xnet_tiny_c0101"
},
"version" :
{
"major" : 2,
"minor" : 7
}
}

View File

@ -0,0 +1,14 @@
{
"backtraceGraph" :
{
"commands" : [],
"files" : [],
"nodes" : []
},
"installers" : [],
"paths" :
{
"build" : ".",
"source" : "."
}
}

View File

@ -0,0 +1,14 @@
{
"backtraceGraph" :
{
"commands" : [],
"files" : [],
"nodes" : []
},
"installers" : [],
"paths" :
{
"build" : "src/xnet_app",
"source" : "src/xnet_app"
}
}

View File

@ -0,0 +1,14 @@
{
"backtraceGraph" :
{
"commands" : [],
"files" : [],
"nodes" : []
},
"installers" : [],
"paths" :
{
"build" : "src/xnet_tiny",
"source" : "src/xnet_tiny"
}
}

View File

@ -0,0 +1,132 @@
{
"cmake" :
{
"generator" :
{
"multiConfig" : false,
"name" : "MinGW Makefiles"
},
"paths" :
{
"cmake" : "D:/cmake/bin/cmake.exe",
"cpack" : "D:/cmake/bin/cpack.exe",
"ctest" : "D:/cmake/bin/ctest.exe",
"root" : "D:/cmake/share/cmake-3.30"
},
"version" :
{
"isDirty" : false,
"major" : 3,
"minor" : 30,
"patch" : 3,
"string" : "3.30.3",
"suffix" : ""
}
},
"objects" :
[
{
"jsonFile" : "codemodel-v2-26e095933dd6160a6495.json",
"kind" : "codemodel",
"version" :
{
"major" : 2,
"minor" : 7
}
},
{
"jsonFile" : "cache-v2-85c8c8b4b757524c1070.json",
"kind" : "cache",
"version" :
{
"major" : 2,
"minor" : 0
}
},
{
"jsonFile" : "cmakeFiles-v1-0a429aa47da5e5edf8a5.json",
"kind" : "cmakeFiles",
"version" :
{
"major" : 1,
"minor" : 1
}
},
{
"jsonFile" : "toolchains-v1-4e4f3158ee096c2b8391.json",
"kind" : "toolchains",
"version" :
{
"major" : 1,
"minor" : 0
}
}
],
"reply" :
{
"client-vscode" :
{
"query.json" :
{
"requests" :
[
{
"kind" : "cache",
"version" : 2
},
{
"kind" : "codemodel",
"version" : 2
},
{
"kind" : "toolchains",
"version" : 1
},
{
"kind" : "cmakeFiles",
"version" : 1
}
],
"responses" :
[
{
"jsonFile" : "cache-v2-85c8c8b4b757524c1070.json",
"kind" : "cache",
"version" :
{
"major" : 2,
"minor" : 0
}
},
{
"jsonFile" : "codemodel-v2-26e095933dd6160a6495.json",
"kind" : "codemodel",
"version" :
{
"major" : 2,
"minor" : 7
}
},
{
"jsonFile" : "toolchains-v1-4e4f3158ee096c2b8391.json",
"kind" : "toolchains",
"version" :
{
"major" : 1,
"minor" : 0
}
},
{
"jsonFile" : "cmakeFiles-v1-0a429aa47da5e5edf8a5.json",
"kind" : "cmakeFiles",
"version" :
{
"major" : 1,
"minor" : 1
}
}
]
}
}
}
}

View File

@ -0,0 +1,221 @@
{
"artifacts" :
[
{
"path" : "xnet.exe"
},
{
"path" : "xnet.pdb"
}
],
"backtrace" : 1,
"backtraceGraph" :
{
"commands" :
[
"add_executable",
"LINK_DIRECTORIES",
"target_link_libraries",
"add_compile_options",
"add_definitions",
"include_directories"
],
"files" :
[
"CMakeLists.txt"
],
"nodes" :
[
{
"file" : 0
},
{
"command" : 0,
"file" : 0,
"line" : 22,
"parent" : 0
},
{
"command" : 1,
"file" : 0,
"line" : 4,
"parent" : 0
},
{
"command" : 2,
"file" : 0,
"line" : 28,
"parent" : 0
},
{
"command" : 3,
"file" : 0,
"line" : 12,
"parent" : 0
},
{
"command" : 4,
"file" : 0,
"line" : 26,
"parent" : 0
},
{
"command" : 4,
"file" : 0,
"line" : 11,
"parent" : 0
},
{
"command" : 5,
"file" : 0,
"line" : 14,
"parent" : 0
}
]
},
"compileGroups" :
[
{
"compileCommandFragments" :
[
{
"fragment" : "-g"
},
{
"backtrace" : 4,
"fragment" : "-g"
}
],
"defines" :
[
{
"backtrace" : 5,
"define" : "NET_DRIVER_PCAP"
},
{
"backtrace" : 6,
"define" : "_CRT_SECURE_NO_WARNINGS"
}
],
"includes" :
[
{
"backtrace" : 7,
"path" : "D:/c_work/start/xnet_tiny_c0101"
},
{
"backtrace" : 7,
"path" : "D:/c_work/start/xnet_tiny_c0101/../lib/npcap/Include"
},
{
"backtrace" : 7,
"path" : "D:/c_work/start/xnet_tiny_c0101/src/xnet_app"
},
{
"backtrace" : 7,
"path" : "D:/c_work/start/xnet_tiny_c0101/src/xnet_tiny"
},
{
"backtrace" : 7,
"path" : "D:/c_work/start/xnet_tiny_c0101/../lib/xnet"
}
],
"language" : "C",
"sourceIndexes" :
[
0,
1
]
}
],
"dependencies" :
[
{
"backtrace" : 3,
"id" : "xnet_tiny::@746c93521a1b098f3dd3"
},
{
"backtrace" : 3,
"id" : "xnet_app::@59b125fae35e6df3589a"
}
],
"id" : "xnet::@6890427a1f51a3e7e1df",
"link" :
{
"commandFragments" :
[
{
"fragment" : "-g",
"role" : "flags"
},
{
"fragment" : "",
"role" : "flags"
},
{
"backtrace" : 2,
"fragment" : "-LD:\\c_work\\start\\xnet_tiny_c0101\\..\\lib\\npcap\\Lib\\x64",
"role" : "libraryPath"
},
{
"backtrace" : 3,
"fragment" : "src\\xnet_tiny\\libxnet_tiny.a",
"role" : "libraries"
},
{
"backtrace" : 3,
"fragment" : "src\\xnet_app\\libxnet_app.a",
"role" : "libraries"
},
{
"backtrace" : 3,
"fragment" : "D:\\c_work\\start\\xnet_tiny_c0101\\..\\lib\\npcap\\Lib\\x64\\wpcap.lib",
"role" : "libraries"
},
{
"backtrace" : 3,
"fragment" : "-lWs2_32",
"role" : "libraries"
},
{
"fragment" : "-lkernel32 -luser32 -lgdi32 -lwinspool -lshell32 -lole32 -loleaut32 -luuid -lcomdlg32 -ladvapi32",
"role" : "libraries"
}
],
"language" : "C"
},
"name" : "xnet",
"nameOnDisk" : "xnet.exe",
"paths" :
{
"build" : ".",
"source" : "."
},
"sourceGroups" :
[
{
"name" : "Source Files",
"sourceIndexes" :
[
0,
1
]
}
],
"sources" :
[
{
"backtrace" : 1,
"compileGroupIndex" : 0,
"path" : "D:/c_work/start/lib/xnet/pcap_device.c",
"sourceGroupIndex" : 0
},
{
"backtrace" : 1,
"compileGroupIndex" : 0,
"path" : "src/app.c",
"sourceGroupIndex" : 0
}
],
"type" : "EXECUTABLE"
}

View File

@ -0,0 +1,152 @@
{
"archive" : {},
"artifacts" :
[
{
"path" : "src/xnet_app/libxnet_app.a"
}
],
"backtrace" : 1,
"backtraceGraph" :
{
"commands" :
[
"add_library",
"add_compile_options",
"add_definitions",
"include_directories"
],
"files" :
[
"src/xnet_app/CMakeLists.txt",
"CMakeLists.txt"
],
"nodes" :
[
{
"file" : 0
},
{
"command" : 0,
"file" : 0,
"line" : 2,
"parent" : 0
},
{
"file" : 1
},
{
"command" : 1,
"file" : 1,
"line" : 12,
"parent" : 2
},
{
"command" : 2,
"file" : 1,
"line" : 11,
"parent" : 2
},
{
"command" : 3,
"file" : 1,
"line" : 14,
"parent" : 2
}
]
},
"compileGroups" :
[
{
"compileCommandFragments" :
[
{
"fragment" : "-g"
},
{
"backtrace" : 3,
"fragment" : "-g"
}
],
"defines" :
[
{
"backtrace" : 4,
"define" : "_CRT_SECURE_NO_WARNINGS"
}
],
"includes" :
[
{
"backtrace" : 5,
"path" : "D:/c_work/start/xnet_tiny_c0101"
},
{
"backtrace" : 5,
"path" : "D:/c_work/start/xnet_tiny_c0101/../lib/npcap/Include"
},
{
"backtrace" : 5,
"path" : "D:/c_work/start/xnet_tiny_c0101/src/xnet_app"
},
{
"backtrace" : 5,
"path" : "D:/c_work/start/xnet_tiny_c0101/src/xnet_tiny"
},
{
"backtrace" : 5,
"path" : "D:/c_work/start/xnet_tiny_c0101/../lib/xnet"
}
],
"language" : "C",
"sourceIndexes" :
[
0,
1,
2
]
}
],
"id" : "xnet_app::@59b125fae35e6df3589a",
"name" : "xnet_app",
"nameOnDisk" : "libxnet_app.a",
"paths" :
{
"build" : "src/xnet_app",
"source" : "src/xnet_app"
},
"sourceGroups" :
[
{
"name" : "Source Files",
"sourceIndexes" :
[
0,
1,
2
]
}
],
"sources" :
[
{
"backtrace" : 1,
"compileGroupIndex" : 0,
"path" : "src/xnet_app/port_pcap.c",
"sourceGroupIndex" : 0
},
{
"backtrace" : 1,
"compileGroupIndex" : 0,
"path" : "src/xnet_app/xserver_datetime.c",
"sourceGroupIndex" : 0
},
{
"backtrace" : 1,
"compileGroupIndex" : 0,
"path" : "src/xnet_app/xserver_http.c",
"sourceGroupIndex" : 0
}
],
"type" : "STATIC_LIBRARY"
}

View File

@ -0,0 +1,136 @@
{
"archive" : {},
"artifacts" :
[
{
"path" : "src/xnet_tiny/libxnet_tiny.a"
}
],
"backtrace" : 1,
"backtraceGraph" :
{
"commands" :
[
"add_library",
"add_compile_options",
"add_definitions",
"include_directories"
],
"files" :
[
"src/xnet_tiny/CMakeLists.txt",
"CMakeLists.txt"
],
"nodes" :
[
{
"file" : 0
},
{
"command" : 0,
"file" : 0,
"line" : 2,
"parent" : 0
},
{
"file" : 1
},
{
"command" : 1,
"file" : 1,
"line" : 12,
"parent" : 2
},
{
"command" : 2,
"file" : 1,
"line" : 11,
"parent" : 2
},
{
"command" : 3,
"file" : 1,
"line" : 14,
"parent" : 2
}
]
},
"compileGroups" :
[
{
"compileCommandFragments" :
[
{
"fragment" : "-g"
},
{
"backtrace" : 3,
"fragment" : "-g"
}
],
"defines" :
[
{
"backtrace" : 4,
"define" : "_CRT_SECURE_NO_WARNINGS"
}
],
"includes" :
[
{
"backtrace" : 5,
"path" : "D:/c_work/start/xnet_tiny_c0101"
},
{
"backtrace" : 5,
"path" : "D:/c_work/start/xnet_tiny_c0101/../lib/npcap/Include"
},
{
"backtrace" : 5,
"path" : "D:/c_work/start/xnet_tiny_c0101/src/xnet_app"
},
{
"backtrace" : 5,
"path" : "D:/c_work/start/xnet_tiny_c0101/src/xnet_tiny"
},
{
"backtrace" : 5,
"path" : "D:/c_work/start/xnet_tiny_c0101/../lib/xnet"
}
],
"language" : "C",
"sourceIndexes" :
[
0
]
}
],
"id" : "xnet_tiny::@746c93521a1b098f3dd3",
"name" : "xnet_tiny",
"nameOnDisk" : "libxnet_tiny.a",
"paths" :
{
"build" : "src/xnet_tiny",
"source" : "src/xnet_tiny"
},
"sourceGroups" :
[
{
"name" : "Source Files",
"sourceIndexes" :
[
0
]
}
],
"sources" :
[
{
"backtrace" : 1,
"compileGroupIndex" : 0,
"path" : "src/xnet_tiny/xnet_tiny.c",
"sourceGroupIndex" : 0
}
],
"type" : "STATIC_LIBRARY"
}

View File

@ -0,0 +1,136 @@
{
"kind" : "toolchains",
"toolchains" :
[
{
"compiler" :
{
"id" : "GNU",
"implicit" :
{
"includeDirectories" :
[
"D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include",
"D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include-fixed",
"D:/c/mingw64/x86_64-w64-mingw32/include"
],
"linkDirectories" :
[
"D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0",
"D:/c/mingw64/lib/gcc",
"D:/c/mingw64/x86_64-w64-mingw32/lib",
"D:/c/mingw64/lib"
],
"linkFrameworkDirectories" : [],
"linkLibraries" :
[
"mingw32",
"gcc",
"moldname",
"mingwex",
"advapi32",
"shell32",
"user32",
"kernel32",
"iconv",
"mingw32",
"gcc",
"moldname",
"mingwex"
]
},
"path" : "D:/c/mingw64/bin/gcc.exe",
"version" : "8.1.0"
},
"language" : "C",
"sourceFileExtensions" :
[
"c",
"m"
]
},
{
"compiler" :
{
"id" : "GNU",
"implicit" :
{
"includeDirectories" :
[
"D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/c++",
"D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/c++/x86_64-w64-mingw32",
"D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/c++/backward",
"D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include",
"D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include-fixed",
"D:/c/mingw64/x86_64-w64-mingw32/include"
],
"linkDirectories" :
[
"D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0",
"D:/c/mingw64/lib/gcc",
"D:/c/mingw64/x86_64-w64-mingw32/lib",
"D:/c/mingw64/lib"
],
"linkFrameworkDirectories" : [],
"linkLibraries" :
[
"stdc++",
"mingw32",
"gcc_s",
"gcc",
"moldname",
"mingwex",
"advapi32",
"shell32",
"user32",
"kernel32",
"iconv",
"mingw32",
"gcc_s",
"gcc",
"moldname",
"mingwex"
]
},
"path" : "D:/c/mingw64/bin/g++.exe",
"version" : "8.1.0"
},
"language" : "CXX",
"sourceFileExtensions" :
[
"C",
"M",
"c++",
"cc",
"cpp",
"cxx",
"mm",
"mpp",
"CPP",
"ixx",
"cppm",
"ccm",
"cxxm",
"c++m"
]
},
{
"compiler" :
{
"implicit" : {},
"path" : "D:/c/mingw64/bin/windres.exe"
},
"language" : "RC",
"sourceFileExtensions" :
[
"rc",
"RC"
]
}
],
"version" :
{
"major" : 1,
"minor" : 0
}
}

View File

@ -0,0 +1,418 @@
# This is the CMakeCache file.
# For build in directory: d:/c_work/start/build
# It was generated by CMake: D:/cmake/bin/cmake.exe
# You can edit this file to change values found and used by cmake.
# If you do not want to change any of the values, simply exit the editor.
# If you do want to change a value, simply edit, save, and exit the editor.
# The syntax for the file is as follows:
# KEY:TYPE=VALUE
# KEY is the name of a variable in the cache.
# TYPE is a hint to GUIs for the type of VALUE, DO NOT EDIT TYPE!.
# VALUE is the current value for the KEY.
########################
# EXTERNAL cache entries
########################
//Path to a program.
CMAKE_ADDR2LINE:FILEPATH=D:/c/mingw64/bin/addr2line.exe
//Path to a program.
CMAKE_AR:FILEPATH=D:/c/mingw64/bin/ar.exe
//No help, variable specified on the command line.
CMAKE_BUILD_TYPE:STRING=Debug
//Enable/Disable color output during build.
CMAKE_COLOR_MAKEFILE:BOOL=ON
//No help, variable specified on the command line.
CMAKE_CXX_COMPILER:FILEPATH=D:/c/mingw64/bin/g++.exe
//A wrapper around 'ar' adding the appropriate '--plugin' option
// for the GCC compiler
CMAKE_CXX_COMPILER_AR:FILEPATH=D:/c/mingw64/bin/gcc-ar.exe
//A wrapper around 'ranlib' adding the appropriate '--plugin' option
// for the GCC compiler
CMAKE_CXX_COMPILER_RANLIB:FILEPATH=D:/c/mingw64/bin/gcc-ranlib.exe
//Flags used by the CXX compiler during all build types.
CMAKE_CXX_FLAGS:STRING=
//Flags used by the CXX compiler during DEBUG builds.
CMAKE_CXX_FLAGS_DEBUG:STRING=-g
//Flags used by the CXX compiler during MINSIZEREL builds.
CMAKE_CXX_FLAGS_MINSIZEREL:STRING=-Os -DNDEBUG
//Flags used by the CXX compiler during RELEASE builds.
CMAKE_CXX_FLAGS_RELEASE:STRING=-O3 -DNDEBUG
//Flags used by the CXX compiler during RELWITHDEBINFO builds.
CMAKE_CXX_FLAGS_RELWITHDEBINFO:STRING=-O2 -g -DNDEBUG
//Libraries linked by default with all C++ applications.
CMAKE_CXX_STANDARD_LIBRARIES:STRING=-lkernel32 -luser32 -lgdi32 -lwinspool -lshell32 -lole32 -loleaut32 -luuid -lcomdlg32 -ladvapi32
//No help, variable specified on the command line.
CMAKE_C_COMPILER:FILEPATH=D:/c/mingw64/bin/gcc.exe
//A wrapper around 'ar' adding the appropriate '--plugin' option
// for the GCC compiler
CMAKE_C_COMPILER_AR:FILEPATH=D:/c/mingw64/bin/gcc-ar.exe
//A wrapper around 'ranlib' adding the appropriate '--plugin' option
// for the GCC compiler
CMAKE_C_COMPILER_RANLIB:FILEPATH=D:/c/mingw64/bin/gcc-ranlib.exe
//Flags used by the C compiler during all build types.
CMAKE_C_FLAGS:STRING=
//Flags used by the C compiler during DEBUG builds.
CMAKE_C_FLAGS_DEBUG:STRING=-g
//Flags used by the C compiler during MINSIZEREL builds.
CMAKE_C_FLAGS_MINSIZEREL:STRING=-Os -DNDEBUG
//Flags used by the C compiler during RELEASE builds.
CMAKE_C_FLAGS_RELEASE:STRING=-O3 -DNDEBUG
//Flags used by the C compiler during RELWITHDEBINFO builds.
CMAKE_C_FLAGS_RELWITHDEBINFO:STRING=-O2 -g -DNDEBUG
//Libraries linked by default with all C applications.
CMAKE_C_STANDARD_LIBRARIES:STRING=-lkernel32 -luser32 -lgdi32 -lwinspool -lshell32 -lole32 -loleaut32 -luuid -lcomdlg32 -ladvapi32
//Path to a program.
CMAKE_DLLTOOL:FILEPATH=D:/c/mingw64/bin/dlltool.exe
//Flags used by the linker during all build types.
CMAKE_EXE_LINKER_FLAGS:STRING=
//Flags used by the linker during DEBUG builds.
CMAKE_EXE_LINKER_FLAGS_DEBUG:STRING=
//Flags used by the linker during MINSIZEREL builds.
CMAKE_EXE_LINKER_FLAGS_MINSIZEREL:STRING=
//Flags used by the linker during RELEASE builds.
CMAKE_EXE_LINKER_FLAGS_RELEASE:STRING=
//Flags used by the linker during RELWITHDEBINFO builds.
CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO:STRING=
//No help, variable specified on the command line.
CMAKE_EXPORT_COMPILE_COMMANDS:BOOL=TRUE
//Value Computed by CMake.
CMAKE_FIND_PACKAGE_REDIRECTS_DIR:STATIC=D:/c_work/start/build/CMakeFiles/pkgRedirects
//Convert GNU import libraries to MS format (requires Visual Studio)
CMAKE_GNUtoMS:BOOL=OFF
//Install path prefix, prepended onto install directories.
CMAKE_INSTALL_PREFIX:PATH=C:/Program Files (x86)/xnet
//Path to a program.
CMAKE_LINKER:FILEPATH=D:/c/mingw64/bin/ld.exe
//Path to a program.
CMAKE_MAKE_PROGRAM:FILEPATH=D:/c/mingw64/bin/mingw32-make.exe
//Flags used by the linker during the creation of modules during
// all build types.
CMAKE_MODULE_LINKER_FLAGS:STRING=
//Flags used by the linker during the creation of modules during
// DEBUG builds.
CMAKE_MODULE_LINKER_FLAGS_DEBUG:STRING=
//Flags used by the linker during the creation of modules during
// MINSIZEREL builds.
CMAKE_MODULE_LINKER_FLAGS_MINSIZEREL:STRING=
//Flags used by the linker during the creation of modules during
// RELEASE builds.
CMAKE_MODULE_LINKER_FLAGS_RELEASE:STRING=
//Flags used by the linker during the creation of modules during
// RELWITHDEBINFO builds.
CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO:STRING=
//Path to a program.
CMAKE_NM:FILEPATH=D:/c/mingw64/bin/nm.exe
//Path to a program.
CMAKE_OBJCOPY:FILEPATH=D:/c/mingw64/bin/objcopy.exe
//Path to a program.
CMAKE_OBJDUMP:FILEPATH=D:/c/mingw64/bin/objdump.exe
//Value Computed by CMake
CMAKE_PROJECT_DESCRIPTION:STATIC=
//Value Computed by CMake
CMAKE_PROJECT_HOMEPAGE_URL:STATIC=
//Value Computed by CMake
CMAKE_PROJECT_NAME:STATIC=xnet
//Path to a program.
CMAKE_RANLIB:FILEPATH=D:/c/mingw64/bin/ranlib.exe
//RC compiler
CMAKE_RC_COMPILER:FILEPATH=D:/c/mingw64/bin/windres.exe
//Flags for Windows Resource Compiler during all build types.
CMAKE_RC_FLAGS:STRING=
//Flags for Windows Resource Compiler during DEBUG builds.
CMAKE_RC_FLAGS_DEBUG:STRING=
//Flags for Windows Resource Compiler during MINSIZEREL builds.
CMAKE_RC_FLAGS_MINSIZEREL:STRING=
//Flags for Windows Resource Compiler during RELEASE builds.
CMAKE_RC_FLAGS_RELEASE:STRING=
//Flags for Windows Resource Compiler during RELWITHDEBINFO builds.
CMAKE_RC_FLAGS_RELWITHDEBINFO:STRING=
//Path to a program.
CMAKE_READELF:FILEPATH=D:/c/mingw64/bin/readelf.exe
//Flags used by the linker during the creation of shared libraries
// during all build types.
CMAKE_SHARED_LINKER_FLAGS:STRING=
//Flags used by the linker during the creation of shared libraries
// during DEBUG builds.
CMAKE_SHARED_LINKER_FLAGS_DEBUG:STRING=
//Flags used by the linker during the creation of shared libraries
// during MINSIZEREL builds.
CMAKE_SHARED_LINKER_FLAGS_MINSIZEREL:STRING=
//Flags used by the linker during the creation of shared libraries
// during RELEASE builds.
CMAKE_SHARED_LINKER_FLAGS_RELEASE:STRING=
//Flags used by the linker during the creation of shared libraries
// during RELWITHDEBINFO builds.
CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO:STRING=
//If set, runtime paths are not added when installing shared libraries,
// but are added when building.
CMAKE_SKIP_INSTALL_RPATH:BOOL=NO
//If set, runtime paths are not added when using shared libraries.
CMAKE_SKIP_RPATH:BOOL=NO
//Flags used by the linker during the creation of static libraries
// during all build types.
CMAKE_STATIC_LINKER_FLAGS:STRING=
//Flags used by the linker during the creation of static libraries
// during DEBUG builds.
CMAKE_STATIC_LINKER_FLAGS_DEBUG:STRING=
//Flags used by the linker during the creation of static libraries
// during MINSIZEREL builds.
CMAKE_STATIC_LINKER_FLAGS_MINSIZEREL:STRING=
//Flags used by the linker during the creation of static libraries
// during RELEASE builds.
CMAKE_STATIC_LINKER_FLAGS_RELEASE:STRING=
//Flags used by the linker during the creation of static libraries
// during RELWITHDEBINFO builds.
CMAKE_STATIC_LINKER_FLAGS_RELWITHDEBINFO:STRING=
//Path to a program.
CMAKE_STRIP:FILEPATH=D:/c/mingw64/bin/strip.exe
//Path to a program.
CMAKE_TAPI:FILEPATH=CMAKE_TAPI-NOTFOUND
//If this value is on, makefiles will be generated without the
// .SILENT directive, and all commands will be echoed to the console
// during the make. This is useful for debugging only. With Visual
// Studio IDE projects all commands are done without /nologo.
CMAKE_VERBOSE_MAKEFILE:BOOL=FALSE
//Value Computed by CMake
xnet_BINARY_DIR:STATIC=D:/c_work/start/build
//Value Computed by CMake
xnet_IS_TOP_LEVEL:STATIC=ON
//Value Computed by CMake
xnet_SOURCE_DIR:STATIC=D:/c_work/start/xnet_tiny_c0101
########################
# INTERNAL cache entries
########################
//ADVANCED property for variable: CMAKE_ADDR2LINE
CMAKE_ADDR2LINE-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_AR
CMAKE_AR-ADVANCED:INTERNAL=1
//This is the directory where this CMakeCache.txt was created
CMAKE_CACHEFILE_DIR:INTERNAL=d:/c_work/start/build
//Major version of cmake used to create the current loaded cache
CMAKE_CACHE_MAJOR_VERSION:INTERNAL=3
//Minor version of cmake used to create the current loaded cache
CMAKE_CACHE_MINOR_VERSION:INTERNAL=30
//Patch version of cmake used to create the current loaded cache
CMAKE_CACHE_PATCH_VERSION:INTERNAL=3
//ADVANCED property for variable: CMAKE_COLOR_MAKEFILE
CMAKE_COLOR_MAKEFILE-ADVANCED:INTERNAL=1
//Path to CMake executable.
CMAKE_COMMAND:INTERNAL=D:/cmake/bin/cmake.exe
//Path to cpack program executable.
CMAKE_CPACK_COMMAND:INTERNAL=D:/cmake/bin/cpack.exe
//Path to ctest program executable.
CMAKE_CTEST_COMMAND:INTERNAL=D:/cmake/bin/ctest.exe
//ADVANCED property for variable: CMAKE_CXX_COMPILER
CMAKE_CXX_COMPILER-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_CXX_COMPILER_AR
CMAKE_CXX_COMPILER_AR-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_CXX_COMPILER_RANLIB
CMAKE_CXX_COMPILER_RANLIB-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_CXX_FLAGS
CMAKE_CXX_FLAGS-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_CXX_FLAGS_DEBUG
CMAKE_CXX_FLAGS_DEBUG-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_CXX_FLAGS_MINSIZEREL
CMAKE_CXX_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_CXX_FLAGS_RELEASE
CMAKE_CXX_FLAGS_RELEASE-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_CXX_FLAGS_RELWITHDEBINFO
CMAKE_CXX_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_CXX_STANDARD_LIBRARIES
CMAKE_CXX_STANDARD_LIBRARIES-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_C_COMPILER
CMAKE_C_COMPILER-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_C_COMPILER_AR
CMAKE_C_COMPILER_AR-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_C_COMPILER_RANLIB
CMAKE_C_COMPILER_RANLIB-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_C_FLAGS
CMAKE_C_FLAGS-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_C_FLAGS_DEBUG
CMAKE_C_FLAGS_DEBUG-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_C_FLAGS_MINSIZEREL
CMAKE_C_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_C_FLAGS_RELEASE
CMAKE_C_FLAGS_RELEASE-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_C_FLAGS_RELWITHDEBINFO
CMAKE_C_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_C_STANDARD_LIBRARIES
CMAKE_C_STANDARD_LIBRARIES-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_DLLTOOL
CMAKE_DLLTOOL-ADVANCED:INTERNAL=1
//Path to cache edit program executable.
CMAKE_EDIT_COMMAND:INTERNAL=D:/cmake/bin/cmake-gui.exe
//Executable file format
CMAKE_EXECUTABLE_FORMAT:INTERNAL=Unknown
//ADVANCED property for variable: CMAKE_EXE_LINKER_FLAGS
CMAKE_EXE_LINKER_FLAGS-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_EXE_LINKER_FLAGS_DEBUG
CMAKE_EXE_LINKER_FLAGS_DEBUG-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_EXE_LINKER_FLAGS_MINSIZEREL
CMAKE_EXE_LINKER_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_EXE_LINKER_FLAGS_RELEASE
CMAKE_EXE_LINKER_FLAGS_RELEASE-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO
CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1
//Name of external makefile project generator.
CMAKE_EXTRA_GENERATOR:INTERNAL=
//Name of generator.
CMAKE_GENERATOR:INTERNAL=MinGW Makefiles
//Generator instance identifier.
CMAKE_GENERATOR_INSTANCE:INTERNAL=
//Name of generator platform.
CMAKE_GENERATOR_PLATFORM:INTERNAL=
//Name of generator toolset.
CMAKE_GENERATOR_TOOLSET:INTERNAL=
//Source directory with the top level CMakeLists.txt file for this
// project
CMAKE_HOME_DIRECTORY:INTERNAL=D:/c_work/start/xnet_tiny_c0101
//ADVANCED property for variable: CMAKE_LINKER
CMAKE_LINKER-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_MAKE_PROGRAM
CMAKE_MAKE_PROGRAM-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_MODULE_LINKER_FLAGS
CMAKE_MODULE_LINKER_FLAGS-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_MODULE_LINKER_FLAGS_DEBUG
CMAKE_MODULE_LINKER_FLAGS_DEBUG-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_MODULE_LINKER_FLAGS_MINSIZEREL
CMAKE_MODULE_LINKER_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_MODULE_LINKER_FLAGS_RELEASE
CMAKE_MODULE_LINKER_FLAGS_RELEASE-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO
CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_NM
CMAKE_NM-ADVANCED:INTERNAL=1
//number of local generators
CMAKE_NUMBER_OF_MAKEFILES:INTERNAL=3
//ADVANCED property for variable: CMAKE_OBJCOPY
CMAKE_OBJCOPY-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_OBJDUMP
CMAKE_OBJDUMP-ADVANCED:INTERNAL=1
//Platform information initialized
CMAKE_PLATFORM_INFO_INITIALIZED:INTERNAL=1
//ADVANCED property for variable: CMAKE_RANLIB
CMAKE_RANLIB-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_RC_COMPILER
CMAKE_RC_COMPILER-ADVANCED:INTERNAL=1
CMAKE_RC_COMPILER_WORKS:INTERNAL=1
//ADVANCED property for variable: CMAKE_RC_FLAGS
CMAKE_RC_FLAGS-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_RC_FLAGS_DEBUG
CMAKE_RC_FLAGS_DEBUG-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_RC_FLAGS_MINSIZEREL
CMAKE_RC_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_RC_FLAGS_RELEASE
CMAKE_RC_FLAGS_RELEASE-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_RC_FLAGS_RELWITHDEBINFO
CMAKE_RC_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_READELF
CMAKE_READELF-ADVANCED:INTERNAL=1
//Path to CMake installation.
CMAKE_ROOT:INTERNAL=D:/cmake/share/cmake-3.30
//ADVANCED property for variable: CMAKE_SHARED_LINKER_FLAGS
CMAKE_SHARED_LINKER_FLAGS-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_SHARED_LINKER_FLAGS_DEBUG
CMAKE_SHARED_LINKER_FLAGS_DEBUG-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_SHARED_LINKER_FLAGS_MINSIZEREL
CMAKE_SHARED_LINKER_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_SHARED_LINKER_FLAGS_RELEASE
CMAKE_SHARED_LINKER_FLAGS_RELEASE-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO
CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_SKIP_INSTALL_RPATH
CMAKE_SKIP_INSTALL_RPATH-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_SKIP_RPATH
CMAKE_SKIP_RPATH-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS
CMAKE_STATIC_LINKER_FLAGS-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS_DEBUG
CMAKE_STATIC_LINKER_FLAGS_DEBUG-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS_MINSIZEREL
CMAKE_STATIC_LINKER_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS_RELEASE
CMAKE_STATIC_LINKER_FLAGS_RELEASE-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS_RELWITHDEBINFO
CMAKE_STATIC_LINKER_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_STRIP
CMAKE_STRIP-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_TAPI
CMAKE_TAPI-ADVANCED:INTERNAL=1
//ADVANCED property for variable: CMAKE_VERBOSE_MAKEFILE
CMAKE_VERBOSE_MAKEFILE-ADVANCED:INTERNAL=1
//linker supports push/pop state
_CMAKE_LINKER_PUSHPOP_STATE_SUPPORTED:INTERNAL=TRUE

View File

@ -0,0 +1,81 @@
set(CMAKE_C_COMPILER "D:/c/mingw64/bin/gcc.exe")
set(CMAKE_C_COMPILER_ARG1 "")
set(CMAKE_C_COMPILER_ID "GNU")
set(CMAKE_C_COMPILER_VERSION "8.1.0")
set(CMAKE_C_COMPILER_VERSION_INTERNAL "")
set(CMAKE_C_COMPILER_WRAPPER "")
set(CMAKE_C_STANDARD_COMPUTED_DEFAULT "17")
set(CMAKE_C_EXTENSIONS_COMPUTED_DEFAULT "ON")
set(CMAKE_C_STANDARD_LATEST "17")
set(CMAKE_C_COMPILE_FEATURES "c_std_90;c_function_prototypes;c_std_99;c_restrict;c_variadic_macros;c_std_11;c_static_assert;c_std_17")
set(CMAKE_C90_COMPILE_FEATURES "c_std_90;c_function_prototypes")
set(CMAKE_C99_COMPILE_FEATURES "c_std_99;c_restrict;c_variadic_macros")
set(CMAKE_C11_COMPILE_FEATURES "c_std_11;c_static_assert")
set(CMAKE_C17_COMPILE_FEATURES "c_std_17")
set(CMAKE_C23_COMPILE_FEATURES "")
set(CMAKE_C_PLATFORM_ID "MinGW")
set(CMAKE_C_SIMULATE_ID "")
set(CMAKE_C_COMPILER_FRONTEND_VARIANT "GNU")
set(CMAKE_C_SIMULATE_VERSION "")
set(CMAKE_AR "D:/c/mingw64/bin/ar.exe")
set(CMAKE_C_COMPILER_AR "D:/c/mingw64/bin/gcc-ar.exe")
set(CMAKE_RANLIB "D:/c/mingw64/bin/ranlib.exe")
set(CMAKE_C_COMPILER_RANLIB "D:/c/mingw64/bin/gcc-ranlib.exe")
set(CMAKE_LINKER "D:/c/mingw64/bin/ld.exe")
set(CMAKE_LINKER_LINK "")
set(CMAKE_LINKER_LLD "")
set(CMAKE_C_COMPILER_LINKER "D:/c/mingw64/x86_64-w64-mingw32/bin/ld.exe")
set(CMAKE_C_COMPILER_LINKER_ID "GNU")
set(CMAKE_C_COMPILER_LINKER_VERSION 2.30)
set(CMAKE_C_COMPILER_LINKER_FRONTEND_VARIANT GNU)
set(CMAKE_MT "")
set(CMAKE_TAPI "CMAKE_TAPI-NOTFOUND")
set(CMAKE_COMPILER_IS_GNUCC 1)
set(CMAKE_C_COMPILER_LOADED 1)
set(CMAKE_C_COMPILER_WORKS TRUE)
set(CMAKE_C_ABI_COMPILED TRUE)
set(CMAKE_C_COMPILER_ENV_VAR "CC")
set(CMAKE_C_COMPILER_ID_RUN 1)
set(CMAKE_C_SOURCE_FILE_EXTENSIONS c;m)
set(CMAKE_C_IGNORE_EXTENSIONS h;H;o;O;obj;OBJ;def;DEF;rc;RC)
set(CMAKE_C_LINKER_PREFERENCE 10)
set(CMAKE_C_LINKER_DEPFILE_SUPPORTED FALSE)
# Save compiler ABI information.
set(CMAKE_C_SIZEOF_DATA_PTR "8")
set(CMAKE_C_COMPILER_ABI "")
set(CMAKE_C_BYTE_ORDER "LITTLE_ENDIAN")
set(CMAKE_C_LIBRARY_ARCHITECTURE "")
if(CMAKE_C_SIZEOF_DATA_PTR)
set(CMAKE_SIZEOF_VOID_P "${CMAKE_C_SIZEOF_DATA_PTR}")
endif()
if(CMAKE_C_COMPILER_ABI)
set(CMAKE_INTERNAL_PLATFORM_ABI "${CMAKE_C_COMPILER_ABI}")
endif()
if(CMAKE_C_LIBRARY_ARCHITECTURE)
set(CMAKE_LIBRARY_ARCHITECTURE "")
endif()
set(CMAKE_C_CL_SHOWINCLUDES_PREFIX "")
if(CMAKE_C_CL_SHOWINCLUDES_PREFIX)
set(CMAKE_CL_SHOWINCLUDES_PREFIX "${CMAKE_C_CL_SHOWINCLUDES_PREFIX}")
endif()
set(CMAKE_C_IMPLICIT_INCLUDE_DIRECTORIES "D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include;D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include-fixed;D:/c/mingw64/x86_64-w64-mingw32/include")
set(CMAKE_C_IMPLICIT_LINK_LIBRARIES "mingw32;gcc;moldname;mingwex;advapi32;shell32;user32;kernel32;iconv;mingw32;gcc;moldname;mingwex")
set(CMAKE_C_IMPLICIT_LINK_DIRECTORIES "D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0;D:/c/mingw64/lib/gcc;D:/c/mingw64/x86_64-w64-mingw32/lib;D:/c/mingw64/lib")
set(CMAKE_C_IMPLICIT_LINK_FRAMEWORK_DIRECTORIES "")

View File

@ -0,0 +1,97 @@
set(CMAKE_CXX_COMPILER "D:/c/mingw64/bin/g++.exe")
set(CMAKE_CXX_COMPILER_ARG1 "")
set(CMAKE_CXX_COMPILER_ID "GNU")
set(CMAKE_CXX_COMPILER_VERSION "8.1.0")
set(CMAKE_CXX_COMPILER_VERSION_INTERNAL "")
set(CMAKE_CXX_COMPILER_WRAPPER "")
set(CMAKE_CXX_STANDARD_COMPUTED_DEFAULT "14")
set(CMAKE_CXX_EXTENSIONS_COMPUTED_DEFAULT "ON")
set(CMAKE_CXX_STANDARD_LATEST "20")
set(CMAKE_CXX_COMPILE_FEATURES "cxx_std_98;cxx_template_template_parameters;cxx_std_11;cxx_alias_templates;cxx_alignas;cxx_alignof;cxx_attributes;cxx_auto_type;cxx_constexpr;cxx_decltype;cxx_decltype_incomplete_return_types;cxx_default_function_template_args;cxx_defaulted_functions;cxx_defaulted_move_initializers;cxx_delegating_constructors;cxx_deleted_functions;cxx_enum_forward_declarations;cxx_explicit_conversions;cxx_extended_friend_declarations;cxx_extern_templates;cxx_final;cxx_func_identifier;cxx_generalized_initializers;cxx_inheriting_constructors;cxx_inline_namespaces;cxx_lambdas;cxx_local_type_template_args;cxx_long_long_type;cxx_noexcept;cxx_nonstatic_member_init;cxx_nullptr;cxx_override;cxx_range_for;cxx_raw_string_literals;cxx_reference_qualified_functions;cxx_right_angle_brackets;cxx_rvalue_references;cxx_sizeof_member;cxx_static_assert;cxx_strong_enums;cxx_thread_local;cxx_trailing_return_types;cxx_unicode_literals;cxx_uniform_initialization;cxx_unrestricted_unions;cxx_user_literals;cxx_variadic_macros;cxx_variadic_templates;cxx_std_14;cxx_aggregate_default_initializers;cxx_attribute_deprecated;cxx_binary_literals;cxx_contextual_conversions;cxx_decltype_auto;cxx_digit_separators;cxx_generic_lambdas;cxx_lambda_init_captures;cxx_relaxed_constexpr;cxx_return_type_deduction;cxx_variable_templates;cxx_std_17;cxx_std_20")
set(CMAKE_CXX98_COMPILE_FEATURES "cxx_std_98;cxx_template_template_parameters")
set(CMAKE_CXX11_COMPILE_FEATURES "cxx_std_11;cxx_alias_templates;cxx_alignas;cxx_alignof;cxx_attributes;cxx_auto_type;cxx_constexpr;cxx_decltype;cxx_decltype_incomplete_return_types;cxx_default_function_template_args;cxx_defaulted_functions;cxx_defaulted_move_initializers;cxx_delegating_constructors;cxx_deleted_functions;cxx_enum_forward_declarations;cxx_explicit_conversions;cxx_extended_friend_declarations;cxx_extern_templates;cxx_final;cxx_func_identifier;cxx_generalized_initializers;cxx_inheriting_constructors;cxx_inline_namespaces;cxx_lambdas;cxx_local_type_template_args;cxx_long_long_type;cxx_noexcept;cxx_nonstatic_member_init;cxx_nullptr;cxx_override;cxx_range_for;cxx_raw_string_literals;cxx_reference_qualified_functions;cxx_right_angle_brackets;cxx_rvalue_references;cxx_sizeof_member;cxx_static_assert;cxx_strong_enums;cxx_thread_local;cxx_trailing_return_types;cxx_unicode_literals;cxx_uniform_initialization;cxx_unrestricted_unions;cxx_user_literals;cxx_variadic_macros;cxx_variadic_templates")
set(CMAKE_CXX14_COMPILE_FEATURES "cxx_std_14;cxx_aggregate_default_initializers;cxx_attribute_deprecated;cxx_binary_literals;cxx_contextual_conversions;cxx_decltype_auto;cxx_digit_separators;cxx_generic_lambdas;cxx_lambda_init_captures;cxx_relaxed_constexpr;cxx_return_type_deduction;cxx_variable_templates")
set(CMAKE_CXX17_COMPILE_FEATURES "cxx_std_17")
set(CMAKE_CXX20_COMPILE_FEATURES "cxx_std_20")
set(CMAKE_CXX23_COMPILE_FEATURES "")
set(CMAKE_CXX26_COMPILE_FEATURES "")
set(CMAKE_CXX_PLATFORM_ID "MinGW")
set(CMAKE_CXX_SIMULATE_ID "")
set(CMAKE_CXX_COMPILER_FRONTEND_VARIANT "GNU")
set(CMAKE_CXX_SIMULATE_VERSION "")
set(CMAKE_AR "D:/c/mingw64/bin/ar.exe")
set(CMAKE_CXX_COMPILER_AR "D:/c/mingw64/bin/gcc-ar.exe")
set(CMAKE_RANLIB "D:/c/mingw64/bin/ranlib.exe")
set(CMAKE_CXX_COMPILER_RANLIB "D:/c/mingw64/bin/gcc-ranlib.exe")
set(CMAKE_LINKER "D:/c/mingw64/bin/ld.exe")
set(CMAKE_LINKER_LINK "")
set(CMAKE_LINKER_LLD "")
set(CMAKE_CXX_COMPILER_LINKER "D:/c/mingw64/x86_64-w64-mingw32/bin/ld.exe")
set(CMAKE_CXX_COMPILER_LINKER_ID "GNU")
set(CMAKE_CXX_COMPILER_LINKER_VERSION 2.30)
set(CMAKE_CXX_COMPILER_LINKER_FRONTEND_VARIANT GNU)
set(CMAKE_MT "")
set(CMAKE_TAPI "CMAKE_TAPI-NOTFOUND")
set(CMAKE_COMPILER_IS_GNUCXX 1)
set(CMAKE_CXX_COMPILER_LOADED 1)
set(CMAKE_CXX_COMPILER_WORKS TRUE)
set(CMAKE_CXX_ABI_COMPILED TRUE)
set(CMAKE_CXX_COMPILER_ENV_VAR "CXX")
set(CMAKE_CXX_COMPILER_ID_RUN 1)
set(CMAKE_CXX_SOURCE_FILE_EXTENSIONS C;M;c++;cc;cpp;cxx;m;mm;mpp;CPP;ixx;cppm;ccm;cxxm;c++m)
set(CMAKE_CXX_IGNORE_EXTENSIONS inl;h;hpp;HPP;H;o;O;obj;OBJ;def;DEF;rc;RC)
foreach (lang IN ITEMS C OBJC OBJCXX)
if (CMAKE_${lang}_COMPILER_ID_RUN)
foreach(extension IN LISTS CMAKE_${lang}_SOURCE_FILE_EXTENSIONS)
list(REMOVE_ITEM CMAKE_CXX_SOURCE_FILE_EXTENSIONS ${extension})
endforeach()
endif()
endforeach()
set(CMAKE_CXX_LINKER_PREFERENCE 30)
set(CMAKE_CXX_LINKER_PREFERENCE_PROPAGATES 1)
set(CMAKE_CXX_LINKER_DEPFILE_SUPPORTED FALSE)
# Save compiler ABI information.
set(CMAKE_CXX_SIZEOF_DATA_PTR "8")
set(CMAKE_CXX_COMPILER_ABI "")
set(CMAKE_CXX_BYTE_ORDER "LITTLE_ENDIAN")
set(CMAKE_CXX_LIBRARY_ARCHITECTURE "")
if(CMAKE_CXX_SIZEOF_DATA_PTR)
set(CMAKE_SIZEOF_VOID_P "${CMAKE_CXX_SIZEOF_DATA_PTR}")
endif()
if(CMAKE_CXX_COMPILER_ABI)
set(CMAKE_INTERNAL_PLATFORM_ABI "${CMAKE_CXX_COMPILER_ABI}")
endif()
if(CMAKE_CXX_LIBRARY_ARCHITECTURE)
set(CMAKE_LIBRARY_ARCHITECTURE "")
endif()
set(CMAKE_CXX_CL_SHOWINCLUDES_PREFIX "")
if(CMAKE_CXX_CL_SHOWINCLUDES_PREFIX)
set(CMAKE_CL_SHOWINCLUDES_PREFIX "${CMAKE_CXX_CL_SHOWINCLUDES_PREFIX}")
endif()
set(CMAKE_CXX_IMPLICIT_INCLUDE_DIRECTORIES "D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/c++;D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/c++/x86_64-w64-mingw32;D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/c++/backward;D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include;D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include-fixed;D:/c/mingw64/x86_64-w64-mingw32/include")
set(CMAKE_CXX_IMPLICIT_LINK_LIBRARIES "stdc++;mingw32;gcc_s;gcc;moldname;mingwex;advapi32;shell32;user32;kernel32;iconv;mingw32;gcc_s;gcc;moldname;mingwex")
set(CMAKE_CXX_IMPLICIT_LINK_DIRECTORIES "D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0;D:/c/mingw64/lib/gcc;D:/c/mingw64/x86_64-w64-mingw32/lib;D:/c/mingw64/lib")
set(CMAKE_CXX_IMPLICIT_LINK_FRAMEWORK_DIRECTORIES "")
set(CMAKE_CXX_COMPILER_CLANG_RESOURCE_DIR "")
set(CMAKE_CXX_COMPILER_IMPORT_STD "")

View File

@ -0,0 +1,6 @@
set(CMAKE_RC_COMPILER "D:/c/mingw64/bin/windres.exe")
set(CMAKE_RC_COMPILER_ARG1 "")
set(CMAKE_RC_COMPILER_LOADED 1)
set(CMAKE_RC_SOURCE_FILE_EXTENSIONS rc;RC)
set(CMAKE_RC_OUTPUT_EXTENSION .obj)
set(CMAKE_RC_COMPILER_ENV_VAR "RC")

View File

@ -0,0 +1,15 @@
set(CMAKE_HOST_SYSTEM "Windows-10.0.22631")
set(CMAKE_HOST_SYSTEM_NAME "Windows")
set(CMAKE_HOST_SYSTEM_VERSION "10.0.22631")
set(CMAKE_HOST_SYSTEM_PROCESSOR "AMD64")
set(CMAKE_SYSTEM "Windows-10.0.22631")
set(CMAKE_SYSTEM_NAME "Windows")
set(CMAKE_SYSTEM_VERSION "10.0.22631")
set(CMAKE_SYSTEM_PROCESSOR "AMD64")
set(CMAKE_CROSSCOMPILING "FALSE")
set(CMAKE_SYSTEM_LOADED 1)

View File

@ -0,0 +1,904 @@
#ifdef __cplusplus
# error "A C++ compiler has been selected for C."
#endif
#if defined(__18CXX)
# define ID_VOID_MAIN
#endif
#if defined(__CLASSIC_C__)
/* cv-qualifiers did not exist in K&R C */
# define const
# define volatile
#endif
#if !defined(__has_include)
/* If the compiler does not have __has_include, pretend the answer is
always no. */
# define __has_include(x) 0
#endif
/* Version number components: V=Version, R=Revision, P=Patch
Version date components: YYYY=Year, MM=Month, DD=Day */
#if defined(__INTEL_COMPILER) || defined(__ICC)
# define COMPILER_ID "Intel"
# if defined(_MSC_VER)
# define SIMULATE_ID "MSVC"
# endif
# if defined(__GNUC__)
# define SIMULATE_ID "GNU"
# endif
/* __INTEL_COMPILER = VRP prior to 2021, and then VVVV for 2021 and later,
except that a few beta releases use the old format with V=2021. */
# if __INTEL_COMPILER < 2021 || __INTEL_COMPILER == 202110 || __INTEL_COMPILER == 202111
# define COMPILER_VERSION_MAJOR DEC(__INTEL_COMPILER/100)
# define COMPILER_VERSION_MINOR DEC(__INTEL_COMPILER/10 % 10)
# if defined(__INTEL_COMPILER_UPDATE)
# define COMPILER_VERSION_PATCH DEC(__INTEL_COMPILER_UPDATE)
# else
# define COMPILER_VERSION_PATCH DEC(__INTEL_COMPILER % 10)
# endif
# else
# define COMPILER_VERSION_MAJOR DEC(__INTEL_COMPILER)
# define COMPILER_VERSION_MINOR DEC(__INTEL_COMPILER_UPDATE)
/* The third version component from --version is an update index,
but no macro is provided for it. */
# define COMPILER_VERSION_PATCH DEC(0)
# endif
# if defined(__INTEL_COMPILER_BUILD_DATE)
/* __INTEL_COMPILER_BUILD_DATE = YYYYMMDD */
# define COMPILER_VERSION_TWEAK DEC(__INTEL_COMPILER_BUILD_DATE)
# endif
# if defined(_MSC_VER)
/* _MSC_VER = VVRR */
# define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100)
# define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100)
# endif
# if defined(__GNUC__)
# define SIMULATE_VERSION_MAJOR DEC(__GNUC__)
# elif defined(__GNUG__)
# define SIMULATE_VERSION_MAJOR DEC(__GNUG__)
# endif
# if defined(__GNUC_MINOR__)
# define SIMULATE_VERSION_MINOR DEC(__GNUC_MINOR__)
# endif
# if defined(__GNUC_PATCHLEVEL__)
# define SIMULATE_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__)
# endif
#elif (defined(__clang__) && defined(__INTEL_CLANG_COMPILER)) || defined(__INTEL_LLVM_COMPILER)
# define COMPILER_ID "IntelLLVM"
#if defined(_MSC_VER)
# define SIMULATE_ID "MSVC"
#endif
#if defined(__GNUC__)
# define SIMULATE_ID "GNU"
#endif
/* __INTEL_LLVM_COMPILER = VVVVRP prior to 2021.2.0, VVVVRRPP for 2021.2.0 and
* later. Look for 6 digit vs. 8 digit version number to decide encoding.
* VVVV is no smaller than the current year when a version is released.
*/
#if __INTEL_LLVM_COMPILER < 1000000L
# define COMPILER_VERSION_MAJOR DEC(__INTEL_LLVM_COMPILER/100)
# define COMPILER_VERSION_MINOR DEC(__INTEL_LLVM_COMPILER/10 % 10)
# define COMPILER_VERSION_PATCH DEC(__INTEL_LLVM_COMPILER % 10)
#else
# define COMPILER_VERSION_MAJOR DEC(__INTEL_LLVM_COMPILER/10000)
# define COMPILER_VERSION_MINOR DEC(__INTEL_LLVM_COMPILER/100 % 100)
# define COMPILER_VERSION_PATCH DEC(__INTEL_LLVM_COMPILER % 100)
#endif
#if defined(_MSC_VER)
/* _MSC_VER = VVRR */
# define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100)
# define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100)
#endif
#if defined(__GNUC__)
# define SIMULATE_VERSION_MAJOR DEC(__GNUC__)
#elif defined(__GNUG__)
# define SIMULATE_VERSION_MAJOR DEC(__GNUG__)
#endif
#if defined(__GNUC_MINOR__)
# define SIMULATE_VERSION_MINOR DEC(__GNUC_MINOR__)
#endif
#if defined(__GNUC_PATCHLEVEL__)
# define SIMULATE_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__)
#endif
#elif defined(__PATHCC__)
# define COMPILER_ID "PathScale"
# define COMPILER_VERSION_MAJOR DEC(__PATHCC__)
# define COMPILER_VERSION_MINOR DEC(__PATHCC_MINOR__)
# if defined(__PATHCC_PATCHLEVEL__)
# define COMPILER_VERSION_PATCH DEC(__PATHCC_PATCHLEVEL__)
# endif
#elif defined(__BORLANDC__) && defined(__CODEGEARC_VERSION__)
# define COMPILER_ID "Embarcadero"
# define COMPILER_VERSION_MAJOR HEX(__CODEGEARC_VERSION__>>24 & 0x00FF)
# define COMPILER_VERSION_MINOR HEX(__CODEGEARC_VERSION__>>16 & 0x00FF)
# define COMPILER_VERSION_PATCH DEC(__CODEGEARC_VERSION__ & 0xFFFF)
#elif defined(__BORLANDC__)
# define COMPILER_ID "Borland"
/* __BORLANDC__ = 0xVRR */
# define COMPILER_VERSION_MAJOR HEX(__BORLANDC__>>8)
# define COMPILER_VERSION_MINOR HEX(__BORLANDC__ & 0xFF)
#elif defined(__WATCOMC__) && __WATCOMC__ < 1200
# define COMPILER_ID "Watcom"
/* __WATCOMC__ = VVRR */
# define COMPILER_VERSION_MAJOR DEC(__WATCOMC__ / 100)
# define COMPILER_VERSION_MINOR DEC((__WATCOMC__ / 10) % 10)
# if (__WATCOMC__ % 10) > 0
# define COMPILER_VERSION_PATCH DEC(__WATCOMC__ % 10)
# endif
#elif defined(__WATCOMC__)
# define COMPILER_ID "OpenWatcom"
/* __WATCOMC__ = VVRP + 1100 */
# define COMPILER_VERSION_MAJOR DEC((__WATCOMC__ - 1100) / 100)
# define COMPILER_VERSION_MINOR DEC((__WATCOMC__ / 10) % 10)
# if (__WATCOMC__ % 10) > 0
# define COMPILER_VERSION_PATCH DEC(__WATCOMC__ % 10)
# endif
#elif defined(__SUNPRO_C)
# define COMPILER_ID "SunPro"
# if __SUNPRO_C >= 0x5100
/* __SUNPRO_C = 0xVRRP */
# define COMPILER_VERSION_MAJOR HEX(__SUNPRO_C>>12)
# define COMPILER_VERSION_MINOR HEX(__SUNPRO_C>>4 & 0xFF)
# define COMPILER_VERSION_PATCH HEX(__SUNPRO_C & 0xF)
# else
/* __SUNPRO_CC = 0xVRP */
# define COMPILER_VERSION_MAJOR HEX(__SUNPRO_C>>8)
# define COMPILER_VERSION_MINOR HEX(__SUNPRO_C>>4 & 0xF)
# define COMPILER_VERSION_PATCH HEX(__SUNPRO_C & 0xF)
# endif
#elif defined(__HP_cc)
# define COMPILER_ID "HP"
/* __HP_cc = VVRRPP */
# define COMPILER_VERSION_MAJOR DEC(__HP_cc/10000)
# define COMPILER_VERSION_MINOR DEC(__HP_cc/100 % 100)
# define COMPILER_VERSION_PATCH DEC(__HP_cc % 100)
#elif defined(__DECC)
# define COMPILER_ID "Compaq"
/* __DECC_VER = VVRRTPPPP */
# define COMPILER_VERSION_MAJOR DEC(__DECC_VER/10000000)
# define COMPILER_VERSION_MINOR DEC(__DECC_VER/100000 % 100)
# define COMPILER_VERSION_PATCH DEC(__DECC_VER % 10000)
#elif defined(__IBMC__) && defined(__COMPILER_VER__)
# define COMPILER_ID "zOS"
/* __IBMC__ = VRP */
# define COMPILER_VERSION_MAJOR DEC(__IBMC__/100)
# define COMPILER_VERSION_MINOR DEC(__IBMC__/10 % 10)
# define COMPILER_VERSION_PATCH DEC(__IBMC__ % 10)
#elif defined(__open_xl__) && defined(__clang__)
# define COMPILER_ID "IBMClang"
# define COMPILER_VERSION_MAJOR DEC(__open_xl_version__)
# define COMPILER_VERSION_MINOR DEC(__open_xl_release__)
# define COMPILER_VERSION_PATCH DEC(__open_xl_modification__)
# define COMPILER_VERSION_TWEAK DEC(__open_xl_ptf_fix_level__)
#elif defined(__ibmxl__) && defined(__clang__)
# define COMPILER_ID "XLClang"
# define COMPILER_VERSION_MAJOR DEC(__ibmxl_version__)
# define COMPILER_VERSION_MINOR DEC(__ibmxl_release__)
# define COMPILER_VERSION_PATCH DEC(__ibmxl_modification__)
# define COMPILER_VERSION_TWEAK DEC(__ibmxl_ptf_fix_level__)
#elif defined(__IBMC__) && !defined(__COMPILER_VER__) && __IBMC__ >= 800
# define COMPILER_ID "XL"
/* __IBMC__ = VRP */
# define COMPILER_VERSION_MAJOR DEC(__IBMC__/100)
# define COMPILER_VERSION_MINOR DEC(__IBMC__/10 % 10)
# define COMPILER_VERSION_PATCH DEC(__IBMC__ % 10)
#elif defined(__IBMC__) && !defined(__COMPILER_VER__) && __IBMC__ < 800
# define COMPILER_ID "VisualAge"
/* __IBMC__ = VRP */
# define COMPILER_VERSION_MAJOR DEC(__IBMC__/100)
# define COMPILER_VERSION_MINOR DEC(__IBMC__/10 % 10)
# define COMPILER_VERSION_PATCH DEC(__IBMC__ % 10)
#elif defined(__NVCOMPILER)
# define COMPILER_ID "NVHPC"
# define COMPILER_VERSION_MAJOR DEC(__NVCOMPILER_MAJOR__)
# define COMPILER_VERSION_MINOR DEC(__NVCOMPILER_MINOR__)
# if defined(__NVCOMPILER_PATCHLEVEL__)
# define COMPILER_VERSION_PATCH DEC(__NVCOMPILER_PATCHLEVEL__)
# endif
#elif defined(__PGI)
# define COMPILER_ID "PGI"
# define COMPILER_VERSION_MAJOR DEC(__PGIC__)
# define COMPILER_VERSION_MINOR DEC(__PGIC_MINOR__)
# if defined(__PGIC_PATCHLEVEL__)
# define COMPILER_VERSION_PATCH DEC(__PGIC_PATCHLEVEL__)
# endif
#elif defined(__clang__) && defined(__cray__)
# define COMPILER_ID "CrayClang"
# define COMPILER_VERSION_MAJOR DEC(__cray_major__)
# define COMPILER_VERSION_MINOR DEC(__cray_minor__)
# define COMPILER_VERSION_PATCH DEC(__cray_patchlevel__)
# define COMPILER_VERSION_INTERNAL_STR __clang_version__
#elif defined(_CRAYC)
# define COMPILER_ID "Cray"
# define COMPILER_VERSION_MAJOR DEC(_RELEASE_MAJOR)
# define COMPILER_VERSION_MINOR DEC(_RELEASE_MINOR)
#elif defined(__TI_COMPILER_VERSION__)
# define COMPILER_ID "TI"
/* __TI_COMPILER_VERSION__ = VVVRRRPPP */
# define COMPILER_VERSION_MAJOR DEC(__TI_COMPILER_VERSION__/1000000)
# define COMPILER_VERSION_MINOR DEC(__TI_COMPILER_VERSION__/1000 % 1000)
# define COMPILER_VERSION_PATCH DEC(__TI_COMPILER_VERSION__ % 1000)
#elif defined(__CLANG_FUJITSU)
# define COMPILER_ID "FujitsuClang"
# define COMPILER_VERSION_MAJOR DEC(__FCC_major__)
# define COMPILER_VERSION_MINOR DEC(__FCC_minor__)
# define COMPILER_VERSION_PATCH DEC(__FCC_patchlevel__)
# define COMPILER_VERSION_INTERNAL_STR __clang_version__
#elif defined(__FUJITSU)
# define COMPILER_ID "Fujitsu"
# if defined(__FCC_version__)
# define COMPILER_VERSION __FCC_version__
# elif defined(__FCC_major__)
# define COMPILER_VERSION_MAJOR DEC(__FCC_major__)
# define COMPILER_VERSION_MINOR DEC(__FCC_minor__)
# define COMPILER_VERSION_PATCH DEC(__FCC_patchlevel__)
# endif
# if defined(__fcc_version)
# define COMPILER_VERSION_INTERNAL DEC(__fcc_version)
# elif defined(__FCC_VERSION)
# define COMPILER_VERSION_INTERNAL DEC(__FCC_VERSION)
# endif
#elif defined(__ghs__)
# define COMPILER_ID "GHS"
/* __GHS_VERSION_NUMBER = VVVVRP */
# ifdef __GHS_VERSION_NUMBER
# define COMPILER_VERSION_MAJOR DEC(__GHS_VERSION_NUMBER / 100)
# define COMPILER_VERSION_MINOR DEC(__GHS_VERSION_NUMBER / 10 % 10)
# define COMPILER_VERSION_PATCH DEC(__GHS_VERSION_NUMBER % 10)
# endif
#elif defined(__TASKING__)
# define COMPILER_ID "Tasking"
# define COMPILER_VERSION_MAJOR DEC(__VERSION__/1000)
# define COMPILER_VERSION_MINOR DEC(__VERSION__ % 100)
# define COMPILER_VERSION_INTERNAL DEC(__VERSION__)
#elif defined(__ORANGEC__)
# define COMPILER_ID "OrangeC"
# define COMPILER_VERSION_MAJOR DEC(__ORANGEC_MAJOR__)
# define COMPILER_VERSION_MINOR DEC(__ORANGEC_MINOR__)
# define COMPILER_VERSION_PATCH DEC(__ORANGEC_PATCHLEVEL__)
#elif defined(__TINYC__)
# define COMPILER_ID "TinyCC"
#elif defined(__BCC__)
# define COMPILER_ID "Bruce"
#elif defined(__SCO_VERSION__)
# define COMPILER_ID "SCO"
#elif defined(__ARMCC_VERSION) && !defined(__clang__)
# define COMPILER_ID "ARMCC"
#if __ARMCC_VERSION >= 1000000
/* __ARMCC_VERSION = VRRPPPP */
# define COMPILER_VERSION_MAJOR DEC(__ARMCC_VERSION/1000000)
# define COMPILER_VERSION_MINOR DEC(__ARMCC_VERSION/10000 % 100)
# define COMPILER_VERSION_PATCH DEC(__ARMCC_VERSION % 10000)
#else
/* __ARMCC_VERSION = VRPPPP */
# define COMPILER_VERSION_MAJOR DEC(__ARMCC_VERSION/100000)
# define COMPILER_VERSION_MINOR DEC(__ARMCC_VERSION/10000 % 10)
# define COMPILER_VERSION_PATCH DEC(__ARMCC_VERSION % 10000)
#endif
#elif defined(__clang__) && defined(__apple_build_version__)
# define COMPILER_ID "AppleClang"
# if defined(_MSC_VER)
# define SIMULATE_ID "MSVC"
# endif
# define COMPILER_VERSION_MAJOR DEC(__clang_major__)
# define COMPILER_VERSION_MINOR DEC(__clang_minor__)
# define COMPILER_VERSION_PATCH DEC(__clang_patchlevel__)
# if defined(_MSC_VER)
/* _MSC_VER = VVRR */
# define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100)
# define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100)
# endif
# define COMPILER_VERSION_TWEAK DEC(__apple_build_version__)
#elif defined(__clang__) && defined(__ARMCOMPILER_VERSION)
# define COMPILER_ID "ARMClang"
# define COMPILER_VERSION_MAJOR DEC(__ARMCOMPILER_VERSION/1000000)
# define COMPILER_VERSION_MINOR DEC(__ARMCOMPILER_VERSION/10000 % 100)
# define COMPILER_VERSION_PATCH DEC(__ARMCOMPILER_VERSION/100 % 100)
# define COMPILER_VERSION_INTERNAL DEC(__ARMCOMPILER_VERSION)
#elif defined(__clang__) && defined(__ti__)
# define COMPILER_ID "TIClang"
# define COMPILER_VERSION_MAJOR DEC(__ti_major__)
# define COMPILER_VERSION_MINOR DEC(__ti_minor__)
# define COMPILER_VERSION_PATCH DEC(__ti_patchlevel__)
# define COMPILER_VERSION_INTERNAL DEC(__ti_version__)
#elif defined(__clang__)
# define COMPILER_ID "Clang"
# if defined(_MSC_VER)
# define SIMULATE_ID "MSVC"
# endif
# define COMPILER_VERSION_MAJOR DEC(__clang_major__)
# define COMPILER_VERSION_MINOR DEC(__clang_minor__)
# define COMPILER_VERSION_PATCH DEC(__clang_patchlevel__)
# if defined(_MSC_VER)
/* _MSC_VER = VVRR */
# define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100)
# define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100)
# endif
#elif defined(__LCC__) && (defined(__GNUC__) || defined(__GNUG__) || defined(__MCST__))
# define COMPILER_ID "LCC"
# define COMPILER_VERSION_MAJOR DEC(__LCC__ / 100)
# define COMPILER_VERSION_MINOR DEC(__LCC__ % 100)
# if defined(__LCC_MINOR__)
# define COMPILER_VERSION_PATCH DEC(__LCC_MINOR__)
# endif
# if defined(__GNUC__) && defined(__GNUC_MINOR__)
# define SIMULATE_ID "GNU"
# define SIMULATE_VERSION_MAJOR DEC(__GNUC__)
# define SIMULATE_VERSION_MINOR DEC(__GNUC_MINOR__)
# if defined(__GNUC_PATCHLEVEL__)
# define SIMULATE_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__)
# endif
# endif
#elif defined(__GNUC__)
# define COMPILER_ID "GNU"
# define COMPILER_VERSION_MAJOR DEC(__GNUC__)
# if defined(__GNUC_MINOR__)
# define COMPILER_VERSION_MINOR DEC(__GNUC_MINOR__)
# endif
# if defined(__GNUC_PATCHLEVEL__)
# define COMPILER_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__)
# endif
#elif defined(_MSC_VER)
# define COMPILER_ID "MSVC"
/* _MSC_VER = VVRR */
# define COMPILER_VERSION_MAJOR DEC(_MSC_VER / 100)
# define COMPILER_VERSION_MINOR DEC(_MSC_VER % 100)
# if defined(_MSC_FULL_VER)
# if _MSC_VER >= 1400
/* _MSC_FULL_VER = VVRRPPPPP */
# define COMPILER_VERSION_PATCH DEC(_MSC_FULL_VER % 100000)
# else
/* _MSC_FULL_VER = VVRRPPPP */
# define COMPILER_VERSION_PATCH DEC(_MSC_FULL_VER % 10000)
# endif
# endif
# if defined(_MSC_BUILD)
# define COMPILER_VERSION_TWEAK DEC(_MSC_BUILD)
# endif
#elif defined(_ADI_COMPILER)
# define COMPILER_ID "ADSP"
#if defined(__VERSIONNUM__)
/* __VERSIONNUM__ = 0xVVRRPPTT */
# define COMPILER_VERSION_MAJOR DEC(__VERSIONNUM__ >> 24 & 0xFF)
# define COMPILER_VERSION_MINOR DEC(__VERSIONNUM__ >> 16 & 0xFF)
# define COMPILER_VERSION_PATCH DEC(__VERSIONNUM__ >> 8 & 0xFF)
# define COMPILER_VERSION_TWEAK DEC(__VERSIONNUM__ & 0xFF)
#endif
#elif defined(__IAR_SYSTEMS_ICC__) || defined(__IAR_SYSTEMS_ICC)
# define COMPILER_ID "IAR"
# if defined(__VER__) && defined(__ICCARM__)
# define COMPILER_VERSION_MAJOR DEC((__VER__) / 1000000)
# define COMPILER_VERSION_MINOR DEC(((__VER__) / 1000) % 1000)
# define COMPILER_VERSION_PATCH DEC((__VER__) % 1000)
# define COMPILER_VERSION_INTERNAL DEC(__IAR_SYSTEMS_ICC__)
# elif defined(__VER__) && (defined(__ICCAVR__) || defined(__ICCRX__) || defined(__ICCRH850__) || defined(__ICCRL78__) || defined(__ICC430__) || defined(__ICCRISCV__) || defined(__ICCV850__) || defined(__ICC8051__) || defined(__ICCSTM8__))
# define COMPILER_VERSION_MAJOR DEC((__VER__) / 100)
# define COMPILER_VERSION_MINOR DEC((__VER__) - (((__VER__) / 100)*100))
# define COMPILER_VERSION_PATCH DEC(__SUBVERSION__)
# define COMPILER_VERSION_INTERNAL DEC(__IAR_SYSTEMS_ICC__)
# endif
#elif defined(__SDCC_VERSION_MAJOR) || defined(SDCC)
# define COMPILER_ID "SDCC"
# if defined(__SDCC_VERSION_MAJOR)
# define COMPILER_VERSION_MAJOR DEC(__SDCC_VERSION_MAJOR)
# define COMPILER_VERSION_MINOR DEC(__SDCC_VERSION_MINOR)
# define COMPILER_VERSION_PATCH DEC(__SDCC_VERSION_PATCH)
# else
/* SDCC = VRP */
# define COMPILER_VERSION_MAJOR DEC(SDCC/100)
# define COMPILER_VERSION_MINOR DEC(SDCC/10 % 10)
# define COMPILER_VERSION_PATCH DEC(SDCC % 10)
# endif
/* These compilers are either not known or too old to define an
identification macro. Try to identify the platform and guess that
it is the native compiler. */
#elif defined(__hpux) || defined(__hpua)
# define COMPILER_ID "HP"
#else /* unknown compiler */
# define COMPILER_ID ""
#endif
/* Construct the string literal in pieces to prevent the source from
getting matched. Store it in a pointer rather than an array
because some compilers will just produce instructions to fill the
array rather than assigning a pointer to a static array. */
char const* info_compiler = "INFO" ":" "compiler[" COMPILER_ID "]";
#ifdef SIMULATE_ID
char const* info_simulate = "INFO" ":" "simulate[" SIMULATE_ID "]";
#endif
#ifdef __QNXNTO__
char const* qnxnto = "INFO" ":" "qnxnto[]";
#endif
#if defined(__CRAYXT_COMPUTE_LINUX_TARGET)
char const *info_cray = "INFO" ":" "compiler_wrapper[CrayPrgEnv]";
#endif
#define STRINGIFY_HELPER(X) #X
#define STRINGIFY(X) STRINGIFY_HELPER(X)
/* Identify known platforms by name. */
#if defined(__linux) || defined(__linux__) || defined(linux)
# define PLATFORM_ID "Linux"
#elif defined(__MSYS__)
# define PLATFORM_ID "MSYS"
#elif defined(__CYGWIN__)
# define PLATFORM_ID "Cygwin"
#elif defined(__MINGW32__)
# define PLATFORM_ID "MinGW"
#elif defined(__APPLE__)
# define PLATFORM_ID "Darwin"
#elif defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
# define PLATFORM_ID "Windows"
#elif defined(__FreeBSD__) || defined(__FreeBSD)
# define PLATFORM_ID "FreeBSD"
#elif defined(__NetBSD__) || defined(__NetBSD)
# define PLATFORM_ID "NetBSD"
#elif defined(__OpenBSD__) || defined(__OPENBSD)
# define PLATFORM_ID "OpenBSD"
#elif defined(__sun) || defined(sun)
# define PLATFORM_ID "SunOS"
#elif defined(_AIX) || defined(__AIX) || defined(__AIX__) || defined(__aix) || defined(__aix__)
# define PLATFORM_ID "AIX"
#elif defined(__hpux) || defined(__hpux__)
# define PLATFORM_ID "HP-UX"
#elif defined(__HAIKU__)
# define PLATFORM_ID "Haiku"
#elif defined(__BeOS) || defined(__BEOS__) || defined(_BEOS)
# define PLATFORM_ID "BeOS"
#elif defined(__QNX__) || defined(__QNXNTO__)
# define PLATFORM_ID "QNX"
#elif defined(__tru64) || defined(_tru64) || defined(__TRU64__)
# define PLATFORM_ID "Tru64"
#elif defined(__riscos) || defined(__riscos__)
# define PLATFORM_ID "RISCos"
#elif defined(__sinix) || defined(__sinix__) || defined(__SINIX__)
# define PLATFORM_ID "SINIX"
#elif defined(__UNIX_SV__)
# define PLATFORM_ID "UNIX_SV"
#elif defined(__bsdos__)
# define PLATFORM_ID "BSDOS"
#elif defined(_MPRAS) || defined(MPRAS)
# define PLATFORM_ID "MP-RAS"
#elif defined(__osf) || defined(__osf__)
# define PLATFORM_ID "OSF1"
#elif defined(_SCO_SV) || defined(SCO_SV) || defined(sco_sv)
# define PLATFORM_ID "SCO_SV"
#elif defined(__ultrix) || defined(__ultrix__) || defined(_ULTRIX)
# define PLATFORM_ID "ULTRIX"
#elif defined(__XENIX__) || defined(_XENIX) || defined(XENIX)
# define PLATFORM_ID "Xenix"
#elif defined(__WATCOMC__)
# if defined(__LINUX__)
# define PLATFORM_ID "Linux"
# elif defined(__DOS__)
# define PLATFORM_ID "DOS"
# elif defined(__OS2__)
# define PLATFORM_ID "OS2"
# elif defined(__WINDOWS__)
# define PLATFORM_ID "Windows3x"
# elif defined(__VXWORKS__)
# define PLATFORM_ID "VxWorks"
# else /* unknown platform */
# define PLATFORM_ID
# endif
#elif defined(__INTEGRITY)
# if defined(INT_178B)
# define PLATFORM_ID "Integrity178"
# else /* regular Integrity */
# define PLATFORM_ID "Integrity"
# endif
# elif defined(_ADI_COMPILER)
# define PLATFORM_ID "ADSP"
#else /* unknown platform */
# define PLATFORM_ID
#endif
/* For windows compilers MSVC and Intel we can determine
the architecture of the compiler being used. This is because
the compilers do not have flags that can change the architecture,
but rather depend on which compiler is being used
*/
#if defined(_WIN32) && defined(_MSC_VER)
# if defined(_M_IA64)
# define ARCHITECTURE_ID "IA64"
# elif defined(_M_ARM64EC)
# define ARCHITECTURE_ID "ARM64EC"
# elif defined(_M_X64) || defined(_M_AMD64)
# define ARCHITECTURE_ID "x64"
# elif defined(_M_IX86)
# define ARCHITECTURE_ID "X86"
# elif defined(_M_ARM64)
# define ARCHITECTURE_ID "ARM64"
# elif defined(_M_ARM)
# if _M_ARM == 4
# define ARCHITECTURE_ID "ARMV4I"
# elif _M_ARM == 5
# define ARCHITECTURE_ID "ARMV5I"
# else
# define ARCHITECTURE_ID "ARMV" STRINGIFY(_M_ARM)
# endif
# elif defined(_M_MIPS)
# define ARCHITECTURE_ID "MIPS"
# elif defined(_M_SH)
# define ARCHITECTURE_ID "SHx"
# else /* unknown architecture */
# define ARCHITECTURE_ID ""
# endif
#elif defined(__WATCOMC__)
# if defined(_M_I86)
# define ARCHITECTURE_ID "I86"
# elif defined(_M_IX86)
# define ARCHITECTURE_ID "X86"
# else /* unknown architecture */
# define ARCHITECTURE_ID ""
# endif
#elif defined(__IAR_SYSTEMS_ICC__) || defined(__IAR_SYSTEMS_ICC)
# if defined(__ICCARM__)
# define ARCHITECTURE_ID "ARM"
# elif defined(__ICCRX__)
# define ARCHITECTURE_ID "RX"
# elif defined(__ICCRH850__)
# define ARCHITECTURE_ID "RH850"
# elif defined(__ICCRL78__)
# define ARCHITECTURE_ID "RL78"
# elif defined(__ICCRISCV__)
# define ARCHITECTURE_ID "RISCV"
# elif defined(__ICCAVR__)
# define ARCHITECTURE_ID "AVR"
# elif defined(__ICC430__)
# define ARCHITECTURE_ID "MSP430"
# elif defined(__ICCV850__)
# define ARCHITECTURE_ID "V850"
# elif defined(__ICC8051__)
# define ARCHITECTURE_ID "8051"
# elif defined(__ICCSTM8__)
# define ARCHITECTURE_ID "STM8"
# else /* unknown architecture */
# define ARCHITECTURE_ID ""
# endif
#elif defined(__ghs__)
# if defined(__PPC64__)
# define ARCHITECTURE_ID "PPC64"
# elif defined(__ppc__)
# define ARCHITECTURE_ID "PPC"
# elif defined(__ARM__)
# define ARCHITECTURE_ID "ARM"
# elif defined(__x86_64__)
# define ARCHITECTURE_ID "x64"
# elif defined(__i386__)
# define ARCHITECTURE_ID "X86"
# else /* unknown architecture */
# define ARCHITECTURE_ID ""
# endif
#elif defined(__clang__) && defined(__ti__)
# if defined(__ARM_ARCH)
# define ARCHITECTURE_ID "Arm"
# else /* unknown architecture */
# define ARCHITECTURE_ID ""
# endif
#elif defined(__TI_COMPILER_VERSION__)
# if defined(__TI_ARM__)
# define ARCHITECTURE_ID "ARM"
# elif defined(__MSP430__)
# define ARCHITECTURE_ID "MSP430"
# elif defined(__TMS320C28XX__)
# define ARCHITECTURE_ID "TMS320C28x"
# elif defined(__TMS320C6X__) || defined(_TMS320C6X)
# define ARCHITECTURE_ID "TMS320C6x"
# else /* unknown architecture */
# define ARCHITECTURE_ID ""
# endif
# elif defined(__ADSPSHARC__)
# define ARCHITECTURE_ID "SHARC"
# elif defined(__ADSPBLACKFIN__)
# define ARCHITECTURE_ID "Blackfin"
#elif defined(__TASKING__)
# if defined(__CTC__) || defined(__CPTC__)
# define ARCHITECTURE_ID "TriCore"
# elif defined(__CMCS__)
# define ARCHITECTURE_ID "MCS"
# elif defined(__CARM__)
# define ARCHITECTURE_ID "ARM"
# elif defined(__CARC__)
# define ARCHITECTURE_ID "ARC"
# elif defined(__C51__)
# define ARCHITECTURE_ID "8051"
# elif defined(__CPCP__)
# define ARCHITECTURE_ID "PCP"
# else
# define ARCHITECTURE_ID ""
# endif
#else
# define ARCHITECTURE_ID
#endif
/* Convert integer to decimal digit literals. */
#define DEC(n) \
('0' + (((n) / 10000000)%10)), \
('0' + (((n) / 1000000)%10)), \
('0' + (((n) / 100000)%10)), \
('0' + (((n) / 10000)%10)), \
('0' + (((n) / 1000)%10)), \
('0' + (((n) / 100)%10)), \
('0' + (((n) / 10)%10)), \
('0' + ((n) % 10))
/* Convert integer to hex digit literals. */
#define HEX(n) \
('0' + ((n)>>28 & 0xF)), \
('0' + ((n)>>24 & 0xF)), \
('0' + ((n)>>20 & 0xF)), \
('0' + ((n)>>16 & 0xF)), \
('0' + ((n)>>12 & 0xF)), \
('0' + ((n)>>8 & 0xF)), \
('0' + ((n)>>4 & 0xF)), \
('0' + ((n) & 0xF))
/* Construct a string literal encoding the version number. */
#ifdef COMPILER_VERSION
char const* info_version = "INFO" ":" "compiler_version[" COMPILER_VERSION "]";
/* Construct a string literal encoding the version number components. */
#elif defined(COMPILER_VERSION_MAJOR)
char const info_version[] = {
'I', 'N', 'F', 'O', ':',
'c','o','m','p','i','l','e','r','_','v','e','r','s','i','o','n','[',
COMPILER_VERSION_MAJOR,
# ifdef COMPILER_VERSION_MINOR
'.', COMPILER_VERSION_MINOR,
# ifdef COMPILER_VERSION_PATCH
'.', COMPILER_VERSION_PATCH,
# ifdef COMPILER_VERSION_TWEAK
'.', COMPILER_VERSION_TWEAK,
# endif
# endif
# endif
']','\0'};
#endif
/* Construct a string literal encoding the internal version number. */
#ifdef COMPILER_VERSION_INTERNAL
char const info_version_internal[] = {
'I', 'N', 'F', 'O', ':',
'c','o','m','p','i','l','e','r','_','v','e','r','s','i','o','n','_',
'i','n','t','e','r','n','a','l','[',
COMPILER_VERSION_INTERNAL,']','\0'};
#elif defined(COMPILER_VERSION_INTERNAL_STR)
char const* info_version_internal = "INFO" ":" "compiler_version_internal[" COMPILER_VERSION_INTERNAL_STR "]";
#endif
/* Construct a string literal encoding the version number components. */
#ifdef SIMULATE_VERSION_MAJOR
char const info_simulate_version[] = {
'I', 'N', 'F', 'O', ':',
's','i','m','u','l','a','t','e','_','v','e','r','s','i','o','n','[',
SIMULATE_VERSION_MAJOR,
# ifdef SIMULATE_VERSION_MINOR
'.', SIMULATE_VERSION_MINOR,
# ifdef SIMULATE_VERSION_PATCH
'.', SIMULATE_VERSION_PATCH,
# ifdef SIMULATE_VERSION_TWEAK
'.', SIMULATE_VERSION_TWEAK,
# endif
# endif
# endif
']','\0'};
#endif
/* Construct the string literal in pieces to prevent the source from
getting matched. Store it in a pointer rather than an array
because some compilers will just produce instructions to fill the
array rather than assigning a pointer to a static array. */
char const* info_platform = "INFO" ":" "platform[" PLATFORM_ID "]";
char const* info_arch = "INFO" ":" "arch[" ARCHITECTURE_ID "]";
#define C_STD_99 199901L
#define C_STD_11 201112L
#define C_STD_17 201710L
#define C_STD_23 202311L
#ifdef __STDC_VERSION__
# define C_STD __STDC_VERSION__
#endif
#if !defined(__STDC__) && !defined(__clang__)
# if defined(_MSC_VER) || defined(__ibmxl__) || defined(__IBMC__)
# define C_VERSION "90"
# else
# define C_VERSION
# endif
#elif C_STD > C_STD_17
# define C_VERSION "23"
#elif C_STD > C_STD_11
# define C_VERSION "17"
#elif C_STD > C_STD_99
# define C_VERSION "11"
#elif C_STD >= C_STD_99
# define C_VERSION "99"
#else
# define C_VERSION "90"
#endif
const char* info_language_standard_default =
"INFO" ":" "standard_default[" C_VERSION "]";
const char* info_language_extensions_default = "INFO" ":" "extensions_default["
#if (defined(__clang__) || defined(__GNUC__) || defined(__xlC__) || \
defined(__TI_COMPILER_VERSION__)) && \
!defined(__STRICT_ANSI__)
"ON"
#else
"OFF"
#endif
"]";
/*--------------------------------------------------------------------------*/
#ifdef ID_VOID_MAIN
void main() {}
#else
# if defined(__CLASSIC_C__)
int main(argc, argv) int argc; char *argv[];
# else
int main(int argc, char* argv[])
# endif
{
int require = 0;
require += info_compiler[argc];
require += info_platform[argc];
require += info_arch[argc];
#ifdef COMPILER_VERSION_MAJOR
require += info_version[argc];
#endif
#ifdef COMPILER_VERSION_INTERNAL
require += info_version_internal[argc];
#endif
#ifdef SIMULATE_ID
require += info_simulate[argc];
#endif
#ifdef SIMULATE_VERSION_MAJOR
require += info_simulate_version[argc];
#endif
#if defined(__CRAYXT_COMPUTE_LINUX_TARGET)
require += info_cray[argc];
#endif
require += info_language_standard_default[argc];
require += info_language_extensions_default[argc];
(void)argv;
return require;
}
#endif

View File

@ -0,0 +1,919 @@
/* This source file must have a .cpp extension so that all C++ compilers
recognize the extension without flags. Borland does not know .cxx for
example. */
#ifndef __cplusplus
# error "A C compiler has been selected for C++."
#endif
#if !defined(__has_include)
/* If the compiler does not have __has_include, pretend the answer is
always no. */
# define __has_include(x) 0
#endif
/* Version number components: V=Version, R=Revision, P=Patch
Version date components: YYYY=Year, MM=Month, DD=Day */
#if defined(__INTEL_COMPILER) || defined(__ICC)
# define COMPILER_ID "Intel"
# if defined(_MSC_VER)
# define SIMULATE_ID "MSVC"
# endif
# if defined(__GNUC__)
# define SIMULATE_ID "GNU"
# endif
/* __INTEL_COMPILER = VRP prior to 2021, and then VVVV for 2021 and later,
except that a few beta releases use the old format with V=2021. */
# if __INTEL_COMPILER < 2021 || __INTEL_COMPILER == 202110 || __INTEL_COMPILER == 202111
# define COMPILER_VERSION_MAJOR DEC(__INTEL_COMPILER/100)
# define COMPILER_VERSION_MINOR DEC(__INTEL_COMPILER/10 % 10)
# if defined(__INTEL_COMPILER_UPDATE)
# define COMPILER_VERSION_PATCH DEC(__INTEL_COMPILER_UPDATE)
# else
# define COMPILER_VERSION_PATCH DEC(__INTEL_COMPILER % 10)
# endif
# else
# define COMPILER_VERSION_MAJOR DEC(__INTEL_COMPILER)
# define COMPILER_VERSION_MINOR DEC(__INTEL_COMPILER_UPDATE)
/* The third version component from --version is an update index,
but no macro is provided for it. */
# define COMPILER_VERSION_PATCH DEC(0)
# endif
# if defined(__INTEL_COMPILER_BUILD_DATE)
/* __INTEL_COMPILER_BUILD_DATE = YYYYMMDD */
# define COMPILER_VERSION_TWEAK DEC(__INTEL_COMPILER_BUILD_DATE)
# endif
# if defined(_MSC_VER)
/* _MSC_VER = VVRR */
# define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100)
# define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100)
# endif
# if defined(__GNUC__)
# define SIMULATE_VERSION_MAJOR DEC(__GNUC__)
# elif defined(__GNUG__)
# define SIMULATE_VERSION_MAJOR DEC(__GNUG__)
# endif
# if defined(__GNUC_MINOR__)
# define SIMULATE_VERSION_MINOR DEC(__GNUC_MINOR__)
# endif
# if defined(__GNUC_PATCHLEVEL__)
# define SIMULATE_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__)
# endif
#elif (defined(__clang__) && defined(__INTEL_CLANG_COMPILER)) || defined(__INTEL_LLVM_COMPILER)
# define COMPILER_ID "IntelLLVM"
#if defined(_MSC_VER)
# define SIMULATE_ID "MSVC"
#endif
#if defined(__GNUC__)
# define SIMULATE_ID "GNU"
#endif
/* __INTEL_LLVM_COMPILER = VVVVRP prior to 2021.2.0, VVVVRRPP for 2021.2.0 and
* later. Look for 6 digit vs. 8 digit version number to decide encoding.
* VVVV is no smaller than the current year when a version is released.
*/
#if __INTEL_LLVM_COMPILER < 1000000L
# define COMPILER_VERSION_MAJOR DEC(__INTEL_LLVM_COMPILER/100)
# define COMPILER_VERSION_MINOR DEC(__INTEL_LLVM_COMPILER/10 % 10)
# define COMPILER_VERSION_PATCH DEC(__INTEL_LLVM_COMPILER % 10)
#else
# define COMPILER_VERSION_MAJOR DEC(__INTEL_LLVM_COMPILER/10000)
# define COMPILER_VERSION_MINOR DEC(__INTEL_LLVM_COMPILER/100 % 100)
# define COMPILER_VERSION_PATCH DEC(__INTEL_LLVM_COMPILER % 100)
#endif
#if defined(_MSC_VER)
/* _MSC_VER = VVRR */
# define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100)
# define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100)
#endif
#if defined(__GNUC__)
# define SIMULATE_VERSION_MAJOR DEC(__GNUC__)
#elif defined(__GNUG__)
# define SIMULATE_VERSION_MAJOR DEC(__GNUG__)
#endif
#if defined(__GNUC_MINOR__)
# define SIMULATE_VERSION_MINOR DEC(__GNUC_MINOR__)
#endif
#if defined(__GNUC_PATCHLEVEL__)
# define SIMULATE_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__)
#endif
#elif defined(__PATHCC__)
# define COMPILER_ID "PathScale"
# define COMPILER_VERSION_MAJOR DEC(__PATHCC__)
# define COMPILER_VERSION_MINOR DEC(__PATHCC_MINOR__)
# if defined(__PATHCC_PATCHLEVEL__)
# define COMPILER_VERSION_PATCH DEC(__PATHCC_PATCHLEVEL__)
# endif
#elif defined(__BORLANDC__) && defined(__CODEGEARC_VERSION__)
# define COMPILER_ID "Embarcadero"
# define COMPILER_VERSION_MAJOR HEX(__CODEGEARC_VERSION__>>24 & 0x00FF)
# define COMPILER_VERSION_MINOR HEX(__CODEGEARC_VERSION__>>16 & 0x00FF)
# define COMPILER_VERSION_PATCH DEC(__CODEGEARC_VERSION__ & 0xFFFF)
#elif defined(__BORLANDC__)
# define COMPILER_ID "Borland"
/* __BORLANDC__ = 0xVRR */
# define COMPILER_VERSION_MAJOR HEX(__BORLANDC__>>8)
# define COMPILER_VERSION_MINOR HEX(__BORLANDC__ & 0xFF)
#elif defined(__WATCOMC__) && __WATCOMC__ < 1200
# define COMPILER_ID "Watcom"
/* __WATCOMC__ = VVRR */
# define COMPILER_VERSION_MAJOR DEC(__WATCOMC__ / 100)
# define COMPILER_VERSION_MINOR DEC((__WATCOMC__ / 10) % 10)
# if (__WATCOMC__ % 10) > 0
# define COMPILER_VERSION_PATCH DEC(__WATCOMC__ % 10)
# endif
#elif defined(__WATCOMC__)
# define COMPILER_ID "OpenWatcom"
/* __WATCOMC__ = VVRP + 1100 */
# define COMPILER_VERSION_MAJOR DEC((__WATCOMC__ - 1100) / 100)
# define COMPILER_VERSION_MINOR DEC((__WATCOMC__ / 10) % 10)
# if (__WATCOMC__ % 10) > 0
# define COMPILER_VERSION_PATCH DEC(__WATCOMC__ % 10)
# endif
#elif defined(__SUNPRO_CC)
# define COMPILER_ID "SunPro"
# if __SUNPRO_CC >= 0x5100
/* __SUNPRO_CC = 0xVRRP */
# define COMPILER_VERSION_MAJOR HEX(__SUNPRO_CC>>12)
# define COMPILER_VERSION_MINOR HEX(__SUNPRO_CC>>4 & 0xFF)
# define COMPILER_VERSION_PATCH HEX(__SUNPRO_CC & 0xF)
# else
/* __SUNPRO_CC = 0xVRP */
# define COMPILER_VERSION_MAJOR HEX(__SUNPRO_CC>>8)
# define COMPILER_VERSION_MINOR HEX(__SUNPRO_CC>>4 & 0xF)
# define COMPILER_VERSION_PATCH HEX(__SUNPRO_CC & 0xF)
# endif
#elif defined(__HP_aCC)
# define COMPILER_ID "HP"
/* __HP_aCC = VVRRPP */
# define COMPILER_VERSION_MAJOR DEC(__HP_aCC/10000)
# define COMPILER_VERSION_MINOR DEC(__HP_aCC/100 % 100)
# define COMPILER_VERSION_PATCH DEC(__HP_aCC % 100)
#elif defined(__DECCXX)
# define COMPILER_ID "Compaq"
/* __DECCXX_VER = VVRRTPPPP */
# define COMPILER_VERSION_MAJOR DEC(__DECCXX_VER/10000000)
# define COMPILER_VERSION_MINOR DEC(__DECCXX_VER/100000 % 100)
# define COMPILER_VERSION_PATCH DEC(__DECCXX_VER % 10000)
#elif defined(__IBMCPP__) && defined(__COMPILER_VER__)
# define COMPILER_ID "zOS"
/* __IBMCPP__ = VRP */
# define COMPILER_VERSION_MAJOR DEC(__IBMCPP__/100)
# define COMPILER_VERSION_MINOR DEC(__IBMCPP__/10 % 10)
# define COMPILER_VERSION_PATCH DEC(__IBMCPP__ % 10)
#elif defined(__open_xl__) && defined(__clang__)
# define COMPILER_ID "IBMClang"
# define COMPILER_VERSION_MAJOR DEC(__open_xl_version__)
# define COMPILER_VERSION_MINOR DEC(__open_xl_release__)
# define COMPILER_VERSION_PATCH DEC(__open_xl_modification__)
# define COMPILER_VERSION_TWEAK DEC(__open_xl_ptf_fix_level__)
#elif defined(__ibmxl__) && defined(__clang__)
# define COMPILER_ID "XLClang"
# define COMPILER_VERSION_MAJOR DEC(__ibmxl_version__)
# define COMPILER_VERSION_MINOR DEC(__ibmxl_release__)
# define COMPILER_VERSION_PATCH DEC(__ibmxl_modification__)
# define COMPILER_VERSION_TWEAK DEC(__ibmxl_ptf_fix_level__)
#elif defined(__IBMCPP__) && !defined(__COMPILER_VER__) && __IBMCPP__ >= 800
# define COMPILER_ID "XL"
/* __IBMCPP__ = VRP */
# define COMPILER_VERSION_MAJOR DEC(__IBMCPP__/100)
# define COMPILER_VERSION_MINOR DEC(__IBMCPP__/10 % 10)
# define COMPILER_VERSION_PATCH DEC(__IBMCPP__ % 10)
#elif defined(__IBMCPP__) && !defined(__COMPILER_VER__) && __IBMCPP__ < 800
# define COMPILER_ID "VisualAge"
/* __IBMCPP__ = VRP */
# define COMPILER_VERSION_MAJOR DEC(__IBMCPP__/100)
# define COMPILER_VERSION_MINOR DEC(__IBMCPP__/10 % 10)
# define COMPILER_VERSION_PATCH DEC(__IBMCPP__ % 10)
#elif defined(__NVCOMPILER)
# define COMPILER_ID "NVHPC"
# define COMPILER_VERSION_MAJOR DEC(__NVCOMPILER_MAJOR__)
# define COMPILER_VERSION_MINOR DEC(__NVCOMPILER_MINOR__)
# if defined(__NVCOMPILER_PATCHLEVEL__)
# define COMPILER_VERSION_PATCH DEC(__NVCOMPILER_PATCHLEVEL__)
# endif
#elif defined(__PGI)
# define COMPILER_ID "PGI"
# define COMPILER_VERSION_MAJOR DEC(__PGIC__)
# define COMPILER_VERSION_MINOR DEC(__PGIC_MINOR__)
# if defined(__PGIC_PATCHLEVEL__)
# define COMPILER_VERSION_PATCH DEC(__PGIC_PATCHLEVEL__)
# endif
#elif defined(__clang__) && defined(__cray__)
# define COMPILER_ID "CrayClang"
# define COMPILER_VERSION_MAJOR DEC(__cray_major__)
# define COMPILER_VERSION_MINOR DEC(__cray_minor__)
# define COMPILER_VERSION_PATCH DEC(__cray_patchlevel__)
# define COMPILER_VERSION_INTERNAL_STR __clang_version__
#elif defined(_CRAYC)
# define COMPILER_ID "Cray"
# define COMPILER_VERSION_MAJOR DEC(_RELEASE_MAJOR)
# define COMPILER_VERSION_MINOR DEC(_RELEASE_MINOR)
#elif defined(__TI_COMPILER_VERSION__)
# define COMPILER_ID "TI"
/* __TI_COMPILER_VERSION__ = VVVRRRPPP */
# define COMPILER_VERSION_MAJOR DEC(__TI_COMPILER_VERSION__/1000000)
# define COMPILER_VERSION_MINOR DEC(__TI_COMPILER_VERSION__/1000 % 1000)
# define COMPILER_VERSION_PATCH DEC(__TI_COMPILER_VERSION__ % 1000)
#elif defined(__CLANG_FUJITSU)
# define COMPILER_ID "FujitsuClang"
# define COMPILER_VERSION_MAJOR DEC(__FCC_major__)
# define COMPILER_VERSION_MINOR DEC(__FCC_minor__)
# define COMPILER_VERSION_PATCH DEC(__FCC_patchlevel__)
# define COMPILER_VERSION_INTERNAL_STR __clang_version__
#elif defined(__FUJITSU)
# define COMPILER_ID "Fujitsu"
# if defined(__FCC_version__)
# define COMPILER_VERSION __FCC_version__
# elif defined(__FCC_major__)
# define COMPILER_VERSION_MAJOR DEC(__FCC_major__)
# define COMPILER_VERSION_MINOR DEC(__FCC_minor__)
# define COMPILER_VERSION_PATCH DEC(__FCC_patchlevel__)
# endif
# if defined(__fcc_version)
# define COMPILER_VERSION_INTERNAL DEC(__fcc_version)
# elif defined(__FCC_VERSION)
# define COMPILER_VERSION_INTERNAL DEC(__FCC_VERSION)
# endif
#elif defined(__ghs__)
# define COMPILER_ID "GHS"
/* __GHS_VERSION_NUMBER = VVVVRP */
# ifdef __GHS_VERSION_NUMBER
# define COMPILER_VERSION_MAJOR DEC(__GHS_VERSION_NUMBER / 100)
# define COMPILER_VERSION_MINOR DEC(__GHS_VERSION_NUMBER / 10 % 10)
# define COMPILER_VERSION_PATCH DEC(__GHS_VERSION_NUMBER % 10)
# endif
#elif defined(__TASKING__)
# define COMPILER_ID "Tasking"
# define COMPILER_VERSION_MAJOR DEC(__VERSION__/1000)
# define COMPILER_VERSION_MINOR DEC(__VERSION__ % 100)
# define COMPILER_VERSION_INTERNAL DEC(__VERSION__)
#elif defined(__ORANGEC__)
# define COMPILER_ID "OrangeC"
# define COMPILER_VERSION_MAJOR DEC(__ORANGEC_MAJOR__)
# define COMPILER_VERSION_MINOR DEC(__ORANGEC_MINOR__)
# define COMPILER_VERSION_PATCH DEC(__ORANGEC_PATCHLEVEL__)
#elif defined(__SCO_VERSION__)
# define COMPILER_ID "SCO"
#elif defined(__ARMCC_VERSION) && !defined(__clang__)
# define COMPILER_ID "ARMCC"
#if __ARMCC_VERSION >= 1000000
/* __ARMCC_VERSION = VRRPPPP */
# define COMPILER_VERSION_MAJOR DEC(__ARMCC_VERSION/1000000)
# define COMPILER_VERSION_MINOR DEC(__ARMCC_VERSION/10000 % 100)
# define COMPILER_VERSION_PATCH DEC(__ARMCC_VERSION % 10000)
#else
/* __ARMCC_VERSION = VRPPPP */
# define COMPILER_VERSION_MAJOR DEC(__ARMCC_VERSION/100000)
# define COMPILER_VERSION_MINOR DEC(__ARMCC_VERSION/10000 % 10)
# define COMPILER_VERSION_PATCH DEC(__ARMCC_VERSION % 10000)
#endif
#elif defined(__clang__) && defined(__apple_build_version__)
# define COMPILER_ID "AppleClang"
# if defined(_MSC_VER)
# define SIMULATE_ID "MSVC"
# endif
# define COMPILER_VERSION_MAJOR DEC(__clang_major__)
# define COMPILER_VERSION_MINOR DEC(__clang_minor__)
# define COMPILER_VERSION_PATCH DEC(__clang_patchlevel__)
# if defined(_MSC_VER)
/* _MSC_VER = VVRR */
# define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100)
# define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100)
# endif
# define COMPILER_VERSION_TWEAK DEC(__apple_build_version__)
#elif defined(__clang__) && defined(__ARMCOMPILER_VERSION)
# define COMPILER_ID "ARMClang"
# define COMPILER_VERSION_MAJOR DEC(__ARMCOMPILER_VERSION/1000000)
# define COMPILER_VERSION_MINOR DEC(__ARMCOMPILER_VERSION/10000 % 100)
# define COMPILER_VERSION_PATCH DEC(__ARMCOMPILER_VERSION/100 % 100)
# define COMPILER_VERSION_INTERNAL DEC(__ARMCOMPILER_VERSION)
#elif defined(__clang__) && defined(__ti__)
# define COMPILER_ID "TIClang"
# define COMPILER_VERSION_MAJOR DEC(__ti_major__)
# define COMPILER_VERSION_MINOR DEC(__ti_minor__)
# define COMPILER_VERSION_PATCH DEC(__ti_patchlevel__)
# define COMPILER_VERSION_INTERNAL DEC(__ti_version__)
#elif defined(__clang__)
# define COMPILER_ID "Clang"
# if defined(_MSC_VER)
# define SIMULATE_ID "MSVC"
# endif
# define COMPILER_VERSION_MAJOR DEC(__clang_major__)
# define COMPILER_VERSION_MINOR DEC(__clang_minor__)
# define COMPILER_VERSION_PATCH DEC(__clang_patchlevel__)
# if defined(_MSC_VER)
/* _MSC_VER = VVRR */
# define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100)
# define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100)
# endif
#elif defined(__LCC__) && (defined(__GNUC__) || defined(__GNUG__) || defined(__MCST__))
# define COMPILER_ID "LCC"
# define COMPILER_VERSION_MAJOR DEC(__LCC__ / 100)
# define COMPILER_VERSION_MINOR DEC(__LCC__ % 100)
# if defined(__LCC_MINOR__)
# define COMPILER_VERSION_PATCH DEC(__LCC_MINOR__)
# endif
# if defined(__GNUC__) && defined(__GNUC_MINOR__)
# define SIMULATE_ID "GNU"
# define SIMULATE_VERSION_MAJOR DEC(__GNUC__)
# define SIMULATE_VERSION_MINOR DEC(__GNUC_MINOR__)
# if defined(__GNUC_PATCHLEVEL__)
# define SIMULATE_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__)
# endif
# endif
#elif defined(__GNUC__) || defined(__GNUG__)
# define COMPILER_ID "GNU"
# if defined(__GNUC__)
# define COMPILER_VERSION_MAJOR DEC(__GNUC__)
# else
# define COMPILER_VERSION_MAJOR DEC(__GNUG__)
# endif
# if defined(__GNUC_MINOR__)
# define COMPILER_VERSION_MINOR DEC(__GNUC_MINOR__)
# endif
# if defined(__GNUC_PATCHLEVEL__)
# define COMPILER_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__)
# endif
#elif defined(_MSC_VER)
# define COMPILER_ID "MSVC"
/* _MSC_VER = VVRR */
# define COMPILER_VERSION_MAJOR DEC(_MSC_VER / 100)
# define COMPILER_VERSION_MINOR DEC(_MSC_VER % 100)
# if defined(_MSC_FULL_VER)
# if _MSC_VER >= 1400
/* _MSC_FULL_VER = VVRRPPPPP */
# define COMPILER_VERSION_PATCH DEC(_MSC_FULL_VER % 100000)
# else
/* _MSC_FULL_VER = VVRRPPPP */
# define COMPILER_VERSION_PATCH DEC(_MSC_FULL_VER % 10000)
# endif
# endif
# if defined(_MSC_BUILD)
# define COMPILER_VERSION_TWEAK DEC(_MSC_BUILD)
# endif
#elif defined(_ADI_COMPILER)
# define COMPILER_ID "ADSP"
#if defined(__VERSIONNUM__)
/* __VERSIONNUM__ = 0xVVRRPPTT */
# define COMPILER_VERSION_MAJOR DEC(__VERSIONNUM__ >> 24 & 0xFF)
# define COMPILER_VERSION_MINOR DEC(__VERSIONNUM__ >> 16 & 0xFF)
# define COMPILER_VERSION_PATCH DEC(__VERSIONNUM__ >> 8 & 0xFF)
# define COMPILER_VERSION_TWEAK DEC(__VERSIONNUM__ & 0xFF)
#endif
#elif defined(__IAR_SYSTEMS_ICC__) || defined(__IAR_SYSTEMS_ICC)
# define COMPILER_ID "IAR"
# if defined(__VER__) && defined(__ICCARM__)
# define COMPILER_VERSION_MAJOR DEC((__VER__) / 1000000)
# define COMPILER_VERSION_MINOR DEC(((__VER__) / 1000) % 1000)
# define COMPILER_VERSION_PATCH DEC((__VER__) % 1000)
# define COMPILER_VERSION_INTERNAL DEC(__IAR_SYSTEMS_ICC__)
# elif defined(__VER__) && (defined(__ICCAVR__) || defined(__ICCRX__) || defined(__ICCRH850__) || defined(__ICCRL78__) || defined(__ICC430__) || defined(__ICCRISCV__) || defined(__ICCV850__) || defined(__ICC8051__) || defined(__ICCSTM8__))
# define COMPILER_VERSION_MAJOR DEC((__VER__) / 100)
# define COMPILER_VERSION_MINOR DEC((__VER__) - (((__VER__) / 100)*100))
# define COMPILER_VERSION_PATCH DEC(__SUBVERSION__)
# define COMPILER_VERSION_INTERNAL DEC(__IAR_SYSTEMS_ICC__)
# endif
/* These compilers are either not known or too old to define an
identification macro. Try to identify the platform and guess that
it is the native compiler. */
#elif defined(__hpux) || defined(__hpua)
# define COMPILER_ID "HP"
#else /* unknown compiler */
# define COMPILER_ID ""
#endif
/* Construct the string literal in pieces to prevent the source from
getting matched. Store it in a pointer rather than an array
because some compilers will just produce instructions to fill the
array rather than assigning a pointer to a static array. */
char const* info_compiler = "INFO" ":" "compiler[" COMPILER_ID "]";
#ifdef SIMULATE_ID
char const* info_simulate = "INFO" ":" "simulate[" SIMULATE_ID "]";
#endif
#ifdef __QNXNTO__
char const* qnxnto = "INFO" ":" "qnxnto[]";
#endif
#if defined(__CRAYXT_COMPUTE_LINUX_TARGET)
char const *info_cray = "INFO" ":" "compiler_wrapper[CrayPrgEnv]";
#endif
#define STRINGIFY_HELPER(X) #X
#define STRINGIFY(X) STRINGIFY_HELPER(X)
/* Identify known platforms by name. */
#if defined(__linux) || defined(__linux__) || defined(linux)
# define PLATFORM_ID "Linux"
#elif defined(__MSYS__)
# define PLATFORM_ID "MSYS"
#elif defined(__CYGWIN__)
# define PLATFORM_ID "Cygwin"
#elif defined(__MINGW32__)
# define PLATFORM_ID "MinGW"
#elif defined(__APPLE__)
# define PLATFORM_ID "Darwin"
#elif defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
# define PLATFORM_ID "Windows"
#elif defined(__FreeBSD__) || defined(__FreeBSD)
# define PLATFORM_ID "FreeBSD"
#elif defined(__NetBSD__) || defined(__NetBSD)
# define PLATFORM_ID "NetBSD"
#elif defined(__OpenBSD__) || defined(__OPENBSD)
# define PLATFORM_ID "OpenBSD"
#elif defined(__sun) || defined(sun)
# define PLATFORM_ID "SunOS"
#elif defined(_AIX) || defined(__AIX) || defined(__AIX__) || defined(__aix) || defined(__aix__)
# define PLATFORM_ID "AIX"
#elif defined(__hpux) || defined(__hpux__)
# define PLATFORM_ID "HP-UX"
#elif defined(__HAIKU__)
# define PLATFORM_ID "Haiku"
#elif defined(__BeOS) || defined(__BEOS__) || defined(_BEOS)
# define PLATFORM_ID "BeOS"
#elif defined(__QNX__) || defined(__QNXNTO__)
# define PLATFORM_ID "QNX"
#elif defined(__tru64) || defined(_tru64) || defined(__TRU64__)
# define PLATFORM_ID "Tru64"
#elif defined(__riscos) || defined(__riscos__)
# define PLATFORM_ID "RISCos"
#elif defined(__sinix) || defined(__sinix__) || defined(__SINIX__)
# define PLATFORM_ID "SINIX"
#elif defined(__UNIX_SV__)
# define PLATFORM_ID "UNIX_SV"
#elif defined(__bsdos__)
# define PLATFORM_ID "BSDOS"
#elif defined(_MPRAS) || defined(MPRAS)
# define PLATFORM_ID "MP-RAS"
#elif defined(__osf) || defined(__osf__)
# define PLATFORM_ID "OSF1"
#elif defined(_SCO_SV) || defined(SCO_SV) || defined(sco_sv)
# define PLATFORM_ID "SCO_SV"
#elif defined(__ultrix) || defined(__ultrix__) || defined(_ULTRIX)
# define PLATFORM_ID "ULTRIX"
#elif defined(__XENIX__) || defined(_XENIX) || defined(XENIX)
# define PLATFORM_ID "Xenix"
#elif defined(__WATCOMC__)
# if defined(__LINUX__)
# define PLATFORM_ID "Linux"
# elif defined(__DOS__)
# define PLATFORM_ID "DOS"
# elif defined(__OS2__)
# define PLATFORM_ID "OS2"
# elif defined(__WINDOWS__)
# define PLATFORM_ID "Windows3x"
# elif defined(__VXWORKS__)
# define PLATFORM_ID "VxWorks"
# else /* unknown platform */
# define PLATFORM_ID
# endif
#elif defined(__INTEGRITY)
# if defined(INT_178B)
# define PLATFORM_ID "Integrity178"
# else /* regular Integrity */
# define PLATFORM_ID "Integrity"
# endif
# elif defined(_ADI_COMPILER)
# define PLATFORM_ID "ADSP"
#else /* unknown platform */
# define PLATFORM_ID
#endif
/* For windows compilers MSVC and Intel we can determine
the architecture of the compiler being used. This is because
the compilers do not have flags that can change the architecture,
but rather depend on which compiler is being used
*/
#if defined(_WIN32) && defined(_MSC_VER)
# if defined(_M_IA64)
# define ARCHITECTURE_ID "IA64"
# elif defined(_M_ARM64EC)
# define ARCHITECTURE_ID "ARM64EC"
# elif defined(_M_X64) || defined(_M_AMD64)
# define ARCHITECTURE_ID "x64"
# elif defined(_M_IX86)
# define ARCHITECTURE_ID "X86"
# elif defined(_M_ARM64)
# define ARCHITECTURE_ID "ARM64"
# elif defined(_M_ARM)
# if _M_ARM == 4
# define ARCHITECTURE_ID "ARMV4I"
# elif _M_ARM == 5
# define ARCHITECTURE_ID "ARMV5I"
# else
# define ARCHITECTURE_ID "ARMV" STRINGIFY(_M_ARM)
# endif
# elif defined(_M_MIPS)
# define ARCHITECTURE_ID "MIPS"
# elif defined(_M_SH)
# define ARCHITECTURE_ID "SHx"
# else /* unknown architecture */
# define ARCHITECTURE_ID ""
# endif
#elif defined(__WATCOMC__)
# if defined(_M_I86)
# define ARCHITECTURE_ID "I86"
# elif defined(_M_IX86)
# define ARCHITECTURE_ID "X86"
# else /* unknown architecture */
# define ARCHITECTURE_ID ""
# endif
#elif defined(__IAR_SYSTEMS_ICC__) || defined(__IAR_SYSTEMS_ICC)
# if defined(__ICCARM__)
# define ARCHITECTURE_ID "ARM"
# elif defined(__ICCRX__)
# define ARCHITECTURE_ID "RX"
# elif defined(__ICCRH850__)
# define ARCHITECTURE_ID "RH850"
# elif defined(__ICCRL78__)
# define ARCHITECTURE_ID "RL78"
# elif defined(__ICCRISCV__)
# define ARCHITECTURE_ID "RISCV"
# elif defined(__ICCAVR__)
# define ARCHITECTURE_ID "AVR"
# elif defined(__ICC430__)
# define ARCHITECTURE_ID "MSP430"
# elif defined(__ICCV850__)
# define ARCHITECTURE_ID "V850"
# elif defined(__ICC8051__)
# define ARCHITECTURE_ID "8051"
# elif defined(__ICCSTM8__)
# define ARCHITECTURE_ID "STM8"
# else /* unknown architecture */
# define ARCHITECTURE_ID ""
# endif
#elif defined(__ghs__)
# if defined(__PPC64__)
# define ARCHITECTURE_ID "PPC64"
# elif defined(__ppc__)
# define ARCHITECTURE_ID "PPC"
# elif defined(__ARM__)
# define ARCHITECTURE_ID "ARM"
# elif defined(__x86_64__)
# define ARCHITECTURE_ID "x64"
# elif defined(__i386__)
# define ARCHITECTURE_ID "X86"
# else /* unknown architecture */
# define ARCHITECTURE_ID ""
# endif
#elif defined(__clang__) && defined(__ti__)
# if defined(__ARM_ARCH)
# define ARCHITECTURE_ID "Arm"
# else /* unknown architecture */
# define ARCHITECTURE_ID ""
# endif
#elif defined(__TI_COMPILER_VERSION__)
# if defined(__TI_ARM__)
# define ARCHITECTURE_ID "ARM"
# elif defined(__MSP430__)
# define ARCHITECTURE_ID "MSP430"
# elif defined(__TMS320C28XX__)
# define ARCHITECTURE_ID "TMS320C28x"
# elif defined(__TMS320C6X__) || defined(_TMS320C6X)
# define ARCHITECTURE_ID "TMS320C6x"
# else /* unknown architecture */
# define ARCHITECTURE_ID ""
# endif
# elif defined(__ADSPSHARC__)
# define ARCHITECTURE_ID "SHARC"
# elif defined(__ADSPBLACKFIN__)
# define ARCHITECTURE_ID "Blackfin"
#elif defined(__TASKING__)
# if defined(__CTC__) || defined(__CPTC__)
# define ARCHITECTURE_ID "TriCore"
# elif defined(__CMCS__)
# define ARCHITECTURE_ID "MCS"
# elif defined(__CARM__)
# define ARCHITECTURE_ID "ARM"
# elif defined(__CARC__)
# define ARCHITECTURE_ID "ARC"
# elif defined(__C51__)
# define ARCHITECTURE_ID "8051"
# elif defined(__CPCP__)
# define ARCHITECTURE_ID "PCP"
# else
# define ARCHITECTURE_ID ""
# endif
#else
# define ARCHITECTURE_ID
#endif
/* Convert integer to decimal digit literals. */
#define DEC(n) \
('0' + (((n) / 10000000)%10)), \
('0' + (((n) / 1000000)%10)), \
('0' + (((n) / 100000)%10)), \
('0' + (((n) / 10000)%10)), \
('0' + (((n) / 1000)%10)), \
('0' + (((n) / 100)%10)), \
('0' + (((n) / 10)%10)), \
('0' + ((n) % 10))
/* Convert integer to hex digit literals. */
#define HEX(n) \
('0' + ((n)>>28 & 0xF)), \
('0' + ((n)>>24 & 0xF)), \
('0' + ((n)>>20 & 0xF)), \
('0' + ((n)>>16 & 0xF)), \
('0' + ((n)>>12 & 0xF)), \
('0' + ((n)>>8 & 0xF)), \
('0' + ((n)>>4 & 0xF)), \
('0' + ((n) & 0xF))
/* Construct a string literal encoding the version number. */
#ifdef COMPILER_VERSION
char const* info_version = "INFO" ":" "compiler_version[" COMPILER_VERSION "]";
/* Construct a string literal encoding the version number components. */
#elif defined(COMPILER_VERSION_MAJOR)
char const info_version[] = {
'I', 'N', 'F', 'O', ':',
'c','o','m','p','i','l','e','r','_','v','e','r','s','i','o','n','[',
COMPILER_VERSION_MAJOR,
# ifdef COMPILER_VERSION_MINOR
'.', COMPILER_VERSION_MINOR,
# ifdef COMPILER_VERSION_PATCH
'.', COMPILER_VERSION_PATCH,
# ifdef COMPILER_VERSION_TWEAK
'.', COMPILER_VERSION_TWEAK,
# endif
# endif
# endif
']','\0'};
#endif
/* Construct a string literal encoding the internal version number. */
#ifdef COMPILER_VERSION_INTERNAL
char const info_version_internal[] = {
'I', 'N', 'F', 'O', ':',
'c','o','m','p','i','l','e','r','_','v','e','r','s','i','o','n','_',
'i','n','t','e','r','n','a','l','[',
COMPILER_VERSION_INTERNAL,']','\0'};
#elif defined(COMPILER_VERSION_INTERNAL_STR)
char const* info_version_internal = "INFO" ":" "compiler_version_internal[" COMPILER_VERSION_INTERNAL_STR "]";
#endif
/* Construct a string literal encoding the version number components. */
#ifdef SIMULATE_VERSION_MAJOR
char const info_simulate_version[] = {
'I', 'N', 'F', 'O', ':',
's','i','m','u','l','a','t','e','_','v','e','r','s','i','o','n','[',
SIMULATE_VERSION_MAJOR,
# ifdef SIMULATE_VERSION_MINOR
'.', SIMULATE_VERSION_MINOR,
# ifdef SIMULATE_VERSION_PATCH
'.', SIMULATE_VERSION_PATCH,
# ifdef SIMULATE_VERSION_TWEAK
'.', SIMULATE_VERSION_TWEAK,
# endif
# endif
# endif
']','\0'};
#endif
/* Construct the string literal in pieces to prevent the source from
getting matched. Store it in a pointer rather than an array
because some compilers will just produce instructions to fill the
array rather than assigning a pointer to a static array. */
char const* info_platform = "INFO" ":" "platform[" PLATFORM_ID "]";
char const* info_arch = "INFO" ":" "arch[" ARCHITECTURE_ID "]";
#define CXX_STD_98 199711L
#define CXX_STD_11 201103L
#define CXX_STD_14 201402L
#define CXX_STD_17 201703L
#define CXX_STD_20 202002L
#define CXX_STD_23 202302L
#if defined(__INTEL_COMPILER) && defined(_MSVC_LANG)
# if _MSVC_LANG > CXX_STD_17
# define CXX_STD _MSVC_LANG
# elif _MSVC_LANG == CXX_STD_17 && defined(__cpp_aggregate_paren_init)
# define CXX_STD CXX_STD_20
# elif _MSVC_LANG > CXX_STD_14 && __cplusplus > CXX_STD_17
# define CXX_STD CXX_STD_20
# elif _MSVC_LANG > CXX_STD_14
# define CXX_STD CXX_STD_17
# elif defined(__INTEL_CXX11_MODE__) && defined(__cpp_aggregate_nsdmi)
# define CXX_STD CXX_STD_14
# elif defined(__INTEL_CXX11_MODE__)
# define CXX_STD CXX_STD_11
# else
# define CXX_STD CXX_STD_98
# endif
#elif defined(_MSC_VER) && defined(_MSVC_LANG)
# if _MSVC_LANG > __cplusplus
# define CXX_STD _MSVC_LANG
# else
# define CXX_STD __cplusplus
# endif
#elif defined(__NVCOMPILER)
# if __cplusplus == CXX_STD_17 && defined(__cpp_aggregate_paren_init)
# define CXX_STD CXX_STD_20
# else
# define CXX_STD __cplusplus
# endif
#elif defined(__INTEL_COMPILER) || defined(__PGI)
# if __cplusplus == CXX_STD_11 && defined(__cpp_namespace_attributes)
# define CXX_STD CXX_STD_17
# elif __cplusplus == CXX_STD_11 && defined(__cpp_aggregate_nsdmi)
# define CXX_STD CXX_STD_14
# else
# define CXX_STD __cplusplus
# endif
#elif (defined(__IBMCPP__) || defined(__ibmxl__)) && defined(__linux__)
# if __cplusplus == CXX_STD_11 && defined(__cpp_aggregate_nsdmi)
# define CXX_STD CXX_STD_14
# else
# define CXX_STD __cplusplus
# endif
#elif __cplusplus == 1 && defined(__GXX_EXPERIMENTAL_CXX0X__)
# define CXX_STD CXX_STD_11
#else
# define CXX_STD __cplusplus
#endif
const char* info_language_standard_default = "INFO" ":" "standard_default["
#if CXX_STD > CXX_STD_23
"26"
#elif CXX_STD > CXX_STD_20
"23"
#elif CXX_STD > CXX_STD_17
"20"
#elif CXX_STD > CXX_STD_14
"17"
#elif CXX_STD > CXX_STD_11
"14"
#elif CXX_STD >= CXX_STD_11
"11"
#else
"98"
#endif
"]";
const char* info_language_extensions_default = "INFO" ":" "extensions_default["
#if (defined(__clang__) || defined(__GNUC__) || defined(__xlC__) || \
defined(__TI_COMPILER_VERSION__)) && \
!defined(__STRICT_ANSI__)
"ON"
#else
"OFF"
#endif
"]";
/*--------------------------------------------------------------------------*/
int main(int argc, char* argv[])
{
int require = 0;
require += info_compiler[argc];
require += info_platform[argc];
require += info_arch[argc];
#ifdef COMPILER_VERSION_MAJOR
require += info_version[argc];
#endif
#ifdef COMPILER_VERSION_INTERNAL
require += info_version_internal[argc];
#endif
#ifdef SIMULATE_ID
require += info_simulate[argc];
#endif
#ifdef SIMULATE_VERSION_MAJOR
require += info_simulate_version[argc];
#endif
#if defined(__CRAYXT_COMPUTE_LINUX_TARGET)
require += info_cray[argc];
#endif
require += info_language_standard_default[argc];
require += info_language_extensions_default[argc];
(void)argv;
return require;
}

View File

@ -0,0 +1,633 @@
---
events:
-
kind: "message-v1"
backtrace:
- "D:/cmake/share/cmake-3.30/Modules/CMakeDetermineSystem.cmake:205 (message)"
- "CMakeLists.txt:2 (project)"
message: |
The system is: Windows - 10.0.22631 - AMD64
-
kind: "message-v1"
backtrace:
- "D:/cmake/share/cmake-3.30/Modules/CMakeDetermineCompilerId.cmake:17 (message)"
- "D:/cmake/share/cmake-3.30/Modules/CMakeDetermineCompilerId.cmake:64 (__determine_compiler_id_test)"
- "D:/cmake/share/cmake-3.30/Modules/CMakeDetermineCCompiler.cmake:123 (CMAKE_DETERMINE_COMPILER_ID)"
- "CMakeLists.txt:2 (project)"
message: |
Compiling the C compiler identification source file "CMakeCCompilerId.c" succeeded.
Compiler: D:/c/mingw64/bin/gcc.exe
Build flags:
Id flags:
The output was:
0
Compilation of the C compiler identification source "CMakeCCompilerId.c" produced "a.exe"
The C compiler identification is GNU, found in:
D:/c_work/start/build/CMakeFiles/3.30.3/CompilerIdC/a.exe
-
kind: "message-v1"
backtrace:
- "D:/cmake/share/cmake-3.30/Modules/CMakeDetermineCompilerId.cmake:17 (message)"
- "D:/cmake/share/cmake-3.30/Modules/CMakeDetermineCompilerId.cmake:64 (__determine_compiler_id_test)"
- "D:/cmake/share/cmake-3.30/Modules/CMakeDetermineCXXCompiler.cmake:126 (CMAKE_DETERMINE_COMPILER_ID)"
- "CMakeLists.txt:2 (project)"
message: |
Compiling the CXX compiler identification source file "CMakeCXXCompilerId.cpp" succeeded.
Compiler: D:/c/mingw64/bin/g++.exe
Build flags:
Id flags:
The output was:
0
Compilation of the CXX compiler identification source "CMakeCXXCompilerId.cpp" produced "a.exe"
The CXX compiler identification is GNU, found in:
D:/c_work/start/build/CMakeFiles/3.30.3/CompilerIdCXX/a.exe
-
kind: "try_compile-v1"
backtrace:
- "D:/cmake/share/cmake-3.30/Modules/CMakeDetermineCompilerABI.cmake:74 (try_compile)"
- "D:/cmake/share/cmake-3.30/Modules/CMakeTestCCompiler.cmake:26 (CMAKE_DETERMINE_COMPILER_ABI)"
- "CMakeLists.txt:2 (project)"
checks:
- "Detecting C compiler ABI info"
directories:
source: "D:/c_work/start/build/CMakeFiles/CMakeScratch/TryCompile-r96baa"
binary: "D:/c_work/start/build/CMakeFiles/CMakeScratch/TryCompile-r96baa"
cmakeVariables:
CMAKE_C_FLAGS: ""
CMAKE_C_FLAGS_DEBUG: "-g"
CMAKE_EXE_LINKER_FLAGS: ""
buildResult:
variable: "CMAKE_C_ABI_COMPILED"
cached: true
stdout: |
Change Dir: 'D:/c_work/start/build/CMakeFiles/CMakeScratch/TryCompile-r96baa'
Run Build Command(s): D:/cmake/bin/cmake.exe -E env VERBOSE=1 D:/c/mingw64/bin/mingw32-make.exe -f Makefile cmTC_c4c09/fast
D:/c/mingw64/bin/mingw32-make.exe -f CMakeFiles\\cmTC_c4c09.dir\\build.make CMakeFiles/cmTC_c4c09.dir/build
mingw32-make.exe[1]: Entering directory 'D:/c_work/start/build/CMakeFiles/CMakeScratch/TryCompile-r96baa'
Building C object CMakeFiles/cmTC_c4c09.dir/CMakeCCompilerABI.c.obj
D:\\c\\mingw64\\bin\\gcc.exe -v -o CMakeFiles\\cmTC_c4c09.dir\\CMakeCCompilerABI.c.obj -c D:\\cmake\\share\\cmake-3.30\\Modules\\CMakeCCompilerABI.c
Using built-in specs.
COLLECT_GCC=D:\\c\\mingw64\\bin\\gcc.exe
Target: x86_64-w64-mingw32
Configured with: ../../../src/gcc-8.1.0/configure --host=x86_64-w64-mingw32 --build=x86_64-w64-mingw32 --target=x86_64-w64-mingw32 --prefix=/mingw64 --with-sysroot=/c/mingw810/x86_64-810-win32-seh-rt_v6-rev0/mingw64 --enable-shared --enable-static --disable-multilib --enable-languages=c,c++,fortran,lto --enable-libstdcxx-time=yes --enable-threads=win32 --enable-libgomp --enable-libatomic --enable-lto --enable-graphite --enable-checking=release --enable-fully-dynamic-string --enable-version-specific-runtime-libs --disable-libstdcxx-pch --disable-libstdcxx-debug --enable-bootstrap --disable-rpath --disable-win32-registry --disable-nls --disable-werror --disable-symvers --with-gnu-as --with-gnu-ld --with-arch=nocona --with-tune=core2 --with-libiconv --with-system-zlib --with-gmp=/c/mingw810/prerequisites/x86_64-w64-mingw32-static --with-mpfr=/c/mingw810/prerequisites/x86_64-w64-mingw32-static --with-mpc=/c/mingw810/prerequisites/x86_64-w64-mingw32-static --with-isl=/c/mingw810/prerequisites/x86_64-w64-mingw32-static --with-pkgversion='x86_64-win32-seh-rev0, Built by MinGW-W64 project' --with-bugurl=https://sourceforge.net/projects/mingw-w64 CFLAGS='-O2 -pipe -fno-ident -I/c/mingw810/x86_64-810-win32-seh-rt_v6-rev0/mingw64/opt/include -I/c/mingw810/prerequisites/x86_64-zlib-static/include -I/c/mingw810/prerequisites/x86_64-w64-mingw32-static/include' CXXFLAGS='-O2 -pipe -fno-ident -I/c/mingw810/x86_64-810-win32-seh-rt_v6-rev0/mingw64/opt/include -I/c/mingw810/prerequisites/x86_64-zlib-static/include -I/c/mingw810/prerequisites/x86_64-w64-mingw32-static/include' CPPFLAGS=' -I/c/mingw810/x86_64-810-win32-seh-rt_v6-rev0/mingw64/opt/include -I/c/mingw810/prerequisites/x86_64-zlib-static/include -I/c/mingw810/prerequisites/x86_64-w64-mingw32-static/include' LDFLAGS='-pipe -fno-ident -L/c/mingw810/x86_64-810-win32-seh-rt_v6-rev0/mingw64/opt/lib -L/c/mingw810/prerequisites/x86_64-zlib-static/lib -L/c/mingw810/prerequisites/x86_64-w64-mingw32-static/lib '
Thread model: win32
gcc version 8.1.0 (x86_64-win32-seh-rev0, Built by MinGW-W64 project)
COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles\\cmTC_c4c09.dir\\CMakeCCompilerABI.c.obj' '-c' '-mtune=core2' '-march=nocona'
D:/c/mingw64/bin/../libexec/gcc/x86_64-w64-mingw32/8.1.0/cc1.exe -quiet -v -iprefix D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/ -U_REENTRANT D:\\cmake\\share\\cmake-3.30\\Modules\\CMakeCCompilerABI.c -quiet -dumpbase CMakeCCompilerABI.c -mtune=core2 -march=nocona -auxbase-strip CMakeFiles\\cmTC_c4c09.dir\\CMakeCCompilerABI.c.obj -version -o C:\\Users\\OMEN\\AppData\\Local\\Temp\\ccPiSQIT.s
GNU C17 (x86_64-win32-seh-rev0, Built by MinGW-W64 project) version 8.1.0 (x86_64-w64-mingw32)
compiled by GNU C version 8.1.0, GMP version 6.1.2, MPFR version 4.0.1, MPC version 1.1.0, isl version isl-0.18-GMP
GGC heuristics: --param ggc-min-expand=100 --param ggc-min-heapsize=131072
ignoring duplicate directory "D:/c/mingw64/lib/gcc/../../lib/gcc/x86_64-w64-mingw32/8.1.0/include"
ignoring nonexistent directory "C:/mingw810/x86_64-810-win32-seh-rt_v6-rev0/mingw64C:/msys64/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../include"
ignoring duplicate directory "D:/c/mingw64/lib/gcc/../../lib/gcc/x86_64-w64-mingw32/8.1.0/include-fixed"
ignoring duplicate directory "D:/c/mingw64/lib/gcc/../../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../x86_64-w64-mingw32/include"
ignoring nonexistent directory "C:/mingw810/x86_64-810-win32-seh-rt_v6-rev0/mingw64/mingw/include"
#include "..." search starts here:
#include <...> search starts here:
D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/include
D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/include-fixed
D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../x86_64-w64-mingw32/include
End of search list.
GNU C17 (x86_64-win32-seh-rev0, Built by MinGW-W64 project) version 8.1.0 (x86_64-w64-mingw32)
compiled by GNU C version 8.1.0, GMP version 6.1.2, MPFR version 4.0.1, MPC version 1.1.0, isl version isl-0.18-GMP
GGC heuristics: --param ggc-min-expand=100 --param ggc-min-heapsize=131072
Compiler executable checksum: bb117049c51d03d971e874cfcb35cac9
COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles\\cmTC_c4c09.dir\\CMakeCCompilerABI.c.obj' '-c' '-mtune=core2' '-march=nocona'
D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../x86_64-w64-mingw32/bin/as.exe -v -o CMakeFiles\\cmTC_c4c09.dir\\CMakeCCompilerABI.c.obj C:\\Users\\OMEN\\AppData\\Local\\Temp\\ccPiSQIT.s
GNU assembler version 2.30 (x86_64-w64-mingw32) using BFD version (GNU Binutils) 2.30
COMPILER_PATH=D:/c/mingw64/bin/../libexec/gcc/x86_64-w64-mingw32/8.1.0/;D:/c/mingw64/bin/../libexec/gcc/;D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../x86_64-w64-mingw32/bin/
LIBRARY_PATH=D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/;D:/c/mingw64/bin/../lib/gcc/;D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../x86_64-w64-mingw32/lib/../lib/;D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../lib/;D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../x86_64-w64-mingw32/lib/;D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../
COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles\\cmTC_c4c09.dir\\CMakeCCompilerABI.c.obj' '-c' '-mtune=core2' '-march=nocona'
Linking C executable cmTC_c4c09.exe
D:\\cmake\\bin\\cmake.exe -E cmake_link_script CMakeFiles\\cmTC_c4c09.dir\\link.txt --verbose=1
D:\\cmake\\bin\\cmake.exe -E rm -f CMakeFiles\\cmTC_c4c09.dir/objects.a
D:\\c\\mingw64\\bin\\ar.exe qc CMakeFiles\\cmTC_c4c09.dir/objects.a @CMakeFiles\\cmTC_c4c09.dir\\objects1.rsp
D:\\c\\mingw64\\bin\\gcc.exe -v -Wl,-v -Wl,--whole-archive CMakeFiles\\cmTC_c4c09.dir/objects.a -Wl,--no-whole-archive -o cmTC_c4c09.exe -Wl,--out-implib,libcmTC_c4c09.dll.a -Wl,--major-image-version,0,--minor-image-version,0
Using built-in specs.
COLLECT_GCC=D:\\c\\mingw64\\bin\\gcc.exe
COLLECT_LTO_WRAPPER=D:/c/mingw64/bin/../libexec/gcc/x86_64-w64-mingw32/8.1.0/lto-wrapper.exe
Target: x86_64-w64-mingw32
Configured with: ../../../src/gcc-8.1.0/configure --host=x86_64-w64-mingw32 --build=x86_64-w64-mingw32 --target=x86_64-w64-mingw32 --prefix=/mingw64 --with-sysroot=/c/mingw810/x86_64-810-win32-seh-rt_v6-rev0/mingw64 --enable-shared --enable-static --disable-multilib --enable-languages=c,c++,fortran,lto --enable-libstdcxx-time=yes --enable-threads=win32 --enable-libgomp --enable-libatomic --enable-lto --enable-graphite --enable-checking=release --enable-fully-dynamic-string --enable-version-specific-runtime-libs --disable-libstdcxx-pch --disable-libstdcxx-debug --enable-bootstrap --disable-rpath --disable-win32-registry --disable-nls --disable-werror --disable-symvers --with-gnu-as --with-gnu-ld --with-arch=nocona --with-tune=core2 --with-libiconv --with-system-zlib --with-gmp=/c/mingw810/prerequisites/x86_64-w64-mingw32-static --with-mpfr=/c/mingw810/prerequisites/x86_64-w64-mingw32-static --with-mpc=/c/mingw810/prerequisites/x86_64-w64-mingw32-static --with-isl=/c/mingw810/prerequisites/x86_64-w64-mingw32-static --with-pkgversion='x86_64-win32-seh-rev0, Built by MinGW-W64 project' --with-bugurl=https://sourceforge.net/projects/mingw-w64 CFLAGS='-O2 -pipe -fno-ident -I/c/mingw810/x86_64-810-win32-seh-rt_v6-rev0/mingw64/opt/include -I/c/mingw810/prerequisites/x86_64-zlib-static/include -I/c/mingw810/prerequisites/x86_64-w64-mingw32-static/include' CXXFLAGS='-O2 -pipe -fno-ident -I/c/mingw810/x86_64-810-win32-seh-rt_v6-rev0/mingw64/opt/include -I/c/mingw810/prerequisites/x86_64-zlib-static/include -I/c/mingw810/prerequisites/x86_64-w64-mingw32-static/include' CPPFLAGS=' -I/c/mingw810/x86_64-810-win32-seh-rt_v6-rev0/mingw64/opt/include -I/c/mingw810/prerequisites/x86_64-zlib-static/include -I/c/mingw810/prerequisites/x86_64-w64-mingw32-static/include' LDFLAGS='-pipe -fno-ident -L/c/mingw810/x86_64-810-win32-seh-rt_v6-rev0/mingw64/opt/lib -L/c/mingw810/prerequisites/x86_64-zlib-static/lib -L/c/mingw810/prerequisites/x86_64-w64-mingw32-static/lib '
Thread model: win32
gcc version 8.1.0 (x86_64-win32-seh-rev0, Built by MinGW-W64 project)
COMPILER_PATH=D:/c/mingw64/bin/../libexec/gcc/x86_64-w64-mingw32/8.1.0/;D:/c/mingw64/bin/../libexec/gcc/;D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../x86_64-w64-mingw32/bin/
LIBRARY_PATH=D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/;D:/c/mingw64/bin/../lib/gcc/;D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../x86_64-w64-mingw32/lib/../lib/;D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../lib/;D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../x86_64-w64-mingw32/lib/;D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../
COLLECT_GCC_OPTIONS='-v' '-o' 'cmTC_c4c09.exe' '-mtune=core2' '-march=nocona'
D:/c/mingw64/bin/../libexec/gcc/x86_64-w64-mingw32/8.1.0/collect2.exe -plugin D:/c/mingw64/bin/../libexec/gcc/x86_64-w64-mingw32/8.1.0/liblto_plugin-0.dll -plugin-opt=D:/c/mingw64/bin/../libexec/gcc/x86_64-w64-mingw32/8.1.0/lto-wrapper.exe -plugin-opt=-fresolution=C:\\Users\\OMEN\\AppData\\Local\\Temp\\cc9S4M14.res -plugin-opt=-pass-through=-lmingw32 -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lgcc_eh -plugin-opt=-pass-through=-lmoldname -plugin-opt=-pass-through=-lmingwex -plugin-opt=-pass-through=-lmsvcrt -plugin-opt=-pass-through=-ladvapi32 -plugin-opt=-pass-through=-lshell32 -plugin-opt=-pass-through=-luser32 -plugin-opt=-pass-through=-lkernel32 -plugin-opt=-pass-through=-liconv -plugin-opt=-pass-through=-lmingw32 -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lgcc_eh -plugin-opt=-pass-through=-lmoldname -plugin-opt=-pass-through=-lmingwex -plugin-opt=-pass-through=-lmsvcrt --sysroot=C:/mingw810/x86_64-810-win32-seh-rt_v6-rev0/mingw64 -m i386pep -Bdynamic -o cmTC_c4c09.exe D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../x86_64-w64-mingw32/lib/../lib/crt2.o D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/crtbegin.o -LD:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0 -LD:/c/mingw64/bin/../lib/gcc -LD:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../x86_64-w64-mingw32/lib/../lib -LD:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../lib -LD:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../x86_64-w64-mingw32/lib -LD:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../.. -v --whole-archive CMakeFiles\\cmTC_c4c09.dir/objects.a --no-whole-archive --out-implib libcmTC_c4c09.dll.a --major-image-version 0 --minor-image-version 0 -lmingw32 -lgcc -lgcc_eh -lmoldname -lmingwex -lmsvcrt -ladvapi32 -lshell32 -luser32 -lkernel32 -liconv -lmingw32 -lgcc -lgcc_eh -lmoldname -lmingwex -lmsvcrt D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/crtend.o
collect2 version 8.1.0
D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../x86_64-w64-mingw32/bin/ld.exe -plugin D:/c/mingw64/bin/../libexec/gcc/x86_64-w64-mingw32/8.1.0/liblto_plugin-0.dll -plugin-opt=D:/c/mingw64/bin/../libexec/gcc/x86_64-w64-mingw32/8.1.0/lto-wrapper.exe -plugin-opt=-fresolution=C:\\Users\\OMEN\\AppData\\Local\\Temp\\cc9S4M14.res -plugin-opt=-pass-through=-lmingw32 -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lgcc_eh -plugin-opt=-pass-through=-lmoldname -plugin-opt=-pass-through=-lmingwex -plugin-opt=-pass-through=-lmsvcrt -plugin-opt=-pass-through=-ladvapi32 -plugin-opt=-pass-through=-lshell32 -plugin-opt=-pass-through=-luser32 -plugin-opt=-pass-through=-lkernel32 -plugin-opt=-pass-through=-liconv -plugin-opt=-pass-through=-lmingw32 -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lgcc_eh -plugin-opt=-pass-through=-lmoldname -plugin-opt=-pass-through=-lmingwex -plugin-opt=-pass-through=-lmsvcrt --sysroot=C:/mingw810/x86_64-810-win32-seh-rt_v6-rev0/mingw64 -m i386pep -Bdynamic -o cmTC_c4c09.exe D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../x86_64-w64-mingw32/lib/../lib/crt2.o D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/crtbegin.o -LD:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0 -LD:/c/mingw64/bin/../lib/gcc -LD:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../x86_64-w64-mingw32/lib/../lib -LD:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../lib -LD:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../x86_64-w64-mingw32/lib -LD:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../.. -v --whole-archive CMakeFiles\\cmTC_c4c09.dir/objects.a --no-whole-archive --out-implib libcmTC_c4c09.dll.a --major-image-version 0 --minor-image-version 0 -lmingw32 -lgcc -lgcc_eh -lmoldname -lmingwex -lmsvcrt -ladvapi32 -lshell32 -luser32 -lkernel32 -liconv -lmingw32 -lgcc -lgcc_eh -lmoldname -lmingwex -lmsvcrt D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/crtend.o
GNU ld (GNU Binutils) 2.30
COLLECT_GCC_OPTIONS='-v' '-o' 'cmTC_c4c09.exe' '-mtune=core2' '-march=nocona'
mingw32-make.exe[1]: Leaving directory 'D:/c_work/start/build/CMakeFiles/CMakeScratch/TryCompile-r96baa'
exitCode: 0
-
kind: "message-v1"
backtrace:
- "D:/cmake/share/cmake-3.30/Modules/CMakeDetermineCompilerABI.cmake:182 (message)"
- "D:/cmake/share/cmake-3.30/Modules/CMakeTestCCompiler.cmake:26 (CMAKE_DETERMINE_COMPILER_ABI)"
- "CMakeLists.txt:2 (project)"
message: |
Parsed C implicit include dir info: rv=done
found start of include info
found start of implicit include info
add: [D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/include]
add: [D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/include-fixed]
add: [D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../x86_64-w64-mingw32/include]
end of search list found
collapse include dir [D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/include] ==> [D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include]
collapse include dir [D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/include-fixed] ==> [D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include-fixed]
collapse include dir [D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../x86_64-w64-mingw32/include] ==> [D:/c/mingw64/x86_64-w64-mingw32/include]
implicit include dirs: [D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include;D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include-fixed;D:/c/mingw64/x86_64-w64-mingw32/include]
-
kind: "message-v1"
backtrace:
- "D:/cmake/share/cmake-3.30/Modules/CMakeDetermineCompilerABI.cmake:218 (message)"
- "D:/cmake/share/cmake-3.30/Modules/CMakeTestCCompiler.cmake:26 (CMAKE_DETERMINE_COMPILER_ABI)"
- "CMakeLists.txt:2 (project)"
message: |
Parsed C implicit link information:
link line regex: [^( *|.*[/\\])(ld[0-9]*(\\.[a-z]+)?|CMAKE_LINK_STARTFILE-NOTFOUND|([^/\\]+-)?ld|collect2)[^/\\]*( |$)]
linker tool regex: [^[ ]*(->|")?[ ]*(([^"]*[/\\])?(ld[0-9]*(\\.[a-z]+)?))("|,| |$)]
ignore line: [Change Dir: 'D:/c_work/start/build/CMakeFiles/CMakeScratch/TryCompile-r96baa']
ignore line: []
ignore line: [Run Build Command(s): D:/cmake/bin/cmake.exe -E env VERBOSE=1 D:/c/mingw64/bin/mingw32-make.exe -f Makefile cmTC_c4c09/fast]
ignore line: [D:/c/mingw64/bin/mingw32-make.exe -f CMakeFiles\\cmTC_c4c09.dir\\build.make CMakeFiles/cmTC_c4c09.dir/build]
ignore line: [mingw32-make.exe[1]: Entering directory 'D:/c_work/start/build/CMakeFiles/CMakeScratch/TryCompile-r96baa']
ignore line: [Building C object CMakeFiles/cmTC_c4c09.dir/CMakeCCompilerABI.c.obj]
ignore line: [D:\\c\\mingw64\\bin\\gcc.exe -v -o CMakeFiles\\cmTC_c4c09.dir\\CMakeCCompilerABI.c.obj -c D:\\cmake\\share\\cmake-3.30\\Modules\\CMakeCCompilerABI.c]
ignore line: [Using built-in specs.]
ignore line: [COLLECT_GCC=D:\\c\\mingw64\\bin\\gcc.exe]
ignore line: [Target: x86_64-w64-mingw32]
ignore line: [Configured with: ../../../src/gcc-8.1.0/configure --host=x86_64-w64-mingw32 --build=x86_64-w64-mingw32 --target=x86_64-w64-mingw32 --prefix=/mingw64 --with-sysroot=/c/mingw810/x86_64-810-win32-seh-rt_v6-rev0/mingw64 --enable-shared --enable-static --disable-multilib --enable-languages=c,c++,fortran,lto --enable-libstdcxx-time=yes --enable-threads=win32 --enable-libgomp --enable-libatomic --enable-lto --enable-graphite --enable-checking=release --enable-fully-dynamic-string --enable-version-specific-runtime-libs --disable-libstdcxx-pch --disable-libstdcxx-debug --enable-bootstrap --disable-rpath --disable-win32-registry --disable-nls --disable-werror --disable-symvers --with-gnu-as --with-gnu-ld --with-arch=nocona --with-tune=core2 --with-libiconv --with-system-zlib --with-gmp=/c/mingw810/prerequisites/x86_64-w64-mingw32-static --with-mpfr=/c/mingw810/prerequisites/x86_64-w64-mingw32-static --with-mpc=/c/mingw810/prerequisites/x86_64-w64-mingw32-static --with-isl=/c/mingw810/prerequisites/x86_64-w64-mingw32-static --with-pkgversion='x86_64-win32-seh-rev0, Built by MinGW-W64 project' --with-bugurl=https://sourceforge.net/projects/mingw-w64 CFLAGS='-O2 -pipe -fno-ident -I/c/mingw810/x86_64-810-win32-seh-rt_v6-rev0/mingw64/opt/include -I/c/mingw810/prerequisites/x86_64-zlib-static/include -I/c/mingw810/prerequisites/x86_64-w64-mingw32-static/include' CXXFLAGS='-O2 -pipe -fno-ident -I/c/mingw810/x86_64-810-win32-seh-rt_v6-rev0/mingw64/opt/include -I/c/mingw810/prerequisites/x86_64-zlib-static/include -I/c/mingw810/prerequisites/x86_64-w64-mingw32-static/include' CPPFLAGS=' -I/c/mingw810/x86_64-810-win32-seh-rt_v6-rev0/mingw64/opt/include -I/c/mingw810/prerequisites/x86_64-zlib-static/include -I/c/mingw810/prerequisites/x86_64-w64-mingw32-static/include' LDFLAGS='-pipe -fno-ident -L/c/mingw810/x86_64-810-win32-seh-rt_v6-rev0/mingw64/opt/lib -L/c/mingw810/prerequisites/x86_64-zlib-static/lib -L/c/mingw810/prerequisites/x86_64-w64-mingw32-static/lib ']
ignore line: [Thread model: win32]
ignore line: [gcc version 8.1.0 (x86_64-win32-seh-rev0 Built by MinGW-W64 project) ]
ignore line: [COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles\\cmTC_c4c09.dir\\CMakeCCompilerABI.c.obj' '-c' '-mtune=core2' '-march=nocona']
ignore line: [ D:/c/mingw64/bin/../libexec/gcc/x86_64-w64-mingw32/8.1.0/cc1.exe -quiet -v -iprefix D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/ -U_REENTRANT D:\\cmake\\share\\cmake-3.30\\Modules\\CMakeCCompilerABI.c -quiet -dumpbase CMakeCCompilerABI.c -mtune=core2 -march=nocona -auxbase-strip CMakeFiles\\cmTC_c4c09.dir\\CMakeCCompilerABI.c.obj -version -o C:\\Users\\OMEN\\AppData\\Local\\Temp\\ccPiSQIT.s]
ignore line: [GNU C17 (x86_64-win32-seh-rev0 Built by MinGW-W64 project) version 8.1.0 (x86_64-w64-mingw32)]
ignore line: [ compiled by GNU C version 8.1.0 GMP version 6.1.2 MPFR version 4.0.1 MPC version 1.1.0 isl version isl-0.18-GMP]
ignore line: []
ignore line: [GGC heuristics: --param ggc-min-expand=100 --param ggc-min-heapsize=131072]
ignore line: [ignoring duplicate directory "D:/c/mingw64/lib/gcc/../../lib/gcc/x86_64-w64-mingw32/8.1.0/include"]
ignore line: [ignoring nonexistent directory "C:/mingw810/x86_64-810-win32-seh-rt_v6-rev0/mingw64C:/msys64/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../include"]
ignore line: [ignoring duplicate directory "D:/c/mingw64/lib/gcc/../../lib/gcc/x86_64-w64-mingw32/8.1.0/include-fixed"]
ignore line: [ignoring duplicate directory "D:/c/mingw64/lib/gcc/../../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../x86_64-w64-mingw32/include"]
ignore line: [ignoring nonexistent directory "C:/mingw810/x86_64-810-win32-seh-rt_v6-rev0/mingw64/mingw/include"]
ignore line: [#include "..." search starts here:]
ignore line: [#include <...> search starts here:]
ignore line: [ D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/include]
ignore line: [ D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/include-fixed]
ignore line: [ D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../x86_64-w64-mingw32/include]
ignore line: [End of search list.]
ignore line: [GNU C17 (x86_64-win32-seh-rev0 Built by MinGW-W64 project) version 8.1.0 (x86_64-w64-mingw32)]
ignore line: [ compiled by GNU C version 8.1.0 GMP version 6.1.2 MPFR version 4.0.1 MPC version 1.1.0 isl version isl-0.18-GMP]
ignore line: []
ignore line: [GGC heuristics: --param ggc-min-expand=100 --param ggc-min-heapsize=131072]
ignore line: [Compiler executable checksum: bb117049c51d03d971e874cfcb35cac9]
ignore line: [COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles\\cmTC_c4c09.dir\\CMakeCCompilerABI.c.obj' '-c' '-mtune=core2' '-march=nocona']
ignore line: [ D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../x86_64-w64-mingw32/bin/as.exe -v -o CMakeFiles\\cmTC_c4c09.dir\\CMakeCCompilerABI.c.obj C:\\Users\\OMEN\\AppData\\Local\\Temp\\ccPiSQIT.s]
ignore line: [GNU assembler version 2.30 (x86_64-w64-mingw32) using BFD version (GNU Binutils) 2.30]
ignore line: [COMPILER_PATH=D:/c/mingw64/bin/../libexec/gcc/x86_64-w64-mingw32/8.1.0/]
ignore line: [D:/c/mingw64/bin/../libexec/gcc/]
ignore line: [D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../x86_64-w64-mingw32/bin/]
ignore line: [LIBRARY_PATH=D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/]
ignore line: [D:/c/mingw64/bin/../lib/gcc/]
ignore line: [D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../x86_64-w64-mingw32/lib/../lib/]
ignore line: [D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../lib/]
ignore line: [D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../x86_64-w64-mingw32/lib/]
ignore line: [D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../]
ignore line: [COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles\\cmTC_c4c09.dir\\CMakeCCompilerABI.c.obj' '-c' '-mtune=core2' '-march=nocona']
ignore line: [Linking C executable cmTC_c4c09.exe]
ignore line: [D:\\cmake\\bin\\cmake.exe -E cmake_link_script CMakeFiles\\cmTC_c4c09.dir\\link.txt --verbose=1]
ignore line: [D:\\cmake\\bin\\cmake.exe -E rm -f CMakeFiles\\cmTC_c4c09.dir/objects.a]
ignore line: [D:\\c\\mingw64\\bin\\ar.exe qc CMakeFiles\\cmTC_c4c09.dir/objects.a @CMakeFiles\\cmTC_c4c09.dir\\objects1.rsp]
ignore line: [D:\\c\\mingw64\\bin\\gcc.exe -v -Wl -v -Wl --whole-archive CMakeFiles\\cmTC_c4c09.dir/objects.a -Wl --no-whole-archive -o cmTC_c4c09.exe -Wl --out-implib libcmTC_c4c09.dll.a -Wl --major-image-version 0 --minor-image-version 0]
ignore line: [Using built-in specs.]
ignore line: [COLLECT_GCC=D:\\c\\mingw64\\bin\\gcc.exe]
ignore line: [COLLECT_LTO_WRAPPER=D:/c/mingw64/bin/../libexec/gcc/x86_64-w64-mingw32/8.1.0/lto-wrapper.exe]
ignore line: [Target: x86_64-w64-mingw32]
ignore line: [Configured with: ../../../src/gcc-8.1.0/configure --host=x86_64-w64-mingw32 --build=x86_64-w64-mingw32 --target=x86_64-w64-mingw32 --prefix=/mingw64 --with-sysroot=/c/mingw810/x86_64-810-win32-seh-rt_v6-rev0/mingw64 --enable-shared --enable-static --disable-multilib --enable-languages=c,c++,fortran,lto --enable-libstdcxx-time=yes --enable-threads=win32 --enable-libgomp --enable-libatomic --enable-lto --enable-graphite --enable-checking=release --enable-fully-dynamic-string --enable-version-specific-runtime-libs --disable-libstdcxx-pch --disable-libstdcxx-debug --enable-bootstrap --disable-rpath --disable-win32-registry --disable-nls --disable-werror --disable-symvers --with-gnu-as --with-gnu-ld --with-arch=nocona --with-tune=core2 --with-libiconv --with-system-zlib --with-gmp=/c/mingw810/prerequisites/x86_64-w64-mingw32-static --with-mpfr=/c/mingw810/prerequisites/x86_64-w64-mingw32-static --with-mpc=/c/mingw810/prerequisites/x86_64-w64-mingw32-static --with-isl=/c/mingw810/prerequisites/x86_64-w64-mingw32-static --with-pkgversion='x86_64-win32-seh-rev0, Built by MinGW-W64 project' --with-bugurl=https://sourceforge.net/projects/mingw-w64 CFLAGS='-O2 -pipe -fno-ident -I/c/mingw810/x86_64-810-win32-seh-rt_v6-rev0/mingw64/opt/include -I/c/mingw810/prerequisites/x86_64-zlib-static/include -I/c/mingw810/prerequisites/x86_64-w64-mingw32-static/include' CXXFLAGS='-O2 -pipe -fno-ident -I/c/mingw810/x86_64-810-win32-seh-rt_v6-rev0/mingw64/opt/include -I/c/mingw810/prerequisites/x86_64-zlib-static/include -I/c/mingw810/prerequisites/x86_64-w64-mingw32-static/include' CPPFLAGS=' -I/c/mingw810/x86_64-810-win32-seh-rt_v6-rev0/mingw64/opt/include -I/c/mingw810/prerequisites/x86_64-zlib-static/include -I/c/mingw810/prerequisites/x86_64-w64-mingw32-static/include' LDFLAGS='-pipe -fno-ident -L/c/mingw810/x86_64-810-win32-seh-rt_v6-rev0/mingw64/opt/lib -L/c/mingw810/prerequisites/x86_64-zlib-static/lib -L/c/mingw810/prerequisites/x86_64-w64-mingw32-static/lib ']
ignore line: [Thread model: win32]
ignore line: [gcc version 8.1.0 (x86_64-win32-seh-rev0 Built by MinGW-W64 project) ]
ignore line: [COMPILER_PATH=D:/c/mingw64/bin/../libexec/gcc/x86_64-w64-mingw32/8.1.0/]
ignore line: [D:/c/mingw64/bin/../libexec/gcc/]
ignore line: [D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../x86_64-w64-mingw32/bin/]
ignore line: [LIBRARY_PATH=D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/]
ignore line: [D:/c/mingw64/bin/../lib/gcc/]
ignore line: [D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../x86_64-w64-mingw32/lib/../lib/]
ignore line: [D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../lib/]
ignore line: [D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../x86_64-w64-mingw32/lib/]
ignore line: [D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../]
ignore line: [COLLECT_GCC_OPTIONS='-v' '-o' 'cmTC_c4c09.exe' '-mtune=core2' '-march=nocona']
link line: [ D:/c/mingw64/bin/../libexec/gcc/x86_64-w64-mingw32/8.1.0/collect2.exe -plugin D:/c/mingw64/bin/../libexec/gcc/x86_64-w64-mingw32/8.1.0/liblto_plugin-0.dll -plugin-opt=D:/c/mingw64/bin/../libexec/gcc/x86_64-w64-mingw32/8.1.0/lto-wrapper.exe -plugin-opt=-fresolution=C:\\Users\\OMEN\\AppData\\Local\\Temp\\cc9S4M14.res -plugin-opt=-pass-through=-lmingw32 -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lgcc_eh -plugin-opt=-pass-through=-lmoldname -plugin-opt=-pass-through=-lmingwex -plugin-opt=-pass-through=-lmsvcrt -plugin-opt=-pass-through=-ladvapi32 -plugin-opt=-pass-through=-lshell32 -plugin-opt=-pass-through=-luser32 -plugin-opt=-pass-through=-lkernel32 -plugin-opt=-pass-through=-liconv -plugin-opt=-pass-through=-lmingw32 -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lgcc_eh -plugin-opt=-pass-through=-lmoldname -plugin-opt=-pass-through=-lmingwex -plugin-opt=-pass-through=-lmsvcrt --sysroot=C:/mingw810/x86_64-810-win32-seh-rt_v6-rev0/mingw64 -m i386pep -Bdynamic -o cmTC_c4c09.exe D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../x86_64-w64-mingw32/lib/../lib/crt2.o D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/crtbegin.o -LD:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0 -LD:/c/mingw64/bin/../lib/gcc -LD:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../x86_64-w64-mingw32/lib/../lib -LD:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../lib -LD:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../x86_64-w64-mingw32/lib -LD:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../.. -v --whole-archive CMakeFiles\\cmTC_c4c09.dir/objects.a --no-whole-archive --out-implib libcmTC_c4c09.dll.a --major-image-version 0 --minor-image-version 0 -lmingw32 -lgcc -lgcc_eh -lmoldname -lmingwex -lmsvcrt -ladvapi32 -lshell32 -luser32 -lkernel32 -liconv -lmingw32 -lgcc -lgcc_eh -lmoldname -lmingwex -lmsvcrt D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/crtend.o]
arg [D:/c/mingw64/bin/../libexec/gcc/x86_64-w64-mingw32/8.1.0/collect2.exe] ==> ignore
arg [-plugin] ==> ignore
arg [D:/c/mingw64/bin/../libexec/gcc/x86_64-w64-mingw32/8.1.0/liblto_plugin-0.dll] ==> ignore
arg [-plugin-opt=D:/c/mingw64/bin/../libexec/gcc/x86_64-w64-mingw32/8.1.0/lto-wrapper.exe] ==> ignore
arg [-plugin-opt=-fresolution=C:\\Users\\OMEN\\AppData\\Local\\Temp\\cc9S4M14.res] ==> ignore
arg [-plugin-opt=-pass-through=-lmingw32] ==> ignore
arg [-plugin-opt=-pass-through=-lgcc] ==> ignore
arg [-plugin-opt=-pass-through=-lgcc_eh] ==> ignore
arg [-plugin-opt=-pass-through=-lmoldname] ==> ignore
arg [-plugin-opt=-pass-through=-lmingwex] ==> ignore
arg [-plugin-opt=-pass-through=-lmsvcrt] ==> ignore
arg [-plugin-opt=-pass-through=-ladvapi32] ==> ignore
arg [-plugin-opt=-pass-through=-lshell32] ==> ignore
arg [-plugin-opt=-pass-through=-luser32] ==> ignore
arg [-plugin-opt=-pass-through=-lkernel32] ==> ignore
arg [-plugin-opt=-pass-through=-liconv] ==> ignore
arg [-plugin-opt=-pass-through=-lmingw32] ==> ignore
arg [-plugin-opt=-pass-through=-lgcc] ==> ignore
arg [-plugin-opt=-pass-through=-lgcc_eh] ==> ignore
arg [-plugin-opt=-pass-through=-lmoldname] ==> ignore
arg [-plugin-opt=-pass-through=-lmingwex] ==> ignore
arg [-plugin-opt=-pass-through=-lmsvcrt] ==> ignore
arg [--sysroot=C:/mingw810/x86_64-810-win32-seh-rt_v6-rev0/mingw64] ==> ignore
arg [-m] ==> ignore
arg [i386pep] ==> ignore
arg [-Bdynamic] ==> search dynamic
arg [-o] ==> ignore
arg [cmTC_c4c09.exe] ==> ignore
arg [D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../x86_64-w64-mingw32/lib/../lib/crt2.o] ==> obj [D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../x86_64-w64-mingw32/lib/../lib/crt2.o]
arg [D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/crtbegin.o] ==> obj [D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/crtbegin.o]
arg [-LD:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0] ==> dir [D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0]
arg [-LD:/c/mingw64/bin/../lib/gcc] ==> dir [D:/c/mingw64/bin/../lib/gcc]
arg [-LD:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../x86_64-w64-mingw32/lib/../lib] ==> dir [D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../x86_64-w64-mingw32/lib/../lib]
arg [-LD:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../lib] ==> dir [D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../lib]
arg [-LD:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../x86_64-w64-mingw32/lib] ==> dir [D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../x86_64-w64-mingw32/lib]
arg [-LD:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../..] ==> dir [D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../..]
arg [-v] ==> ignore
arg [--whole-archive] ==> ignore
arg [CMakeFiles\\cmTC_c4c09.dir/objects.a] ==> ignore
arg [--no-whole-archive] ==> ignore
arg [--out-implib] ==> ignore
arg [libcmTC_c4c09.dll.a] ==> ignore
arg [--major-image-version] ==> ignore
arg [0] ==> ignore
arg [--minor-image-version] ==> ignore
arg [0] ==> ignore
arg [-lmingw32] ==> lib [mingw32]
arg [-lgcc] ==> lib [gcc]
arg [-lgcc_eh] ==> lib [gcc_eh]
arg [-lmoldname] ==> lib [moldname]
arg [-lmingwex] ==> lib [mingwex]
arg [-lmsvcrt] ==> lib [msvcrt]
arg [-ladvapi32] ==> lib [advapi32]
arg [-lshell32] ==> lib [shell32]
arg [-luser32] ==> lib [user32]
arg [-lkernel32] ==> lib [kernel32]
arg [-liconv] ==> lib [iconv]
arg [-lmingw32] ==> lib [mingw32]
arg [-lgcc] ==> lib [gcc]
arg [-lgcc_eh] ==> lib [gcc_eh]
arg [-lmoldname] ==> lib [moldname]
arg [-lmingwex] ==> lib [mingwex]
arg [-lmsvcrt] ==> lib [msvcrt]
arg [D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/crtend.o] ==> obj [D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/crtend.o]
ignore line: [collect2 version 8.1.0]
ignore line: [D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../x86_64-w64-mingw32/bin/ld.exe -plugin D:/c/mingw64/bin/../libexec/gcc/x86_64-w64-mingw32/8.1.0/liblto_plugin-0.dll -plugin-opt=D:/c/mingw64/bin/../libexec/gcc/x86_64-w64-mingw32/8.1.0/lto-wrapper.exe -plugin-opt=-fresolution=C:\\Users\\OMEN\\AppData\\Local\\Temp\\cc9S4M14.res -plugin-opt=-pass-through=-lmingw32 -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lgcc_eh -plugin-opt=-pass-through=-lmoldname -plugin-opt=-pass-through=-lmingwex -plugin-opt=-pass-through=-lmsvcrt -plugin-opt=-pass-through=-ladvapi32 -plugin-opt=-pass-through=-lshell32 -plugin-opt=-pass-through=-luser32 -plugin-opt=-pass-through=-lkernel32 -plugin-opt=-pass-through=-liconv -plugin-opt=-pass-through=-lmingw32 -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lgcc_eh -plugin-opt=-pass-through=-lmoldname -plugin-opt=-pass-through=-lmingwex -plugin-opt=-pass-through=-lmsvcrt --sysroot=C:/mingw810/x86_64-810-win32-seh-rt_v6-rev0/mingw64 -m i386pep -Bdynamic -o cmTC_c4c09.exe D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../x86_64-w64-mingw32/lib/../lib/crt2.o D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/crtbegin.o -LD:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0 -LD:/c/mingw64/bin/../lib/gcc -LD:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../x86_64-w64-mingw32/lib/../lib -LD:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../lib -LD:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../x86_64-w64-mingw32/lib -LD:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../.. -v --whole-archive CMakeFiles\\cmTC_c4c09.dir/objects.a --no-whole-archive --out-implib libcmTC_c4c09.dll.a --major-image-version 0 --minor-image-version 0 -lmingw32 -lgcc -lgcc_eh -lmoldname -lmingwex -lmsvcrt -ladvapi32 -lshell32 -luser32 -lkernel32 -liconv -lmingw32 -lgcc -lgcc_eh -lmoldname -lmingwex -lmsvcrt D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/crtend.o]
linker tool for 'C': D:/c/mingw64/x86_64-w64-mingw32/bin/ld.exe
remove lib [gcc_eh]
remove lib [msvcrt]
remove lib [gcc_eh]
remove lib [msvcrt]
collapse obj [D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../x86_64-w64-mingw32/lib/../lib/crt2.o] ==> [D:/c/mingw64/x86_64-w64-mingw32/lib/crt2.o]
collapse obj [D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/crtbegin.o] ==> [D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/crtbegin.o]
collapse obj [D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/crtend.o] ==> [D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/crtend.o]
collapse library dir [D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0] ==> [D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0]
collapse library dir [D:/c/mingw64/bin/../lib/gcc] ==> [D:/c/mingw64/lib/gcc]
collapse library dir [D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../x86_64-w64-mingw32/lib/../lib] ==> [D:/c/mingw64/x86_64-w64-mingw32/lib]
collapse library dir [D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../lib] ==> [D:/c/mingw64/lib]
collapse library dir [D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../x86_64-w64-mingw32/lib] ==> [D:/c/mingw64/x86_64-w64-mingw32/lib]
collapse library dir [D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../..] ==> [D:/c/mingw64/lib]
implicit libs: [mingw32;gcc;moldname;mingwex;advapi32;shell32;user32;kernel32;iconv;mingw32;gcc;moldname;mingwex]
implicit objs: [D:/c/mingw64/x86_64-w64-mingw32/lib/crt2.o;D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/crtbegin.o;D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/crtend.o]
implicit dirs: [D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0;D:/c/mingw64/lib/gcc;D:/c/mingw64/x86_64-w64-mingw32/lib;D:/c/mingw64/lib]
implicit fwks: []
-
kind: "message-v1"
backtrace:
- "D:/cmake/share/cmake-3.30/Modules/Internal/CMakeDetermineLinkerId.cmake:40 (message)"
- "D:/cmake/share/cmake-3.30/Modules/CMakeDetermineCompilerABI.cmake:255 (cmake_determine_linker_id)"
- "D:/cmake/share/cmake-3.30/Modules/CMakeTestCCompiler.cmake:26 (CMAKE_DETERMINE_COMPILER_ABI)"
- "CMakeLists.txt:2 (project)"
message: |
Running the C compiler's linker: "D:/c/mingw64/x86_64-w64-mingw32/bin/ld.exe" "-v"
GNU ld (GNU Binutils) 2.30
-
kind: "try_compile-v1"
backtrace:
- "D:/cmake/share/cmake-3.30/Modules/CMakeDetermineCompilerABI.cmake:74 (try_compile)"
- "D:/cmake/share/cmake-3.30/Modules/CMakeTestCXXCompiler.cmake:26 (CMAKE_DETERMINE_COMPILER_ABI)"
- "CMakeLists.txt:2 (project)"
checks:
- "Detecting CXX compiler ABI info"
directories:
source: "D:/c_work/start/build/CMakeFiles/CMakeScratch/TryCompile-ejot5b"
binary: "D:/c_work/start/build/CMakeFiles/CMakeScratch/TryCompile-ejot5b"
cmakeVariables:
CMAKE_CXX_FLAGS: ""
CMAKE_CXX_FLAGS_DEBUG: "-g"
CMAKE_CXX_SCAN_FOR_MODULES: "OFF"
CMAKE_EXE_LINKER_FLAGS: ""
buildResult:
variable: "CMAKE_CXX_ABI_COMPILED"
cached: true
stdout: |
Change Dir: 'D:/c_work/start/build/CMakeFiles/CMakeScratch/TryCompile-ejot5b'
Run Build Command(s): D:/cmake/bin/cmake.exe -E env VERBOSE=1 D:/c/mingw64/bin/mingw32-make.exe -f Makefile cmTC_5c3f4/fast
D:/c/mingw64/bin/mingw32-make.exe -f CMakeFiles\\cmTC_5c3f4.dir\\build.make CMakeFiles/cmTC_5c3f4.dir/build
mingw32-make.exe[1]: Entering directory 'D:/c_work/start/build/CMakeFiles/CMakeScratch/TryCompile-ejot5b'
Building CXX object CMakeFiles/cmTC_5c3f4.dir/CMakeCXXCompilerABI.cpp.obj
D:\\c\\mingw64\\bin\\g++.exe -v -o CMakeFiles\\cmTC_5c3f4.dir\\CMakeCXXCompilerABI.cpp.obj -c D:\\cmake\\share\\cmake-3.30\\Modules\\CMakeCXXCompilerABI.cpp
Using built-in specs.
COLLECT_GCC=D:\\c\\mingw64\\bin\\g++.exe
Target: x86_64-w64-mingw32
Configured with: ../../../src/gcc-8.1.0/configure --host=x86_64-w64-mingw32 --build=x86_64-w64-mingw32 --target=x86_64-w64-mingw32 --prefix=/mingw64 --with-sysroot=/c/mingw810/x86_64-810-win32-seh-rt_v6-rev0/mingw64 --enable-shared --enable-static --disable-multilib --enable-languages=c,c++,fortran,lto --enable-libstdcxx-time=yes --enable-threads=win32 --enable-libgomp --enable-libatomic --enable-lto --enable-graphite --enable-checking=release --enable-fully-dynamic-string --enable-version-specific-runtime-libs --disable-libstdcxx-pch --disable-libstdcxx-debug --enable-bootstrap --disable-rpath --disable-win32-registry --disable-nls --disable-werror --disable-symvers --with-gnu-as --with-gnu-ld --with-arch=nocona --with-tune=core2 --with-libiconv --with-system-zlib --with-gmp=/c/mingw810/prerequisites/x86_64-w64-mingw32-static --with-mpfr=/c/mingw810/prerequisites/x86_64-w64-mingw32-static --with-mpc=/c/mingw810/prerequisites/x86_64-w64-mingw32-static --with-isl=/c/mingw810/prerequisites/x86_64-w64-mingw32-static --with-pkgversion='x86_64-win32-seh-rev0, Built by MinGW-W64 project' --with-bugurl=https://sourceforge.net/projects/mingw-w64 CFLAGS='-O2 -pipe -fno-ident -I/c/mingw810/x86_64-810-win32-seh-rt_v6-rev0/mingw64/opt/include -I/c/mingw810/prerequisites/x86_64-zlib-static/include -I/c/mingw810/prerequisites/x86_64-w64-mingw32-static/include' CXXFLAGS='-O2 -pipe -fno-ident -I/c/mingw810/x86_64-810-win32-seh-rt_v6-rev0/mingw64/opt/include -I/c/mingw810/prerequisites/x86_64-zlib-static/include -I/c/mingw810/prerequisites/x86_64-w64-mingw32-static/include' CPPFLAGS=' -I/c/mingw810/x86_64-810-win32-seh-rt_v6-rev0/mingw64/opt/include -I/c/mingw810/prerequisites/x86_64-zlib-static/include -I/c/mingw810/prerequisites/x86_64-w64-mingw32-static/include' LDFLAGS='-pipe -fno-ident -L/c/mingw810/x86_64-810-win32-seh-rt_v6-rev0/mingw64/opt/lib -L/c/mingw810/prerequisites/x86_64-zlib-static/lib -L/c/mingw810/prerequisites/x86_64-w64-mingw32-static/lib '
Thread model: win32
gcc version 8.1.0 (x86_64-win32-seh-rev0, Built by MinGW-W64 project)
COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles\\cmTC_5c3f4.dir\\CMakeCXXCompilerABI.cpp.obj' '-c' '-shared-libgcc' '-mtune=core2' '-march=nocona'
D:/c/mingw64/bin/../libexec/gcc/x86_64-w64-mingw32/8.1.0/cc1plus.exe -quiet -v -iprefix D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/ -U_REENTRANT D:\\cmake\\share\\cmake-3.30\\Modules\\CMakeCXXCompilerABI.cpp -quiet -dumpbase CMakeCXXCompilerABI.cpp -mtune=core2 -march=nocona -auxbase-strip CMakeFiles\\cmTC_5c3f4.dir\\CMakeCXXCompilerABI.cpp.obj -version -o C:\\Users\\OMEN\\AppData\\Local\\Temp\\cc4jQ2pe.s
GNU C++14 (x86_64-win32-seh-rev0, Built by MinGW-W64 project) version 8.1.0 (x86_64-w64-mingw32)
compiled by GNU C version 8.1.0, GMP version 6.1.2, MPFR version 4.0.1, MPC version 1.1.0, isl version isl-0.18-GMP
GGC heuristics: --param ggc-min-expand=100 --param ggc-min-heapsize=131072
ignoring duplicate directory "D:/c/mingw64/lib/gcc/../../lib/gcc/x86_64-w64-mingw32/8.1.0/include/c++"
ignoring duplicate directory "D:/c/mingw64/lib/gcc/../../lib/gcc/x86_64-w64-mingw32/8.1.0/include/c++/x86_64-w64-mingw32"
ignoring duplicate directory "D:/c/mingw64/lib/gcc/../../lib/gcc/x86_64-w64-mingw32/8.1.0/include/c++/backward"
ignoring duplicate directory "D:/c/mingw64/lib/gcc/../../lib/gcc/x86_64-w64-mingw32/8.1.0/include"
ignoring nonexistent directory "C:/mingw810/x86_64-810-win32-seh-rt_v6-rev0/mingw64C:/msys64/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../include"
ignoring duplicate directory "D:/c/mingw64/lib/gcc/../../lib/gcc/x86_64-w64-mingw32/8.1.0/include-fixed"
ignoring duplicate directory "D:/c/mingw64/lib/gcc/../../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../x86_64-w64-mingw32/include"
ignoring nonexistent directory "C:/mingw810/x86_64-810-win32-seh-rt_v6-rev0/mingw64/mingw/include"
#include "..." search starts here:
#include <...> search starts here:
D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/include/c++
D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/include/c++/x86_64-w64-mingw32
D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/include/c++/backward
D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/include
D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/include-fixed
D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../x86_64-w64-mingw32/include
End of search list.
GNU C++14 (x86_64-win32-seh-rev0, Built by MinGW-W64 project) version 8.1.0 (x86_64-w64-mingw32)
compiled by GNU C version 8.1.0, GMP version 6.1.2, MPFR version 4.0.1, MPC version 1.1.0, isl version isl-0.18-GMP
GGC heuristics: --param ggc-min-expand=100 --param ggc-min-heapsize=131072
Compiler executable checksum: 768151575aea5e2fb63ae2dd7f500530
COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles\\cmTC_5c3f4.dir\\CMakeCXXCompilerABI.cpp.obj' '-c' '-shared-libgcc' '-mtune=core2' '-march=nocona'
D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../x86_64-w64-mingw32/bin/as.exe -v -o CMakeFiles\\cmTC_5c3f4.dir\\CMakeCXXCompilerABI.cpp.obj C:\\Users\\OMEN\\AppData\\Local\\Temp\\cc4jQ2pe.s
GNU assembler version 2.30 (x86_64-w64-mingw32) using BFD version (GNU Binutils) 2.30
COMPILER_PATH=D:/c/mingw64/bin/../libexec/gcc/x86_64-w64-mingw32/8.1.0/;D:/c/mingw64/bin/../libexec/gcc/;D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../x86_64-w64-mingw32/bin/
LIBRARY_PATH=D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/;D:/c/mingw64/bin/../lib/gcc/;D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../x86_64-w64-mingw32/lib/../lib/;D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../lib/;D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../x86_64-w64-mingw32/lib/;D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../
COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles\\cmTC_5c3f4.dir\\CMakeCXXCompilerABI.cpp.obj' '-c' '-shared-libgcc' '-mtune=core2' '-march=nocona'
Linking CXX executable cmTC_5c3f4.exe
D:\\cmake\\bin\\cmake.exe -E cmake_link_script CMakeFiles\\cmTC_5c3f4.dir\\link.txt --verbose=1
D:\\cmake\\bin\\cmake.exe -E rm -f CMakeFiles\\cmTC_5c3f4.dir/objects.a
D:\\c\\mingw64\\bin\\ar.exe qc CMakeFiles\\cmTC_5c3f4.dir/objects.a @CMakeFiles\\cmTC_5c3f4.dir\\objects1.rsp
D:\\c\\mingw64\\bin\\g++.exe -v -Wl,-v -Wl,--whole-archive CMakeFiles\\cmTC_5c3f4.dir/objects.a -Wl,--no-whole-archive -o cmTC_5c3f4.exe -Wl,--out-implib,libcmTC_5c3f4.dll.a -Wl,--major-image-version,0,--minor-image-version,0
Using built-in specs.
COLLECT_GCC=D:\\c\\mingw64\\bin\\g++.exe
COLLECT_LTO_WRAPPER=D:/c/mingw64/bin/../libexec/gcc/x86_64-w64-mingw32/8.1.0/lto-wrapper.exe
Target: x86_64-w64-mingw32
Configured with: ../../../src/gcc-8.1.0/configure --host=x86_64-w64-mingw32 --build=x86_64-w64-mingw32 --target=x86_64-w64-mingw32 --prefix=/mingw64 --with-sysroot=/c/mingw810/x86_64-810-win32-seh-rt_v6-rev0/mingw64 --enable-shared --enable-static --disable-multilib --enable-languages=c,c++,fortran,lto --enable-libstdcxx-time=yes --enable-threads=win32 --enable-libgomp --enable-libatomic --enable-lto --enable-graphite --enable-checking=release --enable-fully-dynamic-string --enable-version-specific-runtime-libs --disable-libstdcxx-pch --disable-libstdcxx-debug --enable-bootstrap --disable-rpath --disable-win32-registry --disable-nls --disable-werror --disable-symvers --with-gnu-as --with-gnu-ld --with-arch=nocona --with-tune=core2 --with-libiconv --with-system-zlib --with-gmp=/c/mingw810/prerequisites/x86_64-w64-mingw32-static --with-mpfr=/c/mingw810/prerequisites/x86_64-w64-mingw32-static --with-mpc=/c/mingw810/prerequisites/x86_64-w64-mingw32-static --with-isl=/c/mingw810/prerequisites/x86_64-w64-mingw32-static --with-pkgversion='x86_64-win32-seh-rev0, Built by MinGW-W64 project' --with-bugurl=https://sourceforge.net/projects/mingw-w64 CFLAGS='-O2 -pipe -fno-ident -I/c/mingw810/x86_64-810-win32-seh-rt_v6-rev0/mingw64/opt/include -I/c/mingw810/prerequisites/x86_64-zlib-static/include -I/c/mingw810/prerequisites/x86_64-w64-mingw32-static/include' CXXFLAGS='-O2 -pipe -fno-ident -I/c/mingw810/x86_64-810-win32-seh-rt_v6-rev0/mingw64/opt/include -I/c/mingw810/prerequisites/x86_64-zlib-static/include -I/c/mingw810/prerequisites/x86_64-w64-mingw32-static/include' CPPFLAGS=' -I/c/mingw810/x86_64-810-win32-seh-rt_v6-rev0/mingw64/opt/include -I/c/mingw810/prerequisites/x86_64-zlib-static/include -I/c/mingw810/prerequisites/x86_64-w64-mingw32-static/include' LDFLAGS='-pipe -fno-ident -L/c/mingw810/x86_64-810-win32-seh-rt_v6-rev0/mingw64/opt/lib -L/c/mingw810/prerequisites/x86_64-zlib-static/lib -L/c/mingw810/prerequisites/x86_64-w64-mingw32-static/lib '
Thread model: win32
gcc version 8.1.0 (x86_64-win32-seh-rev0, Built by MinGW-W64 project)
COMPILER_PATH=D:/c/mingw64/bin/../libexec/gcc/x86_64-w64-mingw32/8.1.0/;D:/c/mingw64/bin/../libexec/gcc/;D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../x86_64-w64-mingw32/bin/
LIBRARY_PATH=D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/;D:/c/mingw64/bin/../lib/gcc/;D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../x86_64-w64-mingw32/lib/../lib/;D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../lib/;D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../x86_64-w64-mingw32/lib/;D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../
COLLECT_GCC_OPTIONS='-v' '-o' 'cmTC_5c3f4.exe' '-shared-libgcc' '-mtune=core2' '-march=nocona'
D:/c/mingw64/bin/../libexec/gcc/x86_64-w64-mingw32/8.1.0/collect2.exe -plugin D:/c/mingw64/bin/../libexec/gcc/x86_64-w64-mingw32/8.1.0/liblto_plugin-0.dll -plugin-opt=D:/c/mingw64/bin/../libexec/gcc/x86_64-w64-mingw32/8.1.0/lto-wrapper.exe -plugin-opt=-fresolution=C:\\Users\\OMEN\\AppData\\Local\\Temp\\cc2y9LGp.res -plugin-opt=-pass-through=-lmingw32 -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lmoldname -plugin-opt=-pass-through=-lmingwex -plugin-opt=-pass-through=-lmsvcrt -plugin-opt=-pass-through=-ladvapi32 -plugin-opt=-pass-through=-lshell32 -plugin-opt=-pass-through=-luser32 -plugin-opt=-pass-through=-lkernel32 -plugin-opt=-pass-through=-liconv -plugin-opt=-pass-through=-lmingw32 -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lmoldname -plugin-opt=-pass-through=-lmingwex -plugin-opt=-pass-through=-lmsvcrt --sysroot=C:/mingw810/x86_64-810-win32-seh-rt_v6-rev0/mingw64 -m i386pep -Bdynamic -o cmTC_5c3f4.exe D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../x86_64-w64-mingw32/lib/../lib/crt2.o D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/crtbegin.o -LD:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0 -LD:/c/mingw64/bin/../lib/gcc -LD:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../x86_64-w64-mingw32/lib/../lib -LD:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../lib -LD:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../x86_64-w64-mingw32/lib -LD:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../.. -v --whole-archive CMakeFiles\\cmTC_5c3f4.dir/objects.a --no-whole-archive --out-implib libcmTC_5c3f4.dll.a --major-image-version 0 --minor-image-version 0 -lstdc++ -lmingw32 -lgcc_s -lgcc -lmoldname -lmingwex -lmsvcrt -ladvapi32 -lshell32 -luser32 -lkernel32 -liconv -lmingw32 -lgcc_s -lgcc -lmoldname -lmingwex -lmsvcrt D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/crtend.o
collect2 version 8.1.0
D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../x86_64-w64-mingw32/bin/ld.exe -plugin D:/c/mingw64/bin/../libexec/gcc/x86_64-w64-mingw32/8.1.0/liblto_plugin-0.dll -plugin-opt=D:/c/mingw64/bin/../libexec/gcc/x86_64-w64-mingw32/8.1.0/lto-wrapper.exe -plugin-opt=-fresolution=C:\\Users\\OMEN\\AppData\\Local\\Temp\\cc2y9LGp.res -plugin-opt=-pass-through=-lmingw32 -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lmoldname -plugin-opt=-pass-through=-lmingwex -plugin-opt=-pass-through=-lmsvcrt -plugin-opt=-pass-through=-ladvapi32 -plugin-opt=-pass-through=-lshell32 -plugin-opt=-pass-through=-luser32 -plugin-opt=-pass-through=-lkernel32 -plugin-opt=-pass-through=-liconv -plugin-opt=-pass-through=-lmingw32 -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lmoldname -plugin-opt=-pass-through=-lmingwex -plugin-opt=-pass-through=-lmsvcrt --sysroot=C:/mingw810/x86_64-810-win32-seh-rt_v6-rev0/mingw64 -m i386pep -Bdynamic -o cmTC_5c3f4.exe D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../x86_64-w64-mingw32/lib/../lib/crt2.o D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/crtbegin.o -LD:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0 -LD:/c/mingw64/bin/../lib/gcc -LD:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../x86_64-w64-mingw32/lib/../lib -LD:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../lib -LD:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../x86_64-w64-mingw32/lib -LD:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../.. -v --whole-archive CMakeFiles\\cmTC_5c3f4.dir/objects.a --no-whole-archive --out-implib libcmTC_5c3f4.dll.a --major-image-version 0 --minor-image-version 0 -lstdc++ -lmingw32 -lgcc_s -lgcc -lmoldname -lmingwex -lmsvcrt -ladvapi32 -lshell32 -luser32 -lkernel32 -liconv -lmingw32 -lgcc_s -lgcc -lmoldname -lmingwex -lmsvcrt D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/crtend.o
GNU ld (GNU Binutils) 2.30
COLLECT_GCC_OPTIONS='-v' '-o' 'cmTC_5c3f4.exe' '-shared-libgcc' '-mtune=core2' '-march=nocona'
mingw32-make.exe[1]: Leaving directory 'D:/c_work/start/build/CMakeFiles/CMakeScratch/TryCompile-ejot5b'
exitCode: 0
-
kind: "message-v1"
backtrace:
- "D:/cmake/share/cmake-3.30/Modules/CMakeDetermineCompilerABI.cmake:182 (message)"
- "D:/cmake/share/cmake-3.30/Modules/CMakeTestCXXCompiler.cmake:26 (CMAKE_DETERMINE_COMPILER_ABI)"
- "CMakeLists.txt:2 (project)"
message: |
Parsed CXX implicit include dir info: rv=done
found start of include info
found start of implicit include info
add: [D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/include/c++]
add: [D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/include/c++/x86_64-w64-mingw32]
add: [D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/include/c++/backward]
add: [D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/include]
add: [D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/include-fixed]
add: [D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../x86_64-w64-mingw32/include]
end of search list found
collapse include dir [D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/include/c++] ==> [D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/c++]
collapse include dir [D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/include/c++/x86_64-w64-mingw32] ==> [D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/c++/x86_64-w64-mingw32]
collapse include dir [D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/include/c++/backward] ==> [D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/c++/backward]
collapse include dir [D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/include] ==> [D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include]
collapse include dir [D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/include-fixed] ==> [D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include-fixed]
collapse include dir [D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../x86_64-w64-mingw32/include] ==> [D:/c/mingw64/x86_64-w64-mingw32/include]
implicit include dirs: [D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/c++;D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/c++/x86_64-w64-mingw32;D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/c++/backward;D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include;D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include-fixed;D:/c/mingw64/x86_64-w64-mingw32/include]
-
kind: "message-v1"
backtrace:
- "D:/cmake/share/cmake-3.30/Modules/CMakeDetermineCompilerABI.cmake:218 (message)"
- "D:/cmake/share/cmake-3.30/Modules/CMakeTestCXXCompiler.cmake:26 (CMAKE_DETERMINE_COMPILER_ABI)"
- "CMakeLists.txt:2 (project)"
message: |
Parsed CXX implicit link information:
link line regex: [^( *|.*[/\\])(ld[0-9]*(\\.[a-z]+)?|CMAKE_LINK_STARTFILE-NOTFOUND|([^/\\]+-)?ld|collect2)[^/\\]*( |$)]
linker tool regex: [^[ ]*(->|")?[ ]*(([^"]*[/\\])?(ld[0-9]*(\\.[a-z]+)?))("|,| |$)]
ignore line: [Change Dir: 'D:/c_work/start/build/CMakeFiles/CMakeScratch/TryCompile-ejot5b']
ignore line: []
ignore line: [Run Build Command(s): D:/cmake/bin/cmake.exe -E env VERBOSE=1 D:/c/mingw64/bin/mingw32-make.exe -f Makefile cmTC_5c3f4/fast]
ignore line: [D:/c/mingw64/bin/mingw32-make.exe -f CMakeFiles\\cmTC_5c3f4.dir\\build.make CMakeFiles/cmTC_5c3f4.dir/build]
ignore line: [mingw32-make.exe[1]: Entering directory 'D:/c_work/start/build/CMakeFiles/CMakeScratch/TryCompile-ejot5b']
ignore line: [Building CXX object CMakeFiles/cmTC_5c3f4.dir/CMakeCXXCompilerABI.cpp.obj]
ignore line: [D:\\c\\mingw64\\bin\\g++.exe -v -o CMakeFiles\\cmTC_5c3f4.dir\\CMakeCXXCompilerABI.cpp.obj -c D:\\cmake\\share\\cmake-3.30\\Modules\\CMakeCXXCompilerABI.cpp]
ignore line: [Using built-in specs.]
ignore line: [COLLECT_GCC=D:\\c\\mingw64\\bin\\g++.exe]
ignore line: [Target: x86_64-w64-mingw32]
ignore line: [Configured with: ../../../src/gcc-8.1.0/configure --host=x86_64-w64-mingw32 --build=x86_64-w64-mingw32 --target=x86_64-w64-mingw32 --prefix=/mingw64 --with-sysroot=/c/mingw810/x86_64-810-win32-seh-rt_v6-rev0/mingw64 --enable-shared --enable-static --disable-multilib --enable-languages=c,c++,fortran,lto --enable-libstdcxx-time=yes --enable-threads=win32 --enable-libgomp --enable-libatomic --enable-lto --enable-graphite --enable-checking=release --enable-fully-dynamic-string --enable-version-specific-runtime-libs --disable-libstdcxx-pch --disable-libstdcxx-debug --enable-bootstrap --disable-rpath --disable-win32-registry --disable-nls --disable-werror --disable-symvers --with-gnu-as --with-gnu-ld --with-arch=nocona --with-tune=core2 --with-libiconv --with-system-zlib --with-gmp=/c/mingw810/prerequisites/x86_64-w64-mingw32-static --with-mpfr=/c/mingw810/prerequisites/x86_64-w64-mingw32-static --with-mpc=/c/mingw810/prerequisites/x86_64-w64-mingw32-static --with-isl=/c/mingw810/prerequisites/x86_64-w64-mingw32-static --with-pkgversion='x86_64-win32-seh-rev0, Built by MinGW-W64 project' --with-bugurl=https://sourceforge.net/projects/mingw-w64 CFLAGS='-O2 -pipe -fno-ident -I/c/mingw810/x86_64-810-win32-seh-rt_v6-rev0/mingw64/opt/include -I/c/mingw810/prerequisites/x86_64-zlib-static/include -I/c/mingw810/prerequisites/x86_64-w64-mingw32-static/include' CXXFLAGS='-O2 -pipe -fno-ident -I/c/mingw810/x86_64-810-win32-seh-rt_v6-rev0/mingw64/opt/include -I/c/mingw810/prerequisites/x86_64-zlib-static/include -I/c/mingw810/prerequisites/x86_64-w64-mingw32-static/include' CPPFLAGS=' -I/c/mingw810/x86_64-810-win32-seh-rt_v6-rev0/mingw64/opt/include -I/c/mingw810/prerequisites/x86_64-zlib-static/include -I/c/mingw810/prerequisites/x86_64-w64-mingw32-static/include' LDFLAGS='-pipe -fno-ident -L/c/mingw810/x86_64-810-win32-seh-rt_v6-rev0/mingw64/opt/lib -L/c/mingw810/prerequisites/x86_64-zlib-static/lib -L/c/mingw810/prerequisites/x86_64-w64-mingw32-static/lib ']
ignore line: [Thread model: win32]
ignore line: [gcc version 8.1.0 (x86_64-win32-seh-rev0 Built by MinGW-W64 project) ]
ignore line: [COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles\\cmTC_5c3f4.dir\\CMakeCXXCompilerABI.cpp.obj' '-c' '-shared-libgcc' '-mtune=core2' '-march=nocona']
ignore line: [ D:/c/mingw64/bin/../libexec/gcc/x86_64-w64-mingw32/8.1.0/cc1plus.exe -quiet -v -iprefix D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/ -U_REENTRANT D:\\cmake\\share\\cmake-3.30\\Modules\\CMakeCXXCompilerABI.cpp -quiet -dumpbase CMakeCXXCompilerABI.cpp -mtune=core2 -march=nocona -auxbase-strip CMakeFiles\\cmTC_5c3f4.dir\\CMakeCXXCompilerABI.cpp.obj -version -o C:\\Users\\OMEN\\AppData\\Local\\Temp\\cc4jQ2pe.s]
ignore line: [GNU C++14 (x86_64-win32-seh-rev0 Built by MinGW-W64 project) version 8.1.0 (x86_64-w64-mingw32)]
ignore line: [ compiled by GNU C version 8.1.0 GMP version 6.1.2 MPFR version 4.0.1 MPC version 1.1.0 isl version isl-0.18-GMP]
ignore line: []
ignore line: [GGC heuristics: --param ggc-min-expand=100 --param ggc-min-heapsize=131072]
ignore line: [ignoring duplicate directory "D:/c/mingw64/lib/gcc/../../lib/gcc/x86_64-w64-mingw32/8.1.0/include/c++"]
ignore line: [ignoring duplicate directory "D:/c/mingw64/lib/gcc/../../lib/gcc/x86_64-w64-mingw32/8.1.0/include/c++/x86_64-w64-mingw32"]
ignore line: [ignoring duplicate directory "D:/c/mingw64/lib/gcc/../../lib/gcc/x86_64-w64-mingw32/8.1.0/include/c++/backward"]
ignore line: [ignoring duplicate directory "D:/c/mingw64/lib/gcc/../../lib/gcc/x86_64-w64-mingw32/8.1.0/include"]
ignore line: [ignoring nonexistent directory "C:/mingw810/x86_64-810-win32-seh-rt_v6-rev0/mingw64C:/msys64/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../include"]
ignore line: [ignoring duplicate directory "D:/c/mingw64/lib/gcc/../../lib/gcc/x86_64-w64-mingw32/8.1.0/include-fixed"]
ignore line: [ignoring duplicate directory "D:/c/mingw64/lib/gcc/../../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../x86_64-w64-mingw32/include"]
ignore line: [ignoring nonexistent directory "C:/mingw810/x86_64-810-win32-seh-rt_v6-rev0/mingw64/mingw/include"]
ignore line: [#include "..." search starts here:]
ignore line: [#include <...> search starts here:]
ignore line: [ D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/include/c++]
ignore line: [ D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/include/c++/x86_64-w64-mingw32]
ignore line: [ D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/include/c++/backward]
ignore line: [ D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/include]
ignore line: [ D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/include-fixed]
ignore line: [ D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../x86_64-w64-mingw32/include]
ignore line: [End of search list.]
ignore line: [GNU C++14 (x86_64-win32-seh-rev0 Built by MinGW-W64 project) version 8.1.0 (x86_64-w64-mingw32)]
ignore line: [ compiled by GNU C version 8.1.0 GMP version 6.1.2 MPFR version 4.0.1 MPC version 1.1.0 isl version isl-0.18-GMP]
ignore line: []
ignore line: [GGC heuristics: --param ggc-min-expand=100 --param ggc-min-heapsize=131072]
ignore line: [Compiler executable checksum: 768151575aea5e2fb63ae2dd7f500530]
ignore line: [COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles\\cmTC_5c3f4.dir\\CMakeCXXCompilerABI.cpp.obj' '-c' '-shared-libgcc' '-mtune=core2' '-march=nocona']
ignore line: [ D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../x86_64-w64-mingw32/bin/as.exe -v -o CMakeFiles\\cmTC_5c3f4.dir\\CMakeCXXCompilerABI.cpp.obj C:\\Users\\OMEN\\AppData\\Local\\Temp\\cc4jQ2pe.s]
ignore line: [GNU assembler version 2.30 (x86_64-w64-mingw32) using BFD version (GNU Binutils) 2.30]
ignore line: [COMPILER_PATH=D:/c/mingw64/bin/../libexec/gcc/x86_64-w64-mingw32/8.1.0/]
ignore line: [D:/c/mingw64/bin/../libexec/gcc/]
ignore line: [D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../x86_64-w64-mingw32/bin/]
ignore line: [LIBRARY_PATH=D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/]
ignore line: [D:/c/mingw64/bin/../lib/gcc/]
ignore line: [D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../x86_64-w64-mingw32/lib/../lib/]
ignore line: [D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../lib/]
ignore line: [D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../x86_64-w64-mingw32/lib/]
ignore line: [D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../]
ignore line: [COLLECT_GCC_OPTIONS='-v' '-o' 'CMakeFiles\\cmTC_5c3f4.dir\\CMakeCXXCompilerABI.cpp.obj' '-c' '-shared-libgcc' '-mtune=core2' '-march=nocona']
ignore line: [Linking CXX executable cmTC_5c3f4.exe]
ignore line: [D:\\cmake\\bin\\cmake.exe -E cmake_link_script CMakeFiles\\cmTC_5c3f4.dir\\link.txt --verbose=1]
ignore line: [D:\\cmake\\bin\\cmake.exe -E rm -f CMakeFiles\\cmTC_5c3f4.dir/objects.a]
ignore line: [D:\\c\\mingw64\\bin\\ar.exe qc CMakeFiles\\cmTC_5c3f4.dir/objects.a @CMakeFiles\\cmTC_5c3f4.dir\\objects1.rsp]
ignore line: [D:\\c\\mingw64\\bin\\g++.exe -v -Wl -v -Wl --whole-archive CMakeFiles\\cmTC_5c3f4.dir/objects.a -Wl --no-whole-archive -o cmTC_5c3f4.exe -Wl --out-implib libcmTC_5c3f4.dll.a -Wl --major-image-version 0 --minor-image-version 0]
ignore line: [Using built-in specs.]
ignore line: [COLLECT_GCC=D:\\c\\mingw64\\bin\\g++.exe]
ignore line: [COLLECT_LTO_WRAPPER=D:/c/mingw64/bin/../libexec/gcc/x86_64-w64-mingw32/8.1.0/lto-wrapper.exe]
ignore line: [Target: x86_64-w64-mingw32]
ignore line: [Configured with: ../../../src/gcc-8.1.0/configure --host=x86_64-w64-mingw32 --build=x86_64-w64-mingw32 --target=x86_64-w64-mingw32 --prefix=/mingw64 --with-sysroot=/c/mingw810/x86_64-810-win32-seh-rt_v6-rev0/mingw64 --enable-shared --enable-static --disable-multilib --enable-languages=c,c++,fortran,lto --enable-libstdcxx-time=yes --enable-threads=win32 --enable-libgomp --enable-libatomic --enable-lto --enable-graphite --enable-checking=release --enable-fully-dynamic-string --enable-version-specific-runtime-libs --disable-libstdcxx-pch --disable-libstdcxx-debug --enable-bootstrap --disable-rpath --disable-win32-registry --disable-nls --disable-werror --disable-symvers --with-gnu-as --with-gnu-ld --with-arch=nocona --with-tune=core2 --with-libiconv --with-system-zlib --with-gmp=/c/mingw810/prerequisites/x86_64-w64-mingw32-static --with-mpfr=/c/mingw810/prerequisites/x86_64-w64-mingw32-static --with-mpc=/c/mingw810/prerequisites/x86_64-w64-mingw32-static --with-isl=/c/mingw810/prerequisites/x86_64-w64-mingw32-static --with-pkgversion='x86_64-win32-seh-rev0, Built by MinGW-W64 project' --with-bugurl=https://sourceforge.net/projects/mingw-w64 CFLAGS='-O2 -pipe -fno-ident -I/c/mingw810/x86_64-810-win32-seh-rt_v6-rev0/mingw64/opt/include -I/c/mingw810/prerequisites/x86_64-zlib-static/include -I/c/mingw810/prerequisites/x86_64-w64-mingw32-static/include' CXXFLAGS='-O2 -pipe -fno-ident -I/c/mingw810/x86_64-810-win32-seh-rt_v6-rev0/mingw64/opt/include -I/c/mingw810/prerequisites/x86_64-zlib-static/include -I/c/mingw810/prerequisites/x86_64-w64-mingw32-static/include' CPPFLAGS=' -I/c/mingw810/x86_64-810-win32-seh-rt_v6-rev0/mingw64/opt/include -I/c/mingw810/prerequisites/x86_64-zlib-static/include -I/c/mingw810/prerequisites/x86_64-w64-mingw32-static/include' LDFLAGS='-pipe -fno-ident -L/c/mingw810/x86_64-810-win32-seh-rt_v6-rev0/mingw64/opt/lib -L/c/mingw810/prerequisites/x86_64-zlib-static/lib -L/c/mingw810/prerequisites/x86_64-w64-mingw32-static/lib ']
ignore line: [Thread model: win32]
ignore line: [gcc version 8.1.0 (x86_64-win32-seh-rev0 Built by MinGW-W64 project) ]
ignore line: [COMPILER_PATH=D:/c/mingw64/bin/../libexec/gcc/x86_64-w64-mingw32/8.1.0/]
ignore line: [D:/c/mingw64/bin/../libexec/gcc/]
ignore line: [D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../x86_64-w64-mingw32/bin/]
ignore line: [LIBRARY_PATH=D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/]
ignore line: [D:/c/mingw64/bin/../lib/gcc/]
ignore line: [D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../x86_64-w64-mingw32/lib/../lib/]
ignore line: [D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../lib/]
ignore line: [D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../x86_64-w64-mingw32/lib/]
ignore line: [D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../]
ignore line: [COLLECT_GCC_OPTIONS='-v' '-o' 'cmTC_5c3f4.exe' '-shared-libgcc' '-mtune=core2' '-march=nocona']
link line: [ D:/c/mingw64/bin/../libexec/gcc/x86_64-w64-mingw32/8.1.0/collect2.exe -plugin D:/c/mingw64/bin/../libexec/gcc/x86_64-w64-mingw32/8.1.0/liblto_plugin-0.dll -plugin-opt=D:/c/mingw64/bin/../libexec/gcc/x86_64-w64-mingw32/8.1.0/lto-wrapper.exe -plugin-opt=-fresolution=C:\\Users\\OMEN\\AppData\\Local\\Temp\\cc2y9LGp.res -plugin-opt=-pass-through=-lmingw32 -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lmoldname -plugin-opt=-pass-through=-lmingwex -plugin-opt=-pass-through=-lmsvcrt -plugin-opt=-pass-through=-ladvapi32 -plugin-opt=-pass-through=-lshell32 -plugin-opt=-pass-through=-luser32 -plugin-opt=-pass-through=-lkernel32 -plugin-opt=-pass-through=-liconv -plugin-opt=-pass-through=-lmingw32 -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lmoldname -plugin-opt=-pass-through=-lmingwex -plugin-opt=-pass-through=-lmsvcrt --sysroot=C:/mingw810/x86_64-810-win32-seh-rt_v6-rev0/mingw64 -m i386pep -Bdynamic -o cmTC_5c3f4.exe D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../x86_64-w64-mingw32/lib/../lib/crt2.o D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/crtbegin.o -LD:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0 -LD:/c/mingw64/bin/../lib/gcc -LD:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../x86_64-w64-mingw32/lib/../lib -LD:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../lib -LD:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../x86_64-w64-mingw32/lib -LD:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../.. -v --whole-archive CMakeFiles\\cmTC_5c3f4.dir/objects.a --no-whole-archive --out-implib libcmTC_5c3f4.dll.a --major-image-version 0 --minor-image-version 0 -lstdc++ -lmingw32 -lgcc_s -lgcc -lmoldname -lmingwex -lmsvcrt -ladvapi32 -lshell32 -luser32 -lkernel32 -liconv -lmingw32 -lgcc_s -lgcc -lmoldname -lmingwex -lmsvcrt D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/crtend.o]
arg [D:/c/mingw64/bin/../libexec/gcc/x86_64-w64-mingw32/8.1.0/collect2.exe] ==> ignore
arg [-plugin] ==> ignore
arg [D:/c/mingw64/bin/../libexec/gcc/x86_64-w64-mingw32/8.1.0/liblto_plugin-0.dll] ==> ignore
arg [-plugin-opt=D:/c/mingw64/bin/../libexec/gcc/x86_64-w64-mingw32/8.1.0/lto-wrapper.exe] ==> ignore
arg [-plugin-opt=-fresolution=C:\\Users\\OMEN\\AppData\\Local\\Temp\\cc2y9LGp.res] ==> ignore
arg [-plugin-opt=-pass-through=-lmingw32] ==> ignore
arg [-plugin-opt=-pass-through=-lgcc_s] ==> ignore
arg [-plugin-opt=-pass-through=-lgcc] ==> ignore
arg [-plugin-opt=-pass-through=-lmoldname] ==> ignore
arg [-plugin-opt=-pass-through=-lmingwex] ==> ignore
arg [-plugin-opt=-pass-through=-lmsvcrt] ==> ignore
arg [-plugin-opt=-pass-through=-ladvapi32] ==> ignore
arg [-plugin-opt=-pass-through=-lshell32] ==> ignore
arg [-plugin-opt=-pass-through=-luser32] ==> ignore
arg [-plugin-opt=-pass-through=-lkernel32] ==> ignore
arg [-plugin-opt=-pass-through=-liconv] ==> ignore
arg [-plugin-opt=-pass-through=-lmingw32] ==> ignore
arg [-plugin-opt=-pass-through=-lgcc_s] ==> ignore
arg [-plugin-opt=-pass-through=-lgcc] ==> ignore
arg [-plugin-opt=-pass-through=-lmoldname] ==> ignore
arg [-plugin-opt=-pass-through=-lmingwex] ==> ignore
arg [-plugin-opt=-pass-through=-lmsvcrt] ==> ignore
arg [--sysroot=C:/mingw810/x86_64-810-win32-seh-rt_v6-rev0/mingw64] ==> ignore
arg [-m] ==> ignore
arg [i386pep] ==> ignore
arg [-Bdynamic] ==> search dynamic
arg [-o] ==> ignore
arg [cmTC_5c3f4.exe] ==> ignore
arg [D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../x86_64-w64-mingw32/lib/../lib/crt2.o] ==> obj [D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../x86_64-w64-mingw32/lib/../lib/crt2.o]
arg [D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/crtbegin.o] ==> obj [D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/crtbegin.o]
arg [-LD:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0] ==> dir [D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0]
arg [-LD:/c/mingw64/bin/../lib/gcc] ==> dir [D:/c/mingw64/bin/../lib/gcc]
arg [-LD:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../x86_64-w64-mingw32/lib/../lib] ==> dir [D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../x86_64-w64-mingw32/lib/../lib]
arg [-LD:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../lib] ==> dir [D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../lib]
arg [-LD:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../x86_64-w64-mingw32/lib] ==> dir [D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../x86_64-w64-mingw32/lib]
arg [-LD:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../..] ==> dir [D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../..]
arg [-v] ==> ignore
arg [--whole-archive] ==> ignore
arg [CMakeFiles\\cmTC_5c3f4.dir/objects.a] ==> ignore
arg [--no-whole-archive] ==> ignore
arg [--out-implib] ==> ignore
arg [libcmTC_5c3f4.dll.a] ==> ignore
arg [--major-image-version] ==> ignore
arg [0] ==> ignore
arg [--minor-image-version] ==> ignore
arg [0] ==> ignore
arg [-lstdc++] ==> lib [stdc++]
arg [-lmingw32] ==> lib [mingw32]
arg [-lgcc_s] ==> lib [gcc_s]
arg [-lgcc] ==> lib [gcc]
arg [-lmoldname] ==> lib [moldname]
arg [-lmingwex] ==> lib [mingwex]
arg [-lmsvcrt] ==> lib [msvcrt]
arg [-ladvapi32] ==> lib [advapi32]
arg [-lshell32] ==> lib [shell32]
arg [-luser32] ==> lib [user32]
arg [-lkernel32] ==> lib [kernel32]
arg [-liconv] ==> lib [iconv]
arg [-lmingw32] ==> lib [mingw32]
arg [-lgcc_s] ==> lib [gcc_s]
arg [-lgcc] ==> lib [gcc]
arg [-lmoldname] ==> lib [moldname]
arg [-lmingwex] ==> lib [mingwex]
arg [-lmsvcrt] ==> lib [msvcrt]
arg [D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/crtend.o] ==> obj [D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/crtend.o]
ignore line: [collect2 version 8.1.0]
ignore line: [D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../x86_64-w64-mingw32/bin/ld.exe -plugin D:/c/mingw64/bin/../libexec/gcc/x86_64-w64-mingw32/8.1.0/liblto_plugin-0.dll -plugin-opt=D:/c/mingw64/bin/../libexec/gcc/x86_64-w64-mingw32/8.1.0/lto-wrapper.exe -plugin-opt=-fresolution=C:\\Users\\OMEN\\AppData\\Local\\Temp\\cc2y9LGp.res -plugin-opt=-pass-through=-lmingw32 -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lmoldname -plugin-opt=-pass-through=-lmingwex -plugin-opt=-pass-through=-lmsvcrt -plugin-opt=-pass-through=-ladvapi32 -plugin-opt=-pass-through=-lshell32 -plugin-opt=-pass-through=-luser32 -plugin-opt=-pass-through=-lkernel32 -plugin-opt=-pass-through=-liconv -plugin-opt=-pass-through=-lmingw32 -plugin-opt=-pass-through=-lgcc_s -plugin-opt=-pass-through=-lgcc -plugin-opt=-pass-through=-lmoldname -plugin-opt=-pass-through=-lmingwex -plugin-opt=-pass-through=-lmsvcrt --sysroot=C:/mingw810/x86_64-810-win32-seh-rt_v6-rev0/mingw64 -m i386pep -Bdynamic -o cmTC_5c3f4.exe D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../x86_64-w64-mingw32/lib/../lib/crt2.o D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/crtbegin.o -LD:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0 -LD:/c/mingw64/bin/../lib/gcc -LD:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../x86_64-w64-mingw32/lib/../lib -LD:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../lib -LD:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../x86_64-w64-mingw32/lib -LD:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../.. -v --whole-archive CMakeFiles\\cmTC_5c3f4.dir/objects.a --no-whole-archive --out-implib libcmTC_5c3f4.dll.a --major-image-version 0 --minor-image-version 0 -lstdc++ -lmingw32 -lgcc_s -lgcc -lmoldname -lmingwex -lmsvcrt -ladvapi32 -lshell32 -luser32 -lkernel32 -liconv -lmingw32 -lgcc_s -lgcc -lmoldname -lmingwex -lmsvcrt D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/crtend.o]
linker tool for 'CXX': D:/c/mingw64/x86_64-w64-mingw32/bin/ld.exe
remove lib [msvcrt]
remove lib [msvcrt]
collapse obj [D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../x86_64-w64-mingw32/lib/../lib/crt2.o] ==> [D:/c/mingw64/x86_64-w64-mingw32/lib/crt2.o]
collapse obj [D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/crtbegin.o] ==> [D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/crtbegin.o]
collapse obj [D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/crtend.o] ==> [D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/crtend.o]
collapse library dir [D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0] ==> [D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0]
collapse library dir [D:/c/mingw64/bin/../lib/gcc] ==> [D:/c/mingw64/lib/gcc]
collapse library dir [D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../x86_64-w64-mingw32/lib/../lib] ==> [D:/c/mingw64/x86_64-w64-mingw32/lib]
collapse library dir [D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../lib] ==> [D:/c/mingw64/lib]
collapse library dir [D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../../../x86_64-w64-mingw32/lib] ==> [D:/c/mingw64/x86_64-w64-mingw32/lib]
collapse library dir [D:/c/mingw64/bin/../lib/gcc/x86_64-w64-mingw32/8.1.0/../../..] ==> [D:/c/mingw64/lib]
implicit libs: [stdc++;mingw32;gcc_s;gcc;moldname;mingwex;advapi32;shell32;user32;kernel32;iconv;mingw32;gcc_s;gcc;moldname;mingwex]
implicit objs: [D:/c/mingw64/x86_64-w64-mingw32/lib/crt2.o;D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/crtbegin.o;D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/crtend.o]
implicit dirs: [D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0;D:/c/mingw64/lib/gcc;D:/c/mingw64/x86_64-w64-mingw32/lib;D:/c/mingw64/lib]
implicit fwks: []
-
kind: "message-v1"
backtrace:
- "D:/cmake/share/cmake-3.30/Modules/Internal/CMakeDetermineLinkerId.cmake:40 (message)"
- "D:/cmake/share/cmake-3.30/Modules/CMakeDetermineCompilerABI.cmake:255 (cmake_determine_linker_id)"
- "D:/cmake/share/cmake-3.30/Modules/CMakeTestCXXCompiler.cmake:26 (CMAKE_DETERMINE_COMPILER_ABI)"
- "CMakeLists.txt:2 (project)"
message: |
Running the CXX compiler's linker: "D:/c/mingw64/x86_64-w64-mingw32/bin/ld.exe" "-v"
GNU ld (GNU Binutils) 2.30
...

View File

@ -0,0 +1,16 @@
# CMAKE generated file: DO NOT EDIT!
# Generated by "MinGW Makefiles" Generator, CMake Version 3.30
# Relative path conversion top directories.
set(CMAKE_RELATIVE_PATH_TOP_SOURCE "D:/c_work/start/xnet_tiny_c0101")
set(CMAKE_RELATIVE_PATH_TOP_BINARY "D:/c_work/start/build")
# Force unix paths in dependencies.
set(CMAKE_FORCE_UNIX_PATHS 1)
# The C and CXX include file regular expressions for this directory.
set(CMAKE_C_INCLUDE_REGEX_SCAN "^.*$")
set(CMAKE_C_INCLUDE_REGEX_COMPLAIN "^$")
set(CMAKE_CXX_INCLUDE_REGEX_SCAN ${CMAKE_C_INCLUDE_REGEX_SCAN})
set(CMAKE_CXX_INCLUDE_REGEX_COMPLAIN ${CMAKE_C_INCLUDE_REGEX_COMPLAIN})

View File

@ -0,0 +1,59 @@
# CMAKE generated file: DO NOT EDIT!
# Generated by "MinGW Makefiles" Generator, CMake Version 3.30
# The generator used is:
set(CMAKE_DEPENDS_GENERATOR "MinGW Makefiles")
# The top level Makefile was generated from the following files:
set(CMAKE_MAKEFILE_DEPENDS
"CMakeCache.txt"
"CMakeFiles/3.30.3/CMakeCCompiler.cmake"
"CMakeFiles/3.30.3/CMakeCXXCompiler.cmake"
"CMakeFiles/3.30.3/CMakeRCCompiler.cmake"
"CMakeFiles/3.30.3/CMakeSystem.cmake"
"D:/c_work/start/xnet_tiny_c0101/CMakeLists.txt"
"D:/c_work/start/xnet_tiny_c0101/src/xnet_app/CMakeLists.txt"
"D:/c_work/start/xnet_tiny_c0101/src/xnet_tiny/CMakeLists.txt"
"D:/cmake/share/cmake-3.30/Modules/CMakeCInformation.cmake"
"D:/cmake/share/cmake-3.30/Modules/CMakeCXXInformation.cmake"
"D:/cmake/share/cmake-3.30/Modules/CMakeCommonLanguageInclude.cmake"
"D:/cmake/share/cmake-3.30/Modules/CMakeGenericSystem.cmake"
"D:/cmake/share/cmake-3.30/Modules/CMakeInitializeConfigs.cmake"
"D:/cmake/share/cmake-3.30/Modules/CMakeLanguageInformation.cmake"
"D:/cmake/share/cmake-3.30/Modules/CMakeRCInformation.cmake"
"D:/cmake/share/cmake-3.30/Modules/CMakeSystemSpecificInformation.cmake"
"D:/cmake/share/cmake-3.30/Modules/CMakeSystemSpecificInitialize.cmake"
"D:/cmake/share/cmake-3.30/Modules/Compiler/CMakeCommonCompilerMacros.cmake"
"D:/cmake/share/cmake-3.30/Modules/Compiler/GNU-C.cmake"
"D:/cmake/share/cmake-3.30/Modules/Compiler/GNU-CXX.cmake"
"D:/cmake/share/cmake-3.30/Modules/Compiler/GNU.cmake"
"D:/cmake/share/cmake-3.30/Modules/Platform/Windows-GNU-C-ABI.cmake"
"D:/cmake/share/cmake-3.30/Modules/Platform/Windows-GNU-C.cmake"
"D:/cmake/share/cmake-3.30/Modules/Platform/Windows-GNU-CXX-ABI.cmake"
"D:/cmake/share/cmake-3.30/Modules/Platform/Windows-GNU-CXX.cmake"
"D:/cmake/share/cmake-3.30/Modules/Platform/Windows-GNU.cmake"
"D:/cmake/share/cmake-3.30/Modules/Platform/Windows-Initialize.cmake"
"D:/cmake/share/cmake-3.30/Modules/Platform/Windows-windres.cmake"
"D:/cmake/share/cmake-3.30/Modules/Platform/Windows.cmake"
"D:/cmake/share/cmake-3.30/Modules/Platform/WindowsPaths.cmake"
)
# The corresponding makefile is:
set(CMAKE_MAKEFILE_OUTPUTS
"Makefile"
"CMakeFiles/cmake.check_cache"
)
# Byproducts of CMake generate step:
set(CMAKE_MAKEFILE_PRODUCTS
"CMakeFiles/CMakeDirectoryInformation.cmake"
"src/xnet_tiny/CMakeFiles/CMakeDirectoryInformation.cmake"
"src/xnet_app/CMakeFiles/CMakeDirectoryInformation.cmake"
)
# Dependency information for all targets:
set(CMAKE_DEPEND_INFO_FILES
"CMakeFiles/xnet.dir/DependInfo.cmake"
"src/xnet_tiny/CMakeFiles/xnet_tiny.dir/DependInfo.cmake"
"src/xnet_app/CMakeFiles/xnet_app.dir/DependInfo.cmake"
)

View File

@ -0,0 +1,199 @@
# CMAKE generated file: DO NOT EDIT!
# Generated by "MinGW Makefiles" Generator, CMake Version 3.30
# Default target executed when no arguments are given to make.
default_target: all
.PHONY : default_target
#=============================================================================
# Special targets provided by cmake.
# Disable implicit rules so canonical targets will work.
.SUFFIXES:
# Disable VCS-based implicit rules.
% : %,v
# Disable VCS-based implicit rules.
% : RCS/%
# Disable VCS-based implicit rules.
% : RCS/%,v
# Disable VCS-based implicit rules.
% : SCCS/s.%
# Disable VCS-based implicit rules.
% : s.%
.SUFFIXES: .hpux_make_needs_suffix_list
# Command-line flag to silence nested $(MAKE).
$(VERBOSE)MAKESILENT = -s
#Suppress display of executed commands.
$(VERBOSE).SILENT:
# A target that is always out of date.
cmake_force:
.PHONY : cmake_force
#=============================================================================
# Set environment variables for the build.
SHELL = cmd.exe
# The CMake executable.
CMAKE_COMMAND = D:\cmake\bin\cmake.exe
# The command to remove a file.
RM = D:\cmake\bin\cmake.exe -E rm -f
# Escaping for special characters.
EQUALS = =
# The top-level source directory on which CMake was run.
CMAKE_SOURCE_DIR = D:\c_work\start\xnet_tiny_c0101
# The top-level build directory on which CMake was run.
CMAKE_BINARY_DIR = D:\c_work\start\build
#=============================================================================
# Directory level rules for the build root directory
# The main recursive "all" target.
all: CMakeFiles/xnet.dir/all
all: src/xnet_tiny/all
all: src/xnet_app/all
.PHONY : all
# The main recursive "preinstall" target.
preinstall: src/xnet_tiny/preinstall
preinstall: src/xnet_app/preinstall
.PHONY : preinstall
# The main recursive "clean" target.
clean: CMakeFiles/xnet.dir/clean
clean: src/xnet_tiny/clean
clean: src/xnet_app/clean
.PHONY : clean
#=============================================================================
# Directory level rules for directory src/xnet_app
# Recursive "all" directory target.
src/xnet_app/all: src/xnet_app/CMakeFiles/xnet_app.dir/all
.PHONY : src/xnet_app/all
# Recursive "preinstall" directory target.
src/xnet_app/preinstall:
.PHONY : src/xnet_app/preinstall
# Recursive "clean" directory target.
src/xnet_app/clean: src/xnet_app/CMakeFiles/xnet_app.dir/clean
.PHONY : src/xnet_app/clean
#=============================================================================
# Directory level rules for directory src/xnet_tiny
# Recursive "all" directory target.
src/xnet_tiny/all: src/xnet_tiny/CMakeFiles/xnet_tiny.dir/all
.PHONY : src/xnet_tiny/all
# Recursive "preinstall" directory target.
src/xnet_tiny/preinstall:
.PHONY : src/xnet_tiny/preinstall
# Recursive "clean" directory target.
src/xnet_tiny/clean: src/xnet_tiny/CMakeFiles/xnet_tiny.dir/clean
.PHONY : src/xnet_tiny/clean
#=============================================================================
# Target rules for target CMakeFiles/xnet.dir
# All Build rule for target.
CMakeFiles/xnet.dir/all: src/xnet_tiny/CMakeFiles/xnet_tiny.dir/all
CMakeFiles/xnet.dir/all: src/xnet_app/CMakeFiles/xnet_app.dir/all
$(MAKE) $(MAKESILENT) -f CMakeFiles\xnet.dir\build.make CMakeFiles/xnet.dir/depend
$(MAKE) $(MAKESILENT) -f CMakeFiles\xnet.dir\build.make CMakeFiles/xnet.dir/build
@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --progress-dir=D:\c_work\start\build\CMakeFiles --progress-num=1,2,3 "Built target xnet"
.PHONY : CMakeFiles/xnet.dir/all
# Build rule for subdir invocation for target.
CMakeFiles/xnet.dir/rule: cmake_check_build_system
$(CMAKE_COMMAND) -E cmake_progress_start D:\c_work\start\build\CMakeFiles 9
$(MAKE) $(MAKESILENT) -f CMakeFiles\Makefile2 CMakeFiles/xnet.dir/all
$(CMAKE_COMMAND) -E cmake_progress_start D:\c_work\start\build\CMakeFiles 0
.PHONY : CMakeFiles/xnet.dir/rule
# Convenience name for target.
xnet: CMakeFiles/xnet.dir/rule
.PHONY : xnet
# clean rule for target.
CMakeFiles/xnet.dir/clean:
$(MAKE) $(MAKESILENT) -f CMakeFiles\xnet.dir\build.make CMakeFiles/xnet.dir/clean
.PHONY : CMakeFiles/xnet.dir/clean
#=============================================================================
# Target rules for target src/xnet_tiny/CMakeFiles/xnet_tiny.dir
# All Build rule for target.
src/xnet_tiny/CMakeFiles/xnet_tiny.dir/all:
$(MAKE) $(MAKESILENT) -f src\xnet_tiny\CMakeFiles\xnet_tiny.dir\build.make src/xnet_tiny/CMakeFiles/xnet_tiny.dir/depend
$(MAKE) $(MAKESILENT) -f src\xnet_tiny\CMakeFiles\xnet_tiny.dir\build.make src/xnet_tiny/CMakeFiles/xnet_tiny.dir/build
@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --progress-dir=D:\c_work\start\build\CMakeFiles --progress-num=8,9 "Built target xnet_tiny"
.PHONY : src/xnet_tiny/CMakeFiles/xnet_tiny.dir/all
# Build rule for subdir invocation for target.
src/xnet_tiny/CMakeFiles/xnet_tiny.dir/rule: cmake_check_build_system
$(CMAKE_COMMAND) -E cmake_progress_start D:\c_work\start\build\CMakeFiles 2
$(MAKE) $(MAKESILENT) -f CMakeFiles\Makefile2 src/xnet_tiny/CMakeFiles/xnet_tiny.dir/all
$(CMAKE_COMMAND) -E cmake_progress_start D:\c_work\start\build\CMakeFiles 0
.PHONY : src/xnet_tiny/CMakeFiles/xnet_tiny.dir/rule
# Convenience name for target.
xnet_tiny: src/xnet_tiny/CMakeFiles/xnet_tiny.dir/rule
.PHONY : xnet_tiny
# clean rule for target.
src/xnet_tiny/CMakeFiles/xnet_tiny.dir/clean:
$(MAKE) $(MAKESILENT) -f src\xnet_tiny\CMakeFiles\xnet_tiny.dir\build.make src/xnet_tiny/CMakeFiles/xnet_tiny.dir/clean
.PHONY : src/xnet_tiny/CMakeFiles/xnet_tiny.dir/clean
#=============================================================================
# Target rules for target src/xnet_app/CMakeFiles/xnet_app.dir
# All Build rule for target.
src/xnet_app/CMakeFiles/xnet_app.dir/all:
$(MAKE) $(MAKESILENT) -f src\xnet_app\CMakeFiles\xnet_app.dir\build.make src/xnet_app/CMakeFiles/xnet_app.dir/depend
$(MAKE) $(MAKESILENT) -f src\xnet_app\CMakeFiles\xnet_app.dir\build.make src/xnet_app/CMakeFiles/xnet_app.dir/build
@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --progress-dir=D:\c_work\start\build\CMakeFiles --progress-num=4,5,6,7 "Built target xnet_app"
.PHONY : src/xnet_app/CMakeFiles/xnet_app.dir/all
# Build rule for subdir invocation for target.
src/xnet_app/CMakeFiles/xnet_app.dir/rule: cmake_check_build_system
$(CMAKE_COMMAND) -E cmake_progress_start D:\c_work\start\build\CMakeFiles 4
$(MAKE) $(MAKESILENT) -f CMakeFiles\Makefile2 src/xnet_app/CMakeFiles/xnet_app.dir/all
$(CMAKE_COMMAND) -E cmake_progress_start D:\c_work\start\build\CMakeFiles 0
.PHONY : src/xnet_app/CMakeFiles/xnet_app.dir/rule
# Convenience name for target.
xnet_app: src/xnet_app/CMakeFiles/xnet_app.dir/rule
.PHONY : xnet_app
# clean rule for target.
src/xnet_app/CMakeFiles/xnet_app.dir/clean:
$(MAKE) $(MAKESILENT) -f src\xnet_app\CMakeFiles\xnet_app.dir\build.make src/xnet_app/CMakeFiles/xnet_app.dir/clean
.PHONY : src/xnet_app/CMakeFiles/xnet_app.dir/clean
#=============================================================================
# Special targets to cleanup operation of make.
# Special rule to run CMake to check the build system integrity.
# No rule that depends on this can have commands that come from listfiles
# because they might be regenerated.
cmake_check_build_system:
$(CMAKE_COMMAND) -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) --check-build-system CMakeFiles\Makefile.cmake 0
.PHONY : cmake_check_build_system

View File

@ -0,0 +1,9 @@
D:/c_work/start/build/CMakeFiles/xnet.dir
D:/c_work/start/build/CMakeFiles/edit_cache.dir
D:/c_work/start/build/CMakeFiles/rebuild_cache.dir
D:/c_work/start/build/src/xnet_tiny/CMakeFiles/xnet_tiny.dir
D:/c_work/start/build/src/xnet_tiny/CMakeFiles/edit_cache.dir
D:/c_work/start/build/src/xnet_tiny/CMakeFiles/rebuild_cache.dir
D:/c_work/start/build/src/xnet_app/CMakeFiles/xnet_app.dir
D:/c_work/start/build/src/xnet_app/CMakeFiles/edit_cache.dir
D:/c_work/start/build/src/xnet_app/CMakeFiles/rebuild_cache.dir

View File

@ -0,0 +1 @@
# This file is generated by cmake for dependency checking of the CMakeCache.txt file

View File

@ -0,0 +1 @@
9

View File

@ -0,0 +1,262 @@
CMakeFiles/xnet.dir/D_/c_work/start/lib/xnet/pcap_device.c.obj: \
D:\c_work\start\lib\xnet\pcap_device.c \
D:/c/mingw64/x86_64-w64-mingw32/include/memory.h \
D:/c/mingw64/x86_64-w64-mingw32/include/crtdefs.h \
D:/c/mingw64/x86_64-w64-mingw32/include/_mingw.h \
D:/c/mingw64/x86_64-w64-mingw32/include/_mingw_mac.h \
D:/c/mingw64/x86_64-w64-mingw32/include/_mingw_secapi.h \
D:/c/mingw64/x86_64-w64-mingw32/include/vadefs.h \
D:/c/mingw64/x86_64-w64-mingw32/include/sdks/_mingw_directx.h \
D:/c/mingw64/x86_64-w64-mingw32/include/sdks/_mingw_ddk.h \
D:\c_work\start\lib\xnet\pcap_device.h \
D:/c_work/start/lib/npcap/Include/pcap.h \
D:/c_work/start/lib/npcap/Include/pcap/pcap.h \
D:/c_work/start/lib/npcap/Include/pcap/funcattrs.h \
D:/c_work/start/lib/npcap/Include/pcap/compiler-tests.h \
D:/c_work/start/lib/npcap/Include/pcap/pcap-inttypes.h \
D:/c/mingw64/x86_64-w64-mingw32/include/inttypes.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/stdint.h \
D:/c/mingw64/x86_64-w64-mingw32/include/stdint.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/stddef.h \
D:/c/mingw64/x86_64-w64-mingw32/include/stddef.h \
D:/c/mingw64/x86_64-w64-mingw32/include/_mingw_print_push.h \
D:/c/mingw64/x86_64-w64-mingw32/include/_mingw_print_pop.h \
D:/c/mingw64/x86_64-w64-mingw32/include/winsock2.h \
D:/c/mingw64/x86_64-w64-mingw32/include/_mingw_unicode.h \
D:/c/mingw64/x86_64-w64-mingw32/include/windows.h \
D:/c/mingw64/x86_64-w64-mingw32/include/sdkddkver.h \
D:/c/mingw64/x86_64-w64-mingw32/include/excpt.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/stdarg.h \
D:/c/mingw64/x86_64-w64-mingw32/include/stdarg.h \
D:/c/mingw64/x86_64-w64-mingw32/include/_mingw_stdarg.h \
D:/c/mingw64/x86_64-w64-mingw32/include/windef.h \
D:/c/mingw64/x86_64-w64-mingw32/include/minwindef.h \
D:/c/mingw64/x86_64-w64-mingw32/include/winapifamily.h \
D:/c/mingw64/x86_64-w64-mingw32/include/specstrings.h \
D:/c/mingw64/x86_64-w64-mingw32/include/sal.h \
D:/c/mingw64/x86_64-w64-mingw32/include/driverspecs.h \
D:/c/mingw64/x86_64-w64-mingw32/include/winnt.h \
D:/c/mingw64/x86_64-w64-mingw32/include/ctype.h \
D:/c/mingw64/x86_64-w64-mingw32/include/apiset.h \
D:/c/mingw64/x86_64-w64-mingw32/include/psdk_inc/intrin-impl.h \
D:/c/mingw64/x86_64-w64-mingw32/include/basetsd.h \
D:/c/mingw64/x86_64-w64-mingw32/include/guiddef.h \
D:/c/mingw64/x86_64-w64-mingw32/include/string.h \
D:/c/mingw64/x86_64-w64-mingw32/include/sec_api/string_s.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/x86intrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/ia32intrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/mmintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/xmmintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/mm_malloc.h \
D:/c/mingw64/x86_64-w64-mingw32/include/stdlib.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include-fixed/limits.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include-fixed/syslimits.h \
D:/c/mingw64/x86_64-w64-mingw32/include/limits.h \
D:/c/mingw64/x86_64-w64-mingw32/include/sec_api/stdlib_s.h \
D:/c/mingw64/x86_64-w64-mingw32/include/malloc.h \
D:/c/mingw64/x86_64-w64-mingw32/include/errno.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/emmintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/pmmintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/tmmintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/ammintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/smmintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/popcntintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/wmmintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/immintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/avxintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/avx2intrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/avx512fintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/avx512erintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/avx512pfintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/avx512cdintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/avx512vlintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/avx512bwintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/avx512dqintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/avx512vlbwintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/avx512vldqintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/avx512ifmaintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/avx512ifmavlintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/avx512vbmiintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/avx512vbmivlintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/avx5124fmapsintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/avx5124vnniwintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/avx512vpopcntdqintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/avx512vbmi2intrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/avx512vbmi2vlintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/avx512vnniintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/avx512vnnivlintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/avx512vpopcntdqvlintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/avx512bitalgintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/shaintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/lzcntintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/bmiintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/bmi2intrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/fmaintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/f16cintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/rtmintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/xtestintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/cetintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/gfniintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/vaesintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/vpclmulqdqintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/movdirintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/mm3dnow.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/prfchwintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/fma4intrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/xopintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/lwpintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/tbmintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/rdseedintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/fxsrintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/xsaveintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/xsaveoptintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/sgxintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/pconfigintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/adxintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/clwbintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/clflushoptintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/xsavesintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/xsavecintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/mwaitxintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/clzerointrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/wbnoinvdintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/pkuintrin.h \
D:/c/mingw64/x86_64-w64-mingw32/include/pshpack4.h \
D:/c/mingw64/x86_64-w64-mingw32/include/poppack.h \
D:/c/mingw64/x86_64-w64-mingw32/include/pshpack4.h \
D:/c/mingw64/x86_64-w64-mingw32/include/pshpack2.h \
D:/c/mingw64/x86_64-w64-mingw32/include/poppack.h \
D:/c/mingw64/x86_64-w64-mingw32/include/pshpack2.h \
D:/c/mingw64/x86_64-w64-mingw32/include/pshpack8.h \
D:/c/mingw64/x86_64-w64-mingw32/include/pshpack8.h \
D:/c/mingw64/x86_64-w64-mingw32/include/ktmtypes.h \
D:/c/mingw64/x86_64-w64-mingw32/include/winbase.h \
D:/c/mingw64/x86_64-w64-mingw32/include/apisetcconv.h \
D:/c/mingw64/x86_64-w64-mingw32/include/minwinbase.h \
D:/c/mingw64/x86_64-w64-mingw32/include/bemapiset.h \
D:/c/mingw64/x86_64-w64-mingw32/include/debugapi.h \
D:/c/mingw64/x86_64-w64-mingw32/include/errhandlingapi.h \
D:/c/mingw64/x86_64-w64-mingw32/include/fibersapi.h \
D:/c/mingw64/x86_64-w64-mingw32/include/fileapi.h \
D:/c/mingw64/x86_64-w64-mingw32/include/handleapi.h \
D:/c/mingw64/x86_64-w64-mingw32/include/heapapi.h \
D:/c/mingw64/x86_64-w64-mingw32/include/ioapiset.h \
D:/c/mingw64/x86_64-w64-mingw32/include/interlockedapi.h \
D:/c/mingw64/x86_64-w64-mingw32/include/jobapi.h \
D:/c/mingw64/x86_64-w64-mingw32/include/libloaderapi.h \
D:/c/mingw64/x86_64-w64-mingw32/include/memoryapi.h \
D:/c/mingw64/x86_64-w64-mingw32/include/namedpipeapi.h \
D:/c/mingw64/x86_64-w64-mingw32/include/namespaceapi.h \
D:/c/mingw64/x86_64-w64-mingw32/include/processenv.h \
D:/c/mingw64/x86_64-w64-mingw32/include/processthreadsapi.h \
D:/c/mingw64/x86_64-w64-mingw32/include/processtopologyapi.h \
D:/c/mingw64/x86_64-w64-mingw32/include/profileapi.h \
D:/c/mingw64/x86_64-w64-mingw32/include/realtimeapiset.h \
D:/c/mingw64/x86_64-w64-mingw32/include/securityappcontainer.h \
D:/c/mingw64/x86_64-w64-mingw32/include/securitybaseapi.h \
D:/c/mingw64/x86_64-w64-mingw32/include/synchapi.h \
D:/c/mingw64/x86_64-w64-mingw32/include/sysinfoapi.h \
D:/c/mingw64/x86_64-w64-mingw32/include/systemtopologyapi.h \
D:/c/mingw64/x86_64-w64-mingw32/include/threadpoolapiset.h \
D:/c/mingw64/x86_64-w64-mingw32/include/threadpoollegacyapiset.h \
D:/c/mingw64/x86_64-w64-mingw32/include/utilapiset.h \
D:/c/mingw64/x86_64-w64-mingw32/include/wow64apiset.h \
D:/c/mingw64/x86_64-w64-mingw32/include/winerror.h \
D:/c/mingw64/x86_64-w64-mingw32/include/fltwinerror.h \
D:/c/mingw64/x86_64-w64-mingw32/include/timezoneapi.h \
D:/c/mingw64/x86_64-w64-mingw32/include/wingdi.h \
D:/c/mingw64/x86_64-w64-mingw32/include/pshpack1.h \
D:/c/mingw64/x86_64-w64-mingw32/include/winuser.h \
D:/c/mingw64/x86_64-w64-mingw32/include/tvout.h \
D:/c/mingw64/x86_64-w64-mingw32/include/winnls.h \
D:/c/mingw64/x86_64-w64-mingw32/include/datetimeapi.h \
D:/c/mingw64/x86_64-w64-mingw32/include/stringapiset.h \
D:/c/mingw64/x86_64-w64-mingw32/include/wincon.h \
D:/c/mingw64/x86_64-w64-mingw32/include/winver.h \
D:/c/mingw64/x86_64-w64-mingw32/include/winreg.h \
D:/c/mingw64/x86_64-w64-mingw32/include/reason.h \
D:/c/mingw64/x86_64-w64-mingw32/include/winnetwk.h \
D:/c/mingw64/x86_64-w64-mingw32/include/wnnc.h \
D:/c/mingw64/x86_64-w64-mingw32/include/virtdisk.h \
D:/c/mingw64/x86_64-w64-mingw32/include/cderr.h \
D:/c/mingw64/x86_64-w64-mingw32/include/dde.h \
D:/c/mingw64/x86_64-w64-mingw32/include/ddeml.h \
D:/c/mingw64/x86_64-w64-mingw32/include/dlgs.h \
D:/c/mingw64/x86_64-w64-mingw32/include/lzexpand.h \
D:/c/mingw64/x86_64-w64-mingw32/include/mmsystem.h \
D:/c/mingw64/x86_64-w64-mingw32/include/nb30.h \
D:/c/mingw64/x86_64-w64-mingw32/include/rpc.h \
D:/c/mingw64/x86_64-w64-mingw32/include/rpcdce.h \
D:/c/mingw64/x86_64-w64-mingw32/include/rpcdcep.h \
D:/c/mingw64/x86_64-w64-mingw32/include/rpcnsi.h \
D:/c/mingw64/x86_64-w64-mingw32/include/rpcnterr.h \
D:/c/mingw64/x86_64-w64-mingw32/include/rpcasync.h \
D:/c/mingw64/x86_64-w64-mingw32/include/shellapi.h \
D:/c/mingw64/x86_64-w64-mingw32/include/winperf.h \
D:/c/mingw64/x86_64-w64-mingw32/include/winsock.h \
D:/c/mingw64/x86_64-w64-mingw32/include/wincrypt.h \
D:/c/mingw64/x86_64-w64-mingw32/include/bcrypt.h \
D:/c/mingw64/x86_64-w64-mingw32/include/ncrypt.h \
D:/c/mingw64/x86_64-w64-mingw32/include/dpapi.h \
D:/c/mingw64/x86_64-w64-mingw32/include/winefs.h \
D:/c/mingw64/x86_64-w64-mingw32/include/winscard.h \
D:/c/mingw64/x86_64-w64-mingw32/include/wtypes.h \
D:/c/mingw64/x86_64-w64-mingw32/include/rpcndr.h \
D:/c/mingw64/x86_64-w64-mingw32/include/rpcnsip.h \
D:/c/mingw64/x86_64-w64-mingw32/include/rpcsal.h \
D:/c/mingw64/x86_64-w64-mingw32/include/ole2.h \
D:/c/mingw64/x86_64-w64-mingw32/include/objbase.h \
D:/c/mingw64/x86_64-w64-mingw32/include/combaseapi.h \
D:/c/mingw64/x86_64-w64-mingw32/include/wtypesbase.h \
D:/c/mingw64/x86_64-w64-mingw32/include/unknwnbase.h \
D:/c/mingw64/x86_64-w64-mingw32/include/objidlbase.h \
D:/c/mingw64/x86_64-w64-mingw32/include/cguid.h \
D:/c/mingw64/x86_64-w64-mingw32/include/objidl.h \
D:/c/mingw64/x86_64-w64-mingw32/include/unknwn.h \
D:/c/mingw64/x86_64-w64-mingw32/include/urlmon.h \
D:/c/mingw64/x86_64-w64-mingw32/include/oleidl.h \
D:/c/mingw64/x86_64-w64-mingw32/include/servprov.h \
D:/c/mingw64/x86_64-w64-mingw32/include/msxml.h \
D:/c/mingw64/x86_64-w64-mingw32/include/oaidl.h \
D:/c/mingw64/x86_64-w64-mingw32/include/propidl.h \
D:/c/mingw64/x86_64-w64-mingw32/include/oleauto.h \
D:/c/mingw64/x86_64-w64-mingw32/include/winioctl.h \
D:/c/mingw64/x86_64-w64-mingw32/include/winsmcrd.h \
D:/c/mingw64/x86_64-w64-mingw32/include/winspool.h \
D:/c/mingw64/x86_64-w64-mingw32/include/prsht.h \
D:/c/mingw64/x86_64-w64-mingw32/include/commdlg.h \
D:/c/mingw64/x86_64-w64-mingw32/include/stralign.h \
D:/c/mingw64/x86_64-w64-mingw32/include/sec_api/stralign_s.h \
D:/c/mingw64/x86_64-w64-mingw32/include/winsvc.h \
D:/c/mingw64/x86_64-w64-mingw32/include/mcx.h \
D:/c/mingw64/x86_64-w64-mingw32/include/imm.h \
D:/c/mingw64/x86_64-w64-mingw32/include/psdk_inc/_ws1_undef.h \
D:/c/mingw64/x86_64-w64-mingw32/include/_timeval.h \
D:/c/mingw64/x86_64-w64-mingw32/include/_bsd_types.h \
D:/c/mingw64/x86_64-w64-mingw32/include/inaddr.h \
D:/c/mingw64/x86_64-w64-mingw32/include/psdk_inc/_socket_types.h \
D:/c/mingw64/x86_64-w64-mingw32/include/psdk_inc/_fd_types.h \
D:/c/mingw64/x86_64-w64-mingw32/include/psdk_inc/_ip_types.h \
D:/c/mingw64/x86_64-w64-mingw32/include/psdk_inc/_wsadata.h \
D:/c/mingw64/x86_64-w64-mingw32/include/ws2def.h \
D:/c/mingw64/x86_64-w64-mingw32/include/psdk_inc/_wsa_errnos.h \
D:/c/mingw64/x86_64-w64-mingw32/include/qos.h \
D:/c/mingw64/x86_64-w64-mingw32/include/io.h \
D:/c/mingw64/x86_64-w64-mingw32/include/_mingw_off_t.h \
D:/c_work/start/lib/npcap/Include/pcap/socket.h \
D:/c/mingw64/x86_64-w64-mingw32/include/ws2tcpip.h \
D:/c/mingw64/x86_64-w64-mingw32/include/ws2ipdef.h \
D:/c/mingw64/x86_64-w64-mingw32/include/in6addr.h \
D:/c/mingw64/x86_64-w64-mingw32/include/psdk_inc/_ip_mreq1.h \
D:/c/mingw64/x86_64-w64-mingw32/include/mstcpip.h \
D:/c_work/start/lib/npcap/Include/pcap/bpf.h \
D:/c_work/start/lib/npcap/Include/pcap/dlt.h \
D:/c/mingw64/x86_64-w64-mingw32/include/stdio.h \
D:/c/mingw64/x86_64-w64-mingw32/include/swprintf.inl \
D:/c/mingw64/x86_64-w64-mingw32/include/sec_api/stdio_s.h \
D:/c/mingw64/x86_64-w64-mingw32/include/tchar.h \
D:/c/mingw64/x86_64-w64-mingw32/include/sec_api/tchar_s.h \
D:/c/mingw64/x86_64-w64-mingw32/include/time.h \
D:/c/mingw64/x86_64-w64-mingw32/include/sys/timeb.h \
D:/c/mingw64/x86_64-w64-mingw32/include/sec_api/sys/timeb_s.h \
D:/c/mingw64/x86_64-w64-mingw32/include/pthread_time.h

View File

@ -0,0 +1,24 @@
# Consider dependencies only in project.
set(CMAKE_DEPENDS_IN_PROJECT_ONLY OFF)
# The set of languages for which implicit dependencies are needed:
set(CMAKE_DEPENDS_LANGUAGES
)
# The set of dependency files which are needed:
set(CMAKE_DEPENDS_DEPENDENCY_FILES
"D:/c_work/start/lib/xnet/pcap_device.c" "CMakeFiles/xnet.dir/D_/c_work/start/lib/xnet/pcap_device.c.obj" "gcc" "CMakeFiles/xnet.dir/D_/c_work/start/lib/xnet/pcap_device.c.obj.d"
"D:/c_work/start/xnet_tiny_c0101/src/app.c" "CMakeFiles/xnet.dir/src/app.c.obj" "gcc" "CMakeFiles/xnet.dir/src/app.c.obj.d"
)
# Targets to which this target links which contain Fortran sources.
set(CMAKE_Fortran_TARGET_LINKED_INFO_FILES
)
# Targets to which this target links which contain Fortran sources.
set(CMAKE_Fortran_TARGET_FORWARD_LINKED_INFO_FILES
)
# Fortran module output directory.
set(CMAKE_Fortran_TARGET_MODULE_DIR "")

View File

@ -0,0 +1,132 @@
# CMAKE generated file: DO NOT EDIT!
# Generated by "MinGW Makefiles" Generator, CMake Version 3.30
# Delete rule output on recipe failure.
.DELETE_ON_ERROR:
#=============================================================================
# Special targets provided by cmake.
# Disable implicit rules so canonical targets will work.
.SUFFIXES:
# Disable VCS-based implicit rules.
% : %,v
# Disable VCS-based implicit rules.
% : RCS/%
# Disable VCS-based implicit rules.
% : RCS/%,v
# Disable VCS-based implicit rules.
% : SCCS/s.%
# Disable VCS-based implicit rules.
% : s.%
.SUFFIXES: .hpux_make_needs_suffix_list
# Command-line flag to silence nested $(MAKE).
$(VERBOSE)MAKESILENT = -s
#Suppress display of executed commands.
$(VERBOSE).SILENT:
# A target that is always out of date.
cmake_force:
.PHONY : cmake_force
#=============================================================================
# Set environment variables for the build.
SHELL = cmd.exe
# The CMake executable.
CMAKE_COMMAND = D:\cmake\bin\cmake.exe
# The command to remove a file.
RM = D:\cmake\bin\cmake.exe -E rm -f
# Escaping for special characters.
EQUALS = =
# The top-level source directory on which CMake was run.
CMAKE_SOURCE_DIR = D:\c_work\start\xnet_tiny_c0101
# The top-level build directory on which CMake was run.
CMAKE_BINARY_DIR = D:\c_work\start\build
# Include any dependencies generated for this target.
include CMakeFiles/xnet.dir/depend.make
# Include any dependencies generated by the compiler for this target.
include CMakeFiles/xnet.dir/compiler_depend.make
# Include the progress variables for this target.
include CMakeFiles/xnet.dir/progress.make
# Include the compile flags for this target's objects.
include CMakeFiles/xnet.dir/flags.make
CMakeFiles/xnet.dir/D_/c_work/start/lib/xnet/pcap_device.c.obj: CMakeFiles/xnet.dir/flags.make
CMakeFiles/xnet.dir/D_/c_work/start/lib/xnet/pcap_device.c.obj: CMakeFiles/xnet.dir/includes_C.rsp
CMakeFiles/xnet.dir/D_/c_work/start/lib/xnet/pcap_device.c.obj: D:/c_work/start/lib/xnet/pcap_device.c
CMakeFiles/xnet.dir/D_/c_work/start/lib/xnet/pcap_device.c.obj: CMakeFiles/xnet.dir/compiler_depend.ts
@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=D:\c_work\start\build\CMakeFiles --progress-num=$(CMAKE_PROGRESS_1) "Building C object CMakeFiles/xnet.dir/D_/c_work/start/lib/xnet/pcap_device.c.obj"
D:\c\mingw64\bin\gcc.exe $(C_DEFINES) $(C_INCLUDES) $(C_FLAGS) -MD -MT CMakeFiles/xnet.dir/D_/c_work/start/lib/xnet/pcap_device.c.obj -MF CMakeFiles\xnet.dir\D_\c_work\start\lib\xnet\pcap_device.c.obj.d -o CMakeFiles\xnet.dir\D_\c_work\start\lib\xnet\pcap_device.c.obj -c D:\c_work\start\lib\xnet\pcap_device.c
CMakeFiles/xnet.dir/D_/c_work/start/lib/xnet/pcap_device.c.i: cmake_force
@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing C source to CMakeFiles/xnet.dir/D_/c_work/start/lib/xnet/pcap_device.c.i"
D:\c\mingw64\bin\gcc.exe $(C_DEFINES) $(C_INCLUDES) $(C_FLAGS) -E D:\c_work\start\lib\xnet\pcap_device.c > CMakeFiles\xnet.dir\D_\c_work\start\lib\xnet\pcap_device.c.i
CMakeFiles/xnet.dir/D_/c_work/start/lib/xnet/pcap_device.c.s: cmake_force
@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling C source to assembly CMakeFiles/xnet.dir/D_/c_work/start/lib/xnet/pcap_device.c.s"
D:\c\mingw64\bin\gcc.exe $(C_DEFINES) $(C_INCLUDES) $(C_FLAGS) -S D:\c_work\start\lib\xnet\pcap_device.c -o CMakeFiles\xnet.dir\D_\c_work\start\lib\xnet\pcap_device.c.s
CMakeFiles/xnet.dir/src/app.c.obj: CMakeFiles/xnet.dir/flags.make
CMakeFiles/xnet.dir/src/app.c.obj: CMakeFiles/xnet.dir/includes_C.rsp
CMakeFiles/xnet.dir/src/app.c.obj: D:/c_work/start/xnet_tiny_c0101/src/app.c
CMakeFiles/xnet.dir/src/app.c.obj: CMakeFiles/xnet.dir/compiler_depend.ts
@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=D:\c_work\start\build\CMakeFiles --progress-num=$(CMAKE_PROGRESS_2) "Building C object CMakeFiles/xnet.dir/src/app.c.obj"
D:\c\mingw64\bin\gcc.exe $(C_DEFINES) $(C_INCLUDES) $(C_FLAGS) -MD -MT CMakeFiles/xnet.dir/src/app.c.obj -MF CMakeFiles\xnet.dir\src\app.c.obj.d -o CMakeFiles\xnet.dir\src\app.c.obj -c D:\c_work\start\xnet_tiny_c0101\src\app.c
CMakeFiles/xnet.dir/src/app.c.i: cmake_force
@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing C source to CMakeFiles/xnet.dir/src/app.c.i"
D:\c\mingw64\bin\gcc.exe $(C_DEFINES) $(C_INCLUDES) $(C_FLAGS) -E D:\c_work\start\xnet_tiny_c0101\src\app.c > CMakeFiles\xnet.dir\src\app.c.i
CMakeFiles/xnet.dir/src/app.c.s: cmake_force
@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling C source to assembly CMakeFiles/xnet.dir/src/app.c.s"
D:\c\mingw64\bin\gcc.exe $(C_DEFINES) $(C_INCLUDES) $(C_FLAGS) -S D:\c_work\start\xnet_tiny_c0101\src\app.c -o CMakeFiles\xnet.dir\src\app.c.s
# Object files for target xnet
xnet_OBJECTS = \
"CMakeFiles/xnet.dir/D_/c_work/start/lib/xnet/pcap_device.c.obj" \
"CMakeFiles/xnet.dir/src/app.c.obj"
# External object files for target xnet
xnet_EXTERNAL_OBJECTS =
xnet.exe: CMakeFiles/xnet.dir/D_/c_work/start/lib/xnet/pcap_device.c.obj
xnet.exe: CMakeFiles/xnet.dir/src/app.c.obj
xnet.exe: CMakeFiles/xnet.dir/build.make
xnet.exe: src/xnet_tiny/libxnet_tiny.a
xnet.exe: src/xnet_app/libxnet_app.a
xnet.exe: D:/c_work/start/xnet_tiny_c0101/../lib/npcap/Lib/x64/wpcap.lib
xnet.exe: CMakeFiles/xnet.dir/linkLibs.rsp
xnet.exe: CMakeFiles/xnet.dir/objects1.rsp
xnet.exe: CMakeFiles/xnet.dir/link.txt
@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --bold --progress-dir=D:\c_work\start\build\CMakeFiles --progress-num=$(CMAKE_PROGRESS_3) "Linking C executable xnet.exe"
$(CMAKE_COMMAND) -E cmake_link_script CMakeFiles\xnet.dir\link.txt --verbose=$(VERBOSE)
# Rule to build all files generated by this target.
CMakeFiles/xnet.dir/build: xnet.exe
.PHONY : CMakeFiles/xnet.dir/build
CMakeFiles/xnet.dir/clean:
$(CMAKE_COMMAND) -P CMakeFiles\xnet.dir\cmake_clean.cmake
.PHONY : CMakeFiles/xnet.dir/clean
CMakeFiles/xnet.dir/depend:
$(CMAKE_COMMAND) -E cmake_depends "MinGW Makefiles" D:\c_work\start\xnet_tiny_c0101 D:\c_work\start\xnet_tiny_c0101 D:\c_work\start\build D:\c_work\start\build D:\c_work\start\build\CMakeFiles\xnet.dir\DependInfo.cmake "--color=$(COLOR)"
.PHONY : CMakeFiles/xnet.dir/depend

View File

@ -0,0 +1,15 @@
file(REMOVE_RECURSE
"CMakeFiles/xnet.dir/D_/c_work/start/lib/xnet/pcap_device.c.obj"
"CMakeFiles/xnet.dir/D_/c_work/start/lib/xnet/pcap_device.c.obj.d"
"CMakeFiles/xnet.dir/src/app.c.obj"
"CMakeFiles/xnet.dir/src/app.c.obj.d"
"libxnet.dll.a"
"xnet.exe"
"xnet.exe.manifest"
"xnet.pdb"
)
# Per-language clean rules from dependency scanning.
foreach(lang C)
include(CMakeFiles/xnet.dir/cmake_clean_${lang}.cmake OPTIONAL)
endforeach()

View File

@ -0,0 +1,2 @@
# Empty compiler generated dependencies file for xnet.
# This may be replaced when dependencies are built.

View File

@ -0,0 +1,2 @@
# CMAKE generated file: DO NOT EDIT!
# Timestamp file for compiler generated dependencies management for xnet.

View File

@ -0,0 +1,2 @@
# Empty dependencies file for xnet.
# This may be replaced when dependencies are built.

View File

@ -0,0 +1,10 @@
# CMAKE generated file: DO NOT EDIT!
# Generated by "MinGW Makefiles" Generator, CMake Version 3.30
# compile C with D:/c/mingw64/bin/gcc.exe
C_DEFINES = -DNET_DRIVER_PCAP -D_CRT_SECURE_NO_WARNINGS
C_INCLUDES = @CMakeFiles/xnet.dir/includes_C.rsp
C_FLAGS = -g -g

View File

@ -0,0 +1 @@
-ID:/c_work/start/xnet_tiny_c0101 -ID:/c_work/start/xnet_tiny_c0101/../lib/npcap/Include -ID:/c_work/start/xnet_tiny_c0101/src/xnet_app -ID:/c_work/start/xnet_tiny_c0101/src/xnet_tiny -ID:/c_work/start/xnet_tiny_c0101/../lib/xnet

View File

@ -0,0 +1,3 @@
D:\cmake\bin\cmake.exe -E rm -f CMakeFiles\xnet.dir/objects.a
D:\c\mingw64\bin\ar.exe qc CMakeFiles\xnet.dir/objects.a @CMakeFiles\xnet.dir\objects1.rsp
D:\c\mingw64\bin\gcc.exe -g -Wl,--whole-archive CMakeFiles\xnet.dir/objects.a -Wl,--no-whole-archive -o xnet.exe -Wl,--out-implib,libxnet.dll.a -Wl,--major-image-version,0,--minor-image-version,0 @CMakeFiles\xnet.dir\linkLibs.rsp

View File

@ -0,0 +1 @@
-LD:/c_work/start/xnet_tiny_c0101/../lib/npcap/Lib/x64 src/xnet_tiny/libxnet_tiny.a src/xnet_app/libxnet_app.a D:/c_work/start/xnet_tiny_c0101/../lib/npcap/Lib/x64/wpcap.lib -lWs2_32 -lkernel32 -luser32 -lgdi32 -lwinspool -lshell32 -lole32 -loleaut32 -luuid -lcomdlg32 -ladvapi32

Binary file not shown.

View File

@ -0,0 +1 @@
CMakeFiles/xnet.dir/D_/c_work/start/lib/xnet/pcap_device.c.obj CMakeFiles/xnet.dir/src/app.c.obj

View File

@ -0,0 +1,4 @@
CMAKE_PROGRESS_1 = 1
CMAKE_PROGRESS_2 = 2
CMAKE_PROGRESS_3 = 3

View File

@ -0,0 +1,20 @@
CMakeFiles/xnet.dir/src/app.c.obj: \
D:\c_work\start\xnet_tiny_c0101\src\app.c \
D:/c/mingw64/x86_64-w64-mingw32/include/stdio.h \
D:/c/mingw64/x86_64-w64-mingw32/include/crtdefs.h \
D:/c/mingw64/x86_64-w64-mingw32/include/_mingw.h \
D:/c/mingw64/x86_64-w64-mingw32/include/_mingw_mac.h \
D:/c/mingw64/x86_64-w64-mingw32/include/_mingw_secapi.h \
D:/c/mingw64/x86_64-w64-mingw32/include/vadefs.h \
D:/c/mingw64/x86_64-w64-mingw32/include/sdks/_mingw_directx.h \
D:/c/mingw64/x86_64-w64-mingw32/include/sdks/_mingw_ddk.h \
D:/c/mingw64/x86_64-w64-mingw32/include/_mingw_print_push.h \
D:/c/mingw64/x86_64-w64-mingw32/include/_mingw_off_t.h \
D:/c/mingw64/x86_64-w64-mingw32/include/swprintf.inl \
D:/c/mingw64/x86_64-w64-mingw32/include/sec_api/stdio_s.h \
D:/c/mingw64/x86_64-w64-mingw32/include/_mingw_print_pop.h \
D:/c_work/start/xnet_tiny_c0101/src/xnet_tiny/xnet_tiny.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/stdint.h \
D:/c/mingw64/x86_64-w64-mingw32/include/stdint.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/stddef.h \
D:/c/mingw64/x86_64-w64-mingw32/include/stddef.h

View File

@ -0,0 +1,235 @@
# CMAKE generated file: DO NOT EDIT!
# Generated by "MinGW Makefiles" Generator, CMake Version 3.30
# Default target executed when no arguments are given to make.
default_target: all
.PHONY : default_target
# Allow only one "make -f Makefile2" at a time, but pass parallelism.
.NOTPARALLEL:
#=============================================================================
# Special targets provided by cmake.
# Disable implicit rules so canonical targets will work.
.SUFFIXES:
# Disable VCS-based implicit rules.
% : %,v
# Disable VCS-based implicit rules.
% : RCS/%
# Disable VCS-based implicit rules.
% : RCS/%,v
# Disable VCS-based implicit rules.
% : SCCS/s.%
# Disable VCS-based implicit rules.
% : s.%
.SUFFIXES: .hpux_make_needs_suffix_list
# Command-line flag to silence nested $(MAKE).
$(VERBOSE)MAKESILENT = -s
#Suppress display of executed commands.
$(VERBOSE).SILENT:
# A target that is always out of date.
cmake_force:
.PHONY : cmake_force
#=============================================================================
# Set environment variables for the build.
SHELL = cmd.exe
# The CMake executable.
CMAKE_COMMAND = D:\cmake\bin\cmake.exe
# The command to remove a file.
RM = D:\cmake\bin\cmake.exe -E rm -f
# Escaping for special characters.
EQUALS = =
# The top-level source directory on which CMake was run.
CMAKE_SOURCE_DIR = D:\c_work\start\xnet_tiny_c0101
# The top-level build directory on which CMake was run.
CMAKE_BINARY_DIR = D:\c_work\start\build
#=============================================================================
# Targets provided globally by CMake.
# Special rule for the target edit_cache
edit_cache:
@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Running CMake cache editor..."
D:\cmake\bin\cmake-gui.exe -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR)
.PHONY : edit_cache
# Special rule for the target edit_cache
edit_cache/fast: edit_cache
.PHONY : edit_cache/fast
# Special rule for the target rebuild_cache
rebuild_cache:
@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Running CMake to regenerate build system..."
D:\cmake\bin\cmake.exe --regenerate-during-build -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR)
.PHONY : rebuild_cache
# Special rule for the target rebuild_cache
rebuild_cache/fast: rebuild_cache
.PHONY : rebuild_cache/fast
# The main all target
all: cmake_check_build_system
$(CMAKE_COMMAND) -E cmake_progress_start D:\c_work\start\build\CMakeFiles D:\c_work\start\build\\CMakeFiles\progress.marks
$(MAKE) $(MAKESILENT) -f CMakeFiles\Makefile2 all
$(CMAKE_COMMAND) -E cmake_progress_start D:\c_work\start\build\CMakeFiles 0
.PHONY : all
# The main clean target
clean:
$(MAKE) $(MAKESILENT) -f CMakeFiles\Makefile2 clean
.PHONY : clean
# The main clean target
clean/fast: clean
.PHONY : clean/fast
# Prepare targets for installation.
preinstall: all
$(MAKE) $(MAKESILENT) -f CMakeFiles\Makefile2 preinstall
.PHONY : preinstall
# Prepare targets for installation.
preinstall/fast:
$(MAKE) $(MAKESILENT) -f CMakeFiles\Makefile2 preinstall
.PHONY : preinstall/fast
# clear depends
depend:
$(CMAKE_COMMAND) -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) --check-build-system CMakeFiles\Makefile.cmake 1
.PHONY : depend
#=============================================================================
# Target rules for targets named xnet
# Build rule for target.
xnet: cmake_check_build_system
$(MAKE) $(MAKESILENT) -f CMakeFiles\Makefile2 xnet
.PHONY : xnet
# fast build rule for target.
xnet/fast:
$(MAKE) $(MAKESILENT) -f CMakeFiles\xnet.dir\build.make CMakeFiles/xnet.dir/build
.PHONY : xnet/fast
#=============================================================================
# Target rules for targets named xnet_tiny
# Build rule for target.
xnet_tiny: cmake_check_build_system
$(MAKE) $(MAKESILENT) -f CMakeFiles\Makefile2 xnet_tiny
.PHONY : xnet_tiny
# fast build rule for target.
xnet_tiny/fast:
$(MAKE) $(MAKESILENT) -f src\xnet_tiny\CMakeFiles\xnet_tiny.dir\build.make src/xnet_tiny/CMakeFiles/xnet_tiny.dir/build
.PHONY : xnet_tiny/fast
#=============================================================================
# Target rules for targets named xnet_app
# Build rule for target.
xnet_app: cmake_check_build_system
$(MAKE) $(MAKESILENT) -f CMakeFiles\Makefile2 xnet_app
.PHONY : xnet_app
# fast build rule for target.
xnet_app/fast:
$(MAKE) $(MAKESILENT) -f src\xnet_app\CMakeFiles\xnet_app.dir\build.make src/xnet_app/CMakeFiles/xnet_app.dir/build
.PHONY : xnet_app/fast
D_/c_work/start/lib/xnet/pcap_device.obj: D_/c_work/start/lib/xnet/pcap_device.c.obj
.PHONY : D_/c_work/start/lib/xnet/pcap_device.obj
# target to build an object file
D_/c_work/start/lib/xnet/pcap_device.c.obj:
$(MAKE) $(MAKESILENT) -f CMakeFiles\xnet.dir\build.make CMakeFiles/xnet.dir/D_/c_work/start/lib/xnet/pcap_device.c.obj
.PHONY : D_/c_work/start/lib/xnet/pcap_device.c.obj
D_/c_work/start/lib/xnet/pcap_device.i: D_/c_work/start/lib/xnet/pcap_device.c.i
.PHONY : D_/c_work/start/lib/xnet/pcap_device.i
# target to preprocess a source file
D_/c_work/start/lib/xnet/pcap_device.c.i:
$(MAKE) $(MAKESILENT) -f CMakeFiles\xnet.dir\build.make CMakeFiles/xnet.dir/D_/c_work/start/lib/xnet/pcap_device.c.i
.PHONY : D_/c_work/start/lib/xnet/pcap_device.c.i
D_/c_work/start/lib/xnet/pcap_device.s: D_/c_work/start/lib/xnet/pcap_device.c.s
.PHONY : D_/c_work/start/lib/xnet/pcap_device.s
# target to generate assembly for a file
D_/c_work/start/lib/xnet/pcap_device.c.s:
$(MAKE) $(MAKESILENT) -f CMakeFiles\xnet.dir\build.make CMakeFiles/xnet.dir/D_/c_work/start/lib/xnet/pcap_device.c.s
.PHONY : D_/c_work/start/lib/xnet/pcap_device.c.s
src/app.obj: src/app.c.obj
.PHONY : src/app.obj
# target to build an object file
src/app.c.obj:
$(MAKE) $(MAKESILENT) -f CMakeFiles\xnet.dir\build.make CMakeFiles/xnet.dir/src/app.c.obj
.PHONY : src/app.c.obj
src/app.i: src/app.c.i
.PHONY : src/app.i
# target to preprocess a source file
src/app.c.i:
$(MAKE) $(MAKESILENT) -f CMakeFiles\xnet.dir\build.make CMakeFiles/xnet.dir/src/app.c.i
.PHONY : src/app.c.i
src/app.s: src/app.c.s
.PHONY : src/app.s
# target to generate assembly for a file
src/app.c.s:
$(MAKE) $(MAKESILENT) -f CMakeFiles\xnet.dir\build.make CMakeFiles/xnet.dir/src/app.c.s
.PHONY : src/app.c.s
# Help Target
help:
@echo The following are some of the valid targets for this Makefile:
@echo ... all (the default if no target is provided)
@echo ... clean
@echo ... depend
@echo ... edit_cache
@echo ... rebuild_cache
@echo ... xnet
@echo ... xnet_app
@echo ... xnet_tiny
@echo ... D_/c_work/start/lib/xnet/pcap_device.obj
@echo ... D_/c_work/start/lib/xnet/pcap_device.i
@echo ... D_/c_work/start/lib/xnet/pcap_device.s
@echo ... src/app.obj
@echo ... src/app.i
@echo ... src/app.s
.PHONY : help
#=============================================================================
# Special targets to cleanup operation of make.
# Special rule to run CMake to check the build system integrity.
# No rule that depends on this can have commands that come from listfiles
# because they might be regenerated.
cmake_check_build_system:
$(CMAKE_COMMAND) -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) --check-build-system CMakeFiles\Makefile.cmake 0
.PHONY : cmake_check_build_system

View File

@ -0,0 +1,64 @@
# Install script for directory: D:/c_work/start/xnet_tiny_c0101
# Set the install prefix
if(NOT DEFINED CMAKE_INSTALL_PREFIX)
set(CMAKE_INSTALL_PREFIX "C:/Program Files (x86)/xnet")
endif()
string(REGEX REPLACE "/$" "" CMAKE_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}")
# Set the install configuration name.
if(NOT DEFINED CMAKE_INSTALL_CONFIG_NAME)
if(BUILD_TYPE)
string(REGEX REPLACE "^[^A-Za-z0-9_]+" ""
CMAKE_INSTALL_CONFIG_NAME "${BUILD_TYPE}")
else()
set(CMAKE_INSTALL_CONFIG_NAME "Debug")
endif()
message(STATUS "Install configuration: \"${CMAKE_INSTALL_CONFIG_NAME}\"")
endif()
# Set the component getting installed.
if(NOT CMAKE_INSTALL_COMPONENT)
if(COMPONENT)
message(STATUS "Install component: \"${COMPONENT}\"")
set(CMAKE_INSTALL_COMPONENT "${COMPONENT}")
else()
set(CMAKE_INSTALL_COMPONENT)
endif()
endif()
# Is this installation the result of a crosscompile?
if(NOT DEFINED CMAKE_CROSSCOMPILING)
set(CMAKE_CROSSCOMPILING "FALSE")
endif()
# Set path to fallback-tool for dependency-resolution.
if(NOT DEFINED CMAKE_OBJDUMP)
set(CMAKE_OBJDUMP "D:/c/mingw64/bin/objdump.exe")
endif()
if(NOT CMAKE_INSTALL_LOCAL_ONLY)
# Include the install script for each subdirectory.
include("D:/c_work/start/build/src/xnet_tiny/cmake_install.cmake")
include("D:/c_work/start/build/src/xnet_app/cmake_install.cmake")
endif()
if(CMAKE_INSTALL_COMPONENT)
if(CMAKE_INSTALL_COMPONENT MATCHES "^[a-zA-Z0-9_.+-]+$")
set(CMAKE_INSTALL_MANIFEST "install_manifest_${CMAKE_INSTALL_COMPONENT}.txt")
else()
string(MD5 CMAKE_INST_COMP_HASH "${CMAKE_INSTALL_COMPONENT}")
set(CMAKE_INSTALL_MANIFEST "install_manifest_${CMAKE_INST_COMP_HASH}.txt")
unset(CMAKE_INST_COMP_HASH)
endif()
else()
set(CMAKE_INSTALL_MANIFEST "install_manifest.txt")
endif()
if(NOT CMAKE_INSTALL_LOCAL_ONLY)
string(REPLACE ";" "\n" CMAKE_INSTALL_MANIFEST_CONTENT
"${CMAKE_INSTALL_MANIFEST_FILES}")
file(WRITE "D:/c_work/start/build/${CMAKE_INSTALL_MANIFEST}"
"${CMAKE_INSTALL_MANIFEST_CONTENT}")
endif()

View File

@ -0,0 +1,38 @@
[
{
"directory": "D:/c_work/start/build",
"command": "D:\\c\\mingw64\\bin\\gcc.exe -DNET_DRIVER_PCAP -D_CRT_SECURE_NO_WARNINGS @CMakeFiles/xnet.dir/includes_C.rsp -g -g -o CMakeFiles\\xnet.dir\\D_\\c_work\\start\\lib\\xnet\\pcap_device.c.obj -c D:\\c_work\\start\\lib\\xnet\\pcap_device.c",
"file": "D:/c_work/start/lib/xnet/pcap_device.c",
"output": "CMakeFiles/xnet.dir/D_/c_work/start/lib/xnet/pcap_device.c.obj"
},
{
"directory": "D:/c_work/start/build",
"command": "D:\\c\\mingw64\\bin\\gcc.exe -DNET_DRIVER_PCAP -D_CRT_SECURE_NO_WARNINGS @CMakeFiles/xnet.dir/includes_C.rsp -g -g -o CMakeFiles\\xnet.dir\\src\\app.c.obj -c D:\\c_work\\start\\xnet_tiny_c0101\\src\\app.c",
"file": "D:/c_work/start/xnet_tiny_c0101/src/app.c",
"output": "CMakeFiles/xnet.dir/src/app.c.obj"
},
{
"directory": "D:/c_work/start/build/src/xnet_tiny",
"command": "D:\\c\\mingw64\\bin\\gcc.exe -D_CRT_SECURE_NO_WARNINGS @CMakeFiles/xnet_tiny.dir/includes_C.rsp -g -g -o CMakeFiles\\xnet_tiny.dir\\xnet_tiny.c.obj -c D:\\c_work\\start\\xnet_tiny_c0101\\src\\xnet_tiny\\xnet_tiny.c",
"file": "D:/c_work/start/xnet_tiny_c0101/src/xnet_tiny/xnet_tiny.c",
"output": "src/xnet_tiny/CMakeFiles/xnet_tiny.dir/xnet_tiny.c.obj"
},
{
"directory": "D:/c_work/start/build/src/xnet_app",
"command": "D:\\c\\mingw64\\bin\\gcc.exe -D_CRT_SECURE_NO_WARNINGS @CMakeFiles/xnet_app.dir/includes_C.rsp -g -g -o CMakeFiles\\xnet_app.dir\\port_pcap.c.obj -c D:\\c_work\\start\\xnet_tiny_c0101\\src\\xnet_app\\port_pcap.c",
"file": "D:/c_work/start/xnet_tiny_c0101/src/xnet_app/port_pcap.c",
"output": "src/xnet_app/CMakeFiles/xnet_app.dir/port_pcap.c.obj"
},
{
"directory": "D:/c_work/start/build/src/xnet_app",
"command": "D:\\c\\mingw64\\bin\\gcc.exe -D_CRT_SECURE_NO_WARNINGS @CMakeFiles/xnet_app.dir/includes_C.rsp -g -g -o CMakeFiles\\xnet_app.dir\\xserver_datetime.c.obj -c D:\\c_work\\start\\xnet_tiny_c0101\\src\\xnet_app\\xserver_datetime.c",
"file": "D:/c_work/start/xnet_tiny_c0101/src/xnet_app/xserver_datetime.c",
"output": "src/xnet_app/CMakeFiles/xnet_app.dir/xserver_datetime.c.obj"
},
{
"directory": "D:/c_work/start/build/src/xnet_app",
"command": "D:\\c\\mingw64\\bin\\gcc.exe -D_CRT_SECURE_NO_WARNINGS @CMakeFiles/xnet_app.dir/includes_C.rsp -g -g -o CMakeFiles\\xnet_app.dir\\xserver_http.c.obj -c D:\\c_work\\start\\xnet_tiny_c0101\\src\\xnet_app\\xserver_http.c",
"file": "D:/c_work/start/xnet_tiny_c0101/src/xnet_app/xserver_http.c",
"output": "src/xnet_app/CMakeFiles/xnet_app.dir/xserver_http.c.obj"
}
]

View File

@ -0,0 +1,16 @@
# CMAKE generated file: DO NOT EDIT!
# Generated by "MinGW Makefiles" Generator, CMake Version 3.30
# Relative path conversion top directories.
set(CMAKE_RELATIVE_PATH_TOP_SOURCE "D:/c_work/start/xnet_tiny_c0101")
set(CMAKE_RELATIVE_PATH_TOP_BINARY "D:/c_work/start/build")
# Force unix paths in dependencies.
set(CMAKE_FORCE_UNIX_PATHS 1)
# The C and CXX include file regular expressions for this directory.
set(CMAKE_C_INCLUDE_REGEX_SCAN "^.*$")
set(CMAKE_C_INCLUDE_REGEX_COMPLAIN "^$")
set(CMAKE_CXX_INCLUDE_REGEX_SCAN ${CMAKE_C_INCLUDE_REGEX_SCAN})
set(CMAKE_CXX_INCLUDE_REGEX_COMPLAIN ${CMAKE_C_INCLUDE_REGEX_COMPLAIN})

View File

@ -0,0 +1 @@
4

View File

@ -0,0 +1,25 @@
# Consider dependencies only in project.
set(CMAKE_DEPENDS_IN_PROJECT_ONLY OFF)
# The set of languages for which implicit dependencies are needed:
set(CMAKE_DEPENDS_LANGUAGES
)
# The set of dependency files which are needed:
set(CMAKE_DEPENDS_DEPENDENCY_FILES
"D:/c_work/start/xnet_tiny_c0101/src/xnet_app/port_pcap.c" "src/xnet_app/CMakeFiles/xnet_app.dir/port_pcap.c.obj" "gcc" "src/xnet_app/CMakeFiles/xnet_app.dir/port_pcap.c.obj.d"
"D:/c_work/start/xnet_tiny_c0101/src/xnet_app/xserver_datetime.c" "src/xnet_app/CMakeFiles/xnet_app.dir/xserver_datetime.c.obj" "gcc" "src/xnet_app/CMakeFiles/xnet_app.dir/xserver_datetime.c.obj.d"
"D:/c_work/start/xnet_tiny_c0101/src/xnet_app/xserver_http.c" "src/xnet_app/CMakeFiles/xnet_app.dir/xserver_http.c.obj" "gcc" "src/xnet_app/CMakeFiles/xnet_app.dir/xserver_http.c.obj.d"
)
# Targets to which this target links which contain Fortran sources.
set(CMAKE_Fortran_TARGET_LINKED_INFO_FILES
)
# Targets to which this target links which contain Fortran sources.
set(CMAKE_Fortran_TARGET_FORWARD_LINKED_INFO_FILES
)
# Fortran module output directory.
set(CMAKE_Fortran_TARGET_MODULE_DIR "")

View File

@ -0,0 +1,145 @@
# CMAKE generated file: DO NOT EDIT!
# Generated by "MinGW Makefiles" Generator, CMake Version 3.30
# Delete rule output on recipe failure.
.DELETE_ON_ERROR:
#=============================================================================
# Special targets provided by cmake.
# Disable implicit rules so canonical targets will work.
.SUFFIXES:
# Disable VCS-based implicit rules.
% : %,v
# Disable VCS-based implicit rules.
% : RCS/%
# Disable VCS-based implicit rules.
% : RCS/%,v
# Disable VCS-based implicit rules.
% : SCCS/s.%
# Disable VCS-based implicit rules.
% : s.%
.SUFFIXES: .hpux_make_needs_suffix_list
# Command-line flag to silence nested $(MAKE).
$(VERBOSE)MAKESILENT = -s
#Suppress display of executed commands.
$(VERBOSE).SILENT:
# A target that is always out of date.
cmake_force:
.PHONY : cmake_force
#=============================================================================
# Set environment variables for the build.
SHELL = cmd.exe
# The CMake executable.
CMAKE_COMMAND = D:\cmake\bin\cmake.exe
# The command to remove a file.
RM = D:\cmake\bin\cmake.exe -E rm -f
# Escaping for special characters.
EQUALS = =
# The top-level source directory on which CMake was run.
CMAKE_SOURCE_DIR = D:\c_work\start\xnet_tiny_c0101
# The top-level build directory on which CMake was run.
CMAKE_BINARY_DIR = D:\c_work\start\build
# Include any dependencies generated for this target.
include src/xnet_app/CMakeFiles/xnet_app.dir/depend.make
# Include any dependencies generated by the compiler for this target.
include src/xnet_app/CMakeFiles/xnet_app.dir/compiler_depend.make
# Include the progress variables for this target.
include src/xnet_app/CMakeFiles/xnet_app.dir/progress.make
# Include the compile flags for this target's objects.
include src/xnet_app/CMakeFiles/xnet_app.dir/flags.make
src/xnet_app/CMakeFiles/xnet_app.dir/port_pcap.c.obj: src/xnet_app/CMakeFiles/xnet_app.dir/flags.make
src/xnet_app/CMakeFiles/xnet_app.dir/port_pcap.c.obj: src/xnet_app/CMakeFiles/xnet_app.dir/includes_C.rsp
src/xnet_app/CMakeFiles/xnet_app.dir/port_pcap.c.obj: D:/c_work/start/xnet_tiny_c0101/src/xnet_app/port_pcap.c
src/xnet_app/CMakeFiles/xnet_app.dir/port_pcap.c.obj: src/xnet_app/CMakeFiles/xnet_app.dir/compiler_depend.ts
@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=D:\c_work\start\build\CMakeFiles --progress-num=$(CMAKE_PROGRESS_1) "Building C object src/xnet_app/CMakeFiles/xnet_app.dir/port_pcap.c.obj"
cd /d D:\c_work\start\build\src\xnet_app && D:\c\mingw64\bin\gcc.exe $(C_DEFINES) $(C_INCLUDES) $(C_FLAGS) -MD -MT src/xnet_app/CMakeFiles/xnet_app.dir/port_pcap.c.obj -MF CMakeFiles\xnet_app.dir\port_pcap.c.obj.d -o CMakeFiles\xnet_app.dir\port_pcap.c.obj -c D:\c_work\start\xnet_tiny_c0101\src\xnet_app\port_pcap.c
src/xnet_app/CMakeFiles/xnet_app.dir/port_pcap.c.i: cmake_force
@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing C source to CMakeFiles/xnet_app.dir/port_pcap.c.i"
cd /d D:\c_work\start\build\src\xnet_app && D:\c\mingw64\bin\gcc.exe $(C_DEFINES) $(C_INCLUDES) $(C_FLAGS) -E D:\c_work\start\xnet_tiny_c0101\src\xnet_app\port_pcap.c > CMakeFiles\xnet_app.dir\port_pcap.c.i
src/xnet_app/CMakeFiles/xnet_app.dir/port_pcap.c.s: cmake_force
@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling C source to assembly CMakeFiles/xnet_app.dir/port_pcap.c.s"
cd /d D:\c_work\start\build\src\xnet_app && D:\c\mingw64\bin\gcc.exe $(C_DEFINES) $(C_INCLUDES) $(C_FLAGS) -S D:\c_work\start\xnet_tiny_c0101\src\xnet_app\port_pcap.c -o CMakeFiles\xnet_app.dir\port_pcap.c.s
src/xnet_app/CMakeFiles/xnet_app.dir/xserver_datetime.c.obj: src/xnet_app/CMakeFiles/xnet_app.dir/flags.make
src/xnet_app/CMakeFiles/xnet_app.dir/xserver_datetime.c.obj: src/xnet_app/CMakeFiles/xnet_app.dir/includes_C.rsp
src/xnet_app/CMakeFiles/xnet_app.dir/xserver_datetime.c.obj: D:/c_work/start/xnet_tiny_c0101/src/xnet_app/xserver_datetime.c
src/xnet_app/CMakeFiles/xnet_app.dir/xserver_datetime.c.obj: src/xnet_app/CMakeFiles/xnet_app.dir/compiler_depend.ts
@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=D:\c_work\start\build\CMakeFiles --progress-num=$(CMAKE_PROGRESS_2) "Building C object src/xnet_app/CMakeFiles/xnet_app.dir/xserver_datetime.c.obj"
cd /d D:\c_work\start\build\src\xnet_app && D:\c\mingw64\bin\gcc.exe $(C_DEFINES) $(C_INCLUDES) $(C_FLAGS) -MD -MT src/xnet_app/CMakeFiles/xnet_app.dir/xserver_datetime.c.obj -MF CMakeFiles\xnet_app.dir\xserver_datetime.c.obj.d -o CMakeFiles\xnet_app.dir\xserver_datetime.c.obj -c D:\c_work\start\xnet_tiny_c0101\src\xnet_app\xserver_datetime.c
src/xnet_app/CMakeFiles/xnet_app.dir/xserver_datetime.c.i: cmake_force
@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing C source to CMakeFiles/xnet_app.dir/xserver_datetime.c.i"
cd /d D:\c_work\start\build\src\xnet_app && D:\c\mingw64\bin\gcc.exe $(C_DEFINES) $(C_INCLUDES) $(C_FLAGS) -E D:\c_work\start\xnet_tiny_c0101\src\xnet_app\xserver_datetime.c > CMakeFiles\xnet_app.dir\xserver_datetime.c.i
src/xnet_app/CMakeFiles/xnet_app.dir/xserver_datetime.c.s: cmake_force
@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling C source to assembly CMakeFiles/xnet_app.dir/xserver_datetime.c.s"
cd /d D:\c_work\start\build\src\xnet_app && D:\c\mingw64\bin\gcc.exe $(C_DEFINES) $(C_INCLUDES) $(C_FLAGS) -S D:\c_work\start\xnet_tiny_c0101\src\xnet_app\xserver_datetime.c -o CMakeFiles\xnet_app.dir\xserver_datetime.c.s
src/xnet_app/CMakeFiles/xnet_app.dir/xserver_http.c.obj: src/xnet_app/CMakeFiles/xnet_app.dir/flags.make
src/xnet_app/CMakeFiles/xnet_app.dir/xserver_http.c.obj: src/xnet_app/CMakeFiles/xnet_app.dir/includes_C.rsp
src/xnet_app/CMakeFiles/xnet_app.dir/xserver_http.c.obj: D:/c_work/start/xnet_tiny_c0101/src/xnet_app/xserver_http.c
src/xnet_app/CMakeFiles/xnet_app.dir/xserver_http.c.obj: src/xnet_app/CMakeFiles/xnet_app.dir/compiler_depend.ts
@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=D:\c_work\start\build\CMakeFiles --progress-num=$(CMAKE_PROGRESS_3) "Building C object src/xnet_app/CMakeFiles/xnet_app.dir/xserver_http.c.obj"
cd /d D:\c_work\start\build\src\xnet_app && D:\c\mingw64\bin\gcc.exe $(C_DEFINES) $(C_INCLUDES) $(C_FLAGS) -MD -MT src/xnet_app/CMakeFiles/xnet_app.dir/xserver_http.c.obj -MF CMakeFiles\xnet_app.dir\xserver_http.c.obj.d -o CMakeFiles\xnet_app.dir\xserver_http.c.obj -c D:\c_work\start\xnet_tiny_c0101\src\xnet_app\xserver_http.c
src/xnet_app/CMakeFiles/xnet_app.dir/xserver_http.c.i: cmake_force
@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing C source to CMakeFiles/xnet_app.dir/xserver_http.c.i"
cd /d D:\c_work\start\build\src\xnet_app && D:\c\mingw64\bin\gcc.exe $(C_DEFINES) $(C_INCLUDES) $(C_FLAGS) -E D:\c_work\start\xnet_tiny_c0101\src\xnet_app\xserver_http.c > CMakeFiles\xnet_app.dir\xserver_http.c.i
src/xnet_app/CMakeFiles/xnet_app.dir/xserver_http.c.s: cmake_force
@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling C source to assembly CMakeFiles/xnet_app.dir/xserver_http.c.s"
cd /d D:\c_work\start\build\src\xnet_app && D:\c\mingw64\bin\gcc.exe $(C_DEFINES) $(C_INCLUDES) $(C_FLAGS) -S D:\c_work\start\xnet_tiny_c0101\src\xnet_app\xserver_http.c -o CMakeFiles\xnet_app.dir\xserver_http.c.s
# Object files for target xnet_app
xnet_app_OBJECTS = \
"CMakeFiles/xnet_app.dir/port_pcap.c.obj" \
"CMakeFiles/xnet_app.dir/xserver_datetime.c.obj" \
"CMakeFiles/xnet_app.dir/xserver_http.c.obj"
# External object files for target xnet_app
xnet_app_EXTERNAL_OBJECTS =
src/xnet_app/libxnet_app.a: src/xnet_app/CMakeFiles/xnet_app.dir/port_pcap.c.obj
src/xnet_app/libxnet_app.a: src/xnet_app/CMakeFiles/xnet_app.dir/xserver_datetime.c.obj
src/xnet_app/libxnet_app.a: src/xnet_app/CMakeFiles/xnet_app.dir/xserver_http.c.obj
src/xnet_app/libxnet_app.a: src/xnet_app/CMakeFiles/xnet_app.dir/build.make
src/xnet_app/libxnet_app.a: src/xnet_app/CMakeFiles/xnet_app.dir/link.txt
@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --bold --progress-dir=D:\c_work\start\build\CMakeFiles --progress-num=$(CMAKE_PROGRESS_4) "Linking C static library libxnet_app.a"
cd /d D:\c_work\start\build\src\xnet_app && $(CMAKE_COMMAND) -P CMakeFiles\xnet_app.dir\cmake_clean_target.cmake
cd /d D:\c_work\start\build\src\xnet_app && $(CMAKE_COMMAND) -E cmake_link_script CMakeFiles\xnet_app.dir\link.txt --verbose=$(VERBOSE)
# Rule to build all files generated by this target.
src/xnet_app/CMakeFiles/xnet_app.dir/build: src/xnet_app/libxnet_app.a
.PHONY : src/xnet_app/CMakeFiles/xnet_app.dir/build
src/xnet_app/CMakeFiles/xnet_app.dir/clean:
cd /d D:\c_work\start\build\src\xnet_app && $(CMAKE_COMMAND) -P CMakeFiles\xnet_app.dir\cmake_clean.cmake
.PHONY : src/xnet_app/CMakeFiles/xnet_app.dir/clean
src/xnet_app/CMakeFiles/xnet_app.dir/depend:
$(CMAKE_COMMAND) -E cmake_depends "MinGW Makefiles" D:\c_work\start\xnet_tiny_c0101 D:\c_work\start\xnet_tiny_c0101\src\xnet_app D:\c_work\start\build D:\c_work\start\build\src\xnet_app D:\c_work\start\build\src\xnet_app\CMakeFiles\xnet_app.dir\DependInfo.cmake "--color=$(COLOR)"
.PHONY : src/xnet_app/CMakeFiles/xnet_app.dir/depend

View File

@ -0,0 +1,15 @@
file(REMOVE_RECURSE
"CMakeFiles/xnet_app.dir/port_pcap.c.obj"
"CMakeFiles/xnet_app.dir/port_pcap.c.obj.d"
"CMakeFiles/xnet_app.dir/xserver_datetime.c.obj"
"CMakeFiles/xnet_app.dir/xserver_datetime.c.obj.d"
"CMakeFiles/xnet_app.dir/xserver_http.c.obj"
"CMakeFiles/xnet_app.dir/xserver_http.c.obj.d"
"libxnet_app.a"
"libxnet_app.pdb"
)
# Per-language clean rules from dependency scanning.
foreach(lang C)
include(CMakeFiles/xnet_app.dir/cmake_clean_${lang}.cmake OPTIONAL)
endforeach()

View File

@ -0,0 +1,3 @@
file(REMOVE_RECURSE
"libxnet_app.a"
)

View File

@ -0,0 +1,2 @@
# Empty compiler generated dependencies file for xnet_app.
# This may be replaced when dependencies are built.

View File

@ -0,0 +1,2 @@
# CMAKE generated file: DO NOT EDIT!
# Timestamp file for compiler generated dependencies management for xnet_app.

View File

@ -0,0 +1,2 @@
# Empty dependencies file for xnet_app.
# This may be replaced when dependencies are built.

View File

@ -0,0 +1,10 @@
# CMAKE generated file: DO NOT EDIT!
# Generated by "MinGW Makefiles" Generator, CMake Version 3.30
# compile C with D:/c/mingw64/bin/gcc.exe
C_DEFINES = -D_CRT_SECURE_NO_WARNINGS
C_INCLUDES = @CMakeFiles/xnet_app.dir/includes_C.rsp
C_FLAGS = -g -g

View File

@ -0,0 +1 @@
-ID:/c_work/start/xnet_tiny_c0101 -ID:/c_work/start/xnet_tiny_c0101/../lib/npcap/Include -ID:/c_work/start/xnet_tiny_c0101/src/xnet_app -ID:/c_work/start/xnet_tiny_c0101/src/xnet_tiny -ID:/c_work/start/xnet_tiny_c0101/../lib/xnet

View File

@ -0,0 +1,2 @@
D:\c\mingw64\bin\ar.exe qc libxnet_app.a CMakeFiles/xnet_app.dir/port_pcap.c.obj CMakeFiles/xnet_app.dir/xserver_datetime.c.obj CMakeFiles/xnet_app.dir/xserver_http.c.obj
D:\c\mingw64\bin\ranlib.exe libxnet_app.a

View File

@ -0,0 +1,255 @@
src/xnet_app/CMakeFiles/xnet_app.dir/port_pcap.c.obj: \
D:\c_work\start\xnet_tiny_c0101\src\xnet_app\port_pcap.c \
D:/c/mingw64/x86_64-w64-mingw32/include/string.h \
D:/c/mingw64/x86_64-w64-mingw32/include/crtdefs.h \
D:/c/mingw64/x86_64-w64-mingw32/include/_mingw.h \
D:/c/mingw64/x86_64-w64-mingw32/include/_mingw_mac.h \
D:/c/mingw64/x86_64-w64-mingw32/include/_mingw_secapi.h \
D:/c/mingw64/x86_64-w64-mingw32/include/vadefs.h \
D:/c/mingw64/x86_64-w64-mingw32/include/sdks/_mingw_directx.h \
D:/c/mingw64/x86_64-w64-mingw32/include/sdks/_mingw_ddk.h \
D:/c/mingw64/x86_64-w64-mingw32/include/sec_api/string_s.h \
D:/c/mingw64/x86_64-w64-mingw32/include/stdlib.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include-fixed/limits.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include-fixed/syslimits.h \
D:/c/mingw64/x86_64-w64-mingw32/include/limits.h \
D:/c/mingw64/x86_64-w64-mingw32/include/sec_api/stdlib_s.h \
D:/c/mingw64/x86_64-w64-mingw32/include/malloc.h \
D:/c_work/start/lib/xnet/pcap_device.h \
D:/c_work/start/lib/npcap/Include/pcap.h \
D:/c_work/start/lib/npcap/Include/pcap/pcap.h \
D:/c_work/start/lib/npcap/Include/pcap/funcattrs.h \
D:/c_work/start/lib/npcap/Include/pcap/compiler-tests.h \
D:/c_work/start/lib/npcap/Include/pcap/pcap-inttypes.h \
D:/c/mingw64/x86_64-w64-mingw32/include/inttypes.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/stdint.h \
D:/c/mingw64/x86_64-w64-mingw32/include/stdint.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/stddef.h \
D:/c/mingw64/x86_64-w64-mingw32/include/stddef.h \
D:/c/mingw64/x86_64-w64-mingw32/include/_mingw_print_push.h \
D:/c/mingw64/x86_64-w64-mingw32/include/_mingw_print_pop.h \
D:/c/mingw64/x86_64-w64-mingw32/include/winsock2.h \
D:/c/mingw64/x86_64-w64-mingw32/include/_mingw_unicode.h \
D:/c/mingw64/x86_64-w64-mingw32/include/windows.h \
D:/c/mingw64/x86_64-w64-mingw32/include/sdkddkver.h \
D:/c/mingw64/x86_64-w64-mingw32/include/excpt.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/stdarg.h \
D:/c/mingw64/x86_64-w64-mingw32/include/stdarg.h \
D:/c/mingw64/x86_64-w64-mingw32/include/_mingw_stdarg.h \
D:/c/mingw64/x86_64-w64-mingw32/include/windef.h \
D:/c/mingw64/x86_64-w64-mingw32/include/minwindef.h \
D:/c/mingw64/x86_64-w64-mingw32/include/winapifamily.h \
D:/c/mingw64/x86_64-w64-mingw32/include/specstrings.h \
D:/c/mingw64/x86_64-w64-mingw32/include/sal.h \
D:/c/mingw64/x86_64-w64-mingw32/include/driverspecs.h \
D:/c/mingw64/x86_64-w64-mingw32/include/winnt.h \
D:/c/mingw64/x86_64-w64-mingw32/include/ctype.h \
D:/c/mingw64/x86_64-w64-mingw32/include/apiset.h \
D:/c/mingw64/x86_64-w64-mingw32/include/psdk_inc/intrin-impl.h \
D:/c/mingw64/x86_64-w64-mingw32/include/basetsd.h \
D:/c/mingw64/x86_64-w64-mingw32/include/guiddef.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/x86intrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/ia32intrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/mmintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/xmmintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/mm_malloc.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/emmintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/pmmintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/tmmintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/ammintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/smmintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/popcntintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/wmmintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/immintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/avxintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/avx2intrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/avx512fintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/avx512erintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/avx512pfintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/avx512cdintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/avx512vlintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/avx512bwintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/avx512dqintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/avx512vlbwintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/avx512vldqintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/avx512ifmaintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/avx512ifmavlintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/avx512vbmiintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/avx512vbmivlintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/avx5124fmapsintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/avx5124vnniwintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/avx512vpopcntdqintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/avx512vbmi2intrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/avx512vbmi2vlintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/avx512vnniintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/avx512vnnivlintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/avx512vpopcntdqvlintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/avx512bitalgintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/shaintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/lzcntintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/bmiintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/bmi2intrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/fmaintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/f16cintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/rtmintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/xtestintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/cetintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/gfniintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/vaesintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/vpclmulqdqintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/movdirintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/mm3dnow.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/prfchwintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/fma4intrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/xopintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/lwpintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/tbmintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/rdseedintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/fxsrintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/xsaveintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/xsaveoptintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/sgxintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/pconfigintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/adxintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/clwbintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/clflushoptintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/xsavesintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/xsavecintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/mwaitxintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/clzerointrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/wbnoinvdintrin.h \
D:/c/mingw64/lib/gcc/x86_64-w64-mingw32/8.1.0/include/pkuintrin.h \
D:/c/mingw64/x86_64-w64-mingw32/include/pshpack4.h \
D:/c/mingw64/x86_64-w64-mingw32/include/poppack.h \
D:/c/mingw64/x86_64-w64-mingw32/include/pshpack4.h \
D:/c/mingw64/x86_64-w64-mingw32/include/pshpack2.h \
D:/c/mingw64/x86_64-w64-mingw32/include/poppack.h \
D:/c/mingw64/x86_64-w64-mingw32/include/pshpack2.h \
D:/c/mingw64/x86_64-w64-mingw32/include/pshpack8.h \
D:/c/mingw64/x86_64-w64-mingw32/include/pshpack8.h \
D:/c/mingw64/x86_64-w64-mingw32/include/ktmtypes.h \
D:/c/mingw64/x86_64-w64-mingw32/include/winbase.h \
D:/c/mingw64/x86_64-w64-mingw32/include/apisetcconv.h \
D:/c/mingw64/x86_64-w64-mingw32/include/minwinbase.h \
D:/c/mingw64/x86_64-w64-mingw32/include/bemapiset.h \
D:/c/mingw64/x86_64-w64-mingw32/include/debugapi.h \
D:/c/mingw64/x86_64-w64-mingw32/include/errhandlingapi.h \
D:/c/mingw64/x86_64-w64-mingw32/include/fibersapi.h \
D:/c/mingw64/x86_64-w64-mingw32/include/fileapi.h \
D:/c/mingw64/x86_64-w64-mingw32/include/handleapi.h \
D:/c/mingw64/x86_64-w64-mingw32/include/heapapi.h \
D:/c/mingw64/x86_64-w64-mingw32/include/ioapiset.h \
D:/c/mingw64/x86_64-w64-mingw32/include/interlockedapi.h \
D:/c/mingw64/x86_64-w64-mingw32/include/jobapi.h \
D:/c/mingw64/x86_64-w64-mingw32/include/libloaderapi.h \
D:/c/mingw64/x86_64-w64-mingw32/include/memoryapi.h \
D:/c/mingw64/x86_64-w64-mingw32/include/namedpipeapi.h \
D:/c/mingw64/x86_64-w64-mingw32/include/namespaceapi.h \
D:/c/mingw64/x86_64-w64-mingw32/include/processenv.h \
D:/c/mingw64/x86_64-w64-mingw32/include/processthreadsapi.h \
D:/c/mingw64/x86_64-w64-mingw32/include/processtopologyapi.h \
D:/c/mingw64/x86_64-w64-mingw32/include/profileapi.h \
D:/c/mingw64/x86_64-w64-mingw32/include/realtimeapiset.h \
D:/c/mingw64/x86_64-w64-mingw32/include/securityappcontainer.h \
D:/c/mingw64/x86_64-w64-mingw32/include/securitybaseapi.h \
D:/c/mingw64/x86_64-w64-mingw32/include/synchapi.h \
D:/c/mingw64/x86_64-w64-mingw32/include/sysinfoapi.h \
D:/c/mingw64/x86_64-w64-mingw32/include/systemtopologyapi.h \
D:/c/mingw64/x86_64-w64-mingw32/include/threadpoolapiset.h \
D:/c/mingw64/x86_64-w64-mingw32/include/threadpoollegacyapiset.h \
D:/c/mingw64/x86_64-w64-mingw32/include/utilapiset.h \
D:/c/mingw64/x86_64-w64-mingw32/include/wow64apiset.h \
D:/c/mingw64/x86_64-w64-mingw32/include/winerror.h \
D:/c/mingw64/x86_64-w64-mingw32/include/fltwinerror.h \
D:/c/mingw64/x86_64-w64-mingw32/include/timezoneapi.h \
D:/c/mingw64/x86_64-w64-mingw32/include/wingdi.h \
D:/c/mingw64/x86_64-w64-mingw32/include/pshpack1.h \
D:/c/mingw64/x86_64-w64-mingw32/include/winuser.h \
D:/c/mingw64/x86_64-w64-mingw32/include/tvout.h \
D:/c/mingw64/x86_64-w64-mingw32/include/winnls.h \
D:/c/mingw64/x86_64-w64-mingw32/include/datetimeapi.h \
D:/c/mingw64/x86_64-w64-mingw32/include/stringapiset.h \
D:/c/mingw64/x86_64-w64-mingw32/include/wincon.h \
D:/c/mingw64/x86_64-w64-mingw32/include/winver.h \
D:/c/mingw64/x86_64-w64-mingw32/include/winreg.h \
D:/c/mingw64/x86_64-w64-mingw32/include/reason.h \
D:/c/mingw64/x86_64-w64-mingw32/include/winnetwk.h \
D:/c/mingw64/x86_64-w64-mingw32/include/wnnc.h \
D:/c/mingw64/x86_64-w64-mingw32/include/virtdisk.h \
D:/c/mingw64/x86_64-w64-mingw32/include/cderr.h \
D:/c/mingw64/x86_64-w64-mingw32/include/dde.h \
D:/c/mingw64/x86_64-w64-mingw32/include/ddeml.h \
D:/c/mingw64/x86_64-w64-mingw32/include/dlgs.h \
D:/c/mingw64/x86_64-w64-mingw32/include/lzexpand.h \
D:/c/mingw64/x86_64-w64-mingw32/include/mmsystem.h \
D:/c/mingw64/x86_64-w64-mingw32/include/nb30.h \
D:/c/mingw64/x86_64-w64-mingw32/include/rpc.h \
D:/c/mingw64/x86_64-w64-mingw32/include/rpcdce.h \
D:/c/mingw64/x86_64-w64-mingw32/include/rpcdcep.h \
D:/c/mingw64/x86_64-w64-mingw32/include/rpcnsi.h \
D:/c/mingw64/x86_64-w64-mingw32/include/rpcnterr.h \
D:/c/mingw64/x86_64-w64-mingw32/include/rpcasync.h \
D:/c/mingw64/x86_64-w64-mingw32/include/shellapi.h \
D:/c/mingw64/x86_64-w64-mingw32/include/winperf.h \
D:/c/mingw64/x86_64-w64-mingw32/include/winsock.h \
D:/c/mingw64/x86_64-w64-mingw32/include/wincrypt.h \
D:/c/mingw64/x86_64-w64-mingw32/include/bcrypt.h \
D:/c/mingw64/x86_64-w64-mingw32/include/ncrypt.h \
D:/c/mingw64/x86_64-w64-mingw32/include/dpapi.h \
D:/c/mingw64/x86_64-w64-mingw32/include/winefs.h \
D:/c/mingw64/x86_64-w64-mingw32/include/winscard.h \
D:/c/mingw64/x86_64-w64-mingw32/include/wtypes.h \
D:/c/mingw64/x86_64-w64-mingw32/include/rpcndr.h \
D:/c/mingw64/x86_64-w64-mingw32/include/rpcnsip.h \
D:/c/mingw64/x86_64-w64-mingw32/include/rpcsal.h \
D:/c/mingw64/x86_64-w64-mingw32/include/ole2.h \
D:/c/mingw64/x86_64-w64-mingw32/include/objbase.h \
D:/c/mingw64/x86_64-w64-mingw32/include/combaseapi.h \
D:/c/mingw64/x86_64-w64-mingw32/include/wtypesbase.h \
D:/c/mingw64/x86_64-w64-mingw32/include/unknwnbase.h \
D:/c/mingw64/x86_64-w64-mingw32/include/objidlbase.h \
D:/c/mingw64/x86_64-w64-mingw32/include/cguid.h \
D:/c/mingw64/x86_64-w64-mingw32/include/objidl.h \
D:/c/mingw64/x86_64-w64-mingw32/include/unknwn.h \
D:/c/mingw64/x86_64-w64-mingw32/include/urlmon.h \
D:/c/mingw64/x86_64-w64-mingw32/include/oleidl.h \
D:/c/mingw64/x86_64-w64-mingw32/include/servprov.h \
D:/c/mingw64/x86_64-w64-mingw32/include/msxml.h \
D:/c/mingw64/x86_64-w64-mingw32/include/oaidl.h \
D:/c/mingw64/x86_64-w64-mingw32/include/propidl.h \
D:/c/mingw64/x86_64-w64-mingw32/include/oleauto.h \
D:/c/mingw64/x86_64-w64-mingw32/include/winioctl.h \
D:/c/mingw64/x86_64-w64-mingw32/include/winsmcrd.h \
D:/c/mingw64/x86_64-w64-mingw32/include/winspool.h \
D:/c/mingw64/x86_64-w64-mingw32/include/prsht.h \
D:/c/mingw64/x86_64-w64-mingw32/include/commdlg.h \
D:/c/mingw64/x86_64-w64-mingw32/include/stralign.h \
D:/c/mingw64/x86_64-w64-mingw32/include/sec_api/stralign_s.h \
D:/c/mingw64/x86_64-w64-mingw32/include/winsvc.h \
D:/c/mingw64/x86_64-w64-mingw32/include/mcx.h \
D:/c/mingw64/x86_64-w64-mingw32/include/imm.h \
D:/c/mingw64/x86_64-w64-mingw32/include/psdk_inc/_ws1_undef.h \
D:/c/mingw64/x86_64-w64-mingw32/include/_timeval.h \
D:/c/mingw64/x86_64-w64-mingw32/include/_bsd_types.h \
D:/c/mingw64/x86_64-w64-mingw32/include/inaddr.h \
D:/c/mingw64/x86_64-w64-mingw32/include/psdk_inc/_socket_types.h \
D:/c/mingw64/x86_64-w64-mingw32/include/psdk_inc/_fd_types.h \
D:/c/mingw64/x86_64-w64-mingw32/include/psdk_inc/_ip_types.h \
D:/c/mingw64/x86_64-w64-mingw32/include/psdk_inc/_wsadata.h \
D:/c/mingw64/x86_64-w64-mingw32/include/ws2def.h \
D:/c/mingw64/x86_64-w64-mingw32/include/psdk_inc/_wsa_errnos.h \
D:/c/mingw64/x86_64-w64-mingw32/include/qos.h \
D:/c/mingw64/x86_64-w64-mingw32/include/io.h \
D:/c/mingw64/x86_64-w64-mingw32/include/_mingw_off_t.h \
D:/c_work/start/lib/npcap/Include/pcap/socket.h \
D:/c/mingw64/x86_64-w64-mingw32/include/ws2tcpip.h \
D:/c/mingw64/x86_64-w64-mingw32/include/ws2ipdef.h \
D:/c/mingw64/x86_64-w64-mingw32/include/in6addr.h \
D:/c/mingw64/x86_64-w64-mingw32/include/psdk_inc/_ip_mreq1.h \
D:/c/mingw64/x86_64-w64-mingw32/include/mstcpip.h \
D:/c_work/start/lib/npcap/Include/pcap/bpf.h \
D:/c_work/start/lib/npcap/Include/pcap/dlt.h \
D:/c/mingw64/x86_64-w64-mingw32/include/stdio.h \
D:/c/mingw64/x86_64-w64-mingw32/include/swprintf.inl \
D:/c/mingw64/x86_64-w64-mingw32/include/sec_api/stdio_s.h \
D:/c_work/start/xnet_tiny_c0101/src/xnet_tiny/xnet_tiny.h

View File

@ -0,0 +1,5 @@
CMAKE_PROGRESS_1 = 4
CMAKE_PROGRESS_2 = 5
CMAKE_PROGRESS_3 = 6
CMAKE_PROGRESS_4 = 7

View File

@ -0,0 +1,2 @@
src/xnet_app/CMakeFiles/xnet_app.dir/xserver_datetime.c.obj: \
D:\c_work\start\xnet_tiny_c0101\src\xnet_app\xserver_datetime.c

View File

@ -0,0 +1,2 @@
src/xnet_app/CMakeFiles/xnet_app.dir/xserver_http.c.obj: \
D:\c_work\start\xnet_tiny_c0101\src\xnet_app\xserver_http.c

View File

@ -0,0 +1,235 @@
# CMAKE generated file: DO NOT EDIT!
# Generated by "MinGW Makefiles" Generator, CMake Version 3.30
# Default target executed when no arguments are given to make.
default_target: all
.PHONY : default_target
# Allow only one "make -f Makefile2" at a time, but pass parallelism.
.NOTPARALLEL:
#=============================================================================
# Special targets provided by cmake.
# Disable implicit rules so canonical targets will work.
.SUFFIXES:
# Disable VCS-based implicit rules.
% : %,v
# Disable VCS-based implicit rules.
% : RCS/%
# Disable VCS-based implicit rules.
% : RCS/%,v
# Disable VCS-based implicit rules.
% : SCCS/s.%
# Disable VCS-based implicit rules.
% : s.%
.SUFFIXES: .hpux_make_needs_suffix_list
# Command-line flag to silence nested $(MAKE).
$(VERBOSE)MAKESILENT = -s
#Suppress display of executed commands.
$(VERBOSE).SILENT:
# A target that is always out of date.
cmake_force:
.PHONY : cmake_force
#=============================================================================
# Set environment variables for the build.
SHELL = cmd.exe
# The CMake executable.
CMAKE_COMMAND = D:\cmake\bin\cmake.exe
# The command to remove a file.
RM = D:\cmake\bin\cmake.exe -E rm -f
# Escaping for special characters.
EQUALS = =
# The top-level source directory on which CMake was run.
CMAKE_SOURCE_DIR = D:\c_work\start\xnet_tiny_c0101
# The top-level build directory on which CMake was run.
CMAKE_BINARY_DIR = D:\c_work\start\build
#=============================================================================
# Targets provided globally by CMake.
# Special rule for the target edit_cache
edit_cache:
@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Running CMake cache editor..."
D:\cmake\bin\cmake-gui.exe -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR)
.PHONY : edit_cache
# Special rule for the target edit_cache
edit_cache/fast: edit_cache
.PHONY : edit_cache/fast
# Special rule for the target rebuild_cache
rebuild_cache:
@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Running CMake to regenerate build system..."
D:\cmake\bin\cmake.exe --regenerate-during-build -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR)
.PHONY : rebuild_cache
# Special rule for the target rebuild_cache
rebuild_cache/fast: rebuild_cache
.PHONY : rebuild_cache/fast
# The main all target
all: cmake_check_build_system
cd /d D:\c_work\start\build && $(CMAKE_COMMAND) -E cmake_progress_start D:\c_work\start\build\CMakeFiles D:\c_work\start\build\src\xnet_app\\CMakeFiles\progress.marks
cd /d D:\c_work\start\build && $(MAKE) $(MAKESILENT) -f CMakeFiles\Makefile2 src/xnet_app/all
$(CMAKE_COMMAND) -E cmake_progress_start D:\c_work\start\build\CMakeFiles 0
.PHONY : all
# The main clean target
clean:
cd /d D:\c_work\start\build && $(MAKE) $(MAKESILENT) -f CMakeFiles\Makefile2 src/xnet_app/clean
.PHONY : clean
# The main clean target
clean/fast: clean
.PHONY : clean/fast
# Prepare targets for installation.
preinstall: all
cd /d D:\c_work\start\build && $(MAKE) $(MAKESILENT) -f CMakeFiles\Makefile2 src/xnet_app/preinstall
.PHONY : preinstall
# Prepare targets for installation.
preinstall/fast:
cd /d D:\c_work\start\build && $(MAKE) $(MAKESILENT) -f CMakeFiles\Makefile2 src/xnet_app/preinstall
.PHONY : preinstall/fast
# clear depends
depend:
cd /d D:\c_work\start\build && $(CMAKE_COMMAND) -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) --check-build-system CMakeFiles\Makefile.cmake 1
.PHONY : depend
# Convenience name for target.
src/xnet_app/CMakeFiles/xnet_app.dir/rule:
cd /d D:\c_work\start\build && $(MAKE) $(MAKESILENT) -f CMakeFiles\Makefile2 src/xnet_app/CMakeFiles/xnet_app.dir/rule
.PHONY : src/xnet_app/CMakeFiles/xnet_app.dir/rule
# Convenience name for target.
xnet_app: src/xnet_app/CMakeFiles/xnet_app.dir/rule
.PHONY : xnet_app
# fast build rule for target.
xnet_app/fast:
cd /d D:\c_work\start\build && $(MAKE) $(MAKESILENT) -f src\xnet_app\CMakeFiles\xnet_app.dir\build.make src/xnet_app/CMakeFiles/xnet_app.dir/build
.PHONY : xnet_app/fast
port_pcap.obj: port_pcap.c.obj
.PHONY : port_pcap.obj
# target to build an object file
port_pcap.c.obj:
cd /d D:\c_work\start\build && $(MAKE) $(MAKESILENT) -f src\xnet_app\CMakeFiles\xnet_app.dir\build.make src/xnet_app/CMakeFiles/xnet_app.dir/port_pcap.c.obj
.PHONY : port_pcap.c.obj
port_pcap.i: port_pcap.c.i
.PHONY : port_pcap.i
# target to preprocess a source file
port_pcap.c.i:
cd /d D:\c_work\start\build && $(MAKE) $(MAKESILENT) -f src\xnet_app\CMakeFiles\xnet_app.dir\build.make src/xnet_app/CMakeFiles/xnet_app.dir/port_pcap.c.i
.PHONY : port_pcap.c.i
port_pcap.s: port_pcap.c.s
.PHONY : port_pcap.s
# target to generate assembly for a file
port_pcap.c.s:
cd /d D:\c_work\start\build && $(MAKE) $(MAKESILENT) -f src\xnet_app\CMakeFiles\xnet_app.dir\build.make src/xnet_app/CMakeFiles/xnet_app.dir/port_pcap.c.s
.PHONY : port_pcap.c.s
xserver_datetime.obj: xserver_datetime.c.obj
.PHONY : xserver_datetime.obj
# target to build an object file
xserver_datetime.c.obj:
cd /d D:\c_work\start\build && $(MAKE) $(MAKESILENT) -f src\xnet_app\CMakeFiles\xnet_app.dir\build.make src/xnet_app/CMakeFiles/xnet_app.dir/xserver_datetime.c.obj
.PHONY : xserver_datetime.c.obj
xserver_datetime.i: xserver_datetime.c.i
.PHONY : xserver_datetime.i
# target to preprocess a source file
xserver_datetime.c.i:
cd /d D:\c_work\start\build && $(MAKE) $(MAKESILENT) -f src\xnet_app\CMakeFiles\xnet_app.dir\build.make src/xnet_app/CMakeFiles/xnet_app.dir/xserver_datetime.c.i
.PHONY : xserver_datetime.c.i
xserver_datetime.s: xserver_datetime.c.s
.PHONY : xserver_datetime.s
# target to generate assembly for a file
xserver_datetime.c.s:
cd /d D:\c_work\start\build && $(MAKE) $(MAKESILENT) -f src\xnet_app\CMakeFiles\xnet_app.dir\build.make src/xnet_app/CMakeFiles/xnet_app.dir/xserver_datetime.c.s
.PHONY : xserver_datetime.c.s
xserver_http.obj: xserver_http.c.obj
.PHONY : xserver_http.obj
# target to build an object file
xserver_http.c.obj:
cd /d D:\c_work\start\build && $(MAKE) $(MAKESILENT) -f src\xnet_app\CMakeFiles\xnet_app.dir\build.make src/xnet_app/CMakeFiles/xnet_app.dir/xserver_http.c.obj
.PHONY : xserver_http.c.obj
xserver_http.i: xserver_http.c.i
.PHONY : xserver_http.i
# target to preprocess a source file
xserver_http.c.i:
cd /d D:\c_work\start\build && $(MAKE) $(MAKESILENT) -f src\xnet_app\CMakeFiles\xnet_app.dir\build.make src/xnet_app/CMakeFiles/xnet_app.dir/xserver_http.c.i
.PHONY : xserver_http.c.i
xserver_http.s: xserver_http.c.s
.PHONY : xserver_http.s
# target to generate assembly for a file
xserver_http.c.s:
cd /d D:\c_work\start\build && $(MAKE) $(MAKESILENT) -f src\xnet_app\CMakeFiles\xnet_app.dir\build.make src/xnet_app/CMakeFiles/xnet_app.dir/xserver_http.c.s
.PHONY : xserver_http.c.s
# Help Target
help:
@echo The following are some of the valid targets for this Makefile:
@echo ... all (the default if no target is provided)
@echo ... clean
@echo ... depend
@echo ... edit_cache
@echo ... rebuild_cache
@echo ... xnet_app
@echo ... port_pcap.obj
@echo ... port_pcap.i
@echo ... port_pcap.s
@echo ... xserver_datetime.obj
@echo ... xserver_datetime.i
@echo ... xserver_datetime.s
@echo ... xserver_http.obj
@echo ... xserver_http.i
@echo ... xserver_http.s
.PHONY : help
#=============================================================================
# Special targets to cleanup operation of make.
# Special rule to run CMake to check the build system integrity.
# No rule that depends on this can have commands that come from listfiles
# because they might be regenerated.
cmake_check_build_system:
cd /d D:\c_work\start\build && $(CMAKE_COMMAND) -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) --check-build-system CMakeFiles\Makefile.cmake 0
.PHONY : cmake_check_build_system

View File

@ -0,0 +1,39 @@
# Install script for directory: D:/c_work/start/xnet_tiny_c0101/src/xnet_app
# Set the install prefix
if(NOT DEFINED CMAKE_INSTALL_PREFIX)
set(CMAKE_INSTALL_PREFIX "C:/Program Files (x86)/xnet")
endif()
string(REGEX REPLACE "/$" "" CMAKE_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}")
# Set the install configuration name.
if(NOT DEFINED CMAKE_INSTALL_CONFIG_NAME)
if(BUILD_TYPE)
string(REGEX REPLACE "^[^A-Za-z0-9_]+" ""
CMAKE_INSTALL_CONFIG_NAME "${BUILD_TYPE}")
else()
set(CMAKE_INSTALL_CONFIG_NAME "Debug")
endif()
message(STATUS "Install configuration: \"${CMAKE_INSTALL_CONFIG_NAME}\"")
endif()
# Set the component getting installed.
if(NOT CMAKE_INSTALL_COMPONENT)
if(COMPONENT)
message(STATUS "Install component: \"${COMPONENT}\"")
set(CMAKE_INSTALL_COMPONENT "${COMPONENT}")
else()
set(CMAKE_INSTALL_COMPONENT)
endif()
endif()
# Is this installation the result of a crosscompile?
if(NOT DEFINED CMAKE_CROSSCOMPILING)
set(CMAKE_CROSSCOMPILING "FALSE")
endif()
# Set path to fallback-tool for dependency-resolution.
if(NOT DEFINED CMAKE_OBJDUMP)
set(CMAKE_OBJDUMP "D:/c/mingw64/bin/objdump.exe")
endif()

Some files were not shown because too many files have changed in this diff Show More