diff --git a/programming/build/component.xml b/programming/build/component.xml new file mode 100644 index 0000000000..678f939048 --- /dev/null +++ b/programming/build/component.xml @@ -0,0 +1,3 @@ + + programming.build + diff --git a/programming/build/llvm/actions.py b/programming/build/llvm/actions.py new file mode 100644 index 0000000000..bf18e2bfc9 --- /dev/null +++ b/programming/build/llvm/actions.py @@ -0,0 +1,114 @@ + +# -*- coding: utf-8 -*- +# +# Licensed under the GNU General Public License, version 3. +# See the file http://www.gnu.org/licenses/gpl.txt + +from pisi.actionsapi import autotools +from pisi.actionsapi import pisitools +from pisi.actionsapi import shelltools +from pisi.actionsapi import pkgconfig +from pisi.actionsapi import get +from pisi.actionsapi import kde4 + +#WorkDir = "%s-%s.src" % (get.srcNAME(), get.srcVERSION()) +libdir = "/usr/lib32/llvm" if get.buildTYPE() == "emul32" else "/usr/lib/llvm" +lib = "lib32" if get.buildTYPE() == "emul32" else "lib" + +def setup(): + if not shelltools.isDirectory("tools/clang"): + pisitools.dosed("tools/cfe-3.5.0.src/lib/Driver/ToolChains.cpp", '"ld"', '"ld.gold"') + shelltools.move("tools/cfe-%s.src" % get.srcVERSION(), "tools/clang") + shelltools.move("tools/clang-tools-extra-*", "tools/clang/extra") + if not shelltools.isDirectory("projects/compiler-rt"): + shelltools.move("projects/compiler-rt-3.5*", "projects/compiler-rt") + + pisitools.dosed("utils/llvm-build/llvm-build", "python", "python2.7") + pisitools.dosed("bindings/ocaml/Makefile.ocaml", '\$\(PROJ_libdir\)', libdir) + pisitools.dosed("Makefile.config.in", "\$\(PROJ_prefix\)/etc/llvm", "/etc/llvm") + pisitools.dosed("Makefile.config.in", "\$\(PROJ_prefix\)/lib", "$(PROJ_prefix)/%s/llvm" % lib) + pisitools.dosed("Makefile.config.in", "\$\(PROJ_prefix\)/docs/llvm", "$(PROJ_prefix)/share/doc/llvm") + pisitools.dosed("tools/llvm-config/llvm-config.cpp", '(ActiveLibDir\s=\sActivePrefix\s\+\s\"\/lib)(.*)', r'\1/llvm\2') + pisitools.dosed("autoconf/configure.ac", '\LLVM_LIBDIR="\$\{prefix\}/lib"', 'LLVM_LIBDIR="${prefix}/%s/llvm"' % lib) + + pisitools.dosed("Makefile.rules", "\$\(RPATH\)\s-Wl,\$\(ExmplDir\)\s\$\(DynamicFlag\)", "$(DynamicFlag)") + pisitools.dosed("Makefile.rules", "\$\(RPATH\)\s-Wl,\$\(ToolDir\)\s\$\(DynamicFlag\)", "$(DynamicFlag)") + + shelltools.export("CPPFLAGS","%s %s" % (get.CXXFLAGS(),pkgconfig.getLibraryCFLAGS("libffi"))) + + #pic_option = "enable" if get.ARCH() == "x86_64" else "disable" + shelltools.export("CC", "gcc") + shelltools.export("CXX", "g++") + + options = "--libdir=%s \ + --datadir=/usr/share/llvm \ + --sysconfdir=/etc \ + --enable-shared \ + --enable-libffi \ + --enable-targets=all \ + --disable-expensive-checks \ + --disable-debug-runtime \ + --disable-assertions \ + --disable-assertions \ + --with-python=/usr/bin/python2.7 \ + --with-binutils-include=/usr/include \ + " % libdir + + autotools.configure(options) + + +#def check(): +# autotools.make("check") +# autotools.make("-C tools/clang test") + +def build(): + autotools.make("REQUIRES_RTTI=1") + +def install(): + if get.buildTYPE() == "emul32": + + autotools.rawInstall("DESTDIR=%s \ + PROJ_etcdir=/etc/llvm \ + PROJ_libdir=/usr/lib32/llvm \ + PROJ_docsdir=/%s/llvm" + % (get.installDIR(), get.docDIR())) + shelltools.chmod("%s/usr/lib32/llvm/*.a" % get.installDIR(), mode = 0644) + pisitools.dosym("llvm/LLVMgold.so", "/usr/lib32/LLVMgold.so") + pisitools.remove("/usr/lib32/llvm/*LLVMHello.*") + return + else: + autotools.rawInstall("DESTDIR=%s \ + PROJ_etcdir=/etc/llvm \ + PROJ_libdir=%s \ + PROJ_docsdir=/%s/llvm" + % (get.installDIR(), libdir, get.docDIR())) + + + shelltools.chmod("%s/usr/lib/llvm/*.a" % get.installDIR(), 0644) + + # Install static analyzers which aren't installed by default + for exe in ("scan-build", "scan-view"): + pisitools.insinto("/usr/lib/clang-analyzer/%s" % exe, "tools/clang/tools/%s/%s" % (exe, exe)) + pisitools.dosym("/usr/lib/clang-analyzer/%s/%s" % (exe, exe), "/usr/bin/%s" % exe) + + pisitools.dodir("/etc/ld.so.conf.d") + shelltools.echo("%s/etc/ld.so.conf.d/51-llvm.conf" % get.installDIR(), "/usr/lib/llvm") + + # Symlink the gold plugin where clang expects it + pisitools.dosym("llvm/LLVMgold.so", "/usr/lib/LLVMgold.so") + + # Remove example file + pisitools.remove("/usr/lib/llvm/*LLVMHello.*") + + pisitools.remove("/usr/share/doc/llvm/*.tar.gz") + pisitools.remove("/usr/share/doc/llvm/ocamldoc/html/*.tar.gz") + pisitools.removeDir("/usr/share/doc/llvm/ps") + + # Install vim syntax files for .ll and .td files + # llvm.vim additional file add ftdetct vim file to detect .ll and .td as llvm files + pisitools.insinto("/usr/share/vim/vimfiles/syntax", "utils/vim/*.vim") + + # Install kate syntax file + pisitools.insinto("%s/katepart/syntax" % kde4.appsdir, "utils/kate/*.xml") + + pisitools.dodoc("CREDITS.TXT", "LICENSE.TXT", "README.txt") diff --git a/programming/build/llvm/files/llvm-3.5.0-fix-cmake-llvm-exports.patch b/programming/build/llvm/files/llvm-3.5.0-fix-cmake-llvm-exports.patch new file mode 100644 index 0000000000..7a7d42a3d4 --- /dev/null +++ b/programming/build/llvm/files/llvm-3.5.0-fix-cmake-llvm-exports.patch @@ -0,0 +1,39 @@ +Index: cmake/modules/Makefile +=================================================================== +--- cmake/modules/Makefile (revision 217483) ++++ cmake/modules/Makefile (revision 217484) +@@ -33,6 +33,16 @@ + LLVM_ENABLE_RTTI := 0 + endif + ++LLVM_LIBS_TO_EXPORT := $(subst -l,,$(shell $(LLVM_CONFIG) --libs $(LINK_COMPONENTS) || echo Error)) ++ ++ifeq ($(LLVM_LIBS_TO_EXPORT),Error) ++$(error llvm-config --libs failed) ++endif ++ ++ifndef LLVM_LIBS_TO_EXPORT ++$(error LLVM_LIBS_TO_EXPORT cannot be empty) ++endif ++ + OBJMODS := LLVMConfig.cmake LLVMConfigVersion.cmake LLVMExports.cmake + + $(PROJ_OBJ_DIR)/LLVMConfig.cmake: LLVMConfig.cmake.in $(LLVMBuildCMakeFrag) +@@ -45,7 +55,7 @@ + -e 's/@LLVM_VERSION_PATCH@/'"$(LLVM_VERSION_PATCH)"'/' \ + -e 's/@PACKAGE_VERSION@/'"$(LLVMVersion)"'/' \ + -e 's/@LLVM_COMMON_DEPENDS@//' \ +- -e 's/@LLVM_AVAILABLE_LIBS@/'"$(subst -l,,$(LLVMConfigLibs))"'/' \ ++ -e 's/@LLVM_AVAILABLE_LIBS@/'"$(LLVM_LIBS_TO_EXPORT)"'/' \ + -e 's/@LLVM_ALL_TARGETS@/'"$(ALL_TARGETS)"'/' \ + -e 's/@LLVM_TARGETS_TO_BUILD@/'"$(TARGETS_TO_BUILD)"'/' \ + -e 's/@LLVM_TARGETS_WITH_JIT@/'"$(TARGETS_WITH_JIT)"'/' \ +@@ -83,7 +93,7 @@ + $(Echo) 'Generating LLVM CMake target exports file' + $(Verb) ( \ + echo '# LLVM CMake target exports. Do not include directly.' && \ +- for lib in $(subst -l,,$(LLVMConfigLibs)); do \ ++ for lib in $(LLVM_LIBS_TO_EXPORT); do \ + echo 'add_library('"$$lib"' STATIC IMPORTED)' && \ + echo 'set_property(TARGET '"$$lib"' PROPERTY IMPORTED_LOCATION "'"$(PROJ_libdir)/lib$$lib.a"'")' ; \ + done && \ diff --git a/programming/build/llvm/files/llvm-3.5.0-force-link-pass.o.patch b/programming/build/llvm/files/llvm-3.5.0-force-link-pass.o.patch new file mode 100644 index 0000000000..acc4c13396 --- /dev/null +++ b/programming/build/llvm/files/llvm-3.5.0-force-link-pass.o.patch @@ -0,0 +1,28 @@ +Index: llvm-toolchain-snapshot-3.5~svn211313/tools/bugpoint/Makefile +=================================================================== +--- llvm-toolchain-snapshot-3.5~svn211313.orig/tools/bugpoint/Makefile ++++ llvm-toolchain-snapshot-3.5~svn211313/tools/bugpoint/Makefile +@@ -12,6 +12,9 @@ TOOLNAME := bugpoint + LINK_COMPONENTS := asmparser instrumentation scalaropts ipo linker bitreader \ + bitwriter irreader vectorize objcarcopts codegen + ++# Crappy workaround to make sure it links correctly. ++LLVMLibsOptions := ../../lib/IR/Release*/Pass.o ++ + # Support plugins. + NO_DEAD_STRIP := 1 + +Index: llvm-toolchain-snapshot-3.5~svn211313/tools/opt/Makefile +=================================================================== +--- llvm-toolchain-snapshot-3.5~svn211313.orig/tools/opt/Makefile ++++ llvm-toolchain-snapshot-3.5~svn211313/tools/opt/Makefile +@@ -10,7 +10,9 @@ + LEVEL := ../.. + TOOLNAME := opt + LINK_COMPONENTS := bitreader bitwriter asmparser irreader instrumentation scalaropts objcarcopts ipo vectorize all-targets codegen ++# Crappy workaround to make sure it links correctly. + ++LLVMLibsOptions := ../../lib/IR/Release*/Pass.o + # Support plugins. + NO_DEAD_STRIP := 1 + diff --git a/programming/build/llvm/pspec.xml b/programming/build/llvm/pspec.xml new file mode 100644 index 0000000000..dc87e8a790 --- /dev/null +++ b/programming/build/llvm/pspec.xml @@ -0,0 +1,202 @@ + + + + + llvm + http://www.llvm.org/ + + Serdar Soytetir + kaptan@pisilinux.org + + NCSA + The Low Level Virtual Machine + The LLVM Project is a collection of modular and reusable compiler and toolchain technologies. Despite its name, LLVM has little to do with traditional virtual machines, though it does provide helpful libraries that can be used to build them. + http://llvm.org/releases/3.5.0/llvm-3.5.0.src.tar.xz + http://llvm.org/releases/3.5.0/cfe-3.5.0.src.tar.xz + http://llvm.org/releases/3.5.0/clang-tools-extra-3.5.0.src.tar.xz + http://llvm.org/releases/3.5.0/compiler-rt-3.5.0.src.tar.xz + + + ocaml + libffi-devel + libedit-devel + + binutils + + + llvm-3.5.0-fix-cmake-llvm-exports.patch + llvm-3.5.0-force-link-pass.o.patch + + + + + llvm + app:console + library + + llvm-libs + + + /usr/bin + /usr/bin/llvm-config + /usr/include/llvm* + /usr/lib/llvm + /usr/lib + /etc/ld.so.conf.d + /etc/llvm + /usr/share/doc + /usr/share/vim + /usr/share/llvm/cmake + + /usr/share/kde4 + /usr/share/man + + + + + llvm-libs + library + + /usr/lib/llvm/libLLVM-3* + /usr/share/licenses/llvm-libs/LICENSE + + + + + llvm-ocaml + library + programming.language.ocaml + OCaml binding for LLVM + + llvm + ocaml + + + /usr/lib/ocaml + + + + + llvm-clang-analyzer + app:console + A source code analysis framework + The Clang Static Analyzer consists of both a source code analysis framework and a standalone tool that finds bugs in C and Objective-C programs. + + llvm-clang + + + /usr/lib/clang-analyzer + /usr/bin/scan-* + + + + + llvm-clang + A C language family front-end for LLVM + The goal of the Clang project is to create a new C, C++, Objective C and Objective C++ front-end for the LLVM compiler. + + llvm + + + /usr/bin/clang* + /usr/bin/tblgen + /usr/lib/clang + /usr/lib/clang/libclang.so + /usr/share/man/man1/clang.1 + + + + + llvm-clang-devel + Development headers for llvm-clang + + llvm-clang + + + /usr/include/clang + /usr/include/clang-c + + + + + llvm-docs + programming.docs + data:doc + Documentation for LLVM + + /usr/share/doc/llvm/html + /usr/share/doc/llvm/ocamldoc + + + + + llvm-32bit + emul32 + 32-bit shared libraries for llvm + emul32 + + zlib-32bit + libffi-32bit + + + llvm + zlib-32bit + libffi-32bit + + + /usr/lib32 + + + + + + 2014-09-23 + 3.5.0 + Version bump. + Serdar Soytetir + kaptan@pisilinux.org + + + 2014-05-11 + 3.4.1 + Release bump. + Marcin Bojara + marcin@pisilinux.org + + + 2014-05-11 + 3.4.1 + Version bump. + Yusuf Aydemir + yusuf.aydemir@pisilinux.org + + + 2013-09-01 + 3.3 + Release bump, already cleaned. + marcin bojara + marcin@pisilinux.org + + + 2013-07-26 + 3.3 + Version bump. + marcin bojara + marcin@pisilinux.org + + + 2013-02-18 + 3.2 + version bump + PisiLinux Community + admins@pisilinux.org + + + 2012-06-11 + 3.1 + First release + marcin bojara + marcin@pisilinux.org + + + diff --git a/programming/build/llvm/translations.xml b/programming/build/llvm/translations.xml new file mode 100644 index 0000000000..7ebd970163 --- /dev/null +++ b/programming/build/llvm/translations.xml @@ -0,0 +1,33 @@ + + + + llvm + Düşük Seviye Sanal Makine (LLVM) + LLVM projesi, modüler ve tekrar tekrar kullanılabilir derleyici teknolojileri koleksiyonudur. Adının aksine geleneksel sanal makinelerden çok farklıdır; ancak sanal makineleri oluşturmak için faydalı kitaplıklar içerir. + + + + llvm-ocaml + LLVM için OCaml bağlayıcısı + + + + llvm-clang-analyzer + C ve Objective-C için kod analiz altyapısı + + + + llvm-clang + LLVM için C dili ailesi ön ucu + + + + llvm-clang-devel + llvm-clang için başlık dosyaları + + + + llvm-docs + LLVM belgeleri + + diff --git a/programming/language/ocaml/component.xml b/programming/language/ocaml/component.xml new file mode 100644 index 0000000000..bcae4bf1bf --- /dev/null +++ b/programming/language/ocaml/component.xml @@ -0,0 +1,3 @@ + + programming.language.ocaml + diff --git a/programming/language/ocaml/ocaml/actions.py b/programming/language/ocaml/ocaml/actions.py new file mode 100644 index 0000000000..b9784fffc6 --- /dev/null +++ b/programming/language/ocaml/ocaml/actions.py @@ -0,0 +1,45 @@ +#!/usr/bin/python +# -*- coding: utf-8 -*- +# +# Licensed under the GNU General Public License, version 3. +# See the file http://www.gnu.org/licenses/gpl.txt + +from pisi.actionsapi import autotools +from pisi.actionsapi import pisitools +from pisi.actionsapi import shelltools +from pisi.actionsapi import get + +def setup(): + #shelltools.export("CFLAGS", get.CFLAGS().replace("-fomit-frame-pointer", "")) + #shelltools.export("LDFLAGS", get.LDFLAGS()) + + autotools.rawConfigure("-prefix /usr \ + -bindir /usr/bin \ + -x11include /usr/include \ + -libdir /usr/lib/ocaml \ + -mandir /usr/share/man \ + --with-pthread") + +def build(): + autotools.make("-j1 world") + autotools.make("-j1 opt") + autotools.make("-j1 opt.opt") + autotools.make("-C emacs ocamltags") + +def install(): + autotools.rawInstall("BINDIR=%(install)s/usr/bin \ + LIBDIR=%(install)s/usr/lib/ocaml \ + MANDIR=%(install)s/usr/share/man" \ + % { "install": get.installDIR()}) + + pisitools.dodoc("Changes", "LICENSE", "README") + + + ''' autotools.rawInstall("-C emacs \ + BINDIR=%(install)s/usr/bin \ + EMACSDIR=%(install)s/usr/share/emacs/site-lisp" + % { "install": get.installDIR()}) + ''' + # Remove rpaths from stublibs .so files + shelltools.system("chrpath --delete %s/usr/lib/ocaml/stublibs/*.so" + % get.installDIR()) diff --git a/programming/language/ocaml/ocaml/files/fedora/0001-Don-t-ignore-.-configure-it-s-a-real-git-file.patch b/programming/language/ocaml/ocaml/files/fedora/0001-Don-t-ignore-.-configure-it-s-a-real-git-file.patch new file mode 100644 index 0000000000..6561c038fe --- /dev/null +++ b/programming/language/ocaml/ocaml/files/fedora/0001-Don-t-ignore-.-configure-it-s-a-real-git-file.patch @@ -0,0 +1,24 @@ +From ccc1bf226619608230dc94b26377756719cf7b20 Mon Sep 17 00:00:00 2001 +From: "Richard W.M. Jones" +Date: Tue, 24 Jun 2014 22:29:38 +0100 +Subject: [PATCH 01/12] Don't ignore ./configure, it's a real git file. + +--- + .gitignore | 1 - + 1 file changed, 1 deletion(-) + +diff --git a/.gitignore b/.gitignore +index d36195a..dbb0e3e 100644 +--- a/.gitignore ++++ b/.gitignore +@@ -19,7 +19,6 @@ + /.depend + /.depend.nt + /.DS_Store +-/configure + /ocamlc + /ocamlc.opt + /expunge +-- +2.0.4 + diff --git a/programming/language/ocaml/ocaml/files/fedora/0002-Ensure-empty-compilerlibs-directory-is-created-by-gi.patch b/programming/language/ocaml/ocaml/files/fedora/0002-Ensure-empty-compilerlibs-directory-is-created-by-gi.patch new file mode 100644 index 0000000000..6560bd343d --- /dev/null +++ b/programming/language/ocaml/ocaml/files/fedora/0002-Ensure-empty-compilerlibs-directory-is-created-by-gi.patch @@ -0,0 +1,18 @@ +From 0e3b6450f6ab803442a809b6da41d5d5c5da650f Mon Sep 17 00:00:00 2001 +From: "Richard W.M. Jones" +Date: Thu, 7 Jun 2012 15:36:16 +0100 +Subject: [PATCH 02/12] Ensure empty compilerlibs/ directory is created by git. + +This directory exists in the OCaml tarball, but is empty. As a +result, git ignores it unless we put a dummy file in it. +--- + compilerlibs/.exists | 0 + 1 file changed, 0 insertions(+), 0 deletions(-) + create mode 100644 compilerlibs/.exists + +diff --git a/compilerlibs/.exists b/compilerlibs/.exists +new file mode 100644 +index 0000000..e69de29 +-- +2.0.4 + diff --git a/programming/language/ocaml/ocaml/files/fedora/0003-Don-t-add-rpaths-to-libraries.patch b/programming/language/ocaml/ocaml/files/fedora/0003-Don-t-add-rpaths-to-libraries.patch new file mode 100644 index 0000000000..1d36cccb11 --- /dev/null +++ b/programming/language/ocaml/ocaml/files/fedora/0003-Don-t-add-rpaths-to-libraries.patch @@ -0,0 +1,29 @@ +From 79f0f91e3e4abbfbd3564c11ea72e53310236afc Mon Sep 17 00:00:00 2001 +From: "Richard W.M. Jones" +Date: Tue, 24 Jun 2014 10:00:15 +0100 +Subject: [PATCH 03/12] Don't add rpaths to libraries. + +--- + tools/Makefile.shared | 6 +++--- + 1 file changed, 3 insertions(+), 3 deletions(-) + +diff --git a/tools/Makefile.shared b/tools/Makefile.shared +index 2517434..75a75b4 100644 +--- a/tools/Makefile.shared ++++ b/tools/Makefile.shared +@@ -112,9 +112,9 @@ ocamlmklibconfig.ml: ../config/Makefile + echo 'let ext_dll = "$(EXT_DLL)"'; \ + echo 'let supports_shared_libraries = $(SUPPORTS_SHARED_LIBRARIES)';\ + echo 'let mkdll = "$(MKDLL)"'; \ +- echo 'let byteccrpath = "$(BYTECCRPATH)"'; \ +- echo 'let nativeccrpath = "$(NATIVECCRPATH)"'; \ +- echo 'let mksharedlibrpath = "$(MKSHAREDLIBRPATH)"'; \ ++ echo 'let byteccrpath = ""'; \ ++ echo 'let nativeccrpath = ""'; \ ++ echo 'let mksharedlibrpath = ""'; \ + echo 'let toolpref = "$(TOOLPREF)"'; \ + sed -n -e 's/^#ml //p' ../config/Makefile) \ + > ocamlmklibconfig.ml +-- +2.0.4 + diff --git a/programming/language/ocaml/ocaml/files/fedora/0004-ocamlbyteinfo-ocamlplugininfo-Useful-utilities-from-.patch b/programming/language/ocaml/ocaml/files/fedora/0004-ocamlbyteinfo-ocamlplugininfo-Useful-utilities-from-.patch new file mode 100644 index 0000000000..5e117b7dc4 --- /dev/null +++ b/programming/language/ocaml/ocaml/files/fedora/0004-ocamlbyteinfo-ocamlplugininfo-Useful-utilities-from-.patch @@ -0,0 +1,240 @@ +From 11b377aee2811891635982a5590fef62f12645b6 Mon Sep 17 00:00:00 2001 +From: "Richard W.M. Jones" +Date: Tue, 29 May 2012 20:40:36 +0100 +Subject: [PATCH 04/12] ocamlbyteinfo, ocamlplugininfo: Useful utilities from + Debian, sent upstream. + +See: +http://git.debian.org/?p=pkg-ocaml-maint/packages/ocaml.git;a=tree;f=debian/ocamlbyteinfo;hb=HEAD +--- + ocamlbyteinfo.ml | 101 +++++++++++++++++++++++++++++++++++++++++++++++++ + ocamlplugininfo.ml | 109 +++++++++++++++++++++++++++++++++++++++++++++++++++++ + 2 files changed, 210 insertions(+) + create mode 100644 ocamlbyteinfo.ml + create mode 100644 ocamlplugininfo.ml + +diff --git a/ocamlbyteinfo.ml b/ocamlbyteinfo.ml +new file mode 100644 +index 0000000..eb9a293 +--- /dev/null ++++ b/ocamlbyteinfo.ml +@@ -0,0 +1,101 @@ ++(***********************************************************************) ++(* *) ++(* Objective Caml *) ++(* *) ++(* Xavier Leroy, projet Gallium, INRIA Rocquencourt *) ++(* *) ++(* Copyright 2009 Institut National de Recherche en Informatique et *) ++(* en Automatique. All rights reserved. This file is distributed *) ++(* under the terms of the GNU Library General Public License, with *) ++(* the special exception on linking described in file ../../LICENSE. *) ++(* *) ++(***********************************************************************) ++ ++(* $Id$ *) ++ ++(* Dumps a bytecode binary file *) ++ ++open Sys ++open Dynlinkaux ++ ++let input_stringlist ic len = ++ let get_string_list sect len = ++ let rec fold s e acc = ++ if e != len then ++ if sect.[e] = '\000' then ++ fold (e+1) (e+1) (String.sub sect s (e-s) :: acc) ++ else fold s (e+1) acc ++ else acc ++ in fold 0 0 [] ++ in ++ let sect = String.create len in ++ let _ = really_input ic sect 0 len in ++ get_string_list sect len ++ ++let print = Printf.printf ++let perr s = ++ Printf.eprintf "%s\n" s; ++ exit(1) ++let p_title title = print "%s:\n" title ++ ++let p_section title format pdata = function ++ | [] -> () ++ | l -> ++ p_title title; ++ List.iter ++ (fun (name, data) -> print format (pdata data) name) ++ l ++ ++let p_list title format = function ++ | [] -> () ++ | l -> ++ p_title title; ++ List.iter ++ (fun name -> print format name) ++ l ++ ++let _ = ++ try ++ let input_name = Sys.argv.(1) in ++ let ic = open_in_bin input_name in ++ Bytesections.read_toc ic; ++ List.iter ++ (fun section -> ++ try ++ let len = Bytesections.seek_section ic section in ++ if len > 0 then match section with ++ | "CRCS" -> ++ p_section ++ "Imported Units" ++ "\t%s\t%s\n" ++ Digest.to_hex ++ (input_value ic : (string * Digest.t) list) ++ | "DLLS" -> ++ p_list ++ "Used Dlls" "\t%s\n" ++ (input_stringlist ic len) ++ | "DLPT" -> ++ p_list ++ "Additional Dll paths" ++ "\t%s\n" ++ (input_stringlist ic len) ++ | "PRIM" -> ++ let prims = (input_stringlist ic len) in ++ print "Uses unsafe features: "; ++ begin match prims with ++ [] -> print "no\n" ++ | l -> print "YES\n"; ++ p_list "Primitives declared in this module" ++ "\t%s\n" ++ l ++ end ++ | _ -> () ++ with Not_found | Failure _ | Invalid_argument _ -> () ++ ) ++ ["CRCS"; "DLLS"; "DLPT"; "PRIM"]; ++ close_in ic ++ with ++ | Sys_error msg -> ++ perr msg ++ | Invalid_argument("index out of bounds") -> ++ perr (Printf.sprintf "Usage: %s filename" Sys.argv.(0)) +diff --git a/ocamlplugininfo.ml b/ocamlplugininfo.ml +new file mode 100644 +index 0000000..e28800f +--- /dev/null ++++ b/ocamlplugininfo.ml +@@ -0,0 +1,109 @@ ++(***********************************************************************) ++(* *) ++(* Objective Caml *) ++(* *) ++(* Xavier Leroy, projet Gallium, INRIA Rocquencourt *) ++(* *) ++(* Copyright 2009 Institut National de Recherche en Informatique et *) ++(* en Automatique. All rights reserved. This file is distributed *) ++(* under the terms of the GNU Library General Public License, with *) ++(* the special exception on linking described in file ../../LICENSE. *) ++(* *) ++(***********************************************************************) ++ ++(* $Id$ *) ++ ++(* Dumps a .cmxs file *) ++ ++open Natdynlink ++open Format ++ ++let file = ++ try ++ Sys.argv.(1) ++ with _ -> begin ++ Printf.eprintf "Usage: %s file.cmxs\n" Sys.argv.(0); ++ exit(1) ++ end ++ ++exception Abnormal_exit ++ ++let error s e = ++ let eprint = Printf.eprintf in ++ let print_exc s = function ++ | End_of_file -> ++ eprint "%s: %s\n" s file ++ | Abnormal_exit -> ++ eprint "%s\n" s ++ | e -> eprint "%s\n" (Printexc.to_string e) ++ in ++ print_exc s e; ++ exit(1) ++ ++let read_in command = ++ let cmd = Printf.sprintf command file in ++ let ic = Unix.open_process_in cmd in ++ try ++ let line = input_line ic in ++ begin match (Unix.close_process_in ic) with ++ | Unix.WEXITED 0 -> Str.split (Str.regexp "[ ]+") line ++ | Unix.WEXITED _ | Unix.WSIGNALED _ | Unix.WSTOPPED _ -> ++ error ++ (Printf.sprintf ++ "Command \"%s\" exited abnormally" ++ cmd ++ ) ++ Abnormal_exit ++ end ++ with e -> error "File is empty" e ++ ++let get_offset adr_off adr_sec = ++ try ++ let adr = List.nth adr_off 4 in ++ let off = List.nth adr_off 5 in ++ let sec = List.hd adr_sec in ++ ++ let (!) x = Int64.of_string ("0x" ^ x) in ++ let (+) = Int64.add in ++ let (-) = Int64.sub in ++ ++ Int64.to_int (!off + !sec - !adr) ++ ++ with Failure _ | Invalid_argument _ -> ++ error ++ "Command output doesn't have the expected format" ++ Abnormal_exit ++ ++let print_infos name crc defines cmi cmx = ++ let print_name_crc (name, crc) = ++ printf "@ %s (%s)" name (Digest.to_hex crc) ++ in ++ let pr_imports ppf imps = List.iter print_name_crc imps in ++ printf "Name: %s@." name; ++ printf "CRC of implementation: %s@." (Digest.to_hex crc); ++ printf "@[Globals defined:"; ++ List.iter (fun s -> printf "@ %s" s) defines; ++ printf "@]@."; ++ printf "@[Interfaces imported:%a@]@." pr_imports cmi; ++ printf "@[Implementations imported:%a@]@." pr_imports cmx ++ ++let _ = ++ let adr_off = read_in "objdump -h %s | grep ' .data '" in ++ let adr_sec = read_in "objdump -T %s | grep ' caml_plugin_header$'" in ++ ++ let ic = open_in file in ++ let _ = seek_in ic (get_offset adr_off adr_sec) in ++ let header = (input_value ic : Natdynlink.dynheader) in ++ if header.magic <> Natdynlink.dyn_magic_number then ++ raise(Error(Natdynlink.Not_a_bytecode_file file)) ++ else begin ++ List.iter ++ (fun ui -> ++ print_infos ++ ui.name ++ ui.crc ++ ui.defines ++ ui.imports_cmi ++ ui.imports_cmx) ++ header.units ++ end +-- +2.0.4 + diff --git a/programming/language/ocaml/ocaml/files/fedora/0005-configure-Allow-user-defined-C-compiler-flags.patch b/programming/language/ocaml/ocaml/files/fedora/0005-configure-Allow-user-defined-C-compiler-flags.patch new file mode 100644 index 0000000000..c66d1fbaf2 --- /dev/null +++ b/programming/language/ocaml/ocaml/files/fedora/0005-configure-Allow-user-defined-C-compiler-flags.patch @@ -0,0 +1,27 @@ +From 5308c47681201ef3beef3e543ab877f81aa08784 Mon Sep 17 00:00:00 2001 +From: "Richard W.M. Jones" +Date: Tue, 29 May 2012 20:44:18 +0100 +Subject: [PATCH 05/12] configure: Allow user defined C compiler flags. + +--- + configure | 4 ++++ + 1 file changed, 4 insertions(+) + +diff --git a/configure b/configure +index dbc6178..c1133ee 100755 +--- a/configure ++++ b/configure +@@ -1633,6 +1633,10 @@ case "$buggycc" in + nativecccompopts="$nativecccompopts -fomit-frame-pointer";; + esac + ++# Allow user defined C Compiler flags ++bytecccompopts="$bytecccompopts $CFLAGS" ++nativecccompopts="$nativecccompopts $CFLAGS" ++ + # Finish generated files + + cclibs="$cclibs $mathlib" +-- +2.0.4 + diff --git a/programming/language/ocaml/ocaml/files/fedora/0009-arg-Add-no_arg-and-get_arg-helper-functions.patch b/programming/language/ocaml/ocaml/files/fedora/0009-arg-Add-no_arg-and-get_arg-helper-functions.patch new file mode 100644 index 0000000000..3dbebc987d --- /dev/null +++ b/programming/language/ocaml/ocaml/files/fedora/0009-arg-Add-no_arg-and-get_arg-helper-functions.patch @@ -0,0 +1,118 @@ +From 0641f11626be99c8bde349520ac28a8d93106856 Mon Sep 17 00:00:00 2001 +From: "Richard W.M. Jones" +Date: Tue, 1 Apr 2014 11:17:07 +0100 +Subject: [PATCH 09/12] arg: Add no_arg and get_arg helper functions. + +The no_arg function in this patch is a no-op. It will do something +useful in the followups. + +The get_arg function simply checks the next position on the command +line exists and returns that argument or raises a Arg.Missing. + +This patch should introduce no functional change, it is simply code +refactoring. + +In particular, this should not change the treatment of Arg.current +(see: http://caml.inria.fr/mantis/view.php?id=5197#c11147) +--- + stdlib/arg.ml | 47 ++++++++++++++++++++++++++--------------------- + 1 file changed, 26 insertions(+), 21 deletions(-) + +diff --git a/stdlib/arg.ml b/stdlib/arg.ml +index 0f6480b..a41e0a2 100644 +--- a/stdlib/arg.ml ++++ b/stdlib/arg.ml +@@ -134,56 +134,62 @@ let parse_argv_dynamic ?(current=current) argv speclist anonfun errmsg = + try assoc3 s !speclist + with Not_found -> stop (Unknown s) + in ++ let no_arg () = () in ++ let get_arg () = ++ if !current + 1 < l then argv.(!current + 1) ++ else stop (Missing s) ++ in + begin try + let rec treat_action = function +- | Unit f -> f (); +- | Bool f when !current + 1 < l -> +- let arg = argv.(!current + 1) in ++ | Unit f -> no_arg (); f (); ++ | Bool f -> ++ let arg = get_arg () in + begin try f (bool_of_string arg) + with Invalid_argument "bool_of_string" -> + raise (Stop (Wrong (s, arg, "a boolean"))) + end; + incr current; +- | Set r -> r := true; +- | Clear r -> r := false; +- | String f when !current + 1 < l -> +- f argv.(!current + 1); ++ | Set r -> no_arg (); r := true; ++ | Clear r -> no_arg (); r := false; ++ | String f -> ++ let arg = get_arg () in ++ f arg; + incr current; +- | Symbol (symb, f) when !current + 1 < l -> +- let arg = argv.(!current + 1) in ++ | Symbol (symb, f) -> ++ let arg = get_arg () in + if List.mem arg symb then begin +- f argv.(!current + 1); ++ f arg; + incr current; + end else begin + raise (Stop (Wrong (s, arg, "one of: " + ^ (make_symlist "" " " "" symb)))) + end +- | Set_string r when !current + 1 < l -> +- r := argv.(!current + 1); ++ | Set_string r -> ++ r := get_arg (); + incr current; +- | Int f when !current + 1 < l -> +- let arg = argv.(!current + 1) in ++ | Int f -> ++ let arg = get_arg () in + begin try f (int_of_string arg) + with Failure "int_of_string" -> + raise (Stop (Wrong (s, arg, "an integer"))) + end; + incr current; +- | Set_int r when !current + 1 < l -> +- let arg = argv.(!current + 1) in ++ | Set_int r -> ++ let arg = get_arg () in + begin try r := (int_of_string arg) + with Failure "int_of_string" -> + raise (Stop (Wrong (s, arg, "an integer"))) + end; + incr current; +- | Float f when !current + 1 < l -> +- let arg = argv.(!current + 1) in ++ | Float f -> ++ let arg = get_arg () in + begin try f (float_of_string arg); + with Failure "float_of_string" -> + raise (Stop (Wrong (s, arg, "a float"))) + end; + incr current; +- | Set_float r when !current + 1 < l -> +- let arg = argv.(!current + 1) in ++ | Set_float r -> ++ let arg = get_arg () in + begin try r := (float_of_string arg); + with Failure "float_of_string" -> + raise (Stop (Wrong (s, arg, "a float"))) +@@ -196,7 +202,6 @@ let parse_argv_dynamic ?(current=current) argv speclist anonfun errmsg = + f argv.(!current + 1); + incr current; + done; +- | _ -> raise (Stop (Missing s)) + in + treat_action action + with Bad m -> stop (Message m); +-- +2.0.4 + diff --git a/programming/language/ocaml/ocaml/files/fedora/0010-arg-Allow-flags-such-as-flag-arg-as-well-as-flag-arg.patch b/programming/language/ocaml/ocaml/files/fedora/0010-arg-Allow-flags-such-as-flag-arg-as-well-as-flag-arg.patch new file mode 100644 index 0000000000..d9f7fc9bc1 --- /dev/null +++ b/programming/language/ocaml/ocaml/files/fedora/0010-arg-Allow-flags-such-as-flag-arg-as-well-as-flag-arg.patch @@ -0,0 +1,84 @@ +From 4d1defe6f017b86b0766fd02005a468bedd9aa88 Mon Sep 17 00:00:00 2001 +From: "Richard W.M. Jones" +Date: Tue, 1 Apr 2014 11:21:40 +0100 +Subject: [PATCH 10/12] arg: Allow flags such as --flag=arg as well as --flag + arg. + +Allow flags to be followed directly by their argument, separated by an '=' +sign. This is consistent with what GNU getopt_long and many other +command line parsing libraries allow. + +Fix for the following issue: +http://caml.inria.fr/mantis/view.php?id=5197 +--- + stdlib/arg.ml | 30 ++++++++++++++++++++++++------ + stdlib/arg.mli | 3 ++- + 2 files changed, 26 insertions(+), 7 deletions(-) + +diff --git a/stdlib/arg.ml b/stdlib/arg.ml +index a41e0a2..5ffdabc 100644 +--- a/stdlib/arg.ml ++++ b/stdlib/arg.ml +@@ -55,6 +55,12 @@ let rec assoc3 x l = + | _ :: t -> assoc3 x t + ;; + ++let split s = ++ let i = String.index s '=' in ++ let len = String.length s in ++ String.sub s 0 i, String.sub s (i+1) (len-(i+1)) ++;; ++ + let make_symlist prefix sep suffix l = + match l with + | [] -> "" +@@ -130,14 +136,26 @@ let parse_argv_dynamic ?(current=current) argv speclist anonfun errmsg = + while !current < l do + let s = argv.(!current) in + if String.length s >= 1 && s.[0] = '-' then begin +- let action = +- try assoc3 s !speclist +- with Not_found -> stop (Unknown s) ++ let action, follow = ++ try assoc3 s !speclist, None ++ with Not_found -> ++ try ++ let keyword, arg = split s in ++ assoc3 keyword !speclist, Some arg ++ with Not_found -> stop (Unknown s) + in +- let no_arg () = () in ++ let no_arg () = ++ match follow with ++ | None -> () ++ | Some arg -> stop (Wrong (s, arg, "no argument")) in + let get_arg () = +- if !current + 1 < l then argv.(!current + 1) +- else stop (Missing s) ++ match follow with ++ | None -> ++ if !current + 1 < l then argv.(!current + 1) ++ else stop (Missing s) ++ | Some arg -> ++ decr current; ++ arg + in + begin try + let rec treat_action = function +diff --git a/stdlib/arg.mli b/stdlib/arg.mli +index 22eda40..7078071 100644 +--- a/stdlib/arg.mli ++++ b/stdlib/arg.mli +@@ -25,7 +25,8 @@ + [Unit], [Set] and [Clear] keywords take no argument. A [Rest] + keyword takes the remaining of the command line as arguments. + Every other keyword takes the following word on the command line +- as argument. ++ as argument. For compatibility with GNU getopt_long, [keyword=arg] ++ is also allowed. + Arguments not preceded by a keyword are called anonymous arguments. + + Examples ([cmd] is assumed to be the command name): +-- +2.0.4 + diff --git a/programming/language/ocaml/ocaml/files/fedora/0011-PR-6517-use-ISO-C99-types-u-int-32-64-_t-in-preferen.patch b/programming/language/ocaml/ocaml/files/fedora/0011-PR-6517-use-ISO-C99-types-u-int-32-64-_t-in-preferen.patch new file mode 100644 index 0000000000..cf8f07ab8d --- /dev/null +++ b/programming/language/ocaml/ocaml/files/fedora/0011-PR-6517-use-ISO-C99-types-u-int-32-64-_t-in-preferen.patch @@ -0,0 +1,1963 @@ +From 6156d208e6cc6e28a964be5dd34585bd54f6eadf Mon Sep 17 00:00:00 2001 +From: Xavier Leroy +Date: Wed, 27 Aug 2014 09:58:33 +0000 +Subject: [PATCH 11/12] PR#6517: use ISO C99 types {,u}int{32,64}_t in + preference to our homegrown types {,u}int{32,64}. + +git-svn-id: http://caml.inria.fr/svn/ocaml/trunk@15131 f963ae5c-01c2-4b8c-9fe0-0dff7051ff02 + +---------------------------------------------------------------------- +For Fedora: + +This commit was cherry picked from upstream +commit b868c05ec91a7ee193010a421de768a3b1a80952 (SVN 15131). + +See also: + +http://caml.inria.fr/mantis/view.php?id=6517 +--- + asmrun/backtrace.c | 6 +- + byterun/alloc.h | 4 +- + byterun/backtrace.c | 2 +- + byterun/config.h | 35 +++++++---- + byterun/debugger.h | 28 ++++----- + byterun/exec.h | 4 +- + byterun/extern.c | 4 +- + byterun/fix_code.c | 8 +-- + byterun/floats.c | 6 +- + byterun/globroots.c | 4 +- + byterun/hash.c | 44 +++++++------- + byterun/hash.h | 12 ++-- + byterun/int64_emul.h | 114 ++++++++++++++++++------------------ + byterun/int64_format.h | 4 +- + byterun/int64_native.h | 20 +++---- + byterun/intern.c | 20 +++---- + byterun/interp.c | 2 +- + byterun/intext.h | 12 ++-- + byterun/ints.c | 112 +++++++++++++++++------------------ + byterun/io.c | 6 +- + byterun/io.h | 6 +- + byterun/md5.c | 26 ++++---- + byterun/md5.h | 6 +- + byterun/mlvalues.h | 12 ++-- + byterun/startup.c | 10 ++-- + byterun/startup.h | 4 +- + byterun/str.c | 20 +++---- + config/auto-aux/int64align.c | 14 ++--- + config/s-nt.h | 3 + + configure | 25 ++------ + otherlibs/bigarray/bigarray_stubs.c | 48 +++++++-------- + otherlibs/num/nat_stubs.c | 14 ++--- + otherlibs/unix/addrofstr.c | 2 +- + stdlib/header.c | 2 +- + 34 files changed, 319 insertions(+), 320 deletions(-) + +diff --git a/asmrun/backtrace.c b/asmrun/backtrace.c +index c72a237..773e22c 100644 +--- a/asmrun/backtrace.c ++++ b/asmrun/backtrace.c +@@ -217,7 +217,7 @@ static void extract_location_info(frame_descr * d, + /*out*/ struct loc_info * li) + { + uintnat infoptr; +- uint32 info1, info2; ++ uint32_t info1, info2; + + /* If no debugging information available, print nothing. + When everything is compiled with -g, this corresponds to +@@ -232,8 +232,8 @@ static void extract_location_info(frame_descr * d, + sizeof(char *) + sizeof(short) + sizeof(short) + + sizeof(short) * d->num_live + sizeof(frame_descr *) - 1) + & -sizeof(frame_descr *); +- info1 = ((uint32 *)infoptr)[0]; +- info2 = ((uint32 *)infoptr)[1]; ++ info1 = ((uint32_t *)infoptr)[0]; ++ info2 = ((uint32_t *)infoptr)[1]; + /* Format of the two info words: + llllllllllllllllllll aaaaaaaa bbbbbbbbbb nnnnnnnnnnnnnnnnnnnnnnnn kk + 44 36 26 2 0 +diff --git a/byterun/alloc.h b/byterun/alloc.h +index f00a7ef..2a640eb 100644 +--- a/byterun/alloc.h ++++ b/byterun/alloc.h +@@ -32,8 +32,8 @@ CAMLextern value caml_alloc_string (mlsize_t); /* size in bytes */ + CAMLextern value caml_copy_string (char const *); + CAMLextern value caml_copy_string_array (char const **); + CAMLextern value caml_copy_double (double); +-CAMLextern value caml_copy_int32 (int32); /* defined in [ints.c] */ +-CAMLextern value caml_copy_int64 (int64); /* defined in [ints.c] */ ++CAMLextern value caml_copy_int32 (int32_t); /* defined in [ints.c] */ ++CAMLextern value caml_copy_int64 (int64_t); /* defined in [ints.c] */ + CAMLextern value caml_copy_nativeint (intnat); /* defined in [ints.c] */ + CAMLextern value caml_alloc_array (value (*funct) (char const *), + char const ** array); +diff --git a/byterun/backtrace.c b/byterun/backtrace.c +index 76e3ddf..6ed56c8 100644 +--- a/byterun/backtrace.c ++++ b/byterun/backtrace.c +@@ -229,7 +229,7 @@ static void read_debug_info(void) + int fd; + struct exec_trailer trail; + struct channel * chan; +- uint32 num_events, orig, i; ++ uint32_t num_events, orig, i; + intnat j; + value evl, l, ev_start; + +diff --git a/byterun/config.h b/byterun/config.h +index f775988..6c86d16 100644 +--- a/byterun/config.h ++++ b/byterun/config.h +@@ -25,24 +25,30 @@ + #include "compatibility.h" + #endif + +-/* Types for 32-bit integers, 64-bit integers, ++#ifdef HAS_STDINT_H ++#include ++#endif ++ ++/* Types for 32-bit integers, 64-bit integers, and + native integers (as wide as a pointer type) */ + ++#ifndef ARCH_INT32_TYPE + #if SIZEOF_INT == 4 +-typedef int int32; +-typedef unsigned int uint32; ++#define ARCH_INT32_TYPE int ++#define ARCH_UINT32_TYPE unsigned int + #define ARCH_INT32_PRINTF_FORMAT "" + #elif SIZEOF_LONG == 4 +-typedef long int32; +-typedef unsigned long uint32; ++#define ARCH_INT32_TYPE long ++#define ARCH_UINT32_TYPE unsigned long + #define ARCH_INT32_PRINTF_FORMAT "l" + #elif SIZEOF_SHORT == 4 +-typedef short int32; +-typedef unsigned short uint32; ++#define ARCH_INT32_TYPE short ++#define ARCH_UINT32_TYPE unsigned short + #define ARCH_INT32_PRINTF_FORMAT "" + #else + #error "No 32-bit integer type available" + #endif ++#endif + + #ifndef ARCH_INT64_TYPE + #if SIZEOF_LONGLONG == 8 +@@ -58,8 +64,13 @@ typedef unsigned short uint32; + #endif + #endif + +-typedef ARCH_INT64_TYPE int64; +-typedef ARCH_UINT64_TYPE uint64; ++#ifndef HAS_STDINT_H ++/* Not a C99 compiler, typically MSVC. Define the C99 types we use. */ ++typedef ARCH_INT32_TYPE int32_t; ++typedef ARCH_UINT32_TYPE uint32_t; ++typedef ARCH_INT64_TYPE int64_t; ++typedef ARCH_UINT64_TYPE uint64_t; ++#endif + + #if SIZEOF_PTR == SIZEOF_LONG + /* Standard models: ILP32 or I32LP64 */ +@@ -72,9 +83,9 @@ typedef int intnat; + typedef unsigned int uintnat; + #define ARCH_INTNAT_PRINTF_FORMAT "" + #elif SIZEOF_PTR == 8 +-/* Win64 model: IL32LLP64 */ +-typedef int64 intnat; +-typedef uint64 uintnat; ++/* Win64 model: IL32P64 */ ++typedef int64_t intnat; ++typedef uint64_t uintnat; + #define ARCH_INTNAT_PRINTF_FORMAT ARCH_INT64_PRINTF_FORMAT + #else + #error "No integer type available to represent pointers" +diff --git a/byterun/debugger.h b/byterun/debugger.h +index b5079eb..e68ef75 100644 +--- a/byterun/debugger.h ++++ b/byterun/debugger.h +@@ -37,17 +37,17 @@ void caml_debugger_cleanup_fork (void); + /* Requests from the debugger to the runtime system */ + + enum debugger_request { +- REQ_SET_EVENT = 'e', /* uint32 pos */ ++ REQ_SET_EVENT = 'e', /* uint32_t pos */ + /* Set an event on the instruction at position pos */ +- REQ_SET_BREAKPOINT = 'B', /* uint32 pos, (char k) */ ++ REQ_SET_BREAKPOINT = 'B', /* uint32_t pos, (char k) */ + /* Set a breakpoint at position pos */ + /* In profiling mode, the breakpoint kind is set to k */ +- REQ_RESET_INSTR = 'i', /* uint32 pos */ ++ REQ_RESET_INSTR = 'i', /* uint32_t pos */ + /* Clear an event or breapoint at position pos, restores initial instr. */ + REQ_CHECKPOINT = 'c', /* no args */ + /* Checkpoint the runtime system by forking a child process. + Reply is pid of child process or -1 if checkpoint failed. */ +- REQ_GO = 'g', /* uint32 n */ ++ REQ_GO = 'g', /* uint32_t n */ + /* Run the program for n events. + Reply is one of debugger_reply described below. */ + REQ_STOP = 's', /* no args */ +@@ -59,38 +59,38 @@ enum debugger_request { + Reply is stack offset and current pc. */ + REQ_GET_FRAME = 'f', /* no args */ + /* Return current frame location (stack offset + current pc). */ +- REQ_SET_FRAME = 'S', /* uint32 stack_offset */ ++ REQ_SET_FRAME = 'S', /* uint32_t stack_offset */ + /* Set current frame to given stack offset. No reply. */ +- REQ_UP_FRAME = 'U', /* uint32 n */ ++ REQ_UP_FRAME = 'U', /* uint32_t n */ + /* Move one frame up. Argument n is size of current frame (in words). + Reply is stack offset and current pc, or -1 if top of stack reached. */ +- REQ_SET_TRAP_BARRIER = 'b', /* uint32 offset */ ++ REQ_SET_TRAP_BARRIER = 'b', /* uint32_t offset */ + /* Set the trap barrier at the given offset. */ +- REQ_GET_LOCAL = 'L', /* uint32 slot_number */ ++ REQ_GET_LOCAL = 'L', /* uint32_t slot_number */ + /* Return the local variable at the given slot in the current frame. + Reply is one value. */ +- REQ_GET_ENVIRONMENT = 'E', /* uint32 slot_number */ ++ REQ_GET_ENVIRONMENT = 'E', /* uint32_t slot_number */ + /* Return the local variable at the given slot in the heap environment + of the current frame. Reply is one value. */ +- REQ_GET_GLOBAL = 'G', /* uint32 global_number */ ++ REQ_GET_GLOBAL = 'G', /* uint32_t global_number */ + /* Return the specified global variable. Reply is one value. */ + REQ_GET_ACCU = 'A', /* no args */ + /* Return the current contents of the accumulator. Reply is one value. */ + REQ_GET_HEADER = 'H', /* mlvalue v */ + /* As REQ_GET_OBJ, but sends only the header. */ +- REQ_GET_FIELD = 'F', /* mlvalue v, uint32 fieldnum */ ++ REQ_GET_FIELD = 'F', /* mlvalue v, uint32_t fieldnum */ + /* As REQ_GET_OBJ, but sends only one field. */ + REQ_MARSHAL_OBJ = 'M', /* mlvalue v */ + /* Send a copy of the data structure rooted at v, using the same + format as [caml_output_value]. */ + REQ_GET_CLOSURE_CODE = 'C', /* mlvalue v */ + /* Send the code address of the given closure. +- Reply is one uint32. */ +- REQ_SET_FORK_MODE = 'K' /* uint32 m */ ++ Reply is one uint32_t. */ ++ REQ_SET_FORK_MODE = 'K' /* uint32_t m */ + /* Set whether to follow the child (m=0) or the parent on fork. */ + }; + +-/* Replies to a REQ_GO request. All replies are followed by three uint32: ++/* Replies to a REQ_GO request. All replies are followed by three uint32_t: + - the value of the event counter + - the position of the stack + - the current pc. */ +diff --git a/byterun/exec.h b/byterun/exec.h +index a58bcf8..7e084ac 100644 +--- a/byterun/exec.h ++++ b/byterun/exec.h +@@ -39,13 +39,13 @@ + + struct section_descriptor { + char name[4]; /* Section name */ +- uint32 len; /* Length of data in bytes */ ++ uint32_t len; /* Length of data in bytes */ + }; + + /* Structure of the trailer. */ + + struct exec_trailer { +- uint32 num_sections; /* Number of sections */ ++ uint32_t num_sections; /* Number of sections */ + char magic[12]; /* The magic number */ + struct section_descriptor * section; /* Not part of file */ + }; +diff --git a/byterun/extern.c b/byterun/extern.c +index 33fa89a..e67d7a3 100644 +--- a/byterun/extern.c ++++ b/byterun/extern.c +@@ -720,7 +720,7 @@ CAMLexport void caml_serialize_int_2(int i) + extern_ptr += 2; + } + +-CAMLexport void caml_serialize_int_4(int32 i) ++CAMLexport void caml_serialize_int_4(int32_t i) + { + if (extern_ptr + 4 > extern_limit) grow_extern_output(4); + extern_ptr[0] = i >> 24; +@@ -730,7 +730,7 @@ CAMLexport void caml_serialize_int_4(int32 i) + extern_ptr += 4; + } + +-CAMLexport void caml_serialize_int_8(int64 i) ++CAMLexport void caml_serialize_int_8(int64_t i) + { + caml_serialize_block_8(&i, 1); + } +diff --git a/byterun/fix_code.c b/byterun/fix_code.c +index 3380dc9..4fa0275 100644 +--- a/byterun/fix_code.c ++++ b/byterun/fix_code.c +@@ -134,12 +134,12 @@ void caml_thread_code (code_t code, asize_t len) + } + *p++ = (opcode_t)(caml_instr_table[instr] - caml_instr_base); + if (instr == SWITCH) { +- uint32 sizes = *p++; +- uint32 const_size = sizes & 0xFFFF; +- uint32 block_size = sizes >> 16; ++ uint32_t sizes = *p++; ++ uint32_t const_size = sizes & 0xFFFF; ++ uint32_t block_size = sizes >> 16; + p += const_size + block_size; + } else if (instr == CLOSUREREC) { +- uint32 nfuncs = *p++; ++ uint32_t nfuncs = *p++; + p++; /* skip nvars */ + p += nfuncs; + } else { +diff --git a/byterun/floats.c b/byterun/floats.c +index 7ff6d89..d8fdd05 100644 +--- a/byterun/floats.c ++++ b/byterun/floats.c +@@ -378,9 +378,9 @@ CAMLprim value caml_log1p_float(value f) + union double_as_two_int32 { + double d; + #if defined(ARCH_BIG_ENDIAN) || (defined(__arm__) && !defined(__ARM_EABI__)) +- struct { uint32 h; uint32 l; } i; ++ struct { uint32_t h; uint32_t l; } i; + #else +- struct { uint32 l; uint32 h; } i; ++ struct { uint32_t l; uint32_t h; } i; + #endif + }; + +@@ -467,7 +467,7 @@ CAMLprim value caml_classify_float(value vd) + } + #else + union double_as_two_int32 u; +- uint32 h, l; ++ uint32_t h, l; + + u.d = Double_val(vd); + h = u.i.h; l = u.i.l; +diff --git a/byterun/globroots.c b/byterun/globroots.c +index ded393e..d9111ee 100644 +--- a/byterun/globroots.c ++++ b/byterun/globroots.c +@@ -43,11 +43,11 @@ struct global_root_list { + (i.e. 2 * (NUM_LEVELS - 1)). Moreover, the congruential PRNG + is faster and guaranteed to be deterministic (to reproduce bugs). */ + +-static uint32 random_seed = 0; ++static uint32_t random_seed = 0; + + static int random_level(void) + { +- uint32 r; ++ uint32_t r; + int level = 0; + + /* Linear congruence with modulus = 2^32, multiplier = 69069 +diff --git a/byterun/hash.c b/byterun/hash.c +index f896426..12912d3 100644 +--- a/byterun/hash.c ++++ b/byterun/hash.c +@@ -41,7 +41,7 @@ + h *= 0xc2b2ae35; \ + h ^= h >> 16; + +-CAMLexport uint32 caml_hash_mix_uint32(uint32 h, uint32 d) ++CAMLexport uint32_t caml_hash_mix_uint32(uint32_t h, uint32_t d) + { + MIX(h, d); + return h; +@@ -49,17 +49,17 @@ CAMLexport uint32 caml_hash_mix_uint32(uint32 h, uint32 d) + + /* Mix a platform-native integer. */ + +-CAMLexport uint32 caml_hash_mix_intnat(uint32 h, intnat d) ++CAMLexport uint32_t caml_hash_mix_intnat(uint32_t h, intnat d) + { +- uint32 n; ++ uint32_t n; + #ifdef ARCH_SIXTYFOUR + /* Mix the low 32 bits and the high 32 bits, in a way that preserves +- 32/64 compatibility: we want n = (uint32) d ++ 32/64 compatibility: we want n = (uint32_t) d + if d is in the range [-2^31, 2^31-1]. */ + n = (d >> 32) ^ (d >> 63) ^ d; + /* If 0 <= d < 2^31: d >> 32 = 0 d >> 63 = 0 + If -2^31 <= d < 0: d >> 32 = -1 d >> 63 = -1 +- In both cases, n = (uint32) d. */ ++ In both cases, n = (uint32_t) d. */ + #else + n = d; + #endif +@@ -69,9 +69,9 @@ CAMLexport uint32 caml_hash_mix_intnat(uint32 h, intnat d) + + /* Mix a 64-bit integer. */ + +-CAMLexport uint32 caml_hash_mix_int64(uint32 h, int64 d) ++CAMLexport uint32_t caml_hash_mix_int64(uint32_t h, int64_t d) + { +- uint32 hi = (uint32) (d >> 32), lo = (uint32) d; ++ uint32_t hi = (uint32_t) (d >> 32), lo = (uint32_t) d; + MIX(h, lo); + MIX(h, hi); + return h; +@@ -82,17 +82,17 @@ CAMLexport uint32 caml_hash_mix_int64(uint32 h, int64 d) + Treats all NaNs identically. + */ + +-CAMLexport uint32 caml_hash_mix_double(uint32 hash, double d) ++CAMLexport uint32_t caml_hash_mix_double(uint32_t hash, double d) + { + union { + double d; + #if defined(ARCH_BIG_ENDIAN) || (defined(__arm__) && !defined(__ARM_EABI__)) +- struct { uint32 h; uint32 l; } i; ++ struct { uint32_t h; uint32_t l; } i; + #else +- struct { uint32 l; uint32 h; } i; ++ struct { uint32_t l; uint32_t h; } i; + #endif + } u; +- uint32 h, l; ++ uint32_t h, l; + /* Convert to two 32-bit halves */ + u.d = d; + h = u.i.h; l = u.i.l; +@@ -115,14 +115,14 @@ CAMLexport uint32 caml_hash_mix_double(uint32 hash, double d) + Treats all NaNs identically. + */ + +-CAMLexport uint32 caml_hash_mix_float(uint32 hash, float d) ++CAMLexport uint32_t caml_hash_mix_float(uint32_t hash, float d) + { + union { + float f; +- uint32 i; ++ uint32_t i; + } u; +- uint32 n; +- /* Convert to int32 */ ++ uint32_t n; ++ /* Convert to int32_t */ + u.f = d; n = u.i; + /* Normalize NaNs */ + if ((n & 0x7F800000) == 0x7F800000 && (n & 0x007FFFFF) != 0) { +@@ -138,11 +138,11 @@ CAMLexport uint32 caml_hash_mix_float(uint32 hash, float d) + + /* Mix an OCaml string */ + +-CAMLexport uint32 caml_hash_mix_string(uint32 h, value s) ++CAMLexport uint32_t caml_hash_mix_string(uint32_t h, value s) + { + mlsize_t len = caml_string_length(s); + mlsize_t i; +- uint32 w; ++ uint32_t w; + + /* Mix by 32-bit blocks (little-endian) */ + for (i = 0; i + 4 <= len; i += 4) { +@@ -152,7 +152,7 @@ CAMLexport uint32 caml_hash_mix_string(uint32 h, value s) + | (Byte_u(s, i+2) << 16) + | (Byte_u(s, i+3) << 24); + #else +- w = *((uint32 *) &Byte_u(s, i)); ++ w = *((uint32_t *) &Byte_u(s, i)); + #endif + MIX(h, w); + } +@@ -166,7 +166,7 @@ CAMLexport uint32 caml_hash_mix_string(uint32 h, value s) + default: /*skip*/; /* len & 3 == 0, no extra bytes, do nothing */ + } + /* Finally, mix in the length. Ignore the upper 32 bits, generally 0. */ +- h ^= (uint32) len; ++ h ^= (uint32_t) len; + return h; + } + +@@ -184,7 +184,7 @@ CAMLprim value caml_hash(value count, value limit, value seed, value obj) + intnat wr; /* One past position of last value in queue */ + intnat sz; /* Max number of values to put in queue */ + intnat num; /* Max number of meaningful values to see */ +- uint32 h; /* Rolling hash */ ++ uint32_t h; /* Rolling hash */ + value v; + mlsize_t i, len; + +@@ -245,7 +245,7 @@ CAMLprim value caml_hash(value count, value limit, value seed, value obj) + /* If no hashing function provided, do nothing. */ + /* Only use low 32 bits of custom hash, for 32/64 compatibility */ + if (Custom_ops_val(v)->hash != NULL) { +- uint32 n = (uint32) Custom_ops_val(v)->hash(v); ++ uint32_t n = (uint32_t) Custom_ops_val(v)->hash(v); + h = caml_hash_mix_uint32(h, n); + num--; + } +@@ -408,5 +408,5 @@ CAMLexport value caml_hash_variant(char const * tag) + #endif + /* Force sign extension of bit 31 for compatibility between 32 and 64-bit + platforms */ +- return (int32) accu; ++ return (int32_t) accu; + } +diff --git a/byterun/hash.h b/byterun/hash.h +index 436a8bb..6561397 100644 +--- a/byterun/hash.h ++++ b/byterun/hash.h +@@ -18,12 +18,12 @@ + + #include "mlvalues.h" + +-CAMLextern uint32 caml_hash_mix_uint32(uint32 h, uint32 d); +-CAMLextern uint32 caml_hash_mix_intnat(uint32 h, intnat d); +-CAMLextern uint32 caml_hash_mix_int64(uint32 h, int64 d); +-CAMLextern uint32 caml_hash_mix_double(uint32 h, double d); +-CAMLextern uint32 caml_hash_mix_float(uint32 h, float d); +-CAMLextern uint32 caml_hash_mix_string(uint32 h, value s); ++CAMLextern uint32_t caml_hash_mix_uint32(uint32_t h, uint32_t d); ++CAMLextern uint32_t caml_hash_mix_intnat(uint32_t h, intnat d); ++CAMLextern uint32_t caml_hash_mix_int64(uint32_t h, int64_t d); ++CAMLextern uint32_t caml_hash_mix_double(uint32_t h, double d); ++CAMLextern uint32_t caml_hash_mix_float(uint32_t h, float d); ++CAMLextern uint32_t caml_hash_mix_string(uint32_t h, value s); + + + #endif +diff --git a/byterun/int64_emul.h b/byterun/int64_emul.h +index ba7904a..2554df1 100644 +--- a/byterun/int64_emul.h ++++ b/byterun/int64_emul.h +@@ -28,7 +28,7 @@ + #define I64_split(x,hi,lo) (hi = (x).h, lo = (x).l) + + /* Unsigned comparison */ +-static int I64_ucompare(uint64 x, uint64 y) ++static int I64_ucompare(uint64_t x, uint64_t y) + { + if (x.h > y.h) return 1; + if (x.h < y.h) return -1; +@@ -40,19 +40,19 @@ static int I64_ucompare(uint64 x, uint64 y) + #define I64_ult(x, y) (I64_ucompare(x, y) < 0) + + /* Signed comparison */ +-static int I64_compare(int64 x, int64 y) ++static int I64_compare(int64_t x, int64_t y) + { +- if ((int32)x.h > (int32)y.h) return 1; +- if ((int32)x.h < (int32)y.h) return -1; ++ if ((int32_t)x.h > (int32_t)y.h) return 1; ++ if ((int32_t)x.h < (int32_t)y.h) return -1; + if (x.l > y.l) return 1; + if (x.l < y.l) return -1; + return 0; + } + + /* Negation */ +-static int64 I64_neg(int64 x) ++static int64_t I64_neg(int64_t x) + { +- int64 res; ++ int64_t res; + res.l = -x.l; + res.h = ~x.h; + if (res.l == 0) res.h++; +@@ -60,9 +60,9 @@ static int64 I64_neg(int64 x) + } + + /* Addition */ +-static int64 I64_add(int64 x, int64 y) ++static int64_t I64_add(int64_t x, int64_t y) + { +- int64 res; ++ int64_t res; + res.l = x.l + y.l; + res.h = x.h + y.h; + if (res.l < x.l) res.h++; +@@ -70,9 +70,9 @@ static int64 I64_add(int64 x, int64 y) + } + + /* Subtraction */ +-static int64 I64_sub(int64 x, int64 y) ++static int64_t I64_sub(int64_t x, int64_t y) + { +- int64 res; ++ int64_t res; + res.l = x.l - y.l; + res.h = x.h - y.h; + if (x.l < y.l) res.h--; +@@ -80,13 +80,13 @@ static int64 I64_sub(int64 x, int64 y) + } + + /* Multiplication */ +-static int64 I64_mul(int64 x, int64 y) ++static int64_t I64_mul(int64_t x, int64_t y) + { +- int64 res; +- uint32 prod00 = (x.l & 0xFFFF) * (y.l & 0xFFFF); +- uint32 prod10 = (x.l >> 16) * (y.l & 0xFFFF); +- uint32 prod01 = (x.l & 0xFFFF) * (y.l >> 16); +- uint32 prod11 = (x.l >> 16) * (y.l >> 16); ++ int64_t res; ++ uint32_t prod00 = (x.l & 0xFFFF) * (y.l & 0xFFFF); ++ uint32_t prod10 = (x.l >> 16) * (y.l & 0xFFFF); ++ uint32_t prod01 = (x.l & 0xFFFF) * (y.l >> 16); ++ uint32_t prod11 = (x.l >> 16) * (y.l >> 16); + res.l = prod00; + res.h = prod11 + (prod01 >> 16) + (prod10 >> 16); + prod01 = prod01 << 16; res.l += prod01; if (res.l < prod01) res.h++; +@@ -96,39 +96,39 @@ static int64 I64_mul(int64 x, int64 y) + } + + #define I64_is_zero(x) (((x).l | (x).h) == 0) +-#define I64_is_negative(x) ((int32) (x).h < 0) ++#define I64_is_negative(x) ((int32_t) (x).h < 0) + #define I64_is_min_int(x) ((x).l == 0 && (x).h == 0x80000000U) + #define I64_is_minus_one(x) (((x).l & (x).h) == 0xFFFFFFFFU) + + /* Bitwise operations */ +-static int64 I64_and(int64 x, int64 y) ++static int64_t I64_and(int64_t x, int64_t y) + { +- int64 res; ++ int64_t res; + res.l = x.l & y.l; + res.h = x.h & y.h; + return res; + } + +-static int64 I64_or(int64 x, int64 y) ++static int64_t I64_or(int64_t x, int64_t y) + { +- int64 res; ++ int64_t res; + res.l = x.l | y.l; + res.h = x.h | y.h; + return res; + } + +-static int64 I64_xor(int64 x, int64 y) ++static int64_t I64_xor(int64_t x, int64_t y) + { +- int64 res; ++ int64_t res; + res.l = x.l ^ y.l; + res.h = x.h ^ y.h; + return res; + } + + /* Shifts */ +-static int64 I64_lsl(int64 x, int s) ++static int64_t I64_lsl(int64_t x, int s) + { +- int64 res; ++ int64_t res; + s = s & 63; + if (s == 0) return x; + if (s < 32) { +@@ -141,9 +141,9 @@ static int64 I64_lsl(int64 x, int s) + return res; + } + +-static int64 I64_lsr(int64 x, int s) ++static int64_t I64_lsr(int64_t x, int s) + { +- int64 res; ++ int64_t res; + s = s & 63; + if (s == 0) return x; + if (s < 32) { +@@ -156,17 +156,17 @@ static int64 I64_lsr(int64 x, int s) + return res; + } + +-static int64 I64_asr(int64 x, int s) ++static int64_t I64_asr(int64_t x, int s) + { +- int64 res; ++ int64_t res; + s = s & 63; + if (s == 0) return x; + if (s < 32) { + res.l = (x.l >> s) | (x.h << (32 - s)); +- res.h = (int32) x.h >> s; ++ res.h = (int32_t) x.h >> s; + } else { +- res.l = (int32) x.h >> (s - 32); +- res.h = (int32) x.h >> 31; ++ res.l = (int32_t) x.h >> (s - 32); ++ res.h = (int32_t) x.h >> 31; + } + return res; + } +@@ -176,15 +176,15 @@ static int64 I64_asr(int64 x, int s) + #define I64_SHL1(x) x.h = (x.h << 1) | (x.l >> 31); x.l <<= 1 + #define I64_SHR1(x) x.l = (x.l >> 1) | (x.h << 31); x.h >>= 1 + +-static void I64_udivmod(uint64 modulus, uint64 divisor, +- uint64 * quo, uint64 * mod) ++static void I64_udivmod(uint64_t modulus, uint64_t divisor, ++ uint64_t * quo, uint64_t * mod) + { +- int64 quotient, mask; ++ int64_t quotient, mask; + int cmp; + + quotient.h = 0; quotient.l = 0; + mask.h = 0; mask.l = 1; +- while ((int32) divisor.h >= 0) { ++ while ((int32_t) divisor.h >= 0) { + cmp = I64_ucompare(divisor, modulus); + I64_SHL1(divisor); + I64_SHL1(mask); +@@ -202,27 +202,27 @@ static void I64_udivmod(uint64 modulus, uint64 divisor, + *mod = modulus; + } + +-static int64 I64_div(int64 x, int64 y) ++static int64_t I64_div(int64_t x, int64_t y) + { +- int64 q, r; +- int32 sign; ++ int64_t q, r; ++ int32_t sign; + + sign = x.h ^ y.h; +- if ((int32) x.h < 0) x = I64_neg(x); +- if ((int32) y.h < 0) y = I64_neg(y); ++ if ((int32_t) x.h < 0) x = I64_neg(x); ++ if ((int32_t) y.h < 0) y = I64_neg(y); + I64_udivmod(x, y, &q, &r); + if (sign < 0) q = I64_neg(q); + return q; + } + +-static int64 I64_mod(int64 x, int64 y) ++static int64_t I64_mod(int64_t x, int64_t y) + { +- int64 q, r; +- int32 sign; ++ int64_t q, r; ++ int32_t sign; + + sign = x.h; +- if ((int32) x.h < 0) x = I64_neg(x); +- if ((int32) y.h < 0) y = I64_neg(y); ++ if ((int32_t) x.h < 0) x = I64_neg(x); ++ if ((int32_t) y.h < 0) y = I64_neg(y); + I64_udivmod(x, y, &q, &r); + if (sign < 0) r = I64_neg(r); + return r; +@@ -230,49 +230,49 @@ static int64 I64_mod(int64 x, int64 y) + + /* Coercions */ + +-static int64 I64_of_int32(int32 x) ++static int64_t I64_of_int32(int32_t x) + { +- int64 res; ++ int64_t res; + res.l = x; + res.h = x >> 31; + return res; + } + +-#define I64_to_int32(x) ((int32) (x).l) ++#define I64_to_int32(x) ((int32_t) (x).l) + + /* Note: we assume sizeof(intnat) = 4 here, which is true otherwise + autoconfiguration would have selected native 64-bit integers */ + #define I64_of_intnat I64_of_int32 + #define I64_to_intnat I64_to_int32 + +-static double I64_to_double(int64 x) ++static double I64_to_double(int64_t x) + { + double res; +- int32 sign = x.h; ++ int32_t sign = x.h; + if (sign < 0) x = I64_neg(x); + res = ldexp((double) x.h, 32) + x.l; + if (sign < 0) res = -res; + return res; + } + +-static int64 I64_of_double(double f) ++static int64_t I64_of_double(double f) + { +- int64 res; ++ int64_t res; + double frac, integ; + int neg; + + neg = (f < 0); + f = fabs(f); + frac = modf(ldexp(f, -32), &integ); +- res.h = (uint32) integ; +- res.l = (uint32) ldexp(frac, 32); ++ res.h = (uint32_t) integ; ++ res.l = (uint32_t) ldexp(frac, 32); + if (neg) res = I64_neg(res); + return res; + } + +-static int64 I64_bswap(int64 x) ++static int64_t I64_bswap(int64_t x) + { +- int64 res; ++ int64_t res; + res.h = (((x.l & 0x000000FF) << 24) | + ((x.l & 0x0000FF00) << 8) | + ((x.l & 0x00FF0000) >> 8) | +diff --git a/byterun/int64_format.h b/byterun/int64_format.h +index b0de527..aa8f1ab 100644 +--- a/byterun/int64_format.h ++++ b/byterun/int64_format.h +@@ -17,7 +17,7 @@ + #ifndef CAML_INT64_FORMAT_H + #define CAML_INT64_FORMAT_H + +-static void I64_format(char * buffer, char * fmt, int64 x) ++static void I64_format(char * buffer, char * fmt, int64_t x) + { + static char conv_lower[] = "0123456789abcdef"; + static char conv_upper[] = "0123456789ABCDEF"; +@@ -26,7 +26,7 @@ static void I64_format(char * buffer, char * fmt, int64 x) + int base, width, sign, i, rawlen; + char * cvtbl; + char * p, * r; +- int64 wbase, digit; ++ int64_t wbase, digit; + + /* Parsing of format */ + justify = '+'; +diff --git a/byterun/int64_native.h b/byterun/int64_native.h +index e9ffe67..b6716ad 100644 +--- a/byterun/int64_native.h ++++ b/byterun/int64_native.h +@@ -18,36 +18,36 @@ + #ifndef CAML_INT64_NATIVE_H + #define CAML_INT64_NATIVE_H + +-#define I64_literal(hi,lo) ((int64)(hi) << 32 | (lo)) +-#define I64_split(x,hi,lo) (hi = (uint32)((x)>>32), lo = (uint32)(x)) ++#define I64_literal(hi,lo) ((int64_t)(hi) << 32 | (lo)) ++#define I64_split(x,hi,lo) (hi = (uint32_t)((x)>>32), lo = (uint32_t)(x)) + #define I64_compare(x,y) (((x) > (y)) - ((x) < (y))) +-#define I64_ult(x,y) ((uint64)(x) < (uint64)(y)) ++#define I64_ult(x,y) ((uint64_t)(x) < (uint64_t)(y)) + #define I64_neg(x) (-(x)) + #define I64_add(x,y) ((x) + (y)) + #define I64_sub(x,y) ((x) - (y)) + #define I64_mul(x,y) ((x) * (y)) + #define I64_is_zero(x) ((x) == 0) + #define I64_is_negative(x) ((x) < 0) +-#define I64_is_min_int(x) ((x) == ((int64)1 << 63)) ++#define I64_is_min_int(x) ((x) == ((int64_t)1 << 63)) + #define I64_is_minus_one(x) ((x) == -1) + + #define I64_div(x,y) ((x) / (y)) + #define I64_mod(x,y) ((x) % (y)) + #define I64_udivmod(x,y,quo,rem) \ +- (*(rem) = (uint64)(x) % (uint64)(y), \ +- *(quo) = (uint64)(x) / (uint64)(y)) ++ (*(rem) = (uint64_t)(x) % (uint64_t)(y), \ ++ *(quo) = (uint64_t)(x) / (uint64_t)(y)) + #define I64_and(x,y) ((x) & (y)) + #define I64_or(x,y) ((x) | (y)) + #define I64_xor(x,y) ((x) ^ (y)) + #define I64_lsl(x,y) ((x) << (y)) + #define I64_asr(x,y) ((x) >> (y)) +-#define I64_lsr(x,y) ((uint64)(x) >> (y)) ++#define I64_lsr(x,y) ((uint64_t)(x) >> (y)) + #define I64_to_intnat(x) ((intnat) (x)) + #define I64_of_intnat(x) ((intnat) (x)) +-#define I64_to_int32(x) ((int32) (x)) +-#define I64_of_int32(x) ((int64) (x)) ++#define I64_to_int32(x) ((int32_t) (x)) ++#define I64_of_int32(x) ((int64_t) (x)) + #define I64_to_double(x) ((double)(x)) +-#define I64_of_double(x) ((int64)(x)) ++#define I64_of_double(x) ((int64_t)(x)) + + #define I64_bswap(x) ((((x) & 0x00000000000000FFULL) << 56) | \ + (((x) & 0x000000000000FF00ULL) << 40) | \ +diff --git a/byterun/intern.c b/byterun/intern.c +index e0fcc5d..638ff72 100644 +--- a/byterun/intern.c ++++ b/byterun/intern.c +@@ -553,7 +553,7 @@ static void intern_add_to_heap(mlsize_t whsize) + + value caml_input_val(struct channel *chan) + { +- uint32 magic; ++ uint32_t magic; + mlsize_t block_len, num_objects, whsize; + char * block; + value res; +@@ -663,7 +663,7 @@ static value input_val_from_block(void) + + CAMLexport value caml_input_value_from_malloc(char * data, intnat ofs) + { +- uint32 magic; ++ uint32_t magic; + value obj; + + intern_input = (unsigned char *) data; +@@ -681,7 +681,7 @@ CAMLexport value caml_input_value_from_malloc(char * data, intnat ofs) + + CAMLexport value caml_input_value_from_block(char * data, intnat len) + { +- uint32 magic; ++ uint32_t magic; + mlsize_t block_len; + value obj; + +@@ -700,7 +700,7 @@ CAMLexport value caml_input_value_from_block(char * data, intnat len) + + CAMLprim value caml_marshal_data_size(value buff, value ofs) + { +- uint32 magic; ++ uint32_t magic; + mlsize_t block_len; + + intern_src = &Byte_u(buff, Long_val(ofs)); +@@ -771,26 +771,26 @@ CAMLexport int caml_deserialize_sint_2(void) + return read16s(); + } + +-CAMLexport uint32 caml_deserialize_uint_4(void) ++CAMLexport uint32_t caml_deserialize_uint_4(void) + { + return read32u(); + } + +-CAMLexport int32 caml_deserialize_sint_4(void) ++CAMLexport int32_t caml_deserialize_sint_4(void) + { + return read32s(); + } + +-CAMLexport uint64 caml_deserialize_uint_8(void) ++CAMLexport uint64_t caml_deserialize_uint_8(void) + { +- uint64 i; ++ uint64_t i; + caml_deserialize_block_8(&i, 1); + return i; + } + +-CAMLexport int64 caml_deserialize_sint_8(void) ++CAMLexport int64_t caml_deserialize_sint_8(void) + { +- int64 i; ++ int64_t i; + caml_deserialize_block_8(&i, 1); + return i; + } +diff --git a/byterun/interp.c b/byterun/interp.c +index 9b682ba..e22b28b 100644 +--- a/byterun/interp.c ++++ b/byterun/interp.c +@@ -793,7 +793,7 @@ value caml_interprete(code_t prog, asize_t prog_size) + if (accu == Val_false) pc += *pc; else pc++; + Next; + Instruct(SWITCH): { +- uint32 sizes = *pc++; ++ uint32_t sizes = *pc++; + if (Is_block(accu)) { + intnat index = Tag_val(accu); + Assert ((uintnat) index < (sizes >> 16)); +diff --git a/byterun/intext.h b/byterun/intext.h +index f7aa655..2c108a4 100644 +--- a/byterun/intext.h ++++ b/byterun/intext.h +@@ -119,8 +119,8 @@ CAMLextern value caml_input_value_from_block(char * data, intnat len); + + CAMLextern void caml_serialize_int_1(int i); + CAMLextern void caml_serialize_int_2(int i); +-CAMLextern void caml_serialize_int_4(int32 i); +-CAMLextern void caml_serialize_int_8(int64 i); ++CAMLextern void caml_serialize_int_4(int32_t i); ++CAMLextern void caml_serialize_int_8(int64_t i); + CAMLextern void caml_serialize_float_4(float f); + CAMLextern void caml_serialize_float_8(double f); + CAMLextern void caml_serialize_block_1(void * data, intnat len); +@@ -133,10 +133,10 @@ CAMLextern int caml_deserialize_uint_1(void); + CAMLextern int caml_deserialize_sint_1(void); + CAMLextern int caml_deserialize_uint_2(void); + CAMLextern int caml_deserialize_sint_2(void); +-CAMLextern uint32 caml_deserialize_uint_4(void); +-CAMLextern int32 caml_deserialize_sint_4(void); +-CAMLextern uint64 caml_deserialize_uint_8(void); +-CAMLextern int64 caml_deserialize_sint_8(void); ++CAMLextern uint32_t caml_deserialize_uint_4(void); ++CAMLextern int32_t caml_deserialize_sint_4(void); ++CAMLextern uint64_t caml_deserialize_uint_8(void); ++CAMLextern int64_t caml_deserialize_sint_8(void); + CAMLextern float caml_deserialize_float_4(void); + CAMLextern double caml_deserialize_float_8(void); + CAMLextern void caml_deserialize_block_1(void * data, intnat len); +diff --git a/byterun/ints.c b/byterun/ints.c +index d762c76..056e82a 100644 +--- a/byterun/ints.c ++++ b/byterun/ints.c +@@ -172,8 +172,8 @@ CAMLprim value caml_format_int(value fmt, value arg) + + static int int32_cmp(value v1, value v2) + { +- int32 i1 = Int32_val(v1); +- int32 i2 = Int32_val(v2); ++ int32_t i1 = Int32_val(v1); ++ int32_t i2 = Int32_val(v2); + return (i1 > i2) - (i1 < i2); + } + +@@ -191,7 +191,7 @@ static void int32_serialize(value v, uintnat * wsize_32, + + static uintnat int32_deserialize(void * dst) + { +- *((int32 *) dst) = caml_deserialize_sint_4(); ++ *((int32_t *) dst) = caml_deserialize_sint_4(); + return 4; + } + +@@ -205,7 +205,7 @@ CAMLexport struct custom_operations caml_int32_ops = { + custom_compare_ext_default + }; + +-CAMLexport value caml_copy_int32(int32 i) ++CAMLexport value caml_copy_int32(int32_t i) + { + value res = caml_alloc_custom(&caml_int32_ops, 4, 0, 1); + Int32_val(res) = i; +@@ -226,8 +226,8 @@ CAMLprim value caml_int32_mul(value v1, value v2) + + CAMLprim value caml_int32_div(value v1, value v2) + { +- int32 dividend = Int32_val(v1); +- int32 divisor = Int32_val(v2); ++ int32_t dividend = Int32_val(v1); ++ int32_t divisor = Int32_val(v2); + if (divisor == 0) caml_raise_zero_divide(); + /* PR#4740: on some processors, division crashes on overflow. + Implement the same behavior as for type "int". */ +@@ -237,8 +237,8 @@ CAMLprim value caml_int32_div(value v1, value v2) + + CAMLprim value caml_int32_mod(value v1, value v2) + { +- int32 dividend = Int32_val(v1); +- int32 divisor = Int32_val(v2); ++ int32_t dividend = Int32_val(v1); ++ int32_t divisor = Int32_val(v2); + if (divisor == 0) caml_raise_zero_divide(); + /* PR#4740: on some processors, modulus crashes if division overflows. + Implement the same behavior as for type "int". */ +@@ -262,9 +262,9 @@ CAMLprim value caml_int32_shift_right(value v1, value v2) + { return caml_copy_int32(Int32_val(v1) >> Int_val(v2)); } + + CAMLprim value caml_int32_shift_right_unsigned(value v1, value v2) +-{ return caml_copy_int32((uint32)Int32_val(v1) >> Int_val(v2)); } ++{ return caml_copy_int32((uint32_t)Int32_val(v1) >> Int_val(v2)); } + +-static int32 caml_swap32(int32 x) ++static int32_t caml_swap32(int32_t x) + { + return (((x & 0x000000FF) << 24) | + ((x & 0x0000FF00) << 8) | +@@ -285,15 +285,15 @@ CAMLprim value caml_int32_to_int(value v) + { return Val_long(Int32_val(v)); } + + CAMLprim value caml_int32_of_float(value v) +-{ return caml_copy_int32((int32)(Double_val(v))); } ++{ return caml_copy_int32((int32_t)(Double_val(v))); } + + CAMLprim value caml_int32_to_float(value v) + { return caml_copy_double((double)(Int32_val(v))); } + + CAMLprim value caml_int32_compare(value v1, value v2) + { +- int32 i1 = Int32_val(v1); +- int32 i2 = Int32_val(v2); ++ int32_t i1 = Int32_val(v1); ++ int32_t i2 = Int32_val(v2); + int res = (i1 > i2) - (i1 < i2); + return Val_int(res); + } +@@ -313,14 +313,14 @@ CAMLprim value caml_int32_of_string(value s) + + CAMLprim value caml_int32_bits_of_float(value vd) + { +- union { float d; int32 i; } u; ++ union { float d; int32_t i; } u; + u.d = Double_val(vd); + return caml_copy_int32(u.i); + } + + CAMLprim value caml_int32_float_of_bits(value vi) + { +- union { float d; int32 i; } u; ++ union { float d; int32_t i; } u; + u.i = Int32_val(vi); + return caml_copy_double(u.d); + } +@@ -329,11 +329,11 @@ CAMLprim value caml_int32_float_of_bits(value vi) + + #ifdef ARCH_ALIGN_INT64 + +-CAMLexport int64 caml_Int64_val(value v) ++CAMLexport int64_t caml_Int64_val(value v) + { +- union { int32 i[2]; int64 j; } buffer; +- buffer.i[0] = ((int32 *) Data_custom_val(v))[0]; +- buffer.i[1] = ((int32 *) Data_custom_val(v))[1]; ++ union { int32_t i[2]; int64_t j; } buffer; ++ buffer.i[0] = ((int32_t *) Data_custom_val(v))[0]; ++ buffer.i[1] = ((int32_t *) Data_custom_val(v))[1]; + return buffer.j; + } + +@@ -341,15 +341,15 @@ CAMLexport int64 caml_Int64_val(value v) + + static int int64_cmp(value v1, value v2) + { +- int64 i1 = Int64_val(v1); +- int64 i2 = Int64_val(v2); ++ int64_t i1 = Int64_val(v1); ++ int64_t i2 = Int64_val(v2); + return (i1 > i2) - (i1 < i2); + } + + static intnat int64_hash(value v) + { +- int64 x = Int64_val(v); +- uint32 lo = (uint32) x, hi = (uint32) (x >> 32); ++ int64_t x = Int64_val(v); ++ uint32_t lo = (uint32_t) x, hi = (uint32_t) (x >> 32); + return hi ^ lo; + } + +@@ -363,12 +363,12 @@ static void int64_serialize(value v, uintnat * wsize_32, + static uintnat int64_deserialize(void * dst) + { + #ifndef ARCH_ALIGN_INT64 +- *((int64 *) dst) = caml_deserialize_sint_8(); ++ *((int64_t *) dst) = caml_deserialize_sint_8(); + #else +- union { int32 i[2]; int64 j; } buffer; ++ union { int32_t i[2]; int64_t j; } buffer; + buffer.j = caml_deserialize_sint_8(); +- ((int32 *) dst)[0] = buffer.i[0]; +- ((int32 *) dst)[1] = buffer.i[1]; ++ ((int32_t *) dst)[0] = buffer.i[0]; ++ ((int32_t *) dst)[1] = buffer.i[1]; + #endif + return 8; + } +@@ -383,16 +383,16 @@ CAMLexport struct custom_operations caml_int64_ops = { + custom_compare_ext_default + }; + +-CAMLexport value caml_copy_int64(int64 i) ++CAMLexport value caml_copy_int64(int64_t i) + { + value res = caml_alloc_custom(&caml_int64_ops, 8, 0, 1); + #ifndef ARCH_ALIGN_INT64 + Int64_val(res) = i; + #else +- union { int32 i[2]; int64 j; } buffer; ++ union { int32_t i[2]; int64_t j; } buffer; + buffer.j = i; +- ((int32 *) Data_custom_val(res))[0] = buffer.i[0]; +- ((int32 *) Data_custom_val(res))[1] = buffer.i[1]; ++ ((int32_t *) Data_custom_val(res))[0] = buffer.i[0]; ++ ((int32_t *) Data_custom_val(res))[1] = buffer.i[1]; + #endif + return res; + } +@@ -413,23 +413,23 @@ CAMLprim value caml_int64_mul(value v1, value v2) + + CAMLprim value caml_int64_div(value v1, value v2) + { +- int64 dividend = Int64_val(v1); +- int64 divisor = Int64_val(v2); ++ int64_t dividend = Int64_val(v1); ++ int64_t divisor = Int64_val(v2); + if (divisor == 0) caml_raise_zero_divide(); + /* PR#4740: on some processors, division crashes on overflow. + Implement the same behavior as for type "int". */ +- if (dividend == ((int64)1 << 63) && divisor == -1) return v1; ++ if (dividend == ((int64_t)1 << 63) && divisor == -1) return v1; + return caml_copy_int64(Int64_val(v1) / divisor); + } + + CAMLprim value caml_int64_mod(value v1, value v2) + { +- int64 dividend = Int64_val(v1); +- int64 divisor = Int64_val(v2); ++ int64_t dividend = Int64_val(v1); ++ int64_t divisor = Int64_val(v2); + if (divisor == 0) caml_raise_zero_divide(); + /* PR#4740: on some processors, division crashes on overflow. + Implement the same behavior as for type "int". */ +- if (dividend == ((int64)1 << 63) && divisor == -1) return caml_copy_int64(0); ++ if (dividend == ((int64_t)1 << 63) && divisor == -1) return caml_copy_int64(0); + return caml_copy_int64(Int64_val(v1) % divisor); + } + +@@ -449,7 +449,7 @@ CAMLprim value caml_int64_shift_right(value v1, value v2) + { return caml_copy_int64(Int64_val(v1) >> Int_val(v2)); } + + CAMLprim value caml_int64_shift_right_unsigned(value v1, value v2) +-{ return caml_copy_int64((uint64) (Int64_val(v1)) >> Int_val(v2)); } ++{ return caml_copy_int64((uint64_t) (Int64_val(v1)) >> Int_val(v2)); } + + #ifdef ARCH_SIXTYFOUR + static value caml_swap64(value x) +@@ -470,7 +470,7 @@ value caml_int64_direct_bswap(value v) + + CAMLprim value caml_int64_bswap(value v) + { +- int64 x = Int64_val(v); ++ int64_t x = Int64_val(v); + return caml_copy_int64 + (((x & 0x00000000000000FFULL) << 56) | + ((x & 0x000000000000FF00ULL) << 40) | +@@ -483,33 +483,33 @@ CAMLprim value caml_int64_bswap(value v) + } + + CAMLprim value caml_int64_of_int(value v) +-{ return caml_copy_int64((int64) (Long_val(v))); } ++{ return caml_copy_int64((int64_t) (Long_val(v))); } + + CAMLprim value caml_int64_to_int(value v) + { return Val_long((intnat) (Int64_val(v))); } + + CAMLprim value caml_int64_of_float(value v) +-{ return caml_copy_int64((int64) (Double_val(v))); } ++{ return caml_copy_int64((int64_t) (Double_val(v))); } + + CAMLprim value caml_int64_to_float(value v) + { return caml_copy_double((double) (Int64_val(v))); } + + CAMLprim value caml_int64_of_int32(value v) +-{ return caml_copy_int64((int64) (Int32_val(v))); } ++{ return caml_copy_int64((int64_t) (Int32_val(v))); } + + CAMLprim value caml_int64_to_int32(value v) +-{ return caml_copy_int32((int32) (Int64_val(v))); } ++{ return caml_copy_int32((int32_t) (Int64_val(v))); } + + CAMLprim value caml_int64_of_nativeint(value v) +-{ return caml_copy_int64((int64) (Nativeint_val(v))); } ++{ return caml_copy_int64((int64_t) (Nativeint_val(v))); } + + CAMLprim value caml_int64_to_nativeint(value v) + { return caml_copy_nativeint((intnat) (Int64_val(v))); } + + CAMLprim value caml_int64_compare(value v1, value v2) + { +- int64 i1 = Int64_val(v1); +- int64 i2 = Int64_val(v2); ++ int64_t i1 = Int64_val(v1); ++ int64_t i2 = Int64_val(v2); + return Val_int((i1 > i2) - (i1 < i2)); + } + +@@ -524,11 +524,11 @@ CAMLprim value caml_int64_format(value fmt, value arg) + CAMLprim value caml_int64_of_string(value s) + { + char * p; +- uint64 res, threshold; ++ uint64_t res, threshold; + int sign, base, d; + + p = parse_sign_and_base(String_val(s), &base, &sign); +- threshold = ((uint64) -1) / base; ++ threshold = ((uint64_t) -1) / base; + d = parse_digit(*p); + if (d < 0 || d >= base) caml_failwith("int_of_string"); + res = d; +@@ -541,7 +541,7 @@ CAMLprim value caml_int64_of_string(value s) + if (res > threshold) caml_failwith("int_of_string"); + res = base * res + d; + /* Detect overflow in addition (base * res) + d */ +- if (res < (uint64) d) caml_failwith("int_of_string"); ++ if (res < (uint64_t) d) caml_failwith("int_of_string"); + } + if (p != String_val(s) + caml_string_length(s)){ + caml_failwith("int_of_string"); +@@ -549,9 +549,9 @@ CAMLprim value caml_int64_of_string(value s) + if (base == 10) { + /* Signed representation expected, allow -2^63 to 2^63 - 1 only */ + if (sign >= 0) { +- if (res >= (uint64)1 << 63) caml_failwith("int_of_string"); ++ if (res >= (uint64_t)1 << 63) caml_failwith("int_of_string"); + } else { +- if (res > (uint64)1 << 63) caml_failwith("int_of_string"); ++ if (res > (uint64_t)1 << 63) caml_failwith("int_of_string"); + } + } + if (sign < 0) res = - res; +@@ -560,20 +560,20 @@ CAMLprim value caml_int64_of_string(value s) + + CAMLprim value caml_int64_bits_of_float(value vd) + { +- union { double d; int64 i; int32 h[2]; } u; ++ union { double d; int64_t i; int32_t h[2]; } u; + u.d = Double_val(vd); + #if defined(__arm__) && !defined(__ARM_EABI__) +- { int32 t = u.h[0]; u.h[0] = u.h[1]; u.h[1] = t; } ++ { int32_t t = u.h[0]; u.h[0] = u.h[1]; u.h[1] = t; } + #endif + return caml_copy_int64(u.i); + } + + CAMLprim value caml_int64_float_of_bits(value vi) + { +- union { double d; int64 i; int32 h[2]; } u; ++ union { double d; int64_t i; int32_t h[2]; } u; + u.i = Int64_val(vi); + #if defined(__arm__) && !defined(__ARM_EABI__) +- { int32 t = u.h[0]; u.h[0] = u.h[1]; u.h[1] = t; } ++ { int32_t t = u.h[0]; u.h[0] = u.h[1]; u.h[1] = t; } + #endif + return caml_copy_double(u.d); + } +@@ -606,7 +606,7 @@ static void nativeint_serialize(value v, uintnat * wsize_32, + #ifdef ARCH_SIXTYFOUR + if (l >= -((intnat)1 << 31) && l < ((intnat)1 << 31)) { + caml_serialize_int_1(1); +- caml_serialize_int_4((int32) l); ++ caml_serialize_int_4((int32_t) l); + } else { + caml_serialize_int_1(2); + caml_serialize_int_8(l); +diff --git a/byterun/io.c b/byterun/io.c +index 5f04a96..bedc0f0 100644 +--- a/byterun/io.c ++++ b/byterun/io.c +@@ -207,7 +207,7 @@ CAMLexport void caml_flush(struct channel *channel) + + /* Output data */ + +-CAMLexport void caml_putword(struct channel *channel, uint32 w) ++CAMLexport void caml_putword(struct channel *channel, uint32_t w) + { + if (! caml_channel_binary_mode(channel)) + caml_failwith("output_binary_int: not a binary channel"); +@@ -303,10 +303,10 @@ CAMLexport unsigned char caml_refill(struct channel *channel) + return (unsigned char)(channel->buff[0]); + } + +-CAMLexport uint32 caml_getword(struct channel *channel) ++CAMLexport uint32_t caml_getword(struct channel *channel) + { + int i; +- uint32 res; ++ uint32_t res; + + if (! caml_channel_binary_mode(channel)) + caml_failwith("input_binary_int: not a binary channel"); +diff --git a/byterun/io.h b/byterun/io.h +index 64a8bf5..5a9c037 100644 +--- a/byterun/io.h ++++ b/byterun/io.h +@@ -78,12 +78,12 @@ CAMLextern value caml_alloc_channel(struct channel *chan); + + CAMLextern int caml_flush_partial (struct channel *); + CAMLextern void caml_flush (struct channel *); +-CAMLextern void caml_putword (struct channel *, uint32); ++CAMLextern void caml_putword (struct channel *, uint32_t); + CAMLextern int caml_putblock (struct channel *, char *, intnat); + CAMLextern void caml_really_putblock (struct channel *, char *, intnat); + + CAMLextern unsigned char caml_refill (struct channel *); +-CAMLextern uint32 caml_getword (struct channel *); ++CAMLextern uint32_t caml_getword (struct channel *); + CAMLextern int caml_getblock (struct channel *, char *, intnat); + CAMLextern int caml_really_getblock (struct channel *, char *, intnat); + +@@ -107,7 +107,7 @@ CAMLextern struct channel * caml_all_opened_channels; + #define Unlock_exn() \ + if (caml_channel_mutex_unlock_exn != NULL) (*caml_channel_mutex_unlock_exn)() + +-/* Conversion between file_offset and int64 */ ++/* Conversion between file_offset and int64_t */ + + #define Val_file_offset(fofs) caml_copy_int64(fofs) + #define File_offset_val(v) ((file_offset) Int64_val(v)) +diff --git a/byterun/md5.c b/byterun/md5.c +index 10ac76a..2dc90a2 100644 +--- a/byterun/md5.c ++++ b/byterun/md5.c +@@ -97,11 +97,11 @@ CAMLexport void caml_md5_block(unsigned char digest[16], + #else + static void byteReverse(unsigned char * buf, unsigned longs) + { +- uint32 t; ++ uint32_t t; + do { +- t = (uint32) ((unsigned) buf[3] << 8 | buf[2]) << 16 | ++ t = (uint32_t) ((unsigned) buf[3] << 8 | buf[2]) << 16 | + ((unsigned) buf[1] << 8 | buf[0]); +- *(uint32 *) buf = t; ++ *(uint32_t *) buf = t; + buf += 4; + } while (--longs); + } +@@ -129,12 +129,12 @@ CAMLexport void caml_MD5Init(struct MD5Context *ctx) + CAMLexport void caml_MD5Update(struct MD5Context *ctx, unsigned char *buf, + uintnat len) + { +- uint32 t; ++ uint32_t t; + + /* Update bitcount */ + + t = ctx->bits[0]; +- if ((ctx->bits[0] = t + ((uint32) len << 3)) < t) ++ if ((ctx->bits[0] = t + ((uint32_t) len << 3)) < t) + ctx->bits[1]++; /* Carry from low to high */ + ctx->bits[1] += len >> 29; + +@@ -152,7 +152,7 @@ CAMLexport void caml_MD5Update(struct MD5Context *ctx, unsigned char *buf, + } + memcpy(p, buf, t); + byteReverse(ctx->in, 16); +- caml_MD5Transform(ctx->buf, (uint32 *) ctx->in); ++ caml_MD5Transform(ctx->buf, (uint32_t *) ctx->in); + buf += t; + len -= t; + } +@@ -161,7 +161,7 @@ CAMLexport void caml_MD5Update(struct MD5Context *ctx, unsigned char *buf, + while (len >= 64) { + memcpy(ctx->in, buf, 64); + byteReverse(ctx->in, 16); +- caml_MD5Transform(ctx->buf, (uint32 *) ctx->in); ++ caml_MD5Transform(ctx->buf, (uint32_t *) ctx->in); + buf += 64; + len -= 64; + } +@@ -196,7 +196,7 @@ CAMLexport void caml_MD5Final(unsigned char *digest, struct MD5Context *ctx) + /* Two lots of padding: Pad the first block to 64 bytes */ + memset(p, 0, count); + byteReverse(ctx->in, 16); +- caml_MD5Transform(ctx->buf, (uint32 *) ctx->in); ++ caml_MD5Transform(ctx->buf, (uint32_t *) ctx->in); + + /* Now fill the next block with 56 bytes */ + memset(ctx->in, 0, 56); +@@ -207,10 +207,10 @@ CAMLexport void caml_MD5Final(unsigned char *digest, struct MD5Context *ctx) + byteReverse(ctx->in, 14); + + /* Append length in bits and transform */ +- ((uint32 *) ctx->in)[14] = ctx->bits[0]; +- ((uint32 *) ctx->in)[15] = ctx->bits[1]; ++ ((uint32_t *) ctx->in)[14] = ctx->bits[0]; ++ ((uint32_t *) ctx->in)[15] = ctx->bits[1]; + +- caml_MD5Transform(ctx->buf, (uint32 *) ctx->in); ++ caml_MD5Transform(ctx->buf, (uint32_t *) ctx->in); + byteReverse((unsigned char *) ctx->buf, 4); + memcpy(digest, ctx->buf, 16); + memset(ctx, 0, sizeof(*ctx)); /* In case it's sensitive */ +@@ -233,9 +233,9 @@ CAMLexport void caml_MD5Final(unsigned char *digest, struct MD5Context *ctx) + * reflect the addition of 16 longwords of new data. caml_MD5Update blocks + * the data and converts bytes into longwords for this routine. + */ +-CAMLexport void caml_MD5Transform(uint32 *buf, uint32 *in) ++CAMLexport void caml_MD5Transform(uint32_t *buf, uint32_t *in) + { +- register uint32 a, b, c, d; ++ register uint32_t a, b, c, d; + + a = buf[0]; + b = buf[1]; +diff --git a/byterun/md5.h b/byterun/md5.h +index d8aff09..f63667d 100644 +--- a/byterun/md5.h ++++ b/byterun/md5.h +@@ -26,8 +26,8 @@ CAMLextern void caml_md5_block(unsigned char digest[16], + void * data, uintnat len); + + struct MD5Context { +- uint32 buf[4]; +- uint32 bits[2]; ++ uint32_t buf[4]; ++ uint32_t bits[2]; + unsigned char in[64]; + }; + +@@ -35,7 +35,7 @@ CAMLextern void caml_MD5Init (struct MD5Context *context); + CAMLextern void caml_MD5Update (struct MD5Context *context, unsigned char *buf, + uintnat len); + CAMLextern void caml_MD5Final (unsigned char *digest, struct MD5Context *ctx); +-CAMLextern void caml_MD5Transform (uint32 *buf, uint32 *in); ++CAMLextern void caml_MD5Transform (uint32_t *buf, uint32_t *in); + + + #endif /* CAML_MD5_H */ +diff --git a/byterun/mlvalues.h b/byterun/mlvalues.h +index 268bcfe..a08948e 100644 +--- a/byterun/mlvalues.h ++++ b/byterun/mlvalues.h +@@ -38,8 +38,8 @@ extern "C" { + bp: Pointer to the first byte of a block. (a char *) + op: Pointer to the first field of a block. (a value *) + hp: Pointer to the header of a block. (a char *) +- int32: Four bytes on all architectures. +- int64: Eight bytes on all architectures. ++ int32_t: Four bytes on all architectures. ++ int64_t: Eight bytes on all architectures. + + Remark: A block size is always a multiple of the word size, and at least + one word plus the header. +@@ -161,7 +161,7 @@ bits 63 10 9 8 7 0 + /* Fields are numbered from 0. */ + #define Field(x, i) (((value *)(x)) [i]) /* Also an l-value. */ + +-typedef int32 opcode_t; ++typedef int32_t opcode_t; + typedef opcode_t * code_t; + + /* NOTE: [Forward_tag] and [Infix_tag] must be just under +@@ -262,12 +262,12 @@ struct custom_operations; /* defined in [custom.h] */ + + /* Int32.t, Int64.t and Nativeint.t are represented as custom blocks. */ + +-#define Int32_val(v) (*((int32 *) Data_custom_val(v))) ++#define Int32_val(v) (*((int32_t *) Data_custom_val(v))) + #define Nativeint_val(v) (*((intnat *) Data_custom_val(v))) + #ifndef ARCH_ALIGN_INT64 +-#define Int64_val(v) (*((int64 *) Data_custom_val(v))) ++#define Int64_val(v) (*((int64_t *) Data_custom_val(v))) + #else +-CAMLextern int64 caml_Int64_val(value v); ++CAMLextern int64_t caml_Int64_val(value v); + #define Int64_val(v) caml_Int64_val(v) + #endif + +diff --git a/byterun/startup.c b/byterun/startup.c +index 3697220..ab926ef 100644 +--- a/byterun/startup.c ++++ b/byterun/startup.c +@@ -79,7 +79,7 @@ static void init_atoms(void) + + /* Read the trailer of a bytecode file */ + +-static void fixup_endianness_trailer(uint32 * p) ++static void fixup_endianness_trailer(uint32_t * p) + { + #ifndef ARCH_BIG_ENDIAN + Reverse_32(p, p); +@@ -153,7 +153,7 @@ void caml_read_section_descriptors(int fd, struct exec_trailer *trail) + Return the length of the section data in bytes, or -1 if no section + found with that name. */ + +-int32 caml_seek_optional_section(int fd, struct exec_trailer *trail, char *name) ++int32_t caml_seek_optional_section(int fd, struct exec_trailer *trail, char *name) + { + long ofs; + int i; +@@ -172,9 +172,9 @@ int32 caml_seek_optional_section(int fd, struct exec_trailer *trail, char *name) + /* Position fd at the beginning of the section having the given name. + Return the length of the section data in bytes. */ + +-int32 caml_seek_section(int fd, struct exec_trailer *trail, char *name) ++int32_t caml_seek_section(int fd, struct exec_trailer *trail, char *name) + { +- int32 len = caml_seek_optional_section(fd, trail, name); ++ int32_t len = caml_seek_optional_section(fd, trail, name); + if (len == -1) + caml_fatal_error_arg("Fatal_error: section `%s' is missing\n", name); + return len; +@@ -185,7 +185,7 @@ int32 caml_seek_section(int fd, struct exec_trailer *trail, char *name) + + static char * read_section(int fd, struct exec_trailer *trail, char *name) + { +- int32 len; ++ int32_t len; + char * data; + + len = caml_seek_optional_section(fd, trail, name); +diff --git a/byterun/startup.h b/byterun/startup.h +index 3dda64b..3268d88 100644 +--- a/byterun/startup.h ++++ b/byterun/startup.h +@@ -30,9 +30,9 @@ enum { FILE_NOT_FOUND = -1, BAD_BYTECODE = -2 }; + extern int caml_attempt_open(char **name, struct exec_trailer *trail, + int do_open_script); + extern void caml_read_section_descriptors(int fd, struct exec_trailer *trail); +-extern int32 caml_seek_optional_section(int fd, struct exec_trailer *trail, ++extern int32_t caml_seek_optional_section(int fd, struct exec_trailer *trail, + char *name); +-extern int32 caml_seek_section(int fd, struct exec_trailer *trail, char *name); ++extern int32_t caml_seek_section(int fd, struct exec_trailer *trail, char *name); + + + #endif /* CAML_STARTUP_H */ +diff --git a/byterun/str.c b/byterun/str.c +index 6effa91..9c7baa1 100644 +--- a/byterun/str.c ++++ b/byterun/str.c +@@ -101,7 +101,7 @@ CAMLprim value caml_string_get32(value str, value index) + + CAMLprim value caml_string_get64(value str, value index) + { +- uint64 res; ++ uint64_t res; + unsigned char b1, b2, b3, b4, b5, b6, b7, b8; + intnat idx = Long_val(index); + if (idx < 0 || idx + 7 >= caml_string_length(str)) caml_array_bound_error(); +@@ -114,15 +114,15 @@ CAMLprim value caml_string_get64(value str, value index) + b7 = Byte_u(str, idx + 6); + b8 = Byte_u(str, idx + 7); + #ifdef ARCH_BIG_ENDIAN +- res = (uint64) b1 << 56 | (uint64) b2 << 48 +- | (uint64) b3 << 40 | (uint64) b4 << 32 +- | (uint64) b5 << 24 | (uint64) b6 << 16 +- | (uint64) b7 << 8 | (uint64) b8; ++ res = (uint64_t) b1 << 56 | (uint64_t) b2 << 48 ++ | (uint64_t) b3 << 40 | (uint64_t) b4 << 32 ++ | (uint64_t) b5 << 24 | (uint64_t) b6 << 16 ++ | (uint64_t) b7 << 8 | (uint64_t) b8; + #else +- res = (uint64) b8 << 56 | (uint64) b7 << 48 +- | (uint64) b6 << 40 | (uint64) b5 << 32 +- | (uint64) b4 << 24 | (uint64) b3 << 16 +- | (uint64) b2 << 8 | (uint64) b1; ++ res = (uint64_t) b8 << 56 | (uint64_t) b7 << 48 ++ | (uint64_t) b6 << 40 | (uint64_t) b5 << 32 ++ | (uint64_t) b4 << 24 | (uint64_t) b3 << 16 ++ | (uint64_t) b2 << 8 | (uint64_t) b1; + #endif + return caml_copy_int64(res); + } +@@ -174,7 +174,7 @@ CAMLprim value caml_string_set32(value str, value index, value newval) + CAMLprim value caml_string_set64(value str, value index, value newval) + { + unsigned char b1, b2, b3, b4, b5, b6, b7, b8; +- int64 val; ++ int64_t val; + intnat idx = Long_val(index); + if (idx < 0 || idx + 7 >= caml_string_length(str)) caml_array_bound_error(); + val = Int64_val(newval); +diff --git a/config/auto-aux/int64align.c b/config/auto-aux/int64align.c +index 5795e48..c143986 100644 +--- a/config/auto-aux/int64align.c ++++ b/config/auto-aux/int64align.c +@@ -17,18 +17,18 @@ + #include "m.h" + + #if defined(ARCH_INT64_TYPE) +-typedef ARCH_INT64_TYPE int64; ++typedef ARCH_INT64_TYPE int64_t; + #elif SIZEOF_LONG == 8 +-typedef long int64; ++typedef long int64_t; + #elif SIZEOF_LONGLONG == 8 +-typedef long long int64; ++typedef long long int64_t; + #else + #error "No 64-bit integer type available" + #endif + +-int64 foo; ++int64_t foo; + +-void access_int64(int64 *p) ++void access_int64(int64_t *p) + { + foo = *p; + } +@@ -49,8 +49,8 @@ int main(void) + signal(SIGBUS, sig_handler); + #endif + if(setjmp(failure) == 0) { +- access_int64((int64 *) n); +- access_int64((int64 *) (n+1)); ++ access_int64((int64_t *) n); ++ access_int64((int64_t *) (n+1)); + res = 0; + } else { + res = 1; +diff --git a/config/s-nt.h b/config/s-nt.h +index 6df440b..603b050 100644 +--- a/config/s-nt.h ++++ b/config/s-nt.h +@@ -15,6 +15,9 @@ + + #define OCAML_OS_TYPE "Win32" + ++#ifdef __MINGW32__ ++#define HAS_STDINT_H ++#endif + #undef BSD_SIGNALS + #define HAS_STRERROR + #define HAS_SOCKETS +diff --git a/configure b/configure +index 0bf4ebd..8a9be78 100755 +--- a/configure ++++ b/configure +@@ -615,26 +615,6 @@ case "$target" in + esac + esac + +-# Check semantics of division and modulus +- +-sh ./runtest divmod.c +-case $? in +- 0) inf "Native division and modulus have round-towards-zero semantics," \ +- "will use them." +- echo "#undef NONSTANDARD_DIV_MOD" >> m.h;; +- 1) inf "Native division and modulus do not have round-towards-zero" +- "semantics, will use software emulation." +- echo "#define NONSTANDARD_DIV_MOD" >> m.h;; +- *) case $target in +- *-*-mingw*) inf "Native division and modulus have round-towards-zero" \ +- "semantics, will use them." +- echo "#undef NONSTANDARD_DIV_MOD" >> m.h;; +- *) wrn "Something went wrong while checking native division and modulus"\ +- "please report it at http://http://caml.inria.fr/mantis/" +- echo "#define NONSTANDARD_DIV_MOD" >> m.h;; +- esac;; +-esac +- + # Shared library support + + shared_libraries_supported=false +@@ -1085,6 +1065,11 @@ if sh ./hasgot -i sys/types.h -i sys/socket.h -i netinet/in.h \ + echo "#define HAS_IPV6" >> s.h + fi + ++if sh ./hasgot -i stdint.h; then ++ inf "stdint.h found." ++ echo "#define HAS_STDINT_H" >> s.h ++fi ++ + if sh ./hasgot -i unistd.h; then + inf "unistd.h found." + echo "#define HAS_UNISTD" >> s.h +diff --git a/otherlibs/bigarray/bigarray_stubs.c b/otherlibs/bigarray/bigarray_stubs.c +index 7e63cbf..f2ccb92 100644 +--- a/otherlibs/bigarray/bigarray_stubs.c ++++ b/otherlibs/bigarray/bigarray_stubs.c +@@ -279,9 +279,9 @@ value caml_ba_get_N(value vb, value * vind, int nind) + case CAML_BA_UINT16: + return Val_int(((uint16 *) b->data)[offset]); + case CAML_BA_INT32: +- return caml_copy_int32(((int32 *) b->data)[offset]); ++ return caml_copy_int32(((int32_t *) b->data)[offset]); + case CAML_BA_INT64: +- return caml_copy_int64(((int64 *) b->data)[offset]); ++ return caml_copy_int64(((int64_t *) b->data)[offset]); + case CAML_BA_NATIVE_INT: + return caml_copy_nativeint(((intnat *) b->data)[offset]); + case CAML_BA_CAML_INT: +@@ -388,7 +388,7 @@ CAMLprim value caml_ba_uint8_get32(value vb, value vind) + + CAMLprim value caml_ba_uint8_get64(value vb, value vind) + { +- uint64 res; ++ uint64_t res; + unsigned char b1, b2, b3, b4, b5, b6, b7, b8; + intnat idx = Long_val(vind); + struct caml_ba_array * b = Caml_ba_array_val(vb); +@@ -402,15 +402,15 @@ CAMLprim value caml_ba_uint8_get64(value vb, value vind) + b7 = ((unsigned char*) b->data)[idx+6]; + b8 = ((unsigned char*) b->data)[idx+7]; + #ifdef ARCH_BIG_ENDIAN +- res = (uint64) b1 << 56 | (uint64) b2 << 48 +- | (uint64) b3 << 40 | (uint64) b4 << 32 +- | (uint64) b5 << 24 | (uint64) b6 << 16 +- | (uint64) b7 << 8 | (uint64) b8; ++ res = (uint64_t) b1 << 56 | (uint64_t) b2 << 48 ++ | (uint64_t) b3 << 40 | (uint64_t) b4 << 32 ++ | (uint64_t) b5 << 24 | (uint64_t) b6 << 16 ++ | (uint64_t) b7 << 8 | (uint64_t) b8; + #else +- res = (uint64) b8 << 56 | (uint64) b7 << 48 +- | (uint64) b6 << 40 | (uint64) b5 << 32 +- | (uint64) b4 << 24 | (uint64) b3 << 16 +- | (uint64) b2 << 8 | (uint64) b1; ++ res = (uint64_t) b8 << 56 | (uint64_t) b7 << 48 ++ | (uint64_t) b6 << 40 | (uint64_t) b5 << 32 ++ | (uint64_t) b4 << 24 | (uint64_t) b3 << 16 ++ | (uint64_t) b2 << 8 | (uint64_t) b1; + #endif + return caml_copy_int64(res); + } +@@ -447,9 +447,9 @@ static value caml_ba_set_aux(value vb, value * vind, intnat nind, value newval) + case CAML_BA_UINT16: + ((int16 *) b->data)[offset] = Int_val(newval); break; + case CAML_BA_INT32: +- ((int32 *) b->data)[offset] = Int32_val(newval); break; ++ ((int32_t *) b->data)[offset] = Int32_val(newval); break; + case CAML_BA_INT64: +- ((int64 *) b->data)[offset] = Int64_val(newval); break; ++ ((int64_t *) b->data)[offset] = Int64_val(newval); break; + case CAML_BA_NATIVE_INT: + ((intnat *) b->data)[offset] = Nativeint_val(newval); break; + case CAML_BA_CAML_INT: +@@ -577,7 +577,7 @@ CAMLprim value caml_ba_uint8_set64(value vb, value vind, value newval) + { + unsigned char b1, b2, b3, b4, b5, b6, b7, b8; + intnat idx = Long_val(vind); +- int64 val; ++ int64_t val; + struct caml_ba_array * b = Caml_ba_array_val(vb); + if (idx < 0 || idx >= b->dim[0] - 7) caml_array_bound_error(); + val = Int64_val(newval); +@@ -760,9 +760,9 @@ static int caml_ba_compare(value v1, value v2) + case CAML_BA_UINT16: + DO_INTEGER_COMPARISON(uint16); + case CAML_BA_INT32: +- DO_INTEGER_COMPARISON(int32); ++ DO_INTEGER_COMPARISON(int32_t); + case CAML_BA_INT64: +- DO_INTEGER_COMPARISON(int64); ++ DO_INTEGER_COMPARISON(int64_t); + case CAML_BA_CAML_INT: + case CAML_BA_NATIVE_INT: + DO_INTEGER_COMPARISON(intnat); +@@ -780,7 +780,7 @@ static intnat caml_ba_hash(value v) + { + struct caml_ba_array * b = Caml_ba_array_val(v); + intnat num_elts, n; +- uint32 h, w; ++ uint32_t h, w; + int i; + + num_elts = 1; +@@ -820,7 +820,7 @@ static intnat caml_ba_hash(value v) + } + case CAML_BA_INT32: + { +- uint32 * p = b->data; ++ uint32_t * p = b->data; + if (num_elts > 64) num_elts = 64; + for (n = 0; n < num_elts; n++, p++) h = caml_hash_mix_uint32(h, *p); + break; +@@ -835,7 +835,7 @@ static intnat caml_ba_hash(value v) + } + case CAML_BA_INT64: + { +- int64 * p = b->data; ++ int64_t * p = b->data; + if (num_elts > 32) num_elts = 32; + for (n = 0; n < num_elts; n++, p++) h = caml_hash_mix_int64(h, *p); + break; +@@ -878,7 +878,7 @@ static void caml_ba_serialize_longarray(void * data, + } else { + caml_serialize_int_1(0); + for (n = 0, p = data; n < num_elts; n++, p++) +- caml_serialize_int_4((int32) *p); ++ caml_serialize_int_4((int32_t) *p); + } + #else + caml_serialize_int_1(0); +@@ -1181,14 +1181,14 @@ CAMLprim value caml_ba_fill(value vb, value vinit) + break; + } + case CAML_BA_INT32: { +- int32 init = Int32_val(vinit); +- int32 * p; ++ int32_t init = Int32_val(vinit); ++ int32_t * p; + for (p = b->data; num_elts > 0; p++, num_elts--) *p = init; + break; + } + case CAML_BA_INT64: { +- int64 init = Int64_val(vinit); +- int64 * p; ++ int64_t init = Int64_val(vinit); ++ int64_t * p; + for (p = b->data; num_elts > 0; p++, num_elts--) *p = init; + break; + } +diff --git a/otherlibs/num/nat_stubs.c b/otherlibs/num/nat_stubs.c +index 9a62759..d718a05 100644 +--- a/otherlibs/num/nat_stubs.c ++++ b/otherlibs/num/nat_stubs.c +@@ -347,9 +347,9 @@ static void serialize_nat(value nat, + if (len >= ((mlsize_t)1 << 32)) + failwith("output_value: nat too big"); + #endif +- serialize_int_4((int32) len); ++ serialize_int_4((int32_t) len); + #if defined(ARCH_SIXTYFOUR) && defined(ARCH_BIG_ENDIAN) +- { int32 * p; ++ { int32_t * p; + mlsize_t i; + for (i = len, p = Data_custom_val(nat); i > 0; i -= 2, p += 2) { + serialize_int_4(p[1]); /* low 32 bits of 64-bit digit */ +@@ -369,7 +369,7 @@ static uintnat deserialize_nat(void * dst) + + len = deserialize_uint_4(); + #if defined(ARCH_SIXTYFOUR) && defined(ARCH_BIG_ENDIAN) +- { uint32 * p; ++ { uint32_t * p; + mlsize_t i; + for (i = len, p = dst; i > 1; i -= 2, p += 2) { + p[1] = deserialize_uint_4(); /* low 32 bits of 64-bit digit */ +@@ -385,7 +385,7 @@ static uintnat deserialize_nat(void * dst) + deserialize_block_4(dst, len); + #if defined(ARCH_SIXTYFOUR) + if (len & 1){ +- ((uint32 *) dst)[len] = 0; ++ ((uint32_t *) dst)[len] = 0; + ++ len; + } + #endif +@@ -396,7 +396,7 @@ static uintnat deserialize_nat(void * dst) + static intnat hash_nat(value v) + { + bngsize len, i; +- uint32 h; ++ uint32_t h; + + len = bng_num_digits(&Digit_val(v,0), Wosize_val(v) - 1); + h = 0; +@@ -406,10 +406,10 @@ static intnat hash_nat(value v) + /* Mix the two 32-bit halves as if we were on a 32-bit platform, + namely low 32 bits first, then high 32 bits. + Also, ignore final 32 bits if they are zero. */ +- h = caml_hash_mix_uint32(h, (uint32) d); ++ h = caml_hash_mix_uint32(h, (uint32_t) d); + d = d >> 32; + if (d == 0 && i + 1 == len) break; +- h = caml_hash_mix_uint32(h, (uint32) d); ++ h = caml_hash_mix_uint32(h, (uint32_t) d); + #else + h = caml_hash_mix_uint32(h, d); + #endif +diff --git a/otherlibs/unix/addrofstr.c b/otherlibs/unix/addrofstr.c +index e17841f..a2830ba 100644 +--- a/otherlibs/unix/addrofstr.c ++++ b/otherlibs/unix/addrofstr.c +@@ -73,7 +73,7 @@ CAMLprim value unix_inet_addr_of_string(value s) + #else + struct in_addr address; + address.s_addr = inet_addr(String_val(s)); +- if (address.s_addr == (uint32) -1) failwith("inet_addr_of_string"); ++ if (address.s_addr == (uint32_t) -1) failwith("inet_addr_of_string"); + return alloc_inet_addr(&address); + #endif + } +diff --git a/stdlib/header.c b/stdlib/header.c +index cb3d995..93cdfeb 100644 +--- a/stdlib/header.c ++++ b/stdlib/header.c +@@ -133,7 +133,7 @@ static char * read_runtime_path(int fd) + char buffer[TRAILER_SIZE]; + static char runtime_path[MAXPATHLEN]; + int num_sections, i; +- uint32 path_size; ++ uint32_t path_size; + long ofs; + + lseek(fd, (long) -TRAILER_SIZE, SEEK_END); +-- +2.0.4 + diff --git a/programming/language/ocaml/ocaml/pspec.xml b/programming/language/ocaml/ocaml/pspec.xml new file mode 100644 index 0000000000..90cbf22f0e --- /dev/null +++ b/programming/language/ocaml/ocaml/pspec.xml @@ -0,0 +1,106 @@ + + + + + ocaml + http://www.ocaml.org/ + + Serdar Soytetir + kaptan@pisilinux.org + + OPL + app:console + Fast modern type-inferring functional programming language + A fast modern type-inferring functional programming language descended from the ML (Meta Language) family. + + http://caml.inria.fr/pub/distrib/ocaml-4.02/ocaml-4.02.1.tar.xz + + zlib-devel + ncurses-devel + libX11-devel + chrpath + + + fedora/0001-Don-t-ignore-.-configure-it-s-a-real-git-file.patch + fedora/0002-Ensure-empty-compilerlibs-directory-is-created-by-gi.patch + fedora/0003-Don-t-add-rpaths-to-libraries.patch + fedora/0004-ocamlbyteinfo-ocamlplugininfo-Useful-utilities-from-.patch + fedora/0005-configure-Allow-user-defined-C-compiler-flags.patch + fedora/0009-arg-Add-no_arg-and-get_arg-helper-functions.patch + fedora/0010-arg-Allow-flags-such-as-flag-arg-as-well-as-flag-arg.patch + fedora/0011-PR-6517-use-ISO-C99-types-u-int-32-64-_t-in-preferen.patch + + + + + ocaml + + zlib + ncurses + libX11 + + + /usr/bin/ + /usr/lib/ + /usr/share/doc/ + /usr/share/man/ + + + + + + 2015-04-04 + 4.02.1 + Version bump. + Yusuf Aydemir + yusuf.aydemir@pisilinux.org + + + 2014-11-16 + 4.00.2 + Rebuild + Yusuf Aydemir + yusuf.aydemir@pisilinux.org + + + 2014-09-23 + 4.00.2 + Version bump. + Serdar Soytetir + kaptan@pisilinux.org + + + 2014-05-24 + 3.4.1 + Version bump. + PisiLinux Community + admins@pisilinux.org + + + 2014-02-07 + 4.00.1 + Rebuild. + Serdar Soytetir + kaptan@pisilinux.org + + + 2014-01-29 + 4.01.0 + Version bump. + Stefan Gronewold(groni) + groni@pisilinux.org + + + 2012-09-20 + 4.00.0 + First release + Serdar Soytetir + kaptan@pisilinux.org + + + diff --git a/programming/language/ocaml/ocaml/translations.xml b/programming/language/ocaml/ocaml/translations.xml new file mode 100644 index 0000000000..23241c023a --- /dev/null +++ b/programming/language/ocaml/ocaml/translations.xml @@ -0,0 +1,18 @@ + + + + ocaml + Hızlı ve modern bir programlama dili + OcaML, ML dilinin soyundan gelen fonksiyonel bir programlama dilidir + + + + ocaml-mode + Emacs için ocaml kipi + + + + labltk + Ocaml için tk araç bağlayıcıları + + diff --git a/programming/language/tcl/component.xml b/programming/language/tcl/component.xml new file mode 100644 index 0000000000..cd2f226305 --- /dev/null +++ b/programming/language/tcl/component.xml @@ -0,0 +1,3 @@ + + programming.language.tcl + diff --git a/programming/language/tcl/tcl/actions.py b/programming/language/tcl/tcl/actions.py new file mode 100755 index 0000000000..1d45fa7076 --- /dev/null +++ b/programming/language/tcl/tcl/actions.py @@ -0,0 +1,61 @@ +# -*- coding: utf-8 -*- +# +# Licensed under the GNU General Public License, version 3. +# See the file http://www.gnu.org/licenses/gpl.txt + +from pisi.actionsapi import autotools +from pisi.actionsapi import get +from pisi.actionsapi import pisitools +from pisi.actionsapi import shelltools + +def setup(): + shelltools.unlinkDir("%s/tcl8.6.4/pkgs/sqlite3.8.8.3" % get.workDIR()) + shelltools.cd("unix") + + autotools.autoreconf("-fi") + autotools.configure("--with-encoding=utf-8 \ + --enable-threads \ + --enable-man-compression=gzip \ + --mandir=/usr/share/man \ + --enable-man-symlinks \ + --enable-shared \ + --enable-64bit") + +def build(): + shelltools.cd("unix") + autotools.make() + +def install(): + shelltools.cd("unix") + autotools.rawInstall("DESTDIR=%s" % get.installDIR()) + + # Collect private headers, 3rd party apps like Tile depends on this + shelltools.cd("..") + pisitools.dodir("/usr/include/tcl-private/generic") + pisitools.dodir("/usr/include/tcl-private/unix") + shelltools.copy("unix/*.h","%s/usr/include/tcl-private/unix" % get.installDIR()) + shelltools.copy("generic/*.h", "%s/usr/include/tcl-private/generic" % get.installDIR()) + + # Remove duplicated headers + pisitools.remove("/usr/include/tcl-private/generic/tcl.h") + pisitools.remove("/usr/include/tcl-private/generic/tclDecls.h") + pisitools.remove("/usr/include/tcl-private/generic/tclPlatDecls.h") + + # Remove man file sqlite paket çakışması için silindi. + #pisitools.remove("/usr/share/man/mann/sqlite3.n") + + # Expect package needs these symlinks + pisitools.dosym("/usr/include/tcl-private/unix/tclUnixPort.h","/usr/include/tcl-private/generic/tclUnixPort.h") + pisitools.dosym("/usr/include/tcl-private/unix/tclUnixThrd.h","/usr/include/tcl-private/generic/tclUnixThrd.h") + + # Remove tmp path from tclConfig.sh + pisitools.dosed("%s/usr/lib/tclConfig.sh" % get.installDIR(),"%s/unix" % get.curDIR() ,"/usr/lib/") + pisitools.dosed("%s/usr/lib/tclConfig.sh" % get.installDIR(),"%s" % get.curDIR() ,"/usr/include/tcl-private") + + # Some apps need compat headers + pisitools.dodir("/usr/include/tcl-private/compat") + shelltools.copy("compat/*.h", "%s/usr/include/tcl-private/compat" % get.installDIR()) + + pisitools.dosym("/usr/bin/tclsh8.6","/usr/bin/tclsh") + + pisitools.dodoc("ChangeLog","changes","license.terms","README") \ No newline at end of file diff --git a/programming/language/tcl/tcl/files/tcl-8.6.1-conf.patch b/programming/language/tcl/tcl/files/tcl-8.6.1-conf.patch new file mode 100755 index 0000000000..894a7df3ca --- /dev/null +++ b/programming/language/tcl/tcl/files/tcl-8.6.1-conf.patch @@ -0,0 +1,19 @@ +diff --git a/unix/tcl.m4 b/unix/tcl.m4 +index 194cf90..76773f3 100644 +--- a/unix/tcl.m4 ++++ b/unix/tcl.m4 +@@ -1415,12 +1415,12 @@ AC_DEFUN([SC_CONFIG_CFLAGS], [ + # get rid of the warnings. + #CFLAGS_OPTIMIZE="${CFLAGS_OPTIMIZE} -D__NO_STRING_INLINES -D__NO_MATH_INLINES" + +- SHLIB_LD='${CC} -shared ${CFLAGS} ${LDFLAGS}' ++ SHLIB_LD='${CC} -shared ${CFLAGS} ${LDFLAGS} -fPIC -Wl,-soname,${@}' + DL_OBJS="tclLoadDl.o" + DL_LIBS="-ldl" + LDFLAGS="$LDFLAGS -Wl,--export-dynamic" + AS_IF([test $doRpath = yes], [ +- CC_SEARCH_FLAGS='-Wl,-rpath,${LIB_RUNTIME_DIR}']) ++ CC_SEARCH_FLAGS='']) + LD_SEARCH_FLAGS=${CC_SEARCH_FLAGS} + AS_IF([test "`uname -m`" = "alpha"], [CFLAGS="$CFLAGS -mieee"]) + AS_IF([test $do64bit = yes], [ \ No newline at end of file diff --git a/programming/language/tcl/tcl/files/tcl-8.6.1-hidden.patch b/programming/language/tcl/tcl/files/tcl-8.6.1-hidden.patch new file mode 100755 index 0000000000..32d580ca55 --- /dev/null +++ b/programming/language/tcl/tcl/files/tcl-8.6.1-hidden.patch @@ -0,0 +1,35 @@ +diff --git a/generic/tclInt.h b/generic/tclInt.h +index 380284f..7bb5eb9 100644 +--- a/generic/tclInt.h ++++ b/generic/tclInt.h +@@ -3160,7 +3160,7 @@ MODULE_SCOPE void TclClockInit(Tcl_Interp *interp); + MODULE_SCOPE int TclClockOldscanObjCmd( + ClientData clientData, Tcl_Interp *interp, + int objc, Tcl_Obj *const objv[]); +-MODULE_SCOPE int Tcl_CloseObjCmd(ClientData clientData, ++extern int Tcl_CloseObjCmd(ClientData clientData, + Tcl_Interp *interp, int objc, + Tcl_Obj *const objv[]); + MODULE_SCOPE int Tcl_ConcatObjCmd(ClientData clientData, +@@ -3343,7 +3343,7 @@ MODULE_SCOPE int Tcl_RenameObjCmd(ClientData clientData, + MODULE_SCOPE int Tcl_RepresentationCmd(ClientData clientData, + Tcl_Interp *interp, int objc, + Tcl_Obj *const objv[]); +-MODULE_SCOPE int Tcl_ReturnObjCmd(ClientData clientData, ++extern int Tcl_ReturnObjCmd(ClientData clientData, + Tcl_Interp *interp, int objc, + Tcl_Obj *const objv[]); + MODULE_SCOPE int Tcl_ScanObjCmd(ClientData clientData, +diff --git a/generic/tclPort.h b/generic/tclPort.h +index 12a60db..d817154 100644 +--- a/generic/tclPort.h ++++ b/generic/tclPort.h +@@ -20,7 +20,7 @@ + #if defined(_WIN32) + # include "tclWinPort.h" + #else +-# include "tclUnixPort.h" ++# include "../unix/tclUnixPort.h" + #endif + #include "tcl.h" + \ No newline at end of file diff --git a/programming/language/tcl/tcl/pspec.xml b/programming/language/tcl/tcl/pspec.xml new file mode 100755 index 0000000000..32040147d1 --- /dev/null +++ b/programming/language/tcl/tcl/pspec.xml @@ -0,0 +1,135 @@ + + + + + tcl + http://www.tcl.tk + + PisiLinux Community + admins@pisilinux.org + + as-is + app:console + Tcl programming language + Tcl provides a powerful platform for creating integration applications that tie together diverse applications, protocols, devices, and frameworks. + mirrors://sourceforge/tcl/tcl8.6.4-src.tar.gz + + zlib-devel + + + + + tcl + + zlib + + + /usr/bin + /usr/lib + /usr/lib/tcl8.5 + /usr/share/doc + /usr/share/man + + + + + tcl-devel + Development files for tcl + + tcl + + + /usr/include + /usr/lib/*.a + /usr/lib/pkgconfig + /usr/lib/tclConfig.sh + /usr/share/man/man3 + + + + sqlite-tcl + files for sqlite-tcl + + tcl + + + /usr/lib/sqlite3.8.8.3/libsqlite* + /usr/lib/tcl8/8.6/tdbc/sqlite3-1.0.3.tm + /usr/share/man/mann/tdbc_sqlite3.n + /usr/share/man/mann/sqlite3.n + + + + + + 2015-06-11 + 8.6.4 + Version bump. + Ertuğrul Erata + ertugrulerata@gmail.com + + + 2015-03-03 + 8.6.3 + Rebuild. + Yusuf Aydemir + yusuf.aydemir@pisilinux.org + + + 2014-12-12 + 8.6.3 + Version bump. + Yusuf Aydemir + yusuf.aydemir@pisilinux.org + + + 2014-09-30 + 8.6.2 + Version bump. + Kamil Atlı + suvari@pisilinux.org + + + 2014-05-17 + 8.6.1 + Add patch. + Alihan Öztürk + alihan@pisilinux.org + + + 2014-01-06 + 8.6.1 + Rebuild to fix stripping. + Yusuf Aydemir + yusuf.aydemir@pisilinux.org + + + 2013-10-24 + 8.6.1 + Version bump. + Yusuf Aydemir + yusuf.aydemir@pisilinux.org + + + 2013-07-26 + 8.6.0 + Move pc files to devel pack, increase release no. + Serdar Soytetir + kaptan@pisilinux.org + + + 2013-01-26 + 8.6.0 + bump + Erdinç Gültekin + admins@pisilinux.org + + + 2012-09-15 + 8.5.12 + First release + Serdar Soytetir + kaptan@pisilinux.org + + + diff --git a/programming/language/tcl/tcl/translations.xml b/programming/language/tcl/tcl/translations.xml new file mode 100755 index 0000000000..e44f5c02c1 --- /dev/null +++ b/programming/language/tcl/tcl/translations.xml @@ -0,0 +1,14 @@ + + + + tcl + Tcl programlama dili + Tcl, çeşitli uygulamalar geliştirmek için kullanılabilen bir programlama dilidir. + Tcl provee una plataforma potente para crear aplicaciones de integración de diversos aplicaciones, protocolos, dispositivos y frameworks + + + + tcl-devel + tcl için geliştirme dosyaları + + diff --git a/programming/language/tcl/tcltk/actions.py b/programming/language/tcl/tcltk/actions.py new file mode 100755 index 0000000000..6c245962c0 --- /dev/null +++ b/programming/language/tcl/tcltk/actions.py @@ -0,0 +1,47 @@ +#!/usr/bin/python +# -*- coding: utf-8 -*- +# +# Licensed under the GNU General Public License, version 3. +# See the file http://www.gnu.org/licenses/gpl.txt + +from pisi.actionsapi import autotools +from pisi.actionsapi import get +from pisi.actionsapi import pisitools +from pisi.actionsapi import shelltools + +WorkDir="tk%s" % get.srcVERSION() + +def setup(): + shelltools.cd("unix") + autotools.autoconf() + autotools.configure("--enable-threads \ + --enable-man-compression=gzip \ + --enable-man-symlinks \ + --enable-64bit \ + --with-x \ + --enable-xft") + +def build(): + autotools.make("-C unix") + +def install(): + shelltools.system("make -C unix DESTDIR=%s install" % get.installDIR()) + + # Collect private headers, 3rd party apps like Tile depends on this + pisitools.dodir("/usr/include/tk-private/generic") + pisitools.dodir("/usr/include/tk-private/unix") + shelltools.copy("unix/*.h", "%s/usr/include/tk-private/unix" % get.installDIR()) + shelltools.copy("generic/*.h", "%s/usr/include/tk-private/generic" % get.installDIR()) + + # Remove duplicated headers + pisitools.remove("/usr/include/tk-private/generic/tk.h") + pisitools.remove("/usr/include/tk-private/generic/tkDecls.h") + pisitools.remove("/usr/include/tk-private/generic/tkPlatDecls.h") + + # Remove tmp path from tclConfig.sh + pisitools.dosed("%s/usr/lib/tkConfig.sh" % get.installDIR(), "%s/unix" % get.curDIR(), "/usr/lib/") + pisitools.dosed("%s/usr/lib/tkConfig.sh" % get.installDIR(), get.curDIR(), "/usr/include/tk-private") + + pisitools.dosym("/usr/bin/wish8.6", "/usr/bin/wish") + + pisitools.dodoc("ChangeLog", "changes", "license.terms", "README") diff --git a/programming/language/tcl/tcltk/files/tclm4_soname.patch b/programming/language/tcl/tcltk/files/tclm4_soname.patch new file mode 100755 index 0000000000..f5f5127ce2 --- /dev/null +++ b/programming/language/tcl/tcltk/files/tclm4_soname.patch @@ -0,0 +1,27 @@ +diff -Nuar tk8.5.10.orig/unix/tcl.m4 tk8.5.10/unix/tcl.m4 +--- tk8.5.10.orig/unix/tcl.m4 2011-08-01 14:24:06.823000004 +0300 ++++ tk8.5.10/unix/tcl.m4 2011-08-01 14:43:01.760000005 +0300 +@@ -1399,12 +1399,12 @@ + # get rid of the warnings. + #CFLAGS_OPTIMIZE="${CFLAGS_OPTIMIZE} -D__NO_STRING_INLINES -D__NO_MATH_INLINES" + +- SHLIB_LD='${CC} -shared ${CFLAGS} ${LDFLAGS}' ++ SHLIB_LD='${CC} -shared ${CFLAGS} ${LDFLAGS} -Wl,-soname,${@}' + DL_OBJS="tclLoadDl.o" + DL_LIBS="-ldl" + LDFLAGS="$LDFLAGS -Wl,--export-dynamic" + AS_IF([test $doRpath = yes], [ +- CC_SEARCH_FLAGS='-Wl,-rpath,${LIB_RUNTIME_DIR}']) ++ CC_SEARCH_FLAGS='']) + LD_SEARCH_FLAGS=${CC_SEARCH_FLAGS} + AS_IF([test "`uname -m`" = "alpha"], [CFLAGS="$CFLAGS -mieee"]) + AS_IF([test $do64bit = yes], [ +@@ -1431,7 +1431,7 @@ + SHLIB_CFLAGS="-fPIC" + SHLIB_SUFFIX=".so" + +- SHLIB_LD='${CC} -shared' ++ SHLIB_LD='${CC} ${CFLAGS} -shared' + DL_OBJS="" + DL_LIBS="-ldl" + LDFLAGS="$LDFLAGS -Wl,--export-dynamic" diff --git a/programming/language/tcl/tcltk/files/tk-8.6.1-conf.patch b/programming/language/tcl/tcltk/files/tk-8.6.1-conf.patch new file mode 100755 index 0000000000..49a16d6ab4 --- /dev/null +++ b/programming/language/tcl/tcltk/files/tk-8.6.1-conf.patch @@ -0,0 +1,19 @@ +diff --git a/unix/tcl.m4 b/unix/tcl.m4 +index 194cf90..c470e36 100644 +--- a/unix/tcl.m4 ++++ b/unix/tcl.m4 +@@ -1415,12 +1415,12 @@ AC_DEFUN([SC_CONFIG_CFLAGS], [ + # get rid of the warnings. + #CFLAGS_OPTIMIZE="${CFLAGS_OPTIMIZE} -D__NO_STRING_INLINES -D__NO_MATH_INLINES" + +- SHLIB_LD='${CC} -shared ${CFLAGS} ${LDFLAGS}' ++ SHLIB_LD='${CC} -shared ${CFLAGS} ${LDFLAGS} -Wl,-soname,${@}' + DL_OBJS="tclLoadDl.o" + DL_LIBS="-ldl" + LDFLAGS="$LDFLAGS -Wl,--export-dynamic" + AS_IF([test $doRpath = yes], [ +- CC_SEARCH_FLAGS='-Wl,-rpath,${LIB_RUNTIME_DIR}']) ++ CC_SEARCH_FLAGS='']) + LD_SEARCH_FLAGS=${CC_SEARCH_FLAGS} + AS_IF([test "`uname -m`" = "alpha"], [CFLAGS="$CFLAGS -mieee"]) + AS_IF([test $do64bit = yes], [ \ No newline at end of file diff --git a/programming/language/tcl/tcltk/files/tk-8.6.1-fix-xft.patch b/programming/language/tcl/tcltk/files/tk-8.6.1-fix-xft.patch new file mode 100755 index 0000000000..b39be15db7 --- /dev/null +++ b/programming/language/tcl/tcltk/files/tk-8.6.1-fix-xft.patch @@ -0,0 +1,15 @@ +diff --git a/unix/configure.in b/unix/configure.in +index e7bf023..7d12f41 100755 +--- a/unix/configure.in ++++ b/unix/configure.in +@@ -485,8 +485,8 @@ if test $tk_aqua = no; then + XFT_LIBS=`xft-config --libs 2>/dev/null` || found_xft="no" + if test "$found_xft" = "no" ; then + found_xft=yes +- XFT_CFLAGS=`pkg-config --cflags xft 2>/dev/null` || found_xft="no" +- XFT_LIBS=`pkg-config --libs xft 2>/dev/null` || found_xft="no" ++ XFT_CFLAGS=`pkg-config --cflags xft freetype2 2>/dev/null` || found_xft="no" ++ XFT_LIBS=`pkg-config --libs xft freetype2 2>/dev/null` || found_xft="no" + fi + AC_MSG_RESULT([$found_xft]) + dnl make sure that compiling against Xft header file doesn't bomb \ No newline at end of file diff --git a/programming/language/tcl/tcltk/files/tk-8.6.1-make.patch b/programming/language/tcl/tcltk/files/tk-8.6.1-make.patch new file mode 100755 index 0000000000..c4533d1d8f --- /dev/null +++ b/programming/language/tcl/tcltk/files/tk-8.6.1-make.patch @@ -0,0 +1,13 @@ +diff --git a/unix/Makefile.in b/unix/Makefile.in +index 3914940..a69df0e 100644 +--- a/unix/Makefile.in ++++ b/unix/Makefile.in +@@ -743,7 +743,7 @@ install-binaries: $(TK_LIB_FILE) $(TK_STUB_LIB_FILE) ${WISH_EXE} + fi + @echo "Installing $(LIB_FILE) to $(DLL_INSTALL_DIR)/" + @@INSTALL_LIB@ +- @chmod 555 "$(DLL_INSTALL_DIR)/$(LIB_FILE)" ++ @chmod 755 "$(DLL_INSTALL_DIR)/$(LIB_FILE)" + @if test -f "tk${MAJOR_VERSION}${MINOR_VERSION}.dll"; then \ + $(INSTALL_LIBRARY) "tk${MAJOR_VERSION}${MINOR_VERSION}.dll" "$(DLL_INSTALL_DIR)";\ + chmod 555 "$(DLL_INSTALL_DIR)/tk${MAJOR_VERSION}${MINOR_VERSION}.dll";\ \ No newline at end of file diff --git a/programming/language/tcl/tcltk/pspec.xml b/programming/language/tcl/tcltk/pspec.xml new file mode 100755 index 0000000000..053867529f --- /dev/null +++ b/programming/language/tcl/tcltk/pspec.xml @@ -0,0 +1,114 @@ + + + + + tcltk + http://www.tcl.tk + + PisiLinux Community + admins@pisilinux.org + + as-is + library + An X11 toolkit implemented with the Tcl scripting language + Tk is an X Windows widget set designed to work closely with the tcl scripting language. It allows you to write simple programs with full featured GUIs in only a little more time then it takes to write a text based interface. + mirrors://sourceforge/tcl/tk8.6.3-src.tar.gz + + tcl-devel + libX11-devel + libXft-devel + + fontconfig-devel + + + tk-8.6.1-conf.patch + tk-8.6.1-fix-xft.patch + tk-8.6.1-make.patch + + + + + tcltk + + tcl + libX11 + libXft + + fontconfig + + + /usr/bin + /usr/lib + /usr/lib/tk8.5 + /usr/share/doc + /usr/share/man + + + + + tcltk-devel + Development files for tcltk + + tcltk + + + /usr/include + /usr/lib/*.a + /usr/lib/tkConfig.sh + /usr/lib/pkgconfig + /usr/share/man/man3 + + + + + + 2014-12-14 + 8.6.3 + Version bump. + Yusuf Aydemir + yusuf.aydemir@pisilinux.org + + + 2014-09-30 + 8.6.2 + Version bump. + Kamil Atlı + suvari@pisilinux.org + + + 2014-05-17 + 8.6.1 + Version bump and add patch. + Alihan Öztürk + alihan@pisilinux.org + + + 2014-03-09 + 8.6.0 + Rebuild + Varol Maksutoğlu + waroi@pisilinux.org + + + 2013-07-26 + 8.6.0 + Move pc files to devel pack, increase release no. + Serdar Soytetir + kaptan@pisilinux.org + + + 2013-01-26 + 8.6.0 + bump + Erdinç Gültekin + admins@pisilinux.org + + + 2012-09-15 + 8.5.12 + First release + Serdar Soytetir + kaptan@pisilinux.org + + + \ No newline at end of file diff --git a/programming/language/tcl/tcltk/translations.xml b/programming/language/tcl/tcltk/translations.xml new file mode 100755 index 0000000000..02f0fa033a --- /dev/null +++ b/programming/language/tcl/tcltk/translations.xml @@ -0,0 +1,14 @@ + + + + tcltk + Tcl betik dili ile yazılmış X11 araç ve kitaplıkları + Tk est une boîte à outils X11 implémentée avec le langage de script Tcl. + Tk, tcl betik dili ile birlikte kullanılması için tasarlanmış bir X Windows araç setidir. Metin tabanlı arayüzlere oranla daha kısa sürede tam özellikli grafik arayüzlere sahip basit programlar yazmanızı sağlar. + + + + tcltk-devel + tcltk için geliştirme dosyaları + + diff --git a/x11/library/libXdamage/pspec.xml b/x11/library/libXdamage/pspec.xml index 6a64695fcb..f1ab6b95f9 100644 --- a/x11/library/libXdamage/pspec.xml +++ b/x11/library/libXdamage/pspec.xml @@ -23,6 +23,7 @@ libXdamage libXfixes + libX11 /usr/lib @@ -36,6 +37,7 @@ libXdamage libXfixes-devel + libX11-devel /usr/include/X11 @@ -50,9 +52,12 @@ 32-bit shared libraries for libXdamage emul32 - libXfixes + glibc-32bit + libX11-32bit + libXfixes-32bit + glibc-32bit libXdamage libXfixes-32bit libX11-32bit diff --git a/x11/library/libXft/actions.py b/x11/library/libXft/actions.py new file mode 100644 index 0000000000..7411064b11 --- /dev/null +++ b/x11/library/libXft/actions.py @@ -0,0 +1,20 @@ +# -*- coding: utf-8 -*- +# +# Licensed under the GNU General Public License, version 3. +# See the file http://www.gnu.org/licenses/gpl.txt + +from pisi.actionsapi import autotools +from pisi.actionsapi import pisitools +from pisi.actionsapi import get + +def setup(): + autotools.autoreconf("-vif") + autotools.configure("--disable-static") + +def build(): + autotools.make() + +def install(): + autotools.rawInstall("DESTDIR=%s" % get.installDIR()) + + pisitools.dodoc("AUTHORS", "ChangeLog", "COPYING", "NEWS", "README") diff --git a/x11/library/libXft/files/freetype_header.patch b/x11/library/libXft/files/freetype_header.patch new file mode 100644 index 0000000000..eb702f21b4 --- /dev/null +++ b/x11/library/libXft/files/freetype_header.patch @@ -0,0 +1,29 @@ +From 4acfdaf95adb0a05c2a25550bdde036c865902f4 Mon Sep 17 00:00:00 2001 +From: Julien Cristau +Date: Mon, 02 Dec 2013 15:26:24 +0000 +Subject: Use FT_*_H macros instead of including + +freetype moved its headers around in 2.5.1. + +Signed-off-by: Julien Cristau +--- +diff --git a/src/xftglyphs.c b/src/xftglyphs.c +index 2f3dc5a..4b5fb82 100644 +--- a/src/xftglyphs.c ++++ b/src/xftglyphs.c +@@ -21,10 +21,10 @@ + */ + + #include "xftint.h" +-#include +-#include ++#include FT_OUTLINE_H ++#include FT_LCD_FILTER_H + +-#include ++#include FT_SYNTHESIS_H + + /* + * Validate the memory info for a font +-- +cgit v0.9.0.2-2-gbebe diff --git a/x11/library/libXft/pspec.xml b/x11/library/libXft/pspec.xml new file mode 100644 index 0000000000..734d9ad672 --- /dev/null +++ b/x11/library/libXft/pspec.xml @@ -0,0 +1,128 @@ + + + + + libXft + http://www.x.org/ + + PisiLinux Community + admins@pisilinux.org + + MIT + library + X.Org Xft library + libXft is the X FreeType interface library. + mirrors://xorg/individual/lib/libXft-2.3.2.tar.bz2 + + util-macros + freetype-devel + expat-devel + fontconfig-devel + libXrender-devel + + + + + libXft + + libX11 + freetype + fontconfig + libXrender + + + /usr/lib + /usr/share/doc + + + + + libXft-devel + Development files for libXft + + libXft + freetype-devel + fontconfig-devel + libXrender-devel + + + /usr/bin + /usr/include/X11 + /usr/lib/pkgconfig + /usr/lib32/pkgconfig + /usr/share/man + + + + + libXft-32bit + emul32 + 32-bit shared libraries for libXft + emul32 + + freetype-32bit + fontconfig-32bit + libXrender-32bit + zlib-32bit + libX11-32bit + glibc-32bit + + + libXft + freetype-32bit + fontconfig-32bit + libXrender-32bit + zlib-32bit + libX11-32bit + glibc-32bit + + + /usr/lib32 + + + + + + 2014-08-31 + 2.3.2 + Version bump. + Marcin Bojara + marcin@pisilinux.org + + + 2014-05-16 + 2.3.1 + Release bump. + Marcin Bojara + marcin@pisilinux.org + + + 2014-02-01 + 2.3.1 + Rebuild for freetype. + Serdar Soytetir + kaptan@pisilinux.org + + + 2013-10-07 + 2.3.1 + Rebuild. + Serdar Soytetir + kaptan@pisilinux.org + + + 2013-08-25 + 2.3.1 + Release bump. + Marcin Bojara + marcin@pisilinux.org + + + 2012-11-22 + 2.3.1 + First release + Marcin Bojara + marcin@pisilinux.org + + + diff --git a/x11/library/libXft/translations.xml b/x11/library/libXft/translations.xml new file mode 100644 index 0000000000..7955c32e30 --- /dev/null +++ b/x11/library/libXft/translations.xml @@ -0,0 +1,19 @@ + + + + libXft + X.Org Xft kitaplığı + Librairie Xft de X.Org + X.Org Xft Bibliothek + + + + libXft-devel + libXft için geliştirme dosyaları + + + + libXft-32bit + libXft için 32-bit paylaşımlı kitaplıklar + + diff --git a/x11/library/libxkbcommon/pspec.xml b/x11/library/libxkbcommon/pspec.xml index 6fa3d452df..7a3e0c0d10 100755 --- a/x11/library/libxkbcommon/pspec.xml +++ b/x11/library/libxkbcommon/pspec.xml @@ -13,10 +13,17 @@ Library to convert evdev keycodes to keysyms Library to convert evdev keycodes to keysyms https://github.com/xkbcommon/libxkbcommon/archive/xkbcommon-0.5.0.tar.gz + + util-macros + libxcb-devel + libxkbcommon + + libxcb + /usr/share/doc/libxkbcommon/ /usr/lib/lib*.so* @@ -41,9 +48,14 @@ emul32 32-bit shared libraries for libxkbcommon emul32 + + libxcb-32bit + glibc-32bit + libxkbcommon libxcb-32bit + glibc-32bit /usr/lib32 diff --git a/x11/library/xcb-util/pspec.xml b/x11/library/xcb-util/pspec.xml index 5e6be8ddc7..305eb722f4 100644 --- a/x11/library/xcb-util/pspec.xml +++ b/x11/library/xcb-util/pspec.xml @@ -13,10 +13,17 @@ A number of libraries which sit on top of libxcb The xcb-util module provides a number of libraries which sit on top of libxcb, the core X protocol library, and some of the extension libraries. http://xcb.freedesktop.org/dist/xcb-util-0.3.9.tar.bz2 + + util-macros + libxcb-devel + xcb-util + + libxcb + /usr/lib /usr/share/doc @@ -43,10 +50,12 @@ emul32 libxcb-32bit + glibc-32bit xcb-util libxcb-32bit + glibc-32bit /usr/lib32