/* Cycript - Optimizing JavaScript Compiler/Runtime
- * Copyright (C) 2009-2013 Jay Freeman (saurik)
+ * Copyright (C) 2009-2015 Jay Freeman (saurik)
*/
-/* GNU General Public License, Version 3 {{{ */
+/* GNU Affero General Public License, Version 3 {{{ */
/*
- * Cycript is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published
- * by the Free Software Foundation, either version 3 of the License,
- * or (at your option) any later version.
- *
- * Cycript is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with Cycript. If not, see <http://www.gnu.org/licenses/>.
+ * GNU Affero General Public License for more details.
+
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
**/
/* }}} */
#include <cstdlib>
#include "List.hpp"
+#include "Location.hpp"
#include "Pooling.hpp"
#include "Options.hpp"
}
struct CYStatement :
- CYNext<CYStatement>
+ CYNext<CYStatement>,
+ CYThing
{
virtual ~CYStatement() {
}
void Single(CYOutput &out, CYFlags flags) const;
void Multiple(CYOutput &out, CYFlags flags = CYNoFlags) const;
+ virtual void Output(CYOutput &out) const;
virtual CYStatement *Replace(CYContext &context) = 0;
struct CYScope {
bool transparent_;
-
- CYContext &context_;
- CYStatement *&statements_;
-
CYScope *parent_;
CYIdentifierAddressFlagsMap internal_;
CYIdentifierValueSet identifiers_;
- CYScope(bool transparent, CYContext &context, CYStatement *&statements);
- virtual ~CYScope();
-
- void Close();
+ CYScope(bool transparent, CYContext &context);
void Declare(CYContext &context, CYIdentifier *identifier, CYIdentifierFlags flags);
virtual CYIdentifier *Lookup(CYContext &context, CYIdentifier *identifier);
void Merge(CYContext &context, CYIdentifier *identifier);
- void Scope(CYContext &context, CYStatement *&statements);
+ void Close(CYContext &context, CYStatement *&statements);
};
struct CYProgram :
CYThing
{
- CYStatement *statements_;
+ CYStatement *code_;
- CYProgram(CYStatement *statements) :
- statements_(statements)
+ CYProgram(CYStatement *code) :
+ code_(code)
{
}
virtual ~CYContext() {
}
- template <typename Type_>
- void ReplaceAll(Type_ *&values) {
- Type_ **last(&values);
- CYForEach (next, values) {
- Replace(*last = next);
- if (*last != NULL)
- last = &(*last)->next_;
- }
+ void ReplaceAll(CYStatement *&statement) {
+ if (statement == NULL)
+ return;
+ CYStatement *next(statement->next_);
+
+ Replace(statement);
+ ReplaceAll(next);
+
+ if (statement == NULL)
+ statement = next;
+ else
+ statement->SetNext(next);
}
template <typename Type_>
};
struct CYBlock :
- CYStatement,
- CYThing
+ CYStatement
{
- CYStatement *statements_;
+ CYStatement *code_;
- CYBlock(CYStatement *statements) :
- statements_(statements)
+ CYBlock(CYStatement *code) :
+ code_(code)
{
}
- operator CYStatement *() const {
- return statements_;
- }
-
- void AddPrev(CYStatement *statement) {
- CYSetLast(statement) = statements_;
- statements_ = statement;
- }
-
virtual CYStatement *Replace(CYContext &context);
- virtual void Output(CYOutput &out) const;
virtual void Output(CYOutput &out, CYFlags flags) const;
};
virtual void Output(CYOutput &out, CYFlags flags) const = 0;
};
+struct CYFunctionParameter;
+
struct CYNumber;
struct CYString;
return NULL;
}
+ virtual CYFunctionParameter *Parameter() const;
+
virtual CYNumber *Number(CYContext &context) {
return NULL;
}
CYExpression *expression_;
CYExpression *next_;
- CYCompound(CYExpression *expression, CYExpression *next = NULL) :
+ CYCompound(CYExpression *expression, CYExpression *next) :
expression_(expression),
next_(next)
{
- if (expression_ == NULL)
- throw;
_assert(expression_ != NULL);
+ _assert(next != NULL);
}
CYPrecedence(17)
virtual CYExpression *Replace(CYContext &context);
void Output(CYOutput &out, CYFlags flags) const;
- virtual CYExpression *Primitive(CYContext &context);
+ virtual CYFunctionParameter *Parameter() const;
+};
+
+struct CYParenthetical :
+ CYExpression
+{
+ CYExpression *expression_;
+
+ CYParenthetical(CYExpression *expression) :
+ expression_(expression)
+ {
+ }
+
+ CYPrecedence(0)
+
+ virtual CYExpression *Replace(CYContext &context);
+ void Output(CYOutput &out, CYFlags flags) const;
};
struct CYDeclaration;
{
}
- void Replace(CYContext &context, CYBlock &code);
+ void Replace(CYContext &context, CYStatement *&statements);
void Output(CYOutput &out) const;
};
virtual CYExpression *Replace(CYContext &context);
virtual void Output(CYOutput &out, CYFlags flags) const;
+
+ virtual CYFunctionParameter *Parameter() const;
};
struct CYPrefix :
CYNext<CYClause>
{
CYExpression *case_;
- CYStatement *statements_;
+ CYStatement *code_;
- CYClause(CYExpression *_case, CYStatement *statements) :
+ CYClause(CYExpression *_case, CYStatement *code) :
case_(_case),
- statements_(statements)
+ code_(code)
{
}
void Replace(CYContext &context);
- CYCompound *Compound(CYContext &context);
+ CYExpression *Expression(CYContext &context);
CYProperty *Property(CYContext &context);
CYArgument *Argument(CYContext &context);
CYFunctionParameter *Parameter(CYContext &context);
{
}
- virtual CYCompound *Replace(CYContext &context);
+ virtual CYExpression *Replace(CYContext &context);
virtual void Output(CYOutput &out, CYFlags flags) const;
};
struct CYFunction {
CYIdentifier *name_;
CYFunctionParameter *parameters_;
- CYBlock code_;
+ CYStatement *code_;
CYNonLocal *nonlocal_;
CYThisScope this_;
- CYFunction(CYIdentifier *name, CYFunctionParameter *parameters, CYStatement *statements) :
+ CYFunction(CYIdentifier *name, CYFunctionParameter *parameters, CYStatement *code) :
name_(name),
parameters_(parameters),
- code_(statements),
+ code_(code),
nonlocal_(NULL)
{
}
CYFunction,
CYExpression
{
- CYFunctionExpression(CYIdentifier *name, CYFunctionParameter *parameters, CYStatement *statements) :
- CYFunction(name, parameters, statements)
+ CYFunctionExpression(CYIdentifier *name, CYFunctionParameter *parameters, CYStatement *code) :
+ CYFunction(name, parameters, code)
{
}
CYFunction,
CYExpression
{
- CYFatArrow(CYFunctionParameter *parameters, CYStatement *statements) :
- CYFunction(NULL, parameters, statements)
+ CYFatArrow(CYFunctionParameter *parameters, CYStatement *code) :
+ CYFunction(NULL, parameters, code)
{
}
struct CYRubyProc :
CYFunctionExpression
{
- CYRubyProc(CYFunctionParameter *parameters, CYStatement *statements) :
- CYFunctionExpression(NULL, parameters, statements)
+ CYRubyProc(CYFunctionParameter *parameters, CYStatement *code) :
+ CYFunctionExpression(NULL, parameters, code)
{
}
CYFunction,
CYStatement
{
- CYFunctionStatement(CYIdentifier *name, CYFunctionParameter *parameters, CYStatement *statements) :
- CYFunction(name, parameters, statements)
+ CYFunctionStatement(CYIdentifier *name, CYFunctionParameter *parameters, CYStatement *code) :
+ CYFunction(name, parameters, code)
{
}
struct CYFinally :
CYThing
{
- CYBlock code_;
+ CYStatement *code_;
- CYFinally(CYStatement *statements) :
- code_(statements)
+ CYFinally(CYStatement *code) :
+ code_(code)
{
}
virtual void Output(CYOutput &out) const;
};
+struct CYTypeFunctionWith;
+
struct CYTypeModifier :
CYNext<CYTypeModifier>
{
virtual void Output(CYOutput &out, CYIdentifier *identifier) const = 0;
void Output(CYOutput &out, int precedence, CYIdentifier *identifier) const;
+
+ virtual CYTypeFunctionWith *Function() { return NULL; }
};
struct CYTypeArrayOf :
CYNext<CYTypedIdentifier>,
CYThing
{
+ CYLocation location_;
CYIdentifier *identifier_;
CYTypeSpecifier *specifier_;
CYTypeModifier *modifier_;
- CYTypedIdentifier(CYIdentifier *identifier = NULL) :
+ CYTypedIdentifier(const CYLocation &location, CYIdentifier *identifier = NULL) :
+ location_(location),
identifier_(identifier),
specifier_(NULL),
modifier_(NULL)
virtual CYExpression *Replace(CYContext &context);
virtual void Output(CYOutput &out) const;
+
+ CYTypeFunctionWith *Function();
};
struct CYEncodedType :
{
CYTypedIdentifier *typed_;
CYTypedParameter *parameters_;
- CYStatement *statements_;
+ CYStatement *code_;
- CYLambda(CYTypedIdentifier *typed, CYTypedParameter *parameters, CYStatement *statements) :
+ CYLambda(CYTypedIdentifier *typed, CYTypedParameter *parameters, CYStatement *code) :
typed_(typed),
parameters_(parameters),
- statements_(statements)
+ code_(code)
{
}
virtual void Output(CYOutput &out, CYFlags flags) const;
};
+struct CYExternal :
+ CYStatement
+{
+ CYString *abi_;
+ CYTypedIdentifier *typed_;
+
+ CYExternal(CYString *abi, CYTypedIdentifier *typed) :
+ abi_(abi),
+ typed_(typed)
+ {
+ }
+
+ virtual CYStatement *Replace(CYContext &context);
+ virtual void Output(CYOutput &out, CYFlags flags) const;
+};
+
struct CYTypeDefinition :
CYStatement
{
virtual CYExpression *Replace_(CYContext &context, CYExpression *type);
virtual void Output(CYOutput &out, CYIdentifier *identifier) const;
+
+ virtual CYTypeFunctionWith *Function() { return this; }
};
namespace cy {
CYThing
{
CYIdentifier *name_;
- CYBlock code_;
+ CYStatement *code_;
- Catch(CYIdentifier *name, CYStatement *statements) :
+ Catch(CYIdentifier *name, CYStatement *code) :
name_(name),
- code_(statements)
+ code_(code)
{
}
struct Try :
CYStatement
{
- CYBlock code_;
+ CYStatement *code_;
Catch *catch_;
CYFinally *finally_;
- Try(CYStatement *statements, Catch *_catch, CYFinally *finally) :
- code_(statements),
+ Try(CYStatement *code, Catch *_catch, CYFinally *finally) :
+ code_(code),
catch_(_catch),
finally_(finally)
{
projects / cycript.git / blobdiff