Add support to @encode, Decode_, and With blocks.

diff --git a/Cycript.yy.in b/Cycript.yy.in
index 89ed1a9d0577d2f26e4040147d5ab62c4d1c94fe..e1408da4ea74983595dcad480c5b09f186d0025f 100644 (file)
--- a/Cycript.yy.in
+++ b/Cycript.yy.in
@@ -1391,6 +1391,7 @@ FunctionedType
 
 SuffixedType
     : ArrayedType { $$ = $1; }
 
 SuffixedType
     : ArrayedType { $$ = $1; }

+    | "(" LexPushInOff "^" TypeQualifierRight ")" LexPopIn "(" LexPushInOff TypedParameterListOpt ")" LexPopIn { $$ = $4; $$->modifier_ = CYNew CYTypeBlockWith($9, $$->modifier_); }

     | TypeParenthetical FunctionedType { $$ = $1; CYSetLast($2) = $$->modifier_; $$->modifier_ = $2; }
     | FunctionedType { $$ = CYNew CYTypedIdentifier(); CYSetLast($1) = $$->modifier_; $$->modifier_ = $1; }
     ;
     | TypeParenthetical FunctionedType { $$ = $1; CYSetLast($2) = $$->modifier_; $$->modifier_ = $2; }
     | FunctionedType { $$ = CYNew CYTypedIdentifier(); CYSetLast($1) = $$->modifier_; $$->modifier_ = $1; }
     ;

diff --git a/Decode.cpp b/Decode.cpp
index f99f61fa20bb0ee89f954fc886e0e0f2e0c30d44..9cb165c8b3358e677a699b00db43ee5f1bda05b0 100644 (file)
--- a/Decode.cpp
+++ b/Decode.cpp
@@ -38,7 +38,14 @@ CYTypedIdentifier *Decode_(CYPool &pool, struct sig::Type *type) {
         case sig::union_P: _assert(false); break;
         case sig::string_P: return $ CYTypedIdentifier($V("char"), $ CYTypePointerTo());
         case sig::selector_P: return $ CYTypedIdentifier($V("SEL"));
         case sig::union_P: _assert(false); break;
         case sig::string_P: return $ CYTypedIdentifier($V("char"), $ CYTypePointerTo());
         case sig::selector_P: return $ CYTypedIdentifier($V("SEL"));

-        case sig::block_P: _assert(false); break;
+
+        case sig::block_P: {
+            _assert(type->data.signature.count != 0);
+            CYTypedParameter *parameter(NULL);
+            for (size_t i(type->data.signature.count - 1); i != 0; --i)
+                parameter = $ CYTypedParameter(Decode(pool, type->data.signature.elements[i].type), parameter);
+            return Decode(pool, type->data.signature.elements[0].type)->Modify($ CYTypeBlockWith(parameter));
+        } break;

 
         case sig::object_P: {
             if (type->name == NULL)
 
         case sig::object_P: {
             if (type->name == NULL)

diff --git a/Execute.cpp b/Execute.cpp
index 6c262406ad8f754a2c3ed68b636a21c2b2e589b8..aff9a7e50cda572da73bb5bdd723d232112f29b6 100644 (file)
--- a/Execute.cpp
+++ b/Execute.cpp
@@ -1069,6 +1069,38 @@ static JSObjectRef Type_new(JSContextRef context, JSObjectRef object, size_t cou
     return CYMakeType(context, type);
 } CYCatch(NULL) }
 
     return CYMakeType(context, type);
 } CYCatch(NULL) }
 

+static JSValueRef Type_callAsFunction_$With(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], sig::Primitive primitive, JSValueRef *exception) { CYTry {
+    Type_privateData *internal(reinterpret_cast<Type_privateData *>(JSObjectGetPrivate(_this)));
+
+    CYPool pool;
+
+    sig::Type type;
+    type.name = NULL;
+    type.flags = 0;
+
+    type.primitive = primitive;
+    type.data.signature.elements = new(pool) sig::Element[1 + count];
+    type.data.signature.count = 1 + count;
+
+    type.data.signature.elements[0].name = NULL;
+    type.data.signature.elements[0].type = internal->type_;
+    type.data.signature.elements[0].offset = _not(size_t);
+
+    for (size_t i(0); i != count; ++i) {
+        sig::Element &element(type.data.signature.elements[i + 1]);
+        element.name = NULL;
+        element.offset = _not(size_t);
+
+        JSObjectRef object(CYCastJSObject(context, arguments[i]));
+        _assert(JSValueIsObjectOfClass(context, object, Type_privateData::Class_));
+        Type_privateData *internal(reinterpret_cast<Type_privateData *>(JSObjectGetPrivate(object)));
+
+        element.type = internal->type_;
+    }
+
+    return CYMakeType(context, &type);
+} CYCatch(NULL) }
+

 static JSValueRef Type_callAsFunction_arrayOf(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
     if (count != 1)
         throw CYJSError(context, "incorrect number of arguments to Type.arrayOf");
 static JSValueRef Type_callAsFunction_arrayOf(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
     if (count != 1)
         throw CYJSError(context, "incorrect number of arguments to Type.arrayOf");


@@ -1090,6 +1122,10 @@ static JSValueRef Type_callAsFunction_arrayOf(JSContextRef context, JSObjectRef
     return CYMakeType(context, &type);
 } CYCatch(NULL) }
 
     return CYMakeType(context, &type);
 } CYCatch(NULL) }
 

+static JSValueRef Type_callAsFunction_blockWith(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) {
+    return Type_callAsFunction_$With(context, object, _this, count, arguments, sig::block_P, exception);
+}
+

 static JSValueRef Type_callAsFunction_constant(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
     if (count != 0)
         throw CYJSError(context, "incorrect number of arguments to Type.constant");
 static JSValueRef Type_callAsFunction_constant(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
     if (count != 0)
         throw CYJSError(context, "incorrect number of arguments to Type.constant");


@@ -1100,37 +1136,9 @@ static JSValueRef Type_callAsFunction_constant(JSContextRef context, JSObjectRef
     return CYMakeType(context, &type);
 } CYCatch(NULL) }
 
     return CYMakeType(context, &type);
 } CYCatch(NULL) }
 

-static JSValueRef Type_callAsFunction_functionWith(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
-    Type_privateData *internal(reinterpret_cast<Type_privateData *>(JSObjectGetPrivate(_this)));
-
-    CYPool pool;
-
-    sig::Type type;
-    type.name = NULL;
-    type.flags = 0;
-
-    type.primitive = sig::function_P;
-    type.data.signature.elements = new(pool) sig::Element[1 + count];
-    type.data.signature.count = 1 + count;
-
-    type.data.signature.elements[0].name = NULL;
-    type.data.signature.elements[0].type = internal->type_;
-    type.data.signature.elements[0].offset = _not(size_t);
-
-    for (size_t i(0); i != count; ++i) {
-        sig::Element &element(type.data.signature.elements[i + 1]);
-        element.name = NULL;
-        element.offset = _not(size_t);
-
-        JSObjectRef object(CYCastJSObject(context, arguments[i]));
-        _assert(JSValueIsObjectOfClass(context, object, Type_privateData::Class_));
-        Type_privateData *internal(reinterpret_cast<Type_privateData *>(JSObjectGetPrivate(object)));
-
-        element.type = internal->type_;
-    }
-
-    return CYMakeType(context, &type);
-} CYCatch(NULL) }
+static JSValueRef Type_callAsFunction_functionWith(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) {
+    return Type_callAsFunction_$With(context, object, _this, count, arguments, sig::function_P, exception);
+}

 
 static JSValueRef Type_callAsFunction_pointerTo(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
     if (count != 0)
 
 static JSValueRef Type_callAsFunction_pointerTo(JSContextRef context, JSObjectRef object, JSObjectRef _this, size_t count, const JSValueRef arguments[], JSValueRef *exception) { CYTry {
     if (count != 0)


@@ -1319,8 +1327,9 @@ static JSStaticValue Type_staticValues[4] = {
     {NULL, NULL, NULL, 0}
 };
 
     {NULL, NULL, NULL, 0}
 };
 

-static JSStaticFunction Type_staticFunctions[9] = {
+static JSStaticFunction Type_staticFunctions[10] = {

     {"arrayOf", &Type_callAsFunction_arrayOf, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete},
     {"arrayOf", &Type_callAsFunction_arrayOf, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete},

+    {"blockWith", &Type_callAsFunction_blockWith, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete},

     {"constant", &Type_callAsFunction_constant, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete},
     {"functionWith", &Type_callAsFunction_functionWith, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete},
     {"pointerTo", &Type_callAsFunction_pointerTo, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete},
     {"constant", &Type_callAsFunction_constant, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete},
     {"functionWith", &Type_callAsFunction_functionWith, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete},
     {"pointerTo", &Type_callAsFunction_pointerTo, kJSPropertyAttributeDontEnum | kJSPropertyAttributeDontDelete},

diff --git a/Output.cpp b/Output.cpp
index 17f7bde19345cf9d50cbb11e20488ecf6ee330e4..51134c767d46e4d113508e5bfe0c1400a4ac384d 100644 (file)
--- a/Output.cpp
+++ b/Output.cpp
@@ -481,6 +481,12 @@ void CYTypeArrayOf::Output(CYOutput &out, CYIdentifier *identifier) const {
     out << ']';
 }
 
     out << ']';
 }
 

+void CYTypeBlockWith::Output(CYOutput &out, CYIdentifier *identifier) const {
+    out << '(' << '^';
+    next_->Output(out, Precedence(), identifier);
+    out << ')' << '(' << parameters_ << ')';
+}
+

 void CYTypeConstant::Output(CYOutput &out, CYIdentifier *identifier) const {
     out << "const";
     next_->Output(out, Precedence(), identifier);
 void CYTypeConstant::Output(CYOutput &out, CYIdentifier *identifier) const {
     out << "const";
     next_->Output(out, Precedence(), identifier);

diff --git a/Parser.hpp b/Parser.hpp
index e68cf1a57b7ea4b1eb84bb375cd095c3ba964232..e182c574a424c3ccfdfe6a21a00e9a1227cc4f09 100644 (file)
--- a/Parser.hpp
+++ b/Parser.hpp
@@ -1776,6 +1776,23 @@ struct CYTypeDefinition :
     virtual void Output(CYOutput &out, CYFlags flags) const;
 };
 
     virtual void Output(CYOutput &out, CYFlags flags) const;
 };
 

+struct CYTypeBlockWith :
+    CYTypeModifier
+{
+    CYTypedParameter *parameters_;
+
+    CYTypeBlockWith(CYTypedParameter *parameters, CYTypeModifier *next = NULL) :
+        CYTypeModifier(next),
+        parameters_(parameters)
+    {
+    }
+
+    CYPrecedence(0)
+
+    virtual CYExpression *Replace_(CYContext &context, CYExpression *type);
+    virtual void Output(CYOutput &out, CYIdentifier *identifier) const;
+};
+

 struct CYTypeFunctionWith :
     CYTypeModifier
 {
 struct CYTypeFunctionWith :
     CYTypeModifier
 {

diff --git a/Replace.cpp b/Replace.cpp
index 1ddc5c1dfd444f26840531b2f68d262fae6b1231..83a5c47328840c8238115c6908ac47563dafa51b 100644 (file)
--- a/Replace.cpp
+++ b/Replace.cpp
@@ -873,6 +873,10 @@ CYExpression *CYTypeArrayOf::Replace_(CYContext &context, CYExpression *type) {
     return next_->Replace(context, $ CYCall($ CYDirectMember(type, $ CYString("arrayOf")), $ CYArgument(size_)));
 }
 
     return next_->Replace(context, $ CYCall($ CYDirectMember(type, $ CYString("arrayOf")), $ CYArgument(size_)));
 }
 

+CYExpression *CYTypeBlockWith::Replace_(CYContext &context, CYExpression *type) {
+    return next_->Replace(context, $ CYCall($ CYDirectMember(type, $ CYString("blockWith")), parameters_->Argument(context)));
+}
+

 CYExpression *CYTypeConstant::Replace_(CYContext &context, CYExpression *type) {
     return next_->Replace(context, $ CYCall($ CYDirectMember(type, $ CYString("constant"))));
 }
 CYExpression *CYTypeConstant::Replace_(CYContext &context, CYExpression *type) {
     return next_->Replace(context, $ CYCall($ CYDirectMember(type, $ CYString("constant"))));
 }

diff --git a/sig/copy.cpp b/sig/copy.cpp
index b2c20f5542a4959b0cd0228019c6e97d97bbe5f7..9300a1d03948e8c21089676031a22408f9d6be1e 100644 (file)
--- a/sig/copy.cpp
+++ b/sig/copy.cpp
@@ -58,7 +58,7 @@ void Copy(CYPool &pool, Type &lhs, const Type &rhs) {
     lhs.name = pool.strdup(rhs.name);
     lhs.flags = rhs.flags;
 
     lhs.name = pool.strdup(rhs.name);
     lhs.flags = rhs.flags;
 

-    if (rhs.primitive == '\0' || sig::IsAggregate(rhs.primitive))
+    if (sig::IsFunctional(rhs.primitive) || sig::IsAggregate(rhs.primitive))

         Copy(pool, lhs.data.signature, rhs.data.signature);
     else {
         sig::Type *&lht(lhs.data.data.type);
         Copy(pool, lhs.data.signature, rhs.data.signature);
     else {
         sig::Type *&lht(lhs.data.data.type);

diff --git a/sig/types.hpp b/sig/types.hpp
index e66e0c3e69aa4574bb49b72485eb19b7f701c9c6..150a057539c4faf20e36ca34d7c4f49eb26feac0 100644 (file)
--- a/sig/types.hpp
+++ b/sig/types.hpp
@@ -94,6 +94,10 @@ struct Type {
 struct Type *joc_parse_type(char **name, char eos, bool variable, bool signature);
 void joc_parse_signature(struct Signature *signature, char **name, char eos, bool variable);
 
 struct Type *joc_parse_type(char **name, char eos, bool variable, bool signature);
 void joc_parse_signature(struct Signature *signature, char **name, char eos, bool variable);
 

+_finline bool IsFunctional(Primitive primitive) {
+    return primitive == block_P || primitive == function_P;
+}
+

 _finline bool IsAggregate(Primitive primitive) {
     return primitive == struct_P || primitive == union_P;
 }
 _finline bool IsAggregate(Primitive primitive) {
     return primitive == struct_P || primitive == union_P;
 }