├── theos ├── lib │ └── .keep ├── makefiles │ ├── targets │ │ ├── Linux │ │ │ ├── native.mk │ │ │ ├── linux.mk │ │ │ └── iphone.mk │ │ ├── Darwin-arm │ │ │ ├── native.mk │ │ │ └── iphone.mk │ │ ├── Darwin │ │ │ ├── native.mk │ │ │ ├── macosx.mk │ │ │ ├── simulator.mk │ │ │ └── iphone.mk │ │ └── _common │ │ │ ├── darwin_flat_bundle.mk │ │ │ ├── linux.mk │ │ │ ├── darwin_hierarchial_bundle.mk │ │ │ └── darwin.mk │ ├── install │ │ ├── none_remote.mk │ │ ├── none_local.mk │ │ ├── deb_local.mk │ │ └── deb_remote.mk │ ├── tool.mk │ ├── library.mk │ ├── platform │ │ ├── Linux.mk │ │ ├── Darwin-arm.mk │ │ └── Darwin.mk │ ├── package │ │ ├── none.mk │ │ └── deb.mk │ ├── master │ │ ├── tool.mk │ │ ├── library.mk │ │ └── rules.mk │ ├── stage.mk │ ├── messages.mk │ ├── legacy.mk │ ├── instance │ │ ├── tool.mk │ │ ├── library.mk │ │ └── rules.mk │ ├── rules.mk │ ├── package.mk │ └── common.mk ├── bin │ ├── install.copyFile │ ├── install.exec │ ├── install.mergeDir │ ├── target.pl │ ├── deb_build_num.sh │ ├── vercmp.pl │ ├── fakeroot.sh │ └── package_version.sh └── Prefix.pch ├── .gitignore ├── test.sh ├── control ├── test.c ├── Makefile ├── fauxsu.sh.in ├── fauxsu.info └── fauxsu.cc /theos/lib/.keep: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | _ 2 | obj 3 | *.deb 4 | -------------------------------------------------------------------------------- /theos/makefiles/targets/Linux/native.mk: -------------------------------------------------------------------------------- 1 | linux.mk -------------------------------------------------------------------------------- /theos/makefiles/install/none_remote.mk: -------------------------------------------------------------------------------- 1 | none_local.mk -------------------------------------------------------------------------------- /theos/makefiles/targets/Darwin-arm/native.mk: -------------------------------------------------------------------------------- 1 | iphone.mk -------------------------------------------------------------------------------- /theos/makefiles/targets/Darwin/native.mk: -------------------------------------------------------------------------------- 1 | macosx.mk -------------------------------------------------------------------------------- /test.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | export DYLD_INSERT_LIBRARIES=$PWD/obj/macosx/libfauxsu.dylib 3 | exec $* 4 | -------------------------------------------------------------------------------- /theos/makefiles/install/none_local.mk: -------------------------------------------------------------------------------- 1 | internal-install:: stage 2 | install.mergeDir "$(THEOS_STAGING_DIR)" "/" 3 | -------------------------------------------------------------------------------- /control: -------------------------------------------------------------------------------- 1 | Package: fauxsu 2 | Architecture: darwin-i386 3 | Maintainer: Dustin Howett 4 | Version: 0.9 5 | -------------------------------------------------------------------------------- /theos/bin/install.copyFile: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | if [[ TARGET_INSTALL_REMOTE -eq 1 ]]; then 3 | scp -P $THEOS_DEVICE_PORT "$1" root@$THEOS_DEVICE_IP:$2 4 | else 5 | cp "$1" "$2" 6 | fi 7 | -------------------------------------------------------------------------------- /theos/bin/install.exec: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | if [[ TARGET_INSTALL_REMOTE -eq 1 ]]; then 3 | exec ssh -p $THEOS_DEVICE_PORT root@$THEOS_DEVICE_IP "$@" 4 | else 5 | exec sh -c "$@" 6 | fi 7 | -------------------------------------------------------------------------------- /theos/makefiles/targets/_common/darwin_flat_bundle.mk: -------------------------------------------------------------------------------- 1 | _THEOS_TARGET_BUNDLE_INFO_PLIST_SUBDIRECTORY := 2 | _THEOS_TARGET_BUNDLE_RESOURCE_SUBDIRECTORY := 3 | _THEOS_TARGET_BUNDLE_BINARY_SUBDIRECTORY := 4 | -------------------------------------------------------------------------------- /theos/makefiles/tool.mk: -------------------------------------------------------------------------------- 1 | ifeq ($(THEOS_CURRENT_INSTANCE),) 2 | include $(THEOS_MAKE_PATH)/master/tool.mk 3 | else 4 | ifeq ($(_THEOS_CURRENT_TYPE),tool) 5 | include $(THEOS_MAKE_PATH)/instance/tool.mk 6 | endif 7 | endif 8 | -------------------------------------------------------------------------------- /theos/makefiles/library.mk: -------------------------------------------------------------------------------- 1 | ifeq ($(THEOS_CURRENT_INSTANCE),) 2 | include $(THEOS_MAKE_PATH)/master/library.mk 3 | else 4 | ifeq ($(_THEOS_CURRENT_TYPE),library) 5 | include $(THEOS_MAKE_PATH)/instance/library.mk 6 | endif 7 | endif 8 | -------------------------------------------------------------------------------- /theos/makefiles/targets/_common/linux.mk: -------------------------------------------------------------------------------- 1 | # Variables that are common to all Linux-based targets. 2 | TARGET_EXE_EXT := 3 | TARGET_LIB_EXT := .so 4 | 5 | TARGET_LDFLAGS_DYNAMICLIB = -shared -Wl,-soname,$(1) 6 | TARGET_CFLAGS_DYNAMICLIB = -fPIC 7 | -------------------------------------------------------------------------------- /theos/bin/install.mergeDir: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | cd "$1" 3 | # Use fakeroot.sh to ensure that permissions are preserved, and install.exec to ensure that we are running tar -x on the right system. 4 | fakeroot.sh -r tar -c . | install.exec "tar -x -C \"$2\"" 5 | -------------------------------------------------------------------------------- /theos/makefiles/targets/_common/darwin_hierarchial_bundle.mk: -------------------------------------------------------------------------------- 1 | _THEOS_TARGET_BUNDLE_INFO_PLIST_SUBDIRECTORY := /Contents 2 | _THEOS_TARGET_BUNDLE_RESOURCE_SUBDIRECTORY := /Contents/Resources 3 | _THEOS_TARGET_BUNDLE_BINARY_SUBDIRECTORY := /Contents/MacOS 4 | -------------------------------------------------------------------------------- /theos/makefiles/platform/Linux.mk: -------------------------------------------------------------------------------- 1 | ifeq ($(_THEOS_PLATFORM_LOADED),) 2 | _THEOS_PLATFORM_LOADED := 1 3 | THEOS_PLATFORM_NAME := linux 4 | 5 | _THEOS_PLATFORM_DEFAULT_TARGET := iphone 6 | _THEOS_PLATFORM_DU_EXCLUDE := --exclude 7 | _THEOS_PLATFORM_MD5SUM := md5sum 8 | endif 9 | -------------------------------------------------------------------------------- /theos/makefiles/platform/Darwin-arm.mk: -------------------------------------------------------------------------------- 1 | ifeq ($(_THEOS_PLATFORM_LOADED),) 2 | _THEOS_PLATFORM_LOADED := 1 3 | THEOS_PLATFORM_NAME := iphone 4 | 5 | _THEOS_PLATFORM_DEFAULT_TARGET := iphone 6 | _THEOS_PLATFORM_DU_EXCLUDE := --exclude 7 | _THEOS_PLATFORM_MD5SUM := md5sum 8 | endif 9 | -------------------------------------------------------------------------------- /theos/makefiles/package/none.mk: -------------------------------------------------------------------------------- 1 | ifeq ($(_THEOS_PACKAGE_FORMAT_LOADED),) 2 | _THEOS_PACKAGE_FORMAT_LOADED := 1 3 | 4 | # This package format does nothing - it simply relies upon the internal-package rule in package.mk to do nothing for it. 5 | endif # _THEOS_PACKAGE_FORMAT_LOADED 6 | -------------------------------------------------------------------------------- /test.c: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | int main() { 5 | struct stat buf; 6 | stat("test.c", &buf); 7 | fprintf(stderr, "owned by %d:%d\n", buf.st_uid, buf.st_gid); 8 | chown("test.c", 0, 0); 9 | stat("test.c", &buf); 10 | fprintf(stderr, "owned by %d:%d\n", buf.st_uid, buf.st_gid); 11 | return 0; 12 | } 13 | -------------------------------------------------------------------------------- /theos/makefiles/platform/Darwin.mk: -------------------------------------------------------------------------------- 1 | ifeq ($(_THEOS_PLATFORM_LOADED),) 2 | _THEOS_PLATFORM_LOADED := 1 3 | THEOS_PLATFORM_NAME := macosx 4 | 5 | THEOS_PLATFORM_SDK_ROOT ?= $(shell xcode-select -print-path) 6 | 7 | _THEOS_PLATFORM_DEFAULT_TARGET := iphone 8 | _THEOS_PLATFORM_DU_EXCLUDE := -I 9 | _THEOS_PLATFORM_MD5SUM := md5 10 | endif 11 | -------------------------------------------------------------------------------- /theos/makefiles/targets/_common/darwin.mk: -------------------------------------------------------------------------------- 1 | # Variables that are common to all Darwin-based targets. 2 | TARGET_EXE_EXT := 3 | TARGET_LIB_EXT := .dylib 4 | 5 | TARGET_LDFLAGS_DYNAMICLIB = -dynamiclib -install_name "$(LOCAL_INSTALL_PATH)/$(1)" 6 | TARGET_CFLAGS_DYNAMICLIB = 7 | 8 | _THEOS_TARGET_ONLY_OBJCFLAGS := -std=c99 9 | 10 | _THEOS_TARGET_SUPPORTS_BUNDLES := 1 11 | -------------------------------------------------------------------------------- /theos/makefiles/install/deb_local.mk: -------------------------------------------------------------------------------- 1 | internal-install:: 2 | @if [ -z "$(_THEOS_PACKAGE_LAST_FILENAME)" ]; then \ 3 | echo "$(MAKE) install requires that you build a package before you try to install it." >&2; \ 4 | exit 1; \ 5 | fi 6 | @if [ ! -f "$(_THEOS_PACKAGE_LAST_FILENAME)" ]; then \ 7 | echo "Could not find \"$(_THEOS_PACKAGE_LAST_FILENAME)\" to install. Aborting." >&2; \ 8 | exit 1; \ 9 | fi 10 | install.exec "dpkg -i \"$(_THEOS_PACKAGE_LAST_FILENAME)\"" 11 | -------------------------------------------------------------------------------- /theos/makefiles/install/deb_remote.mk: -------------------------------------------------------------------------------- 1 | internal-install:: 2 | @if [ -z "$(_THEOS_PACKAGE_LAST_FILENAME)" ]; then \ 3 | echo "$(MAKE) install requires that you build a package before you try to install it." >&2; \ 4 | exit 1; \ 5 | fi 6 | @if [ ! -f "$(_THEOS_PACKAGE_LAST_FILENAME)" ]; then \ 7 | echo "Could not find \"$(_THEOS_PACKAGE_LAST_FILENAME)\" to install. Aborting." >&2; \ 8 | exit 1; \ 9 | fi 10 | install.exec "cat > /tmp/_theos_install.deb; dpkg -i /tmp/_theos_install.deb && rm /tmp/_theos_install.deb" < "$(_THEOS_PACKAGE_LAST_FILENAME)" 11 | -------------------------------------------------------------------------------- /theos/bin/target.pl: -------------------------------------------------------------------------------- 1 | #!/usr/bin/perl 2 | use File::Temp; 3 | 4 | my @o; 5 | for(reverse @ARGV) { 6 | my $i = 0; 7 | for my $a (split /:/) { 8 | if(length $a > 0) { 9 | @o = () if($i == 0 && $o[$i] && $o[$i] ne $a); 10 | $o[$i] = $a; 11 | } 12 | $i++; 13 | } 14 | } 15 | #print join(':', map { $_ eq "" ? "-" : $_ } @o); 16 | my $i = 0; 17 | my ($fh, $tempfile) = File::Temp::tempfile(); 18 | binmode($fh, ":utf8"); 19 | 20 | for(@o) { 21 | print $fh "export __THEOS_TARGET_ARG_$i := $_\n"; 22 | ++$i; 23 | } 24 | 25 | close($fh); 26 | print $tempfile,$/; 27 | -------------------------------------------------------------------------------- /theos/makefiles/targets/Linux/linux.mk: -------------------------------------------------------------------------------- 1 | ifeq ($(_THEOS_TARGET_LOADED),) 2 | _THEOS_TARGET_LOADED := 1 3 | THEOS_TARGET_NAME := linux 4 | 5 | ifneq ($(__THEOS_TARGET_ARG_1),) 6 | CROSS_COMPILE := $(__THEOS_TARGET_ARG_1)- 7 | endif 8 | 9 | TARGET_CC ?= $(CROSS_COMPILE)gcc 10 | TARGET_CXX ?= $(CROSS_COMPILE)g++ 11 | TARGET_LD ?= $(CROSS_COMPILE)g++ 12 | TARGET_STRIP ?= $(CROSS_COMPILE)strip 13 | TARGET_STRIP_FLAGS ?= 14 | TARGET_CODESIGN_ALLOCATE ?= 15 | TARGET_CODESIGN ?= 16 | TARGET_CODESIGN_FLAGS ?= 17 | 18 | include $(THEOS_MAKE_PATH)/targets/_common/linux.mk 19 | 20 | endif 21 | -------------------------------------------------------------------------------- /theos/bin/deb_build_num.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | GETONLY=0 3 | if [[ $1 == "-g" ]]; then 4 | GETONLY=1 5 | shift 6 | fi 7 | 8 | if [[ $# -lt 2 ]]; then 9 | echo "Syntax: $0 [-g] packagename versionname" >&2 10 | exit 1 11 | fi 12 | 13 | if [[ ! -d $TOP_DIR/.debmake ]]; then 14 | mkdir $TOP_DIR/.debmake 15 | fi 16 | 17 | PACKAGE=$1 18 | VERSION=$2 19 | INFOFILE=$TOP_DIR/.debmake/$PACKAGE-$VERSION 20 | if [[ ! -e $INFOFILE ]]; then 21 | echo -n 1 > $INFOFILE 22 | echo -n 1 23 | exit 0 24 | else 25 | CURNUM=$(cat $INFOFILE) 26 | if [[ $GETONLY -eq 0 ]]; then 27 | let CURNUM++ 28 | echo -n $CURNUM > $INFOFILE 29 | fi 30 | echo $CURNUM 31 | fi 32 | -------------------------------------------------------------------------------- /theos/bin/vercmp.pl: -------------------------------------------------------------------------------- 1 | #!/usr/bin/perl 2 | use warnings; 3 | use strict; 4 | if(@ARGV < 3) { 5 | exit 1; 6 | } 7 | my @afirst = split(/\./, $ARGV[0]); 8 | my $op = $ARGV[1]; 9 | my @asecond = split(/\./, $ARGV[2]); 10 | 11 | push(@afirst, 0) while(@afirst < @asecond); 12 | push(@asecond, 0) while(@asecond < @afirst); 13 | 14 | my $v1 = 0; 15 | my $v2 = 0; 16 | map { ($v1 *= 100) += $_ } (@afirst); 17 | map { ($v2 *= 100) += $_ } (@asecond); 18 | 19 | print "1" if $v1 > $v2 && $op eq "gt"; 20 | print "1" if $v1 < $v2 && $op eq "lt"; 21 | print "1" if $v1 >= $v2 && $op eq "ge"; 22 | print "1" if $v1 <= $v2 && $op eq "le"; 23 | print "1" if $v1 == $v2 && $op eq "eq"; 24 | -------------------------------------------------------------------------------- /theos/makefiles/master/tool.mk: -------------------------------------------------------------------------------- 1 | TOOL_NAME := $(strip $(TOOL_NAME)) 2 | 3 | ifeq ($(_THEOS_RULES_LOADED),) 4 | include $(THEOS_MAKE_PATH)/rules.mk 5 | endif 6 | 7 | internal-all:: $(TOOL_NAME:=.all.tool.variables); 8 | 9 | internal-stage:: $(TOOL_NAME:=.stage.tool.variables); 10 | 11 | TOOLS_WITH_SUBPROJECTS = $(strip $(foreach tool,$(TOOL_NAME),$(patsubst %,$(tool),$(call __schema_var_all,$(tool)_,SUBPROJECTS)))) 12 | ifneq ($(TOOLS_WITH_SUBPROJECTS),) 13 | internal-clean:: $(TOOLS_WITH_SUBPROJECTS:=.clean.tool.subprojects) 14 | endif 15 | 16 | $(TOOL_NAME): 17 | @$(MAKE) -f $(_THEOS_PROJECT_MAKEFILE_NAME) --no-print-directory --no-keep-going $@.all.tool.variables 18 | 19 | $(eval $(call __mod,master/tool.mk)) 20 | -------------------------------------------------------------------------------- /theos/makefiles/master/library.mk: -------------------------------------------------------------------------------- 1 | LIBRARY_NAME := $(strip $(LIBRARY_NAME)) 2 | 3 | ifeq ($(_THEOS_RULES_LOADED),) 4 | include $(THEOS_MAKE_PATH)/rules.mk 5 | endif 6 | 7 | internal-all:: $(LIBRARY_NAME:=.all.library.variables); 8 | 9 | internal-stage:: $(LIBRARY_NAME:=.stage.library.variables); 10 | 11 | LIBRARYS_WITH_SUBPROJECTS = $(strip $(foreach library,$(LIBRARY_NAME),$(patsubst %,$(library),$(call __schema_var_all,$(library)_,SUBPROJECTS)))) 12 | ifneq ($(LIBRARYS_WITH_SUBPROJECTS),) 13 | internal-clean:: $(LIBRARYS_WITH_SUBPROJECTS:=.clean.library.subprojects) 14 | endif 15 | 16 | $(LIBRARY_NAME): 17 | @$(MAKE) -f $(_THEOS_PROJECT_MAKEFILE_NAME) --no-print-directory --no-keep-going $@.all.library.variables 18 | 19 | $(eval $(call __mod,master/library.mk)) 20 | -------------------------------------------------------------------------------- /Makefile: -------------------------------------------------------------------------------- 1 | TARGET = native 2 | #DEBUG = 1 3 | GO_EASY_ON_ME = 1 4 | include theos/makefiles/common.mk 5 | 6 | INSTALL_PREFIX ?= /usr 7 | LIBRARY_NAME = libfauxsu 8 | libfauxsu_FILES = fauxsu.cc 9 | libfauxsu_INSTALL_PATH = $(INSTALL_PREFIX)/libexec/fauxsu 10 | 11 | #TOOL_NAME = test 12 | test_FILES = test.c 13 | 14 | ADDITIONAL_CFLAGS = -Wno-format -Wno-sign-compare 15 | 16 | include $(THEOS_MAKE_PATH)/library.mk 17 | #include $(THEOS_MAKE_PATH)/tool.mk 18 | 19 | after-all:: $(THEOS_OBJ_DIR)/fauxsu.sh 20 | 21 | internal-stage:: 22 | @mkdir -p $(THEOS_STAGING_DIR)$(INSTALL_PREFIX)/bin 23 | @cp $(THEOS_OBJ_DIR)/fauxsu.sh $(THEOS_STAGING_DIR)$(INSTALL_PREFIX)/bin/fauxsu 24 | @chmod +x $(THEOS_STAGING_DIR)$(INSTALL_PREFIX)/bin/fauxsu 25 | 26 | $(THEOS_OBJ_DIR)/fauxsu.sh: fauxsu.sh.in 27 | @sed -e 's|@@FAUXSU_INSTALL_PATH@@|$(libfauxsu_INSTALL_PATH)|g' $< > $@ 28 | -------------------------------------------------------------------------------- /fauxsu.sh.in: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | unset persist 4 | while getopts "p:" Option; do 5 | case $Option in 6 | p) persist="${OPTARG}" ;; 7 | *) exit 1 ;; 8 | esac 9 | done 10 | 11 | shift $(($OPTIND - 1)) 12 | 13 | if [[ ! -z "$persist" ]]; then 14 | export _FAUXSU_PERSIST_FILENAME="$persist" 15 | fi 16 | 17 | _LIBFAUXSU="@@FAUXSU_INSTALL_PATH@@/libfauxsu.dylib" 18 | 19 | if [[ ! -z "${THEOS_BIN_PATH}" ]]; then 20 | _LIBFAUXSU="${THEOS_BIN_PATH}/libfauxsu.dylib" 21 | fi 22 | 23 | if [[ ! -z "${FW_BINDIR}" ]]; then 24 | _LIBFAUXSU="${FW_BINDIR}/libfauxsu.dylib" 25 | fi 26 | 27 | if [[ ! -f "$_LIBFAUXSU" ]]; then 28 | _SELF="$(dirname $0)" 29 | _LIBFAUXSU="$_SELF/libfauxsu.dylib" 30 | fi 31 | 32 | if [[ ! -f "$_LIBFAUXSU" ]]; then 33 | echo "I couldn't find libfauxsu.dylib :(" 1>&2 34 | fi 35 | 36 | export DYLD_INSERT_LIBRARIES="${_LIBFAUXSU}" 37 | if [[ $# -eq 0 ]]; then 38 | ${SHELL:-/bin/sh} 39 | RESULT=$? 40 | else 41 | "$@" 42 | RESULT=$? 43 | fi 44 | exit $RESULT 45 | -------------------------------------------------------------------------------- /theos/makefiles/targets/Linux/iphone.mk: -------------------------------------------------------------------------------- 1 | ifeq ($(_THEOS_TARGET_LOADED),) 2 | _THEOS_TARGET_LOADED := 1 3 | THEOS_TARGET_NAME := iphone 4 | 5 | SDKTARGET ?= arm-apple-darwin9 6 | SDKBINPATH ?= /opt/iphone-sdk-3.0/prefix/bin 7 | SYSROOT ?= /opt/iphone-sdk-3.0/sysroot 8 | 9 | PREFIX := $(SDKBINPATH)/$(SDKTARGET)- 10 | 11 | TARGET_CC ?= $(PREFIX)gcc 12 | TARGET_CXX ?= $(PREFIX)g++ 13 | TARGET_LD ?= $(PREFIX)g++ 14 | TARGET_STRIP ?= $(PREFIX)strip 15 | TARGET_STRIP_FLAGS ?= -x 16 | TARGET_CODESIGN_ALLOCATE ?= $(PREFIX)codesign_allocate 17 | TARGET_CODESIGN ?= ldid 18 | TARGET_CODESIGN_FLAGS ?= -S 19 | 20 | include $(THEOS_MAKE_PATH)/targets/_common/darwin.mk 21 | include $(THEOS_MAKE_PATH)/targets/_common/darwin_flat_bundle.mk 22 | 23 | TARGET_PRIVATE_FRAMEWORK_PATH = $(SYSROOT)/System/Library/PrivateFrameworks 24 | 25 | SDKFLAGS := -isysroot $(SYSROOT) 26 | _THEOS_TARGET_CFLAGS := $(SDKFLAGS) 27 | _THEOS_TARGET_LDFLAGS := $(SDKFLAGS) -multiply_defined suppress 28 | 29 | TARGET_INSTALL_REMOTE := $(_THEOS_TRUE) 30 | _THEOS_TARGET_DEFAULT_PACKAGE_FORMAT := deb 31 | endif 32 | -------------------------------------------------------------------------------- /theos/Prefix.pch: -------------------------------------------------------------------------------- 1 | #ifdef __OBJC__ 2 | #import 3 | #if TARGET_IPHONE || TARGET_IPHONE_SIMULATOR 4 | #import 5 | #endif 6 | 7 | #define CLASS(cls) objc_getClass(#cls) 8 | 9 | #ifdef DEBUG 10 | #define __DEBUG__ 11 | #endif 12 | 13 | #ifdef __DEBUG__ 14 | #define CMLog(format, ...) NSLog(@"(%s) in [%s:%d] ::: %@", __PRETTY_FUNCTION__, __FILE__, __LINE__, [NSString stringWithFormat:format, ## __VA_ARGS__]) 15 | #define MARK CMLog(@"%s", __PRETTY_FUNCTION__); 16 | #define START_TIMER NSTimeInterval start = [NSDate timeIntervalSinceReferenceDate]; 17 | #define END_TIMER(msg) NSTimeInterval stop = [NSDate timeIntervalSinceReferenceDate]; CMLog([NSString stringWithFormat:@"%@ Time = %f", msg, stop-start]) 18 | #else 19 | #define CMLog(format, ...) 20 | #define MARK 21 | #define START_TIMER 22 | #define END_TIMER(msg) 23 | //#define NSLog(...) 24 | #endif 25 | 26 | #define NB [NSBundle mainBundle] 27 | #define UD [NSUserDefaults standardUserDefaults] 28 | #define FM [NSFileManager defaultManager] 29 | #endif 30 | -------------------------------------------------------------------------------- /theos/bin/fakeroot.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | required=0 3 | persistence=/tmp/dhbxxx 4 | 5 | while getopts ":p:rc" flag; do 6 | case "$flag" in 7 | :) echo "$0: Option -$OPTARG requires an argument." 1>&2 8 | exit 1 9 | ;; 10 | \?) echo "$0: Option -$OPTARG unrecognized." 1>&2 11 | exit 1 12 | ;; 13 | p) persistence="$OPTARG" ;; 14 | r) required=1 ;; 15 | c) delpersistence=1 ;; 16 | esac 17 | done 18 | shift $((OPTIND-1)) 19 | cmd=$* 20 | 21 | mkdir -p $(dirname $persistence) 22 | touch $persistence 23 | 24 | if [[ $delpersistence -eq 1 ]]; then 25 | rm -f $persistence 26 | exit 0 27 | fi 28 | 29 | if [[ "$USER" == "root" ]]; then 30 | fakeroot="" 31 | elif type fauxsu &> /dev/null; then 32 | fakeroot="fauxsu -p $persistence -- " 33 | elif type fakeroot-ng &> /dev/null; then 34 | fakeroot="fakeroot-ng -p $persistence -- " 35 | elif type fakeroot &> /dev/null; then 36 | fakeroot="fakeroot -i $persistence -s $persistence -- " 37 | else 38 | if [[ $required -eq 1 ]]; then 39 | fakeroot="" 40 | else 41 | fakeroot=": " 42 | fi 43 | fi 44 | 45 | #echo $fakeroot $cmd 46 | $fakeroot $cmd 47 | -------------------------------------------------------------------------------- /fauxsu.info: -------------------------------------------------------------------------------- 1 | Package: fauxsu 2 | Homepage: http://github.com/DHowett/fauxsu 3 | Maintainer: Dustin Howett 4 | Version: 0.9.1 5 | Revision: 1 6 | License: GPL 7 | BuildDepends: fink (>= 0.28) 8 | Source: http://dist.howett.net/f/fauxsu/fauxsu-%v.tgz 9 | SourceDirectory: fauxsu-%v 10 | Source-MD5: 097e61d9e9042cc7ff93815f98c1933c 11 | CompileScript: << 12 | #!/bin/bash -e -x 13 | sed -i '' -e 's/libexec/%lib/' Makefile 14 | make INSTALL_PREFIX=%p messages=yes 15 | << 16 | InstallScript: << 17 | #!/bin/bash -e -x 18 | d=$(mktemp -d "/tmp/fink-%N-XXXXXX") 19 | if ! [ -d "$d" ]; then 20 | printf "failed to create temporary directory\n" >&2 21 | exit 1 22 | fi 23 | make stage INSTALL_PREFIX=%p THEOS_STAGING_DIR="$d" messages=yes 24 | rsync -a --delete "$d/" "%d/" 25 | mkdir -p %i/share/doc/%N 26 | cp LICENSE %i/share/doc/%N || true 27 | [ -d "$d" ] && rm -rf "$d" 28 | << 29 | Description: Grants applications fake root privileges 30 | DescDetail: << 31 | fauxsu wraps system calls involved in changing file ownership and modes, 32 | allowing programs to act as if run as the superuser. 33 | << 34 | Shlibs: << 35 | !%p/lib/%N/libfauxsu.dylib 36 | << 37 | -------------------------------------------------------------------------------- /theos/bin/package_version.sh: -------------------------------------------------------------------------------- 1 | #!/bin/bash 2 | 3 | function build_num_from_file { 4 | version=$(< "$1") 5 | version=${version##*-} 6 | version=${version%%+*} 7 | version=${version%%~*} 8 | echo -n "$version" 9 | } 10 | 11 | while getopts ":N:V:" flag; do 12 | case "$flag" in 13 | :) echo "$0: Option -$OPTARG requires an argument." 1>&2 14 | exit 1 15 | ;; 16 | \?) echo "$0: What're you talking about?" 1>&2 17 | exit 1 18 | ;; 19 | N) package="$OPTARG" ;; 20 | V) version="$OPTARG" ;; 21 | esac 22 | done 23 | 24 | if [[ ! -d "${THEOS_PROJECT_DIR}/.theos/packages" ]]; then 25 | if [[ -d "${THEOS_PROJECT_DIR}/.debmake" ]]; then 26 | mkdir -p "${THEOS_PROJECT_DIR}/.theos" 27 | mv "${THEOS_PROJECT_DIR}/.debmake" "${THEOS_PROJECT_DIR}/.theos/packages" 28 | else 29 | mkdir -p "${THEOS_PROJECT_DIR}/.theos/packages" 30 | fi 31 | fi 32 | 33 | versionfile="${THEOS_PROJECT_DIR}/.theos/packages/$package-$version" 34 | build_number=0 35 | 36 | if [[ ! -e "$versionfile" ]]; then 37 | build_number=1 38 | else 39 | build_number=$(build_num_from_file "$versionfile") 40 | let build_number++ 41 | fi 42 | 43 | echo -n "$build_number" > "$versionfile" 44 | echo "$build_number" 45 | -------------------------------------------------------------------------------- /theos/makefiles/stage.mk: -------------------------------------------------------------------------------- 1 | ifeq ($(_THEOS_STAGING_RULES_LOADED),) 2 | _THEOS_STAGING_RULES_LOADED := 1 3 | 4 | .PHONY: stage before-stage internal-stage after-stage 5 | 6 | # For the toplevel invocation of make, mark 'all' and the *-stage rules as prerequisites. 7 | # We do not do this for anything else, because otherwise, all the staging rules would run for every subproject. 8 | ifeq ($(_THEOS_TOP_INVOCATION_DONE),) 9 | stage:: all before-stage internal-stage after-stage 10 | else # _THEOS_TOP_INVOCATION_DONE 11 | stage:: internal-stage 12 | endif 13 | 14 | # Only do the master staging rules if we're the toplevel make invocation. 15 | ifeq ($(_THEOS_TOP_INVOCATION_DONE),) 16 | before-stage:: 17 | $(ECHO_NOTHING)rm -rf "$(THEOS_STAGING_DIR)"$(ECHO_END) 18 | $(ECHO_NOTHING)$(FAKEROOT) -c$(ECHO_END) 19 | $(ECHO_NOTHING)mkdir -p "$(THEOS_STAGING_DIR)"$(ECHO_END) 20 | else # _THEOS_TOP_INVOCATION_DONE 21 | before-stage:: 22 | @: 23 | endif # _THEOS_TOP_INVOCATION_DONE 24 | 25 | internal-stage:: 26 | $(ECHO_NOTHING)[ -d layout ] && rsync -a "layout/" "$(THEOS_STAGING_DIR)" --exclude "DEBIAN" $(_THEOS_RSYNC_EXCLUDE_COMMANDLINE) || true$(ECHO_END) 27 | 28 | after-stage:: 29 | @: 30 | 31 | endif # _THEOS_STAGING_RULES_LOADED 32 | -------------------------------------------------------------------------------- /theos/makefiles/messages.mk: -------------------------------------------------------------------------------- 1 | ifneq ($(call __theos_bool,$(or $(messages),$(MESSAGES))),$(_THEOS_TRUE)) 2 | ECHO_COMPILING = @(echo " Compiling $<..."; 3 | ECHO_LINKING = @(echo " Linking $(_THEOS_CURRENT_TYPE) $(THEOS_CURRENT_INSTANCE)..."; 4 | ECHO_STRIPPING = @(echo " Stripping $(THEOS_CURRENT_INSTANCE)..."; 5 | ECHO_SIGNING = @(echo " Signing $(THEOS_CURRENT_INSTANCE)..."; 6 | ECHO_PREPROCESSING = @(echo " Preprocessing $<..."; 7 | ECHO_COPYING_RESOURCE_FILES = @(echo " Copying resource files into the $(_THEOS_CURRENT_TYPE) wrapper..."; 8 | ECHO_COPYING_RESOURCE_DIRS = @(echo " Copying resource directories into the $(_THEOS_CURRENT_TYPE) wrapper..."; 9 | ECHO_NOTHING = @( 10 | 11 | STDERR_NULL_REDIRECT = 2> /dev/null 12 | 13 | ECHO_END = ) 14 | 15 | _THEOS_VERBOSE := $(_THEOS_FALSE) 16 | else 17 | ECHO_COMPILING = 18 | ECHO_LINKING = 19 | ECHO_STRIPPING = 20 | ECHO_SIGNING = 21 | ECHO_PREPROCESSING = 22 | ECHO_COPYING_RESOURCE_FILES = 23 | ECHO_COPYING_RESOURCE_DIRS = 24 | ECHO_NOTHING = 25 | STDERR_NULL_REDIRECT = 26 | ECHO_END = 27 | 28 | _THEOS_VERBOSE := $(_THEOS_TRUE) 29 | endif 30 | 31 | WARNING_EMPTY_LINKING = @(echo " Warning! No files to link. Please check your Makefile! Make sure you set $(THEOS_CURRENT_INSTANCE)_FILES (or similar variables)") 32 | 33 | # (bundle) 34 | NOTICE_EMPTY_LINKING = @(echo " Notice: No files to link - creating a bundle containing only resources") 35 | 36 | $(eval $(call __mod,messages.mk)) 37 | -------------------------------------------------------------------------------- /theos/makefiles/targets/Darwin/macosx.mk: -------------------------------------------------------------------------------- 1 | ifeq ($(_THEOS_TARGET_LOADED),) 2 | _THEOS_TARGET_LOADED := 1 3 | THEOS_TARGET_NAME := macosx 4 | 5 | ifeq ($(__THEOS_TARGET_ARG_1),clang) 6 | _THEOS_TARGET_CC := clang 7 | _THEOS_TARGET_CXX := clang++ 8 | _THEOS_TARGET_ARG_ORDER := 2 9 | else 10 | _THEOS_TARGET_CC := gcc 11 | _THEOS_TARGET_CXX := g++ 12 | _THEOS_TARGET_ARG_ORDER := 1 13 | endif 14 | 15 | _THEOS_TARGET_MACOSX_DEPLOYMENT_VERSION := $(__THEOS_TARGET_ARG_$(_THEOS_TARGET_ARG_ORDER)) 16 | TARGET_CC ?= xcrun -sdk macosx $(_THEOS_TARGET_CC) 17 | TARGET_CXX ?= xcrun -sdk macosx $(_THEOS_TARGET_CXX) 18 | TARGET_LD ?= xcrun -sdk macosx $(_THEOS_TARGET_CXX) 19 | TARGET_STRIP ?= xcrun -sdk macosx strip 20 | TARGET_STRIP_FLAGS ?= -x 21 | TARGET_CODESIGN_ALLOCATE ?= "$(shell xcrun -sdk macosx -find codesign_allocate)" 22 | TARGET_CODESIGN ?= 23 | TARGET_CODESIGN_FLAGS ?= 24 | 25 | TARGET_PRIVATE_FRAMEWORK_PATH = /System/Library/PrivateFrameworks 26 | 27 | include $(THEOS_MAKE_PATH)/targets/_common/darwin.mk 28 | include $(THEOS_MAKE_PATH)/targets/_common/darwin_hierarchial_bundle.mk 29 | 30 | ARCHS ?= i386 x86_64 31 | SDKFLAGS := $(foreach ARCH,$(ARCHS),-arch $(ARCH)) $(if $(_THEOS_TARGET_MACOSX_DEPLOYMENT_VERSION),-mmacosx-version-min=$(_THEOS_TARGET_MACOSX_DEPLOYMENT_VERSION)) 32 | _THEOS_TARGET_CFLAGS := $(SDKFLAGS) 33 | _THEOS_TARGET_LDFLAGS := $(SDKFLAGS) -multiply_defined suppress 34 | 35 | export TARGET_INSTALL_REMOTE := $(_THEOS_FALSE) 36 | export _THEOS_TARGET_DEFAULT_PACKAGE_FORMAT := deb 37 | endif 38 | -------------------------------------------------------------------------------- /theos/makefiles/legacy.mk: -------------------------------------------------------------------------------- 1 | FRAMEWORKDIR = $(THEOS) 2 | FW_BINDIR = $(THEOS_BIN_PATH) 3 | FW_MAKEDIR = $(THEOS_MAKE_PATH) 4 | FW_INCDIR = $(THEOS_INCLUDE_PATH) 5 | FW_LIBDIR = $(THEOS_LIBRARY_PATH) 6 | FW_MODDIR = $(THEOS_MODULE_PATH) 7 | 8 | FW_PROJECT_DIR = $(THEOS_PROJECT_DIR) 9 | 10 | export FRAMEWORKDIR FW_BINDIR FW_MAKEDIR FW_INCDIR FW_LIBDIR FW_MODDIR 11 | export FW_PROJECT_DIR 12 | 13 | FW_PLATFORM_NAME = $(THEOS_PLATFORM_NAME) 14 | FW_TARGET_NAME = $(THEOS_TARGET_NAME) 15 | 16 | FW_STAGING_DIR = $(THEOS_STAGING_DIR) 17 | 18 | ifneq ($(FW_BUILD_DIR),) 19 | THEOS_BUILD_DIR ?= $(FW_BUILD_DIR) 20 | else 21 | FW_BUILD_DIR = $(THEOS_BUILD_DIR) 22 | endif 23 | 24 | ifneq ($(FW_OBJ_DIR_NAME),) 25 | THEOS_OBJ_DIR_NAME ?= $(FW_OBJ_DIR_NAME) 26 | endif 27 | 28 | FW_OBJ_DIR = $(THEOS_OBJ_DIR) 29 | 30 | ifneq ($(FW_SUBPROJECT_PRODUCT),) 31 | THEOS_SUBPROJECT_PRODUCT ?= $(FW_SUBPROJECT_PRODUCT) 32 | else 33 | FW_SUBPROJECT_PRODUCT = $(THEOS_SUBPROJECT_PRODUCT) 34 | endif 35 | 36 | FW_INSTANCE = $(THEOS_CURRENT_INSTANCE) 37 | 38 | FW_SHARED_BUNDLE_RESOURCE_PATH = $(THEOS_SHARED_BUNDLE_RESOURCE_PATH) 39 | FW_PACKAGE_NAME = $(THEOS_PACKAGE_NAME) 40 | FW_PACKAGE_ARCH = $(THEOS_PACKAGE_ARCH) 41 | FW_PACKAGE_VERSION = $(THEOS_PACKAGE_BASE_VERSION) 42 | FW_PACKAGE_DEBVERSION = $(THEOS_PACKAGE_VERSION) 43 | FW_PACKAGE_FILENAME = $(THEOS_PACKAGE_FILENAME) 44 | 45 | ifneq ($(FW_DEVICE_IP),) 46 | THEOS_DEVICE_IP ?= $(FW_DEVICE_IP) 47 | endif 48 | 49 | ifneq ($(FW_DEVICE_PORT),) 50 | THEOS_DEVICE_PORT ?= $(FW_DEVICE_PORT) 51 | endif 52 | 53 | -------------------------------------------------------------------------------- /theos/makefiles/instance/tool.mk: -------------------------------------------------------------------------------- 1 | ifeq ($(_THEOS_RULES_LOADED),) 2 | include $(THEOS_MAKE_PATH)/rules.mk 3 | endif 4 | 5 | .PHONY: internal-tool-all_ internal-tool-stage_ internal-tool-compile 6 | 7 | ifeq ($(_THEOS_MAKE_PARALLEL_BUILDING), no) 8 | internal-tool-all_:: $(_OBJ_DIR_STAMPS) $(THEOS_OBJ_DIR)/$(THEOS_CURRENT_INSTANCE)$(TARGET_EXE_EXT) 9 | else 10 | internal-tool-all_:: $(_OBJ_DIR_STAMPS) 11 | $(ECHO_NOTHING)$(MAKE) -f $(_THEOS_PROJECT_MAKEFILE_NAME) --no-print-directory --no-keep-going \ 12 | internal-tool-compile \ 13 | _THEOS_CURRENT_TYPE=$(_THEOS_CURRENT_TYPE) THEOS_CURRENT_INSTANCE=$(THEOS_CURRENT_INSTANCE) _THEOS_CURRENT_OPERATION=compile \ 14 | THEOS_BUILD_DIR="$(THEOS_BUILD_DIR)" _THEOS_MAKE_PARALLEL=yes$(ECHO_END) 15 | 16 | internal-tool-compile: $(THEOS_OBJ_DIR)/$(THEOS_CURRENT_INSTANCE)$(TARGET_EXE_EXT) 17 | endif 18 | 19 | $(eval $(call _THEOS_TEMPLATE_DEFAULT_LINKING_RULE,$(THEOS_CURRENT_INSTANCE)$(TARGET_EXE_EXT))) 20 | 21 | LOCAL_INSTALL_PATH = $(strip $($(THEOS_CURRENT_INSTANCE)_INSTALL_PATH)) 22 | ifeq ($(LOCAL_INSTALL_PATH),) 23 | LOCAL_INSTALL_PATH = $($(THEOS_CURRENT_INSTANCE)_PACKAGE_TARGET_DIR) 24 | ifeq ($(LOCAL_INSTALL_PATH),) 25 | LOCAL_INSTALL_PATH = /usr/bin 26 | endif 27 | endif 28 | 29 | internal-tool-stage_:: 30 | $(ECHO_NOTHING)mkdir -p "$(THEOS_STAGING_DIR)$(LOCAL_INSTALL_PATH)"$(ECHO_END) 31 | $(ECHO_NOTHING)cp $(THEOS_OBJ_DIR)/$(THEOS_CURRENT_INSTANCE)$(TARGET_EXE_EXT) "$(THEOS_STAGING_DIR)$(LOCAL_INSTALL_PATH)"$(ECHO_END) 32 | 33 | $(eval $(call __mod,instance/tool.mk)) 34 | -------------------------------------------------------------------------------- /theos/makefiles/rules.mk: -------------------------------------------------------------------------------- 1 | ifeq ($(_THEOS_RULES_LOADED),) 2 | _THEOS_RULES_LOADED := 1 3 | 4 | ifeq ($(THEOS_CURRENT_INSTANCE),) 5 | include $(THEOS_MAKE_PATH)/master/rules.mk 6 | else 7 | include $(THEOS_MAKE_PATH)/instance/rules.mk 8 | endif 9 | 10 | ifeq ($(_THEOS_MAKE_PARALLEL_BUILDING), no) 11 | .NOTPARALLEL: 12 | else 13 | ifneq ($(_THEOS_MAKE_PARALLEL), yes) 14 | .NOTPARALLEL: 15 | endif 16 | endif 17 | 18 | %.mm: %.l.mm 19 | $(THEOS_BIN_PATH)/logos.pl $< > $@ 20 | 21 | %.mm: %.xmm 22 | $(THEOS_BIN_PATH)/logos.pl $< > $@ 23 | 24 | %.mm: %.xm 25 | $(THEOS_BIN_PATH)/logos.pl $< > $@ 26 | 27 | %.m: %.xm 28 | $(THEOS_BIN_PATH)/logos.pl $< > $@ 29 | 30 | ifneq ($(THEOS_BUILD_DIR),.) 31 | $(THEOS_BUILD_DIR): 32 | @mkdir -p $(THEOS_BUILD_DIR) 33 | endif 34 | 35 | $(THEOS_OBJ_DIR): 36 | @cd $(THEOS_BUILD_DIR); mkdir -p $(THEOS_OBJ_DIR_NAME) 37 | 38 | $(THEOS_OBJ_DIR)/.stamp: $(THEOS_OBJ_DIR) 39 | @touch $@ 40 | 41 | $(THEOS_OBJ_DIR)/%/.stamp: $(THEOS_OBJ_DIR) 42 | @mkdir -p $(dir $@); touch $@ 43 | 44 | Makefile: ; 45 | $(_THEOS_RELATIVE_MAKE_PATH)%.mk: ; 46 | $(THEOS_MAKE_PATH)/%.mk: ; 47 | $(THEOS_MAKE_PATH)/master/%.mk: ; 48 | $(THEOS_MAKE_PATH)/instance/%.mk: ; 49 | $(THEOS_MAKE_PATH)/instance/shared/%.mk: ; 50 | $(THEOS_MAKE_PATH)/platform/%.mk: ; 51 | $(THEOS_MAKE_PATH)/targets/%.mk: ; 52 | $(THEOS_MAKE_PATH)/targets/%/%.mk: ; 53 | 54 | ifneq ($(THEOS_PACKAGE_DIR_NAME),) 55 | $(THEOS_PACKAGE_DIR): 56 | @cd $(THEOS_BUILD_DIR); mkdir -p $(THEOS_PACKAGE_DIR_NAME) 57 | endif 58 | 59 | endif 60 | 61 | # TODO MAKE A BUNCH OF THINGS PHONY 62 | $(eval $(call __mod,rules.mk)) 63 | -------------------------------------------------------------------------------- /theos/makefiles/instance/library.mk: -------------------------------------------------------------------------------- 1 | ifeq ($(_THEOS_RULES_LOADED),) 2 | include $(THEOS_MAKE_PATH)/rules.mk 3 | endif 4 | 5 | .PHONY: internal-library-all_ internal-library-stage_ internal-library-compile 6 | 7 | LOCAL_INSTALL_PATH ?= $(strip $($(THEOS_CURRENT_INSTANCE)_INSTALL_PATH)) 8 | ifeq ($(LOCAL_INSTALL_PATH),) 9 | LOCAL_INSTALL_PATH = /usr/lib 10 | endif 11 | 12 | _THEOS_INTERNAL_LDFLAGS += $(call TARGET_LDFLAGS_DYNAMICLIB,$(THEOS_CURRENT_INSTANCE)$(TARGET_LIB_EXT)) 13 | _THEOS_INTERNAL_CFLAGS += $(TARGET_CFLAGS_DYNAMICLIB) 14 | 15 | ifeq ($(_THEOS_MAKE_PARALLEL_BUILDING), no) 16 | internal-library-all_:: $(_OBJ_DIR_STAMPS) $(THEOS_OBJ_DIR)/$(THEOS_CURRENT_INSTANCE)$(TARGET_LIB_EXT) 17 | else 18 | internal-library-all_:: $(_OBJ_DIR_STAMPS) 19 | $(ECHO_NOTHING)$(MAKE) -f $(_THEOS_PROJECT_MAKEFILE_NAME) --no-print-directory --no-keep-going \ 20 | internal-library-compile \ 21 | _THEOS_CURRENT_TYPE=$(_THEOS_CURRENT_TYPE) THEOS_CURRENT_INSTANCE=$(THEOS_CURRENT_INSTANCE) _THEOS_CURRENT_OPERATION=compile \ 22 | THEOS_BUILD_DIR="$(THEOS_BUILD_DIR)" _THEOS_MAKE_PARALLEL=yes$(ECHO_END) 23 | 24 | internal-library-compile: $(THEOS_OBJ_DIR)/$(THEOS_CURRENT_INSTANCE)$(TARGET_LIB_EXT) 25 | endif 26 | 27 | $(eval $(call _THEOS_TEMPLATE_DEFAULT_LINKING_RULE,$(THEOS_CURRENT_INSTANCE)$(TARGET_LIB_EXT))) 28 | 29 | internal-library-stage_:: 30 | $(ECHO_NOTHING)mkdir -p "$(THEOS_STAGING_DIR)$(LOCAL_INSTALL_PATH)/"$(ECHO_END) 31 | $(ECHO_NOTHING)cp $(THEOS_OBJ_DIR)/$(THEOS_CURRENT_INSTANCE)$(TARGET_LIB_EXT) "$(THEOS_STAGING_DIR)$(LOCAL_INSTALL_PATH)/"$(ECHO_END) 32 | 33 | $(eval $(call __mod,instance/library.mk)) 34 | -------------------------------------------------------------------------------- /theos/makefiles/package/deb.mk: -------------------------------------------------------------------------------- 1 | ifeq ($(_THEOS_PACKAGE_FORMAT_LOADED),) 2 | _THEOS_PACKAGE_FORMAT_LOADED := 1 3 | 4 | _THEOS_DEB_PACKAGE_CONTROL_PATH := $(or $(wildcard $(THEOS_PROJECT_DIR)/control),$(wildcard $(THEOS_PROJECT_DIR)/layout/DEBIAN/control)) 5 | _THEOS_DEB_CAN_PACKAGE := $(if $(_THEOS_DEB_PACKAGE_CONTROL_PATH),$(_THEOS_TRUE),$(_THEOS_FALSE)) 6 | 7 | _THEOS_DEB_HAS_DPKG_DEB := $(call __executable,dpkg-deb) 8 | ifneq ($(_THEOS_DEB_HAS_DPKG_DEB),$(_THEOS_TRUE)) 9 | internal-package-check:: 10 | @echo "$(MAKE) package requires dpkg-deb."; exit 1 11 | endif 12 | 13 | ifeq ($(_THEOS_DEB_CAN_PACKAGE),$(_THEOS_TRUE)) # Control file found (or layout/ found.) 14 | THEOS_PACKAGE_NAME := $(shell grep -i "^Package:" "$(_THEOS_DEB_PACKAGE_CONTROL_PATH)" | cut -d' ' -f2-) 15 | THEOS_PACKAGE_ARCH := $(shell grep -i "^Architecture:" "$(_THEOS_DEB_PACKAGE_CONTROL_PATH)" | cut -d' ' -f2-) 16 | THEOS_PACKAGE_BASE_VERSION := $(shell grep -i "^Version:" "$(_THEOS_DEB_PACKAGE_CONTROL_PATH)" | cut -d' ' -f2-) 17 | 18 | $(_THEOS_ESCAPED_STAGING_DIR)/DEBIAN: 19 | $(ECHO_NOTHING)mkdir -p "$(THEOS_STAGING_DIR)/DEBIAN"$(ECHO_END) 20 | ifeq ($(_THEOS_HAS_STAGING_LAYOUT),1) # If we have a layout/ directory, copy layout/DEBIAN to the staging directory. 21 | $(ECHO_NOTHING)[ -d "$(THEOS_PROJECT_DIR)/layout/DEBIAN" ] && rsync -a "$(THEOS_PROJECT_DIR)/layout/DEBIAN/" "$(THEOS_STAGING_DIR)/DEBIAN" $(_THEOS_RSYNC_EXCLUDE_COMMANDLINE) || true$(ECHO_END) 22 | endif # _THEOS_HAS_STAGING_LAYOUT 23 | 24 | $(_THEOS_ESCAPED_STAGING_DIR)/DEBIAN/control: $(_THEOS_ESCAPED_STAGING_DIR)/DEBIAN 25 | $(ECHO_NOTHING)sed -e '/^[Vv]ersion:/d' "$(_THEOS_DEB_PACKAGE_CONTROL_PATH)" > "$@"$(ECHO_END) 26 | $(ECHO_NOTHING)echo "Version: $(_THEOS_INTERNAL_PACKAGE_VERSION)" >> "$@"$(ECHO_END) 27 | $(ECHO_NOTHING)echo "Installed-Size: $(shell du $(_THEOS_PLATFORM_DU_EXCLUDE) DEBIAN -ks "$(THEOS_STAGING_DIR)" | cut -f 1)" >> "$@"$(ECHO_END) 28 | 29 | before-package:: $(_THEOS_ESCAPED_STAGING_DIR)/DEBIAN/control 30 | 31 | _THEOS_DEB_PACKAGE_FILENAME = $(THEOS_PACKAGE_DIR)/$(THEOS_PACKAGE_NAME)_$(_THEOS_INTERNAL_PACKAGE_VERSION)_$(THEOS_PACKAGE_ARCH).deb 32 | internal-package:: 33 | $(ECHO_NOTHING)COPYFILE_DISABLE=1 $(FAKEROOT) -r dpkg-deb -b "$(THEOS_STAGING_DIR)" "$(_THEOS_DEB_PACKAGE_FILENAME)" $(STDERR_NULL_REDIRECT)$(ECHO_END) 34 | 35 | # This variable is used in package.mk 36 | after-package:: __THEOS_LAST_PACKAGE_FILENAME = $(_THEOS_DEB_PACKAGE_FILENAME) 37 | 38 | else # _THEOS_DEB_CAN_PACKAGE == 0 39 | internal-package:: 40 | @echo "$(MAKE) package requires you to have a layout/ directory in the project root, containing the basic package structure, or a control file in the project root describing the package."; exit 1 41 | 42 | endif # _THEOS_DEB_CAN_PACKAGE 43 | endif # _THEOS_PACKAGE_FORMAT_LOADED 44 | -------------------------------------------------------------------------------- /theos/makefiles/targets/Darwin/simulator.mk: -------------------------------------------------------------------------------- 1 | ifeq ($(_THEOS_TARGET_LOADED),) 2 | _THEOS_TARGET_LOADED := 1 3 | THEOS_TARGET_NAME := iphone_simulator 4 | 5 | ifeq ($(__THEOS_TARGET_ARG_1),clang) 6 | _THEOS_TARGET_CC := clang 7 | _THEOS_TARGET_CXX := clang++ 8 | _THEOS_TARGET_ARG_ORDER := 2 3 9 | else 10 | _THEOS_TARGET_CC := gcc 11 | _THEOS_TARGET_CXX := g++ 12 | _THEOS_TARGET_ARG_ORDER := 1 2 13 | endif 14 | 15 | # A version specified as a target argument overrides all previous definitions. 16 | _SDKVERSION := $(or $(__THEOS_TARGET_ARG_$(word 1,$(_THEOS_TARGET_ARG_ORDER))),$(SDKVERSION)) 17 | _THEOS_TARGET_IPHONEOS_DEPLOYMENT_VERSION := $(or $(__THEOS_TARGET_ARG_$(word 2,$(_THEOS_TARGET_ARG_ORDER))),$(TARGET_IPHONEOS_DEPLOYMENT_VERSION),$(_SDKVERSION),3.0) 18 | _THEOS_TARGET_SDK_VERSION := $(or $(_SDKVERSION),latest) 19 | 20 | _SDK_DIR := $(THEOS_PLATFORM_SDK_ROOT)/Platforms/iPhoneSimulator.platform/Developer/SDKs 21 | _IOS_SDKS := $(sort $(patsubst $(_SDK_DIR)/iPhoneSimulator%.sdk,%,$(wildcard $(_SDK_DIR)/iPhoneSimulator*.sdk))) 22 | _LATEST_SDK := $(word $(words $(_IOS_SDKS)),$(_IOS_SDKS)) 23 | 24 | ifeq ($(_THEOS_TARGET_SDK_VERSION),latest) 25 | override _THEOS_TARGET_SDK_VERSION := $(_LATEST_SDK) 26 | endif 27 | 28 | ifeq ($(_THEOS_TARGET_IPHONEOS_DEPLOYMENT_VERSION),latest) 29 | override _THEOS_TARGET_IPHONEOS_DEPLOYMENT_VERSION := $(_LATEST_SDK) 30 | endif 31 | 32 | SYSROOT ?= $(THEOS_PLATFORM_SDK_ROOT)/Platforms/iPhoneSimulator.platform/Developer/SDKs/iPhoneSimulator$(_THEOS_TARGET_SDK_VERSION).sdk 33 | 34 | TARGET_CC ?= xcrun -sdk iphonesimulator $(_THEOS_TARGET_CC) 35 | TARGET_CXX ?= xcrun -sdk iphonesimulator $(_THEOS_TARGET_CXX) 36 | TARGET_LD ?= xcrun -sdk iphonesimulator $(_THEOS_TARGET_CXX) 37 | TARGET_STRIP ?= xcrun -sdk iphonesimulator strip 38 | TARGET_STRIP_FLAGS ?= -x 39 | TARGET_CODESIGN_ALLOCATE ?= "$(shell xcrun -sdk iphonesimulator -find codesign_allocate)" 40 | TARGET_CODESIGN ?= 41 | TARGET_CODESIGN_FLAGS ?= 42 | 43 | TARGET_PRIVATE_FRAMEWORK_PATH = $(SYSROOT)/System/Library/PrivateFrameworks 44 | 45 | include $(THEOS_MAKE_PATH)/targets/_common/darwin.mk 46 | include $(THEOS_MAKE_PATH)/targets/_common/darwin_flat_bundle.mk 47 | 48 | ifeq ($(IPHONE_SIMULATOR_ROOT),) 49 | internal-install:: 50 | $(info $(MAKE) install for the simulator requires that you set IPHONE_SIMULATOR_ROOT to the root directory of the simulated OS.) 51 | @exit 1 52 | else 53 | internal-install:: stage 54 | install.mergeDir "$(THEOS_STAGING_DIR)" "$(IPHONE_SIMULATOR_ROOT)" 55 | endif 56 | 57 | ARCHS ?= i386 58 | 59 | _TARGET_VERSION_GE_3_2 = $(call __simplify,_TARGET_VERSION_GE_3_2,$(shell $(THEOS_BIN_PATH)/vercmp.pl $(_THEOS_TARGET_SDK_VERSION) ge 3.2)) 60 | _TARGET_VERSION_GE_4_0 = $(call __simplify,_TARGET_VERSION_GE_4_0,$(shell $(THEOS_BIN_PATH)/vercmp.pl $(_THEOS_TARGET_SDK_VERSION) ge 4.0)) 61 | _TARGET_OSX_VERSION_FLAG = -mmacosx-version-min=$(if $(_TARGET_VERSION_GE_4_0),10.6,10.5) 62 | _TARGET_OBJC_ABI_CFLAGS = $(if $(_TARGET_VERSION_GE_3_2),-fobjc-abi-version=2 -fobjc-legacy-dispatch) 63 | _TARGET_OBJC_ABI_LDFLAGS = $(if $(_TARGET_VERSION_GE_3_2),-Xlinker -objc_abi_version -Xlinker 2) 64 | 65 | SDKFLAGS := -isysroot $(SYSROOT) $(foreach ARCH,$(ARCHS),-arch $(ARCH)) -D__IPHONE_OS_VERSION_MIN_REQUIRED=__IPHONE_$(subst .,_,$(_THEOS_TARGET_IPHONEOS_DEPLOYMENT_VERSION)) $(_TARGET_OSX_VERSION_FLAG) 66 | 67 | _THEOS_TARGET_CFLAGS := $(SDKFLAGS) $(_TARGET_OBJC_ABI_CFLAGS) 68 | _THEOS_TARGET_LDFLAGS := $(SDKFLAGS) -multiply_defined suppress $(_TARGET_OBJC_ABI_LDFLAGS) 69 | endif 70 | -------------------------------------------------------------------------------- /theos/makefiles/targets/Darwin/iphone.mk: -------------------------------------------------------------------------------- 1 | ifeq ($(_THEOS_TARGET_LOADED),) 2 | _THEOS_TARGET_LOADED := 1 3 | THEOS_TARGET_NAME := iphone 4 | 5 | ifeq ($(__THEOS_TARGET_ARG_1),clang) 6 | _THEOS_TARGET_CC := clang 7 | _THEOS_TARGET_CXX := clang++ 8 | _THEOS_TARGET_ARG_ORDER := 2 3 9 | else 10 | _THEOS_TARGET_CC := gcc 11 | _THEOS_TARGET_CXX := g++ 12 | _THEOS_TARGET_ARG_ORDER := 1 2 13 | endif 14 | 15 | # A version specified as a target argument overrides all previous definitions. 16 | _SDKVERSION := $(or $(__THEOS_TARGET_ARG_$(word 1,$(_THEOS_TARGET_ARG_ORDER))),$(SDKVERSION)) 17 | _THEOS_TARGET_SDK_VERSION := $(or $(_SDKVERSION),latest) 18 | 19 | _SDK_DIR := $(THEOS_PLATFORM_SDK_ROOT)/Platforms/iPhoneOS.platform/Developer/SDKs 20 | _IOS_SDKS := $(sort $(patsubst $(_SDK_DIR)/iPhoneOS%.sdk,%,$(wildcard $(_SDK_DIR)/iPhoneOS*.sdk))) 21 | _LATEST_SDK := $(word $(words $(_IOS_SDKS)),$(_IOS_SDKS)) 22 | 23 | ifeq ($(_THEOS_TARGET_SDK_VERSION),latest) 24 | override _THEOS_TARGET_SDK_VERSION := $(_LATEST_SDK) 25 | endif 26 | 27 | # We have to figure out the target version here, as we need it in the calculation of the deployment version. 28 | _TARGET_VERSION_GE_6_0 = $(call __simplify,_TARGET_VERSION_GE_6_0,$(shell $(THEOS_BIN_PATH)/vercmp.pl $(_THEOS_TARGET_SDK_VERSION) ge 6.0)) 29 | _TARGET_VERSION_GE_3_0 = $(call __simplify,_TARGET_VERSION_GE_3_0,$(shell $(THEOS_BIN_PATH)/vercmp.pl $(_THEOS_TARGET_SDK_VERSION) ge 3.0)) 30 | _THEOS_TARGET_IPHONEOS_DEPLOYMENT_VERSION := $(or $(__THEOS_TARGET_ARG_$(word 2,$(_THEOS_TARGET_ARG_ORDER))),$(TARGET_IPHONEOS_DEPLOYMENT_VERSION),$(_SDKVERSION),3.0) 31 | 32 | ifeq ($(_THEOS_TARGET_IPHONEOS_DEPLOYMENT_VERSION),latest) 33 | override _THEOS_TARGET_IPHONEOS_DEPLOYMENT_VERSION := $(_LATEST_SDK) 34 | endif 35 | 36 | _DEPLOY_VERSION_GE_3_0 = $(call __simplify,_DEPLOY_VERSION_GE_3_0,$(shell $(THEOS_BIN_PATH)/vercmp.pl $(_THEOS_TARGET_IPHONEOS_DEPLOYMENT_VERSION) ge 3.0)) 37 | _DEPLOY_VERSION_LT_4_3 = $(call __simplify,_DEPLOY_VERSION_LT_4_3,$(shell $(THEOS_BIN_PATH)/vercmp.pl $(_THEOS_TARGET_IPHONEOS_DEPLOYMENT_VERSION) lt 4.3)) 38 | 39 | ifeq ($(_TARGET_VERSION_GE_6_0)$(_DEPLOY_VERSION_GE_3_0)$(_DEPLOY_VERSION_LT_4_3),111) 40 | ifeq ($(ARCHS)$(_THEOS_TARGET_WARNED_DEPLOY),) 41 | $(warning Deploying to iOS 3.0 while building for 6.0 will generate armv7-only binaries.) 42 | export _THEOS_TARGET_WARNED_DEPLOY := 1 43 | endif 44 | endif 45 | 46 | SYSROOT ?= $(THEOS_PLATFORM_SDK_ROOT)/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS$(_THEOS_TARGET_SDK_VERSION).sdk 47 | 48 | TARGET_CC ?= xcrun -sdk iphoneos $(_THEOS_TARGET_CC) 49 | TARGET_CXX ?= xcrun -sdk iphoneos $(_THEOS_TARGET_CXX) 50 | TARGET_LD ?= xcrun -sdk iphoneos $(_THEOS_TARGET_CXX) 51 | TARGET_STRIP ?= xcrun -sdk iphoneos strip 52 | TARGET_STRIP_FLAGS ?= -x 53 | TARGET_CODESIGN_ALLOCATE ?= "$(shell xcrun -sdk iphoneos -find codesign_allocate)" 54 | TARGET_CODESIGN ?= ldid 55 | TARGET_CODESIGN_FLAGS ?= -S 56 | 57 | TARGET_PRIVATE_FRAMEWORK_PATH = $(SYSROOT)/System/Library/PrivateFrameworks 58 | 59 | include $(THEOS_MAKE_PATH)/targets/_common/darwin.mk 60 | include $(THEOS_MAKE_PATH)/targets/_common/darwin_flat_bundle.mk 61 | 62 | ifeq ($(_TARGET_VERSION_GE_6_0),1) # >= 6.0 { 63 | ifeq ($(_DEPLOY_VERSION_GE_3_0)$(_DEPLOY_VERSION_LT_4_3),11) # 3.0 <= Deploy < 4.3 { 64 | ARCHS ?= armv7 65 | else # } else { 66 | ARCHS ?= armv7 armv7s 67 | endif # } 68 | else # } < 6.0 { 69 | ifeq ($(_TARGET_VERSION_GE_3_0),1) # >= 3.0 { 70 | ARCHS ?= armv6 armv7 71 | else # } < 3.0 { 72 | ARCHS ?= armv6 73 | endif # } 74 | endif # } 75 | 76 | SDKFLAGS := -isysroot "$(SYSROOT)" $(foreach ARCH,$(ARCHS),-arch $(ARCH)) -D__IPHONE_OS_VERSION_MIN_REQUIRED=__IPHONE_$(subst .,_,$(_THEOS_TARGET_IPHONEOS_DEPLOYMENT_VERSION)) -miphoneos-version-min=$(_THEOS_TARGET_IPHONEOS_DEPLOYMENT_VERSION) 77 | _THEOS_TARGET_CFLAGS := $(SDKFLAGS) 78 | _THEOS_TARGET_LDFLAGS := $(SDKFLAGS) -multiply_defined suppress 79 | 80 | TARGET_INSTALL_REMOTE := $(_THEOS_TRUE) 81 | _THEOS_TARGET_DEFAULT_PACKAGE_FORMAT := deb 82 | endif 83 | -------------------------------------------------------------------------------- /theos/makefiles/master/rules.mk: -------------------------------------------------------------------------------- 1 | __THEOS_RULES_MK_VERSION := 1 2 | ifneq ($(__THEOS_RULES_MK_VERSION),$(__THEOS_COMMON_MK_VERSION)) 3 | all:: 4 | @echo Theos version mismatch! common.mk [version $(or $(__THEOS_COMMON_MK_VERSION),0)] loaded in tandem with rules.mk [version $(or $(__THEOS_RULES_MK_VERSION),0)] Check that \$$\(THEOS\) is set properly! 5 | @exit 1 6 | endif 7 | 8 | .PHONY: all before-all internal-all after-all \ 9 | clean before-clean internal-clean after-clean 10 | ifeq ($(THEOS_BUILD_DIR),.) 11 | all:: before-all internal-all after-all 12 | else 13 | all:: $(THEOS_BUILD_DIR) before-all internal-all after-all 14 | endif 15 | 16 | clean:: before-clean internal-clean after-clean 17 | 18 | before-all:: 19 | ifneq ($(SYSROOT),) 20 | @[ -d "$(SYSROOT)" ] || { echo "Your current SYSROOT, \"$(SYSROOT)\", appears to be missing."; exit 1; } 21 | endif 22 | 23 | internal-all:: 24 | 25 | after-all:: 26 | 27 | before-clean:: 28 | 29 | internal-clean:: 30 | rm -rf $(THEOS_OBJ_DIR) 31 | ifeq ($(MAKELEVEL),0) 32 | rm -rf "$(THEOS_STAGING_DIR)" 33 | endif 34 | 35 | after-clean:: 36 | 37 | ifeq ($(MAKELEVEL),0) 38 | ifneq ($(THEOS_BUILD_DIR),.) 39 | _THEOS_ABSOLUTE_BUILD_DIR = $(call __clean_pwd,$(THEOS_BUILD_DIR)) 40 | else 41 | _THEOS_ABSOLUTE_BUILD_DIR = . 42 | endif 43 | else 44 | _THEOS_ABSOLUTE_BUILD_DIR = $(strip $(THEOS_BUILD_DIR)) 45 | endif 46 | 47 | .PRECIOUS: %.variables %.subprojects 48 | 49 | %.variables: _INSTANCE = $(basename $(basename $*)) 50 | %.variables: _OPERATION = $(subst .,,$(suffix $(basename $*))) 51 | %.variables: _TYPE = $(subst -,_,$(subst .,,$(suffix $*))) 52 | %.variables: __SUBPROJECTS = $(strip $(call __schema_var_all,$(_INSTANCE)_,SUBPROJECTS)) 53 | %.variables: 54 | @ \ 55 | abs_build_dir=$(_THEOS_ABSOLUTE_BUILD_DIR); \ 56 | if [ "$(__SUBPROJECTS)" != "" ]; then \ 57 | echo Making $(_OPERATION) in subprojects of $(_TYPE) $(_INSTANCE)...; \ 58 | for d in $(__SUBPROJECTS); do \ 59 | d="$${d%:*}"; \ 60 | if [ "$${abs_build_dir}" = "." ]; then \ 61 | lbuilddir="."; \ 62 | else \ 63 | lbuilddir="$${abs_build_dir}/$$d"; \ 64 | fi; \ 65 | if $(MAKE) -C $$d -f $(_THEOS_PROJECT_MAKEFILE_NAME) $(_THEOS_NO_PRINT_DIRECTORY_FLAG) --no-keep-going $(_OPERATION) \ 66 | THEOS_BUILD_DIR="$$lbuilddir" \ 67 | ; then\ 68 | :; \ 69 | else exit $$?; \ 70 | fi; \ 71 | done; \ 72 | fi; \ 73 | echo Making $(_OPERATION) for $(_TYPE) $(_INSTANCE)...; \ 74 | $(MAKE) -f $(_THEOS_PROJECT_MAKEFILE_NAME) --no-print-directory --no-keep-going \ 75 | internal-$(_TYPE)-$(_OPERATION) \ 76 | _THEOS_CURRENT_TYPE="$(_TYPE)" \ 77 | THEOS_CURRENT_INSTANCE="$(_INSTANCE)" \ 78 | _THEOS_CURRENT_OPERATION="$(_OPERATION)" \ 79 | THEOS_BUILD_DIR="$(_THEOS_ABSOLUTE_BUILD_DIR)" 80 | 81 | %.subprojects: _INSTANCE = $(basename $(basename $*)) 82 | %.subprojects: _OPERATION = $(subst .,,$(suffix $(basename $*))) 83 | %.subprojects: _TYPE = $(subst -,_,$(subst .,,$(suffix $*))) 84 | %.subprojects: __SUBPROJECTS = $(strip $(call __schema_var_all,$(_INSTANCE)_,SUBPROJECTS)) 85 | %.subprojects: 86 | @ \ 87 | abs_build_dir=$(_THEOS_ABSOLUTE_BUILD_DIR); \ 88 | if [ "$(__SUBPROJECTS)" != "" ]; then \ 89 | echo Making $(_OPERATION) in subprojects of $(_TYPE) $(_INSTANCE)...; \ 90 | for d in $(__SUBPROJECTS); do \ 91 | d="$${d%:*}"; \ 92 | if [ "$${abs_build_dir}" = "." ]; then \ 93 | lbuilddir="."; \ 94 | else \ 95 | lbuilddir="$${abs_build_dir}/$$d"; \ 96 | fi; \ 97 | if $(MAKE) -C $$d -f $(_THEOS_PROJECT_MAKEFILE_NAME) $(_THEOS_NO_PRINT_DIRECTORY_FLAG) --no-keep-going $(_OPERATION) \ 98 | THEOS_BUILD_DIR="$$lbuilddir" \ 99 | ; then\ 100 | :; \ 101 | else exit $$?; \ 102 | fi; \ 103 | done; \ 104 | fi 105 | 106 | $(eval $(call __mod,master/rules.mk)) 107 | 108 | ifeq ($(_THEOS_TOP_INVOCATION_DONE),) 109 | export _THEOS_TOP_INVOCATION_DONE = 1 110 | endif 111 | -------------------------------------------------------------------------------- /theos/makefiles/targets/Darwin-arm/iphone.mk: -------------------------------------------------------------------------------- 1 | ifeq ($(_THEOS_TARGET_LOADED),) 2 | _THEOS_TARGET_LOADED := 1 3 | THEOS_TARGET_NAME := iphone 4 | 5 | _THEOS_TARGET_CC := arm-apple-darwin9-gcc 6 | _THEOS_TARGET_CXX := arm-apple-darwin9-g++ 7 | _THEOS_TARGET_ARG_ORDER := 1 2 8 | ifeq ($(__THEOS_TARGET_ARG_1),clang) 9 | _THEOS_TARGET_CC := clang 10 | _THEOS_TARGET_CXX := clang++ 11 | _THEOS_TARGET_ARG_ORDER := 2 3 12 | else ifeq ($(__THEOS_TARGET_ARG_1),gcc) 13 | _THEOS_TARGET_ARG_ORDER := 2 3 14 | endif 15 | 16 | _SDKVERSION := $(or $(__THEOS_TARGET_ARG_$(word 1,$(_THEOS_TARGET_ARG_ORDER))),$(SDKVERSION)) 17 | _THEOS_TARGET_SDK_VERSION := $(or $(_SDKVERSION),latest) 18 | 19 | _SDK_DIR := $(THEOS)/sdks 20 | _IOS_SDKS := $(sort $(patsubst $(_SDK_DIR)/iPhoneOS%.sdk,%,$(wildcard $(_SDK_DIR)/iPhoneOS*.sdk))) 21 | _LATEST_SDK := $(word $(words $(_IOS_SDKS)),$(_IOS_SDKS)) 22 | 23 | ifeq ($(_THEOS_TARGET_SDK_VERSION),latest) 24 | override _THEOS_TARGET_SDK_VERSION := $(_LATEST_SDK) 25 | endif 26 | 27 | # We have to figure out the target version here, as we need it in the calculation of the deployment version. 28 | _TARGET_VERSION_GE_6_0 = $(call __simplify,_TARGET_VERSION_GE_6_0,$(shell $(THEOS_BIN_PATH)/vercmp.pl $(_THEOS_TARGET_SDK_VERSION) ge 6.0)) 29 | _TARGET_VERSION_GE_3_0 = $(call __simplify,_TARGET_VERSION_GE_3_0,$(shell $(THEOS_BIN_PATH)/vercmp.pl $(_THEOS_TARGET_SDK_VERSION) ge 3.0)) 30 | _TARGET_VERSION_GE_4_0 = $(call __simplify,_TARGET_VERSION_GE_4_0,$(shell $(THEOS_BIN_PATH)/vercmp.pl $(_THEOS_TARGET_SDK_VERSION) ge 4.0)) 31 | _THEOS_TARGET_IPHONEOS_DEPLOYMENT_VERSION := $(or $(__THEOS_TARGET_ARG_$(word 2,$(_THEOS_TARGET_ARG_ORDER))),$(TARGET_IPHONEOS_DEPLOYMENT_VERSION),$(_SDKVERSION),3.0) 32 | 33 | ifeq ($(_THEOS_TARGET_IPHONEOS_DEPLOYMENT_VERSION),latest) 34 | override _THEOS_TARGET_IPHONEOS_DEPLOYMENT_VERSION := $(_LATEST_SDK) 35 | endif 36 | 37 | _DEPLOY_VERSION_GE_3_0 = $(call __simplify,_DEPLOY_VERSION_GE_3_0,$(shell $(THEOS_BIN_PATH)/vercmp.pl $(_THEOS_TARGET_IPHONEOS_DEPLOYMENT_VERSION) ge 3.0)) 38 | _DEPLOY_VERSION_LT_4_3 = $(call __simplify,_DEPLOY_VERSION_LT_4_3,$(shell $(THEOS_BIN_PATH)/vercmp.pl $(_THEOS_TARGET_IPHONEOS_DEPLOYMENT_VERSION) lt 4.3)) 39 | 40 | ifeq ($(_TARGET_VERSION_GE_4_0),1) 41 | ifeq ($(_THEOS_TARGET_CC),arm-apple-darwin9-gcc) 42 | ifeq ($(_THEOS_TARGET_WARNED_TARGETGCC),) 43 | $(warning Targeting iOS 4.0 and higher is not supported with iphone-gcc. Forcing clang.) 44 | export _THEOS_TARGET_WARNED_TARGETGCC := 1 45 | endif 46 | override _THEOS_TARGET_CC := clang 47 | override _THEOS_TARGET_CXX := clang++ 48 | endif 49 | endif 50 | 51 | ifeq ($(_TARGET_VERSION_GE_6_0)$(_DEPLOY_VERSION_GE_3_0)$(_DEPLOY_VERSION_LT_4_3),111) 52 | ifeq ($(_THEOS_TARGET_WARNED_DEPLOY),) 53 | $(warning Deploying to iOS 3.0 while building for 6.0 will generate armv7-only binaries.) 54 | export _THEOS_TARGET_WARNED_DEPLOY := 1 55 | endif 56 | endif 57 | 58 | SYSROOT ?= $(_SDK_DIR)/iPhoneOS$(_THEOS_TARGET_SDK_VERSION).sdk 59 | 60 | TARGET_CC ?= $(_THEOS_TARGET_CC) 61 | TARGET_CXX ?= $(_THEOS_TARGET_CXX) 62 | TARGET_LD ?= $(_THEOS_TARGET_CXX) 63 | TARGET_STRIP ?= strip 64 | TARGET_STRIP_FLAGS ?= -x 65 | TARGET_CODESIGN_ALLOCATE ?= codesign_allocate 66 | TARGET_CODESIGN ?= ldid 67 | TARGET_CODESIGN_FLAGS ?= -S 68 | 69 | TARGET_PRIVATE_FRAMEWORK_PATH = $(SYSROOT)/System/Library/PrivateFrameworks 70 | 71 | include $(THEOS_MAKE_PATH)/targets/_common/darwin.mk 72 | include $(THEOS_MAKE_PATH)/targets/_common/darwin_flat_bundle.mk 73 | 74 | ifeq ($(_TARGET_VERSION_GE_6_0),1) # >= 6.0 { 75 | ARCHS ?= armv7 76 | else # } < 6.0 { 77 | ifeq ($(_TARGET_VERSION_GE_3_0,1) # >= 3.0 { 78 | ifeq ($(_THEOS_TARGET_CC),arm-apple-darwin9-gcc) # iphone-gcc doesn't support armv7 79 | ARCHS ?= armv6 80 | else 81 | ARCHS ?= armv6 armv7 82 | endif 83 | else # } < 3.0 { 84 | ARCHS ?= armv6 85 | endif # } 86 | endif # } 87 | 88 | SDKFLAGS := -isysroot "$(SYSROOT)" $(foreach ARCH,$(ARCHS),-arch $(ARCH)) -D__IPHONE_OS_VERSION_MIN_REQUIRED=__IPHONE_$(subst .,_,$(_THEOS_TARGET_IPHONEOS_DEPLOYMENT_VERSION)) -miphoneos-version-min=$(_THEOS_TARGET_IPHONEOS_DEPLOYMENT_VERSION) 89 | _THEOS_TARGET_CFLAGS := $(SDKFLAGS) 90 | _THEOS_TARGET_LDFLAGS := $(SDKFLAGS) -multiply_defined suppress 91 | 92 | TARGET_INSTALL_REMOTE := $(_THEOS_FALSE) 93 | _THEOS_TARGET_DEFAULT_PACKAGE_FORMAT := deb 94 | endif 95 | -------------------------------------------------------------------------------- /theos/makefiles/package.mk: -------------------------------------------------------------------------------- 1 | ifeq ($(_THEOS_PACKAGE_RULES_LOADED),) 2 | _THEOS_PACKAGE_RULES_LOADED := 1 3 | 4 | ## Packaging Core Rules 5 | .PHONY: package internal-package-check before-package internal-package after-package 6 | 7 | package:: internal-package-check stage before-package internal-package after-package 8 | before-package:: $(THEOS_PACKAGE_DIR) 9 | internal-package internal-package-check:: 10 | @: 11 | 12 | # __THEOS_LAST_PACKAGE_FILENAME is to be set by a rule variable in the package format makefile. 13 | after-package:: 14 | @echo "$(__THEOS_LAST_PACKAGE_FILENAME)" > "$(_THEOS_LOCAL_DATA_DIR)/last_package" 15 | 16 | THEOS_PACKAGE_NAME := 17 | THEOS_PACKAGE_ARCH := 18 | THEOS_PACKAGE_BASE_VERSION := 19 | # THEOS_PACKAGE_VERSION is set in common.mk (to give its warning.) 20 | 21 | -include $(THEOS_MAKE_PATH)/package/$(_THEOS_PACKAGE_FORMAT).mk 22 | $(eval $(call __mod,package/$(_THEOS_PACKAGE_FORMAT).mk)) 23 | 24 | ifeq ($(_THEOS_PACKAGE_FORMAT_LOADED),) 25 | $(error I simply cannot figure out how to create $(_THEOS_PACKAGE_FORMAT)-format packages.) 26 | endif 27 | 28 | export THEOS_PACKAGE_NAME THEOS_PACKAGE_ARCH THEOS_PACKAGE_BASE_VERSION 29 | 30 | # These are here to be used by the package makefile included above. 31 | # We want them after the package makefile so that we can use variables set within it. 32 | 33 | # eval PACKAGE_VERSION *now* (to clear out references to VERSION.*: they have no bearing on 34 | # the 'base' version we calculate.) 35 | VERSION.INC_BUILD_NUMBER := X 36 | VERSION.EXTRAVERSION := X 37 | __USERVER_FOR_BUILDNUM := $(PACKAGE_VERSION) 38 | __BASEVER_FOR_BUILDNUM = $(or $(__USERVER_FOR_BUILDNUM),$(THEOS_PACKAGE_BASE_VERSION)) 39 | 40 | 41 | # We simplify the version vars so that they are evaluated only when completely necessary. 42 | # This is because they can include things like incrementing build numbers. 43 | 44 | # I am committing a willful departure from the THEOS_ naming convention, because I believe 45 | # that offering these via an easy-to-use interface makes more sense than hiding them behind 46 | # a really stupidly long name. 47 | # VERSION.* are meant to be used in user PACKAGE_VERSIONs. 48 | VERSION.INC_BUILD_NUMBER = $(shell THEOS_PROJECT_DIR="$(THEOS_PROJECT_DIR)" "$(THEOS_BIN_PATH)/package_version.sh" -N "$(THEOS_PACKAGE_NAME)" -V "$(__BASEVER_FOR_BUILDNUM)") 49 | VERSION.EXTRAVERSION = $(if $(PACKAGE_BUILDNAME),+$(PACKAGE_BUILDNAME)) 50 | _THEOS_PACKAGE_DEFAULT_VERSION_FORMAT = $(THEOS_PACKAGE_BASE_VERSION)-$(VERSION.INC_BUILD_NUMBER)$(VERSION.EXTRAVERSION) 51 | 52 | # Copy the actual value of PACKAGE_VERSION to __PACKAGE_VERSION and replace PACKAGE_VERSION with 53 | # a mere reference (to a simplified copy.) 54 | # We're doing this to clean up the user's PACKAGE_VERSION and make it safe for reuse. 55 | # (otherwise, they might trigger build number increases without meaning to.) 56 | # Defer the simplification until __PACKAGE_VERSION is used - do not do it before the eval 57 | # However, we want to do the schema calculation and value stuff before the eval, so that 58 | # __PACKAGE_VERSION becomes an exact copy of the PACKAGE_VERSION variable we chose. 59 | $(eval __PACKAGE_VERSION = $$(call __simplify,__PACKAGE_VERSION,$(value $(call __schema_var_name_last,,PACKAGE_VERSION)))) 60 | override PACKAGE_VERSION = $(__PACKAGE_VERSION) 61 | 62 | _THEOS_INTERNAL_PACKAGE_VERSION = $(call __simplify,_THEOS_INTERNAL_PACKAGE_VERSION,$(or $(__PACKAGE_VERSION),$(_THEOS_PACKAGE_DEFAULT_VERSION_FORMAT),1)) 63 | 64 | ## Installation Core Rules 65 | install:: before-install internal-install after-install 66 | 67 | export TARGET_INSTALL_REMOTE 68 | _THEOS_INSTALL_TYPE := local 69 | ifeq ($(TARGET_INSTALL_REMOTE),$(_THEOS_TRUE)) 70 | _THEOS_INSTALL_TYPE := remote 71 | ifeq ($(THEOS_DEVICE_IP),) 72 | internal-install:: 73 | $(info $(MAKE) install requires that you set THEOS_DEVICE_IP in your environment. It is also recommended that you have public-key authentication set up for root over SSH, or you will be entering your password a lot.) 74 | @exit 1 75 | endif # THEOS_DEVICE_IP == "" 76 | THEOS_DEVICE_PORT ?= 22 77 | export THEOS_DEVICE_IP THEOS_DEVICE_PORT 78 | endif # TARGET_INSTALL_REMOTE == true 79 | 80 | after-install:: internal-after-install 81 | before-install internal-install internal-after-install:: 82 | @: 83 | 84 | -include $(THEOS_MAKE_PATH)/install/$(_THEOS_PACKAGE_FORMAT)_$(_THEOS_INSTALL_TYPE).mk 85 | $(eval $(call __mod,install/$(_THEOS_PACKAGE_FORMAT)_$(_THEOS_INSTALL_TYPE).mk)) 86 | 87 | endif # _THEOS_PACKAGE_RULES_LOADED 88 | -------------------------------------------------------------------------------- /fauxsu.cc: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | 10 | #include 11 | using namespace std; 12 | 13 | // {,l,f}stat, access, chmod, fchmod, chown, fchown 14 | 15 | #ifdef DEBUG 16 | #define dlog(args...) fprintf(stderr, args); 17 | #else 18 | #define dlog(args...) 19 | #endif 20 | 21 | struct ownership_entry { 22 | uid_t owner; 23 | gid_t group; 24 | }; 25 | 26 | struct mode_entry { 27 | mode_t mode; 28 | }; 29 | 30 | typedef map ownmap; 31 | typedef map modemap; 32 | 33 | ownmap &olist() { 34 | static ownmap olist_; 35 | return olist_; 36 | } 37 | 38 | modemap &mlist() { 39 | static modemap mlist_; 40 | return mlist_; 41 | } 42 | 43 | static __attribute((unused)) void hexdump(void *mem, unsigned int c) { 44 | unsigned int num; 45 | for(num = 0; num < c; ++num) { 46 | //if(num % 16 == 0) dlog("LIB %p: ", (unsigned char *)mem + num); 47 | dlog("%02x ", *(((unsigned char *)mem) + num)); 48 | if(num % 16 == 15) dlog("\n"); 49 | } 50 | if(num % 16 != 0) dlog("\n"); 51 | } 52 | 53 | static void ifakemode(dev_t dev, ino_t ino, mode_t mode) { 54 | dlog("Setting faking mode to %o for %d.\n", mode, ino); 55 | mlist()[ino] = mode; 56 | } 57 | 58 | static void ifakeown(dev_t dev, ino_t ino, uid_t owner, gid_t group) { 59 | dlog("Setting fake ownership to %d:%d for %d.\n", owner, group, ino); 60 | struct ownership_entry *x = new ownership_entry(); 61 | x->owner = owner; 62 | x->group = group; 63 | olist()[ino] = x; 64 | } 65 | 66 | static void fakemode(const char *path, mode_t mode) { 67 | struct stat buf; 68 | stat(path, &buf); 69 | ifakemode(buf.st_dev, buf.st_ino, mode); 70 | } 71 | 72 | static void ffakemode(int fildes, mode_t mode) { 73 | struct stat buf; 74 | fstat(fildes, &buf); 75 | ifakemode(buf.st_dev, buf.st_ino, mode); 76 | } 77 | 78 | static void fakeown(const char *path, uid_t owner, gid_t group) { 79 | struct stat buf; 80 | stat(path, &buf); 81 | owner = (owner == -1 ? buf.st_uid : owner); group = (group == -1 ? buf.st_gid : group); 82 | ifakeown(buf.st_dev, buf.st_ino, owner, group); 83 | } 84 | 85 | static void ffakeown(int fildes, uid_t owner, gid_t group) { 86 | struct stat buf; 87 | fstat(fildes, &buf); 88 | owner = (owner == -1 ? buf.st_uid : owner); group = (group == -1 ? buf.st_gid : group); 89 | ifakeown(buf.st_dev, buf.st_ino, owner, group); 90 | } 91 | 92 | static void lfakeown(const char *path, uid_t owner, gid_t group) { 93 | struct stat buf; 94 | lstat(path, &buf); 95 | owner = (owner == -1 ? buf.st_uid : owner); group = (group == -1 ? buf.st_gid : group); 96 | ifakeown(buf.st_dev, buf.st_ino, owner, group); 97 | } 98 | 99 | static void dofake(struct stat *buf) { 100 | buf->st_uid = 0; 101 | buf->st_gid = 0; 102 | 103 | if(olist().find(buf->st_ino) != olist().end()) { 104 | struct ownership_entry *x = olist()[buf->st_ino]; 105 | buf->st_uid = x->owner; 106 | buf->st_gid = x->group; 107 | dlog("Returning fake ownership %d:%d for %d.\n", buf->st_uid, buf->st_gid, buf->st_ino); 108 | } 109 | 110 | if(mlist().find(buf->st_ino) != mlist().end()) { 111 | buf->st_mode = mlist()[buf->st_ino]; 112 | dlog("Returning fake mode %d for %d.\n", buf->st_mode, buf->st_ino); 113 | } 114 | 115 | return; 116 | } 117 | 118 | extern "C" int my_chmod(const char *path, mode_t mode) { 119 | int ret = chmod(path, mode); 120 | if(ret != 0 && errno == EPERM) { 121 | fakemode(path, mode); 122 | ret = 0; errno = 0; 123 | } 124 | return ret; 125 | } 126 | 127 | extern "C" int my_fchmod(int fildes, mode_t mode) { 128 | int ret = fchmod(fildes, mode); 129 | if(ret != 0 && errno == EPERM) { 130 | ffakemode(fildes, mode); 131 | ret = 0; errno = 0; 132 | } 133 | return ret; 134 | } 135 | 136 | extern "C" int my_chown(const char *path, uid_t owner, gid_t group) { 137 | int ret = chown(path, owner, group); 138 | if(ret != 0 && errno == EPERM) { 139 | fakeown(path, owner, group); 140 | ret = 0; errno = 0; 141 | } 142 | return ret; 143 | } 144 | 145 | extern "C" int my_fchown(int fildes, uid_t owner, gid_t group) { 146 | int ret = fchown(fildes, owner, group); 147 | if(ret != 0 && errno == EPERM) { 148 | ffakeown(fildes, owner, group); 149 | ret = 0; errno = 0; 150 | } 151 | return ret; 152 | } 153 | 154 | extern "C" int my_lchown(const char *path, uid_t owner, gid_t group) { 155 | int ret = lchown(path, owner, group); 156 | if(ret != 0 && errno == EPERM) { 157 | lfakeown(path, owner, group); 158 | ret = 0; errno = 0; 159 | } 160 | return ret; 161 | } 162 | 163 | extern "C" int my_stat(const char *path, struct stat *buf) { 164 | int ret = stat(path, buf); 165 | dofake(buf); 166 | return ret; 167 | } 168 | 169 | extern "C" int my_lstat(const char *path, struct stat *buf) { 170 | int ret = lstat(path, buf); 171 | dofake(buf); 172 | return ret; 173 | } 174 | 175 | extern "C" int my_fstat(int fildes, struct stat *buf) { 176 | int ret = fstat(fildes, buf); 177 | dofake(buf); 178 | return ret; 179 | } 180 | 181 | extern "C" uid_t my_getuid() { return 0; } 182 | extern "C" uid_t my_geteuid() { return 0; } 183 | extern "C" gid_t my_getgid() { return 0; } 184 | extern "C" gid_t my_getegid() { return 0; } 185 | 186 | #define DEFAULT_PERSIST_FILENAME ".fauxsu" 187 | static char _persist_filename[PATH_MAX] = ""; 188 | 189 | char *persist_file_name() { 190 | if(_persist_filename[0] == '\0') { 191 | char *env = getenv("_FAUXSU_PERSIST_FILENAME"); 192 | if(env && strlen(env) > 0) { 193 | strncpy(_persist_filename, env, PATH_MAX); 194 | } else { 195 | snprintf(_persist_filename, PATH_MAX, DEFAULT_PERSIST_FILENAME); 196 | } 197 | dlog("persist filename is %s\n", _persist_filename); 198 | } 199 | return _persist_filename; 200 | } 201 | 202 | static __attribute__((destructor)) void fini() { 203 | int nmodes = mlist().size(); 204 | int nowns = olist().size(); 205 | if(nmodes == 0 && nowns == 0) return; 206 | FILE *o = fopen(persist_file_name(), "wb+"); 207 | fwrite(&nmodes, 1, sizeof(int), o); 208 | fwrite(&nowns, 1, sizeof(int), o); 209 | for(modemap::const_iterator it = mlist().begin(); it != mlist().end(); ++it) { 210 | ino_t ino = it->first; 211 | mode_t mode = it->second; 212 | fwrite(&ino, 1, sizeof(ino_t), o); 213 | fwrite(&mode, 1, sizeof(mode_t), o); 214 | } 215 | for(ownmap::const_iterator it = olist().begin(); it != olist().end(); ++it) { 216 | ino_t ino = it->first; 217 | struct ownership_entry *x = it->second; 218 | fwrite(&ino, 1, sizeof(ino_t), o); 219 | fwrite(&x->owner, 1, sizeof(uid_t), o); 220 | fwrite(&x->group, 1, sizeof(gid_t), o); 221 | } 222 | fclose(o); 223 | } 224 | 225 | static __attribute__((constructor)) void init() { 226 | int nmodes, nowns; 227 | FILE *o = fopen(persist_file_name(), "rb+"); 228 | if(!o) return; 229 | fread(&nmodes, 1, sizeof(int), o); 230 | fread(&nowns, 1, sizeof(int), o); 231 | for(int i = 0; i < nmodes; ++i) { 232 | ino_t ino; 233 | mode_t mode; 234 | fread(&ino, 1, sizeof(ino_t), o); 235 | fread(&mode, 1, sizeof(mode_t), o); 236 | mlist()[ino] = mode; 237 | } 238 | for(int i = 0; i < nowns; ++i) { 239 | ino_t ino; 240 | uid_t owner; 241 | gid_t group; 242 | fread(&ino, 1, sizeof(ino_t), o); 243 | fread(&owner, 1, sizeof(uid_t), o); 244 | fread(&group, 1, sizeof(gid_t), o); 245 | struct ownership_entry *x = new ownership_entry(); 246 | x->owner = owner; 247 | x->group = group; 248 | olist()[ino] = x; 249 | } 250 | } 251 | 252 | extern "C" const struct {void *n; void *o;} interposers[] __attribute((section("__DATA, __interpose"))) = { 253 | { (void *)my_chmod, (void *)chmod }, 254 | { (void *)my_fchmod, (void *)fchmod }, 255 | { (void *)my_chown, (void *)chown }, 256 | { (void *)my_fchown, (void *)fchown }, 257 | { (void *)my_lchown, (void *)lchown }, 258 | { (void *)my_stat, (void *)stat }, 259 | { (void *)my_lstat, (void *)lstat }, 260 | { (void *)my_fstat, (void *)fstat }, 261 | { (void*)my_getuid, (void *)getuid }, 262 | { (void*)my_geteuid, (void *)geteuid }, 263 | { (void*)my_getgid, (void *)getgid }, 264 | { (void*)my_getegid, (void *)getegid }, 265 | }; 266 | -------------------------------------------------------------------------------- /theos/makefiles/common.mk: -------------------------------------------------------------------------------- 1 | all:: 2 | 3 | ifeq ($(notdir $(firstword $(SUDO_COMMAND))),make) 4 | $(error Do not use 'sudo make') 5 | endif 6 | 7 | THEOS_PROJECT_DIR ?= $(shell pwd) 8 | _THEOS_LOCAL_DATA_DIR := $(THEOS_PROJECT_DIR)/.theos 9 | 10 | ### Functions 11 | # Function for getting a clean absolute path from cd. 12 | __clean_pwd = $(shell (unset CDPATH; cd "$(1)"; pwd)) 13 | # Truthiness 14 | _THEOS_TRUE := 1 15 | _THEOS_FALSE := 16 | __theos_bool = $(if $(filter Y y YES yes 1,$(1)),$(_THEOS_TRUE),$(_THEOS_FALSE)) 17 | # Existence 18 | __exists = $(if $(wildcard $(1)),$(_THEOS_TRUE),$(_THEOS_FALSE)) 19 | __executable = $(if $(shell PATH="$(THEOS_BIN_PATH):$$PATH" type "$(1)" > /dev/null 2>&1 && echo 1),$(_THEOS_TRUE),$(_THEOS_FALSE)) 20 | # Static redefinition 21 | __simplify = $(2)$(eval $(1):=$(2)) 22 | ### 23 | 24 | __THEOS_COMMON_MK_VERSION := 1 25 | 26 | ifeq ($(_THEOS_PROJECT_MAKEFILE_NAME),) 27 | _THEOS_STATIC_MAKEFILE_LIST := $(filter-out $(lastword $(MAKEFILE_LIST)),$(MAKEFILE_LIST)) 28 | export _THEOS_PROJECT_MAKEFILE_NAME := $(notdir $(lastword $(_THEOS_STATIC_MAKEFILE_LIST))) 29 | endif 30 | 31 | ifeq ($(_THEOS_INTERNAL_TRUE_PATH),) 32 | _THEOS_RELATIVE_MAKE_PATH := $(dir $(lastword $(MAKEFILE_LIST))) 33 | _THEOS_INTERNAL_TRUE_PATH := $(call __clean_pwd,$(_THEOS_RELATIVE_MAKE_PATH)/..) 34 | ifneq ($(words $(_THEOS_INTERNAL_TRUE_PATH)),1) # It's a hack, but it works. 35 | $(shell unlink /tmp/theos &> /dev/null; ln -Ffs "$(_THEOS_INTERNAL_TRUE_PATH)" /tmp/theos) 36 | _THEOS_INTERNAL_TRUE_PATH := /tmp/theos 37 | endif 38 | override THEOS := $(_THEOS_INTERNAL_TRUE_PATH) 39 | export _THEOS_INTERNAL_TRUE_PATH 40 | endif 41 | THEOS_MAKE_PATH := $(THEOS)/makefiles 42 | THEOS_BIN_PATH := $(THEOS)/bin 43 | THEOS_LIBRARY_PATH := $(THEOS)/lib 44 | THEOS_INCLUDE_PATH := $(THEOS)/include 45 | THEOS_MODULE_PATH := $(THEOS)/mod 46 | export THEOS THEOS_BIN_PATH THEOS_MAKE_PATH THEOS_LIBRARY_PATH THEOS_INCLUDE_PATH 47 | export THEOS_PROJECT_DIR 48 | 49 | export PATH := $(THEOS_BIN_PATH):$(PATH) 50 | 51 | ifeq ($(THEOS_SCHEMA),) 52 | _THEOS_SCHEMA := $(shell echo "$(strip $(schema) $(SCHEMA))" | tr 'a-z' 'A-Z') 53 | _THEOS_ON_SCHEMA := DEFAULT $(filter-out -%,$(_THEOS_SCHEMA)) 54 | ifeq ($(call __theos_bool,$(or $(debug),$(DEBUG))),$(_THEOS_TRUE)) 55 | _THEOS_ON_SCHEMA += DEBUG 56 | endif 57 | _THEOS_OFF_SCHEMA := $(patsubst -%,%,$(filter -%,$(_THEOS_SCHEMA))) 58 | override THEOS_SCHEMA := $(strip $(filter-out $(_THEOS_OFF_SCHEMA),$(_THEOS_ON_SCHEMA))) 59 | override _THEOS_CLEANED_SCHEMA_SET := $(shell echo "$(filter-out DEFAULT,$(THEOS_SCHEMA))" | tr -Cd ' A-Z' | tr ' A-Z' '_a-z') 60 | export THEOS_SCHEMA _THEOS_CLEANED_SCHEMA_SET 61 | endif 62 | 63 | ### 64 | # __schema_defined_var_names bears explanation: 65 | # For each schema'd variable gathered from __schema_all_var_names, we generate a list of 66 | # "origin:name" pairs, and then filter out all pairs where the origin is "undefined". 67 | # We then substitute " " for ":" and take the last word, so we end up with only the entries from 68 | # __schema_all_var_names that are defined. 69 | __schema_all_var_names = $(foreach sch,$(THEOS_SCHEMA),$(subst DEFAULT.,,$(sch).)$(1)$(2)) 70 | __schema_defined_var_names = $(foreach tuple,$(filter-out undefined:%,$(foreach schvar,$(call __schema_all_var_names,$(1),$(2)),$(origin $(schvar)):$(schvar))),$(lastword $(subst :, ,$(tuple)))) 71 | __schema_var_all = $(strip $(foreach sch,$(call __schema_all_var_names,$(1),$(2)),$($(sch)))) 72 | __schema_var_name_last = $(strip $(lastword $(call __schema_defined_var_names,$(1),$(2)))) 73 | __schema_var_last = $(strip $($(lastword $(call __schema_defined_var_names,$(1),$(2))))) 74 | 75 | ifeq ($(_THEOS_HAS_STAGING_LAYOUT),) 76 | _THEOS_HAS_STAGING_LAYOUT := $(call __exists,$(THEOS_PROJECT_DIR)/layout) 77 | endif 78 | 79 | _THEOS_LOAD_MODULES := $(sort $(call __schema_var_all,,MODULES) $(THEOS_AUTOLOAD_MODULES)) 80 | __mod = -include $$(foreach mod,$$(_THEOS_LOAD_MODULES),$$(THEOS_MODULE_PATH)/$$(mod)/$(1)) 81 | 82 | include $(THEOS_MAKE_PATH)/legacy.mk 83 | 84 | ifneq ($(_THEOS_PLATFORM_CALCULATED),1) 85 | uname_s := $(shell uname -s) 86 | uname_p := $(shell uname -p) 87 | export _THEOS_PLATFORM_ARCH = $(uname_s)-$(uname_p) 88 | export _THEOS_PLATFORM = $(uname_s) 89 | export _THEOS_PLATFORM_CALCULATED := 1 90 | endif 91 | 92 | -include $(THEOS_MAKE_PATH)/platform/$(_THEOS_PLATFORM_ARCH).mk 93 | -include $(THEOS_MAKE_PATH)/platform/$(_THEOS_PLATFORM).mk 94 | $(eval $(call __mod,platform/$(_THEOS_PLATFORM_ARCH).mk)) 95 | $(eval $(call __mod,platform/$(_THEOS_PLATFORM).mk)) 96 | 97 | ifneq ($(_THEOS_TARGET_CALCULATED),1) 98 | __TARGET_MAKEFILE := $(shell $(THEOS_BIN_PATH)/target.pl "$(target)" "$(call __schema_var_last,,TARGET)" "$(_THEOS_PLATFORM_DEFAULT_TARGET)") 99 | -include $(__TARGET_MAKEFILE) 100 | $(shell rm -f $(__TARGET_MAKEFILE) > /dev/null 2>&1) 101 | export _THEOS_TARGET := $(__THEOS_TARGET_ARG_0) 102 | ifeq ($(_THEOS_TARGET),) 103 | $(error You did not specify a target, and the "$(THEOS_PLATFORM_NAME)" platform does not define a default target) 104 | endif 105 | export _THEOS_TARGET_CALCULATED := 1 106 | endif 107 | 108 | -include $(THEOS_MAKE_PATH)/targets/$(_THEOS_PLATFORM_ARCH)/$(_THEOS_TARGET).mk 109 | -include $(THEOS_MAKE_PATH)/targets/$(_THEOS_PLATFORM)/$(_THEOS_TARGET).mk 110 | -include $(THEOS_MAKE_PATH)/targets/$(_THEOS_TARGET).mk 111 | $(eval $(call __mod,targets/$(_THEOS_PLATFORM_ARCH)/$(_THEOS_TARGET).mk)) 112 | $(eval $(call __mod,targets/$(_THEOS_PLATFORM)/$(_THEOS_TARGET).mk)) 113 | $(eval $(call __mod,targets/$(_THEOS_TARGET).mk)) 114 | 115 | ifneq ($(_THEOS_TARGET_LOADED),1) 116 | $(error The "$(_THEOS_TARGET)" target is not supported on the "$(THEOS_PLATFORM_NAME)" platform) 117 | endif 118 | 119 | _THEOS_TARGET_NAME_DEFINE := $(shell echo "$(THEOS_TARGET_NAME)" | tr 'a-z' 'A-Z') 120 | 121 | export TARGET_CC TARGET_CXX TARGET_LD TARGET_STRIP TARGET_CODESIGN_ALLOCATE TARGET_CODESIGN TARGET_CODESIGN_FLAGS 122 | 123 | THEOS_TARGET_INCLUDE_PATH := $(THEOS_INCLUDE_PATH)/$(THEOS_TARGET_NAME) 124 | THEOS_TARGET_LIBRARY_PATH := $(THEOS_LIBRARY_PATH)/$(THEOS_TARGET_NAME) 125 | _THEOS_TARGET_HAS_INCLUDE_PATH := $(call __exists,$(THEOS_TARGET_INCLUDE_PATH)) 126 | _THEOS_TARGET_HAS_LIBRARY_PATH := $(call __exists,$(THEOS_TARGET_LIBRARY_PATH)) 127 | 128 | # Package Format requires Target default and falls back to `none'. 129 | _THEOS_PACKAGE_FORMAT := $(or $(call __schema_var_last,,PACKAGE_FORMAT),$(_THEOS_TARGET_DEFAULT_PACKAGE_FORMAT),none) 130 | _THEOS_PACKAGE_LAST_FILENAME = $(call __simplify,_THEOS_PACKAGE_LAST_FILENAME,$(shell cat "$(_THEOS_LOCAL_DATA_DIR)/last_package" 2>/dev/null)) 131 | 132 | # ObjC/++ stuff is not here, it's in instance/rules.mk and only added if there are OBJC/OBJCC objects. 133 | _THEOS_INTERNAL_LDFLAGS = $(if $(_THEOS_TARGET_HAS_LIBRARY_PATH),-L$(THEOS_TARGET_LIBRARY_PATH) )-L$(THEOS_LIBRARY_PATH) 134 | 135 | OPTFLAG ?= -O2 136 | DEBUGFLAG ?= -ggdb 137 | DEBUG.CFLAGS = -DDEBUG $(DEBUGFLAG) -O0 138 | DEBUG.LDFLAGS = $(DEBUGFLAG) -O0 139 | ifneq ($(findstring DEBUG,$(THEOS_SCHEMA)),) 140 | TARGET_STRIP = : 141 | PACKAGE_BUILDNAME ?= debug 142 | endif 143 | 144 | _THEOS_INTERNAL_CFLAGS = -DTARGET_$(_THEOS_TARGET_NAME_DEFINE)=1 $(OPTFLAG) $(if $(_THEOS_TARGET_HAS_INCLUDE_PATH),-I$(THEOS_TARGET_INCLUDE_PATH) )-I$(THEOS_INCLUDE_PATH) -include $(THEOS)/Prefix.pch -Wall 145 | ifneq ($(GO_EASY_ON_ME),1) 146 | _THEOS_INTERNAL_LOGOSFLAGS += -c warnings=error 147 | _THEOS_INTERNAL_CFLAGS += -Werror 148 | endif 149 | 150 | THEOS_BUILD_DIR ?= . 151 | 152 | ifneq ($(_THEOS_CLEANED_SCHEMA_SET),) 153 | _THEOS_OBJ_DIR_EXTENSION = /$(_THEOS_CLEANED_SCHEMA_SET) 154 | endif 155 | ifneq ($(THEOS_TARGET_NAME),$(_THEOS_PLATFORM_DEFAULT_TARGET)) 156 | THEOS_OBJ_DIR_NAME ?= obj/$(THEOS_TARGET_NAME)$(_THEOS_OBJ_DIR_EXTENSION) 157 | else 158 | THEOS_OBJ_DIR_NAME ?= obj$(_THEOS_OBJ_DIR_EXTENSION) 159 | endif 160 | THEOS_OBJ_DIR = $(THEOS_BUILD_DIR)/$(THEOS_OBJ_DIR_NAME) 161 | 162 | THEOS_STAGING_DIR_NAME ?= _ 163 | THEOS_STAGING_DIR = $(THEOS_PROJECT_DIR)/$(THEOS_STAGING_DIR_NAME) 164 | _SPACE := 165 | _SPACE += 166 | _THEOS_ESCAPED_STAGING_DIR = $(subst $(_SPACE),\ ,$(THEOS_STAGING_DIR)) 167 | 168 | ifeq ($(THEOS_PACKAGE_DIR_NAME),) 169 | THEOS_PACKAGE_DIR = $(THEOS_BUILD_DIR) 170 | else 171 | THEOS_PACKAGE_DIR = $(THEOS_BUILD_DIR)/$(THEOS_PACKAGE_DIR_NAME) 172 | endif 173 | 174 | # $(warning ...) expands to the empty string, so the contents of THEOS_STAGING_DIR are not damaged in this copy. 175 | FW_PACKAGE_STAGING_DIR = $(THEOS_STAGING_DIR)$(warning FW_PACKAGE_STAGING_DIR is deprecated; please use THEOS_STAGING_DIR) 176 | 177 | THEOS_SUBPROJECT_PRODUCT = subproject.o 178 | 179 | include $(THEOS_MAKE_PATH)/messages.mk 180 | ifeq ($(_THEOS_VERBOSE),$(_THEOS_FALSE)) 181 | _THEOS_NO_PRINT_DIRECTORY_FLAG := --no-print-directory 182 | else 183 | _THEOS_NO_PRINT_DIRECTORY_FLAG := 184 | endif 185 | 186 | unexport THEOS_CURRENT_INSTANCE _THEOS_CURRENT_TYPE 187 | 188 | THEOS_RSYNC_EXCLUDES ?= _MTN .git .svn .DS_Store ._* 189 | _THEOS_RSYNC_EXCLUDE_COMMANDLINE := $(foreach exclude,$(THEOS_RSYNC_EXCLUDES),--exclude "$(exclude)") 190 | 191 | FAKEROOT := $(THEOS_BIN_PATH)/fakeroot.sh -p "$(_THEOS_LOCAL_DATA_DIR)/fakeroot" 192 | export FAKEROOT 193 | 194 | _THEOS_MAKE_PARALLEL_BUILDING ?= yes 195 | 196 | ifeq ($(THEOS_CURRENT_INSTANCE),) 197 | include $(THEOS_MAKE_PATH)/stage.mk 198 | include $(THEOS_MAKE_PATH)/package.mk 199 | endif 200 | THEOS_PACKAGE_VERSION = $(call __simplify,THEOS_PACKAGE_VERSION,$(THEOS_PACKAGE_BASE_VERSION)$(warning THEOS_PACKAGE_VERSION is deprecated. Please migrate to THEOS_PACKAGE_BASE_VERSION.)) 201 | 202 | $(eval $(call __mod,common.mk)) 203 | -------------------------------------------------------------------------------- /theos/makefiles/instance/rules.mk: -------------------------------------------------------------------------------- 1 | .PHONY: before-$(THEOS_CURRENT_INSTANCE)-all after-$(THEOS_CURRENT_INSTANCE)-all internal-$(_THEOS_CURRENT_TYPE)-all \ 2 | before-$(THEOS_CURRENT_INSTANCE)-stage after-$(THEOS_CURRENT_INSTANCE)-stage internal-$(_THEOS_CURRENT_TYPE)-stage 3 | 4 | __ALL_FILES = $(call __schema_var_all,$(THEOS_CURRENT_INSTANCE)_,FILES) $($(THEOS_CURRENT_INSTANCE)_OBJCC_FILES) $($(THEOS_CURRENT_INSTANCE)_LOGOS_FILES) $($(THEOS_CURRENT_INSTANCE)_OBJC_FILES) $($(THEOS_CURRENT_INSTANCE)_CC_FILES) $($(THEOS_CURRENT_INSTANCE)_C_FILES) 5 | __ON_FILES = $(filter-out -%,$(__ALL_FILES)) 6 | __OFF_FILES = $(patsubst -%,%,$(filter -%,$(__ALL_FILES))) 7 | _FILES = $(strip $(filter-out $(__OFF_FILES),$(__ON_FILES))) 8 | OBJ_FILES = $(strip $(patsubst %,%.$(_THEOS_OBJ_FILE_TAG).o,$(_FILES))) 9 | 10 | _OBJC_FILE_COUNT = $(words $(filter %.m %.mm %.x %.xm %.xi %.xmi,$(_FILES))) 11 | _OBJCC_FILE_COUNT = $(words $(filter %.mm %.xm %.xmi,$(_FILES))) 12 | 13 | # This is := because it would otherwise be evaluated immediately afterwards. 14 | _SUBPROJECTS := $(strip $(call __schema_var_all,$(THEOS_CURRENT_INSTANCE)_,SUBPROJECTS)) 15 | ifneq ($(_SUBPROJECTS),) 16 | SUBPROJECT_OBJ_FILES = $(foreach d, $(_SUBPROJECTS), $(THEOS_BUILD_DIR)/$(firstword $(subst :, ,$(d)))/$(THEOS_OBJ_DIR_NAME)/$(or $(word 2,$(subst :, ,$(d))),*).$(THEOS_SUBPROJECT_PRODUCT)) 17 | #SUBPROJECT_OBJ_FILES = $(addsuffix /$(THEOS_OBJ_DIR_NAME)/$(THEOS_SUBPROJECT_PRODUCT), $(addprefix $(THEOS_BUILD_DIR)/,$($(THEOS_CURRENT_INSTANCE)_SUBPROJECTS))) 18 | SUBPROJECT_LDFLAGS = $(shell sort $(foreach d,$(_SUBPROJECTS),$(THEOS_BUILD_DIR)/$(firstword $(subst :, ,$(d)))/$(THEOS_OBJ_DIR_NAME)/$(or $(word 2,$(subst :, ,$(d))),*).ldflags) | uniq) 19 | _THEOS_INTERNAL_LDFLAGS += $(SUBPROJECT_LDFLAGS) 20 | endif 21 | 22 | OBJ_FILES_TO_LINK = $(strip $(addprefix $(THEOS_OBJ_DIR)/,$(OBJ_FILES)) $(call __schema_var_all,$(THEOS_CURRENT_INSTANCE)_,OBJ_FILES) $(SUBPROJECT_OBJ_FILES)) 23 | _OBJ_DIR_STAMPS = $(sort $(foreach o,$(filter $(THEOS_OBJ_DIR)%,$(OBJ_FILES_TO_LINK)),$(dir $o).stamp)) 24 | 25 | ADDITIONAL_CPPFLAGS += $(call __schema_var_all,$(THEOS_CURRENT_INSTANCE)_,CPPFLAGS) 26 | 27 | # If we have any Objective-C objects, link Foundation and libobjc. 28 | ifneq ($(_OBJC_FILE_COUNT),0) 29 | _THEOS_INTERNAL_LDFLAGS += -lobjc -framework Foundation -framework CoreFoundation 30 | endif 31 | 32 | # In addition, if we have any Objective-C++, add the ObjC++ linker flags. 33 | ifneq ($(_OBJCC_FILE_COUNT),0) 34 | _THEOS_INTERNAL_LDFLAGS += -ObjC++ -fobjc-exceptions -fobjc-call-cxx-cdtors 35 | endif 36 | 37 | # Add all frameworks from the type and instance. 38 | _THEOS_INTERNAL_LDFLAGS += $(foreach framework,$($(_THEOS_CURRENT_TYPE)_FRAMEWORKS),-framework $(framework)) 39 | _THEOS_INTERNAL_LDFLAGS += $(foreach framework,$(call __schema_var_all,$(THEOS_CURRENT_INSTANCE)_,FRAMEWORKS),-framework $(framework)) 40 | 41 | # Add all libraries from the type and instance. 42 | _THEOS_INTERNAL_LDFLAGS += $(foreach library,$($(_THEOS_CURRENT_TYPE)_LIBRARIES),-l$(library)) 43 | _THEOS_INTERNAL_LDFLAGS += $(foreach library,$(call __schema_var_all,$(THEOS_CURRENT_INSTANCE)_,LIBRARIES),-l$(library)) 44 | 45 | # Add all private frameworks from the type and instance, as well as -F for the private framework dir. 46 | ifneq ($(words $($(_THEOS_CURRENT_TYPE)_PRIVATE_FRAMEWORKS)$(call __schema_var_all,$(THEOS_CURRENT_INSTANCE)_,PRIVATE_FRAMEWORKS)),0) 47 | _THEOS_INTERNAL_OBJCFLAGS += -F$(TARGET_PRIVATE_FRAMEWORK_PATH) 48 | _THEOS_INTERNAL_LDFLAGS += -F$(TARGET_PRIVATE_FRAMEWORK_PATH) 49 | endif 50 | 51 | _THEOS_INTERNAL_LDFLAGS += $(foreach framework,$($(_THEOS_CURRENT_TYPE)_PRIVATE_FRAMEWORKS),-framework $(framework)) 52 | _THEOS_INTERNAL_LDFLAGS += $(foreach framework,$(call __schema_var_all,$(THEOS_CURRENT_INSTANCE)_,PRIVATE_FRAMEWORKS),-framework $(framework)) 53 | 54 | ALL_CFLAGS = $(_THEOS_INTERNAL_CFLAGS) $(_THEOS_TARGET_CFLAGS) $(ADDITIONAL_CFLAGS) $(call __schema_var_all,$(THEOS_CURRENT_INSTANCE)_,CFLAGS) $(call __schema_var_all,,CFLAGS) 55 | ALL_CCFLAGS = $(_THEOS_INTERNAL_CCFLAGS) $(ADDITIONAL_CCFLAGS) $(call __schema_var_all,$(THEOS_CURRENT_INSTANCE)_,CCFLAGS) $(call __schema_var_all,,CCFLAGS) 56 | ALL_OBJCFLAGS = $(_THEOS_INTERNAL_OBJCFLAGS) $(_THEOS_TARGET_OBJCFLAGS) $(ADDITIONAL_OBJCFLAGS) $(call __schema_var_all,$(THEOS_CURRENT_INSTANCE)_,OBJCFLAGS) $(call __schema_var_all,,OBJCFLAGS) 57 | ALL_OBJCCFLAGS = $(_THEOS_INTERNAL_OBJCCFLAGS) $(ADDITIONAL_OBJCCFLAGS) $(call __schema_var_all,$(THEOS_CURRENT_INSTANCE)_,OBJCCFLAGS) $(call __schema_var_all,,OBJCCFLAGS) 58 | ALL_LOGOSFLAGS = $(_THEOS_INTERNAL_LOGOSFLAGS) $(ADDITIONAL_LOGOSFLAGS) $(call __schema_var_all,$(THEOS_CURRENT_INSTANCE)_,LOGOSFLAGS) $(call __schema_var_all,,LOGOSFLAGS) 59 | 60 | ALL_LDFLAGS = $(_THEOS_INTERNAL_LDFLAGS) $(ADDITIONAL_LDFLAGS) $(_THEOS_TARGET_LDFLAGS) $(call __schema_var_all,$(THEOS_CURRENT_INSTANCE)_,LDFLAGS) $(call __schema_var_all,,LDFLAGS) 61 | 62 | ifneq ($(TARGET_CODESIGN),) 63 | _THEOS_CODESIGN_COMMANDLINE = CODESIGN_ALLOCATE=$(TARGET_CODESIGN_ALLOCATE) $(TARGET_CODESIGN) $(or $(call __schema_var_all,$(THEOS_CURRENT_INSTANCE)_,CODESIGN_FLAGS),$(TARGET_CODESIGN_FLAGS)) 64 | else 65 | _THEOS_CODESIGN_COMMANDLINE = 66 | endif 67 | 68 | ALL_STRIP_FLAGS = $(or $(call __schema_var_all,$(THEOS_CURRENT_INSTANCE)_,STRIP_FLAGS),$(TARGET_STRIP_FLAGS)) 69 | 70 | _THEOS_OBJ_FILE_TAG = $(call __simplify,_THEOS_OBJ_FILE_TAG,$(shell echo "$(ALL_CFLAGS) $(ALL_OBJCFLAGS) $(ALL_CCFLAGS) $(ALL_OBJCCFLAGS) $(ALL_LOGOSFLAGS)" | $(_THEOS_PLATFORM_MD5SUM) | cut -c1-8)) 71 | _THEOS_OUT_FILE_TAG = $(call __simplify,_THEOS_OUT_FILE_TAG,$(shell echo "$(ALL_STRIP_FLAGS) $(_THEOS_CODESIGN_COMMANDLINE)" | $(_THEOS_PLATFORM_MD5SUM) | cut -c1-8)) 72 | 73 | ifneq ($(_THEOS_MAKE_PARALLEL_BUILDING)$(_THEOS_MAKE_PARALLEL),yesyes) 74 | ifneq ($(_THEOS_MAKE_PARALLEL_BUILDING),no) 75 | override _THEOS_OBJ_FILE_TAG := dummy 76 | endif 77 | endif 78 | 79 | before-$(THEOS_CURRENT_INSTANCE)-all after-$(THEOS_CURRENT_INSTANCE)-all:: 80 | @: 81 | 82 | internal-$(_THEOS_CURRENT_TYPE)-all:: before-$(THEOS_CURRENT_INSTANCE)-all internal-$(_THEOS_CURRENT_TYPE)-all_ after-$(THEOS_CURRENT_INSTANCE)-all 83 | @: 84 | 85 | before-$(THEOS_CURRENT_INSTANCE)-stage after-$(THEOS_CURRENT_INSTANCE)-stage:: 86 | @: 87 | 88 | internal-$(_THEOS_CURRENT_TYPE)-stage:: before-$(THEOS_CURRENT_INSTANCE)-stage internal-$(_THEOS_CURRENT_TYPE)-stage_ after-$(THEOS_CURRENT_INSTANCE)-stage 89 | @: 90 | 91 | .SUFFIXES: 92 | 93 | .SUFFIXES: .m .mm .c .cc .cpp .xm 94 | 95 | $(THEOS_OBJ_DIR)/%.m.$(_THEOS_OBJ_FILE_TAG).o: %.m 96 | $(ECHO_COMPILING)$(TARGET_CXX) -x objective-c -c $(ALL_CFLAGS) $(ALL_OBJCFLAGS) $(_THEOS_TARGET_ONLY_OBJCFLAGS) $< -o $@$(ECHO_END) 97 | 98 | $(THEOS_OBJ_DIR)/%.mi.$(_THEOS_OBJ_FILE_TAG).o: %.mi 99 | $(ECHO_COMPILING)$(TARGET_CXX) -x objective-c-cpp-output -c $(ALL_CFLAGS) $(ALL_OBJCFLAGS) $(_THEOS_TARGET_ONLY_OBJCFLAGS) $< -o $@$(ECHO_END) 100 | 101 | $(THEOS_OBJ_DIR)/%.mm.$(_THEOS_OBJ_FILE_TAG).o: %.mm 102 | $(ECHO_COMPILING)$(TARGET_CXX) -x objective-c++ -c $(ALL_CFLAGS) $(ALL_OBJCFLAGS) $(ALL_CCFLAGS) $(ALL_OBJCCFLAGS) $< -o $@$(ECHO_END) 103 | 104 | $(THEOS_OBJ_DIR)/%.mii.$(_THEOS_OBJ_FILE_TAG).o: %.mii 105 | $(ECHO_COMPILING)$(TARGET_CXX) -x objective-c++-cpp-output -c $(ALL_CFLAGS) $(ALL_OBJCFLAGS) $(_THEOS_TARGET_ONLY_OBJCFLAGS) $< -o $@$(ECHO_END) 106 | 107 | $(THEOS_OBJ_DIR)/%.c.$(_THEOS_OBJ_FILE_TAG).o: %.c 108 | $(ECHO_COMPILING)$(TARGET_CXX) -x c -c $(ALL_CFLAGS) $< -o $@$(ECHO_END) 109 | 110 | $(THEOS_OBJ_DIR)/%.i.$(_THEOS_OBJ_FILE_TAG).o: %.i 111 | $(ECHO_COMPILING)$(TARGET_CXX) -x c-cpp-output -c $(ALL_CFLAGS) $< -o $@$(ECHO_END) 112 | 113 | $(THEOS_OBJ_DIR)/%.s.$(_THEOS_OBJ_FILE_TAG).o: %.s 114 | $(ECHO_COMPILING)$(TARGET_CXX) -x assembler -c $(ALL_CFLAGS) $< -o $@$(ECHO_END) 115 | 116 | $(THEOS_OBJ_DIR)/%.S.$(_THEOS_OBJ_FILE_TAG).o: %.S 117 | $(ECHO_COMPILING)$(TARGET_CXX) -x assembler-with-cpp -c $(ALL_CFLAGS) $< -o $@$(ECHO_END) 118 | 119 | $(THEOS_OBJ_DIR)/%.cc.$(_THEOS_OBJ_FILE_TAG).o: %.cc 120 | $(ECHO_COMPILING)$(TARGET_CXX) -x c++ -c $(ALL_CFLAGS) $(ALL_CCFLAGS) $< -o $@$(ECHO_END) 121 | 122 | $(THEOS_OBJ_DIR)/%.cp.$(_THEOS_OBJ_FILE_TAG).o: %.cp 123 | $(ECHO_COMPILING)$(TARGET_CXX) -x c++ -c $(ALL_CFLAGS) $(ALL_CCFLAGS) $< -o $@$(ECHO_END) 124 | 125 | $(THEOS_OBJ_DIR)/%.cxx.$(_THEOS_OBJ_FILE_TAG).o: %.cxx 126 | $(ECHO_COMPILING)$(TARGET_CXX) -x c++ -c $(ALL_CFLAGS) $(ALL_CCFLAGS) $< -o $@$(ECHO_END) 127 | 128 | $(THEOS_OBJ_DIR)/%.cpp.$(_THEOS_OBJ_FILE_TAG).o: %.cpp 129 | $(ECHO_COMPILING)$(TARGET_CXX) -x c++ -c $(ALL_CFLAGS) $(ALL_CCFLAGS) $< -o $@$(ECHO_END) 130 | 131 | $(THEOS_OBJ_DIR)/%.c++.$(_THEOS_OBJ_FILE_TAG).o: %.c++ 132 | $(ECHO_COMPILING)$(TARGET_CXX) -x c++ -c $(ALL_CFLAGS) $(ALL_CCFLAGS) $< -o $@$(ECHO_END) 133 | 134 | $(THEOS_OBJ_DIR)/%.ii.$(_THEOS_OBJ_FILE_TAG).o: %.ii 135 | $(ECHO_COMPILING)$(TARGET_CXX) -x c++-cpp-output -c $(ALL_CFLAGS) $< -o $@$(ECHO_END) 136 | 137 | 138 | $(THEOS_OBJ_DIR)/%.x.$(_THEOS_OBJ_FILE_TAG).o: %.x 139 | $(ECHO_PREPROCESSING)$(THEOS_BIN_PATH)/logos.pl $(ALL_LOGOSFLAGS) $< > $(THEOS_OBJ_DIR)/$<.m$(ECHO_END) 140 | $(ECHO_COMPILING)$(TARGET_CXX) -x objective-c -c -I"$(call __clean_pwd,$(dir $<))" $(ALL_CFLAGS) $(ALL_OBJCFLAGS) $(_THEOS_TARGET_ONLY_OBJCFLAGS) -include "logos/logos.h" $(THEOS_OBJ_DIR)/$<.m -o $@$(ECHO_END) 141 | $(ECHO_NOTHING)rm $(THEOS_OBJ_DIR)/$<.m$(ECHO_END) 142 | 143 | $(THEOS_OBJ_DIR)/%.xm.$(_THEOS_OBJ_FILE_TAG).o: %.xm 144 | $(ECHO_PREPROCESSING)$(THEOS_BIN_PATH)/logos.pl $(ALL_LOGOSFLAGS) $< > $(THEOS_OBJ_DIR)/$<.mm$(ECHO_END) 145 | $(ECHO_COMPILING)$(TARGET_CXX) -x objective-c++ -c -I"$(call __clean_pwd,$(dir $<))" $(ALL_CFLAGS) $(ALL_OBJCFLAGS) $(ALL_CCFLAGS) $(ALL_OBJCCFLAGS) -include "logos/logos.h" $(THEOS_OBJ_DIR)/$<.mm -o $@$(ECHO_END) 146 | $(ECHO_NOTHING)rm $(THEOS_OBJ_DIR)/$<.mm$(ECHO_END) 147 | 148 | $(THEOS_OBJ_DIR)/%.xi.$(_THEOS_OBJ_FILE_TAG).o: %.xi 149 | $(ECHO_PREPROCESSING)$(TARGET_CXX) -x objective-c -E -I"$(call __clean_pwd,$(dir $<))" $(ALL_CFLAGS) $(ALL_OBJCFLAGS) $(_THEOS_TARGET_ONLY_OBJCFLAGS) -include "logos/logos.h" -include substrate.h $< > $(THEOS_OBJ_DIR)/$<.pre && $(THEOS_BIN_PATH)/logos.pl $(ALL_LOGOSFLAGS) $(THEOS_OBJ_DIR)/$<.pre > $(THEOS_OBJ_DIR)/$<.mi $(ECHO_END) 150 | $(ECHO_COMPILING)$(TARGET_CXX) -c $(ALL_CFLAGS) $(ALL_OBJCFLAGS) $(_THEOS_TARGET_ONLY_OBJCFLAGS) $(THEOS_OBJ_DIR)/$<.mi -o $@$(ECHO_END) 151 | $(ECHO_NOTHING)rm $(THEOS_OBJ_DIR)/$<.pre $(THEOS_OBJ_DIR)/$<.mi$(ECHO_END) 152 | 153 | $(THEOS_OBJ_DIR)/%.xmi.$(_THEOS_OBJ_FILE_TAG).o: %.xmi 154 | $(ECHO_PREPROCESSING)$(TARGET_CXX) -x objective-c++ -E -I"$(call __clean_pwd,$(dir $<))" $(ALL_CFLAGS) $(ALL_OBJCFLAGS) $(ALL_CCFLAGS) $(ALL_OBJCCFLAGS) -include "logos/logos.h" -include substrate.h $< > $(THEOS_OBJ_DIR)/$<.pre && $(THEOS_BIN_PATH)/logos.pl $(ALL_LOGOSFLAGS) $(THEOS_OBJ_DIR)/$<.pre > $(THEOS_OBJ_DIR)/$<.mii $(ECHO_END) 155 | $(ECHO_COMPILING)$(TARGET_CXX) -c $(ALL_CFLAGS) $(ALL_OBJCFLAGS) $(ALL_CCFLAGS) $(ALL_OBJCCFLAGS) $(THEOS_OBJ_DIR)/$<.mii -o $@$(ECHO_END) 156 | $(ECHO_NOTHING)rm $(THEOS_OBJ_DIR)/$<.pre $(THEOS_OBJ_DIR)/$<.mii$(ECHO_END) 157 | 158 | define _THEOS_TEMPLATE_DEFAULT_LINKING_RULE 159 | ifneq ($$(TARGET_CODESIGN),) 160 | .INTERMEDIATE: $$(THEOS_OBJ_DIR)/$(1).$(_THEOS_OUT_FILE_TAG).unsigned 161 | $$(THEOS_OBJ_DIR)/$(1): $$(THEOS_OBJ_DIR)/$(1).$(_THEOS_OUT_FILE_TAG).unsigned 162 | $$(ECHO_SIGNING)$$(_THEOS_CODESIGN_COMMANDLINE) "$$<"; mv "$$<" "$$@"$$(ECHO_END) 163 | $$(THEOS_OBJ_DIR)/$(1).$(_THEOS_OUT_FILE_TAG).unsigned: $$(OBJ_FILES_TO_LINK) 164 | else 165 | $$(THEOS_OBJ_DIR)/$(1): $$(OBJ_FILES_TO_LINK) 166 | endif 167 | ifneq ($(2),nowarn) 168 | ifeq ($$(OBJ_FILES_TO_LINK),) 169 | $$(WARNING_EMPTY_LINKING) 170 | endif 171 | endif 172 | $$(ECHO_LINKING)$$(TARGET_LD) $$(ALL_LDFLAGS) -o "$$@" $$^$$(ECHO_END) 173 | ifeq ($$(findstring DEBUG,$$(THEOS_SCHEMA)),) 174 | $$(ECHO_STRIPPING)$$(TARGET_STRIP) $$(ALL_STRIP_FLAGS) "$$@"$$(ECHO_END) 175 | endif 176 | endef 177 | 178 | $(eval $(call __mod,instance/rules.mk)) 179 | --------------------------------------------------------------------------------