１、プログラムと各部の説明
作成したコンパイラのプログラムの説明を行う。
最初に作成したコンパイラのプログラムを記述しておく。

プログラムソース'compiler.c'ここから↓
-------------------------------------------------------------------------------------------------------------
/*--------------------------------------------------------------------------------------------*/
/*                               四則演算を解析するコンパイラ                                 */
/*--------------------------------------------------------------------------------------------*/
/*                                作成者：松本亮介(Ryousuke Matsumoto)                        */
/*                                作成日：2006.01.31                                          */
/*--------------------------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------------------------*/
/*                                  ファイル名: compiler.c                                    */
/*--------------------------------------------------------------------------------------------*/

#include <stdio.h>
#include<stdlib.h>
#include <ctype.h>

#define MAXLENG 128
#define MAXLENGS 256

/* ------------サブルーチンここから--------------- */
int lexical_analysis(void);/* 字句解析関数 */
int syntactic_analysis_1(void);/* 構文解析関数１ */
void syntactic_analysis_2(void);/* 構文解析関数２ */
void syntactic_analysis_3(void);/* 構文解析関数３ */
void syntactic_analysis_4(void);/* 構文解析関数４ */
int code_generation(void);/* コード生成関数 */
/* ----------------------------------------------- */
/* ---------グローバル宣言--------- */

FILE *fp,*fp2;

/* ----------字句解析の字句と種類を格納する構造体ここから-------- */
struct character{
	char jiku[MAXLENG];
	int result;
}lexical_result[MAXLENG],syntactic_result[MAXLENG];
/* ---------字句解析の字句と種類を格納する構造体ここまで--------- */

	int i=0,j=0,n,o;
	int num,gyou_kaihi;
	int stack[MAXLENGS];
	char op,*temp[MAXLENGS];
/* -------------------------------- */

/* ---------------------------------------メインルーチンここから----------------------------------------- */
int main(int argc,char *argv[]){
	int ni;

	if((fp=fopen(argv[1],"r"))==NULL){
		printf("Cannot Open File.\n");
		exit(1);
	}
	fp2=fopen("compiler_data.txt","w");
	ni=1;
	do{
		while(op!=';'){
			gyou_kaihi=ni;
			fprintf(fp2,"【%d-gyoume】\n",ni);
			ni++;
			fprintf(fp2,"【motono-siki】\n");
			lexical_analysis();/* 字句解析関数呼び出し */
			fprintf(fp2,"\n");
			syntactic_analysis_1();/* 構文解析関数呼び出し */
			code_generation();/* コード生成関数呼び出し */
		}
		op=getc(fp);
	}while(op!=EOF);
	printf("\nIt succeeded in making 'compiler_data.txt'.\n");
	return 0;
}
/* ------------------------------------------メインルーチンここまで--------------------------------------- */

/* -------------------------------------サブルーチン（字句解析）ここから---------------------------------- */
/* ---------------------------------
・構造体のresultに字句の種類を格納
・構造体のjikuに字句を格納
--------------------------------- */
int lexical_analysis(){
	int d,h,li,li2;
	d=0,h=0;
	
	for(li=0;li<MAXLENG;li++){
		lexical_result[li].result=0;
		for(li2=0;li2<MAXLENG;li2++){
			lexical_result[li].jiku[li2]=' ';
		}
	}
	n=1;
	o=1;
	op=getc(fp);
	while(1){
		if(isspace(op)){/* スペースの判定 */
			putc(op,fp2);
			op=getc(fp);
		}
		else if(isalpha(op)){/* 識別子の判定 */
			lexical_result[d].result=1;
			lexical_result[d].jiku[h]=op;
			op=getc(fp);
			h++;
			while(isalnum(op)){
				lexical_result[d].jiku[h]=op;
				op=getc(fp);
				h++;
			}
			fprintf(fp2,"i%d.%d",n,gyou_kaihi);
			n++;
			d++;
			h=0;
		}
		else if(isdigit(op)){/* 定数の判定 */
			lexical_result[d].result=2;
			lexical_result[d].jiku[h]=op;
			op=getc(fp);
			h++;
			while(isdigit(op)){
				lexical_result[d].jiku[h]=op;
				op=getc(fp);
				h++;
			}
			fprintf(fp2,"num%d.%d",o,gyou_kaihi);
			o++;
			d++;
			h=0;
		}
		else if(op==':'){/* ':='の判定 */
			lexical_result[d].result=3;
			lexical_result[d].jiku[h]=op;
			putc(op,fp2);
			op=getc(fp);
			h++;
			if(op=='='){
				lexical_result[d].jiku[h]=op;
				putc(op,fp2);
				op=getc(fp);
				d++;
				h=0;
			}
			else{
				printf("lexical ERROR!\n");/* ':'の次に'='がこなかったときエラー表示 */
			}
		}
		else if(op=='+'){/* '+'の判定 */
			lexical_result[d].result=4;
			lexical_result[d].jiku[h]=op;
			putc(op,fp2);
			op=getc(fp);
			d++;
			h=0;
		}
		else if(op=='-'){/* '-'の判定 */
			lexical_result[d].result=5;
			lexical_result[d].jiku[h]=op;
			putc(op,fp2);
			op=getc(fp);
			d++;
			h=0;
		}
		else if(op=='*'){/* '*'の判定 */
			lexical_result[d].result=6;
			lexical_result[d].jiku[h]=op;
			putc(op,fp2);
			op=getc(fp);
			d++;
			h=0;
		}
		else if(op=='/'){/* '/'の判定 */
			lexical_result[d].result=7;
			lexical_result[d].jiku[h]=op;
			putc(op,fp2);
			op=getc(fp);
			d++;
			h=0;
		}
		else if(op=='('){/* '('の判定 */
			lexical_result[d].result=8;
			lexical_result[d].jiku[h]=op;
			putc(op,fp2);
			op=getc(fp);
			d++;
			h=0;
		}
		else if(op==')'){/* ')'の判定 */
			lexical_result[d].result=9;
			lexical_result[d].jiku[h]=op;
			putc(op,fp2);
			op=getc(fp);
			d++;
			h=0;
		}
		else if(op==';'){/* ';'の判定 */
			lexical_result[d].result=10;
			lexical_result[d].jiku[h]=op;
			break;
		}
	}
	return 0;
}
/* -------------------------------------サブルーチン（字句解析）ここまで---------------------------------- */


/* ------------------------------------サブルーチン（構文解析１）ここから--------------------------------- */
int syntactic_analysis_1(){
	int m,l,gyou1;
	char *x;
	
	for(m=0;m<MAXLENG;m++){
		for(l=0;l<MAXLENG;l++){
			syntactic_result[m].jiku[l]=' ';
		}
	}


	i=0;
	j=0;
	l=0;
	n=1;
	o=1;
	fprintf(fp2,"\n【gyakupooranndokihou-siki】\n");
	while(lexical_result[i].result!=10){
/* １文字目の字句の構文解析の判定 */
		if(lexical_result[i].result==1){
			syntactic_result[j].result=1;
			for(m=0;m<MAXLENG;m++){
				if(isalnum(lexical_result[i].jiku[m])){
					syntactic_result[j].jiku[m]=lexical_result[i].jiku[m];
				}
			}
			fprintf(fp2,"i%d.%d ",n,gyou_kaihi);
			n++;
			j++;
		}
		i++;

/* ２文字目以降の字句の構文解析の判定 */
		if(lexical_result[i].result==2||lexical_result[i].result==3||lexical_result[i].result==4||lexical_result[i].result==5||
		lexical_result[i].result==6||lexical_result[i].result==7||lexical_result[i].result==8||lexical_result[i].result==9){
			syntactic_analysis_4();
			syntactic_analysis_3();
			syntactic_analysis_2();
		}
		
		if(lexical_result[i].result==10){
			syntactic_result[j].result=3;
			fprintf(fp2,":= ");
			break;
		}
	}
	
	fprintf(fp2,"\n\n【kigouhyou/teisuuhyou】\n");/* 記号表・定数表の作成 */
	fprintf(fp2,"kigou1\t\tkigou2\t\taddress\n");/* 記号表の作成 */

	n=1;
	for(m=0;m<MAXLENG;m++){
		if(syntactic_result[m].result==1){
			while(isalnum(syntactic_result[m].jiku[l])){
				putc(syntactic_result[m].jiku[l],fp2);
				l++;
			}
			fprintf(fp2,"\t\ti%d.%d",n,gyou_kaihi);
			n++;
			x=syntactic_result[m].jiku;
			if(gyou_kaihi!=0){/* アドレスの重複を防ぐために、行数によってアドレスをすすめておく */
				for(gyou1=0;gyou1<=gyou_kaihi;gyou1++){
					x++;
				}
			}
			temp[m]=x;
			fprintf(fp2,"\t\t%p\n",x);
			l=0;
		}
	}
	fprintf(fp2,"\nteisu1\t\tteisu2\t\taddress\n");/* 定数表の作成 */
		n=1;
		for(m=0;m<MAXLENG;m++){
			if(syntactic_result[m].result==2){
				while(isdigit(syntactic_result[m].jiku[l])){
					putc(syntactic_result[m].jiku[l],fp2);
					l++;
				}
				fprintf(fp2,"\t\tnum%d.%d",n,gyou_kaihi);
				n++;
				x=syntactic_result[m].jiku;
				if(gyou_kaihi!=0){/* アドレスの重複を防ぐために、行数によってアドレスをすすめておく */
					for(gyou1=0;gyou1<=gyou_kaihi*3;gyou1++){
						x++;
					}
				}
				temp[m]=x;
				fprintf(fp2,"\t\t%p\n",x);
				l=0;
			}
		}
		fprintf(fp2,"\n");
		return 0;
}
/* ------------------------------------サブルーチン（構文解析１）ここまで--------------------------------- */

/*

E → TE'
E' → +T[+}E'|ε
E' → -T[-}E'|ε
T → FT'
T' → *F[*]T'|ε
T' → /F[/]T'|ε
F → (E)|i[i]|num[num]

*/

/*
E'がsyntactic_analysis_2()関数に対応
T'がsyntactic_analysis_3()関数に対応
F がsyntactic_analysis_4()関数に対応
*/

/* ------------------------------------サブルーチン（構文解析２）ここから--------------------------------- */
void syntactic_analysis_2()
{
	if(lexical_result[i].result==4){/* '+'の構文解析の判定 */
		i++;
		syntactic_analysis_4();
		syntactic_analysis_3();
		syntactic_result[j].result=4;
		fprintf(fp2,"+ ");
		j++;
		syntactic_analysis_2();
	}
	else if(lexical_result[i].result==5){/* '-'の構文解析の判定 */
		i++;
		syntactic_analysis_4();
		syntactic_analysis_3();
		syntactic_result[j].result=5;
		fprintf(fp2,"- ");
		j++;
		syntactic_analysis_2();
	}
}
/* ------------------------------------サブルーチン（構文解析２）ここまで--------------------------------- */


/* ------------------------------------サブルーチン（構文解析３）ここから--------------------------------- */
void syntactic_analysis_3()
{
	if(lexical_result[i].result==6){/* '*'の構文解析の判定 */
		i++;
		syntactic_analysis_4();
		syntactic_result[j].result=6;
		fprintf(fp2,"* ");
		j++;
		syntactic_analysis_3();
	}
	else if(lexical_result[i].result==7){/* '/'の構文解析の判定 */
		i++;
		syntactic_analysis_4();
		syntactic_result[j].result=7;
		fprintf(fp2,"/ ");
		j++;
		syntactic_analysis_3();
	}
}
/* ------------------------------------サブルーチン（構文解析３）ここまで--------------------------------- */


/* ------------------------------------サブルーチン（構文解析４）ここから--------------------------------- */
void syntactic_analysis_4(){
	int t;
	
	if(lexical_result[i].result==1){/* '識別子'の構文解析の判定 */
		syntactic_result[j].result=1;
		for(t=0;t<MAXLENG;t++){
			if(isalnum(lexical_result[i].jiku[t])){
				syntactic_result[j].jiku[t]=lexical_result[i].jiku[t];
			}
		}
		fprintf(fp2,"i%d.%d ",n,gyou_kaihi);
		n++;
		j++;
		i++;
	}
	else if(lexical_result[i].result==2){/* '定数'の構文解析の判定 */
		syntactic_result[j].result=2;
		for(t=0;t<MAXLENG;t++){
			if(isdigit(lexical_result[i].jiku[t])){
				syntactic_result[j].jiku[t]=lexical_result[i].jiku[t];
			}
		}
		fprintf(fp2,"num%d.%d ",o,gyou_kaihi);
		o++;
		j++;
		i++;
	}
	else if(lexical_result[i].result==8){/* '('と')'の構文解析の判定 */
		syntactic_result[j].result=8;
		i++;
		j++;
		syntactic_analysis_4();
		syntactic_analysis_3();
		syntactic_analysis_2();
		if(lexical_result[i].result==9){
			syntactic_result[j].result=9;
			i++;
			j++;
		}
	}
}
/* ------------------------------------サブルーチン（構文解析４）ここまで--------------------------------- */


/* ------------------------------------サブルーチン（コード生成）ここから--------------------------------- */
int code_generation(){
/* 
・構造体のkindにACCの時は'-1'そうでないときは'1'を格納。
・構造体のdataにアドレスを格納。
 */
	struct stacks{
		int kind;
		char data;
	}stack[MAXLENG];
	
	int p,q,r,gyou2;
	char *str;
	
	q=0;
	fprintf(fp2,"【code-generation】\n");
	if(syntactic_result[0].result==1||syntactic_result[0].result==2){/* 一つめのスタックに格納 */
		str=syntactic_result[0].jiku;
		stack[0].kind=1;
		stack[0].data=(int)&str;
	}
	else{
		printf("code_generation ERROR!\n");/* 一つめのスタックに識別子か定数が格納されなかった場合エラー表示 */
	}
	
	for(p=1;p<MAXLENG;p++){
		if(syntactic_result[p].result==1||syntactic_result[p].result==2){/* 識別子か定数の場合はスタックにアドレスをプッシュダウンしていく */
			if(stack[q].kind==0){
				str=syntactic_result[p].jiku;
				stack[q].kind=1;
				stack[q].data=(int)&str;
				break;
			}
			q++;
			str=syntactic_result[p].jiku;
			stack[q].kind=1;
			stack[q].data=(int)&str;
			if(gyou_kaihi!=0){
				for(gyou2=0;gyou2<=gyou_kaihi*MAXLENG;gyou2++){
					str++;
				}
			}
		}
/* -----------------------------------------------------------
スタック[i]とスタック[i-1]が演算数が記憶されたアドレスである時
----------------------------------------------------------- */
		else if(stack[q].kind==1 && stack[q-1].kind==1){
			if(syntactic_result[p].result==3){/* ':='のコード生成の判定 */
				for(r=0;r<q;r++){/* スタック内にACCの存在を検索 */
					if(stack[r].kind==-1){
						stack[r].kind=1;
						stack[r].data=(int)&str;
						fprintf(fp2,"STORE\t\t%p\n",str);
						str++;
						break;
					}
				}
				fprintf(fp2,"LOAD\t\t%p\n",temp[p-1]);
				fprintf(fp2,"STORE\t\t%p\n",temp[p-2]);
				stack[q].kind=0;
				stack[--q].kind=-1;
			}
			
			if(syntactic_result[p].result==4){/* '+'のコード生成の判定 */
				for(r=0;r<q;r++){
					if(stack[r].kind==-1){
						stack[r].kind=1;
						stack[r].data=(int)&str;
						fprintf(fp2,"STORE\t\t%p\n",str);
						str++;
						break;
					}
				}
				fprintf(fp2,"LOAD\t\t%p\n",temp[p-2]);
				fprintf(fp2,"ADD\t\t%p\n",temp[p-1]);
				stack[q].kind=0;
				stack[--q].kind=-1;
			}
			if(syntactic_result[p].result==5){/* '-'のコード生成の判定 */
				for(r=0;r<q;r++){
					if(stack[r].kind==-1){
						stack[r].kind=1;
						stack[r].data=(int)&str;
						fprintf(fp2,"STORE\t\t%p\n",str);
						str++;
						break;
					}
				}
				fprintf(fp2,"LOAD\t\t%p\n",temp[p-2]);
				fprintf(fp2,"SUB\t\t%p\n",temp[p-1]);
				stack[q].kind=0;
				stack[--q].kind=-1;
			}
			if(syntactic_result[p].result==6){/* '*'のコード生成の判定 */
				for(r=0;r<q;r++){
					if(stack[r].kind==-1){
						stack[r].kind=1;
						stack[r].data=(int)&str;
						fprintf(fp2,"STORE\t\t%p\n",str);
						str++;
						break;
					}
				}
				fprintf(fp2,"LOAD\t\t%p\n",temp[p-2]);
				fprintf(fp2,"MUL\t\t%p\n",temp[p-1]);
				stack[q].kind=0;
				stack[--q].kind=-1;
			}
			if(syntactic_result[p].result==7){/* '/'のコード生成の判定 */
				for(r=0;r<q;r++){
					if(stack[r].kind==-1){
						stack[r].kind=1;
						stack[r].data=(int)&str;
						fprintf(fp2,"STORE\t\t%p\n",str);
						str++;
						break;
					}
				}
				fprintf(fp2,"LOAD\t\t%p\n",temp[p-2]);
				fprintf(fp2,"DIV\t\t%p\n",temp[p-1]);
				stack[q].kind=0;
				stack[--q].kind=-1;
			}
		}
/* --------------------------------------------------------------------------------------
スタック[i]が演算数が記憶されたアドレスで、スタック[i-1]が演算数がACCに記憶さてれている時
-------------------------------------------------------------------------------------- */
		else if(stack[q].kind==1 && stack[q-1].kind==-1){
			if(syntactic_result[p].result==3){
				fprintf(fp2,"STORE\t\t%p\n",temp[p-1]);/* ':='のコード生成の判定 */
				stack[q].kind=0;
				stack[--q].kind=-1;
			}
			if(syntactic_result[p].result==4){/* '+'のコード生成の判定 */
				fprintf(fp2,"ADD\t\t%p\n",temp[p-1]);
				stack[q].kind=0;
				stack[--q].kind=-1;
			}
			if(syntactic_result[p].result==5){/* '-'のコード生成の判定 */
				fprintf(fp2,"SUB\t\t%p\n",temp[p-1]);
				stack[q].kind=0;
				stack[--q].kind=-1;
			}
			if(syntactic_result[p].result==6){/* '*'のコード生成の判定 */
				fprintf(fp2,"MUL\t\t%p\n",temp[p-1]);
				stack[q].kind=0;
				stack[--q].kind=-1;
			}
			if(syntactic_result[p].result==7){/* '/'のコード生成の判定 */
				fprintf(fp2,"DIV\t\t%p\n",temp[p-1]);
				stack[q].kind=0;
				stack[--q].kind=-1;
			}
		}
/* --------------------------------------------------------------------------------------
スタック[i]が演算数がACCに記憶さてれていて、スタック[i-1]が演算数が記憶されたアドレスの時
-------------------------------------------------------------------------------------- */
		else if(stack[q].kind==-1 && stack[q-1].kind==1){
			if(syntactic_result[p].result==3){/* ':='のコード生成の判定 */
				fprintf(fp2,"STORE\t\t%p\n",temp[q-1]);
				stack[q].kind=0;
				stack[--q].kind=-1;
			}
			if(syntactic_result[p].result==4){/* '+'のコード生成の判定 */
				str--;
				fprintf(fp2,"ADD\t\t%p\n",str);
				str++;
				stack[q].kind=0;
				stack[--q].kind=-1;
			}
			if(syntactic_result[p].result==5){/* '-'のコード生成の判定 */
				fprintf(fp2,"STORE\t\t%p\n",str);
				str--;
				fprintf(fp2,"LOAD\t\t%p\n",str);
				str++;
				fprintf(fp2,"SUB\t\t%p\n",str);
				str++;
				stack[q].kind=0;
				stack[--q].kind=-1;
			}
			if(syntactic_result[p].result==6){/* '*'のコード生成の判定 */
				str--;
				fprintf(fp2,"MUL\t\t%p\n",str);
				str++;
				stack[q].kind=0;
				stack[--q].kind=-1;
			}
			if(syntactic_result[p].result==7){/* '/'のコード生成の判定 */
				fprintf(fp2,"STORE\t\t%p\n",str);
				str--;
				fprintf(fp2,"LOAD\t\t%p\n",str);
				str++;
				fprintf(fp2,"DIV\t\t%p\n",str);
				str++;
				stack[q].kind=0;
				stack[--q].kind=-1;
			}
		}
	}
	fprintf(fp2,"\n\n\n");
	return 0;
}
/* -----------------------------------サブルーチン（コード生成）ここまで-------------------------------- */

-------------------------------------------------------------------------------------------------------------
プログラムソース'compiler.c'ここまで↑


まずは、サブルーチンから。
lexical_analysis・・・字句解析関数
syntactic_analysis1~4・・・構文解析関数
code_generarion・・・コード生成関数

まずは、全体を通して使う構造体として、

lexical_result[].jiku
lexical_result[].result
syntactic_result[].jiku
syntactic_result[].result

を宣言しておく。

順次、lexical_analysis関数の説明からしていく。

§1、lexical_analysis()関数

.jikuには、解析した字句を格納する。
.resultには、解析した字句の種類を格納する。

ここでは、字句の種類を以下の数字に置き換えて格納していく。

識別子のときは、'1'
定数のときは、'2'

':='のときは、'3'
'+'のときは、'4'
'-'のときは、'5'
'*'のときは、'6'
'/'のときは、'7'
'('のときは、'8'
')'のときは、'9'
';'のときは、'10'

対象言語のテキストファイルより、一文字づつ取り出し、'op'に格納して、その文字の判定を行う。


§2、syntactic_analysis_1()関数

lexical_result[].resultに格納されている結果にしたがって、順次構文解析を行っていく。

配列[i]があるとして、
lexical_result[i].resultの格納されている値を、配列の数[i]に対応して、syntactic_result[i].resultにそれぞれ格納していく。

同様に、
lexical_result[i].jikuの格納されている値を、配列の数[i]に対応して、syntactic_result[i].jikuにそれぞれ格納していく。

syntactic_analysis_2()関数、syntactic_analysis_3()関数、syntactic_analysis_4()関数、

を通過し、構文解析によって振り分けられた字句に識別子や定数に対応するアドレスを、記号表と定数表に表示する。

その際に、以下のプログラムソースで、対象言語の１行目から、次の行の対象言語を読み込んだときに、アドレスが重複してしまわないように、１行目のアドレスの振り分けが終わった時点で、先頭で使用したアドレスから行数に対応してアドレスを進めておくことで、重複を避けている。
	
x=syntactic_result[m].jiku;
if(w!=0){
	for(gyou1=0;gyou1<=w;gyou1++){
		x++;
	}
}
temp[m]=x;

また、この関数の時点で、コード生成で用いるアドレスをtemp[]に格納している。
syntactic_result[i].resultとlexical_result[i].resultとtemp[i]の値は、それぞれのものと一貫性があるように格納していく。


§3、syntactic_analysis_2()関数,syntactic_analysis_3()関数,syntactic_analysis_4()関数

これらの関数の基本的な仕組みは、以下の生成規則に対応している。

E → TE'
E' → +T[+}E'|ε
E' → -T[-}E'|ε
T → FT'
T' → *F[*]T'|ε
T' → /F[/]T'|ε
F → (E)|i[i]|num[num]

この生成規則の、

E'がsyntactic_analysis_2()関数に対応
T'がsyntactic_analysis_3()関数に対応
F がsyntactic_analysis_4()関数に対応

している。

この生成規則にしたがって、syntactic_analysis_1()関数〜syntactic_analysis_4()関数の中を字句に対応して関数内を通過し、構文解析を行っていく。


§4、code_generation()関数

コード生成を行う関数である。

stack[].kind・・・ACCの時は'-1'を、そうでないときは'1'を格納する。

そして、このstack[].kindに従ってコード生成を行う。
sytactic[].resultに格納されている値（演算記号の種類）と、コード生成におけるコードは以下のように対応して生成される。


'3'・・・STORE
'4'・・・ADD
'5'・・・SUB
'6'・・・MUL
'7'・・・DIV

さらに、stack[].kindに格納されている値（ACCの有無）に従って、以下のようなコード生成の場合分けがされている。


（�@）stack[i]==1、stack[i-1]==1の時、
stack[i]のアドレスがV1、stack[i-1]のアドレスがV2であれば、その時のsytactic[].resultに格納されている値に従って、以下のようなコードが生成される。

STORE	T	（ただし、stack[1,....,i-2]の中に'-1'がある場合）
LOAE	V2
コード	V1	（コードはsytactic[].resultの値に従う）

また、x := 3;（x 3 :=）のような対象言語の場合は、xのアドレスがV2、3のアドレスがV1となるので、以下のようなコードが生成される。

LOAD	V1
STORE	V2


（�A）stack[i]==1、stack[i-1]==-1の時、
stack[i]のアドレスがV1であれば、sytactic[].resultに格納されている値に従って、以下のようなコードが生成される。

コード	V1	（コードはsytactic[].resultの値に従う）


（�B）stack[i]==-1、stack[i-1]==1の時、
stack[i-1]のアドレスがV2であれば、その時のsytactic[].resultに格納されている値に従って、以下のようなコードが生成される。

�T）sytactic[].result=='4'または'5'の時、

コード	V2	（コードはsytactic[].resultの値に従う）	

�U）sytactic[].result=='6'または'7'の時、

STORE	T
LOAD	V2
コード	T	（コードはsytactic[].resultの値に従う）

�V）sytactic[].result=='3'の時、

STORE	V2


また、ここでもsyntactic_analysis_1()関数と同様に、行数によるアドレスの重複を防ぐために、以下のコードにより上のコード生成におけるアドレスTに対応するアドレスを、次の行に進むに従って十分に進めている。

	if(w!=0){
		for(gyou2=0;gyou2<=w*MAXLENG;gyou2++){
			str++;
		}
	}


§5、メインルーチン
最後にメイン関数の説明を行う。
引数にとる対象言語のテキストファイルの存在の有無を調べ、エラーを出力する。

また、字句解析、構文解析、コード生成の関数を呼び出している。

そして、対象言語のテキストファイルのEOFを読み込んだら、解析を完了とし、

It succeeded in making 'compiler_data.txt'.

を、プロンプト上に出力し、'compiler_data.txt'をコンパイラと同じフォルダ内に出力する。

記号表、定数表、対象言語を字句で表示したもの、対象言語を構文解析したもの、アセンブリ言語で書かれたコード

が、この'compiler_data.txt'に記述されている。

その例をここに記述しておく。

↓ここから
-------------------------------------------------------

【1-gyoume】
【motono-siki】
i1 := num1 * i2 - i3

【gyakupooranndokihou-siki】
i1 num1 i2 * i3 - := 

【kigouhyou/teisuuhyou】
kigou1		kigou2		address
abc		i1		00412906
e3		i2		00412A0E
def		i3		00412B16

teisu1		teisu2		address
256		num1		0041298C

【code-generation】
LOAD		0041298C
MUL		00412A0E
SUB		00412B16
STORE		00412906


-------------------------------------------------------
↑ここまで