gbc_trans_subr.c

Gambas is a graphical development environment based on a Basic interpreter, like Visual Basic. It us

/***************************************************************************

  trans_subr.c

  Subroutine synonymous compiler

  (c) 2000-2004 Beno顃 Minisini <[e-mail]>

  This program 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 1, or (at your option)
  any later version.

  This program 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., 675 Mass Ave, Cambridge, MA 02139, USA.

***************************************************************************/

#define _TRANS_SUBR_C

#include <stdlib.h>
#include <string.h>
#include <stdio.h>

#include "gb_common.h"
#include "gb_error.h"
#include "gbc_compile.h"
#include "gbc_trans.h"
#include "gb_code.h"
#include "gb_limit.h"

/*#define DEBUG*/


typedef
  struct {
    char *name;
    SUBR_INFO *info;
    }
  TRANS_SUBR_INFO;


PRIVATE void trans_subr(int subr, int nparam)
{
  static TRANS_SUBR_INFO subr_info[] =
  {
    { "Print" }, { "Input" }, { "Write" }, { "Read" },  { "Open" },
    { "Close" }, { "Seek" }, { "Type" }, { "LineInput" }, { "Flush" },
    { "Exec" }, { "Shell" }, { "Wait" }, { "Kill" }, { "Rename" },
    { "Mkdir" }, { "Rmdir" }, { "Array" }, { "Use" }, { "Copy" },
    { "Link" }, { "Error" }, { "Lock" }, { "Unlock" }
  };

  TRANS_SUBR_INFO *tsi = &subr_info[subr];

  if (tsi->info == NULL)
    tsi->info = SUBR_get(tsi->name);

  CODE_subr(tsi->info->opcode, nparam, tsi->info->optype, FALSE, tsi->info->min_param == tsi->info->max_param);
}


PRIVATE boolean trans_stream(int default_stream)
{
  if (TRANS_is(RS_SHARP))
  {
    TRANS_expression(FALSE);

    if (PATTERN_is(*JOB->current, RS_COMMA))
    {
      JOB->current++;
      if (PATTERN_is_newline(*JOB->current))
        THROW(E_SYNTAX);
    }

    return FALSE;
  }
  else
  {
    CODE_push_number(default_stream);
    return TRUE;
  }
}


PUBLIC void TRANS_print(void)
{
  int nparam = 1;
  boolean semicolon = FALSE;

  trans_stream(TS_STDOUT);

  for(;;)
  {
    if (PATTERN_is_newline(*JOB->current))
      break;

    TRANS_expression(FALSE);
    nparam++;
    semicolon = FALSE;

    if (PATTERN_is_newline(*JOB->current))
      break;

    if (TRANS_is(RS_SCOLON))
    {
      if (TRANS_is(RS_SCOLON))
      {
        CODE_push_char(' ');
        nparam++;
      }
      semicolon = TRUE;
    }
    else if (TRANS_is(RS_COMMA))
    {
      CODE_push_char('\t');
      nparam++;
      semicolon = FALSE;
    }
    else
      THROW(E_SYNTAX);
  }

  if (!semicolon)
  {
    CODE_push_char('\n');
    nparam++;
  }

  trans_subr(TS_SUBR_PRINT, nparam);
  CODE_drop();
}


PUBLIC void TRANS_write(void)
{
  int nparam = 1;

  trans_stream(TS_STDOUT);

  TRANS_expression(FALSE);
  nparam++;

  if (TRANS_is(RS_COMMA))
  {
    TRANS_expression(FALSE);
    nparam++;
  }

  trans_subr(TS_SUBR_WRITE, nparam);
  CODE_drop();
}


PUBLIC void TRANS_input(void)
{
  boolean stream = TRUE;

  trans_stream(TS_STDIN);

  for(;;)
  {
    trans_subr(TS_SUBR_INPUT, (stream ? 1 : 0));
    stream = FALSE;

    TRANS_reference();

    if (PATTERN_is_newline(*JOB->current))
      break;

    if (!PATTERN_is(*JOB->current, RS_COMMA)
        && !PATTERN_is(*JOB->current, RS_SCOLON))
      THROW(E_SYNTAX);

    JOB->current++;
  }
}


PUBLIC void TRANS_read(void)
{
  int nparam = 2;
  PATTERN *save_return;
  PATTERN *save_current;

  trans_stream(TS_STDIN);

  save_return = JOB->current;

  TRANS_expression(FALSE);
  /*trans_calc_type();*/

  if (TRANS_is(RS_COMMA))
  {
    TRANS_expression(FALSE);
    nparam++;
  }

  trans_subr(TS_SUBR_READ, nparam);

  save_current = JOB->current;
  JOB->current = save_return;
  TRANS_reference();

  JOB->current = save_current;
}


PUBLIC void TRANS_open(void)
{
  int mode = TS_MODE_READ;

  /* Nom du fichier */

  TRANS_expression(FALSE);

  /* mode d'ouverture */

  if (TRANS_is(RS_FOR))
  {
    if (TRANS_is(RS_READ))
      mode |= TS_MODE_READ;

    if (TRANS_is(RS_WRITE))
      mode |= TS_MODE_WRITE;

    if (TRANS_is(RS_CREATE))
      mode |= TS_MODE_CREATE;
    else if (TRANS_is(RS_APPEND))
      mode |= TS_MODE_APPEND;

    if (TRANS_is(RS_DIRECT))
      mode |= TS_MODE_DIRECT;

    if (TRANS_is(RS_WATCH))
      mode |= TS_MODE_WATCH;

    if (TRANS_is(RS_BIG))
      mode |= TS_MODE_BIG;
    else if (TRANS_is(RS_LITTLE))
      mode |= TS_MODE_LITTLE;

    /*JOB->current--;
    if (PATTERN_is(*JOB->current, RS_FOR))
      THROW("Syntax error in file open mode");
    JOB->current++;*/
  }

  CODE_push_number(mode);

  trans_subr(TS_SUBR_OPEN, 2);

  /* handle du fichier */

  TRANS_want(RS_AS, NULL);
  TRANS_ignore(RS_SHARP);

  TRANS_reference();

}


PUBLIC void TRANS_close(void)
{
  if (PATTERN_is_newline(*JOB->current))
    THROW(E_SYNTAX);

  TRANS_ignore(RS_SHARP);
  TRANS_expression(FALSE);

  trans_subr(TS_SUBR_CLOSE, 1);
  CODE_drop();
}


static void trans_lock_unlock(bool unlock)
{
  if (PATTERN_is_newline(*JOB->current))
    THROW(E_SYNTAX);

  TRANS_ignore(RS_SHARP);
  TRANS_expression(FALSE);

  trans_subr(unlock ? TS_SUBR_UNLOCK : TS_SUBR_LOCK, 1);
  CODE_drop();
}


PUBLIC void TRANS_lock(void)
{
  trans_lock_unlock(FALSE);
}


PUBLIC void TRANS_unlock(void)
{
  trans_lock_unlock(TRUE);
}


PUBLIC void TRANS_seek(void)
{
  int nparam;

  if (trans_stream(TS_STDIN))
    THROW("Syntax error. '#' expected");

  TRANS_expression(FALSE);
  nparam = 2;

  /*
  if (TRANS_is(RS_COMMA))
  {
    TRANS_expression(FALSE);
    nparam++;
  }
  */

  trans_subr(TS_SUBR_SEEK, nparam);
  CODE_drop();
}


PUBLIC void TRANS_line_input(void)
{
  trans_stream(TS_STDIN);
  trans_subr(TS_SUBR_LINE_INPUT, 1);
  TRANS_reference();
}


PUBLIC void TRANS_flush(void)
{
  trans_stream(TS_STDOUT);
  trans_subr(TS_SUBR_FLUSH, 1);
  CODE_drop();
}


PUBLIC void TRANS_stop(void)
{
  if (TRANS_is(RS_EVENT))
    CODE_stop_event();
  else
    CODE_stop();
}


PUBLIC void TRANS_quit(void)
{
	CODE_quit();
}


PRIVATE void trans_exec_shell(bool shell)
{
  int mode = 0;
  bool wait = FALSE;

  /* programme