pl0.txt

ＰＬ／０的Ｃ语言版本

     }
    }while(sym == comma);
    skip(rbrack);
    break;
   }
  }
 }
}

void varpar(int * t)
{
 int j;
 check(ident);
 j = position();
 selector(t, &j);
 if(j != 0)
  addressvar(j);
}

/*标准函数*/
void standfct(int n)
{
 int x, l;
 switch(n)
 {
 case fabs:
  skip(lparen);
  expression(&x);
  mustbe(intip, x);
  gen0(dupl);
  gen1(ldc, 0);
  gen0(lssi);
  l = codelabel();
  gen1(jumpz, 0);
  gen0(neg);
  code[l].a = codelabel();
  skip(rparen);
  break;
 case fsqr:
  skip(lparen);
  expression(&x);
  mustbe(intip, x);
  gen0(dupl);
  gen0(mul);
  skip(rparen);
  break;
 case fodd:
  skip(lparen);
  expression(&x);
  mustbe(intip, x);
  gen0(rem2);
  skip(rparen);
  break;
 case fchr:
  skip(lparen);
  expression(&x);
  mustbe(intip, x);
  skip(rparen);
  break;
 case ford:
  skip(lparen);
  expression(&x);
  mustbe(chartip, x);
  skip(rparen);
  break;
 case fwrite:
 case fwriteln:
  if(n == fwrite)
   check(lparen);
  if(sym == lparen)
  {
   do{
    getsym();
    if(sym == sstring)
    {
     for(x = 0; x < slen; x++)
     {
      gen1(ldc, str[x]);
      gen0(wrc);
     }
     getsym();
    }
    else
    {
     expression(&x);
     if(sym == colon)
     {
      mustbe(intip, x);
      getsym();
      expression(&x);
      mustbe(intip, x);
      gen0(wri);
     }
     else if(x == intip)
     {
      gen1(ldc, 8);
      gen0(wri);
     }
     else if(x == chartip)
     {
      gen0(wrc);
     }
     else
      error(111);
    }
   }while(sym == comma);
   skip(rparen);
  }
  if(n == fwriteln)
   gen0(wrl);
  break;
 case fread:
 case freadln:
  if(n == fread)
   check(lparen);
  if(sym == lparen)
  {
   do{
    getsym();
    varpar(&x);
    if(x == intip)
     gen0(rdi);
    else if(x == chartip)
     gen0(rdc);
    else
     error(112);
   }while(sym == comma);
   skip(rparen);
  }
  if(n == freadln)
   gen0(rdl);
  break;
 case feoln:
  gen0(eol);
  break;
 }
}

/*函数，过程调用*/
void funcall(int i)
{
 int d, p, x;
 getsym();
 if(itab[i].flevel < 0)
  standfct(itab[i].fadr);
 else
 {
  if(itab[i].tip != 0)
   gen1(ldc, 0);
  p = i;
  d = dx;
  if(sym == lparen)
  {
   do{
    getsym();
    if(p == itab[i].lastpar)
     error(113);
    else
    {
     p = p + 1;
     if(itab[p].refpar == TRUE)
      varpar(&x);
     else
     {
      expression(&x);
      if(ttab[x].kind != simple)
       gen1(copy, ttab[x].size);
     }
    }
    mustbe(itab[p].tip, x);
   }while(sym == comma);
   skip(rparen);
  }
  if(p != itab[i].lastpar)
   error(114);
  if(itab[i].flevel != 0)
   address(itab[i].flevel, 0);
  gen1(call, itab[i].fadr);
  dx = d;
 }
}

/*因子*/
void factor(int * t)
{
 int i;
 if(sym == ident)
 {
  i = position();
  *t = itab[i].tip;
  switch(itab[i].kind)
  {
  case konst:
   getsym();
   gen1(ldc, itab[i].val);
   break;
  case varbl:
   selector(t, &i);
   if(i != 0)
    addressvar(i);
   if(ttab[i].kind == simple)
    gen0(load);
   break;
  case funkt:
   if(*t == 0)
    error(115);
   else
    funcall(i);
   break;
  case tipe:
   error(116); /*类型名不能作为因子*/
   break;
  }
 }
 else if(sym == number)
 {
  gen1(ldc, num);
  *t = intip;
  getsym();
 }
 else if(sym == sstring && slen == 2)
 {
  gen1(ldc, str[0]);
  *t = chartip;
  getsym();
 }
 else if(sym == lparen)
 {
  getsym();
  expression(t);
  skip(rparen);
 }
 else if(sym == notsym)
 {
  getsym();
  factor(t);
  mustbe(booltip, *t);
  gen0(neg);
  gen1(addc, 1);
 }
 else
  error(117);
}

/*表达式的项*/
void term(int * x)
{
 int y;
 factor(x);
 while(sym == andsym || sym == star || sym == divsym || sym == modsym)
 {
  if(sym == andsym)
   mustbe(booltip, *x);
  else
   mustbe(intip, *x);
  switch(sym)
  {
  case star:
   getsym();
   factor(&y);
   gen0(mul);
   break;
  case divsym:
   getsym();
   factor(&y);
   gen0(divd);
   break;
  case modsym:
   getsym();
   factor(&y);
   gen0(remd);
   break;
  case andsym:
   getsym();
   factor(&y);
   gen0(andb);
   break;
  }
  mustbe(*x, y);
 }
}

/*简单表达式*/
void simpleexpression(int * x)
{
 int y;
 if(sym == plus)
 {
  getsym();
  term(x);
  mustbe(intip, *x);
 }
 else if(sym == minus)
 {
  getsym();
  term(x);
  mustbe(intip, *x);
  gen0(neg);
 }
 else
  term(x);
 while(sym == orsym || sym == plus || sym == minus)
 {
  if(sym == orsym)
   mustbe(booltip, *x);
  else
   mustbe(intip, *x);
  switch(sym)
  {
  case plus:
   getsym();
   term(&y);
   gen0(add);
   break;
  case minus:
   getsym();
   term(&y);
   gen0(neg);
   gen0(add);
   break;
  case orsym:
   getsym();
   term(&y);
   gen0(orb);
   break;
  }
  mustbe(*x, y);
 }
}

/*表达式*/
void expression(int * x)
{
 symbol op;
 int y;
 simpleexpression(x);
 if(sym == eql ||sym == neq || sym == lss || sym == leq || sym == gtr ||sym == geq)
 {
  if(ttab[*x].kind != simple)
   error(118);
  else
  {
   op = sym;
   getsym();
   simpleexpression(&y);
   mustbe(*x, y);
   switch(op)
   {
   case eql:
    gen0(eqli);
    break;
   case neq:
    gen0(neqi);
    break;
   case lss:
    gen0(lssi);
    break;
   case leq:
    gen0(leqi);
    break;
   case gtr:
    gen0(gtri);
    break;
   case geq:
    gen0(geqi);
    break;
   }
   *x = booltip;
  }
 }
}

/*语句*/
void statement()
{
 int i, j, t, x;
 if(sym == ident)
 {
  i = position();
  switch(itab[i].kind)
  {
  case varbl:
   selector(&t, &i);
   skip(becomes);
   expression(&x);
   mustbe(t, x);
   if(i == 0)
    gen0(swap);
   else
    addressvar(i);
   if(ttab[i].kind == simple)
    gen0(stor);
   else
    gen1(move, ttab[i].size);
   break;
  case funkt:
   if(itab[i].tip == 0)
    funcall(i);
   else
   {
    if(itab[i].inside == FALSE)
     error(119);/*此处不能对函数赋值*/
    else
    {
     getsym();
     skip(becomes);
     expression(&x);
     mustbe(itab[i].tip, x);
     address(itab[i].flevel + 1, itab[i].resultadr);
     gen0(stor);
    }
   }
   break;
  case konst:
  case field:
  case tipe:
   error(120); /*变量不能用在此处*/
   break;
  }
 }
 else if(sym == ifsym)
 {
  getsym();
  expression(&t);
  mustbe(booltip, t);
  skip(thensym);
  i = codelabel();
  gen1(jumpz, 0);
  statement();
  if(sym == elsesym)
  {
   getsym();
   j = codelabel();
   gen1(jump, 0);
   code[i].a = codelabel();
   i = j;
   statement();
  }
  code[i].a = codelabel();
 }
 else if(sym == whilesym)
 {
  getsym();
  i = codelabel();
  expression(&t);
  mustbe(booltip, t);
  skip(dosym);
  j = codelabel();
  gen1(jumpz, 0);
  statement();
  gen1(jump, i);
  /*这里表写错了*/
  code[j].a = codelabel();
 }
 else if(sym == repeatsym)
 {
  i = codelabel();
  do{
   getsym();
   statement();
  }while(sym == semicolon);
  skip(untilsym);
  expression(&t);
  mustbe(booltip, t);
  gen1(jumpz, i);
 }
 else if(sym == beginsym)
 {
  do{
   getsym();
   statement();
  }while(sym == semicolon);
  skip(endsym);
 }
}

void block(int l);

/*常量*/
void constant(int * c, int * t)
{
 int i, s;
 if(sym == sstring && slen == 2)
 {
  *c = str[0];
  *t = chartip;
 }
 else
 {
  if(sym == plus)
  {
   getsym();
   s = +1;
  }
  else if(sym == minus)
  {
   getsym();
   s = -1;
  }
  else
   s = 0;
  if(sym == ident)
  {
   i = position();
   if(itab[i].kind != konst)
    error(121);
   else
   {
    *c = itab[i].val;
    *t = itab[i].tip;
   }
  }
  else if(sym == number)
  {
   *c = num;
   *t = intip;
  }
  else
   error(122);
  if(s != 0)
  {
   mustbe(*t, intip);
   (*c) = (*c) * (s);
  }
 }
 getsym();
}

/*常量声明*/
void constdeclaration()
{
 alfa a;
 int t, c;
 strcpy(a, id);
 getsym();
 skip(eql);
 constant(&c, &t);
 skip(semicolon);
 enter(a, konst, t);
 itab[ix].val = c;
}

void typ(int * t);

/*数组类型*/
void arraytyp(int * t)
{
 int x;
 ttab[*t].kind = arrays;
 getsym();
 constant(&(ttab[*t].low), &x);
 mustbe(intip, x);
 skip(colon);
 constant(&(ttab[*t].high), &x);
 mustbe(intip, x);
 if(ttab[*t].low > ttab[*t].high)
  error(123); /*数组边界问题*/
 if(sym == comma)
  arraytyp(&(ttab[*t].elemtip));
 else
 {
  skip(rbrack);
  skip(ofsym);
  typ(&(ttab[*t].elemtip));
 }
 ttab[*t].size = (ttab[*t].high - ttab[*t].low + 1) * ttab[ttab[*t].elemtip].size;
}

/*类型定义*/
void typ(int * t)
{
 int i, j, sz, ft;
 if(sym == ident)
 {
  i = position();
  if(itab[i].kind != tipe)
   error(124); /*这个标识符不是类型能够*/
  else
  {
   *t = itab[i].tip;
   getsym();
  }
 }
 else
 {
  if(tx == tmax)
  {
   error(125); /*溢出，应退出*/
  }
  else
  {
   tx = tx + 1;
   *t = tx;
  }
  if(sym == arraysym)
  {
   getsym();
   check(lbrack);
   arraytyp(t);
  }
  else
  {
   skip(recordsym);
   if(lev == lmax)
   {
    error(126); /*深度超过限度，应退出*/
   }
   else
   {
    lev = lev + 1;
    if(lev == -1)
     nl = 0;
    else
     namelist[lev] = 0;
    check(ident);
    sz = 0;
    do{
     enter(id, field, 0);
     i = ix;
     getsym();
     while(sym == comma)
     {
      getsym();
      check(ident);
      enter(id, field, 0);
      getsym();
     }
     j = ix;
     skip(colon);
     typ(&ft);
     do{
      itab[i].tip = ft;
      itab[i].offset = sz;
      sz = sz + ttab[ft].size;
      i = i + 1;
     }while(i <= j);
     if(sym == semicolon)
      getsym();
     else
      check(endsym);
    }while(sym == ident);
    ttab[*t].size = sz;
    ttab[*t].kind = records;
    if(lev == -1)
     ttab[*t].fields = nl;
    else
     ttab[*t].fields = namelist[lev];
    lev = lev - 1;
    skip(endsym);
   }
  }
 }
}

/*类型声明，type保留字处*/
void typedeclaration()
{
 alfa a;
 int t;
 strcpy(a, id);
 getsym();
 skip(eql);
 typ(&t);
 skip(semicolon);
 enter(a, tipe, t);
}

/*变量声明*/
void vardeclaration()
{
 int p, q, t;