X-Git-Url: https://gitweb.ps.run/toc/blobdiff_plain/45409c781a9e35df68c43b1e2f028d30bf90c0a0..3715a3f575b615f66e8ea7e57f83849e8bae4deb:/src/repr.h

diff --git a/src/repr.h b/src/repr.h
index ce176ef..ff54f97 100644
--- a/src/repr.h
+++ b/src/repr.h
@@ -13,143 +13,319 @@ struct Variable;
 struct Body;
 struct Function;
 struct Struct;
+struct Namespace;
 struct Program;
-struct CallExpr;
-struct LiteralExpr;
-struct VariableExpr;
-struct BracketsExpr;
-struct OperatorExpr;
+
+struct FuncExpr;
+struct MethodExpr;
+struct LitExpr;
+struct ParenExpr;
 struct DotExpr;
+struct PrefixOperatorExpr;
+struct PostfixOperatorExpr;
+struct BinaryOperatorExpr;
+struct TernaryOperatorExpr;
+struct BracketsExpr;
+struct IdentifierExpr;
 struct Expr;
+
 struct IfStmt;
+struct SwitchStmt;
+struct ForStmt;
 struct WhileStmt;
-struct ReturnStmt;
 struct AssignStmt;
+struct ReturnStmt;
 struct Stmt;
 
+struct Context
+{
+  std::shared_ptr<Context> parent;
+  std::vector<Variable> variables;
+};
+
+enum class TypeModifierType
+{
+  Pointer, Array
+};
+
+struct TypeModifier
+{
+  TypeModifierType type;
 
-struct Type {
+  bool _staticArray;
+  int _arraySize;
+};
+
+struct Type
+{
+  std::vector<std::string> namespacePrefixes;
   std::string name;
+  std::vector<TypeModifier> modifiers;
+  std::vector<Type> genericInstantiation;
 };
 
-struct Variable {
+struct Variable
+{
   std::string name;
   Type type;
 };
 
-struct Body {
-  std::vector<Variable> variables;
+struct Body
+{
+  std::shared_ptr<Context> ctx;
   std::vector<Stmt> statements;
 };
 
-struct Function {
+struct Function
+{
   std::string name;
+  Type returnType;
   std::vector<Variable> parameters;
+  bool defined;
+
+  std::vector<std::string> genericTypeNames;
+  std::vector<std::vector<Type>> genericInstantiations;
+
   Body body;
 };
 
-struct Struct {
+template<typename T>
+struct StructMember
+{
+  T t;
+  bool isPublic;
+  operator T() { return t; }
+};
+
+struct Struct
+{
   std::string name;
-  std::vector<Variable> members;
-  std::vector<Function> methods;
+  std::vector<std::string> genericTypeNames;
+  std::vector<std::vector<Type>> genericInstantiations;
+  std::vector<StructMember<Variable>> members;
+  std::vector<StructMember<Function>> methods;
 };
 
-struct Program {
-  std::vector<Variable> variables;
+struct Namespace
+{
+  std::string name;
+  std::shared_ptr<Context> ctx;
+  std::vector<Struct> structs;
+  std::vector<Function> functions;
+  std::vector<Namespace> namespaces;
+};
+
+struct Program
+{
+  std::shared_ptr<Context> ctx;
   std::vector<Struct> structs;
   std::vector<Function> functions;
+  std::vector<Namespace> namespaces;
 };
 
-enum class ExprType {
-  Call, Literal, Variable, Brackets, Operator, Dot
+enum class ExprType
+{
+  Func, Method, Lit, Paren, Dot, PrefixOp, PostfixOp, BinaryOp, TernaryOp, Bracket, Identifier
 };
 
-struct CallExpr {
-  Function function;
+struct FuncExpr
+{
+  std::vector<std::string> namespacePrefixes;
+  std::string functionName;
   std::vector<Expr> arguments;
+  std::vector<Type> genericInstantiation;
 };
 
-struct LiteralExpr {
-  int i;
+struct MethodExpr
+{
+  std::shared_ptr<Expr> expr;
+  std::string methodName;
+  std::vector<Expr> arguments;
+  std::vector<Type> genericInstantiation;
 };
 
-struct VariableExpr {
-  std::string name;
+enum class LitType
+{
+  Int, Decimal, String, Bool
 };
 
-struct BracketsExpr {
-  BracketsExpr() {}
-  BracketsExpr(const BracketsExpr &) {}
-  BracketsExpr & operator=(const BracketsExpr &) {return *this;};
-  std::unique_ptr<Expr> lexpr;
-  std::unique_ptr<Expr> rexpr;
+struct LitExpr
+{
+  LitType type;
+
+  int _int;
+  double _decimal;
+  std::string _string;
+  bool _bool;
 };
 
-enum class OperatorType {
-  Plus, Minus, Multiply, Divide,
-  Equals, NotEquals,
-  LessThan, GreaterThan
+struct ParenExpr
+{
+  std::shared_ptr<Expr> expr;
 };
 
-struct OperatorExpr {
-  OperatorExpr() {}
-  OperatorExpr(const OperatorExpr &) {}
-  OperatorExpr & operator=(const OperatorExpr &) {return *this;};
-  std::unique_ptr<Expr> lexpr;
-  std::unique_ptr<Expr> rexpr;
-  OperatorType type;
+struct DotExpr
+{
+  bool isPointer;
+  std::shared_ptr<Expr> expr;
+  std::string identifier;
 };
 
-struct DotExpr {
-  DotExpr() {}
-  DotExpr(const DotExpr &) {}
-  DotExpr & operator=(const DotExpr &) {return *this;};
-  std::unique_ptr<Expr> lexpr;
-  std::string name;
+enum class PrefixOperatorType
+{
+  Plus, Minus, Increment, Decrement,
+  LogicalNot, BitwiseNot, Dereference, AddressOf,
+  COUNT
 };
+static std::string PrefixOperatorTypeStrings[] =
+{
+  "+", "-", "++", "--", "!", "~", "*", "&" };
 
-struct Expr {
+struct PrefixOperatorExpr
+{
+  PrefixOperatorType type;
+  std::shared_ptr<Expr> expr;
+};
+
+enum class PostfixOperatorType
+{
+  Increment, Decrement,
+  COUNT
+};
+static std::string PostfixOperatorTypeStrings[] =
+{
+  "++", "--" };
+
+struct PostfixOperatorExpr
+{
+  PostfixOperatorType type;
+  std::shared_ptr<Expr> expr;
+};
+
+enum class BinaryOperatorType
+{
+  Plus, Minus, Multiply, Divide, Modulo, BitwiseAnd, BitwiseOr, BitwiseXor, LessThan, GreaterThan,
+  LeftShift, RightShift, LogicalAnd, LogicalOr, Equals, NotEquals, LessThanEquals, GreaterThanEquals, BitwiseAndEquals, BitwiseOrEquals, BitwiseXorEquals,
+  PlusEquals, MinusEquals, MultiplyEquals, DivideEquals, ModuloEquals,
+  LeftShiftEquals, RightShiftEquals,
+  COUNT
+};
+static std::string BinaryOperatorTypeStrings[] =
+{
+  "+", "-", "*", "/", "%", "&", "|", "^", "<", ">",
+  "<<",">>","&&","||","==","!=","<=",">=","&=","|=","^=",
+  "+=","-=","*=","/=","%=",
+  "<<=",">>=" };
+
+struct BinaryOperatorExpr
+{
+  BinaryOperatorType type;
+  std::shared_ptr<Expr> lexpr;
+  std::shared_ptr<Expr> rexpr;
+};
+
+struct TernaryOperatorExpr
+{
+  std::shared_ptr<Expr> lexpr;
+  std::shared_ptr<Expr> rexprTrue;
+  std::shared_ptr<Expr> rexprFalse;
+};
+
+struct BracketsExpr
+{
+  std::shared_ptr<Expr> lexpr;
+  std::shared_ptr<Expr> rexpr;
+};
+
+struct IdentifierExpr
+{
+  std::vector<std::string> namespacePrefixes;
+  std::string identifier;
+};
+
+struct Expr
+{
   ExprType type;
 
-  CallExpr     _call;
-  LiteralExpr  _literal;
-  VariableExpr _variable;
-  BracketsExpr _brackets;
-  OperatorExpr _operator;
-  DotExpr      _dot;
+  FuncExpr            _func;
+  MethodExpr          _method;
+  LitExpr             _lit;
+  ParenExpr           _paren;
+  DotExpr             _dot;
+  PrefixOperatorExpr  _prefixOp;
+  PostfixOperatorExpr _postfixOp;
+  BinaryOperatorExpr  _binaryOp;
+  TernaryOperatorExpr _ternaryOp;
+  BracketsExpr        _brackets;
+  IdentifierExpr      _identifier;
 };
 
-enum class StmtType {
-  If, While, Return, Assign, Expr
+enum class StmtType
+{
+  If, Switch, For, While, Assign, Return, Expr
 };
 
-struct IfStmt {
+struct ElseStmt
+{
+  bool _if;
+  std::shared_ptr<Expr> expr;
+  Body body;
+};
+struct IfStmt
+{
   Expr condition;
   Body body;
+  std::vector<ElseStmt> elses;
+};
+
+struct SwitchCase
+{
+  std::shared_ptr<Expr> expr;
+  Body body;
 };
 
-struct WhileStmt {
+struct SwitchStmt
+{
+  std::shared_ptr<Expr> ident;
+  std::vector<SwitchCase> cases;
+};
+
+// TODO: int i = 0 (var decl)
+struct ForStmt
+{
+  std::shared_ptr<AssignStmt> init;
+  std::shared_ptr<Expr> condition;
+  std::shared_ptr<Expr> action;
+  Body body;
+};
+
+struct WhileStmt
+{
   Expr condition;
   Body body;
 };
 
-struct ReturnStmt {
-  Expr expr;
+struct AssignStmt
+{
+  Expr lexpr, rexpr;
 };
 
-struct AssignStmt {
-  Expr lexpr;
-  Expr rexpr;
+struct ReturnStmt
+{
+  Expr expr;
 };
 
-struct Stmt {
+struct Stmt
+{
   StmtType type;
   
-  IfStmt     _if;
-  WhileStmt  _while;
-  ReturnStmt _return;
-  AssignStmt _assign;
-  Expr       _expr;
+  IfStmt      _if;
+  SwitchStmt  _switch;
+  ForStmt     _for;
+  WhileStmt   _while;
+  AssignStmt  _assign;
+  ReturnStmt  _return;
+  Expr        _expr;
 };