gcc/d/dmd/cxxfrontend.d

   1 /**
   2  * Contains C++ interfaces for interacting with DMD as a library.
   3  *
   4  * Copyright:   Copyright (C) 1999-2024 by The D Language Foundation, All Rights Reserved
   5  * Authors:     $(LINK2 https://www.digitalmars.com, Walter Bright)
   6  * License:     $(LINK2 https://www.boost.org/LICENSE_1_0.txt, Boost License 1.0)
   7  * Source:      $(LINK2 https://github.com/dlang/dmd/blob/master/src/dmd/cxxfrontend.d, _cxxfrontend.d)
   8  * Documentation:  https://dlang.org/phobos/dmd_cxxfrontend.html
   9  * Coverage:    https://codecov.io/gh/dlang/dmd/src/master/src/dmd/cxxfrontend.d
  10  */
  11 module dmd.cxxfrontend;
  12
  13 import dmd.aggregate : AggregateDeclaration;
  14 import dmd.arraytypes;
  15 import dmd.astenums;
  16 import dmd.common.outbuffer : OutBuffer;
  17 import dmd.denum : EnumDeclaration;
  18 import dmd.dmodule /*: Module*/;
  19 import dmd.dscope : Scope;
  20 import dmd.dstruct /*: StructDeclaration*/;
  21 import dmd.dsymbol : Dsymbol, ScopeDsymbol, CAsmDeclaration, SearchOpt, SearchOptFlags;
  22 import dmd.dtemplate /*: TemplateInstance, TemplateParameter, Tuple*/;
  23 import dmd.errorsink : ErrorSink;
  24 import dmd.expression /*: Expression*/;
  25 import dmd.func : FuncDeclaration;
  26 import dmd.globals;
  27 import dmd.identifier : Identifier;
  28 import dmd.init : Initializer, NeedInterpret;
  29 import dmd.location : Loc;
  30 import dmd.mtype /*: Covariant, Type, Parameter, ParameterList*/;
  31 import dmd.rootobject : RootObject;
  32 import dmd.statement : Statement, AsmStatement, GccAsmStatement;
  33
  34 // NB: At some point in the future, we can switch to shortened function syntax.
  35 extern (C++, "dmd"):
  36
  37 /***********************************************************
  38  * cppmangle.d
  39  */
  40 const(char)* toCppMangleItanium(Dsymbol s)
  41 {
  42     import dmd.cppmangle;
  43     return dmd.cppmangle.toCppMangleItanium(s);
  44 }
  45
  46 const(char)* cppTypeInfoMangleItanium(Dsymbol s)
  47 {
  48     import dmd.cppmangle;
  49     return dmd.cppmangle.cppTypeInfoMangleItanium(s);
  50 }
  51
  52 const(char)* cppThunkMangleItanium(FuncDeclaration fd, int offset)
  53 {
  54     import dmd.cppmangle;
  55     return dmd.cppmangle.cppThunkMangleItanium(fd, offset);
  56 }
  57
  58 /***********************************************************
  59  * dinterpret.d
  60  */
  61 Expression ctfeInterpret(Expression e)
  62 {
  63     import dmd.dinterpret;
  64     return dmd.dinterpret.ctfeInterpret(e);
  65 }
  66
  67 /***********************************************************
  68  * dmangle.d
  69  */
  70 const(char)* mangleExact(FuncDeclaration fd)
  71 {
  72     import dmd.dmangle;
  73     return dmd.dmangle.mangleExact(fd);
  74 }
  75
  76 void mangleToBuffer(Type t, ref OutBuffer buf)
  77 {
  78     import dmd.dmangle;
  79     return dmd.dmangle.mangleToBuffer(t, buf);
  80 }
  81
  82 void mangleToBuffer(Expression e, ref OutBuffer buf)
  83 {
  84     import dmd.dmangle;
  85     return dmd.dmangle.mangleToBuffer(e, buf);
  86 }
  87
  88 void mangleToBuffer(Dsymbol s, ref OutBuffer buf)
  89 {
  90     import dmd.dmangle;
  91     return dmd.dmangle.mangleToBuffer(s, buf);
  92 }
  93
  94 void mangleToBuffer(TemplateInstance ti, ref OutBuffer buf)
  95 {
  96     import dmd.dmangle;
  97     return dmd.dmangle.mangleToBuffer(ti, buf);
  98 }
  99
 100 /***********************************************************
 101  * dmodule.d
 102  */
 103 void getLocalClasses(Module mod, ref ClassDeclarations aclasses)
 104 {
 105     return dmd.dmodule.getLocalClasses(mod, aclasses);
 106 }
 107
 108 FuncDeclaration findGetMembers(ScopeDsymbol dsym)
 109 {
 110     return dmd.dmodule.findGetMembers(dsym);
 111 }
 112
 113 /***********************************************************
 114  * doc.d
 115  */
 116 void gendocfile(Module m, const char* ddoctext_ptr, size_t ddoctext_length,
 117                 const char* datetime, ErrorSink eSink, ref OutBuffer outbuf)
 118 {
 119     import dmd.doc;
 120     return dmd.doc.gendocfile(m, ddoctext_ptr, ddoctext_length, datetime, eSink, outbuf);
 121 }
 122
 123 /***********************************************************
 124  * dstruct.d
 125  */
 126 FuncDeclaration search_toString(StructDeclaration sd)
 127 {
 128     return dmd.dstruct.search_toString(sd);
 129 }
 130
 131 /***********************************************************
 132  * dsymbolsem.d
 133  */
 134 void dsymbolSemantic(Dsymbol dsym, Scope* sc)
 135 {
 136     import dmd.dsymbolsem;
 137     return dmd.dsymbolsem.dsymbolSemantic(dsym, sc);
 138 }
 139
 140 void addMember(Dsymbol dsym, Scope* sc, ScopeDsymbol sds)
 141 {
 142     import dmd.dsymbolsem;
 143     return dmd.dsymbolsem.addMember(dsym, sc, sds);
 144 }
 145
 146 Dsymbol search(Dsymbol d, const ref Loc loc, Identifier ident, SearchOptFlags
 147                flags = SearchOpt.all)
 148 {
 149     import dmd.dsymbolsem;
 150     return dmd.dsymbolsem.search(d, loc, ident, flags);
 151 }
 152
 153 void setScope(Dsymbol d, Scope* sc)
 154 {
 155     import dmd.dsymbolsem;
 156     return dmd.dsymbolsem.setScope(d, sc);
 157 }
 158
 159 void importAll(Dsymbol d, Scope* sc)
 160 {
 161     import dmd.dsymbolsem;
 162     return dmd.dsymbolsem.importAll(d, sc);
 163 }
 164
 165 /***********************************************************
 166  * dtemplate.d
 167  */
 168 inout(Expression) isExpression(inout RootObject o)
 169 {
 170     return dmd.dtemplate.isExpression(o);
 171 }
 172
 173 inout(Dsymbol) isDsymbol(inout RootObject o)
 174 {
 175     return dmd.dtemplate.isDsymbol(o);
 176 }
 177
 178 inout(Type) isType(inout RootObject o)
 179 {
 180     return dmd.dtemplate.isType(o);
 181 }
 182
 183 inout(Tuple) isTuple(inout RootObject o)
 184 {
 185     return dmd.dtemplate.isTuple(o);
 186 }
 187
 188 inout(Parameter) isParameter(inout RootObject o)
 189 {
 190     return dmd.dtemplate.isParameter(o);
 191 }
 192
 193 inout(TemplateParameter) isTemplateParameter(inout RootObject o)
 194 {
 195     return dmd.dtemplate.isTemplateParameter(o);
 196 }
 197
 198 bool isError(const RootObject o)
 199 {
 200     return dmd.dtemplate.isError(o);
 201 }
 202
 203 void printTemplateStats(bool listInstances, ErrorSink eSink)
 204 {
 205     return dmd.dtemplate.printTemplateStats(listInstances, eSink);
 206 }
 207
 208 /***********************************************************
 209  * dtoh.d
 210  */
 211 void genCppHdrFiles(ref Modules ms)
 212 {
 213     import dmd.dtoh;
 214     return dmd.dtoh.genCppHdrFiles(ms);
 215 }
 216
 217 /***********************************************************
 218  * enumsem.d
 219  */
 220 Expression getDefaultValue(EnumDeclaration ed, const ref Loc loc)
 221 {
 222     import dmd.enumsem;
 223     return dmd.enumsem.getDefaultValue(ed, loc);
 224 }
 225
 226 /***********************************************************
 227  * expression.d
 228  */
 229 void expandTuples(Expressions* exps, Identifiers* names = null)
 230 {
 231     return dmd.expression.expandTuples(exps, names);
 232 }
 233
 234 /***********************************************************
 235  * expressionsem.d
 236  */
 237 Expression expressionSemantic(Expression e, Scope* sc)
 238 {
 239     import dmd.expressionsem;
 240     return dmd.expressionsem.expressionSemantic(e, sc);
 241 }
 242
 243 /***********************************************************
 244  * funcsem.d
 245  */
 246 bool functionSemantic(FuncDeclaration fd)
 247 {
 248     import dmd.funcsem;
 249     return dmd.funcsem.functionSemantic(fd);
 250 }
 251
 252 bool functionSemantic3(FuncDeclaration fd)
 253 {
 254     import dmd.funcsem;
 255     return dmd.funcsem.functionSemantic3(fd);
 256 }
 257
 258 /***********************************************************
 259  * hdrgen.d
 260  */
 261 void genhdrfile(Module m, bool doFuncBodies, ref OutBuffer buf)
 262 {
 263     import dmd.hdrgen;
 264     return dmd.hdrgen.genhdrfile(m, doFuncBodies, buf);
 265 }
 266
 267 const(char)* toChars(const Statement s)
 268 {
 269     import dmd.hdrgen;
 270     return dmd.hdrgen.toChars(s);
 271 }
 272
 273 const(char)* toChars(const Expression e)
 274 {
 275     import dmd.hdrgen;
 276     return dmd.hdrgen.toChars(e);
 277 }
 278
 279 const(char)* toChars(const Initializer i)
 280 {
 281     import dmd.hdrgen;
 282     return dmd.hdrgen.toChars(i);
 283 }
 284
 285 const(char)* toChars(const Type t)
 286 {
 287     import dmd.hdrgen;
 288     return dmd.hdrgen.toChars(t);
 289 }
 290
 291 void moduleToBuffer(ref OutBuffer buf, bool vcg_ast, Module m)
 292 {
 293     import dmd.hdrgen;
 294     return dmd.hdrgen.moduleToBuffer(buf, vcg_ast, m);
 295 }
 296
 297 const(char)* parametersTypeToChars(ParameterList pl)
 298 {
 299     import dmd.hdrgen;
 300     return dmd.hdrgen.parametersTypeToChars(pl);
 301 }
 302
 303 /***********************************************************
 304  * iasm.d
 305  */
 306 Statement asmSemantic(AsmStatement s, Scope *sc)
 307 {
 308     import dmd.iasm;
 309     return dmd.iasm.asmSemantic(s, sc);
 310 }
 311
 312 void asmSemantic(CAsmDeclaration d, Scope *sc)
 313 {
 314     import dmd.iasm;
 315     return dmd.iasm.asmSemantic(d, sc);
 316 }
 317
 318 /***********************************************************
 319  * iasmgcc.d
 320  */
 321 Statement gccAsmSemantic(GccAsmStatement s, Scope *sc)
 322 {
 323     import dmd.iasmgcc;
 324     return dmd.iasmgcc.gccAsmSemantic(s, sc);
 325 }
 326
 327 void gccAsmSemantic(CAsmDeclaration d, Scope *sc)
 328 {
 329     import dmd.iasmgcc;
 330     return dmd.iasmgcc.gccAsmSemantic(d, sc);
 331 }
 332
 333 /***********************************************************
 334  * initsem.d
 335  */
 336 Initializer initializerSemantic(Initializer init, Scope* sc, ref Type tx,
 337                                 NeedInterpret needInterpret)
 338 {
 339     import dmd.initsem;
 340     return dmd.initsem.initializerSemantic(init, sc, tx, needInterpret);
 341 }
 342
 343 Expression initializerToExpression(Initializer init, Type itype = null, const
 344                                    bool isCfile = false)
 345 {
 346     import dmd.initsem;
 347     return dmd.initsem.initializerToExpression(init, itype, isCfile);
 348 }
 349
 350 /***********************************************************
 351  * json.d
 352  */
 353 void json_generate(ref Modules modules, ref OutBuffer buf)
 354 {
 355     import dmd.json;
 356     return dmd.json.json_generate(modules, buf);
 357 }
 358
 359 JsonFieldFlags tryParseJsonField(const(char)* fieldName)
 360 {
 361     import dmd.json;
 362     return dmd.json.tryParseJsonField(fieldName);
 363 }
 364
 365 /***********************************************************
 366  * mtype.d
 367  */
 368 AggregateDeclaration isAggregate(Type t)
 369 {
 370     return dmd.mtype.isAggregate(t);
 371 }
 372
 373 /***********************************************************
 374  * optimize.d
 375  */
 376 Expression optimize(Expression e, int result, bool keepLvalue = false)
 377 {
 378     import dmd.optimize;
 379     return dmd.optimize.optimize(e, result, keepLvalue);
 380 }
 381
 382 /***********************************************************
 383  * semantic2.d
 384  */
 385 void semantic2(Dsymbol dsym, Scope* sc)
 386 {
 387     import dmd.semantic2;
 388     return dmd.semantic2.semantic2(dsym, sc);
 389 }
 390
 391 /***********************************************************
 392  * semantic3.d
 393  */
 394 void semantic3(Dsymbol dsym, Scope* sc)
 395 {
 396     import dmd.semantic3;
 397     return dmd.semantic3.semantic3(dsym, sc);
 398 }
 399
 400 void semanticTypeInfoMembers(StructDeclaration sd)
 401 {
 402     import dmd.semantic3;
 403     return dmd.semantic3.semanticTypeInfoMembers(sd);
 404 }
 405
 406 /***********************************************************
 407  * statementsem.d
 408  */
 409 Statement statementSemantic(Statement s, Scope* sc)
 410 {
 411     import dmd.statementsem;
 412     return dmd.statementsem.statementSemantic(s, sc);
 413 }
 414
 415 /***********************************************************
 416  * templateparamsem.d
 417  */
 418 bool tpsemantic(TemplateParameter tp, Scope* sc, TemplateParameters* parameters)
 419 {
 420     import dmd.templateparamsem;
 421     return dmd.templateparamsem.tpsemantic(tp, sc, parameters);
 422 }
 423
 424 /***********************************************************
 425  * typesem.d
 426  */
 427 bool hasPointers(Type t)
 428 {
 429     import dmd.typesem;
 430     return dmd.typesem.hasPointers(t);
 431 }
 432
 433 Type typeSemantic(Type type, const ref Loc loc, Scope* sc)
 434 {
 435     import dmd.typesem;
 436     return dmd.typesem.typeSemantic(type, loc, sc);
 437 }
 438
 439 Type trySemantic(Type type, const ref Loc loc, Scope* sc)
 440 {
 441     import dmd.typesem;
 442     return dmd.typesem.trySemantic(type, loc, sc);
 443 }
 444
 445 Type merge(Type type)
 446 {
 447     import dmd.typesem;
 448     return dmd.typesem.merge(type);
 449 }
 450
 451 Type merge2(Type type)
 452 {
 453     import dmd.typesem;
 454     return dmd.typesem.merge2(type);
 455 }
 456
 457 Expression defaultInit(Type mt, const ref Loc loc, const bool isCfile = false)
 458 {
 459     import dmd.typesem;
 460     return dmd.typesem.defaultInit(mt, loc, isCfile);
 461 }
 462
 463 Dsymbol toDsymbol(Type type, Scope* sc)
 464 {
 465     import dmd.typesem;
 466     return dmd.typesem.toDsymbol(type, sc);
 467 }
 468
 469 Covariant covariant(Type src, Type t, StorageClass* pstc = null, bool
 470                     cppCovariant = false)
 471 {
 472     import dmd.typesem;
 473     return dmd.typesem.covariant(src, t, pstc, cppCovariant);
 474 }
 475
 476 bool isBaseOf(Type tthis, Type t, int* poffset)
 477 {
 478     import dmd.typesem;
 479     return dmd.typesem.isBaseOf(tthis, t, poffset);
 480 }
 481
 482 bool equivalent(Type src, Type t)
 483 {
 484     import dmd.typesem;
 485     return dmd.typesem.equivalent(src, t);
 486 }
 487
 488 Type sarrayOf(Type type, dinteger_t dim)
 489 {
 490     import dmd.typesem;
 491     return dmd.typesem.sarrayOf(type, dim);
 492 }
 493
 494 Type arrayOf(Type type)
 495 {
 496     import dmd.typesem;
 497     return dmd.typesem.arrayOf(type);
 498 }
 499
 500 Type constOf(Type type)
 501 {
 502     import dmd.typesem;
 503     return dmd.typesem.constOf(type);
 504 }
 505
 506 Type immutableOf(Type type)
 507 {
 508     import dmd.typesem;
 509     return dmd.typesem.immutableOf(type);
 510 }
 511
 512 Type mutableOf(Type type)
 513 {
 514     import dmd.typesem;
 515     return dmd.typesem.mutableOf(type);
 516 }
 517
 518 Type sharedOf(Type type)
 519 {
 520     import dmd.typesem;
 521     return dmd.typesem.sharedOf(type);
 522 }
 523
 524 Type sharedConstOf(Type type)
 525 {
 526     import dmd.typesem;
 527     return dmd.typesem.sharedConstOf(type);
 528 }
 529
 530 Type unSharedOf(Type type)
 531 {
 532     import dmd.typesem;
 533     return dmd.typesem.unSharedOf(type);
 534 }
 535
 536 Type wildOf(Type type)
 537 {
 538     import dmd.typesem;
 539     return dmd.typesem.wildOf(type);
 540 }
 541
 542 Type wildConstOf(Type type)
 543 {
 544     import dmd.typesem;
 545     return dmd.typesem.wildConstOf(type);
 546 }
 547
 548 Type sharedWildOf(Type type)
 549 {
 550     import dmd.typesem;
 551     return dmd.typesem.sharedWildOf(type);
 552 }
 553
 554 Type sharedWildConstOf(Type type)
 555 {
 556     import dmd.typesem;
 557     return dmd.typesem.sharedWildConstOf(type);
 558 }
 559
 560 Type substWildTo(Type type, uint mod)
 561 {
 562     import dmd.typesem;
 563     return dmd.typesem.substWildTo(type, mod);
 564 }
 565
 566 Type unqualify(Type type, uint m)
 567 {
 568     import dmd.typesem;
 569     return dmd.typesem.unqualify(type, m);
 570 }
 571
 572 Type toHeadMutable(const(Type) type)
 573 {
 574     import dmd.typesem;
 575     return dmd.typesem.toHeadMutable(type);
 576 }
 577
 578 Type aliasthisOf(Type type)
 579 {
 580     import dmd.typesem;
 581     return dmd.typesem.aliasthisOf(type);
 582 }
 583
 584 Type castMod(Type type, MOD mod)
 585 {
 586     import dmd.typesem;
 587     return dmd.typesem.castMod(type, mod);
 588 }
 589
 590 Type addMod(Type type, MOD mod)
 591 {
 592     import dmd.typesem;
 593     return dmd.typesem.addMod(type, mod);
 594 }
 595
 596 Type addStorageClass(Type type, StorageClass stc)
 597 {
 598     import dmd.typesem;
 599     return dmd.typesem.addStorageClass(type, stc);
 600 }
 601
 602 Type pointerTo(Type type)
 603 {
 604     import dmd.typesem;
 605     return dmd.typesem.pointerTo(type);
 606 }
 607
 608 Type referenceTo(Type type)
 609 {
 610     import dmd.typesem;
 611     return dmd.typesem.referenceTo(type);
 612 }
 613
 614 /***********************************************************
 615  * typinf.d
 616  */
 617 bool genTypeInfo(Expression e, const ref Loc loc, Type torig, Scope* sc)
 618 {
 619     import dmd.typinf;
 620     return dmd.typinf.genTypeInfo(e, loc, torig, sc);
 621 }
 622
 623 bool isSpeculativeType(Type t)
 624 {
 625     import dmd.typinf;
 626     return dmd.typinf.isSpeculativeType(t);
 627 }
 628
 629 bool builtinTypeInfo(Type t)
 630 {
 631     import dmd.typinf;
 632     return dmd.typinf.builtinTypeInfo(t);
 633 }
 634
 635 version (IN_LLVM)
 636 {
 637     /***********************************************************
 638      * argtypes_aarch64.d
 639      */
 640     TypeTuple toArgTypes_aarch64(Type t)
 641     {
 642         import dmd.argtypes_aarch64;
 643         return dmd.argtypes_aarch64.toArgTypes_aarch64(t);
 644     }
 645
 646     bool isHFVA(Type t, int maxNumElements = 4, Type* rewriteType = null)
 647     {
 648         import dmd.argtypes_aarch64;
 649         return dmd.argtypes_aarch64.isHFVA(t, maxNumElements, rewriteType);
 650     }
 651
 652     /***********************************************************
 653      * argtypes_sysv_x64.d
 654      */
 655     TypeTuple toArgTypes_sysv_x64(Type t)
 656     {
 657         import dmd.argtypes_sysv_x64;
 658         return dmd.argtypes_sysv_x64.toArgTypes_sysv_x64(t);
 659     }
 660
 661     /***********************************************************
 662      * argtypes_x86.d
 663      */
 664     TypeTuple toArgTypes_x86(Type t)
 665     {
 666         import dmd.argtypes_x86;
 667         return dmd.argtypes_x86.toArgTypes_x86(t);
 668     }
 669 }