minic.c

来自「压缩包里面的都是精致的基本C语言小程序」· C语言 代码 · 共 286 行

#include <stdio.h>
#include "../lib/error.h"
#include "../lib/mystdlib.h"
#include "../lib/nat.h"
#include "../lib/poly.h"
#include "../lib/commonInter.h"
#include "miniC.h"

exp miniCNewExpAdd (exp e1, exp e2)
{
  exp e = checkedMalloc (sizeof (*e));
  e->kind = ADD;
  (e->u).binop.e1 = e1;
  (e->u).binop.e2 = e2;
  
  return e;
}

exp miniCNewExpSub (exp e1, exp e2)
{
  exp e = checkedMalloc (sizeof (*e));
  e->kind = SUB;
  (e->u).binop.e1 = e1;
  (e->u).binop.e2 = e2;
  
  return e;
}

exp miniCNewExpTimes (exp e1, exp e2)
{
  exp e = checkedMalloc (sizeof (*e));
  e->kind = TIMES;
  (e->u).binop.e1 = e1;
  (e->u).binop.e2 = e2;
  
  return e;
}

exp miniCNewExpId (str id)
{
  exp e = checkedMalloc (sizeof (*e));
  e->kind = ID;
  (e->u).id = id;
  
  return e;
}

exp miniCNewExpNum (int i)
{
  exp e = checkedMalloc (sizeof (*e));
  e->kind = NUM;
  (e->u).i = i;
  
  return e;
}

stm miniCNewStmAssign (str id, exp e)
{
  stm s = checkedMalloc (sizeof (*s));
  s->kind = ASSIGN;
  (s->u).a.id = id;
  (s->u).a.e = e;
  
  return s;
}

stm miniCNewStmPrint (exp e)
{
  stm s = checkedMalloc (sizeof (*s));
  s->kind = PRINT;
  (s->u).print = e;
  
  return s;
}

prog miniCNewProg (linkedList stms)
{
  prog p = checkedMalloc (sizeof (*p));
  p->stms = stms;
  return p;
}

void miniCPrettyPrintExp (exp e)
{
  switch (e->kind)
  {
    case ADD :
    {
      printf ("(");
      miniCPrettyPrintExp ((e->u).binop.e1);
      printf (" + ");
      miniCPrettyPrintExp ((e->u).binop.e2);
      printf (")");
      break;
    }
    case SUB : 
    {
      printf ("(");
      miniCPrettyPrintExp ((e->u).binop.e1);
      printf (" - ");
      miniCPrettyPrintExp ((e->u).binop.e2);
      printf (")");
      break;
    }
    case TIMES : 
    {
      printf ("(");
      miniCPrettyPrintExp ((e->u).binop.e1);
      printf (" * ");
      miniCPrettyPrintExp ((e->u).binop.e2);
      printf (")");
      break;
    }
    case ID : 
    {
      strOutput ((e->u).id);
      break;
    }
    case NUM : 
    {
      printf ("%d", (e->u).i);
      break;
    }
    default: break;
  }
  
  return;
}

void miniCPrettyPrintStm (stm s)
{
  switch (s->kind)
  {
    case ASSIGN:
      {
        strOutput((s->u).a.id);
        printf (" = ");
        miniCPrettyPrintExp ((s->u).a.e);
        printf (";\n");
        break;
      }
    case PRINT:
      {
        printf ("print (");
        miniCPrettyPrintExp ((s->u).print);
        printf (");\n");
        break;
      }
    default:
      {
        error ("no this case\n");
        break;
      }
  }
}

typedef void (*f) (poly);

void miniCPrettyPrintProg (prog p)
{
  linkedList l = p->stms;
  linkedListForeach (l, (f)miniCPrettyPrintStm);
  return;
}

str miniCToStringExp (exp e)
{
  switch (e->kind)
  {
    case ADD :
    {
      str r = newStr ("(");
      r = strConcat (r, miniCToStringExp ((e->u).binop.e1));
      r = strConcat (r, newStr (" + "));
      r = strConcat (r, miniCToStringExp ((e->u).binop.e2));
      r = strConcat (r, newStr (")"));
      return r;
    }
    case SUB : 
    {
      str r = newStr ("(");
      r = strConcat (r, miniCToStringExp ((e->u).binop.e1));
      r = strConcat (r, newStr (" - "));
      r = strConcat (r, miniCToStringExp ((e->u).binop.e2));
      r = strConcat (r, newStr (")"));
      return r;
    }
    case TIMES : 
    {
      str r = newStr ("(");
      r = strConcat (r, miniCToStringExp ((e->u).binop.e1));
      r = strConcat (r, newStr (" * "));
      r = strConcat (r, miniCToStringExp ((e->u).binop.e2));
      r = strConcat (r, newStr (")"));
      return r;
    }
    case ID : 
    {
      return ((e->u).id);
    }
    case NUM : 
    {
      nat n = newNat ((e->u).i);
      return ((commonInter)n)->vft->toString (n);
    }
    default: return newStr ("");
  }
}

str miniCToStringStm (stm s)
{
  switch (s->kind)
  {
    case ASSIGN:
      {
        str r = (s->u).a.id;
        r = strConcat (r, newStr (" = "));
        r = strConcat (r, miniCToStringExp ((s->u).a.e));
        r = strConcat (r, newStr (";\n"));
        return r;
      }
    case PRINT:
      {
        str r = newStr ("print (");
        r = strConcat (r, miniCToStringExp ((s->u).print));
        r = strConcat (r, newStr (");\n"));
        return r;
      }
    default:
      {
        error ("no this case\n");
        return newStr ("");
      }
  }
}

str miniCToString (prog p)
{
  linkedList l = p->stms->next;
  
  str s = newStr ("");
  while (l)
  {
    s = strConcat (s, miniCToStringStm (l->data));
    l = l->next;
  }
  return s;
}

set miniCSetOfNum (exp e)
{  
  switch (e->kind)
  {
    case ADD :
    {
      set s1 = miniCSetOfNum ((e->u).binop.e1);
      set s2 = miniCSetOfNum ((e->u).binop.e2);
      set s = setUnion2 (s1, s2);
      return s;
    }
    case SUB : 
    {
      return setUnion2 (miniCSetOfNum ((e->u).binop.e1),
                       miniCSetOfNum ((e->u).binop.e2));
    }
    case TIMES : 
    {
      return setUnion2 (miniCSetOfNum ((e->u).binop.e1),
                       miniCSetOfNum ((e->u).binop.e2));
    }
    case ID : 
    {
      return newSet ();
    }
    case NUM : 
    {
      set s = newSet ();
      setInsert2 (s, newNat ((e->u).i));
      return (s);
    }
    default: return newSet ();
  }
}