Extern/Beef
1
0
Fork 0
mirror of https://github.com/beefytech/Beef.git synced 2025-06-08 19:48:20 +02:00
Code Activity
Beef/IDEHelper/Compiler/BfAst.h

3436 lines
83 KiB
C
Raw Normal View History

Initial checkin
2019-08-23 11:56:54 -07:00
#pragma once
#include "BeefySysLib/Common.h"
#include "BeefySysLib/util/DLIList.h"
#include "BeefySysLib/util/BumpAllocator.h"
Fix for lambda caching within mixin
2020-10-30 09:03:36 -07:00
#include "BeefySysLib/util/SizedArray.h"
Initial checkin
2019-08-23 11:56:54 -07:00
#include "BfAstAllocator.h"
#include "BfIRBuilder.h"
//#define BF_AST_HAS_PARENT_MEMBER
//#define BF_AST_COMPACT
//#define BF_AST_VTABLE
#ifdef _DEBUG
#define BF_AST_VTABLE
#endif
/*#pragma warning(push)
#pragma warning(disable:4141)
#pragma warning(disable:4624)
#pragma warning(disable:4996)
#pragma warning(disable:4267)
#pragma warning(disable:4291)
#pragma warning(disable:4267)
#pragma warning(disable:4141)
#pragma warning(disable:4146)
#include "llvm/Support/raw_ostream.h"
#include "llvm/ADT/SmallVector.h"
#pragma warning(pop)*/
namespace llvm
{
class Value;
};
NS_BF_BEGIN
class BfType;
class BfParser;
class BfSource;
class BfAstNode;
class BfTokenNode;
class BfTokenPairNode;
Start of anonymous 'using' field
2022-02-19 07:38:05 -05:00
class BfUsingSpecifierNode;
Initial checkin
2019-08-23 11:56:54 -07:00
class BfTypeReference;
class BfTypeDef;
class BfMethodDef;
class BfFieldDef;
class BfSystem;
class BfMethodInstance;
class BfPassInstance;
enum BfProtection : uint8
{
BfProtection_Hidden,
Removed 'internal' protection - it's all about [Friend] now
2020-03-09 06:34:16 -07:00
BfProtection_Private,
Internal protection, 'using internal <type or namespace>;`
2020-10-14 11:33:41 -07:00
BfProtection_Internal,
Initial checkin
2019-08-23 11:56:54 -07:00
BfProtection_Protected,
Added 'protected internal' protection
2020-12-07 07:53:12 -08:00
BfProtection_ProtectedInternal,
Fixed protection string table oob
2020-12-14 06:13:40 -08:00
BfProtection_Public,
BfProtection_COUNT
Initial checkin
2019-08-23 11:56:54 -07:00
};
Fixes to enum changes, fixed [Checked] debugger interaction
2019-11-29 09:21:51 -08:00
enum BfCheckedKind : int8
{
BfCheckedKind_NotSet,
BfCheckedKind_Checked,
BfCheckedKind_Unchecked
};
Initial checkin
2019-08-23 11:56:54 -07:00
static bool CheckProtection(BfProtection protection, bool allowProtected, bool allowPrivate)
Removed 'internal' protection - it's all about [Friend] now
2020-03-09 06:34:16 -07:00
{
Initial checkin
2019-08-23 11:56:54 -07:00
return (protection == BfProtection_Public) ||
((protection == BfProtection_Protected) && (allowProtected)) ||
((protection == BfProtection_Private) && (allowPrivate));
}
struct BfVariant
{
BfTypeCode mTypeCode;
int mWarnType;
union
{
bool mBool;
int8 mInt8;
uint8 mUInt8;
int16 mInt16;
uint16 mUInt16;
int32 mInt32;
uint32 mUInt32;
int64 mInt64;
uint64 mUInt64;
float mSingle;
double mDouble;
String* mString;
void* mPtr;
};
double ToDouble()
{
if (mTypeCode == BfTypeCode_Double)
return mDouble;
Renamed TypeCode_Single to TypeCode_Float. Float struct interop fixes.
2020-07-03 13:54:45 -07:00
if (mTypeCode == BfTypeCode_Float)
Initial checkin
2019-08-23 11:56:54 -07:00
return mSingle;
return (double)mInt64;
}
};
enum BfToken : uint8
{
BfToken_None,
BfToken_Abstract,
BfToken_AlignOf,
Added alloctype(T)
2020-08-12 15:07:56 -07:00
BfToken_AllocType,
Initial checkin
2019-08-23 11:56:54 -07:00
BfToken_Append,
BfToken_As,
BfToken_Asm,
BfToken_AsmNewline,
BfToken_Base,
BfToken_Box,
BfToken_Break,
BfToken_Case,
BfToken_Catch,
BfToken_Checked,
BfToken_Class,
Added comptype
2021-01-15 14:28:21 -08:00
BfToken_Comptype,
Initial checkin
2019-08-23 11:56:54 -07:00
BfToken_Concrete,
BfToken_Const,
BfToken_Continue,
BfToken_Decltype,
BfToken_Default,
BfToken_Defer,
BfToken_Delegate,
BfToken_Delete,
BfToken_Do,
BfToken_Else,
BfToken_Enum,
BfToken_Explicit,
BfToken_Extern,
BfToken_Extension,
BfToken_Fallthrough,
BfToken_Finally,
BfToken_Fixed,
BfToken_For,
BfToken_Function,
BfToken_Goto,
BfToken_If,
BfToken_Implicit,
BfToken_In,
BfToken_Inline,
BfToken_Interface,
BfToken_Internal,
BfToken_Is,
BfToken_Let,
BfToken_Mixin,
BfToken_Mut,
Added concept of strict equality
2020-06-17 05:13:53 -07:00
BfToken_NameOf,
Initial checkin
2019-08-23 11:56:54 -07:00
BfToken_Namespace,
BfToken_New,
BfToken_Null,
Added nullable(T), Result<T> can use null conditionals
2020-04-27 15:09:10 -07:00
BfToken_Nullable,
offsetof
2021-09-10 14:21:25 -07:00
BfToken_OffsetOf,
Initial checkin
2019-08-23 11:56:54 -07:00
BfToken_Operator,
BfToken_Out,
BfToken_Override,
BfToken_Params,
BfToken_Private,
BfToken_Protected,
BfToken_Public,
BfToken_ReadOnly,
BfToken_Repeat,
BfToken_Ref,
BfToken_RetType,
BfToken_Return,
BfToken_Scope,
BfToken_Sealed,
BfToken_SizeOf,
BfToken_Stack,
BfToken_Static,
BfToken_StrideOf,
BfToken_Struct,
BfToken_Switch,
BfToken_This,
BfToken_Throw,
BfToken_Try,
BfToken_TypeAlias,
BfToken_TypeOf,
BfToken_Unchecked,
BfToken_Unsigned,
BfToken_Using,
BfToken_Var,
BfToken_Virtual,
BfToken_Volatile,
BfToken_When,
BfToken_Where,
BfToken_While,
BfToken_Yield,
BfToken_AssignEquals,
BfToken_CompareEquals,
Added concept of strict equality
2020-06-17 05:13:53 -07:00
BfToken_CompareStrictEquals,
Initial checkin
2019-08-23 11:56:54 -07:00
BfToken_CompareNotEquals,
Added concept of strict equality
2020-06-17 05:13:53 -07:00
BfToken_CompareStrictNotEquals,
Initial checkin
2019-08-23 11:56:54 -07:00
BfToken_LessEquals,
BfToken_GreaterEquals,
BfToken_Spaceship,
BfToken_PlusEquals,
BfToken_MinusEquals,
BfToken_MultiplyEquals,
BfToken_DivideEquals,
BfToken_ModulusEquals,
BfToken_ShiftLeftEquals,
BfToken_ShiftRightEquals,
BfToken_AndEquals,
Added overflow operators &+, &-, &*
2021-07-15 06:01:17 -07:00
BfToken_AndMinus,
BfToken_AndPlus,
BfToken_AndStar,
Improvements to overflow arithmetic
2022-01-11 10:36:22 -05:00
BfToken_AndMinusEquals,
BfToken_AndPlusEquals,
BfToken_AndStarEquals,
Initial checkin
2019-08-23 11:56:54 -07:00
BfToken_OrEquals,
BfToken_XorEquals,
Operator '??=', '?' out discard
2020-09-07 15:24:42 -07:00
BfToken_NullCoalsceEquals,
Initial checkin
2019-08-23 11:56:54 -07:00
BfToken_LBrace,
BfToken_RBrace,
BfToken_LParen,
BfToken_RParen,
BfToken_LBracket,
BfToken_RBracket,
BfToken_LChevron,
BfToken_RChevron,
BfToken_LDblChevron,
BfToken_RDblChevron,
BfToken_Semicolon,
BfToken_Colon,
BfToken_Comma,
BfToken_Dot,
BfToken_DotDot,
Added support for C-style vararg methods
2020-02-11 07:34:47 -08:00
BfToken_DotDotDot,
Ranges (ie: `for (int a in 0..<count)` `for (int i in 1…10)`)
2021-07-21 07:48:37 -07:00
BfToken_DotDotLess,
Initial checkin
2019-08-23 11:56:54 -07:00
BfToken_QuestionDot,
BfToken_QuestionLBracket,
BfToken_AutocompleteDot,
BfToken_Plus,
BfToken_Minus,
BfToken_DblPlus,
BfToken_DblMinus,
BfToken_Star,
BfToken_ForwardSlash,
BfToken_Modulus,
BfToken_Ampersand,
BfToken_At,
BfToken_DblAmpersand,
BfToken_Bar,
BfToken_DblBar,
BfToken_Bang,
BfToken_Carat,
BfToken_Tilde,
BfToken_Question,
BfToken_DblQuestion,
BfToken_Arrow,
BfToken_FatArrow,
};
class BfAstNode;
class BfScopeNode;
class BfNewNode;
class BfLabeledBlock;
class BfGenericArgumentsNode;
class BfStatement;
class BfLabelableStatement;
class BfExpression;
class BfExpressionStatement;
class BfAttributedExpression;
Added [IgnoreErrors] block attribute
2020-08-16 08:33:51 -07:00
class BfAttributedStatement;
Initial checkin
2019-08-23 11:56:54 -07:00
class BfLiteralExpression;
String interpolation
2020-11-11 05:46:52 -08:00
class BfStringInterpolationExpression;
Initial checkin
2019-08-23 11:56:54 -07:00
class BfBlock;
Fixed string interpolation scoping, {{ }} escaping
2021-01-04 06:33:39 -08:00
class BfUnscopedBlock;
Initial checkin
2019-08-23 11:56:54 -07:00
class BfBlockExtension;
class BfRootNode;
class BfErrorNode;
class BfTokenNode;
class BfIdentifierNode;
class BfAttributedIdentifierNode;
class BfQualifiedNameNode;
class BfNamespaceDeclaration;
class BfTypeDeclaration;
class BfTypeAliasDeclaration;
class BfMethodDeclaration;
class BfOperatorDeclaration;
class BfFieldDeclaration;
class BfEnumCaseDeclaration;
class BfParameterDeclaration;
class BfForStatement;
class BfUsingStatement;
class BfDoStatement;
class BfRepeatStatement;
class BfWhileStatement;
class BfMemberDeclaration;
class BfTypeReference;
class BfParameterDeclaration;
class BfVariableDeclaration;
class BfLocalMethodDeclaration;
class BfScopedInvocationTarget;
class BfInvocationExpression;
class BfDeferStatement;
class BfReturnStatement;
class BfYieldStatement;
class BfUnaryOperatorExpression;
class BfBinaryOperatorExpression;
class BfArrayTypeRef;
class BfPointerTypeRef;
class BfDotTypeReference;
class BfVarTypeReference;
class BfVarRefTypeReference;
class BfLetTypeReference;
class BfGenericInstanceTypeRef;
class BfTupleTypeRef;
class BfDelegateTypeRef;
Added comptype
2021-01-15 14:28:21 -08:00
class BfExprModTypeRef;
Initial checkin
2019-08-23 11:56:54 -07:00
class BfCommentNode;
class BfIfStatement;
class BfParenthesizedExpression;
class BfTupleExpression;
class BfAssignmentExpression;
class BfNamedTypeReference;
class BfObjectCreateExpression;
class BfBoxExpression;
class BfDelegateBindExpression;
class BfLambdaBindExpression;
class BfCastExpression;
class BfGenericParamsDeclaration;
class BfThisExpression;
class BfBaseExpression;
class BfMixinExpression;
class BfTryStatement;
class BfCatchStatement;
class BfFinallyStatement;
class BfCheckedStatement;
class BfUncheckedStatement;
class BfBreakStatement;
class BfContinueStatement;
class BfFallthroughStatement;
class BfThrowStatement;
class BfDeleteStatement;
class BfIndexerExpression;
class BfMemberReferenceExpression;
class BfDynamicCastExpression;
class BfCheckTypeExpression;
class BfConstructorDeclaration;
Added auto-constructors (ie: 'struct Vec : this(float x, float y);')
2021-01-02 12:54:05 -08:00
class BfAutoConstructorDeclaration;
Initial checkin
2019-08-23 11:56:54 -07:00
class BfDestructorDeclaration;
class BfQualifiedTypeReference;
class BfUsingDirective;
Internal protection, 'using internal <type or namespace>;`
2020-10-14 11:33:41 -07:00
class BfUsingModDirective;
Initial checkin
2019-08-23 11:56:54 -07:00
class BfPropertyMethodDeclaration;
Added expression bodies for properties
2019-09-30 12:24:02 -07:00
class BfPropertyBodyExpression;
Initial checkin
2019-08-23 11:56:54 -07:00
class BfPropertyDeclaration;
class BfIndexerDeclaration;
class BfPreprocesorIgnoredSectionNode;
class BfPreprocessorNode;
class BfPreprocessorDefinedExpression;
class BfTypeOfExpression;
class BfEnumCaseBindExpression;
class BfSwitchCase;
class BfCaseExpression;
class BfWhenExpression;
class BfSwitchStatement;
class BfForEachStatement;
class BfTypedValueExpression;
class BfTypeAttrExpression;
class BfSizeOfExpression;
class BfAlignOfExpression;
offsetof
2021-09-10 14:21:25 -07:00
class BfOffsetOfExpression;
Initial checkin
2019-08-23 11:56:54 -07:00
class BfStrideOfExpression;
class BfDefaultExpression;
class BfUninitializedExpression;
class BfConditionalExpression;
Initializer expressions
2020-06-18 06:12:14 -07:00
class BfInitializerExpression;
Initial checkin
2019-08-23 11:56:54 -07:00
class BfCollectionInitializerExpression;
class BfSizedArrayCreateExpression;
class BfEmptyStatement;
Added constraints for operators, 'external' constraints for methods
2019-11-17 09:28:39 -08:00
class BfGenericOperatorConstraint;
Initial checkin
2019-08-23 11:56:54 -07:00
class BfGenericConstraintsDeclaration;
class BfAttributeDirective;
class BfNullableTypeRef;
class BfRefTypeRef;
Added nullable(T), Result<T> can use null conditionals
2020-04-27 15:09:10 -07:00
class BfModifiedTypeRef;
Initial checkin
2019-08-23 11:56:54 -07:00
class BfConstTypeRef;
class BfConstExprTypeRef;
class BfInlineAsmStatement;
class BfInlineAsmInstruction;
class BfFieldDtorDeclaration;
class BfStructuralVisitor
{
public:
bool mCapturingChildRef;
BfAstNode** mCurChildRef;
public:
void VisitMembers(BfBlock* node);
void VisitChildNoRef(BfAstNode* nodeRef);
void DoVisitChild(BfAstNode*& nodeRef);
void AssertValidChildAddr(BfAstNode** nodeRef);
template <typename T>
void VisitChild(T& nodeRef)
{
/*if ((BfAstNode*)nodeRef == NULL)
return;
nodeRef->Accept(this);*/
if (nodeRef == NULL)
return;
if (mCapturingChildRef)
{
mCurChildRef = ((BfAstNode**) &nodeRef);
//AssertValidChildAddr(mCurChildRef);
}
nodeRef->Accept(this);
mCurChildRef = NULL;
}
Fixed missing-comma formatting
2020-09-06 05:28:19 -07:00
template <typename T>
void VisitChildNoRef(const T& nodeRef)
{
if ((BfAstNode*)nodeRef == NULL)
return;
nodeRef->Accept(this);
};
Initial checkin
2019-08-23 11:56:54 -07:00
public:
BfStructuralVisitor();
virtual void Visit(BfAstNode* bfAstNode) {}
Better handling of autocomplete with tokens
2020-05-26 06:10:51 -07:00
virtual void Visit(BfErrorNode* bfErrorNode);
Initial checkin
2019-08-23 11:56:54 -07:00
virtual void Visit(BfScopeNode* scopeNode);
virtual void Visit(BfNewNode* newNode);
virtual void Visit(BfLabeledBlock* labeledBlock);
virtual void Visit(BfExpression* expr);
virtual void Visit(BfExpressionStatement* exprStmt);
Added [IgnoreErrors] block attribute
2020-08-16 08:33:51 -07:00
virtual void Visit(BfAttributedExpression* attribExpr);
Initial checkin
2019-08-23 11:56:54 -07:00
virtual void Visit(BfStatement* stmt);
Added [IgnoreErrors] block attribute
2020-08-16 08:33:51 -07:00
virtual void Visit(BfAttributedStatement* attribStmt);
Initial checkin
2019-08-23 11:56:54 -07:00
virtual void Visit(BfLabelableStatement* labelableStmt);
virtual void Visit(BfTypedValueExpression* typedValueExpr);
virtual void Visit(BfCommentNode* commentNode);
virtual void Visit(BfPreprocesorIgnoredSectionNode* preprocesorIgnoredSection);
virtual void Visit(BfPreprocessorNode* preprocessorNode);
virtual void Visit(BfPreprocessorDefinedExpression* definedExpr);
virtual void Visit(BfAttributeDirective* attributeDirective);
virtual void Visit(BfGenericParamsDeclaration* genericParams);
Added constraints for operators, 'external' constraints for methods
2019-11-17 09:28:39 -08:00
virtual void Visit(BfGenericOperatorConstraint* genericConstraints);
Initial checkin
2019-08-23 11:56:54 -07:00
virtual void Visit(BfGenericConstraintsDeclaration* genericConstraints);
virtual void Visit(BfGenericArgumentsNode* genericArgumentsNode);
virtual void Visit(BfEmptyStatement* emptyStmt);
virtual void Visit(BfTokenNode* tokenNode);
String interpolation
2020-11-11 05:46:52 -08:00
virtual void Visit(BfTokenPairNode* tokenPairNode);
Start of anonymous 'using' field
2022-02-19 07:38:05 -05:00
virtual void Visit(BfUsingSpecifierNode* usingSpecifier);
Initial checkin
2019-08-23 11:56:54 -07:00
virtual void Visit(BfLiteralExpression* literalExpr);
String interpolation
2020-11-11 05:46:52 -08:00
virtual void Visit(BfStringInterpolationExpression* stringInterpolationExpression);
Initial checkin
2019-08-23 11:56:54 -07:00
virtual void Visit(BfIdentifierNode* identifierNode);
virtual void Visit(BfAttributedIdentifierNode* attrIdentifierNode);
virtual void Visit(BfQualifiedNameNode* nameNode);
virtual void Visit(BfThisExpression* thisExpr);
virtual void Visit(BfBaseExpression* baseExpr);
virtual void Visit(BfMixinExpression* thisExpr);
virtual void Visit(BfSizedArrayCreateExpression* createExpr);
Initializer expressions
2020-06-18 06:12:14 -07:00
virtual void Visit(BfInitializerExpression* collectionInitExpr);
Fixed repr for on-demand delegate types, avoiding circular Event refs
2020-01-23 12:02:54 -08:00
virtual void Visit(BfCollectionInitializerExpression* collectionInitExpr);
Initial checkin
2019-08-23 11:56:54 -07:00
virtual void Visit(BfTypeReference* typeRef);
virtual void Visit(BfNamedTypeReference* typeRef);
virtual void Visit(BfQualifiedTypeReference* qualifiedType);
virtual void Visit(BfDotTypeReference* typeRef);
virtual void Visit(BfVarTypeReference* typeRef);
virtual void Visit(BfVarRefTypeReference* typeRef);
virtual void Visit(BfLetTypeReference* typeRef);
virtual void Visit(BfConstTypeRef* typeRef);
virtual void Visit(BfConstExprTypeRef* typeRef);
virtual void Visit(BfRefTypeRef* typeRef);
Added nullable(T), Result<T> can use null conditionals
2020-04-27 15:09:10 -07:00
virtual void Visit(BfModifiedTypeRef* typeRef);
Initial checkin
2019-08-23 11:56:54 -07:00
virtual void Visit(BfArrayTypeRef* typeRef);
virtual void Visit(BfGenericInstanceTypeRef* typeRef);
virtual void Visit(BfTupleTypeRef* typeRef);
Added comptype
2021-01-15 14:28:21 -08:00
virtual void Visit(BfDelegateTypeRef* typeRef);
virtual void Visit(BfExprModTypeRef* declTypeRef);
Initial checkin
2019-08-23 11:56:54 -07:00
virtual void Visit(BfPointerTypeRef* typeRef);
virtual void Visit(BfNullableTypeRef* typeRef);
virtual void Visit(BfVariableDeclaration* varDecl);
virtual void Visit(BfLocalMethodDeclaration* methodDecl);
Fixed params expression with ref values
2020-05-19 09:42:11 -07:00
virtual void Visit(BfParameterDeclaration* paramDecl);
Initial checkin
2019-08-23 11:56:54 -07:00
virtual void Visit(BfTypeAttrExpression* typeAttrExpr);
virtual void Visit(BfTypeOfExpression* typeOfExpr);
virtual void Visit(BfSizeOfExpression* sizeOfExpr);
virtual void Visit(BfAlignOfExpression* alignOfExpr);
virtual void Visit(BfStrideOfExpression* strideOfExpr);
offsetof
2021-09-10 14:21:25 -07:00
virtual void Visit(BfOffsetOfExpression* offsetOfExpr);
Initial checkin
2019-08-23 11:56:54 -07:00
virtual void Visit(BfDefaultExpression* defaultExpr);
virtual void Visit(BfUninitializedExpression* uninitializedExpr);
virtual void Visit(BfCheckTypeExpression* checkTypeExpr);
virtual void Visit(BfDynamicCastExpression* dynCastExpr);
virtual void Visit(BfCastExpression* castExpr);
virtual void Visit(BfDelegateBindExpression* delegateBindExpr);
virtual void Visit(BfLambdaBindExpression* lambdaBindExpr);
virtual void Visit(BfObjectCreateExpression* objCreateExpr);
virtual void Visit(BfBoxExpression* boxExpr);
virtual void Visit(BfScopedInvocationTarget* scopedTarget);
virtual void Visit(BfInvocationExpression* invocationExpr);
virtual void Visit(BfEnumCaseBindExpression* caseBindExpr);
virtual void Visit(BfCaseExpression* caseExpr);
virtual void Visit(BfSwitchCase* switchCase);
virtual void Visit(BfWhenExpression* whenExpr);
virtual void Visit(BfSwitchStatement* switchStmt);
virtual void Visit(BfTryStatement* tryStmt);
virtual void Visit(BfCatchStatement* catchStmt);
virtual void Visit(BfFinallyStatement* finallyStmt);
virtual void Visit(BfCheckedStatement* checkedStmt);
virtual void Visit(BfUncheckedStatement* uncheckedStmt);
virtual void Visit(BfIfStatement* ifStmt);
virtual void Visit(BfThrowStatement* throwStmt);
virtual void Visit(BfDeleteStatement* deleteStmt);
virtual void Visit(BfReturnStatement* returnStmt);
virtual void Visit(BfYieldStatement* returnStmt);
virtual void Visit(BfBreakStatement* breakStmt);
virtual void Visit(BfContinueStatement* continueStmt);
virtual void Visit(BfFallthroughStatement* fallthroughStmt);
virtual void Visit(BfUsingStatement* whileStmt);
virtual void Visit(BfDoStatement* whileStmt);
virtual void Visit(BfRepeatStatement* repeatStmt);
virtual void Visit(BfWhileStatement* whileStmt);
virtual void Visit(BfForStatement* forStmt);
virtual void Visit(BfForEachStatement* forEachStmt);
virtual void Visit(BfDeferStatement* deferStmt);
virtual void Visit(BfConditionalExpression* condExpr);
virtual void Visit(BfAssignmentExpression* assignExpr);
virtual void Visit(BfParenthesizedExpression* parenExpr);
virtual void Visit(BfTupleExpression* parenExpr);
virtual void Visit(BfMemberReferenceExpression* memberRefExpr);
virtual void Visit(BfIndexerExpression* indexerExpr);
virtual void Visit(BfUnaryOperatorExpression* binOpExpr);
virtual void Visit(BfBinaryOperatorExpression* binOpExpr);
virtual void Visit(BfConstructorDeclaration* ctorDeclaration);
virtual void Visit(BfDestructorDeclaration* dtorDeclaration);
virtual void Visit(BfMethodDeclaration* methodDeclaration);
virtual void Visit(BfOperatorDeclaration* operatorDeclaration);
virtual void Visit(BfPropertyMethodDeclaration* propertyMethodDeclaration);
Added expression bodies for properties
2019-09-30 12:24:02 -07:00
virtual void Visit(BfPropertyBodyExpression* propertyBodyExpression);
Initial checkin
2019-08-23 11:56:54 -07:00
virtual void Visit(BfPropertyDeclaration* propertyDeclaration);
virtual void Visit(BfIndexerDeclaration* indexerDeclaration);
virtual void Visit(BfFieldDeclaration* fieldDeclaration);
virtual void Visit(BfEnumCaseDeclaration* enumCaseDeclaration);
virtual void Visit(BfFieldDtorDeclaration* fieldDtorDeclaration);
virtual void Visit(BfTypeDeclaration* typeDeclaration);
virtual void Visit(BfTypeAliasDeclaration* typeDeclaration);
virtual void Visit(BfUsingDirective* usingDirective);
Internal protection, 'using internal <type or namespace>;`
2020-10-14 11:33:41 -07:00
virtual void Visit(BfUsingModDirective* usingDirective);
Initial checkin
2019-08-23 11:56:54 -07:00
virtual void Visit(BfNamespaceDeclaration* namespaceDeclaration);
virtual void Visit(BfBlock* block);
Fixed string interpolation scoping, {{ }} escaping
2021-01-04 06:33:39 -08:00
virtual void Visit(BfUnscopedBlock* block);
Initial checkin
2019-08-23 11:56:54 -07:00
virtual void Visit(BfBlockExtension* block);
virtual void Visit(BfRootNode* rootNode);
virtual void Visit(BfInlineAsmStatement* asmStmt);
virtual void Visit(BfInlineAsmInstruction* asmInst);
};
enum BfTypedValueKind
{
BfTypedValueKind_Addr,
Better fix for direct autprop optimization
2021-01-20 08:53:43 -08:00
BfTypedValueKind_CopyOnMutateAddr,
Improvements to auto-impl properties
2022-03-01 09:49:02 -08:00
BfTypedValueKind_CopyOnMutateAddr_Derived,
Initial checkin
2019-08-23 11:56:54 -07:00
BfTypedValueKind_ReadOnlyAddr,
BfTypedValueKind_TempAddr,
Made a different `restricted temp address` for return values
2020-07-01 06:14:43 -07:00
BfTypedValueKind_RestrictedTempAddr,
Initial checkin
2019-08-23 11:56:54 -07:00
BfTypedValueKind_ReadOnlyTempAddr,
BfTypedValueKind_ThisAddr,
BfTypedValueKind_BaseAddr,
BfTypedValueKind_ReadOnlyThisAddr,
BfTypedValueKind_ReadOnlyBaseAddr,
BfTypedValueKind_Value,
BfTypedValueKind_ThisValue,
BfTypedValueKind_BaseValue,
BfTypedValueKind_ReadOnlyThisValue,
BfTypedValueKind_ReadOnlyBaseValue,
BfTypedValueKind_MutableValue, // Only applicable for generic params
BfTypedValueKind_SplatHead,
BfTypedValueKind_ThisSplatHead,
BfTypedValueKind_BaseSplatHead,
BfTypedValueKind_SplatHead_NeedsCasting,
BfTypedValueKind_ParamsSplat,
BfTypedValueKind_Params,
BfTypedValueKind_NoValue,
BfTypedValueKind_UntypedValue,
BfTypedValueKind_GenericConstValue
};
class BfTypedValue
{
public:
//llvm::Value* mValue;
BfIRValue mValue;
BfType* mType;
BfTypedValueKind mKind; // Is address of variable
public:
BfTypedValue()
{
mType = NULL;
mKind = BfTypedValueKind_NoValue;
}
BfTypedValue(BfTypedValueKind kind)
{
mType = NULL;
mKind = kind;
}
BfTypedValue(BfType* resolvedType)
{
mType = resolvedType;
mKind = BfTypedValueKind_NoValue;
}
BfTypedValue(BfIRValue val, BfType* resolvedType, bool isAddr)
{
BF_ASSERT((!val) || (resolvedType != NULL));
mValue = val;
mType = resolvedType;
mKind = isAddr ? BfTypedValueKind_Addr : BfTypedValueKind_Value;
#ifdef _DEBUG
//DbgCheckType();
#endif
BF_ASSERT(val);
/*if ((!val) && (resolvedType != NULL))
{
BF_ASSERT(IsValuelessType());
}
else if (IsValuelessType())
{
//BF_ASSERT(!val || IsAddr());
}*/
}
BfTypedValue(BfIRValue val, BfType* resolvedType, BfTypedValueKind kind = BfTypedValueKind_Value)
{
BF_ASSERT((!val) || (resolvedType != NULL));
mValue = val;
mType = resolvedType;
mKind = kind;
#ifdef _DEBUG
//DbgCheckType();
#endif
if ((!val) && (resolvedType != NULL))
{
BF_ASSERT(IsValuelessType());
}
/*else if (IsValuelessType())
{
BF_ASSERT(!val || IsAddr());
}*/
}
void DbgCheckType() const;
bool IsValuelessType() const;
bool HasType() const
{
return mType != NULL;
}
bool IsStatic() const
{
Improvements to const string generic arg, literal generic args
2022-02-05 09:23:44 -05:00
return (!mValue) && (mKind != BfTypedValueKind_GenericConstValue);
Initial checkin
2019-08-23 11:56:54 -07:00
}
bool IsAddr() const
{
return (mKind < BfTypedValueKind_Value);
}
bool IsTempAddr() const
{
Made a different `restricted temp address` for return values
2020-07-01 06:14:43 -07:00
return ((mKind == BfTypedValueKind_ReadOnlyTempAddr) || (mKind == BfTypedValueKind_RestrictedTempAddr) || (mKind == BfTypedValueKind_TempAddr));
Initial checkin
2019-08-23 11:56:54 -07:00
}
Better fix for direct autprop optimization
2021-01-20 08:53:43 -08:00
bool IsCopyOnMutate() const
{
Improvements to auto-impl properties
2022-03-01 09:49:02 -08:00
return (mKind == BfTypedValueKind_CopyOnMutateAddr) || (mKind == BfTypedValueKind_CopyOnMutateAddr_Derived);
Better fix for direct autprop optimization
2021-01-20 08:53:43 -08:00
}
Initial checkin
2019-08-23 11:56:54 -07:00
bool IsReadOnly() const
{
switch (mKind)
{
case BfTypedValueKind_ReadOnlyAddr:
case BfTypedValueKind_ReadOnlyTempAddr:
case BfTypedValueKind_ReadOnlyThisValue:
case BfTypedValueKind_ReadOnlyBaseValue:
case BfTypedValueKind_ReadOnlyThisAddr:
case BfTypedValueKind_ReadOnlyBaseAddr:
case BfTypedValueKind_MutableValue: // 'mutable' means we can call mut methods, not that we can assign to it
case BfTypedValueKind_SplatHead:
case BfTypedValueKind_ThisSplatHead:
case BfTypedValueKind_BaseSplatHead:
case BfTypedValueKind_ParamsSplat:
case BfTypedValueKind_Params:
return true;
Initial macOS changes Many changes are related to fixing warnings
2019-10-14 14:08:29 -07:00
default:
return false;
Initial checkin
2019-08-23 11:56:54 -07:00
}
return false;
}
bool IsThis() const
{
return (mKind == BfTypedValueKind_ThisValue) || (mKind == BfTypedValueKind_ThisAddr) || (mKind == BfTypedValueKind_ReadOnlyThisValue) ||
(mKind == BfTypedValueKind_ReadOnlyThisAddr) || (mKind == BfTypedValueKind_ThisSplatHead);
}
bool IsBase() const
{
return (mKind == BfTypedValueKind_BaseValue) || (mKind == BfTypedValueKind_BaseAddr) || (mKind == BfTypedValueKind_ReadOnlyBaseValue) ||
(mKind == BfTypedValueKind_ReadOnlyBaseAddr) || (mKind == BfTypedValueKind_BaseSplatHead);
}
void ToBase()
{
BF_ASSERT(IsThis());
mKind = (BfTypedValueKind)((int)mKind + 1);
}
void ToThis()
{
BF_ASSERT(IsBase());
mKind = (BfTypedValueKind)((int)mKind - 1);
}
bool IsSplat() const
{
return (mKind >= BfTypedValueKind_SplatHead) && (mKind <= BfTypedValueKind_ParamsSplat);
}
bool IsUntypedValue() const
{
return (mKind == BfTypedValueKind_UntypedValue);
}
bool IsParams()
{
return (mKind == BfTypedValueKind_ParamsSplat) || (mKind == BfTypedValueKind_Params);
}
operator bool() const
{
//return (mKind != BfTypedValueKind_NoValue) && ((mValue) || ((mType != NULL) && (IsValuelessType())));
return (mKind != BfTypedValueKind_NoValue);
}
Improving auto-implemented properties
2020-04-10 07:53:56 -07:00
void MakeReadOnly()
{
switch (mKind)
{
case BfTypedValueKind_Addr:
mKind = BfTypedValueKind_ReadOnlyAddr;
break;
case BfTypedValueKind_TempAddr:
Made a different `restricted temp address` for return values
2020-07-01 06:14:43 -07:00
case BfTypedValueKind_RestrictedTempAddr:
Improving auto-implemented properties
2020-04-10 07:53:56 -07:00
mKind = BfTypedValueKind_ReadOnlyTempAddr;
break;
Working on Linux fixes
2020-05-21 06:58:26 -07:00
default:
break;
Improving auto-implemented properties
2020-04-10 07:53:56 -07:00
}
}
Made method mutability part of signature and method selection
2020-08-29 14:18:05 -07:00
bool CanModify() const;
Initial checkin
2019-08-23 11:56:54 -07:00
};
#define BF_AST_TYPE(name, TBase) \
static BfAstTypeInfo sTypeInfo;\
static void ClassAccept(BfAstNode* node, BfStructuralVisitor* bfVisitor) { bfVisitor->Visit((name*)node); } \
TBase* ToBase() { return (TBase*)this; } \
name() { InitWithTypeId(sTypeInfo.mTypeId); }
#ifdef BF_AST_DO_IMPL
#define BF_AST_DECL(name, TBase) \
BfAstTypeInfo name::sTypeInfo(#name, &TBase::sTypeInfo, &name::ClassAccept);
#else
#define BF_AST_DECL(name, TBase)
#endif
class BfAstNode;
Fix for lambda caching within mixin
2020-10-30 09:03:36 -07:00
class BfAstNodeList
{
public:
SizedArray<BfAstNode*, 4> mList;
public:
bool operator==(const BfAstNodeList& rhs)
{
if (mList.mSize != rhs.mList.mSize)
return false;
for (int i = 0; i < mList.mSize; i++)
if (mList[i] != rhs.mList[i])
return false;
== fix
2020-10-30 09:35:48 -07:00
return true;
Fix for lambda caching within mixin
2020-10-30 09:03:36 -07:00
}
};
Initial checkin
2019-08-23 11:56:54 -07:00
template <typename T>
class BfChunkedArray
{
public:
static const int sLeafSize = 8;
T** mRoots;
int mSize;
public:
BfChunkedArray()
{
mSize = 0;
}
int GetRootCount()
{
return (mSize + sLeafSize - 1) / sLeafSize;
}
void Add(T val, BfAstAllocator* bumpAlloc)
{
int idx = mSize;
if ((mSize % sLeafSize) == 0)
{
int rootCount = GetRootCount();
mSize++;
int newRootCount = GetRootCount();
if (rootCount != newRootCount)
{
T** newRoots = (T**)bumpAlloc->AllocBytes(newRootCount * sizeof(T**), sizeof(T**));
memcpy(newRoots, mRoots, rootCount * sizeof(T*));
mRoots = newRoots;
}
mRoots[idx / sLeafSize] = (T*)bumpAlloc->AllocBytes(sLeafSize * sizeof(T*), sizeof(T*));
}
else
mSize++;
mRoots[idx / sLeafSize][idx % sLeafSize] = val;
}
bool IsEmpty()
{
return mSize == 0;
}
void SetSize(int size)
{
BF_ASSERT(size <= mSize);
mSize = size;
}
T& operator[](int idx)
{
return mRoots[idx / sLeafSize][idx % sLeafSize];
}
T Get(int idx)
{
if ((idx < 0) || (idx >= mSize))
return (T)0;
return mRoots[idx / sLeafSize][idx % sLeafSize];
}
T GetLast()
{
if (mSize == 0)
return (T)0;
return (*this)[mSize - 1];
}
T GetFirst()
{
if (mSize == 0)
return (T)0;
return (*this)[0];
}
};
template <typename T>
class BfDebugArray
{
public:
static const int STATIC_SIZE = 1024;
Array<T> mElements;
int mSize;
public:
BfDebugArray()
{
mSize = 0;
}
void Add(T val, BfAstAllocator* bumpAlloc)
{
mElements.push_back(val);
mSize++;
}
bool IsEmpty()
{
return mSize == 0;
}
void SetSize(int size)
{
BF_ASSERT(size <= mSize);
mSize = size;
}
T& operator[](int idx)
{
return mElements[idx];
}
T Get(int idx)
{
if ((idx < 0) || (idx >= mSize))
return (T)0;
return mElements[idx];
}
T GetLast()
{
if (mSize == 0)
return (T)0;
return mElements[mSize - 1];
}
T GetFirst()
{
if (mSize == 0)
return (T)0;
return (*this)[0];
}
};
template <typename T>
class BfDeferredSizedArray : public llvm::SmallVector<T, 8>
{
public:
BfSizedArray<T>* mSizedArray;
BfAstAllocator* mAlloc;
public:
BfDeferredSizedArray(BfSizedArray<T>& arr, BfAstAllocator* alloc)
{
mSizedArray = &arr;
mAlloc = alloc;
}
~BfDeferredSizedArray()
{
mSizedArray->mSize = (int)this->size();
if (mSizedArray->mSize > 0)
{
mSizedArray->mVals = (T*)mAlloc->AllocBytes(mSizedArray->mSize * sizeof(T), sizeof(T));
memcpy(mSizedArray->mVals, &(*this)[0], mSizedArray->mSize * sizeof(T));
}
}
};
#ifdef BF_USE_NEAR_NODE_REF
#define ASTREF(T) BfNearNodeRef<T>
#else
#define ASTREF(T) T
#endif
template <typename T, typename T2>
static void BfSizedArrayInitIndirect(BfSizedArray<T>& sizedArray, const SizedArrayImpl<T2>& vec, BfAstAllocator* alloc)
{
sizedArray.mSize = (int)vec.size();
BF_ASSERT(sizedArray.mSize >= 0);
if (sizedArray.mSize > 0)
{
sizedArray.mVals = (T*)alloc->AllocBytes(sizedArray.mSize * sizeof(T), sizeof(T));
for (int i = 0; i < sizedArray.mSize; i++)
sizedArray.mVals[i] = vec[i];
}
}
template <typename T>
class BfDeferredAstSizedArray : public SizedArray<T, 8>
{
Parser fixes
2020-09-12 08:11:29 -07:00
public:
Initial checkin
2019-08-23 11:56:54 -07:00
BfSizedArray<ASTREF(T)>* mSizedArray;
BfAstAllocator* mAlloc;
public:
BfDeferredAstSizedArray(BfSizedArray<ASTREF(T)>& arr, BfAstAllocator* alloc)
Parser fixes
2020-09-12 08:11:29 -07:00
{
Initial checkin
2019-08-23 11:56:54 -07:00
mSizedArray = &arr;
Parser fixes
2020-09-12 08:11:29 -07:00
mAlloc = alloc;
Initial checkin
2019-08-23 11:56:54 -07:00
}
~BfDeferredAstSizedArray()
{
Parser fixes
2020-09-12 08:11:29 -07:00
BfSizedArrayInitIndirect(*mSizedArray, *this, mAlloc);
}
};
Initial checkin
2019-08-23 11:56:54 -07:00
typedef void(*BfAstAcceptFunc)(BfAstNode* node, BfStructuralVisitor* visitor);
class BfAstTypeInfo
{
public:
const char* mName;
BfAstTypeInfo* mBaseType;
Array<BfAstTypeInfo*> mDerivedTypes;
uint8 mTypeId;
uint8 mFullDerivedCount; // Including all ancestors
BfAstAcceptFunc mAcceptFunc;
BfAstTypeInfo(const char* name, BfAstTypeInfo* baseType, BfAstAcceptFunc acceptFunc);
public:
static void Init();
};
#ifdef BF_AST_COMPACT
struct BfAstInfo
{
int mTriviaStart;
int mSrcStart;
int mSrcEnd;
uint8 mTypeId;
BfToken mToken;
};
#endif
class BfAstNode
{
public:
static BfAstTypeInfo sTypeInfo;
#ifndef BF_AST_ALLOCATOR_USE_PAGES
BfSourceData* mSourceData;
#endif
#ifdef BF_AST_HAS_PARENT_MEMBER
BfAstNode* mParent;
#endif
#ifdef BF_AST_COMPACT
union
{
struct
{
uint8 mCompact_TriviaLen;
uint8 mCompact_SrcLen;
uint8 mCompact_TypeId;
BfToken mCompact_Token;
int mCompact_SrcStart : 31;
int mIsCompact : 1;
};
BfAstInfo* mAstInfo;
};
#else
int mTriviaStart;
int mSrcStart;
int mSrcEnd;
uint8 mTypeId;
BfToken mToken;
#endif
public:
BfAstNode()
{
#ifdef BF_AST_COMPACT
// Nothing
mIsCompact = true;
#else
//mParent = NULL;
mTriviaStart = -1;
mSrcStart = 0x7FFFFFFF;
Fixed typealias dependencies
2019-11-27 08:02:15 -08:00
mSrcEnd = 0;
Initial checkin
2019-08-23 11:56:54 -07:00
//mSrcEnd = 0;
#endif
}
#ifdef BF_AST_VTABLE
virtual ~BfAstNode()
{
}
#endif
void RemoveSelf();
void DeleteSelf();
void RemoveNextSibling();
void DeleteNextSibling();
bool IsTemporary();
int GetStartCharId();
BfSourceData* GetSourceData();
Made callstack aware of outer types vs namespaces. Colorized classview
2019-12-11 12:54:50 -08:00
BfParserData* GetParserData();
Initial checkin
2019-08-23 11:56:54 -07:00
BfParser* GetParser();
Comptime updates, start of metaprogramming support
2021-01-08 16:21:03 -08:00
bool IsEmitted();
Initial checkin
2019-08-23 11:56:54 -07:00
bool IsFromParser(BfParser* parser);
String ToString();
StringView ToStringView();
void ToString(StringImpl& str);
Alloc allign attributes, lambda captures
2019-11-26 13:11:17 -08:00
bool Equals(const StringImpl& str);
Fixed false signature change with multiple extensions
2020-12-31 09:56:51 -08:00
bool Equals(const StringView& str);
Better handling of this/base for autocomplete, colorization, goto def
2020-02-21 09:26:02 -08:00
bool Equals(const char* str);
Initial checkin
2019-08-23 11:56:54 -07:00
void Init(BfParser* bfParser);
void Accept(BfStructuralVisitor* bfVisitor);
static void ClassAccept(BfAstNode* node, BfStructuralVisitor* bfVisitor) { bfVisitor->Visit(node); }
bool LocationEquals(BfAstNode* otherNode);
bool LocationEndEquals(BfAstNode* otherNode);
Early code generation support
2021-01-11 09:41:43 -08:00
String LocationToString();
Initial checkin
2019-08-23 11:56:54 -07:00
void Add(BfAstNode* bfAstNode);
bool IsMissingSemicolon();
bool IsExpression();
AllowDuplicatesAttribute
2019-12-25 16:38:17 -08:00
bool WantsWarning(int warningNumber);
Initial checkin
2019-08-23 11:56:54 -07:00
template <typename T>
bool IsA()
{
return (uint)GetTypeId() - (uint)T::sTypeInfo.mTypeId <= (uint)T::sTypeInfo.mFullDerivedCount;
}
template <typename T>
bool IsExact()
{
return (uint)GetTypeId() == (uint)T::sTypeInfo.mTypeId;
}
#ifdef BF_AST_COMPACT
BfAstInfo* AllocAstInfo();
void InitEmpty()
{
mIsCompact = true;
mCompact_SrcStart = 0;
mCompact_SrcLen = 0;
mCompact_TriviaLen = 0;
}
void InitWithTypeId(int typeId)
{
mCompact_TypeId = typeId;
}
bool IsInitialized()
{
return (!mIsCompact) || (mCompact_SrcLen != 0);
}
BfToken GetToken()
{
if (mIsCompact)
return mCompact_Token;
return mAstInfo->mToken;
}
void SetToken(BfToken token)
{
if (mIsCompact)
mCompact_Token = token;
else
mAstInfo->mToken = token;
}
void Init(int triviaStart, int srcStart, int srcEnd)
{
int triviaLen = srcStart - triviaStart;
int srcLen = srcEnd - srcStart;
if ((triviaLen <= 255) && (srcLen <= 255))
{
mCompact_SrcStart = srcStart;
mIsCompact = 1;
mCompact_TriviaLen = (uint8)triviaLen;
mCompact_SrcLen = (uint8)srcLen;
}
else
{
auto astInfo = AllocAstInfo();
astInfo->mTypeId = mCompact_TypeId;
astInfo->mToken = mCompact_Token;
astInfo->mTriviaStart = triviaStart;
astInfo->mSrcStart = srcStart;
astInfo->mSrcEnd = srcEnd;
mAstInfo = astInfo;
}
}
int GetTypeId()
{
if (mIsCompact)
return mCompact_TypeId;
return mAstInfo->mTypeId;
}
void GetSrcPositions(int& triviaStart, int& srcStart, int& srcEnd)
{
if (mIsCompact)
{
srcStart = mCompact_SrcStart;
srcEnd = srcStart + mCompact_SrcLen;
triviaStart = srcStart - mCompact_TriviaLen;
}
else
{
triviaStart = mAstInfo->mTriviaStart;
srcStart = mAstInfo->mSrcStart;
srcEnd = mAstInfo->mSrcEnd;
}
}
int GetTriviaStart()
{
if (mIsCompact)
return mCompact_SrcStart - mCompact_TriviaLen;
return mAstInfo->mTriviaStart;
}
void SetTriviaStart(int triviaStart)
{
if (mIsCompact)
{
int triviaLen = mCompact_SrcStart - triviaStart;
if (triviaLen <= 255)
{
mCompact_TriviaLen = (uint8)triviaLen;
return;
}
auto astInfo = AllocAstInfo();
astInfo->mTypeId = mCompact_TypeId;
astInfo->mToken = mCompact_Token;
astInfo->mSrcStart = mCompact_SrcStart;
astInfo->mSrcEnd = mCompact_SrcStart + mCompact_SrcLen;
mAstInfo = astInfo;
}
mAstInfo->mTriviaStart = triviaStart;
}
int GetSrcStart()
{
if (mIsCompact)
return mCompact_SrcStart;
return mAstInfo->mSrcStart;
}
void SetSrcStart(int srcStart)
{
if (mIsCompact)
{
int startAdjust = srcStart - mCompact_SrcStart;
uint32 triviaLen = (uint32)((int)mCompact_TriviaLen + startAdjust);
uint32 srcLen = (uint32)((int)mCompact_SrcLen - startAdjust);
if ((triviaLen <= 255) && (srcLen <= 255))
{
mCompact_SrcStart = srcStart;
mCompact_TriviaLen = (uint8)triviaLen;
mCompact_SrcLen = (uint8)srcLen;
}
else
{
auto astInfo = AllocAstInfo();
astInfo->mTypeId = mCompact_TypeId;
astInfo->mSrcStart = srcStart;
astInfo->mTriviaStart = srcStart - triviaLen;
astInfo->mSrcEnd = srcStart + srcLen;
mAstInfo = astInfo;
}
}
else
mAstInfo->mSrcStart = srcStart;
}
int GetSrcEnd()
{
if (mIsCompact)
return mCompact_SrcStart + mCompact_SrcLen;
return mAstInfo->mSrcEnd;
}
void SetSrcEnd(int srcEnd)
{
if (mIsCompact)
{
int srcLen = srcEnd - mCompact_SrcStart;
if (srcLen <= 255)
{
mCompact_SrcLen = (uint8)srcLen;
return;
}
auto astInfo = AllocAstInfo();
astInfo->mTypeId = mCompact_TypeId;
astInfo->mSrcStart = mCompact_SrcStart;
astInfo->mTriviaStart = mCompact_SrcStart - mCompact_TriviaLen;
mAstInfo = astInfo;
}
mAstInfo->mSrcEnd = srcEnd;
}
void AdjustSrcEnd(BfAstNode* srcNode)
{
int srcEnd = srcNode->GetSrcEnd();
if (srcEnd > GetSrcEnd())
SetSrcEnd(srcEnd);
}
int GetSrcLength()
{
if (mIsCompact)
return mCompact_SrcLen;
return mAstInfo->mSrcEnd - mAstInfo->mSrcStart;
}
bool Contains(int srcPos)
{
if (mIsCompact)
return (srcPos >= mCompact_SrcStart) && (srcPos < mCompact_SrcStart + mCompact_SrcLen);
return (srcPos >= mAstInfo->mSrcStart) && (srcPos < mAstInfo->mSrcEnd);
}
#else
void InitEmpty()
{
mTriviaStart = 0;
mSrcStart = 0;
mSrcEnd = 0;
}
void InitWithTypeId(int typeId)
{
mTypeId = typeId;
}
bool IsInitialized()
{
return mSrcStart != 0x7FFFFFFF;
}
void Init(int triviaStart, int srcStart, int srcEnd)
{
mTriviaStart = triviaStart;
mSrcStart = srcStart;
mSrcEnd = srcEnd;
}
BfToken GetToken()
{
return mToken;
}
void SetToken(BfToken token)
{
mToken = token;
}
int GetTypeId()
{
return mTypeId;
}
void GetSrcPositions(int& triviaStart, int& srcStart, int& srcEnd)
{
triviaStart = mTriviaStart;
srcStart = mSrcStart;
srcEnd = mSrcEnd;
}
int GetTriviaStart()
{
return mTriviaStart;
}
void SetTriviaStart(int triviaStart)
{
mTriviaStart = triviaStart;
}
int GetSrcStart()
{
return mSrcStart;
}
void SetSrcStart(int srcStart)
{
mSrcStart = srcStart;
}
int GetSrcEnd()
{
return mSrcEnd;
}
void SetSrcEnd(int srcEnd)
{
mSrcEnd = srcEnd;
}
void AdjustSrcEnd(BfAstNode* srcNode)
{
int srcEnd = srcNode->GetSrcEnd();
if (srcEnd > GetSrcEnd())
SetSrcEnd(srcEnd);
}
int GetSrcLength()
{
return mSrcEnd - mSrcStart;
}
bool Contains(int srcPos)
{
return (srcPos >= mSrcStart) && (srcPos < mSrcEnd);
}
bool Contains(int srcPos, int lenAdd, int startAdd)
{
return (srcPos >= mSrcStart + startAdd) && (srcPos < mSrcEnd + lenAdd);
}
Additional `if` variable restrictions
2020-09-25 05:36:58 -07:00
bool Contains(BfAstNode* node)
{
return (node->mSrcStart >= mSrcStart) && (node->mSrcEnd <= mSrcEnd);
}
Initial checkin
2019-08-23 11:56:54 -07:00
#endif
#ifdef BF_AST_HAS_PARENT_MEMBER
template <typename T>
T* FindParentOfType()
{
BfAstNode* checkParent = mParent;
while (checkParent != NULL)
{
if (checkParent->IsA<T>())
return (T*)checkParent;
checkParent = checkParent->mParent;
}
return NULL;
}
#endif
#ifdef BF_AST_HAS_PARENT_MEMBER
template <typename T>
static T* ZeroedAlloc()
{
T* val = new T();
memset((uint8*)val + offsetof(T, mParent), 0, sizeof(T) - offsetof(T, mParent));
return val;
}
#else
template <typename T>
static T* ZeroedAlloc()
{
T* val = new T();
#ifdef BF_AST_COMPACT
memset((uint8*)val + offsetof(T, mAstInfo), 0, sizeof(T) - offsetof(T, mAstInfo));
#else
memset((uint8*)val + offsetof(T, mTriviaStart), 0, sizeof(T) - offsetof(T, mTriviaStart));
#endif
val->InitWithTypeId(T::sTypeInfo.mTypeId);
return val;
}
Fixed zeroing of paramdecl in lambdas
2020-05-17 06:58:03 -07:00
template <typename T>
static void Zero(T* val)
{
#ifdef BF_AST_COMPACT
memset((uint8*)val + offsetof(T, mAstInfo), 0, sizeof(T) - offsetof(T, mAstInfo));
#else
memset((uint8*)val + offsetof(T, mTriviaStart), 0, sizeof(T) - offsetof(T, mTriviaStart));
#endif
val->InitWithTypeId(T::sTypeInfo.mTypeId);
}
Initial checkin
2019-08-23 11:56:54 -07:00
#endif
};
#ifdef BF_AST_DO_IMPL
BfAstTypeInfo BfAstNode::sTypeInfo("BfAstNode", NULL, &BfAstNode::ClassAccept);
#endif
template <typename T>
bool BfNodeIsA(BfAstNode* node)
{
if (node == NULL)
return false;
bool canCast = (uint)node->GetTypeId() - (uint)T::sTypeInfo.mTypeId <= (uint)T::sTypeInfo.mFullDerivedCount;
return canCast;
}
template <typename T>
bool BfNodeIsExact(BfAstNode* node)
{
if (node == NULL)
return false;
bool canCast = (uint)node->GetTypeId() == (uint)T::sTypeInfo.mTypeId;
return canCast;
}
template <typename T>
T* BfNodeDynCast(BfAstNode* node)
{
if (node == NULL)
return NULL;
bool canCast = (uint)node->GetTypeId() - (uint)T::sTypeInfo.mTypeId <= (uint)T::sTypeInfo.mFullDerivedCount;
//BF_ASSERT(canCast == (node->DynCast(T::TypeId) != NULL));
return canCast ? (T*)node : NULL;
}
template <typename T>
T* BfNodeDynCastExact(BfAstNode* node)
{
if (node == NULL)
return NULL;
bool canCast = node->GetTypeId() == T::sTypeInfo.mTypeId;
//BF_ASSERT(canCast == (node->GetTypeId() == T::TypeId));
return canCast ? (T*)node : NULL;
}
Fix for 'using static' namespace search inside namespace declarations
2022-01-07 08:58:19 -05:00
struct BfExteriorNode
{
BfSizedArray<BfNamespaceDeclaration*> mNamespaceNodes;
BfAstNode* mNode;
};
Initial checkin
2019-08-23 11:56:54 -07:00
BfIdentifierNode* BfIdentifierCast(BfAstNode* node);
BfAstNode* BfNodeToNonTemporary(BfAstNode* node);
Linux fixes
2020-09-29 08:53:36 -07:00
template <typename T>
class BfDeferredAstNodeSizedArray : public SizedArray<T, 8>
{
public:
BfAstNode* mParentNode;
BfSizedArray<ASTREF(T)>* mSizedArray;
BfAstAllocator* mAlloc;
public:
BfDeferredAstNodeSizedArray(BfAstNode* parentNode, BfSizedArray<ASTREF(T)>& arr, BfAstAllocator* alloc)
{
mParentNode = parentNode;
mSizedArray = &arr;
mAlloc = alloc;
}
~BfDeferredAstNodeSizedArray()
{
BfSizedArrayInitIndirect(*mSizedArray, *this, mAlloc);
if (!this->mSizedArray->IsEmpty())
{
int endPos = this->mSizedArray->back()->mSrcEnd;
if (endPos > this->mParentNode->mSrcEnd)
this->mParentNode->mSrcEnd = endPos;
}
}
};
Initial checkin
2019-08-23 11:56:54 -07:00
class BfStatement : public BfAstNode
{
public:
BF_AST_TYPE(BfStatement, BfAstNode);
BfTokenNode* mTrailingSemicolon;
// bool IsMissingSemicolon();
// {
// return mTrailingSemicolon == false;
// }
}; BF_AST_DECL(BfStatement, BfAstNode);
class BfExpression : public BfAstNode
{
public:
BF_AST_TYPE(BfExpression, BfAstNode);
// bool IsUsedAsStatement()
// {
// return mTrailingSemicolon != NULL;
// }
bool VerifyIsStatement(BfPassInstance* passInstance, bool ignoreError = false);
}; BF_AST_DECL(BfExpression, BfAstNode);
Better handling of autocomplete with tokens
2020-05-26 06:10:51 -07:00
class BfErrorNode : public BfExpression
{
public:
BF_AST_TYPE(BfErrorNode, BfExpression);
BfAstNode* mRefNode;
}; BF_AST_DECL(BfErrorNode, BfExpression);
Initial checkin
2019-08-23 11:56:54 -07:00
class BfExpressionStatement : public BfStatement
{
public:
BF_AST_TYPE(BfExpressionStatement, BfStatement);
BfExpression* mExpression;
}; BF_AST_DECL(BfExpressionStatement, BfStatement);
class BfBlockExtension : public BfAstNode
{
public:
BF_AST_TYPE(BfBlockExtension, BfAstNode);
BfSizedArray<ASTREF(BfAstNode*)> mChildArr;
}; BF_AST_DECL(BfBlockExtension, BfAstNode);
class BfBlock : public BfExpression
{
public:
struct Iterator
{
public:
ASTREF(BfAstNode*)* mPtr;
int mValsLeft;
public:
Iterator()
{
mPtr = NULL;
mValsLeft = 0;
}
Iterator(ASTREF(BfAstNode*)* ptr, int valsLeft)
{
mPtr = ptr;
mValsLeft = valsLeft;
if (mValsLeft == 0)
mPtr = NULL;
}
Iterator& operator++()
{
BF_ASSERT(mValsLeft >= 0);
mValsLeft--;
mPtr++;
if (mValsLeft == 0)
{
mPtr = NULL;
}
else
{
BfAstNode* curNode = *mPtr;
if (auto blockExpr = BfNodeDynCastExact<BfBlockExtension>(*mPtr))
{
BF_ASSERT(mValsLeft == 1);
mPtr = blockExpr->mChildArr.mVals;
mValsLeft = blockExpr->mChildArr.mSize;
}
}
return *this;
}
bool operator!=(const Iterator& itr) const
{
return itr.mPtr != mPtr;
}
bool operator==(const Iterator& itr) const
{
return itr.mPtr == mPtr;
}
ASTREF(BfAstNode*)& operator*()
{
return *mPtr;
}
BfAstNode* Get()
{
if (mValsLeft == 0)
return NULL;
return *mPtr;
}
bool IsLast()
{
return mValsLeft == 1;
}
};
public:
BF_AST_TYPE(BfBlock, BfExpression);
ASTREF(BfTokenNode*) mOpenBrace;
ASTREF(BfTokenNode*) mCloseBrace;
//BfDebugArray<BfAstNode*> mChildArr;
BfSizedArray<ASTREF(BfAstNode*)> mChildArr;
public:
using BfAstNode::Init;
void Init(const SizedArrayImpl<BfAstNode*>& vec, BfAstAllocator* alloc);
BfAstNode* GetFirst();
BfAstNode* GetLast();
int GetSize();
void SetSize(int wantSize);
// virtual bool IsMissingSemicolon() override
// {
// return false;
// }
ASTREF(BfAstNode*)& operator[](int idx)
{
#ifdef BF_USE_NEAR_NODE_REF
BfSizedArray<ASTREF(BfAstNode*)>* childArr = &mChildArr;
while (true)
{
if (idx < childArr->mSize - 1)
return childArr->mVals[idx];
if (idx == childArr->mSize - 1)
{
auto& checkNode = childArr->mVals[childArr->mSize - 1];
if (!checkNode->IsA<BfBlockExtension>())
return checkNode;
}
idx -= childArr->mSize - 1;
BfBlockExtension* blockExt = (BfBlockExtension*)(BfAstNode*)childArr->mVals[childArr->mSize - 1];
BF_ASSERT(blockExt->GetTypeId() == BfBlockExtension::TypeId);
childArr = &blockExt->mChildArr;
}
#else
return mChildArr.mVals[idx];
#endif
}
Iterator begin()
{
return Iterator(mChildArr.mVals, mChildArr.mSize);
}
Iterator end()
{
return Iterator(NULL, 0);
}
}; BF_AST_DECL(BfBlock, BfExpression);
Fixed string interpolation scoping, {{ }} escaping
2021-01-04 06:33:39 -08:00
class BfUnscopedBlock : public BfBlock
{
public:
BF_AST_TYPE(BfUnscopedBlock, BfBlock);
}; BF_AST_DECL(BfUnscopedBlock, BfBlock);
Initial checkin
2019-08-23 11:56:54 -07:00
class BfTypedValueExpression : public BfExpression
{
public:
BF_AST_TYPE(BfTypedValueExpression, BfExpression);
BfTypedValue mTypedValue;
BfAstNode* mRefNode;
public:
void Init(const BfTypedValue& typedValue)
{
mTypedValue = typedValue;
mRefNode = NULL;
#ifdef BF_AST_HAS_PARENT_MEMBER
mParent = NULL;
#endif
}
}; BF_AST_DECL(BfTypedValueExpression, BfExpression);
// Compound statements don't require semicolon termination
class BfCompoundStatement : public BfStatement
{
public:
BF_AST_TYPE(BfCompoundStatement, BfStatement);
}; BF_AST_DECL(BfCompoundStatement, BfStatement);
class BfLabelNode : public BfAstNode
{
public:
BF_AST_TYPE(BfLabelNode, BfAstNode);
BfIdentifierNode* mLabel;
BfTokenNode* mColonToken;
}; BF_AST_DECL(BfLabelNode, BfAstNode);
class BfLabelableStatement : public BfCompoundStatement
{
public:
BF_AST_TYPE(BfLabelableStatement, BfCompoundStatement);
BfLabelNode* mLabelNode;
}; BF_AST_DECL(BfLabelableStatement, BfCompoundStatement);
class BfLabeledBlock : public BfLabelableStatement
{
public:
BF_AST_TYPE(BfLabeledBlock, BfLabelableStatement);
BfBlock* mBlock;
}; BF_AST_DECL(BfLabeledBlock, BfLabelableStatement);
enum BfBinaryOp
{
BfBinaryOp_None,
BfBinaryOp_Add,
BfBinaryOp_Subtract,
BfBinaryOp_Multiply,
Added overflow operators &+, &-, &*
2021-07-15 06:01:17 -07:00
BfBinaryOp_OverflowAdd,
BfBinaryOp_OverflowSubtract,
BfBinaryOp_OverflowMultiply,
Initial checkin
2019-08-23 11:56:54 -07:00
BfBinaryOp_Divide,
BfBinaryOp_Modulus,
BfBinaryOp_BitwiseAnd,
BfBinaryOp_BitwiseOr,
BfBinaryOp_ExclusiveOr,
BfBinaryOp_LeftShift,
BfBinaryOp_RightShift,
BfBinaryOp_Equality,
Added concept of strict equality
2020-06-17 05:13:53 -07:00
BfBinaryOp_StrictEquality,
Initial checkin
2019-08-23 11:56:54 -07:00
BfBinaryOp_InEquality,
Added concept of strict equality
2020-06-17 05:13:53 -07:00
BfBinaryOp_StrictInEquality,
Initial checkin
2019-08-23 11:56:54 -07:00
BfBinaryOp_GreaterThan,
BfBinaryOp_LessThan,
BfBinaryOp_GreaterThanOrEqual,
BfBinaryOp_LessThanOrEqual,
BfBinaryOp_Compare,
BfBinaryOp_ConditionalAnd,
BfBinaryOp_ConditionalOr,
BfBinaryOp_NullCoalesce,
BfBinaryOp_Is,
Ranges (ie: `for (int a in 0..<count)` `for (int i in 1…10)`)
2021-07-21 07:48:37 -07:00
BfBinaryOp_As,
BfBinaryOp_Range,
BfBinaryOp_ClosedRange,
Initial checkin
2019-08-23 11:56:54 -07:00
};
enum BfAssignmentOp
{
BfAssignmentOp_None,
BfAssignmentOp_Assign,
BfAssignmentOp_Add,
BfAssignmentOp_Subtract,
BfAssignmentOp_Multiply,
Improvements to overflow arithmetic
2022-01-11 10:36:22 -05:00
BfAssignmentOp_OverflowAdd,
BfAssignmentOp_OverflowSubtract,
BfAssignmentOp_OverflowMultiply,
Initial checkin
2019-08-23 11:56:54 -07:00
BfAssignmentOp_Divide,
BfAssignmentOp_Modulus,
BfAssignmentOp_ShiftLeft,
BfAssignmentOp_ShiftRight,
BfAssignmentOp_BitwiseAnd,
BfAssignmentOp_BitwiseOr,
Operator '??=', '?' out discard
2020-09-07 15:24:42 -07:00
BfAssignmentOp_ExclusiveOr,
BfAssignmentOp_NullCoalesce
Initial checkin
2019-08-23 11:56:54 -07:00
};
enum BfUnaryOp
{
BfUnaryOp_None,
BfUnaryOp_AddressOf,
BfUnaryOp_Dereference,
BfUnaryOp_Negate,
BfUnaryOp_Not,
BfUnaryOp_Positive,
BfUnaryOp_InvertBits,
BfUnaryOp_Increment,
BfUnaryOp_Decrement,
BfUnaryOp_PostIncrement,
BfUnaryOp_PostDecrement,
Added nullable(T), Result<T> can use null conditionals
2020-04-27 15:09:10 -07:00
BfUnaryOp_NullConditional,
Initial checkin
2019-08-23 11:56:54 -07:00
BfUnaryOp_Ref,
BfUnaryOp_Out,
BfUnaryOp_Mut,
Argument cascades
2021-01-02 08:11:07 -08:00
BfUnaryOp_Params,
Ranges (ie: `for (int a in 0..<count)` `for (int i in 1…10)`)
2021-07-21 07:48:37 -07:00
BfUnaryOp_Cascade,
Enhanced ranges
2021-10-24 08:12:18 -07:00
BfUnaryOp_FromEnd,
Ranges (ie: `for (int a in 0..<count)` `for (int i in 1…10)`)
2021-07-21 07:48:37 -07:00
BfUnaryOp_PartialRangeUpTo,
BfUnaryOp_PartialRangeThrough,
BfUnaryOp_PartialRangeFrom,
Initial checkin
2019-08-23 11:56:54 -07:00
};
class BfTokenNode : public BfAstNode
{
public:
BF_AST_TYPE(BfTokenNode, BfAstNode);
}; BF_AST_DECL(BfTokenNode, BfAstNode);
class BfScopeNode : public BfAstNode
{
public:
BF_AST_TYPE(BfScopeNode, BfAstNode);
BfTokenNode* mScopeToken;
BfTokenNode* mColonToken;
BfAstNode* mTargetNode; // . : or identifier
Alloc allign attributes, lambda captures
2019-11-26 13:11:17 -08:00
BfAttributeDirective* mAttributes;
Initial checkin
2019-08-23 11:56:54 -07:00
}; BF_AST_DECL(BfScopeNode, BfAstNode);
class BfNewNode : public BfAstNode
{
public:
BF_AST_TYPE(BfNewNode, BfAstNode);
BfTokenNode* mNewToken;
BfTokenNode* mColonToken;
BfAstNode* mAllocNode; // Expression or BfScopedInvocationTarget
Alloc allign attributes, lambda captures
2019-11-26 13:11:17 -08:00
BfAttributeDirective* mAttributes;
Initial checkin
2019-08-23 11:56:54 -07:00
}; BF_AST_DECL(BfNewNode, BfAstNode);
enum BfCommentKind
{
Working on wrapping for formatter
2020-03-28 14:26:14 -07:00
BfCommentKind_Line,
BfCommentKind_Block,
BfCommentKind_Documentation_Block_Pre,
BfCommentKind_Documentation_Line_Pre,
BfCommentKind_Documentation_Block_Post,
BfCommentKind_Documentation_Line_Post,
Initial checkin
2019-08-23 11:56:54 -07:00
};
class BfCommentNode : public BfAstNode
{
public:
BF_AST_TYPE(BfCommentNode, BfAstNode);
BfCommentKind mCommentKind;
Added mouseover docs support
2020-09-25 08:50:39 -07:00
void GetDocString(StringImpl& docString)
{
ToString(docString);
for (int i = 0; i < (int)docString.length(); i++)
{
char c = docString[i];
if (c == '\n')
docString[i] = '\x3';
}
}
Initial checkin
2019-08-23 11:56:54 -07:00
}; BF_AST_DECL(BfCommentNode, BfAstNode);
class BfPreprocesorIgnoredSectionNode : public BfAstNode
{
public:
BF_AST_TYPE(BfPreprocesorIgnoredSectionNode, BfAstNode);
}; BF_AST_DECL(BfPreprocesorIgnoredSectionNode, BfAstNode);
class BfPreprocessorNode : public BfAstNode
{
public:
BF_AST_TYPE(BfPreprocessorNode, BfAstNode);
BfIdentifierNode* mCommand;
BfBlock* mArgument;
}; BF_AST_DECL(BfPreprocessorNode, BfAstNode);
class BfPreprocessorDefinedExpression : public BfExpression
{
public:
BF_AST_TYPE(BfPreprocessorDefinedExpression, BfExpression);
BfIdentifierNode* mIdentifier;
}; BF_AST_DECL(BfPreprocessorDefinedExpression, BfExpression);
class BfReplaceNode : public BfAstNode
{
public:
BF_AST_TYPE(BfReplaceNode, BfAstNode);
}; BF_AST_DECL(BfReplaceNode, BfAstNode);
s/seperate/separate
2021-01-29 23:52:58 -08:00
//TODO: Should we have a separate BfIdentifierExpression?
Initial checkin
2019-08-23 11:56:54 -07:00
class BfIdentifierNode : public BfExpression
{
public:
BF_AST_TYPE(BfIdentifierNode, BfExpression);
}; BF_AST_DECL(BfIdentifierNode, BfExpression);
class BfAttributedIdentifierNode : public BfExpression
{
public:
BF_AST_TYPE(BfAttributedIdentifierNode, BfExpression);
BfIdentifierNode* mIdentifier;
BfAttributeDirective* mAttributes;
}; BF_AST_DECL(BfAttributedIdentifierNode, BfExpression);
class BfQualifiedNameNode : public BfIdentifierNode
{
public:
BF_AST_TYPE(BfQualifiedNameNode, BfIdentifierNode);
ASTREF(BfIdentifierNode*) mLeft;
ASTREF(BfTokenNode*) mDot;
ASTREF(BfIdentifierNode*) mRight;
}; BF_AST_DECL(BfQualifiedNameNode, BfIdentifierNode);
class BfUsingDirective : public BfStatement
{
public:
BF_AST_TYPE(BfUsingDirective, BfStatement);
BfTokenNode* mUsingToken;
BfIdentifierNode* mNamespace;
}; BF_AST_DECL(BfUsingDirective, BfStatement);
Internal protection, 'using internal <type or namespace>;`
2020-10-14 11:33:41 -07:00
class BfUsingModDirective : public BfStatement
Initial checkin
2019-08-23 11:56:54 -07:00
{
public:
Internal protection, 'using internal <type or namespace>;`
2020-10-14 11:33:41 -07:00
BF_AST_TYPE(BfUsingModDirective, BfStatement);
Initial checkin
2019-08-23 11:56:54 -07:00
BfTokenNode* mUsingToken;
Internal protection, 'using internal <type or namespace>;`
2020-10-14 11:33:41 -07:00
BfTokenNode* mModToken;
Initial checkin
2019-08-23 11:56:54 -07:00
BfTypeReference* mTypeRef;
Internal protection, 'using internal <type or namespace>;`
2020-10-14 11:33:41 -07:00
}; BF_AST_DECL(BfUsingModDirective, BfStatement);
Initial checkin
2019-08-23 11:56:54 -07:00
class BfAttributeTargetSpecifier : public BfAstNode
{
public:
BF_AST_TYPE(BfAttributeTargetSpecifier, BfAstNode);
ASTREF(BfAstNode*) mTargetToken;
ASTREF(BfTokenNode*) mColonToken;
}; BF_AST_DECL(BfAttributeTargetSpecifier, BfAstNode);
class BfAttributeDirective : public BfAstNode
{
public:
BF_AST_TYPE(BfAttributeDirective, BfAstNode);
ASTREF(BfTokenNode*) mAttrOpenToken; // [ @ ,
ASTREF(BfTokenNode*) mAttrCloseToken;
Alloc allign attributes, lambda captures
2019-11-26 13:11:17 -08:00
ASTREF(BfAstNode*) mAttributeTargetSpecifier;
Initial checkin
2019-08-23 11:56:54 -07:00
ASTREF(BfTypeReference*) mAttributeTypeRef;
ASTREF(BfTokenNode*) mCtorOpenParen;
ASTREF(BfTokenNode*) mCtorCloseParen;
BfSizedArray<ASTREF(BfExpression*)> mArguments;
BfSizedArray<ASTREF(BfTokenNode*)> mCommas;
ASTREF(BfAttributeDirective*) mNextAttribute;
public:
bool Contains(const StringImpl& findName);
}; BF_AST_DECL(BfAttributeDirective, BfAstNode);
class BfNamespaceDeclaration : public BfAstNode
{
public:
BF_AST_TYPE(BfNamespaceDeclaration, BfAstNode);
BfTokenNode* mNamespaceNode;
BfIdentifierNode* mNameNode;
BfBlock* mBlock;
}; BF_AST_DECL(BfNamespaceDeclaration, BfAstNode);
class BfBinaryOperatorExpression : public BfExpression
{
public:
BF_AST_TYPE(BfBinaryOperatorExpression, BfExpression);
BfBinaryOp mOp;
ASTREF(BfTokenNode*) mOpToken;
ASTREF(BfExpression*) mLeft;
ASTREF(BfExpression*) mRight;
}; BF_AST_DECL(BfBinaryOperatorExpression, BfExpression);
class BfConditionalExpression : public BfExpression
{
public:
BF_AST_TYPE(BfConditionalExpression, BfExpression);
BfExpression* mConditionExpression;
BfTokenNode* mQuestionToken;
BfExpression* mTrueExpression;
BfTokenNode* mColonToken;
BfExpression* mFalseExpression;
}; BF_AST_DECL(BfConditionalExpression, BfExpression);
class BfAssignmentExpression : public BfExpression
{
public:
BF_AST_TYPE(BfAssignmentExpression, BfExpression);
BfAssignmentOp mOp;
ASTREF(BfTokenNode*) mOpToken;
ASTREF(BfExpression*) mLeft;
ASTREF(BfExpression*) mRight;
}; BF_AST_DECL(BfAssignmentExpression, BfExpression);
class BfMethodBoundExpression : public BfExpression
{
public:
BF_AST_TYPE(BfMethodBoundExpression, BfExpression);
}; BF_AST_DECL(BfMethodBoundExpression, BfExpression);
class BfIndexerExpression : public BfMethodBoundExpression
{
public:
BF_AST_TYPE(BfIndexerExpression, BfMethodBoundExpression);
BfExpression* mTarget;
BfTokenNode* mOpenBracket;
BfTokenNode* mCloseBracket;
BfSizedArray<ASTREF(BfExpression*)> mArguments;
BfSizedArray<ASTREF(BfTokenNode*)> mCommas;
}; BF_AST_DECL(BfIndexerExpression, BfMethodBoundExpression);
class BfMemberReferenceExpression : public BfExpression
{
public:
BF_AST_TYPE(BfMemberReferenceExpression, BfExpression);
ASTREF(BfTokenNode*) mDotToken;
ASTREF(BfAstNode*) mTarget; // Can be expression or typeRef
ASTREF(BfAstNode*) mMemberName; // Either or BfIdentiferNode or a BfLiteralNode (for tuple "name.0" type lookups)
}; BF_AST_DECL(BfMemberReferenceExpression, BfExpression);
class BfUnaryOperatorExpression : public BfExpression
{
public:
BF_AST_TYPE(BfUnaryOperatorExpression, BfExpression);
BfUnaryOp mOp;
ASTREF(BfTokenNode*) mOpToken;
ASTREF(BfExpression*) mExpression;
}; BF_AST_DECL(BfUnaryOperatorExpression, BfExpression);
class BfMixinExpression : public BfExpression
{
public:
BF_AST_TYPE(BfMixinExpression, BfExpression);
}; BF_AST_DECL(BfMixinExpression, BfExpression);
class BfThisExpression : public BfExpression
{
public:
BF_AST_TYPE(BfThisExpression, BfExpression);
}; BF_AST_DECL(BfThisExpression, BfExpression);
class BfBaseExpression : public BfExpression
{
public:
BF_AST_TYPE(BfBaseExpression, BfExpression);
}; BF_AST_DECL(BfBaseExpression, BfExpression);
class BfLiteralExpression : public BfExpression
{
public:
BF_AST_TYPE(BfLiteralExpression, BfExpression);
BfVariant mValue;
}; BF_AST_DECL(BfLiteralExpression, BfExpression);
String interpolation
2020-11-11 05:46:52 -08:00
class BfStringInterpolationExpression : public BfExpression
{
public:
BF_AST_TYPE(BfStringInterpolationExpression, BfExpression);
BfAstNode* mAllocNode;
String* mString;
BfSizedArray<ASTREF(BfBlock*)> mExpressions;
}; BF_AST_DECL(BfStringInterpolationExpression, BfExpression);
Initializer expressions
2020-06-18 06:12:14 -07:00
class BfInitializerExpression : public BfExpression
{
public:
BF_AST_TYPE(BfInitializerExpression, BfExpression);
Added '.{ x = 1, y = 2}' initializer expression
2021-01-02 06:14:29 -08:00
BfAstNode* mTarget;
Initializer expressions
2020-06-18 06:12:14 -07:00
BfTokenNode* mOpenBrace;
BfSizedArray<BfExpression*> mValues;
BfSizedArray<BfTokenNode*> mCommas;
BfTokenNode* mCloseBrace;
}; BF_AST_DECL(BfInitializerExpression, BfExpression);
Initial checkin
2019-08-23 11:56:54 -07:00
class BfCollectionInitializerExpression : public BfExpression
{
public:
BF_AST_TYPE(BfCollectionInitializerExpression, BfExpression);
BfTokenNode* mOpenBrace;
BfSizedArray<ASTREF(BfExpression*)> mValues;
BfSizedArray<ASTREF(BfTokenNode*)> mCommas;
BfTokenNode* mCloseBrace;
}; BF_AST_DECL(BfCollectionInitializerExpression, BfExpression);
class BfSizedArrayCreateExpression : public BfExpression
{
public:
BF_AST_TYPE(BfSizedArrayCreateExpression, BfExpression);
BfArrayTypeRef* mTypeRef;
BfCollectionInitializerExpression* mInitializer;
}; BF_AST_DECL(BfSizedArrayCreateExpression, BfExpression);
class BfParenthesizedExpression : public BfExpression
{
public:
BF_AST_TYPE(BfParenthesizedExpression, BfExpression);
BfTokenNode* mOpenParen;
BfExpression* mExpression;
BfTokenNode* mCloseParen;
}; BF_AST_DECL(BfParenthesizedExpression, BfExpression);
class BfTupleNameNode : public BfAstNode
{
public:
BF_AST_TYPE(BfTupleNameNode, BfAstNode);
BfIdentifierNode* mNameNode;
BfTokenNode* mColonToken;
}; BF_AST_DECL(BfTupleNameNode, BfAstNode);
class BfTupleExpression : public BfExpression
{
public:
BF_AST_TYPE(BfTupleExpression, BfExpression);
BfTokenNode* mOpenParen;
BfSizedArray<ASTREF(BfTupleNameNode*)> mNames;
BfSizedArray<ASTREF(BfExpression*)> mValues;
BfSizedArray<ASTREF(BfTokenNode*)> mCommas;
ASTREF(BfTokenNode*) mCloseParen;
}; BF_AST_DECL(BfTupleExpression, BfExpression);
class BfWhenExpression : public BfExpression
{
public:
BF_AST_TYPE(BfWhenExpression, BfExpression);
BfTokenNode* mWhenToken;
BfExpression* mExpression;
}; BF_AST_DECL(BfWhenExpression, BfExpression);
class BfEnumCaseBindExpression : public BfExpression
{
public:
BF_AST_TYPE(BfEnumCaseBindExpression, BfExpression);
BfTokenNode* mBindToken; // Either 'var' or 'let'
BfAstNode* mEnumMemberExpr; // Either a BfMemberReferenceExpression or a BfIdentifierNode
BfTupleExpression* mBindNames;
}; BF_AST_DECL(BfEnumCaseBindExpression, BfExpression);
class BfCaseExpression : public BfExpression
{
public:
BF_AST_TYPE(BfCaseExpression, BfExpression);
BfTokenNode* mCaseToken;
BfExpression* mCaseExpression;
BfTokenNode* mEqualsNode;
BfExpression* mValueExpression;
}; BF_AST_DECL(BfCaseExpression, BfExpression);
class BfSwitchCase : public BfAstNode
{
public:
BF_AST_TYPE(BfSwitchCase, BfAstNode);
BfTokenNode* mCaseToken;
BfSizedArray<ASTREF(BfExpression*)> mCaseExpressions;
BfSizedArray<ASTREF(BfTokenNode*)> mCaseCommas;
BfTokenNode* mColonToken;
BfBlock* mCodeBlock; // May or may not have braces set
BfTokenNode* mEndingToken; // Null, Fallthrough, or Break
BfTokenNode* mEndingSemicolonToken;
}; BF_AST_DECL(BfSwitchCase, BfAstNode);
class BfSwitchStatement : public BfLabelableStatement
{
public:
BF_AST_TYPE(BfSwitchStatement, BfLabelableStatement);
BfTokenNode* mSwitchToken;
BfTokenNode* mOpenParen;
BfExpression* mSwitchValue;
BfTokenNode* mCloseParen;
BfTokenNode* mOpenBrace;
BfSizedArray<ASTREF(BfSwitchCase*)> mSwitchCases;
BfSwitchCase* mDefaultCase;
BfTokenNode* mCloseBrace;
}; BF_AST_DECL(BfSwitchStatement, BfLabelableStatement);
class BfIfStatement : public BfLabelableStatement
{
public:
BF_AST_TYPE(BfIfStatement, BfLabelableStatement);
BfTokenNode* mIfToken;
BfTokenNode* mOpenParen;
BfExpression* mCondition;
BfTokenNode* mCloseParen;
BfAstNode* mTrueStatement;
BfTokenNode* mElseToken;
BfAstNode* mFalseStatement;
}; BF_AST_DECL(BfIfStatement, BfLabelableStatement);
class BfEmptyStatement : public BfStatement
{
public:
BF_AST_TYPE(BfEmptyStatement, BfStatement);
}; BF_AST_DECL(BfEmptyStatement, BfStatement);
class BfRootNode : public BfBlock
{
public:
BF_AST_TYPE(BfRootNode, BfBlock);
}; BF_AST_DECL(BfRootNode, BfBlock);
class BfGenericConstraintsDeclaration;
class BfTypeDeclaration : public BfAstNode
{
public:
BF_AST_TYPE(BfTypeDeclaration, BfAstNode);
BfCommentNode* mDocumentation;
BfAttributeDirective* mAttributes;
BfTokenNode* mAbstractSpecifier;
Removed 'internal' protection - it's all about [Friend] now
2020-03-09 06:34:16 -07:00
BfTokenNode* mSealedSpecifier;
Added 'protected internal' protection
2020-12-07 07:53:12 -08:00
BfAstNode* mProtectionSpecifier;
Initial checkin
2019-08-23 11:56:54 -07:00
BfTokenNode* mStaticSpecifier;
BfTokenNode* mPartialSpecifier;
BfTokenNode* mTypeNode;
BfIdentifierNode* mNameNode;
BfAstNode* mDefineNode;
Added auto-constructors (ie: 'struct Vec : this(float x, float y);')
2021-01-02 12:54:05 -08:00
BfAutoConstructorDeclaration* mAutoCtor;
Initial checkin
2019-08-23 11:56:54 -07:00
BfGenericParamsDeclaration* mGenericParams;
BfGenericConstraintsDeclaration* mGenericConstraintsDeclaration;
bool mIgnoreDeclaration;
BfTokenNode* mColonToken;
BfSizedArray<ASTREF(BfTypeReference*)> mBaseClasses;
BfSizedArray<ASTREF(BfAstNode*)> mBaseClassCommas;
}; BF_AST_DECL(BfTypeDeclaration, BfAstNode);
class BfTypeAliasDeclaration : public BfTypeDeclaration
{
public:
BF_AST_TYPE(BfTypeAliasDeclaration, BfTypeDeclaration);
BfTokenNode* mEqualsToken;
BfTypeReference* mAliasToType;
BfTokenNode* mEndSemicolon;
}; BF_AST_DECL(BfTypeAliasDeclaration, BfTypeDeclaration);
class BfTypeReference : public BfAstNode
{
public:
BF_AST_TYPE(BfTypeReference, BfAstNode);
bool IsNamedTypeReference();
bool IsTypeDefTypeReference();
fix builtin attrib matching
2021-05-26 20:23:12 +02:00
String ToCleanAttributeString();
Initial checkin
2019-08-23 11:56:54 -07:00
}; BF_AST_DECL(BfTypeReference, BfAstNode);
class BfDirectTypeReference : public BfTypeReference
{
public:
BF_AST_TYPE(BfDirectTypeReference, BfAstNode);
BfType* mType;
void Init(BfType* type)
{
mType = type;
InitEmpty();
}
}; BF_AST_DECL(BfDirectTypeReference, BfAstNode);
class BfDirectTypeDefReference : public BfTypeReference
{
public:
BF_AST_TYPE(BfDirectTypeDefReference, BfTypeReference);
BfTypeDef* mTypeDef;
void Init(BfTypeDef* type)
{
mTypeDef = type;
InitEmpty();
}
}; BF_AST_DECL(BfDirectTypeDefReference, BfTypeReference);
// class BfTypeDefTypeReference : public BfTypeReference
// {
// public:
// BF_AST_TYPE(BfTypeDefTypeReference, BfTypeReference);
//
// BfTypeDef* mTypeDef;
// }; BF_AST_DECL(BfTypeDefTypeReference, BfTypeReference);
class BfDirectStrTypeReference : public BfTypeReference
{
public:
BF_AST_TYPE(BfDirectStrTypeReference, BfTypeReference);
String mTypeName;
using BfAstNode::Init;
void Init(const StringImpl& str)
{
mTypeName = str;
#ifdef BF_AST_HAS_PARENT_MEMBER
mParent = NULL;
#endif
InitEmpty();
//mTypeDef = NULL;
}
}; BF_AST_DECL(BfDirectStrTypeReference, BfTypeReference);
class BfDotTypeReference : public BfTypeReference
{
public:
BF_AST_TYPE(BfDotTypeReference, BfTypeReference);
BfTokenNode* mDotToken;
}; BF_AST_DECL(BfDotTypeReference, BfTypeReference);
class BfVarTypeReference : public BfTypeReference
{
public:
BF_AST_TYPE(BfVarTypeReference, BfTypeReference);
BfTokenNode* mVarToken;
}; BF_AST_DECL(BfVarTypeReference, BfTypeReference);
class BfVarRefTypeReference : public BfTypeReference
{
public:
BF_AST_TYPE(BfVarRefTypeReference, BfTypeReference);
BfTokenNode* mVarToken;
BfTokenNode* mRefToken;
}; BF_AST_DECL(BfVarRefTypeReference, BfTypeReference);
class BfLetTypeReference : public BfTypeReference
{
public:
BF_AST_TYPE(BfLetTypeReference, BfTypeReference);
BfTokenNode* mLetToken;
}; BF_AST_DECL(BfLetTypeReference, BfTypeReference);
class BfWildcardTypeReference : public BfTypeReference
{
public:
BF_AST_TYPE(BfWildcardTypeReference, BfTypeReference);
BfTokenNode* mWildcardToken;
}; BF_AST_DECL(BfWildcardTypeReference, BfTypeReference);
class BfQualifiedTypeReference : public BfTypeReference
{
public:
BF_AST_TYPE(BfQualifiedTypeReference, BfTypeReference);
ASTREF(BfTypeReference*) mLeft;
ASTREF(BfTokenNode*) mDot;
ASTREF(BfTypeReference*) mRight;
}; BF_AST_DECL(BfQualifiedTypeReference, BfTypeReference);
class BfResolvedTypeReference : public BfTypeReference
{
public:
BF_AST_TYPE(BfResolvedTypeReference, BfTypeReference);
BfType* mType;
}; BF_AST_DECL(BfResolvedTypeReference, BfTypeReference);
// "Named" means no wrapping (ie: not array, not generic instance, not pointer, etc
class BfNamedTypeReference : public BfTypeReference
{
public:
BF_AST_TYPE(BfNamedTypeReference, BfTypeReference);
ASTREF(BfIdentifierNode*) mNameNode;
}; BF_AST_DECL(BfNamedTypeReference, BfTypeReference);
class BfElementedTypeRef : public BfTypeReference
{
public:
BF_AST_TYPE(BfElementedTypeRef, BfTypeReference);
ASTREF(BfTypeReference*) mElementType;
}; BF_AST_DECL(BfElementedTypeRef, BfTypeReference);
Added nullable(T), Result<T> can use null conditionals
2020-04-27 15:09:10 -07:00
class BfModifiedTypeRef : public BfElementedTypeRef
Initial checkin
2019-08-23 11:56:54 -07:00
{
public:
Added nullable(T), Result<T> can use null conditionals
2020-04-27 15:09:10 -07:00
BF_AST_TYPE(BfModifiedTypeRef, BfElementedTypeRef);
Initial checkin
2019-08-23 11:56:54 -07:00
BfTokenNode* mRetTypeToken;
BfTokenNode* mOpenParen;
BfTokenNode* mCloseParen;
Added nullable(T), Result<T> can use null conditionals
2020-04-27 15:09:10 -07:00
}; BF_AST_DECL(BfModifiedTypeRef, BfElementedTypeRef);
Initial checkin
2019-08-23 11:56:54 -07:00
class BfArrayTypeRef : public BfElementedTypeRef
{
public:
BF_AST_TYPE(BfArrayTypeRef, BfElementedTypeRef);
int mDimensions;
BfTokenNode* mOpenBracket;
BfSizedArray<ASTREF(BfAstNode*)> mParams; // Either commas or constant size expression
BfTokenNode* mCloseBracket;
Fixed sized array size inference, primitive type handling in ir
2020-12-24 06:58:38 -08:00
bool IsInferredSize()
{
if (mParams.mSize > 0)
return BfNodeIsA<BfUninitializedExpression>(mParams[0]);
return false;
}
Initial checkin
2019-08-23 11:56:54 -07:00
}; BF_AST_DECL(BfArrayTypeRef, BfElementedTypeRef);
class BfNullableTypeRef : public BfElementedTypeRef
{
public:
BF_AST_TYPE(BfNullableTypeRef, BfElementedTypeRef);
BfTokenNode* mQuestionToken;
}; BF_AST_DECL(BfNullableTypeRef, BfElementedTypeRef);
class BfGenericInstanceTypeRef : public BfElementedTypeRef
{
public:
BF_AST_TYPE(BfGenericInstanceTypeRef, BfElementedTypeRef);
BfTokenNode* mOpenChevron;
Reflect Filtered, extension attribs fix, generic arg BfAstNode
2022-02-04 12:00:43 -05:00
BfSizedArray<BfAstNode*> mGenericArguments;
Initial checkin
2019-08-23 11:56:54 -07:00
BfSizedArray<ASTREF(BfAstNode*)> mCommas;
BfTokenNode* mCloseChevron;
int GetGenericArgCount()
{
if (!mCommas.empty())
return (int)mCommas.size() + 1;
return std::max(1, (int)mGenericArguments.size());
}
}; BF_AST_DECL(BfGenericInstanceTypeRef, BfElementedTypeRef);
class BfTupleTypeRef : public BfElementedTypeRef
{
public:
BF_AST_TYPE(BfTupleTypeRef, BfElementedTypeRef);
ASTREF(BfTokenNode*) mOpenParen;
BfSizedArray<ASTREF(BfTypeReference*)> mFieldTypes;
BfSizedArray<ASTREF(BfIdentifierNode*)> mFieldNames;
BfSizedArray<ASTREF(BfAstNode*)> mCommas;
ASTREF(BfTokenNode*) mCloseParen;
int GetGenericArgCount()
{
if (!mCommas.empty())
return (int)mCommas.size() + 1;
return std::max(1, (int)mFieldTypes.size());
}
}; BF_AST_DECL(BfTupleTypeRef, BfElementedTypeRef);
class BfDelegateTypeRef : public BfTypeReference
{
public:
BF_AST_TYPE(BfDelegateTypeRef, BfTypeReference);
BfTokenNode* mTypeToken; // Delegate or Function
BfAttributeDirective* mAttributes;
BfTypeReference* mReturnType;
BfAstNode* mOpenParen;
BfSizedArray<BfParameterDeclaration*> mParams;
BfSizedArray<BfTokenNode*> mCommas;
BfAstNode* mCloseParen;
}; BF_AST_DECL(BfDelegateTypeRef, BfTypeReference);
Added comptype
2021-01-15 14:28:21 -08:00
class BfExprModTypeRef : public BfTypeReference
Initial checkin
2019-08-23 11:56:54 -07:00
{
public:
Added comptype
2021-01-15 14:28:21 -08:00
BF_AST_TYPE(BfExprModTypeRef, BfTypeReference);
Initial checkin
2019-08-23 11:56:54 -07:00
BfTokenNode* mToken;
BfTokenNode* mOpenParen;
BfExpression* mTarget;
BfTokenNode* mCloseParen;
Added comptype
2021-01-15 14:28:21 -08:00
}; BF_AST_DECL(BfExprModTypeRef, BfTypeReference);
Initial checkin
2019-08-23 11:56:54 -07:00
enum BfGenericParamKind
{
BfGenericParamKind_Type,
BfGenericParamKind_Method
};
class BfGenericParamTypeRef : public BfTypeReference
{
public:
BF_AST_TYPE(BfGenericParamTypeRef, BfTypeReference);
BfGenericParamKind mGenericParamKind;
int mGenericParamIdx;
}; BF_AST_DECL(BfGenericParamTypeRef, BfTypeReference);
class BfPointerTypeRef : public BfElementedTypeRef
{
public:
BF_AST_TYPE(BfPointerTypeRef, BfElementedTypeRef);
BfTokenNode* mStarNode;
}; BF_AST_DECL(BfPointerTypeRef, BfElementedTypeRef);
class BfConstTypeRef : public BfElementedTypeRef
{
public:
BF_AST_TYPE(BfConstTypeRef, BfElementedTypeRef);
BfTokenNode* mConstToken;
}; BF_AST_DECL(BfConstTypeRef, BfElementedTypeRef);
class BfConstExprTypeRef : public BfTypeReference
{
public:
BF_AST_TYPE(BfConstExprTypeRef, BfTypeReference);
BfTokenNode* mConstToken;
BfExpression* mConstExpr;
}; BF_AST_DECL(BfConstExprTypeRef, BfTypeReference);
class BfUnsignedTypeRef : public BfElementedTypeRef
{
public:
BF_AST_TYPE(BfUnsignedTypeRef, BfElementedTypeRef);
BfTokenNode* mUnsignedToken;
}; BF_AST_DECL(BfUnsignedTypeRef, BfElementedTypeRef);
class BfRefTypeRef : public BfElementedTypeRef
{
public:
BF_AST_TYPE(BfRefTypeRef, BfElementedTypeRef);
BfTokenNode* mRefToken;
}; BF_AST_DECL(BfRefTypeRef, BfElementedTypeRef);
class BfTypeAttrExpression : public BfExpression
{
public:
BF_AST_TYPE(BfTypeAttrExpression, BfExpression);
BfTokenNode* mToken;
BfTokenNode* mOpenParen;
BfTypeReference* mTypeRef;
BfTokenNode* mCloseParen;
}; BF_AST_DECL(BfTypeAttrExpression, BfExpression);
class BfTypeOfExpression : public BfTypeAttrExpression
{
public:
BF_AST_TYPE(BfTypeOfExpression, BfTypeAttrExpression);
}; BF_AST_DECL(BfTypeOfExpression, BfTypeAttrExpression);
class BfSizeOfExpression : public BfTypeAttrExpression
{
public:
BF_AST_TYPE(BfSizeOfExpression, BfTypeAttrExpression);
}; BF_AST_DECL(BfSizeOfExpression, BfTypeAttrExpression);
class BfAlignOfExpression : public BfTypeAttrExpression
{
public:
offsetof
2021-09-10 14:21:25 -07:00
BF_AST_TYPE(BfAlignOfExpression, BfTypeAttrExpression);
Initial checkin
2019-08-23 11:56:54 -07:00
}; BF_AST_DECL(BfAlignOfExpression, BfTypeAttrExpression);
class BfStrideOfExpression : public BfTypeAttrExpression
{
public:
BF_AST_TYPE(BfStrideOfExpression, BfTypeAttrExpression);
}; BF_AST_DECL(BfStrideOfExpression, BfTypeAttrExpression);
offsetof
2021-09-10 14:21:25 -07:00
class BfOffsetOfExpression : public BfTypeAttrExpression
{
public:
BF_AST_TYPE(BfOffsetOfExpression, BfTypeAttrExpression);
BfTokenNode* mCommaToken;
BfIdentifierNode* mMemberName;
}; BF_AST_DECL(BfOffsetOfExpression, BfTypeAttrExpression);
Initial checkin
2019-08-23 11:56:54 -07:00
class BfDefaultExpression : public BfExpression
{
public:
BF_AST_TYPE(BfDefaultExpression, BfExpression);
BfTokenNode* mDefaultToken;
BfTokenNode* mOpenParen;
BfTypeReference* mTypeRef;
BfTokenNode* mCloseParen;
}; BF_AST_DECL(BfDefaultExpression, BfExpression);
class BfUninitializedExpression : public BfExpression
{
public:
BF_AST_TYPE(BfUninitializedExpression, BfExpression);
BfTokenNode* mQuestionToken;
}; BF_AST_DECL(BfUninitializedExpression, BfExpression);
class BfCheckTypeExpression : public BfExpression
{
public:
BF_AST_TYPE(BfCheckTypeExpression, BfExpression);
BfExpression* mTarget;
BfTokenNode* mIsToken;
BfTypeReference* mTypeRef;
}; BF_AST_DECL(BfCheckTypeExpression, BfExpression);
class BfDynamicCastExpression : public BfExpression
{
public:
BF_AST_TYPE(BfDynamicCastExpression, BfExpression);
BfExpression* mTarget;
BfTokenNode* mAsToken;
BfTypeReference* mTypeRef;
}; BF_AST_DECL(BfDynamicCastExpression, BfExpression);
class BfCastExpression : public BfUnaryOperatorExpression
{
public:
BF_AST_TYPE(BfCastExpression, BfUnaryOperatorExpression);
BfTokenNode* mOpenParen;
BfTypeReference* mTypeRef;
BfTokenNode* mCloseParen;
}; BF_AST_DECL(BfCastExpression, BfUnaryOperatorExpression);
class BfDelegateBindExpression : public BfMethodBoundExpression
{
public:
BF_AST_TYPE(BfDelegateBindExpression, BfMethodBoundExpression);
BfAstNode* mNewToken;
BfTokenNode* mFatArrowToken;
BfExpression* mTarget;
BfGenericArgumentsNode* mGenericArgs;
}; BF_AST_DECL(BfDelegateBindExpression, BfMethodBoundExpression);
class BfLambdaBindExpression : public BfExpression
{
public:
BF_AST_TYPE(BfLambdaBindExpression, BfExpression);
Alloc allign attributes, lambda captures
2019-11-26 13:11:17 -08:00
BfAstNode* mNewToken;
Initial checkin
2019-08-23 11:56:54 -07:00
BfTokenNode* mOpenParen;
BfTokenNode* mCloseParen;
BfSizedArray<ASTREF(BfIdentifierNode*)> mParams;
BfSizedArray<ASTREF(BfTokenNode*)> mCommas;
Enhanced expression-body support
2020-05-08 11:11:01 -07:00
BfTokenNode* mFatArrowToken;
Initial checkin
2019-08-23 11:56:54 -07:00
BfAstNode* mBody; // Either expression or block
BfFieldDtorDeclaration* mDtor;
}; BF_AST_DECL(BfLambdaBindExpression, BfExpression);
class BfAttributedExpression : public BfExpression
{
public:
BF_AST_TYPE(BfAttributedExpression, BfExpression);
BfAttributeDirective* mAttributes;
BfExpression* mExpression;
}; BF_AST_DECL(BfAttributedExpression, BfExpression);
Added [IgnoreErrors] block attribute
2020-08-16 08:33:51 -07:00
class BfAttributedStatement : public BfStatement
{
public:
BF_AST_TYPE(BfAttributedStatement, BfStatement);
BfAttributeDirective* mAttributes;
BfAstNode* mStatement;
}; BF_AST_DECL(BfAttributedStatement, BfStatement);
Initial checkin
2019-08-23 11:56:54 -07:00
class BfObjectCreateExpression : public BfMethodBoundExpression
{
public:
BF_AST_TYPE(BfObjectCreateExpression, BfMethodBoundExpression);
BfAstNode* mNewNode;
BfTokenNode* mStarToken;
BfTypeReference* mTypeRef;
BfTokenNode* mOpenToken;
BfTokenNode* mCloseToken;
BfSizedArray<BfExpression*> mArguments;
Initializer expressions
2020-06-18 06:12:14 -07:00
BfSizedArray<BfTokenNode*> mCommas;
Initial checkin
2019-08-23 11:56:54 -07:00
}; BF_AST_DECL(BfObjectCreateExpression, BfMethodBoundExpression);
class BfBoxExpression : public BfExpression
{
public:
BF_AST_TYPE(BfBoxExpression, BfExpression);
BfAstNode* mAllocNode;
BfTokenNode* mBoxToken;
BfExpression* mExpression;
}; BF_AST_DECL(BfBoxExpression, BfExpression);
class BfDeleteStatement : public BfStatement
{
public:
BF_AST_TYPE(BfDeleteStatement, BfStatement);
BfTokenNode* mDeleteToken;
BfTokenNode* mTargetTypeToken; // colon token
BfAstNode* mAllocExpr;
Removed 'internal' protection - it's all about [Friend] now
2020-03-09 06:34:16 -07:00
BfAttributeDirective* mAttributes;
Initial checkin
2019-08-23 11:56:54 -07:00
BfExpression* mExpression;
}; BF_AST_DECL(BfDeleteStatement, BfStatement);
class BfDeferBindNode : public BfAstNode
{
public:
BF_AST_TYPE(BfDeferBindNode, BfAstNode);
BfTokenNode* mOpenBracket;
BfTokenNode* mCloseBracket;
BfSizedArray<ASTREF(BfIdentifierNode*)> mParams;
BfSizedArray<ASTREF(BfTokenNode*)> mCommas;
}; BF_AST_DECL(BfDeferBindNode, BfAstNode);
class BfDeferStatement : public BfStatement
{
public:
BF_AST_TYPE(BfDeferStatement, BfStatement);
BfTokenNode* mDeferToken;
BfTokenNode* mColonToken;
BfAstNode* mScopeName; // :, mixin, or identifier
BfDeferBindNode* mBind;
//Legacy compat, remove
BfTokenNode* mOpenParen;
BfTokenNode* mScopeToken;
BfTokenNode* mCloseParen;
BfAstNode* mTargetNode;
// virtual bool IsMissingSemicolon() override
// {
// return BfNodeDynCastExact<BfBlock>(mTargetNode) == NULL;
// }
}; BF_AST_DECL(BfDeferStatement, BfStatement);
class BfThrowStatement : public BfStatement
{
public:
BF_AST_TYPE(BfThrowStatement, BfStatement);
BfTokenNode* mThrowToken;
BfExpression* mExpression;
}; BF_AST_DECL(BfThrowStatement, BfStatement);
class BfScopedInvocationTarget : public BfAstNode
{
public:
BF_AST_TYPE(BfScopedInvocationTarget, BfAstNode);
BfAstNode* mTarget;
BfTokenNode* mColonToken;
BfAstNode* mScopeName; // :, mixin, or identifier
}; BF_AST_DECL(BfScopedInvocationTarget, BfAstNode);
class BfInvocationExpression : public BfMethodBoundExpression
{
public:
BF_AST_TYPE(BfInvocationExpression, BfMethodBoundExpression);
ASTREF(BfAstNode*) mTarget;
ASTREF(BfTokenNode*) mOpenParen;
ASTREF(BfTokenNode*) mCloseParen;
ASTREF(BfGenericArgumentsNode*) mGenericArgs;
BfSizedArray<ASTREF(BfExpression*)> mArguments;
BfSizedArray<ASTREF(BfTokenNode*)> mCommas;
}; BF_AST_DECL(BfInvocationExpression, BfMethodBoundExpression);
class BfEnumCaseDeclaration : public BfAstNode
{
public:
BF_AST_TYPE(BfEnumCaseDeclaration, BfAstNode);
ASTREF(BfTokenNode*) mCaseToken;
BfSizedArray<ASTREF(BfFieldDeclaration*)> mEntries;
BfSizedArray<ASTREF(BfTokenNode*)> mCommas;
}; BF_AST_DECL(BfEnumCaseDeclaration, BfAstNode);
class BfMemberDeclaration : public BfAstNode
{
public:
BF_AST_TYPE(BfMemberDeclaration, BfAstNode);
Removed 'internal' protection - it's all about [Friend] now
2020-03-09 06:34:16 -07:00
BfAttributeDirective* mAttributes;
Added 'protected internal' protection
2020-12-07 07:53:12 -08:00
BfAstNode* mProtectionSpecifier;
Initial checkin
2019-08-23 11:56:54 -07:00
BfTokenNode* mStaticSpecifier;
BfTokenNode* mReadOnlySpecifier; // Also stores 'inline'
}; BF_AST_DECL(BfMemberDeclaration, BfAstNode);
class BfVariableDeclaration : public BfExpression
{
public:
BF_AST_TYPE(BfVariableDeclaration, BfExpression);
ASTREF(BfAttributeDirective*) mAttributes;
ASTREF(BfTokenNode*) mModSpecifier;
ASTREF(BfTypeReference*) mTypeRef;
ASTREF(BfTokenNode*) mPrecedingComma;
BfAstNode* mNameNode; // Either BfIdentifierNode or BfTupleExpression
ASTREF(BfTokenNode*) mEqualsNode;
ASTREF(BfExpression*) mInitializer;
}; BF_AST_DECL(BfVariableDeclaration, BfExpression);
class BfLocalMethodDeclaration : public BfCompoundStatement
{
public:
BF_AST_TYPE(BfLocalMethodDeclaration, BfCompoundStatement);
BfMethodDeclaration* mMethodDeclaration;
}; BF_AST_DECL(BfLocalMethodDeclaration, BfCompoundStatement);
class BfParameterDeclaration : public BfVariableDeclaration
{
public:
BF_AST_TYPE(BfParameterDeclaration, BfVariableDeclaration);
BfTokenNode* mModToken; // 'Params'
}; BF_AST_DECL(BfParameterDeclaration, BfVariableDeclaration);
class BfGenericParamsDeclaration : public BfAstNode
{
public:
BF_AST_TYPE(BfGenericParamsDeclaration, BfAstNode);
ASTREF(BfTokenNode*) mOpenChevron;
BfSizedArray<ASTREF(BfIdentifierNode*)> mGenericParams;
BfSizedArray<ASTREF(BfAstNode*)> mCommas;
ASTREF(BfTokenNode*) mCloseChevron;
}; BF_AST_DECL(BfGenericParamsDeclaration, BfAstNode);
class BfGenericArgumentsNode : public BfAstNode
{
public:
BF_AST_TYPE(BfGenericArgumentsNode, BfAstNode);
ASTREF(BfTokenNode*) mOpenChevron;
Improvements to const string generic arg, literal generic args
2022-02-05 09:23:44 -05:00
BfSizedArray<ASTREF(BfAstNode*)> mGenericArgs;
Initial checkin
2019-08-23 11:56:54 -07:00
BfSizedArray<ASTREF(BfAstNode*)> mCommas;
ASTREF(BfTokenNode*) mCloseChevron;
}; BF_AST_DECL(BfGenericArgumentsNode, BfAstNode);
class BfTokenPairNode : public BfAstNode
{
public:
BF_AST_TYPE(BfTokenPairNode, BfAstNode);
BfTokenNode* mLeft;
BfTokenNode* mRight;
}; BF_AST_DECL(BfTokenPairNode, BfAstNode);
Added constraints for operators, 'external' constraints for methods
2019-11-17 09:28:39 -08:00
class BfGenericOperatorConstraint : public BfAstNode
{
public:
BF_AST_TYPE(BfGenericOperatorConstraint, BfAstNode);
BfTokenNode* mOperatorToken;
BfTypeReference* mLeftType;
BfTokenNode* mOpToken;
BfTypeReference* mRightType;
}; BF_AST_DECL(BfGenericOperatorConstraint, BfAstNode);
Initial checkin
2019-08-23 11:56:54 -07:00
class BfGenericConstraint : public BfAstNode
{
public:
BF_AST_TYPE(BfGenericConstraint, BfAstNode);
Added constraints for operators, 'external' constraints for methods
2019-11-17 09:28:39 -08:00
BfTokenNode* mWhereToken;
BfTypeReference* mTypeRef;
Initial checkin
2019-08-23 11:56:54 -07:00
BfTokenNode* mColonToken;
Added constraints for operators, 'external' constraints for methods
2019-11-17 09:28:39 -08:00
BfSizedArray<BfAstNode*> mConstraintTypes;
Initial checkin
2019-08-23 11:56:54 -07:00
BfSizedArray<ASTREF(BfTokenNode*)> mCommas;
}; BF_AST_DECL(BfGenericConstraint, BfAstNode);
class BfGenericConstraintsDeclaration : public BfAstNode
{
public:
BF_AST_TYPE(BfGenericConstraintsDeclaration, BfAstNode);
Added constraints for operators, 'external' constraints for methods
2019-11-17 09:28:39 -08:00
BfSizedArray<BfGenericConstraint*> mGenericConstraints;
Initial checkin
2019-08-23 11:56:54 -07:00
}; BF_AST_DECL(BfGenericConstraintsDeclaration, BfAstNode);
class BfMethodDeclaration : public BfMemberDeclaration
{
public:
BF_AST_TYPE(BfMethodDeclaration, BfMemberDeclaration);
Added [MangleConst] support
2020-11-16 11:05:08 -08:00
BfCommentNode* mDocumentation;
Added extension methods
2020-06-03 05:22:11 -07:00
BfTokenNode* mExternSpecifier;
BfTokenNode* mVirtualSpecifier; // either 'virtual', 'override', or 'abstract'
BfTokenNode* mNewSpecifier;
BfTokenNode* mMixinSpecifier;
BfTokenNode* mPartialSpecifier;
BfTokenNode* mMutSpecifier;
BfTypeReference* mReturnType;
BfTypeReference* mExplicitInterface;
BfTokenNode* mExplicitInterfaceDotToken;
BfIdentifierNode* mNameNode;
BfTokenNode* mOpenParen;
BfTokenNode* mThisToken;
BfSizedArray<BfParameterDeclaration*> mParams;
BfSizedArray<BfTokenNode*> mCommas;
BfTokenNode* mCloseParen;
BfGenericParamsDeclaration* mGenericParams;
BfGenericConstraintsDeclaration* mGenericConstraintsDeclaration;
BfAstNode* mEndSemicolon;
BfTokenNode* mFatArrowToken;
BfAstNode* mBody; // Either expression or block
Initial checkin
2019-08-23 11:56:54 -07:00
//BfMethodDef* mMethodDef;
bool mHadYield;
}; BF_AST_DECL(BfMethodDeclaration, BfMemberDeclaration);
class BfOperatorDeclaration : public BfMethodDeclaration
{
public:
BF_AST_TYPE(BfOperatorDeclaration, BfMethodDeclaration);
BfTokenNode* mExplicitToken; // Explicit or Implicit
BfTokenNode* mOperatorToken;
BfTokenNode* mOpTypeToken;
bool mIsConvOperator;
BfUnaryOp mUnaryOp;
BfBinaryOp mBinOp;
BfAssignmentOp mAssignOp;
}; BF_AST_DECL(BfOperatorDeclaration, BfMethodDeclaration);
class BfConstructorDeclaration : public BfMethodDeclaration
{
public:
BF_AST_TYPE(BfConstructorDeclaration, BfMethodDeclaration);
BfTokenNode* mThisToken;
BfTokenNode* mInitializerColonToken;
Fixed extension initializers and dtors. [NoExtension]. Extension warning
2020-10-22 11:33:13 -07:00
BfExpression* mInitializer;
Initial checkin
2019-08-23 11:56:54 -07:00
}; BF_AST_DECL(BfConstructorDeclaration, BfMethodDeclaration);
Added auto-constructors (ie: 'struct Vec : this(float x, float y);')
2021-01-02 12:54:05 -08:00
class BfAutoConstructorDeclaration : public BfConstructorDeclaration
{
public:
BF_AST_TYPE(BfAutoConstructorDeclaration, BfConstructorDeclaration);
}; BF_AST_DECL(BfAutoConstructorDeclaration, BfConstructorDeclaration);
Initial checkin
2019-08-23 11:56:54 -07:00
class BfDestructorDeclaration : public BfMethodDeclaration
{
public:
BF_AST_TYPE(BfDestructorDeclaration, BfMethodDeclaration);
BfTokenNode* mTildeToken;
BfTokenNode* mThisToken;
}; BF_AST_DECL(BfDestructorDeclaration, BfMethodDeclaration);
class BfFieldDtorDeclaration : public BfAstNode
{
public:
BF_AST_TYPE(BfFieldDtorDeclaration, BfAstNode);
BfTokenNode* mTildeToken;
BfAstNode* mBody;
BfFieldDtorDeclaration* mNextFieldDtor;
}; BF_AST_DECL(BfFieldDtorDeclaration, BfAstNode);
Start of anonymous 'using' field
2022-02-19 07:38:05 -05:00
class BfUsingSpecifierNode : public BfAstNode
{
public:
BF_AST_TYPE(BfUsingSpecifierNode, BfAstNode);
BfAstNode* mProtection;
BfTokenNode* mUsingToken;
}; BF_AST_DECL(BfUsingSpecifierNode, BfAstNode);
Initial checkin
2019-08-23 11:56:54 -07:00
class BfFieldDeclaration : public BfMemberDeclaration
{
public:
BF_AST_TYPE(BfFieldDeclaration, BfMemberDeclaration);
BfCommentNode* mDocumentation;
BfTokenNode* mPrecedingComma;
Start of anonymous 'using' field
2022-02-19 07:38:05 -05:00
BfAstNode* mConstSpecifier; // Could be 'const' or 'using'
Initial checkin
2019-08-23 11:56:54 -07:00
BfTokenNode* mVolatileSpecifier;
BfTokenNode* mNewSpecifier;
BfTokenNode* mExternSpecifier;
BfTypeReference* mTypeRef;
BfIdentifierNode* mNameNode;
BfTokenNode* mEqualsNode;
BfExpression* mInitializer;
BfFieldDtorDeclaration* mFieldDtor;
BfFieldDef* mFieldDef;
}; BF_AST_DECL(BfFieldDeclaration, BfMemberDeclaration);
class BfEnumEntryDeclaration : public BfFieldDeclaration
{
public:
BF_AST_TYPE(BfEnumEntryDeclaration, BfFieldDeclaration);
}; BF_AST_DECL(BfEnumEntryDeclaration, BfFieldDeclaration);
class BfPropertyMethodDeclaration : public BfAstNode
{
public:
BF_AST_TYPE(BfPropertyMethodDeclaration, BfAstNode);
BfPropertyDeclaration* mPropertyDeclaration;
BfAttributeDirective* mAttributes;
Added 'protected internal' protection
2020-12-07 07:53:12 -08:00
BfAstNode* mProtectionSpecifier;
Allow ref property setter specifier
2021-11-27 09:05:23 -08:00
BfTokenNode* mSetRefSpecifier;
Added expression bodies for properties
2019-09-30 12:24:02 -07:00
BfTokenNode* mMutSpecifier;
Initial checkin
2019-08-23 11:56:54 -07:00
BfIdentifierNode* mNameNode;
Enhanced expression-body support
2020-05-08 11:11:01 -07:00
BfTokenNode* mFatArrowToken;
Added expression bodies for properties
2019-09-30 12:24:02 -07:00
BfAstNode* mBody;
Enhanced expression-body support
2020-05-08 11:11:01 -07:00
BfAstNode* mEndSemicolon;
Initial checkin
2019-08-23 11:56:54 -07:00
}; BF_AST_DECL(BfPropertyMethodDeclaration, BfAstNode);
Added expression bodies for properties
2019-09-30 12:24:02 -07:00
class BfPropertyBodyExpression : public BfAstNode
{
public:
BF_AST_TYPE(BfPropertyBodyExpression, BfAstNode);
Support for expression-bodied properties with mut
2022-01-03 14:41:12 -05:00
BfTokenNode* mMutSpecifier;
Added expression bodies for properties
2019-09-30 12:24:02 -07:00
BfTokenNode* mFatTokenArrow;
}; BF_AST_DECL(BfPropertyBodyExpression, BfAstNode);
Initial checkin
2019-08-23 11:56:54 -07:00
class BfPropertyDeclaration : public BfFieldDeclaration
{
public:
BF_AST_TYPE(BfPropertyDeclaration, BfFieldDeclaration);
BfTokenNode* mVirtualSpecifier; // either 'virtual', 'override', or 'abstract'
BfTypeReference* mExplicitInterface;
Added expression bodies for properties
2019-09-30 12:24:02 -07:00
BfTokenNode* mExplicitInterfaceDotToken;
BfAstNode* mDefinitionBlock;
Initial checkin
2019-08-23 11:56:54 -07:00
BfSizedArray<BfPropertyMethodDeclaration*> mMethods;
BfPropertyMethodDeclaration* GetMethod(const StringImpl& name);
}; BF_AST_DECL(BfPropertyDeclaration, BfFieldDeclaration);
class BfIndexerDeclaration : public BfPropertyDeclaration
{
public:
BF_AST_TYPE(BfIndexerDeclaration, BfPropertyDeclaration);
BfTokenNode* mThisToken;
BfTokenNode* mOpenBracket;
BfSizedArray<ASTREF(BfParameterDeclaration*)> mParams;
BfSizedArray<ASTREF(BfTokenNode*)> mCommas;
BfTokenNode* mCloseBracket;
}; BF_AST_DECL(BfIndexerDeclaration, BfPropertyDeclaration);
class BfBreakStatement : public BfStatement
{
public:
BF_AST_TYPE(BfBreakStatement, BfStatement);
BfTokenNode* mBreakNode;
BfAstNode* mLabel;
}; BF_AST_DECL(BfBreakStatement, BfStatement);
class BfTryStatement : public BfCompoundStatement
{
public:
BF_AST_TYPE(BfTryStatement, BfCompoundStatement);
BfTokenNode* mTryToken;
BfAstNode* mStatement;
}; BF_AST_DECL(BfTryStatement, BfCompoundStatement);
class BfCatchStatement : public BfCompoundStatement
{
public:
BF_AST_TYPE(BfCatchStatement, BfCompoundStatement);
BfTokenNode* mCatchToken;
BfAstNode* mStatement;
}; BF_AST_DECL(BfCatchStatement, BfCompoundStatement);
class BfFinallyStatement : public BfCompoundStatement
{
public:
BF_AST_TYPE(BfFinallyStatement, BfCompoundStatement);
BfTokenNode* mFinallyToken;
BfAstNode* mStatement;
}; BF_AST_DECL(BfFinallyStatement, BfCompoundStatement);
class BfCheckedStatement : public BfCompoundStatement
{
public:
BF_AST_TYPE(BfCheckedStatement, BfCompoundStatement);
BfTokenNode* mCheckedToken;
BfAstNode* mStatement;
}; BF_AST_DECL(BfCheckedStatement, BfCompoundStatement);
class BfUncheckedStatement : public BfCompoundStatement
{
public:
BF_AST_TYPE(BfUncheckedStatement, BfCompoundStatement);
BfTokenNode* mUncheckedToken;
BfAstNode* mStatement;
}; BF_AST_DECL(BfUncheckedStatement, BfCompoundStatement);
class BfContinueStatement : public BfStatement
{
public:
BF_AST_TYPE(BfContinueStatement, BfStatement);
BfTokenNode* mContinueNode;
BfAstNode* mLabel;
}; BF_AST_DECL(BfContinueStatement, BfStatement);
class BfFallthroughStatement : public BfStatement
{
public:
BF_AST_TYPE(BfFallthroughStatement, BfStatement);
BfTokenNode* mFallthroughToken;
}; BF_AST_DECL(BfFallthroughStatement, BfStatement);
class BfForEachStatement : public BfLabelableStatement
{
public:
BF_AST_TYPE(BfForEachStatement, BfLabelableStatement);
BfTokenNode* mForToken;
BfTokenNode* mOpenParen;
BfTokenNode* mReadOnlyToken;
BfTypeReference* mVariableTypeRef;
BfAstNode* mVariableName; // Either BfIdentifierNode or BfTupleExpression
BfTokenNode* mInToken;
BfExpression* mCollectionExpression;
BfTokenNode* mCloseParen;
BfAstNode* mEmbeddedStatement;
}; BF_AST_DECL(BfForEachStatement, BfLabelableStatement);
class BfForStatement : public BfLabelableStatement
{
public:
BF_AST_TYPE(BfForStatement, BfLabelableStatement);
BfTokenNode* mForToken;
BfTokenNode* mOpenParen;
BfSizedArray<ASTREF(BfAstNode*)> mInitializers;
BfSizedArray<ASTREF(BfTokenNode*)> mInitializerCommas;
BfTokenNode* mInitializerSemicolon;
BfExpression* mCondition;
BfTokenNode* mConditionSemicolon;
BfSizedArray<ASTREF(BfAstNode*)> mIterators;
BfSizedArray<ASTREF(BfTokenNode*)> mIteratorCommas;
BfTokenNode* mCloseParen;
BfAstNode* mEmbeddedStatement;
}; BF_AST_DECL(BfForStatement, BfLabelableStatement);
class BfUsingStatement : public BfCompoundStatement
{
public:
BF_AST_TYPE(BfUsingStatement, BfCompoundStatement);
BfTokenNode* mUsingToken;
BfTokenNode* mOpenParen;
BfVariableDeclaration* mVariableDeclaration;
BfTokenNode* mCloseParen;
BfAstNode* mEmbeddedStatement;
}; BF_AST_DECL(BfUsingStatement, BfCompoundStatement);
class BfDoStatement : public BfLabelableStatement
{
public:
BF_AST_TYPE(BfDoStatement, BfLabelableStatement);
BfTokenNode* mDoToken;
BfAstNode* mEmbeddedStatement;
}; BF_AST_DECL(BfDoStatement, BfLabelableStatement);
class BfRepeatStatement : public BfLabelableStatement
{
public:
BF_AST_TYPE(BfRepeatStatement, BfLabelableStatement);
BfTokenNode* mRepeatToken;
BfAstNode* mEmbeddedStatement;
BfTokenNode* mWhileToken;
BfTokenNode* mOpenParen;
BfExpression* mCondition;
BfTokenNode* mCloseParen;
}; BF_AST_DECL(BfRepeatStatement, BfLabelableStatement);
class BfWhileStatement : public BfLabelableStatement
{
public:
BF_AST_TYPE(BfWhileStatement, BfLabelableStatement);
BfTokenNode* mWhileToken;
BfTokenNode* mOpenParen;
BfExpression* mCondition;
BfTokenNode* mCloseParen;
BfAstNode* mEmbeddedStatement;
}; BF_AST_DECL(BfWhileStatement, BfLabelableStatement);
class BfReturnStatement : public BfStatement
{
public:
BF_AST_TYPE(BfReturnStatement, BfStatement);
BfTokenNode* mReturnToken;
BfExpression* mExpression;
}; BF_AST_DECL(BfReturnStatement, BfStatement);
class BfYieldStatement : public BfStatement
{
public:
BF_AST_TYPE(BfYieldStatement, BfStatement);
BfTokenNode* mReturnOrBreakToken;
BfExpression* mExpression;
}; BF_AST_DECL(BfYieldStatement, BfStatement);
class BfInlineAsmStatement : public BfCompoundStatement
{
public:
BF_AST_TYPE(BfInlineAsmStatement, BfCompoundStatement);
BfTokenNode* mOpenBrace;
BfTokenNode* mCloseBrace;
Array<BfInlineAsmInstruction*> mInstructions;
//TODO: Make a block here
}; BF_AST_DECL(BfInlineAsmStatement, BfCompoundStatement);
class BfInlineAsmInstruction : public BfAstNode
{
public:
class AsmArg
{
public:
enum EArgType
{
ARGTYPE_Immediate, // immediate integer; uses mInt only
ARGTYPE_FloatReg, // float point st register; mInt is st reg index
ARGTYPE_IntReg, // general integer register; mReg is register name
ARGTYPE_Memory, // memory access; arg mem flags indicate additive permutation, [baseReg + adjReg*scalar + immDisplacement]
};
enum EArgMemFlags
{
ARGMEMF_ImmediateDisp = (1 << 0), // uses immediate displacement constant
ARGMEMF_BaseReg = (1 << 1), // uses unscaled base register
ARGMEMF_AdjReg = (1 << 2), // uses scaled adjustment register and scalar value
};
EArgType mType;
unsigned long mMemFlags;
String mSegPrefix; // if non-empty, cs|ds|es|fs|gs|ss
String mSizePrefix; // if non-empty, size prefix for memory accesses (e.g. byte|word|dword), syntactically followed by "ptr" although that's omitted here
int mInt; // memory displacement, immediate integer, fp st register index, etc.
String mReg; // general register, or unscaled base register for memory accesses
String mAdjReg; // scaled adjustment register for memory accesses
int mAdjRegScalar; // adjustment scalar (e.g. 2, 4, or 8).
String mMemberSuffix; // if non-empty, struct member suffix following memory access, e.g. [ebx].mFoo
AsmArg();
String ToString();
};
class AsmInst
{
public:
String mLabel;
Array<String> mOpPrefixes;
String mOpCode;
Array<AsmArg> mArgs;
int mDebugLine;
AsmInst();
String ToString();
};
public:
BF_AST_TYPE(BfInlineAsmInstruction, BfAstNode);
AsmInst mAsmInst;
}; BF_AST_DECL(BfInlineAsmInstruction, BfAstNode);
const char* BfTokenToString(BfToken token);
bool BfTokenIsKeyword(BfToken token);
BfBinaryOp BfAssignOpToBinaryOp(BfAssignmentOp assignmentOp);
Added constraints for operators, 'external' constraints for methods
2019-11-17 09:28:39 -08:00
BfBinaryOp BfGetOppositeBinaryOp(BfBinaryOp origOp);
BfBinaryOp BfGetFlippedBinaryOp(BfBinaryOp origOp);
Added concept of strict equality
2020-06-17 05:13:53 -07:00
bool BfBinOpEqualityCheck(BfBinaryOp binOp);
Initial checkin
2019-08-23 11:56:54 -07:00
int BfGetBinaryOpPrecendence(BfBinaryOp binOp);
const char* BfGetOpName(BfBinaryOp binOp);
const char* BfGetOpName(BfUnaryOp unaryOp);
Added nullable(T), Result<T> can use null conditionals
2020-04-27 15:09:10 -07:00
bool BfCanOverloadOperator(BfUnaryOp unaryOp);
Added constraints for operators, 'external' constraints for methods
2019-11-17 09:28:39 -08:00
BfBinaryOp BfTokenToBinaryOp(BfToken token);
BfUnaryOp BfTokenToUnaryOp(BfToken token);
BfAssignmentOp BfTokenToAssignmentOp(BfToken token);
Working on wrapping for formatter
2020-03-28 14:26:14 -07:00
bool BfIsCommentBlock(BfCommentKind commentKind);
Initial checkin
2019-08-23 11:56:54 -07:00
Fix for lambda caching within mixin
2020-10-30 09:03:36 -07:00
NS_BF_END
namespace std
{
template<>
struct hash<Beefy::BfAstNodeList>
{
size_t operator()(const Beefy::BfAstNodeList& val) const
{
if (val.mList.mSize == 0)
return 0;
if (val.mList.mSize == 0)
return (size_t)val.mList.mVals[0];
return HashBytes((uint8*)val.mList.mVals, sizeof(Beefy::BfAstNode*) * val.mList.mSize);
}
};
}
Copy permalink