/** * Defines lexical tokens. * * Specification: $(LINK2 https://dlang.org/spec/lex.html#tokens, Tokens) * * Copyright: Copyright (C) 1999-2022 by The D Language Foundation, All Rights Reserved * Authors: $(LINK2 https://www.digitalmars.com, Walter Bright) * License: $(LINK2 https://www.boost.org/LICENSE_1_0.txt, Boost License 1.0) * Source: $(LINK2 https://github.com/dlang/dmd/blob/master/src/dmd/tokens.d, _tokens.d) * Documentation: https://dlang.org/phobos/dmd_tokens.html * Coverage: https://codecov.io/gh/dlang/dmd/src/master/src/dmd/tokens.d */ module dmd.tokens; import core.stdc.ctype; import core.stdc.stdio; import core.stdc.string; import dmd.globals; import dmd.identifier; import dmd.root.ctfloat; import dmd.common.outbuffer; import dmd.root.rmem; import dmd.root.utf; enum TOK : ubyte { reserved, // Other leftParenthesis, rightParenthesis, leftBracket, rightBracket, leftCurly, rightCurly, colon, semicolon, dotDotDot, endOfFile, cast_, null_, assert_, true_, false_, throw_, new_, delete_, variable, slice, version_, module_, dollar, template_, typeof_, pragma_, typeid_, comment, // Operators lessThan, greaterThan, lessOrEqual, greaterOrEqual, equal, notEqual, identity, notIdentity, is_, leftShift, rightShift, leftShiftAssign, rightShiftAssign, unsignedRightShift, unsignedRightShiftAssign, concatenateAssign, // ~= add, min, addAssign, minAssign, mul, div, mod, mulAssign, divAssign, modAssign, and, or, xor, andAssign, orAssign, xorAssign, assign, not, tilde, plusPlus, minusMinus, dot, comma, question, andAnd, orOr, // Numeric literals int32Literal, uns32Literal, int64Literal, uns64Literal, int128Literal, uns128Literal, float32Literal, float64Literal, float80Literal, imaginary32Literal, imaginary64Literal, imaginary80Literal, // Char constants charLiteral, wcharLiteral, dcharLiteral, // Leaf operators identifier, string_, this_, super_, error, // Basic types void_, int8, uns8, int16, uns16, int32, uns32, int64, uns64, int128, uns128, float32, float64, float80, imaginary32, imaginary64, imaginary80, complex32, complex64, complex80, char_, wchar_, dchar_, bool_, // Aggregates struct_, class_, interface_, union_, enum_, import_, alias_, override_, delegate_, function_, mixin_, align_, extern_, private_, protected_, public_, export_, static_, final_, const_, abstract_, debug_, deprecated_, in_, out_, inout_, lazy_, auto_, package_, immutable_, // Statements if_, else_, while_, for_, do_, switch_, case_, default_, break_, continue_, with_, synchronized_, return_, goto_, try_, catch_, finally_, asm_, foreach_, foreach_reverse_, scope_, onScopeExit, onScopeFailure, onScopeSuccess, // Contracts invariant_, // Testing unittest_, // Added after 1.0 argumentTypes, ref_, macro_, parameters, traits, pure_, nothrow_, gshared, line, file, fileFullPath, moduleString, // __MODULE__ functionString, // __FUNCTION__ prettyFunction, // __PRETTY_FUNCTION__ shared_, at, pow, powAssign, goesTo, vector, pound, arrow, // -> colonColon, // :: wchar_tLiteral, endOfLine, // \n, \r, \u2028, \u2029 whitespace, // C only keywords inline, register, restrict, signed, sizeof_, typedef_, unsigned, volatile, _Alignas, _Alignof, _Atomic, _Bool, _Complex, _Generic, _Imaginary, _Noreturn, _Static_assert, _Thread_local, // C only extended keywords _import, __cdecl, __declspec, __stdcall, __pragma, __attribute__, } /// Expression nodes enum EXP : ubyte { reserved, // Other negate, cast_, null_, assert_, true_, false_, array, call, address, type, throw_, new_, delete_, star, symbolOffset, variable, dotVariable, dotIdentifier, dotTemplateInstance, dotType, slice, arrayLength, version_, dollar, template_, dotTemplateDeclaration, declaration, typeof_, pragma_, dSymbol, typeid_, uadd, remove, newAnonymousClass, arrayLiteral, assocArrayLiteral, structLiteral, classReference, thrownException, delegatePointer, delegateFunctionPointer, // Operators lessThan, greaterThan, lessOrEqual, greaterOrEqual, equal, notEqual, identity, notIdentity, index, is_, leftShift, rightShift, leftShiftAssign, rightShiftAssign, unsignedRightShift, unsignedRightShiftAssign, concatenate, concatenateAssign, // ~= concatenateElemAssign, concatenateDcharAssign, add, min, addAssign, minAssign, mul, div, mod, mulAssign, divAssign, modAssign, and, or, xor, andAssign, orAssign, xorAssign, assign, not, tilde, plusPlus, minusMinus, construct, blit, dot, comma, question, andAnd, orOr, prePlusPlus, preMinusMinus, // Leaf operators identifier, string_, this_, super_, halt, tuple, error, // Basic types void_, int64, float64, complex80, char_, import_, delegate_, function_, mixin_, in_, default_, break_, continue_, goto_, scope_, traits, overloadSet, line, file, fileFullPath, moduleString, // __MODULE__ functionString, // __FUNCTION__ prettyFunction, // __PRETTY_FUNCTION__ shared_, pow, powAssign, vector, voidExpression, cantExpression, showCtfeContext, objcClassReference, vectorArray, arrow, // -> compoundLiteral, // ( type-name ) { initializer-list } _Generic, interval, } enum FirstCKeyword = TOK.inline; // Assert that all token enum members have consecutive values and // that none of them overlap static assert(() { foreach (idx, enumName; __traits(allMembers, TOK)) { static if (idx != __traits(getMember, TOK, enumName)) { pragma(msg, "Error: Expected TOK.", enumName, " to be ", idx, " but is ", __traits(getMember, TOK, enumName)); static assert(0); } } return true; }()); /**************************************** */ private immutable TOK[] keywords = [ TOK.this_, TOK.super_, TOK.assert_, TOK.null_, TOK.true_, TOK.false_, TOK.cast_, TOK.new_, TOK.delete_, TOK.throw_, TOK.module_, TOK.pragma_, TOK.typeof_, TOK.typeid_, TOK.template_, TOK.void_, TOK.int8, TOK.uns8, TOK.int16, TOK.uns16, TOK.int32, TOK.uns32, TOK.int64, TOK.uns64, TOK.int128, TOK.uns128, TOK.float32, TOK.float64, TOK.float80, TOK.bool_, TOK.char_, TOK.wchar_, TOK.dchar_, TOK.imaginary32, TOK.imaginary64, TOK.imaginary80, TOK.complex32, TOK.complex64, TOK.complex80, TOK.delegate_, TOK.function_, TOK.is_, TOK.if_, TOK.else_, TOK.while_, TOK.for_, TOK.do_, TOK.switch_, TOK.case_, TOK.default_, TOK.break_, TOK.continue_, TOK.synchronized_, TOK.return_, TOK.goto_, TOK.try_, TOK.catch_, TOK.finally_, TOK.with_, TOK.asm_, TOK.foreach_, TOK.foreach_reverse_, TOK.scope_, TOK.struct_, TOK.class_, TOK.interface_, TOK.union_, TOK.enum_, TOK.import_, TOK.mixin_, TOK.static_, TOK.final_, TOK.const_, TOK.alias_, TOK.override_, TOK.abstract_, TOK.debug_, TOK.deprecated_, TOK.in_, TOK.out_, TOK.inout_, TOK.lazy_, TOK.auto_, TOK.align_, TOK.extern_, TOK.private_, TOK.package_, TOK.protected_, TOK.public_, TOK.export_, TOK.invariant_, TOK.unittest_, TOK.version_, TOK.argumentTypes, TOK.parameters, TOK.ref_, TOK.macro_, TOK.pure_, TOK.nothrow_, TOK.gshared, TOK.traits, TOK.vector, TOK.file, TOK.fileFullPath, TOK.line, TOK.moduleString, TOK.functionString, TOK.prettyFunction, TOK.shared_, TOK.immutable_, // C only keywords TOK.inline, TOK.register, TOK.restrict, TOK.signed, TOK.sizeof_, TOK.typedef_, TOK.unsigned, TOK.volatile, TOK._Alignas, TOK._Alignof, TOK._Atomic, TOK._Bool, TOK._Complex, TOK._Generic, TOK._Imaginary, TOK._Noreturn, TOK._Static_assert, TOK._Thread_local, // C only extended keywords TOK._import, TOK.__cdecl, TOK.__declspec, TOK.__stdcall, TOK.__pragma, TOK.__attribute__, ]; // Initialize the identifier pool shared static this() nothrow { Identifier.initTable(); foreach (kw; keywords) { //printf("keyword[%d] = '%s'\n",kw, Token.tochars[kw].ptr); Identifier.idPool(Token.tochars[kw].ptr, Token.tochars[kw].length, cast(uint)kw); } } /************************************ * This is used to pick the C keywords out of the tokens. * If it's not a C keyword, then it's an identifier. */ static immutable TOK[TOK.max + 1] Ckeywords = () { with (TOK) { TOK[TOK.max + 1] tab = identifier; // default to identifier enum Ckwds = [ auto_, break_, case_, char_, const_, continue_, default_, do_, float64, else_, enum_, extern_, float32, for_, goto_, if_, inline, int32, int64, register, restrict, return_, int16, signed, sizeof_, static_, struct_, switch_, typedef_, union_, unsigned, void_, volatile, while_, asm_, typeof_, _Alignas, _Alignof, _Atomic, _Bool, _Complex, _Generic, _Imaginary, _Noreturn, _Static_assert, _Thread_local, _import, __cdecl, __declspec, __stdcall, __pragma, __attribute__ ]; foreach (kw; Ckwds) tab[kw] = cast(TOK) kw; return tab; } } (); /*********************************************************** */ extern (C++) struct Token { Token* next; Loc loc; const(char)* ptr; // pointer to first character of this token within buffer TOK value; const(char)[] blockComment; // doc comment string prior to this token const(char)[] lineComment; // doc comment for previous token union { // Integers sinteger_t intvalue; uinteger_t unsvalue; // Floats real_t floatvalue; struct { const(char)* ustring; // UTF8 string uint len; ubyte postfix; // 'c', 'w', 'd' } Identifier ident; } extern (D) private static immutable string[TOK.max + 1] tochars = [ // Keywords TOK.this_: "this", TOK.super_: "super", TOK.assert_: "assert", TOK.null_: "null", TOK.true_: "true", TOK.false_: "false", TOK.cast_: "cast", TOK.new_: "new", TOK.delete_: "delete", TOK.throw_: "throw", TOK.module_: "module", TOK.pragma_: "pragma", TOK.typeof_: "typeof", TOK.typeid_: "typeid", TOK.template_: "template", TOK.void_: "void", TOK.int8: "byte", TOK.uns8: "ubyte", TOK.int16: "short", TOK.uns16: "ushort", TOK.int32: "int", TOK.uns32: "uint", TOK.int64: "long", TOK.uns64: "ulong", TOK.int128: "cent", TOK.uns128: "ucent", TOK.float32: "float", TOK.float64: "double", TOK.float80: "real", TOK.bool_: "bool", TOK.char_: "char", TOK.wchar_: "wchar", TOK.dchar_: "dchar", TOK.imaginary32: "ifloat", TOK.imaginary64: "idouble", TOK.imaginary80: "ireal", TOK.complex32: "cfloat", TOK.complex64: "cdouble", TOK.complex80: "creal", TOK.delegate_: "delegate", TOK.function_: "function", TOK.is_: "is", TOK.if_: "if", TOK.else_: "else", TOK.while_: "while", TOK.for_: "for", TOK.do_: "do", TOK.switch_: "switch", TOK.case_: "case", TOK.default_: "default", TOK.break_: "break", TOK.continue_: "continue", TOK.synchronized_: "synchronized", TOK.return_: "return", TOK.goto_: "goto", TOK.try_: "try", TOK.catch_: "catch", TOK.finally_: "finally", TOK.with_: "with", TOK.asm_: "asm", TOK.foreach_: "foreach", TOK.foreach_reverse_: "foreach_reverse", TOK.scope_: "scope", TOK.struct_: "struct", TOK.class_: "class", TOK.interface_: "interface", TOK.union_: "union", TOK.enum_: "enum", TOK.import_: "import", TOK.mixin_: "mixin", TOK.static_: "static", TOK.final_: "final", TOK.const_: "const", TOK.alias_: "alias", TOK.override_: "override", TOK.abstract_: "abstract", TOK.debug_: "debug", TOK.deprecated_: "deprecated", TOK.in_: "in", TOK.out_: "out", TOK.inout_: "inout", TOK.lazy_: "lazy", TOK.auto_: "auto", TOK.align_: "align", TOK.extern_: "extern", TOK.private_: "private", TOK.package_: "package", TOK.protected_: "protected", TOK.public_: "public", TOK.export_: "export", TOK.invariant_: "invariant", TOK.unittest_: "unittest", TOK.version_: "version", TOK.argumentTypes: "__argTypes", TOK.parameters: "__parameters", TOK.ref_: "ref", TOK.macro_: "macro", TOK.pure_: "pure", TOK.nothrow_: "nothrow", TOK.gshared: "__gshared", TOK.traits: "__traits", TOK.vector: "__vector", TOK.file: "__FILE__", TOK.fileFullPath: "__FILE_FULL_PATH__", TOK.line: "__LINE__", TOK.moduleString: "__MODULE__", TOK.functionString: "__FUNCTION__", TOK.prettyFunction: "__PRETTY_FUNCTION__", TOK.shared_: "shared", TOK.immutable_: "immutable", TOK.endOfFile: "End of File", TOK.leftCurly: "{", TOK.rightCurly: "}", TOK.leftParenthesis: "(", TOK.rightParenthesis: ")", TOK.leftBracket: "[", TOK.rightBracket: "]", TOK.semicolon: ";", TOK.colon: ":", TOK.comma: ",", TOK.dot: ".", TOK.xor: "^", TOK.xorAssign: "^=", TOK.assign: "=", TOK.lessThan: "<", TOK.greaterThan: ">", TOK.lessOrEqual: "<=", TOK.greaterOrEqual: ">=", TOK.equal: "==", TOK.notEqual: "!=", TOK.not: "!", TOK.leftShift: "<<", TOK.rightShift: ">>", TOK.unsignedRightShift: ">>>", TOK.add: "+", TOK.min: "-", TOK.mul: "*", TOK.div: "/", TOK.mod: "%", TOK.slice: "..", TOK.dotDotDot: "...", TOK.and: "&", TOK.andAnd: "&&", TOK.or: "|", TOK.orOr: "||", TOK.tilde: "~", TOK.dollar: "$", TOK.plusPlus: "++", TOK.minusMinus: "--", TOK.question: "?", TOK.variable: "var", TOK.addAssign: "+=", TOK.minAssign: "-=", TOK.mulAssign: "*=", TOK.divAssign: "/=", TOK.modAssign: "%=", TOK.leftShiftAssign: "<<=", TOK.rightShiftAssign: ">>=", TOK.unsignedRightShiftAssign: ">>>=", TOK.andAssign: "&=", TOK.orAssign: "|=", TOK.concatenateAssign: "~=", TOK.identity: "is", TOK.notIdentity: "!is", TOK.identifier: "identifier", TOK.at: "@", TOK.pow: "^^", TOK.powAssign: "^^=", TOK.goesTo: "=>", TOK.pound: "#", TOK.arrow: "->", TOK.colonColon: "::", // For debugging TOK.error: "error", TOK.string_: "string", TOK.onScopeExit: "scope(exit)", TOK.onScopeSuccess: "scope(success)", TOK.onScopeFailure: "scope(failure)", // Finish up TOK.reserved: "reserved", TOK.comment: "comment", TOK.int32Literal: "int32v", TOK.uns32Literal: "uns32v", TOK.int64Literal: "int64v", TOK.uns64Literal: "uns64v", TOK.int128Literal: "int128v", TOK.uns128Literal: "uns128v", TOK.float32Literal: "float32v", TOK.float64Literal: "float64v", TOK.float80Literal: "float80v", TOK.imaginary32Literal: "imaginary32v", TOK.imaginary64Literal: "imaginary64v", TOK.imaginary80Literal: "imaginary80v", TOK.charLiteral: "charv", TOK.wcharLiteral: "wcharv", TOK.dcharLiteral: "dcharv", TOK.wchar_tLiteral: "wchar_tv", TOK.endOfLine: "\\n", TOK.whitespace: "whitespace", // C only keywords TOK.inline : "inline", TOK.register : "register", TOK.restrict : "restrict", TOK.signed : "signed", TOK.sizeof_ : "sizeof", TOK.typedef_ : "typedef", TOK.unsigned : "unsigned", TOK.volatile : "volatile", TOK._Alignas : "_Alignas", TOK._Alignof : "_Alignof", TOK._Atomic : "_Atomic", TOK._Bool : "_Bool", TOK._Complex : "_Complex", TOK._Generic : "_Generic", TOK._Imaginary: "_Imaginary", TOK._Noreturn : "_Noreturn", TOK._Static_assert : "_Static_assert", TOK._Thread_local : "_Thread_local", // C only extended keywords TOK._import : "__import", TOK.__cdecl : "__cdecl", TOK.__declspec : "__declspec", TOK.__stdcall : "__stdcall", TOK.__pragma : "__pragma", TOK.__attribute__ : "__attribute__", ]; static assert(() { foreach (s; tochars) assert(s.length); return true; }()); nothrow: int isKeyword() const { foreach (kw; keywords) { if (kw == value) return 1; } return 0; } /**** * Set to contents of ptr[0..length] * Params: * ptr = pointer to string * length = length of string */ void setString(const(char)* ptr, size_t length) { auto s = cast(char*)mem.xmalloc_noscan(length + 1); memcpy(s, ptr, length); s[length] = 0; ustring = s; len = cast(uint)length; postfix = 0; } /**** * Set to contents of buf * Params: * buf = string (not zero terminated) */ void setString(const ref OutBuffer buf) { setString(cast(const(char)*)buf[].ptr, buf.length); } /**** * Set to empty string */ void setString() { ustring = ""; len = 0; postfix = 0; } extern (C++) const(char)* toChars() const { __gshared char[3 + 3 * floatvalue.sizeof + 1] buffer; const(char)* p = &buffer[0]; switch (value) { case TOK.int32Literal: sprintf(&buffer[0], "%d", cast(int)intvalue); break; case TOK.uns32Literal: case TOK.wchar_tLiteral: sprintf(&buffer[0], "%uU", cast(uint)unsvalue); break; case TOK.wcharLiteral: case TOK.dcharLiteral: case TOK.charLiteral: { OutBuffer buf; buf.writeSingleCharLiteral(cast(dchar) intvalue); buf.writeByte('\0'); p = buf.extractSlice().ptr; } break; case TOK.int64Literal: sprintf(&buffer[0], "%lldL", cast(long)intvalue); break; case TOK.uns64Literal: sprintf(&buffer[0], "%lluUL", cast(ulong)unsvalue); break; case TOK.float32Literal: CTFloat.sprint(&buffer[0], 'g', floatvalue); strcat(&buffer[0], "f"); break; case TOK.float64Literal: CTFloat.sprint(&buffer[0], 'g', floatvalue); break; case TOK.float80Literal: CTFloat.sprint(&buffer[0], 'g', floatvalue); strcat(&buffer[0], "L"); break; case TOK.imaginary32Literal: CTFloat.sprint(&buffer[0], 'g', floatvalue); strcat(&buffer[0], "fi"); break; case TOK.imaginary64Literal: CTFloat.sprint(&buffer[0], 'g', floatvalue); strcat(&buffer[0], "i"); break; case TOK.imaginary80Literal: CTFloat.sprint(&buffer[0], 'g', floatvalue); strcat(&buffer[0], "Li"); break; case TOK.string_: { OutBuffer buf; buf.writeByte('"'); for (size_t i = 0; i < len;) { dchar c; utf_decodeChar(ustring[0 .. len], i, c); writeCharLiteral(buf, c); } buf.writeByte('"'); if (postfix) buf.writeByte(postfix); buf.writeByte(0); p = buf.extractSlice().ptr; } break; case TOK.identifier: case TOK.enum_: case TOK.struct_: case TOK.import_: case TOK.wchar_: case TOK.dchar_: case TOK.bool_: case TOK.char_: case TOK.int8: case TOK.uns8: case TOK.int16: case TOK.uns16: case TOK.int32: case TOK.uns32: case TOK.int64: case TOK.uns64: case TOK.int128: case TOK.uns128: case TOK.float32: case TOK.float64: case TOK.float80: case TOK.imaginary32: case TOK.imaginary64: case TOK.imaginary80: case TOK.complex32: case TOK.complex64: case TOK.complex80: case TOK.void_: p = ident.toChars(); break; default: p = toChars(value); break; } return p; } static const(char)* toChars(TOK value) { return toString(value).ptr; } extern (D) static string toString(TOK value) pure nothrow @nogc @safe { return tochars[value]; } } /** * Write a character, using a readable escape sequence if needed * * Useful for printing "" string literals in e.g. error messages, ddoc, or the `.stringof` property * * Params: * buf = buffer to append character in * c = code point to write */ nothrow void writeCharLiteral(ref OutBuffer buf, dchar c) { switch (c) { case '\0': buf.writestring("\\0"); break; case '\n': buf.writestring("\\n"); break; case '\r': buf.writestring("\\r"); break; case '\t': buf.writestring("\\t"); break; case '\b': buf.writestring("\\b"); break; case '\f': buf.writestring("\\f"); break; case '"': case '\\': buf.writeByte('\\'); goto default; default: if (c <= 0xFF) { if (isprint(c)) buf.writeByte(c); else buf.printf("\\x%02x", c); } else if (c <= 0xFFFF) buf.printf("\\u%04x", c); else buf.printf("\\U%08x", c); break; } } unittest { OutBuffer buf; foreach(dchar d; "a\n\r\t\b\f\0\x11\u7233\U00017233"d) { writeCharLiteral(buf, d); } assert(buf.extractSlice() == `a\n\r\t\b\f\0\x11\u7233\U00017233`); } /** * Write a single-quoted character literal * * Useful for printing '' char literals in e.g. error messages, ddoc, or the `.stringof` property * * Params: * buf = buffer to append character in * c = code point to write */ nothrow void writeSingleCharLiteral(ref OutBuffer buf, dchar c) { buf.writeByte('\''); if (c == '\'') buf.writeByte('\\'); if (c == '"') buf.writeByte('"'); else writeCharLiteral(buf, c); buf.writeByte('\''); } unittest { OutBuffer buf; writeSingleCharLiteral(buf, '\''); assert(buf.extractSlice() == `'\''`); buf.reset(); writeSingleCharLiteral(buf, '"'); assert(buf.extractSlice() == `'"'`); buf.reset(); writeSingleCharLiteral(buf, '\n'); assert(buf.extractSlice() == `'\n'`); }