2600→		val, err := strconv.ParseInt(literal, base, 64)
  2601→		if err != nil {
  2602→			p.addError(fmt.Sprintf("could not parse %q as integer", p.curToken.Literal))
  2603→			return nil
  2604→		}
  2605→		left = &ast.IntegerLiteral{Token: p.curToken, Value: val}
  2606→	case lexer.TRUE:
  2607→		left = &ast.BooleanLiteral{Token: p.curToken, Value: true}
  2608→	case lexer.FALSE:
  2609→		left = &ast.BooleanLiteral{Token: p.curToken, Value: false}
  2610→	case lexer.STRING:
  2611→		left = &ast.StringLiteral{Token: p.curToken, Value: p.curToken.Literal}
  2612→	case lexer.BYTE_LIT:
  2613→		b, err := p.parseByteLiteralValue(p.curToken.Literal)
  2614→		if err != nil {
  2615→			p.addError(err.Error())
  2616→			return nil
  2617→		}
  2618→		left = &ast.ByteLiteral{Token: p.curToken, Value: b}
  2619→	case lexer.LPAREN:
  2620→		p.nextToken()
  2621→		left = p.parseExpression(LOWEST)
  2622→		if !p.expectPeek(lexer.RPAREN) {
  2623→			return nil
  2624→		}
  2625→	case lexer.MINUS, lexer.MINUS_KW:
  2626→		token := p.curToken
  2627→		p.nextToken()
  2628→		left = &ast.UnaryExpr{
  2629→			Token:    token,

     1→package codegen
     2→
     3→import (
     4→	"fmt"
     5→	"strings"
     6→
     7→	"github.com/codeassociates/occam2go/ast"
     8→)
     9→
    10→// Generator converts an AST to Go code
    11→type Generator struct {
    12→	indent   int
    13→	builder  strings.Builder
    14→	needSync bool // track if we need sync package import
    15→	needFmt  bool // track if we need fmt package import
    16→	needTime bool // track if we need time package import
    17→	needOs   bool // track if we need os package import
    18→	needMath bool // track if we need math package import
    19→	needMathBits bool // track if we need math/bits package import
    20→
    21→	// Track procedure signatures for proper pointer handling
    22→	procSigs map[string][]ast.ProcParam
    23→	// Track current procedure's reference parameters
    24→	refParams map[string]bool
    25→
    26→	// Protocol support
    27→	protocolDefs  map[string]*ast.ProtocolDecl
    28→	chanProtocols map[string]string // channel name → protocol name
    29→	tmpCounter    int               // for unique temp variable names
    30→
    31→	// Record support
    32→	recordDefs map[string]*ast.RecordDecl
    33→	recordVars map[string]string // variable name → record type name
    34→
    35→	// Nesting level: 0 = package level, >0 = inside a function
    36→	nestingLevel int
    37→
    38→	// RETYPES parameter renames: when a RETYPES declaration shadows a
    39→	// parameter (e.g. VAL INT X RETYPES X :), the parameter is renamed
    40→	// in the signature so := can create a new variable with the original name.
    41→	retypesRenames map[string]string
    42→}
    43→
    44→// Transputer intrinsic function names
    45→var transpIntrinsics = map[string]bool{
    46→	"LONGPROD":   true,
    47→	"LONGDIV":    true,
    48→	"LONGSUM":    true,
    49→	"LONGDIFF":   true,
    50→	"NORMALISE":  true,
    51→	"SHIFTRIGHT": true,
    52→	"SHIFTLEFT":  true,
    53→}
    54→
    55→// Built-in print procedures
    56→var printBuiltins = map[string]bool{
    57→	"print.int":     true,
    58→	"print.string":  true,
    59→	"print.bool":    true,
    60→	"print.newline": true,

2317:// parseByteLiteralValue processes the raw content of a byte literal (between single quotes),
2319:func (p *Parser) parseByteLiteralValue(raw string) (byte, error) {
2613:		b, err := p.parseByteLiteralValue(p.curToken.Literal)

  2317→// parseByteLiteralValue processes the raw content of a byte literal (between single quotes),
  2318→// handling occam escape sequences (* prefix), and returns the resulting byte value.
  2319→func (p *Parser) parseByteLiteralValue(raw string) (byte, error) {
  2320→	if len(raw) == 0 {
  2321→		return 0, fmt.Errorf("empty byte literal")
  2322→	}
  2323→	if raw[0] == '*' {
  2324→		if len(raw) != 2 {
  2325→			return 0, fmt.Errorf("invalid escape sequence in byte literal: '*%s'", raw[1:])
  2326→		}
  2327→		switch raw[1] {
  2328→		case 'n':
  2329→			return '\n', nil
  2330→		case 'c':
  2331→			return '\r', nil
  2332→		case 't':
  2333→			return '\t', nil
  2334→		case 's':
  2335→			return ' ', nil
  2336→		case '*':
  2337→			return '*', nil
  2338→		case '\'':
  2339→			return '\'', nil
  2340→		case '"':
  2341→			return '"', nil
  2342→		default:
  2343→			return 0, fmt.Errorf("unknown escape sequence in byte literal: '*%c'", raw[1])
  2344→		}
  2345→	}
  2346→	if len(raw) != 1 {
  2347→		return 0, fmt.Errorf("byte literal must be a single character, got %q", raw)
  2348→	}
  2349→	return raw[0], nil
  2350→}
  2351→
  2352→func (p *Parser) parseFuncCallExpr() *ast.FuncCall {
  2353→	call := &ast.FuncCall{
  2354→		Token: p.curToken,
  2355→		Name:  p.curToken.Literal,
  2356→	}
  2357→
  2358→	p.nextToken() // consume (
  2359→
  2360→	if p.peekTokenIs(lexer.RPAREN) {
  2361→		p.nextToken() // consume )
  2362→		return call
  2363→	}
  2364→
  2365→	p.nextToken() // move to first arg
  2366→	call.Args = append(call.Args, p.parseExpression(LOWEST))

   240→				goType = "[]" + goType
   241→			}
   242→			g.builder.WriteString("var ")
   243→			g.write(fmt.Sprintf("%s %s = ", goIdent(abbr.Name), goType))
   244→			g.generateExpression(abbr.Value)
   245→			g.write("\n")
   246→		}
   247→	}
   248→	if len(abbrDecls) > 0 {
   249→		g.writeLine("")
   250→	}
   251→
   252→	// Generate procedure declarations (at package level)
   253→	for _, stmt := range procDecls {
   254→		g.generateStatement(stmt)
   255→	}
   256→
   257→	// Generate main function with other statements
   258→	if len(mainStatements) > 0 {
   259→		g.writeLine("func main() {")
   260→		g.indent++
   261→		g.nestingLevel++
   262→		for _, stmt := range mainStatements {
   263→			g.generateStatement(stmt)
   264→		}
   265→		g.nestingLevel--
   266→		g.indent--
   267→		g.writeLine("}")
   268→	}
   269→
   270→	return g.builder.String()
   271→}
   272→
   273→// collectNestedProcSigs recursively collects procedure/function signatures
   274→// from nested declarations inside PROC bodies.
   275→func (g *Generator) collectNestedProcSigs(stmts []ast.Statement) {
   276→	for _, stmt := range stmts {
   277→		switch s := stmt.(type) {
   278→		case *ast.ProcDecl:
   279→			g.procSigs[s.Name] = s.Params
   280→			g.collectNestedProcSigs(s.Body)
   281→		case *ast.FuncDecl:
   282→			g.procSigs[s.Name] = s.Params
   283→			g.collectNestedProcSigs(s.Body)
   284→		case *ast.SeqBlock:
   285→			g.collectNestedProcSigs(s.Statements)
   286→		case *ast.ParBlock:
   287→			g.collectNestedProcSigs(s.Statements)
   288→		case *ast.IfStatement:
   289→			for _, c := range s.Choices {
   290→				g.collectNestedProcSigs(c.Body)
   291→			}
   292→		case *ast.WhileLoop:
   293→			g.collectNestedProcSigs(s.Body)
   294→		case *ast.CaseStatement:
   295→			for _, ch := range s.Choices {
   296→				g.collectNestedProcSigs(ch.Body)
   297→			}
   298→		}
   299→	}
   300→}
   301→
   302→// collectNestedProcSigsScoped registers nested proc/func signatures into procSigs
   303→// for the current scope. It saves old values into oldSigs so they can be restored
   304→// after the scope ends (preventing name collisions between same-named nested procs
   305→// in different parent procs).
   306→func (g *Generator) collectNestedProcSigsScoped(stmts []ast.Statement, oldSigs map[string][]ast.ProcParam) {
   307→	for _, stmt := range stmts {
   308→		switch s := stmt.(type) {
   309→		case *ast.ProcDecl:
   310→			if _, saved := oldSigs[s.Name]; !saved {
   311→				oldSigs[s.Name] = g.procSigs[s.Name] // nil if not previously set
   312→			}
   313→			g.procSigs[s.Name] = s.Params
   314→			g.collectNestedProcSigsScoped(s.Body, oldSigs)
   315→		case *ast.FuncDecl:
   316→			if _, saved := oldSigs[s.Name]; !saved {
   317→				oldSigs[s.Name] = g.procSigs[s.Name]
   318→			}
   319→			g.procSigs[s.Name] = s.Params

88:func (g *Generator) Generate(program *ast.Program) string {

    88→func (g *Generator) Generate(program *ast.Program) string {
    89→	g.builder.Reset()
    90→	g.needSync = false
    91→	g.needFmt = false
    92→	g.needTime = false
    93→	g.needOs = false
    94→	g.needMath = false
    95→	g.needMathBits = false
    96→	g.procSigs = make(map[string][]ast.ProcParam)
    97→	g.refParams = make(map[string]bool)
    98→	g.protocolDefs = make(map[string]*ast.ProtocolDecl)
    99→	g.chanProtocols = make(map[string]string)
   100→	g.tmpCounter = 0
   101→	g.recordDefs = make(map[string]*ast.RecordDecl)
   102→	g.recordVars = make(map[string]string)
   103→
   104→	// First pass: collect procedure signatures, protocols, and check for PAR/print
   105→	for _, stmt := range program.Statements {
   106→		if g.containsPar(stmt) {
   107→			g.needSync = true
   108→		}
   109→		if g.containsPrint(stmt) {
   110→			g.needFmt = true
   111→		}
   112→		if g.containsTimer(stmt) {
   113→			g.needTime = true
   114→		}
   115→		if g.containsStop(stmt) {
   116→			g.needOs = true
   117→			g.needFmt = true
   118→		}
   119→		if g.containsMostExpr(stmt) {
   120→			g.needMath = true
   121→		}
   122→		if g.containsIntrinsics(stmt) {
   123→			g.needMathBits = true
   124→		}
   125→		if g.containsRetypes(stmt) {
   126→			g.needMath = true
   127→		}
   128→		if proc, ok := stmt.(*ast.ProcDecl); ok {
   129→			g.procSigs[proc.Name] = proc.Params
   130→			g.collectNestedProcSigs(proc.Body)
   131→		}
   132→		if fn, ok := stmt.(*ast.FuncDecl); ok {
   133→			g.procSigs[fn.Name] = fn.Params
   134→		}
   135→		if proto, ok := stmt.(*ast.ProtocolDecl); ok {
   136→			g.protocolDefs[proto.Name] = proto
   137→		}
   138→		if rec, ok := stmt.(*ast.RecordDecl); ok {
   139→			g.recordDefs[rec.Name] = rec
   140→		}
   141→		g.collectChanProtocols(stmt)
   142→		g.collectRecordVars(stmt)
   143→	}
   144→
   145→	// Write package declaration
   146→	g.writeLine("package main")
   147→	g.writeLine("")
   148→
   149→	// Write imports
   150→	if g.needSync || g.needFmt || g.needTime || g.needOs || g.needMath || g.needMathBits {
   151→		g.writeLine("import (")
   152→		g.indent++
   153→		if g.needFmt {
   154→			g.writeLine(`"fmt"`)
   155→		}
   156→		if g.needMath {
   157→			g.writeLine(`"math"`)
   158→		}
   159→		if g.needMathBits {
   160→			g.writeLine(`"math/bits"`)
   161→		}
   162→		if g.needOs {
   163→			g.writeLine(`"os"`)
   164→		}
   165→		if g.needSync {
   166→			g.writeLine(`"sync"`)
   167→		}
   168→		if g.needTime {
   169→			g.writeLine(`"time"`)
   170→		}
   171→		g.indent--
   172→		g.writeLine(")")
   173→		g.writeLine("")
   174→	}
   175→
   176→	// Emit transputer intrinsic helper functions
   177→	if g.needMathBits {
   178→		g.emitIntrinsicHelpers()
   179→	}
   180→
   181→	// Separate protocol, record, procedure declarations from other statements
   182→	var typeDecls []ast.Statement
   183→	var procDecls []ast.Statement
   184→	var mainStatements []ast.Statement
   185→
   186→	// First pass: check if there are any proc/func declarations
   187→	hasProcDecls := false
   188→	for _, stmt := range program.Statements {
   189→		if _, ok := stmt.(*ast.ProcDecl); ok {
   190→			hasProcDecls = true
   191→			break
   192→		}
   193→		if _, ok := stmt.(*ast.FuncDecl); ok {
   194→			hasProcDecls = true
   195→			break
   196→		}
   197→	}
   198→
   199→	var abbrDecls []ast.Statement
   200→	for _, stmt := range program.Statements {
   201→		switch s := stmt.(type) {
   202→		case *ast.ProtocolDecl, *ast.RecordDecl:
   203→			typeDecls = append(typeDecls, stmt)
   204→		case *ast.ProcDecl, *ast.FuncDecl:
   205→			procDecls = append(procDecls, stmt)
   206→		case *ast.Abbreviation:
   207→			if hasProcDecls {
   208→				// Top-level abbreviations need to be at package level
   209→				// so PROCs can reference them
   210→				abbrDecls = append(abbrDecls, stmt)
   211→			} else {
   212→				mainStatements = append(mainStatements, stmt)
   213→			}
   214→		case *ast.RetypesDecl:
   215→			_ = s
   216→			// RETYPES declarations are local to functions, not package-level
   217→			mainStatements = append(mainStatements, stmt)
   218→		default:
   219→			mainStatements = append(mainStatements, stmt)
   220→		}
   221→	}
   222→
   223→	// Generate type definitions first (at package level)
   224→	for _, stmt := range typeDecls {
   225→		g.generateStatement(stmt)
   226→	}
   227→
   228→	// Generate package-level abbreviations (constants)
   229→	for _, stmt := range abbrDecls {
   230→		abbr := stmt.(*ast.Abbreviation)
   231→		if abbr.Type == "" {
   232→			// Untyped VAL: let Go infer the type
   233→			g.builder.WriteString("var ")
   234→			g.write(fmt.Sprintf("%s = ", goIdent(abbr.Name)))
   235→			g.generateExpression(abbr.Value)
   236→			g.write("\n")
   237→		} else {
   238→			goType := g.occamTypeToGo(abbr.Type)
   239→			if abbr.IsOpenArray {
   240→				goType = "[]" + goType
   241→			}
   242→			g.builder.WriteString("var ")
   243→			g.write(fmt.Sprintf("%s %s = ", goIdent(abbr.Name), goType))
   244→			g.generateExpression(abbr.Value)
   245→			g.write("\n")
   246→		}
   247→	}

    60→	"print.newline": true,
    61→}
    62→
    63→// New creates a new code generator
    64→func New() *Generator {
    65→	return &Generator{}
    66→}
    67→
    68→// goIdent converts an occam identifier to a valid Go identifier.
    69→// Occam allows dots in identifiers (e.g., out.repeat); Go does not.
    70→// goReserved is a set of Go keywords and predeclared identifiers that cannot be
    71→// used as variable names when they also appear as type conversions in the generated code.
    72→var goReserved = map[string]bool{
    73→	"byte": true, "int": true, "string": true, "len": true, "cap": true,
    74→	"make": true, "new": true, "copy": true, "close": true, "delete": true,
    75→	"panic": true, "recover": true, "print": true, "println": true,
    76→	"error": true, "rune": true, "bool": true, "true": true, "false": true,
    77→}
    78→
    79→func goIdent(name string) string {
    80→	name = strings.ReplaceAll(name, ".", "_")
    81→	if goReserved[name] {
    82→		return "_" + name
    83→	}
    84→	return name
    85→}
    86→
    87→// Generate produces Go code from the AST
    88→func (g *Generator) Generate(program *ast.Program) string {
    89→	g.builder.Reset()

144:type ProcParam struct {
145-	IsVal        bool   // VAL parameter (pass by value)
146-	Type         string // INT, BYTE, BOOL, etc.
147-	Name         string
148-	IsChan       bool   // true if this is a CHAN OF <type> parameter
149-	IsChanArray  bool   // true for []CHAN OF TYPE params
150-	IsOpenArray  bool   // true for []TYPE params (open array)
151-	ChanElemType string // element type when IsChan (e.g., "INT")
152-	ChanDir      string // "?" for input, "!" for output, "" for bidirectional
153-	ArraySize    string // non-empty for fixed-size array params like [2]INT
154-}
155-
156-// ProcCall represents a procedure call
157-type ProcCall struct {
158-	Token lexer.Token // the procedure name token
159-	Name  string

/home/david/projects/code-associates/occam2go/kroc/modules/course/examples/hello_world.occ

2059:	case *ast.StringLiteral:
2060-		g.write(fmt.Sprintf("%q", e.Value))
2061-	case *ast.ByteLiteral:
2062-		g.write(fmt.Sprintf("byte(%d)", e.Value))

     1→#INCLUDE "course.module"
     2→
     3→PROC hello.world (CHAN BYTE keyboard?, screen!, error!)
     4→  --{{{
     5→  out.string ("Hello World*c*n", 0, screen!)
     6→  --}}}
     7→:
     8→

106:		if g.containsPar(stmt) {
109:		if g.containsPrint(stmt) {
112:		if g.containsTimer(stmt) {
115:		if g.containsStop(stmt) {
119:		if g.containsMostExpr(stmt) {
122:		if g.containsIntrinsics(stmt) {
125:		if g.containsRetypes(stmt) {
339:func (g *Generator) containsPar(stmt ast.Statement) bool {
345:			if g.containsPar(inner) {
352:				if g.containsPar(inner) {
359:			if g.containsPar(inner) {
365:			if g.containsPar(inner) {
371:			if g.containsPar(inner) {
378:				if g.containsPar(choice.NestedIf) {
383:				if g.containsPar(inner) {
391:				if g.containsPar(inner) {
398:			if c.Body != nil && g.containsPar(c.Body) {
406:func (g *Generator) containsPrint(stmt ast.Statement) bool {
412:			if g.containsPrint(inner) {
418:			if g.containsPrint(inner) {

[Showing results with pagination = limit: 20, offset: 0]

Task #1 created successfully: Add convertOccamStringEscapes to parser

Task #2 created successfully: Generate main() harness for entry point PROCs

Task #3 created successfully: Add parser and codegen tests

Updated task #1 status

The file /home/david/projects/code-associates/occam2go/parser/parser.go has been updated successfully.

3:import (
4:	"fmt"
6:	"strings"

[Showing results with pagination = limit: 10, offset: 0]

The file /home/david/projects/code-associates/occam2go/parser/parser.go has been updated successfully.

Updated task #1 status

Updated task #2 status

The file /home/david/projects/code-associates/occam2go/codegen/codegen.go has been updated successfully.

The file /home/david/projects/code-associates/occam2go/codegen/codegen.go has been updated successfully.

The file /home/david/projects/code-associates/occam2go/codegen/codegen.go has been updated successfully.

The file /home/david/projects/code-associates/occam2go/codegen/codegen.go has been updated successfully.

89:func (g *Generator) Generate(program *ast.Program) string {
282:func (g *Generator) collectNestedProcSigs(stmts []ast.Statement) {
313:func (g *Generator) collectNestedProcSigsScoped(stmts []ast.Statement, oldSigs map[string][]ast.ProcParam) {
346:func (g *Generator) containsPar(stmt ast.Statement) bool {
413:func (g *Generator) containsPrint(stmt ast.Statement) bool {
486:func (g *Generator) containsTimer(stmt ast.Statement) bool {
562:func (g *Generator) containsStop(stmt ast.Statement) bool {
635:func (g *Generator) containsMostExpr(stmt ast.Statement) bool {
750:func (g *Generator) exprNeedsMath(expr ast.Expression) bool {
788:func (g *Generator) generateMostExpr(e *ast.MostExpr) {
817:func (g *Generator) writeLine(s string) {
827:func (g *Generator) write(s string) {
831:func (g *Generator) generateStatement(stmt ast.Statement) {
887:func (g *Generator) generateVarDecl(decl *ast.VarDecl) {
900:func (g *Generator) generateAbbreviation(abbr *ast.Abbreviation) {
911:func (g *Generator) generateChanDecl(decl *ast.ChanDecl) {
930:func (g *Generator) generateTimerDecl(decl *ast.TimerDecl) {
936:func (g *Generator) generateTimerRead(tr *ast.TimerRead) {
940:func (g *Generator) generateArrayDecl(decl *ast.ArrayDecl) {
951:func (g *Generator) generateSend(send *ast.Send) {
998:func (g *Generator) generateReceive(recv *ast.Receive) {
1040:func (g *Generator) generateProtocolDecl(proto *ast.ProtocolDecl) {
1087:func (g *Generator) generateVariantReceive(vr *ast.VariantReceive) {
1118:func (g *Generator) isVariantTag(protoName, tagName string) bool {
1131:func (g *Generator) collectChanProtocols(stmt ast.Statement) {
1191:func (g *Generator) collectRecordVars(stmt ast.Statement) {
1250:func (g *Generator) generateRecordDecl(rec *ast.RecordDecl) {
1264:func (g *Generator) occamTypeToGoBase(occamType string) string {
1283:func (g *Generator) occamTypeToGo(occamType string) string {
1310:func (g *Generator) generateAssignment(assign *ast.Assignment) {
1364:func (g *Generator) generateSeqBlock(seq *ast.SeqBlock) {
1407:func (g *Generator) generateParBlock(par *ast.ParBlock) {
1474:func (g *Generator) generateAltBlock(alt *ast.AltBlock) {
1530:func (g *Generator) generateProcDecl(proc *ast.ProcDecl) {
1623:func (g *Generator) generateProcParams(params []ast.ProcParam) string {
1664:func (g *Generator) generateProcCall(call *ast.ProcCall) {
1706:func (g *Generator) generateFuncDecl(fn *ast.FuncDecl) {
1753:func (g *Generator) generateFuncCallExpr(call *ast.FuncCall) {
1777:func (g *Generator) generateMultiAssignment(stmt *ast.MultiAssignment) {
1820:func (g *Generator) generatePrintCall(call *ast.ProcCall) {
1837:func (g *Generator) generateWhileLoop(loop *ast.WhileLoop) {
1852:func (g *Generator) generateIfStatement(stmt *ast.IfStatement) {
1865:func (g *Generator) flattenIfChoices(choices []ast.IfChoice) []ast.IfChoice {
1880:func (g *Generator) generateReplicatedIfLoop(stmt *ast.IfStatement, withinFlag bool, flagName ...string) {
1938:func (g *Generator) generateIfChoiceChain(choices []ast.IfChoice, isFirst bool) {
2026:func (g *Generator) generateCaseStatement(stmt *ast.CaseStatement) {
2056:func (g *Generator) generateExpression(expr ast.Expression) {
2127:func (g *Generator) generateBinaryExpr(expr *ast.BinaryExpr) {
2137:func (g *Generator) generateUnaryExpr(expr *ast.UnaryExpr) {
2148:func (g *Generator) occamOpToGo(op string) string {
2188:func (g *Generator) generateArrayLiteral(al *ast.ArrayLiteral) {
2204:func (g *Generator) generateRetypesDecl(r *ast.RetypesDecl) {
2224:func (g *Generator) containsIntrinsics(stmt ast.Statement) bool {
2234:func (g *Generator) containsRetypes(stmt ast.Statement) bool {
2293:func (g *Generator) walkStatements(stmt ast.Statement, fn func(ast.Expression) bool) bool {
2402:func (g *Generator) walkExpr(expr ast.Expression, fn func(ast.Expression) bool) bool {
2442:func (g *Generator) emitIntrinsicHelpers() {

   336→		case *ast.WhileLoop:
   337→			g.collectNestedProcSigsScoped(s.Body, oldSigs)
   338→		case *ast.CaseStatement:
   339→			for _, ch := range s.Choices {
   340→				g.collectNestedProcSigsScoped(ch.Body, oldSigs)
   341→			}
   342→		}
   343→	}
   344→}
   345→
   346→func (g *Generator) containsPar(stmt ast.Statement) bool {
   347→	switch s := stmt.(type) {
   348→	case *ast.ParBlock:
   349→		return true
   350→	case *ast.SeqBlock:

The file /home/david/projects/code-associates/occam2go/codegen/codegen.go has been updated successfully.

    89→func (g *Generator) Generate(program *ast.Program) string {
    90→	g.builder.Reset()
    91→	g.needSync = false
    92→	g.needFmt = false
    93→	g.needTime = false
    94→	g.needOs = false
    95→	g.needMath = false
    96→	g.needMathBits = false
    97→	g.needBufio = false
    98→	g.procSigs = make(map[string][]ast.ProcParam)
    99→	g.refParams = make(map[string]bool)
   100→	g.protocolDefs = make(map[string]*ast.ProtocolDecl)
   101→	g.chanProtocols = make(map[string]string)
   102→	g.tmpCounter = 0
   103→	g.recordDefs = make(map[string]*ast.RecordDecl)
   104→	g.recordVars = make(map[string]string)
   105→
   106→	// First pass: collect procedure signatures, protocols, and check for PAR/print
   107→	for _, stmt := range program.Statements {
   108→		if g.containsPar(stmt) {

   196→			break
   197→		}
   198→		if _, ok := stmt.(*ast.FuncDecl); ok {
   199→			hasProcDecls = true
   200→			break
   201→		}
   202→	}
   203→
   204→	var abbrDecls []ast.Statement
   205→	for _, stmt := range program.Statements {
   206→		switch s := stmt.(type) {
   207→		case *ast.ProtocolDecl, *ast.RecordDecl:
   208→			typeDecls = append(typeDecls, stmt)
   209→		case *ast.ProcDecl, *ast.FuncDecl:
   210→			procDecls = append(procDecls, stmt)
   211→		case *ast.Abbreviation:
   212→			if hasProcDecls {
   213→				// Top-level abbreviations need to be at package level
   214→				// so PROCs can reference them
   215→				abbrDecls = append(abbrDecls, stmt)
   216→			} else {
   217→				mainStatements = append(mainStatements, stmt)
   218→			}
   219→		case *ast.RetypesDecl:
   220→			_ = s
   221→			// RETYPES declarations are local to functions, not package-level
   222→			mainStatements = append(mainStatements, stmt)
   223→		default:
   224→			mainStatements = append(mainStatements, stmt)
   225→		}
   226→	}
   227→
   228→	// Generate type definitions first (at package level)
   229→	for _, stmt := range typeDecls {
   230→		g.generateStatement(stmt)
   231→	}
   232→
   233→	// Generate package-level abbreviations (constants)
   234→	for _, stmt := range abbrDecls {
   235→		abbr := stmt.(*ast.Abbreviation)
   236→		if abbr.Type == "" {
   237→			// Untyped VAL: let Go infer the type
   238→			g.builder.WriteString("var ")
   239→			g.write(fmt.Sprintf("%s = ", goIdent(abbr.Name)))
   240→			g.generateExpression(abbr.Value)
   241→			g.write("\n")
   242→		} else {
   243→			goType := g.occamTypeToGo(abbr.Type)
   244→			if abbr.IsOpenArray {
   245→				goType = "[]" + goType
   246→			}
   247→			g.builder.WriteString("var ")
   248→			g.write(fmt.Sprintf("%s %s = ", goIdent(abbr.Name), goType))
   249→			g.generateExpression(abbr.Value)
   250→			g.write("\n")
   251→		}
   252→	}
   253→	if len(abbrDecls) > 0 {
   254→		g.writeLine("")
   255→	}
   256→
   257→	// Generate procedure declarations (at package level)
   258→	for _, stmt := range procDecls {
   259→		g.generateStatement(stmt)
   260→	}
   261→
   262→	// Generate main function with other statements
   263→	if len(mainStatements) > 0 {
   264→		g.writeLine("func main() {")
   265→		g.indent++
   266→		g.nestingLevel++
   267→		for _, stmt := range mainStatements {
   268→			g.generateStatement(stmt)
   269→		}
   270→		g.nestingLevel--
   271→		g.indent--
   272→		g.writeLine("}")
   273→	} else if entryProc := g.findEntryProc(procDecls); entryProc != nil {
   274→		g.generateEntryHarness(entryProc)
   275→	}
   276→
   277→	return g.builder.String()
   278→}
   279→
   280→// collectNestedProcSigs recursively collects procedure/function signatures

The file /home/david/projects/code-associates/occam2go/codegen/codegen.go has been updated successfully.

The file /home/david/projects/code-associates/occam2go/codegen/codegen.go has been updated successfully.

The file /home/david/projects/code-associates/occam2go/codegen/codegen.go has been updated successfully.

   148→	g.writeLine("package main")
   149→	g.writeLine("")
   150→
   151→	// Write imports
   152→	if g.needSync || g.needFmt || g.needTime || g.needOs || g.needMath || g.needMathBits || g.needBufio {
   153→		g.writeLine("import (")
   154→		g.indent++
   155→		if g.needBufio {
   156→			g.writeLine(`"bufio"`)
   157→		}
   158→		if g.needFmt {
   159→			g.writeLine(`"fmt"`)
   160→		}
   161→		if g.needMath {
   162→			g.writeLine(`"math"`)
   163→		}
   164→		if g.needMathBits {
   165→			g.writeLine(`"math/bits"`)
   166→		}
   167→		if g.needOs {
   168→			g.writeLine(`"os"`)
   169→		}
   170→		if g.needSync {
   171→			g.writeLine(`"sync"`)
   172→		}
   173→		if g.needTime {
   174→			g.writeLine(`"time"`)
   175→		}
   176→		g.indent--
   177→		g.writeLine(")")
   178→		g.writeLine("")
   179→	}
   180→
   181→	// Emit transputer intrinsic helper functions
   182→	if g.needMathBits {
   183→		g.emitIntrinsicHelpers()
   184→	}
   185→
   186→	// Separate protocol, record, procedure declarations from other statements
   187→	var typeDecls []ast.Statement
   188→	var procDecls []ast.Statement
   189→	var mainStatements []ast.Statement
   190→
   191→	// First pass: check if there are any proc/func declarations
   192→	hasProcDecls := false
   193→	for _, stmt := range program.Statements {
   194→		if _, ok := stmt.(*ast.ProcDecl); ok {
   195→			hasProcDecls = true
   196→			break
   197→		}
   198→		if _, ok := stmt.(*ast.FuncDecl); ok {
   199→			hasProcDecls = true
   200→			break
   201→		}
   202→	}
   203→
   204→	var abbrDecls []ast.Statement
   205→	for _, stmt := range program.Statements {
   206→		switch s := stmt.(type) {
   207→		case *ast.ProtocolDecl, *ast.RecordDecl:
   208→			typeDecls = append(typeDecls, stmt)
   209→		case *ast.ProcDecl, *ast.FuncDecl:
   210→			procDecls = append(procDecls, stmt)
   211→		case *ast.Abbreviation:
   212→			if hasProcDecls {
   213→				// Top-level abbreviations need to be at package level
   214→				// so PROCs can reference them
   215→				abbrDecls = append(abbrDecls, stmt)
   216→			} else {
   217→				mainStatements = append(mainStatements, stmt)
   218→			}
   219→		case *ast.RetypesDecl:
   220→			_ = s
   221→			// RETYPES declarations are local to functions, not package-level
   222→			mainStatements = append(mainStatements, stmt)
   223→		default:
   224→			mainStatements = append(mainStatements, stmt)
   225→		}
   226→	}
   227→
   228→	// Detect entry point PROC early so we can set import flags before writing imports
   229→	var entryProc *ast.ProcDecl
   230→	if len(mainStatements) == 0 {
   231→		entryProc = g.findEntryProc(procDecls)
   232→		if entryProc != nil {
   233→			g.needOs = true
   234→			g.needSync = true
   235→			g.needBufio = true
   236→		}
   237→	}
   238→
   239→	// Generate type definitions first (at package level)
   240→	for _, stmt := range typeDecls {
   241→		g.generateStatement(stmt)
   242→	}
   243→
   244→	// Generate package-level abbreviations (constants)
   245→	for _, stmt := range abbrDecls {
   246→		abbr := stmt.(*ast.Abbreviation)
   247→		if abbr.Type == "" {

The file /home/david/projects/code-associates/occam2go/codegen/codegen.go has been updated successfully.

Hello World^M

00000000: 4865 6c6c 6f20 576f 726c 640d 0a         Hello World..

Updated task #2 status

Updated task #3 status

10:func TestVarDecl(t *testing.T) {
36:func TestMultipleVarDecl(t *testing.T) {
64:func TestAssignment(t *testing.T) {
95:func TestBinaryExpression(t *testing.T) {
133:func TestSeqBlock(t *testing.T) {
167:func TestParBlock(t *testing.T) {
191:func TestChanDecl(t *testing.T) {
217:func TestSend(t *testing.T) {
248:func TestReceive(t *testing.T) {
274:func TestAltBlock(t *testing.T) {
316:func TestAltBlockWithGuard(t *testing.T) {
352:func TestWhileLoop(t *testing.T) {
379:func TestIfStatement(t *testing.T) {
421:func TestReplicatedSeq(t *testing.T) {
464:func TestReplicatedSeqWithStep(t *testing.T) {
518:func TestReplicatedPar(t *testing.T) {
545:func TestReplicatedIf(t *testing.T) {
585:func TestArrayDecl(t *testing.T) {
619:func TestArrayDeclMultipleNames(t *testing.T) {
651:func TestIndexedAssignment(t *testing.T) {

[Showing results with pagination = limit: 20, offset: 0]

11:func TestSimpleVarDecl(t *testing.T) {
21:func TestMultipleVarDecl(t *testing.T) {
31:func TestReal32VarDecl(t *testing.T) {
41:func TestReal64VarDecl(t *testing.T) {
51:func TestAssignment(t *testing.T) {
61:func TestBinaryExpression(t *testing.T) {
71:func TestComparisonOperators(t *testing.T) {
88:func TestSeqBlock(t *testing.T) {
104:func TestParBlock(t *testing.T) {
126:func TestProcDecl(t *testing.T) {
137:func TestProcDeclWithRefParam(t *testing.T) {
149:func TestIfStatement(t *testing.T) {
166:func TestReplicatedIf(t *testing.T) {
184:func TestArrayDecl(t *testing.T) {
194:func TestIndexedAssignment(t *testing.T) {
222:func TestBitwiseOperators(t *testing.T) {
243:func TestStringLiteral(t *testing.T) {
253:func TestByteLiteral(t *testing.T) {
262:func TestByteLiteralEscape(t *testing.T) {
271:func TestStop(t *testing.T) {

[Showing results with pagination = limit: 20, offset: 0]

/home/david/projects/code-associates/occam2go/codegen/e2e_concurrency_test.go
/home/david/projects/code-associates/occam2go/codegen/e2e_preproc_test.go
/home/david/projects/code-associates/occam2go/codegen/e2e_helpers_test.go
/home/david/projects/code-associates/occam2go/codegen/e2e_protocol_test.go
/home/david/projects/code-associates/occam2go/codegen/e2e_record_test.go
/home/david/projects/code-associates/occam2go/codegen/e2e_proc_func_test.go
/home/david/projects/code-associates/occam2go/codegen/e2e_replicator_test.go
/home/david/projects/code-associates/occam2go/codegen/e2e_array_test.go
/home/david/projects/code-associates/occam2go/codegen/e2e_basic_test.go
/home/david/projects/code-associates/occam2go/codegen/e2e_types_test.go
/home/david/projects/code-associates/occam2go/codegen/e2e_control_test.go
/home/david/projects/code-associates/occam2go/codegen/e2e_phase2_test.go

     1→package codegen
     2→
     3→import (
     4→	"os"
     5→	"os/exec"
     6→	"path/filepath"
     7→	"testing"
     8→
     9→	"github.com/codeassociates/occam2go/lexer"
    10→	"github.com/codeassociates/occam2go/parser"
    11→	"github.com/codeassociates/occam2go/preproc"
    12→)
    13→
    14→// transpileCompileRun takes Occam source, transpiles to Go, compiles, runs,
    15→// and returns the stdout output
    16→func transpileCompileRun(t *testing.T, occamSource string) string {
    17→	t.Helper()
    18→
    19→	// Transpile
    20→	l := lexer.New(occamSource)
    21→	p := parser.New(l)
    22→	program := p.ParseProgram()
    23→
    24→	if len(p.Errors()) > 0 {
    25→		for _, err := range p.Errors() {
    26→			t.Errorf("parser error: %s", err)
    27→		}
    28→		t.FailNow()
    29→	}
    30→
    31→	gen := New()
    32→	goCode := gen.Generate(program)
    33→
    34→	// Create temp directory for this test
    35→	tmpDir, err := os.MkdirTemp("", "occam2go-test-*")
    36→	if err != nil {
    37→		t.Fatalf("failed to create temp dir: %v", err)
    38→	}
    39→	defer os.RemoveAll(tmpDir)
    40→
    41→	// Write Go source
    42→	goFile := filepath.Join(tmpDir, "main.go")
    43→	if err := os.WriteFile(goFile, []byte(goCode), 0644); err != nil {
    44→		t.Fatalf("failed to write Go file: %v", err)
    45→	}
    46→
    47→	// Compile
    48→	binFile := filepath.Join(tmpDir, "main")
    49→	compileCmd := exec.Command("go", "build", "-o", binFile, goFile)
    50→	compileOutput, err := compileCmd.CombinedOutput()
    51→	if err != nil {
    52→		t.Fatalf("compilation failed: %v\nOutput: %s\nGo code:\n%s", err, compileOutput, goCode)
    53→	}
    54→
    55→	// Run
    56→	runCmd := exec.Command(binFile)
    57→	output, err := runCmd.CombinedOutput()
    58→	if err != nil {
    59→		t.Fatalf("execution failed: %v\nOutput: %s", err, output)
    60→	}
    61→
    62→	return string(output)
    63→}
    64→
    65→// transpileCompileRunFromFile takes an occam file path, preprocesses it,
    66→// then transpiles, compiles, and runs.
    67→func transpileCompileRunFromFile(t *testing.T, mainFile string, includePaths []string) string {
    68→	t.Helper()
    69→
    70→	pp := preproc.New(preproc.WithIncludePaths(includePaths))
    71→	expanded, err := pp.ProcessFile(mainFile)
    72→	if err != nil {
    73→		t.Fatalf("preprocessor error: %v", err)
    74→	}
    75→	if len(pp.Errors()) > 0 {
    76→		for _, e := range pp.Errors() {
    77→			t.Errorf("preprocessor warning: %s", e)
    78→		}
    79→	}
    80→
    81→	return transpileCompileRun(t, expanded)
    82→}
    83→

     1→package codegen
     2→
     3→import (
     4→	"strings"
     5→	"testing"
     6→)
     7→
     8→func TestE2E_PrintInt(t *testing.T) {
     9→	occam := `SEQ
    10→  INT x:
    11→  x := 42
    12→  print.int(x)
    13→`
    14→	output := transpileCompileRun(t, occam)
    15→	expected := "42\n"
    16→	if output != expected {
    17→		t.Errorf("expected %q, got %q", expected, output)
    18→	}
    19→}
    20→
    21→func TestE2E_Addition(t *testing.T) {
    22→	occam := `SEQ
    23→  INT x, y:
    24→  x := 10
    25→  y := 20
    26→  print.int(x + y)
    27→`
    28→	output := transpileCompileRun(t, occam)
    29→	expected := "30\n"
    30→	if output != expected {
    31→		t.Errorf("expected %q, got %q", expected, output)
    32→	}
    33→}
    34→
    35→func TestE2E_Multiplication(t *testing.T) {
    36→	occam := `SEQ
    37→  INT a, b, c:
    38→  a := 3
    39→  b := 4
    40→  c := a * b
    41→  print.int(c)
    42→`
    43→	output := transpileCompileRun(t, occam)
    44→	expected := "12\n"
    45→	if output != expected {
    46→		t.Errorf("expected %q, got %q", expected, output)
    47→	}
    48→}
    49→
    50→func TestE2E_Expression(t *testing.T) {
    51→	occam := `SEQ
    52→  INT result:
    53→  result := (2 + 3) * 4
    54→  print.int(result)
    55→`
    56→	output := transpileCompileRun(t, occam)
    57→	expected := "20\n"
    58→	if output != expected {
    59→		t.Errorf("expected %q, got %q", expected, output)
    60→	}

   243→func TestStringLiteral(t *testing.T) {
   244→	input := `x := "hello world"
   245→`
   246→	output := transpile(t, input)
   247→
   248→	if !strings.Contains(output, `x = "hello world"`) {
   249→		t.Errorf("expected 'x = \"hello world\"' in output, got:\n%s", output)
   250→	}
   251→}
   252→
   253→func TestByteLiteral(t *testing.T) {
   254→	input := "x := 'A'\n"
   255→	output := transpile(t, input)
   256→
   257→	if !strings.Contains(output, "x = byte(65)") {
   258→		t.Errorf("expected 'x = byte(65)' in output, got:\n%s", output)
   259→	}
   260→}
   261→
   262→func TestByteLiteralEscape(t *testing.T) {
   263→	input := "x := '*n'\n"
   264→	output := transpile(t, input)
   265→
   266→	if !strings.Contains(output, "x = byte(10)") {
   267→		t.Errorf("expected 'x = byte(10)' in output, got:\n%s", output)
   268→	}
   269→}
   270→
   271→func TestStop(t *testing.T) {
   272→	input := "STOP\n"
   273→	output := transpile(t, input)
   274→
   275→	if !strings.Contains(output, `fmt.Fprintln(os.Stderr, "STOP encountered")`) {
   276→		t.Errorf("expected fmt.Fprintln(os.Stderr, ...) in output, got:\n%s", output)
   277→	}
   278→	if !strings.Contains(output, "select {}") {
   279→		t.Errorf("expected 'select {}' in output, got:\n%s", output)
   280→	}
   281→	if !strings.Contains(output, `"os"`) {
   282→		t.Errorf("expected os import in output, got:\n%s", output)

204:func transpile(t *testing.T, input string) string {
205-	t.Helper()
206-
207-	l := lexer.New(input)
208-	p := parser.New(l)
209-	program := p.ParseProgram()
210-
211-	if len(p.Errors()) > 0 {
212-		for _, err := range p.Errors() {
213-			t.Errorf("parser error: %s", err)
214-		}
215-		t.FailNow()
216-	}
217-
218-	gen := New()
219-	return gen.Generate(program)

     1→package codegen
     2→
     3→import (
     4→	"os"
     5→	"path/filepath"
     6→	"testing"
     7→)
     8→
     9→func TestE2E_IncludeConstants(t *testing.T) {
    10→	// Test #INCLUDE of a constants file and using the constant in a program
    11→	tmpDir := t.TempDir()
    12→
    13→	// Create a constants file with a function
    14→	constsContent := "INT FUNCTION magic(VAL INT n)\n  IS n * 2\n"
    15→	os.WriteFile(filepath.Join(tmpDir, "consts.inc"), []byte(constsContent), 0644)
    16→
    17→	// Create main file that includes the constants
    18→	mainContent := `#INCLUDE "consts.inc"
    19→SEQ
    20→  print.int(magic(21))
    21→`
    22→	mainFile := filepath.Join(tmpDir, "main.occ")
    23→	os.WriteFile(mainFile, []byte(mainContent), 0644)
    24→
    25→	output := transpileCompileRunFromFile(t, mainFile, nil)
    26→	expected := "42\n"
    27→	if output != expected {
    28→		t.Errorf("expected %q, got %q", expected, output)
    29→	}
    30→}
    31→
    32→func TestE2E_IfFalseExcludes(t *testing.T) {
    33→	// Test that #IF FALSE excludes code from compilation
    34→	tmpDir := t.TempDir()
    35→
    36→	mainContent := `SEQ
    37→  print.int(1)
    38→#IF FALSE
    39→  THIS IS INVALID OCCAM AND SHOULD NOT BE PARSED
    40→#ENDIF

     1→package codegen
     2→
     3→import (
     4→	"os"
     5→	"os/exec"
     6→	"path/filepath"
     7→	"testing"
     8→
     9→	"github.com/codeassociates/occam2go/lexer"
    10→	"github.com/codeassociates/occam2go/parser"
    11→)
    12→
    13→func TestE2E_UntypedValAbbreviation(t *testing.T) {
    14→	occam := `SEQ
    15→  VAL x IS 42 :
    16→  print.int(x)
    17→`
    18→	output := transpileCompileRun(t, occam)
    19→	expected := "42\n"
    20→	if output != expected {
    21→		t.Errorf("expected %q, got %q", expected, output)
    22→	}
    23→}
    24→
    25→func TestE2E_ArrayLiteralIndexing(t *testing.T) {
    26→	occam := `SEQ
    27→  VAL arr IS [10, 20, 30] :
    28→  print.int(arr[1])
    29→`
    30→	output := transpileCompileRun(t, occam)
    31→	expected := "20\n"
    32→	if output != expected {
    33→		t.Errorf("expected %q, got %q", expected, output)
    34→	}
    35→}
    36→
    37→func TestE2E_MultiLineBooleanIF(t *testing.T) {
    38→	occam := `SEQ
    39→  INT x:
    40→  x := 1
    41→  IF
    42→    (x > 0) AND
    43→      (x < 10)
    44→      print.int(x)
    45→    TRUE
    46→      print.int(0)
    47→`
    48→	output := transpileCompileRun(t, occam)
    49→	expected := "1\n"
    50→	if output != expected {
    51→		t.Errorf("expected %q, got %q", expected, output)
    52→	}
    53→}
    54→
    55→func TestE2E_CAUSEERROR(t *testing.T) {
    56→	occamSource := `PROC main()
    57→  CAUSEERROR()
    58→:
    59→`
    60→	// Transpile
    61→	l := lexer.New(occamSource)
    62→	p := parser.New(l)
    63→	program := p.ParseProgram()
    64→
    65→	if len(p.Errors()) > 0 {
    66→		for _, err := range p.Errors() {
    67→			t.Errorf("parser error: %s", err)
    68→		}
    69→		t.FailNow()
    70→	}
    71→
    72→	gen := New()
    73→	goCode := gen.Generate(program)
    74→
    75→	// Create temp directory
    76→	tmpDir, err := os.MkdirTemp("", "occam2go-test-*")
    77→	if err != nil {
    78→		t.Fatalf("failed to create temp dir: %v", err)
    79→	}
    80→	defer os.RemoveAll(tmpDir)
    81→
    82→	// Write Go source
    83→	goFile := filepath.Join(tmpDir, "main.go")
    84→	if err := os.WriteFile(goFile, []byte(goCode), 0644); err != nil {
    85→		t.Fatalf("failed to write Go file: %v", err)
    86→	}
    87→
    88→	// Compile
    89→	binFile := filepath.Join(tmpDir, "main")
    90→	compileCmd := exec.Command("go", "build", "-o", binFile, goFile)
    91→	compileOutput, err := compileCmd.CombinedOutput()
    92→	if err != nil {
    93→		t.Fatalf("compilation failed: %v\nOutput: %s\nGo code:\n%s", err, compileOutput, goCode)
    94→	}
    95→
    96→	// Run — expect non-zero exit code (panic)
    97→	runCmd := exec.Command(binFile)
    98→	err = runCmd.Run()
    99→	if err == nil {
   100→		t.Fatalf("expected CAUSEERROR to cause a non-zero exit, but program exited successfully")
   101→	}
   102→}
   103→

1313:func TestStringLiteral(t *testing.T) {
1314-	input := `x := "hello world"
1315-`
1316-	l := lexer.New(input)
1317-	p := New(l)
1318-	program := p.ParseProgram()
1319-	checkParserErrors(t, p)
1320-
1321-	if len(program.Statements) != 1 {
1322-		t.Fatalf("expected 1 statement, got %d", len(program.Statements))
1323-	}
1324-
1325-	assign, ok := program.Statements[0].(*ast.Assignment)
1326-	if !ok {
1327-		t.Fatalf("expected Assignment, got %T", program.Statements[0])
1328-	}
1329-
1330-	if assign.Name != "x" {
1331-		t.Errorf("expected Name=x, got %s", assign.Name)
1332-	}
1333-
1334-	strLit, ok := assign.Value.(*ast.StringLiteral)
1335-	if !ok {
1336-		t.Fatalf("expected StringLiteral, got %T", assign.Value)
1337-	}
1338-
1339-	if strLit.Value != "hello world" {
1340-		t.Errorf("expected Value='hello world', got '%s'", strLit.Value)
1341-	}
1342-}
1343-
1344:func TestByteLiteral(t *testing.T) {
1345-	tests := []struct {
1346-		input    string
1347-		expected byte
1348-	}{
1349-		{"x := 'A'\n", 'A'},
1350-		{"x := '0'\n", '0'},
1351-		{"x := ' '\n", ' '},
1352-		{"x := '*n'\n", '\n'},
1353-		{"x := '*c'\n", '\r'},
1354-		{"x := '*t'\n", '\t'},
1355-		{"x := '*s'\n", ' '},
1356-		{"x := '**'\n", '*'},
1357-		{"x := '*''\n", '\''},
1358-		{"x := '*\"'\n", '"'},
1359-	}
1360-
1361-	for _, tt := range tests {
1362-		l := lexer.New(tt.input)
1363-		p := New(l)
1364-		program := p.ParseProgram()
1365-		checkParserErrors(t, p)
1366-
1367-		if len(program.Statements) != 1 {
1368-			t.Fatalf("input %q: expected 1 statement, got %d", tt.input, len(program.Statements))
1369-		}
1370-
1371-		assign, ok := program.Statements[0].(*ast.Assignment)
1372-		if !ok {
1373-			t.Fatalf("input %q: expected Assignment, got %T", tt.input, program.Statements[0])
1374-		}
--
1387:func TestStringLiteralInProcCall(t *testing.T) {
1388-	input := `print.string("hello")
1389-`
1390-	l := lexer.New(input)
1391-	p := New(l)
1392-	program := p.ParseProgram()
1393-	checkParserErrors(t, p)
1394-
1395-	if len(program.Statements) != 1 {
1396-		t.Fatalf("expected 1 statement, got %d", len(program.Statements))
1397-	}
1398-
1399-	call, ok := program.Statements[0].(*ast.ProcCall)
1400-	if !ok {
1401-		t.Fatalf("expected ProcCall, got %T", program.Statements[0])
1402-	}
1403-
1404-	if len(call.Args) != 1 {
1405-		t.Fatalf("expected 1 arg, got %d", len(call.Args))
1406-	}
1407-
1408-	strLit, ok := call.Args[0].(*ast.StringLiteral)
1409-	if !ok {
1410-		t.Fatalf("expected StringLiteral arg, got %T", call.Args[0])
1411-	}
1412-
1413-	if strLit.Value != "hello" {
1414-		t.Errorf("expected Value='hello', got '%s'", strLit.Value)
1415-	}
1416-}
1417-

    64→
    65→// transpileCompileRunFromFile takes an occam file path, preprocesses it,
    66→// then transpiles, compiles, and runs.
    67→func transpileCompileRunFromFile(t *testing.T, mainFile string, includePaths []string) string {
    68→	t.Helper()
    69→
    70→	pp := preproc.New(preproc.WithIncludePaths(includePaths))
    71→	expanded, err := pp.ProcessFile(mainFile)
    72→	if err != nil {
    73→		t.Fatalf("preprocessor error: %v", err)
    74→	}
    75→	if len(pp.Errors()) > 0 {
    76→		for _, e := range pp.Errors() {
    77→			t.Errorf("preprocessor warning: %s", e)
    78→		}
    79→	}
    80→
    81→	return transpileCompileRun(t, expanded)
    82→}
    83→

17:// WithIncludePaths sets the search paths for #INCLUDE resolution.
18:func WithIncludePaths(paths []string) Option {
19-	return func(pp *Preprocessor) {
20-		pp.includePaths = paths
21-	}
22-}
23-
24:// WithDefines sets predefined symbols.
25:func WithDefines(defs map[string]string) Option {
26-	return func(pp *Preprocessor) {
27-		for k, v := range defs {
28-			pp.defines[k] = v
29-		}
30-	}
31-}
32-
33-// Preprocessor performs textual preprocessing of occam source.
--
43:func New(opts ...Option) *Preprocessor {
44-	pp := &Preprocessor{
45-		defines:    map[string]string{},
46-		processing: map[string]bool{},
47-		included:   map[string]bool{},
48-	}
49-	// Predefined symbols
50-	pp.defines["TARGET.BITS.PER.WORD"] = "64"
51-

  1339→	if strLit.Value != "hello world" {
  1340→		t.Errorf("expected Value='hello world', got '%s'", strLit.Value)
  1341→	}
  1342→}
  1343→

The file /home/david/projects/code-associates/occam2go/parser/parser_test.go has been updated successfully.

   243→func TestStringLiteral(t *testing.T) {
   244→	input := `x := "hello world"
   245→`
   246→	output := transpile(t, input)
   247→
   248→	if !strings.Contains(output, `x = "hello world"`) {
   249→		t.Errorf("expected 'x = \"hello world\"' in output, got:\n%s", output)
   250→	}
   251→}
   252→
   253→func TestByteLiteral(t *testing.T) {
   254→	input := "x := 'A'\n"

The file /home/david/projects/code-associates/occam2go/codegen/codegen_test.go has been updated successfully.

File created successfully at: /home/david/projects/code-associates/occam2go/codegen/e2e_course_test.go

217:		tok.Type = STRING
304:func (l *Lexer) readString() string {

[Showing results with pagination = limit: 5, offset: 0]

   304→func (l *Lexer) readString() string {
   305→	position := l.position + 1
   306→	for {
   307→		l.readChar()
   308→		if l.ch == '"' || l.ch == 0 {
   309→			break
   310→		}
   311→	}
   312→	return l.input[position:l.position]
   313→}
   314→
   315→func (l *Lexer) readByteLiteral() string {
   316→	// Current char is the opening single quote.
   317→	// Read content between single quotes, handling *' escape.
   318→	// In occam, * is the escape character. ** means literal *, *' means literal '.
   319→	position := l.position + 1
   320→	escaped := false
   321→	for {
   322→		l.readChar()
   323→		if l.ch == 0 {

The file /home/david/projects/code-associates/occam2go/parser/parser_test.go has been updated successfully.

=== RUN   TestStringEscapeConversion
--- PASS: TestStringEscapeConversion (0.00s)
PASS
ok  	github.com/codeassociates/occam2go/parser	0.001s

=== RUN   TestStringEscapeCodegen
--- PASS: TestStringEscapeCodegen (0.00s)
PASS
ok  	github.com/codeassociates/occam2go/codegen	0.001s

=== RUN   TestE2E_HelloWorldCourseModule
--- PASS: TestE2E_HelloWorldCourseModule (0.15s)
PASS
ok  	github.com/codeassociates/occam2go/codegen	0.147s

?   	github.com/codeassociates/occam2go	[no test files]
?   	github.com/codeassociates/occam2go/ast	[no test files]
ok  	github.com/codeassociates/occam2go/codegen	11.061s
ok  	github.com/codeassociates/occam2go/lexer	(cached)
ok  	github.com/codeassociates/occam2go/modgen	(cached)
ok  	github.com/codeassociates/occam2go/parser	0.002s
ok  	github.com/codeassociates/occam2go/preproc	(cached)

Updated task #3 status

No files found

No files found

/home/david/projects/code-associates/occam2go/scripts/clone-kroc.sh
/home/david/projects/code-associates/occam2go/kroc/distribution/windows/build_kroc.sh
/home/david/projects/code-associates/occam2go/kroc/distribution/osx/build_kroc.sh
/home/david/projects/code-associates/occam2go/kroc/tools/kroc/kroc-setup.csh.in
/home/david/projects/code-associates/occam2go/kroc/tools/kroc/kroc-setup.sh.in

     1→#!/bin/bash
     2→# Clone the KRoC (Kent Retargetable occam Compiler) repository.
     3→# This provides the occam "course" standard library source code
     4→# needed for transpiling programs that use it.
     5→
     6→set -e
     7→
     8→REPO_URL="https://github.com/concurrency/kroc.git"
     9→SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
    10→PROJECT_DIR="$(dirname "$SCRIPT_DIR")"
    11→TARGET_DIR="$PROJECT_DIR/kroc"
    12→
    13→if [ -d "$TARGET_DIR" ]; then
    14→    echo "kroc/ already exists. To re-clone, remove it first:"
    15→    echo "  rm -rf $TARGET_DIR"
    16→    exit 1
    17→fi
    18→
    19→echo "Cloning KRoC repository into kroc/..."
    20→git clone "$REPO_URL" "$TARGET_DIR"
    21→
    22→# The KRoC repo contains .go files (in tests/ccsp-comparisons/go/) that fail
    23→# to compile. Adding a go.mod creates a module boundary so that "go build ./..."
    24→# and "go test ./..." from the project root skip the kroc/ directory entirely.
    25→cat > "$TARGET_DIR/go.mod" <<'EOF'
    26→module kroc-vendored
    27→
    28→go 1.25.6
    29→EOF
    30→
    31→echo "Done."
    32→

     1→# Preamble
     2→
     3→Greetings humans. This paragraph is the only part of this repo generated by a human. Everything else (code, PRs, CI) was created by LLMs (so far Claude Code Opus 4.5 and 4.6).
     4→My goal as the human in this endevour was to see if I could refute posts I saw after Anthropic publicised their project to have Claude write a C compiler. I noticed many comments to the effect
     5→"well that's eacy because there's many C compilers in the training data". I had the idea "well Occam is so old that there's basically nothing about it on the modern internet.
     6→I had also had a long standing curiosity about the connection between Occam and go(lang) that made be curious as to whether you could build an Occam to golang transpiler.
     7→This project is the result: scratching two itches -- can an LLM create a working compiler for a language that doesn't show up in its training data, and can one transpile Occam to Go.
     8→Without Claude I'd never have the time to scratch that second itch. And...over to Claude:
     9→
    10→# occam2go
    11→
    12→A transpiler from Occam to Go, written in Go.
    13→
    14→Occam was developed in the 1980s to support concurrent programming on the Transputer. Go, created decades later, shares similar CSP-influenced concurrency primitives. This transpiler bridges the two.
    15→
    16→## Building
    17→
    18→```bash
    19→go build -o occam2go
    20→```
    21→
    22→## Usage
    23→
    24→```bash
    25→./occam2go [options] <input.occ>
    26→./occam2go gen-module [-o output] [-name GUARD] <SConscript>
    27→```
    28→
    29→Options:
    30→- `-o <file>` - Write output to file (default: stdout)
    31→- `-I <path>` - Include search path for `#INCLUDE` resolution (repeatable)
    32→- `-D <SYMBOL>` - Predefined preprocessor symbol (repeatable, supports `SYMBOL=value`)
    33→- `-version` - Print version and exit
    34→
    35→## Running an Example
    36→
    37→Here's how to transpile, compile, and run an Occam program:
    38→
    39→```bash
    40→# 1. Build the transpiler (only needed once)
    41→go build -o occam2go
    42→
    43→# 2. Transpile an Occam file to Go
    44→./occam2go -o output.go examples/print.occ
    45→
    46→# 3. Compile the generated Go code
    47→go build -o output output.go
    48→
    49→# 4. Run the compiled program
    50→./output
    51→```
    52→
    53→Or as a one-liner to see the output immediately:
    54→
    55→```bash
    56→./occam2go -o output.go examples/print.occ && go run output.go
    57→```
    58→
    59→## Example
    60→
    61→Input (`example.occ`):
    62→```occam
    63→SEQ
    64→  INT x, y:
    65→  PAR
    66→    x := 1
    67→    y := 2
    68→  x := x + y
    69→```
    70→
    71→Output:
    72→```go
    73→package main
    74→
    75→import (
    76→	"sync"
    77→)
    78→
    79→func main() {
    80→	var x, y int
    81→	var wg sync.WaitGroup
    82→	wg.Add(2)
    83→	go func() {
    84→		defer wg.Done()
    85→		x = 1
    86→	}()
    87→	go func() {
    88→		defer wg.Done()
    89→		y = 2
    90→	}()
    91→	wg.Wait()
    92→	x = (x + y)
    93→}
    94→```
    95→
    96→## Implemented Features
    97→
    98→See [TODO.md](TODO.md) for the full implementation status and roadmap.
    99→
   100→| Occam | Go |
   101→|-------|-----|
   102→| `INT`, `BYTE`, `BOOL`, `REAL` | `int`, `byte`, `bool`, `float64` |
   103→| `SEQ` | Sequential code |
   104→| `PAR` | Goroutines with `sync.WaitGroup` |
   105→| `IF` | `if / else if` |
   106→| `WHILE` | `for` loop |
   107→| `STOP` | Print to stderr + `select {}` (deadlock) |
   108→| `PROC` with `VAL` params | Functions with value/pointer params |
   109→| `:=` assignment | `=` assignment |
   110→| Arithmetic: `+`, `-`, `*`, `/`, `\` | `+`, `-`, `*`, `/`, `%` |
   111→| Comparison: `=`, `<>`, `<`, `>`, `<=`, `>=` | `==`, `!=`, `<`, `>`, `<=`, `>=` |
   112→| Logic: `AND`, `OR`, `NOT` | `&&`, `\|\|`, `!` |
   113→| Bitwise: `/\`, `\/`, `><`, `~` | `&`, `\|`, `^`, `^` (AND, OR, XOR, NOT) |
   114→| Shifts: `<<`, `>>` | `<<`, `>>` |
   115→| Type conversions: `INT x`, `BYTE n` | `int(x)`, `byte(n)` |
   116→
   117→### Channels
   118→
   119→| Occam | Go |
   120→|-------|-----|
   121→| `CHAN OF INT c:` | `c := make(chan int)` |
   122→| `c ! x` (send) | `c <- x` |
   123→| `c ? y` (receive) | `y = <-c` |
   124→| `[5]CHAN OF INT cs:` | `cs := make([]chan int, 5)` + init loop |
   125→| `cs[i] ! x` (indexed send) | `cs[i] <- x` |
   126→| `cs[i] ? y` (indexed receive) | `y = <-cs[i]` |
   127→| `PROC f([]CHAN OF INT cs)` | `func f(cs []chan int)` |
   128→
   129→Example:
   130→```occam
   131→SEQ
   132→  CHAN OF INT c:
   133→  INT result:
   134→  PAR
   135→    c ! 42
   136→    c ? result
   137→  print.int(result)
   138→```
   139→
   140→Channel array example:
   141→```occam
   142→SEQ
   143→  [3]CHAN OF INT cs:
   144→  INT sum:
   145→  sum := 0
   146→  PAR
   147→    PAR i = 0 FOR 3
   148→      cs[i] ! (i + 1) * 10
   149→    SEQ i = 0 FOR 3
   150→      INT x:
   151→      cs[i] ? x
   152→      sum := sum + x
   153→  print.int(sum)
   154→```
   155→
   156→### Protocols
   157→
   158→Protocols define the type of data carried on a channel. Three forms are supported:
   159→
   160→| Occam | Go |
   161→|-------|-----|
   162→| `PROTOCOL SIG IS INT` | `type _proto_SIG = int` |
   163→| `PROTOCOL PAIR IS INT ; BYTE` | `type _proto_PAIR struct { _0 int; _1 byte }` |
   164→| `PROTOCOL MSG CASE tag; INT ...` | Interface + concrete structs per tag |
   165→| `c ! 42 ; 65` (sequential send) | `c <- _proto_PAIR{42, 65}` |
   166→| `c ? x ; y` (sequential recv) | `_tmp := <-c; x = _tmp._0; y = _tmp._1` |
   167→| `c ! tag ; val` (variant send) | `c <- _proto_MSG_tag{val}` |
   168→| `c ? CASE ...` (variant recv) | `switch _v := (<-c).(type) { ... }` |
   169→
   170→Sequential protocol example:
   171→```occam
   172→PROTOCOL PAIR IS INT ; INT
   173→
   174→SEQ
   175→  CHAN OF PAIR c:
   176→  INT x, y:
   177→  PAR
   178→    c ! 10 ; 20
   179→    c ? x ; y
   180→  print.int(x + y)
   181→```
   182→
   183→Variant protocol example:
   184→```occam
   185→PROTOCOL MSG
   186→  CASE
   187→    data; INT
   188→    quit
   189→
   190→SEQ
   191→  CHAN OF MSG c:
   192→  INT result:
   193→  PAR
   194→    c ! data ; 42
   195→    c ? CASE
   196→      data ; result
   197→        print.int(result)
   198→      quit
   199→        SKIP
   200→```
   201→
   202→### Records
   203→
   204→| Occam | Go |
   205→|-------|-----|
   206→| `RECORD POINT` with `INT x:` `INT y:` | `type POINT struct { x int; y int }` |
   207→| `POINT p:` | `var p POINT` |
   208→| `p[x] := 10` | `p.x = 10` |
   209→| `p[x]` (in expression) | `p.x` |
   210→| `PROC foo(POINT p)` (ref) | `func foo(p *POINT)` |
   211→| `PROC foo(VAL POINT p)` (val) | `func foo(p POINT)` |
   212→
   213→Example:
   214→```occam
   215→RECORD POINT
   216→  INT x:
   217→  INT y:
   218→
   219→SEQ
   220→  POINT p:
   221→  p[x] := 10
   222→  p[y] := 20
   223→  print.int(p[x] + p[y])
   224→```
   225→
   226→### Arrays
   227→
   228→| Occam | Go |
   229→|-------|-----|
   230→| `[5]INT arr:` | `arr := make([]int, 5)` |
   231→| `arr[i] := x` | `arr[i] = x` |
   232→| `x := arr[i]` | `x = arr[i]` |
   233→
   234→Example:
   235→```occam
   236→SEQ
   237→  [5]INT arr:
   238→  SEQ i = 0 FOR 5
   239→    arr[i] := (i + 1) * 10
   240→  INT sum:
   241→  sum := 0
   242→  SEQ i = 0 FOR 5
   243→    sum := sum + arr[i]
   244→  print.int(sum)
   245→```
   246→
   247→### ALT (Alternation)
   248→
   249→| Occam | Go |
   250→|-------|-----|
   251→| `ALT` | `select` |
   252→| `guard & c ? x` | Conditional channel with nil pattern |
   253→| `SEQ i = 0 FOR n` | `for i := 0; i < n; i++` |
   254→| `PAR i = 0 FOR n` | Parallel `for` loop with goroutines |
   255→
   256→Example:
   257→```occam
   258→ALT
   259→  c1 ? x
   260→    print.int(x)
   261→  c2 ? y
   262→    print.int(y)
   263→```
   264→
   265→Generates:
   266→```go
   267→select {
   268→case x = <-c1:
   269→    fmt.Println(x)
   270→case y = <-c2:
   271→    fmt.Println(y)
   272→}
   273→```
   274→
   275→ALT with guards (optional boolean conditions):
   276→```occam
   277→ALT
   278→  enabled & c1 ? x
   279→    process(x)
   280→  TRUE & c2 ? y
   281→    process(y)
   282→```
   283→
   284→### Replicators
   285→
   286→Replicators allow you to repeat a block of code a specified number of times.
   287→
   288→| Occam | Go |
   289→|-------|-----|
   290→| `SEQ i = 0 FOR n` | `for i := 0; i < n; i++` |
   291→| `PAR i = 0 FOR n` | Parallel for loop with goroutines |
   292→
   293→Example with replicated SEQ:
   294→```occam
   295→SEQ i = 1 FOR 5
   296→  print.int(i)
   297→```
   298→
   299→This prints 1, 2, 3, 4, 5.
   300→
   301→Example with replicated PAR (spawns n concurrent processes):
   302→```occam
   303→PAR i = 0 FOR 4
   304→  c ! i
   305→```
   306→
   307→### Built-in I/O Procedures
   308→
   309→| Occam | Go |
   310→|-------|-----|
   311→| `print.int(x)` | `fmt.Println(x)` |
   312→| `print.bool(x)` | `fmt.Println(x)` |
   313→| `print.string(x)` | `fmt.Println(x)` |
   314→| `print.newline()` | `fmt.Println()` |
   315→
   316→## Preprocessor and Modules
   317→
   318→Occam programs use `#INCLUDE` to import library modules. The transpiler includes a textual preprocessor that runs before lexing, handling conditional compilation and file inclusion.
   319→
   320→### Preprocessor Directives
   321→
   322→| Directive | Description |
   323→|-----------|-------------|
   324→| `#INCLUDE "file"` | Textually include a file (resolved relative to current file, then `-I` paths) |
   325→| `#DEFINE SYMBOL` | Define a preprocessor symbol |
   326→| `#IF expr` | Conditional compilation (`TRUE`, `FALSE`, `DEFINED (SYM)`, `NOT`, `(SYM = val)`) |
   327→| `#ELSE` | Alternative branch |
   328→| `#ENDIF` | End conditional block |
   329→| `#COMMENT`, `#PRAGMA`, `#USE` | Ignored (replaced with blank lines to preserve line numbers) |
   330→
   331→The predefined symbol `TARGET.BITS.PER.WORD` is set to `64` (Go always uses 64-bit integers).
   332→
   333→### Using Modules with `#INCLUDE`
   334→
   335→Create a module file with include guards to prevent double-inclusion:
   336→
   337→```occam
   338→-- mathlib.module
   339→#IF NOT (DEFINED (MATHLIB.MODULE))
   340→#DEFINE MATHLIB.MODULE
   341→
   342→INT FUNCTION abs(VAL INT x)
   343→  INT result:
   344→  VALOF
   345→    IF
   346→      x < 0
   347→        result := 0 - x
   348→      TRUE
   349→        result := x
   350→    RESULT result
   351→
   352→#ENDIF
   353→```
   354→
   355→Then include it in your program:
   356→
   357→```occam
   358→-- main.occ
   359→#INCLUDE "mathlib.module"
   360→
   361→SEQ
   362→  print.int(abs(0 - 42))
   363→```
   364→
   365→Transpile with `-I` to specify where to find the module:
   366→
   367→```bash
   368→./occam2go -I examples -o main.go examples/include_demo.occ
   369→go run main.go
   370→```
   371→
   372→Output:
   373→```
   374→42
   375→20
   376→10
   377→```
   378→
   379→A working example is provided in `examples/include_demo.occ` with `examples/mathlib.module`.
   380→
   381→### Generating Module Files from KRoC SConscript
   382→
   383→The KRoC project defines module composition in SConscript (Python) build files. The `gen-module` subcommand parses these to generate `.module` files:
   384→
   385→```bash
   386→# Clone the KRoC repository (one-time setup)
   387→./scripts/clone-kroc.sh
   388→
   389→# Generate a module file from SConscript
   390→./occam2go gen-module kroc/modules/course/libsrc/SConscript
   391→```
   392→
   393→This outputs:
   394→```
   395→#IF NOT (DEFINED (COURSE.MODULE))
   396→#DEFINE COURSE.MODULE
   397→#INCLUDE "consts.inc"
   398→#INCLUDE "utils.occ"
   399→#INCLUDE "string.occ"
   400→#INCLUDE "demo_cycles.occ"
   401→#INCLUDE "demo_nets.occ"
   402→#INCLUDE "file_in.occ"
   403→#INCLUDE "float_io.occ"
   404→#INCLUDE "random.occ"
   405→#ENDIF
   406→```
   407→
   408→> **Note:** The preprocessor and module infrastructure is in place, but the KRoC course module source files themselves use several occam features not yet supported by the transpiler (abbreviations like `VAL INT x IS 1:`, `CHAN BYTE` without `OF`, `VAL []BYTE` array slice params, `SIZE`, `:` PROC terminators). Full course module transpilation is a future goal. See [TODO.md](TODO.md) for the implementation roadmap.
   409→
   410→## How Channels are Mapped
   411→
   412→Both Occam and Go draw from Tony Hoare's Communicating Sequential Processes (CSP) model, making channel communication a natural fit for transpilation.
   413→
   414→### Conceptual Mapping
   415→
   416→In Occam, channels are the primary mechanism for communication between parallel processes. A channel is a synchronous, unbuffered, point-to-point connection. Go channels share these characteristics by default.
   417→
   418→| Concept | Occam | Go |
   419→|---------|-------|-----|
   420→| Declaration | `CHAN OF INT c:` | `c := make(chan int)` |
   421→| Send (blocks until receiver ready) | `c ! value` | `c <- value` |
   422→| Receive (blocks until sender ready) | `c ? variable` | `variable = <-c` |
   423→| Synchronisation | Implicit in `!` and `?` | Implicit in `<-` |
   424→
   425→### Synchronous Communication
   426→
   427→Both languages use synchronous (rendezvous) communication by default:
   428→
   429→```occam
   430→PAR
   431→  c ! 42      -- blocks until receiver is ready
   432→  c ? x       -- blocks until sender is ready
   433→```
   434→
   435→The sender and receiver must both be ready before the communication occurs. This is preserved in the generated Go code, where unbuffered channels have the same semantics.
   436→
   437→### Differences and Limitations
   438→
   439→1. **Channel direction**: Occam channels are inherently unidirectional. Go channels can be bidirectional but can be restricted using types (`chan<-` for send-only, `<-chan` for receive-only). The transpiler currently generates bidirectional Go channels.
   440→
   441→2. **Protocol types**: Simple, sequential, and variant protocols are supported. Nested protocols (protocols referencing other protocols) are not yet supported.
   442→
   443→3. **Channel arrays**: Channel arrays (`[n]CHAN OF TYPE`) are supported, including indexed send/receive, `[]CHAN OF TYPE` proc params, and ALT with indexed channels.
   444→
   445→4. **ALT construct**: Occam's `ALT` maps to Go's `select` statement. Basic ALT, guards, and timer timeouts are supported. Priority ALT (`PRI ALT`) and replicated ALT are not yet implemented.
   446→
   447→## How PAR is Mapped
   448→
   449→Occam's `PAR` construct runs processes truly in parallel. On the Transputer this was hardware-scheduled; in Go it maps to goroutines coordinated with a `sync.WaitGroup`.
   450→
   451→### Basic PAR
   452→
   453→Each branch of a `PAR` block becomes a goroutine. The transpiler inserts a `WaitGroup` to ensure all branches complete before execution continues:
   454→
   455→```occam
   456→PAR
   457→  c ! 42
   458→  c ? x
   459→```
   460→
   461→Generates:
   462→
   463→```go
   464→var wg sync.WaitGroup
   465→wg.Add(2)
   466→go func() {
   467→    defer wg.Done()
   468→    c <- 42
   469→}()
   470→go func() {
   471→    defer wg.Done()
   472→    x = <-c
   473→}()
   474→wg.Wait()
   475→```
   476→
   477→The `wg.Wait()` call blocks until all goroutines have finished, preserving Occam's semantics that execution only continues after all parallel branches complete.
   478→
   479→### Replicated PAR
   480→
   481→A replicated `PAR` spawns N concurrent processes using a loop. Each iteration captures the loop variable to avoid closure issues:
   482→
   483→```occam
   484→PAR i = 0 FOR 4
   485→  c ! i
   486→```
   487→
   488→Generates:
   489→
   490→```go
   491→var wg sync.WaitGroup
   492→wg.Add(int(4))
   493→for i := 0; i < 0 + 4; i++ {
   494→    i := i  // capture loop variable
   495→    go func() {
   496→        defer wg.Done()
   497→        c <- i
   498→    }()
   499→}
   500→wg.Wait()
   501→```
   502→
   503→### Differences and Limitations
   504→
   505→1. **Scheduling**: Occam on the Transputer had deterministic, priority-based scheduling. Go's goroutine scheduler is preemptive and non-deterministic. Programs that depend on execution order between `PAR` branches may behave differently.
   506→
   507→2. **Shared memory**: Occam enforces at compile time that parallel processes do not share variables (the "disjointness" rule). The transpiler does not enforce this, so generated Go code may contain data races if the original Occam would have been rejected by a full Occam compiler.
   508→
   509→3. **PLACED PAR**: Occam's `PLACED PAR` for assigning processes to specific Transputer links or processors is not supported.
   510→
   511→## How Timers are Mapped
   512→
   513→Occam's `TIMER` provides access to a hardware clock. The transpiler maps timer operations to Go's `time` package.
   514→
   515→### Timer Declaration
   516→
   517→Timer declarations are no-ops in the generated code since Go accesses time through the `time` package directly:
   518→
   519→```occam
   520→TIMER tim:
   521→```
   522→
   523→Generates:
   524→
   525→```go
   526→// TIMER tim
   527→```
   528→
   529→### Reading the Current Time
   530→
   531→A timer read stores the current time as an integer (microseconds since epoch):
   532→
   533→```occam
   534→TIMER tim:
   535→INT t:
   536→tim ? t
   537→```
   538→
   539→Generates:
   540→
   541→```go
   542→// TIMER tim
   543→var t int
   544→t = int(time.Now().UnixMicro())
   545→```
   546→
   547→### Timer Timeouts in ALT
   548→
   549→Timer cases in ALT allow a process to wait until a deadline. This maps to Go's `time.After` inside a `select`:
   550→
   551→```occam
   552→TIMER tim:
   553→INT t:
   554→tim ? t
   555→ALT
   556→  c ? x
   557→    process(x)
   558→  tim ? AFTER (t + 100000)
   559→    handle.timeout()
   560→```
   561→
   562→Generates:
   563→
   564→```go
   565→// TIMER tim
   566→var t int
   567→t = int(time.Now().UnixMicro())
   568→select {
   569→case x = <-c:
   570→    process(x)
   571→case <-time.After(time.Duration((t + 100000) - int(time.Now().UnixMicro())) * time.Microsecond):
   572→    handle_timeout()
   573→}
   574→```
   575→
   576→The deadline expression `(t + 100000)` represents an absolute time. The generated code computes the remaining duration by subtracting the current time.
   577→
   578→### AFTER as a Boolean Expression
   579→
   580→The `AFTER` operator compares two time values and evaluates to `true` if the left operand is later than the right. It maps to `>`:
   581→
   582→```occam
   583→IF
   584→  t2 AFTER t1
   585→    -- t2 is later
   586→```
   587→
   588→Generates:
   589→
   590→```go
   591→if (t2 > t1) {
   592→    // t2 is later
   593→}
   594→```
   595→
   596→### Differences and Limitations
   597→
   598→1. **Clock resolution**: Occam timers are hardware-dependent (often microsecond resolution on the Transputer). The transpiler uses `time.Now().UnixMicro()` for microsecond values, but actual resolution depends on the OS.
   599→
   600→2. **Guarded timer ALT**: `guard & tim ? AFTER deadline` (timer cases with boolean guards) is not yet supported.
   601→
   602→3. **Clock wraparound**: Occam's `AFTER` operator handles 32-bit clock wraparound correctly. The transpiler uses a simple `>` comparison, which does not handle wraparound.
   603→

/home/david/projects/code-associates/occam2go/examples/replicator.occ
/home/david/projects/code-associates/occam2go/examples/alt.occ
/home/david/projects/code-associates/occam2go/examples/while.occ
/home/david/projects/code-associates/occam2go/examples/array.occ
/home/david/projects/code-associates/occam2go/examples/if.occ
/home/david/projects/code-associates/occam2go/examples/procedure.occ
/home/david/projects/code-associates/occam2go/examples/print.occ
/home/david/projects/code-associates/occam2go/examples/include_demo.occ
/home/david/projects/code-associates/occam2go/examples/simple.occ
/home/david/projects/code-associates/occam2go/examples/parallel.occ
/home/david/projects/code-associates/occam2go/examples/channel.occ

     1→-- Print example
     2→SEQ
     3→  INT x, y:
     4→  x := 10
     5→  y := 20
     6→  print.int(x + y)
     7→

/home/david/projects/code-associates/occam2go/kroc/modules/course/examples/hello_seq_world.occ
/home/david/projects/code-associates/occam2go/kroc/modules/course/examples/hello_world.occ
/home/david/projects/code-associates/occam2go/kroc/modules/course/examples/demo.occ
/home/david/projects/code-associates/occam2go/kroc/modules/course/examples/hello_raw_world.occ
/home/david/projects/code-associates/occam2go/kroc/modules/course/examples/echoing.occ
/home/david/projects/code-associates/occam2go/kroc/modules/course/examples/double_echo.occ
/home/david/projects/code-associates/occam2go/kroc/modules/course/examples/sort_pump.occ
/home/david/projects/code-associates/occam2go/kroc/modules/course/examples/bar.occ
/home/david/projects/code-associates/occam2go/kroc/modules/course/examples/test_utils.occ
/home/david/projects/code-associates/occam2go/kroc/modules/course/examples/sort_inside.occ
/home/david/projects/code-associates/occam2go/kroc/modules/course/examples/test_bell.occ
/home/david/projects/code-associates/occam2go/kroc/modules/course/examples/commstime.occ
/home/david/projects/code-associates/occam2go/kroc/modules/course/examples/casting.occ
/home/david/projects/code-associates/occam2go/kroc/modules/course/examples/cast.occ
/home/david/projects/code-associates/occam2go/kroc/modules/course/examples/sort_inside_2.occ
/home/david/projects/code-associates/occam2go/kroc/modules/course/examples/sort_pump_2.occ

     1→PROC hello.world (CHAN BYTE keyboard?, screen!, error!)
     2→  --{{{
     3→  VAL []BYTE greeting IS "Hello World*c*n":
     4→  SEQ i = 0 FOR SIZE greeting
     5→    screen ! greeting[i]
     6→  --}}}
     7→:
     8→

     1→
     2→#INCLUDE "course.module"
     3→
     4→--{{{  PROC seq.delta (CHAN INT in?, out.0!, out.1!)
     5→PROC seq.delta (CHAN INT in?, out.0!, out.1!)
     6→  WHILE TRUE
     7→    INT n:
     8→    SEQ
     9→      in ? n
    10→      out.0 ! n
    11→      out.1 ! n
    12→:
    13→--}}}
    14→
    15→--{{{  PROC consume (VAL INT n.loops, CHAN INT in?, CHAN BYTE out!)
    16→PROC consume (VAL INT n.loops, CHAN INT in?, CHAN BYTE out!)
    17→  TIMER tim:
    18→  INT t0, t1:
    19→  INT value:
    20→  SEQ
    21→    --{{{  warm-up loop
    22→    VAL INT warm.up IS 16:
    23→    SEQ i = 0 FOR warm.up
    24→      in ? value
    25→    --}}}
    26→    WHILE TRUE
    27→      SEQ
    28→        tim ? t0
    29→        --{{{  bench-mark loop
    30→        SEQ i = 0 FOR n.loops
    31→          in ? value
    32→        --}}}
    33→        tim ? t1
    34→        --{{{  report
    35→        VAL INT microsecs IS t1 MINUS t0:
    36→        VAL INT64 nanosecs IS 1000 * (INT64 microsecs):
    37→        SEQ
    38→          out.string ("Last value received = ", 0, out!)
    39→          out.int (value, 0, out!)
    40→          out.string ("*c*n", 0, out!)
    41→          out.string ("Time = ", 0, out!)
    42→          out.int (microsecs, 0, out!)
    43→          out.string (" microsecs*c*n", 0, out!)
    44→          out.string ("Time per loop = ", 0, out!)
    45→          out.int (INT (nanosecs/(INT64 n.loops)), 0, out!)
    46→          out.string (" nanosecs*c*n", 0, out!)
    47→          out.string ("Context switch = ", 0, out!)
    48→          out.int (INT ((nanosecs/(INT64 n.loops))/4), 0, out!)
    49→          out.string (" nanosecs*c*n*n", 0, out!)
    50→        --}}}
    51→:
    52→--}}}
    53→
    54→--{{{  PROC comms.time (CHAN BYTE keyboard?, screen!, error!)
    55→PROC comms.time (CHAN BYTE keyboard?, screen!, error!)
    56→
    57→  BOOL use.seq.delta:
    58→
    59→  SEQ
    60→
    61→    --{{{  announce
    62→    SEQ
    63→      out.string ("*c*nCommstime in occam ...*c*n*n", 0, screen!)
    64→      out.string ("Using the SEQ-output version of the delta process*c*n", 0, screen!)
    65→      out.string ("yields a more accurate measure of context-switch time*c*n*n", 0, screen!)
    66→      out.string ("Using the PAR-output version carries an extra overhead*c*n", 0, screen!)
    67→      out.string ("of one process startup/shutdown per Commstime loop*c*n*n", 0, screen!)
    68→      out.string ("By comparing **loop** times between the SEQ and PAR versions,*c*n", 0, screen!)
    69→      out.string ("the process startup/shutdown overhead may be deduced*c*n*n", 0, screen!)
    70→    --}}}
    71→
    72→    ask.bool ("Sequential delta? ", use.seq.delta, keyboard?, screen!)
    73→    out.string ("*nCommstime starting ...*c*n*n", 0, screen!)
    74→
    75→    CHAN INT a, b, c, d:
    76→    PAR
    77→      prefix (0, b?, a!)
    78→      IF
    79→        use.seq.delta
    80→          seq.delta (a?, c!, d!)    -- the one defined above
    81→        TRUE
    82→          delta (a?, c!, d!)        -- the one that does a parallel output
    83→      succ (c?, b!)
    84→      consume (1000000, d?, screen!)
    85→
    86→:
    87→--}}}
    88→
    89→

kroc/modules/course/libsrc/demo_nets.occ:35:PROC numbers (CHAN INT out!)
kroc/modules/course/libsrc/demo_nets.occ:46:PROC integrate (CHAN INT in?, out!)
kroc/modules/course/libsrc/demo_nets.occ:57:PROC pairs (CHAN INT in?, out!)
kroc/modules/course/libsrc/demo_nets.occ:69:PROC squares (CHAN INT out!)
kroc/modules/course/libsrc/demo_nets.occ:80:PROC fibonacci (CHAN INT out!)
kroc/modules/course/libsrc/demo_nets.occ:92:PROC times (CHAN INT out!)
kroc/modules/course/libsrc/string.occ:34:PROC make.string ([]BYTE a,  VAL INT length)
kroc/modules/course/libsrc/string.occ:52:PROC copy.string (VAL []BYTE a, []BYTE b)
kroc/modules/course/libsrc/string.occ:275:PROC write.string (VAL []BYTE a,  VAL INT field,  CHAN BYTE out!)
kroc/modules/course/libsrc/stringbuf.occ:31:PROC buffer.set.string ([]BYTE buf, INT len, VAL []BYTE to.add)
kroc/modules/course/libsrc/stringbuf.occ:51:PROC buffer.set.int ([]BYTE buf, INT len, VAL INT n)
kroc/modules/course/libsrc/stringbuf.occ:115:PROC buffer.set.hex ([]BYTE buf, INT len, VAL INT n)
kroc/modules/course/libsrc/stringbuf.occ:159:PROC buffer.set.bin8 ([]BYTE buf, INT len, VAL BYTE n)
kroc/modules/course/libsrc/stringbuf.occ:185:PROC buffer.set.real32 ([]BYTE buf, INT len, VAL INT ip, dp, VAL REAL32 n)
kroc/modules/course/libsrc/stringbuf.occ:202:PROC buffer.set.real64 ([]BYTE buf, INT len, VAL INT ip, dp, VAL REAL64 n)
kroc/modules/course/libsrc/utils.doc:6:PROC out.repeat (VAL BYTE ch, VAL INT n, CHAN OF BYTE out)
kroc/modules/course/libsrc/utils.doc:12:PROC out.ch (VAL BYTE ch, VAL INT field, CHAN OF BYTE out)
kroc/modules/course/libsrc/utils.doc:21:PROC out.string (VAL []BYTE s, VAL INT field, CHAN OF BYTE out)
kroc/modules/course/libsrc/utils.doc:26:PROC out.byte (VAL BYTE b, VAL INT field, CHAN OF BYTE out)
kroc/modules/course/libsrc/utils.doc:35:PROC out.int (VAL INT n, VAL INT field, CHAN OF BYTE out)
kroc/modules/course/libsrc/utils.doc:41:PROC out.bool (VAL BOOL b, VAL INT field, CHAN OF BYTE out)
kroc/modules/course/libsrc/utils.doc:47:PROC out.yes.no (VAL BOOL b, VAL INT field, CHAN OF BYTE out)
kroc/modules/course/libsrc/utils.doc:53:PROC flush (CHAN OF BYTE out)
kroc/modules/course/libsrc/utils.doc:65:PROC in.skip (BYTE ch, CHAN OF BYTE in)
kroc/modules/course/libsrc/utils.doc:71:PROC in.digit (BYTE d, CHAN OF BYTE in, out)
kroc/modules/course/libsrc/utils.doc:78:PROC in.string ([]BYTE s, INT length, VAL INT max, CHAN OF BYTE in, out)
kroc/modules/course/libsrc/utils.doc:88:PROC in.bool (BOOL b, CHAN OF BYTE in, out)
kroc/modules/course/libsrc/utils.doc:96:PROC in.byte.chars ([]BYTE s, INT length, CHAN OF BYTE in, out)
kroc/modules/course/libsrc/utils.doc:114:PROC in.byte (BYTE b, VAL INT max, CHAN OF BYTE in, out)
kroc/modules/course/libsrc/utils.doc:123:PROC in.num.chars ([]BYTE s, INT length, VAL INT max, CHAN OF BYTE in, out)
kroc/modules/course/libsrc/utils.doc:149:PROC in.int (INT n, VAL INT max, CHAN OF BYTE in, out)
kroc/modules/course/libsrc/utils.doc:158:PROC black.hole (CHAN OF BYTE in)
kroc/modules/course/libsrc/utils.doc:171:PROC ask.string (VAL []BYTE prompt, []BYTE s, INT length,
kroc/modules/course/libsrc/utils.doc:180:PROC ask.bool (VAL []BYTE prompt, BOOL b, CHAN OF BYTE in, out)
kroc/modules/course/libsrc/utils.doc:189:PROC ask.byte (VAL []BYTE prompt, BYTE b, VAL INT max, CHAN OF BYTE in, out)
kroc/modules/course/libsrc/utils.doc:198:PROC ask.int (VAL []BYTE prompt, INT n, VAL INT max, CHAN OF BYTE in, out)
kroc/modules/course/libsrc/utils.doc:210:PROC cursor.x.y (VAL BYTE x, y, CHAN OF BYTE out)
kroc/modules/course/libsrc/utils.doc:216:PROC cursor.up (VAL BYTE n, CHAN OF BYTE out)
kroc/modules/course/libsrc/utils.doc:222:PROC cursor.down (VAL BYTE n, CHAN OF BYTE out)
kroc/modules/course/libsrc/utils.doc:228:PROC cursor.right (VAL BYTE n, CHAN OF BYTE out)
kroc/modules/course/libsrc/utils.doc:234:PROC cursor.left (VAL BYTE n, CHAN OF BYTE out)
kroc/modules/course/libsrc/utils.doc:240:PROC erase.eol (CHAN OF BYTE out)
kroc/modules/course/libsrc/utils.doc:246:PROC erase.bol (CHAN OF BYTE out)
kroc/modules/course/libsrc/utils.doc:252:PROC erase.line (CHAN OF BYTE out)
kroc/modules/course/libsrc/utils.doc:258:PROC erase.eos (CHAN OF BYTE out)
kroc/modules/course/libsrc/utils.doc:264:PROC erase.bos (CHAN OF BYTE out)
kroc/modules/course/libsrc/utils.doc:270:PROC erase.screen (CHAN OF BYTE out)
kroc/modules/course/libsrc/utils.doc:275:PROC cursor.visible (CHAN OF BYTE out)
kroc/modules/course/libsrc/utils.doc:280:PROC cursor.invisible (CHAN OF BYTE out)
kroc/modules/course/libsrc/utils.doc:285:PROC goto.x.y (VAL INT x, y, CHAN OF BYTE out)
kroc/modules/course/libsrc/utils.doc:292:PROC pos.int (VAL INT col, row, n, field, CHAN OF BYTE out)
kroc/modules/course/libsrc/utils.doc:298:PROC pos.yes.no (VAL INT col, row, VAL BOOL b,
kroc/modules/course/libsrc/file_in.occ:31:PROC file.in.string ([]BYTE s,  INT length,  VAL INT max,  CHAN BYTE in?)
kroc/modules/course/libsrc/file_in.occ:84:PROC file.in.token ([]BYTE t,  INT length,  VAL INT max,  CHAN BYTE in?)
kroc/modules/course/libsrc/file_in.occ:229:PROC file.in.int (INT n,  VAL INT max,  BOOL ok,  CHAN BYTE in?)
kroc/modules/course/libsrc/file_in.occ:257:PROC file.in.number (INT n, VAL INT max, BOOL ok, CHAN BYTE in?)
kroc/modules/course/libsrc/utils.occ:34:PROC out.repeat (VAL BYTE ch, VAL INT n, CHAN BYTE out!)
kroc/modules/course/libsrc/utils.occ:55:PROC out.ch (VAL BYTE ch, VAL INT field, CHAN BYTE out!)
kroc/modules/course/libsrc/utils.occ:69:PROC out.string (VAL []BYTE s, VAL INT field, CHAN BYTE out!)
kroc/modules/course/libsrc/utils.occ:89:PROC out.byte (VAL BYTE b, VAL INT field, CHAN BYTE out!)
kroc/modules/course/libsrc/utils.occ:121:PROC out.int (VAL INT n, VAL INT field, CHAN BYTE out!)
kroc/modules/course/libsrc/utils.occ:186:PROC out.hex (VAL INT n, VAL INT field, CHAN BYTE out!)
kroc/modules/course/libsrc/utils.occ:223:PROC out.bool (VAL BOOL b, VAL INT field, CHAN BYTE out!)
kroc/modules/course/libsrc/utils.occ:240:PROC out.yes.no (VAL BOOL b, VAL INT field, CHAN BYTE out!)
kroc/modules/course/libsrc/utils.occ:257:PROC flush (CHAN BYTE out!)
kroc/modules/course/libsrc/utils.occ:271:PROC in.skip (BYTE ch, CHAN BYTE in?)
kroc/modules/course/libsrc/utils.occ:288:PROC in.digit (BYTE d, CHAN BYTE in?, out!)
kroc/modules/course/libsrc/utils.occ:314:PROC in.string ([]BYTE s, INT length, VAL INT max, CHAN BYTE in?, out!)
kroc/modules/course/libsrc/utils.occ:388:PROC in.bool (BOOL b, CHAN BYTE in?, out!)
kroc/modules/course/libsrc/utils.occ:422:PROC in.byte.chars ([]BYTE s, INT length, CHAN BYTE in?, out!)
kroc/modules/course/libsrc/utils.occ:515:PROC in.byte (BYTE b, VAL INT max, CHAN BYTE in?, out!)
kroc/modules/course/libsrc/utils.occ:564:PROC in.num.chars ([]BYTE s, INT length, VAL INT max, CHAN BYTE in?, out!)
kroc/modules/course/libsrc/utils.occ:735:PROC in.int (INT n, VAL INT max, CHAN BYTE in?, out!)
kroc/modules/course/libsrc/utils.occ:783:PROC black.hole (CHAN BYTE in?)
kroc/modules/course/libsrc/utils.occ:802:PROC ask.string (VAL []BYTE prompt, []BYTE s, INT length,
kroc/modules/course/libsrc/utils.occ:822:PROC ask.bool (VAL []BYTE prompt, BOOL b, CHAN BYTE in?, out!)
kroc/modules/course/libsrc/utils.occ:842:PROC ask.byte (VAL []BYTE prompt, BYTE b, VAL INT max, CHAN BYTE in?, out!)
kroc/modules/course/libsrc/utils.occ:861:PROC ask.int (VAL []BYTE prompt, INT n, VAL INT max, CHAN BYTE in?, out!)
kroc/modules/course/libsrc/utils.occ:881:PROC cursor.x.y (VAL BYTE x, y, CHAN BYTE out!)
kroc/modules/course/libsrc/utils.occ:899:PROC cursor.up (VAL BYTE n, CHAN BYTE out!)
kroc/modules/course/libsrc/utils.occ:915:PROC cursor.down (VAL BYTE n, CHAN BYTE out!)
kroc/modules/course/libsrc/utils.occ:931:PROC cursor.right (VAL BYTE n, CHAN BYTE out!)
kroc/modules/course/libsrc/utils.occ:947:PROC cursor.left (VAL BYTE n, CHAN BYTE out!)
kroc/modules/course/libsrc/utils.occ:962:PROC erase.eol (CHAN BYTE out!)
kroc/modules/course/libsrc/utils.occ:977:PROC erase.bol (CHAN BYTE out!)
kroc/modules/course/libsrc/utils.occ:992:PROC erase.line (CHAN BYTE out!)
kroc/modules/course/libsrc/utils.occ:1007:PROC erase.eos (CHAN BYTE out!)
kroc/modules/course/libsrc/utils.occ:1022:PROC erase.bos (CHAN BYTE out!)
kroc/modules/course/libsrc/utils.occ:1037:PROC erase.screen (CHAN BYTE out!)
kroc/modules/course/libsrc/utils.occ:1051:PROC cursor.visible (CHAN BYTE out!)
kroc/modules/course/libsrc/utils.occ:1067:PROC cursor.invisible (CHAN BYTE out!)
kroc/modules/course/libsrc/utils.occ:1089:PROC pos.int (VAL INT col, row, n, field, CHAN BYTE out!)
kroc/modules/course/libsrc/utils.occ:1107:PROC pos.yes.no (VAL INT col, row, VAL BOOL b,
kroc/modules/course/libsrc/utils.occ:1122:PROC out.number (VAL INT n, w, CHAN BYTE o!)
kroc/modules/course/libsrc/utils.occ:1127:PROC goto.x.y (VAL INT x, y, CHAN BYTE o!)
kroc/modules/course/libsrc/demo_cycles.occ:33:PROC id (CHAN INT in?, out!)
kroc/modules/course/libsrc/demo_cycles.occ:44:PROC succ (CHAN INT in?, out!)
kroc/modules/course/libsrc/demo_cycles.occ:55:PROC plus (CHAN INT in.1?, in.2?, out!)
kroc/modules/course/libsrc/demo_cycles.occ:68:PROC delta (CHAN INT in?, out.1!, out.2!)
kroc/modules/course/libsrc/demo_cycles.occ:81:PROC prefix (VAL INT n, CHAN INT in?, out!)
kroc/modules/course/libsrc/demo_cycles.occ:90:PROC tail (CHAN INT in?, out!)
kroc/modules/course/libsrc/shared_screen.occ:39:PROC fg.col (VAL COLOUR c, CHAN BYTE out!)
kroc/modules/course/libsrc/shared_screen.occ:74:PROC screen.interpret (VAL []SCREEN.NODE node, CHAN BYTE out!)
kroc/modules/course/libsrc/shared_screen.occ:185:PROC screen.driver (CHAN SCREEN.CONTROL in?, CHAN BYTE out!)
kroc/modules/course/libsrc/float_io.occ:47:PROC course.REAL32TOSTRING (RESULT INT len, RESULT []BYTE string, VAL REAL32 X, VAL INT Ip, Dp)
kroc/modules/course/libsrc/float_io.occ:1015:PROC course.REAL64TOSTRING (RESULT INT len, RESULT []BYTE string, VAL REAL64 X, VAL INT Ip, Dp)
kroc/modules/course/libsrc/float_io.occ:2200:PROC course.HEXTOSTRING (INT len, []BYTE string, VAL INT n)
kroc/modules/course/libsrc/float_io.occ:2245:PROC out.real32 (VAL REAL32 num, VAL INT ip, dp, CHAN BYTE out!)
kroc/modules/course/libsrc/float_io.occ:2260:PROC out.real64 (VAL REAL64 num, VAL INT ip, dp, CHAN BYTE out!)

     1→#INCLUDE "course.module"
     2→
     3→PROC hello.world (CHAN BYTE keyboard?, screen!, error!)
     4→  --{{{
     5→  out.string ("Hello World*c*n", 0, screen!)
     6→  --}}}
     7→:
     8→

Hello World

File created successfully at: /home/david/projects/code-associates/occam2go/examples/course_hello.occ

Hello from occam2go!
The answer is: 42
------------------------------
Counting: 1, 2, 3, 4, 5

   380→
   381→### Generating Module Files from KRoC SConscript
   382→
   383→The KRoC project defines module composition in SConscript (Python) build files. The `gen-module` subcommand parses these to generate `.module` files:
   384→
   385→```bash
   386→# Clone the KRoC repository (one-time setup)
   387→./scripts/clone-kroc.sh
   388→
   389→# Generate a module file from SConscript
   390→./occam2go gen-module kroc/modules/course/libsrc/SConscript
   391→```
   392→
   393→This outputs:
   394→```
   395→#IF NOT (DEFINED (COURSE.MODULE))
   396→#DEFINE COURSE.MODULE
   397→#INCLUDE "consts.inc"
   398→#INCLUDE "utils.occ"
   399→#INCLUDE "string.occ"
   400→#INCLUDE "demo_cycles.occ"
   401→#INCLUDE "demo_nets.occ"
   402→#INCLUDE "file_in.occ"
   403→#INCLUDE "float_io.occ"
   404→#INCLUDE "random.occ"
   405→#ENDIF
   406→```
   407→
   408→> **Note:** The preprocessor and module infrastructure is in place, but the KRoC course module source files themselves use several occam features not yet supported by the transpiler (abbreviations like `VAL INT x IS 1:`, `CHAN BYTE` without `OF`, `VAL []BYTE` array slice params, `SIZE`, `:` PROC terminators). Full course module transpilation is a future goal. See [TODO.md](TODO.md) for the implementation roadmap.
   409→

The file /home/david/projects/code-associates/occam2go/README.md has been updated successfully.

?   	github.com/codeassociates/occam2go	[no test files]
?   	github.com/codeassociates/occam2go/ast	[no test files]
ok  	github.com/codeassociates/occam2go/codegen	(cached)
ok  	github.com/codeassociates/occam2go/lexer	(cached)
ok  	github.com/codeassociates/occam2go/modgen	(cached)
ok  	github.com/codeassociates/occam2go/parser	(cached)
ok  	github.com/codeassociates/occam2go/preproc	(cached)

Hello from occam2go!
The answer is: 42
------------------------------
Counting: 1, 2, 3, 4, 5

On branch main
Your branch is up to date with 'origin/main'.

Changes not staged for commit:
  (use "git add <file>..." to update what will be committed)
  (use "git restore <file>..." to discard changes in working directory)
	modified:   README.md
	modified:   codegen/codegen.go
	modified:   codegen/codegen_test.go
	modified:   parser/parser.go
	modified:   parser/parser_test.go

Untracked files:
  (use "git add <file>..." to include in what will be committed)
	codegen/e2e_course_test.go
	examples/course_hello.occ

no changes added to commit (use "git add" and/or "git commit -a")

diff --git a/README.md b/README.md
index 79f264d..a4da1de 100644
--- a/README.md
+++ b/README.md
@@ -405,7 +405,70 @@ This outputs:
 #ENDIF
 ```
 
-> **Note:** The preprocessor and module infrastructure is in place, but the KRoC course module source files themselves use several occam features not yet supported by the transpiler (abbreviations like `VAL INT x IS 1:`, `CHAN BYTE` without `OF`, `VAL []BYTE` array slice params, `SIZE`, `:` PROC terminators). Full course module transpilation is a future goal. See [TODO.md](TODO.md) for the implementation roadmap.
+### Running Programs with the Course Module
+
+The KRoC [course module](https://www.cs.kent.ac.uk/projects/ofa/kroc/) is a standard occam library providing I/O utilities (`out.string`, `out.int`, `out.repeat`, etc.) for character-level communication over byte channels. The transpiler fully supports it.
+
+Occam programs that follow the standard entry point pattern — a PROC with three `CHAN BYTE` parameters `(keyboard?, screen!, error!)` — automatically get a generated `main()` that wires stdin, stdout, and stderr to channels.
+
+```bash
+# 1. Clone the KRoC repository (one-time setup)
+./scripts/clone-kroc.sh
+
+# 2. Build the transpiler
+go build -o occam2go
+
+# 3. Transpile an example that uses the course module
+./occam2go -I kroc/modules/course/libsrc \
+           -D TARGET.BITS.PER.WORD=32     \
+           -o hello.go examples/course_hello.occ
+
+# 4. Run it
+go run hello.go
+```
+
+Output:
+```
+Hello from occam2go!
+The answer is: 42
+------------------------------
+Counting: 1, 2, 3, 4, 5
+```
+
+The `-I` flag tells the preprocessor where to find the course module source files, and `-D TARGET.BITS.PER.WORD=32` sets the word size expected by the course module (the transpiler defaults to 64).
+
+The example program (`examples/course_hello.occ`):
+```occam
+#INCLUDE "course.module"
+
+PROC hello (CHAN BYTE keyboard?, screen!, error!)
+  SEQ
+    out.string ("Hello from occam2go!*c*n", 0, screen!)
+    out.string ("The answer is: ", 0, screen!)
+    out.int (42, 0, screen!)
+    out.string ("*c*n", 0, screen!)
+    out.repeat ('-', 30, screen!)
+    out.string ("*c*n", 0, screen!)
+    out.string ("Counting: ", 0, screen!)
+    SEQ i = 1 FOR 5
+      SEQ
+        IF
+          i > 1
+            out.string (", ", 0, screen!)
+          TRUE
+            SKIP
+        out.int (i, 0, screen!)
+    out.string ("*c*n", 0, screen!)
+:
+```
+
+You can also transpile the KRoC examples directly:
+```bash
+./occam2go -I kroc/modules/course/libsrc \
+           -D TARGET.BITS.PER.WORD=32     \
+           -o hello_world.go kroc/modules/course/examples/hello_world.occ
+go run hello_world.go
+```
 
 ## How Channels are Mapped
 
diff --git a/codegen/codegen.go b/codegen/codegen.go
index e994e39..d9b2d69 100644
--- a/codegen/codegen.go
+++ b/codegen/codegen.go
@@ -17,6 +17,7 @@ type Generator struct {
 	needOs   bool // track if we need os package import
 	needMath bool // track if we need math package import
 	needMathBits bool // track if we need math/bits package import
+	needBufio    bool // track if we need bufio package import
 
 	// Track procedure signatures for proper pointer handling
 	procSigs map[string][]ast.ProcParam
@@ -93,6 +94,7 @@ func (g *Generator) Generate(program *ast.Program) string {
 	g.needOs = false
 	g.needMath = false
 	g.needMathBits = false
+	g.needBufio = false
 	g.procSigs = make(map[string][]ast.ProcParam)
 	g.refParams = make(map[string]bool)
 	g.protocolDefs = make(map[string]*ast.ProtocolDecl)
@@ -142,42 +144,6 @@ func (g *Generator) Generate(program *ast.Program) string {
 		g.collectRecordVars(stmt)
 	}
 
-	// Write package declaration
-	g.writeLine("package main")
-	g.writeLine("")
-
-	// Write imports
-	if g.needSync || g.needFmt || g.needTime || g.needOs || g.needMath || g.needMathBits {
-		g.writeLine("import (")
-		g.indent++
-		if g.needFmt {
-			g.writeLine(`"fmt"`)
-		}
-		if g.needMath {
-			g.writeLine(`"math"`)
-		}
-		if g.needMathBits {
-			g.writeLine(`"math/bits"`)
-		}
-		if g.needOs {
-			g.writeLine(`"os"`)
-		}
-		if g.needSync {
-			g.writeLine(`"sync"`)
-		}
-		if g.needTime {
-			g.writeLine(`"time"`)
-		}
-		g.indent--
-		g.writeLine(")")
-		g.writeLine("")
-	}
-
-	// Emit transputer intrinsic helper functions
-	if g.needMathBits {
-		g.emitIntrinsicHelpers()
-	}
-
 	// Separate protocol, record, procedure declarations from other statements
 	var typeDecls []ast.Statement
 	var procDecls []ast.Statement
@@ -220,6 +186,56 @@ func (g *Generator) Generate(program *ast.Program) string {
 		}
 	}
 
+	// Detect entry point PROC so we can set import flags before writing imports
+	var entryProc *ast.ProcDecl
+	if len(mainStatements) == 0 {
+		entryProc = g.findEntryProc(procDecls)
+		if entryProc != nil {
+			g.needOs = true
+			g.needSync = true
+			g.needBufio = true
+		}
+	}
+
+	// Write package declaration
+	g.writeLine("package main")
+	g.writeLine("")
+
+	// Write imports
+	if g.needSync || g.needFmt || g.needTime || g.needOs || g.needMath || g.needMathBits || g.needBufio {
+		g.writeLine("import (")
+		g.indent++
+		if g.needBufio {
+			g.writeLine(`"bufio"`)
+		}
+		if g.needFmt {
+			g.writeLine(`"fmt"`)
+		}
+		if g.needMath {
+			g.writeLine(`"math"`)
+		}
+		if g.needMathBits {
+			g.writeLine(`"math/bits"`)
+		}
+		if g.needOs {
+			g.writeLine(`"os"`)
+		}
+		if g.needSync {
+			g.writeLine(`"sync"`)
+		}
+		if g.needTime {
+			g.writeLine(`"time"`)
+		}
+		g.indent--
+		g.writeLine(")")
+		g.writeLine("")
+	}
+
+	// Emit transputer intrinsic helper functions
+	if g.needMathBits {
+		g.emitIntrinsicHelpers()
+	}
+
 	// Generate type definitions first (at package level)
 	for _, stmt := range typeDecls {
 		g.generateStatement(stmt)
@@ -265,6 +281,8 @@ func (g *Generator) Generate(program *ast.Program) string {
 		g.nestingLevel--
 		g.indent--
 		g.writeLine("}")
+	} else if entryProc != nil {
+		g.generateEntryHarness(entryProc)
 	}
 
 	return g.builder.String()
@@ -336,6 +354,125 @@ func (g *Generator) collectNestedProcSigsScoped(stmts []ast.Statement, oldSigs m
 	}
 }
 
+// findEntryProc looks for the last top-level PROC with the standard occam
+// entry point signature: exactly 3 CHAN OF BYTE params (keyboard?, screen!, error!).
+func (g *Generator) findEntryProc(procDecls []ast.Statement) *ast.ProcDecl {
+	var entry *ast.ProcDecl
+	for _, stmt := range procDecls {
+		proc, ok := stmt.(*ast.ProcDecl)
+		if !ok {
+			continue
+		}
+		if len(proc.Params) != 3 {
+			continue
+		}
+		p0, p1, p2 := proc.Params[0], proc.Params[1], proc.Params[2]
+		if p0.IsChan && p0.ChanElemType == "BYTE" && p0.ChanDir == "?" &&
+			p1.IsChan && p1.ChanElemType == "BYTE" && p1.ChanDir == "!" &&
+			p2.IsChan && p2.ChanElemType == "BYTE" && p2.ChanDir == "!" {
+			entry = proc
+		}
+	}
+	return entry
+}
+
+// generateEntryHarness emits a func main() that wires stdin/stdout/stderr
+// to channels and calls the entry PROC.
+func (g *Generator) generateEntryHarness(proc *ast.ProcDecl) {
+	name := goIdent(proc.Name)
+	g.writeLine("func main() {")
+	g.indent++
+
+	// Create channels
+	g.writeLine("keyboard := make(chan byte, 256)")
+	g.writeLine("screen := make(chan byte, 256)")
+	g.writeLine("_error := make(chan byte, 256)")
+	g.writeLine("")
+
+	// WaitGroup for writer goroutines to finish draining
+	g.writeLine("var wg sync.WaitGroup")
+	g.writeLine("wg.Add(2)")
+	g.writeLine("")
+
+	// Screen writer goroutine
+	g.writeLine("go func() {")
+	g.indent++
+	g.writeLine("defer wg.Done()")
+	g.writeLine("w := bufio.NewWriter(os.Stdout)")
+	g.writeLine("for b := range screen {")
+	g.indent++
+	g.writeLine("if b == 255 {")
+	g.indent++
+	g.writeLine("w.Flush()")
+	g.indent--
+	g.writeLine("} else {")
+	g.indent++
+	g.writeLine("w.WriteByte(b)")
+	g.indent--
+	g.writeLine("}")
+	g.indent--
+	g.writeLine("}")
+	g.writeLine("w.Flush()")
+	g.indent--
+	g.writeLine("}()")
+	g.writeLine("")
+
+	// Error writer goroutine
+	g.writeLine("go func() {")
+	g.indent++
+	g.writeLine("defer wg.Done()")
+	g.writeLine("w := bufio.NewWriter(os.Stderr)")
+	g.writeLine("for b := range _error {")
+	g.indent++
+	g.writeLine("if b == 255 {")
+	g.indent++
+	g.writeLine("w.Flush()")
+	g.indent--
+	g.writeLine("} else {")
+	g.indent++
+	g.writeLine("w.WriteByte(b)")
+	g.indent--
+	g.writeLine("}")
+	g.indent--
+	g.writeLine("}")
+	g.writeLine("w.Flush()")
+	g.indent--
+	g.writeLine("}()")
+	g.writeLine("")
+
+	// Keyboard reader goroutine
+	g.writeLine("go func() {")
+	g.indent++
+	g.writeLine("r := bufio.NewReader(os.Stdin)")
+	g.writeLine("for {")
+	g.indent++
+	g.writeLine("b, err := r.ReadByte()")
+	g.writeLine("if err != nil {")
+	g.indent++
+	g.writeLine("close(keyboard)")
+	g.writeLine("return")
+	g.indent--
+	g.writeLine("}")
+	g.writeLine("keyboard <- b")
+	g.indent--
+	g.writeLine("}")
+	g.indent--
+	g.writeLine("}()")
+	g.writeLine("")
+
+	// Call the entry proc
+	g.writeLine(fmt.Sprintf("%s(keyboard, screen, _error)", name))
+	g.writeLine("")
+
+	// Close output channels and wait for writers to drain
+	g.writeLine("close(screen)")
+	g.writeLine("close(_error)")
+	g.writeLine("wg.Wait()")
+
+	g.indent--
+	g.writeLine("}")
+}
+
 func (g *Generator) containsPar(stmt ast.Statement) bool {
 	switch s := stmt.(type) {
 	case *ast.ParBlock:
diff --git a/codegen/codegen_test.go b/codegen/codegen_test.go
index d4610ee..d911685 100644
--- a/codegen/codegen_test.go
+++ b/codegen/codegen_test.go
@@ -250,6 +250,17 @@ func TestStringLiteral(t *testing.T) {
 	}
 }
 
+func TestStringEscapeCodegen(t *testing.T) {
+	input := `x := "hello*c*n"
+`
+	output := transpile(t, input)
+
+	// The *c*n should become \r\n in the Go output (via %q formatting)
+	if !strings.Contains(output, `x = "hello\r\n"`) {
+		t.Errorf("expected string with \\r\\n escape, got:\n%s", output)
+	}
+}
+
 func TestByteLiteral(t *testing.T) {
 	input := "x := 'A'\n"
 	output := transpile(t, input)
diff --git a/parser/parser.go b/parser/parser.go
index 22e63cb..df08c88 100644
--- a/parser/parser.go
+++ b/parser/parser.go
@@ -2314,6 +2314,41 @@ func (p *Parser) parseFuncDecl() *ast.FuncDecl {
 	return fn
 }
 
+// convertOccamStringEscapes converts occam escape sequences in string literals
+// to their actual byte values. Occam uses *c, *n, *t, *s, **, *", *' as escapes.
+func (p *Parser) convertOccamStringEscapes(raw string) string {
+	var buf strings.Builder
+	buf.Grow(len(raw))
+	for i := 0; i < len(raw); i++ {
+		if raw[i] == '*' && i+1 < len(raw) {
+			i++
+			switch raw[i] {
+			case 'n':
+				buf.WriteByte('\n')
+			case 'c':
+				buf.WriteByte('\r')
+			case 't':
+				buf.WriteByte('\t')
+			case 's':
+				buf.WriteByte(' ')
+			case '*':
+				buf.WriteByte('*')
+			case '"':
+				buf.WriteByte('"')
+			case '\'':
+				buf.WriteByte('\'')
+			default:
+				// Unknown escape: pass through as-is
+				buf.WriteByte('*')
+				buf.WriteByte(raw[i])
+			}
+		} else {
+			buf.WriteByte(raw[i])
+		}
+	}
+	return buf.String()
+}
+
 // parseByteLiteralValue processes the raw content of a byte literal (between single quotes),
 // handling occam escape sequences (* prefix), and returns the resulting byte value.
 func (p *Parser) parseByteLiteralValue(raw string) (byte, error) {
@@ -2608,7 +2643,7 @@ func (p *Parser) parseExpression(precedence int) ast.Expression {
 	case lexer.FALSE:
 		left = &ast.BooleanLiteral{Token: p.curToken, Value: false}
 	case lexer.STRING:
-		left = &ast.StringLiteral{Token: p.curToken, Value: p.curToken.Literal}
+		left = &ast.StringLiteral{Token: p.curToken, Value: p.convertOccamStringEscapes(p.curToken.Literal)}
 	case lexer.BYTE_LIT:
 		b, err := p.parseByteLiteralValue(p.curToken.Literal)
 		if err != nil {
diff --git a/parser/parser_test.go b/parser/parser_test.go
index dd34074..1213381 100644
--- a/parser/parser_test.go
+++ b/parser/parser_test.go
@@ -1341,6 +1341,45 @@ func TestStringLiteral(t *testing.T) {
 	}
 }
 
+func TestStringEscapeConversion(t *testing.T) {
+	tests := []struct {
+		input    string
+		expected string
+	}{
+		{`x := "hello*n"` + "\n", "hello\n"},
+		{`x := "hello*c*n"` + "\n", "hello\r\n"},
+		{`x := "*t*s"` + "\n", "\t "},
+		{`x := "a**b"` + "\n", "a*b"},
+		{`x := "it*'s"` + "\n", "it's"},
+		{`x := "no escapes"` + "\n", "no escapes"},
+	}
+
+	for _, tt := range tests {
+		l := lexer.New(tt.input)
+		p := New(l)
+		program := p.ParseProgram()
+		checkParserErrors(t, p)
+
+		if len(program.Statements) != 1 {
+			t.Fatalf("input %q: expected 1 statement, got %d", tt.input, len(program.Statements))
+		}
+
+		assign, ok := program.Statements[0].(*ast.Assignment)
+		if !ok {
+			t.Fatalf("input %q: expected Assignment, got %T", tt.input, program.Statements[0])
+		}
+
+		strLit, ok := assign.Value.(*ast.StringLiteral)
+		if !ok {
+			t.Fatalf("input %q: expected StringLiteral, got %T", tt.input, assign.Value)
+		}
+
+		if strLit.Value != tt.expected {
+			t.Errorf("input %q: expected Value=%q, got %q", tt.input, tt.expected, strLit.Value)
+		}
+	}
+}
+
 func TestByteLiteral(t *testing.T) {
 	tests := []struct {
 		input    string

413a0f2 Merge pull request #27 from codeassociates/feat/course-module-phase2
7b9314b Support full course module transpilation including float_io.occ
bb41e4d Add project preamble to README
40f906f Merge pull request #26 from codeassociates/feat/course-module-phase1
ba39c57 Update CLAUDE.md with Phase 1 features and Phase 2 roadmap

Switched to a new branch 'feat/course-module-runnable'

7 files changed, 455 insertions(+), 38 deletions(-)
 create mode 100644 codegen/e2e_course_test.go
 create mode 100644 examples/course_hello.occ

remote: 
remote: Create a pull request for 'feat/course-module-runnable' on GitHub by visiting:        
remote:      https://github.com/codeassociates/occam2go/pull/new/feat/course-module-runnable        
remote: 
To associate-1.github.com:codeassociates/occam2go.git
 * [new branch]      feat/course-module-runnable -> feat/course-module-runnable
branch 'feat/course-module-runnable' set up to track 'origin/feat/course-module-runnable'.

https://github.com/codeassociates/occam2go/pull/28

MERGED