123.txt

技术型论文

  end
  else
  error(4) (* 如果常量声明过程遇到的第一个符号不为标识符，抛出4号错误 *)
end(* constdeclaration *);
(* 变量声明过程vardeclaration *) 
procedure vardeclaration;
begin
  if sym = ident then (* 变量声明过程开始遇到的第一个符号必然应为标识符 *)
  begin
  enter(variable); (* 将标识符登陆到符号表中 *)
  getsym (* 获取下一个token，为后面作准备 *)
  end
  else
  error(4) (* 如果变量声明过程遇到的第一个符号不是标识符，抛出4号错误 *)
end(* vardeclaration *);
(* 列出当前一层类PCODE目标代码过程listcode *) 
procedure listcode;
var 
  i: integer;
begin (* list code generated for this block *)
  if listswitch then (* 如果用户选择是要列出代码的情况下才列出代码 *)
  begin
  for i := cx0 to cx - 1 do (* 从当前层代码开始位置到当前代码位置-1处，即为本分程序块 *)
    with code do
    begin
      writeln(i: 4, mnemonic[f]: 5, l: 3, a: 5); (* 显示出第i行代码的助记符和L与A操作数 *)
      (* 我修改的代码：原程序此处在输出i时，没有指定占4个字符宽度，不美观也与下面一句不配套。 *)
      writeln(fa, i: 4, mnemonic[f]: 5, l: 3, a: 5) (* 同时把屏显打印到文件 *)
    end;
  end
end(* listcode *);
(* 语句处理过程statement *)
(* 参数说明：fsys: 如果出错可用来恢复语法分析的符号集合 *)
procedure statement(fsys: symset);
var 
  i, cx1, cx2: integer;
  (* 表达式处理过程expression *)
  (* 参数说明：fsys: 如果出错可用来恢复语法分析的符号集合 *)
  procedure expression(fsys: symset);
  var 
  addop: symbol;
  (* 项处理过程term *)
  (* 参数说明：fsys: 如果出错可用来恢复语法分析的符号集合 *)
  procedure term(fsys: symset);
  var 
    mulop: symbol;
    (* 因子处理过程factor *)
    (* 参数说明：fsys: 如果出错可用来恢复语法分析的符号集合 *)
    procedure factor(fsys: symset);
    var 
      i: integer;
    begin
      test(facbegsys, fsys, 24); (* 开始因子处理前，先检查当前token是否在facbegsys集合中。 *)
                        (* 如果不是合法的token，抛24号错误，并通过fsys集恢复使语法处理可以继续进行 *)       
      while sym in facbegsys do (* 循环处理因子 *)
      begin
      if sym = ident then (* 如果遇到的是标识符 *)
      begin
        i := position(id); (* 查符号表，找到当前标识符在符号表中的位置 *)
        if i = 0 then (* 如果查符号表返回为0，表示没有找到标识符 *)
          error(11) (* 抛出11号错误 *)
        else
          with table do (* 如果在符号表中找到了当前标识符的位置，开始生成相应代码 *)
          case kind of
            constant: gen(lit, 0, val); (* 如果这个标识符对应的是常量，值为val，生成lit指令，把val放到栈顶 *)
            variable: gen(lod, lev - level, adr); (* 如果标识符是变量名，生成lod指令， *)
                                      (* 把位于距离当前层level的层的偏移地址为adr的变量放到栈顶 *)
            procedur: error(21) (* 如果在因子处理中遇到的标识符是过程名，出错了，抛21号错 *)
          end;
        getsym (* 获取下一token，继续循环处理 *)
      end
      else
        if sym = number then (* 如果因子处理时遇到数字 *)
        begin
          if num > amax then (* 如果数字的大小超过允许最大值amax *)
          begin
          error(31); (* 抛出31号错 *)
          num := 0 (* 把数字按0值处理 *)
          end;
          gen(lit, 0, num); (* 生成lit指令，把这个数值字面常量放到栈顶 *)
          getsym (* 获取下一token *)
        end
        else
          if sym = lparen then (* 如果遇到的是左括号 *)
          begin
          getsym; (* 获取一个token *)
          expression( [rparen] + fsys ); (* 递归调用expression子程序分析一个子表达式 *)
          if sym = rparen then (* 子表达式分析完后，应遇到右括号 *)
            getsym (* 如果的确遇到右括号，读取下一个token *)
          else
            error(22) (* 否则抛出22号错误 *)
          end;
      test(fsys, facbegsys, 23) (* 一个因子处理完毕，遇到的token应在fsys集合中 *)
                        (* 如果不是，抛23号错，并找到下一个因子的开始，使语法分析可以继续运行下去 *)
      end
    end(* factor *);
  begin (* term *)
    factor([times, slash] + fsys); (* 每一个项都应该由因子开始，因此调用factor子程序分析因子 *)
    while sym in [times, slash] do (* 一个因子后应当遇到乘号或除号 *)
    begin
      mulop := sym; (* 保存当前运算符 *)
      getsym; (* 获取下一个token *)
      factor(fsys + [times, slash]); (* 运算符后应是一个因子，故调factor子程序分析因子 *)
      if mulop = times then (* 如果刚才遇到乘号 *)
      gen(opr, 0, 4) (* 生成乘法指令 *)
      else
      gen(opr, 0, 5) (* 不是乘号一定是除号，生成除法指令 *)
    end
  end (* term *);
  begin (* expression *)
  if sym in [plus, minus] then (* 一个表达式可能会由加号或减号开始，表示正负号 *)
  begin
    addop := sym; (* 把当前的正号或负号保存起来，以便下面生成相应代码 *)
    getsym; (* 获取一个token *)
    term(fsys + [plus, minus]); (* 正负号后面应该是一个项，调term子程序分析 *)
    if addop = minus then (* 如果保存下来的符号是负号 *)
      gen(opr, 0, 1) (* 生成一条1号操作指令：取反运算 *)
    (* 如果不是负号就是正号，不需生成相应的指令 *)
  end
  else (* 如果不是由正负号开头，就应是一个项开头 *)
    term(fsys + [plus, minus]); (* 调用term子程序分析项 *) 
  while sym in [plus, minus] do (* 项后应是加运算或减运算 *)
  begin
    addop := sym; (* 把运算符保存下来 *)
    getsym; (* 获取下一个token，加减运算符后应跟的是一个项 *)
    term(fsys + [plus, minus]); (* 调term子程序分析项 *)
    if addop = plus then (* 如果项与项之间的运算符是加号 *)
      gen(opr, 0, 2) (* 生成2号操作指令：加法 *)
    else (* 否则是减法 *)
      gen(opr, 0, 3) (* 生成3号操作指令：减法 *)
  end
  end (* expression *);
  (* 条件处理过程condition *)
  (* 参数说明：fsys: 如果出错可用来恢复语法分析的符号集合 *)
  procedure condition(fsys: symset);
  var 
  relop: symbol; (* 用于临时记录token(这里一定是一个二元逻辑运算符)的内容 *)
  begin
  if sym = oddsym then (* 如果是odd运算符(一元) *)
  begin
    getsym; (* 获取下一个token *)
    expression(fsys); (* 对odd的表达式进行处理计算 *)
    gen(opr, 0, 6); (* 生成6号操作指令：奇偶判断运算 *)
  end
  else (* 如果不是odd运算符(那就一定是二元逻辑运算符) *)
  begin
    expression([eql, neq, lss, leq, gtr, geq] + fsys); (* 对表达式左部进行处理计算 *)
    if not (sym in [eql, neq, lss, leq, gtr, geq]) then (* 如果token不是逻辑运算符中的一个 *)
      error(20) (* 抛出20号错误 *)
    else
    begin
      relop := sym; (* 记录下当前的逻辑运算符 *)
      getsym; (* 获取下一个token *)
      expression(fsys); (* 对表达式右部进行处理计算 *)
      case relop of (* 如果刚才的运算符是下面的一种 *)
      eql: gen(opr, 0, 8); (* 等号：产生8号判等指令 *)
      neq: gen(opr, 0, 9); (* 不等号：产生9号判不等指令 *)
      lss: gen(opr, 0, 10); (* 小于号：产生10号判小指令 *)
      geq: gen(opr, 0, 11); (* 大于等号号：产生11号判不小于指令 *)
      gtr: gen(opr, 0, 12); (* 大于号：产生12号判大于指令 *)
      leq: gen(opr, 0, 13); (* 小于等于号：产生13号判不大于指令 *)
      end
    end
  end
  end (* condition *);
begin (* statement *)
  if sym = ident then (* 所谓"语句"可能是赋值语句，以标识符开头 *)
  begin
  i := position(id); (* 在符号表中查到该标识符所在位置 *)
  if i = 0 then (* 如果没找到 *)
    error(11) (* 抛出11号错误 *)
  else
    if table.kind <> variable then (* 如果在符号表中找到该标识符，但该标识符不是变量名 *) 
    begin
      error(12); (* 抛出12号错误 *)
      i := 0 (* i置0作为错误标志 *)
    end;
  getsym; (* 获得下一个token，正常应为赋值号 *)
  if sym = becomes then (* 如果的确为赋值号 *)
    getsym (* 获取下一个token，正常应为一个表达式 *)
  else
    error(13); (* 如果赋值语句的左部标识符号后所接不是赋值号，抛出13号错误 *)
  expression(fsys); (* 处理表达式 *)
  if i <> 0 then (* 如果不曾出错，i将不为0，i所指为当前语名左部标识符在符号表中的位置 *)
    with table do
      gen(sto, lev - level, adr) (* 产生一行把表达式值写往指定内存的sto目标代码 *)
  end
  else
  if sym = readsym then (* 如果不是赋值语句，而是遇到了read语句 *)
  begin
    getsym; (* 获得下一token，正常情况下应为左括号 *)
    if sym <> lparen then (* 如果read语句后跟的不是左括号 *)
      error(34) (* 抛出34号错误 *)
    else
      repeat (* 循环得到read语句括号中的参数表，依次产生相应的“从键盘读入”目标代码 *)
      getsym; (* 获得一个token，正常应是一个变量名 *)
      if sym = ident then (* 如果确为一个标识符 *) 
      (* 这里略有问题，还应判断一下这个标识符是不是变量名，如果是常量名或过程名应出错 *)
        i := position(id) (* 查符号表，找到它所在位置给i，找不到时i会为0 *)
      else
        i := 0; (* 不是标识符则有问题，i置0作为出错标志 *)
      if i = 0 then (* 如果有错误 *)
        error(35) (* 抛出35号错误 *)
      else (* 否则生成相应的目标代码 *)
        with table do
        begin
          gen(opr, 0, 16); (* 生成16号操作指令:从键盘读入数字 *)
          gen(sto, lev - level, adr) (* 生成sto指令，把读入的值存入指定变量所在的空间 *)
        end;
      getsym (* 获取下一个token，如果是逗号，则read语还没完，否则应当是右括号 *)
      until sym <> comma; (* 不断生成代码直到read语句的参数表中的变量遍历完为止，这里遇到不是逗号，应为右括号 *)
    if sym <> rparen then (* 如果不是我们预想中的右括号 *)
    begin