Compiler/code generator: Difference between revisions

into lower level code, either assembly, object, or virtual.

 

 

Take the output of the Syntax analyzer [[Compiler/syntax_analyzer|task]] - which is a [[Flatten_a_list|flattened]] Abstract Syntax Tree (AST) - and convert it to virtual machine code, that can be run by the

|-

| style="vertical-align:top" |

while (count < 10) {

print("count is: ", count, "\n");

count = count + 1;

 

| style="vertical-align:top" |

Loading this data into an internal parse tree should be as simple as:

 

def load_ast()

line = readline()

right = load_ast()

return make_node(node_type, left, right)

 

; Output format - refer to the table above

<br>

As noted in the code, the generated IL is naive - the sample focuses on simplicity.

COMMENT

this writes a .NET IL assembler source to standard output.

code header;

gen( code );

{{out}}

<pre>

 

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

% parse tree nodes %

record node( integer type

genOp0( oHalt );

emitCode

{{out}}

The While Counter example

60 jmp (-51) 10

65 halt

</pre>

 

=={{header|AWK}}==

Tested with gawk 4.1.1 and mawk 1.3.4.

function error(msg) {

printf("%s\n", msg)

list_code()

}

{{out|case=count}}

<b>

=={{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=While counter example}}

Code by Steve Williams. Tested with GnuCOBOL 2.2.

 

identification division.

*> this code is dedicated to the public domain

.

end program showhex.

 

{{out|case=Count}}

=={{header|Forth}}==

Tested with Gforth 0.7.3

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

: GETC PEEK 0 BUF ! ;

DUP 5 < IF CELLS .INT + @ EXECUTE ELSE DROP THEN CR

REPEAT DROP R> DROP ;

Passes all tests.

 

Fortran 2008/2018 code with C preprocessing. On case-sensitive systems, if you call the source file gen.F90, with a capital F, 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|C}}

 

import (

codeFinish()

listCode()

 

{{out}}

 

Implementation:

 

(opcodes)=: opcodes=: ;:{{)n

gen_code load_ast y

list_code gen_op halt

 

Count example:

count=:{{)n

count = 1;

60 jmp (-51) 10

65 halt

 

=={{header|Java}}==

{{trans|Python}}

 

import java.io.File;

}

}

 

=={{header|Julia}}==

 

mutable struct Asm32

 

compiletoasm(iob)

Datasize: 1 Strings: 2

"count is: "

 

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

Module CodeGenerator (s$){

Function code$(op$) {

Integer 1

}

 

{{out}}

=={{header|Nim}}==

 

 

type

if toClose: stream.close()

 

 

{{out}}

=={{header|Perl}}==

Tested with perl v5.26.1

 

use strict; # gen.pl - flatAST to stack machine code

print "Datasize: $namecount Strings: $stringcount\n";

print "$_\n" for sort { $strings{$a} <=> $strings{$b} } keys %strings;

Passes all tests.

 

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

Deviates somewhat from the task specification in that it generates executable machine code.

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

-- demo\rosetta\Compiler\cgen.e

<span style="color: #008080;">end</span> <span style="color: #008080;">while</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">procedure</span>

And a simple test driver for the specific task:

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

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

{{out}}

<pre>

=={{header|Python}}==

Tested with Python 2.7 and 3.x

import sys, struct, shlex, operator

 

code_gen(n)

code_finish()

 

{{out|case=While counter example}}

Using 'while-count' example, input used is here: [https://github.com/SqrtNegInf/Rosettacode-Perl6-Smoke/blob/master/ref/ast.txt ast.txt]

{{trans|Perl}}

Less lt LessEqual le Multiply mul Subtract sub NotEqual ne

Divide div GreaterEqual ge Equal eq Greater gt Negate neg

say "Datasize: $name-count Strings: $string-count\n"

~ join('', %strings.keys.sort.reverse «~» "\n")

{{out}}

<pre>Datasize: 1 Strings: 2

 

 

#

# The Rosetta Code code generator in Ratfor 77.

end

 

 

{{out}}

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

 

package xyz.hyperreal.rosettacodeCompiler

 

 

}

 

=={{header|Scheme}}==

 

(import (scheme base)

(scheme file)

(generate-code (read-code (cadr (command-line))))

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

 

Tested on all examples in [[Compiler/Sample programs]].

{{libheader|Wren-fmt}}

{{libheader|Wren-ioutil}}

 

var nodes = [

codeGen.call(loadAst.call())

codeFinish.call()

 

{{out}}

 

=={{header|Zig}}==

const std = @import("std");

 

}

}

 

=={{header|zkl}}==

{{trans|Python}}

 

const WORD_SIZE=4;

code.insert(0,66,text.len(),text);

})

all_ops,nthString := all_syms.pump(Dictionary(),"reverse"),-1;

println("Datasize: %d bytes, Strings: %d bytes"

}

}

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)

code:=asm(ast,Data());

code_finish(code);

unasm(code);

File("code.bin","wb").write(code);

File ast.txt is the text at the start of this task.

{{out}}