sudo port install py27-pip
sudo pip-2.7 install cython

sudo apt-get install python-pip
sudo pip install cython

     - Now close shell and re-open a new dev shell (```MinGW-w64 Win64 Shell```)
     ```
pacman -Su
pacman -S mingw-w64-x86_64-python2-pip mingw-w64-x86_64-gcc git make

   - **User Install** is available for your user only but does not require special privileges

   - **Developer Setup** only links this code into your installation and allows
   you to change/develop the code and test it immediately. (I prefer user install here)

   - **Run In Place** allows you to run the binaries directly from the `bin` directory
  without any installation. You need `setup.py` only to build the native library
  of vamos:

## Contents

### Tools

  - [vamos](doc/vamos.md) **V)irtual AM)iga OS**

    The most ambitious project in the collection emulates the Amiga OS library
    API so that native m68k Amiga OS 1.x - 3.x binaries can be loaded and
    executed (think of Wine for Amiga :). With this approach only API conform
    programs can be run (i.e. no direct hardware access is possible).

    The goal is to run CLI programs relying on Exec and Dos library starting
    with a minimal set of implemented functions. But the design of vamos is
    flexible enough to add more libraries and more functions later on.

    Remember, vamos is and never will be a full Amiga system emulator like
    WinUAE or FS-UAE!!

    It uses the Hunk library of amitools to load and relocate the binary. A
    m68k CPU emulator is used to execute the code (here: Musashi emulator
    in native C with Python binding generated via Cython.

    Every call to a library is trapped during execution and realized with own
    Python code or simply ignored if no trap is defined.

    All public in memory structures (e.g. ExecBase) are also provided. vamos
    implements a memory handler to allocate and free structures used in the
    heap of a program or for library data exchange.

    Currently, this is a work in progress and mostly a proof of concept that
    is very instructive and even fairly fast. Its a playground for me to learn
    lots about Amiga OS, its binaries, its libraries and how they work
    together...

  - [xdftool](doc/xdftool.txt)

    Create and modify ADF or HDF disk image files.

  - [xdfscan](doc/xdfscan.txt)

    Scan directory trees for ADF or HDF disk image files and verify the contents.

  - [rdbtool](doc/rdbtool.txt)

    Create or modify disk images with Rigid Disk Block (RDB)

  - [romtool](doc/romtool.md)

    A tool to inspect, dissect, and build Amiga Kickstart ROM images to be
    used with emulators, run with soft kickers or burned into flash ROMs.

  - hunktool

    The hunktool uses amitools' hunk library to load a hunk-based amiga
    binary. Currently, its main purpose is to display the contents of the
    files in various formats.

    You can load hunk-based binaries, libraries, and object files. Even
    overlayed binary files are supporte.

  - typetool

    This little tool is a companion for vamos. It allows you to dump and get
    further information on the API C structure of AmigaOS used in vamos.

  - fdtool

    This tool reads the fd (function description) files Commodore supplied for
    all of their libraries and dumps their contents in different formats
    including a code structure used in vamos.

    You can query functions and find their jump table offset.


### Libraries

  - Hunk library ```amitools.binfmt.hunk```

    This library allows to read Amiga OS loadSeg()able binaries and represent
    them in a python structure. You could query all items found there,
    retrieve the code, data, and bss segments and even relocate them to target
    addresses

  - ELF library ```amitools.binfmt.elf```

    This library allows to read a subset of the ELF format mainly used in
    AROS m68k.

  - .fd File Parser ```amitools.fd```

    Parse function descriptions shipped by Commodore to describe the Amiga APIs

  - OFS and FFS File System Tools ```amitools.fs```

    Create or modify Amiga's OFS and FFS file system structures

  - File Scanners ```amitools.scan```

    I've written some scanners that walk through file trees and retrieve the
    file data for further processing. I support file trees on the file system,
    in lha archives or in adf/hdf disk images