월급좀도둑의 블로그

배열추가 완성본.c

내가 완성하지 못한 명령어를 포함한채로 제출 하지는 않았을테고........

분명히 최종 완성본이 있을텐데 어디있는지 모르겠음

몇년전에 만들어둔걸 올리다보니...

잘 돌아갈수도 있고....안 돌아가면 말고

-----------------------------------------------------------------------------------

/* A tiny BASIC interpreter */
#include <stdio.h>
#include <setjmp.h>
#include <math.h>
#include <ctype.h>
#include <stdlib.h>
#include <string.h>

//디버깅 하지 않을때는 주석처리한다
#define DEBUG //original code 용
#define DEBUG2 //추가 코드 용
//#define DEBUG3 //추가 코드 - 추가 함수용

#define NUM_LAB 100
#define LAB_LEN 10
#define FOR_NEST 25
#define SUB_NEST 25
#define PROG_SIZE 10000

#define DELIMITER 1
#define VARIABLE 2
#define NUMBER 3
#define COMMAND 4
#define STRING 5
#define QUOTE 6
#define ARRAY 7//(dim추가구분)

//tok
#define PRINT 1
#define INPUT 2
#define IF 3
#define THEN 4
#define FOR 5
#define NEXT 6
#define TO 7
#define GOTO 8
#define EOL 9
#define FINISHED 10
#define GOSUB 11
#define RETURN 12
#define DIM 13//(dim추가구분)
#define CLEAR 14//(clear추가구분)
#define END 15

//단일변수
char *prog; //다음에 실행할 basic 문자를 지정
jmp_buf e_buf; //PASS

char token[80]; //공백을 제외한 단어의 개수
char token_type, tok;

char *gstack[SUB_NEST]; /* stack for gosub */

int ftos; /* index to top of FOR stack */
int gtos; /* index to top of GOSUB stack */

int variables[26]={ //basic 변수 이름 부분
0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0
};

//구조체
struct label
{
char name[LAB_LEN];
char *p; /* points to place to go in source file */
};
struct label label_table[NUM_LAB];

struct for_stack
{
int var; /* counter variable */
int target; /* target value */
char *loc;
} fstack[FOR_NEST]; /* stack for FOR/NEXT loop */
struct for_stack fpop();

/* keyword lookup table */
struct commands
{
char command[20];
char tok;
} table[] = { /* Commands must be entered lowercase */
{"print",PRINT}, /* in this table */
{"input",INPUT},
{"if",IF},
{"then",THEN},
{"goto",GOTO},
{"for",FOR},
{"next",NEXT},
{"to",TO},
{"gosub",GOSUB},
{"return",RETURN},
{"end",END},
{"clear", CLEAR}, //(clear추가구분)
{"dim", DIM}, //(dim추가구분)
{"",END} /* mark end of table */
};

//추가 구조체
struct arr_str //(dim추가구분)
{
int num; //배열 선언시 범위 저장
int arr_value[100]; //배열의 값 저장
int guard; //중복 선언을 막아줌
} arr_table[26]; //variable과 마찬가지로 26개 선언

//funtion - 매개변수 표시
void print();
void scan_labels();
void find_eol();
void exec_goto();
void exec_if();
void exec_for();
void next();
void fpush(struct for_stack i);
void input();
void gosub();
void greturn();
void gpush(char *s);
void label_init();

//function - 선언추가 및 매개변수 표시
int load_program(char *p, char *fname);
char get_token(void);
void putback(void);
void assignment(void);
int find_var(char *s);
int get_next_label(char *s);
int iswhite(char c);
int isdelim(char c);
int look_up(char *s);
void get_exp(int *result);
void serror(int error);
char *find_label(char *s);
char *gpop();

//추가 함수
void clear(); //변수값 초기화 함수(clear추가구분)
void assignment_arr(void); //token_type : array시 연산 (dim추가구분)
void dim(); //다차원 배열 선언(dim추가구분)

void main(int argc,char *argv[])
{
//char in[80]; no using
//int answer; no using
//char *t; no using

char *p_buf;

if(argc!=2) //프롬프트 에서 잘못 입력시
{
printf("usage: P/Gname <filename>\n");
exit(1);
}

/* allocate memory for the program */
if(!(p_buf=(char *) malloc(PROG_SIZE))) //방의 크기가 10000이 넘을때
{
printf("allocation failure");
exit(1);
}

/* load the program to execute */
if(!load_program(p_buf,argv[1])) //.bas의 문자열을 저장
{
exit(1);
}

/* initialize the long jump buffer */
if(setjmp(e_buf)) //PASS
{
exit(1);
}

prog=p_buf;

/* find the labels in the program */
scan_labels(); // 248 : L

/* initialize the FOR stack index */
ftos = 0; //전역변수

/* initialize the GOSUB stack index */
gtos = 0; //전역변수

do
{

token_type=get_token();

/* check for assignment statement */
if(token_type == VARIABLE) //변수일때
{
/*return the var to the input stream */
putback(); //전역변수 prog를 초기화

/* must be assignment statement */
assignment(); //변수 형태 오류검사 ex) A = 10
}

else if(token_type == ARRAY) //(dim추가구분)
{
putback(); //전역변수 prog를 초기화

assignment_arr(); //변수 형태 오류검사 ex) A = 10

}

/* is command */
else //변수가 아닐때 즉 명령어 일때
{
switch(tok)
{
case PRINT:
print();
break;

case GOTO:
exec_goto();
break;

case IF:
exec_if();
break;

case FOR:
exec_for();
break;

case NEXT:
next();
break;

case INPUT:
input();
break;

case GOSUB:
gosub();
break;

case RETURN:
greturn();
break;

case CLEAR:
clear();
break;

case DIM: //(dim추가구분)
dim();
break;

case END:
exit(0);

} //switch end
} //else end
} while (tok != FINISHED); //while end

} //main end

/* Load a program. */
int load_program(char *p, char *fname)
{
FILE *fp;
int i = 0;

if(!(fp=fopen(fname,"r")))
{
return 0;
}

i=0;

do
{
*p = getc(fp);
p++; i++;
} while(!feof(fp) && i<PROG_SIZE);

/* null terminate the program */
*(p-1)='\0';

fclose(fp);

return 1;
}

/* Assign a variable a value. */
void assignment(void)
{
int var, value;

/* get the variable a value */
get_token();

if(!isalpha(*token))
{
serror(4);
return;
}

var = toupper(*token)-'A';

/* get the equals sign */
get_token();

if(*token!='=')
{
serror(3);
return;
}

/* get the value to assign to var */
get_exp(&value);

/* assign the value */
variables[var] = value;
}

void assignment_arr(void) //(dim 추가구분)
{
int var, value;
int arr_temp = 0; //배열주소 (dim추가구분)

#ifdef DEBUG2
printf("assignment_arr 함수 진입 성공 \n");
#endif

/* get the variable a value */
get_token(); //배열 이름 받음

#ifdef DEBUG2
printf("assignment_arr - token(1) : %s \n",token);
#endif

if(!isalpha(*token)) //알파벳이 판단 함수
{
serror(4);
return;
}

var = toupper(*token)-'A'; //대문자로 변환(내장함수)

get_token(); //'(' 받음

#ifdef DEBUG2
printf("assignment_arr - token(2) : %s \n",token);
#endif

if(*token!='(')
{
serror(14);
return;
}

get_token(); //숫자 받음

if(token_type == NUMBER)
{
arr_temp = atoi(token); //c문법대로라면 현행 베이직 문법대로라면 + 1을 해야함

if(arr_table[var].num < arr_temp) //선언한 배열값을 넘을경우
{
serror(18);
return;
}
}

else //만약 숫자가 아닐경우
{
#ifdef DEBUG2
printf("assignment_arr - serror(17) - token : %s \n",token);
#endif

serror(17);
return;
}

get_token();

#ifdef DEBUG2
printf("assignment_arr - token(3) : %s \n",token);
#endif

if(*token!=')')
{
serror(15);
return;
}

get_token();

if(*token!='=')
{
serror(3);
return;
}

get_exp(&value);

arr_table[var].arr_value[arr_temp] = value;

#ifdef DEBUG2
printf("assignment_arr - var : %d \n",var);
printf("assignment_arr - arr_table[%d].arr_value[%d] : %d \n",var, arr_temp,
arr_table[var].arr_value[arr_temp]);
#endif

}

/* Execute a simple version of the BASIC PRINT statement */
void print()
{
int answer;
int len=0,spaces;
char last_delim;

do
{
/* get next list item */
get_token();

if(tok==EOL || tok==FINISHED)
{
break;
}

/* is string */
if(token_type==QUOTE)
{
printf(token);
len += strlen(token);
get_token();
}

/* is expression */
else
{
putback();

#ifdef DEBUG
printf("PRINT 내부 get_exp 함수 진입 \n");
#endif

get_exp(&answer);

get_token();
len += printf("%d",answer);
}

last_delim = *token;

if(*token==';')
{
/* compute number of spaces to move to next tab */
spaces = 8 - (len % 8);

/* add in the tabbing position */
len += spaces;

while(spaces)
{
printf(" ");
spaces--;
}
}

/* do nothing */
else if(*token==',');

else if(tok!=EOL && tok!=FINISHED)
{
#ifdef DEBUG
printf("print(1) - serror(0); \n");
#endif

serror(0);
}

} while (*token==';' || *token==','); //do-while end

if(tok==EOL || tok==FINISHED)
{
if(last_delim != ';' && last_delim != ',')
{
printf("\n");
}
}

/* error is not,or; */
else
{
#ifdef DEBUG
printf("print(1) - serror(0); \n");
#endif

serror(0);
}

} //function end

/* Find all labels. */
void scan_labels()
{
int addr;
char *temp;

/* zero all labels */
label_init();

/* save pointer to top of program */
temp = prog;

/* if the first token in the file is a label */
get_token();

if(token_type==NUMBER)
{
strcpy(label_table[0].name,token);
label_table[0].p=prog;
}

find_eol();

do
{
get_token();
if(token_type==NUMBER)
{
addr = get_next_label(token);

if(addr== -1 || addr== -2)
{
(addr== -1) ?serror(5):serror(6);
}

strcpy(label_table[addr].name,token);

/* current point in program */
label_table[addr].p=prog;

} //if end

/* if not on a blank line,find next line */
if(tok!=EOL)
{
find_eol();
}

} while(tok!=FINISHED); //do-while end

/* restore to original */
prog = temp;

} //function end

/* Find the start of next line */
void find_eol()
{
while(*prog!='\n' && *prog!='\0')
{
++prog;
}

if(*prog)
{
prog++;
}

}

/*
Return index of next free position in label array.
A -1 is returned if the array is full.
A -2 is returned when duplicate label is found.
*/
int get_next_label(char *s)
{
register int t;

for(t=0; t<NUM_LAB; ++t)
{
if(label_table[t].name[0]==0)
{
return t;
}

/* dup */
if(!strcmp(label_table[t].name,s))
{
return -2;
}
}

return -1;
}

/* Find location of given label. A null is returned if
label is not found; otherwise a pointer to the position
of the label is returned */
char *find_label(char *s)
{
register int t;

for(t=0; t<NUM_LAB; ++t)
{
if(!strcmp(label_table[t].name,s))
{
return label_table[t].p;
}
}

/* error condition */
return '\0';
}

/* Execute a GOTO statement. */
void exec_goto()
{
char *loc;

/* get label to go to */
get_token();

/* find the location of the label */
loc = find_label(token);

if(loc=='\0')
{
/* label not defined */
serror(7);
}

/* start program running at that loc */
else
{
prog=loc;
}
}

/* Initialize the array that holds the labels.
By convention,a null label name indicates that */
void label_init()
{
register int t;

for(t=0; t<NUM_LAB; ++t)
{
label_table[t].name[0]='\0';
}
}

/* Execute an IF statement. */
void exec_if()
{
int x,y,cond;
char op;

/* get left expression */
get_exp(&x);

/* get the operator */
get_token();

if(!strchr("=<>",*token))
{
#ifdef DEBUG
printf("exec_if - serror(0); \n");
#endif

/* not a legal operator */
serror(0);
return;
}

op = *token;

/* get right expression */
get_exp(&y);

/* determine the outcome */
cond = 0;

switch(op)
{
case '<':
if(x<y)
{
cond=1;
}
break;

case '>':
if(x>y)
{
cond=1;
}
break;

case '=':
if(x==y)
{
cond=1;
}
break;
}

/* is true so process target of IF */
if(cond)
{
get_token();

/* else program execution starts on next line */
if(tok!=THEN)
{
serror(8);
return;
}
}

/* find start of next line */
else
{
find_eol();
}

} //function end

/* Execute a for loop */
void exec_for()
{
struct for_stack i;
int value;

/* read the control variable */
get_token();

if(!isalpha(*token))
{
serror(4);
return;
}

/* save its index */
i.var=toupper(*token)-'A';

/* read the equal sign */
get_token();

if(*token!='=')
{
serror(3);
return;
}

/* get initial value */
get_exp(&value);

variables[i.var]=value;

get_token();

/* read and discard the TO */
if(tok!=TO)
{
serror(9);
}

/* get target value */
get_exp(&i.target);

/* if loop can execute at least once,push info on stack */
if(value>=variables[i.var])
{
i.loc = prog;
fpush(i);
}

/* otherwise,skip loop code altogether */
else
{
while(tok!=NEXT)
{
get_token();
}
}

}

/* Execute a NEXT statement. */
void next()
{
struct for_stack i;

/* read the info */
i=fpop();

/* increment control variable */
variables[i.var]++;

if(variables[i.var]>i.target)
{
/* all don */
return;
}

/* otherwise, restore the info */
fpush(i);

/* loop */
prog = i.loc;
}

/* Push function for the FOR stack */
void fpush(struct for_stack i)
{
if(ftos>FOR_NEST)
{
serror(10);
}

fstack[ftos]=i;
ftos++;
}

struct for_stack fpop()
{
ftos--;

if(ftos<0)
{
serror(11);
}

return(fstack[ftos]);
}

/* Execute a simple from of the BASIC INPUT command */
void input()
{
//char str[80]; no using***********************
char var;
int i;

/* see if prompt string is present */
get_token();

if(token_type==QUOTE)
{
/* if so,print it and check for comma */
printf(token);
get_token();

if(*token!=',')
{
serror(1);
}

get_token();
}

else
{
/* otherwise,prompt with / */
printf("? ");
}

/* get the input var */
var = toupper(*token)-'A';

/*read input */
scanf("%d",&i);

/* store it */
variables[var] = i;
}

/* Execute a GOSUB command. */
void gosub()
{
char *loc;

get_token();

/* find the label to call */
loc = find_label(token);

if(loc=='\0')
{
/* label not defined */
serror(7);
}

else
{
/* save place to return to */
gpush(prog);
/* start program running at that loc */
prog = loc;
}
}

/* Return from GOSUB */
void greturn()
{
prog = gpop();
}

/* GOSUB stack push function. */
void gpush(char *s)
{
gtos++;

if(gtos==SUB_NEST)
{
serror(12);
return;
}

gstack[gtos]=s;
}

/* GOSUB stack pop function. */
char *gpop()
{
if(gtos==0)
{
serror(13);
return 0;
}

return(gstack[gtos--]);
}

/* recursive descent parser for integer expressions
which may include variables */
#define DELIMITER 1
#define VARIABLE 2
#define NUMBER 3
#define COMMAND 4
#define STRING 5
#define QUOTE 6

#define EOL 9
#define FINISHED 10

void level2(),level3(),level4(),level5();
void level6(),primitive(),arith(),unary();

/* Entry point into parser. */
void get_exp(int *result)
{
get_token();

#ifdef DEBUG
printf("get_exp - token : %s \n",token);
#endif

if(! *token)
{
serror(2);
return;
}

level2(result);
putback();
}

/* Add or subtract two terms. */
void level2(int *result)
{
register char op;
int hold;

level3(result);

while((op = *token) == '+' || op == '-')
{
get_token();

#ifdef DEBUG
printf("level2 - token : %s \n",token);
#endif

level3(&hold);
arith(op,result,&hold);
}
}

/* Multiply or divide two factors. */
void level3(int *result)
{
register char op;
int hold;

level4(result);
while((op = *token) == '*' || op == '/' || op == '%')
{
get_token();

#ifdef DEBUG
printf("level3 - token : %s \n",token);
#endif

level4(&hold);
arith(op,result,&hold);
}
}

/* Process integer exponent. */
void level4(int *result)
{
int hold;

level5(result);

if(*token == '^')
{
get_token();

#ifdef DEBUG
printf("level4 - token : %s \n",token);
#endif

level4(&hold);
arith('^',result,&hold);
}

}

/* Is a unary + or -. */
void level5(int *result)
{
register char op;

op = 0;

if((token_type==DELIMITER) && *token == '+' || *token == '-')
{
op = *token;
get_token();

#ifdef DEBUG
printf("level5 - token : %s \n",token);
#endif

}

level6(result);

if(op)
{
unary(op,result);
}
}

/* Process parenthesized expression. */
void level6(int *result)
{
if((*token == '(') && (token_type == DELIMITER))
{
get_token();

#ifdef DEBUG
printf("level6 - token(1) : %s \n",token);
#endif

level2(result);

if(*token != ')')
{
serror(1);
}

get_token();

#ifdef DEBUG
printf("level6 - token(2) : %s \n",token);
#endif

}

else
{
primitive(result);
}
}

/* Find value of number or variable. */
void primitive(int *result)
{
int v_t=0;
int a_t=0;

switch(token_type)
{
case VARIABLE:

#ifdef DEBUG
printf("primitive case VARIABLE 진입 \n");
#endif

*result = find_var(token);
get_token();

#ifdef DEBUG
printf("primitive - token(1) : %s \n",token);
#endif

return;

case NUMBER:
*result = atoi(token);
get_token();

#ifdef DEBUG
printf("primitive - token(2) : %s \n",token);
#endif

return;

case ARRAY:
v_t = toupper(*token)-'A';
get_token(); //"(" get

get_token(); //배열주소 get
a_t = atoi(token);

get_token(); //")" get

*result = arr_table[v_t].arr_value[a_t];

get_token();

return;

default:
#ifdef DEBUG
printf("primitive - serror(0) token : %s \n",token);
#endif

serror(0);

}
}

/* Perform the specified arithmetic. */
void arith(char o, int *r, int *h)
{
register int t, ex;

switch(o)
{
case '-':
*r = *r - *h;
break;

case '+':
*r = *r + *h;
break;

case '*':
*r = *r * *h;
break;

case '/':
*r = (*r) / (*h);
break;

case '%':
t = (*r) / (*h);
*r = *r - (t*(*h));
break;

case '^':
ex = *r;

if(*h == 0)
{
*r = 1;
break;
}

for(t = *h-1; t>0; --t)
{
*r= (*r) * ex;
}

break;
}
}

/* Reverce the sign. */
void unary(char o, int *r)
{
if(o == '-')
{
*r = -(*r);
}
}

/* Find the value of a variable */
int find_var(char *s)
{
if(!isalpha(*s))
{
#ifdef DEBUG
printf("find_var - serror(4) \n");
#endif

/* not a variable */
serror(4);
return 0;
}

return variables[toupper(*token) - 'A'];
}

/* Display an error message */
void serror(int error)
{
static char *e[] = {
"syntex error", //0
"unbalenced parentheses", //1
"no expression present", //2
"equal sign expected", //3
"not a variable", //4
"label table full", //5
"duplicate label", //6
"undefined label", //7
"THEN expected", //8
"TO expected", //9
"too many nested FOR loops", //10
"NEXT without FOR", //11
"too many nested GOSUBs", //12
"RETURN without GOSUB", //13
"'(' is a requisite", //14 (dim추가구분)
"')' is a requisite", //15 (dim추가구분)
"array limited 99", //16 (dim추가구분)
"not a number", //17 (dim추가구분)
"over array size", //18 (dim추가구분)
"declare already" //19 (dim추가구분)
};

printf("%s\n",e[error]);

/* return to save point */
longjmp(e_buf,1);
}

/* Get a token. */
char get_token(void)
{
register char *temp;

token_type=0; tok=0;
temp = token;

/* end of file */
if(*prog == '\0')
{
*token = 0;
tok = FINISHED;
return(token_type=DELIMITER);
}

/* skip over white space */
while(iswhite(*prog))
{
++prog;
}

/* crLf */
if(*prog=='\n')
{
++prog;
tok = EOL; *token='\n';
token[1]='\0';
return(token_type = DELIMITER);
}

/* delimiter */
if(strchr("+-*^/%=;(),><",*prog))
{
*temp = *prog;
/* advanced to next position */
prog++;
temp++;
*temp=0;
return(token_type=DELIMITER);
}

/* quoted string */
if(*prog=='"')
{
prog++;

while(*prog!='"' && *prog!='\n')
{
*temp++ = *prog++;
}

if(*prog=='\n')
{
serror(1);
}

prog++; *temp=0;
return(token_type=QUOTE);
}

/* number */
if(isdigit(*prog))
{
while(!isdelim(*prog))
{
*temp++ = *prog++;
}

*temp='\0';
return(token_type=NUMBER);
}

/* var or command */
if(isalpha(*prog))
{
while(!isdelim(*prog))
{
*temp++ = *prog++;
}

token_type=STRING;
}

*temp='\0';

/* see if a string is a command or a variable */
if(token_type==STRING)
{
/* convert to internal rep */
tok=look_up(token);

if(*prog++ == '(') //(dim추가구분)
{
#ifdef DEBUG2
printf("token_type : ARRAY 부여 \n");
#endif

token_type=ARRAY;
*prog--;
}

else if(!tok)
{
#ifdef DEBUG
printf("token_type : VARIABLE 부여 \n");
#endif

token_type=VARIABLE;
}

/* is a command */
else
{
token_type=COMMAND;
}
}
return token_type;
}

/* Return a token to input stream. */
void putback(void)
{
char *t;

t = token;
for(; *t; t++)
{
prog--;
}
}

/* Look up a token's internal representation in the
token table */
int look_up(char *s)
{
register int i;//,j; no using************************
char *p;

/* convert to lowercase */
p = s;

while(*p)
{
*p = tolower(*p); p++;
}

/* see if token is in table */
for(i=0; *table[i].command; i++)
{
if(!strcmp(table[i].command,s))
{
return table[i].tok;
}
}

/* unknown command */
return 0;
}

/* Return true if c is a delimiter. */
int isdelim(char c)
{
if(strchr(" ;,+-<>/*%^=()",c) || c==9 || c=='\n' || c==0)
{
return 1;
}

return 0;
}

/* Return 1 if c is space or tab */
int iswhite(char c)
{
if(c==' ' || c=='\t')
{
return 1;
}

else return 0;
}

void clear(void)//보류
{
int count1, count2;

printf("clear all data & memory \n");

for(count1 = 0; count1<80; count1++)
{
token[count1] = '0';
}

//*prog = '0'; //다음에 실행할 basic 문자를 지정
//token_type = '0';
//tok = '0';

//char *gstack[SUB_NEST]; /* stack for gosub */

ftos=0; /* index to top of FOR stack */
gtos=0; /* index to top of GOSUB stack */
/*
for(count1 = 0; count1<26; count1++)
{
variables[count1] = 0;
}
*/

for(count1 = 0; count1<100; count1++)
{
//*label_table[count1].p = '0';
//label_table[count1].p++;

for(count2 = 0; count2<10; count2++)
{
label_table[count1].name[count2] = '0';
}

}

/*
for(count1 = 0; count1<25; count1++)
{
fstack[count1].var = 0;
fstack[count1].target = 0;
*fstack[count1].loc = '0';
}
*/

}

void dim(void) //(dim추가구분)
{
int var;

get_token(); //배열이름

if(!isalpha(*token)) //알파벳이 판단 함수
{
serror(4);
return;
}

var = toupper(*token)-'A';

if(arr_table[var].guard)
{
serror(18);
return;
}

else
{
arr_table[var].guard = 1;
}

get_token(); //'(' 받음

if(*token!='(')
{
serror(14);
return;
}

get_token(); //숫자 받음

if(token_type == NUMBER)
{
arr_table[var].num = atoi(token); //c문법대로라면 현행 베이직 문법대로라면 + 1을 해야함
}

else //만약 숫자가 아닐경우
{
#ifdef DEBUG2
printf("dim - serror(17) - token : %s \n",token);
#endif

serror(17);
return;
}

get_token(); //')'받음

if(*token!=')')
{
serror(15);
return;
}


}

/*
1. clear 명령어 완성못함

3. 동적 메모리 할당으로 배열길이 자유조절하기
*/

mybasic.c

비주얼 베이직 코드를 수행하는 인터프리터

-----------------------------------------------------------------------------------

/* A tiny BASIC interpreter */
#include "stdio.h"
#include "setjmp.h"
#include "math.h"
#include "ctype.h"
#include "stdlib.h"

#define NUM_LAB 100
#define LAB_LEN 10
#define FOR_NEST 25
#define SUB_NEST 25
#define PROG_SIZE 10000

#define DELIMITER 1
#define VARIABLE 2
#define NUMBER 3
#define COMMAND 4
#define STRING 5
#define QUOTE 6

#define PRINT 1
#define INPUT 2
#define IF 3
#define THEN 4
#define FOR 5
#define NEXT 6
#define TO 7
#define GOTO 8
#define EOL 9
#define FINISHED 10
#define GOSUB 11
#define RETURN 12
#define END 13

char *prog; /* holds expression to be analyzed */
jmp_buf e_buf; /* hold environment for longjmp() */

int variables[26]={ /* 26 user variables, A-Z */
0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0,0,0,0,0,
0,0,0,0,0,0
};

struct commands { /* keyword lookup table */
char command[20];
char tok;
} table[] = { /* Commands must be entered lowercase */
"print",PRINT, /* in this table */
"input",INPUT,
"if",IF,
"then",THEN,
"goto",GOTO,
"for",FOR,
"next",NEXT,
"to",TO,
"gosub",GOSUB,
"return",RETURN,
"end",END,
"",END /* mark end of table */
};

char token[80];
char token_type,tok;

struct label {
char name[LAB_LEN];
char *p; /* points to place to go in source file */
};
struct label label_table[NUM_LAB];

char *find_label(), *gpop();

struct for_stack {
int var; /* counter variable */
int target; /* target value */
char *loc;
} fstack[FOR_NEST]; /* stack for FOR/NEXT loop */
struct for_stack fpop();

char *gstack[SUB_NEST]; /* stack for gosub */

int ftos; /* index to top of FOR stack */
int gtos; /* index to top of GOSUB stack */

void print(),scan_labels(),find_eol(),exec_goto();
void exec_if(),exec_for(),next(),fpush(),input();
void gosub(),greturn(),gpush(),label_init();

main(argc,argv)
int argc;
char *argv[];
{
char in[80];
int answer;
char *p_buf;
char *t;

if(argc!=2) {
printf("usage: run <filename>\n");
exit(1);
}

/* allocate memory for the program */
if(!(p_buf=(char *) malloc(PROG_SIZE))) {
printf("allocation failure");
exit(1);
}

/* load the program to execute */
if(!load_program(p_buf,argv[1])) exit(1);

if(setjmp(e_buf)) exit(1); /* initialize the long jump buffer */

prog=p_buf;
scan_labels(); /* find the labels in the program */
ftos = 0; /* initialize the FOR stack index */
gtos = 0; /* initialize the GOSUB stack index */
do {
token_type=get_token();
/* check for assignment statement */
if(token_type == VARIABLE) {
putback(); /*return the var to the input stream */
assignment(); /* must be assignment statement */
}
else /* is command */
switch(tok) {
case PRINT:
print();
break;
case GOTO:
exec_goto();
break;
case IF:
exec_if();
break;
case FOR:
exec_for();
break;
case NEXT:
next();
break;
case INPUT:
input();
break;
case GOSUB:
gosub();
break;
case RETURN:
greturn();
break;
case END:
exit(0);
}
} while (tok != FINISHED);
}

/* Load a program. */
load_program(p,fname)
char *p;
char *fname;
{
FILE *fp;
int i = 0;

if(!(fp=fopen(fname,"r"))) return 0;

i=0;
do {
*p = getc(fp);
p++; i++;
} while(!feof(fp) && i<PROG_SIZE);
*(p-1)='\0'; /* null terminate the program */
fclose(fp);
return 1;
}

/* Assign a variable a value. */
assignment()
{
int var, value;

/* get the variable a value */
get_token();
if(!isalpha(*token)) {
serror(4);
return;
}

var = toupper(*token)-'A';

/* get the equals sign */
get_token();
if(*token!='=') {
serror(3);
return;
}

/* get the value to assign to var */
get_exp(&value);

/* assign the value */
variables[var] = value;
}

/* Execute a simple version of the BASIC PRINT statement */
void print()
{
int answer;
int len=0,spaces;
char last_delim;

do {
get_token(); /* get next list item */
if(tok==EOL || tok==FINISHED) break;
if(token_type==QUOTE) { /* is string */
printf(token);
len += strlen(token);
get_token();
}
else { /* is expression */
putback();
get_exp(&answer);
get_token();
len += printf("%d",answer);
}
last_delim = *token;

if(*token==';') {
/* compute number of spaces to move to next tab */
spaces = 8 - (len % 8);
len += spaces; /* add in the tabbing position */
while(spaces) {
printf(" ");
spaces--;
}
}
else if(*token==','); /* do nothing */
else if(tok!=EOL && tok!=FINISHED) serror(0);
} while (*token==';' || *token==',');

if(tok==EOL || tok==FINISHED) {
if(last_delim != ';' && last_delim != ',') printf("\n");
}
else serror(0); /* error is not,or; */
}

/* Find all labels. */
void scan_labels()
{
int addr;
char *temp;

label_init(); /* zero all labels */
temp = prog; /* save pointer to top of program */

/* if the first token in the file is a label */
get_token();
if(token_type==NUMBER) {
strcpy(label_table[0].name,token);
label_table[0].p=prog;
}

find_eol();
do {
get_token();
if(token_type==NUMBER) {
addr = get_next_label(token);
if(addr== -1 || addr== -2) {
(addr== -1) ?serror(5):serror(6);
}
strcpy(label_table[addr].name,token);
label_table[addr].p=prog; /* current point in program */
}
/* if not on a blank line,find next line */
if(tok!=EOL) find_eol();
} while(tok!=FINISHED);
prog = temp; /* restore to original */
}

/* Find the start of next line */
void find_eol()
{
while(*prog!='\n' && *prog!='\0') ++prog;
if(*prog) prog++;
}

/* Return index of next free position in label array.
A -1 is returned if the array is full.
A -2 is returned when duplicate label is found.
*/
get_next_label(s)
char *s;
{
register int t;

for(t=0; t<NUM_LAB; ++t) {
if(label_table[t].name[0]==0) return t;
if(!strcmp(label_table[t].name,s)) return -2; /* dup */
}

return -1;
}

/* Find location of given label. A null is returned if
label is not found; otherwise a pointer to the position
of the label is returned */
char *find_label(s)
char *s;
{
register int t;

for(t=0; t<NUM_LAB; ++t)
if(!strcmp(label_table[t].name,s)) return label_table[t].p;
return '\0'; /* error condition */
}

/* Execute a GOTO statement. */
void exec_goto()
{
char *loc;

get_token(); /* get label to go to */
/* find the location of the label */
loc = find_label(token);
if(loc=='\0')
serror(7); /* label not defined */

else prog=loc; /* start program running at that loc */
}

/* Initialize the array that holds the labels.
By convention,a null label name indicates that */
void label_init()
{
register int t;

for(t=0; t<NUM_LAB; ++t) label_table[t].name[0]='\0';
}

/* Execute an IF statement. */
void exec_if()
{
int x,y,cond;
char op;

get_exp(&x); /* get left expression */

get_token(); /* get the operator */
if(!strchr("=<>",*token)) {
serror(0); /* not a legal operator */
return;
}
op=*token;

get_exp(&y); /* get right expression */

/* determine the outcome */
cond = 0;
switch(op) {
case '<':
if(x<y) cond=1;
break;
case '>':
if(x>y) cond=1;
break;
case '=':
if(x==y) cond=1;
break;
}
if(cond) { /* is true so process target of IF */
get_token();
if(tok!=THEN) {
serror(8);
return;
} /* else program execution starts on next line */
}
else find_eol(); /* find start of next line */
}

/* Execute a for loop */
void exec_for()
{
struct for_stack i;
int value;

get_token(); /* read the control variable */
if(!isalpha(*token)) {
serror(4);
return;
}

i.var=toupper(*token)-'A'; /* save its index */

get_token(); /* read the equal sign */
if(*token!='=') {
serror(3);
return;
}

get_exp(&value); /* get initial value */

variables[i.var]=value;

get_token();
if(tok!=TO) serror(9); /* read and discard the TO */

get_exp(&i.target); /* get target value */

/* if loop can execute at least once,push info on stack */
if(value>=variables[i.var]) {
i.loc = prog;
fpush(i);
}
else /* otherwise,skip loop code altogether */
while(tok!=NEXT) get_token();
}

/* Execute a NEXT statement. */
void next()
{
struct for_stack i;

i=fpop(); /* read the info */

variables[i.var]++; /* increment control variable */
if(variables[i.var]>i.target) return; /* all don */
fpush(i); /* otherwise, restore the info */
prog = i.loc; /* loop */
}

/* Push function for the FOR stack */
void fpush(i)
struct for_stack i;
{
if(ftos>FOR_NEST)
serror(10);

fstack[ftos]=i;
ftos++;
}

struct for_stack fpop()
{
ftos--;
if(ftos<0) serror(11);
return(fstack[ftos]);
}

/* Execute a simple from of the BASIC INPUT command */
void input()
{
char str[80],var;
int i;

get_token(); /* see if prompt string is present */
if(token_type==QUOTE) {
printf(token); /* if so,print it and check for comma */
get_token();
if(*token!=',') serror(1);
get_token();
}
else printf("? "); /* otherwise,prompt with / */
var = toupper(*token)-'A'; /* get the input var */

scanf("%d",&i); /*read input */

variables[var] = i; /* store it */
}

/* Execute a GOSUB command. */
void gosub()
{
char *loc;

get_token();
/* find the label to call */
loc = find_label(token);
if(loc=='\0')
serror(7); /* label not defined */
else {
gpush(prog); /* save place to return to */
prog = loc; /* start program running at that loc */
}
}

/* Return from GOSUB */
void greturn()
{
prog = gpop();
}

/* GOSUB stack push function. */
void gpush(s)
char *s;
{
gtos++;

if(gtos==SUB_NEST) {
serror(12);
return;
}

gstack[gtos]=s;
}

/* GOSUB stack pop function. */
char *gpop()
{
if(gtos==0) {
serror(13);
return 0;
}
return(gstack[gtos--]);
}
/* recursive descent parser for integer expressions
which may include variables */

#define DELIMITER 1
#define VARIABLE 2
#define NUMBER 3
#define COMMAND 4
#define STRING 5
#define QUOTE 6

#define EOL 9
#define FINISHED 10

void level2(),level3(),level4(),level5();
void level6(),primitive(),arith(),unary();

/* Entry point into parser. */
get_exp(result)
int *result;
{
get_token();
if(! *token) {
serror(2);
return;
}
level2(result);
putback();
}
/* Add or subtract two terms. */
void level2(result)
int *result;
{
register char op;
int hold;

level3(result);
while((op = *token) == '+' || op == '-') {
get_token();
level3(&hold);
arith(op,result,&hold);
}
}

/* Multiply or divide two factors. */
void level3(result)
int *result;
{
register char op;
int hold;

level4(result);
while((op = *token) == '*' || op == '/' || op == '%') {
get_token();
level4(&hold);
arith(op,result,&hold);
}
}

/* Process integer exponent. */
void level4(result)
int *result;
{
int hold;

level5(result);
if(*token == '^') {
get_token();
level4(&hold);
arith('^',result,&hold);
}

}

/* Is a unary + or -. */
void level5(result)
int *result;
{
register char op;

op = 0;
if((token_type==DELIMITER) && *token == '+' || *token == '-') {
op = *token;
get_token();
}
level6(result);
if(op)
unary(op,result);
}

/* Process parenthesized expression. */
void level6(result)
int *result;
{
if((*token == '(') && (token_type == DELIMITER)) {
get_token();
level2(result);
if(*token != ')')
serror(1);
get_token();
}
else
primitive(result);
}

/* Find value of number or variable. */
void primitive(result)
int *result;
{
switch(token_type) {
case VARIABLE:
*result = find_var(token);
get_token();
return;
case NUMBER:
*result = atoi(token);
get_token();
return;
default:
serror(0);
}
}

/* Perform the specified arithmetic. */
void arith(o,r,h)
char o;
int *r, *h;
{
register int t, ex;

switch(o) {
case '-':
*r = *r - *h;
break;
case '+':
*r = *r + *h;
break;
case '*':
*r = *r * *h;
break;
case '/':
*r = (*r) / (*h);
break;
case '%':
t = (*r) / (*h);
*r = *r - (t*(*h));
break;
case '^':
ex = *r;
if(*h == 0) {
*r = 1;
break;
}
for(t = *h-1; t>0; --t) *r= (*r) * ex;
break;
}
}
/* Reverce the sign. */
void unary(o,r)
char o;
int *r;
{
if(o == '-') *r = -(*r);
}

/* Find the value of a variable */
int find_var(s)
char *s;
{
if(!isalpha(*s)) {
serror(4); /* not a variable */
return 0;
}
return variables[toupper(*token) - 'A'];
}

/* Display an error message */
serror(error)
int error;
{
static char *e[] = {
"syntex error",
"unbalenced parentheses",
"no expression present",
"equal sign expected",
"not a variable",
"label table full",
"duplicate label",
"undefined label",
"THEN expected",
"TO expected",
"too many nested FOR loops",
"NEXT without FOR",
"too many nested GOSUBs",
"RETURN without GOSUB"
};
printf("%s\n",e[error]);
longjmp(e_buf,1); /* return to save point */
}

/* Get a token. */
get_token()
{
register char *temp;

token_type=0; tok=0;
temp = token;
if(*prog == '\0') { /* end of file */
*token = 0;
tok = FINISHED;
return(token_type=DELIMITER);
}

while(iswhite(*prog)) ++prog; /* skip over white space */

if(*prog=='\n') { /* crLf */
++prog;
tok = EOL; *token='\n';
token[1]='\0';
return(token_type = DELIMITER);
}

if(strchr("+-*^/%=;(),><",*prog)) { /* delimiter */
*temp = *prog;
prog++; /* advanced to next position */
temp++;
*temp=0;
return(token_type=DELIMITER);
}

if(*prog=='"') { /* quoted string */
prog++;
while(*prog!='"' && *prog!='\n') *temp++ = *prog++;
if(*prog=='\n') serror(1);
prog++; *temp=0;
return(token_type=QUOTE);
}

if(isdigit(*prog)) { /* number */
while(!isdelim(*prog)) *temp++ = *prog++;
*temp='\0';
return(token_type=NUMBER);
}

if(isalpha(*prog)) { /* var or command */
while(!isdelim(*prog)) *temp++ = *prog++;
token_type=STRING;
}

*temp='\0';

/* see if a string is a command or a variable */
if(token_type==STRING) {
tok=look_up(token); /* convert to internal rep */
if(!tok) token_type=VARIABLE;
else token_type=COMMAND; /* is a command */
}
return token_type;
}

/* Return a token to input stream. */
putback()
{
char *t;

t = token;
for(; *t; t++) prog--;
}

/* Look up a token's internal representation in the
token table */
look_up(s)
char *s;
{
register int i,j;
char *p;

/* convert to lowercase */
p = s;
while(*p){ *p = tolower(*p); p++; }

/* see if token is in table */
for(i=0; *table[i].command; i++)
if(!strcmp(table[i].command,s)) return table[i].tok;
return 0; /* unknown command */
}

/* Return true if c is a delimiter. */
isdelim(c)
char c;
{
if(strchr(" ;,+-<>/*%^=()",c) || c==9 || c=='\n' || c==0)
return 1;
return 0;
}

/* Return 1 if c is space or tab */
iswhite(c)
char c;
{
if(c==' ' || c=='\t') return 1;
else return 0;
}

#include <stdio.h>
#include <time.h>

#define STACK_SIZE 10

int push(int* stack, int* top, int value);
int pop(int* stack, int *top, int *value);
int Dfs(int (*dfs)[11], int* pred, int* r_stack, int* r_top);

main()
{
int i,j, k;
int temp;
int dfs_array[10][11]={
{0, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1},
{0, 2, 3, 7, 9, -1, -1, -1, -1, -1, -1},
{0, 1, 4, 8, -1, -1, -1, -1, -1, -1, -1},
{0, 1, 4, 5, -1, -1, -1, -1, -1, -1, -1},
{0, 2, 3, -1, -1, -1, -1, -1, -1, -1, -1},
{0, 3, 6, -1, -1, -1, -1, -1, -1, -1, -1},
{0, 5, 7, -1, -1, -1, -1, -1, -1, -1, -1},
{0, 1, 6, -1, -1, -1, -1, -1, -1, -1, -1},
{0, 0, 2, 9, -1, -1, -1, -1, -1, -1, -1},
{0, 1, 8, -1, -1, -1, -1, -1, -1, -1, -1}
};

int r_stack[10];
int r_top = 0;

int pred[10];
double start, finish;

start = clock();

printf("BFS 알고리즘\n");

Dfs(dfs_array, pred, r_stack, &r_top);

printf("Pred : ");
for(i=0; i<9; i++)
{
printf("%d ", pred[i]);
}
printf("\n");

printf("Stack : ");
for(i=0; i<9; i++)
{
printf("%d ", r_stack[i]);
}
printf("\n");

finish =clock();
printf("소요시간 : %f\n",(finish-start) / (double)CLOCKS_PER_SEC );

}

int Dfs(int (*dfs)[11], int* pred, int* r_stack, int* r_top)
{
int i,j;

int k=1;//vertex가 가리키는값의 위치
int source;//시작점

int s_stack[10];
int s_top = 0;

int pointer = 0;//현재 vertex의 위치
int temp;

printf("source vertex를 선택하세요 : ");
scanf("%d", &source);

pred[source] = -1;//pred 시작점 표시
dfs[source][0] = 1;//true false 구분

push(s_stack, &s_top, source);
push(r_stack, r_top, source);

if(dfs[source][1] > 0)// source가 가르키는값이 존재할때
{
pointer = dfs[source][1];//다음 vertex는 source가 가르키는값
pred[pointer] = source;//다음 vertex의 pred는 source
}

else
return 1;

while(1)
{
//if(dfs[pointer][0] == 0)//현재 vertex가 미 방문일때
{
if(s_top<=0)
return 0;

if(k==1 && (dfs[pointer][0] == 0))//
{
dfs[pointer][0] = 1;//true false 구분

push(s_stack, &s_top, pointer);
push(r_stack, r_top, pointer);
}

temp = dfs[pointer][k];
if(dfs[pointer][k] >= 0 && (dfs[temp][0] == 0))
{//현재 vertex가 가르키는값이 존재하고 미 방문일때

temp = pointer;
pointer = dfs[pointer][k];//가르키는 값이 다음 지시자
pred[pointer] = temp;//pred는 기존 지시자 삽입

k=0;
}

else if(dfs[pointer][k] < 0)//vertex가 가르키는 값이 모두 방문일때
{
pop(s_stack, &s_top, &temp);
//pop(s_stack, &s_top, &temp);
pointer = s_stack[s_top];
k=0;
}

k++;//vertex가 가르키는 값이 이미 방문일때 다음값 지정
}
}
}

int push(int* stack, int* top, int value)
{

if(*top >= STACK_SIZE)
{
printf("input's size is over the range \n");
return 1;
}

stack[*top] = value;
(*top)++;

return 0;
}

int pop(int* stack, int *top, int *value)
{
if(*top < 0)
{
printf("no more data in stack \n");
return 1;
}

(*top)--;
*value = stack[*top];

return 0;
}

dfs.c

//*
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define STACK_SIZE 50

int push(char* stack, int* top, char value);
int pop(char* stack, int *top, char *value);
int Change_to_post(char* stack, char* str, int *top);//infix -> postfix
int Cal_post(char* stack, int *top);

main()
{
char stack[50];//스택
char str[50];//입력 배열
int top=0;
int error_f=0; // 에러시 리턴값 저장

int length;
int i;
int j;

double start, finish;

start = clock();

printf("수식을 입력하시오 : ");
scanf("%s", &str);

error_f = Change_to_post(stack, str, &top);
if(error_f == 1)//함수내에서 1을 반환시 종료
return 1;

//자리수 구분 정리
length = strlen(stack);
for(i = 0, j=0; i<length; i++, j++)
{
if(stack[i] == ' ' && stack[i+1] == ' ')
{
str[j] = ' ';
str[j+1] = 0;
}

if(stack[i] == ' ' && stack[i+1] != ' ')
j--;

else
{
str[j] = stack[i];
str[j+1] = 0;
}
}

printf("변환된 posfix 수식 : ");
length = strlen(str);
for(i = 0; i<length; i++)
{
printf("%c",str[i]);
}
printf("\n\n");

Cal_post(str, &top);

finish =clock();
printf("소요시간 : %f\n",(finish-start) / (double)CLOCKS_PER_SEC );

}
int Cal_post(char* stack, int *top)
{
int i = 0;//stack
int j = 0;//in_stack
int in_stack[50];

while(1)
{
if(stack[i] == 0)
break;

if(stack[i] >= 48 && stack[i] <= 57)
{
in_stack[j] = stack[i] - 48;

if(stack[i+1] >= 48 && stack[i+1] <= 57)
{
in_stack[j] = (in_stack[j]*10) + (stack[i+1] - 48);
i++;
}
}

else if(stack[i] == ' ')
{
j--;
}

else if(stack[i] == '*' || stack[i] == '/' || stack[i] == '+' || stack[i] == '-')
{
if(stack[i] == '*')
{
in_stack[j-2] = in_stack[j-2] * in_stack[j-1];
j = j-2;
}

else if(stack[i] == '/')
{
in_stack[j-2] = in_stack[j-2] / in_stack[j-1];
j = j-2;
}

else if(stack[i] == '+')
{
in_stack[j-2] = in_stack[j-2] + in_stack[j-1];
j = j-2;
}

else if(stack[i] == '-')
{
in_stack[j-2] = in_stack[j-2] - in_stack[j-1];
j = j-2;
}
}

i++;
j++;
}

printf("계산 결과는 %d 입니다 \n", in_stack[0]);

return 0;

}

int Change_to_post(char* stack, char* str, int *top)
{
int i=0;

char ins_stack[50];//명렁어 저장하는 스택
int ins_top=0;//명령어용 top

int error_f=0; // 에러시 리턴값 저장
char char_temp;

char emp = ' ';// 자리수 구분위한 공백

while(1)
{
if(str[i] == 0)
{
while(1)
{
if(ins_top<0)
{
stack[(*top)-1] = 0;
return 0;
}
else
{
error_f = pop(ins_stack, &ins_top, &char_temp);
if(error_f == 1)//pop에서 1을 반환시 종료
return 1;

error_f = push(stack, top, char_temp);
if(error_f == 1)//push에서 1을 반환시 종료
return 1;
}
}
}

else if(str[i] >= 48 && str[i] <= 57)
{
error_f = push(stack, top, str[i]);//피연산자 일때
if(error_f == 1)//push에서 1을 반환시 종료
return 1;
}

else if(str[i] == '*' || str[i] == '/' || str[i] == '+'
|| str[i] == '-' || str[i] == '(' || str[i] == ')')//연산자 일때
{
if((str[i] == '+' || str[i] == '-') && (ins_stack[ins_top-1] == '*'
|| ins_stack[ins_top-1] == '/'))//우선순위 낮을때
{
error_f = pop(ins_stack, &ins_top, &char_temp);
if(error_f == 1)//pop에서 1을 반환시 종료
return 1;

error_f = push(stack, top, char_temp);
if(error_f == 1)//push에서 1을 반환시 종료
return 1;

error_f = push(ins_stack, &ins_top, str[i]);
if(error_f == 1)//push에서 1을 반환시 종료
return 1;
}

else if(str[i] == ')')// 괄호가 끝났을때
{
while(1)
{
if(ins_stack[ins_top-1] == '(')//여는 괄호가 나오면 종료
{
error_f = pop(ins_stack, &ins_top, &char_temp);
if(error_f == 1)//pop에서 1을 반환시 종료
return 1;

break;
}
else//명령어 스택에서 일반 스택으로 이동
{
error_f = pop(ins_stack, &ins_top, &char_temp);
if(error_f == 1)//pop에서 1을 반환시 종료
return 1;

error_f = push(stack, top, char_temp);
if(error_f == 1)//push에서 1을 반환시 종료
return 1;
}
}
}

else //우선순위 낮을때
{
error_f = push(ins_stack, &ins_top, str[i]);
if(error_f == 1)//push에서 1을 반환시 종료
return 1;
}
}//연산자 else if end

else//이 외의 값들 입력시
{
printf("올바르지 않은 형식의 값이 입력되었습니다 \n");
return 1;
}

error_f = push(stack, top, emp);//공백
if(error_f == 1)//push에서 1을 반환시 종료
return 1;

i++;

}//while end
}//fuction end

int push(char* stack, int* top, char value)
{

if(*top >= STACK_SIZE)
{
printf("input's size is over the range \n");
return 1;
}

stack[*top] = value;
(*top)++;

return 0;
}

int pop(char* stack, int *top, char *value)
{
if(*top < 0)
{
printf("no more data in stack \n");
return 1;
}

(*top)--;
*value = stack[*top];

return 0;
}
//*/

infixTOpostfix.c

Euclide & non Euclide gcd algorithm

시간 측정 포함

------------------------------------

#include <time.h>
#include <stdio.h>

int gcd1(int m, int n);
int gcd2(int m, int n);

main(void)
{
int m;
int n;
int i;
int result;

double start, finish;

printf("m과 n을 입력하시오(always m>n) : ");
scanf("%d %d", &m, &n);

start = clock();
result = gcd1(m,n);
for(i=0; i<=999999; i++)
finish =clock();
printf("Euclid's result : %d \n", result);
printf("Execution times : %f\n",(finish-start) / (double)CLOCKS_PER_SEC );

start = clock();
result = gcd2(m,n);
for(i=0; i<=999999; i++)
finish =clock();
printf("Euclid's result : %d \n", result);
printf("Execution times : %f\n",(finish-start) / (double)CLOCKS_PER_SEC );

}

int gcd1(int m, int n)//Euclid
{
int r;
int temp;

if(m <n)
{
temp = m;
m = n;
n = temp;
}

while(m%n != 0)
{
r = m % n;
m = n;
n = r;
}

return n;
}

int gcd2(int m, int n)//non
{
int i;
int result=1;

for(i=1; i<=n; i++)
{
if(m%i==0 && n%i==0)
{
result = i;
}
}

return result;
}

file.c