src/ast.h

Go to the documentation of this file.

/* -*- Mode: objc; c-basic-offset: 2; tab-width: 2 indent-tabs-mode: nil -*- */
/* vim: set filetype=objc ts=2 sw=2 expandtab: */

/* ast.h
 * Copyright (C) 2007 Neil Dantam
 *               2007 Jeff Seibert
 *               
 * This program is free software: you can redistribute it and/or modify it
 * under the terms of the GNU General Public License, verson 3 ONLY, as
 * published by the Free Software Foundation.
 *
 * 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
 * this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef _AST_H_
#define _AST_H_

#include "token.h"
#include "cons.h"
#include "tipe.h"

@interface ASTNode: Object {
  Token *token;  
  Tipe *tipe;    
  BOOL checked;
}
/* Returns read only, borrowd */
-(char*) op;                     
-(BOOL) isOp: (char*) s;         
-(Token*) token;                 
-(void) token: (Token*) t;       
-(void) setToken: (Token*) t;    

-(id) init: (id) t;             
-(void) setTipe: (Tipe*) t;      
-(Tipe*) tipe;                   
-(void) tipe: (Tipe*) t;          
-(char*) op;                     
-(BOOL) isOp: (char*) s;         
-(int) line;                     
@end


@interface Asm : ASTNode {
  Token  *str;   
}
-(id) init: (id) t text: (id) s;
@end


@interface Stmt: ASTNode {
}
@end


@interface Spec: ASTNode{
}
@end

@interface StoreSpec: Spec
@end


@interface Declarator: ASTNode {
  Cons *pointer;      
  Asm *a;             
}
-(void) setPointer: (Cons*) p;
-(void) setAsm: (Asm*) p;
@end

@interface AbstractDeclarator: Declarator
@end

@interface Type: ASTNode {
  Cons* specs; 

  Declarator *abstract;  
}

-(Type*)init: (id) s : (id) a;
@end


@interface Ident: ASTNode {
}
@end

@interface Expr: ASTNode {
}
@end


@interface OpExpr: Expr {
}
@end

@interface Literal: Expr {
}
-(char*) value;
@end

@interface IntLiteral: Literal
@end

@interface StringLiteral: Literal
@end


@interface SimpleDeclarator:Declarator {
  Ident  *ident;
}
@end

@interface ArrayDeclarator: Declarator {
  Declarator *dec; 

  Expr *size;
}
-(id) init: (id) t decl: (id) d size: (id) i; 
@end

@interface FuncDeclarator: Declarator {
  Declarator *dec; 
  Cons *formals;   
}
-(id) init: (id) t decl: (id) d formals: (id) f;
@end

@interface Initializer : Expr {
  Expr *exp; 
}
-(id) init: (id) e;
@end

@interface StructFieldInit : Initializer //{
@end

@interface NamedStructFieldInit : StructFieldInit {
  Ident *field;  
}
-(id) init: (id) t ident: (id) i exp: (id) e;
@end

@interface StructInitializer : Expr {
  Cons *inits; 
}
-(id) init: (id) t inits: (id) i;
@end

@interface DeclInit: ASTNode {
  Declarator *declr;
  Initializer *init;
}
-(DeclInit*) init: (id) d is: (id) e;
@end



@interface VarDecList: Cons 
@end

@interface ExprStmt: Stmt {
  Expr *exp; 
}
-(id) init: (id) t exp: (id) e;
//-(id) init: (id) e;
@end

@interface CastExpr: OpExpr {
  Type *type; 
  Expr *exp;  
}
-(CastExpr*) init: (Token*) tk type: (Type*) t exp: (Expr*) e;
@end

@interface UnExpr: OpExpr {
  id exp; 
}
-(id) init: (id) t exp: (id) e;
@end

@interface PrefixExpr: UnExpr {
}
@end

@interface PostfixExpr: UnExpr {
}
@end

@interface SizeofExpr: UnExpr {
}
@end

@interface BinExpr: OpExpr {
  Expr *lhs;
  Expr *rhs;
}
-(BinExpr*) init: (Token*) tok lhs:  (Expr*) e rhs:  (Expr*) e;
@end

@interface SubscriptExpr: BinExpr 
@end

@interface CondExpr: OpExpr {
        Expr *test;
        Expr *texp;
        Expr *fexp;
}
-(CondExpr*) init: (Token*) tk 
             test: (Expr*)  tst
             texp: (Expr*)  t 
             fexp: (Expr*)  f;
@end

@interface NameExpr: Expr {
  Ident *exp;

  int parent_level;
}
-(char*) key;
//-(NameExpr*) init: (Ident*) i;
@end


@interface CallExpr: Expr{
  Expr *exp; 
  Cons *args; 
}
-(id) init: (id) t exp: (id) e args: (id)a;
@end

@interface LabeledStmt : Stmt {
  Ident *ident;
  IntLiteral *constant;
  Stmt *stmt;
}
-(id) init: (id) i : (id) t : (id) c : (id) s;
@end

@interface JumpStmt : Stmt {
  Ident *ident;
  Expr *expr;
}
-(id) init: (id) t : (id) i : (id) e;
@end

@interface Block: Stmt {
  //Cons *decs;  ///< Declarations at beginning (maybe unnesscary)
  Cons *stmts; 
}
-(id) init: (id) t stmts: (id) s;
@end

@interface SelectionStmt: Stmt {
  Expr *test;      
  Stmt *thenStmt;  
  Stmt *elseStmt;  
}

-(id) init: (id) t test: (id) e 
   if_stmt: (id) ts else_stmt: (id) es;
@end

@interface While: Stmt {
  Expr *test;    
  Stmt *stmt;    
}
-(id) init: (id) t test:(id) e stmt: (id) s;
@end

@interface DoWhile: While {
}
@end

@interface For: Stmt {
  ExprStmt *dec;  
  ExprStmt *test; 
  Expr *step;     
  Stmt *stmt;     
}
-(id) init: (id) t dec: (id) d test: (id) ts step: (id) p stmt: (id) s;
@end

@interface Enum: ASTNode {
  Ident* ident;  
  Cons* expr;    
}
-(Enum*) init: (id) t ident: (id) i list: (id) e;
@end

@interface Enumerator : ASTNode {
  Ident* ident;  
  IntLiteral* constant; 
}
-(id) init: (id) t ident: (id) i value: (id) c;
@end


@interface StructOrUnion: ASTNode {
  Ident* ident; 
  Cons* stmts;  
}
-(StructOrUnion*) init: (id) t : (id) i : (id) d;
@end

@interface StructDeclarator: ASTNode {
    Declarator* dec;
    IntLiteral* constant;
}
-(StructDeclarator*) init: (id) d : (id) c;
@end


@interface StructDeclaration: Stmt {
    Cons* type_specs;
    Cons* struct_decs;
}
-(StructDeclaration*) init: (id) t : (id) s;
@end




@interface TypeSpec: Spec {
  //Enum* enumerator;
  //StructOrUnion* su;
}
-(TypeSpec*) init: (id) t;
//-(TypeSpec*) initEnum: (Enum*) e;
//-(TypeSpec*) initStruct: (StructOrUnion*) s;
@end

@interface PrimitiveTypeSpec : TypeSpec
@end

@interface NameTypeSpec : TypeSpec
@end

@interface PointerSpec : TypeSpec
@end

@interface StructTypeSpec: TypeSpec {
  StructOrUnion *s;
}
-(id) init: (id) i;
@end

@interface EnumTypeSpec: TypeSpec {
  Enum *e;
}
-(id) init: (id) i;
@end

@interface DeclarationSpec: ASTNode{
  Cons *specs;
}
-(void) addSpec: (Spec*) s;
-(void) pushSpec: (Spec*) s;
@end

@interface Declaration: Stmt{
  DeclarationSpec *dspec;   
  Cons *decl_inits;         
}
-(void) addInit: (DeclInit*) d;
-(void) addSpec: (DeclarationSpec*) s;
@end

@interface TypeDefDeclaration : Declaration
@end

@interface Formal: ASTNode 
@end

@interface NormFormal: Formal {
  DeclarationSpec *spec;       
  Declarator* declr;           
}
-(id) init: (id) s: (id) d;
@end


@interface VaFormal: Formal 
@end

@interface FuncDefinition : Stmt {
  DeclarationSpec *decl;   
  Declarator *declr;       
  Cons *decs;              
  Block *stmts;            
}
-(id) init: (id) l : (id) r : (id) c : (id) s;
@end

@interface File : ASTNode {
  Cons *defs;   
}
-(id) init: (id) d;
@end

@interface InstanceVars : Stmt {
  Cons *vars; //Could be tokens, declarations, or other InstanceVars
}
-(id) init: (id) t vars: (id) d;
@end

@interface KeyDeclarator : ASTNode {
  Ident *selector;  
  Type *type1;      
  Type *type2;      
  Ident *ident;     
}
-(id) init: (id) s type1: (id) t1 type2: (id) t2 ident: (id) i;

-(char*) key;
-(Type*) type;
-(Ident*) arg;
@end

@interface Klass : Stmt {
  Ident *class;         
  Ident *super_class;   
  Cons *methods;        
}
-(id) addMethods: (id) d;

-(char*) classname;
@end

@interface Method : Stmt {
  Type *type;   
  Cons *args;   
  Klass *klass; 
}
-(id) init: (id) t rtype: (id) r args: (id) a;
-(char*) msg_name;
@end

@interface MethodDec : Method 
@end

@interface ClassMethodDec : MethodDec
@end

@interface InstanceMethodDec : MethodDec
@end

@interface MethodDefinition : Method {
  Cons *decl;    
  Block *block;  
}
-(id) init: (id) t rtype: (id) r args: (id) a 
      decl: (id) d block: (id) b;
@end

@interface ClassMethodDefinition : MethodDefinition
@end

@interface InstanceMethodDefinition : MethodDefinition
@end

@interface Interface : Klass {
  InstanceVars *instance_vars;  
}
-(id) addInstVars: (id) i;
@end

@interface Implementation : Klass 
@end



@interface SelfExpr : Expr
@end

@interface MessageExpr : Expr {
  Cons *args;        
}
-(id) init: (id) t args: (id) a ;
@end



@interface InstanceMessageExpr : MessageExpr {
  Expr *receiver;    
}
-(id) init: (id) t recv: (id) r args: (id) a;
@end

@interface ClassMessageExpr : MessageExpr {
  Ident *receiver;   
}
-(id) init: (id) t recv: (id) r args: (id) a;
@end

@interface KeywordArgument : ASTNode {
  Ident *selector; 
  Expr *expr;      
}
-(id) init: (id) t sel: (id) s exp: (id) e;
-(char*) key;
-(Expr*) val;
@end

@interface AsmStmt : Stmt {
  Asm *a;
}
-(id) init: (id) t a: (id) aa;
@end

@interface VisSpec : ASTNode
@end

#endif

---