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     CYTypedIdentifier *typed_;
 117
 118     CYField(CYTypedIdentifier *typed, CYField *next = NULL) :
 119         CYNext<CYField>(next),
 120         typed_(typed)
 121     {
 122     }
 123
 124     CYStatement *Replace(CYContext &context) const;
 125     void Output(CYOutput &out) const;
 126 };
 127
 128 struct CYMessageParameter :
 129     CYNext<CYMessageParameter>
 130 {
 131     CYWord *tag_;
 132     CYExpression *type_;
 133     CYIdentifier *name_;
 134
 135     CYMessageParameter(CYWord *tag, CYExpression *type, CYIdentifier *name) :
 136         tag_(tag),
 137         type_(type),
 138         name_(name)
 139     {
 140     }
 141
 142     CYFunctionParameter *Parameters(CYContext &context) const;
 143     CYSelector *Selector(CYContext &context) const;
 144     CYSelectorPart *SelectorPart(CYContext &context) const;
 145     CYExpression *TypeSignature(CYContext &context) const;
 146 };
 147
 148 struct CYMessage :
 149     CYNext<CYMessage>
 150 {
 151     bool instance_;
 152     CYExpression *type_;
 153     CYMessageParameter *parameters_;
 154     CYBlock code_;
 155
 156     CYMessage(bool instance, CYExpression *type, CYMessageParameter *parameter, CYStatement *statements) :
 157         instance_(instance),
 158         type_(type),
 159         parameters_(parameter),
 160         code_(statements)
 161     {
 162     }
 163
 164     CYStatement *Replace(CYContext &context, bool replace) const;
 165     void Output(CYOutput &out, bool replace) const;
 166
 167     CYExpression *TypeSignature(CYContext &context) const;
 168 };
 169
 170 struct CYProtocol :
 171     CYNext<CYProtocol>,
 172     CYThing
 173 {
 174     CYExpression *name_;
 175
 176     CYProtocol(CYExpression *name, CYProtocol *next = NULL) :
 177         CYNext<CYProtocol>(next),
 178         name_(name)
 179     {
 180     }
 181
 182     CYStatement *Replace(CYContext &context) const;
 183     void Output(CYOutput &out) const;
 184 };
 185
 186 struct CYModule :
 187     CYNext<CYModule>,
 188     CYThing
 189 {
 190     CYWord *part_;
 191
 192     CYModule(CYWord *part, CYModule *next = NULL) :
 193         CYNext<CYModule>(next),
 194         part_(part)
 195     {
 196     }
 197
 198     CYString *Replace(CYContext &context, const char *separator) const;
 199     void Output(CYOutput &out) const;
 200 };
 201
 202 struct CYImport :
 203     CYStatement
 204 {
 205     CYModule *module_;
 206
 207     CYImport(CYModule *module) :
 208         module_(module)
 209     {
 210     }
 211
 212     virtual CYStatement *Replace(CYContext &context);
 213     virtual void Output(CYOutput &out, CYFlags flags) const;
 214 };
 215
 216 struct CYClass {
 217     CYClassName *name_;
 218     CYExpression *super_;
 219     CYProtocol *protocols_;
 220     CYField *fields_;
 221     CYMessage *messages_;
 222
 223     CYClass(CYClassName *name, CYExpression *super, CYProtocol *protocols, CYField *fields, CYMessage *messages) :
 224         name_(name),
 225         super_(super),
 226         protocols_(protocols),
 227         fields_(fields),
 228         messages_(messages)
 229     {
 230     }
 231
 232     virtual ~CYClass() {
 233     }
 234
 235     CYExpression *Replace_(CYContext &context);
 236     virtual void Output(CYOutput &out, CYFlags flags) const;
 237 };
 238
 239 struct CYClassExpression :
 240     CYClass,
 241     CYExpression
 242 {
 243     CYClassExpression(CYClassName *name, CYExpression *super, CYProtocol *protocols, CYField *fields, CYMessage *messages) :
 244         CYClass(name, super, protocols, fields, messages)
 245     {
 246     }
 247
 248     CYPrecedence(0)
 249
 250     virtual CYExpression *Replace(CYContext &context);
 251     virtual void Output(CYOutput &out, CYFlags flags) const;
 252 };
 253
 254 struct CYClassStatement :
 255     CYClass,
 256     CYStatement
 257 {
 258     CYClassStatement(CYClassName *name, CYExpression *super, CYProtocol *protocols, CYField *fields, CYMessage *messages) :
 259         CYClass(name, super, protocols, fields, messages)
 260     {
 261     }
 262
 263     virtual CYStatement *Replace(CYContext &context);
 264     virtual void Output(CYOutput &out, CYFlags flags) const;
 265 };
 266
 267 struct CYCategory :
 268     CYStatement
 269 {
 270     CYClassName *name_;
 271     CYMessage *messages_;
 272
 273     CYCategory(CYClassName *name, CYMessage *messages) :
 274         name_(name),
 275         messages_(messages)
 276     {
 277     }
 278
 279     virtual CYStatement *Replace(CYContext &context);
 280     virtual void Output(CYOutput &out, CYFlags flags) const;
 281 };
 282
 283 struct CYSend :
 284     CYExpression
 285 {
 286     CYArgument *arguments_;
 287
 288     CYSend(CYArgument *arguments) :
 289         arguments_(arguments)
 290     {
 291     }
 292
 293     CYPrecedence(0)
 294
 295     virtual void Output(CYOutput &out, CYFlags flags) const;
 296 };
 297
 298 struct CYSendDirect :
 299     CYSend
 300 {
 301     CYExpression *self_;
 302
 303     CYSendDirect(CYExpression *self, CYArgument *arguments) :
 304         CYSend(arguments),
 305         self_(self)
 306     {
 307     }
 308
 309     virtual CYExpression *Replace(CYContext &context);
 310     virtual void Output(CYOutput &out, CYFlags flags) const;
 311 };
 312
 313 struct CYSendSuper :
 314     CYSend
 315 {
 316     CYSendSuper(CYArgument *arguments) :
 317         CYSend(arguments)
 318     {
 319     }
 320
 321     virtual CYExpression *Replace(CYContext &context);
 322     virtual void Output(CYOutput &out, CYFlags flags) const;
 323 };
 324
 325 #endif/*CYCRIPT_OBJECTIVEC_SYNTAX_HPP*/