@@ -211,7 +211,7 @@ build_frontend_type (tree type)
if (dtype->nextOf ()->isTypeBasic () == NULL)
break;
- dtype = (TypeVector::create (Loc (), dtype))->addMod (mod);
+ dtype = (TypeVector::create (dtype))->addMod (mod);
builtin_converted_decls.safe_push (builtin_data (dtype, type));
return dtype;
}
@@ -55,7 +55,6 @@ Global::_init (void)
;
this->stdmsg = stderr;
- this->errorLimit = flag_max_errors;
}
/* Start gagging. Return the current number of gagged errors. */
@@ -293,6 +293,7 @@ d_init_options (unsigned int, cl_decoded_option *decoded_options)
global.params.hdrStripPlainFunctions = true;
global.params.betterC = false;
global.params.allInst = false;
+ global.params.errorLimit = flag_max_errors;
/* Default extern(C++) mangling to C++14. */
global.params.cplusplus = CppStdRevisionCpp14;
@@ -793,7 +794,7 @@ d_post_options (const char ** fn)
/* Make -fmax-errors visible to frontend's diagnostic machinery. */
if (global_options_set.x_flag_max_errors)
- global.errorLimit = flag_max_errors;
+ global.params.errorLimit = flag_max_errors;
if (flag_excess_precision == EXCESS_PRECISION_DEFAULT)
flag_excess_precision = EXCESS_PRECISION_STANDARD;
@@ -97,9 +97,9 @@ Port::isFloat64LiteralOutOfRange (const char *buffer)
/* Fetch a little-endian 16-bit value from BUFFER. */
unsigned
-Port::readwordLE (void *buffer)
+Port::readwordLE (const void *buffer)
{
- unsigned char *p = (unsigned char*) buffer;
+ const unsigned char *p = (const unsigned char*) buffer;
return ((unsigned) p[1] << 8) | (unsigned) p[0];
}
@@ -107,9 +107,9 @@ Port::readwordLE (void *buffer)
/* Fetch a big-endian 16-bit value from BUFFER. */
unsigned
-Port::readwordBE (void *buffer)
+Port::readwordBE (const void *buffer)
{
- unsigned char *p = (unsigned char*) buffer;
+ const unsigned char *p = (const unsigned char*) buffer;
return ((unsigned) p[0] << 8) | (unsigned) p[1];
}
@@ -117,9 +117,9 @@ Port::readwordBE (void *buffer)
/* Fetch a little-endian 32-bit value from BUFFER. */
unsigned
-Port::readlongLE (void *buffer)
+Port::readlongLE (const void *buffer)
{
- unsigned char *p = (unsigned char*) buffer;
+ const unsigned char *p = (const unsigned char*) buffer;
return (((unsigned) p[3] << 24)
| ((unsigned) p[2] << 16)
@@ -130,9 +130,9 @@ Port::readlongLE (void *buffer)
/* Fetch a big-endian 32-bit value from BUFFER. */
unsigned
-Port::readlongBE (void *buffer)
+Port::readlongBE (const void *buffer)
{
- unsigned char *p = (unsigned char*) buffer;
+ const unsigned char *p = (const unsigned char*) buffer;
return (((unsigned) p[0] << 24)
| ((unsigned) p[1] << 16)
@@ -1134,8 +1134,12 @@ get_symbol_decl (Declaration *decl)
{
tree mangled_name;
- if (decl->mangleOverride)
- mangled_name = get_identifier (decl->mangleOverride);
+ if (decl->mangleOverride.length)
+ {
+ mangled_name =
+ get_identifier_with_length (decl->mangleOverride.ptr,
+ decl->mangleOverride.length);
+ }
else
mangled_name = get_identifier (d_mangle_decl (decl));
@@ -1,4 +1,4 @@
-5041e56f12806f13a8fa5e98a6c98279636a8d2a
+13d67c5757b83a86411e510bd65a6b5167241324
The first line of this file holds the git revision number of the last
merge done from the dlang/dmd repository.
@@ -434,6 +434,7 @@ bool symbolIsVisible(Module *mod, Dsymbol *s)
default:
assert(0);
}
+ return false;
}
/**
@@ -475,6 +476,7 @@ bool symbolIsVisible(Scope *sc, Dsymbol *s)
default:
assert(0);
}
+ return false;
}
/**
@@ -310,6 +310,7 @@ public:
Dsymbol *search(const Loc &loc, Identifier *ident, int flags = SearchLocalsOnly);
ClassDeclaration *searchBase(Identifier *ident);
void finalizeSize();
+ bool hasMonitor();
bool isFuncHidden(FuncDeclaration *fd);
FuncDeclaration *findFunc(Identifier *ident, TypeFunction *tf);
void interfaceSemantic(Scope *sc);
new file mode 100644
@@ -0,0 +1,20 @@
+
+/* Compiler implementation of the D programming language
+ * Copyright (C) 1999-2020 by The D Language Foundation, All Rights Reserved
+ * written by Walter Bright
+ * http://www.digitalmars.com
+ * Distributed under the Boost Software License, Version 1.0.
+ * http://www.boost.org/LICENSE_1_0.txt
+ * https://github.com/dlang/dmd/blob/master/src/dmd/ast_node.h
+ */
+
+#pragma once
+
+#include "root/object.h"
+
+class Visitor;
+
+class ASTNode : public RootObject
+{
+ virtual void accept(Visitor*) = 0;
+};
@@ -10,6 +10,7 @@
#pragma once
+#include "ast_node.h"
#include "globals.h"
#include "visitor.h"
@@ -25,7 +26,7 @@ class ForeachRangeStatement;
int findCondition(Identifiers *ids, Identifier *ident);
-class Condition
+class Condition : public ASTNode
{
public:
Loc loc;
@@ -40,7 +41,7 @@ public:
virtual int include(Scope *sc) = 0;
virtual DebugCondition *isDebugCondition() { return NULL; }
virtual VersionCondition *isVersionCondition() { return NULL; }
- virtual void accept(Visitor *v) { v->visit(this); }
+ void accept(Visitor *v) { v->visit(this); }
};
class StaticForeach
@@ -1057,6 +1057,7 @@ static bool numCmp(TOK op, N n1, N n2)
default:
assert(0);
}
+ return false;
}
/// Returns cmp OP 0; where OP is ==, !=, <, >=, etc. Result is 0 or 1
@@ -1089,11 +1090,12 @@ int realCmp(TOK op, real_t r1, real_t r2)
case TOKle:
case TOKgt:
case TOKge:
- return 0;
+ break;
default:
assert(0);
}
+ return 0;
}
else
{
@@ -1100,7 +1100,7 @@ void ClassDeclaration::finalizeSize()
{
alignsize = target.ptrsize;
structsize = target.ptrsize; // allow room for __vptr
- if (!isCPPclass())
+ if (hasMonitor())
structsize += target.ptrsize; // allow room for __monitor
}
@@ -1133,6 +1133,14 @@ void ClassDeclaration::finalizeSize()
checkOverlappedFields();
}
+/**************
+ * Returns: true if there's a __monitor field
+ */
+bool ClassDeclaration::hasMonitor()
+{
+ return classKind == ClassKind::d;
+}
+
/**********************************************************
* fd is in the vtbl[] for this class.
* Return 1 if function is hidden (not findable through search).
@@ -123,7 +123,7 @@ public:
Prot protection;
LINK linkage;
int inuse; // used to detect cycles
- const char *mangleOverride; // overridden symbol with pragma(mangle, "...")
+ DString mangleOverride; // overridden symbol with pragma(mangle, "...")
Declaration(Identifier *id);
void semantic(Scope *sc);
@@ -520,9 +520,9 @@ public:
{
assert(!fd->isFuncAliasDeclaration());
- if (fd->mangleOverride)
+ if (fd->mangleOverride.length)
{
- buf->writestring(fd->mangleOverride);
+ buf->writestring(fd->mangleOverride.ptr);
return;
}
@@ -543,9 +543,9 @@ public:
void visit(VarDeclaration *vd)
{
- if (vd->mangleOverride)
+ if (vd->mangleOverride.length)
{
- buf->writestring(vd->mangleOverride);
+ buf->writestring(vd->mangleOverride.ptr);
return;
}
@@ -12,7 +12,7 @@
#include "root/root.h"
#include "root/stringtable.h"
-
+#include "ast_node.h"
#include "globals.h"
#include "arraytypes.h"
#include "visitor.h"
@@ -145,7 +145,7 @@ enum
typedef int (*Dsymbol_apply_ft_t)(Dsymbol *, void *);
-class Dsymbol : public RootObject
+class Dsymbol : public ASTNode
{
public:
Identifier *ident;
@@ -281,7 +281,7 @@ public:
virtual AttribDeclaration *isAttribDeclaration() { return NULL; }
virtual AnonDeclaration *isAnonDeclaration() { return NULL; }
virtual OverloadSet *isOverloadSet() { return NULL; }
- virtual void accept(Visitor *v) { v->visit(this); }
+ void accept(Visitor *v) { v->visit(this); }
};
// Dsymbol that generates a scope
@@ -2818,6 +2818,524 @@ bool Expression::isBool(bool)
return false;
}
+IntegerExp *Expression::isIntegerExp()
+{
+ return op == TOKint64 ? (IntegerExp *)this : NULL;
+}
+
+ErrorExp *Expression::isErrorExp()
+{
+ return op == TOKerror ? (ErrorExp *)this : NULL;
+}
+
+VoidInitExp *Expression::isVoidInitExp()
+{
+ return op == TOKvoid ? (VoidInitExp *)this : NULL;
+}
+
+RealExp *Expression::isRealExp()
+{
+ return op == TOKfloat64 ? (RealExp *)this : NULL;
+}
+
+ComplexExp *Expression::isComplexExp()
+{
+ return op == TOKcomplex80 ? (ComplexExp *)this : NULL;
+}
+
+IdentifierExp *Expression::isIdentifierExp()
+{
+ return op == TOKidentifier ? (IdentifierExp *)this : NULL;
+}
+
+DollarExp *Expression::isDollarExp()
+{
+ return op == TOKdollar ? (DollarExp *)this : NULL;
+}
+
+DsymbolExp *Expression::isDsymbolExp()
+{
+ return op == TOKdsymbol ? (DsymbolExp *)this : NULL;
+}
+
+ThisExp *Expression::isThisExp()
+{
+ return op == TOKthis ? (ThisExp *)this : NULL;
+}
+
+SuperExp *Expression::isSuperExp()
+{
+ return op == TOKsuper ? (SuperExp *)this : NULL;
+}
+
+NullExp *Expression::isNullExp()
+{
+ return op == TOKnull ? (NullExp *)this : NULL;
+}
+
+StringExp *Expression::isStringExp()
+{
+ return op == TOKstring ? (StringExp *)this : NULL;
+}
+
+TupleExp *Expression::isTupleExp()
+{
+ return op == TOKtuple ? (TupleExp *)this : NULL;
+}
+
+ArrayLiteralExp *Expression::isArrayLiteralExp()
+{
+ return op == TOKarrayliteral ? (ArrayLiteralExp *)this : NULL;
+}
+
+AssocArrayLiteralExp *Expression::isAssocArrayLiteralExp()
+{
+ return op == TOKassocarrayliteral ? (AssocArrayLiteralExp *)this : NULL;
+}
+
+StructLiteralExp *Expression::isStructLiteralExp()
+{
+ return op == TOKstructliteral ? (StructLiteralExp *)this : NULL;
+}
+
+TypeExp *Expression::isTypeExp()
+{
+ return op == TOKtype ? (TypeExp *)this : NULL;
+}
+
+ScopeExp *Expression::isScopeExp()
+{
+ return op == TOKscope ? (ScopeExp *)this : NULL;
+}
+
+TemplateExp *Expression::isTemplateExp()
+{
+ return op == TOKtemplate ? (TemplateExp *)this : NULL;
+}
+
+NewExp *Expression::isNewExp()
+{
+ return op == TOKnew ? (NewExp *)this : NULL;
+}
+
+NewAnonClassExp *Expression::isNewAnonClassExp()
+{
+ return op == TOKnewanonclass ? (NewAnonClassExp *)this : NULL;
+}
+
+SymOffExp *Expression::isSymOffExp()
+{
+ return op == TOKsymoff ? (SymOffExp *)this : NULL;
+}
+
+VarExp *Expression::isVarExp()
+{
+ return op == TOKvar ? (VarExp *)this : NULL;
+}
+
+OverExp *Expression::isOverExp()
+{
+ return op == TOKoverloadset ? (OverExp *)this : NULL;
+}
+
+FuncExp *Expression::isFuncExp()
+{
+ return op == TOKfunction ? (FuncExp *)this : NULL;
+}
+
+DeclarationExp *Expression::isDeclarationExp()
+{
+ return op == TOKdeclaration ? (DeclarationExp *)this : NULL;
+}
+
+TypeidExp *Expression::isTypeidExp()
+{
+ return op == TOKtypeid ? (TypeidExp *)this : NULL;
+}
+
+TraitsExp *Expression::isTraitsExp()
+{
+ return op == TOKtraits ? (TraitsExp *)this : NULL;
+}
+
+HaltExp *Expression::isHaltExp()
+{
+ return op == TOKhalt ? (HaltExp *)this : NULL;
+}
+
+IsExp *Expression::isExp()
+{
+ return op == TOKis ? (IsExp *)this : NULL;
+}
+
+CompileExp *Expression::isCompileExp()
+{
+ return op == TOKmixin ? (CompileExp *)this : NULL;
+}
+
+ImportExp *Expression::isImportExp()
+{
+ return op == TOKimport ? (ImportExp *)this : NULL;
+}
+
+AssertExp *Expression::isAssertExp()
+{
+ return op == TOKassert ? (AssertExp *)this : NULL;
+}
+
+DotIdExp *Expression::isDotIdExp()
+{
+ return op == TOKdotid ? (DotIdExp *)this : NULL;
+}
+
+DotTemplateExp *Expression::isDotTemplateExp()
+{
+ return op == TOKdotti ? (DotTemplateExp *)this : NULL;
+}
+
+DotVarExp *Expression::isDotVarExp()
+{
+ return op == TOKdotvar ? (DotVarExp *)this : NULL;
+}
+
+DotTemplateInstanceExp *Expression::isDotTemplateInstanceExp()
+{
+ return op == TOKdotti ? (DotTemplateInstanceExp *)this : NULL;
+}
+
+DelegateExp *Expression::isDelegateExp()
+{
+ return op == TOKdelegate ? (DelegateExp *)this : NULL;
+}
+
+DotTypeExp *Expression::isDotTypeExp()
+{
+ return op == TOKdottype ? (DotTypeExp *)this : NULL;
+}
+
+CallExp *Expression::isCallExp()
+{
+ return op == TOKcall ? (CallExp *)this : NULL;
+}
+
+AddrExp *Expression::isAddrExp()
+{
+ return op == TOKaddress ? (AddrExp *)this : NULL;
+}
+
+PtrExp *Expression::isPtrExp()
+{
+ return op == TOKstar ? (PtrExp *)this : NULL;
+}
+
+NegExp *Expression::isNegExp()
+{
+ return op == TOKneg ? (NegExp *)this : NULL;
+}
+
+UAddExp *Expression::isUAddExp()
+{
+ return op == TOKuadd ? (UAddExp *)this : NULL;
+}
+
+ComExp *Expression::isComExp()
+{
+ return op == TOKtilde ? (ComExp *)this : NULL;
+}
+
+NotExp *Expression::isNotExp()
+{
+ return op == TOKnot ? (NotExp *)this : NULL;
+}
+
+DeleteExp *Expression::isDeleteExp()
+{
+ return op == TOKdelete ? (DeleteExp *)this : NULL;
+}
+
+CastExp *Expression::isCastExp()
+{
+ return op == TOKcast ? (CastExp *)this : NULL;
+}
+
+VectorExp *Expression::isVectorExp()
+{
+ return op == TOKvector ? (VectorExp *)this : NULL;
+}
+
+VectorArrayExp *Expression::isVectorArrayExp()
+{
+ return op == TOKvectorarray ? (VectorArrayExp *)this : NULL;
+}
+
+SliceExp *Expression::isSliceExp()
+{
+ return op == TOKslice ? (SliceExp *)this : NULL;
+}
+
+ArrayLengthExp *Expression::isArrayLengthExp()
+{
+ return op == TOKarraylength ? (ArrayLengthExp *)this : NULL;
+}
+
+ArrayExp *Expression::isArrayExp()
+{
+ return op == TOKarray ? (ArrayExp *)this : NULL;
+}
+
+DotExp *Expression::isDotExp()
+{
+ return op == TOKdot ? (DotExp *)this : NULL;
+}
+
+CommaExp *Expression::isCommaExp()
+{
+ return op == TOKcomma ? (CommaExp *)this : NULL;
+}
+
+IntervalExp *Expression::isIntervalExp()
+{
+ return op == TOKinterval ? (IntervalExp *)this : NULL;
+}
+
+DelegatePtrExp *Expression::isDelegatePtrExp()
+{
+ return op == TOKdelegateptr ? (DelegatePtrExp *)this : NULL;
+}
+
+DelegateFuncptrExp *Expression::isDelegateFuncptrExp()
+{
+ return op == TOKdelegatefuncptr ? (DelegateFuncptrExp *)this : NULL;
+}
+
+IndexExp *Expression::isIndexExp()
+{
+ return op == TOKindex ? (IndexExp *)this : NULL;
+}
+
+PostExp *Expression::isPostExp()
+{
+ return (op == TOKplusplus || op == TOKminusminus) ? (PostExp *)this : NULL;
+}
+
+PreExp *Expression::isPreExp()
+{
+ return (op == TOKpreplusplus || op == TOKpreminusminus) ? (PreExp *)this : NULL;
+}
+
+AssignExp *Expression::isAssignExp()
+{
+ return op == TOKassign ? (AssignExp *)this : NULL;
+}
+
+ConstructExp *Expression::isConstructExp()
+{
+ return op == TOKconstruct ? (ConstructExp *)this : NULL;
+}
+
+BlitExp *Expression::isBlitExp()
+{
+ return op == TOKblit ? (BlitExp *)this : NULL;
+}
+
+AddAssignExp *Expression::isAddAssignExp()
+{
+ return op == TOKaddass ? (AddAssignExp *)this : NULL;
+}
+
+MinAssignExp *Expression::isMinAssignExp()
+{
+ return op == TOKminass ? (MinAssignExp *)this : NULL;
+}
+
+MulAssignExp *Expression::isMulAssignExp()
+{
+ return op == TOKmulass ? (MulAssignExp *)this : NULL;
+}
+
+
+DivAssignExp *Expression::isDivAssignExp()
+{
+ return op == TOKdivass ? (DivAssignExp *)this : NULL;
+}
+
+ModAssignExp *Expression::isModAssignExp()
+{
+ return op == TOKmodass ? (ModAssignExp *)this : NULL;
+}
+
+AndAssignExp *Expression::isAndAssignExp()
+{
+ return op == TOKandass ? (AndAssignExp *)this : NULL;
+}
+
+OrAssignExp *Expression::isOrAssignExp()
+{
+ return op == TOKorass ? (OrAssignExp *)this : NULL;
+}
+
+XorAssignExp *Expression::isXorAssignExp()
+{
+ return op == TOKxorass ? (XorAssignExp *)this : NULL;
+}
+
+PowAssignExp *Expression::isPowAssignExp()
+{
+ return op == TOKpowass ? (PowAssignExp *)this : NULL;
+}
+
+
+ShlAssignExp *Expression::isShlAssignExp()
+{
+ return op == TOKshlass ? (ShlAssignExp *)this : NULL;
+}
+
+ShrAssignExp *Expression::isShrAssignExp()
+{
+ return op == TOKshrass ? (ShrAssignExp *)this : NULL;
+}
+
+UshrAssignExp *Expression::isUshrAssignExp()
+{
+ return op == TOKushrass ? (UshrAssignExp *)this : NULL;
+}
+
+CatAssignExp *Expression::isCatAssignExp()
+{
+ return op == TOKcatass ? (CatAssignExp *)this : NULL;
+}
+
+AddExp *Expression::isAddExp()
+{
+ return op == TOKadd ? (AddExp *)this : NULL;
+}
+
+MinExp *Expression::isMinExp()
+{
+ return op == TOKmin ? (MinExp *)this : NULL;
+}
+
+CatExp *Expression::isCatExp()
+{
+ return op == TOKcat ? (CatExp *)this : NULL;
+}
+
+MulExp *Expression::isMulExp()
+{
+ return op == TOKmul ? (MulExp *)this : NULL;
+}
+
+DivExp *Expression::isDivExp()
+{
+ return op == TOKdiv ? (DivExp *)this : NULL;
+}
+
+ModExp *Expression::isModExp()
+{
+ return op == TOKmod ? (ModExp *)this : NULL;
+}
+
+PowExp *Expression::isPowExp()
+{
+ return op == TOKpow ? (PowExp *)this : NULL;
+}
+
+ShlExp *Expression::isShlExp()
+{
+ return op == TOKshl ? (ShlExp *)this : NULL;
+}
+
+ShrExp *Expression::isShrExp()
+{
+ return op == TOKshr ? (ShrExp *)this : NULL;
+}
+
+UshrExp *Expression::isUshrExp()
+{
+ return op == TOKushr ? (UshrExp *)this : NULL;
+}
+
+AndExp *Expression::isAndExp()
+{
+ return op == TOKand ? (AndExp *)this : NULL;
+}
+
+OrExp *Expression::isOrExp()
+{
+ return op == TOKor ? (OrExp *)this : NULL;
+}
+
+XorExp *Expression::isXorExp()
+{
+ return op == TOKxor ? (XorExp *)this : NULL;
+}
+
+LogicalExp *Expression::isLogicalExp()
+{
+ return (op == TOKandand || op == TOKoror) ? (LogicalExp *)this : NULL;
+}
+
+InExp *Expression::isInExp()
+{
+ return op == TOKin ? (InExp *)this : NULL;
+}
+
+RemoveExp *Expression::isRemoveExp()
+{
+ return op == TOKremove ? (RemoveExp *)this : NULL;
+}
+
+EqualExp *Expression::isEqualExp()
+{
+ return (op == TOKequal || op == TOKnotequal) ? (EqualExp *)this : NULL;
+}
+
+IdentityExp *Expression::isIdentityExp()
+{
+ return (op == TOKidentity || op == TOKnotidentity) ? (IdentityExp *)this : NULL;
+}
+
+CondExp *Expression::isCondExp()
+{
+ return op == TOKquestion ? (CondExp *)this : NULL;
+}
+
+DefaultInitExp *Expression::isDefaultInitExp()
+{
+ return op == TOKdefault ? (DefaultInitExp *)this : NULL;
+}
+
+FileInitExp *Expression::isFileInitExp()
+{
+ return (op == TOKfile || op == TOKfilefullpath) ? (FileInitExp *)this : NULL;
+}
+
+LineInitExp *Expression::isLineInitExp()
+{
+ return op == TOKline ? (LineInitExp *)this : NULL;
+}
+
+ModuleInitExp *Expression::isModuleInitExp()
+{
+ return op == TOKmodulestring ? (ModuleInitExp *)this : NULL;
+}
+
+FuncInitExp *Expression::isFuncInitExp()
+{
+ return op == TOKfuncstring ? (FuncInitExp *)this : NULL;
+}
+
+PrettyFuncInitExp *Expression::isPrettyFuncInitExp()
+{
+ return op == TOKprettyfunc ? (PrettyFuncInitExp *)this : NULL;
+}
+
+ClassReferenceExp *Expression::isClassReferenceExp()
+{
+ return op == TOKclassreference ? (ClassReferenceExp *)this : NULL;
+}
+
+
/****************************************
* Resolve __FILE__, __LINE__, __MODULE__, __FUNCTION__, __PRETTY_FUNCTION__ to loc.
*/
@@ -10,6 +10,7 @@
#pragma once
+#include "ast_node.h"
#include "complex_t.h"
#include "globals.h"
#include "identifier.h"
@@ -121,7 +122,7 @@ enum OwnedBy
#define WANTvalue 0 // default
#define WANTexpand 1 // expand const/immutable variables if possible
-class Expression : public RootObject
+class Expression : public ASTNode
{
public:
Loc loc; // file location
@@ -218,7 +219,111 @@ public:
return true;
}
- virtual void accept(Visitor *v) { v->visit(this); }
+ IntegerExp* isIntegerExp();
+ ErrorExp* isErrorExp();
+ VoidInitExp* isVoidInitExp();
+ RealExp* isRealExp();
+ ComplexExp* isComplexExp();
+ IdentifierExp* isIdentifierExp();
+ DollarExp* isDollarExp();
+ DsymbolExp* isDsymbolExp();
+ ThisExp* isThisExp();
+ SuperExp* isSuperExp();
+ NullExp* isNullExp();
+ StringExp* isStringExp();
+ TupleExp* isTupleExp();
+ ArrayLiteralExp* isArrayLiteralExp();
+ AssocArrayLiteralExp* isAssocArrayLiteralExp();
+ StructLiteralExp* isStructLiteralExp();
+ TypeExp* isTypeExp();
+ ScopeExp* isScopeExp();
+ TemplateExp* isTemplateExp();
+ NewExp* isNewExp();
+ NewAnonClassExp* isNewAnonClassExp();
+ SymOffExp* isSymOffExp();
+ VarExp* isVarExp();
+ OverExp* isOverExp();
+ FuncExp* isFuncExp();
+ DeclarationExp* isDeclarationExp();
+ TypeidExp* isTypeidExp();
+ TraitsExp* isTraitsExp();
+ HaltExp* isHaltExp();
+ IsExp* isExp();
+ CompileExp* isCompileExp();
+ ImportExp* isImportExp();
+ AssertExp* isAssertExp();
+ DotIdExp* isDotIdExp();
+ DotTemplateExp* isDotTemplateExp();
+ DotVarExp* isDotVarExp();
+ DotTemplateInstanceExp* isDotTemplateInstanceExp();
+ DelegateExp* isDelegateExp();
+ DotTypeExp* isDotTypeExp();
+ CallExp* isCallExp();
+ AddrExp* isAddrExp();
+ PtrExp* isPtrExp();
+ NegExp* isNegExp();
+ UAddExp* isUAddExp();
+ ComExp* isComExp();
+ NotExp* isNotExp();
+ DeleteExp* isDeleteExp();
+ CastExp* isCastExp();
+ VectorExp* isVectorExp();
+ VectorArrayExp* isVectorArrayExp();
+ SliceExp* isSliceExp();
+ ArrayLengthExp* isArrayLengthExp();
+ ArrayExp* isArrayExp();
+ DotExp* isDotExp();
+ CommaExp* isCommaExp();
+ IntervalExp* isIntervalExp();
+ DelegatePtrExp* isDelegatePtrExp();
+ DelegateFuncptrExp* isDelegateFuncptrExp();
+ IndexExp* isIndexExp();
+ PostExp* isPostExp();
+ PreExp* isPreExp();
+ AssignExp* isAssignExp();
+ ConstructExp* isConstructExp();
+ BlitExp* isBlitExp();
+ AddAssignExp* isAddAssignExp();
+ MinAssignExp* isMinAssignExp();
+ MulAssignExp* isMulAssignExp();
+ DivAssignExp* isDivAssignExp();
+ ModAssignExp* isModAssignExp();
+ AndAssignExp* isAndAssignExp();
+ OrAssignExp* isOrAssignExp();
+ XorAssignExp* isXorAssignExp();
+ PowAssignExp* isPowAssignExp();
+ ShlAssignExp* isShlAssignExp();
+ ShrAssignExp* isShrAssignExp();
+ UshrAssignExp* isUshrAssignExp();
+ CatAssignExp* isCatAssignExp();
+ AddExp* isAddExp();
+ MinExp* isMinExp();
+ CatExp* isCatExp();
+ MulExp* isMulExp();
+ DivExp* isDivExp();
+ ModExp* isModExp();
+ PowExp* isPowExp();
+ ShlExp* isShlExp();
+ ShrExp* isShrExp();
+ UshrExp* isUshrExp();
+ AndExp* isAndExp();
+ OrExp* isOrExp();
+ XorExp* isXorExp();
+ LogicalExp* isLogicalExp();
+ InExp* isInExp();
+ RemoveExp* isRemoveExp();
+ EqualExp* isEqualExp();
+ IdentityExp* isIdentityExp();
+ CondExp* isCondExp();
+ DefaultInitExp* isDefaultInitExp();
+ FileInitExp* isFileInitExp();
+ LineInitExp* isLineInitExp();
+ ModuleInitExp* isModuleInitExp();
+ FuncInitExp* isFuncInitExp();
+ PrettyFuncInitExp* isPrettyFuncInitExp();
+ ClassReferenceExp* isClassReferenceExp();
+
+ void accept(Visitor *v) { v->visit(this); }
};
class IntegerExp : public Expression
@@ -144,6 +144,8 @@ struct Param
CHECKACTION checkAction; // action to take when bounds, asserts or switch defaults are violated
+ unsigned errorLimit;
+
DString argv0; // program name
Array<const char *> modFileAliasStrings; // array of char*'s of -I module filename alias strings
Array<const char *> *imppath; // array of char*'s of where to look for import modules
@@ -235,8 +237,7 @@ struct Global
FILE *stdmsg; // where to send verbose messages
unsigned gag; // !=0 means gag reporting of errors & warnings
unsigned gaggedErrors; // number of errors reported while gagged
-
- unsigned errorLimit;
+ unsigned gaggedWarnings; // number of warnings reported while gagged
void* console; // opaque pointer to console for controlling text attributes
@@ -11,7 +11,7 @@
#pragma once
#include "root/root.h"
-
+#include "ast_node.h"
#include "globals.h"
#include "arraytypes.h"
#include "visitor.h"
@@ -29,7 +29,7 @@ class ExpInitializer;
enum NeedInterpret { INITnointerpret, INITinterpret };
-class Initializer : public RootObject
+class Initializer : public ASTNode
{
public:
Loc loc;
@@ -45,7 +45,7 @@ public:
virtual StructInitializer *isStructInitializer() { return NULL; }
virtual ArrayInitializer *isArrayInitializer() { return NULL; }
virtual ExpInitializer *isExpInitializer() { return NULL; }
- virtual void accept(Visitor *v) { v->visit(this); }
+ void accept(Visitor *v) { v->visit(this); }
};
class VoidInitializer : public Initializer
@@ -2328,6 +2328,106 @@ TypeBasic *Type::isTypeBasic()
return NULL;
}
+TypeError *Type::isTypeError()
+{
+ return ty == Terror ? (TypeError *)this : NULL;
+}
+
+TypeVector *Type::isTypeVector()
+{
+ return ty == Tvector ? (TypeVector *)this : NULL;
+}
+
+TypeSArray *Type::isTypeSArray()
+{
+ return ty == Tsarray ? (TypeSArray *)this : NULL;
+}
+
+TypeDArray *Type::isTypeDArray()
+{
+ return ty == Tarray ? (TypeDArray *)this : NULL;
+}
+
+TypeAArray *Type::isTypeAArray()
+{
+ return ty == Taarray ? (TypeAArray *)this : NULL;
+}
+
+TypePointer *Type::isTypePointer()
+{
+ return ty == Tpointer ? (TypePointer *)this : NULL;
+}
+
+TypeReference *Type::isTypeReference()
+{
+ return ty == Treference ? (TypeReference *)this : NULL;
+}
+
+TypeFunction *Type::isTypeFunction()
+{
+ return ty == Tfunction ? (TypeFunction *)this : NULL;
+}
+
+TypeDelegate *Type::isTypeDelegate()
+{
+ return ty == Tdelegate ? (TypeDelegate *)this : NULL;
+}
+
+TypeIdentifier *Type::isTypeIdentifier()
+{
+ return ty == Tident ? (TypeIdentifier *)this : NULL;
+}
+
+TypeInstance *Type::isTypeInstance()
+{
+ return ty == Tinstance ? (TypeInstance *)this : NULL;
+}
+
+TypeTypeof *Type::isTypeTypeof()
+{
+ return ty == Ttypeof ? (TypeTypeof *)this : NULL;
+}
+
+TypeReturn *Type::isTypeReturn()
+{
+ return ty == Treturn ? (TypeReturn *)this : NULL;
+}
+
+TypeStruct *Type::isTypeStruct()
+{
+ return ty == Tstruct ? (TypeStruct *)this : NULL;
+}
+
+TypeEnum *Type::isTypeEnum()
+{
+ return ty == Tenum ? (TypeEnum *)this : NULL;
+}
+
+TypeClass *Type::isTypeClass()
+{
+ return ty == Tclass ? (TypeClass *)this : NULL;
+}
+
+TypeTuple *Type::isTypeTuple()
+{
+ return ty == Ttuple ? (TypeTuple *)this : NULL;
+}
+
+TypeSlice *Type::isTypeSlice()
+{
+ return ty == Tslice ? (TypeSlice *)this : NULL;
+}
+
+TypeNull *Type::isTypeNull()
+{
+ return ty == Tnull ? (TypeNull *)this : NULL;
+}
+
+TypeTraits *Type::isTypeTraits()
+{
+ return ty == Ttraits ? (TypeTraits *)this : NULL;
+}
+
TypeFunction *Type::toTypeFunction()
{
if (ty != Tfunction)
@@ -3688,7 +3788,7 @@ TypeVector::TypeVector(Type *basetype)
this->basetype = basetype;
}
-TypeVector *TypeVector::create(Loc, Type *basetype)
+TypeVector *TypeVector::create(Type *basetype)
{
return new TypeVector(basetype);
}
@@ -8578,7 +8678,7 @@ L1:
return e;
}
- if (ident == Id::__monitor)
+ if (ident == Id::__monitor && sym->hasMonitor())
{
/* The handle to the monitor (call it a void*)
* *(cast(void**)e + 1)
@@ -15,6 +15,7 @@
#include "root/dcompat.h" // for d_size_t
#include "arraytypes.h"
+#include "ast_node.h"
#include "expression.h"
#include "visitor.h"
@@ -134,7 +135,7 @@ enum VarArg
/// or https://dlang.org/spec/function.html#typesafe_variadic_functions
};
-class Type : public RootObject
+class Type : public ASTNode
{
public:
TY ty;
@@ -348,7 +349,28 @@ public:
// For eliminating dynamic_cast
virtual TypeBasic *isTypeBasic();
- virtual void accept(Visitor *v) { v->visit(this); }
+ TypeError *isTypeError();
+ TypeVector *isTypeVector();
+ TypeSArray *isTypeSArray();
+ TypeDArray *isTypeDArray();
+ TypeAArray *isTypeAArray();
+ TypePointer *isTypePointer();
+ TypeReference *isTypeReference();
+ TypeFunction *isTypeFunction();
+ TypeDelegate *isTypeDelegate();
+ TypeIdentifier *isTypeIdentifier();
+ TypeInstance *isTypeInstance();
+ TypeTypeof *isTypeTypeof();
+ TypeReturn *isTypeReturn();
+ TypeStruct *isTypeStruct();
+ TypeEnum *isTypeEnum();
+ TypeClass *isTypeClass();
+ TypeTuple *isTypeTuple();
+ TypeSlice *isTypeSlice();
+ TypeNull *isTypeNull();
+ TypeTraits *isTypeTraits();
+
+ void accept(Visitor *v) { v->visit(this); }
};
class TypeError : public Type
@@ -424,7 +446,7 @@ public:
Type *basetype;
TypeVector(Type *basetype);
- static TypeVector *create(Loc loc, Type *basetype);
+ static TypeVector *create(Type *basetype);
const char *kind();
Type *syntaxCopy();
Type *semantic(Loc loc, Scope *sc);
@@ -595,7 +617,7 @@ enum PURE
PUREstrong = 4 // parameters are values or immutable
};
-class Parameter : public RootObject
+class Parameter : public ASTNode
{
public:
StorageClass storageClass;
@@ -609,7 +631,7 @@ public:
Type *isLazyArray();
// kludge for template.isType()
int dyncast() const { return DYNCAST_PARAMETER; }
- virtual void accept(Visitor *v) { v->visit(this); }
+ void accept(Visitor *v) { v->visit(this); }
static Parameters *arraySyntaxCopy(Parameters *parameters);
static size_t dim(Parameters *parameters);
@@ -32,10 +32,10 @@ struct Port
static bool isFloat64LiteralOutOfRange(const char *s);
static void writelongLE(unsigned value, void *buffer);
- static unsigned readlongLE(void *buffer);
+ static unsigned readlongLE(const void *buffer);
static void writelongBE(unsigned value, void *buffer);
- static unsigned readlongBE(void *buffer);
- static unsigned readwordLE(void *buffer);
- static unsigned readwordBE(void *buffer);
+ static unsigned readlongBE(const void *buffer);
+ static unsigned readwordLE(const void *buffer);
+ static unsigned readwordBE(const void *buffer);
static void valcpy(void *dst, uint64_t val, size_t size);
};
@@ -13,6 +13,7 @@
#include "root/root.h"
#include "arraytypes.h"
+#include "ast_node.h"
#include "dsymbol.h"
#include "visitor.h"
#include "tokens.h"
@@ -66,7 +67,7 @@ enum BE
BEany = (BEfallthru | BEthrow | BEreturn | BEgoto | BEhalt)
};
-class Statement : public RootObject
+class Statement : public ASTNode
{
public:
Loc loc;
@@ -105,7 +106,7 @@ public:
virtual BreakStatement *isBreakStatement() { return NULL; }
virtual DtorExpStatement *isDtorExpStatement() { return NULL; }
virtual ForwardingStatement *isForwardingStatement() { return NULL; }
- virtual void accept(Visitor *v) { v->visit(this); }
+ void accept(Visitor *v) { v->visit(this); }
};
/** Any Statement that fails semantic() or has a component that is an ErrorExp or
@@ -119,7 +119,7 @@ public:
* For this-parameter:
* template Foo(this ident)
*/
-class TemplateParameter
+class TemplateParameter : public ASTNode
{
public:
Loc loc;
@@ -159,7 +159,7 @@ public:
/* Create dummy argument based on parameter.
*/
virtual void *dummyArg() = 0;
- virtual void accept(Visitor *v) { v->visit(this); }
+ void accept(Visitor *v) { v->visit(this); }
};
/* Syntax:
@@ -113,15 +113,16 @@ bool isUniAlpha(dchar_t c)
int utf_codeLengthChar(dchar_t c)
{
- if (c <= 0x7F)
- return 1;
- if (c <= 0x7FF)
- return 2;
- if (c <= 0xFFFF)
- return 3;
- if (c <= 0x10FFFF)
- return 4;
- assert(false);
+ if (c <= 0x7F)
+ return 1;
+ if (c <= 0x7FF)
+ return 2;
+ if (c <= 0xFFFF)
+ return 3;
+ if (c <= 0x10FFFF)
+ return 4;
+ assert(false);
+ return 6;
}
int utf_codeLengthWchar(dchar_t c)