《30天自制操作系统》学习笔记（七）

news2024/12/24 21:00:58

先体验一下编译仿真方法：

30天自制操作系统光盘代码在下面链接，但是没有编译仿真工具：
https://gitee.com/zhanfei3000/30dayMakeOS

仿真工具在下面链接：
https://gitee.com/909854136/nask-code-ide

这是一个集成的编译仿真工具，只需要把上面仿真工具的文件夹：
\nask-code-ide-master\crtools
在这里插入图片描述
复制到源码文件加下，并改名为z_tools就可以按照书中的方法编译仿真了：
\30dayMakeOS-master\z_tools
z_tools如下：
在这里插入图片描述
在代码30dayMakeOS-master\01_day目录下执行下面编译仿真指令就可以看到仿真出的操作系统了。
在这里插入图片描述
在这里插入图片描述
后面章节源码写了 makefile就简单了，只要输入make就可以编辑了 然后再输入make run就可以仿真了

标题一、代码执行顺序（前内容六天的内容）

ipl10.nas–>asmhead.nas–>boopack.c

标题二、代码阅读

1.ipl10.nas（将软盘内容拷贝到内存中）

; haribote-ipl
; TAB=4
; 读取软盘内容到内存中，然后跳转到0xc200开始执行，就是asmhead.nas文件
CYLS	EQU		10				; CYLS=10 读取是10个柱面

		ORG		0x7c00			; 指明程序装载地址

; 以下这段是FAT12格式软盘专用代码  0x7c00--0x7dff 
		JMP        entry
        DB        0x90
        DB        "HARIBOTE"         ; 启动区的名字可以是任意的，但必须是8字节
        DW        512                ; 每个扇区(sector)的大小必须为512字节
        DB        1                  ; 簇(cluster)的大小必须为1个扇区
        DW        1                  ; FAT的起始位置(一般从第一个扇区开始)
        DB        2                  ; FAT的个数(必须为2)
        DW        224                ; 根目录的大小(一般设为244项)
        DW        2880               ; 该磁盘的的大小(必须为2880扇区)
        DB        0xf0               ; 磁盘的种类(必须为0xfd)
        DW        9                  ; FAT的长度(必须为9扇区)
        DW        18                 ; 一个磁道(track)有几个扇区(必须为18)
        DW        2                  ; 磁头数(必须为2)
        DD        0                  ; 不使用分区(必须为0)
        DD        2880               ; 重写一次磁盘大小
        DB        0,0,0x29           ; 意义不明，固定
        DD        0xffffffff         ; (可能是)卷标号码
        DB        "HARIBOTEOS "      ; 磁盘名称(11字节)
        DB        "FAT12   "         ; 磁盘格式名称(8字节)
        RESB    18                   ; 先腾出18字节

; 程序核心

entry:
		MOV		AX,0			; AX=0 初始化寄存器
		MOV		SS,AX			; SS=AX=0
		MOV		SP,0x7c00		; SP=0x7c00
		MOV		DS,AX			; DS=AX=0

; 读磁盘(从软盘中读数据装到内存中0x8200--0x83ff  

		MOV		AX,0x0820		; AX=0x0820 设置缓存区的段地址
		MOV		ES,AX			; ES=AX=0x0820 ES:BX就是缓存区的地址
		MOV		CH,0			; CH=0 CH表示柱面号
		MOV		DH,0			; DH=0 DH表示磁头号
		MOV		CL,2			; CL=2 CL表示扇区号
readloop:
		MOV		SI,0			; SI=0, 用于记录错误次数，实现试错功能（非必须功能）
retry:
		MOV		AH,0x02			; AH=0x02 13号中断所需参数，表示操作类型，0x02（读盘），0x03写盘，0x04校验，0x0c寻道
		MOV		AL,1			; AL=1 AL处理对象的扇区数，表示一次只能读取1个扇区
		MOV		BX,0			; BX=0 缓冲地址
		MOV		DL,0x00			; DL=0x00 DL表示驱动器号
		INT		0x13			; BIOS提供的服务，用于操作软盘
		JNC		next			; CF=0，跳转到next执行
		ADD		SI,1			; SI=SI+1，记录尝试的次数，实现试错功能（非必须功能）
		CMP		SI,5			; 
		JAE		error			; SI >= 5 跳转到error执行
		MOV		AH,0x00			; SI<5 AH=0x00 清空INT 0x13的错误码
		MOV		DL,0x00			; DL=0x00 设置驱动器号
		INT		0x13			; 
		JMP		retry			; 跳转到retry执行
next:
		MOV		AX,ES			; AX=ES
		ADD		AX,0x0020		; AX=AX+0x0020
		MOV		ES,AX			; ES=AX ES向后移动了一个扇区的大小
		ADD		CL,1			; CL=CL+1 扇区号加1
		CMP		CL,18			; 
		JBE		readloop		; CL <= 18 跳转到readloop执行
		MOV		CL,1			; CL > 18 CL=1 
		ADD		DH,1			; DH=1 准备读取磁头0的内容
		CMP		DH,2			; 
		JB		readloop		; DH < 2 跳转到readloop执行
		MOV		DH,0			; DH>=2 说明已读取完成
		ADD		CH,1			; CH=CH+1 准备读取下一个柱面
		CMP		CH,CYLS			; 
		JB		readloop		; CH < CYLS 跳转到readloop执行

; 磁盘内容装载内容的结束地址告诉haribote.sys

		MOV		[0x0ff0],CH		; [0x0ff0]=CH 将CYLS的值写入到内存地址0x0ff0中，可以参考asmhead.nas中对应的变量赋值
		JMP		0xc200			; 跳转到0xc200

error:
		MOV		SI,msg			;SI=msg 显示错误信息
putloop:
		MOV		AL,[SI]			; AL=[SI] 读取[SI]内存中的信息
		ADD		SI,1			; SI=SI+1
		CMP		AL,0			; 
		JE		fin				; AL==0, 错误信息显示完毕，跳转到fin
		MOV		AH,0x0e			; AH=0x0e 设置显示属性
		MOV		BX,15			; BX=15 设置显示属性
		INT		0x10			; 调用BIOS显示服务
		JMP		putloop			; 
fin:
		HLT						; 让CPU停止等待命令
		JMP		fin				; 
msg:
		DB		0x0a, 0x0a		; 
		DB		"load error"
		DB		0x0a			; 
		DB		0				; 

		RESB	0x7dfe-$		; 

		DB		0x55, 0xaa		; 按规定设置字节

2.asmhead.nas(完成一些不能用c语言实现的功能，因为编码问题，有一些乱码，大概能看明白)

; haribote-os boot asm
; TAB=4

[INSTRSET "i486p"]

VBEMODE	EQU		0x105			; 1024 x  768 x 8bit 彩色
; 显示模式
;	0x100 :  640 x  400 x 8bit 彩色
;	0x101 :  640 x  480 x 8bit 彩色
;	0x103 :  800 x  600 x 8bit 彩色
;	0x105 : 1024 x  768 x 8bit 彩色
;	0x107 : 1280 x 1024 x 8bit 彩色

BOTPAK	EQU		0x00280000		; 加载bootpack
DSKCAC	EQU		0x00100000		; 磁盘缓存的位置
DSKCAC0	EQU		0x00008000		; 磁盘缓存的位置（实模式）

; BOOT_INFO 相关
CYLS	EQU		0x0ff0			; 引导扇区设置
LEDS	EQU		0x0ff1
VMODE	EQU		0x0ff2			; 关于颜色的信息
SCRNX	EQU		0x0ff4			; 分辨率X
SCRNY	EQU		0x0ff6			; 分辨率Y
VRAM	EQU		0x0ff8			; 图像缓冲区的起始地址

		ORG		0xc200			;  这个的程序要被装载的内存地址

; 确认VBE是否存在

		MOV		AX,0x9000
		MOV		ES,AX
		MOV		DI,0
		MOV		AX,0x4f00
		INT		0x10
		CMP		AX,0x004f
		JNE		scrn320

; 检查VBE的版本

		MOV		AX,[ES:DI+4]
		CMP		AX,0x0200
		JB		scrn320			; if (AX < 0x0200) goto scrn320

; 取得画面模式信息

		MOV		CX,VBEMODE
		MOV		AX,0x4f01
		INT		0x10
		CMP		AX,0x004f
		JNE		scrn320

; 画面模式信息的确认
		CMP		BYTE [ES:DI+0x19],8		;颜色数必须为8
		JNE		scrn320
		CMP		BYTE [ES:DI+0x1b],4		;颜色的指定方法必须为4(4是调色板模式)
		JNE		scrn320
		MOV		AX,[ES:DI+0x00]				;模式属性bit7不是1就不能加上0x4000
		AND		AX,0x0080
		JZ		scrn320					; 模式属性的bit7是0，所以放弃

;	画面设置

		MOV		BX,VBEMODE+0x4000
		MOV		AX,0x4f02
		INT		0x10
		MOV		BYTE [VMODE],8	; 屏幕的模式（参考C语言的引用）
		MOV		AX,[ES:DI+0x12]
		MOV		[SCRNX],AX
		MOV		AX,[ES:DI+0x14]
		MOV		[SCRNY],AX
		MOV		EAX,[ES:DI+0x28] ;VRAM的地址
		MOV		[VRAM],EAX
		JMP		keystatus

scrn320:
		MOV		AL,0x13						; VGA图、320x200x8bit彩色
		MOV		AH,0x00
		INT		0x10
		MOV		BYTE [VMODE],8		; 记下画面模式（参考C语言）
		MOV		WORD [SCRNX],320
		MOV		WORD [SCRNY],200
		MOV		DWORD [VRAM],0x000a0000

;	通过 BIOS 获取指示灯状态

keystatus:
		MOV		AH,0x02
		INT		0x16 			; keyboard BIOS
		MOV		[LEDS],AL

;	PIC关闭一切中断
;	根据AT兼容机的规格，如果要初始化PIC，
;	必须在CLI之前进行，否则有时会挂起。
;	随后进行PIC的初始化。

		MOV		AL,0xff
		OUT		0x21,AL
		NOP						; 如果连续执行OUT指令，有些机种会无法正常运行
		OUT		0xa1,AL

		CLI						; 禁止CPU级别的中断

;	为了让CPU能够访问1MB以上的内存空间，设定A20GATE

		CALL	waitkbdout
		MOV		AL,0xd1
		OUT		0x64,AL
		CALL	waitkbdout
		MOV		AL,0xdf			; enable A20
		OUT		0x60,AL
		CALL	waitkbdout

;	切换到保护模式

[INSTRSET "i486p"]				; 说明使用486指令

		LGDT	[GDTR0]			; 设置临时GDT
		MOV		EAX,CR0
		AND		EAX,0x7fffffff	; 设bit31为0（禁用分页）
		OR		EAX,0x00000001	; bit0到1转换（保护模式过渡）
		MOV		CR0,EAX
		JMP		pipelineflush
pipelineflush:
		MOV		AX,1*8			;  可读写的段 32bit
		MOV		DS,AX
		MOV		ES,AX
		MOV		FS,AX
		MOV		GS,AX
		MOV		SS,AX

; bootpack传递

		MOV		ESI,bootpack	; 转送源
		MOV		EDI,BOTPAK		; 转送目标
		MOV		ECX,512*1024/4
		CALL	memcpy

; 磁盘数据最终转送到它本来的位置去
; 首先从启动扇区开始

		MOV		ESI,0x7c00		; 转送源
		MOV		EDI,DSKCAC		; 转送目标
		MOV		ECX,512/4
		CALL	memcpy

; 剩余的全部

		MOV		ESI,DSKCAC0+512	; 转送源
		MOV		EDI,DSKCAC+512	; 转送源目标
		MOV		ECX,0
		MOV		CL,BYTE [CYLS]
		IMUL	ECX,512*18*2/4	; 从柱面数变换为字节数/4
		SUB		ECX,512/4		; 减去 IPL 偏移量
		CALL	memcpy

; 必须由asmhead来完成的工作，至此全部完毕
; 以后就交由bootpack来完成

; bootpack启动

		MOV		EBX,BOTPAK
		MOV		ECX,[EBX+16]
		ADD		ECX,3			; ECX += 3;
		SHR		ECX,2			; ECX /= 4;
		JZ		skip			; 没有要转送的东西时
		MOV		ESI,[EBX+20]	; 转送源
		ADD		ESI,EBX
		MOV		EDI,[EBX+12]	; 转送目标
		CALL	memcpy
skip:
		MOV		ESP,[EBX+12]	; 堆栈的初始化
		JMP		DWORD 2*8:0x0000001b

waitkbdout:
		IN		 AL,0x64
		AND		 AL,0x02
		JNZ		waitkbdout	; AND的结果如果不是0，就跳到waitkbdout
		RET

memcpy:
		MOV		EAX,[ESI]
		ADD		ESI,4
		MOV		[EDI],EAX
		ADD		EDI,4
		SUB		ECX,1
		JNZ		memcpy			; 减法运算的结果如果不是0，就跳转到memcpy
		RET
; memcpy地址前缀大小

		ALIGNB	16
GDT0:
		RESB	8				; 初始值
		DW		0xffff,0x0000,0x9200,0x00cf	; 可以读写的段（segment）32bit
		DW		0xffff,0x0000,0x9a28,0x0047	; 可执行的文件的32bit寄存器（bootpack用）

		DW		0
GDTR0:
		DW		8*3-1
		DD		GDT0

		ALIGNB	16
bootpack:

3.bookpack.c(主函数文件，完成初始化等操作)

#include "bootpack.h"
#include <stdio.h>
 
//该结构体用于控制鼠标
struct MOUSE_DEC {
	unsigned char buf[3], phase;	
	int x, y, btn;		
};
 
extern struct FIFO8 keyfifo, mousefifo;	//外部变量，定义在fifo.c文件中
void enable_mouse(struct MOUSE_DEC *mdec);	//启动鼠标的函数
void init_keyboard(void);	//初始化键盘
int mouse_decode(struct MOUSE_DEC *mdec, unsigned char dat);	//处理鼠标信息
 
void HariMain(void)	//主函数
{
	struct BOOTINFO *binfo = (struct BOOTINFO *) ADR_BOOTINFO;	//启动信息数据结构
	char s[40], mcursor[256], keybuf[32], mousebuf[128];	
	int mx, my, i;
	struct MOUSE_DEC mdec;
 
	init_gdtidt();	//初始化gdt.idt
	init_pic();		//初始化pic
	io_sti(); 	//执行STI指令
	fifo8_init(&keyfifo, 32, keybuf);	//初始化键盘缓存区	
	fifo8_init(&mousefifo, 128, mousebuf);	//初始化鼠标缓存区
	io_out8(PIC0_IMR, 0xf9); //设置中断
	io_out8(PIC1_IMR, 0xef); //因为键盘中断是IRQ1，鼠标中断时IRQ12,所以需要打开主从电路上的对应管脚
 
	init_keyboard();	//初始化键盘
 
	init_palette();	//初始化调色板
	init_screen8(binfo->vram, binfo->scrnx, binfo->scrny);	//初始化屏幕，形成最初的窗口界面
	//获取画面中央的坐标
	mx = (binfo->scrnx - 16) / 2; 
	my = (binfo->scrny - 28 - 16) / 2;
	init_mouse_cursor8(mcursor, COL8_008484);	//鼠标光标的显示
	putblock8_8(binfo->vram, binfo->scrnx, 16, 16, mx, my, mcursor, 16);	
	sprintf(s, "(%3d, %3d)", mx, my);	//将鼠标位置转换成字符串
	putfonts8_asc(binfo->vram, binfo->scrnx, 0, 0, COL8_FFFFFF, s);	//显示字符串，这个函数的位置在哪里?
 
	enable_mouse(&mdec);	//启动鼠标
	for (;;) {	
		io_cli();	//关闭中断	
		//如果键盘缓冲区和鼠标缓冲区中都没有数据
		if (fifo8_status(&keyfifo) + fifo8_status(&mousefifo) == 0) {
			io_stihlt();	//打开中断并执行hlt命令
		} else {
			//如果键盘缓存区中有数据
			if (fifo8_status(&keyfifo) != 0) {
				i = fifo8_get(&keyfifo);	//从缓存区中读取数据(FIFO)
				sprintf(s, "%02X", i);	//将数据已字符串形式输出
				boxfill8(binfo->vram, binfo->scrnx, COL8_008484,  0, 16, 15, 31);
				putfonts8_asc(binfo->vram, binfo->scrnx, 0, 16, COL8_FFFFFF, s);	
			} else if (fifo8_status(&mousefifo) != 0) {	//如果鼠标缓存区中有函数(鼠标和键盘的数据是怎么存入到对应缓存区的?)
				i = fifo8_get(&mousefifo);		//从缓存区中读取数据
				io_sti();	//打开中断
				if (mouse_decode(&mdec, i) != 0) {	//对鼠标信息进行处理
					sprintf(s, "[lcr %4d %4d]", mdec.x, mdec.y);	
					if ((mdec.btn & 0x01) != 0) {	
						s[1] = 'L';
					}
					if ((mdec.btn & 0x02) != 0) {
						s[3] = 'R';
					}
					if ((mdec.btn & 0x04) != 0) {
						s[2] = 'C';
					}
					boxfill8(binfo->vram, binfo->scrnx, COL8_008484, 32, 16, 32 + 15 * 8 - 1, 31);
					putfonts8_asc(binfo->vram, binfo->scrnx, 32, 16, COL8_FFFFFF, s);
					boxfill8(binfo->vram, binfo->scrnx, COL8_008484, mx, my, mx + 15, my + 15); 
					mx += mdec.x;
					my += mdec.y;
					if (mx < 0) {
						mx = 0;
					}
					if (my < 0) {
						my = 0;
					}
					if (mx > binfo->scrnx - 16) {
						mx = binfo->scrnx - 16;
					}
					if (my > binfo->scrny - 16) {
						my = binfo->scrny - 16;
					}
					sprintf(s, "(%3d, %3d)", mx, my);
					boxfill8(binfo->vram, binfo->scrnx, COL8_008484, 0, 0, 79, 15);
					putfonts8_asc(binfo->vram, binfo->scrnx, 0, 0, COL8_FFFFFF, s);
					putblock8_8(binfo->vram, binfo->scrnx, 16, 16, mx, my, mcursor, 16); 
				}
			}
		}
	}
}
 
#define PORT_KEYDAT				0x0060
#define PORT_KEYSTA				0x0064
#define PORT_KEYCMD				0x0064
#define KEYSTA_SEND_NOTREADY	0x02
#define KEYCMD_WRITE_MODE		0x60
#define KBC_MODE				0x47
 
//功能:等待键盘控制电路准备完毕
//如果键盘控制电路可以接受CPU指令，CPU从设备号码0x0064处所读取的数据倒数第二位应该是0，否则就是一直循环等待
void wait_KBC_sendready(void)
{
	for (;;) {
		if ((io_in8(PORT_KEYSTA) & KEYSTA_SEND_NOTREADY) == 0) {	//判断第二位的情况
			break;
		}
	}
	return;
}
 
//功能:初始化键盘
void init_keyboard(void)
{
	wait_KBC_sendready();	
	io_out8(PORT_KEYCMD, KEYCMD_WRITE_MODE);
	wait_KBC_sendready();	
	io_out8(PORT_KEYDAT, KBC_MODE);	
	return;
}
 
#define KEYCMD_SENDTO_MOUSE		0xd4
#define MOUSECMD_ENABLE			0xf4
 
//功能:启用鼠标
void enable_mouse(struct MOUSE_DEC *mdec)
{
	wait_KBC_sendready();	
	io_out8(PORT_KEYCMD, KEYCMD_SENDTO_MOUSE);	
	wait_KBC_sendready();
	io_out8(PORT_KEYDAT, MOUSECMD_ENABLE);
	mdec->phase = 0;
	return;
}
 
//处理鼠标信息
int mouse_decode(struct MOUSE_DEC *mdec, unsigned char dat)
{
	if (mdec->phase == 0) {
		if (dat == 0xfa) {
			mdec->phase = 1;
		}
		return 0;
	}
	if (mdec->phase == 1) {
		if ((dat & 0xc8) == 0x08) {
			mdec->buf[0] = dat;
			mdec->phase = 2;
		}
		return 0;
	}
	if (mdec->phase == 2) {
		mdec->buf[1] = dat;
		mdec->phase = 3;
		return 0;
	}
	if (mdec->phase == 3) {
		mdec->buf[2] = dat;
		mdec->phase = 1;	 
		mdec->btn = mdec->buf[0] & 0x07;
		mdec->x = mdec->buf[1];
		mdec->y = mdec->buf[2];
		if ((mdec->buf[0] & 0x10) != 0) {
			mdec->x |= 0xffffff00;
		}
		if ((mdec->buf[0] & 0x20) != 0) {
			mdec->y |= 0xffffff00;
		}
		mdec->y = - mdec->y;
		return 1;
	}
	return -1; 
}

4.dsctbl.c（gdt和idt设置）

#include "bootpack.h"
//初始化gdt和idt
void init_gdtidt(void)
{
	struct SEGMENT_DESCRIPTOR *gdt = (struct SEGMENT_DESCRIPTOR *) ADR_GDT;	//提前设置好的GDT在内存中的地址
	struct GATE_DESCRIPTOR    *idt = (struct GATE_DESCRIPTOR    *) ADR_IDT;	//提前设置好的IDT在内存中的地址
	int i;
 
	for (i = 0; i <= LIMIT_GDT / 8; i++) {	//对所有的全局描述符进行初始化
		set_segmdesc(gdt + i, 0, 0, 0);	//先将所有的全局描述符设置为0
	}
	set_segmdesc(gdt + 1, 0xffffffff,   0x00000000, AR_DATA32_RW);	//设置第1号描述符，段基址为0，大小4gb，可读写32位段
	set_segmdesc(gdt + 2, LIMIT_BOTPAK, ADR_BOTPAK, AR_CODE32_ER);	//设置第2号描述符，段基址0x00280000，大小0x0007ffff，属性0x4092
	load_gdtr(LIMIT_GDT, ADR_GDT);	//载入gdtr到cpu中
 
	for (i = 0; i <= LIMIT_IDT / 8; i++) {	//对所有的idt描述符进行初始化
		set_gatedesc(idt + i, 0, 0, 0);	//先将所有的idt描述符设为0
	}
	load_idtr(LIMIT_IDT, ADR_IDT);	//载入idtr到cpu中
 
	set_gatedesc(idt + 0x21, (int) asm_inthandler21, 2 * 8, AR_INTGATE32);	//对idt描述符赋值，注意第二个变量，是偏移量
	set_gatedesc(idt + 0x27, (int) asm_inthandler27, 2 * 8, AR_INTGATE32);
	set_gatedesc(idt + 0x2c, (int) asm_inthandler2c, 2 * 8, AR_INTGATE32);
 
	return;
}
 
//功能:对段描述符赋值
//参数:段描述符地址，长度、基址、属性值
void set_segmdesc(struct SEGMENT_DESCRIPTOR *sd, unsigned int limit, int base, int ar)
{
	//判断段描述大小的计数单位
	if (limit > 0xfffff) {	//如果段界限超过了限制1MB
		ar |= 0x8000; /* G_bit = 1 */	//将G位设置为1，即大小以Kb为单位
		limit /= 0x1000;	//换算成KB
	}
	sd->limit_low    = limit & 0xffff;	//从低16位开始设置，即段界限的低16位
	sd->base_low     = base & 0xffff;	//接着设置16-31的16位数据，即基地址的低16位
	sd->base_mid     = (base >> 16) & 0xff;	//设置32-39的8位数据，即基地址的中间8位，将base右移16位，然后做与运算，取出中间8位
	sd->access_right = ar & 0xff;	//设置40-47位，即ar的第八位
	sd->limit_high   = ((limit >> 16) & 0x0f) | ((ar >> 8) & 0xf0);	//设置49-56位，limit_high比较特殊，其中四位是段界限，4位是段属性值
	sd->base_high    = (base >> 24) & 0xff;	//设置57-63位，即段基址的高8位
	return;
}
 
//功能:设置门描述符
//参数:门描述符地址，偏移、段选择符，属性值
void set_gatedesc(struct GATE_DESCRIPTOR *gd, int offset, int selector, int ar)
{
	gd->offset_low   = offset & 0xffff;	//设置0-15位，偏移地址的低16位
	gd->selector     = selector;	//设置16-31位，制度段选择子
	gd->dw_count     = (ar >> 8) & 0xff;	//设置32-39位，基本上全是0
	gd->access_right = ar & 0xff;	//设置40-47位，门描述符属性
	gd->offset_high  = (offset >> 16) & 0xffff;	//设置48-63Wie，偏移地址的高16位
	return;
}

5.graphic.c

//用于处理屏幕显示
 
#include "bootpack.h"
 
//初始化调色板
void init_palette(void)
{
	static unsigned char table_rgb[16 * 3] = {	//设置调色板变量,这里3个字符一组，组成了一个颜色，颜色应该是计算机中已经设定好的
		0x00, 0x00, 0x00,	
		0xff, 0x00, 0x00,	
		0x00, 0xff, 0x00,	
		0xff, 0xff, 0x00,	
		0x00, 0x00, 0xff,	
		0xff, 0x00, 0xff,	
		0x00, 0xff, 0xff,	
		0xff, 0xff, 0xff,	
		0xc6, 0xc6, 0xc6,	
		0x84, 0x00, 0x00,	
		0x00, 0x84, 0x00,	
		0x84, 0x84, 0x00,	
		0x00, 0x00, 0x84,	
		0x84, 0x00, 0x84,	
		0x00, 0x84, 0x84,	
		0x84, 0x84, 0x84	
	};
	set_palette(0, 15, table_rgb);	//设置调色板
	return;
 
}
 
//功能:设置调色板，将颜色和编号对上
void set_palette(int start, int end, unsigned char *rgb)
{
	int i, eflags;
	eflags = io_load_eflags();	//汇编语言函数
	io_cli(); //关闭中断					
	io_out8(0x03c8, start);	//写入端口
	for (i = start; i <= end; i++) {	//每三个一组合成一个rgb颜色
		io_out8(0x03c9, rgb[0] / 4);
		io_out8(0x03c9, rgb[1] / 4);
		io_out8(0x03c9, rgb[2] / 4);
		rgb += 3;
	}
	io_store_eflags(eflags);	//汇编语言函数
	return;
}
 
//功能:画一个窗口
//其中xsize表示窗口宽度，理论上应该等于x1-x0
void boxfill8(unsigned char *vram, int xsize, unsigned char c, int x0, int y0, int x1, int y1)
{
	int x, y;
	for (y = y0; y <= y1; y++) {
		for (x = x0; x <= x1; x++)
			vram[y * xsize + x] = c;	//显示出字符
	}
	return;
}
 
//初始化屏幕
void init_screen8(char *vram, int x, int y)
{
	boxfill8(vram, x, COL8_008484,  0,     0,      x -  1, y - 29);
	boxfill8(vram, x, COL8_C6C6C6,  0,     y - 28, x -  1, y - 28);
	boxfill8(vram, x, COL8_FFFFFF,  0,     y - 27, x -  1, y - 27);
	boxfill8(vram, x, COL8_C6C6C6,  0,     y - 26, x -  1, y -  1);
 
	boxfill8(vram, x, COL8_FFFFFF,  3,     y - 24, 59,     y - 24);
	boxfill8(vram, x, COL8_FFFFFF,  2,     y - 24,  2,     y -  4);
	boxfill8(vram, x, COL8_848484,  3,     y -  4, 59,     y -  4);
	boxfill8(vram, x, COL8_848484, 59,     y - 23, 59,     y -  5);
	boxfill8(vram, x, COL8_000000,  2,     y -  3, 59,     y -  3);
	boxfill8(vram, x, COL8_000000, 60,     y - 24, 60,     y -  3);
 
	boxfill8(vram, x, COL8_848484, x - 47, y - 24, x -  4, y - 24);
	boxfill8(vram, x, COL8_848484, x - 47, y - 23, x - 47, y -  4);
	boxfill8(vram, x, COL8_FFFFFF, x - 47, y -  3, x -  4, y -  3);
	boxfill8(vram, x, COL8_FFFFFF, x -  3, y - 24, x -  3, y -  3);
	return;
}
 
//显示字体
void putfont8(char *vram, int xsize, int x, int y, char c, char *font)
{
	int i;
	char *p, d /* data */;
	for (i = 0; i < 16; i++) {
		p = vram + (y + i) * xsize + x;	//显示版面的一行，此处应明白屏幕显示原理
		d = font[i];	//显示字体，按位显示
		if ((d & 0x80) != 0) { p[0] = c; }
		if ((d & 0x40) != 0) { p[1] = c; }
		if ((d & 0x20) != 0) { p[2] = c; }
		if ((d & 0x10) != 0) { p[3] = c; }
		if ((d & 0x08) != 0) { p[4] = c; }
		if ((d & 0x04) != 0) { p[5] = c; }
		if ((d & 0x02) != 0) { p[6] = c; }
		if ((d & 0x01) != 0) { p[7] = c; }
	}
	return;
}
 
void putfonts8_asc(char *vram, int xsize, int x, int y, char c, unsigned char *s)
{
	extern char hankaku[4096];
	for (; *s != 0x00; s++) {
		putfont8(vram, xsize, x, y, c, hankaku + *s * 16);
		x += 8;
	}
	return;
}
 
void init_mouse_cursor8(char *mouse, char bc)
{
	static char cursor[16][16] = {
		"**************..",
		"*OOOOOOOOOOO*...",
		"*OOOOOOOOOO*....",
		"*OOOOOOOOO*.....",
		"*OOOOOOOO*......",
		"*OOOOOOO*.......",
		"*OOOOOOO*.......",
		"*OOOOOOOO*......",
		"*OOOO**OOO*.....",
		"*OOO*..*OOO*....",
		"*OO*....*OOO*...",
		"*O*......*OOO*..",
		"**........*OOO*.",
		"*..........*OOO*",
		"............*OO*",
		".............***"
	};
	int x, y;
 
	for (y = 0; y < 16; y++) {
		for (x = 0; x < 16; x++) {
			if (cursor[y][x] == '*') {
				mouse[y * 16 + x] = COL8_000000;	//显示鼠标
			}
			if (cursor[y][x] == 'O') {
				mouse[y * 16 + x] = COL8_FFFFFF;
			}
			if (cursor[y][x] == '.') {
				mouse[y * 16 + x] = bc;
			}
		}
	}
	return;
}
 
//功能:显示背景
//vram和vxsize是关于vram的信息
//pxsize,pysize是想要显示的图形大小
//px0、py0制定图像在画面上的显示位置
//buf指定图形存放的地址
//bxsize指定每一行含有的像素数
void putblock8_8(char *vram, int vxsize, int pxsize,
	int pysize, int px0, int py0, char *buf, int bxsize)
{
	int x, y;
	for (y = 0; y < pysize; y++) {
		for (x = 0; x < pxsize; x++) {
			vram[(py0 + y) * vxsize + (px0 + x)] = buf[y * bxsize + x];
		}
	}
	return;
}

6.fifo.c

#include "bootpack.h"
 
#define FLAGS_OVERRUN		0x0001
 
//功能:初始化FIFO缓存区
//参数:缓存区结构体，大小，缓存区地址
void fifo8_init(struct FIFO8 *fifo, int size, unsigned char *buf)
{
	fifo->size = size;
	fifo->buf = buf;
	fifo->free = size; 
	fifo->flags = 0;
	fifo->p = 0; 
	fifo->q = 0;
	return;
}
 
//功能:向缓存区写入数据
int fifo8_put(struct FIFO8 *fifo, unsigned char data)
{
	if (fifo->free == 0) {	//如果缓存区大小等于零，代表缓存区已经被写满
		fifo->flags |= FLAGS_OVERRUN;	//将覆盖标志置1
		return -1;	//返回一个错误值
	}
	fifo->buf[fifo->p] = data;	//读取当前缓存区的第一个数据
	fifo->p++;	//将读取指针后移
	if (fifo->p == fifo->size) {	//如果已经读完缓存区
		fifo->p = 0;	//将读取指针指向第一个位置
	}
	fifo->free--;	//缓存区可用位置减1
	return 0;
}
 
//功能:从缓存区读取数据
int fifo8_get(struct FIFO8 *fifo)
{
	int data;
	if (fifo->free == fifo->size) {	//如果缓存区是空的，返回错误
		return -1;
	}
	data = fifo->buf[fifo->q];	//读取数据
	fifo->q++;	//读取指针后移
	if (fifo->q == fifo->size) {	//读到最后一个将读取指针指向第一个位置
		fifo->q = 0;
	}
	fifo->free++;	//可用区域加1 缓存区是循环写入的
	return data;
}
 
int fifo8_status(struct FIFO8 *fifo)	//判断缓存区的状态
{
	return fifo->size - fifo->free;
}

7. int.c

#include "bootpack.h"
#include <stdio.h>
 
//功能:中断初始化函数，初始化pic
void init_pic(void)
{
	io_out8(PIC0_IMR,  0xff  );	//主片禁止所有中断
	io_out8(PIC1_IMR,  0xff  ); //从片禁止所有中断
	//设置pic0，主片
	io_out8(PIC0_ICW1, 0x11  ); //边沿触发模式
	io_out8(PIC0_ICW2, 0x20  ); //IRQ0-7由INT20-27接收
	io_out8(PIC0_ICW3, 1 << 2); //PIC1由IRQ2接收
	io_out8(PIC0_ICW4, 0x01  );	//无缓冲区模式
	//设置pic1，从片
	io_out8(PIC1_ICW1, 0x11  );	//边沿触发模式
	io_out8(PIC1_ICW2, 0x28  );	//IRQ8-15由INT28-2f接收
	io_out8(PIC1_ICW3, 2     ); //PIC1由IRQ2连接
	io_out8(PIC1_ICW4, 0x01  );	//无缓冲区模式
 
	io_out8(PIC0_IMR,  0xfb  ); //11111011，PIC1以外的全部禁止
	io_out8(PIC1_IMR,  0xff  ); //11111111，禁止PIC1的所有中断
 
	return;
}
 
#define PORT_KEYDAT		0x0060
 
struct FIFO8 keyfifo;
//键盘中断处理，键盘是IRQ1,所以编写INT 0x21
//这里已经有了C语言编写的函数，为什么还要添加汇编语言的函数?
//是在汇编语言中调用该函数
void inthandler21(int *esp)
{
	unsigned char data;
	io_out8(PIC0_OCW2, 0x61);	
	data = io_in8(PORT_KEYDAT);	//读取数据
	fifo8_put(&keyfifo, data);	//将数据写入缓存区
	return;
}
 
struct FIFO8 mousefifo;
//功能:鼠标中断处理，编写INT 0x2c
void inthandler2c(int *esp)
{
	unsigned char data;
	io_out8(PIC1_OCW2, 0x64);	
	io_out8(PIC0_OCW2, 0x62);	
	data = io_in8(PORT_KEYDAT);	//读取数据
	fifo8_put(&mousefifo, data);	//将数据写入缓存区
	return;
}
 
void inthandler27(int *esp)								*/
{
	io_out8(PIC0_OCW2, 0x67); 
	return;
}

8. naskfunc.nas（汇编和c语言文件之间的桥梁）

; naskfunc
; TAB=4

[FORMAT "WCOFF"]				;
[INSTRSET "i486p"]				;
[BITS 32]						;
[FILE "naskfunc.nas"]			;
;定义外部符号，可以从文件外进行调用
		GLOBAL	_io_hlt, _io_cli, _io_sti, _io_stihlt
		GLOBAL	_io_in8,  _io_in16,  _io_in32
		GLOBAL	_io_out8, _io_out16, _io_out32
		GLOBAL	_io_load_eflags, _io_store_eflags
		GLOBAL	_load_gdtr, _load_idtr
		GLOBAL	_asm_inthandler21, _asm_inthandler27, _asm_inthandler2c
		EXTERN	_inthandler21, _inthandler27, _inthandler2c

[SECTION .text]

_io_hlt:	; void io_hlt(void);
		HLT
		RET

_io_cli:	; void io_cli(void);
		CLI
		RET

_io_sti:	; void io_sti(void);
		STI
		RET

_io_stihlt:	; void io_stihlt(void);
		STI
		HLT
		RET

_io_in8:	; int io_in8(int port); 从指定端口中读取数据
		MOV		EDX,[ESP+4]		; port，获取端口号
		MOV		EAX,0	;清空ax寄存器
		IN		AL,DX	;从DX指定的端口中读取数据到al
		RET

_io_in16:	; int io_in16(int port);
		MOV		EDX,[ESP+4]		; port
		MOV		EAX,0
		IN		AX,DX
		RET

_io_in32:	; int io_in32(int port);
		MOV		EDX,[ESP+4]		; port
		IN		EAX,DX
		RET

_io_out8:	; void io_out8(int port, int data);	向指定端口写入数据
		MOV		EDX,[ESP+4]		; port	获取端口号
		MOV		AL,[ESP+8]		; data	获取要写入的数据
		OUT		DX,AL	;将al中的数据写入到dx指定的端口中
		RET

_io_out16:	; void io_out16(int port, int data);
		MOV		EDX,[ESP+4]		; port
		MOV		EAX,[ESP+8]		; data
		OUT		DX,AX
		RET

_io_out32:	; void io_out32(int port, int data);
		MOV		EDX,[ESP+4]		; port
		MOV		EAX,[ESP+8]		; data
		OUT		DX,EAX
		RET

_io_load_eflags:	; int io_load_eflags(void);
		PUSHFD		; 将eflags寄存器压入栈中，入栈顺序是EAX,ECX,EDX,EBX,ESP,EBP,ESI,EDI
		POP		EAX	; 将edi的值弹出到eax中
		RET

_io_store_eflags:	; void io_store_eflags(int eflags);
		MOV		EAX,[ESP+4]
		PUSH	EAX
		POPFD		; 将栈中的寄存器值弹出到eflags寄存器中
		RET

_load_gdtr:		; void load_gdtr(int limit, int addr);加载GDTR	
		MOV		AX,[ESP+4]		; limit
		MOV		[ESP+6],AX
		LGDT	[ESP+6]
		RET

_load_idtr:		; void load_idtr(int limit, int addr); 记载IDTR,原理与加载GDTR相同
		MOV		AX,[ESP+4]		; limit
		MOV		[ESP+6],AX
		LIDT	[ESP+6]
		RET

;这个函数只是将寄存器的值保存在栈里，然后将DS和ES调整到与SS相等，再调用_inthandler21,返回后将所有寄存器的值再返回到原来的值，然后执行IRETD
;之所以如此小心翼翼地保护寄存器，原因在于，中断处理发生在函数处理途中，通过IREDT从中断处理后，寄存器就乱了
_asm_inthandler21:
		PUSH	ES
		PUSH	DS
		PUSHAD	;PUSHAD指令压入32位寄存器，其入栈顺序是:EAX,ECX,EDX,EBX,ESP,EBP,ESI,EDI .
		MOV		EAX,ESP	;eax=esp
		PUSH	EAX	压入eax的值，即esp
		MOV		AX,SS	
		MOV		DS,AX	;ds=ss
		MOV		ES,AX	;es=ss
		CALL	_inthandler21	;调用inthandler21函数，c语言编写
		POP		EAX	;弹出esp的值到eax中
		POPAD
		POP		DS	
		POP		ES
		IRETD

_asm_inthandler27:
		PUSH	ES
		PUSH	DS
		PUSHAD
		MOV		EAX,ESP
		PUSH	EAX
		MOV		AX,SS
		MOV		DS,AX
		MOV		ES,AX
		CALL	_inthandler27
		POP		EAX
		POPAD
		POP		DS
		POP		ES
		IRETD

_asm_inthandler2c:
		PUSH	ES
		PUSH	DS
		PUSHAD
		MOV		EAX,ESP
		PUSH	EAX
		MOV		AX,SS
		MOV		DS,AX
		MOV		ES,AX
		CALL	_inthandler2c
		POP		EAX
		POPAD
		POP		DS
		POP		ES
		IRETD

标题三、其它

根据书中的描述，整个项目的编译过程如图
在这里插入图片描述

最后，asmhead文件和bookpack文件会编译到一起，bookpack的内容就是从bootpack标号开始？

关于中断处理程序的调用

如果要让一个中断处理程序发挥作用，首先要将其注册到idt中，书中使用了函数set_gatedesc(idt+0x21,(int)asm_inthandler21,2*8,AR_INTGATE32)2

即将_asm_inthandler21注册为idt的第21号，如果发生中断了，cpu就会自动调用asm_inthandler21

2表示asm_inthandler属于那一个段，因低3位必须是0，所以写成2*8
（ps：一定要读源码）
————————————————
版权声明：本文为CSDN博主「qq_35041101」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_35041101/article/details/51866877

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1394216.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

综述：自动驾驶中的 4D 毫米波雷达

综述：自动驾驶中的 4D 毫米波雷达

论文链接&#xff1a;《4D Millimeter-Wave Radar in Autonomous Driving: A Survey》 摘要 4D 毫米波 (mmWave) 雷达能够测量目标的距离、方位角、仰角和速度&#xff0c;引起了自动驾驶领域的极大兴趣。这归因于其在极端环境下的稳健性以及出色的速度和高度测量能力。 然而…
阅读更多...
Xshell无法ssh连接虚拟机问题或主机无法ping通虚拟机。

Xshell无法ssh连接虚拟机问题或主机无法ping通虚拟机。

常见报错如下&#xff1a; 1&#xff0c;Could not connect to ‘&#xff1f;&#xff1f;&#xff1f;’ (port 22): Connection failed. 2&#xff0c;卡在To escape to local shell, press ‘CtrlAlt]’. 3&#xff0c;Connection closing…Socket close. Connection clos…
阅读更多...
Apache安全及优化

Apache安全及优化

配置第一台虚拟机 VM1网卡 yum仓库 挂载磁盘 上传3个软件包到/目录 到/目录下进行解压缩 tar xf apr-1.6.2.tar.gz tar xf apr-util-1.6.0.tar.gz tar -xjf httpd-2.4.29.tar.bz2 mv apr-1.6.2 httpd-2.4.29/srclib/apr mv apr-util-1.6…
阅读更多...
jetson-inference入门

jetson-inference入门

jetson-inference 文章目录 jetson-inference前言一、jetson-inference二、 下载传输三、 docker的安装使用总结 前言 jetson 部署相关内容 一、jetson-inference 官方推出的体验套餐&#xff0c;提供了三种最常见的AI应用与计算机视觉的类型 图像辨识&#xff08;Image Rec…
阅读更多...
纯CSS3的单选框、复选框、开关按钮UI库-自由分享jQuery、html5、css3的插件库

纯CSS3的单选框、复选框、开关按钮UI库-自由分享jQuery、html5、css3的插件库

纯CSS3的单选框、复选框、开关按钮UI库-自由分享jQuery、html5、css3的插件库-遇见你与你分享
阅读更多...
陪玩系统：最新商业版游戏陪玩语音聊天系统3.0商业升级独立版本源码

陪玩系统：最新商业版游戏陪玩语音聊天系统3.0商业升级独立版本源码

首发价值29800元的最新商业版游戏陪玩语音聊天系统3.0商业升级独立版本源码 &#xff08;价值29800&#xff09;最新陪玩3.0独立版本 &#xff0c;文件截图 结尾将会附上此系统源码以及详细搭建教程包含素材图仅用于学习使用 陪玩系统3.0独立升级版正式发布&#xff0c;此版本…
阅读更多...
Elasticsearch各种高级文档操作2

Elasticsearch各种高级文档操作2

本文来记录下Elasticsearch各种文档操作 文章目录 初始化文档数据 初始化文档数据 在进行各种文档操作之前&#xff0c;我们先进行初始化文档数据的工作
阅读更多...
Pixels：重新定义游戏体验的区块链农场游戏

Pixels：重新定义游戏体验的区块链农场游戏

数据源&#xff1a;Pixels Dashboard 作者&#xff1a;lesleyfootprint.network 最近&#xff0c;Pixels 通过从 Polygon 转移到 Sky Mavis 旗下的 Ronin 网络&#xff0c;完成了一次战略性的转变。 Pixels 每日交易量 Pixels 在 Ronin 网络上的受欢迎程度急剧上升&#xf…
阅读更多...
Linux的权限（2）

Linux的权限（2）

目录 Linux的&#xff08;事物属性&#xff09;文件权限 文件权限值得表示方法 字符表示方法 8进制表示方法 文件访问权限得相关设置方法 chmod修改权限法1 chmod修改权限法2 文件的角色&#xff08;拥有者/所属者&#xff09;修改 chown拥有者 chgrp所属者 &…
阅读更多...
贵阳贵安推进“数字活市”战略成效明显

贵阳贵安推进“数字活市”战略成效明显

作者&#xff1a;黄玉叶 近年来&#xff0c;贵阳贵安将数字经济确立为高质量发展的主路径之一&#xff0c;把推进“数字活市”作为实施主战略、实现主定位&#xff0c;特别是建设“数字经济发展创新区核心区”的重要抓手&#xff0c;从改革、发展、民生三个维度纵深推进“数字活…
阅读更多...
享元模式介绍

享元模式介绍

目录 一、享元模式介绍 1.1 享元模式定义 1.2 享元模式原理 1.2.1 享元模式类图 1.2.2 模式角色说明 1.2.3 示例代码 二、享元模式的应用 2.1 需求说明 2.2 需求实现 2.2.1 类图 2.2.2 具体实现 2.2.2.1 抽象享元类 2.2.2.2 共享享元类-白色棋子 2.2.2.3 共享享元…
阅读更多...
2018年认证杯SPSSPRO杯数学建模A题(第一阶段)海豚与沙丁鱼全过程文档及程序

2018年认证杯SPSSPRO杯数学建模A题(第一阶段)海豚与沙丁鱼全过程文档及程序

2018年认证杯SPSSPRO杯数学建模 探究海豚猎捕时沙丁鱼群的躲避运动模型 A题 海豚与沙丁鱼 原题再现&#xff1a; 沙丁鱼以聚成大群的方式来对抗海豚的捕食。由于水下光线很暗&#xff0c;所以在距离较远时&#xff0c;海豚只能使用回声定位方法来判断鱼群的整体位置&#xf…
阅读更多...
策略模式在工作中的运用

策略模式在工作中的运用

前言 在不同的场景下&#xff0c;执行不同的业务逻辑&#xff0c;在日常工作中是很寻常的事情。比如&#xff0c;订阅系统。在收到阿里云的回调事件、与收到AWS的回调事件&#xff0c;无论是收到的参数&#xff0c;还是执行的逻辑都可能是不同的。为了避免&#xff0c;每次新增…
阅读更多...
老师布置作业的技巧有哪些

老师布置作业的技巧有哪些

布置作业可不只是简单地给学生分配任务&#xff0c;而是需要运用一些技巧&#xff0c;以达到更好的教学效果。那么&#xff0c;老师应该如何布置作业呢&#xff1f; 一、作业要有针对性 布置作业时&#xff0c;老师应该根据学生的实际情况和课程要求&#xff0c;有针对性地设…
阅读更多...
数字创意市场：Web3时代创作者的新机遇

数字创意市场：Web3时代创作者的新机遇

随着Web3时代的崭露头角&#xff0c;数字创意市场正迎来全新的变革和机遇。在这个数字化的时代&#xff0c;创作者们将面对更加开放、去中心化的创作和交易环境。本文将深入探讨Web3时代数字创意市场为创作者带来的新机遇&#xff0c;以及这个时代为创意产业带来的变革。 创作者…
阅读更多...
无心剑七绝《忆彭德怀》

无心剑七绝《忆彭德怀》

七绝忆彭德怀 彭公铁骨傲苍松 德布黎民逆赤龙 怀义光华传百代 真金火炼自从容 2024年1月16日 平水韵二冬平韵 这首七绝以“忆彭德怀”为题&#xff0c;通过四句二十八字的凝练表达&#xff0c;深情缅怀了彭德怀元帅的高尚品质和坚韧精神。作者无心剑运用古典诗词的形式&#xf…
阅读更多...
区域入侵/区域人数统计AI边缘计算智能分析网关V4如何修改IP地址？

区域入侵/区域人数统计AI边缘计算智能分析网关V4如何修改IP地址？

智能分析网关V4是TSINGSEE青犀推出的一款AI边缘计算智能硬件&#xff0c;硬件采用BM1684芯片&#xff0c;集成高性能8核ARM A53&#xff0c;主频高达2.3GHz&#xff0c;INT8峰值算力高达17.6Tops&#xff0c;FB32高精度算力达到2.2T&#xff0c;硬件内置了近40种AI算法模型&…
阅读更多...
IaC基础设施即代码：Terraform使用本地编译(In-house)的Providers

IaC基础设施即代码：Terraform使用本地编译(In-house)的Providers

目录 一、实验 1.环境 2.初始化一个项目 3.Terraform使用本地编译&#xff08;In-house&#xff09;的Providers 二、问题 1.Terraform Provider有哪些全网标识符 2.本地安装Terraform Provider有哪些方法 一、实验 1.环境 &#xff08;1&#xff09;主机 表1-1 主机…
阅读更多...
Spring | Spring中的Bean--上

Spring | Spring中的Bean--上

目录: Spring中的Bean:1.Bean的配置2.Bean的实例化2.1 构造器实例化 3.Bean的作用域3.1 作用域的种类3.2 singleton作用域3.3 prototype 作用域 Spring中的Bean: 1.Bean的配置 Spring可以被看作是个一个大型工厂&#xff0c; 这个工厂的作用就是生产和管理Sping容器中的Bean。…
阅读更多...
QtCreator12无法识别Qt5.15.2的安卓SDK与NDK配置解决

QtCreator12无法识别Qt5.15.2的安卓SDK与NDK配置解决

解决方法: 设置JDK为JDK11 使用Android Studio下载 Android SDK Command-line Tools 10.0 打开Android SDK Location : 双击打开cmdline-tools 复制10.0中所有东西到latest中 点击Manage Kits并选择Devices 然后点击Android会弹出下图窗口,并自动更 安装完成 成功识别
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023