유닉스에서는 되는데.. 리눅에선 안돌아가는군엽..

두군데서 돌렸는데.. 리눅스는 세그먼트 오류를 일으키는 군여...

갑갑해서 소스를 올려봅니다...

<>

#include
#include
#include
#include "node.c"

extern short ic;

int Dataln;

main(argc, argv)
{
int f_descrip;
load(f_descrip);
dump();
ic = 0;
printf("=========================================\n");
control();
}

load(filedes)
{
char buf[16*MSIZE];
int line_num=1, nread, i , j=0, tmp=0;
if( (filedes = open("pgm", O_RDONLY)) == -1 ) {
printf(" Can't open file \n");
exit(1);
}
nread = read(filedes, buf, sizeof(buf));
for (i = 0 ; i<(16*MSIZE) ; i++) {
if(buf[i] == '\n')
line_num++;
}
while(line_num--) {
for(i=0; i<17; i++) {
tmp=(tmp*2+(buf[j++]-'0'));
if(i==15)
memory[Dataln++].wd=tmp;
}
}
}

dump()
{
int i;
printf("=============\n value in memory\n ==============\n");
for (i = 0; i < Dataln-1; i++)
printf("%2d %7d \n", i*2, memory[i].wd);
printf("=============\n");
}

<>

#include "./node.h"

#define MSIZE 64

struct instruction {
unsigned op_code 4, operand 12;
};

struct data {
unsigned byte0 8, byte1 8;
};

typedef union {
short wd;
struct instruction inst;
struct data dat;
} word;

word memory[MSIZE];

int flag=0;
short ic = 0, od; /* instruction count */
short accumulator;
short mar, mdr;
control() /* instruntion cycle */
{
int i=0, acctmp[16], input, tmp=32768;
while(1) {
od=memory[ic].inst.operand;
if((od%2)==1)
flag=1;
switch(memory[ic].inst.op_code) {
case H
exit(1);
break;
case INC
accumulator++;
ic++;
break;
case ADD
alu(PLUS, od);
ic++;
break;
case SUB
alu(MINUS, od);
ic++;
break;
case AND
alu(ANDL, od);
ic++;
break;
case COM
alu(COMPL, od);
ic++;
break;
case RS
alu(RSHFT, od);
ic++;
break;
case LS
alu(LSHFT, od);
ic++;
break;
case LD
mu(SA);
mu(SD);
accumulator = mdr;
ic++;
break;
case ST
mu(SA);
mdr = accumulator;
mu(SM);
ic++;
break;
case RD
printf("input data");
scanf("%d", &input);
accumulator = input;
ic++;
break;
case WR
for(i=1; i<17; i++) {
if((accumulator&tmp)>0)
acctmp[i-1]=1;
else
else
acctmp[i-1]=0;
tmp/=2;
}
for(i=0; i<16; i++)
printf("%d",acctmp[i]);
printf("\n");
ic++;
break;
case B
ic = od/2;
break;
case BZ
alu(ISZERO,od);
break;
case BGZ
alu(GTZERO,od);
break;
case BLZ
alu(LTZERO,od);
break;
}
}
}

mu (code)
{
switch(code) {
case SA
mar=od;
break;
case SM
if(flag==1)
memory[(mar-1)/2].dat.byte1=mdr;
else if(flag==0)
memory[mar/2].dat.byte0=mdr;
break;
case SD
if(flag==1)
mdr=memory[(mar-1)/2].dat.byte1;
else if(flag==0)
mdr=memory[mar/2].dat.byte0;
break;
}
}

alu(code, operand)
{
short i;
int tmp;
switch(code) {
case PLUS
mu(SA);
mu(SD);
accumulator+=mdr;
break;
case MINUS
mu(SA);
mu(SD);
accumulator-=mdr;
break;
case ANDL
mu(SA);
mu(SD);
accumulator&=mdr;
break;
case COMPL
mu(SA);
mu(SD);
tmp=65535;
accumulator=(accumulator^tmp);
break;
case RSHFT
for(i=1; i accumulator/=2;
break;
case LSHFT
for(i=1; i accumulator*=2;
break;
case ISZERO
if(accumulator==0)
ic=operand/2;
else
ic++;
break;
case GTZERO
if(accumulator>0)
ic=operand/2;
else
ic++;
break;
case LTZERO
if(accumulator<0)
ic=operand/2;
else
ic++;
break;
}
}

<< node.h >>

/* codes for alu */

#define PLUS 1
#define MINUS 2
#define ANDL 3
#define COMPL 4
#define RSHFT 5
#define LSHFT 6
#define ISZERO 7
#define GTZERO 8
#define LTZERO 9

/* codes for control */

#define H 0
#define INC 1
#define ADD 2
#define SUB 3
#define AND 4
#define COM 5
#define RS 6
#define LS 7
#define LD 8
#define ST 9
#define RD 10
#define WR 11
#define B 12
#define BZ 13
#define BGZ 14
#define BLZ 15

/* codes for mu */

#define SA 0
#define SM 1
#define SD 2