https://github.com/bhsh0112/compile

https://github.com/bhsh0112/compile

Repository

https://github.com/bhsh0112/compile/blob/main/

### 1 

		

		

### 2 

#### 2.1 

		tokentoken

#### 2.2 token

		token

		

```java
String patternString = 
            "(\\b(main|const|int|char|break|continue|if|else|for|return|void|while)\\b)|" + // 
            "(\\b(getint|getchar|printf)\\b)|"+//
            "(\\b[a-zA-Z_][a-zA-Z0-9_]*\\b)|" + // 
            "(\\b\\d+\\b)|" + // 
            "(\".*?\")|" +
            "(//)|"+//
            "(==|!=|<=|>=|<|>|&&|\\|\\||=|\\+|-|/\\*|\\*/|/\\*|\\*/|\\*|/|%|\\{|\\}|\\(|\\)|\\[|\\]|;|,|&|!|\\|)|" + // 
            "(\'(\\\\.|[^\\'])\')|"+
            "(\\s+)"; // 
```

		token

```java
Pattern pattern = Pattern.compile(patternString);
Matcher matcher = pattern.matcher(code);
```

		token

```java
while (matcher.find()) {
            if(matcher.group().equals("/*")){
                zhuflag=true;
            }
            if(matcher.group().equals("*/")){
                zhuflag=false;
                continue;
            }
            if(matcher.group().equals("//")&&!zhuflag) break;
            if (!matcher.group().matches("\\s+")&&!zhuflag) { // 
                tokens.add(matcher.group());
            }
        }
```

			tokenize

#### 2.3 

		(**Ident**,**IntConst**,**StringConst**,**CharConst**)

		

```java
private static final Map words = new HashMap<>();
static {
        words.put("main", "MAINTK");
        words.put("const", "CONSTTK");
        words.put("int", "INTTK");
        words.put("char", "CHARTK");
        words.put("break", "BREAKTK");
        words.put("continue", "CONTINUETK");
        words.put("if", "IFTK");
        words.put("else", "ELSETK");
        words.put("for", "FORTK");
        words.put("getint", "GETINTTK");
        words.put("getchar", "GETCHARTK");
        words.put("printf", "PRINTFTK");
        words.put("return", "RETURNTK");
        words.put("void", "VOIDTK");
        words.put(";", "SEMICN");
        words.put("!", "NOT");
        words.put("*", "MULT");
        words.put(",", "COMMA");
        words.put("&&", "AND");
        words.put("||", "OR");
        words.put("/", "DIV");
        words.put("%", "MOD");
        words.put("(", "LPARENT");
        words.put(")", "RPARENT");
        words.put("[", "LBRACK");
        words.put("]", "RBRACK");
        words.put("{", "LBRACE");
        words.put("}", "RBRACE");
        words.put("<", "LSS");
        words.put("<=", "LEQ");
        words.put(">", "GRE");
        words.put(">=", "GEQ");
        words.put("==", "EQL");
        words.put("!=", "NEQ");
        words.put("+", "PLUS");
        words.put("-", "MINU");
        words.put("=", "ASSIGN");
    }
```

		

		token

		Ident

```java
    private static boolean isIdentifier(String token) {
        return token.matches("[a-zA-Z_][a-zA-Z0-9_]*");
    }
```

#### 2.4 

		tokentoken

### 3 

#### 3.1 

		

#### 3.2 

		

		

		



first

#### 3.3 

		

- token
- first2token
- 

#### 3.4 

		

- tokenizetoken
- is+
- 
- parser+
- is+
- addNode,insertNode,deletNodepostTraversal

		dataStructureENode()NNode()TNodetoken

### 



****

	debugdebug

	



### 4 

	

### 5 LLVMIR

#### 5.1 

llvm**`llvm.ir.Module.main`**

llvm

```
--llvm
	  |----AddTreeNode.javaAddTree
	  |____ir
	  		  |----NameAllocator.javaValue
	  		  |----StrNameAllocator.javaprintf
	  		  |----Moudle.javallvm
	  		  |____value
	  		  			 |----AddExp.javaAddExp
	  		  			 |----BasicBlock.javaBlock
	  		  			 |----FormatString.javaprintf
	  		  			 |----Function.javamain
	  		  			 |----FunctionParam.java
	  		  			 |----GlobalArray.javaGlobalValue
	  		  			 |----GlobalValue.java
	  		  			 |----GlobalVar.javaGlobalValue
	  		  			 |----ImmediateValue.java
	  		  			 |----InitVal.java
	  		  			 |----Label.java
	  		  			 |----StringConst.java
	  		  			 |----Use.java
	  		  			 |----User.java
	  		  			 |----Value.javaValue
	  		  			 |----instLLVM
	  		  			 |			|----AddInst.java
	  		  			 |			|----AllocaInst.java
	  		  			 |			
	  		  			 |____Type
	  		  			 				|----Type.java
	  		  			 				|----ReturnType.java
	  		  			 				|____VarType.java
```



#### 5.2 

- Module

  - Global Value
    - 
    - 

  - Functionmain
    - BlockBasicBlock
      - 



		MoudleBasicBlockBasicBlock

#### 5.3 

		modulemoduleArrayList

```java
public static ArrayList globalValues = new ArrayList<>();
public static ArrayList functions = new ArrayList<>();
```

##### 5.3.1 

		sysymoduleGlobalValue

##### 5.3.2 

		sysymoduleFunction

```java
ReturnType retType=new ReturnType(symbol.getASTNodeContent(parent, new int[] {0,0}));
String funcName=symbol.getASTNodeContent(parent, new int[] {1,0});
int paraNum=(parent.children.size()==5)?0:symbol.getASTNode(parent, new int[] {3}).children.size()/2+1;
ArrayList paraTypes=new ArrayList();
if (paraNum==0) paraTypes=null;
String[] paraNames=new String[paraNum];
for(int i=0;ibasicBlock->AddExp->xxInst
```

	**`alloca+AddExp+store`**

##### 5.3.4 ()

	**`load+AddExp+store`**

##### 5.3.5 

###### 

	**`getint/getchar:+call`**

									**`printf:formatstring+AddExp{+putint}{+putch`}**

###### 

	**`[+][AddExp+]call`**

##### 5.3.6 

	**`AddExp+return`**

#### 5.4 AddExp

	AddExpAddExpAddExp

	

- AddTree

  ```java
  public class AddTreeNode {
      public String value; // 
      public List children; // 
      public Value exp;
      public String type;
  
      public AddTreeNode(String value) {
          this.value = value;
          this.children = new ArrayList<>();
      }
  
      // 
      public void addChild(AddTreeNode child) {
          children.add(child);
      }
  }
  ```

		

		

		

		1.valueexpvalue

		2.valueexpLoadvalue

		3.valuefuncexpcallvalue

		4.valuetmppAddTree

		intcharintimmcharimm

- AddTree

  

  `flashType()`AddExptype

  ```java
  public void flashType(AddTreeNode parent){
  		type=parent.type;
  }
  ```

		

		charImmintImmintImm

value

```java
AddTreeNode left,right;
left=parent.children.get(0);
right=parent.children.get(2);
if(left.type.equals("charImm")){
  left.value=String.valueOf((int)(left.value.charAt(1)));
  left.exp=new Value(left.value);
  left.type="intImm";
}
if(right.type.equals("charImm")){
  right.value=String.valueOf((int)(right.value.charAt(1)));
  right.exp=new Value(right.value);
  right.type="intImm";
}
System.out.println(left.value+" "+right.value);
if(left.type.equals("intImm")&&right.type.equals("intImm")){
  switch(parent.children.get(1).value){
    case "+":
      value=new Value(String.valueOf(Integer.valueOf(left.value)+Integer.valueOf(right.value)));
      parent.exp=value;
      parent.value=value.name;
      parent.type="intImm";
      break;
    //...
  }
}
else{
  switch(parent.children.get(1).value){
    case "+":
      value=basicBlock.createAddInst((left.type.equals("char"))?basicBlock.createZextInst(left.exp):left.exp, (right.type.equals("char"))?basicBlock.createZextInst(right.exp):right.exp);
      parent.exp=value;
      parent.type="int";
      break;
    //...
  }
}
```



#### 5.5 

##### 5.5.1 

	intcharintImmcharImm

	

```java
if(((VarType)tmpType).type.equals("int")&&tmpAddExp.type.equals("char")) from=createZextInst(from);
else if(((VarType)tmpType).type.equals("char")&&tmpAddExp.type.equals("int")) from=createTruncInst(from);
else if(((VarType)tmpType).type.equals("int")&&tmpAddExp.type.equals("charImm")){
	from.name=String.valueOf((int)(from.name.charAt(1)));
}
```

	

##### 5.5.2 

	AddExpPrintfReturn

Owner

GitHub Events