// ----------------------------------------------------------------------------
// Expressions
-export BinaryExpr
-type BinaryExpr struct {
+export type BinaryExpr struct {
typ_ *Globals.Type;
op int;
x, y Globals.Expr;
// ----------------------------------------------------------------------------
// Statements
-export Block
-type Block struct {
+export type Block struct {
// TODO fill in
}
-export IfStat
-type IfStat struct {
+export type IfStat struct {
cond Globals.Expr;
then_ Globals.Stat;
else_ Globals.Stat;
package base
-type Foo int
+export type Foo int
-type Bar *float;
+export type Bar *float;
-type Node struct {
+export type Node struct {
left, right *Node;
val bool;
f Foo
}
-
-export Foo, Bar, Node
import Verifier "verifier"
-export Compile
-func Compile(comp *Globals.Compilation, file_name string) {
+export func Compile(comp *Globals.Compilation, file_name string) {
src, ok := sys.readfile(file_name);
if !ok {
print "cannot open ", file_name, "\n"
import "base"
import base2 "base"
-const c0 int = 0
-const c1 float = 1.
+export const c0 int = 0
+export const c1 float = 1.
const (
- c2 byte = 2;
- c3 int = 3;
- c4 float = 4.;
+ c2 byte = 2;
+ c3 int = 3;
+ c4 float = 4.;
)
-type Node0 base.Node
-type Node1 *base2.Node
+export type (
+ Node0 base.Node
+ Node1 *base2.Node
+)
-type T0 byte
-type T1 T0
+export type T0 byte
+export type T1 T0
+type (
+ T2 [10]T0;
+ T3 map [string] int;
+)
+export type T4 struct {
+ f1, f2, f3 int;
+ f4 [] float;
+};
type (
- T2 [10]T0;
- T3 map [string] int;
- T4 struct {
- f1, f2, f3 int;
- f4 [] float;
- };
- T5 *T4;
+ T5 *T4;
)
type F0 func ()
type F6 func (a int, b float) bool
type F7 func (a int, b float, c, d *bool) bool
+export type M0 func (p T5) . ();
type (
- M0 func (p T5) . ();
- M1 func (p T5) . (a int);
- M2 func (p T5) . (a, b int, c float);
- M3 func (p T5) . () bool;
- M4 func (p T5) . (a int) (z T5, ok bool);
- M5 func (p T5) . (a, b int, c float) (z T5, ok bool);
+ M1 func (p T5) . (a int);
+ M2 func (p T5) . (a, b int, c float);
+ M3 func (p T5) . () bool;
+ M4 func (p T5) . (a int) (z T5, ok bool);
)
+export type M5 func (p T5) . (a, b int, c float) (z T5, ok bool);
type T6 chan int
type T7 chan<- *T6
type T8 chan-< *T6
type T9 struct {
- p *T9;
- q [] *map [int] *T9;
- f *func(x, y *T9) *T9;
+ p *T9;
+ q [] *map [int] *T9;
+ f *func(x, y *T9) *T9;
}
type T10;
type T11 struct {
- p *T10;
+ p *T10;
}
type T10 struct {
- p *T11;
+ p *T11;
}
type T12 struct {
- p *T12
+ p *T12
}
type I0 interface {}
type I1 interface {
- Do0(q *I0);
- Do1(p *I1) bool;
+ Do0(q *I0);
+ Do1(p *I1) bool;
}
-type I2 interface {
- M0();
- M1(a int);
- M2(a, b int, c float);
- M3() bool;
- M4(a int) (z T5, ok bool);
- M5(a, b int, c float) (z T5, ok bool);
+export type I2 interface {
+ M0();
+ M1(a int);
+ M2(a, b int, c float);
+ M3() bool;
+ M4(a int) (z T5, ok bool);
+ M5(a, b int, c float) (z T5, ok bool);
}
var v0 int
var v1 float = c1
-var (
- v2 T2;
- v3 struct {
- f1, f2, f3 *M0;
- }
+export var (
+ v2 T2;
+ v3 struct {
+ f1, f2, f3 *M0;
+ }
)
-func f0() {}
-func f1(a int) {}
+export func f0() {}
+export func f1(a int) {}
func f2(a, b int, c float) {}
func f3() bool { return false; }
func f4(a int) (z T5, ok bool) {}
func (p *T4) m3() bool { return false; }
func (p *T4) m4(a int) (z T5, ok bool) { return; }
func (p *T4) m5(a, b int, c float) (z T5, ok bool) {
- L: var x = a;
+ L: var x = a;
}
-
-export c0, c1, v2, v3
-export T0, T1, T4, T4, T4, M0, M5, I2, f0, f1
-export Node0, Node1
}
-export Export
-func Export(comp* Globals.Compilation, pkg_name string) {
+export func Export(comp* Globals.Compilation, pkg_name string) {
var E Exporter;
(&E).Export(comp, Utils.FixExt(Utils.BaseName(pkg_name)));
}
export var Universe_undef_t *Type // initialized by Universe to Universe.undef_t
-export NewObject
-func NewObject(pos, kind int, ident string) *Object {
+export func NewObject(pos, kind int, ident string) *Object {
obj := new(Object);
obj.exported = false;
obj.pos = pos;
}
-export NewType
-func NewType(form int) *Type {
+export func NewType(form int) *Type {
typ := new(Type);
typ.ref = -1; // not yet exported
typ.form = form;
}
-export NewPackage;
-func NewPackage(file_name string, obj *Object, scope *Scope) *Package {
+export func NewPackage(file_name string, obj *Object, scope *Scope) *Package {
pkg := new(Package);
pkg.ref = -1; // not yet exported
pkg.file_name = file_name;
}
-export NewList
-func NewList() *List {
+export func NewList() *List {
return new(List);
}
-export NewScope
-func NewScope(parent *Scope) *Scope {
+export func NewScope(parent *Scope) *Scope {
scope := new(Scope);
scope.parent = parent;
scope.entries = NewList();
}
-export NewCompilation;
-func NewCompilation(flags *Flags) *Compilation {
+export func NewCompilation(flags *Flags) *Compilation {
comp := new(Compilation);
comp.flags = flags;
return comp;
}
-export Import
-func Import(comp* Globals.Compilation, pkg_name string) *Globals.Package {
+export func Import(comp* Globals.Compilation, pkg_name string) *Globals.Package {
var I Importer;
return (&I).Import(comp, Utils.FixExt(pkg_name));
}
// globals.go.
-export KindStr
-func KindStr(kind int) string {
+export func KindStr(kind int) string {
switch kind {
case BAD: return "BAD";
case CONST: return "CONST";
import AST "ast"
-export Parser
-type Parser struct {
+export type Parser struct {
comp *Globals.Compilation;
semantic_checks bool;
verbose, indent int;
func (P *Parser) ParseExportDecl() {
P.Trace("ExportDecl");
- // TODO this needs to be clarified - the current syntax is
- // "everything goes" - sigh...
+ // TODO This is deprecated syntax and should go away eventually.
+ // (Also at the moment the syntax is everything goes...)
//P.Expect(Scanner.EXPORT);
+
+ if !P.comp.flags.sixg {
+ P.Error(P.pos, "deprecated export syntax (use -6g to enable)");
+ }
+
has_paren := false;
if P.tok == Scanner.LPAREN {
P.Next();
}
-export PrintObject
-func PrintObject(comp *Globals.Compilation, obj *Globals.Object, print_all bool) {
+export func PrintObject(comp *Globals.Compilation, obj *Globals.Object, print_all bool) {
var P Printer;
(&P).Init(comp, print_all);
(&P).PrintObjectStruct(obj);
var VerboseMsgs bool; // error message customization
-export TokenName
-func TokenName(tok int) string {
+export func TokenName(tok int) string {
switch (tok) {
case ILLEGAL: return "illegal";
case EOF: return "eof";
// globals.go.
-export FormStr
-func FormStr(form int) string {
+export func FormStr(form int) string {
switch form {
case UNDEF: return "UNDEF";
case BAD: return "BAD";
import Type "type"
-export
- scope,
- types,
- undef_t, bad_t, nil_t,
- bool_t,
- uint8_t, uint16_t, uint32_t, uint64_t,
- int8_t, int16_t, int32_t, int64_t,
- float32_t, float64_t, float80_t,
- string_t, any_t,
- byte_t,
- ushort_t, uint_t, ulong_t,
- short_t, int_t, long_t,
- float_t, double_t,
- ptrint_t,
- true_, false_
-
-
-var (
+export var (
scope *Globals.Scope;
types *Globals.List;
package Utils
-export BaseName
-func BaseName(s string) string {
+export func BaseName(s string) string {
// TODO this is not correct for non-ASCII strings!
i := len(s) - 1;
for i >= 0 && s[i] != '/' {
}
-export FixExt
-func FixExt(s string) string {
+export func FixExt(s string) string {
i := len(s) - 3; // 3 == len(".go");
if i >= 0 && s[i : len(s)] == ".go" {
s = s[0 : i];
}
-export GetEnv
-func GetEnv(key string) string {
+export func GetEnv(key string) string {
n := len(key);
for i := 0; i < sys.envc(); i++ {
v := sys.envv(i);
}
-export Verify
-func Verify(comp *Globals.Compilation) {
+export func Verify(comp *Globals.Compilation) {
for i := 0; i < comp.pkg_ref; i++ {
VerifyPackage(comp.pkg_list[i], i);
}