词法分析器JavaCC

最新推荐文章于 2022-11-26 17:11:32 发布
最新推荐文章于 2022-11-26 17:11:32 发布
阅读量930 收藏 15
点赞数 3
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mj256115/article/details/116376909
版权

词法分析器JavaCC

程序输入：从test.txt文件中读取内容

void main()
{
while(a>45)
{
int x,x1;
x=x1+1;
}
}

程序输出：识别出的单词序列，格式为：（种别码，属性值）
在这里插入图片描述

一、支持类型

能识别关键字、标识符、常量（整常数、浮常数、字符串）、运算符、分隔符。能处理单行和多行注释。支持识别的各单词种别码及宏定义如下表

单词

种别码

宏

单词

种别码

宏

单词

种别码

宏

and

1

AND

Or

22

OR

/

43

RDIV

array

2

ARRAY

Packed

23

PACKED

=

44

EQ

begin

3

BEGIN

procedure

24

PROC

< 

45

LT

case

4

CASE

Program

25

PROG

> 

46

GT

const

5

CONST

Record

26

RECORD

<=

47

LE

div

6

DIV

Repeat

27

REPEAT

>=

48

GE

do

7

DO

Set

28

SET

<> 

49

NE

downto

8

DOWNTO

Then

29

THEN

(

50

LA_BRAC

else

9

ELSE

To

30

TO

)

51

BR_BRAC

end

10

END

Type

31

TYPE

,

52

COMMA

file

11

FILE

Until

32

UNTIL

、

53

P_MARK

for

12

FOR

Car

33

CAR

.

54

F_STOP

function

13

FUNC

While

34

WHILE

..

55

RANGE

goto

14

GOTO

With

35

WITH

:

56

COLON

if

15

IF

标识符

36

ID

:=

57

ASSIGN

in

16

IN

整常数

37

INT

;

58

SEMIC

label

17

LABEL

实常数

38

REAL

^

59

CAP

mod

18

MOD

字符串

39

STRING

**

60

EXP

nil

19

NIL

+

40

PLUS

[

61

LS_BRAC

not

20

NOT

-

41

MINUS

]

62

RS_BRAC

of

21

OF

*

 

MULTI

‘

63

Q_MARK

main方法

public class lexical
{
  public static void main(String args [])
  {
    System.out.println("Reading from standard input...");
    System.out.print("Enter an expression like \"1+(2+3)*var;\" :");
try {
			lexical a;
			String file = "test.txt";
			FileInputStream fin=new FileInputStream(file);
			SimpleCharStream scs = new SimpleCharStream(fin);
			lexicalTokenManager tm=new lexicalTokenManager(scs);
			Token t;
			int i=0;
			while(true)
			{
				t=tm.getNextToken();
				if(t.kind==0)break;
				System.out.println(t.kind+ "\t" +t.toString());
			}
		} catch (FileNotFoundException e) {
			// TODO 自动生成的 catch 块
			e.printStackTrace();
		}
  }
}

TOKEN

TOKEN : /* LITERALS */
{
  < INTEGER_LITERAL :
    < DECIMAL_LITERAL > ([ "l", "L" ])?
  | < HEX_LITERAL > ([ "l", "L" ])?
  | < OCTAL_LITERAL > ([ "l", "L" ])? 
    >
| < #DECIMAL_LITERAL : [ "1"-"9" ] ([ "0"-"9" ])* >
| < #HEX_LITERAL : "0" [ "x", "X" ] ([ "0"-"9", "a"-"f", "A"-"F" ])+ >
| < #OCTAL_LITERAL : "0" ([ "0"-"7" ])* >
}

TOKEN : /*keywords*/
{
  < WHILE : "while" >
| < IF : "if" >
}

TOKEN : /*OPERATORS*/
{
  < ADD : "+" >
| < MUL : "*" >
}

TOKEN : /*separators*/
{
  < COMMA : "," >
| < SEMI : ";" >
}


TOKEN : /*kuohao*/
{
  < LPAREN : "(" >
| < RPAREN : ")" >
| < LCURLY : "{" >
| < RCURLY : "}" >
| < GT : ">" >
| < EQ : "=" >
| < LT : "<" >
}

TOKEN : /* IDENTIFIERS */
{
  < IDENTIFIER :
    < LETTER >
    (
      < LETTER >
    | < DIGIT >
    )* >
| < #LETTER : [ "_", "a"-"z", "A"-"Z" ] >
| < #DIGIT : [ "0"-"9" ] >
}

lexical.java源代码

/* Generated By:JJTree&JavaCC: Do not edit this line. lexical.java */
package lexicalll;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
public class lexical/*@bgen(jjtree)*/implements lexicalTreeConstants, lexicalConstants {/*@bgen(jjtree)*/
  protected JJTlexicalState jjtree = new JJTlexicalState();public static void main(String args [])
  {
    System.out.println("Reading from standard input...");
    System.out.print("Enter an expression like \u005c"1+(2+3)*var;\u005c" :\n");
//    lexical parser = new lexical(System.in);
//    try
//    {
//      SimpleNode n = parser.Start();
//      n.dump("");
//      System.out.println("Thank you.");
//    }
//    catch (Exception e)
//    {
//      System.out.println("Oops.");
//      System.out.println(e.getMessage());
//    }
try {
                        lexical a;
                        String file = "test.txt";
                        FileInputStream fin=new FileInputStream(file);
                        SimpleCharStream scs = new SimpleCharStream(fin);
                        lexicalTokenManager tm=new lexicalTokenManager(scs);
                        Token t;
                        int i=0;
                        while(true)
                        {
                                t=tm.getNextToken();
                                if(t.kind==0)break;
                                System.out.println(t.kind+ "\u005ct" +t.toString());
                        }
                } catch (FileNotFoundException e) {
                        // TODO 自动生成的 catch 块
                        e.printStackTrace();
                }
  }

  final public SimpleNode Start() throws ParseException {
 /*@bgen(jjtree) Start */
  SimpleNode jjtn000 = new SimpleNode(JJTSTART);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      Expression();
      jj_consume_token(SEMI);
    jjtree.closeNodeScope(jjtn000, true);
    jjtc000 = false;
    {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
    throw new Error("Missing return statement in function");
  }

  final public void Expression() throws ParseException {
 /*@bgen(jjtree) Expression */
  SimpleNode jjtn000 = new SimpleNode(JJTEXPRESSION);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      AdditiveExpression();
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void AdditiveExpression() throws ParseException {
 /*@bgen(jjtree) AdditiveExpression */
  SimpleNode jjtn000 = new SimpleNode(JJTADDITIVEEXPRESSION);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      MultiplicativeExpression();
      label_1:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case ADD:
        case 27:
          ;
          break;
        default:
          jj_la1[0] = jj_gen;
          break label_1;
        }
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case ADD:
          jj_consume_token(ADD);
          break;
        case 27:
          jj_consume_token(27);
          break;
        default:
          jj_la1[1] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
        MultiplicativeExpression();
      }
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void MultiplicativeExpression() throws ParseException {
 /*@bgen(jjtree) MultiplicativeExpression */
  SimpleNode jjtn000 = new SimpleNode(JJTMULTIPLICATIVEEXPRESSION);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      UnaryExpression();
      label_2:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case MUL:
        case 28:
        case 29:
          ;
          break;
        default:
          jj_la1[2] = jj_gen;
          break label_2;
        }
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case MUL:
          jj_consume_token(MUL);
          break;
        case 28:
          jj_consume_token(28);
          break;
        case 29:
          jj_consume_token(29);
          break;
        default:
          jj_la1[3] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
        UnaryExpression();
      }
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void UnaryExpression() throws ParseException {
 /*@bgen(jjtree) UnaryExpression */
  SimpleNode jjtn000 = new SimpleNode(JJTUNARYEXPRESSION);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case LPAREN:
        jj_consume_token(LPAREN);
        Expression();
        jj_consume_token(RPAREN);
        break;
      case IDENTIFIER:
        Identifier();
        break;
      case INTEGER_LITERAL:
        Integer();
        break;
      default:
        jj_la1[4] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void Identifier() throws ParseException {
 /*@bgen(jjtree) Identifier */
  SimpleNode jjtn000 = new SimpleNode(JJTIDENTIFIER);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      jj_consume_token(IDENTIFIER);
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  final public void Integer() throws ParseException {
 /*@bgen(jjtree) Integer */
  SimpleNode jjtn000 = new SimpleNode(JJTINTEGER);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
    try {
      jj_consume_token(INTEGER_LITERAL);
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
    }
    }
  }

  /** Generated Token Manager. */
  public lexicalTokenManager token_source;
  SimpleCharStream jj_input_stream;
  /** Current token. */
  public Token token;
  /** Next token. */
  public Token jj_nt;
  private int jj_ntk;
  private int jj_gen;
  final private int[] jj_la1 = new int[5];
  static private int[] jj_la1_0;
  static {
      jj_la1_init_0();
   }
   private static void jj_la1_init_0() {
      jj_la1_0 = new int[] {0x8002000,0x8002000,0x30004000,0x30004000,0x1020080,};
   }

  /** Constructor with InputStream. */
  public lexical(java.io.InputStream stream) {
     this(stream, null);
  }
  /** Constructor with InputStream and supplied encoding */
  public lexical(java.io.InputStream stream, String encoding) {
    try { jj_input_stream = new SimpleCharStream(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); }
    token_source = new lexicalTokenManager(jj_input_stream);
    token = new Token();
    jj_ntk = -1;
    jj_gen = 0;
    for (int i = 0; i < 5; i++) jj_la1[i] = -1;
  }

  /** Reinitialise. */
  public void ReInit(java.io.InputStream stream) {
     ReInit(stream, null);
  }
  /** Reinitialise. */
  public void ReInit(java.io.InputStream stream, String encoding) {
    try { jj_input_stream.ReInit(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); }
    token_source.ReInit(jj_input_stream);
    token = new Token();
    jj_ntk = -1;
    jjtree.reset();
    jj_gen = 0;
    for (int i = 0; i < 5; i++) jj_la1[i] = -1;
  }

  /** Constructor. */
  public lexical(java.io.Reader stream) {
    jj_input_stream = new SimpleCharStream(stream, 1, 1);
    token_source = new lexicalTokenManager(jj_input_stream);
    token = new Token();
    jj_ntk = -1;
    jj_gen = 0;
    for (int i = 0; i < 5; i++) jj_la1[i] = -1;
  }

  /** Reinitialise. */
  public void ReInit(java.io.Reader stream) {
    jj_input_stream.ReInit(stream, 1, 1);
    token_source.ReInit(jj_input_stream);
    token = new Token();
    jj_ntk = -1;
    jjtree.reset();
    jj_gen = 0;
    for (int i = 0; i < 5; i++) jj_la1[i] = -1;
  }

  /** Constructor with generated Token Manager. */
  public lexical(lexicalTokenManager tm) {
    token_source = tm;
    token = new Token();
    jj_ntk = -1;
    jj_gen = 0;
    for (int i = 0; i < 5; i++) jj_la1[i] = -1;
  }

  /** Reinitialise. */
  public void ReInit(lexicalTokenManager tm) {
    token_source = tm;
    token = new Token();
    jj_ntk = -1;
    jjtree.reset();
    jj_gen = 0;
    for (int i = 0; i < 5; i++) jj_la1[i] = -1;
  }

  private Token jj_consume_token(int kind) throws ParseException {
    Token oldToken;
    if ((oldToken = token).next != null) token = token.next;
    else token = token.next = token_source.getNextToken();
    jj_ntk = -1;
    if (token.kind == kind) {
      jj_gen++;
      return token;
    }
    token = oldToken;
    jj_kind = kind;
    throw generateParseException();
  }


/** Get the next Token. */
  final public Token getNextToken() {
    if (token.next != null) token = token.next;
    else token = token.next = token_source.getNextToken();
    jj_ntk = -1;
    jj_gen++;
    return token;
  }

/** Get the specific Token. */
  final public Token getToken(int index) {
    Token t = token;
    for (int i = 0; i < index; i++) {
      if (t.next != null) t = t.next;
      else t = t.next = token_source.getNextToken();
    }
    return t;
  }

  private int jj_ntk() {
    if ((jj_nt=token.next) == null)
      return (jj_ntk = (token.next=token_source.getNextToken()).kind);
    else
      return (jj_ntk = jj_nt.kind);
  }

  private java.util.List<int[]> jj_expentries = new java.util.ArrayList<int[]>();
  private int[] jj_expentry;
  private int jj_kind = -1;

  /** Generate ParseException. */
  public ParseException generateParseException() {
    jj_expentries.clear();
    boolean[] la1tokens = new boolean[30];
    if (jj_kind >= 0) {
      la1tokens[jj_kind] = true;
      jj_kind = -1;
    }
    for (int i = 0; i < 5; i++) {
      if (jj_la1[i] == jj_gen) {
        for (int j = 0; j < 32; j++) {
          if ((jj_la1_0[i] & (1<<j)) != 0) {
            la1tokens[j] = true;
          }
        }
      }
    }
    for (int i = 0; i < 30; i++) {
      if (la1tokens[i]) {
        jj_expentry = new int[1];
        jj_expentry[0] = i;
        jj_expentries.add(jj_expentry);
      }
    }
    int[][] exptokseq = new int[jj_expentries.size()][];
    for (int i = 0; i < jj_expentries.size(); i++) {
      exptokseq[i] = jj_expentries.get(i);
    }
    return new ParseException(token, exptokseq, tokenImage);
  }

  /** Enable tracing. */
  final public void enable_tracing() {
  }

  /** Disable tracing. */
  final public void disable_tracing() {
  }

}
熙尛
关注
  • 3
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java实现简单词法、语法分析器
编程小鹏的博客
06-08 310
语法分析器是编译器中的关键组件，用于检查源代码是否遵循编程语言的语法规则。词法分析器是编译器中的一个关键组件，用于将源代码解析成词法单元。
javacc 词法分析器
05-31
对一句话的关键词进行分析，挑出关键词的一种工具
javacc 词法分析
half_m的博客
01-16 1417
javacc 词法分析 词法分析器的功能和输出格式 词法分析器的功能是读入测试源程序，输出单词序列。词法分析器的单词常 表示成二元式：(单词种别码，单词在源代码中的字符串)。 词法分析器需要把对象语言的词法规则全部描述出来，在这我们取 C 语 言子集，它的词法定义如下： （1）关键字 KEYWORD if else int return void while…….. 所有的关键字都是小写。 （2）标识符 IDENTIFIER 标识符的定义采取正则表达式定义方式，标识符由字母、数字、下
javacc 词法分析解释器例子
10-16
cmm javacc 对CMM语言的词法语法分析器的自动实现
JavaCC词法分析器 单词定义超详细 基于Eclipse插件 能从文件读取源代码 输出种别编码和对应单词
12-20
在学编译原理，自己写的，已经比较完善了，希望对你有所帮助，使用/src/la/LexicalTest.java来进行测试
JavaCC语法分析词法分析源代码
11-18
JavaCC语法分析词法分析源代码；解释器构造，编译原理
《实习一：词法分析(javacc)》内有源码
05-06
JavaCC是一个强大的工具，用于生成词法分析器和语法分析器，广泛应用于编译器和解释器的开发。 在JavaCC中，词法分析涉及到几个核心类： 1. **Token** 类：这是表示单词的基本类。`Token`对象包含以下几个主要属性...
基于java实现的语法分析器及词法分析器
最新发布
04-17
在编程语言处理领域，语法分析器和词法分析器是至关重要的组成部分，它们主要用于解析源代码，将其转化为计算机可以理解的形式。在这个项目中，我们关注的是一个基于Java实现的语法分析器和词法分析器。Java是一种...
javacc之路5---词法分析器技巧
u013257767的博客
11-26 610
为语法编写词法规范的方法有很多种，但生成的令牌管理器的性能可能会因您的操作方式而有很大差异。使用它们时，尝试将所有复杂的正则表达式移动到一个词法状态，让其他人只识别简单的字符串文字。这将使识别速度更快。请注意，如果选择是在两个复杂的正则表达式之间进行，那么可以选择。当然，如果你的语法规定其中之一不能使用，那么你别无选择，只能尽量使用< ~[] >。按长度增加的顺序指定所有字符串文字，即所有较短的字符串文字在较长的字符串文字之前。相反，为此有两种不同的令牌类型，并使用非终端，这是这些选择之间的选择。
编译原理中用javacc实现MiniC的词法分析、语法分析、语义分析
02-23
用Javacc实现MiniC的词法分析、语法分析、语义分析。在词法分析部分根据单词的构词规则分类，输出二元式；在语法分析部分利用Javacc实现LL(1)文法，判断源语言是否符合MiniC的语法，如果不符合，给出语法错误信息；语义分析部分是在语法分析的基础上根据属性文法制导翻译，进行语义分析，输出四元式。
编译原理-词法分析javacc实现
llx20001212的博客
12-21 282
编译原理-词法分析javacc实现
词法分析（java）
12-13
词法分析（java）
词法分析器java
11-13
编译词法分析器，用java编写的 public class analyetest { public ArrayList bracket; public ArrayList keyword; public ArrayList symbol; public ArrayList semicolon; public ArrayList operator; static HashMap BRACKET; static HashMap KEYWORD; static HashMap SEMICOLON; static HashMap OPERATOR; public analyetest() { this.KEYWORD = new HashMap(); this.BRACKET = new HashMap(); this.SEMICOLON = new HashMap(); this.OPERATOR = new HashMap(); this.bracket = new ArrayList(); this.keyword = new ArrayList(); this.symbol = new ArrayList(); this.semicolon = new ArrayList(); this.operator = new ArrayList(); }
词法分析程序java版
06-05
编译原理实验写的一份小型词法分析程序,具体掌握基本分析方法,此程序是对源代码的一次分析,可能输出的有点多.
词法分析器（Java实现）
12-30
自己写的课程作业词法分析器，大概一千行左右，支持从文本输入正则表达式构造出DFA。给出源程序能出token序列。
词法分析器(java实现)
07-09
通过java实现词法分析器。 解压： 1) src文件夹：实现代码 2)data文件夹：测试代码 3)README：说明文档
使用JavaCC做语法分析[转]
qq_20125305的专栏
09-22 1699
使用JavaCC做语法分析[转] 实用javacc   前言 本系列的文章的宗旨是让大家能够写出自己的编译器,解释器或者脚本引擎,所以每到理论介绍到一个程度后,我都会来讨论实践问题.理论方面,编译原理的教材已经是够多了,而实践的问题却很少讨论.   前几节文章只讨论到了词法分析和LL文法分析,关键的LR文法分析这里却还没有讲,我们先不要管复杂的LR文法和算法,让我们使用LL算法来实际
词法分析java
zhaojianyin
03-28 2151
欢迎使用Markdown编辑器写博客本Markdown编辑器使用StackEdit修改而来，用它写博客，将会带来全新的体验哦： Markdown和扩展Markdown简洁的语法 代码块高亮 图片链接和图片上传 LaTex数学公式 UML序列图和流程图 离线写博客 导入导出Markdown文件 丰富的快捷键 快捷键 加粗 Ctrl + B 斜体 Ctrl + I 引用 Ctrl
词法分析器Java
Mr_lilongsha的博客
11-05 638
本文章是一篇关于记法分析的程序代码。 本代码还并不完善，只是一雏形还有许多需要改进的地方。 仅供参考：如有问题可发邮件询问 lilongsha@163.com 记法分析主程序:Wordanalysis.java package com.lfsf.lls; import java.util.Scanner; public class Wordanalysis { @Suppress
JavaCC入门教程：解析器与词法分析器详解
JavaCC是一种强大的工具，它同时作为解析器生成器和词法分析器生成器。在IT行业中，编译器和解释器通常会整合词法分析器和解析器来处理包含程序的字符序列输入。然而，这些软件组件的应用远不止于此，它们广泛应用于...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值