# HG changeset patch # User Robert Clipsham # Date 1270343192 -3600 # Node ID 2cc60413963607d06abe8fe1446c53dd3267b480 # Parent 3356c90e9aacd4c97e8afb03651a8391a4e6b90d 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. diff -r 3356c90e9aac -r 2cc604139636 .hgignore --- 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/ diff -r 3356c90e9aac -r 2cc604139636 bin/dmd.conf --- /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 diff -r 3356c90e9aac -r 2cc604139636 bridge/bridge.cpp --- 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 +} diff -r 3356c90e9aac -r 2cc604139636 build.sh --- /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 diff -r 3356c90e9aac -r 2cc604139636 commands.linux.txt --- /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 diff -r 3356c90e9aac -r 2cc604139636 dbg/ui/CrashWindow.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); diff -r 3356c90e9aac -r 2cc604139636 dlib/CrashHandler.d --- 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) diff -r 3356c90e9aac -r 2cc604139636 dmd/Declaration.d --- 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 +} diff -r 3356c90e9aac -r 2cc604139636 dmd/Dsymbol.d --- 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 +} diff -r 3356c90e9aac -r 2cc604139636 dmd/File.d --- 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 +} diff -r 3356c90e9aac -r 2cc604139636 dmd/FileName.d --- 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 +} diff -r 3356c90e9aac -r 2cc604139636 dmd/FuncDeclaration.d --- 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 +} diff -r 3356c90e9aac -r 2cc604139636 dmd/Global.d --- 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; diff -r 3356c90e9aac -r 2cc604139636 dmd/Gnuc.d --- /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; +} diff -r 3356c90e9aac -r 2cc604139636 dmd/Library.d --- 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); + } + +} +} diff -r 3356c90e9aac -r 2cc604139636 dmd/MOD.d --- 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)); diff -r 3356c90e9aac -r 2cc604139636 dmd/Module.d --- 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 +} diff -r 3356c90e9aac -r 2cc604139636 dmd/Type.d --- 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 +} diff -r 3356c90e9aac -r 2cc604139636 dmd/TypeAArray.d --- 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 +} diff -r 3356c90e9aac -r 2cc604139636 dmd/TypeDArray.d --- 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 +} diff -r 3356c90e9aac -r 2cc604139636 dmd/Util.d --- 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 +} diff -r 3356c90e9aac -r 2cc604139636 dmd/backend/Config.d --- 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 diff -r 3356c90e9aac -r 2cc604139636 dmd/backend/Cstate.d --- 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; diff -r 3356c90e9aac -r 2cc604139636 dmd/backend/OPER.d --- 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)); diff -r 3356c90e9aac -r 2cc604139636 dmd/backend/RTLSYM.d --- 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]; diff -r 3356c90e9aac -r 2cc604139636 dmd/backend/TYFL.d --- 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 ++/ diff -r 3356c90e9aac -r 2cc604139636 dmd/backend/TYM.d --- 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)); diff -r 3356c90e9aac -r 2cc604139636 dmd/backend/TYPE.d --- 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]; } diff -r 3356c90e9aac -r 2cc604139636 dmd/backend/Util.d --- 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 +} diff -r 3356c90e9aac -r 2cc604139636 dmd/backend/glue.d --- 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 +} diff -r 3356c90e9aac -r 2cc604139636 dmd/backend/iasm.d --- 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 +} diff -r 3356c90e9aac -r 2cc604139636 dmd/backend/mTY.d --- 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 +} diff -r 3356c90e9aac -r 2cc604139636 main.d --- 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 +}