动手实现编译器（七）——比较运算符

最新推荐文章于 2022-11-25 16:36:06 发布
最新推荐文章于 2022-11-25 16:36:06 发布
阅读量395 收藏
点赞数
分类专栏： 编译器 文章标签： 编译器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34851605/article/details/117967466
版权

上一节中，我们已经实现了全局变量的声明、赋值和计算，本节中我们将会实现计较运算符的计算。

==, !=, <, >, <=, >=

修改词法分析

首先增加新的单词类型

// 单词类型
enum
{
    T_EOF,
    T_ADD, T_SUB, T_MUL, T_DIV, T_MOD, T_EQ, T_NE, T_LT, T_GT, T_LE, T_GE,
    T_INT, T_SEM, T_PRINT, T_EQU, T_IDENT, T_KEYINT
};

我们必须区分 = 和 ==，< 和 <=，> 和 >=。因此我们将需要从输入中读取一个额外的字符，然后在不需要时将其放回原处，修改scan()代码如下：

// 扫描并返回在输入中找到的下一个单词。
// 如果标记有效则返回 1，如果没有标记则返回 0
int scan(struct token *t)
{
    int c, tokentype;
    c = skip_getchr();
    switch (c)
    {
        case EOF:   t->token = T_EOF;   return 0;
        case '+':   t->token = T_ADD;   break;
        case '-':   t->token = T_SUB;   break;
        case '*':   t->token = T_MUL;   break;
        case '/':   t->token = T_DIV;   break;
        case '%':   t->token = T_MOD;   break;
        case ';':   t->token = T_SEM;   break;
        case '=':   
                    if((c = get_nextchr()) == '=')
                    {
                        t->token = T_EQ;
                    }
                    else
                    {
                        t->token = T_EQU;
                        put_backchr(c);
                    }
                    break;
        case '!':   if((c = get_nextchr()) == '=')
                    {
                        t->token = T_NE;
                    }
                    else
                    {
                        fprintf(stderr, "Unrecognised character:%c on line %d\n", c, Line);
                        exit(1);
                    }
                    break;
        case '<':   if((c = get_nextchr()) == '=')
                    {
                        t->token = T_LE;
                    }
                    else
                    {
                        t->token = T_LT;
                        put_backchr(c);
                    }
                    break;
        case '>':   if((c = get_nextchr()) == '=')
                    {
                        t->token = T_GE;
                    }
                    else
                    {
                        t->token = T_GT;
                        put_backchr(c);
                    }
                    break;
        default:    if (isdigit(c)) 
                    {
                        t->intvalue = scan_int(c);
                        t->token = T_INT;
                        break;
                    }
                    else if(isalpha(c) || '_' == c)
                    {
                        scan_ident(c, Text, TEXTLEN);
                        if (tokentype = match_keyword(Text))
                        {
                        	t->token = tokentype;
	                        break;
	                    }
	                    t->token = T_IDENT;
                        break;
                    }
                    printf("Unrecognised character %c on line %d\n", c, Line);
                    exit(1);
    }
    return 1;
}

修改语法分析

增加AST节点类型

// AST节点类型
enum
{
    A_ADD = 1, A_SUB, A_MUL, A_DIV, A_MOD, A_EQ, A_NE, A_LT, A_GT, A_LE, A_GE,
    A_INT, A_IDENT, A_ASSIGN, A_LVIDENT
};

修改单词到AST节点的映射

// 将单词转换为AST操作
int token_op(int tokentype)
{
    if(tokentype > T_EOF && tokentype < T_INT)
    {
        return tokentype;
    }
    fprintf(stderr, "unknown token in token_op() on line %d\n", Line);
    exit(1);
}

注意到，我们简化了映射函数操作，为此，我们在前面的单词类型和AST节点类型要按一定顺序排列
修改AST节点的运算优先级

// 每个AST节点的运算符优先级
int OpPrec[] = {0, 10, 10, 20, 20, 20, 30, 30, 40, 40, 40, 40};

修改代码生成

在代码生成函数code_generator()中加入六种比较运算

// 给定AST，生成汇编代码，返回值为结果所在寄存器号
int code_generator(struct ASTnode *n, int reg)
{
    int leftreg, rightreg;
    if (n->left)    leftreg = code_generator(n->left, -1);
    if (n->right)   rightreg = code_generator(n->right, leftreg);
    switch (n->op)
    {
        case A_ADD:    return (arm_add(leftreg, rightreg));
        case A_SUB:    return (arm_sub(leftreg, rightreg));
        case A_MUL:    return (arm_mul(leftreg, rightreg));
        case A_DIV:    return (arm_div(leftreg, rightreg));
        case A_MOD:    return (arm_mod(leftreg, rightreg));
        case A_EQ:     return (arm_equal(leftreg, rightreg));
        case A_NE:     return (arm_notequal(leftreg, rightreg));
        case A_LT:     return (arm_lessthan(leftreg, rightreg));
        case A_GT:     return (arm_greaterthan(leftreg, rightreg));
        case A_LE:     return (arm_lessequal(leftreg, rightreg));
        case A_GE:     return (arm_greaterequal(leftreg, rightreg));
        case A_INT:    return (arm_load_int(n->v.intvalue));
        case A_IDENT:  return (arm_load_global(n->v.id));
        case A_LVIDENT:return (arm_stor_global(reg, n->v.id));
        case A_ASSIGN: return rightreg;
        default:    fprintf(stderr, "Unknown AST operator %d\n", n->op);
                    exit(1);
    }
}

修改汇编代码
ARM比较需要先调用CMP Rm Rn指令,进行Rm-Rn，并修改CPSR。然后我们调用对应条件的MOV{S} Rd, #<imm8>指令赋值1，再调用相反条件的MOV指令赋值0，最后对赋值寄存器进行字节到字的扩展，因为有条件MOV{S}只能赋值8位立即数。
CPSR（ARM状态寄存器）的最后四位分别是N、Z、C、V。

符号名称作用
N符号标志N=1表示运算结果为负数，N=0表示运算结果为整数
Z全0标志Z=1则表示运算结果为0，否则Z=0
C进位标志加法有进位时C=1（加法运算是数据溢出），无进位时C=0；减法有借位时C=0，无借位时C=1
V数据溢出标志加法运算结果有溢出是V=1，否则V=0

S条件如下：

助记符后缀标志含义符号
EQZ置位相等=
NEZ清零不相等≠
LTN不等于V带符号数小于<
GTZ清零且（N不等于V）带符号数大于>
LEZ置位或（N不等于V）带符号数小于或等于≤
GEN等于V带符号数大于或等于≥
// 比较函数：第一个寄存器减去第二个寄存器并修改CPSR
int arm_compare(int r1, int r2)
{
    fprintf(Outfile, "\tcmp\tr%d, r%d\n", r1, r2);
}

// '=='汇编函数
int arm_equal(int r1, int r2)
{
    arm_compare(r1, r2);
    fprintf(Outfile, "\tmoveq\tr%d, #1\n", r1);
    fprintf(Outfile, "\tmovne\tr%d, #0\n", r1);
    fprintf(Outfile, "\tuxtb\tr%d, r%d\n", r1, r1);
    arm_free_register(r2);
    return r1;
}

// '!='汇编函数
int arm_notequal(int r1, int r2)
{
    arm_compare(r1, r2);
    fprintf(Outfile, "\tmovne\tr%d, #1\n", r1);
    fprintf(Outfile, "\tmoveq\tr%d, #0\n", r1);
    fprintf(Outfile, "\tuxtb\tr%d, r%d\n", r1, r1);
    arm_free_register(r2);
    return r1;
}

// '<'汇编函数
int arm_lessthan(int r1, int r2)
{
    arm_compare(r1, r2);
    fprintf(Outfile, "\tmovlt\tr%d, #1\n", r1);
    fprintf(Outfile, "\tmovge\tr%d, #0\n", r1);
    fprintf(Outfile, "\tuxtb\tr%d, r%d\n", r1, r1);
    arm_free_register(r2);
    return r1;
}

// '>'汇编函数
int arm_greaterthan(int r1, int r2)
{
    arm_compare(r1, r2);
    fprintf(Outfile, "\tmovgt\tr%d, #1\n", r1);
    fprintf(Outfile, "\tmovle\tr%d, #0\n", r1);
    fprintf(Outfile, "\tuxtb\tr%d, r%d\n", r1, r1);
    arm_free_register(r2);
    return r1;
}

// '<='汇编函数
int arm_lessequal(int r1, int r2)
{
    arm_compare(r1, r2);
    fprintf(Outfile, "\tmovle\tr%d, #1\n", r1);
    fprintf(Outfile, "\tmovgt\tr%d, #0\n", r1);
    fprintf(Outfile, "\tuxtb\tr%d, r%d\n", r1, r1);
    arm_free_register(r2);
    return r1;
}

// '>='汇编函数
int arm_greaterequal(int r1, int r2)
{
    arm_compare(r1, r2);
    fprintf(Outfile, "\tmovge\tr%d, #1\n", r1);
    fprintf(Outfile, "\tmovlt\tr%d, #0\n", r1);
    fprintf(Outfile, "\tuxtb\tr%d, r%d\n", r1, r1);
    arm_free_register(r2);
    return r1;
}

结果测试

输入：

int x;
x = 1 < 1;  print x;
x = 1 < 2;  print x;
x = 2 < 1;  print x;
x = 3 <= 3; print x;
x = 3 <= 4; print x;
x = 4 <= 3; print x;
x = 4 != 5; print x;
x = 5 != 5; print x;
x = 6 == 6; print x;
x = 6 == 7; print x;
x = 7 > 7;  print x;
x = 6 > 7;  print x;
x = 7 > 6;  print x;
x = 8 >= 8; print x;
x = 8 >= 9; print x;
x = 9 >= 8; print x;

输出（out.s）：

	.text
	.global __aeabi_idiv
	.section	.rodata
	.align  2
.LC0:
	.ascii  "%d\012\000"
	.text
	.align  2
	.global main
	.type   main, %function
main:
	push    {fp, lr}
	add     fp, sp, #4
	.text
	.comm	x,4,4
	mov	r4, #1
	mov	r5, #1
	cmp	r4, r5
	movlt	r4, #1
	movge	r4, #0
	uxtb	r4, r4
	ldr	r3, .L2+0
	str	r4, [r3]
	ldr	r3, .L2+0
	ldr	r4, [r3]
	mov     r1, r4
	ldr     r0, .L3
	bl      printf
	mov	r4, #1
	mov	r5, #2
	cmp	r4, r5
	movlt	r4, #1
	movge	r4, #0
	uxtb	r4, r4
	ldr	r3, .L2+0
	str	r4, [r3]
	ldr	r3, .L2+0
	ldr	r4, [r3]
	mov     r1, r4
	ldr     r0, .L3
	bl      printf
	mov	r4, #2
	mov	r5, #1
	cmp	r4, r5
	movlt	r4, #1
	movge	r4, #0
	uxtb	r4, r4
	ldr	r3, .L2+0
	str	r4, [r3]
	ldr	r3, .L2+0
	ldr	r4, [r3]
	mov     r1, r4
	ldr     r0, .L3
	bl      printf
	mov	r4, #3
	mov	r5, #3
	cmp	r4, r5
	movle	r4, #1
	movgt	r4, #0
	uxtb	r4, r4
	ldr	r3, .L2+0
	str	r4, [r3]
	ldr	r3, .L2+0
	ldr	r4, [r3]
	mov     r1, r4
	ldr     r0, .L3
	bl      printf
	mov	r4, #3
	mov	r5, #4
	cmp	r4, r5
	movle	r4, #1
	movgt	r4, #0
	uxtb	r4, r4
	ldr	r3, .L2+0
	str	r4, [r3]
	ldr	r3, .L2+0
	ldr	r4, [r3]
	mov     r1, r4
	ldr     r0, .L3
	bl      printf
	mov	r4, #4
	mov	r5, #3
	cmp	r4, r5
	movle	r4, #1
	movgt	r4, #0
	uxtb	r4, r4
	ldr	r3, .L2+0
	str	r4, [r3]
	ldr	r3, .L2+0
	ldr	r4, [r3]
	mov     r1, r4
	ldr     r0, .L3
	bl      printf
	mov	r4, #4
	mov	r5, #5
	cmp	r4, r5
	movne	r4, #1
	moveq	r4, #0
	uxtb	r4, r4
	ldr	r3, .L2+0
	str	r4, [r3]
	ldr	r3, .L2+0
	ldr	r4, [r3]
	mov     r1, r4
	ldr     r0, .L3
	bl      printf
	mov	r4, #5
	mov	r5, #5
	cmp	r4, r5
	movne	r4, #1
	moveq	r4, #0
	uxtb	r4, r4
	ldr	r3, .L2+0
	str	r4, [r3]
	ldr	r3, .L2+0
	ldr	r4, [r3]
	mov     r1, r4
	ldr     r0, .L3
	bl      printf
	mov	r4, #6
	mov	r5, #6
	cmp	r4, r5
	moveq	r4, #1
	movne	r4, #0
	uxtb	r4, r4
	ldr	r3, .L2+0
	str	r4, [r3]
	ldr	r3, .L2+0
	ldr	r4, [r3]
	mov     r1, r4
	ldr     r0, .L3
	bl      printf
	mov	r4, #6
	mov	r5, #7
	cmp	r4, r5
	moveq	r4, #1
	movne	r4, #0
	uxtb	r4, r4
	ldr	r3, .L2+0
	str	r4, [r3]
	ldr	r3, .L2+0
	ldr	r4, [r3]
	mov     r1, r4
	ldr     r0, .L3
	bl      printf
	mov	r4, #7
	mov	r5, #7
	cmp	r4, r5
	movgt	r4, #1
	movle	r4, #0
	uxtb	r4, r4
	ldr	r3, .L2+0
	str	r4, [r3]
	ldr	r3, .L2+0
	ldr	r4, [r3]
	mov     r1, r4
	ldr     r0, .L3
	bl      printf
	mov	r4, #6
	mov	r5, #7
	cmp	r4, r5
	movgt	r4, #1
	movle	r4, #0
	uxtb	r4, r4
	ldr	r3, .L2+0
	str	r4, [r3]
	ldr	r3, .L2+0
	ldr	r4, [r3]
	mov     r1, r4
	ldr     r0, .L3
	bl      printf
	mov	r4, #7
	mov	r5, #6
	cmp	r4, r5
	movgt	r4, #1
	movle	r4, #0
	uxtb	r4, r4
	ldr	r3, .L2+0
	str	r4, [r3]
	ldr	r3, .L2+0
	ldr	r4, [r3]
	mov     r1, r4
	ldr     r0, .L3
	bl      printf
	mov	r4, #8
	mov	r5, #8
	cmp	r4, r5
	movge	r4, #1
	movlt	r4, #0
	uxtb	r4, r4
	ldr	r3, .L2+0
	str	r4, [r3]
	ldr	r3, .L2+0
	ldr	r4, [r3]
	mov     r1, r4
	ldr     r0, .L3
	bl      printf
	mov	r4, #8
	mov	r5, #9
	cmp	r4, r5
	movge	r4, #1
	movlt	r4, #0
	uxtb	r4, r4
	ldr	r3, .L2+0
	str	r4, [r3]
	ldr	r3, .L2+0
	ldr	r4, [r3]
	mov     r1, r4
	ldr     r0, .L3
	bl      printf
	mov	r4, #9
	mov	r5, #8
	cmp	r4, r5
	movge	r4, #1
	movlt	r4, #0
	uxtb	r4, r4
	ldr	r3, .L2+0
	str	r4, [r3]
	ldr	r3, .L2+0
	ldr	r4, [r3]
	mov     r1, r4
	ldr     r0, .L3
	bl      printf
	mov     r3, #0
	mov     r0, r3
	pop     {fp, pc}
.L3:
	.word   .LC0
	.size   main, .-main
.L2:
	.word x

输出（out）:

0
1
0
1
1
0
1
0
1
0
0
0
1
1
0
1

总结

在这一节中，我们实现了六种比较运算符的运算，在下一节中，我们将利用这些比较运算符实现IF语句。

qq_34851605
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
acwj：编译器写作之旅
01-31
通过这个旅程，你不仅将掌握编译器设计的基本原理，还将获得实际动手构建编译器的经验，这对于理解编程语言的底层机制、提升软件开发技能以及进行语言和编译工具的创新都大有裨益。在acwj-master这个项目中，你将有...
基于C语言的编译器设计与实现
毕业作品网站
07-31 1735
目录 1选题背景 1 2系统关键定义 2 2.1单词文法描述 2 2.2语句文法描述 3 2.3 符号表结构描述 4 2.4 错误类型码描述 5 3系统设计与实现 6 3.1编译程序符号表结构 6 3.2编译程序报错功能 7 3.3词法语法分析器（实验一） 7 3.4语义分析（实验二） 8 4系统测试与评价 10 4.1 测试用例 10 4.2 正确性测试 11 4.3 报错功能测试 15 4.4 系统的优点 20 4.5 系统的缺点 20 5实验小结或体会 21 参考文献 22 附件：源代码 23 附录一
c语言实现二元整数算术运算,C编译器剖析_1.5 结合C语言来学汇编_整数运算
weixin_33664286的博客
05-24 639
让我们还是从熟悉的加减乘除等算术运算入手。图1.23给出了一个简单的C程序，其中包含了常见的C语言算术运算，我们依旧采取对比C语言代码和UCC编译器生成的汇编代码的方法来讨论。 图1.23 arith.c我们有意在图1.23的第1至4行定义了几个初始化或未初始化的变量。图1.24给出了这几个变量在汇编代码中的区别。在图1.24中，第7行至第9行对应的是初始化为10的全局变量a；而第11至1...
【黑马JavaSE】1.2.算术\赋值\比较\逻辑\三元运算符、方法入门、JShell编译器
青墟的CSDN博客
12-04 215
计划两天，从6_05看到9_07，加油！大四狗
汇编 c语言 比较大小,C编译器剖析_1.5 结合C语言来学汇编_浮点数运算(比较大小)...
weixin_29185167的博客
05-19 691
接下来，让我们再看一下浮点数之间比较大小的操作，我们以图1.31中的代码为例。在浮点数的编码中，IEEE754引入了一些特殊的编码来表示正无穷大、负无穷大，因为一个正浮点数除以0则得到正无穷大，而一个负浮点数除以0则得到负无穷大；而在实数范畴内，是不能对一个负数进行开根号的，所以IEEE754也引入了一个称为Not ANumber的特殊编码来表示这样的运算结果为“不是一个实数”，简写为NaN。 图...
编译原理 简单计算器的编译器的设计与实现（附源码）
hhypractise的博客
07-05 8694
简单计算器的编译器的设计与实现 通过设计、编制、调试一个算术表达式编译器，进一步加深对编译器的词法分析、语法分析、错误处理及输出等环节的理解，获得对实际编译器的构造原理、过程和方法的感性认识，系统掌握语法制导翻译技术。 已知有如下的布尔表达式文法: E→E+T|E-T|T T→T*F|T/F|F F→ +(E)|id 利用LR分析法编制、调试其语法分析程序,生成的中间代码为后缀表达式，通过语法制导定义和后缀表达式进行计算。编制好分析程序后计若干用例，上机 测试并通过所设计的分析程序。算术表达式的LR分析分为
java实现简单的词法分析
03-29
总结起来，"java实现简单的词法分析"是一个很好的起点，让你亲自动手实现编译器的一个重要组成部分。通过这个项目，你不仅可以学习到Java编程，还能深入理解编译原理中的词法分析概念，提升自己的技术能力。对于初学...
2020-10.rar_编译器/解释器_C/C++__编译器/解释器_C/C++_
08-09
在这个"2020-10.rar"压缩包中，包含的三个文件——`Complier.cpp`、`main.cpp`和`Complier.h`，分别代表了编译器的主要实现部分、主程序入口和编译器相关的头文件。`Complier.cpp`可能是实现词法分析、语法分析、...
TINY 编译器源代码
10-25
在实际操作中，读者可以通过阅读tc源代码，了解每个部分如何实现上述功能，进而动手修改和调试，加深对编译器设计的掌握。这是一次极好的理论与实践结合的学习机会，对于有意从事编译器开发或者软件工程领域的学习者...
编译原理实验：C编译器源代码
11-19
通过这个实验项目，学习者不仅可以了解编译器的基本工作流程，还能实际动手实现编译器的不同部分，从而增强对编译原理的理解。这对于软件开发、系统级编程以及计算机科学教育都是非常有价值的。
编译原理动手实操,用java实现编译器-算术表达式及其语法解析器的实现
tyler_download的专栏
02-26 6098
大家在参考本节时，请先阅读以下博文，进行预热： http://blog.csdn.net/tyler_download/article/details/50708807   本节代码下载地址： http://pan.baidu.com/s/1sjWiwPn 代码的理解和运行是吃透编译原理的关键，如果我们看的是爱情动作片，自然选择无码的好，但如果看得是计算机课程，则必须有码，无码的计算机理
编译原理课程实践——实现一个初等函数运算语言的解释器或编译器
SylvanDing's Blog
07-01 1972
本文主要内容是设计词法分析器、语法分析器（LL(1)、SLR(1)）和语义分析器（基于SLR(1)），实现一个初等函数运算语言的解释器或编译器。在设计词法分析器和语法分析器时，由于考虑尚不完善，以至于进行语义分析和语法制导翻译时存在困难，但本文仍能让读者了解构建词法分析器和递归下降的语法分析器的原理和基本方法，掌握最简单的编译器的实现过程。...
c语言中字符串比较指令,如何比较C条件预处理程序指令中的字符串
weixin_34061587的博客
05-20 352
[更新：2018.05.03]CAVEAT：并非所有编译器都以相同的方式实现C ++ 11规范。下面的代码在我测试的编译器中工作，而许多评论者使用不同的编译器。引自Shafik Yaghmour的回答：在编译时计算C字符串的长度。 这真的是一个constexpr吗？不保证在编译时计算常量表达式 时间，我们只有草案C ++标准的非规范性引用 5.19节这样说的常量表达式：[...]＆gt; ...
手动写编译器实现加减乘除运算
r643064456的博客
11-25 1415
手动写编译器实现加减乘除运算
关于不同编译器下C语言中自加(++)运算符的解释
web开发
02-07 398
这篇备忘是由同学发的一个疑问，确实我也忘了我在学的时候遇到这个问题么有，主要是很少这么用过，而且纯数学计算也没有怎么写过。因为相对来说，用matlab会更好。 其实C语言是门精美的语言，也是我认为最为舒服的语言，只是没有面向对象，扩展后的C++语法复杂性爆炸增长，而且各种库也比较蛋疼，MFC也成了昨日黄花，不知道Object-C如何，想必苹果用的东西应该还可以。要是哪天牛逼到自己写个C的...
比较运算符
weixin_44050355的博客
01-12 3476
/* 比较运算符 大于：> 小于：< 大于等于：>= 小于等于：<= 等于：= 赋值和比较都是用= Mysql 只有 = 没有 == 不等于：!= 或 <> 安全等于：<=> */ #查询薪资大于20000的员工 SELECT * FROM t_employee WHERE salary > 20000; #查询薪资等于9...
python基础
Sk_Ya的博客
06-19 1171
1、python优点 1）、易于阅读和维护 2）、有一个广泛的标准库 3）、python支持坏人各种主流数据库之间的交互 4）、可扩展性和可移植性 5）、GUI编程【图形化界面】 6）、可嵌入型【可以将python程序嵌入到c++中】 缺点：执行效率相对慢 2、python的变量的类型 基本的五种类型： numbers：数字类型 String：字符串类型 List：列表 Tuple：元组 Dictionary：字典 数字类型包括：int（整数），long（长整数），True/False（布尔型），Float
js（三）比较运算符、逻辑运算符
StevenTang957的博客
03-02 396
写在最前面js(二)里面说了简单的加减乘除现在来说另外两种运算符比较运算符“&gt;”、“&lt;”、“==”、“&gt;=”、“&lt;=”、“!=”比较的结果为boolean值逻辑运算符“&amp;&amp;”、“||”、“!”运算结果为真实的值被认定为false的值undefined、null、NaN、""、0、false计较运算符var a = ...
自己动手写编译器 链接器 pdf csdn
最新发布
01-30
自己动手写编译器和链接器对于计算机科学和软件工程领域的学习者来说是一项非常有挑战性和有益的任务。下面我将简要介绍如何在CSDN上找到相关的学习资源和教程。 首先，编译器和链接器是计算机软件开发中非常重要的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值