]>
Commit | Line | Data |
---|---|---|
1 | /* Cycript - Optimizing JavaScript Compiler/Runtime | |
2 | * Copyright (C) 2009-2013 Jay Freeman (saurik) | |
3 | */ | |
4 | ||
5 | /* GNU General Public License, Version 3 {{{ */ | |
6 | /* | |
7 | * Cycript is free software: you can redistribute it and/or modify | |
8 | * it under the terms of the GNU General Public License as published | |
9 | * by the Free Software Foundation, either version 3 of the License, | |
10 | * or (at your option) any later version. | |
11 | * | |
12 | * Cycript is distributed in the hope that it will be useful, but | |
13 | * WITHOUT ANY WARRANTY; without even the implied warranty of | |
14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
15 | * GNU General Public License for more details. | |
16 | * | |
17 | * You should have received a copy of the GNU General Public License | |
18 | * along with Cycript. If not, see <http://www.gnu.org/licenses/>. | |
19 | **/ | |
20 | /* }}} */ | |
21 | ||
22 | #include "Replace.hpp" | |
23 | #include "ObjectiveC/Syntax.hpp" | |
24 | ||
25 | #include <sstream> | |
26 | ||
27 | static CYExpression *MessageType(CYContext &context, CYExpression *type, CYMessageParameter *next, CYExpression *extra = NULL) { | |
28 | if (type == NULL) | |
29 | return NULL; | |
30 | ||
31 | CYExpression *left($C0($M(type, $S("toString")))); | |
32 | if (extra != NULL) | |
33 | left = $ CYAdd(left, extra); | |
34 | ||
35 | if (next == NULL || next->name_ == NULL) | |
36 | return left; | |
37 | ||
38 | CYExpression *right(next->TypeSignature(context)); | |
39 | if (right == NULL) | |
40 | return NULL; | |
41 | ||
42 | return $ CYAdd(left, right); | |
43 | } | |
44 | ||
45 | CYStatement *CYCategory::Replace(CYContext &context) { | |
46 | CYVariable *cyc($V("$cyc")), *cys($V("$cys")); | |
47 | ||
48 | return $E($C1($F(NULL, $P6($L("$cys"), $L("$cyp"), $L("$cyc"), $L("$cyn"), $L("$cyt"), $L("$cym")), $$->* | |
49 | $E($ CYAssign($V("$cyp"), $C1($V("object_getClass"), cys)))->* | |
50 | $E($ CYAssign(cyc, cys))->* | |
51 | $E($ CYAssign($V("$cym"), $C1($V("object_getClass"), cyc)))->* | |
52 | messages_->Replace(context, true) | |
53 | ), name_->ClassName(context, true))); | |
54 | } | |
55 | ||
56 | CYExpression *CYClass::Replace_(CYContext &context) { | |
57 | CYVariable *cyc($V("$cyc")), *cys($V("$cys")); | |
58 | ||
59 | CYExpression *name(name_ != NULL ? name_->ClassName(context, false) : $C1($V("$cyq"), $S("CY$"))); | |
60 | ||
61 | return $C1($F(NULL, $P6($L("$cys"), $L("$cyp"), $L("$cyc"), $L("$cyn"), $L("$cyt"), $L("$cym")), $$->* | |
62 | $E($ CYAssign($V("$cyp"), $C1($V("object_getClass"), cys)))->* | |
63 | $E($ CYAssign(cyc, $C3($V("objc_allocateClassPair"), cys, name, $D(0))))->* | |
64 | $E($ CYAssign($V("$cym"), $C1($V("object_getClass"), cyc)))->* | |
65 | protocols_->Replace(context)->* | |
66 | fields_->Replace(context)->* | |
67 | messages_->Replace(context, false)->* | |
68 | $E($C1($V("objc_registerClassPair"), cyc))->* | |
69 | $ CYReturn(cyc) | |
70 | ), super_ == NULL ? $ CYNull() : super_); | |
71 | } | |
72 | ||
73 | CYExpression *CYClassExpression::Replace(CYContext &context) { | |
74 | return Replace_(context); | |
75 | } | |
76 | ||
77 | CYStatement *CYClassStatement::Replace(CYContext &context) { | |
78 | return $E(Replace_(context)); | |
79 | } | |
80 | ||
81 | CYStatement *CYField::Replace(CYContext &context) const { $T(NULL) | |
82 | CYVariable *cyn($V("$cyn")); | |
83 | CYVariable *cyt($V("$cyt")); | |
84 | ||
85 | CYExpression *type($C0($M(type_, $S("toString")))); | |
86 | ||
87 | return $ CYBlock($$->* | |
88 | next_->Replace(context)->* | |
89 | $E($ CYAssign(cyt, type))->* | |
90 | $E($ CYAssign(cyn, $N1($V("Type"), cyt)))->* | |
91 | $E($C5($V("class_addIvar"), $V("$cyc"), $S(name_->Word()), $M(cyn, $S("size")), $M(cyn, $S("alignment")), cyt)) | |
92 | ); | |
93 | } | |
94 | ||
95 | CYStatement *CYImport::Replace(CYContext &context) { | |
96 | return this; | |
97 | } | |
98 | ||
99 | CYStatement *CYMessage::Replace(CYContext &context, bool replace) const { $T(NULL) | |
100 | CYVariable *cyn($V("$cyn")); | |
101 | CYVariable *cyt($V("$cyt")); | |
102 | CYVariable *self($V("self")); | |
103 | CYVariable *_class($V(instance_ ? "$cys" : "$cyp")); | |
104 | ||
105 | CYExpression *type(TypeSignature(context) ?: $C1($M(cyn, $S("type")), _class)); | |
106 | ||
107 | return $ CYBlock($$->* | |
108 | next_->Replace(context, replace)->* | |
109 | $E($ CYAssign(cyn, parameters_->Selector(context)))->* | |
110 | $E($ CYAssign(cyt, type))->* | |
111 | $E($C4($V(replace ? "class_replaceMethod" : "class_addMethod"), | |
112 | $V(instance_ ? "$cyc" : "$cym"), | |
113 | cyn, | |
114 | $N2($V("Functor"), $F(NULL, $P2($L("self"), $L("_cmd"), parameters_->Parameters(context)), $$->* | |
115 | $ CYVar($L1($L("$cyr", $N2($V("Super"), self, _class))))->* | |
116 | $ CYReturn($C1($M($F(NULL, NULL, code_), $S("call")), self)) | |
117 | ), cyt), | |
118 | cyt | |
119 | )) | |
120 | ); | |
121 | } | |
122 | ||
123 | CYExpression *CYMessage::TypeSignature(CYContext &context) const { | |
124 | return MessageType(context, type_, parameters_, $S("@:")); | |
125 | } | |
126 | ||
127 | CYFunctionParameter *CYMessageParameter::Parameters(CYContext &context) const { $T(NULL) | |
128 | CYFunctionParameter *next(next_->Parameters(context)); | |
129 | return name_ == NULL ? next : $ CYFunctionParameter($ CYDeclaration(name_), next); | |
130 | } | |
131 | ||
132 | CYSelector *CYMessageParameter::Selector(CYContext &context) const { | |
133 | return $ CYSelector(SelectorPart(context)); | |
134 | } | |
135 | ||
136 | CYSelectorPart *CYMessageParameter::SelectorPart(CYContext &context) const { $T(NULL) | |
137 | CYSelectorPart *next(next_->SelectorPart(context)); | |
138 | return tag_ == NULL ? next : $ CYSelectorPart(tag_, name_ != NULL, next); | |
139 | } | |
140 | ||
141 | CYExpression *CYMessageParameter::TypeSignature(CYContext &context) const { | |
142 | return MessageType(context, type_, next_); | |
143 | } | |
144 | ||
145 | CYExpression *CYBox::Replace(CYContext &context) { | |
146 | return $C1($M($V("Instance"), $S("box")), value_); | |
147 | } | |
148 | ||
149 | CYExpression *CYObjCBlock::Replace(CYContext &context) { | |
150 | return $N2($V("Functor"), $ CYFunctionExpression(NULL, $ CYFunctionParameter($ CYDeclaration($ CYIdentifier("$cyt")), parameters_->Parameters(context)), statements_), parameters_->TypeSignature(context, $ CYAdd(typed_->Replace(context), $ CYString("@")))); | |
151 | } | |
152 | ||
153 | CYStatement *CYProtocol::Replace(CYContext &context) const { $T(NULL) | |
154 | return $ CYBlock($$->* | |
155 | next_->Replace(context)->* | |
156 | $E($C2($V("class_addProtocol"), | |
157 | $V("$cyc"), name_ | |
158 | )) | |
159 | ); | |
160 | } | |
161 | ||
162 | CYExpression *CYSelector::Replace(CYContext &context) { | |
163 | return $C1($V("sel_registerName"), name_->Replace(context)); | |
164 | } | |
165 | ||
166 | CYString *CYSelectorPart::Replace(CYContext &context) { | |
167 | std::ostringstream str; | |
168 | CYForEach (part, this) { | |
169 | if (part->name_ != NULL) | |
170 | str << part->name_->Word(); | |
171 | if (part->value_) | |
172 | str << ':'; | |
173 | } | |
174 | return $S($pool.strdup(str.str().c_str())); | |
175 | } | |
176 | ||
177 | CYExpression *CYSendDirect::Replace(CYContext &context) { | |
178 | std::ostringstream name; | |
179 | CYArgument **argument(&arguments_); | |
180 | CYSelectorPart *selector(NULL), *current(NULL); | |
181 | ||
182 | while (*argument != NULL) { | |
183 | if ((*argument)->name_ != NULL) { | |
184 | CYSelectorPart *part($ CYSelectorPart((*argument)->name_, (*argument)->value_ != NULL)); | |
185 | if (selector == NULL) | |
186 | selector = part; | |
187 | if (current != NULL) | |
188 | current->SetNext(part); | |
189 | current = part; | |
190 | (*argument)->name_ = NULL; | |
191 | } | |
192 | ||
193 | if ((*argument)->value_ == NULL) | |
194 | *argument = (*argument)->next_; | |
195 | else | |
196 | argument = &(*argument)->next_; | |
197 | } | |
198 | ||
199 | return $C2($V("objc_msgSend"), self_, ($ CYSelector(selector))->Replace(context), arguments_); | |
200 | } | |
201 | ||
202 | CYExpression *CYSendSuper::Replace(CYContext &context) { | |
203 | return $ CYSendDirect($V("$cyr"), arguments_); | |
204 | } |