So, i ported DASM to AROS....(Andrew Davie, please have a look!)

[Steril707]

If anybody wonders, AROS stands for "AROS Research Operating System" and is the open source OS that is compatible with Amiga OS 3.1. at API level. So you could basically say an open source attempt at a modern Amiga OS running on a couple of platforms.

 

Things are still in infancy on it on most aspects, but it looks and feels surprisingly good already, and since i don't expect all too much from the "official" Amiga OS4 and have a general love for hopeless causes, i feel being drawn to this..

 

Here are some infolinks and a pic:

 

For general information:

http://aros.sourceforge.net/

 

A nice blog about any news concerning AROS:

http://arosshow.blogspot.com/

 

A site for downloading Aros programs:

http://archives.aros-exec.org/

 

and here's a pic of my i386 pc running AROS with a Retro theme and Ken Lesters Icons, you can see various demos and a gui window etc...

http://www.sendlingboogiebreaks.de/amiga.png

 

 

So, i had the idea of porting DASM to this platform, and since an Amiga OS 4 port already existed it wasn't that much work. Granted, it doesn't make too much sense yet, since Stella isn't available for now (but VICE!!!), but that would be my next probable target at porting something.

 

Now my questions, particularly being thrown at Andrew here, are:

1. Can i upload my DASM port to the above mentioned Aros Archives site?

2. If i upload the thing, can i just upload the DASM executable, or must i embed it into the archive structure that i downloaded priorly (e.g. /bin/Amiga/AROS/dasm)

 

Reading your readme.txt in the archive it seems you are fairly mellow about these things, but i think i should ask before i tread on anybodies toes here...

 

greets,

Mike

Edited October 5, 2007 by Steril707

[Tom]

DASM is GPL'd so you may do anything with it that doesn't violate the GPL.

 

In your case this boils basically down to the following:

 

* Your DASM port to Aros must the GPL'd too

* If you distribute binaries, you must distribute the source code to build these binaries too (not necessarily together in one archive with the binaries) (*)

* You only need to distribute those sources that are needed to build the binaries you're distributing - no need to ship DOS or MAC or whatnot executables or sources specific to those platforms with your Aros port.

 

If anybody wishes to incorporate your Aros port back into some other DASM package, he can always do so. Because you must release the sources of your port. But you cannot be held responsible for doing that work yourself.

 

Now, Aros is not GPL'd, but (anybody correct me if I'm wrong) that shouldn't really matter, even if the Aros license wasn't compatible with the GPL - you're not mixing Aros and DASM code, after all, right?

 

 

(*) Btw, vice versa this isn't true: If you distribute GPL'd software in source form only, you don't need to distribute binaries.

[+stephena]

So, i had the idea of porting DASM to this platform, and since an Amiga OS 4 port already existed it wasn't that much work. Granted, it doesn't make too much sense yet, since Stella isn't available for now (but VICE!!!), but that would be my next probable target at porting something.

Stella would basically require SDL to be ported. After that, the Stella codebase itself would be quite easy to port. The code is 32/64 big/little endian clean, so I wouldn't expect many problems.

[Steril707]

So, i had the idea of porting DASM to this platform, and since an Amiga OS 4 port already existed it wasn't that much work. Granted, it doesn't make too much sense yet, since Stella isn't available for now (but VICE!!!), but that would be my next probable target at porting something.

Stella would basically require SDL to be ported. After that, the Stella codebase itself would be quite easy to port. The code is 32/64 big/little endian clean, so I wouldn't expect many problems.

I am by no means an expert on this subject, since i just started messing around with porting stuff to AROS, but i read in some kind of guidelines that SDL is okay, but OpenGL's a big no-no. Reading around the Stella page and inside the configure files i saw a lot of references to "OpenGL" written somewhere.

Are you sure i would just need SDL?

 

Thanks for your input,

Mike

[+stephena]

So, i had the idea of porting DASM to this platform, and since an Amiga OS 4 port already existed it wasn't that much work. Granted, it doesn't make too much sense yet, since Stella isn't available for now (but VICE!!!), but that would be my next probable target at porting something.

Stella would basically require SDL to be ported. After that, the Stella codebase itself would be quite easy to port. The code is 32/64 big/little endian clean, so I wouldn't expect many problems.

I am by no means an expert on this subject, since i just started messing around with porting stuff to AROS, but i read in some kind of guidelines that SDL is okay, but OpenGL's a big no-no. Reading around the Stella page and inside the configure files i saw a lot of references to "OpenGL" written somewhere.

Are you sure i would just need SDL?

 

Thanks for your input,

Mike

Reasonably sure, since I'm the one that added OpenGL support Seriously though, the OpenGL option can be compiled out of the executable. Also, joystick, sound, debugger, and cheat support can be disabled at compile time. Stella can be compiled and run on very 'small' systems, and only have the base features. One other thing I just remembered, you'll need the zlib library as well, and you'd need to create a few OS-specific classes for file handling. But other than that, there shouldn't be many problems.

[Steril707]

So, i had the idea of porting DASM to this platform, and since an Amiga OS 4 port already existed it wasn't that much work. Granted, it doesn't make too much sense yet, since Stella isn't available for now (but VICE!!!), but that would be my next probable target at porting something.

Stella would basically require SDL to be ported. After that, the Stella codebase itself would be quite easy to port. The code is 32/64 big/little endian clean, so I wouldn't expect many problems.

I am by no means an expert on this subject, since i just started messing around with porting stuff to AROS, but i read in some kind of guidelines that SDL is okay, but OpenGL's a big no-no. Reading around the Stella page and inside the configure files i saw a lot of references to "OpenGL" written somewhere.

Are you sure i would just need SDL?

 

Thanks for your input,

Mike

Reasonably sure, since I'm the one that added OpenGL support Seriously though, the OpenGL option can be compiled out of the executable. Also, joystick, sound, debugger, and cheat support can be disabled at compile time. Stella can be compiled and run on very 'small' systems, and only have the base features. One other thing I just remembered, you'll need the zlib library as well, and you'd need to create a few OS-specific classes for file handling. But other than that, there shouldn't be many problems.

 

Hehe ...Seems you really have some insider informations. I had some looks at the configure --help option and makefile, and i noticed about disabling opengl as well already. But at the moment i have some other issues, and i am not sure yet if these come from the aros specific gcc-compiler that i use, or something else. I still get lots of errors while compiling with the aros gcc that shouldn't be there, so i wonder if my compiler setup is somehow tainted.

 

Anyway, it's good to know i can ask somebody (=YOU ) when i am getting into some of the deeper stuff in porting Stella.

 

Thanks for your help,

Mike

Edited October 6, 2007 by Steril707

[Steril707]

Hey Stephena,

 

i tried myself on porting Stella to AROS a little bit, and everything seems to compile rather smooth, but i get loads of linker errors at the end...

 

See yourself...

 

Any idea what may be causing this, and what i can do to improve this somehow? I feel at a deadend at the moment...

 

thanks and greets,

Mike

 

 

There are undefined symbols in 'stella':
	 U _Unwind_SjLj_Register		FSNodePOSIX.cxx:0
	 U _Unwind_SjLj_Resume  FSNodePOSIX.cxx:0
	 U _Unwind_SjLj_Unregister	  FSNodePOSIX.cxx:0
	 U std::string::find_last_of(char const*, unsigned int, unsigned int) const
	 U std::string::find_first_of(char const*, unsigned int, unsigned int) const
	 U std::string::find_last_not_of(char, unsigned int) const
	 U std::string::find_first_not_of(char const*, unsigned int, unsigned int) const
	 U std::string::find_first_not_of(char, unsigned int) const
	 U std::string::find(char const*, unsigned int, unsigned int) const	 ListWidget.cxx:0
	 U std::string::compare(char const*) const
	 U std::string::compare(unsigned int, unsigned int, char const*) const
	 U std::__basic_file<char>::is_open() const
	 U std::basic_stringbuf<char, std::char_traits<char>, std::allocator<char> >::str() const
	 U std::basic_ios<char, std::char_traits<char> >::widen(char) const
	 U std::istream::get(char&)
	 U std::istream::peek()
	 U std::istream::read(char*, int)
	 U std::istream::seekg(long, std::_Ios_Seekdir)
	 U std::istream::tellg()
	 U std::istream::getline(char*, int, char)
	 U std::basic_istream<char, std::char_traits<char> >::~basic_istream()
	 U std::istream::operator>>(int&)
	 U std::ostream::put(char)
	 U std::ostream::write(char const*, int)
	 U std::ostream::operator<<(std::ostream& (*)(std::ostream&))
	 U std::ostream::operator<<(std::ios_base& (*)(std::ios_base&))
	 U std::ostream::operator<<(bool)
	 U std::ostream::operator<<(double)
	 U std::ostream::operator<<(long)
	 U std::ostream::operator<<(unsigned long)
	 U std::string::_M_leak_hard()  ListWidget.cxx:0
	 U std::string::_S_empty_rep_storage	Cart.cxx:0
	 U std::string::_Rep::_M_destroy(std::allocator<char> const&)   FSNodePOSIX.cxx:0
	 U std::string::_Rep::_S_terminal	   FSNodePOSIX.cxx:0
	 U std::string::append(char const*, unsigned int)
	 U std::string::append(std::string const&)
	 U std::string::append(unsigned int, char)
	 U std::string::assign(char const*, unsigned int)	   FSNodePOSIX.cxx:0
	 U std::string::assign(std::string const&)
	 U std::string::resize(unsigned int, char)
	 U std::string::replace(__gnu_cxx::__normal_iterator<char*, std::string>, __gnu_cxx::__normal_iterator<char*, std::string>, unsigned int, char)
	 U std::string::replace(unsigned int, unsigned int, char const*, unsigned int)
	 U std::string::reserve(unsigned int)
	 U std::basic_string<char, std::char_traits<char>, std::allocator<char> >::basic_string(char const*, std::allocator<char> const&) OSystemUNIX.cxx:0
	 U std::basic_string<char, std::char_traits<char>, std::allocator<char> >::basic_string(char const*, unsigned int, std::allocator<char> const&)
	 U std::basic_string<char, std::char_traits<char>, std::allocator<char> >::basic_string(std::string const&)	 FSNodePOSIX.cxx:0
	 U std::basic_string<char, std::char_traits<char>, std::allocator<char> >::basic_string(std::string const&, unsigned int, unsigned int)
	 U std::basic_string<char, std::char_traits<char>, std::allocator<char> >::~basic_string()
	 U std::__basic_file<char>::~__basic_file()
	 U std::basic_filebuf<char, std::char_traits<char> >::open(char const*, std::_Ios_Openmode)
	 U std::basic_filebuf<char, std::char_traits<char> >::close()
	 U std::basic_filebuf<char, std::char_traits<char> >::basic_filebuf()
	 U std::basic_filebuf<char, std::char_traits<char> >::~basic_filebuf()
	 U std::basic_streambuf<char, std::char_traits<char> >::basic_streambuf()
	 U std::basic_streambuf<char, std::char_traits<char> >::~basic_streambuf()
	 U std::basic_stringbuf<char, std::char_traits<char>, std::allocator<char> >::_M_stringbuf_init(std::_Ios_Openmode)
	 U std::__default_alloc_template<true, 0>::deallocate(void*, unsigned int)
	 U std::__default_alloc_template<true, 0>::allocate(unsigned int)
	 U std::locale::~locale()
	 U std::ios_base::Init::Init()  FSNodePOSIX.cxx:0
	 U std::ios_base::Init::~Init() FSNodePOSIX.cxx:0
	 U std::ios_base::ios_base()
	 U std::ios_base::~ios_base()
	 U std::basic_ios<char, std::char_traits<char> >::init(std::basic_streambuf<char, std::char_traits<char> >*)
	 U std::basic_ios<char, std::char_traits<char> >::clear(std::_Ios_Iostate)
	 U std::__throw_out_of_range(char const*)
	 U std::cerr
	 U std::cout
	 U std::basic_ostream<char, std::char_traits<char> >& std::endl<char, std::char_traits<char> >(std::basic_ostream<char, std::char_traits<char> >&)
	 U std::basic_istream<char, std::char_traits<char> >& std::getline<char, std::char_traits<char>, std::allocator<char> >(std::basic_istream<char, std::char_traits<char> >&, std::basic_string<char, std::char_traits<char>, std::allocator<char> >&, char)
	 U std::basic_ostream<char, std::char_traits<char> >& std::operator<< <std::char_traits<char> >(std::basic_ostream<char, std::char_traits<char> >&, char const*)
	 U std::basic_ostream<char, std::char_traits<char> >& std::operator<< <std::char_traits<char> >(std::basic_ostream<char, std::char_traits<char> >&, unsigned char)
	 U std::basic_ostream<char, std::char_traits<char> >& std::operator<< <char, std::char_traits<char>, std::allocator<char> >(std::basic_ostream<char, std::char_traits<char> >&, std::basic_string<char, std::char_traits<char>, std::allocator<char> > const&)
	 U std::basic_istream<char, std::char_traits<char> >& std::operator>><char, std::char_traits<char>, std::allocator<char> >(std::basic_istream<char, std::char_traits<char> >&, std::basic_string<char, std::char_traits<char>, std::allocator<char> >&)
	 U typeinfo for char const*
	 U typeinfo for char*
	 U VTT for std::basic_fstream<char, std::char_traits<char> >
	 U VTT for std::basic_ifstream<char, std::char_traits<char> >
	 U VTT for std::basic_ofstream<char, std::char_traits<char> >
	 U VTT for std::basic_istringstream<char, std::char_traits<char>, std::allocator<char> >
	 U VTT for std::basic_ostringstream<char, std::char_traits<char>, std::allocator<char> >
	 U vtable for std::basic_filebuf<char, std::char_traits<char> >
	 U vtable for std::basic_fstream<char, std::char_traits<char> >
	 U vtable for std::basic_ifstream<char, std::char_traits<char> >
	 U vtable for std::basic_ofstream<char, std::char_traits<char> >
	 U vtable for std::basic_streambuf<char, std::char_traits<char> >
	 U vtable for std::basic_stringbuf<char, std::char_traits<char>, std::allocator<char> >
	 U vtable for std::basic_istringstream<char, std::char_traits<char>, std::allocator<char> >
	 U vtable for std::basic_ostringstream<char, std::char_traits<char>, std::allocator<char> >
	 U vtable for std::basic_ios<char, std::char_traits<char> >
	 U operator delete[](void*)
	 U operator delete(void*)
	 U operator new[](unsigned int)
	 U operator new(unsigned int)
	 U __cxa_allocate_exception
	 U __cxa_begin_catch
	 U __cxa_call_unexpected
	 U __cxa_end_catch
	 U __cxa_pure_virtual   MD5.cxx:0
	 U __cxa_rethrow
	 U __cxa_throw
	 U __gxx_personality_sj0		FSNodePOSIX.cxx:0
make: *** [stella] Error 1

[+stephena]

Hey Stephena,

 

i tried myself on porting Stella to AROS a little bit, and everything seems to compile rather smooth, but i get loads of linker errors at the end...

 

See yourself...

 

Any idea what may be causing this, and what i can do to improve this somehow? I feel at a deadend at the moment...

 

thanks and greets,

Mike

At first glance, I'd say the C++ standard library isn't being linked in. The 'string' and 'stream' stuff is part of the C++ standard, and linking errors usually means the code can't be found. I don't know if it's an issue with the build script (ie, AROS needs some extra commandline arguments to find its libraries), or if the compiler and C++ libs in AROS aren't sufficiently developed to include the stuff that Stella needs. I'm leaning towards the former, but I'd really need to test compiling some small C++ apps in AROS to be sure. Is there a webpage somewhere that documents how to set up an AROS system with compiler tools installed?

 

Also, is the AROS filesystem similar to Unix/POSIX file systems? Because if not, there will need to be a few new classes created (FSNodeAros, perhaps).

[Steril707]

Hello Stephena,

thanks for the fast answer....

 

I guess you just need the Aros SDK, and those compiler files found at Zerohero.se if you want to have a try at compiling Stella

 

Here is the link:

http://www.zerohero.se/cross/aros.html

 

The AROS/Amiga Filesystem is a little bit differing from UNIX.. here i something i found on aros.sourceforge.net on this topic:

 

 

Converting unix paths to AROS paths

 

How do I convert UNIX paths into AROS paths? Exchange getenv("HOME") by "/PROGDIR/"

 

Examples:

 

old: strcpy(path, getenv("HOME"));

new: strcpy(path, "/PROGDIR/");

 

old: strcpy(home,getenv("HOME"));

new: strcpy(home,"/PROGDIR/");

 

old: sprintf(rc_dir, "%s/.gngeo/romrc.d", getenv("HOME"));

new: sprintf(rc_dir, "%sgngeo/romrc.d", "/PROGDIR/");

 

Notice that I removed "/." in the last example.

 

Paths to datadirs are often set during the configure process by issuing -DDATADIR=. If this is the case set it to -DDATADIR=/PROGDIR/ It's also common that the datadir are set in the makefiles. Locate DATADIR= and change it to DATADIR=/PROGDIR/

 

Information is a little bit hard to come by in the little AROS world, but i keep on asking a lot on the IRC channels.

Hopefully some stuff gets more clear for me soon.

 

greets,

Mike

Edited October 31, 2007 by Steril707