void SalinKata (void) {
/* Mengakuisisi kata, menyimpan dalam CKata
I.S. : CC adalah karakter pertama dari kata
F.S. : CKata berisi kata yang sudah diakuisisi, jika karakternya melebihi NMax,
sisa "kata" dibuang; CC = BLANK atau CC = MARK; CC adalah karakter
sesudah karakter terakhir yang diakuisisi */
/* Kamus */
int i=1;
/* Algoritma */
for (;;) {
CKata.TabKata[i]=CC;
ADV();
if (EOP()||(CC==BLANK)||(i==NMax)) {
break;
} else {
i++;
}
}
if (i==NMax) { /* abaikan sisa kata */
while ((CC!=BLANK)&&(!EOP())) {
ADV();
}
}
CKata.length=i;
}
/* Primitif-Primitif Mesin Kata */
void Ignore_Blank (void) {
/* Mengabaikan satu atau beberapa BLANK
I.S. : CC sembarang
F.S. : CC ≠ BLANK atau CC = MARK */
/* Kamus */
/* Algoritma */
while ((CC==BLANK)&&(!EOP())) {
ADV();
}
}
void ADVKATA (void)
{
//algoritma
Ignore_Blank();
if (!EOP()) {
SalinKata();
} else {
EndKata = true;
}
}
void SalinKata (void)
{
//kamus lokal
// int i =0;
//algoritma
CKata.Length=0;
while (CC != BLANK && !EOP()) {
CKata.TabKata[CKata.Length] = CC;
CKata.Length++;
CKata.TabKata[CKata.Length]=0;
ADV();
}
if (CC == EOP() && CKata.Length<NMax)
{
EndKata = true;
} else {
EndKata = false;
}
}
void STARTKATA(void)
{
/* Kamus Lokal */
// Algoritma
START();
Ignore_Blank();
if (EOP() || CC == BLANK ) {
EndKata = true;
} else {
SalinKata();
}
}
void ADVKATA (void) {
/* I.S. : EndKata = false; CC adalah karakter sesudah karakter terakhir dari kata
yang sudah diakuisisi
F.S. : Jika CC = MARK, maka EndKata = true atau EndKata = false,
CKata adalah kata terakhir yang sudah diakuisisi;
CC karakter pertama sesudah karakter terakhir kata */
/* Kamus */
/* Algoritma */
Ignore_Blank();
if (EOP()) {
EndKata=true;
} else {
SalinKata();
}
}
int main()
{
char pita[50];
scanf("%[^\n]s", pita);
START(pita);
while(EOP()!=0){
INC(pita);
CTBS(pita);
DBS();
}
printf("%d\n", GC());
return 0;
}
void STARTKATA (void) {
/* I.S. : CC sembarang
F.S. : EndKata = true, dan CC = Mark, atau EndKata = false,
CKata adalah kata yang sudah diakuisisi,
CC karakter pertama sesudah karakter terakhir kata */
/* Kamus */
/* Algoritma */
START();
Ignore_Blank();
if (EOP()) {
EndKata=true;
} else {
EndKata=false;
SalinKata();
}
}
int main()
{
char pita[50];
scanf("%[^\n]s", pita);
START(pita);
printf("%c\n", GETCC());
while(EOP()!=0){
//INC(pita);
ADV(pita);
printf("%c\n", GETCC());
//sebaiknya titik(EOP) tidak di print
}
return 0;
}
int main()
{
printf("=========================");
printf("=Program Mesin Karakter =");
printf("=========================");
printf("\n\nIsi file krktrdsp.txt...\n");
printf("===========================");
printf("=========================\n\n");
START();
while(!EOP())
{
printf("%c",CC);
DSP+=CountHuruf(CC);
DSPA+=CountHurufA(CC);
DSPAN+=CountAN(CC);
DSPV+=CountVokal(CC);
DSPK+=CountKonsonan(CC);
DSP1+=Count_1(CC);
ADV();
}
printf("\n\n===========================");
printf("=========================\n");
printf("\nAkhir Pembacaan pita...\n");
printf("\nJumlah Total Karakter :%d\n",DSP);
printf("\nJumlah Karakter A :%d\n",DSPA);
printf("\nJumlah Karakter AN :%d\n",DSPAN);
printf("\nJumlah Karakter Vokal :%d\n",DSPV);
printf("\nJumlah Karakter Konsonan :%d\n",DSPK);
printf("\nJumlah Karakter 1 :%d\n",DSP1);
printf("=========================");
printf("=Copyright by @dyarsa_SP=");
printf("=========================");
return 0;
}
STATIC void touchlvalue(elem *e)
{ register int i;
if (e->Eoper == OPind) /* if indirect store */
{
/* NOTE: Some types of array assignments do not need
* to touch all variables. (Like a[5], where a is an
* array instead of a pointer.)
*/
touchfunc(0);
return;
}
for (i = hcstop; --i >= 0;)
{ if (hcstab[i].Helem &&
#if TARGET_MAC // Vsym should be valid before compare
!EOP(hcstab[i].Helem) &&
hcstab[i].Helem->Eoper != OPconst &&
#endif
hcstab[i].Helem->EV.sp.Vsym == e->EV.sp.Vsym)
hcstab[i].Helem = NULL;
}
assert(e->Eoper == OPvar || e->Eoper == OPrelconst);
switch (e->EV.sp.Vsym->Sclass)
{
case SCregpar:
case SCregister:
case SCtmp:
case SCpseudo:
break;
case SCauto:
case SCparameter:
#if TX86
case SCfastpar:
case SCbprel:
#endif
if (e->EV.sp.Vsym->Sflags & SFLunambig)
break;
/* FALL-THROUGH */
case SCstatic:
case SCextern:
case SCglobal:
case SClocstat:
case SCcomdat:
case SCinline:
case SCsinline:
case SCeinline:
#if TX86
case SCcomdef:
#endif
touchstar();
break;
default:
#ifdef DEBUG
elem_print(e);
symbol_print(e->EV.sp.Vsym);
#endif
assert(0);
}
}
code *xmmpost(elem *e,regm_t *pretregs)
{
elem *e1 = e->E1;
elem *e2 = e->E2;
tym_t ty1 = tybasic(e1->Ety);
CodeBuilder cdb;
regm_t retregs;
unsigned reg;
bool regvar = FALSE;
if (config.flags4 & CFG4optimized)
{
// Be careful of cases like (x = x+x+x). We cannot evaluate in
// x if x is in a register.
unsigned varreg;
regm_t varregm;
if (isregvar(e1,&varregm,&varreg) && // if lvalue is register variable
doinreg(e1->EV.sp.Vsym,e2) // and we can compute directly into it
)
{
regvar = TRUE;
retregs = varregm;
reg = varreg; // evaluate directly in target register
cdb.append(getregs(retregs)); // destroy these regs
}
}
code cs;
if (!regvar)
{
code *c = getlvalue(&cs,e1,0); // get EA
cdb.append(c);
retregs = XMMREGS & ~*pretregs;
if (!retregs)
retregs = XMMREGS;
c = allocreg(&retregs,®,ty1);
cdb.append(c);
cs.Iop = xmmload(ty1, true); // MOVSD xmm,xmm_m64
code_newreg(&cs,reg - XMM0);
cdb.gen(&cs);
checkSetVex(cdb.last(), ty1);
}
// Result register
regm_t resultregs = XMMREGS & *pretregs & ~retregs;
if (!resultregs)
resultregs = XMMREGS & ~retregs;
unsigned resultreg;
code *c = allocreg(&resultregs, &resultreg, ty1);
cdb.append(c);
cdb.gen2(xmmload(ty1,true),modregxrmx(3,resultreg-XMM0,reg-XMM0)); // MOVSS/D resultreg,reg
checkSetVex(cdb.last(), ty1);
regm_t rretregs = XMMREGS & ~(*pretregs | retregs | resultregs);
if (!rretregs)
rretregs = XMMREGS & ~(retregs | resultregs);
c = codelem(e2,&rretregs,FALSE); // eval right leaf
cdb.append(c);
unsigned rreg = findreg(rretregs);
unsigned op = xmmoperator(e1->Ety, e->Eoper);
cdb.gen2(op,modregxrmx(3,reg-XMM0,rreg-XMM0)); // ADD reg,rreg
checkSetVex(cdb.last(), e1->Ety);
if (!regvar)
{
cs.Iop = xmmstore(ty1,true); // reverse operand order of MOVS[SD]
cdb.gen(&cs);
checkSetVex(cdb.last(), ty1);
}
if (e1->Ecount || // if lvalue is a CSE or
regvar) // rvalue can't be a CSE
{
cdb.append(getregs_imm(retregs)); // necessary if both lvalue and
// rvalue are CSEs (since a reg
// can hold only one e at a time)
cssave(e1,retregs,EOP(e1)); // if lvalue is a CSE
}
cdb.append(fixresult(e,resultregs,pretregs));
freenode(e1);
return cdb.finish();
}
code *xmmeq(elem *e, unsigned op, elem *e1, elem *e2,regm_t *pretregs)
{
tym_t tymll;
unsigned reg;
int i;
code cs;
elem *e11;
bool regvar; /* TRUE means evaluate into register variable */
regm_t varregm;
unsigned varreg;
targ_int postinc;
//printf("xmmeq(e1 = %p, e2 = %p, *pretregs = %s)\n", e1, e2, regm_str(*pretregs));
int e2oper = e2->Eoper;
tym_t tyml = tybasic(e1->Ety); /* type of lvalue */
regm_t retregs = *pretregs;
if (!(retregs & XMMREGS))
retregs = XMMREGS; // pick any XMM reg
bool aligned = xmmIsAligned(e1);
cs.Iop = (op == OPeq) ? xmmstore(tyml, aligned) : op;
regvar = FALSE;
varregm = 0;
if (config.flags4 & CFG4optimized)
{
// Be careful of cases like (x = x+x+x). We cannot evaluate in
// x if x is in a register.
if (isregvar(e1,&varregm,&varreg) && // if lvalue is register variable
doinreg(e1->EV.sp.Vsym,e2) && // and we can compute directly into it
varregm & XMMREGS
)
{ regvar = TRUE;
retregs = varregm;
reg = varreg; /* evaluate directly in target register */
}
}
if (*pretregs & mPSW && !EOP(e1)) // if evaluating e1 couldn't change flags
{ // Be careful that this lines up with jmpopcode()
retregs |= mPSW;
*pretregs &= ~mPSW;
}
CodeBuilder cdb;
cdb.append(scodelem(e2,&retregs,0,TRUE)); // get rvalue
// Look for special case of (*p++ = ...), where p is a register variable
if (e1->Eoper == OPind &&
((e11 = e1->E1)->Eoper == OPpostinc || e11->Eoper == OPpostdec) &&
e11->E1->Eoper == OPvar &&
e11->E1->EV.sp.Vsym->Sfl == FLreg
)
{
postinc = e11->E2->EV.Vint;
if (e11->Eoper == OPpostdec)
postinc = -postinc;
cdb.append(getlvalue(&cs,e11,RMstore | retregs));
freenode(e11->E2);
}
else
{ postinc = 0;
cdb.append(getlvalue(&cs,e1,RMstore | retregs)); // get lvalue (cl == CNIL if regvar)
}
cdb.append(getregs_imm(regvar ? varregm : 0));
reg = findreg(retregs & XMMREGS);
cs.Irm |= modregrm(0,(reg - XMM0) & 7,0);
if ((reg - XMM0) & 8)
cs.Irex |= REX_R;
// Do not generate mov from register onto itself
if (!(regvar && reg == XMM0 + ((cs.Irm & 7) | (cs.Irex & REX_B ? 8 : 0))))
{
cdb.gen(&cs); // MOV EA+offset,reg
if (op == OPeq)
checkSetVex(cdb.last(), tyml);
}
if (e1->Ecount || // if lvalue is a CSE or
regvar) // rvalue can't be a CSE
{
cdb.append(getregs_imm(retregs)); // necessary if both lvalue and
// rvalue are CSEs (since a reg
// can hold only one e at a time)
cssave(e1,retregs,EOP(e1)); // if lvalue is a CSE
}
cdb.append(fixresult(e,retregs,pretregs));
Lp:
if (postinc)
{
int reg = findreg(idxregm(&cs));
if (*pretregs & mPSW)
{ // Use LEA to avoid touching the flags
unsigned rm = cs.Irm & 7;
if (cs.Irex & REX_B)
rm |= 8;
cdb.genc1(0x8D,buildModregrm(2,reg,rm),FLconst,postinc);
if (tysize(e11->E1->Ety) == 8)
code_orrex(cdb.last(), REX_W);
}
else if (I64)
{
cdb.genc2(0x81,modregrmx(3,0,reg),postinc);
if (tysize(e11->E1->Ety) == 8)
code_orrex(cdb.last(), REX_W);
}
else
{
if (postinc == 1)
cdb.gen1(0x40 + reg); // INC reg
else if (postinc == -(targ_int)1)
cdb.gen1(0x48 + reg); // DEC reg
else
{
cdb.genc2(0x81,modregrm(3,0,reg),postinc);
}
}
}
freenode(e1);
return cdb.finish();
}
code *xmmopass(elem *e,regm_t *pretregs)
{ elem *e1 = e->E1;
elem *e2 = e->E2;
tym_t ty1 = tybasic(e1->Ety);
unsigned sz1 = tysize[ty1];
regm_t rretregs = XMMREGS & ~*pretregs;
if (!rretregs)
rretregs = XMMREGS;
code *cr = codelem(e2,&rretregs,FALSE); // eval right leaf
unsigned rreg = findreg(rretregs);
code cs;
code *cl,*cg;
regm_t retregs;
unsigned reg;
bool regvar = FALSE;
if (config.flags4 & CFG4optimized)
{
// Be careful of cases like (x = x+x+x). We cannot evaluate in
// x if x is in a register.
unsigned varreg;
regm_t varregm;
if (isregvar(e1,&varregm,&varreg) && // if lvalue is register variable
doinreg(e1->EV.sp.Vsym,e2) // and we can compute directly into it
)
{ regvar = TRUE;
retregs = varregm;
reg = varreg; // evaluate directly in target register
cl = NULL;
cg = getregs(retregs); // destroy these regs
}
}
if (!regvar)
{
cl = getlvalue(&cs,e1,rretregs); // get EA
retregs = *pretregs & XMMREGS & ~rretregs;
if (!retregs)
retregs = XMMREGS & ~rretregs;
cg = allocreg(&retregs,®,ty1);
cs.Iop = xmmload(ty1); // MOVSD xmm,xmm_m64
code_newreg(&cs,reg - XMM0);
cg = gen(cg,&cs);
}
unsigned op = xmmoperator(e1->Ety, e->Eoper);
code *co = gen2(CNIL,op,modregxrmx(3,reg-XMM0,rreg-XMM0));
if (!regvar)
{
cs.Iop = xmmstore(ty1); // reverse operand order of MOVS[SD]
gen(co,&cs);
}
if (e1->Ecount || // if lvalue is a CSE or
regvar) // rvalue can't be a CSE
{
cl = cat(cl,getregs_imm(retregs)); // necessary if both lvalue and
// rvalue are CSEs (since a reg
// can hold only one e at a time)
cssave(e1,retregs,EOP(e1)); // if lvalue is a CSE
}
co = cat(co,fixresult(e,retregs,pretregs));
freenode(e1);
return cat4(cr,cl,cg,co);
}
void ADV(){
if(!EOP()){
CC = getchar();
}
}
STATIC void ecom(elem **pe)
{ int i,op,hcstopsave;
unsigned hash;
elem *e,*ehash;
tym_t tym;
e = *pe;
assert(e);
elem_debug(e);
#ifdef DEBUG
assert(e->Ecount == 0);
//assert(e->Ecomsub == 0);
#endif
tym = tybasic(e->Ety);
op = e->Eoper;
switch (op)
{
case OPconst:
case OPvar:
case OPrelconst:
break;
case OPstreq:
case OPpostinc:
case OPpostdec:
case OPeq:
case OPaddass:
case OPminass:
case OPmulass:
case OPdivass:
case OPmodass:
case OPshrass:
case OPashrass:
case OPshlass:
case OPandass:
case OPxorass:
case OPorass:
#if TX86
/* Reverse order of evaluation for double op=. This is so that */
/* the pushing of the address of the second operand is easier. */
/* However, with the 8087 we don't need the kludge. */
if (op != OPeq && tym == TYdouble && !config.inline8087)
{ if (EOP(e->E1))
ecom(&e->E1->E1);
ecom(&e->E2);
}
else
#endif
{
/* Don't mark the increment of an i++ or i-- as a CSE, if it */
/* can be done with an INC or DEC instruction. */
if (!(OTpost(op) && elemisone(e->E2)))
ecom(&e->E2); /* evaluate 2nd operand first */
case OPnegass:
if (EOP(e->E1)) /* if lvalue is an operator */
{
#ifdef DEBUG
if (e->E1->Eoper != OPind)
elem_print(e);
#endif
assert(e->E1->Eoper == OPind);
ecom(&(e->E1->E1));
}
}
touchlvalue(e->E1);
if (!OTpost(op)) /* lvalue of i++ or i-- is not a cse*/
{
hash = cs_comphash(e->E1);
vec_setbit(hash % CSVECDIM,csvec);
addhcstab(e->E1,hash); // add lvalue to hcstab[]
}
return;
case OPbtc:
case OPbts:
case OPbtr:
ecom(&e->E1);
ecom(&e->E2);
touchfunc(0); // indirect assignment
return;
case OPandand:
case OPoror:
ecom(&e->E1);
hcstopsave = hcstop;
ecom(&e->E2);
hcstop = hcstopsave; /* no common subs by E2 */
return; /* if comsub then logexp() will */
/* break */
case OPcond:
ecom(&e->E1);
hcstopsave = hcstop;
ecom(&e->E2->E1); /* left condition */
hcstop = hcstopsave; /* no common subs by E2 */
ecom(&e->E2->E2); /* right condition */
hcstop = hcstopsave; /* no common subs by E2 */
return; /* can't be a common sub */
case OPcall:
case OPcallns:
ecom(&e->E2); /* eval right first */
/* FALL-THROUGH */
case OPucall:
case OPucallns:
ecom(&e->E1);
touchfunc(1);
return;
case OPstrpar: /* so we don't break logexp() */
#if TX86
case OPinp: /* never CSE the I/O instruction itself */
#endif
case OPdctor:
ecom(&e->E1);
/* FALL-THROUGH */
case OPasm:
case OPstrthis: // don't CSE these
case OPframeptr:
case OPgot:
case OPctor:
case OPdtor:
case OPmark:
return;
case OPddtor:
return;
case OPparam:
#if TX86
case OPoutp:
#endif
ecom(&e->E1);
case OPinfo:
ecom(&e->E2);
return;
case OPcomma:
case OPremquo:
ecom(&e->E1);
ecom(&e->E2);
break;
#if TARGET_SEGMENTED
case OPvp_fp:
case OPcvp_fp:
ecom(&e->E1);
touchaccess(e);
break;
#endif
case OPind:
ecom(&e->E1);
/* Generally, CSEing a *(double *) results in worse code */
if (tyfloating(tym))
return;
break;
#if TX86
case OPstrcpy:
case OPstrcat:
case OPmemcpy:
case OPmemset:
ecom(&e->E2);
case OPsetjmp:
ecom(&e->E1);
touchfunc(0);
return;
#endif
default: /* other operators */
#if TX86
#ifdef DEBUG
if (!EBIN(e)) WROP(e->Eoper);
#endif
assert(EBIN(e));
case OPadd:
case OPmin:
case OPmul:
case OPdiv:
case OPor:
case OPxor:
case OPand:
case OPeqeq:
case OPne:
case OPscale:
case OPyl2x:
case OPyl2xp1:
ecom(&e->E1);
ecom(&e->E2);
break;
#else
#ifdef DEBUG
if (!EOP(e)) WROP(e->Eoper);
#endif
assert(EOP(e));
ecom(&e->E1);
if (EBIN(e))
ecom(&e->E2); /* eval left first */
break;
#endif
case OPstring:
case OPaddr:
case OPbit:
#ifdef DEBUG
WROP(e->Eoper);
elem_print(e);
#endif
assert(0); /* optelem() should have removed these */
/* NOTREACHED */
// Explicitly list all the unary ops for speed
case OPnot: case OPcom: case OPneg: case OPuadd:
case OPabs: case OPsqrt: case OPrndtol: case OPsin: case OPcos: case OPrint:
case OPpreinc: case OPpredec:
case OPbool: case OPstrlen: case OPs16_32: case OPu16_32:
case OPd_s32: case OPd_u32:
case OPs32_d: case OPu32_d: case OPd_s16: case OPs16_d: case OP32_16:
case OPd_f: case OPf_d:
case OPd_ld: case OPld_d:
case OPc_r: case OPc_i:
case OPu8_16: case OPs8_16: case OP16_8:
case OPu32_64: case OPs32_64: case OP64_32: case OPmsw:
case OPu64_128: case OPs64_128: case OP128_64:
case OPd_s64: case OPs64_d: case OPd_u64: case OPu64_d:
case OPstrctor: case OPu16_d: case OPd_u16:
case OParrow:
case OPvoid: case OPnullcheck:
case OPbsf: case OPbsr: case OPbswap:
case OPld_u64:
#if TARGET_SEGMENTED
case OPoffset: case OPnp_fp: case OPnp_f16p: case OPf16p_np:
#endif
ecom(&e->E1);
break;
case OPhalt:
return;
}
/* don't CSE structures or unions or volatile stuff */
if (tym == TYstruct ||
tym == TYvoid ||
e->Ety & mTYvolatile
#if TX86
// don't CSE doubles if inline 8087 code (code generator can't handle it)
|| (tyfloating(tym) && config.inline8087)
#endif
)
return;
hash = cs_comphash(e); /* must be AFTER leaves are done */
/* Search for a match in hcstab[].
* Search backwards, as most likely matches will be towards the end
* of the list.
*/
#ifdef DEBUG
if (debugx) dbg_printf("elem: %p hash: %6d\n",e,hash);
#endif
int csveci = hash % CSVECDIM;
if (vec_testbit(csveci,csvec))
{
for (i = hcstop; i--;)
{
#ifdef DEBUG
if (debugx)
dbg_printf("i: %2d Hhash: %6d Helem: %p\n",
i,hcstab[i].Hhash,hcstab[i].Helem);
#endif
if (hash == hcstab[i].Hhash && (ehash = hcstab[i].Helem) != NULL)
{
/* if elems are the same and we still have room for more */
if (el_match(e,ehash) && ehash->Ecount < 0xFF)
{
/* Make sure leaves are also common subexpressions
* to avoid false matches.
*/
if (!OTleaf(op))
{
if (!e->E1->Ecount)
continue;
if (OTbinary(op) && !e->E2->Ecount)
continue;
}
ehash->Ecount++;
*pe = ehash;
#ifdef DEBUG
if (debugx)
dbg_printf("**MATCH** %p with %p\n",e,*pe);
#endif
el_free(e);
return;
}
}
}
}
else
vec_setbit(csveci,csvec);
addhcstab(e,hash); // add this elem to hcstab[]
}
List Read_Board_File (char filename[])
{
Kata Kota;
Kota.Length = 4;
Kota.TabKata[0] = 'k';
Kota.TabKata[1] = 'o';
Kota.TabKata[2] = 't';
Kota.TabKata[3] = 'a';
Kata Pariwisata;
Pariwisata.Length = 10;
Pariwisata.TabKata[0] = 'p';
Pariwisata.TabKata[1] = 'a';
Pariwisata.TabKata[2] = 'r';
Pariwisata.TabKata[3] = 'i';
Pariwisata.TabKata[4] = 'w';
Pariwisata.TabKata[5] = 'i';
Pariwisata.TabKata[6] = 's';
Pariwisata.TabKata[7] = 'a';
Pariwisata.TabKata[8] = 't';
Pariwisata.TabKata[9] = 'a';
Kata Start;
Start.Length = 5;
Start.TabKata[0] = 's';
Start.TabKata[1] = 't';
Start.TabKata[2] = 'r';
Start.TabKata[3] = 'a';
Start.TabKata[4] = 't';
Kata Bonus;
Bonus.Length = 5;
Bonus.TabKata[0] = 'b';
Bonus.TabKata[1] = 'o';
Bonus.TabKata[2] = 'n';
Bonus.TabKata[3] = 'u';
Bonus.TabKata[4] = 's';
Kata Chance;
Chance.Length = 6;
Chance.TabKata[0] = 'c';
Chance.TabKata[1] = 'h';
Chance.TabKata[2] = 'a';
Chance.TabKata[3] = 'n';
Chance.TabKata[4] = 'c';
Chance.TabKata[5] = 'e';
Kata Penjara;
Penjara.Length = 7;
Penjara.TabKata[0] = 'p';
Penjara.TabKata[1] = 'e';
Penjara.TabKata[2] = 'n';
Penjara.TabKata[3] = 'j';
Penjara.TabKata[4] = 'a';
Penjara.TabKata[5] = 'r';
Penjara.TabKata[6] = 'a';
Kata Worldcup;
Worldcup.Length = 8;
Worldcup.TabKata[0] = 'w';
Worldcup.TabKata[1] = 'o';
Worldcup.TabKata[2] = 'r';
Worldcup.TabKata[3] = 'l';
Worldcup.TabKata[4] = 'd';
Worldcup.TabKata[5] = 'c';
Worldcup.TabKata[6] = 'u';
Worldcup.TabKata[7] = 'p';
Kata Worldtravel;
Worldtravel.Length = 11;
Worldtravel.TabKata[0]='w';
Worldtravel.TabKata[1]='o';
Worldtravel.TabKata[2]='r';
Worldtravel.TabKata[3]='l';
Worldtravel.TabKata[4]='d';
Worldtravel.TabKata[5]='t';
Worldtravel.TabKata[6]='r';
Worldtravel.TabKata[7]='a';
Worldtravel.TabKata[8]='v';
Worldtravel.TabKata[9]='e';
Worldtravel.TabKata[10]='l';
Kata Tax;
Tax.Length = 3;
Tax.TabKata[0]='t';
Tax.TabKata[1]='a';
Tax.TabKata[2]='x';
int i,j=0,counter1=0;
Infotype X;
List BoardL;
CreateList(&BoardL);
while (!EOP())
{
if (counter1==0)
{
START(filename);
}
for (i=1; i<=3; i++)
{
ADVKATA(filename);
if (i==1)
{
X.ptk.nama = CopyKata(CKata);
}
else
if (i==2)
{
X.ptk.tipe = CopyKata(CKata);
}
else
if (i==3)
{
X.ptk.currentplayer = CopyKata(CKata);
}
}
if (IsKataSama(X.ptk.tipe,Kota))
{
for (i=1; i<=travkota-3; i++)
{
ADVKATA(filename);
if (i==1)
{
X.ptk.kotapariwisata.kepemilikan = CopyKata(CKata);
}
else if (i==2)
{
X.ptk.kotapariwisata.harga.beli = ConvertToBilangan(CKata);
}
else if (i==3)
{
X.ptk.kotapariwisata.harga.sewa = ConvertToBilangan(CKata);
}
else if (i==4)
{
X.ptk.kotapariwisata.harga.belipaksa = ConvertToBilangan(CKata);
}
else if (i==5)
{
X.ptk.kotapariwisata.harga.listoffered = ConvertToBilangan(CKata);
}
else if (i==6)
{
X.ptk.kotapariwisata.lvlbangunan = ConvertToBilangan(CKata);
}
else if (i==7)
{
X.ptk.kotapariwisata.harga.biayaupgrade[i-6] = ConvertToBilangan(CKata);
}
else if (i==8)
{
X.ptk.kotapariwisata.harga.biayaupgrade[i-6] = ConvertToBilangan(CKata);
}
else if (i==9)
{
X.ptk.kotapariwisata.harga.biayaupgrade[i-6] = ConvertToBilangan(CKata);
}
}
}
else if (IsKataSama(X.ptk.tipe,Pariwisata))
{
for (i=1; i<=travpariwisata-3; i++)
{
ADVKATA(filename);
if (i==1)
{
X.ptk.kotapariwisata.kepemilikan = CopyKata(CKata);
}
else if (i==2)
{
X.ptk.kotapariwisata.harga.beli = ConvertToBilangan(CKata);
}
else if (i==3)
{
X.ptk.kotapariwisata.harga.sewa = ConvertToBilangan(CKata);
}
else if (i==4)
{
X.ptk.kotapariwisata.harga.belipaksa = ConvertToBilangan(CKata);
}
else if (i==5)
{
X.ptk.kotapariwisata.harga.listoffered = ConvertToBilangan(CKata);
}
else if (i==6)
{
X.ptk.kotapariwisata.lvlbangunan = ConvertToBilangan(CKata);
}
else if (i==7)
{
X.ptk.kotapariwisata.harga.biayaupgrade[i-6] = ConvertToBilangan(CKata);
}
}
}
else if (IsKataSama(X.ptk.tipe,Start))
{
}
else if (IsKataSama(X.ptk.tipe,Bonus))
{
}
else if (IsKataSama(X.ptk.tipe,Chance))
{
}
else if (IsKataSama(X.ptk.tipe,Penjara))
{
}
else if (IsKataSama(X.ptk.tipe,Worldcup))
{
}
else if (IsKataSama(X.ptk.tipe,Worldtravel))
{
}
else if (IsKataSama(X.ptk.tipe,Tax))
{
}
if (counter1<1)
{
counter1++;
}
ADVKATA(filename);
X.ptk.id = ConvertToBilangan(CKata);
j++;
if (j>0)
{
InsVLast(&BoardL,X);
}
if(!EOP())
{
ADV(filename);
ADV(filename);
}
}
return BoardL;
}
