ObjectiveC/Syntax.hpp

   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 #ifndef CYCRIPT_OBJECTIVEC_SYNTAX_HPP
  23 #define CYCRIPT_OBJECTIVEC_SYNTAX_HPP
  24
  25 #include "Parser.hpp"
  26
  27 struct CYInstanceLiteral :
  28     CYExpression
  29 {
  30     CYNumber *number_;
  31
  32     CYInstanceLiteral(CYNumber *number) :
  33         number_(number)
  34     {
  35     }
  36
  37     CYPrecedence(1)
  38
  39     virtual CYExpression *Replace(CYContext &context);
  40     virtual void Output(CYOutput &out, CYFlags flags) const;
  41 };
  42
  43 struct CYObjCBlock :
  44     CYExpression
  45 {
  46     CYTypedIdentifier *typed_;
  47     CYTypedParameter *parameters_;
  48     CYStatement *statements_;
  49
  50     CYObjCBlock(CYTypedIdentifier *typed, CYTypedParameter *parameters, CYStatement *statements) :
  51         typed_(typed),
  52         parameters_(parameters),
  53         statements_(statements)
  54     {
  55     }
  56
  57     CYPrecedence(1)
  58
  59     virtual CYExpression *Replace(CYContext &context);
  60     virtual void Output(CYOutput &out, CYFlags flags) const;
  61 };
  62
  63 struct CYBox :
  64     CYExpression
  65 {
  66     CYExpression *value_;
  67
  68     CYBox(CYExpression *value) :
  69         value_(value)
  70     {
  71     }
  72
  73     CYPrecedence(1)
  74
  75     virtual CYExpression *Replace(CYContext &context);
  76     virtual void Output(CYOutput &out, CYFlags flags) const;
  77 };
  78
  79 struct CYSelectorPart :
  80     CYNext<CYSelectorPart>,
  81     CYThing
  82 {
  83     CYWord *name_;
  84     bool value_;
  85
  86     CYSelectorPart(CYWord *name, bool value, CYSelectorPart *next = NULL) :
  87         CYNext<CYSelectorPart>(next),
  88         name_(name),
  89         value_(value)
  90     {
  91     }
  92
  93     CYString *Replace(CYContext &context);
  94     virtual void Output(CYOutput &out) const;
  95 };
  96
  97 struct CYSelector :
  98     CYLiteral
  99 {
 100     CYSelectorPart *name_;
 101
 102     CYSelector(CYSelectorPart *name) :
 103         name_(name)
 104     {
 105     }
 106
 107     CYPrecedence(1)
 108
 109     virtual CYExpression *Replace(CYContext &context);
 110     virtual void Output(CYOutput &out, CYFlags flags) const;
 111 };
 112
 113 struct CYField :
 114     CYNext<CYField>
 115 {
 116     CYExpression *type_;
 117     CYIdentifier *name_;
 118
 119     CYField(CYExpression *type, CYIdentifier *name, CYField *next = NULL) :
 120         CYNext<CYField>(next),
 121         type_(type),
 122         name_(name)
 123     {
 124     }
 125
 126     CYStatement *Replace(CYContext &context) const;
 127     void Output(CYOutput &out) const;
 128 };
 129
 130 struct CYMessageParameter :
 131     CYNext<CYMessageParameter>
 132 {
 133     CYWord *tag_;
 134     CYExpression *type_;
 135     CYIdentifier *name_;
 136
 137     CYMessageParameter(CYWord *tag, CYExpression *type, CYIdentifier *name) :
 138         tag_(tag),
 139         type_(type),
 140         name_(name)
 141     {
 142     }
 143
 144     CYFunctionParameter *Parameters(CYContext &context) const;
 145     CYSelector *Selector(CYContext &context) const;
 146     CYSelectorPart *SelectorPart(CYContext &context) const;
 147     CYExpression *TypeSignature(CYContext &context) const;
 148 };
 149
 150 struct CYMessage :
 151     CYNext<CYMessage>
 152 {
 153     bool instance_;
 154     CYExpression *type_;
 155     CYMessageParameter *parameters_;
 156     CYBlock code_;
 157
 158     CYMessage(bool instance, CYExpression *type, CYMessageParameter *parameter, CYStatement *statements) :
 159         instance_(instance),
 160         type_(type),
 161         parameters_(parameter),
 162         code_(statements)
 163     {
 164     }
 165
 166     CYStatement *Replace(CYContext &context, bool replace) const;
 167     void Output(CYOutput &out, bool replace) const;
 168
 169     CYExpression *TypeSignature(CYContext &context) const;
 170 };
 171
 172 struct CYProtocol :
 173     CYNext<CYProtocol>,
 174     CYThing
 175 {
 176     CYExpression *name_;
 177
 178     CYProtocol(CYExpression *name, CYProtocol *next = NULL) :
 179         CYNext<CYProtocol>(next),
 180         name_(name)
 181     {
 182     }
 183
 184     CYStatement *Replace(CYContext &context) const;
 185     void Output(CYOutput &out) const;
 186 };
 187
 188 struct CYModule :
 189     CYNext<CYModule>,
 190     CYThing
 191 {
 192     CYWord *part_;
 193
 194     CYModule(CYWord *part, CYModule *next = NULL) :
 195         CYNext<CYModule>(next),
 196         part_(part)
 197     {
 198     }
 199
 200     CYString *Replace(CYContext &context, const char *separator) const;
 201     void Output(CYOutput &out) const;
 202 };
 203
 204 struct CYImport :
 205     CYStatement
 206 {
 207     CYModule *module_;
 208
 209     CYImport(CYModule *module) :
 210         module_(module)
 211     {
 212     }
 213
 214     virtual CYStatement *Replace(CYContext &context);
 215     virtual void Output(CYOutput &out, CYFlags flags) const;
 216 };
 217
 218 struct CYClass {
 219     CYClassName *name_;
 220     CYExpression *super_;
 221     CYProtocol *protocols_;
 222     CYField *fields_;
 223     CYMessage *messages_;
 224
 225     CYClass(CYClassName *name, CYExpression *super, CYProtocol *protocols, CYField *fields, CYMessage *messages) :
 226         name_(name),
 227         super_(super),
 228         protocols_(protocols),
 229         fields_(fields),
 230         messages_(messages)
 231     {
 232     }
 233
 234     virtual ~CYClass() {
 235     }
 236
 237     CYExpression *Replace_(CYContext &context);
 238     virtual void Output(CYOutput &out, CYFlags flags) const;
 239 };
 240
 241 struct CYClassExpression :
 242     CYClass,
 243     CYExpression
 244 {
 245     CYClassExpression(CYClassName *name, CYExpression *super, CYProtocol *protocols, CYField *fields, CYMessage *messages) :
 246         CYClass(name, super, protocols, fields, messages)
 247     {
 248     }
 249
 250     CYPrecedence(0)
 251
 252     virtual CYExpression *Replace(CYContext &context);
 253     virtual void Output(CYOutput &out, CYFlags flags) const;
 254 };
 255
 256 struct CYClassStatement :
 257     CYClass,
 258     CYStatement
 259 {
 260     CYClassStatement(CYClassName *name, CYExpression *super, CYProtocol *protocols, CYField *fields, CYMessage *messages) :
 261         CYClass(name, super, protocols, fields, messages)
 262     {
 263     }
 264
 265     virtual CYStatement *Replace(CYContext &context);
 266     virtual void Output(CYOutput &out, CYFlags flags) const;
 267 };
 268
 269 struct CYCategory :
 270     CYStatement
 271 {
 272     CYClassName *name_;
 273     CYMessage *messages_;
 274
 275     CYCategory(CYClassName *name, CYMessage *messages) :
 276         name_(name),
 277         messages_(messages)
 278     {
 279     }
 280
 281     virtual CYStatement *Replace(CYContext &context);
 282     virtual void Output(CYOutput &out, CYFlags flags) const;
 283 };
 284
 285 struct CYSend :
 286     CYExpression
 287 {
 288     CYArgument *arguments_;
 289
 290     CYSend(CYArgument *arguments) :
 291         arguments_(arguments)
 292     {
 293     }
 294
 295     CYPrecedence(0)
 296
 297     virtual void Output(CYOutput &out, CYFlags flags) const;
 298 };
 299
 300 struct CYSendDirect :
 301     CYSend
 302 {
 303     CYExpression *self_;
 304
 305     CYSendDirect(CYExpression *self, CYArgument *arguments) :
 306         CYSend(arguments),
 307         self_(self)
 308     {
 309     }
 310
 311     virtual CYExpression *Replace(CYContext &context);
 312     virtual void Output(CYOutput &out, CYFlags flags) const;
 313 };
 314
 315 struct CYSendSuper :
 316     CYSend
 317 {
 318     CYSendSuper(CYArgument *arguments) :
 319         CYSend(arguments)
 320     {
 321     }
 322
 323     virtual CYExpression *Replace(CYContext &context);
 324     virtual void Output(CYOutput &out, CYFlags flags) const;
 325 };
 326
 327 #endif/*CYCRIPT_OBJECTIVEC_SYNTAX_HPP*/