#!/usr/bin/env python
##
## This file is part of Mipsy, a tiny MIPS simulator
## Copyright (C) 2003 Benoit Perrot <benoit@lrde.epita.fr>
##
## Mipsy is free software; you can redistribute it and/or modify
## it under the terms of the GNU General Public License as published by
## the Free Software Foundation; either version 2 of the License, or
## (at your option) any later version.
## 
## Mipsy is distributed in the hope that it will be useful,
## but WITHOUT ANY WARRANTY; without even the implied warranty of
## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
## GNU General Public License for more details.
## 
## You should have received a copy of the GNU General Public License
## along with this program; if not, write to the Free Software
## Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
##

import sys
import string, re

import mipsy
from mipsy import license, depth, define_id

#### Mipsy's Bison assembly parser generator ---------------
parser = mipsy.InstructionSetParser()
instructions = parser.parse(sys.stdin)

## Prologue --------------------------
print "%{							// -*- C++ -*-"
print license
print """
#include <string>

#include \"common.hh\"

#include \"inst/label.hh\"
#include \"inst/program_builder.hh\"
#include \"inst/exp.hh\"
#include \"inst/register.hh\"
#include \"inst/all.hh\"

#include \"vm/cpu.hh\"

#include \"parse/libparse.hh\"

namespace yy
{
  extern inst::ProgramBuilder program_builder;
}

using namespace inst;
using vm::Cpu;
%}

%error-verbose
%locations
%debug

%union
{
  int			i;
  std::string		*s;
  inst::Label           *label;
  inst::Register        *reg;
  inst::Exp             *exp;
}
%{
#include \"parse/asm-scan.hh\"
%}

%token <label> LABEL		\"label\"
%token <label> LABEL_DEF	\"label definition\"
%token <i> INTEGER              \"integer\"
%token <s> STRING               \"string\"
%token <reg> REGISTER           \"register\"
%type <exp> exp

%token YYEOF		0 \"end of file\"
%token LPAREN		\"(\"
%token RPAREN		\")\"
%token COMMA		\",\"

%left EXP_ADD EXP_SUB
%left EXP_MUL EXP_DIV
%nonassoc EXP_UMINUS

%token DIR_TEXT         \".text\"
%token DIR_DATA         \".data\"
%token DIR_SPACE        \".space\"
%token DIR_WORD         \".word\"
%token DIR_ASCIIZ       \".asciiz\"
"""
  
for i in instructions:
  print "%token " + define_id(i.opcode) + '\t\t"' + i.opcode + '"'
  
print """
  
%start program
%%
// 
program
:
| program DIR_TEXT instructions
| program DIR_DATA datas


// Data definitions
datas
:
| datas data

data
// Label
:  LABEL_DEF
{ program_builder.add_data_label(* $1); }
// Reserve space
| DIR_SPACE INTEGER
{ program_builder.add_space ($2); }
// Values
| DIR_WORD INTEGER
{ program_builder.add_word ($2); }
| DIR_WORD LABEL
{ program_builder.add_word (*$2); }
| DIR_ASCIIZ STRING
{ program_builder.add_asciiz (* $2); }

// Instruction definitions
instructions
:
| instructions instruction

instruction
// Label
: LABEL_DEF
{ program_builder.add_inst_label(* $1); }

// Opcodes"""

## Body ------------------------------
tokid_map = {
  "register" : "REGISTER",
  "immediate": "exp",
  "label"    : "exp",
  "address"  : "REGISTER",
  "hidden"   : ""
  }


for inst in instructions:
  for syntax in inst.syntaxes:

    ## Compute productions
    # A token is a tuple (token id, token name, token value)
    prods = [[(define_id(inst.opcode), "", "")]]
    for i, token in enumerate(syntax.tokens):
      if token.kind == "address":
        prods.append([("LPAREN", "", "")])
      if token.default != "":
        prods.append([(tokid_map[token.kind], token.name, token.value),
                      ("", token.name, token.default)])
      else:
        prods.append([(tokid_map[token.kind], token.name, token.value)])
      if token.kind == "address":
        prods.append([("RPAREN", "", "")])
    prods = depth(prods)

    ## Display rules and actions
    for prod in prods:

      # Add COMMAs
      tokidx = {}
      lparen_p = False
      i = 0
      while True:
        token = prod[i]
        if token[0] != "":
          if i > 1:
            if token[0] == "LPAREN":
              lparen_p = (prod[i - 1][0] != "")
            if not lparen_p:
              prod.insert(i, ("COMMA", "", ""))
              i = i + 1
          if token[0] == "LPAREN":
            lparen_p = True
          elif token[0] == "RPAREN":
            lparen_p = False
        i = i + 1
        if i >= len(prod):
          break
      
      # Compute token indices
      tokidx = {}
      i = 0
      for token in prod:
        if token[0] != "":
          i = i + 1
        if token[1] != "":
          assert(not tokidx.has_key(token[1]))
          tokidx[token[1]] = i
          
      # Build rule and action
      rule = "|"
      action = "program_builder.add_"
      if syntax.alias != "":
        action = action + syntax.alias + "("
      else:
        action = action + inst.opcode + "("
      i = 0
      for token in prod:
        if token[0] != "":
          i = i + 1
          rule = rule + " " + token[0]
        value = "*$" + str(i)
        if token[2] != "":
          value = re.sub(r"\$\{([^}]*)\}", 
                         (lambda m: "*$" + str(tokidx[m.groups(0)[0]])),
                         token[2])
        if token[0] in tokid_map.values():
          action = action + value + ", "
      action = string.rstrip(action, ", ") + ")"

      # Dump rule and associated action
      print rule
      print "{ " + action + "; }"


## Epilogue --------------------------
print """
exp:
  exp EXP_ADD  exp { $$ = new OpExp(*$1, OpExp::add, *$3); }
| exp EXP_SUB  exp { $$ = new OpExp(*$1, OpExp::sub, *$3); }
| exp EXP_MUL  exp { $$ = new OpExp(*$1, OpExp::mul, *$3); }
| exp EXP_DIV  exp { $$ = new OpExp(*$1, OpExp::div, *$3); }
| EXP_SUB exp %prec EXP_UMINUS
        { $$ = new OpExp(*new IntExp(0), OpExp::sub, *$2); }
| LPAREN exp RPAREN { $$ = $2; }
| INTEGER { $$ = new IntExp($1); }
| LABEL { $$ = new LabelExp(*$1); }

%%
void
yy::Parser::error_ ()
{
  std::cerr << location << \": \" << message << std::endl;
  exit_set (exit_parse);
}

void
yy::Parser::print_ ()
{
  std::cerr << ' ' << location;
  switch (looka_)
    {
    case STRING:
      std::cerr << \": \" << *value.s;
      break;
    case INTEGER:
      std::cerr << \": \" << value.i;
      break;
    case REGISTER:
      std::cerr << \": \" << *value.reg;
      break;
    }
}

namespace yy
{
  inst::ProgramBuilder program_builder;
}
"""