ObjectiveC/Syntax.hpp

   1 /* Cycript - Optimizing JavaScript Compiler/Runtime
   2  * Copyright (C) 2009-2015  Jay Freeman (saurik)
   3 */
   4
   5 /* GNU Affero General Public License, Version 3 {{{ */
   6 /*
   7  * This program is free software: you can redistribute it and/or modify
   8  * it under the terms of the GNU Affero General Public License as published by
   9  * the Free Software Foundation, either version 3 of the License, or
  10  * (at your option) any later version.
  11
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU Affero General Public License for more details.
  16
  17  * You should have received a copy of the GNU Affero General Public License
  18  * along with this program.  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 *code_;
  49
  50     CYObjCBlock(CYTypedIdentifier *typed, CYTypedParameter *parameters, CYStatement *code) :
  51         typed_(typed),
  52         parameters_(parameters),
  53         code_(code)
  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 CYClassField :
 114     CYNext<CYClassField>
 115 {
 116     CYTypedIdentifier *typed_;
 117
 118     CYClassField(CYTypedIdentifier *typed, CYClassField *next = NULL) :
 119         CYNext<CYClassField>(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     CYTypedIdentifier *type_;
 133
 134     CYMessageParameter(CYWord *tag, CYTypedIdentifier *type) :
 135         tag_(tag),
 136         type_(type)
 137     {
 138     }
 139
 140     CYFunctionParameter *Parameters(CYContext &context) const;
 141     CYSelector *Selector(CYContext &context) const;
 142     CYSelectorPart *SelectorPart(CYContext &context) const;
 143     CYExpression *TypeSignature(CYContext &context) const;
 144 };
 145
 146 struct CYMessage :
 147     CYNext<CYMessage>
 148 {
 149     bool instance_;
 150     CYTypedIdentifier *type_;
 151     CYMessageParameter *parameters_;
 152     CYBlock code_;
 153
 154     CYMessage(bool instance, CYTypedIdentifier *type, CYMessageParameter *parameter, CYStatement *code) :
 155         instance_(instance),
 156         type_(type),
 157         parameters_(parameter),
 158         code_(code)
 159     {
 160     }
 161
 162     CYStatement *Replace(CYContext &context, bool replace) const;
 163     void Output(CYOutput &out, bool replace) const;
 164
 165     CYExpression *TypeSignature(CYContext &context) const;
 166 };
 167
 168 struct CYProtocol :
 169     CYNext<CYProtocol>,
 170     CYThing
 171 {
 172     CYExpression *name_;
 173
 174     CYProtocol(CYExpression *name, CYProtocol *next = NULL) :
 175         CYNext<CYProtocol>(next),
 176         name_(name)
 177     {
 178     }
 179
 180     CYStatement *Replace(CYContext &context) const;
 181     void Output(CYOutput &out) const;
 182 };
 183
 184 struct CYClass {
 185     CYClassName *name_;
 186     CYExpression *super_;
 187     CYProtocol *protocols_;
 188     CYClassField *fields_;
 189     CYMessage *messages_;
 190
 191     CYClass(CYClassName *name, CYExpression *super, CYProtocol *protocols, CYClassField *fields, CYMessage *messages) :
 192         name_(name),
 193         super_(super),
 194         protocols_(protocols),
 195         fields_(fields),
 196         messages_(messages)
 197     {
 198     }
 199
 200     virtual ~CYClass() {
 201     }
 202
 203     CYExpression *Replace_(CYContext &context);
 204     virtual void Output(CYOutput &out, CYFlags flags) const;
 205 };
 206
 207 struct CYClassExpression :
 208     CYClass,
 209     CYExpression
 210 {
 211     CYClassExpression(CYClassName *name, CYExpression *super, CYProtocol *protocols, CYClassField *fields, CYMessage *messages) :
 212         CYClass(name, super, protocols, fields, messages)
 213     {
 214     }
 215
 216     CYPrecedence(0)
 217
 218     virtual CYExpression *Replace(CYContext &context);
 219     virtual void Output(CYOutput &out, CYFlags flags) const;
 220 };
 221
 222 struct CYClassStatement :
 223     CYClass,
 224     CYStatement
 225 {
 226     CYClassStatement(CYClassName *name, CYExpression *super, CYProtocol *protocols, CYClassField *fields, CYMessage *messages) :
 227         CYClass(name, super, protocols, fields, messages)
 228     {
 229     }
 230
 231     virtual CYStatement *Replace(CYContext &context);
 232     virtual void Output(CYOutput &out, CYFlags flags) const;
 233 };
 234
 235 struct CYCategory :
 236     CYStatement
 237 {
 238     CYClassName *name_;
 239     CYMessage *messages_;
 240
 241     CYCategory(CYClassName *name, CYMessage *messages) :
 242         name_(name),
 243         messages_(messages)
 244     {
 245     }
 246
 247     virtual CYStatement *Replace(CYContext &context);
 248     virtual void Output(CYOutput &out, CYFlags flags) const;
 249 };
 250
 251 struct CYSend :
 252     CYExpression
 253 {
 254     CYArgument *arguments_;
 255
 256     CYSend(CYArgument *arguments) :
 257         arguments_(arguments)
 258     {
 259     }
 260
 261     CYPrecedence(0)
 262
 263     virtual void Output(CYOutput &out, CYFlags flags) const;
 264 };
 265
 266 struct CYSendDirect :
 267     CYSend
 268 {
 269     CYExpression *self_;
 270
 271     CYSendDirect(CYExpression *self, CYArgument *arguments) :
 272         CYSend(arguments),
 273         self_(self)
 274     {
 275     }
 276
 277     virtual CYExpression *Replace(CYContext &context);
 278     virtual void Output(CYOutput &out, CYFlags flags) const;
 279 };
 280
 281 struct CYSendSuper :
 282     CYSend
 283 {
 284     CYSendSuper(CYArgument *arguments) :
 285         CYSend(arguments)
 286     {
 287     }
 288
 289     virtual CYExpression *Replace(CYContext &context);
 290     virtual void Output(CYOutput &out, CYFlags flags) const;
 291 };
 292
 293 #endif/*CYCRIPT_OBJECTIVEC_SYNTAX_HPP*/