Mercurial > projects > ddmd

changeset 14:2cc604139636

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Implemented Linux support for ddmd. Some parts are a bit hacky to just "get it working", that said, druntime and phobos compile, and unittests pass.
author Robert Clipsham <robert@octarineparrot.com>
date Sun, 04 Apr 2010 02:06:32 +0100
parents 3356c90e9aac
children da741eed6c00
files .hgignore bin/dmd.conf bridge/bridge.cpp build.sh commands.linux.txt dbg/ui/CrashWindow.d dlib/CrashHandler.d dmd/Declaration.d dmd/Dsymbol.d dmd/File.d dmd/FileName.d dmd/FuncDeclaration.d dmd/Global.d dmd/Gnuc.d dmd/Library.d dmd/MOD.d dmd/Module.d dmd/Type.d dmd/TypeAArray.d dmd/TypeDArray.d dmd/Util.d dmd/backend/Config.d dmd/backend/Cstate.d dmd/backend/OPER.d dmd/backend/RTLSYM.d dmd/backend/TYFL.d dmd/backend/TYM.d dmd/backend/TYPE.d dmd/backend/Util.d dmd/backend/glue.d dmd/backend/iasm.d dmd/backend/mTY.d main.d
diffstat 33 files changed, 725 insertions(+), 107 deletions(-) [+]
line wrap: on
line diff
--- a/.hgignore	Wed Mar 31 16:29:36 2010 +0400
+++ b/.hgignore	Sun Apr 04 02:06:32 2010 +0100
@@ -1,1 +1,2 @@
 relre:win32/*
+dmd32/
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/bin/dmd.conf	Sun Apr 04 02:06:32 2010 +0100
@@ -0,0 +1,3 @@
+[Environment]
+DFLAGS=-I%@P%/../dmd32/dmd2/src/druntime/import/ -I%@P%/../dmd32/dmd2/src/druntime/src/common/ -I%@P%/../dmd32/dmd2/src/phobos/ -L-L%@P%/../dmd32/dmd2/linux/lib
+;CC=i686-unknown-linux-gnu-gcc
--- a/bridge/bridge.cpp	Wed Mar 31 16:29:36 2010 +0400
+++ b/bridge/bridge.cpp	Sun Apr 04 02:06:32 2010 +0100
@@ -4,6 +4,7 @@
 struct elem;
 struct Blockx;
 struct block;
+enum BC {};
 
 typedef TYPE type;
 
@@ -178,4 +179,4 @@
 unsigned int* get_tytouns()
 {
 	return (unsigned int*)tytouns;
-}
\ No newline at end of file
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/build.sh	Sun Apr 04 02:06:32 2010 +0100
@@ -0,0 +1,4 @@
+#!/bin/sh
+#i686-unknown-linux-gnu-g++ -c bridge/bridge.cpp -obridge.o
+g++ -c bridge/bridge.cpp -obridge.o
+dmd @commands.linux.txt #|& head
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/commands.linux.txt	Sun Apr 04 02:06:32 2010 +0100
@@ -0,0 +1,383 @@
+-g
+-debug
+-version=Bug3602
+-version=Bug4054
+-version=Bug4059
+-version=DMDV2
+-version=TX86
+-version=MARS
+-version=TARGET_LINUX
+-version=POSIX
+-version=NobodyCares
+-version=DumbClone
+-version=STRUCTTHISREF
+-version=CCASTSYNTAX
+-version=CARRAYDECL
+-version=BREAKABI
+-version=SNAN_DEFAULT_INIT
+-ofbin/ddmd
+
+bridge.o
+-L-Ldmd32/dmd2/src/dmd
+-L-ldmd
+-L-lstdc++
+main.d
+dlib/CrashHandler.d
+dbg/ui/CrashWindow.d
+dbg/Debug.d
+dbg/symbol/CodeView.d
+dbg/image/PE.d
+dmd/AggregateDeclaration.d
+dmd/VarExp.d
+dmd/Tuple.d
+dmd/UnrolledLoopStatement.d
+dmd/SwitchErrorStatement.d
+dmd/NewAnonClassExp.d
+dmd/StructLiteralExp.d
+dmd/StaticIfCondition.d
+dmd/BoolExp.d
+dmd/ShlAssignExp.d
+dmd/ShrAssignExp.d
+dmd/UshrAssignExp.d
+dmd/CatAssignExp.d
+dmd/Port.d
+dmd/Gnuc.d
+dmd/declaration/Match.d
+dmd/templates/Util.d
+dmd/expression/Util.d
+dmd/expression/Add.d
+dmd/expression/Xor.d
+dmd/expression/Ptr.d
+dmd/expression/Min.d
+dmd/expression/And.d
+dmd/expression/Shr.d
+dmd/expression/Not.d
+dmd/expression/Mod.d
+dmd/expression/Mul.d
+dmd/expression/Com.d
+dmd/expression/Ushr.d
+dmd/expression/Shl.d
+dmd/expression/Div.d
+dmd/expression/Cmp.d
+dmd/expression/Identity.d
+dmd/expression/ArrayLength.d
+dmd/expression/Equal.d
+dmd/expression/Or.d
+dmd/expression/Neg.d
+dmd/expression/Cat.d
+dmd/expression/Slice.d
+dmd/expression/Index.d
+dmd/expression/shift_optimize.d
+dmd/expression/util/arrayTypeCompatible.d
+dmd/condition/util/findCondition.d
+dmd/OverExp.d
+dmd/Cast.d
+dmd/TupleExp.d
+dmd/ArrayLengthExp.d
+dmd/TypeInfoConstDeclaration.d
+dmd/TypeInfoInvariantDeclaration.d
+dmd/TypeInfoSharedDeclaration.d
+dmd/TypeInfoStructDeclaration.d
+dmd/TypeInfoInterfaceDeclaration.d
+dmd/TypeInfoEnumDeclaration.d
+dmd/TypeInfoClassDeclaration.d
+dmd/TypeInfoArrayDeclaration.d
+dmd/TypeInfoDelegateDeclaration.d
+dmd/TypeInfoTypedefDeclaration.d
+dmd/TypeInfoPointerDeclaration.d
+dmd/DsymbolExp.d
+dmd/GlobalExpressions.d
+dmd/NewExp.d
+dmd/PeelStatement.d
+dmd/HaltExp.d
+dmd/SymOffExp.d
+dmd/type/Util.d
+dmd/SymbolExp.d
+dmd/Optimize.d
+dmd/DotVarExp.d
+dmd/DeclarationExp.d
+dmd/TraitsExp.d
+dmd/ComplexExp.d
+dmd/ErrorExp.d
+dmd/AssignExp.d
+dmd/DotExp.d
+dmd/AliasDeclaration.d
+dmd/DefaultInitExp.d
+dmd/FileInitExp.d
+dmd/LineInitExp.d
+dmd/AnonDeclaration.d
+dmd/AliasThis.d
+dmd/AlignDeclaration.d
+dmd/AnonymousAggregateDeclaration.d
+dmd/Argument.d
+dmd/FuncExp.d
+dmd/ArrayLiteralExp.d
+dmd/AssocArrayLiteralExp.d
+dmd/AssertExp.d
+dmd/IsExp.d
+dmd/TypeExp.d
+dmd/StringExp.d
+dmd/NullExp.d
+dmd/RealExp.d
+dmd/ThisExp.d
+dmd/ScopeExp.d
+dmd/Array.d
+dmd/DotIdExp.d
+dmd/FileExp.d
+dmd/SuperExp.d
+dmd/TypeidExp.d
+dmd/CompileExp.d
+dmd/IdentifierExp.d
+dmd/DollarExp.d
+dmd/AndAndExp.d
+dmd/DotTemplateInstanceExp.d
+dmd/OrExp.d
+dmd/PostExp.d
+dmd/CallExp.d
+dmd/SliceExp.d
+dmd/ArrayExp.d
+dmd/AddrExp.d
+dmd/UAddExp.d
+dmd/XorExp.d
+dmd/CommaExp.d
+dmd/BinExp.d
+dmd/CondExp.d
+dmd/OrOrExp.d
+dmd/AndExp.d
+dmd/InExp.d
+dmd/EqualExp.d
+dmd/CmpExp.d
+dmd/ShlExp.d
+dmd/AddExp.d
+dmd/CatExp.d
+dmd/MinExp.d
+dmd/MulExp.d
+dmd/ModExp.d
+dmd/DivExp.d
+dmd/ShrExp.d
+dmd/UshrExp.d
+dmd/CastExp.d
+dmd/DeleteExp.d
+dmd/ComExp.d
+dmd/NotExp.d
+dmd/UnaExp.d
+dmd/NegExp.d
+dmd/PtrExp.d
+dmd/IntegerExp.d
+dmd/AddAssignExp.d
+dmd/AndAssignExp.d
+dmd/DivAssignExp.d
+dmd/MinAssignExp.d
+dmd/ModAssignExp.d
+dmd/MulAssignExp.d
+dmd/OrAssignExp.d
+dmd/XorAssignExp.d
+dmd/IdentityExp.d
+dmd/ArrayInitializer.d
+dmd/ArrayScopeSymbol.d
+dmd/ArrayTypes.d
+dmd/AsmStatement.d
+dmd/AttribDeclaration.d
+dmd/BUILTIN.d
+dmd/BaseClass.d
+dmd/BreakStatement.d
+dmd/CaseRangeStatement.d
+dmd/CaseStatement.d
+dmd/Catch.d
+dmd/ClassDeclaration.d
+dmd/ClassInfoDeclaration.d
+dmd/CompileDeclaration.d
+dmd/CompileStatement.d
+dmd/CompoundDeclarationStatement.d
+dmd/CompoundStatement.d
+dmd/Condition.d
+dmd/ConditionalDeclaration.d
+dmd/ConditionalStatement.d
+dmd/ContinueStatement.d
+dmd/CppMangleState.d
+dmd/CtorDeclaration.d
+dmd/DVCondition.d
+dmd/Dchar.d
+dmd/DebugCondition.d
+dmd/DebugSymbol.d
+dmd/Declaration.d
+dmd/DeclarationStatement.d
+dmd/DefaultStatement.d
+dmd/DeleteDeclaration.d
+dmd/DoStatement.d
+dmd/DocComment.d
+dmd/Dsymbol.d
+dmd/DsymbolTable.d
+dmd/DtorDeclaration.d
+dmd/EnumDeclaration.d
+dmd/EnumMember.d
+dmd/Escape.d
+dmd/ExpInitializer.d
+dmd/ExpStatement.d
+dmd/Expression.d
+dmd/File.d
+dmd/FileName.d
+dmd/ForStatement.d
+dmd/ForeachRangeStatement.d
+dmd/ForeachStatement.d
+dmd/FuncAliasDeclaration.d
+dmd/FuncDeclaration.d
+dmd/FuncLiteralDeclaration.d
+dmd/Global.d
+dmd/GotoCaseStatement.d
+dmd/GotoDefaultStatement.d
+dmd/GotoStatement.d
+dmd/HdrGenState.d
+dmd/ILS.d
+dmd/IRState.d
+dmd/Id.d
+dmd/Identifier.d
+dmd/IfStatement.d
+dmd/Import.d
+dmd/Initializer.d
+dmd/InlineCostState.d
+dmd/InlineDoState.d
+dmd/InlineScanState.d
+dmd/IntRange.d
+dmd/InterState.d
+dmd/InterfaceDeclaration.d
+dmd/InvariantDeclaration.d
+dmd/LINK.d
+dmd/LabelDsymbol.d
+dmd/LabelStatement.d
+dmd/Lexer.d
+dmd/Library.d
+dmd/LinkDeclaration.d
+dmd/Loc.d
+dmd/Lstring.d
+dmd/MATCH.d
+dmd/Macro.d
+dmd/Module.d
+dmd/ModuleDeclaration.d
+dmd/ModuleInfoDeclaration.d
+dmd/NewDeclaration.d
+dmd/ObjModule.d
+dmd/OnScopeStatement.d
+dmd/OutBuffer.d
+dmd/OverloadSet.d
+dmd/PREC.d
+dmd/PROT.d
+dmd/Package.d
+dmd/Param.d
+dmd/Parser.d
+dmd/PostBlitDeclaration.d
+dmd/PragmaDeclaration.d
+dmd/PragmaStatement.d
+dmd/ProtDeclaration.d
+dmd/RET.d
+dmd/ReturnStatement.d
+dmd/STC.d
+dmd/Scope.d
+dmd/ScopeDsymbol.d
+dmd/ScopeStatement.d
+dmd/Section.d
+dmd/Statement.d
+dmd/StaticAssert.d
+dmd/StaticAssertStatement.d
+dmd/StaticCtorDeclaration.d
+dmd/StaticDtorDeclaration.d
+dmd/StaticIfDeclaration.d
+dmd/StorageClassDeclaration.d
+dmd/String.d
+dmd/StringEntry.d
+dmd/StringTable.d
+dmd/StringValue.d
+dmd/StructDeclaration.d
+dmd/StructInitializer.d
+dmd/SwitchStatement.d
+dmd/SymbolDeclaration.d
+dmd/SynchronizedStatement.d
+dmd/TOK.d
+dmd/TY.d
+dmd/TemplateAliasParameter.d
+dmd/TemplateDeclaration.d
+dmd/TemplateInstance.d
+dmd/TemplateMixin.d
+dmd/TemplateParameter.d
+dmd/TemplateThisParameter.d
+dmd/TemplateTupleParameter.d
+dmd/TemplateTypeParameter.d
+dmd/TemplateValueParameter.d
+dmd/ThisDeclaration.d
+dmd/ThrowStatement.d
+dmd/Token.d
+dmd/TryCatchStatement.d
+dmd/TryFinallyStatement.d
+dmd/TupleDeclaration.d
+dmd/Type.d
+dmd/TypeAArray.d
+dmd/TypeArray.d
+dmd/TypeBasic.d
+dmd/TypeClass.d
+dmd/TypeDArray.d
+dmd/TypeDelegate.d
+dmd/TypeEnum.d
+dmd/TypeFunction.d
+dmd/TypeIdentifier.d
+dmd/TypeInfoDeclaration.d
+dmd/TypeInstance.d
+dmd/TypeNext.d
+dmd/TypePointer.d
+dmd/TypeQualified.d
+dmd/TypeReference.d
+dmd/TypeReturn.d
+dmd/TypeSArray.d
+dmd/EnumUtils.d
+dmd/TypeSlice.d
+dmd/TypeStruct.d
+dmd/TypeTuple.d
+dmd/TypeTypedef.d
+dmd/TypeTypeof.d
+dmd/TypedefDeclaration.d
+dmd/UnionDeclaration.d
+dmd/UnitTestDeclaration.d
+dmd/Utf.d
+dmd/Util.d
+dmd/DotTemplateExp.d
+dmd/DelegateExp.d
+dmd/RemoveExp.d
+dmd/TemplateExp.d
+dmd/DotTypeExp.d
+dmd/IndexExp.d
+dmd/VarDeclaration.d
+dmd/VersionCondition.d
+dmd/VersionSymbol.d
+dmd/VoidInitializer.d
+dmd/VolatileStatement.d
+dmd/WhileStatement.d
+dmd/WithScopeSymbol.d
+dmd/WithStatement.d
+dmd/backend/Blockx.d
+dmd/backend/enum_t.d
+dmd/backend/Symbol.d
+dmd/backend/Util.d
+dmd/backend/TYPE.d
+dmd/backend/TYM.d
+dmd/backend/mTY.d
+dmd/backend/block.d
+dmd/backend/code.d
+dmd/backend/glue.d
+dmd/backend/dt_t.d
+dmd/backend/elem.d
+dmd/backend/func_t.d
+dmd/backend/Cstate.d
+dmd/backend/TYFL.d
+dmd/backend/RTLSYM.d
+dmd/backend/symtab_t.d
+dmd/backend/Classsym.d
+dmd/backend/con_t.d
+dmd/backend/cse_t.d
+dmd/backend/struct_t.d
+dmd/backend/OPER.d
+dmd/backend/StringTab.d
+dmd/backend/DT.d
+dmd/backend/Configv.d
+dmd/backend/iasm.d
+dmd/backend/rel.d
+dmd/backend/LIST.d
+dmd/codegen/Util.d
--- a/dbg/ui/CrashWindow.d	Wed Mar 31 16:29:36 2010 +0400
+++ b/dbg/ui/CrashWindow.d	Sun Apr 04 02:06:32 2010 +0100
@@ -366,4 +366,7 @@
 }
 
 } // version(Gnome)
-else static assert(0);
\ No newline at end of file
+else version (NobodyCares)
+{
+}
+else static assert(0);
--- a/dlib/CrashHandler.d	Wed Mar 31 16:29:36 2010 +0400
+++ b/dlib/CrashHandler.d	Sun Apr 04 02:06:32 2010 +0100
@@ -37,9 +37,9 @@
 	import dbg.symbol.CodeView;
 }
 else version(Posix) {
-	import sys.posix.ucontext;
-	import std.c.signal;
-	import std.c.stdlib : free, exit, EXIT_FAILURE;
+	import core.sys.posix.ucontext;
+	import core.stdc.signal;
+	import core.stdc.stdlib : free, exit, EXIT_FAILURE;
 }
 else static assert(0, "Unsupported platform.");
 
@@ -53,14 +53,15 @@
 		SetUnhandledExceptionFilter(&UnhandledExceptionHandler);
 	}
 	else version(Posix) {
-		sigaction_t sa;
+	assert(0);
+	/+	sigaction_t sa;
 		sa.sa_handler = cast(sighandler_t)&SignalHandler;
 		sigemptyset(&sa.sa_mask);
 		sa.sa_flags = SA_RESTART | SA_SIGINFO;
 
 		sigaction(SIGILL, &sa, null);
 		sigaction(SIGFPE, &sa, null);
-		sigaction(SIGSEGV, &sa, null);
+		sigaction(SIGSEGV, &sa, null);+/
 	}
 	else static assert(0);
 }
@@ -91,7 +92,7 @@
 
 	void Dump() {
 		// TODO: support more dump methods
-		ShowCrashWindow(&this);
+		version(Windows) ShowCrashWindow(&this);
 	}
 
 	/**
@@ -216,6 +217,10 @@
 					}
 				}
 			}
+			else version(POSIX)
+			{
+				assert(0);
+			}
 			else static assert(0);
 
 			frame.moduleName = image.moduleName;
@@ -383,7 +388,8 @@
 	case SIGSEGV:	msg = "Segmentation fault";			break;
 	default:		msg = "Unknown signal";
 	}
-
+	assert(0);
+/+
 	SystemException e = new SystemException(msg);
 
 	e._context = ucontext;
@@ -400,8 +406,7 @@
 			e._backtrace[2] = cast(void*)ucontext.uc_mcontext.gregs[REG_EIP];
 	}
 	else static assert(0);
-
-	throw e;
+	throw e;+/
 }
 
 /**
@@ -409,10 +414,10 @@
  point, which should catch it and manually call this routine.
 */
 void UnhandledExceptionHandler(Throwable e) {
-	ErrorReport crashInfo = void;
+assert(0);
+/+	ErrorReport crashInfo = void;
 
 	with(crashInfo) {
-assert(0);
 	/+error = e;
 
 	// Get the module filename
@@ -443,7 +448,7 @@
 
 	} // with(crashInfo)
 
-	crashInfo.Dump();
+	crashInfo.Dump();+/
 }
 
 } // version(Posix)
--- a/dmd/Declaration.d	Wed Mar 31 16:29:36 2010 +0400
+++ b/dmd/Declaration.d	Sun Apr 04 02:06:32 2010 +0100
@@ -180,7 +180,7 @@
 	}
 
     string mangle()
-	out (result)
+	/+out (result)
 	{
 		try
 		{
@@ -197,8 +197,9 @@
 			assert(false);
 		}
 	}
-	body
+	body+/
 	{
+version(Bug3602) { writef( "Bug3602: Uncomment outblock when fixed" );  }
 		//writef("Declaration.mangle(this = %p, '%s', parent = '%s', linkage = %d)\n", this, toChars(), parent ? parent.toChars() : "null", linkage);
 		if (!parent || parent.isModule() || linkage == LINK.LINKcpp) // if at global scope
 		{
@@ -308,4 +309,4 @@
 	}
 
     Declaration isDeclaration() { return this; }
-}
\ No newline at end of file
+}
--- a/dmd/Dsymbol.d	Wed Mar 31 16:29:36 2010 +0400
+++ b/dmd/Dsymbol.d	Sun Apr 04 02:06:32 2010 +0100
@@ -69,7 +69,8 @@
 import dmd.backend.LIST;
 
 import core.stdc.string : strcmp, memcpy, strlen;
-import core.stdc.stdlib : alloca;
+version (Bug4054) import core.memory;
+else import core.stdc.stdlib : alloca;
 
 import std.stdio;
 
@@ -322,6 +323,9 @@
 		}
 		--len;
 
+version (Bug4054)
+		char* s = cast(char*)GC.malloc(len);
+else
 		char* s = cast(char*)alloca(len);
 		char* q = s + len;
 
@@ -761,6 +765,9 @@
 
 		//printf("Dsymbol::toImport('%s')\n", sym->Sident);
 		n = sym.Sident.ptr;
+version (Bug4054)
+		id = cast(char*) GC.malloc(6 + strlen(n) + 1 + (type_paramsize_i(sym.Stype)).sizeof*3 + 1);
+else
 		id = cast(char*) alloca(6 + strlen(n) + 1 + (type_paramsize_i(sym.Stype)).sizeof*3 + 1);
 		if (sym.Stype.Tmangle == mTYman_std && tyfunc(sym.Stype.Tty))
 		{
@@ -803,6 +810,9 @@
 			n += 2;
 		}
 }
+		version (Bug4054)
+		id = cast(char*) GC.malloc(2 + nlen + size_t.sizeof * 3 + prefix.length + suffix.length + 1);
+		else
 		id = cast(char*) alloca(2 + nlen + size_t.sizeof * 3 + prefix.length + suffix.length + 1);
 		sprintf(id, "_D%.*s%lu%.*s%.*s", n, prefix.length, prefix, suffix);
 		
@@ -859,4 +869,4 @@
 version (TARGET_NET) {
     PragmaScope isPragmaScope() { return null; }
 }
-}
\ No newline at end of file
+}
--- a/dmd/File.d	Wed Mar 31 16:29:36 2010 +0400
+++ b/dmd/File.d	Sun Apr 04 02:06:32 2010 +0100
@@ -5,7 +5,18 @@
 import dmd.Util;
 
 import core.stdc.stdlib;
-import core.sys.windows.windows;
+version (Windows)
+{
+    import core.sys.windows.windows;
+}
+version (POSIX)
+{
+    import core.sys.posix.fcntl;
+    import core.stdc.errno;
+    import core.sys.posix.unistd;
+    import core.sys.posix.utime;
+    import core.stdc.stdio;
+}
 
 import std.string : toStringz;
 
@@ -72,7 +83,7 @@
 		string name = this.name.toChars();
 
 		//printf("File::read('%s')\n",name);
-		int fd = open(name, O_RDONLY);
+		int fd = open(toStringz(name), O_RDONLY);
 		if (fd == -1) {
 			result = errno;
 			//printf("\topen error, errno = %d\n", errno);
@@ -86,7 +97,7 @@
 		ref_ = 0;       // we own the buffer now
 
 		//printf("\tfile opened\n");
-		stat buf;
+		stat_t buf;
 		if (fstat(fd, &buf)) {
 			printf("\tfstat error, errno = %d\n", errno);
 			goto err2;
@@ -388,11 +399,11 @@
     void remove()		// delete file
 	{
 version (POSIX) {
-		.remove(this.name.toChars());
+		.remove(toStringz(this.name.toChars()));
 } else version (_WIN32) {
 		DeleteFileA(toStringz(this.name.toChars()));
 } else {
 		assert(0);
 }
 	}
-}
\ No newline at end of file
+}
--- a/dmd/FileName.d	Wed Mar 31 16:29:36 2010 +0400
+++ b/dmd/FileName.d	Sun Apr 04 02:06:32 2010 +0100
@@ -15,7 +15,17 @@
 import std.string : cmp, icmp;
 import std.file : mkdirRecurse;
 
-import core.sys.windows.windows;
+version (Windows)
+{
+    import core.sys.windows.windows;
+}
+
+version (POSIX)
+{
+    import core.stdc.stdlib;
+    import core.sys.posix.sys.stat;
+    import std.conv;
+}
 
 class FileName : String
 {
@@ -359,7 +369,7 @@
 
 	version (POSIX) {
 						case '~':
-							buf.writestring(getenv("HOME"));
+							buf.writestring(to!string(getenv("HOME")));
 							continue;
 	}
 
@@ -454,7 +464,7 @@
 version (_WIN32) {
 		file.touchtime = GC.malloc(WIN32_FIND_DATA.sizeof);	// keep same file time
 } else version (POSIX) {
-		file.touchtime = GC.malloc(stat.sizeof); // keep same file time
+		file.touchtime = GC.malloc(stat_t.sizeof); // keep same file time
 } else {
 		static assert(0);
 }
@@ -498,9 +508,9 @@
     static int exists(string name)
 	{
 version (POSIX) {
-		stat st;
+		stat_t st;
 
-		if (stat(name, &st) < 0)
+		if (stat(toStringz(name), &st) < 0)
 			return 0;
 		if (S_ISDIR(st.st_mode))
 			return 2;
@@ -534,4 +544,4 @@
 		} catch {
 		}
 	}
-}
\ No newline at end of file
+}
--- a/dmd/FuncDeclaration.d	Wed Mar 31 16:29:36 2010 +0400
+++ b/dmd/FuncDeclaration.d	Sun Apr 04 02:06:32 2010 +0100
@@ -112,6 +112,7 @@
 
 import core.stdc.stdio;
 import core.stdc.string;
+version (Bug4054) import core.memory;
 
 import std.string;
 
@@ -2645,6 +2646,9 @@
 		type *t;
 
 		n = sym.Sident;
+		version (Bug4054)
+		id = cast(char*) GC.malloc(8 + 5 + strlen(n) + 1);
+		else
 		id = cast(char*) alloca(8 + 5 + strlen(n) + 1);
 		sprintf(id, "_thunk%d__%s", offset, n);
 		s = symbol_calloc(id);
@@ -2837,6 +2841,9 @@
 			pi += parameters.dim;
 
 		// Allow extra 2 for sthis and shidden
+		version (Bug4054)
+		params = cast(Symbol**)GC.malloc((pi + 2) * (Symbol*).sizeof);
+		else
 		params = cast(Symbol**)alloca((pi + 2) * (Symbol*).sizeof);
 
 		// Get the actual number of parameters, pi, and fill in the params[]
@@ -3245,4 +3252,4 @@
 	}
 
     FuncDeclaration isFuncDeclaration() { return this; }
-}
\ No newline at end of file
+}
--- a/dmd/Global.d	Wed Mar 31 16:29:36 2010 +0400
+++ b/dmd/Global.d	Sun Apr 04 02:06:32 2010 +0100
@@ -10,7 +10,7 @@
 	
 version (TARGET_WINDOS) {
     string obj_ext = "obj";
-} else version (XXX) {	// TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_SOLARIS
+} else version (POSIX) {	// TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_SOLARIS
     string obj_ext = "o";
 } else version (TARGET_NET) {
 } else {
@@ -19,7 +19,7 @@
 
 version (TARGET_WINDOS) {
     string lib_ext = "lib";
-} else version (XXX) {	// TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_SOLARIS
+} else version (POSIX) {	// TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_SOLARIS
 	string lib_ext = "a";
 } else version (TARGET_NET) {
 } else {
@@ -49,4 +49,4 @@
 	}
 }
 
-Global global;
\ No newline at end of file
+Global global;
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/dmd/Gnuc.d	Sun Apr 04 02:06:32 2010 +0100
@@ -0,0 +1,51 @@
+module dmd.Gnuc;
+
+int memicmp(const char *s1, const char *s2, int n)
+{
+    int result = 0;
+
+    for (int i = 0; i < n; i++)
+    {	char c1 = s1[i];
+	char c2 = s2[i];
+
+	result = c1 - c2;
+	if (result)
+	{
+	    if ('A' <= c1 && c1 <= 'Z')
+		c1 += 'a' - 'A';
+	    if ('A' <= c2 && c2 <= 'Z')
+		c2 += 'a' - 'A';
+	    result = c1 - c2;
+	    if (result)
+		break;
+	}
+    }
+    return result;
+}
+
+int stricmp(const(char) *s1, const(char) *s2)
+{
+    int result = 0;
+
+    for (;;)
+    {	char c1 = *s1;
+	char c2 = *s2;
+
+	result = c1 - c2;
+	if (result)
+	{
+	    if ('A' <= c1 && c1 <= 'Z')
+		c1 += 'a' - 'A';
+	    if ('A' <= c2 && c2 <= 'Z')
+		c2 += 'a' - 'A';
+	    result = c1 - c2;
+	    if (result)
+		break;
+	}
+	if (!c1)
+	    break;
+	s1++;
+	s2++;
+    }
+    return result;
+}
--- a/dmd/Library.d	Wed Mar 31 16:29:36 2010 +0400
+++ b/dmd/Library.d	Sun Apr 04 02:06:32 2010 +0100
@@ -150,7 +150,8 @@
 	
     return cmp((*p1).name, (*p2).name);
 }
-
+version (Windows)
+{
 /*******************************************
  * Write a single entry into dictionary.
  * Returns:
@@ -979,4 +980,26 @@
 		// Write library header at start of buffer
 		memcpy(libbuf.data, &libHeader, libHeader.sizeof);
 	}
-}
\ No newline at end of file
+}
+} // version (Windows)
+else version(TARGET_LINUX)
+{
+class Library
+{
+    void setFilename(string dir, string filename)
+    {
+    	assert(0);
+    }
+    
+    void addObject(string module_name, void *buf, size_t buflen)
+    {
+    	assert(0);
+    }
+    
+    void write()
+    {
+    	assert(0);
+    }
+	
+}
+}
--- a/dmd/MOD.d	Wed Mar 31 16:29:36 2010 +0400
+++ b/dmd/MOD.d	Sun Apr 04 02:06:32 2010 +0100
@@ -1,6 +1,6 @@
 module dmd.MOD;
 
-enum MOD
+public enum MOD
 {
 	MODundefined = 0,
 	MODconst = 1,	// type is const
@@ -9,4 +9,4 @@
 }
 
 import dmd.EnumUtils;
-mixin(BringToCurrentScope!(MOD));
\ No newline at end of file
+mixin(BringToCurrentScope!(MOD));
--- a/dmd/Module.d	Wed Mar 31 16:29:36 2010 +0400
+++ b/dmd/Module.d	Sun Apr 04 02:06:32 2010 +0100
@@ -1221,6 +1221,9 @@
 			}
 			else
 			{
+				version(Bug4054)
+				todo = cast(Dsymbol*)GC.malloc(len * (Dsymbol*).sizeof);
+				else
 				todo = cast(Dsymbol*)alloca(len * (Dsymbol*).sizeof);
 				assert(todo);
 			}
@@ -1564,4 +1567,4 @@
 	}
 
     Module isModule() { return this; }
-}
\ No newline at end of file
+}
--- a/dmd/Type.d	Wed Mar 31 16:29:36 2010 +0400
+++ b/dmd/Type.d	Sun Apr 04 02:06:32 2010 +0100
@@ -1837,6 +1837,9 @@
 			toDecoBuffer(buf);
 
 		len = buf.offset;
+		version (Bug4054)
+		name = cast(char*)GC.malloc(19 + len.sizeof * 3 + len + 1);
+		else
 		name = cast(char*)alloca(19 + len.sizeof * 3 + len + 1);
 		buf.writeByte(0);
 	version (TARGET_OSX) {
@@ -2444,4 +2447,4 @@
 	{
 		return tsize_t;			// matches hash_t alias
 	}
-}
\ No newline at end of file
+}
--- a/dmd/TypeAArray.d	Wed Mar 31 16:29:36 2010 +0400
+++ b/dmd/TypeAArray.d	Sun Apr 04 02:06:32 2010 +0100
@@ -35,7 +35,8 @@
 
 import core.stdc.stdio;
 import core.stdc.stdlib;
-
+version (Bug4054)
+	import core.memory;
 class TypeAArray : TypeArray
 {
     Type index;		// key type
@@ -311,6 +312,9 @@
 
 		sz = next.size();		// it's just data, so we only care about the size
 		sz = (sz + 3) & ~3;		// reduce proliferation of library routines
+		version (Bug4054)
+		id = cast(char*)GC.malloc(3 + strlen(func) + buf.offset + sizeof(sz) * 3 + 1);
+		else
 		id = cast(char*)alloca(3 + strlen(func) + buf.offset + sizeof(sz) * 3 + 1);
 		buf.writeByte(0);
 		if (flags & 1)
@@ -318,6 +322,9 @@
 		else
 			sprintf(id, "_aa%s%s", func, buf.data);
 	} else {
+		version (Bug4054)
+		id = cast(char*)GC.malloc(3 + strlen(func) + 1);
+		else
 		id = cast(char*)alloca(3 + strlen(func) + 1);
 		sprintf(id, "_aa%s", func);
 	}
@@ -357,4 +364,4 @@
 	{
 		assert(false);
 	}
-}
\ No newline at end of file
+}
--- a/dmd/TypeDArray.d	Wed Mar 31 16:29:36 2010 +0400
+++ b/dmd/TypeDArray.d	Sun Apr 04 02:06:32 2010 +0100
@@ -35,6 +35,7 @@
 
 import core.stdc.stdlib;
 import core.stdc.stdio;
+version (Bug4054) import core.memory;
 
 // Dynamic array, no dimension
 class TypeDArray : TypeArray
@@ -299,6 +300,9 @@
 			char *id;
 
 			assert(next.deco);
+			version (Bug4054)
+			id = cast(char*) GC.malloc(7 + next.deco.length + 1);
+			else
 			id = cast(char*) alloca(7 + next.deco.length + 1);
 			sprintf(id, "_Array_%.*s", next.deco);
 			s = symbol_calloc(id);
@@ -336,4 +340,4 @@
 		ctype = t;
 		return t;
 	}
-}
\ No newline at end of file
+}
--- a/dmd/Util.d	Wed Mar 31 16:29:36 2010 +0400
+++ b/dmd/Util.d	Sun Apr 04 02:06:32 2010 +0100
@@ -13,19 +13,23 @@
 import std.process : getenv;
 import std.c.string;
 import std.stdio : writef, writefln, write;
-import std.c.process : spawnl, spawnlp;
+version (Windows)
+{
+    import std.c.process : spawnl, spawnlp;
+}
 import core.stdc.stdlib;
 import core.stdc.ctype;
 import core.stdc.stdarg;
 import core.stdc.stdio;
+version (Bug4054) import core.memory;
 
 extern(C) int putenv(char*);
 
 //version = LOG;
 
-version (Windows) {
-} else {
-	import core.sys.posix.stdlib : putenv;
+version (POSIX)
+{
+	import dmd.Gnuc;
 }
 
 enum MAX_PATH = 256; ///
@@ -272,7 +276,12 @@
 							if (l <= tmp.sizeof)
 								p = tmp.ptr;
 							else
+							{
+							version (Bug4054)
+								p = cast(char*)GC.malloc(l);
+							else
 								p = cast(char*)alloca(l);
+							}
 							l--;
 							memcpy(p, &line[k + 1], l);
 							p[l] = 0;
@@ -784,8 +793,8 @@
 		///delete lnkfilename;
     }
     return status;
-} else if (XXX) {/// linux || __APPLE__ || __FreeBSD__ || __sun&&__SVR4
-	assert(false);
+} else version (POSIX) {/// linux || __APPLE__ || __FreeBSD__ || __sun&&__SVR4
+	assert(false, "Unimplemented");
 	/+
     pid_t childpid;
     int i;
@@ -1004,6 +1013,9 @@
 			case 2: envname[0] = '%';	break;
 			default: break;	///
 		}
+		version (Bug4054)
+		q = cast(char*) GC.malloc(envname.sizeof + len + 1);
+		else
 		q = cast(char*) alloca(envname.sizeof + len + 1);
 		sprintf(q, "%s=%s", envname.ptr + 1, args);
 		status = putenv(q);
@@ -1086,4 +1098,4 @@
     static assert(false);
 }
 }
-}
\ No newline at end of file
+}
--- a/dmd/backend/Config.d	Wed Mar 31 16:29:36 2010 +0400
+++ b/dmd/backend/Config.d	Sun Apr 04 02:06:32 2010 +0100
@@ -8,7 +8,7 @@
 	void cod3_set386();
 }
 
-extern (C++) extern
+debug extern (C) /+extern+/
 {
 	__gshared char debuga;		/* cg - watch assignaddr()		*/
 	__gshared char debugb;		/* watch block optimization		*/
@@ -192,7 +192,7 @@
     LINKAGE linkage;	// default function call linkage
 }
 
-extern (C++) extern __gshared Config config;
+extern (C) /+extern+/ __gshared Config config;
 
 enum CVNONE = 0;		// No symbolic info
 ///enum CVOLD = 1;		// Codeview 1 symbolic info
@@ -256,4 +256,4 @@
 enum WFthunk = 0x1000;	// use fixups instead of direct ref to CS
 enum WFsaveds = 0x2000;	// use push/pop DS for far functions
 enum WFdsnedgroup = 0x4000;	// DS != DGROUP
-enum WFexe = 0x8000;	// generating code for Windows EXE
\ No newline at end of file
+enum WFexe = 0x8000;	// generating code for Windows EXE
--- a/dmd/backend/Cstate.d	Wed Mar 31 16:29:36 2010 +0400
+++ b/dmd/backend/Cstate.d	Sun Apr 04 02:06:32 2010 +0100
@@ -18,4 +18,4 @@
     char* modname;		// module unique identifier
 }
 
-extern (C++) extern __gshared Cstate cstate;
\ No newline at end of file
+extern (C++) /+extern+/ __gshared Cstate cstate;
--- a/dmd/backend/OPER.d	Wed Mar 31 16:29:36 2010 +0400
+++ b/dmd/backend/OPER.d	Sun Apr 04 02:06:32 2010 +0100
@@ -282,10 +282,20 @@
 
 enum RELOPMIN = cast(int)OPER.OPle;
 
-extern(C++) extern __gshared const ubyte[OPER.OPMAX] optab1;
-extern(C++) extern __gshared const ubyte[OPER.OPMAX] optab2;
-extern(C++) extern __gshared const ubyte[OPER.OPMAX] optab3;
-extern(C++) extern __gshared const ubyte[OPER.OPMAX] opcost;
+version (Windows)
+{
+	extern(C++) extern __gshared const ubyte[OPER.OPMAX] optab1;
+	extern(C++) extern __gshared const ubyte[OPER.OPMAX] optab2;
+	extern(C++) extern __gshared const ubyte[OPER.OPMAX] optab3;
+	extern(C++) extern __gshared const ubyte[OPER.OPMAX] opcost;
+}
+else
+{
+	extern(C++) __gshared const ubyte[OPER.OPMAX] optab1;
+	extern(C++) __gshared const ubyte[OPER.OPMAX] optab2;
+	extern(C++) __gshared const ubyte[OPER.OPMAX] optab3;
+	extern(C++) __gshared const ubyte[OPER.OPMAX] opcost;
+}
 
 enum _OT
 {
@@ -355,4 +365,4 @@
 +/
 
 import dmd.EnumUtils;
-mixin(BringToCurrentScope!(OPER));
\ No newline at end of file
+mixin(BringToCurrentScope!(OPER));
--- a/dmd/backend/RTLSYM.d	Wed Mar 31 16:29:36 2010 +0400
+++ b/dmd/backend/RTLSYM.d	Sun Apr 04 02:06:32 2010 +0100
@@ -98,4 +98,5 @@
 import dmd.EnumUtils;
 mixin(BringToCurrentScope!(RTLSYM));
 
-extern(C++) extern __gshared Symbol* rtlsym[RTLSYM.RTLSYM_MAX];
\ No newline at end of file
+//extern(C++) extern __gshared Symbol* rtlsym[RTLSYM.RTLSYM_MAX];
+extern(C++) __gshared Symbol* rtlsym[RTLSYM.RTLSYM_MAX];
--- a/dmd/backend/TYFL.d	Wed Mar 31 16:29:36 2010 +0400
+++ b/dmd/backend/TYFL.d	Sun Apr 04 02:06:32 2010 +0100
@@ -121,17 +121,17 @@
 +/
 
 /* Detect function type	*/
-ubyte tyfunc(uint ty) {
+ubyte tyfunc(ulong ty) {
 	return (tytab2[(ty) & 0xFF] & TYFL.TYFLfunc);
 }
 
 /* Detect function type where parameters are pushed in reverse order	*/
-ubyte tyrevfunc(uint ty) {
+ubyte tyrevfunc(ulong ty) {
 	return (tytab2[(ty) & 0xFF] & TYFL.TYFLrevparam);
 }
 
 /* Detect unsigned types */
-ubyte tyuns(uint ty) {
+ubyte tyuns(ulong ty) {
 	return (tytab[(ty) & 0xFF] & (TYFL.TYFLuns | TYFL.TYFLptr));
 }
 
@@ -153,7 +153,7 @@
 /* Array to convert a type to its unsigned equivalent	*/
 extern(C++) extern tym_t* get_tytouns();
 
-tym_t touns(int ty) {
+tym_t touns(ulong ty) {
 	return get_tytouns[ty & 0xFF];
 }
 
@@ -172,4 +172,4 @@
 #ifndef tyrelax
 #define tyrelax(ty)	(_tyrelax[tybasic(ty)])
 #endif
-+/
\ No newline at end of file
++/
--- a/dmd/backend/TYM.d	Wed Mar 31 16:29:36 2010 +0400
+++ b/dmd/backend/TYM.d	Sun Apr 04 02:06:32 2010 +0100
@@ -76,9 +76,9 @@
 ///#endif
 }
 
-extern (C++) extern {
+extern (C++) /+extern+/ {
 	__gshared int TYptrdiff, TYsize, TYsize_t;
 }
 
 import dmd.EnumUtils;
-mixin(BringToCurrentScope!(TYM));
\ No newline at end of file
+mixin(BringToCurrentScope!(TYM));
--- a/dmd/backend/TYPE.d	Wed Mar 31 16:29:36 2010 +0400
+++ b/dmd/backend/TYPE.d	Sun Apr 04 02:06:32 2010 +0100
@@ -97,8 +97,8 @@
 
 alias type* typep_t;
 
-extern(C++) extern __gshared typep_t tstypes[TYM.TYMAX];
-extern(C++) extern __gshared typep_t tsptr2types[TYM.TYMAX];
+extern(C++) /+extern+/ __gshared typep_t tstypes[TYM.TYMAX];
+extern(C++) /+extern+/ __gshared typep_t tsptr2types[TYM.TYMAX];
 
 ref type* tsbool	  () { return tstypes[TYM.TYbool]; }
 ref type* tschar    () { return tstypes[TYM.TYchar]; }
@@ -124,4 +124,4 @@
 ref type* tsildouble () { return tstypes[TYM.TYildouble]; }
 ref type* tscfloat   () { return tstypes[TYM.TYcfloat]; }
 ref type* tscdouble  () { return tstypes[TYM.TYcdouble]; }
-ref type* tscldouble () { return tstypes[TYM.TYcldouble]; }
\ No newline at end of file
+ref type* tscldouble () { return tstypes[TYM.TYcldouble]; }
--- a/dmd/backend/Util.d	Wed Mar 31 16:29:36 2010 +0400
+++ b/dmd/backend/Util.d	Sun Apr 04 02:06:32 2010 +0100
@@ -49,7 +49,8 @@
 	ectorgates = new Array();
 }
 
-alias uint tym_t;		// data type big enough for type masks
+alias size_t tym_t;		// data type big enough for type masks
+//alias ulong tym_t;		// data type big enough for type masks
 alias elem* elem_p;		// data type big enough for type masks
 
 void el_setLoc(elem* e, Loc loc) {
@@ -69,31 +70,76 @@
 }
 ///#define struct_free(st)	((void)(st))
 
+version (Bug4059)
+{
+	private extern (C) {
+		void _Z12obj_initfilePKcS0_S0_(const(char)* filename, const(char)* csegname, const(char)* modname);
+		elem_p _Z6el_binjmP4elemS0_(uint, tym_t, elem_p, elem_p);
+		elem_p _Z7el_pairmP4elemS0_(tym_t, elem_p, elem_p);
+		elem_p _Z10el_combineP4elemS0_(elem_p, elem_p);
+		elem* _Z8el_paramP4elemS0_(elem* e1, elem* e2);
+		Symbol* _Z13symbol_callocPKc(const(char)* id);
+		int _Z9objextdefPKc(const(char)* name);
+		void _Z14obj_includelibPKc(const(char)* name);
+		Symbol* _Z11symbol_namePKciP4TYPE(const(char)* name, int sclass, type* t);
+		dt_t ** _Z8dtnbytesPP4dt_tmPKc(dt_t** pdtend, targ_size_t size, const(char)* ptr);
+		dt_t** _Z8dtabytesPP4dt_tmmmPKc(dt_t** pdtend, tym_t ty, targ_size_t offset, targ_size_t size, const(char)* ptr);
+		type* _Z10type_settyPP4TYPEl(type**, long);
+
+		void _Z10cod3_thunkP6SymbolS0_jmmim(Symbol* sthunk, Symbol* sfunc, uint p, tym_t thisty, targ_size_t d, int i, targ_size_t d2);
+	}
+	void obj_initfile(const(char)* filename, const(char)* csegname, const(char)* modname) { return _Z12obj_initfilePKcS0_S0_(filename, csegname, modname); }
+	elem_p el_bin(uint a, tym_t b, elem_p c, elem_p d) { return _Z6el_binjmP4elemS0_(a, b, c, d);  }
+	elem_p el_pair(tym_t a, elem_p b, elem_p c) { return _Z7el_pairmP4elemS0_(a, b, c); }
+	elem_p el_combine(elem_p a, elem_p b) { return _Z10el_combineP4elemS0_(a, b); }
+	elem* el_param(elem* e1, elem* e2) { return _Z8el_paramP4elemS0_(e1, e2); }
+	Symbol* symbol_calloc(const(char)* id) { return _Z13symbol_callocPKc(id); }
+	int objextdef(const(char)* name) { return _Z9objextdefPKc(name); }
+	void obj_includelib(const(char)* name) { return _Z14obj_includelibPKc(name); }
+	Symbol* symbol_name(const(char)* name, int sclass, type* t) { return _Z11symbol_namePKciP4TYPE(name, sclass, t); }
+	dt_t ** dtnbytes(dt_t** pdtend, targ_size_t size, const(char)* ptr) { return _Z8dtnbytesPP4dt_tmPKc(pdtend, size, ptr); }
+	dt_t** dtabytes(dt_t** pdtend, tym_t ty, targ_size_t offset, targ_size_t size, const(char)* ptr) { return _Z8dtabytesPP4dt_tmmmPKc(pdtend, ty, offset, size, ptr); }
+	type* type_setty(type** a, long b) { return _Z10type_settyPP4TYPEl(a, b); }
+
+	void cod3_thunk(Symbol* sthunk, Symbol* sfunc, uint p, tym_t thisty, targ_size_t d, int i, targ_size_t d2) { return _Z10cod3_thunkP6SymbolS0_jmmim(sthunk, sfunc, p, thisty, d, i, d2); }
+}
+else
+{
+	extern (C++) {
+		void obj_initfile(const(char)* filename, const(char)* csegname, const(char)* modname);
+		dt_t ** dtnbytes(dt_t** pdtend, targ_size_t size, const(char)* ptr);
+		elem_p el_bin(uint, tym_t, elem_p, elem_p);
+		elem_p el_pair(tym_t, elem_p, elem_p);
+		elem_p el_combine(elem_p, elem_p);
+		elem* el_param(elem* e1, elem* e2);
+		Symbol* symbol_calloc(const(char)* id);
+		int objextdef(const(char)* name);
+		void obj_includelib(const(char)* name);
+		Symbol* symbol_name(const(char)* name, int sclass, type* t);
+		dt_t** dtabytes(dt_t** pdtend, tym_t ty, targ_size_t offset, targ_size_t size, const(char)* ptr);
+		type* type_setty(type**, long);
+	
+		void cod3_thunk(Symbol* sthunk, Symbol* sfunc, uint p, tym_t thisty, targ_size_t d, int i, targ_size_t d2);
+	}
+}
+
 extern (C++) {
+//__gshared:
 	void* mem_fcalloc(uint numbytes);
-	void obj_initfile(const(char)* filename, const(char)* csegname, const(char)* modname);
-	Symbol* symbol_calloc(const(char)* id);
 	type* type_fake(tym_t);
 	dt_t** dtnzeros(dt_t** pdtend, targ_size_t size);
 	void outdata(Symbol* s);
 	int reftoident(int seg, targ_size_t offset, Symbol* s, targ_size_t val, int flags);
-	dt_t ** dtnbytes(dt_t** pdtend, targ_size_t size, const(char)* ptr);
 	type* type_alloc(tym_t ty);
 	elem_p el_params(elem_p, ...);
 	elem_p el_ptr(Symbol*);
 	elem_p el_long(tym_t, targ_long);
-	elem_p el_bin(uint, tym_t, elem_p, elem_p);
 	elem_p el_var(Symbol*);
-	elem_p el_combine(elem_p, elem_p);
 	block* block_calloc();
 	void writefunc(Symbol* sfunc);
 	void obj_termfile();
-	int objextdef(const(char)* name);
-	void obj_includelib(const(char)* name);
 	SYMIDX symbol_add(Symbol* s);
-	elem* el_param(elem* e1, elem* e2);
-	elem* el_una(uint op, tym_t ty, elem* e1);
-	Symbol* symbol_name(const(char)* name, int sclass, type* t);
+	elem_p el_una(uint op, tym_t ty, elem_p e1);
 	type* type_setcv(type** pt, tym_t cv);
 	int type_jparam(type* t);
 	void obj_export(Symbol* s, uint argsize);
@@ -105,7 +151,6 @@
 	void block_next(Blockx* bctx, BC bc, block* bn);
 	dt_t** dtxoff(dt_t** pdtend, Symbol* s,targ_size_t offset, tym_t ty);
 	dt_t** dtdword(dt_t** pdtend, int value);
-	dt_t** dtabytes(dt_t** pdtend, tym_t ty, targ_size_t offset, targ_size_t size, const(char)* ptr);
 	void obj_moduleinfo(Symbol* scc);
 	Symbol* symbol_genauto(TYPE* t);
 	elem* el_same(elem**);
@@ -113,12 +158,10 @@
 	Symbol* symbol_generate(int sclass, type* t);
 	elem* el_calloc();
 	void dt_optimize(dt_t* dt);
-	type* type_setty(type**, int);
 	type* type_setmangle(type** pt, mangle_t mangle);
 	list_t list_append(list_t* plist, void* ptr);
 	dt_t** dtcat(dt_t** pdtend, dt_t* dt);
 	elem_p el_copytree(elem_p);
-	elem_p el_pair(tym_t, elem_p, elem_p);
 	int el_allbits(elem *e, int bit);
 	block* block_goto(Blockx* bctx, BC bc, block* bn);
 	block* block_calloc(Blockx* blx);
@@ -129,10 +172,9 @@
 	elem* el_const(tym_t, eve*);
 	elem *el_params(void** args, int length);
 	
-	void cod3_thunk(Symbol* sthunk, Symbol* sfunc, uint p, tym_t thisty, targ_size_t d, int i, targ_size_t d2);
 	
 	version (SEH) {
 		void nteh_declarvars(Blockx* bx);
 		elem* nteh_setScopeTableIndex(Blockx* blx, int scope_index);
 	}
-}
\ No newline at end of file
+}
--- a/dmd/backend/glue.d	Wed Mar 31 16:29:36 2010 +0400
+++ b/dmd/backend/glue.d	Sun Apr 04 02:06:32 2010 +0100
@@ -20,7 +20,7 @@
 
 __gshared Array obj_symbols_towrite;
 
-extern (C++) extern
+extern (C++) /+extern+/
 {
 	__gshared Outbuffer objbuf;
 	int go_flag(char* cp);
@@ -127,8 +127,9 @@
 version (_WIN32) {
 		*cast(ushort*)p = cast(short)v;
 } else {
-		p[0] = v;
-		p[1] = v >> 8;
+                assert(0, "Check this");
+		p[0] = cast(ubyte)v;
+		p[1] = cast(ubyte)(v >> 8);
 }
 		p += 2;
     }
@@ -271,6 +272,16 @@
     obj_symbols_towrite.push(cast(void*)s);
 }
 
+version (Bug4059)
+{
+	private extern (C) void _Z8obj_initP9OutbufferPKcS2_(Outbuffer* objbuf, const(char)* filename, const(char)* csegname);
+	void obj_init(Outbuffer* objbuf, const(char)* filename, const(char)* csegname) { return _Z8obj_initP9OutbufferPKcS2_(objbuf, filename, csegname); }
+}
+else
+{
+	void obj_init(Outbuffer* objbuf, const(char)* filename, const(char)* csegname);	
+}
+
 extern (C++) {
 	void backend_init();
 	void backend_term();
@@ -280,7 +291,6 @@
 	void el_reset();
 	void cg87_reset();
 	void out_reset();
-	void obj_init(Outbuffer* objbuf, const(char)* filename, const(char)* csegname);
 }
 
 void clearStringTab()
@@ -549,4 +559,4 @@
     debugx = params.debugx;
     debugy = params.debugy;
 }
-}
\ No newline at end of file
+}
--- a/dmd/backend/iasm.d	Wed Mar 31 16:29:36 2010 +0400
+++ b/dmd/backend/iasm.d	Sun Apr 04 02:06:32 2010 +0100
@@ -77,16 +77,25 @@
 	"word".ptr,
 ];
 
-extern (Pascal) extern {
-	code* cat(code* c1 , code* c2 );
+extern (C) code * cat(code *c1,code *c2);
+
+version (Bug4059)
+{
+	private extern(C) OP* _Z13asm_op_lookupPKc(const(char)* s);
+	private extern(C) int _Z6binaryPKcPS0_i(const(char)* p , const(char)** tab, int high);
+	OP* asm_op_lookup(const(char)* s) { return _Z13asm_op_lookupPKc(s); }
+	int binary(const(char)* p , const(char)** tab, int high) { return _Z6binaryPKcPS0_i(p, tab, high); }
 }
-
-extern (C++) extern 
+else
+{
+	OP* asm_op_lookup(const(char)* s);
+	int binary(const(char)* p , const(char)** tab, int high);
+}
+
+extern (C++) //extern 
 {
 	void init_optab();
-	OP* asm_op_lookup(const(char)* s);
 	const(char)* asm_opstr(OP* pop);
-	int binary(const(char)* p , const(char)** tab, int high);
 }
 
 static ubyte asm_TKlbra_seen = false;
@@ -4432,4 +4441,4 @@
 	return(szReg.length == 2 && (szReg[0] == 's' || szReg[0] == 'S') &&
 		(szReg[1] == 't' || szReg[1] == 'T'));
 }
-}
\ No newline at end of file
+}
--- a/dmd/backend/mTY.d	Wed Mar 31 16:29:36 2010 +0400
+++ b/dmd/backend/mTY.d	Sun Apr 04 02:06:32 2010 +0100
@@ -38,6 +38,6 @@
 import dmd.EnumUtils;
 mixin(BringToCurrentScope!(mTY));
 
-uint tybasic(uint ty) {
+uint tybasic(ulong ty) {
 	return ((ty) & mTY.mTYbasic);
-}
\ No newline at end of file
+}
--- a/main.d	Wed Mar 31 16:29:36 2010 +0400
+++ b/main.d	Sun Apr 04 02:06:32 2010 +0100
@@ -57,8 +57,12 @@
 
 shared bool _d_isHalting = false;
 
-import win32.windows;
-
+version (Windows)
+{
+   import win32.windows;
+}
+/* Link to druntimes main() */
+/+
 extern (C) int main(int argc, char **argv)
 {
     char[][] args;
@@ -141,7 +145,7 @@
 
     return result;
 }
-
++/
 int main(string[] args)
 {
     Array files = new Array();
@@ -179,7 +183,7 @@
 
 version (TARGET_WINDOS) {
     global.params.defaultlibname = "phobos";
-} else version (XXX) { //#elif TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_SOLARIS
+} else version (POSIX) { //#elif TARGET_LINUX || TARGET_OSX || TARGET_FREEBSD || TARGET_SOLARIS
     global.params.defaultlibname = "phobos2";
 } else version (TARGET_NET) {
 } else {
@@ -228,8 +232,8 @@
 
 version (_WIN32) {
     inifile(args[0], "sc.ini");
-} else version (XXX) {///linux || __APPLE__ || __FreeBSD__ || __sun&&__SVR4
-    inifile(argv[0], "dmd.conf");
+} else version (POSIX) {///linux || __APPLE__ || __FreeBSD__ || __sun&&__SVR4
+    inifile(args[0], "dmd.conf");
 } else {
         static assert (false, "fix this");
 }
@@ -1102,4 +1106,4 @@
     }
 
     return status;
-}
\ No newline at end of file
+}