projects/dil: trunk/src/dil/ast/Declarations.d comparison

comparison trunk/src/dil/ast/Declarations.d @ 791:5fe89bb8cbdd

Implemented syntax tree copying.

author	Aziz K?ksal <aziz.koeksal@gmail.com>
date	Tue, 26 Feb 2008 20:13:41 +0100
parents	9f61e8af55d5
children

comparison

equal deleted inserted replaced

-:a83a07f6233d
+:5fe89bb8cbdd
 +/
 module dil.ast.Declarations;
 public import dil.ast.Declaration;
 import dil.ast.Node;
-import dil.ast.Expressions;
+import dil.ast.Expression;
 import dil.ast.Types;
 import dil.ast.Statements;
 import dil.ast.Parameters;
+import dil.ast.NodeCopier;
 import dil.lexer.IdTable;
 import dil.semantic.Symbols;
 import dil.Enums;
 import common;
 Declaration[] decls()
 {
 return cast(Declaration[])this.children;
 }
+void decls(Declaration[] decls)
+{
+this.children = decls;
+}
+mixin(copyMethod);
 }
 /// Single semicolon.
 class EmptyDeclaration : Declaration
 {
 this()
 {
 mixin(set_kind);
 }
-}
+mixin(copyMethod);
+}
-/++
-Illegal declarations encompass all tokens that don't
+/// Illegal declarations encompass all tokens that don't
-start a DeclarationDefinition.
+/// start a DeclarationDefinition.
-See_Also: dil.lexer.Token.isDeclDefStartToken()
+/// See_Also: dil.lexer.Token.isDeclDefStartToken()
-+/
 class IllegalDeclaration : Declaration
 {
 this()
 {
 mixin(set_kind);
 }
+mixin(copyMethod);
 }
 /// FQN = fully qualified name
 alias Identifier*[] ModuleFQN; // Identifier(.Identifier)*
 pname ~= pckg.str ~ separator;
 if (pname.length)
 pname = pname[0..$-1]; // Remove last separator
 return pname;
 }
+mixin(copyMethod);
 }
 class ImportDeclaration : Declaration
 {
 private alias Identifier*[] Ids;
 FQN ~= ident.str ~ separator;
 FQNs ~= FQN[0..$-1]; // Remove last separator
 }
 return FQNs;
 }
+mixin(copyMethod);
 }
 class AliasDeclaration : Declaration
 {
 Declaration decl;
 {
 mixin(set_kind);
 addChild(decl);
 this.decl = decl;
 }
+mixin(copyMethod);
 }
 class TypedefDeclaration : Declaration
 {
 Declaration decl;
 {
 mixin(set_kind);
 addChild(decl);
 this.decl = decl;
 }
+mixin(copyMethod);
 }
 class EnumDeclaration : Declaration
 {
 Identifier* name;
 this.baseType = baseType;
 this.members = members;
 }
 Enum symbol;
+mixin(copyMethod);
 }
 class EnumMemberDeclaration : Declaration
 {
 Identifier* name;
 this.name = name;
 this.value = value;
 }
 EnumMember symbol;
+mixin(copyMethod);
 }
 class TemplateDeclaration : Declaration
 {
 Identifier* name;
 this.tparams = tparams;
 this.decls = decls;
 }
 Template symbol; /// The template symbol for this declaration.
+mixin(copyMethod);
 }
 abstract class AggregateDeclaration : Declaration
 {
 Identifier* name;
 super.hasBody = decls !is null;
 this.name = name;
 //     this.tparams = tparams;
 this.decls = decls;
 }
+mixin(copyMethod);
 }
 class ClassDeclaration : AggregateDeclaration
 {
 BaseClassType[] bases;
 this.bases = bases;
 }
 Class symbol; /// The class symbol for this declaration.
+mixin(copyMethod);
 }
 class InterfaceDeclaration : AggregateDeclaration
 {
 BaseClassType[] bases;
 }
 alias dil.semantic.Symbols.Interface Interface;
 Interface symbol; /// The interface symbol for this declaration.
+mixin(copyMethod);
 }
 class StructDeclaration : AggregateDeclaration
 {
 uint alignSize;
 {
 this.alignSize = alignSize;
 }
 Struct symbol; /// The struct symbol for this declaration.
+mixin(copyMethod);
 }
 class UnionDeclaration : AggregateDeclaration
 {
 this(Identifier* name, /+TemplateParameters tparams, +/CompoundDeclaration decls)
 //     addChild(tparams);
 addOptChild(decls);
 }
 Union symbol; /// The union symbol for this declaration.
+mixin(copyMethod);
 }
 class ConstructorDeclaration : Declaration
 {
 Parameters params;
 addChild(funcBody);
 this.params = params;
 this.funcBody = funcBody;
 }
+mixin(copyMethod);
 }
 class StaticConstructorDeclaration : Declaration
 {
 FuncBodyStatement funcBody;
 mixin(set_kind);
 addChild(funcBody);
 this.funcBody = funcBody;
 }
+mixin(copyMethod);
 }
 class DestructorDeclaration : Declaration
 {
 FuncBodyStatement funcBody;
 mixin(set_kind);
 addChild(funcBody);
 this.funcBody = funcBody;
 }
+mixin(copyMethod);
 }
 class StaticDestructorDeclaration : Declaration
 {
 FuncBodyStatement funcBody;
 mixin(set_kind);
 addChild(funcBody);
 this.funcBody = funcBody;
 }
+mixin(copyMethod);
 }
 class FunctionDeclaration : Declaration
 {
 TypeNode returnType;
 bool isTemplatized()
 { // E.g.: void func(T)(T t)
 //                  ^ params.begin.prevNWS
 return params.begin.prevNWS.kind == TOK.RParen;
 }
+mixin(copyMethod);
 }
 /// VariablesDeclaration := Type? Identifier ("=" Init)? ("," Identifier ("=" Init)?)* ";"
 class VariablesDeclaration : Declaration
 {
 {
 this.linkageType = linkageType;
 }
 Variable[] variables;
+mixin(copyMethod);
 }
 class InvariantDeclaration : Declaration
 {
 FuncBodyStatement funcBody;
 mixin(set_kind);
 addChild(funcBody);
 this.funcBody = funcBody;
 }
+mixin(copyMethod);
 }
 class UnittestDeclaration : Declaration
 {
 FuncBodyStatement funcBody;
 mixin(set_kind);
 addChild(funcBody);
 this.funcBody = funcBody;
 }
+mixin(copyMethod);
 }
 abstract class ConditionalCompilationDeclaration : Declaration
 {
 Token* spec;
 this(Token* spec, Token* cond, Declaration decls, Declaration elseDecls)
 {
 super(spec, cond, decls, elseDecls);
 mixin(set_kind);
 }
+mixin(copyMethod);
 }
 class VersionDeclaration : ConditionalCompilationDeclaration
 {
 this(Token* spec, Token* cond, Declaration decls, Declaration elseDecls)
 {
 super(spec, cond, decls, elseDecls);
 mixin(set_kind);
 }
+mixin(copyMethod);
 }
 class StaticIfDeclaration : Declaration
 {
 Expression condition;
 this.condition = condition;
 this.ifDecls = ifDecls;
 this.elseDecls = elseDecls;
 }
+mixin(copyMethod);
 }
 class StaticAssertDeclaration : Declaration
 {
 Expression condition, message;
 addOptChild(message);
 this.condition = condition;
 this.message = message;
 }
+mixin(copyMethod);
 }
 class NewDeclaration : Declaration
 {
 Parameters params;
 addChild(funcBody);
 this.params = params;
 this.funcBody = funcBody;
 }
+mixin(copyMethod);
 }
 class DeleteDeclaration : Declaration
 {
 Parameters params;
 addChild(funcBody);
 this.params = params;
 this.funcBody = funcBody;
 }
+mixin(copyMethod);
 }
 abstract class AttributeDeclaration : Declaration
 {
 Declaration decls;
 {
 super(decls);
 mixin(set_kind);
 this.prot = prot;
 }
+mixin(copyMethod);
 }
 class StorageClassDeclaration : AttributeDeclaration
 {
 StorageClass storageClass;
 super(decl);
 mixin(set_kind);
 this.storageClass = storageClass;
 }
+mixin(copyMethod);
 }
 class LinkageDeclaration : AttributeDeclaration
 {
 LinkageType linkageType;
 super(decls);
 mixin(set_kind);
 this.linkageType = linkageType;
 }
+mixin(copyMethod);
 }
 class AlignDeclaration : AttributeDeclaration
 {
 int size;
 {
 super(decls);
 mixin(set_kind);
 this.size = size;
 }
+mixin(copyMethod);
 }
 class PragmaDeclaration : AttributeDeclaration
 {
 Identifier* ident;
 mixin(set_kind);
 this.ident = ident;
 this.args = args;
 }
+mixin(copyMethod);
 }
 class MixinDeclaration : Declaration
 {
 /// IdExpression := IdentifierExpression | TemplateInstanceExpression
 bool isMixinExpression()
 {
 return argument !is null;
 }
-}
+mixin(copyMethod);
+}

Mercurial > projects > dil

comparison trunk/src/dil/ast/Declarations.d @ 791:5fe89bb8cbdd