@zigc/lib 0.16.0-test.1 → 0.17.0-dev.9

package/std/zig/llvm/Builder.zig

@@ -2343,12 +2343,13 @@ pub const Global = struct {
         none = maxInt(u32),
         _,
 
-        pub fn unwrap(self: Index, builder: *const Builder) Index {
-            var cur = self;
+        pub fn unwrap(orig_index: Index, builder: *const Builder) Index {
+            var cur = orig_index;
             while (true) {
-                const replacement = cur.getReplacement(builder);
-                if (replacement == .none) return cur;
-                cur = replacement;
+                switch (builder.globals.values()[@intFromEnum(cur)].kind) {
+                    .replaced => |replacement| cur = replacement,
+                    else => return cur,
+                }
             }
         }
 
@@ -2388,8 +2389,12 @@ pub const Global = struct {
             return self.ptrConst(builder).type;
         }
 
-        pub fn toConst(self: Index) Constant {
-            return @enumFromInt(@intFromEnum(Constant.first_global) + @intFromEnum(self));
+        pub fn toConst(global: Index) Constant {
+            return @enumFromInt(@intFromEnum(Constant.first_global) + @intFromEnum(global));
+        }
+
+        pub fn toValue(global: Index) Value {
+            return global.toConst().toValue();
         }
 
         pub fn setLinkage(self: Index, linkage: Linkage, builder: *Builder) void {
@@ -2450,6 +2455,42 @@ pub const Global = struct {
             self.ptr(builder).kind = .{ .replaced = .none };
         }
 
+        /// Replaces whatever this `Global` currently contains with a new `Function`. Similar to
+        /// `Builder.addFunction`, but the same `Global` is reused.
+        pub fn toNewFunction(global: Index, builder: *Builder) Allocator.Error!Function.Index {
+            try builder.functions.ensureUnusedCapacity(builder.gpa, 1);
+            errdefer comptime unreachable;
+            const function: Function.Index = @enumFromInt(builder.functions.items.len);
+            builder.functions.appendAssumeCapacity(.{
+                .global = global,
+                .strip = undefined,
+            });
+            global.ptr(builder).kind = .{ .function = function };
+            return function;
+        }
+
+        /// Replaces whatever this `Global` currently contains with a new `Variable`. Similar to
+        /// `Builder.addVariable`, but the same `Global` is reused.
+        pub fn toNewVariable(global: Index, builder: *Builder) Allocator.Error!Variable.Index {
+            try builder.variables.ensureUnusedCapacity(builder.gpa, 1);
+            errdefer comptime unreachable;
+            const variable: Variable.Index = @enumFromInt(builder.variables.items.len);
+            builder.variables.appendAssumeCapacity(.{ .global = global });
+            global.ptr(builder).kind = .{ .variable = variable };
+            return variable;
+        }
+
+        /// Replaces whatever this `Global` currently contains with a new `Alias`. Similar to
+        /// `Builder.addAlias`, but the same `Global` is reused.
+        pub fn toNewAlias(global: Index, builder: *Builder) Allocator.Error!Alias.Index {
+            try builder.aliases.ensureUnusedCapacity(builder.gpa, 1);
+            errdefer comptime unreachable;
+            const alias: Alias.Index = @enumFromInt(builder.aliases.items.len);
+            builder.aliass.appendAssumeCapacity(.{ .global = global, .aliasee = .none });
+            global.ptr(builder).kind = .{ .alias = alias };
+            return alias;
+        }
+
         fn updateDsoLocal(self: Index, builder: *Builder) void {
             const self_ptr = self.ptr(builder);
             switch (self_ptr.linkage) {
@@ -2494,13 +2535,6 @@ pub const Global = struct {
             self.renameAssumeCapacity(builder.next_replaced_global, builder);
             self.ptr(builder).kind = .{ .replaced = other.unwrap(builder) };
         }
-
-        fn getReplacement(self: Index, builder: *const Builder) Index {
-            return switch (builder.globals.values()[@intFromEnum(self)].kind) {
-                .replaced => |replacement| replacement,
-                else => .none,
-            };
-        }
     };
 };
 
@@ -2593,22 +2627,6 @@ pub const Variable = struct {
             return self.toConst(builder).toValue();
         }
 
-        pub fn setLinkage(self: Index, linkage: Linkage, builder: *Builder) void {
-            return self.ptrConst(builder).global.setLinkage(linkage, builder);
-        }
-
-        pub fn setVisibility(self: Index, visibility: Visibility, builder: *Builder) void {
-            return self.ptrConst(builder).global.setVisibility(visibility, builder);
-        }
-
-        pub fn setDllStorageClass(self: Index, class: DllStorageClass, builder: *Builder) void {
-            return self.ptrConst(builder).global.setDllStorageClass(class, builder);
-        }
-
-        pub fn setUnnamedAddr(self: Index, unnamed_addr: UnnamedAddr, builder: *Builder) void {
-            return self.ptrConst(builder).global.setUnnamedAddr(unnamed_addr, builder);
-        }
-
         pub fn setThreadLocal(self: Index, thread_local: ThreadLocal, builder: *Builder) void {
             self.ptr(builder).thread_local = thread_local;
         }
@@ -9692,8 +9710,12 @@ pub fn print(self: *Builder, w: *Writer) (Writer.Error || Allocator.Error)!void
 
     if (self.variables.items.len > 0) {
         if (need_newline) try w.writeByte('\n') else need_newline = true;
-        for (self.variables.items) |variable| {
-            if (variable.global.getReplacement(self) != .none) continue;
+        for (self.variables.items, 0..) |variable, variable_i| {
+            // Skip the variable if its global has been repurposed for something else.
+            switch (variable.global.ptrConst(self).kind) {
+                .variable => |v| if (@intFromEnum(v) != variable_i) continue,
+                else => continue,
+            }
             const global = variable.global.ptrConst(self);
             metadata_formatter.need_comma = true;
             defer metadata_formatter.need_comma = undefined;
@@ -9723,8 +9745,12 @@ pub fn print(self: *Builder, w: *Writer) (Writer.Error || Allocator.Error)!void
 
     if (self.aliases.items.len > 0) {
         if (need_newline) try w.writeByte('\n') else need_newline = true;
-        for (self.aliases.items) |alias| {
-            if (alias.global.getReplacement(self) != .none) continue;
+        for (self.aliases.items, 0..) |alias, alias_i| {
+            // Skip the alias if its global has been repurposed for something else.
+            switch (alias.global.ptrConst(self).kind) {
+                .alias => |a| if (@intFromEnum(a) != alias_i) continue,
+                else => continue,
+            }
             const global = alias.global.ptrConst(self);
             metadata_formatter.need_comma = true;
             defer metadata_formatter.need_comma = undefined;
@@ -9750,7 +9776,11 @@ pub fn print(self: *Builder, w: *Writer) (Writer.Error || Allocator.Error)!void
     defer attribute_groups.deinit(self.gpa);
 
     for (0.., self.functions.items) |function_i, function| {
-        if (function.global.getReplacement(self) != .none) continue;
+        // Skip the function if its global has been repurposed for something else.
+        switch (function.global.ptrConst(self).kind) {
+            .function => |f| if (@intFromEnum(f) != function_i) continue,
+            else => continue,
+        }
         if (need_newline) try w.writeByte('\n') else need_newline = true;
         const function_index: Function.Index = @enumFromInt(function_i);
         const global = function.global.ptrConst(self);
@@ -13687,20 +13717,32 @@ pub fn toBitcode(self: *Builder, allocator: Allocator, producer: Producer) bitco
                 self.aliases.items.len,
         );
 
-        for (self.variables.items) |variable| {
-            if (variable.global.getReplacement(self) != .none) continue;
+        for (self.variables.items, 0..) |variable, variable_i| {
+            // Skip the variable if its global has been repurposed for something else.
+            switch (variable.global.ptrConst(self).kind) {
+                .variable => |v| if (@intFromEnum(v) != variable_i) continue,
+                else => continue,
+            }
 
             globals.putAssumeCapacity(variable.global, {});
         }
 
-        for (self.functions.items) |function| {
-            if (function.global.getReplacement(self) != .none) continue;
+        for (self.functions.items, 0..) |function, function_i| {
+            // Skip the function if its global has been repurposed for something else.
+            switch (function.global.ptrConst(self).kind) {
+                .function => |f| if (@intFromEnum(f) != function_i) continue,
+                else => continue,
+            }
 
             globals.putAssumeCapacity(function.global, {});
         }
 
-        for (self.aliases.items) |alias| {
-            if (alias.global.getReplacement(self) != .none) continue;
+        for (self.aliases.items, 0..) |alias, alias_i| {
+            // Skip the alias if its global has been repurposed for something else.
+            switch (alias.global.ptrConst(self).kind) {
+                .alias => |a| if (@intFromEnum(a) != alias_i) continue,
+                else => continue,
+            }
 
             globals.putAssumeCapacity(alias.global, {});
         }
@@ -13742,8 +13784,12 @@ pub fn toBitcode(self: *Builder, allocator: Allocator, producer: Producer) bitco
             defer section_map.deinit(self.gpa);
             try section_map.ensureUnusedCapacity(self.gpa, globals.count());
 
-            for (self.variables.items) |variable| {
-                if (variable.global.getReplacement(self) != .none) continue;
+            for (self.variables.items, 0..) |variable, variable_i| {
+                // Skip the variable if its global has been repurposed for something else.
+                switch (variable.global.ptrConst(self).kind) {
+                    .variable => |v| if (@intFromEnum(v) != variable_i) continue,
+                    else => continue,
+                }
 
                 const section = blk: {
                     if (variable.section == .none) break :blk 0;
@@ -13789,8 +13835,12 @@ pub fn toBitcode(self: *Builder, allocator: Allocator, producer: Producer) bitco
                 });
             }
 
-            for (self.functions.items) |func| {
-                if (func.global.getReplacement(self) != .none) continue;
+            for (self.functions.items, 0..) |func, func_i| {
+                // Skip the function if its global has been repurposed for something else.
+                switch (func.global.ptrConst(self).kind) {
+                    .function => |f| if (@intFromEnum(f) != func_i) continue,
+                    else => continue,
+                }
 
                 const section = blk: {
                     if (func.section == .none) break :blk 0;
@@ -13830,8 +13880,12 @@ pub fn toBitcode(self: *Builder, allocator: Allocator, producer: Producer) bitco
                 });
             }
 
-            for (self.aliases.items) |alias| {
-                if (alias.global.getReplacement(self) != .none) continue;
+            for (self.aliases.items, 0..) |alias, alias_i| {
+                // Skip the alias if its global has been repurposed for something else.
+                switch (alias.global.ptrConst(self).kind) {
+                    .alias => |a| if (@intFromEnum(a) != alias_i) continue,
+                    else => continue,
+                }
 
                 const strtab = alias.global.strtab(self);
 
@@ -14635,8 +14689,13 @@ pub fn toBitcode(self: *Builder, allocator: Allocator, producer: Producer) bitco
             };
 
             for (self.functions.items, 0..) |func, func_index| {
+                // Skip the function if its global has been repurposed for something else.
+                switch (func.global.ptrConst(self).kind) {
+                    .function => |f| if (@intFromEnum(f) != func_index) continue,
+                    else => continue,
+                }
+
                 const FunctionBlock = ir.ModuleBlock.FunctionBlock;
-                if (func.global.getReplacement(self) != .none) continue;
 
                 if (func.instructions.len == 0) continue;
 

package/std/zig/system.zig

@@ -423,6 +423,7 @@ pub fn resolveTargetQuery(io: Io, query: Target.Query) DetectError!Target {
         error.ConnectionResetByPeer => return error.Unexpected,
         error.NotOpenForReading => return error.Unexpected,
         error.SocketUnconnected => return error.Unexpected,
+        error.ReadOnlyFileSystem => return error.Unexpected,
 
         error.AccessDenied,
         error.SymLinkLoop,
@@ -853,6 +854,7 @@ fn glibcVerFromRPath(io: Io, rpath: []const u8) !std.SemanticVersion {
         error.PathAlreadyExists => return error.Unexpected, // read-only
         error.DeviceBusy => return error.Unexpected, // read-only
         error.FileBusy => return error.Unexpected, // read-only
+        error.ReadOnlyFileSystem => return error.Unexpected, // read-only
         error.NoDevice => return error.Unexpected, // not asking for a special device
         error.FileTooBig => return error.Unexpected,
         error.WouldBlock => return error.Unexpected, // not opened in non-blocking
@@ -1183,11 +1185,25 @@ fn detectAndroidApiLevel(io: Io) !u32 {
         return error.ApiLevelQueryFailed;
     };
 
-    const term = try child.wait(io);
-    if (term != .exited or term.exited != 0) {
-        std.log.err("getprop terminated abnormally: {}", .{term});
-        return error.ApiLevelQueryFailed;
+    switch (try child.wait(io)) {
+        .exited => |code| if (code != 0) {
+            std.log.err("getprop terminated abnormally with exit code: {d}", .{code});
+            return error.ApiLevelQueryFailed;
+        },
+        .signal => |sig| {
+            std.log.err("getprop terminated abnormally with signal: {t}", .{sig});
+            return error.ApiLevelQueryFailed;
+        },
+        .stopped => |sig| {
+            std.log.err("getprop stopped abnormally with signal: {t}", .{sig});
+            return error.ApiLevelQueryFailed;
+        },
+        .unknown => {
+            std.log.err("getprop terminated abnormally", .{});
+            return error.ApiLevelQueryFailed;
+        },
     }
+
     return api_level;
 }
 

package/std/zig/tokenizer.zig

@@ -313,7 +313,8 @@ pub const Token = struct {
             return tag.lexeme() orelse switch (tag) {
                 .invalid => "invalid token",
                 .identifier => "an identifier",
-                .string_literal, .multiline_string_literal_line => "a string literal",
+                .string_literal => "a string literal",
+                .multiline_string_literal_line => "a multiline string literal",
                 .char_literal => "a character literal",
                 .eof => "EOF",
                 .builtin => "a builtin function",

package/std/zig.zig

@@ -23,6 +23,7 @@ pub const primitives = @import("zig/primitives.zig");
 pub const isPrimitive = primitives.isPrimitive;
 pub const Ast = @import("zig/Ast.zig");
 pub const AstGen = @import("zig/AstGen.zig");
+pub const AstSmith = @import("zig/AstSmith.zig");
 pub const Zir = @import("zig/Zir.zig");
 pub const Zoir = @import("zig/Zoir.zig");
 pub const ZonGen = @import("zig/ZonGen.zig");
@@ -985,11 +986,14 @@ pub const EmitArtifact = enum {
     docs,
     pdb,
     h,
+    compiler_rt_dyn_lib,
 
     /// If using `Server` to communicate with the compiler, it will place requested artifacts in
     /// paths under the output directory, where those paths are named according to this function.
     /// Returned string is allocated with `gpa` and owned by the caller.
     pub fn cacheName(ea: EmitArtifact, gpa: Allocator, opts: BinNameOptions) Allocator.Error![]const u8 {
+        // hack for stage2_x86_64 + coff. See Coff.flush.
+        if (ea == .compiler_rt_dyn_lib) return "compiler_rt.dll";
         const suffix: []const u8 = switch (ea) {
             .bin => return binNameAlloc(gpa, opts),
             .@"asm" => ".s",
@@ -999,6 +1003,7 @@ pub const EmitArtifact = enum {
             .docs => "-docs",
             .pdb => ".pdb",
             .h => ".h",
+            .compiler_rt_dyn_lib => unreachable,
         };
         return std.fmt.allocPrint(gpa, "{s}{s}", .{ opts.root_name, suffix });
     }
@@ -1166,6 +1171,7 @@ pub const ClangCliParam = struct {
 test {
     _ = Ast;
     _ = AstRlAnnotate;
+    _ = AstSmith;
     _ = BuiltinFn;
     _ = Client;
     _ = ErrorBundle;

package/compiler/aro/aro/Driver/Filesystem.zig

@@ -1,241 +0,0 @@
-const builtin = @import("builtin");
-const is_windows = builtin.os.tag == .windows;
-
-const std = @import("std");
-const Io = std.Io;
-const mem = std.std.mem;
-
-fn readFileFake(entries: []const Filesystem.Entry, path: []const u8, buf: []u8) ?[]const u8 {
-    @branchHint(.cold);
-    for (entries) |entry| {
-        if (mem.eql(u8, entry.path, path)) {
-            const len = @min(entry.contents.len, buf.len);
-            @memcpy(buf[0..len], entry.contents[0..len]);
-            return buf[0..len];
-        }
-    }
-    return null;
-}
-
-fn findProgramByNameFake(entries: []const Filesystem.Entry, name: []const u8, path: ?[]const u8, buf: []u8) ?[]const u8 {
-    @branchHint(.cold);
-    if (mem.indexOfScalar(u8, name, '/') != null) {
-        @memcpy(buf[0..name.len], name);
-        return buf[0..name.len];
-    }
-    const path_env = path orelse return null;
-    var fib = std.heap.FixedBufferAllocator.init(buf);
-
-    var it = mem.tokenizeScalar(u8, path_env, std.fs.path.delimiter);
-    while (it.next()) |path_dir| {
-        defer fib.reset();
-        const full_path = std.fs.path.join(fib.allocator(), &.{ path_dir, name }) catch continue;
-        if (canExecuteFake(entries, full_path)) return full_path;
-    }
-
-    return null;
-}
-
-fn canExecuteFake(entries: []const Filesystem.Entry, path: []const u8) bool {
-    @branchHint(.cold);
-    for (entries) |entry| {
-        if (mem.eql(u8, entry.path, path)) {
-            return entry.executable;
-        }
-    }
-    return false;
-}
-
-fn existsFake(entries: []const Filesystem.Entry, path: []const u8) bool {
-    @branchHint(.cold);
-    var buf: [std.fs.max_path_bytes]u8 = undefined;
-    var fib = std.heap.FixedBufferAllocator.init(&buf);
-    const resolved = std.fs.path.resolvePosix(fib.allocator(), &.{path}) catch return false;
-    for (entries) |entry| {
-        if (mem.eql(u8, entry.path, resolved)) return true;
-    }
-    return false;
-}
-
-fn canExecutePosix(io: Io, path: []const u8) bool {
-    Io.Dir.accessAbsolute(io, path, .{ .execute = true }) catch return false;
-    // Todo: ensure path is not a directory
-    return true;
-}
-
-/// TODO
-fn canExecuteWindows(path: []const u8) bool {
-    _ = path;
-    return true;
-}
-
-/// TODO
-fn findProgramByNameWindows(allocator: std.mem.Allocator, name: []const u8, path: ?[]const u8, buf: []u8) ?[]const u8 {
-    _ = path;
-    _ = buf;
-    _ = name;
-    _ = allocator;
-    return null;
-}
-
-/// TODO: does WASI need special handling?
-fn findProgramByNamePosix(name: []const u8, path: ?[]const u8, buf: []u8) ?[]const u8 {
-    if (mem.indexOfScalar(u8, name, '/') != null) {
-        @memcpy(buf[0..name.len], name);
-        return buf[0..name.len];
-    }
-    const path_env = path orelse return null;
-    var fib = std.heap.FixedBufferAllocator.init(buf);
-
-    var it = mem.tokenizeScalar(u8, path_env, std.fs.path.delimiter);
-    while (it.next()) |path_dir| {
-        defer fib.reset();
-        const full_path = std.fs.path.join(fib.allocator(), &.{ path_dir, name }) catch continue;
-        if (canExecutePosix(full_path)) return full_path;
-    }
-
-    return null;
-}
-
-pub const Filesystem = union(enum) {
-    real: std.Io.Dir,
-    fake: []const Entry,
-
-    const Entry = struct {
-        path: []const u8,
-        contents: []const u8 = "",
-        executable: bool = false,
-    };
-
-    const FakeDir = struct {
-        entries: []const Entry,
-        path: []const u8,
-
-        fn iterate(self: FakeDir) FakeDir.Iterator {
-            return .{
-                .entries = self.entries,
-                .base = self.path,
-            };
-        }
-
-        const Iterator = struct {
-            entries: []const Entry,
-            base: []const u8,
-            i: usize = 0,
-
-            fn next(self: *@This()) !?std.Io.Dir.Entry {
-                while (self.i < self.entries.len) {
-                    const entry = self.entries[self.i];
-                    self.i += 1;
-                    if (entry.path.len == self.base.len) continue;
-                    if (std.mem.startsWith(u8, entry.path, self.base)) {
-                        const remaining = entry.path[self.base.len + 1 ..];
-                        if (std.mem.indexOfScalar(u8, remaining, std.fs.path.sep) != null) continue;
-                        const extension = std.fs.path.extension(remaining);
-                        const kind: std.Io.Dir.Entry.Kind = if (extension.len == 0) .directory else .file;
-                        return .{ .name = remaining, .kind = kind };
-                    }
-                }
-                return null;
-            }
-        };
-    };
-
-    const Dir = union(enum) {
-        dir: std.Io.Dir,
-        fake: FakeDir,
-
-        pub fn iterate(self: Dir) Iterator {
-            return switch (self) {
-                .dir => |dir| .{ .iterator = dir.iterate() },
-                .fake => |fake| .{ .fake = fake.iterate() },
-            };
-        }
-
-        pub fn close(self: *Dir, io: Io) void {
-            switch (self.*) {
-                .dir => |*d| d.close(io),
-                .fake => {},
-            }
-        }
-    };
-
-    const Iterator = union(enum) {
-        iterator: std.Io.Dir.Iterator,
-        fake: FakeDir.Iterator,
-
-        pub fn next(self: *Iterator) std.Io.Dir.Iterator.Error!?std.Io.Dir.Entry {
-            return switch (self.*) {
-                .iterator => |*it| it.next(),
-                .fake => |*it| it.next(),
-            };
-        }
-    };
-
-    pub fn exists(fs: Filesystem, io: Io, path: []const u8) bool {
-        switch (fs) {
-            .real => |cwd| {
-                cwd.access(io, path, .{}) catch return false;
-                return true;
-            },
-            .fake => |paths| return existsFake(paths, path),
-        }
-    }
-
-    pub fn joinedExists(fs: Filesystem, parts: []const []const u8) bool {
-        var buf: [std.fs.max_path_bytes]u8 = undefined;
-        var fib = std.heap.FixedBufferAllocator.init(&buf);
-        const joined = std.fs.path.join(fib.allocator(), parts) catch return false;
-        return fs.exists(joined);
-    }
-
-    pub fn canExecute(fs: Filesystem, path: []const u8) bool {
-        return switch (fs) {
-            .real => if (is_windows) canExecuteWindows(path) else canExecutePosix(path),
-            .fake => |entries| canExecuteFake(entries, path),
-        };
-    }
-
-    /// Search for an executable named `name` using platform-specific logic
-    /// If it's found, write the full path to `buf` and return a slice of it
-    /// Otherwise retun null
-    pub fn findProgramByName(fs: Filesystem, allocator: std.mem.Allocator, name: []const u8, path: ?[]const u8, buf: []u8) ?[]const u8 {
-        std.debug.assert(name.len > 0);
-        return switch (fs) {
-            .real => if (is_windows) findProgramByNameWindows(allocator, name, path, buf) else findProgramByNamePosix(name, path, buf),
-            .fake => |entries| findProgramByNameFake(entries, name, path, buf),
-        };
-    }
-
-    /// Read the file at `path` into `buf`.
-    /// Returns null if any errors are encountered
-    /// Otherwise returns a slice of `buf`. If the file is larger than `buf` partial contents are returned
-    pub fn readFile(fs: Filesystem, io: Io, path: []const u8, buf: []u8) ?[]const u8 {
-        return switch (fs) {
-            .real => |cwd| {
-                const file = cwd.openFile(io, path, .{}) catch return null;
-                defer file.close(io);
-
-                const bytes_read = file.readAll(buf) catch return null;
-                return buf[0..bytes_read];
-            },
-            .fake => |entries| readFileFake(entries, path, buf),
-        };
-    }
-
-    pub fn openDir(fs: Filesystem, io: Io, dir_name: []const u8) std.Io.Dir.OpenError!Dir {
-        return switch (fs) {
-            .real => |cwd| .{ .dir = try cwd.openDir(io, dir_name, .{ .access_sub_paths = false, .iterate = true }) },
-            .fake => |entries| .{ .fake = .{ .entries = entries, .path = dir_name } },
-        };
-    }
-};
-
-test "Fake filesystem" {
-    const fs: Filesystem = .{ .fake = &.{
-        .{ .path = "/usr/bin" },
-    } };
-    try std.testing.expect(fs.exists("/usr/bin"));
-    try std.testing.expect(fs.exists("/usr/bin/foo/.."));
-    try std.testing.expect(!fs.exists("/usr/bin/bar"));
-}

package/libc/mingw/complex/cabs.c

@@ -1,48 +0,0 @@
-/*
- This Software is provided under the Zope Public License (ZPL) Version 2.1.
-
- Copyright (c) 2009, 2010 by the mingw-w64 project
-
- See the AUTHORS file for the list of contributors to the mingw-w64 project.
-
- This license has been certified as open source. It has also been designated
- as GPL compatible by the Free Software Foundation (FSF).
-
- Redistribution and use in source and binary forms, with or without
- modification, are permitted provided that the following conditions are met:
-
-   1. Redistributions in source code must retain the accompanying copyright
-      notice, this list of conditions, and the following disclaimer.
-   2. Redistributions in binary form must reproduce the accompanying
-      copyright notice, this list of conditions, and the following disclaimer
-      in the documentation and/or other materials provided with the
-      distribution.
-   3. Names of the copyright holders must not be used to endorse or promote
-      products derived from this software without prior written permission
-      from the copyright holders.
-   4. The right to distribute this software or to use it for any purpose does
-      not give you the right to use Servicemarks (sm) or Trademarks (tm) of
-      the copyright holders.  Use of them is covered by separate agreement
-      with the copyright holders.
-   5. If any files are modified, you must cause the modified files to carry
-      prominent notices stating that you changed the files and the date of
-      any change.
-
- Disclaimer
-
- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY EXPRESSED
- OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
- OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
- EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY DIRECT, INDIRECT,
- INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, 
- OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
- EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-*/
-
-/* double version of the functions.  */
-#define  _NEW_COMPLEX_DOUBLE 1
-#include "complex_internal.h"
-#include "cabs.def.h"