Compiler/AST interpreter: Difference between revisions

;Loading the AST from the syntax analyzer is as simple as (pseudo code):

 

line = readline()

# Each line has at least one token

left = load_ast()

right = load_ast()

 

; The interpreter algorithm is relatively simple:

 

if x == NULL return NULL

elif x.node_type == Integer return x.value converted to an integer

return NULL

else

 

Notes:

|-

| style="vertical-align:top" |

Simple prime number generator

*/

}

}

 

| style="vertical-align:top" |

 

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

% parse tree nodes %

record node( integer type

% parse the output from the syntax analyser and intetrpret parse tree %

eval( readNode )

{{out}}

<pre>

11 is prime

...

83 is prime

89 is prime

=={{header|C}}==

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

#include <stdio.h>

#include <string.h>

 

return 0;

 

{{out|case=prime numbers output from AST interpreter}}

Code by Steve Williams. Tested with GnuCOBOL 2.2.

 

identification division.

*> this code is dedicated to the public domain

.

end program reporterror.

 

{{out|case=Primes}}

=={{header|Forth}}==

Tested with Gforth 0.7.3

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

: GETC PEEK 0 BUF ! ;

 

GETAST INTERP

Passes all tests.

 

The code is Fortran 2008/2018 with the C preprocessor. On case-sensitive systems, you can name the source file Interp.F90, with a capital F, so gfortran will know (without an option flag) to invoke the C preprocessor.

 

!!! An implementation of the Rosetta Code interpreter task:

!!! https://rosettacode.org/wiki/Compiler/AST_interpreter

end subroutine print_usage

 

{{out}}

=={{header|Go}}==

{{trans|C}}

 

import (

x := loadAst()

interp(x)

 

{{out}}

Implementation:

 

emit=:{{

outbuf=: outbuf,y

end.

}}

 

Task example:

 

/*

Simple prime number generator

Total primes found: 26

 

 

=={{header|Java}}==

import java.util.Scanner;

import java.io.File;

}

 

 

=={{header|Julia}}==

node_type::String

left::Union{Nothing, Anode}

 

interp(load_ast(lio))

3 is prime

5 is prime

Using AST produced by the parser from the task “syntax analyzer”.

 

 

import ast_parser

if toClose: stream.close()

 

 

{{out}}

Tested with perl v5.26.1

 

 

use strict; # interpreter.pl - execute a flatAST

sub Sequence::run { $_->run for $_[0]->@* }

sub Subtract::run { $_[0][0]->run - $_[0][1]->run }

Passes all tests.

 

=={{header|Phix}}==

Reusing parse.e from the [[Compiler/syntax_analyzer#Phix|Syntax Analyzer task]]

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

-- demo\rosetta\Compiler\interp.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;">"primes.c"</span><span style="color: #0000FF;">})</span>

{{out}}

<pre>

=={{header|Python}}==

Tested with Python 2.7 and 3.x

import sys, shlex, operator

 

 

n = load_ast()

 

{{out|case=prime numbers output from AST interpreter}}

</pre>

</b>

 

=={{header|Scala}}==

The following code implements an interpreter for the output of the [http://rosettacode.org/wiki/Compiler/syntax_analyzer#Scala parser].

 

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}}==

 

(import (scheme base)

(scheme file)

(run-program (read-code (cadr (command-line))))

(display "Error: pass an ast filename\n"))

 

{{out}}

{{libheader|Wren-fmt}}

{{libheader|Wren-ioutil}}

 

var nodes = [

lineCount = lines.count

var x = loadAst.call()

 

{{out}}

Total primes found: 26

</pre>

 

=={{header|Zig}}==

const std = @import("std");

 

.prts => _ = try self.out("{s}", .{(try self.interp(t.left)).?.string}),

.prti => _ = try self.out("{d}", .{(try self.interp(t.left)).?.integer}),

.string => return t.value,

.integer => return t.value,

fn binOp(

self: *Self,

a: ?*Tree,

b: ?*Tree,

 

fn less(a: i32, b: i32) i32 {

}

fn less_equal(a: i32, b: i32) i32 {

}

fn greater(a: i32, b: i32) i32 {

}

fn greater_equal(a: i32, b: i32) i32 {

}

fn equal(a: i32, b: i32) i32 {

}

fn not_equal(a: i32, b: i32) i32 {

}

fn add(a: i32, b: i32) i32 {

}

fn @"or"(a: i32, b: i32) i32 {

}

fn @"and"(a: i32, b: i32) i32 {

}

};

const allocator = arena.allocator();

 

// We accept both files and standard input.

var file_handle = blk: {

if (file_name) |file_name_delimited| {

break :blk try std.fs.cwd().openFile(fname, .{});

} else {

fn loadASTHelper(

allocator: std.mem.Allocator,

string_pool: *std.ArrayList([]const u8),

) LoadASTError!?*Tree {

}

}

 

=={{header|zkl}}==

const FETCH=N, STORE=N, PUSH=N, ADD=N, SUB=N, MUL=N, DIV=N, MOD=N,

LT=N, GT=N, LE=N, GE=N, EQ=N, NE=N,

}

Void

line:=file.readln().strip(); // one or two tokens

if(line[0]==";") return(Void);

left,right := load_ast(file),load_ast(file);

Node(type,Void,left,right)

{{out}}

<pre>