词法分析器JavaCC

最新推荐文章于 2025-05-26 10:00:50 发布
原创 最新推荐文章于 2025-05-26 10:00:50 发布 · 1k 阅读 · 16 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java

词法分析器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() {
  }

}
熙尛
关注
javacc 词法分析器
05-31
对一句话的关键词进行分析，挑出关键词的一种工具
javacc 词法分析
half_m的博客
01-16 1634
javacc 词法分析 词法分析器的功能和输出格式 词法分析器的功能是读入测试源程序，输出单词序列。词法分析器的单词常 表示成二元式：(单词种别码，单词在源代码中的字符串)。 词法分析器需要把对象语言的词法规则全部描述出来，在这我们取 C 语 言子集，它的词法定义如下： （1）关键字 KEYWORD if else int return void while…….. 所有的关键字都是小写。 （2）标识符 IDENTIFIER 标识符的定义采取正则表达式定义方式，标识符由字母、数字、下
Java实现带界面的C语言词法分析器
最新发布
weixin_34456923的博客
05-26 923
词法单元是编程语言中的基本构建块，每个词法单元可以进一步分类为关键字、标识符、数字、字符串、运算符或分隔符。例如，在Java中，“int”是一个关键字，而“x”可能是一个标识符。在实现词法分析器时，这些词法单元的定义需要被明确，并且分析器必须能够准确地识别它们。在编译原理中，词法单元通常由两部分组成：词法单元的名称：代表了词法单元的语义类型，如IDENTIFIER（标识符）、NUMBER（数字）、OPERATOR（运算符）等。词法单元的属性值。
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 668
为语法编写词法规范的方法有很多种，但生成的令牌管理器的性能可能会因您的操作方式而有很大差异。使用它们时，尝试将所有复杂的正则表达式移动到一个词法状态，让其他人只识别简单的字符串文字。这将使识别速度更快。请注意，如果选择是在两个复杂的正则表达式之间进行，那么可以选择。当然，如果你的语法规定其中之一不能使用，那么你别无选择，只能尽量使用< ~[] >。按长度增加的顺序指定所有字符串文字，即所有较短的字符串文字在较长的字符串文字之前。相反，为此有两种不同的令牌类型，并使用非终端，这是这些选择之间的选择。
编译原理中用javacc实现MiniC的词法分析、语法分析、语义分析
02-23
用Javacc实现MiniC的词法分析、语法分析、语义分析。在词法分析部分根据单词的构词规则分类，输出二元式；在语法分析部分利用Javacc实现LL(1)文法，判断源语言是否符合MiniC的语法，如果不符合，给出语法错误信息；语义分析部分是在语法分析的基础上根据属性文法制导翻译，进行语义分析，输出四元式。
编译原理-词法分析javacc实现
llx20001212的博客
12-21 347
编译原理-词法分析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 1756
使用JavaCC做语法分析[转] 实用javacc   前言 本系列的文章的宗旨是让大家能够写出自己的编译器,解释器或者脚本引擎,所以每到理论介绍到一个程度后,我都会来讨论实践问题.理论方面,编译原理的教材已经是够多了,而实践的问题却很少讨论.   前几节文章只讨论到了词法分析和LL文法分析,关键的LR文法分析这里却还没有讲,我们先不要管复杂的LR文法和算法,让我们使用LL算法来实际
词法分析java
zhaojianyin
03-28 2206
欢迎使用Markdown编辑器写博客本Markdown编辑器使用StackEdit修改而来，用它写博客，将会带来全新的体验哦： Markdown和扩展Markdown简洁的语法 代码块高亮 图片链接和图片上传 LaTex数学公式 UML序列图和流程图 离线写博客 导入导出Markdown文件 丰富的快捷键 快捷键 加粗 Ctrl + B 斜体 Ctrl + I 引用 Ctrl
Java实现词法分析
weixin_52008431的博客
04-26 4673
目录 词法分析说明 实现原理分析 代码实现 结果图 词法分析说明 编制一个读单词过程，从输入的源程序中，识别出各个具有独立意义的单词，即基本保留字、标识符、常数、运算符、分隔符五大类。并依次输出各个单词的内部编码及单词符号自身值。 例如： 如源程序为C语言。输入如下一段： main() { int a=-5,b=4,j; if(a>=b) j=a-b; else j=b-a; } 要求输出： （”main”，1，1） （”（”，5） （”）.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值