void JsonOut::objectEnd()
{
indentLevel--;
removeComma();
if (buf->offset >= 2 &&
buf->data[buf->offset - 2] == '{' &&
buf->data[buf->offset - 1] == '\n')
buf->offset -= 1;
else
{
buf->writestring("\n");
indent();
}
buf->writestring("}");
comma();
}
char *ModuleDeclaration::toChars()
{
OutBuffer buf;
if (packages && packages->dim)
{
for (size_t i = 0; i < packages->dim; i++)
{ Identifier *pid = packages->tdata()[i];
buf.writestring(pid->toChars());
buf.writeByte('.');
}
}
buf.writestring(id->toChars());
buf.writeByte(0);
return (char *)buf.extractData();
}
void visit(AssignExp *e)
{
/* Evaluate assign expressions right to left
*/
e->e2->accept(this);
e->e1->accept(this);
buf->writestring("Assign");
}
void JsonOut::arrayEnd()
{
indentLevel--;
removeComma();
if (buf->offset >= 2 &&
buf->data[buf->offset - 2] == '[' &&
buf->data[buf->offset - 1] == '\n')
buf->offset -= 1;
else if (!(buf->offset >= 1 &&
buf->data[buf->offset - 1] == '['))
{
buf->writestring("\n");
indent();
}
buf->writestring("]");
comma();
}
void visit(TypeVector *t)
{
if (substitute(t))
return;
buf.writestring("U8__vector");
t->basetype->accept(this);
store(t);
}
char *mangle(Declaration *sthis)
{
OutBuffer buf;
char *id;
Dsymbol *s;
//printf("::mangle(%s)\n", sthis->toChars());
s = sthis;
do
{
//printf("mangle: s = %p, '%s', parent = %p\n", s, s->toChars(), s->parent);
if (s->ident)
{
FuncDeclaration *fd = s->isFuncDeclaration();
if (s != sthis && fd)
{
id = mangle(fd);
buf.prependstring(id);
goto L1;
}
else
{
id = s->ident->toChars();
int len = strlen(id);
char tmp[sizeof(len) * 3 + 1];
buf.prependstring(id);
sprintf(tmp, "%d", len);
buf.prependstring(tmp);
}
}
else
buf.prependstring("0");
s = s->parent;
} while (s);
// buf.prependstring("_D");
L1:
//printf("deco = '%s'\n", sthis->type->deco ? sthis->type->deco : "null");
//printf("sthis->type = %s\n", sthis->type->toChars());
FuncDeclaration *fd = sthis->isFuncDeclaration();
if (fd && (fd->needThis() || fd->isNested()))
buf.writeByte(Type::needThisPrefix());
if (sthis->type->deco)
buf.writestring(sthis->type->deco);
else
{
#ifdef DEBUG
if (!fd->inferRetType)
printf("%s\n", fd->toChars());
#endif
assert(fd && fd->inferRetType);
}
id = buf.toChars();
buf.data = NULL;
return id;
}
// Helper for printing dependency information
void printDepsConditional(Scope *sc, DVCondition* condition, const char* depType)
{
if (!global.params.moduleDeps || global.params.moduleDepsFile)
return;
OutBuffer *ob = global.params.moduleDeps;
Module* imod = sc ? (sc->instantiatingModule ? sc->instantiatingModule : sc->module) : condition->mod;
if (!imod)
return;
ob->writestring(depType);
ob->writestring(imod->toPrettyChars());
ob->writestring(" (");
escapePath(ob, imod->srcfile->toChars());
ob->writestring(") : ");
if (condition->ident)
ob->printf("%s\n", condition->ident->toChars());
else
ob->printf("%d\n", condition->level);
}
Identifier *Identifier::generateId(const char *prefix, size_t i)
{ OutBuffer buf;
buf.writestring(prefix);
buf.printf("%llu", (ulonglong)i);
char *id = buf.peekString();
return idPool(id);
}
void json_generate(Array *modules)
{ OutBuffer buf;
buf.writestring("[\n");
for (int i = 0; i < modules->dim; i++)
{ Module *m = (Module *)modules->data[i];
if (global.params.verbose)
printf("json gen %s\n", m->toChars());
m->toJsonBuffer(&buf);
buf.writestring(",\n");
}
JsonRemoveComma(&buf);
buf.writestring("]\n");
// Write buf to file
char *arg = global.params.xfilename;
if (!arg || !*arg)
{ // Generate lib file name from first obj name
char *n = (char *)global.params.objfiles->data[0];
n = FileName::name(n);
FileName *fn = FileName::forceExt(n, global.json_ext);
arg = fn->toChars();
}
else if (arg[0] == '-' && arg[1] == 0)
{ // Write to stdout; assume it succeeds
int n = fwrite(buf.data, 1, buf.offset, stdout);
assert(n == buf.offset); // keep gcc happy about return values
return;
}
// if (!FileName::absolute(arg))
// arg = FileName::combine(dir, arg);
FileName *jsonfilename = FileName::defaultExt(arg, global.json_ext);
File *jsonfile = new File(jsonfilename);
assert(jsonfile);
jsonfile->setbuffer(buf.data, buf.offset);
jsonfile->ref = 1;
char *pt = FileName::path(jsonfile->toChars());
if (*pt)
FileName::ensurePathExists(pt);
mem.free(pt);
jsonfile->writev();
}
void argsCppMangle(Parameters *arguments, int varargs)
{
if (arguments)
Parameter::foreach(arguments, &argsCppMangleDg, (void*)this);
if (varargs)
buf.writestring("z");
else if (!arguments || !arguments->dim)
buf.writeByte('v'); // encode ( ) arguments
}
Identifier *Identifier::generateId(const char *prefix, size_t i)
{ OutBuffer buf;
buf.writestring(prefix);
buf.printf("%llu", (ulonglong)i);
char *id = buf.toChars();
buf.data = NULL;
return Lexer::idPool(id);
}
void visit(Declaration *d)
{
//printf("Declaration::mangle(this = %p, '%s', parent = '%s', linkage = %d)\n",
// d, d->toChars(), d->parent ? d->parent->toChars() : "null", d->linkage);
if (!d->parent || d->parent->isModule() || d->linkage == LINKcpp) // if at global scope
{
switch (d->linkage)
{
case LINKd:
break;
case LINKc:
case LINKwindows:
case LINKpascal:
result = d->ident->toChars();
break;
case LINKcpp:
result = toCppMangle(d);
break;
case LINKdefault:
d->error("forward declaration");
result = d->ident->toChars();
break;
default:
fprintf(stderr, "'%s', linkage = %d\n", d->toChars(), d->linkage);
assert(0);
}
}
if (!result)
{
OutBuffer buf;
buf.writestring("_D");
mangleDecl(&buf, d);
result = buf.extractString();
}
#ifdef DEBUG
assert(result);
size_t len = strlen(result);
assert(len > 0);
for (size_t i = 0; i < len; i++)
{
assert(result[i] == '_' ||
result[i] == '@' ||
result[i] == '?' ||
result[i] == '$' ||
isalnum(result[i]) || result[i] & 0x80);
}
#endif
}
Identifier *Identifier::generateId(char *prefix)
{ OutBuffer buf;
char *id;
static unsigned i;
buf.writestring(prefix);
buf.printf("%u", ++i);
id = buf.toChars();
buf.data = NULL;
return new Identifier(id, TOKidentifier);
}
void mangle_function(FuncDeclaration *d)
{
/*
* <mangled-name> ::= _Z <encoding>
* <encoding> ::= <function name> <bare-function-type>
* ::= <data name>
* ::= <special-name>
*/
TypeFunction *tf = (TypeFunction *)d->type;
buf.writestring(global.params.isOSX ? "__Z" : "_Z"); // "__Z" for OSX, "_Z" for other
Dsymbol *p = d->toParent();
if (p && !p->isModule() && tf->linkage == LINKcpp)
{
buf.writeByte('N');
if (d->type->isConst())
buf.writeByte('K');
prefix_name(p);
if (d->isDtorDeclaration())
{
buf.writestring("D1");
}
else
{
source_name(d);
}
buf.writeByte('E');
}
else
{
source_name(d);
}
if (tf->linkage == LINKcpp) //Template args accept extern "C" symbols with special mangling
{
assert(tf->ty == Tfunction);
argsCppMangle(tf->parameters, tf->varargs);
}
}
void argsCppMangle(Parameters *arguments, int varargs)
{
size_t n = 0;
if (arguments)
{
ArgsCppMangleCtx ctx = { this, 0 };
Parameter::foreach(arguments, &argsCppMangleDg, &ctx);
n = ctx.cnt;
}
if (varargs)
buf.writestring("z");
else if (!n)
buf.writeByte('v'); // encode ( ) arguments
}
void visit(TypeVector *t)
{
if (substitute(t)) return;
store(t);
if (t->isImmutable() || t->isShared())
{
visit((Type *)t);
}
if (t->isConst())
buf.writeByte('K');
assert(t->basetype && t->basetype->ty == Tsarray);
assert(((TypeSArray *)t->basetype)->dim);
//buf.printf("Dv%llu_", ((TypeSArray *)t->basetype)->dim->toInteger());// -- Gnu ABI v.4
buf.writestring("U8__vector"); //-- Gnu ABI v.3
t->basetype->nextOf()->accept(this);
}
/**
* Creates the data symbol for a TLS variable for Mach-O.
*
* Input:
* vd the variable declaration for the symbol
* s the regular symbol for the variable
*
* Returns: the newly create symbol
*/
Symbol *createTLVDataSymbol(VarDeclaration *vd, Symbol *s)
{
assert(config.objfmt == OBJ_MACH && I64 && (s->ty() & mTYLINK) == mTYthread);
OutBuffer buffer;
buffer.writestring(s->Sident);
buffer.write("$tlv$init", 9);
const char *tlvInitName = buffer.extractString();
Symbol *tlvInit = symbol_name(tlvInitName, SCstatic, type_fake(vd->type->ty));
tlvInit->Sdt = NULL;
tlvInit->Salignment = type_alignsize(s->Stype);
type_setty(&tlvInit->Stype, tlvInit->Stype->Tty | mTYthreadData);
type_setmangle(&tlvInit->Stype, mangle(vd, tlvInit));
return tlvInit;
}
char *Dsymbol::mangle()
{
OutBuffer buf;
char *id;
//printf("Dsymbol::mangle() '%s'\n", toChars());
id = ident ? ident->toChars() : toChars();
if (parent)
{
//printf(" parent = '%s', kind = '%s'\n", parent->mangle(), parent->kind());
buf.writestring(parent->mangle());
}
buf.printf("%d%s", strlen(id), id);
//buf.writestring("_");
//buf.writestring(id);
id = buf.toChars();
buf.data = NULL;
return id;
}
void JsonOut::stringPart(const char *s)
{
for (; *s; s++)
{
utf8_t c = (utf8_t) *s;
switch (c)
{
case '\n':
buf->writestring("\\n");
break;
case '\r':
buf->writestring("\\r");
break;
case '\t':
buf->writestring("\\t");
break;
case '\"':
buf->writestring("\\\"");
break;
case '\\':
buf->writestring("\\\\");
break;
case '\b':
buf->writestring("\\b");
break;
case '\f':
buf->writestring("\\f");
break;
default:
if (c < 0x20)
buf->printf("\\u%04x", c);
else
// Note that UTF-8 chars pass through here just fine
buf->writeByte(c);
break;
}
}
}
void visit(BinAssignExp *e)
{
/* Evaluate assign expressions right to left
*/
e->e2->accept(this);
e->e1->accept(this);
const char *s;
switch(e->op)
{
case TOKaddass: s = "Addass"; break;
case TOKminass: s = "Minass"; break;
case TOKmulass: s = "Mulass"; break;
case TOKdivass: s = "Divass"; break;
case TOKmodass: s = "Modass"; break;
case TOKxorass: s = "Xorass"; break;
case TOKandass: s = "Andass"; break;
case TOKorass: s = "Orass"; break;
case TOKpowass: s = "Powass"; break;
default: assert(0);
}
buf->writestring(s);
}
/**
* Creates the data symbol used to initialize a TLS variable for Mach-O.
*
* Params:
* vd = the variable declaration for the symbol
* s = the back end symbol corresponding to vd
*
* Returns: the newly created symbol
*/
Symbol *createTLVDataSymbol(VarDeclaration *vd, Symbol *s)
{
assert(config.objfmt == OBJ_MACH && I64 && (s->ty() & mTYLINK) == mTYthread);
// Compute identifier for tlv symbol
OutBuffer buffer;
buffer.writestring(s->Sident);
buffer.write("$tlv$init", 9);
const char *tlvInitName = buffer.peekString();
// Compute type for tlv symbol
type *t = type_fake(vd->type->ty);
type_setty(&t, t->Tty | mTYthreadData);
type_setmangle(&t, mangle(vd));
Symbol *tlvInit = symbol_name(tlvInitName, SCstatic, t);
tlvInit->Sdt = NULL;
tlvInit->Salignment = type_alignsize(s->Stype);
if (vd->linkage == LINKcpp)
tlvInit->Sflags |= SFLpublic;
return tlvInit;
}
Module *Module::load(Loc loc, Array *packages, Identifier *ident)
{ Module *m;
char *filename;
//printf("Module::load(ident = '%s')\n", ident->toChars());
// Build module filename by turning:
// foo.bar.baz
// into:
// foo\bar\baz
filename = ident->toChars();
if (packages && packages->dim)
{
OutBuffer buf;
int i;
for (i = 0; i < packages->dim; i++)
{ Identifier *pid = (Identifier *)packages->data[i];
buf.writestring(pid->toChars());
#if _WIN32
buf.writeByte('\\');
#else
buf.writeByte('/');
#endif
}
buf.writestring(filename);
buf.writeByte(0);
filename = (char *)buf.extractData();
}
m = new Module(filename, ident, 0, 0);
m->loc = loc;
/* Search along global.path for .di file, then .d file.
*/
char *result = NULL;
FileName *fdi = FileName::forceExt(filename, global.hdr_ext);
FileName *fd = FileName::forceExt(filename, global.mars_ext);
char *sdi = fdi->toChars();
char *sd = fd->toChars();
if (FileName::exists(sdi))
result = sdi;
else if (FileName::exists(sd))
result = sd;
else if (FileName::absolute(filename))
;
else if (!global.path)
;
else
{
for (size_t i = 0; i < global.path->dim; i++)
{
char *p = (char *)global.path->data[i];
char *n = FileName::combine(p, sdi);
if (FileName::exists(n))
{ result = n;
break;
}
mem.free(n);
n = FileName::combine(p, sd);
if (FileName::exists(n))
{ result = n;
break;
}
mem.free(n);
}
}
if (result)
m->srcfile = new File(result);
if (global.params.verbose)
{
printf("import ");
if (packages)
{
for (size_t i = 0; i < packages->dim; i++)
{ Identifier *pid = (Identifier *)packages->data[i];
printf("%s.", pid->toChars());
}
}
printf("%s\t(%s)\n", ident->toChars(), m->srcfile->toChars());
}
m->read(loc);
m->parse();
#ifdef IN_GCC
d_gcc_magic_module(m);
#endif
return m;
}
Expression *BinExp::arrayOp(Scope *sc)
{
//printf("BinExp::arrayOp() %s\n", toChars());
Type *tb = type->toBasetype();
assert(tb->ty == Tarray || tb->ty == Tsarray);
if (tb->nextOf()->toBasetype()->ty == Tvoid)
{
error("Cannot perform array operations on void[] arrays");
return new ErrorExp();
}
if (!isArrayOpValid(e2))
{
e2->error("invalid array operation %s (did you forget a [] ?)", toChars());
return new ErrorExp();
}
Expressions *arguments = new Expressions();
/* The expression to generate an array operation for is mangled
* into a name to use as the array operation function name.
* Mangle in the operands and operators in RPN order, and type.
*/
OutBuffer buf;
buf.writestring("_array");
buildArrayIdent(&buf, arguments);
buf.writeByte('_');
/* Append deco of array element type
*/
#if DMDV2
buf.writestring(type->toBasetype()->nextOf()->toBasetype()->mutableOf()->deco);
#else
buf.writestring(type->toBasetype()->nextOf()->toBasetype()->deco);
#endif
size_t namelen = buf.offset;
buf.writeByte(0);
char *name = buf.toChars();
Identifier *ident = Lexer::idPool(name);
/* Look up name in hash table
*/
FuncDeclaration **pfd = (FuncDeclaration **)_aaGet(&arrayfuncs, ident);
FuncDeclaration *fd = (FuncDeclaration *)*pfd;
if (!fd)
{
/* Some of the array op functions are written as library functions,
* presumably to optimize them with special CPU vector instructions.
* List those library functions here, in alpha order.
*/
static const char *libArrayopFuncs[] =
{
"_arrayExpSliceAddass_a",
"_arrayExpSliceAddass_d", // T[]+=T
"_arrayExpSliceAddass_f", // T[]+=T
"_arrayExpSliceAddass_g",
"_arrayExpSliceAddass_h",
"_arrayExpSliceAddass_i",
"_arrayExpSliceAddass_k",
"_arrayExpSliceAddass_s",
"_arrayExpSliceAddass_t",
"_arrayExpSliceAddass_u",
"_arrayExpSliceAddass_w",
"_arrayExpSliceDivass_d", // T[]/=T
"_arrayExpSliceDivass_f", // T[]/=T
"_arrayExpSliceMinSliceAssign_a",
"_arrayExpSliceMinSliceAssign_d", // T[]=T-T[]
"_arrayExpSliceMinSliceAssign_f", // T[]=T-T[]
"_arrayExpSliceMinSliceAssign_g",
"_arrayExpSliceMinSliceAssign_h",
"_arrayExpSliceMinSliceAssign_i",
"_arrayExpSliceMinSliceAssign_k",
"_arrayExpSliceMinSliceAssign_s",
"_arrayExpSliceMinSliceAssign_t",
"_arrayExpSliceMinSliceAssign_u",
"_arrayExpSliceMinSliceAssign_w",
"_arrayExpSliceMinass_a",
"_arrayExpSliceMinass_d", // T[]-=T
"_arrayExpSliceMinass_f", // T[]-=T
"_arrayExpSliceMinass_g",
"_arrayExpSliceMinass_h",
"_arrayExpSliceMinass_i",
"_arrayExpSliceMinass_k",
"_arrayExpSliceMinass_s",
"_arrayExpSliceMinass_t",
"_arrayExpSliceMinass_u",
"_arrayExpSliceMinass_w",
"_arrayExpSliceMulass_d", // T[]*=T
"_arrayExpSliceMulass_f", // T[]*=T
"_arrayExpSliceMulass_i",
"_arrayExpSliceMulass_k",
"_arrayExpSliceMulass_s",
"_arrayExpSliceMulass_t",
"_arrayExpSliceMulass_u",
"_arrayExpSliceMulass_w",
"_arraySliceExpAddSliceAssign_a",
"_arraySliceExpAddSliceAssign_d", // T[]=T[]+T
"_arraySliceExpAddSliceAssign_f", // T[]=T[]+T
"_arraySliceExpAddSliceAssign_g",
"_arraySliceExpAddSliceAssign_h",
"_arraySliceExpAddSliceAssign_i",
"_arraySliceExpAddSliceAssign_k",
"_arraySliceExpAddSliceAssign_s",
"_arraySliceExpAddSliceAssign_t",
"_arraySliceExpAddSliceAssign_u",
"_arraySliceExpAddSliceAssign_w",
"_arraySliceExpDivSliceAssign_d", // T[]=T[]/T
"_arraySliceExpDivSliceAssign_f", // T[]=T[]/T
"_arraySliceExpMinSliceAssign_a",
"_arraySliceExpMinSliceAssign_d", // T[]=T[]-T
"_arraySliceExpMinSliceAssign_f", // T[]=T[]-T
"_arraySliceExpMinSliceAssign_g",
"_arraySliceExpMinSliceAssign_h",
"_arraySliceExpMinSliceAssign_i",
"_arraySliceExpMinSliceAssign_k",
"_arraySliceExpMinSliceAssign_s",
"_arraySliceExpMinSliceAssign_t",
"_arraySliceExpMinSliceAssign_u",
"_arraySliceExpMinSliceAssign_w",
"_arraySliceExpMulSliceAddass_d", // T[] += T[]*T
"_arraySliceExpMulSliceAddass_f",
"_arraySliceExpMulSliceAddass_r",
"_arraySliceExpMulSliceAssign_d", // T[]=T[]*T
"_arraySliceExpMulSliceAssign_f", // T[]=T[]*T
"_arraySliceExpMulSliceAssign_i",
"_arraySliceExpMulSliceAssign_k",
"_arraySliceExpMulSliceAssign_s",
"_arraySliceExpMulSliceAssign_t",
"_arraySliceExpMulSliceAssign_u",
"_arraySliceExpMulSliceAssign_w",
"_arraySliceExpMulSliceMinass_d", // T[] -= T[]*T
"_arraySliceExpMulSliceMinass_f",
"_arraySliceExpMulSliceMinass_r",
"_arraySliceSliceAddSliceAssign_a",
"_arraySliceSliceAddSliceAssign_d", // T[]=T[]+T[]
"_arraySliceSliceAddSliceAssign_f", // T[]=T[]+T[]
"_arraySliceSliceAddSliceAssign_g",
"_arraySliceSliceAddSliceAssign_h",
"_arraySliceSliceAddSliceAssign_i",
"_arraySliceSliceAddSliceAssign_k",
"_arraySliceSliceAddSliceAssign_r", // T[]=T[]+T[]
"_arraySliceSliceAddSliceAssign_s",
"_arraySliceSliceAddSliceAssign_t",
"_arraySliceSliceAddSliceAssign_u",
"_arraySliceSliceAddSliceAssign_w",
"_arraySliceSliceAddass_a",
"_arraySliceSliceAddass_d", // T[]+=T[]
"_arraySliceSliceAddass_f", // T[]+=T[]
"_arraySliceSliceAddass_g",
"_arraySliceSliceAddass_h",
"_arraySliceSliceAddass_i",
"_arraySliceSliceAddass_k",
"_arraySliceSliceAddass_s",
"_arraySliceSliceAddass_t",
"_arraySliceSliceAddass_u",
"_arraySliceSliceAddass_w",
"_arraySliceSliceMinSliceAssign_a",
"_arraySliceSliceMinSliceAssign_d", // T[]=T[]-T[]
"_arraySliceSliceMinSliceAssign_f", // T[]=T[]-T[]
"_arraySliceSliceMinSliceAssign_g",
"_arraySliceSliceMinSliceAssign_h",
"_arraySliceSliceMinSliceAssign_i",
"_arraySliceSliceMinSliceAssign_k",
"_arraySliceSliceMinSliceAssign_r", // T[]=T[]-T[]
"_arraySliceSliceMinSliceAssign_s",
"_arraySliceSliceMinSliceAssign_t",
"_arraySliceSliceMinSliceAssign_u",
"_arraySliceSliceMinSliceAssign_w",
"_arraySliceSliceMinass_a",
"_arraySliceSliceMinass_d", // T[]-=T[]
"_arraySliceSliceMinass_f", // T[]-=T[]
"_arraySliceSliceMinass_g",
"_arraySliceSliceMinass_h",
"_arraySliceSliceMinass_i",
"_arraySliceSliceMinass_k",
"_arraySliceSliceMinass_s",
"_arraySliceSliceMinass_t",
"_arraySliceSliceMinass_u",
"_arraySliceSliceMinass_w",
"_arraySliceSliceMulSliceAssign_d", // T[]=T[]*T[]
"_arraySliceSliceMulSliceAssign_f", // T[]=T[]*T[]
"_arraySliceSliceMulSliceAssign_i",
"_arraySliceSliceMulSliceAssign_k",
"_arraySliceSliceMulSliceAssign_s",
"_arraySliceSliceMulSliceAssign_t",
"_arraySliceSliceMulSliceAssign_u",
"_arraySliceSliceMulSliceAssign_w",
"_arraySliceSliceMulass_d", // T[]*=T[]
"_arraySliceSliceMulass_f", // T[]*=T[]
"_arraySliceSliceMulass_i",
"_arraySliceSliceMulass_k",
"_arraySliceSliceMulass_s",
"_arraySliceSliceMulass_t",
"_arraySliceSliceMulass_u",
"_arraySliceSliceMulass_w",
};
int i = binary(name, libArrayopFuncs, sizeof(libArrayopFuncs) / sizeof(char *));
if (i == -1)
{
#ifdef DEBUG // Make sure our array is alphabetized
for (i = 0; i < sizeof(libArrayopFuncs) / sizeof(char *); i++)
{
if (strcmp(name, libArrayopFuncs[i]) == 0)
assert(0);
}
#endif
/* Not in library, so generate it.
* Construct the function body:
* foreach (i; 0 .. p.length) for (size_t i = 0; i < p.length; i++)
* loopbody;
* return p;
*/
Parameters *fparams = new Parameters();
Expression *loopbody = buildArrayLoop(fparams);
Parameter *p = (*fparams)[0 /*fparams->dim - 1*/];
#if DMDV1
// for (size_t i = 0; i < p.length; i++)
Initializer *init = new ExpInitializer(0, new IntegerExp(0, 0, Type::tsize_t));
Dsymbol *d = new VarDeclaration(0, Type::tsize_t, Id::p, init);
Statement *s1 = new ForStatement(0,
new DeclarationStatement(0, d),
new CmpExp(TOKlt, 0, new IdentifierExp(0, Id::p), new ArrayLengthExp(0, new IdentifierExp(0, p->ident))),
new PostExp(TOKplusplus, 0, new IdentifierExp(0, Id::p)),
new ExpStatement(0, loopbody));
#else
// foreach (i; 0 .. p.length)
Statement *s1 = new ForeachRangeStatement(0, TOKforeach,
new Parameter(0, NULL, Id::p, NULL),
new IntegerExp(0, 0, Type::tsize_t),
new ArrayLengthExp(0, new IdentifierExp(0, p->ident)),
new ExpStatement(0, loopbody));
#endif
Statement *s2 = new ReturnStatement(0, new IdentifierExp(0, p->ident));
//printf("s2: %s\n", s2->toChars());
Statement *fbody = new CompoundStatement(0, s1, s2);
/* Construct the function
*/
TypeFunction *ftype = new TypeFunction(fparams, type, 0, LINKc);
//printf("ftype: %s\n", ftype->toChars());
fd = new FuncDeclaration(loc, 0, ident, STCundefined, ftype);
fd->fbody = fbody;
fd->protection = PROTpublic;
fd->linkage = LINKc;
fd->isArrayOp = 1;
sc->module->importedFrom->members->push(fd);
sc = sc->push();
sc->parent = sc->module->importedFrom;
sc->stc = 0;
sc->linkage = LINKc;
fd->semantic(sc);
fd->semantic2(sc);
fd->semantic3(sc);
sc->pop();
}
else
{ /* In library, refer to it.
*/
fd = FuncDeclaration::genCfunc(type, ident);
}
*pfd = fd; // cache symbol in hash table
}
/* Call the function fd(arguments)
*/
Expression *ec = new VarExp(0, fd);
Expression *e = new CallExp(loc, ec, arguments);
e->type = type;
return e;
}
void Import::semantic(Scope *sc)
{
//printf("Import::semantic('%s')\n", toChars());
// Load if not already done so
if (!mod)
{ load(sc);
if (mod)
mod->importAll(0);
}
if (mod)
{
#if 0
if (mod->loc.linnum != 0)
{ /* If the line number is not 0, then this is not
* a 'root' module, i.e. it was not specified on the command line.
*/
mod->importedFrom = sc->module->importedFrom;
assert(mod->importedFrom);
}
#endif
// Modules need a list of each imported module
//printf("%s imports %s\n", sc->module->toChars(), mod->toChars());
sc->module->aimports.push(mod);
if (!isstatic && !aliasId && !names.dim)
{
if (sc->explicitProtection)
protection = sc->protection;
for (Scope *scd = sc; scd; scd = scd->enclosing)
{
if (scd->scopesym)
{
scd->scopesym->importScope(mod, protection);
break;
}
}
}
mod->semantic();
if (mod->needmoduleinfo)
{ //printf("module4 %s because of %s\n", sc->module->toChars(), mod->toChars());
sc->module->needmoduleinfo = 1;
}
sc = sc->push(mod);
/* BUG: Protection checks can't be enabled yet. The issue is
* that Dsymbol::search errors before overload resolution.
*/
#if 0
sc->protection = protection;
#else
sc->protection = PROTpublic;
#endif
for (size_t i = 0; i < aliasdecls.dim; i++)
{ Dsymbol *s = aliasdecls[i];
//printf("\tImport alias semantic('%s')\n", s->toChars());
if (mod->search(loc, names[i], 0))
s->semantic(sc);
else
{
s = mod->search_correct(names[i]);
if (s)
mod->error(loc, "import '%s' not found, did you mean '%s %s'?", names[i]->toChars(), s->kind(), s->toChars());
else
mod->error(loc, "import '%s' not found", names[i]->toChars());
}
}
sc = sc->pop();
}
if (global.params.moduleDeps != NULL &&
// object self-imports itself, so skip that (Bugzilla 7547)
!(id == Id::object && sc->module->ident == Id::object))
{
/* The grammar of the file is:
* ImportDeclaration
* ::= BasicImportDeclaration [ " : " ImportBindList ] [ " -> "
* ModuleAliasIdentifier ] "\n"
*
* BasicImportDeclaration
* ::= ModuleFullyQualifiedName " (" FilePath ") : " Protection
* " [ " static" ] : " ModuleFullyQualifiedName " (" FilePath ")"
*
* FilePath
* - any string with '(', ')' and '\' escaped with the '\' character
*/
OutBuffer *ob = global.params.moduleDeps;
ob->writestring(sc->module->toPrettyChars());
ob->writestring(" (");
escapePath(ob, sc->module->srcfile->toChars());
ob->writestring(") : ");
// use protection instead of sc->protection because it couldn't be
// resolved yet, see the comment above
ProtDeclaration::protectionToCBuffer(ob, protection);
if (isstatic)
StorageClassDeclaration::stcToCBuffer(ob, STCstatic);
ob->writestring(": ");
if (packages)
{
for (size_t i = 0; i < packages->dim; i++)
{
Identifier *pid = (*packages)[i];
ob->printf("%s.", pid->toChars());
}
}
ob->writestring(id->toChars());
ob->writestring(" (");
if (mod)
escapePath(ob, mod->srcfile->toChars());
else
ob->writestring("???");
ob->writebyte(')');
for (size_t i = 0; i < names.dim; i++)
{
if (i == 0)
ob->writebyte(':');
else
ob->writebyte(',');
Identifier *name = names[i];
Identifier *alias = aliases[i];
if (!alias)
{
ob->printf("%s", name->toChars());
alias = name;
}
else
ob->printf("%s=%s", alias->toChars(), name->toChars());
}
if (aliasId)
ob->printf(" -> %s", aliasId->toChars());
ob->writenl();
}
//printf("-Import::semantic('%s'), pkg = %p\n", toChars(), pkg);
}
int runLINK()
{
#if _WIN32
if (global.params.is64bit)
{
OutBuffer cmdbuf;
cmdbuf.writestring("/NOLOGO ");
for (size_t i = 0; i < global.params.objfiles->dim; i++)
{
if (i)
cmdbuf.writeByte(' ');
const char *p = (*global.params.objfiles)[i];
const char *basename = FileName::removeExt(FileName::name(p));
const char *ext = FileName::ext(p);
if (ext && !strchr(basename, '.'))
{
// Write name sans extension (but not if a double extension)
writeFilename(&cmdbuf, p, ext - p - 1);
}
else
writeFilename(&cmdbuf, p);
FileName::free(basename);
}
if (global.params.resfile)
{
cmdbuf.writeByte(' ');
writeFilename(&cmdbuf, global.params.resfile);
}
cmdbuf.writeByte(' ');
if (global.params.exefile)
{ cmdbuf.writestring("/OUT:");
writeFilename(&cmdbuf, global.params.exefile);
}
else
{ /* Generate exe file name from first obj name.
* No need to add it to cmdbuf because the linker will default to it.
*/
const char *n = (*global.params.objfiles)[0];
n = FileName::name(n);
global.params.exefile = (char *)FileName::forceExt(n, "exe");
}
// Make sure path to exe file exists
ensurePathToNameExists(Loc(), global.params.exefile);
cmdbuf.writeByte(' ');
if (global.params.mapfile)
{ cmdbuf.writestring("/MAP:");
writeFilename(&cmdbuf, global.params.mapfile);
}
else if (global.params.map)
{
const char *fn = FileName::forceExt(global.params.exefile, "map");
const char *path = FileName::path(global.params.exefile);
const char *p;
if (path[0] == '\0')
p = FileName::combine(global.params.objdir, fn);
else
p = fn;
cmdbuf.writestring("/MAP:");
writeFilename(&cmdbuf, p);
}
for (size_t i = 0; i < global.params.libfiles->dim; i++)
{
cmdbuf.writeByte(' ');
cmdbuf.writestring("/DEFAULTLIB:");
writeFilename(&cmdbuf, (*global.params.libfiles)[i]);
}
if (global.params.deffile)
{
cmdbuf.writeByte(' ');
cmdbuf.writestring("/DEF:");
writeFilename(&cmdbuf, global.params.deffile);
}
if (global.params.symdebug)
{
cmdbuf.writeByte(' ');
cmdbuf.writestring("/DEBUG");
// in release mode we need to reactivate /OPT:REF after /DEBUG
if (global.params.release)
cmdbuf.writestring(" /OPT:REF");
}
if (global.params.dll)
{
cmdbuf.writeByte(' ');
cmdbuf.writestring("/DLL");
}
for (size_t i = 0; i < global.params.linkswitches->dim; i++)
{
cmdbuf.writeByte(' ');
cmdbuf.writestring((*global.params.linkswitches)[i]);
}
/* Append the path to the VC lib files, and then the SDK lib files
*/
const char *vcinstalldir = getenv("VCINSTALLDIR");
if (vcinstalldir)
{ cmdbuf.writestring(" \"/LIBPATH:");
cmdbuf.writestring(vcinstalldir);
cmdbuf.writestring("lib\\amd64\"");
}
const char *windowssdkdir = getenv("WindowsSdkDir");
if (windowssdkdir)
{ cmdbuf.writestring(" \"/LIBPATH:");
cmdbuf.writestring(windowssdkdir);
cmdbuf.writestring("lib\\x64\"");
}
char *p = cmdbuf.peekString();
const char *lnkfilename = NULL;
size_t plen = strlen(p);
if (plen > 7000)
{
lnkfilename = FileName::forceExt(global.params.exefile, "lnk");
File flnk(lnkfilename);
flnk.setbuffer(p, plen);
flnk.ref = 1;
if (flnk.write())
error(Loc(), "error writing file %s", lnkfilename);
if (strlen(lnkfilename) < plen)
sprintf(p, "@%s", lnkfilename);
}
const char *linkcmd = getenv("LINKCMD64");
if (!linkcmd)
linkcmd = getenv("LINKCMD"); // backward compatible
if (!linkcmd)
{
if (vcinstalldir)
{
OutBuffer linkcmdbuf;
linkcmdbuf.writestring(vcinstalldir);
linkcmdbuf.writestring("bin\\amd64\\link");
linkcmd = linkcmdbuf.extractString();
}
else
linkcmd = "link";
}
int status = executecmd(linkcmd, p);
if (lnkfilename)
{
remove(lnkfilename);
FileName::free(lnkfilename);
}
return status;
}
else
{
OutBuffer cmdbuf;
global.params.libfiles->push("user32");
global.params.libfiles->push("kernel32");
for (size_t i = 0; i < global.params.objfiles->dim; i++)
{
if (i)
cmdbuf.writeByte('+');
const char *p = (*global.params.objfiles)[i];
const char *basename = FileName::removeExt(FileName::name(p));
const char *ext = FileName::ext(p);
if (ext && !strchr(basename, '.'))
{
// Write name sans extension (but not if a double extension)
writeFilename(&cmdbuf, p, ext - p - 1);
}
else
writeFilename(&cmdbuf, p);
FileName::free(basename);
}
cmdbuf.writeByte(',');
if (global.params.exefile)
writeFilename(&cmdbuf, global.params.exefile);
else
{ /* Generate exe file name from first obj name.
* No need to add it to cmdbuf because the linker will default to it.
*/
const char *n = (*global.params.objfiles)[0];
n = FileName::name(n);
global.params.exefile = (char *)FileName::forceExt(n, "exe");
}
// Make sure path to exe file exists
ensurePathToNameExists(Loc(), global.params.exefile);
cmdbuf.writeByte(',');
if (global.params.mapfile)
writeFilename(&cmdbuf, global.params.mapfile);
else if (global.params.map)
{
const char *fn = FileName::forceExt(global.params.exefile, "map");
const char *path = FileName::path(global.params.exefile);
const char *p;
if (path[0] == '\0')
p = FileName::combine(global.params.objdir, fn);
else
p = fn;
writeFilename(&cmdbuf, p);
}
else
cmdbuf.writestring("nul");
cmdbuf.writeByte(',');
for (size_t i = 0; i < global.params.libfiles->dim; i++)
{
if (i)
cmdbuf.writeByte('+');
writeFilename(&cmdbuf, (*global.params.libfiles)[i]);
}
if (global.params.deffile)
{
cmdbuf.writeByte(',');
writeFilename(&cmdbuf, global.params.deffile);
}
/* Eliminate unnecessary trailing commas */
while (1)
{ size_t i = cmdbuf.offset;
if (!i || cmdbuf.data[i - 1] != ',')
break;
cmdbuf.offset--;
}
if (global.params.resfile)
{
cmdbuf.writestring("/RC:");
writeFilename(&cmdbuf, global.params.resfile);
}
if (global.params.map || global.params.mapfile)
cmdbuf.writestring("/m");
#if 0
if (debuginfo)
cmdbuf.writestring("/li");
if (codeview)
{
cmdbuf.writestring("/co");
if (codeview3)
cmdbuf.writestring(":3");
}
#else
if (global.params.symdebug)
cmdbuf.writestring("/co");
#endif
cmdbuf.writestring("/noi");
for (size_t i = 0; i < global.params.linkswitches->dim; i++)
{
cmdbuf.writestring((*global.params.linkswitches)[i]);
}
cmdbuf.writeByte(';');
char *p = cmdbuf.peekString();
const char *lnkfilename = NULL;
size_t plen = strlen(p);
if (plen > 7000)
{
lnkfilename = FileName::forceExt(global.params.exefile, "lnk");
File flnk(lnkfilename);
flnk.setbuffer(p, plen);
flnk.ref = 1;
if (flnk.write())
error(Loc(), "error writing file %s", lnkfilename);
if (strlen(lnkfilename) < plen)
sprintf(p, "@%s", lnkfilename);
}
const char *linkcmd = getenv("LINKCMD");
if (!linkcmd)
linkcmd = "link";
int status = executecmd(linkcmd, p);
if (lnkfilename)
{
remove(lnkfilename);
FileName::free(lnkfilename);
}
return status;
}
#elif __linux__ || __APPLE__ || __FreeBSD__ || __OpenBSD__ || __sun
pid_t childpid;
int status;
// Build argv[]
Strings argv;
const char *cc = getenv("CC");
if (!cc)
cc = "gcc";
argv.push(cc);
argv.insert(1, global.params.objfiles);
#if __APPLE__
// If we are on Mac OS X and linking a dynamic library,
// add the "-dynamiclib" flag
if (global.params.dll)
argv.push("-dynamiclib");
#elif __linux__ || __FreeBSD__ || __OpenBSD__ || __sun
if (global.params.dll)
argv.push("-shared");
#endif
// None of that a.out stuff. Use explicit exe file name, or
// generate one from name of first source file.
argv.push("-o");
if (global.params.exefile)
{
argv.push(global.params.exefile);
}
else if (global.params.run)
{
#if 1
char name[L_tmpnam + 14 + 1];
strcpy(name, P_tmpdir);
strcat(name, "/dmd_runXXXXXX");
int fd = mkstemp(name);
if (fd == -1)
{ error(Loc(), "error creating temporary file");
return 1;
}
else
close(fd);
global.params.exefile = mem.strdup(name);
argv.push(global.params.exefile);
#else
/* The use of tmpnam raises the issue of "is this a security hole"?
* The hole is that after tmpnam and before the file is opened,
* the attacker modifies the file system to get control of the
* file with that name. I do not know if this is an issue in
* this context.
* We cannot just replace it with mkstemp, because this name is
* passed to the linker that actually opens the file and writes to it.
*/
char s[L_tmpnam + 1];
char *n = tmpnam(s);
global.params.exefile = mem.strdup(n);
argv.push(global.params.exefile);
#endif
}
else
{ // Generate exe file name from first obj name
const char *n = (*global.params.objfiles)[0];
char *ex;
n = FileName::name(n);
const char *e = FileName::ext(n);
if (e)
{
e--; // back up over '.'
ex = (char *)mem.malloc(e - n + 1);
memcpy(ex, n, e - n);
ex[e - n] = 0;
// If generating dll then force dll extension
if (global.params.dll)
ex = (char *)FileName::forceExt(ex, global.dll_ext);
}
else
ex = (char *)"a.out"; // no extension, so give up
argv.push(ex);
global.params.exefile = ex;
}
// Make sure path to exe file exists
ensurePathToNameExists(Loc(), global.params.exefile);
if (global.params.symdebug)
argv.push("-g");
if (global.params.is64bit)
argv.push("-m64");
else
argv.push("-m32");
if (global.params.map || global.params.mapfile)
{
argv.push("-Xlinker");
#if __APPLE__
argv.push("-map");
#else
argv.push("-Map");
#endif
if (!global.params.mapfile)
{
const char *fn = FileName::forceExt(global.params.exefile, "map");
const char *path = FileName::path(global.params.exefile);
const char *p;
if (path[0] == '\0')
p = FileName::combine(global.params.objdir, fn);
else
p = fn;
global.params.mapfile = (char *)p;
}
argv.push("-Xlinker");
argv.push(global.params.mapfile);
}
if (0 && global.params.exefile)
{
/* This switch enables what is known as 'smart linking'
* in the Windows world, where unreferenced sections
* are removed from the executable. It eliminates unreferenced
* functions, essentially making a 'library' out of a module.
* Although it is documented to work with ld version 2.13,
* in practice it does not, but just seems to be ignored.
* Thomas Kuehne has verified that it works with ld 2.16.1.
* BUG: disabled because it causes exception handling to fail
* because EH sections are "unreferenced" and elided
*/
argv.push("-Xlinker");
argv.push("--gc-sections");
}
for (size_t i = 0; i < global.params.linkswitches->dim; i++)
{ const char *p = (*global.params.linkswitches)[i];
if (!p || !p[0] || !(p[0] == '-' && (p[1] == 'l' || p[1] == 'L')))
// Don't need -Xlinker if switch starts with -l or -L.
// Eliding -Xlinker is significant for -L since it allows our paths
// to take precedence over gcc defaults.
argv.push("-Xlinker");
argv.push(p);
}
/* Add each library, prefixing it with "-l".
* The order of libraries passed is:
* 1. any libraries passed with -L command line switch
* 2. libraries specified on the command line
* 3. libraries specified by pragma(lib), which were appended
* to global.params.libfiles.
* 4. standard libraries.
*/
for (size_t i = 0; i < global.params.libfiles->dim; i++)
{ const char *p = (*global.params.libfiles)[i];
size_t plen = strlen(p);
if (plen > 2 && p[plen - 2] == '.' && p[plen -1] == 'a')
argv.push(p);
else
{
char *s = (char *)mem.malloc(plen + 3);
s[0] = '-';
s[1] = 'l';
memcpy(s + 2, p, plen + 1);
argv.push(s);
}
}
for (size_t i = 0; i < global.params.dllfiles->dim; i++)
{
const char *p = (*global.params.dllfiles)[i];
argv.push(p);
}
/* Standard libraries must go after user specified libraries
* passed with -l.
*/
const char *libname = (global.params.symdebug)
? global.params.debuglibname
: global.params.defaultlibname;
size_t slen = strlen(libname);
if (slen)
{
char *buf = (char *)malloc(3 + slen + 1);
strcpy(buf, "-l");
/* Use "-l:libname.a" if the library name is complete
*/
if (slen > 3 + 2 &&
memcmp(libname, "lib", 3) == 0 &&
(memcmp(libname + slen - 2, ".a", 2) == 0 ||
memcmp(libname + slen - 3, ".so", 3) == 0)
)
{
strcat(buf, ":");
}
strcat(buf, libname);
argv.push(buf); // turns into /usr/lib/libphobos2.a
}
#ifdef __sun
argv.push("-mt");
#endif
// argv.push("-ldruntime");
argv.push("-lpthread");
argv.push("-lm");
#if __linux__
// Changes in ld for Ubuntu 11.10 require this to appear after phobos2
argv.push("-lrt");
#endif
if (global.params.verbose)
{
// Print it
for (size_t i = 0; i < argv.dim; i++)
fprintf(global.stdmsg, "%s ", argv[i]);
fprintf(global.stdmsg, "\n");
}
argv.push(NULL);
// set up pipes
int fds[2];
if (pipe(fds) == -1)
{
perror("Unable to create pipe to linker");
return -1;
}
childpid = fork();
if (childpid == 0)
{
// pipe linker stderr to fds[0]
dup2(fds[1], STDERR_FILENO);
close(fds[0]);
execvp(argv[0], (char **)argv.tdata());
perror(argv[0]); // failed to execute
return -1;
}
else if (childpid == -1)
{
perror("Unable to fork");
return -1;
}
close(fds[1]);
const int nme = findNoMainError(fds[0]);
waitpid(childpid, &status, 0);
if (WIFEXITED(status))
{
status = WEXITSTATUS(status);
if (status)
{
if (nme == -1)
{
perror("Error with the linker pipe");
return -1;
}
else
{
printf("--- errorlevel %d\n", status);
if (nme == 1) error(Loc(), "no main function specified");
}
}
}
else if (WIFSIGNALED(status))
{
printf("--- killed by signal %d\n", WTERMSIG(status));
status = 1;
}
return status;
#else
printf ("Linking is not yet supported for this version of DMD.\n");
return -1;
#endif
}
// Split a path into an Array of paths
Strings *FileName::splitPath(const char *path)
{
char c = 0; // unnecessary initializer is for VC /W4
const char *p;
OutBuffer buf;
Strings *array;
array = new Strings();
if (path)
{
p = path;
do
{ char instring = 0;
while (isspace((unsigned char)*p)) // skip leading whitespace
p++;
buf.reserve(strlen(p) + 1); // guess size of path
for (; ; p++)
{
c = *p;
switch (c)
{
case '"':
instring ^= 1; // toggle inside/outside of string
continue;
#if MACINTOSH
case ',':
#endif
#if _WIN32
case ';':
#endif
#if POSIX
case ':':
#endif
p++;
break; // note that ; cannot appear as part
// of a path, quotes won't protect it
case 0x1A: // ^Z means end of file
case 0:
break;
case '\r':
continue; // ignore carriage returns
#if POSIX
case '~':
buf.writestring(getenv("HOME"));
continue;
#endif
#if 0
case ' ':
case '\t': // tabs in filenames?
if (!instring) // if not in string
break; // treat as end of path
#endif
default:
buf.writeByte(c);
continue;
}
break;
}
if (buf.offset) // if path is not empty
{
buf.writeByte(0); // to asciiz
array->push(buf.extractData());
}
} while (c);
}
return array;
}
Expression *createTypeInfoArray(Scope *sc, Expression *exps[], size_t dim)
{
#if 1
/*
* Pass a reference to the TypeInfo_Tuple corresponding to the types of the
* arguments. Source compatibility is maintained by computing _arguments[]
* at the start of the called function by offseting into the TypeInfo_Tuple
* reference.
*/
Parameters *args = new Parameters;
args->setDim(dim);
for (size_t i = 0; i < dim; i++)
{ Parameter *arg = new Parameter(STCin, exps[i]->type, NULL, NULL);
(*args)[i] = arg;
}
TypeTuple *tup = new TypeTuple(args);
Expression *e = tup->getTypeInfo(sc);
e = e->optimize(WANTvalue);
assert(e->op == TOKsymoff); // should be SymOffExp
return e;
#else
/* Improvements:
* 1) create an array literal instead,
* as it would eliminate the extra dereference of loading the
* static variable.
*/
ArrayInitializer *ai = new ArrayInitializer(0);
VarDeclaration *v;
Type *t;
Expression *e;
OutBuffer buf;
Identifier *id;
char *name;
// Generate identifier for _arguments[]
buf.writestring("_arguments_");
for (int i = 0; i < dim; i++)
{ t = exps[i]->type;
t->toDecoBuffer(&buf);
}
buf.writeByte(0);
id = Lexer::idPool((char *)buf.data);
Module *m = sc->module;
Dsymbol *s = m->symtab->lookup(id);
if (s && s->parent == m)
{ // Use existing one
v = s->isVarDeclaration();
assert(v);
}
else
{ // Generate new one
for (int i = 0; i < dim; i++)
{ t = exps[i]->type;
e = t->getTypeInfo(sc);
ai->addInit(new IntegerExp(i), new ExpInitializer(Loc(), e));
}
t = Type::typeinfo->type->arrayOf();
ai->type = t;
v = new VarDeclaration(0, t, id, ai);
m->members->push(v);
m->symtabInsert(v);
sc = sc->push();
sc->linkage = LINKc;
sc->stc = STCstatic | STCcomdat;
ai->semantic(sc, t);
v->semantic(sc);
v->parent = m;
sc = sc->pop();
}
e = new VarExp(Loc(), v);
e = e->semantic(sc);
return e;
#endif
}
void visit(ComExp *e)
{
e->e1->accept(this);
buf->writestring("Com");
}
void visit(NegExp *e)
{
e->e1->accept(this);
buf->writestring("Neg");
}
void visit(SliceExp *e)
{
buf->writestring("Slice");
arguments->shift(e);
}
