/*
*
* archive.cpp
*
* Copyright (c) 2001, 2002
* Andrew Fedoniouk - andrew@terra-informatica.org
* Portions: Serge Kuznetsov -  kuznetsov@deeptown.org
*
* See the file "COPYING" for information on usage 
* and redistribution of this file
*
*/
#include "c-smile.h"
#include "vm.h"
#include "streams.h"
#include "osfile.h"

namespace c_smile
{
  symbol_t
    archive::map ( symbol_t extern_sym )
  {
    if ( extern_sym == undefined_symbol )
      return undefined_symbol;
    for ( int i = 0; i < _symbols.size(); ++i )
      if ( _symbols [ i ] == extern_sym )
        return symbol_t ( i );

    _symbols.push ( extern_sym );
    return symbol_t ( _symbols.size () - 1 );
  }

  void
    archive::write ( const char *buf, size_t sz )
  {
    int s ( sz );
    if ( !_body->write ( buf, s ) || (size_t) s != sz )
      VM::error ( (char *) (const char *) _body->err_message );
  }

  void
    archive::read ( char *buf, size_t sz )
  {
    int s ( sz );
    if ( !_body->read ( buf, s ) || (size_t) s != sz )
      VM::error ( (char *) (const char *) _body->err_message );
  }

  void
    archive::write_class_ref ( const CLASS *cls )
  {
    symbol_t package_name = ( ( cls->package ) ?
                                cls->package->name : undefined_symbol );
    symbol_t class_name = cls->name;
    write ( package_name );
    write ( class_name );
  }

  void
    archive::read_class_ref ( CLASS * &cls )
  {
    symbol_t package_name, class_name;
    read ( package_name );
    read ( class_name );
    if ( package_name == undefined_symbol )
    {
      // package
      cls = VM::find_package ( class_name );
    }
    else
    {
      cls = VM::find_class ( package_name, class_name );
    }
  }

  //|
  //| bool
  //|
  void
    archive::read ( bool & v )
  {
    read ( (char *) &v, sizeof ( v ) );
  }

  void
    archive::write ( bool v )
  {
    write ( (char *) &v, sizeof ( v ) );
  }

  //|
  //| int
  //|
  void
    archive::read ( int & v )
  {
    read ( (char *) &v, sizeof ( v ) );
  }

  void
    archive::write ( int v )
  {
    write ( (char *) &v, sizeof ( v ) );
  }

  //|
  //| double
  //|
  void
    archive::read ( double & v )
  {
    read ( (char *) &v, sizeof ( v ) );
  }

  void
    archive::write ( double v )
  {
    write ( (char *) &v, sizeof ( v ) );
  }

  //|
  //| string
  //|
  void
    archive::read ( string & s )
  {
    int l;
    read ( l );
    assert ( l < 1024 );
    string ss ( ' ', l );
    read ( ss.buffer(), l );
    s = ss;
  }

  void
    archive::write ( const char *s )
  {
    int l = strlen ( s );
    write ( l );
    write ( s, l );
  }

  //|
  //| DICTIONARY
  //|
  void
    archive::read ( DICTIONARY* &dict )
  {
    int sz = 0;
    read ( sz );
    if ( sz == -1 )
      dict = 0;
    else
    {
      dict = DICTIONARY::create ( sz );
      for ( int i = 0; i < sz; i++ )
      {
        DICTIONARY::item& it = ( *dict ) [ i ];
        read ( it.symbol );
        read ( it.type   );
        read ( it.value  );
      }
    }
  }

  void
    archive::write ( const DICTIONARY * dict )
  {
    if ( dict == 0 )
      write ( -1 );
    else
    {
      write ( dict->size () );
      for ( int i = 0; i < dict->size(); i++ )
      {
        const DICTIONARY::item& it = ( *dict ) [ i ];
        write ( it.symbol );
        write ( it.type   );
        write ( it.value  );
      }
    }
  }

  //|
  //| STRING
  //|
  void
    archive::write ( const STRING * str )
  {
    if ( str == 0 )
      write ( -1 );
    else
    {
      int sz = (int) str->size();
      write ( sz );
      if ( sz )
        write ( CSTR ( str ), (int) str->size() );
    }
  }

  void
    archive::read ( STRING* &str )
  {
    int l = 0;
    read ( l );
    if ( l == -1 )
      str = 0;
    else
    {
      string s ( ' ', l );
      read ( s.buffer(), l );
      str = new STRING ( s );
    }
  }

  //|
  //| ARRAY
  //|
  void
    archive::write ( const ARRAY * vec )
  {
    if ( vec == 0 )
      write ( -1 );
    else
    {
      write ( vec->size() );
      for ( int i = 0; i < vec->size(); ++i )
        write ( ( *vec ) [ i ] );
    }
  }

  void
    archive::read ( ARRAY* &vec )
  {
    int l;
    read ( l );
    if ( l < 0 )
      vec = 0;
    else
    {
      vec = new ARRAY ( l );
      for ( int i = 0; i < l; ++i )
        read ( ( *vec ) [ i ] );
    }
  }

  //|
  //| CLASS
  //|
#define PACKAGE_EXISTS 0x01
#define BASE_EXISTS 0x02

  void
    archive::read_class ( CLASS *cls )
  {
    int i_sz = 0;
    read ( i_sz );

    cls->instance_size = i_sz;

    int flags = 0;
    read ( flags );
    if ( flags & PACKAGE_EXISTS )
    {
      symbol_t sym = undefined_symbol;
      read ( sym );
      cls->package = VM::find_package ( sym );
    }
    if ( flags & BASE_EXISTS )
    {
      read_class_ref ( cls->base );
    }
    read ( cls->members );
    for ( int i = 0; i < cls->members->size(); i++ )
    {
      DICTIONARY::item& it = ( *cls->members ) [ i ];
      if ( it.value.is_bytecode() )
      {
        CODE *pbc = it.value.v.v_code;
        pbc->_klass = cls;
        pbc->_name = it.symbol;

        cls->check_name ( pbc->_name, pbc, it.type );
      }
    }
  }

  void
    archive::write_class ( const CLASS *cls )
  {
    write ( (int) cls->instance_size );

    int flags = 0;
    if ( cls->package )
      flags |= PACKAGE_EXISTS;
    if ( cls->base )
      flags |= BASE_EXISTS;

    write ( flags );

    if ( cls->package )
      write ( cls->package->name );
    if ( cls->base )
      write_class_ref ( cls->base );

    write ( cls->members );
  }

  void
    archive::write ( const CLASS * cls )
  {
    write ( cls->name );
    write_class ( cls );
  }

  void
    archive::read ( CLASS* &cls )
  {
    symbol_t t;
    read ( t );
    cls = new CLASS ();
    cls->name = t;
    read_class ( cls );
  }

  //|
  //| PACKAGE
  //|
  void
    archive::write ( const PACKAGE * pkg )
  {
    write ( pkg->name );
    write_class ( (CLASS *) pkg );

    write ( pkg->literals->size () );
    for ( int i = 0; i < pkg->literals->size (); i++ )
      write_literal ( ( *pkg->literals ) [ i ] );

    write ( pkg->init_code );
    write ( pkg->file_name );
  }

  void
    archive::read ( PACKAGE* &pkg )
  {
    symbol_t t;
    read ( t );
    pkg = new PACKAGE ( t );
    VM::add_package ( pkg );
    
    read_class ( (CLASS *) pkg );

    int sz = 0;
    read ( sz );
    pkg->literals = new ARRAY ( sz );
    for ( int i = 0; i < sz; i++ )
    read_literal ( ( *pkg->literals ) [ i ] );

    read ( pkg->init_code );
    pkg->init_code->klass ( pkg );
    read ( pkg->file_name );

    VM::run_init_code ( pkg );

  }

  //|
  //| BYTECODE
  //|
  void
    archive::read ( CODE* &c )
  {
    c = new CODE ();
    bool bc = false;
    read ( bc );
    c->_is_native = !bc;
    if ( bc )
    {
      int sz = 0; read ( sz );
      c->_code.bc = new BUFFER ( sz );
      read ( (char *) &( *c->_code.bc ) [ 0 ], sz );
    }
  }

  //|
  //| BYTECODE
  //|
  void
    archive::read_code_ref ( CODE* &c )
  {
    CLASS *cls = 0;
    read_class_ref ( cls );
    assert ( cls );
    symbol_t sym = undefined_symbol;
    read ( sym );
    ENTRY e = cls->find ( sym );
    assert ( e.is_valid () );
    assert ( e.type () == ST_FUNCTION || e.type () == ST_SFUNCTION );
    c = e.value ()->v.v_code;
  }

  void
    archive::write ( const CODE* c )
  {
    write ( c->is_bytecode () );
    if ( c->is_bytecode () )
    {
      write ( (int) c->_code.bc->size () );
      write ( (char *) &( *c->_code.bc ) [ 0 ], c->_code.bc->size () );
    }
  }

  void
    archive::write_code_ref ( const CODE* c )
  {
    write_class_ref ( c->_klass );
    write ( c->_name );
  }

  //|
  //| ENTRY
  //|
  void
    archive::read ( ENTRY &var )
  {
    read_class_ref ( var.klass );
    int idx = 0;
    read ( var.index );
  }

  void
    archive::write ( const ENTRY &var )
  {
    write_class_ref ( var.klass );
    write ( var.index );
  }

  //|
  //| SYMBOL
  //|
  void
    archive::read ( symbol_t& sym )
  {
    int i;
    read ( i ); //i - local (archive index);
    if ( (symbol_t) i == undefined_symbol )
      sym = undefined_symbol;
    else sym = _symbols [ i ];
  }
  
  void
    archive::write ( symbol_t sym )
  {
    int i = map ( sym );
    write ( i );
  }

  //|
  //| OBJECT
  //|
  void
    archive::read ( OBJECT* &obj )
  {
    CLASS *cls;
    read_class_ref ( cls );
    obj = new OBJECT ( cls );
    for ( int i = 0; i < obj->klass->instance_size; i++ )
      read ( obj->members [ i ] );
  }

  void
    archive::write ( const OBJECT * obj )
  {
    write_class_ref ( obj->klass );
    for ( int i = 0; i < obj->klass->instance_size; i++ )
      write ( obj->members [ i ] );
  }