Grcov report

1

//! An intermediate representation of virtual machine instructions.

2

//!

3

//! This intermediate representation provides conveniences for handling

4

//! variables, labels, and function calls.

5

use std::{

6

    borrow::{Borrow, BorrowMut},

7

    collections::HashMap,

8

    env,

9

    fmt::{Display, Write},

10

    marker::PhantomData,

11

    ops::{Deref, DerefMut},

12

    str::FromStr,

13

};

14

15

use crate::{

16

    symbol::Symbol, Comparison, Environment, Error, FromStack, Noop, StringLiteralDisplay, Value,

17

    ValueKind, ValueOrSource, VirtualMachine,

18

};

19

20

pub mod asm;

21

22

/// A label that can be jumped to.

23

349

#[derive(Debug, Clone, Eq, PartialEq)]

24

pub struct Label {

25

    pub(crate) index: usize,

26

    name: Option<Symbol>,

27

28

29

impl Display for Label {

30

    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

31

32

        if let Some(name) = &self.name {

32

            write!(f, "#{name}")

33

        } else {

34

            write!(f, "#_{}", self.index)

35

36

32

37

38

39

impl From<&Label> for Label {

40

204

    fn from(value: &Label) -> Self {

41

204

        value.clone()

42

204

43

44

45

/// A reference to a local variable.

46

863

#[derive(Debug, Clone, Eq, PartialEq)]

47

pub struct Variable {

48

    index: usize,

49

    name: Symbol,

50

51

52

impl Variable {

53

    /// Returns the index of this variable on the stack.

54

    #[must_use]

55

4308

    pub fn index(&self) -> usize {

56

4308

        self.index

57

4308

58

59

60

impl Display for Variable {

61

8

    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

62

8

        write!(f, "${}", self.name)

63

8

64

65

66

/// A reference to an argument passed to a function.

67

126

#[derive(Debug, Clone, Eq, PartialEq)]

68

pub struct Argument {

69

    index: usize,

70

    name: Symbol,

71

72

73

impl Argument {

74

    /// Returns the index of this variable on the stack.

75

    #[must_use]

76

    pub fn index(&self) -> usize {

77

        self.index

78

79

80

81

impl Display for Argument {

82

38

    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

83

38

        write!(f, "@{}", self.name)

84

38

85

86

87

/// An intermediate representation of an [`crate::Instruction`].

88

37

#[derive(Debug, Clone, PartialEq)]

89

pub enum Instruction<Intrinsic> {

90

    /// Adds `left` and `right` and places the result in `destination`.

91

///

92

    /// If this operation causes an overflow, [`Value::Void`] will be stored in

93

    /// the destination instead.

94

    Add {

95

        /// The left hand side of the operation.

96

        left: LiteralOrSource,

97

        /// The right hand side of the operation.

98

        right: LiteralOrSource,

99

        /// The destination for the result to be stored in.

100

        destination: Destination,

101

},

102

    /// Subtracts `right` from `left` and places the result in `destination`.

103

///

104

    /// If this operation causes an overflow, [`Value::Void`] will be stored in

105

    /// the destination instead.

106

    Sub {

107

        /// The left hand side of the operation.

108

        left: LiteralOrSource,

109

        /// The right hand side of the operation.

110

        right: LiteralOrSource,

111

        /// The destination for the result to be stored in.

112

        destination: Destination,

113

},

114

    /// Multiply `left` by `right` and places the result in `destination`.

115

///

116

    /// If this operation causes an overflow, [`Value::Void`] will be stored in

117

    /// the destination instead.

118

    Multiply {

119

        /// The left hand side of the operation.

120

        left: LiteralOrSource,

121

        /// The right hand side of the operation.

122

        right: LiteralOrSource,

123

        /// The destination for the result to be stored in.

124

        destination: Destination,

125

},

126

    /// Divides `left` by `right` and places the result in `destination`.

127

///

128

    /// If this operation causes an overflow, [`Value::Void`] will be stored in

129

    /// the destination instead.

130

    Divide {

131

        /// The left hand side of the operation.

132

        left: LiteralOrSource,

133

        /// The right hand side of the operation.

134

        right: LiteralOrSource,

135

        /// The destination for the result to be stored in.

136

        destination: Destination,

137

},

138

    /// Performs a logical and of `left` and `right` and places the result in

139

    /// `destination`. This operation always results in a [`Value::Boolean`].

140

///

141

    /// `left` and `right` will be checked for thruthyness. If both are truthy,

142

    /// this operation will store true in `destination`. Otherwise, false will

143

    /// be stored.

144

///

145

    /// # Short Circuiting

146

///

147

    /// This instruction will not evaluate `right`'s truthiness if `left` is

148

    /// false.

149

    LogicalAnd {

150

        /// The left hand side of the operation.

151

        left: LiteralOrSource,

152

        /// The right hand side of the operation.

153

        right: LiteralOrSource,

154

        /// The destination for the result to be stored in.

155

        destination: Destination,

156

},

157

    /// Performs a logical or of `left` and `right` and places the result in

158

    /// `destination`. This operation always results in a [`Value::Boolean`].

159

///

160

    /// `left` and `right` will be checked for thruthyness. If either are

161

    /// truthy, this operation will store true in `destination`. Otherwise,

162

    /// false will be stored.

163

///

164

    /// # Short Circuiting

165

///

166

    /// This instruction will not evaluate `right`'s truthiness if `left` is

167

    /// true.

168

    LogicalOr {

169

        /// The left hand side of the operation.

170

        left: LiteralOrSource,

171

        /// The right hand side of the operation.

172

        right: LiteralOrSource,

173

        /// The destination for the result to be stored in.

174

        destination: Destination,

175

},

176

    /// Performs a logical exclusive-or of `left` and `right` and places the result in

177

    /// `destination`. This operation always results in a [`Value::Boolean`].

178

///

179

    /// `left` and `right` will be checked for thruthyness. If one is truthy and

180

    /// the other is not, this operation will store true in `destination`.

181

    /// Otherwise, false will be stored.

182

    LogicalXor {

183

        /// The left hand side of the operation.

184

        left: LiteralOrSource,

185

        /// The right hand side of the operation.

186

        right: LiteralOrSource,

187

        /// The destination for the result to be stored in.

188

        destination: Destination,

189

},

190

    /// Performs a logical `not` operation for `value`, storing the result in

191

    /// `destination`.

192

///

193

    /// If the value is truthy, false will be stored in the destination. If the

194

    /// value is falsey, true will be stored in the destination.

195

    LogicalNot {

196

        /// The left hand side of the operation.

197

        value: LiteralOrSource,

198

        /// The destination for the result to be stored in.

199

        destination: Destination,

200

},

201

    /// Performs a bitwise and of `left` and `right` and places the result in

202

    /// `destination`. This operation always results in a [`Value::Integer`].

203

///

204

    /// If either `left` or `right ` cannot be coerced to an integer, a fault will be

205

    /// returned.

206

///

207

    /// The result will have each bit set based on whether the corresponding bit

208

    /// in both `left` and `right` are both 1.

209

    BitwiseAnd {

210

        /// The left hand side of the operation.

211

        left: LiteralOrSource,

212

        /// The right hand side of the operation.

213

        right: LiteralOrSource,

214

        /// The destination for the result to be stored in.

215

        destination: Destination,

216

},

217

    /// Performs a bitwise or of `left` and `right` and places the result in

218

    /// `destination`. This operation always results in a [`Value::Integer`].

219

///

220

    /// If either `left` or `right ` cannot be coerced to an integer, a fault will be

221

    /// returned.

222

///

223

    /// The result will have each bit set based on whether either corresponding bit

224

    /// in `left` or `right` are 1.

225

    BitwiseOr {

226

        /// The left hand side of the operation.

227

        left: LiteralOrSource,

228

        /// The right hand side of the operation.

229

        right: LiteralOrSource,

230

        /// The destination for the result to be stored in.

231

        destination: Destination,

232

},

233

    /// Performs a bitwise exclusive-or of `left` and `right` and places the

234

    /// result in `destination`. This operation always results in a

235

    /// [`Value::Integer`].

236

///

237

    /// If either `left` or `right ` cannot be coerced to an integer, a fault will be

238

    /// returned.

239

///

240

    /// The result will have each bit set based on whether only one

241

    /// corresponding bit in either `left` or `right` are 1.

242

    BitwiseXor {

243

        /// The left hand side of the operation.

244

        left: LiteralOrSource,

245

        /// The right hand side of the operation.

246

        right: LiteralOrSource,

247

        /// The destination for the result to be stored in.

248

        destination: Destination,

249

},

250

    /// Performs a bitwise not operation for `value`, storing the result in

251

    /// `destination`. This operation always results in a [`Value::Integer`].

252

///

253

    /// If `value` cannot be coerced to an integer, a fault will be returned.

254

///

255

    /// The result will be `value` with each bit flipped.

256

    BitwiseNot {

257

        /// The left hand side of the operation.

258

        value: LiteralOrSource,

259

        /// The destination for the result to be stored in.

260

        destination: Destination,

261

},

262

    /// Converts a value to another type, storing the result in `destination`.

263

///

264

    /// If `value` cannot be converted, a fault will be returned.

265

    Convert {

266

        /// The left hand side of the operation.

267

        value: LiteralOrSource,

268

        /// The type to convert to.

269

        kind: ValueKind,

270

        /// The destination for the converted value to be stored in.

271

        destination: Destination,

272

},

273

    /// Performs a bitwise shift left of `left` by `right` bits, storing

274

    /// the result in `destination`.

275

///

276

    /// This operation requires both operands to be integers. If either are not

277

    /// integers, a fault will be returned.

278

    ShiftLeft {

279

        /// The value to shift

280

        left: LiteralOrSource,

281

        /// The number of bits to shift by

282

        right: LiteralOrSource,

283

        /// The destination for the result to be stored in.

284

        destination: Destination,

285

},

286

    /// Performs a bitwise shift right of `left` by `right` bits, storing the

287

    /// result in `destination`.

288

///

289

    /// This operation requires both operands to be integers. If either are not

290

    /// integers, a fault will be returned.

291

    ShiftRight {

292

        /// The value to shift

293

        left: LiteralOrSource,

294

        /// The number of bits to shift by

295

        right: LiteralOrSource,

296

        /// The destination for the result to be stored in.

297

        destination: Destination,

298

},

299

    /// Checks [`condition.is_truthy()`](Value::is_truthy), jumping to the

300

    /// target label if false.

301

///

302

    /// If truthy, the virtual machine continues executing the next instruction

303

    /// in sequence.

304

///

305

    /// If not truthy, the virtual machine jumps to label `false_jump_to`.

306

    If {

307

        /// The source of the condition.

308

        condition: LiteralOrSource,

309

        /// The label to jump to if the condition is falsey.

310

        false_jump_to: Label,

311

},

312

    /// Jump execution to the address of the given [`Label`].

313

    JumpTo(Label),

314

    /// Labels the next instruction with the given [`Label`].

315

    Label(Label),

316

    /// Compares `left` and `right` using `comparison` to evaluate a boolean

317

    /// result.

318

///

319

    /// If [`CompareAction::Store`] is used, the boolean result will be stored

320

    /// in the provided destination.

321

///

322

    /// If [`CompareAction::JumpIfFalse`] is used and the result is false,

323

    /// execution will jump to the label specified. If the result is true, the

324

    /// next instruction will continue executing.

325

    Compare {

326

        /// The comparison to perform.

327

        comparison: Comparison,

328

        /// The left hand side of the operation.

329

        left: LiteralOrSource,

330

        /// The right hand side of the operation.

331

        right: LiteralOrSource,

332

        /// The action to take with the result of the comparison.

333

        action: CompareAction,

334

},

335

    /// Pushes a value to the stack.

336

    Push(LiteralOrSource),

337

    /// Loads a `value` into a variable.

338

    Load {

339

        /// The index of the variable to store the value in.

340

        value: LiteralOrSource,

341

        /// The value or source of the value to store.

342

        variable: Variable,

343

},

344

    /// Returns from the current stack frame.

345

    Return(Option<LiteralOrSource>),

346

    /// Calls a function.

347

///

348

    /// When calling a function, values on the stack are "passed" to the

349

    /// function being pushed to the stack before calling the function. To

350

    /// ensure the correct number of arguments are taken even when variable

351

    /// argument lists are supported, the number of arguments is passed and

352

    /// controls the baseline of the stack.

353

///

354

    /// Upon returning from a function call, the arguments will no longer be on

355

    /// the stack. The value returned from the function (or [`Value::Void`] if

356

    /// no value was returned) will be placed in `destination`.

357

    Call {

358

        /// The name of the function to call. If None, the current function is

359

        /// called recursively.

360

        function: Option<Symbol>,

361

362

        /// The number of arguments on the stack that should be used as

363

        /// arguments to this call.

364

        arg_count: usize,

365

366

        /// The destination for the result of the call.

367

        destination: Destination,

368

},

369

    /// Calls an intrinsic runtime function.

370

///

371

    /// When calling a function, values on the stack are "passed" to the

372

    /// function being pushed to the stack before calling the function. To

373

    /// ensure the correct number of arguments are taken even when variable

374

    /// argument lists are supported, the number of arguments is passed and

375

    /// controls the baseline of the stack.

376

///

377

    /// Upon returning from a function call, the arguments will no longer be on

378

    /// the stack. The value returned from the function (or [`Value::Void`] if

379

    /// no value was returned) will be placed in `destination`.

380

    CallIntrinsic {

381

        /// The runtime intrinsic to call.

382

        intrinsic: Intrinsic,

383

        /// The number of arguments on the stack that should be used as

384

        /// arguments to this call.

385

        arg_count: usize,

386

        /// The destination for the result of the call.

387

        destination: Destination,

388

},

389

    /// Calls a function by name on a value.

390

///

391

    /// When calling a function, values on the stack are "passed" to the

392

    /// function being pushed to the stack before calling the function. To

393

    /// ensure the correct number of arguments are taken even when variable

394

    /// argument lists are supported, the number of arguments is passed and

395

    /// controls the baseline of the stack.

396

///

397

    /// Upon returning from a function call, the arguments will no longer be on

398

    /// the stack. The value returned from the function (or [`Value::Void`] if

399

    /// no value was returned) will be placed in `destination`.

400

    CallInstance {

401

        /// The target of the function call. If [`LiteralOrSource::Stack`], the value on

402

        /// the stack prior to the arguments is the target of the call.

403

        target: LiteralOrSource,

404

        /// The name of the function to call.

405

        name: Symbol,

406

        /// The number of arguments on the stack that should be used as

407

        /// arguments to this call.

408

        arg_count: usize,

409

        /// The destination for the result of the call.

410

        destination: Destination,

411

},

412

413

414

impl<Intrinsic> Display for Instruction<Intrinsic>

415

where

416

    Intrinsic: Display,

417

418

    #[allow(clippy::too_many_lines)]

419

80

    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

420

80

        match self {

421

            Instruction::Add {

422

3

                left,

423

3

                right,

424

3

                destination,

425

3

            } => write!(f, "add {left} {right} {destination}"),

426

            Instruction::Sub {

427

4

                left,

428

4

                right,

429

4

                destination,

430

4

            } => write!(f, "sub {left} {right} {destination}"),

431

            Instruction::Multiply {

432

2

                left,

433

2

                right,

434

2

                destination,

435

2

            } => write!(f, "mul {left} {right} {destination}"),

436

            Instruction::Divide {

437

2

                left,

438

2

                right,

439

2

                destination,

440

2

            } => write!(f, "div {left} {right} {destination}"),

441

            Instruction::LogicalAnd {

442

2

                left,

443

2

                right,

444

2

                destination,

445

2

            } => write!(f, "and {left} {right} {destination}"),

446

            Instruction::LogicalOr {

447

2

                left,

448

2

                right,

449

2

                destination,

450

2

            } => write!(f, "or {left} {right} {destination}"),

451

            Instruction::LogicalXor {

452

2

                left,

453

2

                right,

454

2

                destination,

455

2

            } => write!(f, "xor {left} {right} {destination}"),

456

            Instruction::BitwiseAnd {

457

2

                left,

458

2

                right,

459

2

                destination,

460

2

            } => write!(f, "bitand {left} {right} {destination}"),

461

            Instruction::BitwiseOr {

462

2

                left,

463

2

                right,

464

2

                destination,

465

2

            } => write!(f, "bitor {left} {right} {destination}"),

466

            Instruction::BitwiseXor {

467

2

                left,

468

2

                right,

469

2

                destination,

470

2

            } => write!(f, "bitxor {left} {right} {destination}"),

471

            Instruction::ShiftLeft {

472

2

                left,

473

2

                right,

474

2

                destination,

475

2

            } => write!(f, "shl {left} {right} {destination}"),

476

            Instruction::ShiftRight {

477

2

                left,

478

2

                right,

479

2

                destination,

480

2

            } => write!(f, "shr {left} {right} {destination}"),

481

2

            Instruction::LogicalNot { value, destination } => {

482

2

                write!(f, "not {value} {destination}")

483

484

2

            Instruction::BitwiseNot { value, destination } => {

485

2

                write!(f, "bitnot {value} {destination}")

486

487

            Instruction::Convert {

488

8

                value,

489

8

                kind,

490

8

                destination,

491

8

            } => {

492

8

                write!(f, "convert {value} {kind} {destination}")

493

494

            Instruction::If {

495

2

                condition,

496

2

                false_jump_to,

497

2

            } => write!(f, "ifnot {condition} {false_jump_to}"),

498

2

            Instruction::JumpTo(label) => write!(f, "jump {label}"),

499

3

            Instruction::Label(label) => Display::fmt(label, f),

500

            Instruction::Compare {

501

13

                comparison,

502

13

                left,

503

13

                right,

504

13

                action,

505

13

            } => write!(f, "{comparison} {left} {right} {action}"),

506

2

            Instruction::Push(value) => write!(f, "push {value}"),

507

2

            Instruction::Load { value, variable } => write!(f, "load {value} {variable}"),

508

5

            Instruction::Return(opt_value) => {

509

5

                if let Some(value) = opt_value {

510

3

                    write!(f, "return {value}")

511

                } else {

512

2

                    f.write_str("return")

513

514

515

            Instruction::Call {

516

6

                function,

517

6

                arg_count,

518

6

                destination,

519

            } => {

520

6

                if let Some(function) = function {

521

2

                    write!(f, "call {function} {arg_count} {destination}")

522

                } else {

523

4

                    write!(f, "recurse {arg_count} {destination}")

524

525

526

            Instruction::CallIntrinsic {

527

2

                intrinsic,

528

2

                arg_count,

529

2

                destination,

530

2

            } => {

531

2

                write!(f, "intrinsic {intrinsic} {arg_count} {destination}")

532

533

            Instruction::CallInstance {

534

4

                target,

535

4

                name,

536

4

                arg_count,

537

4

                destination,

538

4

            } => {

539

4

                write!(f, "invoke {target} {name} {arg_count} {destination}")

540

541

542

80

543

544

545

/// A literal value.

546

382

#[derive(Debug, Clone, PartialEq)]

547

pub enum Literal {

548

    /// A literal that represents [`Value::Void`].

549

    Void,

550

    /// A signed 64-bit integer literal value.

551

    Integer(i64),

552

    /// A real number literal value (64-bit floating point).

553

    Real(f64),

554

    /// A boolean literal.

555

    Boolean(bool),

556

    /// A string literal.

557

    String(String),

558

559

560

impl From<i64> for Literal {

561

    fn from(value: i64) -> Self {

562

        Self::Integer(value)

563

564

565

566

impl From<f64> for Literal {

567

    fn from(value: f64) -> Self {

568

        Self::Real(value)

569

570

571

572

impl From<bool> for Literal {

573

    fn from(value: bool) -> Self {

574

        Self::Boolean(value)

575

576

577

578

impl From<String> for Literal {

579

    fn from(value: String) -> Self {

580

        Self::String(value)

581

582

583

584

impl<'a> From<&'a str> for Literal {

585

12

    fn from(value: &'a str) -> Self {

586

12

        Self::String(value.to_owned())

587

12

588

589

590

impl Literal {

591

    /// Create an instance of this literal in the given [`Environment`].

592

    #[must_use]

593

252

    pub fn instantiate<Env>(&self) -> Value

594

252

    where

595

252

        Env: Environment,

596

252

597

252

        match self {

598

            Literal::Void => Value::Void,

599

187

            Literal::Integer(value) => Value::Integer(*value),

600

9

            Literal::Real(value) => Value::Real(*value),

601

43

            Literal::Boolean(value) => Value::Boolean(*value),

602

13

            Literal::String(value) => Value::dynamic(<Env::String as From<&str>>::from(value)),

603

604

252

605

606

607

impl Display for Literal {

608

134

    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

609

134

        match self {

610

50

            Self::Integer(value) => Display::fmt(value, f),

611

2

            Self::Real(value) => write!(f, "{value:?}"),

612

4

            Self::Boolean(value) => Display::fmt(value, f),

613

2

            Self::String(string) => Display::fmt(&StringLiteralDisplay::new(string), f),

614

76

            Self::Void => f.write_str("void"),

615

616

134

617

618

619

/// The source of a value.

620

#[derive(Debug, Clone)]

621

pub enum ValueSource {

622

    /// The value is in an argument at the provided 0-based index.

623

    Argument(usize),

624

    /// The value is in a variable specified.

625

    Variable(Variable),

626

627

628

impl Display for ValueSource {

629

    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

630

        match self {

631

            ValueSource::Argument(arg) => Display::fmt(arg, f),

632

            ValueSource::Variable(variable) => Display::fmt(variable, f),

633

634

635

636

637

impl<'a> From<&'a ValueSource> for crate::ValueSource {

638

    fn from(source: &'a ValueSource) -> Self {

639

        match source {

640

            ValueSource::Argument(arg) => Self::Argument(*arg),

641

            ValueSource::Variable(var) => Self::Variable(var.index),

642

643

644

645

646

/// A literal value or a location of a value

647

49

#[derive(Debug, Clone, PartialEq)]

648

pub enum LiteralOrSource {

649

    /// A literal.

650

    Literal(Literal),

651

    /// The value is in an argument at the provided 0-based index.

652

    Argument(Argument), // Make this like Variable

653

    /// The value is in a variable specified.

654

    Variable(Variable),

655

    /// The value is popped from the stack

656

///

657

    /// The order of popping is the order the fields apear in the [`Instruction`]

658

    Stack,

659

660

661

macro_rules! impl_simple_enum_from {

662

    ($enum:ident, $from_type:ident) => {

663

        impl From<$from_type> for $enum {

664

72

            fn from(value: $from_type) -> Self {

665

72

                Self::$from_type(value)

666

72

667

668

        impl<'a> From<&'a $from_type> for $enum {

669

48

            fn from(value: &'a $from_type) -> Self {

670

48

                Self::$from_type(value.clone())

671

48

672

673

};

674

    ($enum:ident, $from_type:ty, $variant:ident) => {

675

        impl From<$from_type> for $enum {

676

            fn from(value: $from_type) -> Self {

677

                Self::$variant(value.into())

678

679

680

};

681

682

683

impl_simple_enum_from!(LiteralOrSource, Literal);

684

impl_simple_enum_from!(LiteralOrSource, bool, Literal);

685

impl_simple_enum_from!(LiteralOrSource, i64, Literal);

686

impl_simple_enum_from!(LiteralOrSource, f64, Literal);

687

impl_simple_enum_from!(LiteralOrSource, String, Literal);

688

impl_simple_enum_from!(LiteralOrSource, &str, Literal);

689

impl_simple_enum_from!(LiteralOrSource, Argument);

690

impl_simple_enum_from!(LiteralOrSource, Variable);

691

692

impl LiteralOrSource {

693

    /// Instantiates this into a [`ValueOrSource`], promoting [`Literal`]s to

694

    /// [`Value`]s.

695

    #[must_use]

696

447

    pub fn instantiate<Env>(&self) -> ValueOrSource

697

447

    where

698

447

        Env: Environment,

699

447

700

447

        match self {

701

252

            LiteralOrSource::Literal(literal) => ValueOrSource::Value(literal.instantiate::<Env>()),

702

23

            LiteralOrSource::Argument(index) => ValueOrSource::Argument(index.index),

703

167

            LiteralOrSource::Variable(index) => ValueOrSource::Variable(index.index),

704

5

            LiteralOrSource::Stack => ValueOrSource::Stack,

705

706

447

707

708

709

impl Display for LiteralOrSource {

710

204

    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

711

204

        match self {

712

134

            LiteralOrSource::Literal(value) => Display::fmt(value, f),

713

38

            LiteralOrSource::Argument(arg) => Display::fmt(arg, f),

714

4

            LiteralOrSource::Variable(variable) => Display::fmt(variable, f),

715

28

            LiteralOrSource::Stack => Display::fmt("$", f),

716

717

204

718

719

720

/// A destination for a value.

721

78

#[derive(Debug, Clone, Eq, PartialEq)]

722

pub enum Destination {

723

    /// Store the value in the 0-based variable index provided.

724

    Variable(Variable),

725

    /// Push the value to the stack.

726

    Stack,

727

    /// Store the value in the return register.

728

    Return,

729

730

731

impl_simple_enum_from!(Destination, Variable);

732

733

impl Display for Destination {

734

116

    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

735

116

        match self {

736

2

            Destination::Variable(variable) => Display::fmt(&variable, f),

737

100

            Destination::Stack => f.write_str("$"),

738

14

            Destination::Return => f.write_str("$$"),

739

740

116

741

742

743

impl<'a> From<&'a Destination> for crate::Destination {

744

1752

    fn from(source: &'a Destination) -> Self {

745

1752

        match source {

746

744

            Destination::Variable(variable) => Self::Variable(variable.index),

747

180

            Destination::Stack => Self::Stack,

748

828

            Destination::Return => Self::Return,

749

750

1752

751

752

753

/// An action to take during an [`Instruction::Compare`].

754

6

#[derive(Debug, Clone, Eq, PartialEq)]

755

pub enum CompareAction {

756

    /// Store the boolean result in the destination indicated.

757

    Store(Destination),

758

    /// If the comparison is false, jump to the 0-based instruction index

759

    /// indicated.

760

    JumpIfFalse(Label),

761

762

763

impl From<&CompareAction> for CompareAction {

764

    fn from(value: &CompareAction) -> Self {

765

        value.clone()

766

767

768

769

impl From<Destination> for CompareAction {

770

    fn from(value: Destination) -> Self {

771

        Self::Store(value)

772

773

774

775

impl From<&Destination> for CompareAction {

776

    fn from(value: &Destination) -> Self {

777

        value.clone().into()

778

779

780

781

impl Display for CompareAction {

782

24

    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

783

24

        match self {

784

10

            CompareAction::Store(destination) => Display::fmt(destination, f),

785

14

            CompareAction::JumpIfFalse(label) => write!(f, "jump {label}"),

786

787

24

788

789

790

impl CompareAction {

791

    /// Converts this intermediate representation of a compare action to the

792

    /// virtual machines [`CompareAction`](crate::CompareAction).

793

384

    pub fn link(&self, labels: &[Option<usize>]) -> Result<crate::CompareAction, LinkError> {

794

384

        match self {

795

192

            CompareAction::Store(destination) => {

796

192

                Ok(crate::CompareAction::Store(destination.into()))

797

798

192

            CompareAction::JumpIfFalse(target) => Ok(crate::CompareAction::JumpIfFalse(

799

192

                labels

800

192

                    .get(target.index)

801

192

                    .and_then(|label| *label)

802

192

                    .ok_or_else(|| LinkError::InvalidLabel(target.clone()))?,

803

)),

804

805

384

806

807

808

/// A type that helps build [`CodeBlock`]s.

809

pub struct CodeBlockBuilder<Intrinsic> {

810

    label_counter: usize,

811

    named_labels: HashMap<Symbol, Label>,

812

    ops: Vec<Instruction<Intrinsic>>,

813

    args: Vec<Argument>,

814

    temporary_variables: usize,

815

    scope: HashMap<Symbol, ScopeSymbol>,

816

    loops: LoopLabels,

817

    variables: HashMap<Symbol, Variable>,

818

819

820

impl<Intrinsic> Default for CodeBlockBuilder<Intrinsic> {

821

120

    fn default() -> Self {

822

120

        Self {

823

120

            label_counter: 0,

824

120

            named_labels: HashMap::default(),

825

120

            ops: Vec::default(),

826

120

            args: Vec::default(),

827

120

            temporary_variables: 0,

828

120

            scope: HashMap::default(),

829

120

            loops: LoopLabels::default(),

830

120

            variables: HashMap::default(),

831

120

832

120

833

834

835

impl<Intrinsic> CodeBlockBuilder<Intrinsic> {

836

    /// Adds a new argument with the given name.

837

14

    pub fn new_argument(&mut self, name: impl Into<Symbol>) -> Argument {

838

14

        let index = self.args.len();

839

14

        let argument = Argument {

840

14

            index,

841

14

            name: name.into(),

842

14

};

843

14

        self.args.push(argument.clone());

844

14

        self.add_symbol(

845

14

            argument.name.clone(),

846

14

            ScopeSymbol::Argument(argument.clone()),

847

14

);

848

14

        argument

849

14

850

851

    /// Finds an argument by a given name, or None if not found.

852

    #[must_use]

853

4

    pub fn argument(&self, name: &Symbol) -> Option<Argument> {

854

4

        self.args.iter().find(|arg| &arg.name == name).cloned()

855

4

856

857

    /// Adds a new symbol to this code block.

858

230

    fn add_symbol(&mut self, symbol: impl Into<Symbol>, value: ScopeSymbol) {

859

230

        self.scope.insert(symbol.into(), value);

860

230

861

862

    /// Create a new label.

863

103

    pub fn new_label(&mut self) -> Label {

864

103

        let label_id = self.label_counter;

865

103

        self.label_counter += 1;

866

103

        Label {

867

103

            index: label_id,

868

103

            name: None,

869

103

870

103

871

872

    /// Create a new label with a given name.

873

8

    pub fn named_label(&mut self, name: impl Into<Symbol>) -> Label {

874

8

        let name = name.into();

875

8

        if let Some(label) = self.named_labels.get(&name).cloned() {

876

4

            label

877

        } else {

878

4

            let mut label = self.new_label();

879

4

            label.name = Some(name.clone());

880

4

            self.named_labels.insert(name, label.clone());

881

4

            label

882

883

8

884

885

    /// Push an instruction.

886

///

887

    /// To push a value to the stack use [`push_to_stack`](Self::push_to_stack).

888

782

    pub fn push(&mut self, operation: Instruction<Intrinsic>) {

889

782

        self.ops.push(operation);

890

782

891

892

    /// Looks up a symbol.

893

    #[must_use]

894

151

    pub fn lookup(&self, symbol: &Symbol) -> Option<&ScopeSymbol> {

895

151

        self.scope.get(symbol)

896

151

897

898

    /// Returns the loop information for a given name, or the current loop if no

899

    /// name is provided.

900

    #[must_use]

901

7

    pub fn loop_info(&self, name: Option<&Symbol>) -> Option<&LoopInfo> {

902

7

        self.loops.find(name)

903

7

904

905

    /// Adds the appropriate instruction to store `value` into `destination`.

906

222

    pub fn store_into_destination(&mut self, value: LiteralOrSource, destination: Destination) {

907

222

        match destination {

908

90

            Destination::Variable(variable) => {

909

90

                self.push(Instruction::Load { value, variable });

910

90

911

69

            Destination::Stack => {

912

69

                self.push(Instruction::Push(value));

913

69

914

63

            Destination::Return => {

915

63

                self.push(Instruction::Return(Some(value)));

916

63

917

918

222

919

920

    /// Adds the correct instruction to load a value from `symbol` and store it

921

    /// in `destination`.

922

    pub fn load_from_symbol(

923

        &mut self,

924

        symbol: &Symbol,

925

        destination: Destination,

926

    ) -> Result<(), LinkError> {

927

17

        match self.scope.get(symbol) {

928

            Some(ScopeSymbol::Argument(index)) => {

929

                self.store_into_destination(LiteralOrSource::Argument(index.clone()), destination);

930

                Ok(())

931

932

17

            Some(ScopeSymbol::Variable(variable)) => {

933

17

                self.store_into_destination(

934

17

                    LiteralOrSource::Variable(variable.clone()),

935

17

                    destination,

936

17

);

937

17

                Ok(())

938

939

            _ => Err(LinkError::UndefinedIdentifier(symbol.clone())),

940

941

17

942

943

    /// Looks up an existing location for a variable with the provided `name`.

944

    /// If an existing location is not found, new space will be allocated for

945

    /// it and returned.

946

225

    pub fn variable_index_from_name(&mut self, name: &Symbol) -> Variable {

947

225

        let new_index = self.variables.len();

948

225

        let variable = self

949

225

            .variables

950

225

            .entry(name.clone())

951

225

            .or_insert_with(|| Variable {

952

193

                index: new_index,

953

193

                name: name.clone(),

954

225

})

955

225

            .clone();

956

225

        if variable.index == new_index {

957

193

            self.add_symbol(name.clone(), ScopeSymbol::Variable(variable.clone()));

958

194

959

225

        variable

960

225

961

962

    /// Creates a new temporary variable.

963

///

964

    /// Internally this simply uses a counter to create a new variable each time

965

    /// this is called named `$1`, `$2`, and so on.

966

141

    pub fn new_temporary_variable(&mut self) -> Variable {

967

141

        self.temporary_variables += 1;

968

141

        let variable = self.variable_index_from_name(&Symbol::from(

969

141

            format!("${}", self.temporary_variables).as_str(),

970

141

));

971

141

        variable

972

141

973

974

    /// Returns the completed code block.

975

    #[must_use]

976

117

    pub fn finish(self) -> CodeBlock<Intrinsic> {

977

117

        CodeBlock {

978

117

            arguments: self.args.into_iter().map(|arg| arg.name).collect(),

979

117

            variables: self.variables.len(),

980

117

            code: self.ops,

981

117

982

117

983

984

    /// Returns the collection of known variables.

985

    #[must_use]

986

98

    pub fn variables(&self) -> &HashMap<Symbol, Variable> {

987

98

        &self.variables

988

98

989

990

991

macro_rules! op {

992

    ($($(#[doc = $doc:expr])* $name:ident $variant:ident {$($field:ident: $type:ty),+$(,)?});+$(;)?) => {

993

        $($(#[doc = $doc])*

994

3

        pub fn $name(

995

3

            &mut self,

996

3

            $($field: impl Into<$type>,)+

997

3

) {

998

3

            self.push(Instruction::$variant {

999

3

                $($field: $field.into(),)+

1000

3

})

1001

3

})+

1002

};

1003

    ($($(#[doc = $doc:expr])* $name:ident $variant:ident ($($field:ident: $type:ty),+$(,)?));+$(;)?) => {

1004

        $($(#[doc = $doc])*

1005

125

        pub fn $name(

1006

125

            &mut self,

1007

125

            $($field: impl Into<$type>,)+

1008

125

) {

1009

125

            self.push(Instruction::$variant (

1010

125

                $( $field.into(),)+

1011

125

))

1012

125

})+

1013

};

1014

1015

1016

macro_rules! unaryop {

1017

    ($($(#[doc = $doc:expr])* $name:ident $variant:ident);+$(;)?) => {

1018

        op!{$(

1019

            $(#[doc = $doc])*

1020

            $name $variant{value: LiteralOrSource, destination: Destination};

1021

)+}

1022

};

1023

1024

1025

macro_rules! binop {

1026

    ($($(#[doc = $doc:expr])* $name:ident $variant:ident);+$(;)?) => {

1027

        op!{$(

1028

            $(#[doc = $doc])*

1029

            $name $variant{left: LiteralOrSource, right: LiteralOrSource, destination: Destination};

1030

)+}

1031

};

1032

1033

1034

/// Builder like functions adding instructions skipping the need of pushing the instructions

1035

/// manually.

1036

impl<Intrinsic> CodeBlockBuilder<Intrinsic> {

1037

    binop! {

1038

        /// Adds `left` and `right` and places the result in `destination`.

1039

///

1040

        /// If this operation causes an overflow, [`Value::Void`] will be stored in

1041

        /// the destination instead.

1042

        add Add;

1043

        /// Subtracts `right` from `left` and places the result in `destination`.

1044

///

1045

        /// If this operation causes an overflow, [`Value::Void`] will be stored in

1046

        /// the destination instead.

1047

        sub Sub;

1048

        /// Multiply `left` by `right` and places the result in `destination`.

1049

///

1050

        /// If this operation causes an overflow, [`Value::Void`] will be stored in

1051

        /// the destination instead.

1052

        multiply Multiply;

1053

        /// Divides `left` by `right` and places the result in `destination`.

1054

///

1055

        /// If this operation causes an overflow, [`Value::Void`] will be stored in

1056

        /// the destination instead.

1057

        divide Divide;

1058

        /// Performs a logical and of `left` and `right` and places the result in

1059

        /// `destination`. This operation always results in a [`Value::Boolean`].

1060

///

1061

        /// `left` and `right` will be checked for thruthyness. If both are truthy,

1062

        /// this operation will store true in `destination`. Otherwise, false will

1063

        /// be stored.

1064

///

1065

        /// # Short Circuiting

1066

///

1067

        /// This instruction will not evaluate `right`'s truthiness if `left` is

1068

        /// false.

1069

        logical_and LogicalAnd;

1070

        /// Performs a logical or of `left` and `right` and places the result in

1071

        /// `destination`. This operation always results in a [`Value::Boolean`].

1072

///

1073

        /// `left` and `right` will be checked for thruthyness. If either are

1074

        /// truthy, this operation will store true in `destination`. Otherwise,

1075

        /// false will be stored.

1076

///

1077

        /// # Short Circuiting

1078

///

1079

        /// This instruction will not evaluate `right`'s truthiness if `left` is

1080

        /// true.

1081

        logical_or LogicalOr;

1082

        /// Performs a logical exclusive-or of `left` and `right` and places the result in

1083

        /// `destination`. This operation always results in a [`Value::Boolean`].

1084

///

1085

        /// `left` and `right` will be checked for thruthyness. If one is truthy and

1086

        /// the other is not, this operation will store true in `destination`.

1087

        /// Otherwise, false will be stored.

1088

        logical_xor LogicalXor;

1089

1090

    unaryop! {

1091

        /// Performs a logical `not` operation for `value`, storing the result in

1092

        /// `destination`.

1093

///

1094

        /// If the value is truthy, false will be stored in the destination. If the

1095

        /// value is falsey, true will be stored in the destination.

1096

        logical_not LogicalNot

1097

1098

    binop! {

1099

        /// Performs a bitwise and of `left` and `right` and places the result in

1100

        /// `destination`. This operation always results in a [`Value::Integer`].

1101

///

1102

        /// If either `left` or `right ` cannot be coerced to an integer, a fault will be

1103

        /// returned.

1104

///

1105

        /// The result will have each bit set based on whether the corresponding bit

1106

        /// in both `left` and `right` are both 1.

1107

        bitwise_and BitwiseAnd;

1108

        /// Performs a bitwise or of `left` and `right` and places the result in

1109

        /// `destination`. This operation always results in a [`Value::Integer`].

1110

///

1111

        /// If either `left` or `right ` cannot be coerced to an integer, a fault will be

1112

        /// returned.

1113

///

1114

        /// The result will have each bit set based on whether either corresponding bit

1115

        /// in `left` or `right` are 1.

1116

        bitwise_or BitwiseOr;

1117

        /// Performs a bitwise exclusive-or of `left` and `right` and places the

1118

        /// result in `destination`. This operation always results in a

1119

        /// [`Value::Integer`].

1120

///

1121

        /// If either `left` or `right ` cannot be coerced to an integer, a fault will be

1122

        /// returned.

1123

///

1124

        /// The result will have each bit set based on whether only one

1125

        /// corresponding bit in either `left` or `right` are 1.

1126

        bitwise_xor BitwiseXor;

1127

1128

    unaryop! {

1129

        /// Performs a bitwise not operation for `value`, storing the result in

1130

        /// `destination`. This operation always results in a [`Value::Integer`].

1131

///

1132

        /// If `value` cannot be coerced to an integer, a fault will be returned.

1133

///

1134

        /// The result will be `value` with each bit flipped.

1135

        bitwise_not BitwiseNot;

1136

1137

    op! {

1138

        /// Converts a value to another type, storing the result in `destination`.

1139

///

1140

        /// If `value` cannot be converted, a fault will be returned.

1141

        convert Convert {

1142

            value: LiteralOrSource,

1143

            kind: ValueKind,

1144

            destination: Destination,

1145

};

1146

1147

    binop! {

1148

        /// Performs a bitwise shift left of `left` by `right` bits, storing

1149

        /// the result in `destination`.

1150

///

1151

        /// This operation requires both operands to be integers. If either are not

1152

        /// integers, a fault will be returned.

1153

        shift_left ShiftLeft;

1154

        /// Performs a bitwise shift right of `left` by `right` bits, storing the

1155

        /// result in `destination`.

1156

///

1157

        /// This operation requires both operands to be integers. If either are not

1158

        /// integers, a fault will be returned.

1159

        shift_right ShiftRight;

1160

1161

    op! {

1162

        /// Checks [`condition.is_truthy()`](Value::is_truthy), jumping to the

1163

        /// target label if false.

1164

///

1165

        /// If truthy, the virtual machine continues executing the next instruction

1166

        /// in sequence.

1167

///

1168

        /// If not truthy, the virtual machine jumps to label `false_jump_to`.

1169

///

1170

        /// Consider using [`begin_if()`](Self::begin_if) instead for a more convinient

1171

        /// option.

1172

        jump_if_false If {

1173

            condition: LiteralOrSource,

1174

            false_jump_to: Label,

1175

};

1176

1177

    /// Begins an if block with the given condition.

1178

///

1179

    /// If the condition is the result of a comparsion consider

1180

    /// [`begin_if_comparison()`](Self::begin_if_comparison).

1181

3

    pub fn begin_if(&mut self, condition: impl Into<LiteralOrSource>) -> If<'_, Intrinsic> {

1182

3

        let label = self.new_label();

1183

3

        self.jump_if_false(condition, &label);

1184

3

        If {

1185

3

            label: Some(label),

1186

3

            code_block: self,

1187

3

1188

3

1189

    op! {

1190

        /// Jump execution to the address of the given [`Label`].

1191

///

1192

        /// Consider using [`begin_loop()`](Self::begin_loop) instead of using

1193

        /// `jump_to` for looping.

1194

        jump_to JumpTo(label: Label);

1195

        /// Labels the next instruction with the given [`Label`].

1196

        label Label(label: Label);

1197

1198

    /// Begins a loop with the given `name`. The result of the loop will be

1199

    /// stored in `result`. If the loop does not return a result, the

1200

    /// destination will be untouched.

1201

12

    pub fn begin_loop(

1202

12

        &mut self,

1203

12

        name: Option<Symbol>,

1204

12

        result: Destination,

1205

12

    ) -> LoopScope<'_, Self, Intrinsic> {

1206

12

        let break_label = self.new_label();

1207

12

        let continue_label = self.new_label();

1208

12

        self.loops.begin(LoopInfo {

1209

12

            name,

1210

12

            break_label: break_label.clone(),

1211

12

            continue_label: continue_label.clone(),

1212

12

            loop_result: result,

1213

12

});

1214

12

        LoopScope {

1215

12

            owner: self,

1216

12

            break_label,

1217

12

            continue_label,

1218

12

            _intrinsic: PhantomData,

1219

12

1220

12

1221

    op! {

1222

        /// Compares `left` and `right` using `comparison` to evaluate a boolean

1223

        /// result.

1224

///

1225

        /// If [`CompareAction::Store`] is used, the boolean result will be stored

1226

        /// in the provided destination.

1227

///

1228

        /// If [`CompareAction::JumpIfFalse`] is used and the result is false,

1229

        /// execution will jump to the label specified. If the result is true, the

1230

        /// next instruction will continue executing. Consider `begin_if_comparison`

1231

        /// for more convinient jumping.

1232

        compare Compare {

1233

            comparison: Comparison,

1234

            left: LiteralOrSource,

1235

            right: LiteralOrSource,

1236

            action: CompareAction,

1237

1238

1239

    /// Begins an if block with the given comparison.

1240

25

    pub fn begin_if_comparison(

1241

25

        &mut self,

1242

25

        comparison: Comparison,

1243

25

        left: impl Into<LiteralOrSource>,

1244

25

        right: impl Into<LiteralOrSource>,

1245

25

    ) -> If<'_, Intrinsic> {

1246

25

        let label = self.new_label();

1247

25

        self.push(Instruction::Compare {

1248

25

            comparison,

1249

25

            left: left.into(),

1250

25

            right: right.into(),

1251

25

            action: CompareAction::JumpIfFalse(label.clone()),

1252

25

});

1253

25

        If {

1254

25

            label: Some(label),

1255

25

            code_block: self,

1256

25

1257

25

1258

    op! {

1259

        /// Pushes a value to the stack.

1260

        push_to_stack Push(value: LiteralOrSource)

1261

1262

    op! {

1263

        /// Loads a `value` into a variable.

1264

        load Load {

1265

            value: LiteralOrSource,

1266

            variable: Variable,

1267

1268

1269

    // I have to admit, part of having two functions for return was, that I didn't know how

1270

    // to name a single function.

1271

    /// Returns a value from the current stack frame.

1272

    pub fn return_value(&mut self, value: impl Into<LiteralOrSource>) {

1273

        self.push(Instruction::Return(Some(value.into())));

1274

1275

    /// Returns from the current stack frame without a value.

1276

    pub fn return_void(&mut self) {

1277

        self.push(Instruction::Return(None));

1278

1279

    /// Calls a function.

1280

///

1281

    /// When calling a function, values on the stack are "passed" to the

1282

    /// function being pushed to the stack before calling the function. To

1283

    /// ensure the correct number of arguments are taken even when variable

1284

    /// argument lists are supported, the number of arguments is passed and

1285

    /// controls the baseline of the stack.

1286

///

1287

    /// Upon returning from a function call, the arguments will no longer be on

1288

    /// the stack. The value returned from the function (or [`Value::Void`] if

1289

    /// no value was returned) will be placed in `destination`.

1290

///

1291

    /// There is also [`recurse()`](Self::recurse) always recursing the current function.

1292

    pub fn call(

1293

        &mut self,

1294

        function: impl Into<Symbol>,

1295

        arg_count: usize,

1296

        destination: impl Into<Destination>,

1297

) {

1298

        self.push(Instruction::Call {

1299

            function: Some(function.into()),

1300

            arg_count,

1301

            destination: destination.into(),

1302

});

1303

1304

    /// Calls the current function recursively.

1305

///

1306

    /// When calling a function, values on the stack are "passed" to the

1307

    /// function being pushed to the stack before calling the function. To

1308

    /// ensure the correct number of arguments are taken even when variable

1309

    /// argument lists are supported, the number of arguments is passed and

1310

    /// controls the baseline of the stack.

1311

///

1312

    /// Upon returning from a function call, the arguments will no longer be on

1313

    /// the stack. The value returned from the function (or [`Value::Void`] if

1314

    /// no value was returned) will be placed in `destination`.

1315

    pub fn recurse(&mut self, arg_count: usize, destination: impl Into<Destination>) {

1316

        self.push(Instruction::Call {

1317

            function: None,

1318

            arg_count,

1319

            destination: destination.into(),

1320

});

1321

1322

    /// Calls an intrinsic runtime function.

1323

///

1324

    /// When calling a function, values on the stack are "passed" to the

1325

    /// function being pushed to the stack before calling the function. To

1326

    /// ensure the correct number of arguments are taken even when variable

1327

    /// argument lists are supported, the number of arguments is passed and

1328

    /// controls the baseline of the stack.

1329

///

1330

    /// Upon returning from a function call, the arguments will no longer be on

1331

    /// the stack. The value returned from the function (or [`Value::Void`] if

1332

    /// no value was returned) will be placed in `destination`.

1333

    pub fn call_intrinsic(

1334

        &mut self,

1335

        intrinsic: impl Into<Intrinsic>,

1336

        arg_count: usize,

1337

        destination: impl Into<Destination>,

1338

) {

1339

        self.push(Instruction::CallIntrinsic {

1340

            intrinsic: intrinsic.into(),

1341

            arg_count,

1342

            destination: destination.into(),

1343

});

1344

1345

    /// Calls a function by name on a value.

1346

///

1347

    /// When calling a function, values on the stack are "passed" to the

1348

    /// function being pushed to the stack before calling the function. To

1349

    /// ensure the correct number of arguments are taken even when variable

1350

    /// argument lists are supported, the number of arguments is passed and

1351

    /// controls the baseline of the stack.

1352

///

1353

    /// Upon returning from a function call, the arguments will no longer be on

1354

    /// the stack. The value returned from the function (or [`Value::Void`] if

1355

    /// no value was returned) will be placed in `destination`.

1356

    pub fn call_instance(

1357

        &mut self,

1358

        target: impl Into<LiteralOrSource>,

1359

        name: impl Into<Symbol>,

1360

        arg_count: usize,

1361

        destination: impl Into<Destination>,

1362

) {

1363

        self.push(Instruction::CallInstance {

1364

            target: target.into(),

1365

            name: name.into(),

1366

            arg_count,

1367

            destination: destination.into(),

1368

});

1369

1370

1371

1372

/// An if within a [`CodeBlockBuilder`].

1373

#[must_use]

1374

pub struct If<'a, Intrinsic> {

1375

    label: Option<Label>,

1376

    code_block: &'a mut CodeBlockBuilder<Intrinsic>,

1377

1378

1379

impl<Intrinsic> Deref for If<'_, Intrinsic> {

1380

    type Target = CodeBlockBuilder<Intrinsic>;

1381

1382

    fn deref(&self) -> &Self::Target {

1383

        self.code_block

1384

1385

1386

1387

impl<Intrinsic> DerefMut for If<'_, Intrinsic> {

1388

72

    fn deref_mut(&mut self) -> &mut Self::Target {

1389

72

        self.code_block

1390

72

1391

1392

1393

impl<Intrinsic> Drop for If<'_, Intrinsic> {

1394

    fn drop(&mut self) {

1395

28

        if let Some(label) = self.label.take() {

1396

6

            self.code_block.label(label);

1397

24

1398

28

1399

1400

1401

impl<'a, Intrinsic> If<'a, Intrinsic> {

1402

    /// Ends the `if` block, equivalent to dropping.

1403

    pub fn end(self) {}

1404

1405

    /// Ends the `if` block, and starts an `else` block.

1406

22

    pub fn begin_else(mut self) -> Else<'a, Intrinsic> {

1407

22

        let label = self.code_block.new_label();

1408

22

        self.code_block.jump_to(&label);

1409

22

        self.code_block.label(

1410

22

            self.label.take().expect(

1411

22

                "should only be None if `.else` or `.end` was called, both consuming self.",

1412

22

),

1413

22

);

1414

22

        Else {

1415

22

            label,

1416

22

            code_block: self,

1417

22

1418

22

1419

1420

1421

#[must_use]

1422

/// An else within a [`CodeBlockBuilder`]

1423

pub struct Else<'a, Intrinsic> {

1424

    label: Label,

1425

    code_block: If<'a, Intrinsic>,

1426

1427

1428

impl<Intrinsic> Deref for Else<'_, Intrinsic> {

1429

    type Target = CodeBlockBuilder<Intrinsic>;

1430

1431

    fn deref(&self) -> &Self::Target {

1432

        &self.code_block

1433

1434

1435

1436

impl<Intrinsic> DerefMut for Else<'_, Intrinsic> {

1437

22

    fn deref_mut(&mut self) -> &mut Self::Target {

1438

22

        &mut self.code_block

1439

22

1440

1441

1442

impl<T> Drop for Else<'_, T> {

1443

22

    fn drop(&mut self) {

1444

22

        self.code_block.label(&self.label);

1445

22

1446

1447

1448

impl<T> Else<'_, T> {

1449

    /// Ends the `else` block, equivalent to dropping.

1450

    pub fn end(self) {}

1451

1452

1453

/// A loop within a [`CodeBlockBuilder`].

1454

#[must_use]

1455

pub struct LoopScope<'a, T, Intrinsic>

1456

where

1457

    T: BorrowMut<CodeBlockBuilder<Intrinsic>>,

1458

1459

    owner: &'a mut T,

1460

    /// The label for a `break` operation.

1461

    pub break_label: Label,

1462

    /// The label for a `continue` operation.

1463

    pub continue_label: Label,

1464

1465

    _intrinsic: PhantomData<Intrinsic>,

1466

1467

1468

impl<'a, T, Intrinsic> LoopScope<'a, T, Intrinsic>

1469

where

1470

    T: BorrowMut<CodeBlockBuilder<Intrinsic>>,

1471

1472

    /// Marks the next instruction as where the `break` operation should jump

1473

    /// to.

1474

12

    pub fn label_break(&mut self) {

1475

12

        self.owner.borrow_mut().label(self.break_label.clone());

1476

12

1477

1478

    /// Marks the next instruction as where the `continue` operation should jump

1479

    /// to.

1480

12

    pub fn label_continue(&mut self) {

1481

12

        self.owner.borrow_mut().label(self.continue_label.clone());

1482

12

1483

1484

1485

impl<'a, T, Intrinsic> Borrow<CodeBlockBuilder<Intrinsic>> for LoopScope<'a, T, Intrinsic>

1486

where

1487

    T: BorrowMut<CodeBlockBuilder<Intrinsic>>,

1488

1489

    fn borrow(&self) -> &CodeBlockBuilder<Intrinsic> {

1490

        (*self.owner).borrow()

1491

1492

1493

1494

impl<'a, T, Intrinsic> BorrowMut<CodeBlockBuilder<Intrinsic>> for LoopScope<'a, T, Intrinsic>

1495

where

1496

    T: BorrowMut<CodeBlockBuilder<Intrinsic>>,

1497

1498

    fn borrow_mut(&mut self) -> &mut CodeBlockBuilder<Intrinsic> {

1499

        self.owner.borrow_mut()

1500

1501

1502

1503

impl<'a, T, Intrinsic> Deref for LoopScope<'a, T, Intrinsic>

1504

where

1505

    T: BorrowMut<CodeBlockBuilder<Intrinsic>>,

1506

1507

    type Target = CodeBlockBuilder<Intrinsic>;

1508

1509

    fn deref(&self) -> &Self::Target {

1510

        self.borrow()

1511

1512

1513

1514

impl<'a, T, Intrinsic> DerefMut for LoopScope<'a, T, Intrinsic>

1515

where

1516

    T: BorrowMut<CodeBlockBuilder<Intrinsic>>,

1517

1518

73

    fn deref_mut(&mut self) -> &mut Self::Target {

1519

73

        self.owner.borrow_mut()

1520

73

1521

1522

1523

impl<'a, T, Intrinsic> Drop for LoopScope<'a, T, Intrinsic>

1524

where

1525

    T: BorrowMut<CodeBlockBuilder<Intrinsic>>,

1526

1527

12

    fn drop(&mut self) {

1528

12

        self.loops.exit_block();

1529

12

1530

1531

1532

120

#[derive(Debug, Default)]

1533

struct LoopLabels {

1534

    scopes: Vec<LoopInfo>,

1535

1536

1537

impl LoopLabels {

1538

144

    fn begin(&mut self, info: LoopInfo) {

1539

144

        self.scopes.push(info);

1540

144

1541

1542

144

    fn exit_block(&mut self) {

1543

144

        self.scopes.pop();

1544

144

1545

1546

84

    fn find(&self, name: Option<&Symbol>) -> Option<&LoopInfo> {

1547

84

        if name.is_some() {

1548

24

            self.scopes

1549

24

                .iter()

1550

24

                .rev()

1551

48

                .find(|info| info.name.as_ref() == name)

1552

        } else {

1553

60

            self.scopes.last()

1554

1555

84

1556

1557

1558

/// Information about a loop.

1559

#[derive(Debug)]

1560

pub struct LoopInfo {

1561

    /// The name of the loop, if specified.

1562

    pub name: Option<Symbol>,

1563

    /// The label for the `break` operation of the loop.

1564

    pub break_label: Label,

1565

    /// The label for the `continue` operation of the loop.

1566

    pub continue_label: Label,

1567

    /// The desination to store the loops result into.

1568

    pub loop_result: Destination,

1569

1570

1571

/// A block of intermediate instructions.

1572

2

#[derive(Debug, PartialEq)]

1573

pub struct CodeBlock<Intrinsic> {

1574

    /// The number of arguments this code block expects to be on the stack.

1575

    pub arguments: Vec<Symbol>,

1576

    /// The number of variables this code block uses.

1577

    pub variables: usize,

1578

    /// The list of instructions.

1579

    pub code: Vec<Instruction<Intrinsic>>,

1580

1581

1582

impl<Intrinsic> CodeBlock<Intrinsic> {

1583

    /// Returns a builder for a new [`CodeBlock`].

1584

    #[must_use]

1585

1

    pub fn build() -> CodeBlockBuilder<Intrinsic> {

1586

1

        CodeBlockBuilder::default()

1587

1

1588

1589

    /// Links the code block against `scope`, resolving all labels and function

1590

    /// calls.

1591

    #[allow(clippy::too_many_lines)]

1592

112

    pub fn link<S, E>(&self, scope: &S) -> Result<crate::CodeBlock<Intrinsic>, LinkError>

1593

112

    where

1594

112

        S: Scope<Environment = E>,

1595

112

        E: Environment<Intrinsic = Intrinsic>,

1596

112

1597

112

        let mut labels = Vec::new();

1598

112

        let mut labels_encountered = 0;

1599

482

        for (index, op) in self.code.iter().enumerate() {

1600

482

            if let Instruction::Label(label) = op {

1601

71

                if labels.len() <= label.index {

1602

49

                    labels.resize(label.index + 1, None);

1603

49

1604

71

                labels[label.index] = Some(index - labels_encountered);

1605

71

                labels_encountered += 1;

1606

411

1607

1608

112

        self.code

1609

112

            .iter()

1610

482

            .filter_map(|op| compile_instruction(op, &labels, scope).transpose())

1611

112

            .collect::<Result<_, LinkError>>()

1612

112

            .map(|instructions| crate::CodeBlock {

1613

112

                variables: self.variables,

1614

112

                code: instructions,

1615

112

})

1616

112

1617

1618

1619

impl<Intrinsic> Display for CodeBlock<Intrinsic>

1620

where

1621

    Intrinsic: Display,

1622

1623

5

    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

1624

5

        let mut is_first = true;

1625

85

        for i in &self.code {

1626

80

            if is_first {

1627

5

                is_first = false;

1628

5

            } else {

1629

75

                f.write_char('\n')?;

1630

1631

80

            Display::fmt(i, f)?;

1632

1633

5

        Ok(())

1634

5

1635

1636

1637

#[allow(clippy::too_many_lines)] // Most are straight mappings...

1638

482

fn compile_instruction<S>(

1639

482

    op: &Instruction<<S::Environment as Environment>::Intrinsic>,

1640

482

    labels: &[Option<usize>],

1641

482

    scope: &S,

1642

482

) -> Result<Option<crate::Instruction<<S::Environment as Environment>::Intrinsic>>, LinkError>

1643

482

where

1644

482

    S: Scope,

1645

482

1646

482

    Ok(Some(match op {

1647

        Instruction::Add {

1648

41

            left,

1649

41

            right,

1650

41

            destination,

1651

41

        } => crate::Instruction::Add {

1652

41

            left: left.instantiate::<S::Environment>(),

1653

41

            right: right.instantiate::<S::Environment>(),

1654

41

            destination: destination.into(),

1655

41

},

1656

        Instruction::Sub {

1657

12

            left,

1658

12

            right,

1659

12

            destination,

1660

12

        } => crate::Instruction::Sub {

1661

12

            left: left.instantiate::<S::Environment>(),

1662

12

            right: right.instantiate::<S::Environment>(),

1663

12

            destination: destination.into(),

1664

12

},

1665

        Instruction::Multiply {

1666

8

            left,

1667

8

            right,

1668

8

            destination,

1669

8

        } => crate::Instruction::Multiply {

1670

8

            left: left.instantiate::<S::Environment>(),

1671

8

            right: right.instantiate::<S::Environment>(),

1672

8

            destination: destination.into(),

1673

8

},

1674

        Instruction::Divide {

1675

3

            left,

1676

3

            right,

1677

3

            destination,

1678

3

        } => crate::Instruction::Divide {

1679

3

            left: left.instantiate::<S::Environment>(),

1680

3

            right: right.instantiate::<S::Environment>(),

1681

3

            destination: destination.into(),

1682

3

},

1683

        Instruction::LogicalOr {

1684

            left,

1685

            right,

1686

            destination,

1687

        } => crate::Instruction::LogicalOr {

1688

            left: left.instantiate::<S::Environment>(),

1689

            right: right.instantiate::<S::Environment>(),

1690

            destination: destination.into(),

1691

},

1692

        Instruction::LogicalAnd {

1693

            left,

1694

            right,

1695

            destination,

1696

        } => crate::Instruction::LogicalAnd {

1697

            left: left.instantiate::<S::Environment>(),

1698

            right: right.instantiate::<S::Environment>(),

1699

            destination: destination.into(),

1700

},

1701

        Instruction::LogicalXor {

1702

4

            left,

1703

4

            right,

1704

4

            destination,

1705

4

        } => crate::Instruction::LogicalXor {

1706

4

            left: left.instantiate::<S::Environment>(),

1707

4

            right: right.instantiate::<S::Environment>(),

1708

4

            destination: destination.into(),

1709

4

},

1710

        Instruction::BitwiseOr {

1711

1

            left,

1712

1

            right,

1713

1

            destination,

1714

1

        } => crate::Instruction::BitwiseOr {

1715

1

            left: left.instantiate::<S::Environment>(),

1716

1

            right: right.instantiate::<S::Environment>(),

1717

1

            destination: destination.into(),

1718

1

},

1719

        Instruction::BitwiseAnd {

1720

1

            left,

1721

1

            right,

1722

1

            destination,

1723

1

        } => crate::Instruction::BitwiseAnd {

1724

1

            left: left.instantiate::<S::Environment>(),

1725

1

            right: right.instantiate::<S::Environment>(),

1726

1

            destination: destination.into(),

1727

1

},

1728

        Instruction::BitwiseXor {

1729

1

            left,

1730

1

            right,

1731

1

            destination,

1732

1

        } => crate::Instruction::BitwiseXor {

1733

1

            left: left.instantiate::<S::Environment>(),

1734

1

            right: right.instantiate::<S::Environment>(),

1735

1

            destination: destination.into(),

1736

1

},

1737

        Instruction::ShiftLeft {

1738

2

            left,

1739

2

            right,

1740

2

            destination,

1741

2

        } => crate::Instruction::ShiftLeft {

1742

2

            left: left.instantiate::<S::Environment>(),

1743

2

            right: right.instantiate::<S::Environment>(),

1744

2

            destination: destination.into(),

1745

2

},

1746

        Instruction::ShiftRight {

1747

2

            left,

1748

2

            right,

1749

2

            destination,

1750

2

        } => crate::Instruction::ShiftRight {

1751

2

            left: left.instantiate::<S::Environment>(),

1752

2

            right: right.instantiate::<S::Environment>(),

1753

2

            destination: destination.into(),

1754

2

},

1755

3

        Instruction::LogicalNot { value, destination } => crate::Instruction::LogicalNot {

1756

3

            value: value.instantiate::<S::Environment>(),

1757

3

            destination: destination.into(),

1758

3

},

1759

1

        Instruction::BitwiseNot { value, destination } => crate::Instruction::BitwiseNot {

1760

1

            value: value.instantiate::<S::Environment>(),

1761

1

            destination: destination.into(),

1762

1

},

1763

        Instruction::Convert {

1764

7

            value,

1765

7

            kind,

1766

7

            destination,

1767

7

        } => crate::Instruction::Convert {

1768

7

            value: value.instantiate::<S::Environment>(),

1769

7

            kind: kind.clone(),

1770

7

            destination: destination.into(),

1771

7

},

1772

        Instruction::If {

1773

19

            condition,

1774

19

            false_jump_to,

1775

19

        } => crate::Instruction::If {

1776

19

            condition: condition.instantiate::<S::Environment>(),

1777

19

            false_jump_to: labels[false_jump_to.index].expect("label not inserted"),

1778

19

},

1779

41

        Instruction::JumpTo(label) => {

1780

41

            crate::Instruction::JumpTo(labels[label.index].expect("label not inserted"))

1781

1782

71

        Instruction::Label(_label) => return Ok(None), // Labels are no-ops

1783

        Instruction::Compare {

1784

32

            comparison,

1785

32

            left,

1786

32

            right,

1787

32

            action,

1788

32

        } => crate::Instruction::Compare {

1789

32

            comparison: *comparison,

1790

32

            left: left.instantiate::<S::Environment>(),

1791

32

            right: right.instantiate::<S::Environment>(),

1792

32

            action: action.link(labels)?,

1793

},

1794

43

        Instruction::Push(value) => crate::Instruction::Push(value.instantiate::<S::Environment>()),

1795

50

        Instruction::Return(value) => crate::Instruction::Return(

1796

50

            value

1797

50

                .as_ref()

1798

50

                .map(LiteralOrSource::instantiate::<S::Environment>),

1799

50

),

1800

90

        Instruction::Load { value, variable } => crate::Instruction::Load {

1801

90

            variable_index: variable.index,

1802

90

            value: value.instantiate::<S::Environment>(),

1803

90

},

1804

        Instruction::Call {

1805

25

            function,

1806

25

            arg_count,

1807

25

            destination,

1808

        } => {

1809

25

            let vtable_index = function

1810

25

                .as_ref()

1811

25

                .map(|symbol| {

1812

15

                    scope

1813

15

                        .resolve_function_vtable_index(symbol)

1814

15

                        .ok_or_else(|| LinkError::UndefinedFunction(symbol.clone()))

1815

25

})

1816

25

                .transpose()?;

1817

25

            crate::Instruction::Call {

1818

25

                vtable_index,

1819

25

                arg_count: *arg_count,

1820

25

                destination: destination.into(),

1821

25

1822

1823

        Instruction::CallInstance {

1824

20

            target,

1825

20

            name,

1826

20

            arg_count,

1827

20

            destination,

1828

20

        } => crate::Instruction::CallInstance {

1829

20

            target: target.instantiate::<S::Environment>(),

1830

20

            name: name.clone(),

1831

20

            arg_count: *arg_count,

1832

20

            destination: destination.into(),

1833

20

},

1834

        Instruction::CallIntrinsic {

1835

5

            intrinsic,

1836

5

            arg_count,

1837

5

            destination,

1838

5

        } => crate::Instruction::CallIntrinsic {

1839

5

            intrinsic: intrinsic.clone(),

1840

5

            arg_count: *arg_count,

1841

5

            destination: destination.into(),

1842

5

},

1843

}))

1844

482

1845

1846

/// A scope for linking and compiling code.

1847

pub trait Scope {

1848

    /// The environment for this scope.

1849

///

1850

    /// This is used when instantiating literals as values.

1851

    type Environment: Environment;

1852

1853

    /// Returns the vtable index of a function with the provided name.

1854

    fn resolve_function_vtable_index(&self, name: &Symbol) -> Option<usize>;

1855

    /// Invokes `callback` for each symbol defined in this scope.

1856

    fn map_each_symbol(&self, callback: &mut impl FnMut(Symbol, ScopeSymbolKind));

1857

1858

    /// Defines a function with the provided name.

1859

    fn define_function(

1860

        &mut self,

1861

        function: crate::Function<<Self::Environment as Environment>::Intrinsic>,

1862

    ) -> Option<usize>;

1863

1864

    /// Defines a persistent variable.

1865

///

1866

    /// This is used to enable interactive sessions.

1867

    fn define_persistent_variable(&mut self, name: Symbol, variable: Variable);

1868

1869

1870

impl Scope for () {

1871

    type Environment = ();

1872

1873

    fn resolve_function_vtable_index(&self, _name: &Symbol) -> Option<usize> {

1874

        None

1875

1876

1877

    fn map_each_symbol(&self, _callback: &mut impl FnMut(Symbol, ScopeSymbolKind)) {}

1878

1879

    fn define_function(&mut self, _function: crate::Function<Noop>) -> Option<usize> {

1880

        None

1881

1882

1883

    fn define_persistent_variable(&mut self, _name: Symbol, _variable: Variable) {}

1884

1885

1886

/// The kind of a [`ScopeSymbol`].

1887

#[derive(Debug)]

1888

pub enum ScopeSymbolKind {

1889

    /// The symbol is an argument passed into the executing function.

1890

    Argument,

1891

    /// The symbol is a local variable.

1892

    Variable,

1893

    /// The symbol is a function.

1894

    Function,

1895

1896

1897

/// A registered symbol.

1898

#[derive(Debug)]

1899

pub enum ScopeSymbol {

1900

    /// An argument passed into the executing function.

1901

    Argument(Argument),

1902

    /// A local variable.

1903

    Variable(Variable),

1904

    /// A function name.

1905

    Function(Symbol),

1906

1907

1908

/// A function, in its intermediate form.

1909

2

#[derive(Debug, PartialEq)]

1910

pub struct Function<Intrinsic> {

1911

    /// The name of the function, if provided.

1912

    pub name: Symbol,

1913

    /// The body of the function.

1914

    pub body: CodeBlock<Intrinsic>,

1915

1916

1917

impl<Intrinsic> Function<Intrinsic>

1918

where

1919

    Intrinsic: Display,

1920

1921

    /// Returns a new function

1922

115

    pub fn new(name: impl Into<Symbol>, body: CodeBlock<Intrinsic>) -> Self {

1923

115

        Self {

1924

115

            name: name.into(),

1925

115

            body,

1926

115

1927

115

1928

1929

    /// Links this function against `scope`, returning a function that is ready

1930

    /// to be executed.

1931

110

    pub fn link<S, E>(&self, scope: &mut S) -> Result<crate::Function<Intrinsic>, LinkError>

1932

110

    where

1933

110

        S: Scope<Environment = E>,

1934

110

        E: Environment<Intrinsic = Intrinsic>,

1935

110

1936

110

        let name = self.name.clone();

1937

110

        let block = self.body.link(scope)?;

1938

110

        if env::var("PRINT_IR").is_ok() {

1939

            println!("{}", block.display_indented("  "));

1940

110

1941

110

        let function = crate::Function {

1942

110

            name,

1943

110

            arg_count: self.body.arguments.len(),

1944

110

            code: block.code,

1945

110

            variable_count: block.variables,

1946

110

};

1947

110

        Ok(function)

1948

110

1949

1950

    /// Links this function against `scope`, and registers the linked function

1951

    /// with `scope`. The `usize` returned is the vtable index of the function.

1952

103

    pub fn link_into<S, E>(&self, scope: &mut S) -> Result<usize, LinkError>

1953

103

    where

1954

103

        S: Scope<Environment = E>,

1955

103

        E: Environment<Intrinsic = Intrinsic>,

1956

103

1957

103

        let function = self.link(scope)?;

1958

1959

103

        let vtable_index = scope

1960

103

            .define_function(function)

1961

103

            .ok_or(LinkError::InvalidScopeOperation)?;

1962

103

        Ok(vtable_index)

1963

103

1964

1965

1966

impl<Intrinsic> Display for Function<Intrinsic>

1967

where

1968

    Intrinsic: Display,

1969

1970

    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

1971

2

        write!(f, "function {}", self.name)?;

1972

4

        for arg in &self.body.arguments {

1973

2

            write!(f, " @{arg}")?;

1974

1975

2

        f.write_char('\n')?;

1976

1977

2

        Display::fmt(&self.body, f)?;

1978

1979

2

        Ok(())

1980

2

1981

1982

1983

/// A collection of functions and modules.

1984

1

#[derive(Debug, PartialEq)]

1985

pub struct Module<Intrinsic> {

1986

    /// A list of functions defined in the module.

1987

    pub vtable: Vec<Function<Intrinsic>>,

1988

    /// A list of submodules.

1989

    pub modules: Vec<Module<Intrinsic>>,

1990

    /// The initialization function of this module, if any.

1991

    pub init: Option<Function<Intrinsic>>,

1992

1993

1994

impl<Intrinsic> Default for Module<Intrinsic> {

1995

3

    fn default() -> Self {

1996

3

        Self {

1997

3

            vtable: Vec::default(),

1998

3

            modules: Vec::default(),

1999

3

            init: None,

2000

3

2001

3

2002

2003

impl<Intrinsic> Module<Intrinsic>

2004

where

2005

    Intrinsic: Clone + FromStr + Display,

2006

2007

    /// Returns a new module.

2008

    #[must_use]

2009

105

    pub fn new(

2010

105

        vtable: Vec<Function<Intrinsic>>,

2011

105

        modules: Vec<Module<Intrinsic>>,

2012

105

        init: Option<Function<Intrinsic>>,

2013

105

    ) -> Self {

2014

105

        Self {

2015

105

            vtable,

2016

105

            modules,

2017

105

            init,

2018

105

2019

105

2020

2021

    /// Returns a module parsed from Bud Assembly (`budasm`).

2022

1

    pub fn from_asm(assembly: &str) -> Result<Self, asm::AsmError> {

2023

1

        asm::Parser::parse(assembly)

2024

1

2025

2026

    /// Runs all code in this unit in the passed context.

2027

96

    pub fn load_into<'a, Output: FromStack, Env>(

2028

96

        &self,

2029

96

        context: &'a mut VirtualMachine<Env>,

2030

96

    ) -> Result<Output, Error<'a, Env, Output>>

2031

96

    where

2032

96

        Env: Environment<Intrinsic = Intrinsic>,

2033

96

2034

        // // Process all modules first

2035

        // for _module in &self.modules {

2036

        //     todo!()

2037

        // }

2038

2039

        // Compile each function

2040

96

        for (index, function) in self.vtable.iter().enumerate() {

2041

9

            if env::var("PRINT_IR").is_ok() {

2042

                println!(

2043

                    "function #{index} - {}({})",

2044

                    function.name,

2045

                    function

2046

                        .body

2047

                        .arguments

2048

                        .iter()

2049

                        .map(Symbol::as_str)

2050

                        .collect::<Vec<_>>()

2051

                        .join(", ")

2052

);

2053

9

2054

9

            function.link_into(context)?;

2055

2056

2057

        // Execute the module initializer if it exists

2058

96

        if let Some(init) = &self.init {

2059

92

            if env::var("PRINT_IR").is_ok() {

2060

                println!("function init");

2061

92

2062

92

            let vtable_index = init.link_into(context)?;

2063

92

            context

2064

92

                .run(

2065

92

                    vec![crate::Instruction::Call {

2066

92

                        vtable_index: Some(vtable_index),

2067

92

                        arg_count: 0,

2068

92

                        destination: crate::Destination::Stack,

2069

92

}],

2070

92

0,

2071

92

2072

92

                .map_err(Error::from)

2073

        } else {

2074

4

            Output::from_value(Value::Void).map_err(Error::from)

2075

2076

96

2077

2078

2079

impl<Intrinsic> Display for Module<Intrinsic>

2080

where

2081

    Intrinsic: Display,

2082

2083

2

    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

2084

2

        let mut needs_end_of_line = false;

2085

2

        if let Some(init) = &self.init {

2086

2

            Display::fmt(&init.body, f)?;

2087

2

            needs_end_of_line = true;

2088

2089

2090

4

        for function in &self.vtable {

2091

2

            if needs_end_of_line {

2092

2

                f.write_char('\n')?;

2093

            } else {

2094

                needs_end_of_line = true;

2095

2096

2

            Display::fmt(function, f)?;

2097

2098

2099

2

        Ok(())

2100

2

2101

2102

2103

/// An error occurred while linking code.

2104

#[derive(Debug, Eq, PartialEq, Clone)]

2105

pub enum LinkError {

2106

    /// An undefined function was encountered.

2107

    UndefinedFunction(Symbol),

2108

    /// An undefined identifier was encountered.

2109

    UndefinedIdentifier(Symbol),

2110

    /// An invalid label was used.

2111

    InvalidLabel(Label),

2112

    /// An invalid operation for the provided [`Scope`] was attempted.

2113

    InvalidScopeOperation,

2114

2115

2116

impl Display for LinkError {

2117

    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {

2118

        match self {

2119

            LinkError::UndefinedFunction(symbol) => {

2120

                write!(f, "undefined function: {symbol}")

2121

2122

            LinkError::InvalidScopeOperation => {

2123

                write!(f, "the scope used did not support a required operation")

2124

2125

            LinkError::UndefinedIdentifier(symbol) => {

2126

                write!(f, "undefined identifier: {symbol}")

2127

2128

            LinkError::InvalidLabel(label) => {

2129

                if let Some(name) = &label.name {

2130

                    write!(f, "invalid label: #{name}")

2131

                } else {

2132

                    write!(f, "invalid label: {}", label.index)

2133

2134

2135

2136

2137

2138

2139

impl std::error::Error for LinkError {}

2140

2141

// #[test]

2142

// fn optimizations() {

2143

//     let unit = crate::parser::parse(

2144

//         r#"function fibonacci(n)

2145

//             if n <= 2

2146

//                 1

2147

//             else

2148

//                 this(n - 1) + this(n - 2)

2149

//             end

2150

//         end

2151

//         "#,

2152

//     )

2153

//     .unwrap()

2154

//     .compile();

2155

//     println!("Unoptimized code:\n{}", unit.vtable[0].body);

2156

//     println!("Unoptimized length: {}", unit.vtable[0].body.code.len());

2157

//     let mut graph = crate::optimizer::CodeGraph::new(&unit.vtable[0].body.code);

2158

//     println!("Graph:\n {graph}");

2159

//     let dag = graph.dags();

2160

//     println!("Dag:\n {dag:?}");

2161

//     // dag.optimize(&mut graph);

2162

// }