|
|
@@ -1,4163 +0,0 @@
|
|
|
-<?php
|
|
|
-function ReadTextFile ($path) {
|
|
|
- if ($handle = fopen($path, "r")) {
|
|
|
- return fread($handle, 400 * 1024);
|
|
|
- fclose($handle);
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-function str_replace_word ($needle, $replacement, $haystack) {
|
|
|
- $pattern = "/\b$needle\b/";
|
|
|
- $haystack = preg_replace($pattern, $replacement, $haystack);
|
|
|
- return $haystack;
|
|
|
-}
|
|
|
-
|
|
|
-function istr_replace_word ($needle, $replacement, $haystack) {
|
|
|
- $pattern = "/\b$needle\b/i";
|
|
|
- $haystack = preg_replace($pattern, $replacement, $haystack);
|
|
|
- return $haystack;
|
|
|
-}
|
|
|
-
|
|
|
-define("CAST_HANDLE", true);
|
|
|
-define("DONT_CAST_HANDLE", false);
|
|
|
-
|
|
|
-define("ACCESS_HANDLE_DIRECT", 1);
|
|
|
-define("ACCESS_HANDLE_FUNCTION", 2);
|
|
|
-
|
|
|
-define("REGISTER_SEL", true);
|
|
|
-define("DONT_REGISTER_SEL", false);
|
|
|
-
|
|
|
-define("USE_HANDLE", true);
|
|
|
-define("DONT_USE_HANDLE", false);
|
|
|
-
|
|
|
-class TPasCocoaParser {
|
|
|
-
|
|
|
- // Frameworks to parse
|
|
|
- var $frameworks = array( "foundation" => array( "root" => "/foundation/Foundation.inc",
|
|
|
- "bridge" => "/bridgesupport/foundation.xml",
|
|
|
- "headers" => "/System/Library/Frameworks/Foundation.framework/Headers",
|
|
|
- "include_pattern" => "{[$]+include (NS.*).inc}",
|
|
|
- "header_pattern" => "^NS(.*)\.h",
|
|
|
- "enabled" => false,
|
|
|
- ),
|
|
|
-
|
|
|
- "appkit" => array( "root" => "/appkit/AppKit.inc",
|
|
|
- "bridge" => "/bridgesupport/appkit.xml",
|
|
|
- "headers" => "/System/Library/Frameworks/AppKit.framework/Headers",
|
|
|
- "include_pattern" => "{[$]+include (NS.*).inc}",
|
|
|
- "header_pattern" => "^NS(.*)\.h",
|
|
|
- "enabled" => false,
|
|
|
- ),
|
|
|
-
|
|
|
- "uikit" => array( "root" => "/uikit/UIKit.inc",
|
|
|
- "bridge" => "/bridgesupport/appkit.xml",
|
|
|
- //"headers" => "/Users/ryanjoseph/Desktop/iphone/UIKit.framework/Headers",
|
|
|
- "headers" => "/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS2.2.1.sdk/System/Library/Frameworks/UIKit.framework/Headers",
|
|
|
- "include_pattern" => "{[$]+include (UI.*).inc}",
|
|
|
- "header_pattern" => "^UI(.*)\.h",
|
|
|
- "enabled" => false,
|
|
|
- ),
|
|
|
-
|
|
|
- "webkit" => array( "root" => "/webkit/WebKit.inc",
|
|
|
- "bridge" => "/bridgesupport/webkit.xml",
|
|
|
- "headers" => "/System/Library/Frameworks/WebKit.framework/Headers",
|
|
|
- "include_pattern" => "{[$]+include (.*).inc}",
|
|
|
- "header_pattern" => "^(.*)\.h",
|
|
|
- "enabled" => false,
|
|
|
- ),
|
|
|
-
|
|
|
- "coredata" => array( "root" => "/coredata/CoreData.inc",
|
|
|
- "bridge" => "/bridgesupport/coredata.xml",
|
|
|
- "headers" => "/Developer/SDKs/MacOSX10.5.sdk/System/Library/Frameworks/CoreData.framework/Headers",
|
|
|
- "include_pattern" => "{[$]+include (.*).inc}",
|
|
|
- "header_pattern" => "^(.*)\.h",
|
|
|
- "enabled" => false,
|
|
|
- ),
|
|
|
- );
|
|
|
-
|
|
|
- var $maximum_method_length = 111; // WE GET THIS ERROR: NSDelegatesAll.pas(6109,296) Error: Identifier not found "NSDelegateController_NSLayoutManagerDelegate_layoutManager_shouldUseTemporaryAttributes_forDrawingToScreen_atCharacterIndex_effectiveRange"
|
|
|
-
|
|
|
- var $output; // current output file handle
|
|
|
- var $root; // root for printing/locating resources
|
|
|
- var $out; // directory to print
|
|
|
- var $show; // print output to screen instead of file
|
|
|
- var $framework; // current framework being parsed
|
|
|
- var $current_class; // reference to current class structure being parsed
|
|
|
- var $current_header; // reference to current header structure being parsed
|
|
|
- var $method_count; // count of all methods parsed
|
|
|
- var $class_count; // count of all classes parsed
|
|
|
- var $warning_count; // count of parser warnings
|
|
|
- var $parser_skipping; // the parser is skipping lines in the current file
|
|
|
- var $inside_macro_block; // the parser is inside a macro block, no nesting!
|
|
|
- var $instance_var_scope; // current scope of the instance variable parser
|
|
|
- var $cocoa_classes = array(); // array of all NS*** classes
|
|
|
- var $cocoa_categories = array(); // array of all NS*** categories
|
|
|
- var $dump = array(); // Convert Pascal classes
|
|
|
- var $delegate_methods = array(); // Delegate methods and types from GEN_BRIDGE_METADATA XML data
|
|
|
- var $delegate_method_names = array(); // Delegate method name array
|
|
|
- var $type_encodings = array(); // Master listing of type encodings for each method in the frameworks
|
|
|
-
|
|
|
- /**
|
|
|
- * PARSER OPTIONS
|
|
|
- */
|
|
|
- var $objc_id = "NSObjectRef"; // Default type for generic objects
|
|
|
- var $objc_id_real = "NSObjectRef"; // The real type of generic objects (id)
|
|
|
- var $objc_id_base = "Pointer"; // The base type for all "Ref" types
|
|
|
- var $sel_string = "SELString"; // The selector string type which registers selectors internally
|
|
|
- var $protocol_suffix = "Protocol"; // All protocols append this suffix
|
|
|
- var $pointer_type_suffx = "Ref"; // NS*** pointers in parameter lists are suffixed with this
|
|
|
- var $class_pointer_suffix = "Pointer"; // Pointers to NS*** classes are suffxed with this
|
|
|
- var $register_selectors = true; // Register selectors automatically inside the wrappers
|
|
|
- var $show_added_messages = false; // show messages when methods are added to a class
|
|
|
- var $show_class_hierarchy = false;
|
|
|
- var $objects_are_wrappers = false; // Treat all objects (id) like wrappers. i.e aObject.Handle;
|
|
|
- var $replace_hinted_params = false; // replace comment hints with hinted type - (void * /* CMProfileRef */)colorSyncProfile;
|
|
|
- var $master_delegate_class = "NSDelegateController"; // Name of the master delegate class
|
|
|
- var $master_delegate_file = "NSDelegatesAll"; // Name of the master delegate file (no extension)
|
|
|
- var $trailing_underscore = false; // Append the trailing underscore for last parameter
|
|
|
- var $record_keyword = "record"; // The keyword used for printing records
|
|
|
- var $bitpacked_record_keyword = "bitpacked record"; // The keyword used for printing bitpacked records
|
|
|
- var $string_macro = "NSString";
|
|
|
-
|
|
|
- // Pascal keywords to protect
|
|
|
- var $reserved_keywords = array( "const", "object", "string", "array", "var", "set", "interface", "classname", "unit",
|
|
|
- "self", "type", "raise", "property", "to", "for", "with", "function", "procedure", "result",
|
|
|
- "pointer", "create", "new", "dispose", "label", "packed", "record", "char", "class",
|
|
|
- );
|
|
|
-
|
|
|
- // FPC methods that can't be overloaded
|
|
|
- var $reserved_methods = array("className");
|
|
|
-
|
|
|
- // Types which can not be altered by reserved keywords
|
|
|
- var $reserved_types = array("Pointer");
|
|
|
-
|
|
|
- // Objective-c types to convert
|
|
|
- var $replace_types = array( "id"=>"NSObjectRef", "void"=>"Pointer", "BOOL"=>"LongBool", "long"=>"LongInt", "int"=>"Integer",
|
|
|
- "unsigned long"=>"UInt32", "unsigned short"=>"UInt8", "void *"=>"Pointer", "unsigned int"=>"UInt16",
|
|
|
- "NSUInteger"=>"UInt32", "NSInteger"=>"SInt32", "Class"=>"Pobjc_class", "uint"=>"UInt16",
|
|
|
- "uint8_t"=>"UInt8", "signed int"=>"Integer", "const char"=>"PChar", "const void"=>"Pointer",
|
|
|
- "const uint8_t"=>"Pointer", "unsigned"=>"UInt8", "int32_t"=>"SInt32", "float"=>"Float32",
|
|
|
- "unsigned long long"=>"UInt64", "int64_t"=>"SInt64", "uint32_t"=>"UInt32", "uint16_t"=>"UInt16",
|
|
|
- "unsigned char"=>"char", "short"=>"SInt8", "double"=>"Float64", "long long"=>"SInt64",
|
|
|
-
|
|
|
- // macros
|
|
|
- "IBAction"=>"void",
|
|
|
-
|
|
|
- // special pointers
|
|
|
- "const id *"=>"NSObjectArrayOfObjectsPtr", "Protocol *"=>"ObjcProtocol", "NSObject *"=>"NSObjectRef",
|
|
|
- "const char *"=>"PChar", "const void *"=>"Pointer", "unsigned char *"=>"Pointer", "char *"=>"Pointer",
|
|
|
- "unsigned *"=>"Pointer",
|
|
|
- );
|
|
|
-
|
|
|
- // These "types" are hints to the Objective-C garbage collector
|
|
|
- var $garbage_collector_hints = array("__strong", "__weak");
|
|
|
-
|
|
|
- var $null_macros = array("IBOutlet", "IBAction");
|
|
|
-
|
|
|
- // External NSString macros. These should be moved into the frameworks array
|
|
|
- var $external_string_macros = "APPKIT_EXTERN|FOUNDATION_EXPORT|UIKIT_EXTERN|COREDATA_EXTERN";
|
|
|
-
|
|
|
- // Types which have known pointers declared in the headers
|
|
|
- var $pointer_types = array( // MacOSAll types
|
|
|
- "CGFloat"=>"psingle", "UInt32"=>"UInt32Ptr", "SInt32"=>"SInt32Ptr",
|
|
|
-
|
|
|
- // Cocoa types
|
|
|
- "BOOL"=>"pboolean",
|
|
|
-
|
|
|
- "unsigned char"=>"pchar",
|
|
|
- "unsigned short"=>"pcushort", "unsigned int"=>"pcuint", "uint"=>"pcuint", "signed int"=>"pcint",
|
|
|
- "float"=>"psingle", "double"=>"pdouble", "long long"=>"pclonglong","long"=>"pclong", "unsigned long"=>"pculong",
|
|
|
- "int"=>"pinteger","uint8_t"=>"pbyte","unsigned"=>"pbyte","unsigned long long"=>"pculonglong"
|
|
|
- );
|
|
|
-
|
|
|
- var $objc_object_array = "id; objParams: array of const"; // Type which represents a dynamic array of Objective-c objects (id)
|
|
|
-
|
|
|
- // Symbols to ignore
|
|
|
- var $ignore_symbol = array("NSApp");
|
|
|
-
|
|
|
- // Categories to ignore
|
|
|
- var $ignore_categories = array("NSCoderMethods", "NSDeprecatedKeyValueCoding", "NSDeprecated");
|
|
|
-
|
|
|
- // Methods to ignore
|
|
|
- var $ignore_methods = array( "retain", "release", "retainCount", "copyWithZone", "mutableCopyWithZone",
|
|
|
- "allocWithZone", "alloc", "copy", "mutableCopy", "self_", "autorelease", "awakeFromNib",
|
|
|
- "observationInfo",
|
|
|
- );
|
|
|
-
|
|
|
- // default protected keywords by class/category
|
|
|
- // these may be useful if super classes were not parsed before
|
|
|
- var $default_protected = array( "*"=>array("description", "classDescription"),
|
|
|
- "NSDeprecated"=>array("accessoryView"),
|
|
|
- "NSToolbarSupport"=>array("toolbar"),
|
|
|
- "DOMNode"=>array("version"),
|
|
|
- "WebView"=>array("frame"),
|
|
|
- "DOMImplementation"=>array("version"),
|
|
|
- );
|
|
|
-
|
|
|
- // Send methods that have a custom design
|
|
|
- var $custom_send_methods = array( "NSArray.arrayWithObjects", "NSArray.initWithObjects",
|
|
|
- "NSDictionary.dictionaryWithObjectsAndKeys", "NSDictionary.initWithObjectsAndKeys",
|
|
|
- "NSSet.setWithObjects", "NSSet.initWithObjects",
|
|
|
- );
|
|
|
-
|
|
|
- var $toll_free_bridge = array(
|
|
|
- "NSString"=>"CFStringRef", "NSArray"=>"CFArrayRef", "NSMutableString"=>"CFMutableStringRef",
|
|
|
- "NSData"=>"CFDataRef", "NSDictionary"=>"CFDictionaryRef", "NSSet"=>"CFSetRef",
|
|
|
- "NSMutableArray"=>"CFMutableArrayRef", "NSMutableCharacterSetRef"=>"CFMutableCharacterSetRef",
|
|
|
- "NSMutableData"=>"CFMutableDataRef", "NSMutableDictionary"=>"CFMutableDictionaryRef",
|
|
|
- "NSMutableSet"=>"CFMutableSetRef", "NSNumber"=>"CFNumberRef", "NSURL"=>"CFURLRef",
|
|
|
- "NSError"=>"CFErrorRef",
|
|
|
-
|
|
|
- /* The Cocoa versions of these API's are much better and not very common, should we replace them?
|
|
|
- "NSOutputStream"=>"CFWriteStreamRef", "NSPasteboard"=>"PasteboardRef"
|
|
|
- "NSInputStream"=>"CFReadStreamRef", "NSTimer"=>"CFRunLoopTimerRef",
|
|
|
- "NSTimeZone"=>"CFTimeZoneRef", "NSCharacterSet"=>"CFCharacterSetRef",
|
|
|
- "NSDate"=>"CFDateRef",
|
|
|
- */
|
|
|
- );
|
|
|
-
|
|
|
- // types that use objc_msgSend_stret on all architectures
|
|
|
- var $struct_types = array( "NSRect", "NSDecimal", "NSFastEnumerationState", "NSMapTableValueCallBacks",
|
|
|
- "NSHashTableCallBacks", "NSMapTableKeyCallBacks",
|
|
|
-
|
|
|
- // TEMPORARY PARSER HACKS
|
|
|
- "aeDesc_",
|
|
|
- );
|
|
|
-
|
|
|
- // structs that use objc_msgSend or objc_msgSend_stret depending on architecture
|
|
|
- // "On Mac OS X Intel/i386, records whose size is 1, 2, 4 or 8 bytes are returned using registers"
|
|
|
- var $struct_register_types = array( "NSRange", "NSPoint", "NSSize", "NSAffineTransformStruct" );
|
|
|
-
|
|
|
- // Functions that return types will invoke objc_msgSend_fpret
|
|
|
- // NOTE: we must also know the exact type so we can make the proper function pointer
|
|
|
- var $float_types = array( // C-types
|
|
|
- "float", "long double", "double",
|
|
|
-
|
|
|
- // Cocoa types
|
|
|
- "NSTimeInterval",
|
|
|
-
|
|
|
- // Pascal types
|
|
|
- "Float64", "Float32",
|
|
|
-
|
|
|
- // CarbonTypes
|
|
|
- "CGFloat",
|
|
|
- );
|
|
|
-
|
|
|
- var $skip_blocks = array( "^#if __LP64__ \|\| NS_BUILD_32_LIKE_64"=>"^#(else|endif)+",
|
|
|
- );
|
|
|
-
|
|
|
- var $macro_blocks = array( "^#if (__LP64__)"=>"\$ifdef cpu64",
|
|
|
- "^#if ![[:space:]]*(__LP64__)"=>"\$ifndef cpu64",
|
|
|
- "^#ifdef __BIG_ENDIAN__"=>"\$ifdef fpc_big_endian",
|
|
|
- //"^#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_[0-9]+_[0-9]+"=>"*",
|
|
|
- );
|
|
|
-
|
|
|
- // these categories should be placed into NSObject
|
|
|
- var $base_categories = array( "NSArchiverCallback", "NSClassDescriptionPrimitives", "NSCoderMethods", "NSComparisonMethods",
|
|
|
- "NSDelayedPerforming", "NSDeprecatedKeyValueCoding", "NSDeprecatedKeyValueObservingCustomization",
|
|
|
- "NSDistributedObjects", "NSErrorRecoveryAttempting", "NSKeyValueCoding", "NSPlaceholders",
|
|
|
- "NSKeyValueObserverRegistration", "NSKeyValueObserving", "NSKeyValueObservingCustomization",
|
|
|
- "NSKeyedArchiverObjectSubstitution", "NSKeyedUnarchiverObjectSubstitution", "NSDeprecatedMethods",
|
|
|
- "NSScriptKeyValueCoding", "NSThreadPerformAdditions", "NSServicesRequests", "NSKeyValueBindingCreation",
|
|
|
- "NSAccessibility", "NSAccessibilityAdditions",
|
|
|
- );
|
|
|
-
|
|
|
- // These really don't feel like they should be in NSObject, removing until we know where to put them.
|
|
|
- // Maybe a new class? NSCategories...
|
|
|
-
|
|
|
- // "NSURLClient", "NSScripting", "NSScriptClassDescription", "NSScriptObjectSpecifiers",
|
|
|
- // "NSScriptingComparisonMethods", "NSFontManagerResponderMethod", "NSMenuValidation",
|
|
|
- // "NSColorPanelResponderMethod", "NSFontPanelValidationAdditions", "NSToolbarItemValidation",
|
|
|
- // "NSDictionaryControllerKeyValuePair", "NSEditor",
|
|
|
- /**
|
|
|
- * COMMON REGULAR EXPRESIONS
|
|
|
- */
|
|
|
- var $regex_objc_method_params = "^(-|\+)[[:space:]]*\((.*)\)[[:space:]]*([a-zA-Z0-9]+):(.*);";
|
|
|
- var $regex_objc_method_no_params = "^(-|\+)[[:space:]]*\((.*)\)[[:space:]]*([a-zA-Z0-9]+);";
|
|
|
- var $regex_objc_category = "^@interface ([a-zA-Z]+)[[:space:]]*\(([a-zA-Z]+)\)";
|
|
|
- var $regex_objc_class = "^@interface ([a-zA-Z]+)[[:space:]]*:[[:space:]]*([a-zA-Z]+)[[:space:]]*(<(.*)>)*";
|
|
|
- var $regex_objc_class_no_super = "^@interface ([a-zA-Z]+)[[:space:]]*<(.*)>[[:space:]]*";
|
|
|
- var $regex_objc_protocol = "^@protocol ([a-zA-Z]+)";
|
|
|
- var $regex_procedure_type = "^[[:space:]]*(void|IBAction)+[[:space:]]*$";
|
|
|
- var $regex_scope_compiler_directive = "^\s*@(private|protected|public)(;*)+\s*$";
|
|
|
- var $regex_objc_property = "^@property\((.*)\)[[:space:]]*(.*);";
|
|
|
-
|
|
|
- /**
|
|
|
- * TEMPLATES
|
|
|
- */
|
|
|
-
|
|
|
- // Template for implemented function
|
|
|
- var $template_implemented_function = "function [CLASS].implemented_[NAME][PARAMS_HEADER]: [RETURN];
|
|
|
-begin
|
|
|
- {\$ifdef NSOBJECT_AUTO_WRAPPER}
|
|
|
- Result := [RETURN](super_[NAME][PARAMS_BODY_WRAPPER]);
|
|
|
- {\$else}
|
|
|
- Result := [RETURN](super_[NAME][PARAMS_BODY]);
|
|
|
- {\$endif}
|
|
|
-end;";
|
|
|
-
|
|
|
- // Template for implemented procedure
|
|
|
- var $template_implemented_procedure = "procedure [CLASS].implemented_[NAME][PARAMS_HEADER];
|
|
|
-begin
|
|
|
- {\$ifdef NSOBJECT_AUTO_WRAPPER}
|
|
|
- super_[NAME][PARAMS_BODY_WRAPPER];
|
|
|
- {\$else}
|
|
|
- super_[NAME][PARAMS_BODY];
|
|
|
- {\$endif}
|
|
|
-end;";
|
|
|
-
|
|
|
- // Template for constructor
|
|
|
- var $template_constructor = "constructor [CLASS][NAME][PARAMS_HEADER];
|
|
|
-type
|
|
|
- TmsgSendWrapper = function (param1: id; param2: SEL[PARAMS_PROC]): id; cdecl;
|
|
|
-var
|
|
|
- vmethod: TmsgSendWrapper;
|
|
|
-begin
|
|
|
- if SEL_[SELNAME] = nil then
|
|
|
- SEL_[SELNAME] := sel_registerName(PChar('[OBJC_METHOD]'));
|
|
|
-
|
|
|
- RegisterSubClass;
|
|
|
- allocbuf := objc_msgSend(ClassID, SEL_alloc, []);
|
|
|
- vmethod := TmsgSendWrapper(@objc_msgSend);
|
|
|
- Handle := vmethod(allocbuf, SEL_[SELNAME][PARAMS_LIST_WRAPPER]);
|
|
|
- retainCount := 1;
|
|
|
- AssignSelf(Handle);
|
|
|
- AddMethods;
|
|
|
- BindMethods;
|
|
|
-end;";
|
|
|
-
|
|
|
- // Template for constructor that does not allocate memory
|
|
|
- var $template_constructor_no_alloc = "constructor [CLASS][NAME][PARAMS_HEADER];
|
|
|
-type
|
|
|
- TmsgSendWrapper = function (param1: id; param2: SEL[PARAMS_PROC]): id; cdecl;
|
|
|
-var
|
|
|
- vmethod: TmsgSendWrapper;
|
|
|
-begin
|
|
|
- if SEL_[SELNAME] = nil then
|
|
|
- SEL_[SELNAME] := sel_registerName(PChar('[OBJC_METHOD]'));
|
|
|
-
|
|
|
- RegisterSubClass;
|
|
|
- vmethod := TmsgSendWrapper(@objc_msgSend);
|
|
|
- Handle := vmethod(ClassID, SEL_[SELNAME][PARAMS_LIST_WRAPPER]);
|
|
|
- AutoReleaseObject;
|
|
|
- AssignSelf(Handle);
|
|
|
- AddMethods;
|
|
|
- BindMethods;
|
|
|
-end;";
|
|
|
-
|
|
|
- // Template for function to send Objective-c message that returns an auto-generated/memory managed wrapper object.
|
|
|
- var $template_function_make_wrapper = "function [CLASS][NAME][PARAMS_HEADER]: [RETURN];
|
|
|
-type
|
|
|
- TmsgSendWrapper = function (param1: id; param2: SEL[PARAMS_PROC]): [RETURN]; cdecl;
|
|
|
-var
|
|
|
- vmethod: TmsgSendWrapper;
|
|
|
- wrapper: [RETURN];
|
|
|
-begin
|
|
|
- vmethod := TmsgSendWrapper(@[MSG_SEND]);
|
|
|
- if SEL_[SELNAME] = nil then
|
|
|
- SEL_[SELNAME] := sel_registerName(PChar('[OBJC_METHOD]'));
|
|
|
-
|
|
|
- {\$ifdef NSOBJECT_AUTO_WRAPPER}
|
|
|
- Result := [RETURN](vmethod([OBJC_OBJECT], SEL_[SELNAME][PARAMS_LIST_WRAPPER]));
|
|
|
- {\$else}
|
|
|
- Result := [RETURN](vmethod([OBJC_OBJECT], SEL_[SELNAME][PARAMS_LIST]));
|
|
|
- {\$endif}
|
|
|
-
|
|
|
- {\$ifdef NSOBJECT_AUTO_WRAPPER}
|
|
|
- wrapper := [RETURN](GetWrapper(Result));
|
|
|
- if wrapper = nil then
|
|
|
- Result := [RETURN]([RETURN].CreateWithHandle(Pobjc_object(Result)).deferObject)
|
|
|
- else
|
|
|
- Result := wrapper;
|
|
|
- {\$endif}
|
|
|
-end;";
|
|
|
-
|
|
|
- var $template_function_make_wrapper_no_params = "function [CLASS][NAME]: [RETURN];
|
|
|
-var
|
|
|
- wrapper: [RETURN];
|
|
|
-begin
|
|
|
- if SEL_[SELNAME] = nil then
|
|
|
- SEL_[SELNAME] := sel_registerName(PChar('[OBJC_METHOD]'));
|
|
|
-
|
|
|
- Result := [RETURN]([MSG_SEND]([OBJC_OBJECT], SEL_[SELNAME], []));
|
|
|
-
|
|
|
- {\$ifdef NSOBJECT_AUTO_WRAPPER}
|
|
|
- wrapper := [RETURN](GetWrapper(Result));
|
|
|
- if wrapper = nil then
|
|
|
- Result := [RETURN]([RETURN].CreateWithHandle(Pobjc_object(Result)).deferObject)
|
|
|
- else
|
|
|
- Result := wrapper;
|
|
|
- {\$endif}
|
|
|
-end;";
|
|
|
-
|
|
|
- // Template for protocol function to send Objective-c message that returns an auto-generated/memory managed wrapper object.
|
|
|
- var $template_protocol_make_wrapper = "function [CLASS][NAME][PARAMS_HEADER]: [RETURN];
|
|
|
-type
|
|
|
- TmsgSendWrapper = function (param1: id; param2: SEL[PARAMS_PROC]): [RETURN]; cdecl;
|
|
|
-var
|
|
|
- vmethod: TmsgSendWrapper;
|
|
|
-begin
|
|
|
- vmethod := TmsgSendWrapper(@[MSG_SEND]);
|
|
|
- if SEL_[SELNAME] = nil then
|
|
|
- SEL_[SELNAME] := sel_registerName(PChar('[OBJC_METHOD]'));
|
|
|
-
|
|
|
- {\$ifdef NSOBJECT_AUTO_WRAPPER}
|
|
|
- Result := [RETURN](vmethod([OBJC_OBJECT], SEL_[SELNAME][PARAMS_LIST_WRAPPER]));
|
|
|
- {\$else}
|
|
|
- Result := [RETURN](vmethod([OBJC_OBJECT], SEL_[SELNAME][PARAMS_LIST]));
|
|
|
- {\$endif}
|
|
|
-
|
|
|
- {\$ifdef NSOBJECT_AUTO_WRAPPER}
|
|
|
- Result := [RETURN]([RETURN].CreateWithHandle(Pobjc_object(Result)).deferObject);
|
|
|
- {\$endif}
|
|
|
-end;";
|
|
|
-
|
|
|
- var $template_protocol_make_wrapper_no_params = "function [CLASS][NAME]: [RETURN];
|
|
|
-begin
|
|
|
- if SEL_[SELNAME] = nil then
|
|
|
- SEL_[SELNAME] := sel_registerName(PChar('[OBJC_METHOD]'));
|
|
|
- Result := [RETURN]([MSG_SEND]([OBJC_OBJECT], SEL_[SELNAME], []));
|
|
|
-
|
|
|
- {\$ifdef NSOBJECT_AUTO_WRAPPER}
|
|
|
- Result := [RETURN]([RETURN].CreateWithHandle(Pobjc_object(Result)).deferObject);
|
|
|
- {\$endif}
|
|
|
-end;";
|
|
|
-
|
|
|
- // Template for function to send Objective-c message
|
|
|
- var $template_function_objc_send = "function [CLASS][NAME][PARAMS_HEADER]: [RETURN];
|
|
|
-type
|
|
|
- TmsgSendWrapper = function (param1: [TARGET_TYPE]; param2: SEL[PARAMS_PROC]): [RETURN]; cdecl;
|
|
|
-var
|
|
|
- vmethod: TmsgSendWrapper;
|
|
|
- super: objc_super;
|
|
|
-begin
|
|
|
- vmethod := TmsgSendWrapper(@[MSG_SEND]);
|
|
|
- if SEL_[SELNAME] = nil then
|
|
|
- SEL_[SELNAME] := sel_registerName(PChar('[OBJC_METHOD]'));
|
|
|
-
|
|
|
- [GET_SUPER_CLASS]
|
|
|
- {\$ifdef NSOBJECT_AUTO_WRAPPER}
|
|
|
- Result := [RETURN](vmethod([OBJC_OBJECT], SEL_[SELNAME][PARAMS_LIST_WRAPPER]));
|
|
|
- {\$else}
|
|
|
- Result := [RETURN](vmethod([OBJC_OBJECT], SEL_[SELNAME][PARAMS_LIST]));
|
|
|
- {\$endif}
|
|
|
-end;";
|
|
|
-
|
|
|
- // Template for function to send Objective-c message (no params)
|
|
|
- var $template_function_objc_send_no_params = "function [CLASS][NAME]: [RETURN];
|
|
|
-var
|
|
|
- super: objc_super;
|
|
|
-begin
|
|
|
- if SEL_[SELNAME] = nil then
|
|
|
- SEL_[SELNAME] := sel_registerName(PChar('[OBJC_METHOD]'));
|
|
|
- [GET_SUPER_CLASS]
|
|
|
- Result := [RETURN]([MSG_SEND]([OBJC_OBJECT], SEL_[SELNAME], []));
|
|
|
-end;";
|
|
|
-
|
|
|
- // Template for function to send Objective-c message which returns a struct
|
|
|
- var $template_function_objc_send_struct = "function [CLASS][NAME][PARAMS_HEADER]: [RETURN];
|
|
|
-type
|
|
|
- TmsgSendWrapper = function (param1: [TARGET_TYPE]; param2: SEL[PARAMS_PROC]): [RETURN]; cdecl;
|
|
|
-var
|
|
|
- vmethod: TmsgSendWrapper;
|
|
|
- super: objc_super;
|
|
|
-begin
|
|
|
- if SEL_[SELNAME] = nil then
|
|
|
- SEL_[SELNAME] := sel_registerName(PChar('[OBJC_METHOD]'));
|
|
|
- vmethod := TmsgSendWrapper(@[MSG_SEND]);
|
|
|
- [GET_SUPER_CLASS]
|
|
|
- {\$ifdef NSOBJECT_AUTO_WRAPPER}
|
|
|
- Result := [RETURN](vmethod([OBJC_OBJECT], SEL_[SELNAME][PARAMS_LIST_WRAPPER]));
|
|
|
- {\$else}
|
|
|
- Result := [RETURN](vmethod([OBJC_OBJECT], SEL_[SELNAME][PARAMS_LIST]));
|
|
|
- {\$endif}
|
|
|
-end;";
|
|
|
-
|
|
|
- // Template for function to send Objective-c message which returns a struct
|
|
|
- var $template_function_objc_send_struct_cpu = "function [CLASS][NAME][PARAMS_HEADER]: [RETURN];
|
|
|
-type
|
|
|
- TmsgSendWrapper_reg = function (param1: [TARGET_TYPE]; param2: SEL[PARAMS_PROC]): [RETURN]; cdecl;
|
|
|
- TmsgSendWrapper_stret = function (param1: [TARGET_TYPE]; param2: SEL[PARAMS_PROC]): [RETURN]; cdecl;
|
|
|
-var
|
|
|
- vmethod_reg: TmsgSendWrapper_reg;
|
|
|
- vmethod_stret: TmsgSendWrapper_stret;
|
|
|
- super: objc_super;
|
|
|
-begin
|
|
|
- if SEL_[SELNAME] = nil then
|
|
|
- SEL_[SELNAME] := sel_registerName(PChar('[OBJC_METHOD]'));
|
|
|
- [GET_SUPER_CLASS]
|
|
|
- {\$ifdef CPUi386}
|
|
|
- vmethod_reg := TmsgSendWrapper_reg(@[MSG_SEND_REGISTER]);
|
|
|
- {\$ifdef NSOBJECT_AUTO_WRAPPER}
|
|
|
- Result := vmethod_reg([OBJC_OBJECT], SEL_[SELNAME][PARAMS_LIST_WRAPPER]);
|
|
|
- {\$else}
|
|
|
- Result := vmethod_reg([OBJC_OBJECT], SEL_[SELNAME][PARAMS_LIST]);
|
|
|
- {\$endif}
|
|
|
- {\$else}
|
|
|
- vmethod_stret := TmsgSendWrapper_stret(@[MSG_SEND_STRET]);
|
|
|
- {\$ifdef NSOBJECT_AUTO_WRAPPER}
|
|
|
- Result := [RETURN](vmethod_stret([OBJC_OBJECT], SEL_[SELNAME][PARAMS_LIST_WRAPPER]));
|
|
|
- {\$else}
|
|
|
- Result := [RETURN](vmethod_stret([OBJC_OBJECT], SEL_[SELNAME][PARAMS_LIST]));
|
|
|
- {\$endif}
|
|
|
- {\$endif}
|
|
|
-end;";
|
|
|
-
|
|
|
- // Template for function to send Objective-c message (no params) which returns a struct
|
|
|
- var $template_function_objc_send_no_params_struct = "function [CLASS][NAME]: [RETURN];
|
|
|
-var
|
|
|
- super: objc_super;
|
|
|
-begin
|
|
|
- if SEL_[SELNAME] = nil then
|
|
|
- SEL_[SELNAME] := sel_registerName(PChar('[OBJC_METHOD]'));
|
|
|
- [GET_SUPER_CLASS]
|
|
|
- [MSG_SEND](@Result, [OBJC_OBJECT], SEL_[SELNAME], []);
|
|
|
-end;";
|
|
|
-
|
|
|
- // Template for function to send Objective-c message (no params) which returns CPU dependent struct
|
|
|
- var $template_function_objc_send_no_params_struct_cpu = "function [CLASS][NAME]: [RETURN];
|
|
|
-type
|
|
|
- TmsgSendWrapper = function (param1: [TARGET_TYPE]; param2: SEL): [RETURN]; cdecl;
|
|
|
-var
|
|
|
- vmethod: TmsgSendWrapper;
|
|
|
- super: objc_super;
|
|
|
-begin
|
|
|
- if SEL_[SELNAME] = nil then
|
|
|
- SEL_[SELNAME] := sel_registerName(PChar('[OBJC_METHOD]'));
|
|
|
- [GET_SUPER_CLASS]
|
|
|
- {\$ifdef CPUi386}
|
|
|
- vmethod := TmsgSendWrapper(@[MSG_SEND_REGISTER]);
|
|
|
- Result := vmethod([OBJC_OBJECT], SEL_[SELNAME] );
|
|
|
- {\$else}
|
|
|
- [MSG_SEND_STRET](@Result, [OBJC_OBJECT], SEL_[SELNAME], []);
|
|
|
- {\$endif}
|
|
|
-end;";
|
|
|
-
|
|
|
- // Template for procedure to send Objective-c message
|
|
|
- var $template_procedure_objc_send = "procedure [CLASS][NAME][PARAMS_HEADER];
|
|
|
-type
|
|
|
- TmsgSendWrapper = procedure (param1: [TARGET_TYPE]; param2: SEL[PARAMS_PROC]); cdecl;
|
|
|
-var
|
|
|
- vmethod: TmsgSendWrapper;
|
|
|
- super: objc_super;
|
|
|
-begin
|
|
|
- if SEL_[SELNAME] = nil then
|
|
|
- SEL_[SELNAME] := sel_registerName(PChar('[OBJC_METHOD]'));
|
|
|
- vmethod := TmsgSendWrapper(@[MSG_SEND]);
|
|
|
- [GET_SUPER_CLASS]
|
|
|
- {\$ifdef NSOBJECT_AUTO_WRAPPER}
|
|
|
- vmethod([OBJC_OBJECT], SEL_[SELNAME][PARAMS_LIST_WRAPPER]);
|
|
|
- {\$else}
|
|
|
- vmethod([OBJC_OBJECT], SEL_[SELNAME][PARAMS_LIST]);
|
|
|
- {\$endif}
|
|
|
-end;";
|
|
|
-
|
|
|
- // Template for procedure to send Objective-c message
|
|
|
- var $template_procedure_objc_send_no_params = "procedure [CLASS][NAME];
|
|
|
-var
|
|
|
- super: objc_super;
|
|
|
-begin
|
|
|
- if SEL_[SELNAME] = nil then
|
|
|
- SEL_[SELNAME] := sel_registerName(PChar('[OBJC_METHOD]'));
|
|
|
- [GET_SUPER_CLASS]
|
|
|
- [MSG_SEND]([OBJC_OBJECT], SEL_[SELNAME], []);
|
|
|
-end;";
|
|
|
-
|
|
|
- // Template for procedure to call implemented class method. This is the procedure which the Objectice-c methods are sent to
|
|
|
- var $template_procedure_objc_wrapper = "procedure [CLASS]_[NAME](_self: id; _cmd: SEL[PARAMS_HEADER]); cdecl;
|
|
|
-var
|
|
|
- this: [CLASS];
|
|
|
- [VARIABLES]
|
|
|
-begin
|
|
|
- this := [CLASS]([CLASS].GetSelf(_self));
|
|
|
- if this <> nil then
|
|
|
- {\$ifdef NSOBJECT_AUTO_WRAPPER}
|
|
|
- begin
|
|
|
- [WRAPPERS_CREATE]
|
|
|
- this.implemented_[NAME][PARAMS_LIST_WRAPPER];
|
|
|
- [WRAPPERS_RELEASE]
|
|
|
- end;
|
|
|
- {\$else}
|
|
|
- this.implemented_[NAME][PARAMS_LIST];
|
|
|
- {\$endif}
|
|
|
-end;";
|
|
|
-
|
|
|
- // Template for procedure to call implemented class method. This is the procedure which the Objectice-c methods are sent to
|
|
|
- var $template_function_objc_wrapper = "function [CLASS]_[NAME](_self: id; _cmd: SEL[PARAMS_HEADER]): [RETURN]; cdecl;
|
|
|
-var
|
|
|
- this: [CLASS];
|
|
|
- [VARIABLES]
|
|
|
-begin
|
|
|
- this := [CLASS]([CLASS].GetSelf(_self));
|
|
|
- if this <> nil then
|
|
|
- {\$ifdef NSOBJECT_AUTO_WRAPPER}
|
|
|
- begin
|
|
|
- [WRAPPERS_CREATE]
|
|
|
- Result := [RETURN](this.implemented_[NAME][PARAMS_LIST_WRAPPER]);
|
|
|
- [WRAPPERS_RELEASE]
|
|
|
- end;
|
|
|
- {\$else}
|
|
|
- Result := [RETURN](this.implemented_[NAME][PARAMS_LIST]);
|
|
|
- {\$endif}
|
|
|
-end;";
|
|
|
-
|
|
|
-
|
|
|
- // Template for method to override Objective-c method
|
|
|
- var $template_method_override = "procedure [CLASS].override_[NAME];
|
|
|
-begin
|
|
|
- AddMethod('[OBJC_METHOD]', '[TYPE_ENCODING]', Pointer(@[CLASS]_[NAME]));
|
|
|
-end;";
|
|
|
-
|
|
|
- // Template for method to override Objective-c method
|
|
|
- var $template_method_override_DEPRECATED = "procedure [CLASS].override_[NAME];
|
|
|
-begin
|
|
|
- OverrideMethod('[OBJC_METHOD]', Pointer(@[CLASS]_[NAME]));
|
|
|
-end;";
|
|
|
-
|
|
|
- // Template for method to add method to Objective-c runtime
|
|
|
- var $template_method_add_runtime = "procedure [CLASS].add_[NAME];
|
|
|
-begin
|
|
|
- AddMethod('[OBJC_METHOD]', '[TYPES]', Pointer(@[CLASS]_[NAME]));
|
|
|
-end;";
|
|
|
-
|
|
|
- // Template for implemented delegate procedure
|
|
|
- var $template_procedure_delegate = "procedure [CLASS].[NAME][PARAMS];
|
|
|
-begin
|
|
|
-end;";
|
|
|
-
|
|
|
- // Template for implemented delegate procedure
|
|
|
- var $template_function_delegate = "function [CLASS].[NAME][PARAMS]: [RETURN];
|
|
|
-begin
|
|
|
-end;";
|
|
|
-
|
|
|
-
|
|
|
- // Template for implemented delegate procedure
|
|
|
- var $template_procedure_delegate_objc = "procedure [CLASS]_[NAME][PARAMS_HEADER]; cdecl;
|
|
|
-var
|
|
|
- this: [CLASS];
|
|
|
- [VARIABLES]
|
|
|
-begin
|
|
|
- this := [CLASS]([CLASS].GetSelf(_self));
|
|
|
- if this <> nil then
|
|
|
- {\$ifdef NSOBJECT_AUTO_WRAPPER}
|
|
|
- begin
|
|
|
- [WRAPPERS_CREATE]
|
|
|
- this.[NAME][PARAMS_LIST_WRAPPER];
|
|
|
- [WRAPPERS_RELEASE]
|
|
|
- end;
|
|
|
- {\$else}
|
|
|
- this.[NAME][PARAMS_LIST];
|
|
|
- {\$endif}
|
|
|
-end;";
|
|
|
-
|
|
|
- // Template for implemented delegate procedure
|
|
|
- var $template_function_delegate_objc = "function [CLASS]_[NAME][PARAMS_HEADER]: [RETURN]; cdecl;
|
|
|
-var
|
|
|
- this: [CLASS];
|
|
|
- [VARIABLES]
|
|
|
-begin
|
|
|
- this := [CLASS]([CLASS].GetSelf(_self));
|
|
|
- if this <> nil then
|
|
|
- {\$ifdef NSOBJECT_AUTO_WRAPPER}
|
|
|
- begin
|
|
|
- [WRAPPERS_CREATE]
|
|
|
- Result := [RETURN](this.[NAME][PARAMS_LIST_WRAPPER]);
|
|
|
- [WRAPPERS_RELEASE]
|
|
|
- end;
|
|
|
- {\$else}
|
|
|
- Result := [RETURN](this.[NAME][PARAMS_LIST]);
|
|
|
- {\$endif}
|
|
|
-end;";
|
|
|
-
|
|
|
- // Template for create override in delegate class
|
|
|
- var $template_delegate_create = "constructor [CLASS].Create;
|
|
|
-begin
|
|
|
- CreateClassDefinition(ClassName, 'NSObject');
|
|
|
-
|
|
|
- ClassID := objc_getClass('[CLASS]');
|
|
|
- allocbuf := objc_msgSend(ClassId, SEL_alloc, []);
|
|
|
- Handle := objc_msgSend(allocbuf, SEL_init, []);
|
|
|
- retainCount := 1;
|
|
|
-
|
|
|
- { Adds custom methods, if any }
|
|
|
- AddMethods;
|
|
|
- BindMethods;
|
|
|
-
|
|
|
- { Assign our wrapper instance }
|
|
|
- if Handle <> nil then
|
|
|
- AssignSelf(Handle);
|
|
|
-end;";
|
|
|
-
|
|
|
- // Template for constructor
|
|
|
- var $template_constructor_constarray = "constructor [CLASS][NAME][PARAMS_HEADER];
|
|
|
-type
|
|
|
- TmsgSendWrapper = function (param1: id; param2: SEL; param3: [CFTYPE]): id; cdecl;
|
|
|
-var
|
|
|
- vmethod: TmsgSendWrapper;
|
|
|
- paramList: [CFTYPE];
|
|
|
- i: integer;
|
|
|
-begin
|
|
|
- if SEL_[SELNAME] = nil then
|
|
|
- SEL_[SELNAME] := sel_registerName(PChar('[OBJC_METHOD]'));
|
|
|
- RegisterSubClass;
|
|
|
- [ALLOC_PARAM_LIST]
|
|
|
- allocbuf := objc_msgSend(ClassID, SEL_alloc, []);
|
|
|
- vmethod := TmsgSendWrapper(@objc_msgSend);
|
|
|
- Handle := vmethod(allocbuf, SEL_[SELNAME], paramList);
|
|
|
- retainCount := 1;
|
|
|
- AssignSelf(Handle);
|
|
|
- AddMethods;
|
|
|
- BindMethods;
|
|
|
- CFRelease(paramList);
|
|
|
-end;";
|
|
|
-
|
|
|
- // Template for constructor that does not allocate memory
|
|
|
- var $template_constructor_constarray_no_alloc = "constructor [CLASS][NAME][PARAMS_HEADER];
|
|
|
-type
|
|
|
- TmsgSendWrapper = function (param1: id; param2: SEL; param3: [CFTYPE]): id; cdecl;
|
|
|
-var
|
|
|
- vmethod: TmsgSendWrapper;
|
|
|
- paramList: [CFTYPE];
|
|
|
- i: integer;
|
|
|
-begin
|
|
|
- if SEL_[SELNAME] = nil then
|
|
|
- SEL_[SELNAME] := sel_registerName(PChar('[OBJC_METHOD]'));
|
|
|
- RegisterSubClass;
|
|
|
- [ALLOC_PARAM_LIST]
|
|
|
- vmethod := TmsgSendWrapper(@objc_msgSend);
|
|
|
- Handle := vmethod(ClassID, SEL_[SELNAME], paramList);
|
|
|
- AutoReleaseObject;
|
|
|
- AssignSelf(Handle);
|
|
|
- AddMethods;
|
|
|
- BindMethods;
|
|
|
- CFRelease(paramList);
|
|
|
-end;";
|
|
|
-
|
|
|
- // template to create param list for NSDictionary methods
|
|
|
- var $template_dictionary_param_list = "paramList := CFDictionaryCreateMutable(nil, 0, @kCFTypeDictionaryKeyCallBacks, @kCFTypeDictionaryValueCallBacks);
|
|
|
- i := High(firstObject);
|
|
|
- while i > 0 do
|
|
|
- begin
|
|
|
- CFDictionaryAddValue(paramList, firstObject[i].VPointer, firstObject[i - 1].VPointer);
|
|
|
- i := i - 2;
|
|
|
- end;";
|
|
|
-
|
|
|
- // template to create param list for NSArray methods
|
|
|
- var $template_array_param_list = "paramList := CFArrayCreateMutable(nil, 0, @kCFTypeArrayCallBacks);
|
|
|
- for i := 0 to High(firstObj) do
|
|
|
- CFArrayAppendValue(paramList, firstObj[i].VPointer);";
|
|
|
-
|
|
|
- // template to create param list for NSSet methods
|
|
|
- var $template_set_param_list = "paramList := CFSetCreateMutable(nil, 0, @kCFTypeSetCallBacks);
|
|
|
- for i := 0 to High(firstObj) do
|
|
|
- CFSetAddValue(paramList, firstObj[i].VPointer);";
|
|
|
-
|
|
|
- /**
|
|
|
- * UTILITIES
|
|
|
- */
|
|
|
-
|
|
|
- // Skips blocks in the current file being parsed
|
|
|
- function SkipBlock ($line) {
|
|
|
-
|
|
|
- if ($line != "") {
|
|
|
- foreach ($this->skip_blocks as $key => $value) {
|
|
|
- if (@ereg($key, $line)) $this->parser_skipping = true;
|
|
|
- if (@ereg($value, $line)) $this->parser_skipping = false;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- return $this->parser_skipping;
|
|
|
- }
|
|
|
-
|
|
|
- function IsKeywordReserved($keyword) {
|
|
|
- $keyword = strtolower($keyword);
|
|
|
- if (in_array($keyword, $this->reserved_keywords)) return true;
|
|
|
- }
|
|
|
-
|
|
|
- // Replace type with pointer equivalent
|
|
|
- function ReplacePointerType ($type) {
|
|
|
-
|
|
|
- $type = "Pointer {".$type."}";
|
|
|
- /*
|
|
|
- foreach ($this->pointer_types as $objc_type => $replace_type) {
|
|
|
- if ($objc_type == $type) {
|
|
|
- $type = $replace_type;
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
- */
|
|
|
- return $type;
|
|
|
- }
|
|
|
-
|
|
|
- // Makes a struct field into an inline array (or returns field un-changed)
|
|
|
- function MakeFieldInlineArray ($io_field, $line, $name, $type) {
|
|
|
-
|
|
|
- if (eregi("\[([0-9]+)\];", $line, $array_size)) {
|
|
|
- $length = (int)$array_size[1] - 1;
|
|
|
- if ($length > 0) {
|
|
|
- $io_field = " $name: array[0..$length] of $type;";
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- return $io_field;
|
|
|
- }
|
|
|
-
|
|
|
- // Makes a type bitpacked (or returns type un-changed)
|
|
|
- function MakeFieldBitPacked ($ioType, $field, &$bitpacked) {
|
|
|
- $bitpacked = false;
|
|
|
-
|
|
|
- if (eregi(":([0-9]+);$", $field, $bitpack)) {
|
|
|
- $length = (int)$bitpack[1];
|
|
|
- if ($length > 1) {
|
|
|
- $ioType = "0..((1 shl $length)-1)";
|
|
|
- } else {
|
|
|
- $ioType = "0..$length";
|
|
|
- }
|
|
|
-
|
|
|
- $bitpacked = true;
|
|
|
- }
|
|
|
-
|
|
|
- return $ioType;
|
|
|
- }
|
|
|
-
|
|
|
- // Replace objc type with preferred type
|
|
|
- function ReplaceObjcType ($type) {
|
|
|
-
|
|
|
- foreach ($this->replace_types as $objc_type => $replace_type) {
|
|
|
- if ($objc_type == $type) {
|
|
|
- $type = $replace_type;
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- return $type;
|
|
|
- }
|
|
|
-
|
|
|
- // Exchanges the preferred objc type with the real type
|
|
|
- function SwapObjcTypeWithReal ($type) {
|
|
|
- if ($type == $this->objc_id) $type = $this->objc_id_real;
|
|
|
-
|
|
|
- return $type;
|
|
|
- }
|
|
|
-
|
|
|
- // Replace garbage collector hints
|
|
|
- function ReplaceGarbageCollectorHints ($string, &$io_hint) {
|
|
|
- $io_hint = false;
|
|
|
-
|
|
|
- foreach ($this->garbage_collector_hints as $hint) {
|
|
|
- $out_string = str_ireplace($hint, "", $string);
|
|
|
- if ($out_string != $string) {
|
|
|
- $io_hint = $hint;
|
|
|
- $string = $out_string;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- return $string;
|
|
|
- }
|
|
|
-
|
|
|
-
|
|
|
- // Replace type of reference parameter with pointer
|
|
|
- function ReplaceReferenceParameterType ($type) {
|
|
|
- foreach ($this->pointer_types as $key => $value) {
|
|
|
- if ($key == $type) {
|
|
|
- $found = true;
|
|
|
- $type = $value;
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- if (!$found) $type = $type."Pointer";
|
|
|
-
|
|
|
- return $type;
|
|
|
- }
|
|
|
-
|
|
|
- // Replace NS*** "toll free bridge" types with CoreFoundation type
|
|
|
- function ReplaceTollFreeBridgeType ($type) {
|
|
|
- foreach ($this->toll_free_bridge as $objc_type => $replace_type) {
|
|
|
- if ($objc_type == $type) {
|
|
|
- $type = istr_replace_word($type, $replace_type, $type);
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- return $type;
|
|
|
- }
|
|
|
-
|
|
|
- // Replace all NS*** classes in a string with the preffered generic type $this->objc_id
|
|
|
- function ReplaceNSTypes ($string) {
|
|
|
- foreach ($this->cocoa_classes as $class) {
|
|
|
- $string = istr_replace_word($class, $this->objc_id, $string);
|
|
|
- }
|
|
|
- return $string;
|
|
|
- }
|
|
|
-
|
|
|
- // Replace all NS*** classes in a string with id
|
|
|
- function ReplaceNSTypesWithReal ($string) {
|
|
|
- foreach ($this->cocoa_classes as $class) {
|
|
|
- $string = istr_replace_word($class, $this->objc_id_real, $string);
|
|
|
- }
|
|
|
- return $string;
|
|
|
- }
|
|
|
-
|
|
|
- // Replace all NS*** classes in a string with their reference equivalent (i.e NSStringRef = id)
|
|
|
- function ReplaceNSTypesWithRef ($string) {
|
|
|
- foreach ($this->cocoa_classes as $class) {
|
|
|
- $string = istr_replace_word($class, $class."Ref", $string);
|
|
|
- }
|
|
|
- return $string;
|
|
|
- }
|
|
|
-
|
|
|
- // Copies the name from an Objective-C method definition
|
|
|
- function CopyObjcMethodName ($method) {
|
|
|
-
|
|
|
- // cut out comments first
|
|
|
- $method = eregi_replace("(/\*.*\*/)", "", $method);
|
|
|
- $method = eregi_replace("//.*$", "", $method);
|
|
|
- $method = trim($method, " ");
|
|
|
-
|
|
|
- $params = explode(":", $method);
|
|
|
- $name = "";
|
|
|
-
|
|
|
- if (count($params) > 1) {
|
|
|
- foreach ($params as $value) {
|
|
|
- $value = trim($value, " ");
|
|
|
- if (eregi("([a-zA-Z0-9_]+)$", $value, $captures)) $name .= $captures[1].":";
|
|
|
- }
|
|
|
- } else {
|
|
|
- if (eregi("([a-zA-Z0-9_]+)[[:space:]]*(;)*$", $method, $captures)) $name = $captures[1];
|
|
|
- }
|
|
|
-
|
|
|
- return $name;
|
|
|
- }
|
|
|
-
|
|
|
- // Converts a function pointer to Pascal function
|
|
|
- function ConvertFunctionPointerToPascal ($result, $param_string) {
|
|
|
-
|
|
|
- if ($result != "") {
|
|
|
- $params = explode(",", $param_string);
|
|
|
- $function = "function (";
|
|
|
- $count = 0;
|
|
|
-
|
|
|
- foreach ($params as $param) {
|
|
|
- $count ++;
|
|
|
- $param = trim($param, " ");
|
|
|
- $param = $this->ReplaceObjcType($param);
|
|
|
- $param = $this->SwapObjcTypeWithReal($param);
|
|
|
- $param = trim($param, "*");
|
|
|
-
|
|
|
- $function .= "param$count: $param; ";
|
|
|
- }
|
|
|
-
|
|
|
- $function = rtrim($function, "; ");
|
|
|
- $function .= "): $result; cdecl;";
|
|
|
- }
|
|
|
-
|
|
|
- //print("$function\n");
|
|
|
- return $function;
|
|
|
- }
|
|
|
-
|
|
|
- // Converts a C parameter string to Pascal
|
|
|
- function ConvertCParamsPascal ($string) {
|
|
|
-
|
|
|
- $params = explode(",", $string);
|
|
|
- $param_string = "";
|
|
|
-
|
|
|
- foreach ($params as $param) {
|
|
|
-
|
|
|
- $param = istr_replace_word("const", "", $param);
|
|
|
- $param = trim($param, " ");
|
|
|
-
|
|
|
- $pair = explode(" ", $param);
|
|
|
- $name = $pair[1];
|
|
|
- $type = $pair[0];
|
|
|
-
|
|
|
- $type = $this->ReplaceObjcType($type);
|
|
|
- $type = $this->SwapObjcTypeWithReal($type);
|
|
|
- $type = $this->ReplaceTollFreeBridgeType($type);
|
|
|
- $type = $this->ReplaceNSTypesWithRef($type);
|
|
|
-
|
|
|
- if (($name[0] == "*") && ($name[1] == "*")) {
|
|
|
- $name = trim($name, "*");
|
|
|
- $type = $this->ReplacePointerType($type);
|
|
|
- } elseif ($name[0] == "*") {
|
|
|
- $name = trim($name, "*");
|
|
|
-
|
|
|
- $name = $name."Pointer";
|
|
|
- //$name = "var $name";
|
|
|
-
|
|
|
- $name = trim($name, " ");
|
|
|
- } else {
|
|
|
- $name = trim($name, "*");
|
|
|
- }
|
|
|
-
|
|
|
- // Remove array brackets (NSUInteger[])p
|
|
|
- if (eregi("\[[0-9]*\]", $name)) {
|
|
|
- $name = "$name";
|
|
|
- $type = "Pointer {array of $type}";
|
|
|
- $name = eregi_replace("\[[0-9]*\]", "", $name);
|
|
|
- }
|
|
|
-
|
|
|
- if ($this->IsKeywordReserved($name)) $name .= "_";
|
|
|
-
|
|
|
- // multiple parameters
|
|
|
- if ($type == "...") {
|
|
|
- $param_string .= "varargs: array of const";
|
|
|
- break;
|
|
|
- }
|
|
|
-
|
|
|
- $param_string .= "$name: $type; ";
|
|
|
- }
|
|
|
-
|
|
|
- $param_string = trim($param_string, "; ");
|
|
|
- return $param_string;
|
|
|
- }
|
|
|
-
|
|
|
- // Remove OS X versions macros from a line
|
|
|
- // NOTE: These should be re-inlcuded in Pascal
|
|
|
- function RemoveOSVersionMacros ($line) {
|
|
|
- $line = eregi_replace("[[:space:]]*AVAILABLE_MAC_OS_X_VERSION_[0-9]+_[0-9]+_AND_LATER[[:space:]]*", "", $line);
|
|
|
- return $line;
|
|
|
- }
|
|
|
-
|
|
|
- // Removes all comments from a line
|
|
|
- function RemoveComments ($line) {
|
|
|
- // remove single-line comments
|
|
|
- $line = eregi_replace("[[:space:]]+//(.*)", "", $line);
|
|
|
-
|
|
|
- // remove multi-line comments /* ... */
|
|
|
- $line = eregi_replace("/\*.*\*/", "", $line);
|
|
|
-
|
|
|
- return $line;
|
|
|
- }
|
|
|
-
|
|
|
- // Performs additional formatting on Objective-c type i.e. (out NSObject **)
|
|
|
- function FormatObjcType ($type, &$modifiers) {
|
|
|
- $modifiers = "";
|
|
|
-
|
|
|
- // toss out all const identifiers
|
|
|
- $type = istr_replace_word("const", "", $type);
|
|
|
-
|
|
|
- // replace inout paramaters
|
|
|
- $type = istr_replace_word("inout", "", $type);
|
|
|
- $type = istr_replace_word("out", "", $type);
|
|
|
- $type_clean = trim($type, "* ");
|
|
|
-
|
|
|
- // Replace types before cleaning
|
|
|
- $type = $this->ReplaceObjcType($type);
|
|
|
-
|
|
|
- // Remove protocol which type conforms to (id <NSURLHandleClient>)
|
|
|
- $type = eregi_replace("<.*>", "", $type);
|
|
|
-
|
|
|
- // Remove array brackets (NSUInteger[])p
|
|
|
- $type = eregi_replace("\[[0-9]*\]", "", $type);
|
|
|
-
|
|
|
- // var params to non-object types (NSRange *)
|
|
|
- if (ereg("([a-zA-Z0-9_]+)[[:space:]]*[*]+$", $type, $captures)) {
|
|
|
- if ((!in_array($captures[1], $this->cocoa_classes)) && ($captures[1] != "id")) {
|
|
|
- $type = $this->ReplaceReferenceParameterType($type_clean); //"$type_clean$this->pointer_type_suffx";
|
|
|
- //$modifiers = "var ";
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- // Handle NS*** pointers (NSError **)
|
|
|
- if (ereg("(NS[a-zA-Z0-9_]+)[[:space:]]*\*\*$", $type, $captures)) {
|
|
|
- if (in_array($captures[1], $this->cocoa_classes)) {
|
|
|
- $type = "$type_clean$this->class_pointer_suffix";
|
|
|
- //$modifiers = "var ";
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- // clean the type
|
|
|
- $type = trim($type, "* ");
|
|
|
-
|
|
|
- //print("$type\n");
|
|
|
- return $type;
|
|
|
- }
|
|
|
-
|
|
|
- // Performs additional formatting on Objective-c parameter types
|
|
|
- function FormatObjcParams ($string) {
|
|
|
- $params = explode(":", $string);
|
|
|
- $string = "";
|
|
|
-
|
|
|
- if (count($params) > 0) {
|
|
|
- foreach ($params as $value) {
|
|
|
- if (ereg("\((.*)\)", $value, $captures)) {
|
|
|
- $new_value = $this->ReplaceObjcType($captures[1]);
|
|
|
-
|
|
|
- if ($new_value != $captures[1]) $value = ereg_replace("\((.*)\)", "($new_value)", $value);
|
|
|
-
|
|
|
- $string .= ":$value";
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- $string = ltrim($string, ":");
|
|
|
- //print("$string\n");
|
|
|
- return $string;
|
|
|
- }
|
|
|
-
|
|
|
- // Converts an Objective-c parameter string to Pascal
|
|
|
- function ConvertObjcParamsToPascal ($string, $protected_keywords, &$variable_arguments) {
|
|
|
- $params = explode(":", $string);
|
|
|
- $list = array();
|
|
|
- $list["pairs"] = array();
|
|
|
- $param_list = array();
|
|
|
- $variable_arguments = false;
|
|
|
-
|
|
|
- if (count($params) > 0) {
|
|
|
- //print_r($params);
|
|
|
- foreach ($params as $value) {
|
|
|
- $value = trim($value);
|
|
|
- $valid = false;
|
|
|
- $modifiers = "";
|
|
|
-
|
|
|
- // function pointer (callback)
|
|
|
- if (eregi("\(([a-zA-Z0-9_]+)[[:space:]]\((.*)\)\((.*)\)\)([a-zA-Z0-9_]+)", $value, $captures)) {
|
|
|
- $name = $captures[4];
|
|
|
-
|
|
|
- $type = $this->current_header["name_clean"].ucwords($name);
|
|
|
-
|
|
|
- // attempt to build a function pointer from the parameter and append the class type
|
|
|
- if ($this->current_header) {
|
|
|
- $function_pointer = $this->ConvertFunctionPointerToPascal($captures[1], $captures[3]);
|
|
|
-
|
|
|
- if (!@in_array($function_pointer, $this->current_header["types"]["callbacks"])) {
|
|
|
- $count = 0;
|
|
|
- while (@array_key_exists($type, $this->current_header["types"]["callbacks"])) {
|
|
|
- $count ++;
|
|
|
- $type = "$type$count";
|
|
|
- }
|
|
|
-
|
|
|
- // append the new type to the the current class
|
|
|
- $this->current_header["types"]["callbacks"][$type] = $function_pointer;
|
|
|
- } else {
|
|
|
- // Use the name of the existing callback of matching type
|
|
|
- $type = array_search($function_pointer, $this->current_header["types"]["callbacks"]);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- $valid = true;
|
|
|
- } elseif (eregi("\(([a-zA-Z_]+).*\)([a-zA-Z_]+).*\.\.\.", $value, $captures)) { // variable arguments
|
|
|
- $name = $captures[2];
|
|
|
- $type = $captures[1];
|
|
|
- $variable_arguments = true;
|
|
|
- $valid = true;
|
|
|
- } elseif (eregi("\((.*)\)[[:space:]]*([a-zA-Z_]+)", $value, $captures)) { // standard parameter
|
|
|
-
|
|
|
- // pointers params to non-object types (NSRange *)
|
|
|
- if (ereg("[a-zA-Z0-9_]+Ptr$", $captures[2])) {
|
|
|
- $captures[1] = trim($captures[1], "* ");
|
|
|
- $captures[1] = $this->ReplaceObjcType($captures[1]);
|
|
|
-
|
|
|
- $type = $captures[1].$this->class_pointer_suffix;//$this->ReplacePointerType($captures[1]);
|
|
|
- $name = $captures[2];
|
|
|
- } else {
|
|
|
- $type = $this->FormatObjcType($captures[1], $modifiers);
|
|
|
- $name = $captures[2];
|
|
|
- }
|
|
|
-
|
|
|
-
|
|
|
- $valid = true;
|
|
|
- }
|
|
|
-
|
|
|
- if ($valid) {
|
|
|
-
|
|
|
- // protect reserved keywords
|
|
|
- if ($this->IsKeywordReserved($name)) $name .= "_";
|
|
|
-
|
|
|
- if (!in_array($type, $this->reserved_types)) {
|
|
|
- if ($this->IsKeywordReserved($type)) $type .= "_";
|
|
|
- }
|
|
|
-
|
|
|
- if (@in_array($name, $protected_keywords)) $name .= "_";
|
|
|
- if (@in_array($type, $protected_keywords)) $type .= "_";
|
|
|
-
|
|
|
- // replace objc types
|
|
|
- $type = $this->ReplaceObjcType($type);
|
|
|
- $type = $this->ReplaceTollFreeBridgeType($type);
|
|
|
-
|
|
|
- // make sure we label duplicate params, which are allowed in Objective-C
|
|
|
- while (in_array($name, $param_list)) {
|
|
|
- $count ++;
|
|
|
- $name = "$name$count";
|
|
|
- }
|
|
|
-
|
|
|
- // id is always a wrapper
|
|
|
- if (($this->objects_are_wrappers) && ($type == $this->objc_id)) {
|
|
|
- $name_list = "$type(GetHandle($name))";
|
|
|
- } else {
|
|
|
- $name_list = $name;
|
|
|
- }
|
|
|
-
|
|
|
- // add modifiers to the name if there are any
|
|
|
- $name_with_modifiers = $modifiers.$name;
|
|
|
-
|
|
|
- // create pair array
|
|
|
- $pair["name"] = $name;
|
|
|
- $pair["type"] = $type;
|
|
|
-
|
|
|
- // append list
|
|
|
- $list["pairs"][] = $pair;
|
|
|
- $list["string_with_modifiers"] .= "$name_with_modifiers: $type; ";
|
|
|
- $list["string"] .= "$name: $type; ";
|
|
|
- $list["list"] .= "$name_list, ";
|
|
|
- $param_list[] = $name;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- // clean up the strings
|
|
|
- $list["string"] = trim($list["string"], "; ");
|
|
|
- $list["string_with_modifiers"] = trim($list["string_with_modifiers"], "; ");
|
|
|
- $list["list"] = trim($list["list"], ", ");
|
|
|
-
|
|
|
- return $list;
|
|
|
- }
|
|
|
-
|
|
|
- // Converts an Objective-c method name to Pascal
|
|
|
- function ConvertObjcMethodName ($method) {
|
|
|
- $params = explode(":", $method);
|
|
|
- $name = "";
|
|
|
-
|
|
|
- if (count($params) > 1) {
|
|
|
- foreach ($params as $value) {
|
|
|
- if (eregi("([a-zA-Z0-9]+)$", $value, $captures)) $name .= $captures[1]."_";
|
|
|
- }
|
|
|
- } else {
|
|
|
- if (eregi("([a-zA-Z0-9]+)(;)*$", $params[0], $captures)) $name .= $captures[1]."_";
|
|
|
- }
|
|
|
-
|
|
|
- // clean it up
|
|
|
- if (!$this->trailing_underscore) $name = trim($name, "_");
|
|
|
-
|
|
|
- $name = $this->ReplaceObjcType($name);
|
|
|
-
|
|
|
- return $name;
|
|
|
- }
|
|
|
-
|
|
|
- // Converts an Objective-C method to Pascal format
|
|
|
- function ConvertObjcMethodToPascal ($class, $source, $parts, $protected_keywords, $has_params) {
|
|
|
-
|
|
|
- // replace "hinted" params comment with hinted type
|
|
|
- if ($this->replace_hinted_params) {
|
|
|
-
|
|
|
- // param string
|
|
|
- if (eregi("(/\*[[:space:]]*(.*)[[:space:]]*\*/)", $parts[4], $captures)) {
|
|
|
- // ??? change the parameter to the hinted type
|
|
|
- //$parts[4] = eregi_replace("(/\*.*\*/)", $captures[2], $parts[4]);
|
|
|
- //$parts[4] = trim($parts[4], " ");
|
|
|
- }
|
|
|
-
|
|
|
- // return type
|
|
|
- if (eregi("(/\*[[:space:]]*(.*)[[:space:]]*\*/)", $parts[2], $captures)) $parts[2] = $captures[2];
|
|
|
-
|
|
|
- //print_r($parts);
|
|
|
-
|
|
|
- } else { // remmove comments from params and return type
|
|
|
- $parts[4] = eregi_replace("(/\*.*\*/)", "", $parts[4]);
|
|
|
- $parts[4] = trim($parts[4], " ");
|
|
|
-
|
|
|
- $parts[2] = eregi_replace("(/\*.*\*/)", "", $parts[2]);
|
|
|
- $parts[2] = trim($parts[2], " ");
|
|
|
- }
|
|
|
-
|
|
|
- $return_type_clean = $parts[2];
|
|
|
-
|
|
|
- // perform preformatting before attempting to protect keywords
|
|
|
- $parts[2] = $this->FormatObjcType($parts[2], $modifiers);
|
|
|
- $parts[4] = $this->FormatObjcParams($parts[4]);
|
|
|
-
|
|
|
- // protect keywords in the parameter and return type
|
|
|
- if (count($protected_keywords) > 0) {
|
|
|
- foreach ($protected_keywords as $keyword) {
|
|
|
- $parts[4] = istr_replace_word($keyword, $keyword."_", $parts[4]);
|
|
|
- $parts[2] = istr_replace_word($keyword, $keyword."_", $parts[2]);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- if ($has_params) {
|
|
|
- $name = $this->ConvertObjcMethodName($source);
|
|
|
-
|
|
|
- // merge default protected keywords for the class/category
|
|
|
- if ($this->default_protected["*"]) $protected_keywords = array_merge($this->default_protected["*"], $protected_keywords);
|
|
|
- if ($this->default_protected[$class]) $protected_keywords = array_merge($this->default_protected[$class], $protected_keywords);
|
|
|
-
|
|
|
- $param_array = $this->ConvertObjcParamsToPascal($parts[4], $protected_keywords, $variable_arguments);
|
|
|
- $params = "(".$param_array["string"].")";
|
|
|
- $params_with_modifiers = "(".$param_array["string_with_modifiers"].")";
|
|
|
- } else {
|
|
|
- $params = "";
|
|
|
- $params_with_modifiers = "";
|
|
|
- $name = $parts[3];
|
|
|
- $param_array = null;
|
|
|
- }
|
|
|
-
|
|
|
- //print("$params_with_modifiers\n");
|
|
|
-
|
|
|
- // protect method name from keywords
|
|
|
- if ($this->IsKeywordReserved($name)) $name .= "_";
|
|
|
-
|
|
|
- // clean return type
|
|
|
- $return_type = trim($parts[2], "* ");
|
|
|
- $return_type = $this->ReplaceObjcType($return_type);
|
|
|
- $return_type = $this->ReplaceTollFreeBridgeType($return_type);
|
|
|
-
|
|
|
- $virtual = "";
|
|
|
- $class_prefix = "";
|
|
|
-
|
|
|
- // determine the type based on return value
|
|
|
- if (ereg($this->regex_procedure_type, $return_type_clean)) {
|
|
|
- $kind = "procedure";
|
|
|
- } else {
|
|
|
- $kind = "function";
|
|
|
-
|
|
|
- // make sure Objective-c objects that are returned from fuctions are not NSObject (and thus auto-wrapped)
|
|
|
- if ($return_type == $this->objc_id) $return_type = $this->objc_id_real;
|
|
|
-
|
|
|
- // method name starts with "init or alloc"
|
|
|
- if ((ereg("^(init|alloc)+[^ialization]", $name)) && ($parts[1] == "-")) {
|
|
|
- $struct["alloc"] = true;
|
|
|
- $kind = "constructor";
|
|
|
- $virtual = " virtual;";
|
|
|
- }
|
|
|
-
|
|
|
- // Class methods with the words: With, By or From in the name
|
|
|
- if ((ereg("^([a-zA-Z]+)(With|By|From)+", $name, $captures)) && ($parts[1] == "+")) $kind = "constructor";
|
|
|
-
|
|
|
- // Class methods which return "id" are constructors
|
|
|
- if (($parts[1] == "+") && ($return_type == $this->objc_id_real)) $kind = "constructor";
|
|
|
-
|
|
|
- // method result is the class name
|
|
|
- if ($return_type == $class) $kind = "constructor";
|
|
|
- }
|
|
|
-
|
|
|
- // determine if this is a class method
|
|
|
- if (($kind != "constructor") && ($parts[1] == "+")) $class_prefix = "class ";
|
|
|
-
|
|
|
- // Determine if the method needs a particular modifier
|
|
|
- // ??? THIS IS NOT COMPILING???
|
|
|
- //if (ereg($this->objc_object_array, $params)) $modifier = " cdecl;";
|
|
|
-
|
|
|
- // Replace SEL with the string equivalent
|
|
|
- if ($this->register_selectors) {
|
|
|
- $params_with_modifiers = str_replace_word("SEL", $this->sel_string, $params_with_modifiers);
|
|
|
- }
|
|
|
-
|
|
|
- // make method templates
|
|
|
- if ($kind != "function") {
|
|
|
- $method = "$class_prefix$kind $name$params_with_modifiers;$modifier$virtual";
|
|
|
- $method_template = "[KIND] [PREFIX]$name"."[PARAMS];$modifier";
|
|
|
- } else {
|
|
|
- $method = $class_prefix."function $name$params_with_modifiers: $return_type;$modifier$virtual";
|
|
|
- $method_template = "[KIND] [PREFIX]$name"."[PARAMS]: [RETURN];$modifier";
|
|
|
- $method_template_function = "function [PREFIX]$name"."[PARAMS]: [RETURN];$modifier";
|
|
|
- }
|
|
|
-
|
|
|
- $method_template_procedure = "procedure [PREFIX]$name"."[PARAMS];$modifier";
|
|
|
- $method_template_function = "function [PREFIX]$name"."[PARAMS]: [RETURN];$modifier";
|
|
|
-
|
|
|
- // ??? DEBUGGING
|
|
|
- //print("$method\n");
|
|
|
-
|
|
|
- // build structure
|
|
|
- $struct["def"] = $method;
|
|
|
- $struct["template"] = $method_template;
|
|
|
- $struct["template_function"] = $method_template_function;
|
|
|
- $struct["template_procedure"] = $method_template_procedure;
|
|
|
- $struct["objc_method"] = $this->CopyObjcMethodName($source);
|
|
|
- $struct["class_prefix"] = $class_prefix;
|
|
|
- //$struct["def_objc"] = eregi("(.*);", $source, $captures[1]);
|
|
|
- if ($return_type == "void") $return_type = "";
|
|
|
- $struct["return"] = $return_type;
|
|
|
- if (in_array($return_type, $this->cocoa_classes)) $struct["returns_wrapper"] = true;
|
|
|
- $struct["param_string_clean"] = trim($params, "()");
|
|
|
- $struct["param_string_clean_with_modifiers"] = trim($params_with_modifiers, "()");
|
|
|
- $struct["param_string"] = $params;
|
|
|
- $struct["param_string_with_modifiers"] = $params_with_modifiers;
|
|
|
- $struct["param_array"] = $param_array["pairs"];
|
|
|
- $struct["param_list"] = $param_array["list"];
|
|
|
- $struct["class"] = $class;
|
|
|
- $struct["name"] = $name;
|
|
|
- $struct["kind"] = $kind;
|
|
|
-
|
|
|
- if ($struct["param_array"] != null) $struct["has_params"] = true;
|
|
|
-
|
|
|
- // determine if the method can be overridden
|
|
|
- // (!eregi("^(set|get|is)+", $name))
|
|
|
- if ($kind != "constructor") $struct["can_override"] = true;
|
|
|
-
|
|
|
- /*
|
|
|
- TEMPORARY! we don't know how to handle super methods that have have floating point values
|
|
|
- */
|
|
|
- if (in_array($struct["return"], $this->float_types)) {
|
|
|
- $struct["can_override"] = false;
|
|
|
- print(" # WARNING: method $name can't override because the return type is float\n");
|
|
|
- $this->warning_count ++;
|
|
|
- }
|
|
|
-
|
|
|
- // FPC bug work around
|
|
|
- if (strlen($name) > $this->maximum_method_length) {
|
|
|
- $struct["can_override"] = false;
|
|
|
- print(" # WARNING: method $name can't override because the name is too long\n");
|
|
|
- $this->warning_count ++;
|
|
|
- }
|
|
|
-
|
|
|
- return $struct;
|
|
|
- }
|
|
|
-
|
|
|
- // Print string to output file
|
|
|
- function PrintOutput ($indent, $string) {
|
|
|
- for ($i=0; $i < $indent; $i++) {
|
|
|
- $indent_string .= " ";
|
|
|
- }
|
|
|
-
|
|
|
- if (($this->output) && (!$this->show)) fwrite($this->output, "$indent_string$string\n");
|
|
|
-
|
|
|
- if ($this->show) print("$indent_string$string\n");
|
|
|
- }
|
|
|
-
|
|
|
- // Returns the message sending template for a method structure
|
|
|
- function GetMsgSendTemplate ($method, $super) {
|
|
|
- if ($method["kind"] == "function") {
|
|
|
- if ($method["has_params"]) {
|
|
|
- $template = $this->template_function_objc_send;
|
|
|
- } else {
|
|
|
- $template = $this->template_function_objc_send_no_params;
|
|
|
- }
|
|
|
- } else {
|
|
|
- if ($method["has_params"]) {
|
|
|
- $template = $this->template_procedure_objc_send;
|
|
|
- } else {
|
|
|
- $template = $this->template_procedure_objc_send_no_params;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- // method returns a NS*** class wrapper. Now, super methods can't return wrappers
|
|
|
- if (!$super) {
|
|
|
- if (($method["kind"] == "function") && (in_array($method["return"], $this->cocoa_classes))) {
|
|
|
- if ($method["has_params"]) {
|
|
|
- $template = $this->template_function_make_wrapper;
|
|
|
- } else {
|
|
|
- $template = $this->template_function_make_wrapper_no_params;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- // method returns a struct
|
|
|
- if (($method["kind"] == "function") && (in_array($method["return"], $this->struct_types))) {
|
|
|
- if ($method["has_params"]) {
|
|
|
- $template = $this->template_function_objc_send_struct;
|
|
|
- } else {
|
|
|
- $template = $this->template_function_objc_send_no_params_struct;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- // method returns an architecture dependent struct
|
|
|
- if (($method["kind"] == "function") && (in_array($method["return"], $this->struct_register_types))) {
|
|
|
- if ($method["has_params"]) {
|
|
|
- $template = $this->template_function_objc_send_struct_cpu;
|
|
|
- } else {
|
|
|
- $template = $this->template_function_objc_send_no_params_struct_cpu;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- // method is a constructor
|
|
|
- if ($method["kind"] == "constructor") {
|
|
|
- $template = $this->template_constructor_no_alloc;
|
|
|
- if ($method["alloc"]) $template = $this->template_constructor;
|
|
|
- }
|
|
|
-
|
|
|
- return $template;
|
|
|
- }
|
|
|
-
|
|
|
- // Returns a class hierarchy array
|
|
|
- function GetClassHierarchy ($class, &$hierarchy) {
|
|
|
- if (!$hierarchy) $hierarchy = array();
|
|
|
- $hierarchy[] = $class["name"];
|
|
|
-
|
|
|
- if ($class["super_class"]) {
|
|
|
- $hierarchy[] = $this->GetClassHierarchy($class["super_class"], $hierarchy);
|
|
|
- } else {
|
|
|
- $hierarchy[] = "NSObject";
|
|
|
- }
|
|
|
-
|
|
|
- return $class["name"];
|
|
|
- }
|
|
|
-
|
|
|
- // returns if a keyword is protected in a class hierarchy
|
|
|
- function IsKeywordProtected ($keyword, $in_class) {
|
|
|
- $keywords = $this->GetClassHierarchy($in_class, $hierarchy);
|
|
|
-
|
|
|
- foreach ($hierarchy as $key) {
|
|
|
- if (@in_array($keyword, $keywords)) { //$this->dump["master"][$key]["protected_keywords"]
|
|
|
- return true;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- // Returns all protected keywords in a class hierarchy
|
|
|
- function GetProtectedKeywords ($in_class) {
|
|
|
- $this->GetClassHierarchy($in_class, $hierarchy);
|
|
|
- $keywords = array();
|
|
|
-
|
|
|
- foreach ($hierarchy as $class) {
|
|
|
- if ($this->dump["master"][$class]["protected_keywords"]) {
|
|
|
- foreach ($this->dump["master"][$class]["protected_keywords"] as $keyword) $keywords[] = $keyword;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- return $keywords;
|
|
|
- }
|
|
|
-
|
|
|
-
|
|
|
- // Returns header a category should be moved to
|
|
|
- function FindCategoryHeader ($category) {
|
|
|
-
|
|
|
- foreach ($this->dump as $name => $header) {
|
|
|
- if ((@array_key_exists($category, $header["classes"])) && ($category != "NSObject")) {
|
|
|
- return $name;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- // Adds a method structure to a class and performs checks for overloaded methods
|
|
|
- function AddMethodToClass (&$method, &$class) {
|
|
|
-
|
|
|
- // ignore methods
|
|
|
- if (in_array($method["name"], $this->ignore_methods)) return false;
|
|
|
-
|
|
|
- if (@!in_array($method["name"], $class["declared_methods"])) {
|
|
|
-
|
|
|
- $class["all"][$method["name"]] = $method;
|
|
|
- $class["protected_keywords"][] = $method["name"];
|
|
|
- $class["declared_methods"][] = $method["name"];
|
|
|
- $this->dump["all_methods"][$class["name"]][] = $method["objc_method"];
|
|
|
-
|
|
|
- if ($this->show_added_messages) print(" @ Added ".$method["name"]." to ".$class["name"]."\n");
|
|
|
-
|
|
|
- $this->method_count ++;
|
|
|
- return true;
|
|
|
- } else {
|
|
|
- print(" ! ".$method["def"]." already exists in ".$class["name"]." defined as ".$class["all"][$method["name"]]["def"]."\n");
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- // Adds a typedef to the header and handles organization to prevent order conflicts
|
|
|
- function AddTypeDef (&$header, $typedef) {
|
|
|
- $header["types"]["typedef"][] = $typedef;
|
|
|
- }
|
|
|
-
|
|
|
- // Returns a paramater list string with options to modify
|
|
|
- function MakeParamList ($param_array, $use_handle, $cast_handle, $direct, $register_selector) {
|
|
|
- $params = "";
|
|
|
- foreach ($param_array as $pair) {
|
|
|
-
|
|
|
- // register selector parameters
|
|
|
- if (($register_selector) && ($pair["type"] == "SEL")) {
|
|
|
- $params .= "sel_registerName(".$pair["name"]."), ";
|
|
|
- continue;
|
|
|
- }
|
|
|
-
|
|
|
- // use the object handle for NSObject descendants
|
|
|
- if ($use_handle) {
|
|
|
- if (in_array($pair["type"], $this->cocoa_classes)) {
|
|
|
-
|
|
|
- // cast the param to the original class type
|
|
|
- if ($cast_handle) {
|
|
|
- if ($direct == ACCESS_HANDLE_DIRECT) {
|
|
|
- $params .= $pair["type"]."(".$pair["name"].".Handle), ";
|
|
|
- } else {
|
|
|
- $params .= $pair["type"]."(GetHandle(".$pair["name"].")), ";
|
|
|
- }
|
|
|
- } else {
|
|
|
- if ($direct == ACCESS_HANDLE_DIRECT) {
|
|
|
- $params .= $pair["name"].".Handle, ";
|
|
|
- } else {
|
|
|
- $params .= "GetHandle(".$pair["name"]."), ";
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- } else {
|
|
|
- if (($this->objects_are_wrappers) && ($pair["type"] == $this->objc_id)) { // id is always a wrapper
|
|
|
- if ($direct == ACCESS_HANDLE_DIRECT) {
|
|
|
- $params .= $pair["type"]."(".$pair["name"].".Handle), ";
|
|
|
- } else {
|
|
|
- $params .= $pair["type"]."(GetHandle(".$pair["name"].")), ";
|
|
|
- }
|
|
|
- } else {
|
|
|
- $params .= $pair["name"].", ";
|
|
|
- }
|
|
|
- }
|
|
|
- } else { // append without modification
|
|
|
- $params .= $pair["name"].", ";
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- return trim($params, ", ");
|
|
|
- }
|
|
|
-
|
|
|
- // Returns a list of paramameter variables with NS*** class types cast to "id" or the original class
|
|
|
- function MakeObjcTypeParamList ($param_array, $objc_type) {
|
|
|
- $params = "";
|
|
|
- foreach ($param_array as $pair) {
|
|
|
- if (in_array($pair["type"], $this->cocoa_classes)) {
|
|
|
- if ($objc_type) {
|
|
|
- $params .= "$this->objc_id(".$pair["name"]."), ";
|
|
|
- } else {
|
|
|
- $params .= $pair["type"]."(".$pair["name"]."), ";
|
|
|
- }
|
|
|
- } else {
|
|
|
- $params .= $pair["name"].", ";
|
|
|
- }
|
|
|
- }
|
|
|
- return trim($params, ", ");
|
|
|
- }
|
|
|
-
|
|
|
- /**
|
|
|
- * PRINTING METHODS
|
|
|
- */
|
|
|
-
|
|
|
- // Prints implemented methods
|
|
|
- function PrintImplementedMethods ($class) {
|
|
|
-
|
|
|
- // print implemented methods
|
|
|
- $this->PrintOutput(0, "");
|
|
|
- $this->PrintOutput(0, "{ Implemented methods }");
|
|
|
- foreach ($class["all"] as $method) {
|
|
|
- if ($method["can_override"]) {
|
|
|
-
|
|
|
- if ($method["kind"] == "function") {
|
|
|
- $template = $this->template_implemented_function;
|
|
|
- } else {
|
|
|
- $template = $this->template_implemented_procedure;
|
|
|
- }
|
|
|
-
|
|
|
- $template = str_replace("[CLASS]", $class["name"], $template);
|
|
|
- $template = str_replace("[NAME]", $method["name"], $template);
|
|
|
-
|
|
|
- $method["return"] = $this->ReplaceNSTypesWithRef($method["return"]);
|
|
|
- $template = str_replace("[RETURN]", $method["return"], $template);
|
|
|
- $template = str_replace("[PARAMS_HEADER]", $method["param_string_with_modifiers"], $template);
|
|
|
-
|
|
|
- // build parameter list
|
|
|
- if ($method["has_params"]) {
|
|
|
-
|
|
|
- // auto-generate wrappers
|
|
|
- $params = "(";
|
|
|
- $params .= $this->MakeParamList($method["param_array"], USE_HANDLE, CAST_HANDLE, ACCESS_HANDLE_FUNCTION, DONT_REGISTER_SEL);
|
|
|
- $params .= ")";
|
|
|
- $template = str_replace("[PARAMS_BODY_WRAPPER]", $params, $template);
|
|
|
-
|
|
|
- // standard params
|
|
|
- $params = "(";
|
|
|
- $params .= $this->MakeObjcTypeParamList($method["param_array"], true);
|
|
|
- $params .= ")";
|
|
|
- $template = str_replace("[PARAMS_BODY]", $params, $template);
|
|
|
-
|
|
|
-
|
|
|
- } else {
|
|
|
- $template = str_replace("[PARAMS_BODY]", "", $template);
|
|
|
- $template = str_replace("[PARAMS_BODY_WRAPPER]", "", $template);
|
|
|
- }
|
|
|
-
|
|
|
- $this->PrintOutput(0, "");
|
|
|
- $this->PrintOutput(0, $template);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- }
|
|
|
-
|
|
|
- // Prints Objective-C wrapper procedures
|
|
|
- function PrintObjcWrapperProcedures ($class) {
|
|
|
-
|
|
|
- // print implemented methods
|
|
|
- $this->PrintOutput(0, "");
|
|
|
- $this->PrintOutput(0, "{ Objective-c wrapper procedures }");
|
|
|
- foreach ($class["all"] as $method) {
|
|
|
- if ($method["can_override"]) {
|
|
|
-
|
|
|
- if ($method["kind"] == "function") {
|
|
|
- $template = $this->template_function_objc_wrapper;
|
|
|
- } else {
|
|
|
- $template = $this->template_procedure_objc_wrapper;
|
|
|
- }
|
|
|
-
|
|
|
- $template = str_replace("[CLASS]", $class["name"], $template);
|
|
|
- $template = str_replace("[NAME]", $method["name"], $template);
|
|
|
- $template = str_replace("[SELNAME]", str_replace(":", "_", $method["objc_method"]), $template);
|
|
|
-
|
|
|
- $method["return"] = $this->ReplaceNSTypesWithRef($method["return"]);
|
|
|
- $template = str_replace("[RETURN]", $method["return"], $template);
|
|
|
-
|
|
|
- if ($method["has_params"]) {
|
|
|
- $method["param_string_clean"] = $this->ReplaceNSTypes($method["param_string_clean"]);
|
|
|
-
|
|
|
- // Make sure we always the id type in objc wrappers
|
|
|
- $params_header = $this->ReplaceNSTypesWithRef($method["param_string_clean_with_modifiers"]);
|
|
|
- $template = str_replace("[PARAMS_HEADER]", "; $params_header", $template);
|
|
|
-
|
|
|
- // auto-generate wrappers
|
|
|
- $wrappers_variables = "";
|
|
|
- $wrappers_create = "";
|
|
|
- $wrappers_release = "";
|
|
|
- $variable_list = "";
|
|
|
-
|
|
|
- foreach ($method["param_array"] as $pair) {
|
|
|
- if (in_array($pair["type"], $this->cocoa_classes)) {
|
|
|
-
|
|
|
- $wrappers_variables .= "object_".$pair["name"].": ".$pair["type"]."\n;";
|
|
|
- $wrappers_create .= "object_".$pair["name"]." := ".$pair["type"].".CreateWithHandle(".$pair["name"].");\n";
|
|
|
- $wrappers_release .= "object_".$pair["name"].".release;\n";
|
|
|
- $variable_list .= "object_".$pair["name"].", ";
|
|
|
- } else {
|
|
|
- $variable_list .= $pair["name"].", ";
|
|
|
- }
|
|
|
- }
|
|
|
- $variable_list = trim($variable_list, ", ");
|
|
|
-
|
|
|
- $template = str_replace("[VARIABLES]", $wrappers_variables, $template);
|
|
|
- $template = str_replace("[WRAPPERS_CREATE]", $wrappers_create, $template);
|
|
|
- $template = str_replace("[WRAPPERS_RELEASE]", $wrappers_release, $template);
|
|
|
-
|
|
|
- $template = str_replace("[PARAMS_LIST_WRAPPER]", "($variable_list)", $template);
|
|
|
-
|
|
|
- $params = $this->MakeObjcTypeParamList($method["param_array"], false);
|
|
|
- $template = str_replace("[PARAMS_LIST]", "($params)", $template);
|
|
|
-
|
|
|
- } else {
|
|
|
- $template = str_replace("[PARAMS_HEADER]", "", $template);
|
|
|
- $template = str_replace("[PARAMS_LIST]", "", $template);
|
|
|
- $template = str_replace("[PARAMS_LIST_WRAPPER]", "", $template);
|
|
|
- $template = str_replace("[VARIABLES]", "", $template);
|
|
|
- $template = str_replace("[WRAPPERS_CREATE]", "", $template);
|
|
|
- $template = str_replace("[WRAPPERS_RELEASE]", "", $template);
|
|
|
- }
|
|
|
-
|
|
|
- $this->PrintOutput(0, "");
|
|
|
- $this->PrintOutput(0, $template);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- // Prints send message objects with a custom implementation
|
|
|
- function PrintCustomSendMessageMethods ($class, $method) {
|
|
|
-
|
|
|
- // NSArray
|
|
|
- if ($class["name"] == "NSArray") {
|
|
|
- if ($method["name"] == "arrayWithObjects") $template = $this->template_constructor_constarray_no_alloc;
|
|
|
- if ($method["name"] == "initWithObjects") $template = $this->template_constructor_constarray;
|
|
|
-
|
|
|
- $template = str_replace("[CFTYPE]", "CFArrayRef", $template);
|
|
|
- $template = str_replace("[ALLOC_PARAM_LIST]", $this->template_array_param_list, $template);
|
|
|
-
|
|
|
- if ($method["name"] == "arrayWithObjects") $template = str_replace("[OBJC_METHOD]", "arrayWithArray:", $template);
|
|
|
- if ($method["name"] == "initWithObjects") $template = str_replace("[OBJC_METHOD]", "initWithArray:", $template);
|
|
|
- }
|
|
|
-
|
|
|
- // NSDictionary
|
|
|
- if ($class["name"] == "NSDictionary") {
|
|
|
- if ($method["name"] == "dictionaryWithObjectsAndKeys") $template = $this->template_constructor_constarray_no_alloc;
|
|
|
- if ($method["name"] == "initWithObjectsAndKeys") $template = $this->template_constructor_constarray;
|
|
|
-
|
|
|
- $template = str_replace("[CFTYPE]", "CFDictionaryRef", $template);
|
|
|
- $template = str_replace("[ALLOC_PARAM_LIST]", $this->template_dictionary_param_list, $template);
|
|
|
-
|
|
|
- if ($method["name"] == "dictionaryWithObjectsAndKeys") $template = str_replace("[OBJC_METHOD]", "dictionaryWithDictionary:", $template);
|
|
|
- if ($method["name"] == "initWithObjectsAndKeys") $template = str_replace("[OBJC_METHOD]", "initWithDictionary:", $template);
|
|
|
- }
|
|
|
-
|
|
|
- // NSSet
|
|
|
- if ($class["name"] == "NSSet") {
|
|
|
- if ($method["name"] == "setWithObjects") $template = $this->template_constructor_constarray_no_alloc;
|
|
|
- if ($method["name"] == "initWithObjects") $template = $this->template_constructor_constarray;
|
|
|
-
|
|
|
- $template = str_replace("[CFTYPE]", "CFSetRef", $template);
|
|
|
- $template = str_replace("[ALLOC_PARAM_LIST]", $this->template_set_param_list, $template);
|
|
|
-
|
|
|
- if ($method["name"] == "setWithObjects") $template = str_replace("[OBJC_METHOD]", "setWithSet:", $template);
|
|
|
- if ($method["name"] == "initWithObjects") $template = str_replace("[OBJC_METHOD]", "initWithSet:", $template);
|
|
|
- }
|
|
|
-
|
|
|
- $template = str_replace("[PARAMS_HEADER]", $method["param_string_with_modifiers"], $template);
|
|
|
- $template = str_replace("[CLASS]", $class["name"].".", $template);
|
|
|
- $template = str_replace("[NAME]", $method["name"], $template);
|
|
|
- $template = str_replace("[SELNAME]", str_replace(":", "_", $method["objc_method"]), $template);
|
|
|
-
|
|
|
- $this->PrintOutput(0, "");
|
|
|
- $this->PrintOutput(0, $template);
|
|
|
- }
|
|
|
-
|
|
|
- // Prints send message objects
|
|
|
- function PrintSendMessageMethods ($class) {
|
|
|
-
|
|
|
- $this->PrintOutput(0, "");
|
|
|
- $this->PrintOutput(0, "{ Objective-c send message methods }");
|
|
|
- foreach ($class["all"] as $method) {
|
|
|
-
|
|
|
- // handle custom methods
|
|
|
- if (in_array($class["name"].".".$method["name"], $this->custom_send_methods)) {
|
|
|
- $this->PrintCustomSendMessageMethods($class, $method);
|
|
|
- continue;
|
|
|
- }
|
|
|
-
|
|
|
- $template = $this->GetMsgSendTemplate($method, false);
|
|
|
-
|
|
|
- $template = $method["class_prefix"].$template;
|
|
|
-
|
|
|
- $template = str_replace("[CLASS]", $class["name"].".", $template);
|
|
|
- $template = str_replace("[NAME]", $method["name"], $template);
|
|
|
- $template = str_replace("[SELNAME]", str_replace(":", "_", $method["objc_method"]), $template);
|
|
|
- $template = str_replace("[RETURN]", $method["return"], $template);
|
|
|
-
|
|
|
- // Replace SEL with the string equivalent so it can be registered inside the wrapper
|
|
|
- if ($this->register_selectors) {
|
|
|
- $params_header = str_replace_word("SEL", $this->sel_string, $method["param_string_with_modifiers"]);
|
|
|
- $register = REGISTER_SEL;
|
|
|
- } else {
|
|
|
- $params_header = $method["param_string_with_modifiers"];
|
|
|
- $register = DONT_REGISTER_SEL;
|
|
|
- }
|
|
|
-
|
|
|
- $template = str_replace("[PARAMS_HEADER]", $params_header, $template);
|
|
|
-
|
|
|
- if ($method["has_params"]) {
|
|
|
- $template = str_replace("[PARAMS_PROC]", "; ".$method["param_string_clean_with_modifiers"], $template);
|
|
|
-
|
|
|
- $params_wrapper = $this->MakeParamList($method["param_array"], USE_HANDLE, CAST_HANDLE, ACCESS_HANDLE_FUNCTION, $register);
|
|
|
- $params_list = $this->MakeParamList($method["param_array"], DONT_USE_HANDLE, DONT_CAST_HANDLE, ACCESS_HANDLE_FUNCTION, $register);
|
|
|
-
|
|
|
- $template = str_replace("[PARAMS_LIST_WRAPPER]", ", ".$params_wrapper, $template);
|
|
|
- $template = str_replace("[PARAMS_LIST]", ", ".$params_list, $template);
|
|
|
- } else {
|
|
|
- $template = str_replace("[PARAMS_PROC]", "", $template);
|
|
|
- $template = str_replace("[PARAMS_LIST]", "", $template);
|
|
|
- $template = str_replace("[PARAMS_LIST_WRAPPER]", "", $template);
|
|
|
- }
|
|
|
-
|
|
|
- $template = str_replace("[TARGET_TYPE]", $this->objc_id_real, $template);
|
|
|
- $template = str_replace("[OBJC_METHOD]", $method["objc_method"], $template);
|
|
|
- $template = str_replace("[GET_SUPER_CLASS]", "", $template);
|
|
|
-
|
|
|
- // decide reference to objc object by method type
|
|
|
- if ($method["class_prefix"] == "") {
|
|
|
- $template = str_replace("[OBJC_OBJECT]", "Handle", $template);
|
|
|
- } else {
|
|
|
- $template = str_replace("[OBJC_OBJECT]", "getClass", $template);
|
|
|
- }
|
|
|
-
|
|
|
- $template = str_replace("[MSG_SEND_STRET]", "objc_msgSend_stret", $template);
|
|
|
- $template = str_replace("[MSG_SEND_REGISTER]", "objc_msgSend", $template);
|
|
|
-
|
|
|
- if (in_array($method["return"], $this->struct_types)) { // structure
|
|
|
- $template = str_replace("[MSG_SEND]", "objc_msgSend_stret", $template);
|
|
|
- } elseif (in_array($method["return"], $this->float_types)) { // floating point
|
|
|
- $template = str_replace("[MSG_SEND]", "objc_msgSend_fpret", $template);
|
|
|
- } else { // simple type
|
|
|
- $template = str_replace("[MSG_SEND]", "objc_msgSend", $template);
|
|
|
- }
|
|
|
-
|
|
|
- $this->PrintOutput(0, "");
|
|
|
- $this->PrintOutput(0, $template);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- // Prints override methods
|
|
|
- function PrintOverrideMethods ($class) {
|
|
|
-
|
|
|
- $this->PrintOutput(0, "");
|
|
|
- $this->PrintOutput(0, "{ Override methods }");
|
|
|
- foreach ($class["all"] as $method) {
|
|
|
- if ($method["can_override"]) {
|
|
|
-
|
|
|
- $template = $this->template_method_override;
|
|
|
-
|
|
|
- $template = str_replace("[CLASS]", $class["name"], $template);
|
|
|
- $template = str_replace("[NAME]", $method["name"], $template);
|
|
|
- $template = str_replace("[SELNAME]", str_replace(":", "_", $method["objc_method"]), $template);
|
|
|
- $template = str_replace("[OBJC_METHOD]", $method["objc_method"], $template);
|
|
|
- $template = str_replace("[TYPE_ENCODING]", $this->type_encodings[$class["name"]][$method["objc_method"]], $template);
|
|
|
-
|
|
|
- $this->PrintOutput(0, "");
|
|
|
- $this->PrintOutput(0, $template);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- // Prints implemented methods that contain sending code
|
|
|
- function PrintImplementedSuperMethods ($class) {
|
|
|
-
|
|
|
- $this->PrintOutput(0, "");
|
|
|
- $this->PrintOutput(0, "{ Implemented methods }");
|
|
|
- foreach ($class["all"] as $method) {
|
|
|
- if ($method["can_override"]) {
|
|
|
-
|
|
|
- $template = $this->GetMsgSendTemplate($method, true);
|
|
|
-
|
|
|
- $template = str_replace("[CLASS]", $class["name"].".", $template);
|
|
|
- $template = str_replace("[NAME]", "implemented_".$method["name"], $template);
|
|
|
- $template = str_replace("[SELNAME]", str_replace(":", "_", $method["objc_method"]), $template);
|
|
|
- $method["return"] = $this->ReplaceNSTypesWithRef($method["return"]);
|
|
|
- $template = str_replace("[RETURN]", $method["return"], $template);
|
|
|
-
|
|
|
- // Replace SEL with the string equivalent so it can be registered inside the wrapper
|
|
|
- if ($this->register_selectors) {
|
|
|
- $params_header = str_replace_word("SEL", $this->sel_string, $method["param_string_with_modifiers"]);
|
|
|
- $register = REGISTER_SEL;
|
|
|
- } else {
|
|
|
- $params_header = $method["param_string_with_modifiers"];
|
|
|
- $register = DONT_REGISTER_SEL;
|
|
|
- }
|
|
|
- $template = str_replace("[PARAMS_HEADER]", $params_header, $template);
|
|
|
-
|
|
|
- if ($method["has_params"]) {
|
|
|
- $template = str_replace("[PARAMS_PROC]", "; ".$method["param_string_clean_with_modifiers"], $template);
|
|
|
-
|
|
|
- $params_wrapper = $this->MakeParamList($method["param_array"], USE_HANDLE, CAST_HANDLE, ACCESS_HANDLE_FUNCTION, $register);
|
|
|
- $params_list = $this->MakeParamList($method["param_array"], DONT_USE_HANDLE, DONT_CAST_HANDLE, ACCESS_HANDLE_FUNCTION, $register);
|
|
|
-
|
|
|
- $template = str_replace("[PARAMS_LIST_WRAPPER]", ", ".$params_wrapper, $template);
|
|
|
- $template = str_replace("[PARAMS_LIST]", ", ".$params_list, $template);
|
|
|
- } else {
|
|
|
- $template = str_replace("[PARAMS_PROC]", "", $template);
|
|
|
- $template = str_replace("[PARAMS_LIST]", "", $template);
|
|
|
- }
|
|
|
-
|
|
|
- $template = str_replace("[TARGET_TYPE]", "Pobjc_super", $template);
|
|
|
- $template = str_replace("[OBJC_METHOD]", $method["objc_method"], $template);
|
|
|
- $template = str_replace("[OBJC_OBJECT]", "@super", $template);
|
|
|
- $template = str_replace("[GET_SUPER_CLASS]", "super := getSuperClass;", $template);
|
|
|
-
|
|
|
- $template = str_replace("[MSG_SEND_STRET]", "objc_msgSendSuper_stret", $template);
|
|
|
- $template = str_replace("[MSG_SEND_REGISTER]", "objc_msgSendSuper", $template);
|
|
|
-
|
|
|
- if (in_array($method["return"], $this->struct_types)) {
|
|
|
- $template = str_replace("[MSG_SEND]", "objc_msgSendSuper_stret", $template);
|
|
|
- } else {
|
|
|
- $template = str_replace("[MSG_SEND]", "objc_msgSendSuper", $template);
|
|
|
- }
|
|
|
-
|
|
|
- $this->PrintOutput(0, "");
|
|
|
- $this->PrintOutput(0, $template);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- // Prints super methods
|
|
|
- function PrintSuperMethods ($class) {
|
|
|
-
|
|
|
- $this->PrintOutput(0, "");
|
|
|
- $this->PrintOutput(0, "{ Super methods }");
|
|
|
- foreach ($class["all"] as $method) {
|
|
|
- if ($method["can_override"]) {
|
|
|
-
|
|
|
- $template = $this->GetMsgSendTemplate($method, true);
|
|
|
-
|
|
|
- $template = str_replace("[CLASS]", $class["name"].".", $template);
|
|
|
- $template = str_replace("[NAME]", "super_".$method["name"], $template);
|
|
|
- $template = str_replace("[SELNAME]", str_replace(":", "_", $method["objc_method"]), $template);
|
|
|
-
|
|
|
- $method["return"] = $this->ReplaceNSTypesWithRef($method["return"]);
|
|
|
- $template = str_replace("[RETURN]", $method["return"], $template);
|
|
|
-
|
|
|
- //$method["param_string"] = $this->ReplaceNSTypesWithReal($method["param_string"]);
|
|
|
- //$method["param_string_clean"] = $this->ReplaceNSTypesWithReal($method["param_string_clean"]);
|
|
|
-
|
|
|
- $template = str_replace("[PARAMS_HEADER]", $method["param_string_with_modifiers"], $template);
|
|
|
- $template = str_replace("[PARAMS_PROC]", "; ".$method["param_string_clean"], $template);
|
|
|
- $template = str_replace("[PARAMS_LIST_WRAPPER]", ", ".$method["param_list"], $template);
|
|
|
- $template = str_replace("[PARAMS_LIST]", ", ".$method["param_list"], $template);
|
|
|
- $template = str_replace("[TARGET_TYPE]", "Pobjc_super", $template);
|
|
|
- $template = str_replace("[OBJC_METHOD]", $method["objc_method"], $template);
|
|
|
- $template = str_replace("[OBJC_OBJECT]", "@super", $template);
|
|
|
- $template = str_replace("[GET_SUPER_CLASS]", "", $template);
|
|
|
-
|
|
|
- if (in_array($method["return"], $this->struct_types)) {
|
|
|
- $template = str_replace("[MSG_SEND]", "objc_msgSendSuper_stret", $template);
|
|
|
- } else {
|
|
|
- $template = str_replace("[MSG_SEND]", "objc_msgSendSuper", $template);
|
|
|
- }
|
|
|
-
|
|
|
-
|
|
|
- $this->PrintOutput(0, "");
|
|
|
- $this->PrintOutput(0, $template);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- function PrintProtocolDeclaration ($protocol, $method) {
|
|
|
- $template = $method["template"];
|
|
|
- $template = str_replace("[PREFIX]", $protocol["name"]."_", $template);
|
|
|
-
|
|
|
- if ($method["param_array"] == 0) {
|
|
|
- $param = "sourceObject: NSObjectRef";
|
|
|
- } else {
|
|
|
- $param = "sourceObject: NSObjectRef; ";
|
|
|
- }
|
|
|
-
|
|
|
- $template = str_replace("[PARAMS]", "($param".$method["param_string_clean_with_modifiers"].")", $template);
|
|
|
- $template = str_replace("[KIND]", $method["kind"], $template);
|
|
|
- $template = str_replace("[RETURN]", $method["return"], $template);
|
|
|
-
|
|
|
- $this->PrintOutput(0, $template);
|
|
|
- }
|
|
|
-
|
|
|
- // Prints all the protocols in the header
|
|
|
- function PrintHeaderProtocols ($header, $implemented) {
|
|
|
-
|
|
|
- if (!$header["protocols"]) return;
|
|
|
-
|
|
|
- foreach ($header["protocols"] as $protocol) {
|
|
|
-
|
|
|
- if ($implemented) {
|
|
|
-
|
|
|
- if (!$protocol["methods"]) continue;
|
|
|
-
|
|
|
- foreach ($protocol["methods"] as $name => $method) {
|
|
|
- if ($method["kind"] != "constructor") {
|
|
|
- //$this->PrintProtocolDeclaration($protocol, $method);
|
|
|
-
|
|
|
- $template = $this->GetMsgSendTemplate($method, false);
|
|
|
-
|
|
|
- // choose the protocol version
|
|
|
- if ($template == $this->template_function_make_wrapper) $template = $this->template_protocol_make_wrapper;
|
|
|
- if ($template == $this->template_function_make_wrapper_no_params) $template = $this->template_protocol_make_wrapper_no_params;
|
|
|
-
|
|
|
- $template = str_replace("[CLASS]", $protocol["name"]."_", $template);
|
|
|
- if ($method["param_array"] == 0) {
|
|
|
- // add header params token to accommodate our extra parameter
|
|
|
- $template = str_replace("[NAME]", $method["name"]."[PARAMS_HEADER]", $template);
|
|
|
- } else {
|
|
|
- $template = str_replace("[NAME]", $method["name"], $template);
|
|
|
- }
|
|
|
- $template = str_replace("[SELNAME]", str_replace(":", "_", $method["objc_method"]), $template);
|
|
|
- $template = str_replace("[RETURN]", $method["return"], $template);
|
|
|
-
|
|
|
- if ($method["param_array"] == 0) {
|
|
|
- $source_param = "sourceObject: NSObjectRef";
|
|
|
- } else {
|
|
|
- $source_param = "sourceObject: NSObjectRef; ";
|
|
|
- }
|
|
|
-
|
|
|
- // Replace SEL with the string equivalent so it can be registered inside the wrapper
|
|
|
- if ($this->register_selectors) {
|
|
|
- $params_header = str_replace_word("SEL", $this->sel_string, $method["param_string_clean_with_modifiers"]);
|
|
|
- $register = REGISTER_SEL;
|
|
|
- } else {
|
|
|
- $params_header = $method["param_string_clean_with_modifiers"];
|
|
|
- $register = DONT_REGISTER_SEL;
|
|
|
- }
|
|
|
-
|
|
|
- $template = str_replace("[PARAMS_HEADER]", "($source_param$params_header)", $template);
|
|
|
-
|
|
|
- if ($method["has_params"]) {
|
|
|
- $template = str_replace("[PARAMS_PROC]", "; ".$method["param_string_clean"], $template);
|
|
|
-
|
|
|
- $params_wrapper = $this->MakeParamList($method["param_array"], USE_HANDLE, CAST_HANDLE, ACCESS_HANDLE_DIRECT, $register);
|
|
|
- $params_list = $this->MakeParamList($method["param_array"], DONT_USE_HANDLE, DONT_CAST_HANDLE, ACCESS_HANDLE_DIRECT, $register);
|
|
|
-
|
|
|
- $template = str_replace("[PARAMS_LIST_WRAPPER]", ", ".$params_wrapper, $template);
|
|
|
- $template = str_replace("[PARAMS_LIST]", ", ".$params_list, $template);
|
|
|
- } else {
|
|
|
- $template = str_replace("[PARAMS_PROC]", "", $template);
|
|
|
- $template = str_replace("[PARAMS_LIST]", "", $template);
|
|
|
- }
|
|
|
-
|
|
|
- $template = str_replace("[TARGET_TYPE]", $this->objc_id_real, $template);
|
|
|
- $template = str_replace("[OBJC_METHOD]", $method["objc_method"], $template);
|
|
|
- $template = str_replace("[GET_SUPER_CLASS]", "", $template);
|
|
|
-
|
|
|
- $template = str_replace("[MSG_SEND_STRET]", "objc_msgSend_stret", $template);
|
|
|
- $template = str_replace("[MSG_SEND_REGISTER]", "objc_msgSend", $template);
|
|
|
-
|
|
|
- // use the source object as the the target
|
|
|
- $template = str_replace("[OBJC_OBJECT]", "sourceObject", $template);
|
|
|
-
|
|
|
- if (in_array($method["return"], $this->struct_types)) { // structure
|
|
|
- $template = str_replace("[MSG_SEND]", "objc_msgSend_stret", $template);
|
|
|
- } elseif (in_array($method["return"], $this->float_types)) { // floating point
|
|
|
- $template = str_replace("[MSG_SEND]", "objc_msgSend_fpret", $template);
|
|
|
- } else { // simple type
|
|
|
- $template = str_replace("[MSG_SEND]", "objc_msgSend", $template);
|
|
|
- }
|
|
|
-
|
|
|
- $this->PrintOutput(0, "");
|
|
|
- $this->PrintOutput(0, $template);
|
|
|
-
|
|
|
-
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- } else {
|
|
|
- if ($protocol["methods"]) {
|
|
|
- $this->PrintOutput(0, "");
|
|
|
- $this->PrintOutput(0, "{ Protocol: ".$protocol["name"]." }");
|
|
|
-
|
|
|
- foreach ($protocol["methods"] as $name => $method) {
|
|
|
- if ($method["kind"] != "constructor") {
|
|
|
- $this->PrintProtocolDeclaration($protocol, $method);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- function PrintSelectorVariables ($class) {
|
|
|
-
|
|
|
- // class has no methods, bail!
|
|
|
- if (!$class["methods"]) return;
|
|
|
-
|
|
|
- $this->PrintOutput(0,"var");
|
|
|
-
|
|
|
- foreach ($class["all"] as $method) {
|
|
|
- $sel_name = str_replace(":", "_", $method["objc_method"]);
|
|
|
- $this->PrintOutput(1, "SEL_$sel_name: SEL;");
|
|
|
- }
|
|
|
-
|
|
|
- }
|
|
|
-
|
|
|
- // Prints a classes implementation in Pascal format to a file handle
|
|
|
- function PrintClassImplementation ($class) {
|
|
|
-
|
|
|
- // class has no methods, bail!
|
|
|
- if (!$class["methods"]) return;
|
|
|
-
|
|
|
- $name = $class["name"];
|
|
|
-
|
|
|
- $this->PrintOutput(0,"");
|
|
|
- $this->PrintOutput(0, "{ Selectors for $name }");
|
|
|
- $this->PrintSelectorVariables($class);
|
|
|
-
|
|
|
- $this->PrintOutput(0,"");
|
|
|
- $this->PrintOutput(0, "{ Implementation for $name }");
|
|
|
-
|
|
|
- // Global accessor object
|
|
|
- $this->PrintOutput(0,"");
|
|
|
- $this->PrintOutput(0,"var");
|
|
|
- $this->PrintOutput(1, "__".$class["name"].": ".$class["name"].";");
|
|
|
-
|
|
|
- // getClass method
|
|
|
- $this->PrintOutput(0,"");
|
|
|
- $this->PrintOutput(0,"class function $name.getClass: $this->objc_id_real;");
|
|
|
- $this->PrintOutput(0,"begin");
|
|
|
- $this->PrintOutput(1,"Result := objc_getClass('$name');");
|
|
|
- $this->PrintOutput(0,"end;");
|
|
|
-
|
|
|
- // withObject static accessor
|
|
|
- $this->PrintOutput(0,"");
|
|
|
- $this->PrintOutput(0, "class function $name.withObject (inObject: Pointer): $name;");
|
|
|
- $this->PrintOutput(0,"begin");
|
|
|
- $this->PrintOutput(1,"if __$name = nil then");
|
|
|
- $this->PrintOutput(2,"__$name := $name.Create;");
|
|
|
- $this->PrintOutput(1,"__$name.Handle := inObject;");
|
|
|
- $this->PrintOutput(1,"result := __$name;");
|
|
|
- $this->PrintOutput(0,"end;");
|
|
|
-
|
|
|
- $this->PrintImplementedSuperMethods($class);
|
|
|
- // DEPRECTAED IN FAVOR OF IMPLEMENTED SUPER METHODS
|
|
|
- //$this->PrintImplementedMethods($class);
|
|
|
- //$this->PrintSuperMethods($class);
|
|
|
- $this->PrintObjcWrapperProcedures($class);
|
|
|
- $this->PrintOverrideMethods($class);
|
|
|
- $this->PrintSendMessageMethods($class);
|
|
|
- }
|
|
|
-
|
|
|
- // Prints a calls in Pascal format to a file handle
|
|
|
- public function PrintClass ($class) {
|
|
|
-
|
|
|
- // class has no methods, bail!
|
|
|
- if (!$class["methods"]) return;
|
|
|
-
|
|
|
- // the delegate class is the super class of NSObject
|
|
|
- if ($class["name"] == "NSObject") $class["super"] = $this->master_delegate_class;
|
|
|
-
|
|
|
- $this->PrintOutput(0, "");
|
|
|
- $this->PrintOutput(0, "{ ".$class["name"]." }");
|
|
|
- $this->PrintOutput(1, $class["name"]." = class(".$class["super"].")");
|
|
|
- $this->PrintOutput(1, "public");
|
|
|
-
|
|
|
- // getClass override
|
|
|
- $this->PrintOutput(2, "class function getClass: $this->objc_id_real; override;");
|
|
|
-
|
|
|
- // static wrapper accessor
|
|
|
- $class_name = $class["name"];
|
|
|
- $this->PrintOutput(2, "class function withObject (inObject: Pointer): $class_name;");
|
|
|
-
|
|
|
- // print class-level methods
|
|
|
- $this->PrintOutput(0, "");
|
|
|
- $this->PrintOutput(2, "{ Class Methods }");
|
|
|
- foreach ($class["methods"] as $method) {
|
|
|
- $this->PrintOutput(2, $method["def"]);
|
|
|
- }
|
|
|
-
|
|
|
- // print category-level methods
|
|
|
- if (count($class["categories"]) > 0) {
|
|
|
- foreach ($class["categories"] as $name => $category) {
|
|
|
- $this->PrintOutput(0, "");
|
|
|
- $this->PrintOutput(2, "{ Category: $name }");
|
|
|
-
|
|
|
- if ($category["methods"]) {
|
|
|
- foreach ($category["methods"] as $method) {
|
|
|
- $this->PrintOutput(2, $method["def"]);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- // print implemented methods
|
|
|
- $this->PrintOutput(0, "");
|
|
|
- $this->PrintOutput(1, "protected");
|
|
|
- $this->PrintOutput(2, "{ Implemented Methods }");
|
|
|
- foreach ($class["all"] as $method) {
|
|
|
- if ($method["can_override"]) {
|
|
|
-
|
|
|
- $template = $method["template"];
|
|
|
- $template = str_replace("[PREFIX]", "implemented_", $template);
|
|
|
- $template = str_replace("[PARAMS]", $method["param_string_with_modifiers"], $template);
|
|
|
- $template = str_replace("[KIND]", $method["kind"], $template);
|
|
|
-
|
|
|
- // implemented methods always return id instead of wrappers
|
|
|
- $method["return"] = $this->ReplaceNSTypesWithRef($method["return"]);
|
|
|
-
|
|
|
- $template = str_replace("[RETURN]", $method["return"], $template);
|
|
|
-
|
|
|
- $this->PrintOutput(2, $template." virtual;");
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- // print override methods
|
|
|
- $this->PrintOutput(0, "");
|
|
|
- $this->PrintOutput(2, "{ Override Methods }");
|
|
|
- foreach ($class["all"] as $method) {
|
|
|
- if ($method["can_override"]) {
|
|
|
-
|
|
|
- $template = $method["template_procedure"];
|
|
|
- $template = str_replace("[PREFIX]", "override_", $template);
|
|
|
- $template = str_replace("[PARAMS]", "", $template);
|
|
|
- $template = str_replace("[RETURN]", "", $template);
|
|
|
-
|
|
|
- $this->PrintOutput(2, $template);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- // print super methods
|
|
|
- /* DEPRECTAED IN FAVOR OF IMPLEMENTED SUPER METHODS
|
|
|
- $this->PrintOutput(0, "");
|
|
|
- $this->PrintOutput(2, "{ Super Methods }");
|
|
|
- foreach ($class["all"] as $method) {
|
|
|
- if ($method["can_override"]) {
|
|
|
-
|
|
|
- $template = $method["template"];
|
|
|
- $template = str_replace("[PREFIX]", "super_", $template);
|
|
|
- $template = str_replace("[PARAMS]", $method["param_string_with_modifiers"], $template);
|
|
|
- $template = str_replace("[KIND]", $method["kind"], $template);
|
|
|
- $template = str_replace("[RETURN]", $this->ReplaceNSTypesWithRef($method["return"]), $template);
|
|
|
-
|
|
|
- $this->PrintOutput(2, $template);
|
|
|
- }
|
|
|
- }
|
|
|
- */
|
|
|
- $this->PrintOutput(1, "end;");
|
|
|
- }
|
|
|
-
|
|
|
- function PrintDelegateReference ($valid_categories) {
|
|
|
-
|
|
|
- ksort($this->delegate_methods);
|
|
|
-
|
|
|
- $this->PrintOutput(0, "unit $this->master_delegate_file;");
|
|
|
- $this->PrintOutput(0, "interface");
|
|
|
- $this->PrintOutput(0, "uses");
|
|
|
- $this->PrintOutput(1, "ctypes, objc, MacOSAll");
|
|
|
-
|
|
|
- $this->PrintOutput(0, "type");
|
|
|
- $this->PrintOutput(1, "$this->master_delegate_class = class");
|
|
|
- $this->PrintOutput(1, "public");
|
|
|
-
|
|
|
- // implemented methods
|
|
|
- foreach ($this->delegate_methods as $category => $selectors) {
|
|
|
- if (in_array($category, $this->ignore_categories)) continue;
|
|
|
-
|
|
|
- // make sure the category is valid
|
|
|
- $valid = false;
|
|
|
- foreach ($valid_categories as $pattern) {
|
|
|
- if (eregi($pattern, $category)) {
|
|
|
- $valid = true;
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
- if (!$valid) continue;
|
|
|
-
|
|
|
- $this->PrintOutput(2, "");
|
|
|
- $this->PrintOutput(2, "{ $category }");
|
|
|
-
|
|
|
- foreach ($selectors as $selector) {
|
|
|
-
|
|
|
- // FPC long name bug work-around
|
|
|
- if (strlen($selector["name_pascal"]) > $this->maximum_method_length) continue;
|
|
|
-
|
|
|
- if ($selector["kind"] == "procedure") {
|
|
|
- $this->PrintOutput(2, $selector["kind"]." ".$selector["name_pascal"].$selector["param_string"].";");
|
|
|
- } else {
|
|
|
- $this->PrintOutput(2, $selector["kind"]." ".$selector["name_pascal"].$selector["param_string"].": ".$selector["method"]["return"].";");
|
|
|
- }
|
|
|
-
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- $this->PrintOutput(1, "end;");
|
|
|
- }
|
|
|
-
|
|
|
-
|
|
|
- function PrintDelegateClass ($valid_categories) {
|
|
|
-
|
|
|
- ksort($this->delegate_methods);
|
|
|
-
|
|
|
- $this->PrintOutput(0, "{\$ifdef FORWARD}");
|
|
|
- $this->PrintOutput(1, "$this->master_delegate_class = class;");
|
|
|
- $this->PrintOutput(0, "{\$endif}");
|
|
|
-
|
|
|
- $this->PrintOutput(0, "{\$ifdef CLASSES}");
|
|
|
- $macro = strtoupper($this->master_delegate_class);
|
|
|
- $this->PrintOutput(0, "{\$ifndef $macro"."_PAS_C}");
|
|
|
- $this->PrintOutput(0, "{\$define $macro"."_PAS_C}");
|
|
|
-
|
|
|
- $this->PrintOutput(1, "$this->master_delegate_class = class(NSObjectCore)");
|
|
|
- $this->PrintOutput(1, "public");
|
|
|
-
|
|
|
- //$this->PrintOutput(2, "constructor Create; override;");
|
|
|
-
|
|
|
- // implemented methods
|
|
|
- foreach ($this->delegate_methods as $category => $selectors) {
|
|
|
- if (in_array($category, $this->ignore_categories)) continue;
|
|
|
-
|
|
|
- // make sure the category is valid
|
|
|
- $valid = false;
|
|
|
- foreach ($valid_categories as $pattern) {
|
|
|
- if (eregi($pattern, $category)) {
|
|
|
- $valid = true;
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
- if (!$valid) continue;
|
|
|
-
|
|
|
- $this->PrintOutput(2, "");
|
|
|
- $this->PrintOutput(2, "{ $category }");
|
|
|
-
|
|
|
- foreach ($selectors as $selector) {
|
|
|
-
|
|
|
- // FPC long name bug work-around
|
|
|
- if (strlen($selector["name_pascal"]) > $this->maximum_method_length) continue;
|
|
|
-
|
|
|
- if ($selector["kind"] == "procedure") {
|
|
|
- $this->PrintOutput(2, $selector["kind"]." ".$selector["name_pascal"].$selector["param_string"]."; virtual;");
|
|
|
- } else {
|
|
|
- $this->PrintOutput(2, $selector["kind"]." ".$selector["name_pascal"].$selector["param_string"].": ".$selector["method"]["return"]."; virtual;");
|
|
|
- }
|
|
|
-
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- // add methods
|
|
|
- $this->PrintOutput(2, "");
|
|
|
- $this->PrintOutput(2, "{ Adding methods }");
|
|
|
- foreach ($this->delegate_methods as $category => $selectors) {
|
|
|
- if (in_array($category, $this->ignore_categories)) continue;
|
|
|
-
|
|
|
- // make sure the category is valid
|
|
|
- $valid = false;
|
|
|
- foreach ($valid_categories as $pattern) {
|
|
|
- if (eregi($pattern, $category)) {
|
|
|
- $valid = true;
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
- if (!$valid) continue;
|
|
|
-
|
|
|
- foreach ($selectors as $selector) {
|
|
|
- // FPC long name bug work-around
|
|
|
- if (strlen("add_".$selector["name_pascal"]) > $this->maximum_method_length) continue;
|
|
|
-
|
|
|
- $this->PrintOutput(2, "procedure add_".$selector["name_pascal"].";");
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- $this->PrintOutput(1, "end;");
|
|
|
- $this->PrintOutput(0, "{\$endif}");
|
|
|
- $this->PrintOutput(0, "{\$endif}");
|
|
|
- $this->PrintOutput(0, "{\$ifdef IMPLEMENTATION}");
|
|
|
-
|
|
|
- // create constructor method
|
|
|
- /*
|
|
|
- $this->PrintOutput(0, "");
|
|
|
- $template = str_replace("[CLASS]", $this->master_delegate_class, $this->template_delegate_create);
|
|
|
- $this->PrintOutput(0, $template);
|
|
|
- */
|
|
|
-
|
|
|
- // print implemented methods
|
|
|
- foreach ($this->delegate_methods as $category => $selectors) {
|
|
|
- if (in_array($category, $this->ignore_categories)) continue;
|
|
|
-
|
|
|
- // make sure the category is valid
|
|
|
- $valid = false;
|
|
|
- foreach ($valid_categories as $pattern) {
|
|
|
- if (eregi($pattern, $category)) {
|
|
|
- $valid = true;
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
- if (!$valid) continue;
|
|
|
-
|
|
|
- // place-holder methods
|
|
|
- foreach ($selectors as $selector) {
|
|
|
-
|
|
|
- // FPC long name bug work-around
|
|
|
- if (strlen($selector["name_pascal"]) > $this->maximum_method_length) continue;
|
|
|
-
|
|
|
- if ($selector["kind"] == "procedure") {
|
|
|
- $this->PrintOutput(0, $selector["kind"]." ".$this->master_delegate_class.".".$selector["name_pascal"].$selector["param_string"].";");
|
|
|
- } else {
|
|
|
- $this->PrintOutput(0, $selector["kind"]." ".$this->master_delegate_class.".".$selector["name_pascal"].$selector["param_string"].": ".$selector["method"]["return"].";");
|
|
|
- }
|
|
|
-
|
|
|
- $this->PrintOutput(0, "begin");
|
|
|
- $this->PrintOutput(0, "end;");
|
|
|
- $this->PrintOutput(0, "");
|
|
|
- }
|
|
|
-
|
|
|
- // objc wrappers
|
|
|
- foreach ($selectors as $selector) {
|
|
|
-
|
|
|
- // FPC long name bug work-around
|
|
|
- if (strlen($selector["name_pascal"]) > $this->maximum_method_length) continue;
|
|
|
-
|
|
|
- if ($selector["kind"] == "function") {
|
|
|
- $template = $this->template_function_delegate_objc;
|
|
|
- } else {
|
|
|
- $template = $this->template_procedure_delegate_objc;
|
|
|
- }
|
|
|
-
|
|
|
- $template = str_replace("[CLASS]", $this->master_delegate_class, $template);
|
|
|
- $template = str_replace("[NAME]", $selector["name_pascal"], $template);
|
|
|
-
|
|
|
- $selector["method"]["return"] = $this->ReplaceNSTypes($selector["method"]["return"]);
|
|
|
- $template = str_replace("[RETURN]", $selector["method"]["return"], $template);
|
|
|
-
|
|
|
- if ($selector["method"]["has_params"]) {
|
|
|
- $selector["method"]["param_string_clean"] = $this->ReplaceNSTypesWithRef($selector["method"]["param_string_clean"]);
|
|
|
- $template = str_replace("[PARAMS_HEADER]", " (_self: $this->objc_id_real; _cmd: SEL; ".$selector["method"]["param_string_clean"].")", $template);
|
|
|
-
|
|
|
- // auto-generate wrappers
|
|
|
- $wrappers_variables = "";
|
|
|
- $wrappers_create = "";
|
|
|
- $wrappers_release = "";
|
|
|
- $variable_list = "";
|
|
|
-
|
|
|
- foreach ($selector["method"]["param_array"] as $pair) {
|
|
|
- if (in_array($pair["type"], $this->cocoa_classes)) {
|
|
|
-
|
|
|
- $wrappers_variables .= "object_".$pair["name"].": ".$pair["type"].";\n";
|
|
|
- $wrappers_create .= "object_".$pair["name"]." := ".$pair["type"].".CreateWithHandle(".$pair["name"].");\n";
|
|
|
- $wrappers_release .= "object_".$pair["name"].".release;\n";
|
|
|
- $variable_list .= "object_".$pair["name"].", ";
|
|
|
- } else {
|
|
|
- $variable_list .= $pair["name"].", ";
|
|
|
- }
|
|
|
- }
|
|
|
- $variable_list = trim($variable_list, ", ");
|
|
|
-
|
|
|
- $template = str_replace("[VARIABLES]", $wrappers_variables, $template);
|
|
|
- $template = str_replace("[WRAPPERS_CREATE]", $wrappers_create, $template);
|
|
|
- $template = str_replace("[WRAPPERS_RELEASE]", $wrappers_release, $template);
|
|
|
-
|
|
|
- $template = str_replace("[PARAMS_LIST_WRAPPER]", "($variable_list)", $template);
|
|
|
-
|
|
|
- $params = $this->MakeObjcTypeParamList($selector["method"]["param_array"], false);
|
|
|
- $template = str_replace("[PARAMS_LIST]", "($params)", $template);
|
|
|
-
|
|
|
- } else {
|
|
|
- $template = str_replace("[PARAMS_HEADER]", "(_self: $this->objc_id_real; _cmd: SEL)", $template);
|
|
|
- $template = str_replace("[PARAMS_LIST]", "", $template);
|
|
|
- $template = str_replace("[PARAMS_LIST_WRAPPER]", "", $template);
|
|
|
- $template = str_replace("[VARIABLES]", "", $template);
|
|
|
- $template = str_replace("[WRAPPERS_CREATE]", "", $template);
|
|
|
- $template = str_replace("[WRAPPERS_RELEASE]", "", $template);
|
|
|
- }
|
|
|
-
|
|
|
- $this->PrintOutput(0, "");
|
|
|
- $this->PrintOutput(0, $template);
|
|
|
- }
|
|
|
-
|
|
|
- // add methods
|
|
|
- foreach ($selectors as $selector) {
|
|
|
-
|
|
|
- // FPC long name bug work-around
|
|
|
- if (strlen($selector["name_pascal"]) > $this->maximum_method_length) continue;
|
|
|
-
|
|
|
- $template = $this->template_method_add_runtime;
|
|
|
-
|
|
|
- $template = str_replace("[CLASS]", $this->master_delegate_class, $template);
|
|
|
- $template = str_replace("[NAME]", $selector["name_pascal"], $template);
|
|
|
- $template = str_replace("[TYPES]", $selector["types"], $template);
|
|
|
- $template = str_replace("[OBJC_METHOD]", $selector["name"], $template);
|
|
|
-
|
|
|
- $this->PrintOutput(0, "");
|
|
|
- $this->PrintOutput(0, $template);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- $this->PrintOutput(0, "");
|
|
|
- $this->PrintOutput(0, "{\$endif}");
|
|
|
-
|
|
|
- print("* Printed delegate class to "."$this->root$this->out/foundation/$this->master_delegate_file.inc\n");
|
|
|
- }
|
|
|
-
|
|
|
- // Prints all externally defined symbols
|
|
|
- function PrintExternalSymbols ($header) {
|
|
|
- if (!$this->dump[$header["name"]]["types"]) return;
|
|
|
- foreach ($this->dump[$header["name"]]["types"] as $key => $type_array) {
|
|
|
-
|
|
|
- // External string constants
|
|
|
- if ($key == "string_constant") {
|
|
|
- $this->PrintOutput(0, "");
|
|
|
- $this->PrintOutput(0, "{ External string constants }");
|
|
|
- $this->PrintOutput(0, "var");
|
|
|
-
|
|
|
- foreach ($type_array as $type) $this->PrintOutput(1, $type);
|
|
|
- }
|
|
|
-
|
|
|
- if ($key == "external_symbol") {
|
|
|
- $this->PrintOutput(0, "");
|
|
|
- $this->PrintOutput(0, "{ External symbols }");
|
|
|
- $this->PrintOutput(0, "var");
|
|
|
-
|
|
|
- foreach ($type_array as $type) $this->PrintOutput(1, $type);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- // Prints all types in the header
|
|
|
- function PrintTypes ($header) {
|
|
|
- if (!$this->dump[$header["name"]]["types"]) return;
|
|
|
-
|
|
|
- foreach ($this->dump[$header["name"]]["types"] as $key => $type_array) {
|
|
|
-
|
|
|
- // External defines
|
|
|
- if ($key == "defines") {
|
|
|
- $this->PrintOutput(0, "");
|
|
|
- $this->PrintOutput(0, "{ Defines }");
|
|
|
- $this->PrintOutput(0, "const");
|
|
|
-
|
|
|
- foreach ($type_array as $type) $this->PrintOutput(1, $type);
|
|
|
- }
|
|
|
-
|
|
|
- // External CFString constants
|
|
|
- /*
|
|
|
- if ($key == "string_constant") {
|
|
|
- $this->PrintOutput(0, "");
|
|
|
- $this->PrintOutput(0, "{ External string constants }");
|
|
|
- $this->PrintOutput(0, "var");
|
|
|
-
|
|
|
- foreach ($type_array as $type) $this->PrintOutput(1, $type);
|
|
|
- }
|
|
|
- */
|
|
|
-
|
|
|
- // Named Enumerations
|
|
|
- /*
|
|
|
- if ($key == "named_enums") {
|
|
|
- $this->PrintOutput(0, "");
|
|
|
- $this->PrintOutput(0, "{ Sets }");
|
|
|
- foreach ($type_array as $type) {
|
|
|
- $this->PrintOutput(0, "");
|
|
|
- $this->PrintOutput(0, "type");
|
|
|
- $this->PrintOutput(1, $type);
|
|
|
- }
|
|
|
- }
|
|
|
- */
|
|
|
-
|
|
|
- // Enumerations
|
|
|
- if ($key == "enums") {
|
|
|
- $this->PrintOutput(0, "");
|
|
|
- $this->PrintOutput(0, "{ Constants }");
|
|
|
- foreach ($type_array as $block) {
|
|
|
- $this->PrintOutput(0, "");
|
|
|
- $this->PrintOutput(0, "const");
|
|
|
- foreach ($block as $type) $this->PrintOutput(1, $type);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- // Typedefs
|
|
|
- if (($key == "typedef") || ($key == "named_enums")) {
|
|
|
- $this->PrintOutput(0, "");
|
|
|
- $this->PrintOutput(0, "{ Types }");
|
|
|
- $this->PrintOutput(0, "type");
|
|
|
-
|
|
|
- foreach ($type_array as $type) $this->PrintOutput(1, $type);
|
|
|
- }
|
|
|
-
|
|
|
- // CallBacks
|
|
|
- if ($key == "callbacks") {
|
|
|
- $this->PrintOutput(0, "");
|
|
|
- $this->PrintOutput(0, "{ Callbacks }");
|
|
|
- $this->PrintOutput(0, "type");
|
|
|
-
|
|
|
- foreach ($type_array as $name => $type) $this->PrintOutput(1, "$name = $type");
|
|
|
- }
|
|
|
-
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- // Prints all records in the header
|
|
|
- function PrintRecords ($header) {
|
|
|
- if (!$this->dump[$header["name"]]["types"]) return;
|
|
|
-
|
|
|
- foreach ($this->dump[$header["name"]]["types"] as $key => $type_array) {
|
|
|
- // Structures
|
|
|
- if ($key == "structs") {
|
|
|
- $this->PrintOutput(0, "");
|
|
|
- $this->PrintOutput(0, "{ Records }");
|
|
|
-
|
|
|
- foreach ($type_array as $type) {
|
|
|
- $this->PrintOutput(0, "type");
|
|
|
- $this->PrintOutput(1, $type);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- // Prints all callbacks in the header
|
|
|
- function PrintCallBacks ($header) {
|
|
|
- if (!$this->dump[$header["name"]]["types"]) return;
|
|
|
-
|
|
|
- foreach ($this->dump[$header["name"]]["types"] as $key => $type_array) {
|
|
|
- if ($key == "callbacks") {
|
|
|
- $this->PrintOutput(0, "");
|
|
|
- $this->PrintOutput(0, "{ Callbacks }");
|
|
|
- $this->PrintOutput(0, "type");
|
|
|
-
|
|
|
- foreach ($type_array as $name => $type) $this->PrintOutput(1, "$name = $type");
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- // Prints all external functions in the header
|
|
|
- function PrintFunctions ($header) {
|
|
|
- if (!$this->dump[$header["name"]]["types"]) return;
|
|
|
-
|
|
|
- foreach ($this->dump[$header["name"]]["types"] as $key => $type_array) {
|
|
|
- if ($key == "functions") {
|
|
|
- $this->PrintOutput(0, "");
|
|
|
- $this->PrintOutput(0, "{ Functions }");
|
|
|
-
|
|
|
- foreach ($type_array as $type) $this->PrintOutput(0, $type);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- // Prints all classes from the header in reference format (not for compiling)
|
|
|
- function PrintHeaderReference ($header, $path) {
|
|
|
-
|
|
|
- $this->output = fopen($path, "w+");
|
|
|
-
|
|
|
- //$this->PrintOutput(0, "{ ".ucfirst($header["framework"]).".framework ".$header["name"]." }");
|
|
|
- $this->PrintOutput(0, "unit ".$header["name_clean"].";");
|
|
|
- $this->PrintOutput(0, "interface");
|
|
|
- $this->PrintOutput(0, "uses");
|
|
|
- $this->PrintOutput(1, "ctypes, objc, MacOSAll;");
|
|
|
-
|
|
|
- if ($header["classes"]) {
|
|
|
- foreach ($header["classes"] as $class) {
|
|
|
- $this->PrintOutput(0, "");
|
|
|
- $this->PrintOutput(0, "type");
|
|
|
- $this->PrintOutput(1, $class["name"]."Ref = ".$this->objc_id_real.";");
|
|
|
- $this->PrintOutput(1, $class["name"]."Pointer = Pointer;");
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- // types
|
|
|
- $this->PrintTypes($header);
|
|
|
- $this->PrintRecords($header);
|
|
|
- $this->PrintFunctions($header);
|
|
|
- $this->PrintExternalSymbols($header);
|
|
|
-
|
|
|
- if ($header["classes"]) {
|
|
|
-
|
|
|
- foreach ($header["classes"] as $class) {
|
|
|
- if (in_array($class["name"], $this->cocoa_classes)) {
|
|
|
- $this->PrintOutput(0, "");
|
|
|
- $this->PrintOutput(0, "type");
|
|
|
-
|
|
|
- $this->PrintOutput(1, $class["name"]." = object(".$class["super"].")");
|
|
|
-
|
|
|
- // print class-level methods
|
|
|
- if (count($class["methods"]) > 0) {
|
|
|
- $this->PrintOutput(0, "");
|
|
|
- foreach ($class["methods"] as $method) {
|
|
|
- $this->PrintOutput(2, $method["def"]);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- // print category-level methods
|
|
|
- if (count($class["categories"]) > 0) {
|
|
|
- foreach ($class["categories"] as $name => $category) {
|
|
|
- $this->PrintOutput(0, "");
|
|
|
- $this->PrintOutput(2, "{ Category: $name }");
|
|
|
-
|
|
|
- if ($category["methods"]) {
|
|
|
- foreach ($category["methods"] as $method) {
|
|
|
- $this->PrintOutput(2, $method["def"]);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- $this->PrintOutput(1, "end;");
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- // print procedural protocols
|
|
|
- if ($header["protocols"]) {
|
|
|
- foreach ($header["protocols"] as $protocol) {
|
|
|
- if ($protocol["methods"]) {
|
|
|
- $this->PrintOutput(0, "");
|
|
|
- $this->PrintOutput(0, "{ Protocol: ".$protocol["name"]." }");
|
|
|
-
|
|
|
- foreach ($protocol["methods"] as $name => $method) {
|
|
|
- if ($method["kind"] != "constructor") {
|
|
|
- $this->PrintProtocolDeclaration($protocol, $method);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- $this->PrintOutput(0, "");
|
|
|
- $this->PrintOutput(0, "implementation");
|
|
|
- $this->PrintOutput(0, "end.");
|
|
|
- }
|
|
|
-
|
|
|
- // Prints all classes from the header
|
|
|
- public function PrintHeader ($header) {
|
|
|
- global $version;
|
|
|
-
|
|
|
- $this->output = fopen($header["path"], "w+");
|
|
|
-
|
|
|
- $this->PrintOutput(0, "{ Parsed from ".ucfirst($header["framework"]).".framework ".$header["name"]." }");
|
|
|
-
|
|
|
- $date = date("D M j G:i:s T Y");
|
|
|
- $this->PrintOutput(0, "{ Version $version - $date }");
|
|
|
- $this->PrintOutput(0, "");
|
|
|
-
|
|
|
- $macro = strtoupper(substr($header["name"], 0, (strripos($header["name"], "."))));
|
|
|
-
|
|
|
- if ($header["classes"]) {
|
|
|
- $this->PrintOutput(0, "{\$ifdef HEADER}");
|
|
|
- $this->PrintOutput(0, "{\$ifndef $macro"."_PAS_H}");
|
|
|
- $this->PrintOutput(0, "{\$define $macro"."_PAS_H}");
|
|
|
-
|
|
|
-
|
|
|
- foreach ($header["classes"] as $class) {
|
|
|
- $this->PrintOutput(0, "type");
|
|
|
-
|
|
|
- // Make a id "reference" to each class which is an object but reveals the name of the class
|
|
|
- if ($class["name"]."Ref" == $this->objc_id_real) {
|
|
|
- $ref = $this->objc_id_base; // replace duplicates with the "base id"
|
|
|
- } else {
|
|
|
- $ref = $this->objc_id_real;
|
|
|
- }
|
|
|
-
|
|
|
- $this->PrintOutput(1, $class["name"]."Ref = ".$ref.";");
|
|
|
-
|
|
|
- // Make a pointer to each class
|
|
|
- $this->PrintOutput(1, $class["name"]."Pointer = Pointer;");
|
|
|
- }
|
|
|
-
|
|
|
- $this->PrintOutput(0, "");
|
|
|
- $this->PrintOutput(0, "{\$endif}");
|
|
|
- $this->PrintOutput(0, "{\$endif}");
|
|
|
- }
|
|
|
-
|
|
|
- $this->PrintOutput(0, "");
|
|
|
- $this->PrintOutput(0, "{\$ifdef TYPES}");
|
|
|
- $this->PrintOutput(0, "{\$ifndef $macro"."_PAS_T}");
|
|
|
- $this->PrintOutput(0, "{\$define $macro"."_PAS_T}");
|
|
|
- $this->PrintTypes($header);
|
|
|
- $this->PrintOutput(0, "");
|
|
|
- $this->PrintOutput(0, "{\$endif}");
|
|
|
- $this->PrintOutput(0, "{\$endif}");
|
|
|
-
|
|
|
- $this->PrintOutput(0, "");
|
|
|
- $this->PrintOutput(0, "{\$ifdef RECORDS}");
|
|
|
- $this->PrintOutput(0, "{\$ifndef $macro"."_PAS_R}");
|
|
|
- $this->PrintOutput(0, "{\$define $macro"."_PAS_R}");
|
|
|
- $this->PrintRecords($header);
|
|
|
- $this->PrintOutput(0, "");
|
|
|
- $this->PrintOutput(0, "{\$endif}");
|
|
|
- $this->PrintOutput(0, "{\$endif}");
|
|
|
-
|
|
|
- $this->PrintOutput(0, "");
|
|
|
- $this->PrintOutput(0, "{\$ifdef FUNCTIONS}");
|
|
|
- $this->PrintOutput(0, "{\$ifndef $macro"."_PAS_F}");
|
|
|
- $this->PrintOutput(0, "{\$define $macro"."_PAS_F}");
|
|
|
- $this->PrintFunctions($header);
|
|
|
- $this->PrintOutput(0, "");
|
|
|
- $this->PrintOutput(0, "{\$endif}");
|
|
|
- $this->PrintOutput(0, "{\$endif}");
|
|
|
-
|
|
|
- $this->PrintOutput(0, "");
|
|
|
- $this->PrintOutput(0, "{\$ifdef CALLBACKS}");
|
|
|
- $this->PrintOutput(0, "{\$ifndef $macro"."_PAS_F}");
|
|
|
- $this->PrintOutput(0, "{\$define $macro"."_PAS_F}");
|
|
|
- $this->PrintCallBacks($header);
|
|
|
- $this->PrintOutput(0, "");
|
|
|
- $this->PrintOutput(0, "{\$endif}");
|
|
|
- $this->PrintOutput(0, "{\$endif}");
|
|
|
-
|
|
|
- $this->PrintOutput(0, "");
|
|
|
- $this->PrintOutput(0, "{\$ifdef EXTERNAL_SYMBOLS}");
|
|
|
- $this->PrintOutput(0, "{\$ifndef $macro"."_PAS_T}");
|
|
|
- $this->PrintOutput(0, "{\$define $macro"."_PAS_T}");
|
|
|
- $this->PrintExternalSymbols($header);
|
|
|
- $this->PrintOutput(0, "");
|
|
|
- $this->PrintOutput(0, "{\$endif}");
|
|
|
- $this->PrintOutput(0, "{\$endif}");
|
|
|
-
|
|
|
- if ($header["classes"]) {
|
|
|
- $this->PrintOutput(0, "");
|
|
|
- $this->PrintOutput(0, "{\$ifdef FORWARD}");
|
|
|
-
|
|
|
- foreach ($header["classes"] as $class) {
|
|
|
- // if the class contains methods make a forward declaration, otherwise a dummy class to NSObject
|
|
|
- if (count($class["all"]) > 0) {
|
|
|
- $this->PrintOutput(1, $class["name"]." = class;");
|
|
|
- } else {
|
|
|
- $this->PrintOutput(1, $class["name"]." = NSObject;");
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- $this->PrintOutput(0, "");
|
|
|
- $this->PrintOutput(0, "{\$endif}");
|
|
|
- }
|
|
|
-
|
|
|
- if ($header["classes"]) {
|
|
|
- $this->PrintOutput(0, "");
|
|
|
- $this->PrintOutput(0, "{\$ifdef CLASSES}");
|
|
|
- $this->PrintOutput(0, "{\$ifndef $macro"."_PAS_C}");
|
|
|
- $this->PrintOutput(0, "{\$define $macro"."_PAS_C}");
|
|
|
-
|
|
|
- foreach ($header["classes"] as $class) {
|
|
|
- if (in_array($class["name"], $this->cocoa_classes)) {
|
|
|
- $this->PrintClass($class);
|
|
|
- //print(" - Printed class ".$class["name"]."\n");
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- $this->PrintOutput(0, "");
|
|
|
- $this->PrintOutput(0, "{\$endif}");
|
|
|
- $this->PrintOutput(0, "{\$endif}");
|
|
|
- }
|
|
|
-
|
|
|
- $this->PrintOutput(0, "");
|
|
|
- $this->PrintOutput(0, "{\$ifdef PROTOCOLS}");
|
|
|
- $this->PrintOutput(0, "{\$ifndef $macro"."_PAS_P}");
|
|
|
- $this->PrintOutput(0, "{\$define $macro"."_PAS_P}");
|
|
|
- $this->PrintHeaderProtocols($header, false);
|
|
|
- $this->PrintOutput(0, "");
|
|
|
- $this->PrintOutput(0, "{\$endif}");
|
|
|
- $this->PrintOutput(0, "{\$endif}");
|
|
|
-
|
|
|
- $this->PrintOutput(0, "");
|
|
|
- $this->PrintOutput(0, "{\$ifdef IMPLEMENTATION}");
|
|
|
-
|
|
|
- $this->PrintHeaderProtocols($header, true);
|
|
|
-
|
|
|
- if ($header["classes"]) {
|
|
|
- foreach ($header["classes"] as $class) {
|
|
|
- if (in_array($class["name"], $this->cocoa_classes)) {
|
|
|
- $this->PrintClassImplementation($class);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- $this->PrintOutput(0, "{\$endif}");
|
|
|
- }
|
|
|
-
|
|
|
- // Prints all headers parsed
|
|
|
- function PrintAllHeaders ($output_path, $ignore_output, $only_files, $print_header_references) {
|
|
|
-
|
|
|
- foreach ($this->dump as $file => $header) {
|
|
|
- if (eregi("^[a-zA-Z]+\.h", $file)) {
|
|
|
-
|
|
|
- // ignore these files
|
|
|
- if (@in_array($header["path_partial"], $ignore_output)) continue;
|
|
|
-
|
|
|
- // only parse these files
|
|
|
- if ((@count($only_files) > 0) && (@!in_array($header["name"], $only_files))) continue;
|
|
|
-
|
|
|
- $name_clean = substr($file, 0, (strripos($file, ".")));
|
|
|
-
|
|
|
- // assign output path
|
|
|
- if ($output_path != "") $header["path"] = $output_path."/".$name_clean.".inc";
|
|
|
-
|
|
|
- $this->PrintHeader($header);
|
|
|
-
|
|
|
- if ($print_header_references) $this->PrintHeaderReference($header, $this->root.$this->out."/reference/".$name_clean.".pas");
|
|
|
-
|
|
|
- print("* Printed $name_clean.h to ".$header["path"]."\n");
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- /**
|
|
|
- * PARSING METHODS
|
|
|
- */
|
|
|
-
|
|
|
- // Insert macro blocks to replace c-style blocks
|
|
|
- function InsertMacroBlocks ($line, &$in_macro_block) {
|
|
|
-
|
|
|
- // only insert if we are in a block already.
|
|
|
- // NOTE: this does not handle nesting!
|
|
|
- if ($in_macro_block) {
|
|
|
-
|
|
|
- // macro else statment
|
|
|
- if (eregi("#else", $line)) {
|
|
|
- return "{\$else}";
|
|
|
- }
|
|
|
-
|
|
|
- // macro endif statment
|
|
|
- if (eregi("#endif", $line)) {
|
|
|
- $in_macro_block = false;
|
|
|
- return "{\$endif}";
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- foreach ($this->macro_blocks as $key => $value) {
|
|
|
- if (eregi($key, $line, $captures)) {
|
|
|
- $in_macro_block = true;
|
|
|
-
|
|
|
- // replace the c-macro with a Pascal version
|
|
|
- if ($value == "*") {
|
|
|
- $captures[0] = trim($captures[0], "#");
|
|
|
- return "{\$".$captures[0]."}";
|
|
|
- } else {
|
|
|
- return "{".$value."}";
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- function ParseInstanceVariables ($line, &$struct) {
|
|
|
- $field = null;
|
|
|
- $field_bitpacked = false;
|
|
|
- //print("$line\n");
|
|
|
-
|
|
|
- // insert macros
|
|
|
- if ($macro = $this->InsertMacroBlocks($line, $this->inside_macro_block)) {
|
|
|
- if ($struct["valid"]) {
|
|
|
- $struct["fields"][] = $macro;
|
|
|
- return null;
|
|
|
- } else {
|
|
|
- return $macro;
|
|
|
- }
|
|
|
-
|
|
|
- }
|
|
|
- // got struct
|
|
|
- if (eregi("^[[:space:]]*struct.*{", $line)) {
|
|
|
- $struct["valid"] = true;
|
|
|
- return null;
|
|
|
- }
|
|
|
-
|
|
|
- if (eregi("^[[:space:]]*}[[:space:]]*([a-zA-Z_0-9]+);", $line, $captures)) {
|
|
|
- $struct["name"] = "_".trim($captures[1], " ");
|
|
|
- //print_r($struct);
|
|
|
- return "struct";
|
|
|
- }
|
|
|
-
|
|
|
- // set field prefix to protect scope
|
|
|
- if (!$struct["valid"]) $field_prefix = "_";
|
|
|
-
|
|
|
- // remove null-defined macros:
|
|
|
- $line = str_ireplace($this->null_macros, "", $line);
|
|
|
-
|
|
|
- // replace garbage collector hints in the field
|
|
|
- $line = $this->ReplaceGarbageCollectorHints($line, $garbage_collector_hint);
|
|
|
-
|
|
|
- if (ereg("^[[:space:]]*([a-zA-Z0-9_]+)[[:space:]]+([a-zA-Z0-9_]+)[[:space:]]+([a-zA-Z0-9_* ]+).*;", $line, $captures)) { // double-word single
|
|
|
-
|
|
|
- $name = trim($captures[3], "* ");
|
|
|
- $name = str_replace(" ", "", $name);
|
|
|
- $name = str_replace(" ", "", $name);
|
|
|
-
|
|
|
- if (eregi("^[[:space:]]*struct", $captures[1])) {
|
|
|
- $type = $captures[2];
|
|
|
- } else {
|
|
|
- $type = $captures[1]." ".$captures[2];
|
|
|
- }
|
|
|
-
|
|
|
- $type = $this->ReplaceObjcType($type);
|
|
|
- $type = $this->SwapObjcTypeWithReal($type);
|
|
|
- $type = $this->MakeFieldBitPacked($type, $line, $field_bitpacked);
|
|
|
- if ($this->IsKeywordReserved($name)) $name .= "_";
|
|
|
- if ($captures[3][0] == "*") $this->ReplacePointerType($type);
|
|
|
-
|
|
|
- $field = "$field_prefix$name: $type;";
|
|
|
- $field = $this->MakeFieldInlineArray($field, $line, $name, $type);
|
|
|
- $field = eregi_replace("<.*>", "", $field);
|
|
|
-
|
|
|
- } elseif (ereg("^[[:space:]]*([a-zA-Z0-9_]+)[[:space:]]+([a-zA-Z0-9_* ]+)(.*);", $line, $captures)) { // double-word type list
|
|
|
- $name = trim($captures[2], "* ");
|
|
|
- $name = str_replace(" ", "", $name);
|
|
|
- $name = str_replace(" ", "", $name);
|
|
|
-
|
|
|
- $type = $this->ReplaceObjcType($captures[1]);
|
|
|
- $type = $this->SwapObjcTypeWithReal($type);
|
|
|
- $type = $this->MakeFieldBitPacked($type, $line, $field_bitpacked);
|
|
|
- if ($this->IsKeywordReserved($name)) $name .= "_";
|
|
|
- if ($captures[2][0] == "*") $this->ReplacePointerType($type);
|
|
|
-
|
|
|
- $field = "$field_prefix$name: $type;";
|
|
|
- $field = $this->MakeFieldInlineArray($field, $line, $name, $type);
|
|
|
- $field = eregi_replace("<.*>", "", $field);
|
|
|
-
|
|
|
- } elseif (ereg("^[[:space:]]*([a-zA-Z0-9_*]+)(.*);", $line, $captures)) { // single word type list
|
|
|
- $name = trim($captures[2], "* ");
|
|
|
- $name = str_replace(" ", "", $name);
|
|
|
- $name = str_replace(" ", "", $name);
|
|
|
-
|
|
|
- $type = $this->ReplaceObjcType($captures[1]);
|
|
|
- $type = $this->SwapObjcTypeWithReal($type);
|
|
|
- $type = $this->MakeFieldBitPacked($type, $line, $field_bitpacked);
|
|
|
- if ($this->IsKeywordReserved($name)) $name .= "_";
|
|
|
- if ($captures[2][0] == "*") $this->ReplacePointerType($type);
|
|
|
- $type = trim($type, "*");
|
|
|
-
|
|
|
- $field = "$field_prefix$name: $type;";
|
|
|
- $field = $this->MakeFieldInlineArray($field, $line, $name, $type);
|
|
|
- $field = eregi_replace("<.*>", "", $field);
|
|
|
- }
|
|
|
-
|
|
|
- // mark the field as having a garbage collector field
|
|
|
- if ($garbage_collector_hint) $field = "$field {garbage collector: $garbage_collector_hint }";
|
|
|
-
|
|
|
- // return field
|
|
|
- if ($struct["valid"]) {
|
|
|
- if ($field_bitpacked) $struct["bitpacked"] = true;
|
|
|
- $struct["fields"][] = $field;
|
|
|
- } else {
|
|
|
- return $field;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- // Parses a struct field into a list
|
|
|
- function ParseStructList ($input, $name, $type) {
|
|
|
- $field = "";
|
|
|
-
|
|
|
- $list = explode(",", $input);
|
|
|
- if (count($list) > 1) {
|
|
|
- $field = " ";
|
|
|
- foreach ($list as $key) {
|
|
|
- $key = trim($key, " ");
|
|
|
- $field .= "$key, ";
|
|
|
- }
|
|
|
-
|
|
|
- $field = rtrim($field, ", ");
|
|
|
- $field .= ": $type;\n";
|
|
|
- } else {
|
|
|
- $field = " $name: $type;\n";
|
|
|
- }
|
|
|
-
|
|
|
- return $field;
|
|
|
- }
|
|
|
-
|
|
|
- // Parse external symbols, enums and typedef's from the header
|
|
|
- function ParseHeaderTypes ($file) {
|
|
|
- $contents = ReadTextFile($file);
|
|
|
- $file_name = substr($file, (strripos($file, "/")) + 1, strlen($file));
|
|
|
- $field_bitpacked = false;
|
|
|
-
|
|
|
- $lines = explode("\n", $contents);
|
|
|
- foreach ($lines as $line) {
|
|
|
-
|
|
|
- // skip blocks
|
|
|
- if ($this->SkipBlock($line)) continue;
|
|
|
-
|
|
|
- // garbage collector hints
|
|
|
- $line = $this->ReplaceGarbageCollectorHints($line, $garbage_collector_hint);
|
|
|
-
|
|
|
- // remove macros
|
|
|
- $line = $this->RemoveOSVersionMacros($line);
|
|
|
-
|
|
|
- // remove comments
|
|
|
- $line = $this->RemoveComments($line);
|
|
|
- $line = trim($line, " ");
|
|
|
-
|
|
|
- if ($got_struct) {
|
|
|
-
|
|
|
- // insert macros
|
|
|
- if ($macro = $this->InsertMacroBlocks($line, $this->inside_macro_block)) $struct_fields .= "$macro\n";
|
|
|
-
|
|
|
- // collect fields
|
|
|
- if (eregi("^[[:space:]]*([a-zA-Z0-9_*]+)[[:space:]]*[*]*\((.*)\)\((.*)\);", $line, $captures)) { // function pointer (callback)
|
|
|
- //continue;
|
|
|
- $name = trim($captures[2], "*");
|
|
|
- $result = $this->ReplaceNSTypesWithReal($captures[1]);
|
|
|
- $result = $this->ReplaceObjcType($result);
|
|
|
- $result = ": ".$this->SwapObjcTypeWithReal($result);
|
|
|
- if ($this->IsKeywordReserved($name)) $name .= "_";
|
|
|
-
|
|
|
- if ($captures[1] == "void") {
|
|
|
- $kind = "procedure";
|
|
|
- $result = "";
|
|
|
- } else {
|
|
|
- $kind = "function";
|
|
|
- }
|
|
|
-
|
|
|
- // ??? convert params to Pascal
|
|
|
- //$method = $this->ConvertFunctionPointerToPascal($result, $captures[3]);
|
|
|
- //$params = $method["param_string_clean"];
|
|
|
- $params = "context: Pointer {bad params!!}";
|
|
|
-
|
|
|
- $struct_fields .= " $name: $kind ($params)$result; cdecl;\n";
|
|
|
- //print("$name: $kind ($params)$result; cdecl;\n");
|
|
|
- } elseif (ereg("^[[:space:]]*([a-zA-Z0-9_]+)[[:space:]]+([a-zA-Z0-9_]+)[[:space:]]+([a-zA-Z0-9_* ]+)(.*);", $line, $captures)) { // double-word single
|
|
|
- $name = trim($captures[3], "* ");
|
|
|
- $name = str_replace(" ", "", $name);
|
|
|
- $name = str_replace(" ", "", $name);
|
|
|
- $type = $captures[1]." ".$captures[2];
|
|
|
- $type = $this->ReplaceObjcType($type);
|
|
|
- $type = $this->SwapObjcTypeWithReal($type);
|
|
|
- $type = $this->MakeFieldBitPacked($type, $line, $field_bitpacked);
|
|
|
- if ($this->IsKeywordReserved($name)) $name .= "_";
|
|
|
- if ($captures[3][0] == "*") $this->ReplacePointerType($type);
|
|
|
-
|
|
|
- //$struct_fields .= " $name: $type;\n";
|
|
|
- $struct_fields .= $this->ParseStructList($captures[3]+$captures[4], $name, $type);
|
|
|
-
|
|
|
- } elseif (ereg("^[[:space:]]*([a-zA-Z0-9_]+)[[:space:]]+([a-zA-Z0-9_* ]+)(.*);", $line, $captures)) { // double-word type list
|
|
|
- $name = trim($captures[2], "* ");
|
|
|
- $name = str_replace(" ", "", $name);
|
|
|
- $name = str_replace(" ", "", $name);
|
|
|
- $type = $this->ReplaceObjcType($captures[1]);
|
|
|
- $type = $this->SwapObjcTypeWithReal($type);
|
|
|
- $type = $this->MakeFieldBitPacked($type, $line, $field_bitpacked);
|
|
|
- if ($this->IsKeywordReserved($name)) $name .= "_";
|
|
|
- if ($captures[2][0] == "*") $this->ReplacePointerType($type);
|
|
|
-
|
|
|
- $struct_fields .= $this->ParseStructList("$captures[2]$captures[3]", $name, $type);
|
|
|
-
|
|
|
- } elseif (ereg("^[[:space:]]*([a-zA-Z0-9_* ]+)(.*);", $line, $captures)) { // single word type list
|
|
|
- $name = trim($captures[2], "* ");
|
|
|
- $captures[1] = str_replace(" ", "", $captures[1]);
|
|
|
- $captures[1] = str_replace(" ", "", $captures[1]);
|
|
|
- $type = $this->ReplaceObjcType($captures[1]);
|
|
|
- $type = $this->SwapObjcTypeWithReal($type);
|
|
|
- $type = $this->MakeFieldBitPacked($type, $line, $field_bitpacked);
|
|
|
- if ($this->IsKeywordReserved($name)) $name .= "_";
|
|
|
- if ($captures[2][0] == "*") $this->ReplacePointerType($type);
|
|
|
-
|
|
|
- //$struct_fields .= " $name: $type;\n";
|
|
|
- $struct_fields .= $this->ParseStructList($captures[2], $name, $type);
|
|
|
- }
|
|
|
-
|
|
|
-
|
|
|
- // got end of struct
|
|
|
- if (ereg("^}[[:space:]]*([a-zA-Z_0-9]+);", $line, $captures)) {
|
|
|
-
|
|
|
- if ($struct_name == "") {
|
|
|
- $struct_name = $captures[1];
|
|
|
- $make_pointer = true;
|
|
|
- } else {
|
|
|
- $struct_type = $captures[1];
|
|
|
- }
|
|
|
-
|
|
|
- if ($field_bitpacked) {
|
|
|
- $struct = "$struct_name = $this->bitpacked_record_keyword\n";
|
|
|
- } else {
|
|
|
- $struct = "$struct_name = $this->record_keyword\n";
|
|
|
- }
|
|
|
-
|
|
|
- $struct .= $struct_fields;
|
|
|
- $struct .= " end;\n";
|
|
|
- if (($struct_type) && ($struct_name != $struct_type)) {
|
|
|
- $struct .= "$struct_type = $struct_name;\n";
|
|
|
- // SEE NOTE BELOW
|
|
|
- //$struct .= $struct_type."Pointer = ^$struct_type;\n";
|
|
|
- $make_pointer = false;
|
|
|
- }
|
|
|
-
|
|
|
- // make an extra pointer for us since Pascal may need it
|
|
|
- // NOTE: remove this until we can protect against duplicate types
|
|
|
- //if ($make_pointer) $struct .= $struct_name."Pointer = ^$struct_name;\n";
|
|
|
-
|
|
|
- $this->dump[$file_name]["types"]["structs"][] = $struct;
|
|
|
- $this->dump["global_structs"][] = $struct_name;
|
|
|
- $got_struct = false;
|
|
|
- $field_bitpacked = false;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
-
|
|
|
- // got struct
|
|
|
- if (ereg("^typedef struct(.*){", $line, $captures)) {
|
|
|
-
|
|
|
- $struct_name = trim($captures[1], " ");
|
|
|
- $struct_type = null;
|
|
|
- $struct_fields = "";
|
|
|
-
|
|
|
- $make_pointer = false;
|
|
|
- $got_struct = true;
|
|
|
- }
|
|
|
-
|
|
|
- // integer #define
|
|
|
- if (ereg("#define[[:space:]]+([a-zA-Z0-9_]+)[[:space:]]+([0-9.]+)", $line, $captures)) {
|
|
|
- $this->dump[$file_name]["types"]["defines"][] = $captures[1]." = ".$captures[2].";";
|
|
|
- }
|
|
|
-
|
|
|
- // parse enum fields
|
|
|
- if (($got_enum) || ($got_named_enum)) {
|
|
|
- //print($line."\n");
|
|
|
-
|
|
|
- // insert macros
|
|
|
- //if ($macro = $this->InsertMacroBlocks($line, $this->inside_macro_block)) $this->dump[$file_name]["types"]["enums"][$block_count][] = $macro;
|
|
|
-
|
|
|
- if (ereg("^[[:space:]]*([a-zA-Z0-9_]+)[[:space:]]*=[[:space:]]*([a-zA-Z_]+)[,]*[[:space:]]*$", $line, $captures)) { // string value
|
|
|
- $captures[2] = trim($captures[2], ", ");
|
|
|
- $this->dump[$file_name]["types"]["enums"][$block_count][] = $captures[1]." = ".$captures[2].";";
|
|
|
- } elseif (ereg("^[[:space:]]*([a-zA-Z0-9_]+)[[:space:]]*=[[:space:]]*([0-9-]+)[,]*[[:space:]]*$", $line, $captures)) { // integer value
|
|
|
- $captures[2] = trim($captures[2], ", ");
|
|
|
- $this->dump[$file_name]["types"]["enums"][$block_count][] = $captures[1]." = ".$captures[2].";";
|
|
|
- } elseif (ereg("^[[:space:]]*([a-zA-Z0-9_]+)[[:space:]]*=[[:space:]]*([0-9]+[xX]+[a-fA-F0-9]+)", $line, $captures)) { // hexadecimal value
|
|
|
- $captures[2] = trim($captures[2], ", ");
|
|
|
- $captures[2] = eregi_replace("^0x", "$", $captures[2]);
|
|
|
- $this->dump[$file_name]["types"]["enums"][$block_count][] = $captures[1]." = ".$captures[2].";";
|
|
|
- } elseif (ereg("^[[:space:]]*([a-zA-Z0-9_]+)[[:space:]]*=[[:space:]]*([0-9]+[[:space:]]*<<[[:space:]]*[0-9]+)", $line, $captures)) { // << shl value, no ()
|
|
|
- $captures[2] = str_replace("<<", " shl ", $captures[2]);
|
|
|
- $this->dump[$file_name]["types"]["enums"][$block_count][] = $captures[1]." = ".$captures[2].";";
|
|
|
- } elseif (ereg("^[[:space:]]*([a-zA-Z0-9_]+)[[:space:]]*=[[:space:]]*\(([0-9]+[[:space:]]*<<[[:space:]]*[0-9]+)\)", $line, $captures)) { // << shl value
|
|
|
- $captures[2] = trim($captures[2], ", ");
|
|
|
- $captures[2] = str_replace("<<", " shl ", $captures[2]);
|
|
|
- $this->dump[$file_name]["types"]["enums"][$block_count][] = $captures[1]." = ".$captures[2].";";
|
|
|
- } elseif (ereg("^[[:space:]]*([a-zA-Z0-9_]+)[[:space:]]*[,}]*[[:space:]]*$", $line, $captures)) { // non-value
|
|
|
-
|
|
|
- // omit lines which started nested structures.
|
|
|
- // bad practice but the single-line regex parser can't handle them
|
|
|
- if (!eregi("[=|]+", $line)) {
|
|
|
- $captures[1] = trim($captures[1], ", ");
|
|
|
- $this->dump[$file_name]["types"]["enums"][$block_count][] = $captures[1]." = ".$auto_increment.";";
|
|
|
- $auto_increment ++;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- // found the end
|
|
|
- if (ereg("^};", $line)) $got_enum = false;
|
|
|
- }
|
|
|
-
|
|
|
- // ==== got enum ===
|
|
|
- if (ereg("^enum {", $line)) {
|
|
|
- $got_enum = true;
|
|
|
- $block_count ++;
|
|
|
- $auto_increment = 0;
|
|
|
- }
|
|
|
-
|
|
|
- // terminate named enum
|
|
|
- if ($got_named_enum) {
|
|
|
- if (ereg("^}[[:space:]]*([a-zA-Z0-9_]+);", $line, $captures)) {
|
|
|
- $got_named_enum = false;
|
|
|
-
|
|
|
- $named_enum = trim($named_enum, ", \n");
|
|
|
-
|
|
|
- $this->dump[$file_name]["types"]["named_enums"][] = "$captures[1] = culong;";
|
|
|
- $this->dump["global_types"][$captures[1]] = $captures[1];
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- // ==== got named enum ===
|
|
|
- if (ereg("^typedef enum {", $line)) {
|
|
|
- $got_named_enum = true;
|
|
|
- $named_enum = "";
|
|
|
- $auto_increment = 0;
|
|
|
- $block_count ++;
|
|
|
- }
|
|
|
-
|
|
|
- // ==== external string constant ===
|
|
|
- if (eregi("^($this->external_string_macros)+[[:space:]]+NSString[[:space:]]+\*[[:space:]]*(const)*[[:space:]]*([a-zA-Z_]+);", $line, $captures)) {
|
|
|
- $name = $captures[3];
|
|
|
-
|
|
|
- if (in_array($name, $this->ignore_symbol)) continue;
|
|
|
-
|
|
|
- $this->dump[$file_name]["types"]["string_constant"][] = "$name: $this->string_macro; external name '_$name';";
|
|
|
- }
|
|
|
-
|
|
|
- // ==== external symbol ===
|
|
|
- if (eregi("^($this->external_string_macros)+[[:space:]]+([a-zA-Z_ ]+)[[:space:]]+([a-zA-Z_]+);", $line, $captures)) {
|
|
|
- $name = $captures[3];
|
|
|
- $type = $captures[2];
|
|
|
-
|
|
|
- // ignore symbols
|
|
|
- if (in_array($name, $this->ignore_symbol)) continue;
|
|
|
-
|
|
|
- $type = istr_replace_word("const", "", $type);
|
|
|
- $type = trim($type, " ");
|
|
|
-
|
|
|
- $this->dump[$file_name]["types"]["external_symbol"][] = "$name: $type; external name '_$name';";
|
|
|
- }
|
|
|
-
|
|
|
-
|
|
|
- // ==== external procedures ===
|
|
|
- if (ereg("^($this->external_string_macros)+[[:space:]]+(.*)[[:space:]]+(\*)*([a-zA-Z0-9_]+)\((.*)\)", $line, $captures)) {
|
|
|
-
|
|
|
- $result = $this->ConvertReturnType($captures[2]);
|
|
|
- $name = $captures[4];
|
|
|
- $params = "";
|
|
|
- $captures[2] = trim($captures[2], " ");
|
|
|
- $captures[5] = trim($captures[5], " ");
|
|
|
-
|
|
|
- // ignore symbols
|
|
|
- if (in_array($name, $this->ignore_symbol)) continue;
|
|
|
-
|
|
|
- if ($captures[5] != "void") $params = "(".$this->ConvertCParamsPascal($captures[5]).")";
|
|
|
-
|
|
|
- if ($captures[2] == "void") {
|
|
|
- $this->dump[$file_name]["types"]["functions"][] = "procedure $name$params; cdecl; external name '$name';";
|
|
|
- } else {
|
|
|
- $this->dump[$file_name]["types"]["functions"][] = "function $name$params: $result; cdecl; external name '$name';";
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- // ==== got typedef ===
|
|
|
- if (ereg("^typedef[[:space:]]+struct[[:space:]]+([a-zA-Z0-9_]+)[[:space:]]+([a-zA-Z0-9_]+);", $line, $captures)) { // defined struct type
|
|
|
- $real_type = $captures[1];
|
|
|
- $struct_type = $captures[1];
|
|
|
- $new_type = $captures[2];
|
|
|
-
|
|
|
- $this->AddTypeDef($this->dump[$file_name], "$struct_type = Pointer;");
|
|
|
-
|
|
|
- $struct_type = $this->ReplaceObjcType($struct_type);
|
|
|
- $struct_type = $this->SwapObjcTypeWithReal($struct_type);
|
|
|
- $this->AddTypeDef($this->dump[$file_name], "$new_type = $struct_type;");
|
|
|
-
|
|
|
- $this->dump["global_types"][$struct_type] = "Pointer";
|
|
|
- $this->dump["global_types"][$new_type] = $real_type;
|
|
|
- } elseif (ereg("^typedef[[:space:]]+struct[[:space:]]+([a-zA-Z0-9_]+)[[:space:]]+([a-zA-Z0-9_*]+);", $line, $captures)) { // pointer to struct
|
|
|
- $real_type = $captures[1];
|
|
|
- $clean_name = trim($captures[2], "*");
|
|
|
- $pointer_type = $captures[1];
|
|
|
-
|
|
|
- // ??? maybe check to see if this type exists like NSRect *NSRect is NSRectPointer which exists
|
|
|
- $pointer_type = "Pointer";
|
|
|
-
|
|
|
- //$captures[2] = $this->FormatObjcType($captures[2], $modifiers);
|
|
|
- //$this->dump[$file_name]["types"]["typedef"][] = "$pointer_type = Pointer;";
|
|
|
- $this->AddTypeDef($this->dump[$file_name], "$clean_name = $pointer_type;");
|
|
|
-
|
|
|
-
|
|
|
- //$this->dump["global_types"][$pointer_type] = "Pointer";
|
|
|
- $this->dump["global_types"][$clean_name] = $real_type;
|
|
|
- } elseif (ereg("^typedef[[:space:]]+(const)*[[:space:]]*struct[[:space:]]+([a-zA-Z0-9_*]+)[[:space:]]+([a-zA-Z0-9_]+);", $line, $captures)) { // struct type (complex)
|
|
|
- $real_type = $captures[1];
|
|
|
-
|
|
|
- $captures[2] = $this->FormatObjcType($captures[2], $modifiers);
|
|
|
- $this->AddTypeDef($this->dump[$file_name], $captures[3]." = ".$captures[2].";");
|
|
|
-
|
|
|
- $this->dump["global_types"][$captures[3]] = $real_type;
|
|
|
- } elseif (ereg("^typedef[[:space:]]+([a-zA-Z0-9_]+)[[:space:]]+([a-zA-Z0-9_*]+);", $line, $captures)) { // single-word type
|
|
|
- $real_type = $captures[1];
|
|
|
-
|
|
|
- // type is a pointer
|
|
|
- if ($captures[2][0] == "*") {
|
|
|
- $captures[2] = trim($captures[2], "*");
|
|
|
- $captures[1] = $this->ReplaceObjcType($captures[1]);
|
|
|
- $captures[1] = $this->SwapObjcTypeWithReal($captures[1]);
|
|
|
- $this->AddTypeDef($this->dump[$file_name], $captures[2]." = ^".$captures[1].";");
|
|
|
-
|
|
|
- $this->dump["global_types"][$captures[2]] = $real_type;
|
|
|
- } else {
|
|
|
- $captures[2] = trim($captures[2], "*");
|
|
|
- $captures[1] = $this->ReplaceObjcType($captures[1]);
|
|
|
- $captures[1] = $this->SwapObjcTypeWithReal($captures[1]);
|
|
|
- $this->AddTypeDef($this->dump[$file_name],$captures[2]." = ".$captures[1].";");
|
|
|
-
|
|
|
- $this->dump["global_types"][$captures[2]] = $real_type;
|
|
|
- }
|
|
|
- } elseif (ereg("^typedef[[:space:]]+([a-zA-Z0-9_]+)[[:space:]]+([a-zA-Z0-9_]+)[[:space:]]+([a-zA-Z0-9_*]+);", $line, $captures)) { // double-word type
|
|
|
- $real_type = $captures[1];
|
|
|
-
|
|
|
- $captures[3] = trim($captures[3], "*");
|
|
|
- $long_type = $captures[1]." ".$captures[2];
|
|
|
- $long_type = $this->ReplaceObjcType($long_type);
|
|
|
- $long_type = $this->SwapObjcTypeWithReal($long_type);
|
|
|
- $this->AddTypeDef($this->dump[$file_name], $captures[3]." = $long_type;");
|
|
|
-
|
|
|
- $this->dump["global_types"][$captures[3]] = $real_type;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- //print_r($this->dump[$file_name]["types"]);
|
|
|
- }
|
|
|
-
|
|
|
- // Parse all protocols in a header
|
|
|
- function ParseHeaderProtocols ($file) {
|
|
|
- $contents = ReadTextFile($file);
|
|
|
- $file_name = substr($file, (strripos($file, "/")) + 1, strlen($file));
|
|
|
-
|
|
|
- $lines = explode("\n", $contents);
|
|
|
- foreach ($lines as $line) {
|
|
|
-
|
|
|
- // parse protocol
|
|
|
- if ($got_protocol) {
|
|
|
-
|
|
|
- // remove comments
|
|
|
- $line = $this->RemoveComments($line);
|
|
|
-
|
|
|
- // found property
|
|
|
- if (eregi($this->regex_objc_property, $line, $captures)) {
|
|
|
- $property = $this->ParseClassProperty($current_protocol, $captures);
|
|
|
-
|
|
|
- if ($property["setter"]) {
|
|
|
- $this->current_header["protocols"][$current_protocol]["methods"][$method["objc_method"]] = $property["setter"];
|
|
|
- }
|
|
|
-
|
|
|
- if ($property["getter"]) {
|
|
|
- $this->current_header["protocols"][$current_protocol]["methods"][$method["objc_method"]] = $property["getter"];
|
|
|
- }
|
|
|
-
|
|
|
- continue;
|
|
|
- }
|
|
|
-
|
|
|
- // found method
|
|
|
- $method = null;
|
|
|
- if (eregi($this->regex_objc_method_params, $line, $captures)) {
|
|
|
- $method = $this->ConvertObjcMethodToPascal($current_protocol, $line, $captures, array(), true);
|
|
|
- } elseif (eregi($this->regex_objc_method_no_params, $line, $captures)) {
|
|
|
- $method = $this->ConvertObjcMethodToPascal($current_protocol, $line, $captures, array(), false);
|
|
|
- }
|
|
|
-
|
|
|
- // append to classes
|
|
|
- if (($method) && (!in_array($current_protocol, $this->ignore_categories)) && (!in_array($method["name"], $this->ignore_methods)) ) {
|
|
|
- $this->current_header["protocols"][$current_protocol]["methods"][$method["objc_method"]] = $method;
|
|
|
- }
|
|
|
-
|
|
|
- // found the end
|
|
|
- if (ereg("^@end", $line)) $got_protocol = false;
|
|
|
- }
|
|
|
-
|
|
|
- // got protocol
|
|
|
- if ((eregi($this->regex_objc_protocol, $line, $captures)) && (!eregi(".*;$", $line))) {
|
|
|
- $got_protocol = true;
|
|
|
- $current_protocol = $captures[1];
|
|
|
- print("+ Protocol $current_protocol\n");
|
|
|
- $this->current_header["protocols"][$current_protocol]["name"] = $captures[1];
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- //print_r($this->current_class);
|
|
|
- }
|
|
|
-
|
|
|
-
|
|
|
- // Parse all categories in a header
|
|
|
- function ParseHeaderCategories ($file) {
|
|
|
- $contents = ReadTextFile($file);
|
|
|
- $file_name = substr($file, (strripos($file, "/")) + 1, strlen($file));
|
|
|
-
|
|
|
- $lines = explode("\n", $contents);
|
|
|
- foreach ($lines as $line) {
|
|
|
-
|
|
|
- // parse category
|
|
|
- if ($got_category) {
|
|
|
-
|
|
|
- // remove comments
|
|
|
- $line = $this->RemoveComments($line);
|
|
|
-
|
|
|
- // found property
|
|
|
- if (eregi($this->regex_objc_property, $line, $captures)) {
|
|
|
- $property = $this->ParseClassProperty($current_category, $captures);
|
|
|
-
|
|
|
- if ($property["setter"]) {
|
|
|
- if ($this->AddMethodToClass($property["setter"], $this->current_class)) {
|
|
|
- $this->dump[$category_owner]["classes"][$current_class]["categories"][$current_category]["methods"][] = $property["setter"];
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- if ($property["getter"]) {
|
|
|
- if ($this->AddMethodToClass($property["getter"], $this->current_class)) {
|
|
|
- $this->dump[$category_owner]["classes"][$current_class]["categories"][$current_category]["methods"][] = $property["getter"];
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- continue;
|
|
|
- }
|
|
|
-
|
|
|
- // found method
|
|
|
- $method = null;
|
|
|
- if (eregi($this->regex_objc_method_params, $line, $captures)) {
|
|
|
- $method = $this->ConvertObjcMethodToPascal($current_category, $line, $captures, $this->GetProtectedKeywords($this->current_class), true);
|
|
|
- } elseif (eregi($this->regex_objc_method_no_params, $line, $captures)) {
|
|
|
- $method = $this->ConvertObjcMethodToPascal($current_category, $line, $captures, $this->GetProtectedKeywords($this->current_class), false);
|
|
|
- }
|
|
|
-
|
|
|
- // append to classes
|
|
|
- if (($method) && (!in_array($method["name"], $this->ignore_categories))) {
|
|
|
- if ($current_class) {
|
|
|
- if ($this->AddMethodToClass($method, $this->current_class)) {
|
|
|
- $this->dump[$category_owner]["classes"][$current_class]["categories"][$current_category]["methods"][] = $method;
|
|
|
- }
|
|
|
- } else {
|
|
|
-
|
|
|
- // add base categories to NSObject
|
|
|
- if (in_array($current_category, $this->base_categories)) {
|
|
|
- if ($this->AddMethodToClass($method, $this->dump["NSObject.h"]["classes"]["NSObject"])) {
|
|
|
- $this->dump["NSObject.h"]["classes"]["NSObject"]["categories"][$current_category]["methods"][] = $method;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- $this->dump["categories"][$current_category]["methods"][$method["objc_method"]] = $method;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- // found the end
|
|
|
- if (ereg("^@end", $line)) $got_category = false;
|
|
|
- }
|
|
|
-
|
|
|
- // got category
|
|
|
- if (eregi($this->regex_objc_category, $line, $captures)) {
|
|
|
-
|
|
|
- // ??? if the current header is NSObject, then we DO want to accept these categories, they are NOT delegates this time...
|
|
|
-
|
|
|
- // append category to it's super class
|
|
|
- $category_owner = $this->FindCategoryHeader($captures[1]);
|
|
|
- if (($category_owner) && ($captures[1] != "NSObject")) {
|
|
|
- $got_category = true;
|
|
|
- $current_category = $captures[2];
|
|
|
- $current_class = $captures[1];
|
|
|
- $this->current_class = &$this->dump[$category_owner]["classes"][$current_class];
|
|
|
-
|
|
|
- $this->dump[$category_owner]["classes"][$current_class]["categories"][$current_category]["name"] = $captures[2];
|
|
|
- $this->dump[$category_owner]["classes"][$current_class]["categories"][$current_category]["super"] = $captures[1];
|
|
|
-
|
|
|
- print(" -> Category $current_category belongs to $current_class in $category_owner\n");
|
|
|
- } else {
|
|
|
-
|
|
|
- if ($captures[1] == "NSObject") {
|
|
|
- print(" + Category ".$captures[2]."->".$captures[1]." belongs to NSObject\n");
|
|
|
- $got_category = true;
|
|
|
- } else {
|
|
|
- $this->warning_count ++;
|
|
|
- print("# WARNING: Category ".$captures[2]." (".$captures[1].") has no header\n");
|
|
|
- $got_category = false;
|
|
|
- }
|
|
|
-
|
|
|
- $current_category = $captures[2];
|
|
|
- $current_class = null;
|
|
|
-
|
|
|
- $this->dump["categories"][$current_category]["name"] = $captures[2];
|
|
|
- $this->dump["categories"][$current_category]["super"] = $captures[1];
|
|
|
- }
|
|
|
-
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- //print_r($this->current_class);
|
|
|
- }
|
|
|
-
|
|
|
- // Parse all "pre-defined" category methods in a header
|
|
|
- function PreparseCategoryMethods ($file) {
|
|
|
- $contents = ReadTextFile($file);
|
|
|
- $file_name = substr($file, (strripos($file, "/")) + 1, strlen($file));
|
|
|
-
|
|
|
- $lines = explode("\n", $contents);
|
|
|
- foreach ($lines as $line) {
|
|
|
-
|
|
|
- // parse category
|
|
|
- if ($got_category) {
|
|
|
-
|
|
|
- // found method
|
|
|
- $method = null;
|
|
|
- if (eregi($this->regex_objc_method_params, $line, $captures)) {
|
|
|
- $method = $this->ConvertObjcMethodToPascal($current_category, $line, $captures, array(), true);
|
|
|
- } elseif (eregi($this->regex_objc_method_no_params, $line, $captures)) {
|
|
|
- $method = $this->ConvertObjcMethodToPascal($current_category, $line, $captures, array(), false);
|
|
|
- }
|
|
|
-
|
|
|
- // append to classes
|
|
|
- if (($method) && ($current_class)) {
|
|
|
- $this->dump[$category_owner]["category_methods"][] = $method["name"];
|
|
|
- //print($method["name"]."\n");
|
|
|
- }
|
|
|
-
|
|
|
- // found the end
|
|
|
- if (ereg("^@end", $line)) $got_category = false;
|
|
|
- }
|
|
|
-
|
|
|
- // got category
|
|
|
- if (eregi($this->regex_objc_category, $line, $captures)) {
|
|
|
- $category_owner = $this->FindCategoryHeader($captures[1]);
|
|
|
- if ($category_owner) {
|
|
|
- $got_category = true;
|
|
|
- $current_category = $captures[2];
|
|
|
- $current_class = $captures[1];
|
|
|
- } else {
|
|
|
- $current_class = null;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- return $this->dump[$category_owner]["category_methods"];
|
|
|
- }
|
|
|
-
|
|
|
- // Preparses a class for protected keywords
|
|
|
- function PreparseClass ($lines, $line_count) {
|
|
|
- $protected_keywords = array();
|
|
|
-
|
|
|
- for ($i=$line_count; $i < count($lines); $i++) {
|
|
|
- $line = $lines[$i - 1];
|
|
|
-
|
|
|
- // found method
|
|
|
- if (eregi($this->regex_objc_method_params, $line, $captures)) {
|
|
|
- $method = $this->ConvertObjcMethodToPascal($current, $line, $captures, $protected_keywords, true);
|
|
|
- $this->current_class["protected_keywords"][] = $method["name"];
|
|
|
- } elseif (eregi($this->regex_objc_method_no_params, $line, $captures)) {
|
|
|
- $method = $this->ConvertObjcMethodToPascal($current, $line, $captures, $protected_keywords, false);
|
|
|
- $this->current_class["protected_keywords"][] = $method["name"];
|
|
|
- }
|
|
|
-
|
|
|
- // class ended
|
|
|
- if (ereg("^@end", $line)) return $protected_keywords;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- // Gets the preferred property name from attributes
|
|
|
- function GetPropertyName ($kind, $params, &$name) {
|
|
|
- foreach ($params as $value) {
|
|
|
- $pair = explode("=", $value);
|
|
|
-
|
|
|
- if ($pair[0] == $kind) {
|
|
|
- $name = $pair[1];
|
|
|
- return true;
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- // Convert a method return type to Pascal
|
|
|
- function ConvertReturnType ($type) {
|
|
|
- $type = trim($type, " ");
|
|
|
- $type = $this->ReplaceObjcType($type);
|
|
|
-
|
|
|
- // if the type was not converted remove the * and process further
|
|
|
- $type = trim($type, "* ");
|
|
|
- $type = $this->ReplaceObjcType($type);
|
|
|
-
|
|
|
- // format the return type again to make sure it's clean
|
|
|
- $type = $this->FormatObjcType($type, $null_modifier);
|
|
|
-
|
|
|
- return $type;
|
|
|
- }
|
|
|
-
|
|
|
- // Parse a property into accessor methods
|
|
|
- function ParseClassProperty ($class, $parts) {
|
|
|
- $property["parameters"] = explode(",", $parts[1]);
|
|
|
- $method = array();
|
|
|
-
|
|
|
- // property name
|
|
|
- if (eregi("([a-zA-Z0-9]+)$", $parts[2], $captures)) $property["name"] = ucwords($captures[1]);
|
|
|
-
|
|
|
- // property type
|
|
|
- $type = istr_replace_word($captures[1], "", $parts[2]);
|
|
|
- $type = $this->ConvertReturnType($type);
|
|
|
-
|
|
|
- // setter
|
|
|
- if (!in_array("readonly", $property["parameters"])) {
|
|
|
- $method["setter"] = array();
|
|
|
-
|
|
|
- $name = $property["name"];
|
|
|
- if (!$this->GetPropertyName("setter", $property["parameters"], $name)) {
|
|
|
- $name = "set$name";
|
|
|
- }
|
|
|
-
|
|
|
- // protect method name from keywords
|
|
|
- if ($this->IsKeywordReserved($name)) $name .= "_";
|
|
|
-
|
|
|
- $method["setter"]["def"] = "procedure $name (newValue: $type);";
|
|
|
- $method["setter"]["objc_method"] = "$name:";
|
|
|
- $method["setter"]["class"] = $class;
|
|
|
- $method["setter"]["name"] = $name;
|
|
|
- $method["setter"]["kind"] = "procedure";
|
|
|
- }
|
|
|
-
|
|
|
- // getter
|
|
|
- $method["getter"] = array();
|
|
|
-
|
|
|
- $name = $property["name"];
|
|
|
- if (!$this->GetPropertyName("getter", $property["parameters"], $name)) {
|
|
|
- $name = strtolower(substr($name, 0, 1)) . substr($name, 1);
|
|
|
- }
|
|
|
-
|
|
|
- // protect method name from keywords
|
|
|
- if ($this->IsKeywordReserved($name)) $name .= "_";
|
|
|
-
|
|
|
- $method["getter"]["def"] = "function $name: $type;";
|
|
|
- $method["getter"]["objc_method"] = $name;
|
|
|
- $method["getter"]["class"] = $class;
|
|
|
- $method["getter"]["name"] = $name;
|
|
|
- $method["getter"]["kind"] = "function";
|
|
|
-
|
|
|
- return $method;
|
|
|
- }
|
|
|
-
|
|
|
- // Main entry to parse a header
|
|
|
- function ParseHeaderClasses ($file) {
|
|
|
- $contents = ReadTextFile($file);
|
|
|
-
|
|
|
- $file_name = substr($file, (strripos($file, "/")) + 1, strlen($file));
|
|
|
- $line_count = 0;
|
|
|
-
|
|
|
- $lines = explode("\n", $contents);
|
|
|
- foreach ($lines as $line) {
|
|
|
- $line_count++;
|
|
|
-
|
|
|
- // remove external class macros
|
|
|
- $line = eregi_replace("^[A-Z0-9]+_EXTERN_CLASS[[:space:]]+", "", $line);
|
|
|
-
|
|
|
- // parse instance vars
|
|
|
- if ($got_instance_vars) {
|
|
|
-
|
|
|
- // scope compiler directive
|
|
|
- if (eregi($this->regex_scope_compiler_directive, $line, $captures)) {
|
|
|
- $this->instance_var_scope = $captures[1];
|
|
|
- continue;
|
|
|
- }
|
|
|
-
|
|
|
- // remove comments
|
|
|
- $line = $this->RemoveComments($line);
|
|
|
-
|
|
|
- // parse instance variables
|
|
|
- $result = $this->ParseInstanceVariables($line, $struct);
|
|
|
-
|
|
|
- // parse structures
|
|
|
- if ($result == "struct") {
|
|
|
- //print_r($struct);
|
|
|
- //$this->dump[$file_name]["classes"][$current]["ivars"][] = $struct["name"].": $current"."_".$struct["name"].";";
|
|
|
- $this->dump[$file_name]["classes"][$current]["ivars_structs"][] = $struct;
|
|
|
-
|
|
|
- // print inline-record type
|
|
|
- if ($struct["bitpacked"]) {
|
|
|
- $this->dump[$file_name]["classes"][$current]["ivars"][] = $struct["name"].": ".$this->bitpacked_record_keyword;
|
|
|
- } else {
|
|
|
- $this->dump[$file_name]["classes"][$current]["ivars"][] = $struct["name"].": ".$this->record_keyword;
|
|
|
- }
|
|
|
-
|
|
|
-
|
|
|
- // print fields
|
|
|
- if ($struct["fields"]) {
|
|
|
- foreach ($struct["fields"] as $field) $this->dump[$file_name]["classes"][$current]["ivars"][] = " ".$field;
|
|
|
- }
|
|
|
- $this->dump[$file_name]["classes"][$current]["ivars"][] = " end;";
|
|
|
-
|
|
|
- $struct = null;
|
|
|
- } elseif($result != null) {
|
|
|
- //print($result);
|
|
|
- $this->dump[$file_name]["classes"][$current]["ivars"][] = $result;
|
|
|
- }
|
|
|
-
|
|
|
- // instance var section terminated.
|
|
|
- if (eregi("^\s*}\s*$", $line)) {
|
|
|
- $struct = null;
|
|
|
- $got_instance_vars = false;
|
|
|
- $this->instance_var_scope = null;
|
|
|
- }
|
|
|
-
|
|
|
- } elseif ($got_class) { // parse the class
|
|
|
-
|
|
|
- // the instance variable section started after the class line and no other ivar's were parsed yet
|
|
|
- if (!$this->dump[$file_name]["classes"][$current]["ivars"]) {
|
|
|
- if (eregi("{\s*$", $line)) {
|
|
|
- $got_instance_vars = true;
|
|
|
- continue;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- // remove comments
|
|
|
- $line = $this->RemoveComments($line);
|
|
|
-
|
|
|
- // found property
|
|
|
- if (eregi($this->regex_objc_property, $line, $captures)) {
|
|
|
- $property = $this->ParseClassProperty($current, $captures);
|
|
|
-
|
|
|
- if ($property["setter"]) {
|
|
|
- if ($this->AddMethodToClass($property["setter"], $this->dump[$file_name]["classes"][$current])) {
|
|
|
- $this->dump[$file_name]["classes"][$current]["methods"][] = $property["setter"];
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- if ($property["getter"]) {
|
|
|
- if ($this->AddMethodToClass($property["getter"], $this->dump[$file_name]["classes"][$current])) {
|
|
|
- $this->dump[$file_name]["classes"][$current]["methods"][] = $property["getter"];
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- continue;
|
|
|
- }
|
|
|
-
|
|
|
- // found method
|
|
|
- if (eregi($this->regex_objc_method_params, $line, $captures)) {
|
|
|
- $method = $this->ConvertObjcMethodToPascal($current, $line, $captures, $this->GetProtectedKeywords($this->current_class), true);
|
|
|
- if ($this->AddMethodToClass($method, $this->dump[$file_name]["classes"][$current])) {
|
|
|
- $this->dump[$file_name]["classes"][$current]["methods"][] = $method;
|
|
|
- }
|
|
|
-
|
|
|
- } elseif (eregi($this->regex_objc_method_no_params, $line, $captures)) {
|
|
|
- $method = $this->ConvertObjcMethodToPascal($current, $line, $captures, $this->GetProtectedKeywords($this->current_class), false);
|
|
|
- if ($this->AddMethodToClass($method, $this->dump[$file_name]["classes"][$current])) {
|
|
|
- $this->dump[$file_name]["classes"][$current]["methods"][] = $method;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- // found the end
|
|
|
- if (ereg("^@end", $line)) $got_class = false;
|
|
|
- }
|
|
|
-
|
|
|
- // ==== got class ====
|
|
|
- if ((eregi($this->regex_objc_class, $line, $captures)) || (eregi($this->regex_objc_class_no_super, $line, $captures))) {
|
|
|
- $current = $captures[1];
|
|
|
- $got_class = true;
|
|
|
-
|
|
|
- // check for instance variable section
|
|
|
- if (eregi("{\s*$", $line)) $got_instance_vars = true;
|
|
|
-
|
|
|
- // get the protocol which the class conforms to
|
|
|
- if (eregi($this->regex_objc_class, $line, $captures)) {
|
|
|
- if ($captures[3]) $this->dump[$file_name]["classes"][$current]["conforms"] = $captures[3];
|
|
|
- } else {
|
|
|
- if ($captures[2]) $this->dump[$file_name]["classes"][$current]["conforms"] = $captures[2];
|
|
|
- }
|
|
|
-
|
|
|
- // clean up the conforms string
|
|
|
- if ($this->dump[$file_name]["classes"][$current]["conforms"]) {
|
|
|
- $conform_protocols = explode(",", $this->dump[$file_name]["classes"][$current]["conforms"]);
|
|
|
-
|
|
|
- foreach ($conform_protocols as $protocol) {
|
|
|
- $protocol = trim($protocol, "<> ");
|
|
|
- $protocol_clean .= $protocol."$this->protocol_suffix, ";
|
|
|
- }
|
|
|
-
|
|
|
- $protocol_clean = trim($protocol_clean, ", ");
|
|
|
- $this->dump[$file_name]["classes"][$current]["conforms"] = $protocol_clean;
|
|
|
-
|
|
|
- $protocol_clean = "";
|
|
|
- }
|
|
|
-
|
|
|
- $this->dump[$file_name]["classes"][$current]["name"] = $captures[1];
|
|
|
- $this->dump[$file_name]["classes"][$current]["super"] = $captures[2];
|
|
|
- $this->dump[$file_name]["classes"][$current]["super_class"] = &$this->dump["master"][$captures[2]];
|
|
|
- $this->dump[$file_name]["classes"][$current]["file_name"] = $file_name;
|
|
|
- $this->dump[$file_name]["classes"][$current]["file_clean"] = substr($file_name, 0, (strripos($file_name, ".")));
|
|
|
- $this->dump[$file_name]["classes"][$current]["protected_keywords"] = array();
|
|
|
- $this->dump[$file_name]["classes"][$current]["declared_methods"] = array();
|
|
|
- $this->dump[$file_name]["category_methods"] = array();
|
|
|
-
|
|
|
- $this->current_class = &$this->dump[$file_name]["classes"][$current];
|
|
|
-
|
|
|
- // append master class listing
|
|
|
- $this->dump["master"][$current] = &$this->dump[$file_name]["classes"][$current];
|
|
|
-
|
|
|
- // preparse for protected keywords
|
|
|
- $this->PreparseClass($lines, $line_count);
|
|
|
-
|
|
|
- // preparse for category methods that may present naming conflicts
|
|
|
- $category_methods = $this->PreparseCategoryMethods($file);
|
|
|
-
|
|
|
- // add category methods to protected keywords
|
|
|
- if ($category_methods) $this->current_class["protected_keywords"] = array_merge($this->current_class["protected_keywords"], $category_methods);
|
|
|
-
|
|
|
- // print class hierarchy
|
|
|
- if ($this->show_class_hierarchy) {
|
|
|
- $this->GetClassHierarchy($this->current_class, $hierarchy);
|
|
|
- $hierarchy_string = "";
|
|
|
- foreach ($hierarchy as $value) {
|
|
|
- $hierarchy_string .= "$value->";
|
|
|
- }
|
|
|
- $hierarchy_string = trim($hierarchy_string, "->");
|
|
|
- print(" - $current: $hierarchy_string\n");
|
|
|
- }
|
|
|
-
|
|
|
- $this->class_count ++;
|
|
|
- //print_r($this->dump[$file_name]["classes"][$current]);
|
|
|
- }
|
|
|
-
|
|
|
- }
|
|
|
-
|
|
|
- //print_r($this->dump[$file_name]["classes"][$current]);
|
|
|
- }
|
|
|
-
|
|
|
- // Parse categories which depend on another header
|
|
|
- function ParseHeaderDependents ($file) {
|
|
|
- $file_name = substr($file, (strripos($file, "/")) + 1, strlen($file));
|
|
|
-
|
|
|
- $this->ParseHeaderCategories($file);
|
|
|
-
|
|
|
- print("+ Parsed $file_name for dependents\n");
|
|
|
- }
|
|
|
-
|
|
|
-
|
|
|
- // Main entry to parse a header
|
|
|
- function ParseHeader ($file) {
|
|
|
- $file_name = substr($file, (strripos($file, "/")) + 1, strlen($file));
|
|
|
- $name_clean = substr($file_name, 0, (strripos($file_name, ".")));
|
|
|
-
|
|
|
- // get framework we're parsing from
|
|
|
- if (eregi("/([a-zA-Z]+)\.framework/", $file, $captures)) $this->framework = strtolower($captures[1]);
|
|
|
-
|
|
|
- // get the output path
|
|
|
- $this->dump[$file_name]["path"] = "$this->root$this->out/$this->framework/$name_clean.inc";
|
|
|
- $this->dump[$file_name]["path_partial"] = "$this->framework/$name_clean.inc";
|
|
|
- $this->dump[$file_name]["framework"] = $this->framework;
|
|
|
- $this->dump[$file_name]["name"] = $file_name;
|
|
|
- $this->dump[$file_name]["name_clean"] = $name_clean;
|
|
|
- $this->current_header = &$this->dump[$file_name];
|
|
|
-
|
|
|
- $this->ParseHeaderProtocols($file);
|
|
|
- $this->ParseHeaderClasses($file);
|
|
|
- $this->ParseHeaderTypes($file);
|
|
|
-
|
|
|
- print("+ Parsed $file_name\n");
|
|
|
- }
|
|
|
-
|
|
|
- // Parse all AppKit and Foundation framework headers
|
|
|
- function ParseCocoaFrameworks ($ignore_files, $parse_only) {
|
|
|
-
|
|
|
- foreach ($this->frameworks as $framework_name => $framework_info) {
|
|
|
-
|
|
|
- // framework is disabled
|
|
|
- if ($framework_info["enabled"] != 1) continue;
|
|
|
-
|
|
|
- if ($this->out != "/") {
|
|
|
- $path = $this->root.$this->out."/".$framework_info["root"];
|
|
|
- } else {
|
|
|
- $path = $this->root.$framework_info["root"];
|
|
|
- }
|
|
|
-
|
|
|
- $contents = ReadTextFile($path);
|
|
|
- $lines = explode("\n", $contents);
|
|
|
-
|
|
|
- foreach ($lines as $line) {
|
|
|
- if (eregi($framework_info["include_pattern"], $line, $captures)) {
|
|
|
- $header = $captures[1].".h";
|
|
|
- $path = $framework_info["headers"]."/$header";
|
|
|
-
|
|
|
- // main header
|
|
|
- if ($parse_only) {
|
|
|
- if (@in_array($header, $parse_only)) $this->ParseHeader($path);
|
|
|
- } elseif (@!in_array($header, $ignore_files)) {
|
|
|
- $this->ParseHeader($path);
|
|
|
- }
|
|
|
-
|
|
|
- // header dependents
|
|
|
- if ($parse_only) {
|
|
|
- if (@in_array($header, $parse_only)) $this->ParseHeaderDependents($path);
|
|
|
- } elseif (@!in_array($header, $ignore_files)) {
|
|
|
- $this->ParseHeaderDependents($path);
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- }
|
|
|
-
|
|
|
- // diagnostics
|
|
|
- print("\n• Parsed $this->method_count methods in $this->class_count classes.\n\n");
|
|
|
-
|
|
|
- if ($this->warning_count > 0) print("• $this->warning_count warnings were encountered.\n\n");
|
|
|
- }
|
|
|
-
|
|
|
- // Parse headers in a system framework
|
|
|
- function ParseFramework ($ignore_files, $parse_only) {
|
|
|
- }
|
|
|
-
|
|
|
- // Parses XML file generated by GEN_BRIDGE_METADATA -f /System/Library/Frameworks/AppKit.framework/
|
|
|
- function ParseBridgeSupportXML ($file, $categories) {
|
|
|
- $contents = ReadTextFile($file);
|
|
|
-
|
|
|
- $lines = explode("\n", $contents);
|
|
|
- foreach ($lines as $line) {
|
|
|
-
|
|
|
- if ($got_informal_protocol) {
|
|
|
-
|
|
|
- if (eregi("<method type='(.*)' selector='(.*)'/>", $line, $captures)) {
|
|
|
-
|
|
|
- $set["name"] = $captures[2];
|
|
|
- $set["name_pascal"] = str_replace(":", "_", $set["name"]);
|
|
|
- $set["name_pascal"] = rtrim($set["name_pascal"], "_");
|
|
|
- $set["types"] = $captures[1];
|
|
|
- $set["param_string"] = $categories[$informal_protocol]["methods"][$captures[2]]["param_string"];
|
|
|
- $set["method"] = &$categories[$informal_protocol]["methods"][$captures[2]];
|
|
|
-
|
|
|
- if ($captures[1][0] == "v") {
|
|
|
- $set["kind"] = "procedure";
|
|
|
- } else {
|
|
|
- $set["kind"] = "function";
|
|
|
- }
|
|
|
-
|
|
|
- // add the selector if the name isn't reserved for Pascal
|
|
|
- if ((!in_array($set["name_pascal"], $this->reserved_keywords)) && (!in_array($set["name_pascal"], $this->reserved_methods))) {
|
|
|
- $this->delegate_methods[$informal_protocol][] = $set;
|
|
|
- $this->delegate_method_names[] = $set["name_pascal"];
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- // end tag
|
|
|
- if ($line == "</informal_protocol>") $got_informal_protocol = false;
|
|
|
- }
|
|
|
-
|
|
|
- // got informal_protocol
|
|
|
- if (eregi("<informal_protocol name='(.*)'>", $line, $captures)) {
|
|
|
- $informal_protocol = $captures[1];
|
|
|
- //print("\"$informal_protocol\", ");
|
|
|
- $got_informal_protocol = true;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- print("+ Parsed bridge support XMl file at $file\n");
|
|
|
- //print_r($this->delegate_methods);
|
|
|
- }
|
|
|
-
|
|
|
- // Parse all classes/categories (non-delegate) from the header
|
|
|
- function ParseAllHeaderClasses ($file) {
|
|
|
- $contents = ReadTextFile($file);
|
|
|
-
|
|
|
- $lines = explode("\n", $contents);
|
|
|
- foreach ($lines as $line) {
|
|
|
-
|
|
|
- // remove external class macros
|
|
|
- $line = eregi_replace("^[A-Z0-9]+_EXTERN_CLASS[[:space:]]+", "", $line);
|
|
|
-
|
|
|
- // classes
|
|
|
- if (eregi($this->regex_objc_class, $line, $captures)) $this->cocoa_classes[] = $captures[1];
|
|
|
- if (eregi($this->regex_objc_class_no_super, $line, $captures)) $this->cocoa_classes[] = $captures[1];
|
|
|
-
|
|
|
- // categories
|
|
|
- if (eregi($this->regex_objc_category, $line, $captures)) {
|
|
|
- $this->cocoa_categories[] = $captures[1];
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- // Build array of all known Cocoa classes in frameworks
|
|
|
- function BuildCocoaClasses () {
|
|
|
-
|
|
|
- foreach ($this->frameworks as $framework_name => $framework_info) {
|
|
|
-
|
|
|
- // framework is disabled
|
|
|
- if ($framework_info["enabled"] != 1) continue;
|
|
|
-
|
|
|
- $handle = opendir($framework_info["headers"]);
|
|
|
- while (($file = readdir($handle)) !== false) {
|
|
|
- if (eregi($framework_info["header_pattern"], $file)) {
|
|
|
- $this->ParseAllHeaderClasses($framework_info["headers"]."/$file");
|
|
|
- }
|
|
|
- }
|
|
|
- closedir($handle);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- function ProcessFile ($file, $print) {
|
|
|
- $this->ParseHeader($file);
|
|
|
- $this->ParseHeaderDependents($file);
|
|
|
-
|
|
|
- if ($print) $this->PrintAllHeaders("", null, null, false);
|
|
|
- }
|
|
|
-
|
|
|
- function ParseDelegateClasses () {
|
|
|
-
|
|
|
- foreach ($this->frameworks as $framework_name => $framework_info) {
|
|
|
-
|
|
|
- // framework is disabled
|
|
|
- if ($framework_info["enabled"] != 1) continue;
|
|
|
-
|
|
|
- $this->ParseBridgeSupportXML("$this->root".$framework_info["bridge"], $this->dump["categories"]);
|
|
|
- }
|
|
|
-
|
|
|
- // These are expressions which match valid class names or the names themself
|
|
|
- $delegate_categories = array( "(Delegation|Delegate|Notification|DataSource|Handler)+",
|
|
|
- "NSDraggingDestination", "NSDistantObjectRequestMethods", "NSDraggingSource",
|
|
|
- "NSEditorRegistration", "NSFileManagerFileOperationAdditions", "NSPasteboardOwner",
|
|
|
- );
|
|
|
-
|
|
|
- $this->output = fopen("$this->root$this->out/foundation/$this->master_delegate_file.inc", "w+");
|
|
|
- $this->PrintDelegateClass($delegate_categories);
|
|
|
- fclose($this->output);
|
|
|
-
|
|
|
- $this->output = fopen("$this->root$this->out/$this->master_delegate_file.pas", "w+");
|
|
|
- $this->PrintDelegateReference($delegate_categories);
|
|
|
- fclose($this->output);
|
|
|
- }
|
|
|
-
|
|
|
- function LoadTypeEncodings ($name) {
|
|
|
- $contents = ReadTextFile("$this->root/$name");
|
|
|
-
|
|
|
- $lines = explode("\n", $contents);
|
|
|
- foreach ($lines as $line) {
|
|
|
- $row = explode("|", $line);
|
|
|
-
|
|
|
- $this->type_encodings[$row[0]][$row[1]] = $row[2];
|
|
|
- }
|
|
|
-
|
|
|
- //print_r($this->type_encodings);
|
|
|
- }
|
|
|
-
|
|
|
- // Prints out code to generate type encodings with GenerateTypeEncodings.p
|
|
|
- // Paste the output of the function into GenerateTypeEncodings.p, run the program and save the output into a text file
|
|
|
- // which is loaded into this script.
|
|
|
- function PrintTypeEncodingGlue () {
|
|
|
- $count = 0;
|
|
|
- $block = true;
|
|
|
- $block_count = 1;
|
|
|
- $limit = 2000;
|
|
|
-
|
|
|
- foreach ($this->dump["all_methods"] as $class => $method) {
|
|
|
- foreach ($method as $name) {
|
|
|
-
|
|
|
- if ($count == 0) {
|
|
|
- print("\n");
|
|
|
- print("procedure PrintGlue$block_count;\n");
|
|
|
- print("begin\n");
|
|
|
-
|
|
|
- $block_count ++;
|
|
|
- }
|
|
|
-
|
|
|
- $count ++;
|
|
|
-
|
|
|
- print("aMethod := class_getInstanceMethod(objc_getClass('$class'), sel_registerName(PChar('$name')));\n");
|
|
|
- print("if aMethod <> nil then\n");
|
|
|
- print("writeln('$class|$name|', method_getTypeEncoding(aMethod));\n");
|
|
|
-
|
|
|
- if ($count == $limit) {
|
|
|
- print("end;\n");
|
|
|
- $count = 0;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- if ($count < $limit) {
|
|
|
- print("end;\n");
|
|
|
- $block_count --;
|
|
|
- }
|
|
|
-
|
|
|
- print("\n========= IMPLEMENTATION =========\n");
|
|
|
- for ($i=1; $i < $block_count + 1; $i++) {
|
|
|
- print("PrintGlue$i;\n");
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- function __construct ($directory, $out_directory, $frameworks, $show) {
|
|
|
- $this->root = $directory;
|
|
|
- $this->out = $out_directory;
|
|
|
- $this->show = $show;
|
|
|
- if ($frameworks) {
|
|
|
- foreach ($frameworks as $name) {
|
|
|
- $this->frameworks[$name]["enabled"] = true;
|
|
|
- }
|
|
|
- }
|
|
|
- $this->BuildCocoaClasses();
|
|
|
- //$this->LoadTypeEncodings("TypeEncodingsAll.txt");
|
|
|
- }
|
|
|
-}
|
|
|
-?>
|
Jonas Maebe