Compiler/virtual machine interpreter: Difference between revisions

; A simple example virtual machine:

 

int stack[data_size + 1000]

set stack[0..data_size - 1] to 0

elif op == PRTS: print the constant string referred to by stack[-1]; stack.pop()

elif op == PRTI: print stack[-1] as an integer; stack.pop()

 

; Additional examples

 

 

-- The Rosetta Code Virtual Machine, in Ada.

--

t : Unbounded_String;

i : Positive;

begin

t := To_Unbounded_String ("");

 

i := s'First;

i := i + 1;

end loop;

 

raise bad_vm with "expected a '""'";

end if;

 

i := i + 1;

if s (i) /= '\' then

Append (t, s (i));

end if;

else

halt := True;

end if;

 

Set_Exit_Status (status);

 

 

count is: 8

count is: 9</pre>

 

=={{header|Aime}}==

file f;

text s;

isk_greater(code, pc, pc);

}

 

=={{header|ALGOL W}}==

% string literals %

string(256) array stringValue ( 0 :: 256 );

end while_not_halted

end

 

=={{header|ATS}}==

{{works with|ATS|Postiats 0.4.1}}

 

(Without the C optimizer, ATS code can run much, much more slowly. It is worth comparing the Mandelbrot example with and without the optimizer.)

 

Usage: vm [INPUTFILE [OUTPUTFILE]]

If INPUTFILE or OUTPUTFILE is "-" or missing, then standard input

}

 

 

{{out}}

count is: 8

count is: 9</pre>

 

=={{header|AWK}}==

Tested with gawk 4.1.1 and mawk 1.3.4.

function error(msg) {

printf("%s\n", msg)

run_vm(data_size)

}

{{out|case=count}}

<b>

=={{header|C}}==

Tested with gcc 4.81 and later, compiles warning free with -Wall -Wextra

#include <stdlib.h>

#include <stdarg.h>

int data[1000 + data_size];

run_vm(object, data, data_size, string_pool);

 

=={{header|COBOL}}==

Code by Steve Williams (with changes to work around code highlighting issues). Tested with GnuCOBOL 2.2.

 

identification division.

*> this code is dedicated to the public domain

end program emitword.

 

 

{{out|case=Count}}

 

 

#|-*- mode:lisp -*-|#

#|

(uiop:quit 0)))

 

 

 

 

 

// The Rosetta Code Virtual Machine in D.

//

 

return 0;

 

 

=={{header|Forth}}==

Tested with Gforth 0.7.3

: PEEK BUF @ 0= IF KEY BUF ! THEN BUF @ ;

: GETC PEEK 0 BUF ! ;

: RUN BYTECODE @ A !

BEGIN C@A+ CELLS OPS + @ EXECUTE AGAIN ;

 

=={{header|Fortran}}==

{{works with|gfortran|11.2.1}}

Fortran 2008/2018 code with some limited use of the C preprocessor. If you are on a platform with case-sensitive filenames, and call the source file vm.F90, then gfortran will know to use the C preprocessor.

use, intrinsic :: iso_fortran_env, only: int32

use, intrinsic :: iso_fortran_env, only: int64

end subroutine print_usage

 

{{out}}

=={{header|Go}}==

{{trans|Python}}

 

import (

scanner = bufio.NewScanner(codeGen)

runVM(loadCode())

 

{{out}}

=={{header|Icon}}==

{{trans|ObjectIcon}}

#

# The Rosetta Code virtual machine in Icon. Migrated from the

write(&errout, "Bad opcode.")

exit(1)

 

{{out}}

=={{header|J}}==

Implementation:

fetch store push add sub mul div mod lt gt le ge

eq ne and or neg not jmp jz prtc prts prti halt

pc=: pc+k

end.

 

Task example:

count = 1;

while (count < 10) {

count is: 8

count is: 9

 

=={{header|Julia}}==

code::Vector{UInt8}

stack::Vector{Int32}

const vm = assemble(iob)

runvm(vm)

count is: 1

count is: 2

=={{header|M2000 Interpreter}}==

===Using Select Case===

Module Virtual_Machine_Interpreter (a$){

\\ function to extract string, replacing escape codes.

65 halt

}

 

===Using Lambda functions===

A call local to function pass the current scope to function, so it's like a call to subroutine, but faster.

 

Module Virtual_Machine_Interpreter (a$){

\\ function to extract string, replacing escape codes.

65 halt

}

 

=={{header|Mercury}}==

 

 

%%%

%%% The Rosetta Code Virtual Machine, in Mercury.

%%% prolog-indent-width: 2

%%% end:

 

 

=={{header|Nim}}==

 

 

type

 

vm.load(code)

 

All tests passed.

 

=={{header|ObjectIcon}}==

#

# The Rosetta Code virtual machine in Object Icon.

exit(1)

end

 

{{out}}

=={{header|Perl}}==

Tested with perl v5.26.1

 

# http://www.rosettacode.org/wiki/Compiler/virtual_machine_interpreter

}

 

Passes all tests.

 

=={{header|Phix}}==

Reusing cgen.e from the [[Compiler/code_generator#Phix|Code Generator task]]

<span style="color: #000080;font-style:italic;">--

-- demo\rosetta\Compiler\vm.exw

<span style="color: #000080;font-style:italic;">--main(command_line())</span>

<span style="color: #000000;">main</span><span style="color: #0000FF;">({</span><span style="color: #000000;">0</span><span style="color: #0000FF;">,</span><span style="color: #000000;">0</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"count.c"</span><span style="color: #0000FF;">})</span>

{{out}}

<pre>

 

 

%%%

%%% The Rosetta Code Virtual Machine, for GNU Prolog.

%%% prolog-indent-width: 2

%%% end:

 

 

=={{header|Python}}==

Tested with Python 2.7 and 3.x

import sys, struct

 

 

data_size = load_code()

 

=={{header|Racket}}==

 

 

;;;

;;; The Rosetta Code Virtual Machine, in Typed Racket.

(close-output-port outf))

 

 

 

 

{{trans|Perl}}

Datasize: 3 Strings: 2

"count is: "

$pc += $w;

%ops{%n2op{ $opcode }}();

{{out}}

<pre>count is: 1

count is: 8

count is: 9</pre>

 

=={{header|Scala}}==

The following code implements a virtual machine for the output of the [http://rosettacode.org/wiki/Compiler/code_generator#Scala code generator].

 

package xyz.hyperreal.rosettacodeCompiler

 

 

}

 

The above code depends on the function <tt>unescape()</tt> to perform string escape sequence translation. That function is defined in the following separate source file.

 

package xyz.hyperreal

 

 

}

 

=={{header|Scheme}}==

All of the "Compiler/Sample programs" are correctly interpreted.

 

(import (scheme base)

(scheme char)

(run-program data strings code))

(display "Error: pass a .asm filename\n"))

 

=={{header|Wren}}==

{{libheader|Wren-fmt}}

{{libheader|Wren-ioutil}}

 

var codes = [

lines = FileUtil.readLines("codegen.txt")

lineCount = lines.count

 

{{out}}

 

=={{header|Zig}}==

const std = @import("std");

 

}

}

 

=={{header|zkl}}==

{{trans|Python}}

File rvm.zkl:

const WORD_SIZE=4;

const{ var _n=-1; var[proxy]N=fcn{ _n+=1 } } // enumerator

code.del(0,sz+2);

}

The binary code file code.bin:

{{out}}