goscript 0.1.0 → 0.1.1

package/gs/go/token/index.ts

@@ -1,9 +1,199 @@
 import * as $ from '@goscript/builtin/index.js'
 
+export type Token = number
 export type Pos = number
 
+export const ILLEGAL: Token = 0
+export const EOF: Token = 1
+export const COMMENT: Token = 2
+const literal_beg: Token = 3
+export const IDENT: Token = 4
+export const INT: Token = 5
+export const FLOAT: Token = 6
+export const IMAG: Token = 7
+export const CHAR: Token = 8
+export const STRING: Token = 9
+const literal_end: Token = 10
+const operator_beg: Token = 11
+export const ADD: Token = 12
+export const SUB: Token = 13
+export const MUL: Token = 14
+export const QUO: Token = 15
+export const REM: Token = 16
+export const AND: Token = 17
+export const OR: Token = 18
+export const XOR: Token = 19
+export const SHL: Token = 20
+export const SHR: Token = 21
+export const AND_NOT: Token = 22
+export const ADD_ASSIGN: Token = 23
+export const SUB_ASSIGN: Token = 24
+export const MUL_ASSIGN: Token = 25
+export const QUO_ASSIGN: Token = 26
+export const REM_ASSIGN: Token = 27
+export const AND_ASSIGN: Token = 28
+export const OR_ASSIGN: Token = 29
+export const XOR_ASSIGN: Token = 30
+export const SHL_ASSIGN: Token = 31
+export const SHR_ASSIGN: Token = 32
+export const AND_NOT_ASSIGN: Token = 33
+export const LAND: Token = 34
+export const LOR: Token = 35
+export const ARROW: Token = 36
+export const INC: Token = 37
+export const DEC: Token = 38
+export const EQL: Token = 39
+export const LSS: Token = 40
+export const GTR: Token = 41
+export const ASSIGN: Token = 42
+export const NOT: Token = 43
+export const NEQ: Token = 44
+export const LEQ: Token = 45
+export const GEQ: Token = 46
+export const DEFINE: Token = 47
+export const ELLIPSIS: Token = 48
+export const LPAREN: Token = 49
+export const LBRACK: Token = 50
+export const LBRACE: Token = 51
+export const COMMA: Token = 52
+export const PERIOD: Token = 53
+export const RPAREN: Token = 54
+export const RBRACK: Token = 55
+export const RBRACE: Token = 56
+export const SEMICOLON: Token = 57
+export const COLON: Token = 58
+const operator_end: Token = 59
+const keyword_beg: Token = 60
+export const BREAK: Token = 61
+export const CASE: Token = 62
+export const CHAN: Token = 63
+export const CONST: Token = 64
+export const CONTINUE: Token = 65
+export const DEFAULT: Token = 66
+export const DEFER: Token = 67
+export const ELSE: Token = 68
+export const FALLTHROUGH: Token = 69
+export const FOR: Token = 70
+export const FUNC: Token = 71
+export const GO: Token = 72
+export const GOTO: Token = 73
+export const IF: Token = 74
+export const IMPORT: Token = 75
+export const INTERFACE: Token = 76
+export const MAP: Token = 77
+export const PACKAGE: Token = 78
+export const RANGE: Token = 79
+export const RETURN: Token = 80
+export const SELECT: Token = 81
+export const STRUCT: Token = 82
+export const SWITCH: Token = 83
+export const TYPE: Token = 84
+export const VAR: Token = 85
+const keyword_end: Token = 86
+export const TILDE: Token = 88
+
+export const LowestPrec = 0
+export const UnaryPrec = 6
+export const HighestPrec = 7
 export const NoPos: Pos = 0
 
+const tokenStrings = new Map<Token, string>([
+  [ILLEGAL, 'ILLEGAL'],
+  [EOF, 'EOF'],
+  [COMMENT, 'COMMENT'],
+  [IDENT, 'IDENT'],
+  [INT, 'INT'],
+  [FLOAT, 'FLOAT'],
+  [IMAG, 'IMAG'],
+  [CHAR, 'CHAR'],
+  [STRING, 'STRING'],
+  [ADD, '+'],
+  [SUB, '-'],
+  [MUL, '*'],
+  [QUO, '/'],
+  [REM, '%'],
+  [AND, '&'],
+  [OR, '|'],
+  [XOR, '^'],
+  [SHL, '<<'],
+  [SHR, '>>'],
+  [AND_NOT, '&^'],
+  [ADD_ASSIGN, '+='],
+  [SUB_ASSIGN, '-='],
+  [MUL_ASSIGN, '*='],
+  [QUO_ASSIGN, '/='],
+  [REM_ASSIGN, '%='],
+  [AND_ASSIGN, '&='],
+  [OR_ASSIGN, '|='],
+  [XOR_ASSIGN, '^='],
+  [SHL_ASSIGN, '<<='],
+  [SHR_ASSIGN, '>>='],
+  [AND_NOT_ASSIGN, '&^='],
+  [LAND, '&&'],
+  [LOR, '||'],
+  [ARROW, '<-'],
+  [INC, '++'],
+  [DEC, '--'],
+  [EQL, '=='],
+  [LSS, '<'],
+  [GTR, '>'],
+  [ASSIGN, '='],
+  [NOT, '!'],
+  [NEQ, '!='],
+  [LEQ, '<='],
+  [GEQ, '>='],
+  [DEFINE, ':='],
+  [ELLIPSIS, '...'],
+  [LPAREN, '('],
+  [LBRACK, '['],
+  [LBRACE, '{'],
+  [COMMA, ','],
+  [PERIOD, '.'],
+  [RPAREN, ')'],
+  [RBRACK, ']'],
+  [RBRACE, '}'],
+  [SEMICOLON, ';'],
+  [COLON, ':'],
+  [BREAK, 'break'],
+  [CASE, 'case'],
+  [CHAN, 'chan'],
+  [CONST, 'const'],
+  [CONTINUE, 'continue'],
+  [DEFAULT, 'default'],
+  [DEFER, 'defer'],
+  [ELSE, 'else'],
+  [FALLTHROUGH, 'fallthrough'],
+  [FOR, 'for'],
+  [FUNC, 'func'],
+  [GO, 'go'],
+  [GOTO, 'goto'],
+  [IF, 'if'],
+  [IMPORT, 'import'],
+  [INTERFACE, 'interface'],
+  [MAP, 'map'],
+  [PACKAGE, 'package'],
+  [RANGE, 'range'],
+  [RETURN, 'return'],
+  [SELECT, 'select'],
+  [STRUCT, 'struct'],
+  [SWITCH, 'switch'],
+  [TYPE, 'type'],
+  [VAR, 'var'],
+  [TILDE, '~'],
+])
+
+const keywords = new Map<string, Token>()
+for (let tok = keyword_beg + 1; tok < keyword_end; tok++) {
+  keywords.set(tokenStrings.get(tok)!, tok)
+}
+
+type lineInfo = {
+  Offset: number
+  Filename: string
+  Line: number
+  Column: number
+}
+
 export class Position {
   public get Filename(): string {
     return this._fields.Filename.value
@@ -109,12 +299,388 @@ export function Position_IsValid(pos: Position): boolean {
 }
 
 export function Position_String(pos: Position): string {
+  let text = pos.Filename
   if (!Position_IsValid(pos)) {
-    return '-'
+    return text === '' ? '-' : text
+  }
+  if (text !== '') {
+    text += ':'
   }
-  const filename = pos.Filename === '' ? '<input>' : pos.Filename
+  text += `${pos.Line}`
   if (pos.Column > 0) {
-    return `${filename}:${pos.Line}:${pos.Column}`
+    text += `:${pos.Column}`
+  }
+  return text
+}
+
+export class File {
+  private nameValue: string
+  private baseValue: number
+  private sizeValue: number
+  private linesValue: number[]
+  private infosValue: lineInfo[]
+
+  constructor(
+    init?: Partial<{
+      name: string
+      base: number
+      size: number
+      lines: number[]
+      infos: lineInfo[]
+    }>,
+  ) {
+    this.nameValue = init?.name ?? ''
+    this.baseValue = init?.base ?? 0
+    this.sizeValue = init?.size ?? 0
+    this.linesValue = init?.lines?.slice() ?? [0]
+    this.infosValue = init?.infos?.slice() ?? []
+  }
+
+  public clone(): File {
+    return new File({
+      name: this.nameValue,
+      base: this.baseValue,
+      size: this.sizeValue,
+      lines: this.linesValue,
+      infos: this.infosValue,
+    })
+  }
+
+  public Name(): string {
+    return this.nameValue
+  }
+
+  public Base(): number {
+    return this.baseValue
+  }
+
+  public Size(): number {
+    return this.sizeValue
+  }
+
+  public End(): Pos {
+    return this.baseValue + this.sizeValue
+  }
+
+  public LineCount(): number {
+    return this.linesValue.length
+  }
+
+  public AddLine(offset: number): void {
+    const last = this.linesValue[this.linesValue.length - 1]
+    if ((this.linesValue.length === 0 || last < offset) && offset < this.sizeValue) {
+      this.linesValue.push(offset)
+    }
+  }
+
+  public MergeLine(line: number): void {
+    if (line < 1 || line >= this.linesValue.length) {
+      $.panic(`invalid line number ${line}`)
+    }
+    this.linesValue.splice(line, 1)
+  }
+
+  public Lines(): $.Slice<number> {
+    return $.arrayToSlice(this.linesValue.slice())
+  }
+
+  public SetLines(lines: $.Slice<number>): boolean {
+    const next = $.asArray(lines)
+    for (let i = 0; i < next.length; i++) {
+      if ((i > 0 && next[i] <= next[i - 1]) || this.sizeValue <= next[i]) {
+        return false
+      }
+    }
+    this.linesValue = next.slice()
+    return true
+  }
+
+  public SetLinesForContent(content: $.Slice<number>): void {
+    const lines: number[] = []
+    let line = 0
+    for (let offset = 0; offset < $.len(content); offset++) {
+      if (line >= 0) {
+        lines.push(line)
+      }
+      line = -1
+      if (content![offset] === 10) {
+        line = offset + 1
+      }
+    }
+    this.linesValue = lines
+  }
+
+  public LineStart(line: number): Pos {
+    if (line < 1 || line > this.linesValue.length) {
+      $.panic(`invalid line number ${line}`)
+    }
+    return this.baseValue + this.linesValue[line - 1]
+  }
+
+  public AddLineInfo(offset: number, filename: string, line: number): void {
+    this.AddLineColumnInfo(offset, filename, line, 1)
+  }
+
+  public AddLineColumnInfo(
+    offset: number,
+    filename: string,
+    line: number,
+    column: number,
+  ): void {
+    const last = this.infosValue[this.infosValue.length - 1]
+    if ((this.infosValue.length === 0 || last.Offset < offset) && offset < this.sizeValue) {
+      this.infosValue.push({ Offset: offset, Filename: filename, Line: line, Column: column })
+    }
+  }
+
+  public Pos(offset: number): Pos {
+    return this.baseValue + this.fixOffset(offset)
+  }
+
+  public Offset(pos: Pos): number {
+    return this.fixOffset(pos - this.baseValue)
+  }
+
+  public Line(pos: Pos): number {
+    return this.Position(pos).Line
+  }
+
+  public PositionFor(pos: Pos, adjusted: boolean): Position {
+    if (pos === NoPos) {
+      return new Position()
+    }
+    return this.position(pos, adjusted)
+  }
+
+  public Position(pos: Pos): Position {
+    return this.PositionFor(pos, true)
+  }
+
+  private fixOffset(offset: number): number {
+    if (offset < 0) {
+      return 0
+    }
+    if (offset > this.sizeValue) {
+      return this.sizeValue
+    }
+    return offset
+  }
+
+  private position(pos: Pos, adjusted: boolean): Position {
+    const offset = this.fixOffset(pos - this.baseValue)
+    let filename = this.nameValue
+    let line = 0
+    let column = 0
+    const lineIndex = searchInts(this.linesValue, offset)
+    if (lineIndex >= 0) {
+      line = lineIndex + 1
+      column = offset - this.linesValue[lineIndex] + 1
+    }
+    if (adjusted && this.infosValue.length > 0) {
+      const infoIndex = searchLineInfos(this.infosValue, offset)
+      if (infoIndex >= 0) {
+        const info = this.infosValue[infoIndex]
+        filename = info.Filename
+        const baseLineIndex = searchInts(this.linesValue, info.Offset)
+        if (baseLineIndex >= 0) {
+          const delta = line - (baseLineIndex + 1)
+          line = info.Line + delta
+          if (info.Column === 0) {
+            column = 0
+          } else if (delta === 0) {
+            column = info.Column + (offset - info.Offset)
+          }
+        }
+      }
+    }
+    return $.markAsStructValue(
+      new Position({
+        Filename: filename,
+        Offset: offset,
+        Line: line,
+        Column: column,
+      }),
+    )
+  }
+}
+
+export class FileSet {
+  private baseValue: number
+  private files: File[]
+
+  constructor(init?: Partial<{ base: number; files: File[] }>) {
+    this.baseValue = init?.base ?? 1
+    this.files = init?.files?.slice() ?? []
+  }
+
+  public clone(): FileSet {
+    return new FileSet({
+      base: this.baseValue,
+      files: this.files,
+    })
+  }
+
+  public Base(): number {
+    return this.baseValue
+  }
+
+  public AddFile(filename: string, base: number, size: number): File {
+    if (base < 0) {
+      base = this.baseValue
+    }
+    if (base < this.baseValue) {
+      $.panic(`invalid base ${base}`)
+    }
+    if (size < 0) {
+      $.panic(`invalid size ${size}`)
+    }
+    const file = new File({ name: filename, base, size })
+    this.files.push(file)
+    this.files.sort((left, right) => left.Base() - right.Base())
+    this.baseValue = base + size + 1
+    return file
+  }
+
+  public AddExistingFiles(...files: File[]): void {
+    for (const file of files) {
+      if (file != null && !this.files.includes(file)) {
+        this.files.push(file)
+        this.baseValue = Math.max(this.baseValue, file.Base() + file.Size() + 1)
+      }
+    }
+    this.files.sort((left, right) => left.Base() - right.Base())
+  }
+
+  public RemoveFile(file: File): void {
+    this.files = this.files.filter((candidate) => candidate !== file)
+  }
+
+  public Iterate(yieldFile: (file: File) => boolean): void {
+    for (const file of this.files.slice()) {
+      if (!yieldFile(file)) {
+        return
+      }
+    }
+  }
+
+  public File(pos: Pos): File | null {
+    if (pos === NoPos) {
+      return null
+    }
+    return this.files.find((file) => file.Base() <= pos && pos <= file.End()) ?? null
+  }
+
+  public PositionFor(pos: Pos, adjusted: boolean): Position {
+    const file = this.File(pos)
+    if (file === null) {
+      return new Position()
+    }
+    return file.PositionFor(pos, adjusted)
+  }
+
+  public Position(pos: Pos): Position {
+    return this.PositionFor(pos, true)
+  }
+}
+
+export function NewFileSet(): FileSet {
+  return new FileSet()
+}
+
+export function Pos_IsValid(pos: Pos): boolean {
+  return pos !== NoPos
+}
+
+export function Token_String(tok: Token): string {
+  return tokenStrings.get(tok) ?? `token(${tok})`
+}
+
+export function Token_Precedence(tok: Token): number {
+  switch (tok) {
+    case LOR:
+      return 1
+    case LAND:
+      return 2
+    case EQL:
+    case NEQ:
+    case LSS:
+    case LEQ:
+    case GTR:
+    case GEQ:
+      return 3
+    case ADD:
+    case SUB:
+    case OR:
+    case XOR:
+      return 4
+    case MUL:
+    case QUO:
+    case REM:
+    case SHL:
+    case SHR:
+    case AND:
+    case AND_NOT:
+      return 5
+    default:
+      return LowestPrec
+  }
+}
+
+export function Token_IsLiteral(tok: Token): boolean {
+  return literal_beg < tok && tok < literal_end
+}
+
+export function Token_IsOperator(tok: Token): boolean {
+  return (operator_beg < tok && tok < operator_end) || tok === TILDE
+}
+
+export function Token_IsKeyword(tok: Token): boolean {
+  return keyword_beg < tok && tok < keyword_end
+}
+
+export function Lookup(ident: string): Token {
+  return keywords.get(ident) ?? IDENT
+}
+
+export function IsExported(name: string): boolean {
+  return /^\p{Lu}/u.test(name)
+}
+
+export function IsKeyword(name: string): boolean {
+  return keywords.has(name)
+}
+
+export function IsIdentifier(name: string): boolean {
+  if (name === '' || IsKeyword(name)) {
+    return false
+  }
+  return /^[$_\p{L}][$_\p{L}\p{N}]*$/u.test(name)
+}
+
+function searchInts(values: number[], offset: number): number {
+  let low = 0
+  let high = values.length
+  while (low < high) {
+    const mid = Math.floor((low + high) / 2)
+    if (values[mid] > offset) {
+      high = mid
+    } else {
+      low = mid + 1
+    }
+  }
+  return low - 1
+}
+
+function searchLineInfos(values: lineInfo[], offset: number): number {
+  let low = 0
+  let high = values.length
+  while (low < high) {
+    const mid = Math.floor((low + high) / 2)
+    if (values[mid].Offset > offset) {
+      high = mid
+    } else {
+      low = mid + 1
+    }
   }
-  return `${filename}:${pos.Line}`
+  return low - 1
 }

package/gs/internal/abi/index.test.ts

@@ -0,0 +1,18 @@
+import { describe, expect, test } from 'vitest'
+
+import {
+  Escape,
+  EscapeNonString,
+  EscapeToResultNonString,
+  NoEscape,
+} from './index.js'
+
+describe('internal/abi escape intrinsics', () => {
+  test('return identity values in the JavaScript target', () => {
+    const value = { id: 1 }
+    expect(Escape(value)).toBe(value)
+    expect(NoEscape(value)).toBe(value)
+    expect(EscapeToResultNonString(value)).toBe(value)
+    expect(EscapeNonString(value)).toBeUndefined()
+  })
+})

package/gs/internal/abi/index.ts

@@ -26,6 +26,20 @@ export class IntArgRegBitmap {
   }
 }
 
+export function NoEscape<T>(p: T): T {
+  return p
+}
+
+export function Escape<T>(x: T): T {
+  return x
+}
+
+export function EscapeNonString<T>(_v: T): void {}
+
+export function EscapeToResultNonString<T>(v: T): T {
+  return v
+}
+
 // FuncPCABI0 returns the entry PC of the function f for ABI0
 export function FuncPCABI0(_f: any): number {
   return 0 // Placeholder

package/gs/internal/bytealg/index.test.ts

@@ -0,0 +1,18 @@
+import { describe, expect, test } from 'vitest'
+
+import { CountString, IndexByteString, LastIndexByteString } from './index.js'
+
+describe('internal/bytealg string byte indexes', () => {
+  test('finds first and last byte positions in strings', () => {
+    expect(IndexByteString('hello', 'l'.charCodeAt(0))).toBe(2)
+    expect(LastIndexByteString('hello', 'l'.charCodeAt(0))).toBe(3)
+    expect(LastIndexByteString('hello', 'x'.charCodeAt(0))).toBe(-1)
+    expect(LastIndexByteString('', 'x'.charCodeAt(0))).toBe(-1)
+  })
+
+  test('counts byte positions in strings', () => {
+    expect(CountString('hello', 'l'.charCodeAt(0))).toBe(2)
+    expect(CountString('hello', 'x'.charCodeAt(0))).toBe(0)
+    expect(CountString('', 'x'.charCodeAt(0))).toBe(0)
+  })
+})

package/gs/internal/bytealg/index.ts

@@ -131,6 +131,22 @@ export function IndexByteString(s: string, b: number): number {
   return s.indexOf(char)
 }
 
+export function LastIndexByteString(s: string, b: number): number {
+  const char = String.fromCharCode(b)
+  return s.lastIndexOf(char)
+}
+
+export function CountString(s: string, b: number): number {
+  const char = String.fromCharCode(b)
+  let count = 0
+  for (let i = 0; i < s.length; i++) {
+    if (s[i] === char) {
+      count++
+    }
+  }
+  return count
+}
+
 export function IndexString(s: string, substr: string): number {
   return s.indexOf(substr)
 }

package/gs/internal/byteorder/index.test.ts

@@ -0,0 +1,39 @@
+import { describe, expect, test } from 'vitest'
+
+import {
+  BEAppendUint64,
+  BEPutUint64,
+  BEUint64,
+  LEAppendUint64,
+  LEPutUint64,
+  LEUint64,
+} from './index.js'
+
+describe('internal/byteorder uint64', () => {
+  test('reads and writes big-endian bigint values', () => {
+    const bytes = new Uint8Array(8)
+
+    BEPutUint64(bytes, 0x0102030405060708n)
+
+    expect(Array.from(bytes)).toEqual([1, 2, 3, 4, 5, 6, 7, 8])
+    expect(BEUint64(bytes)).toBe(Number(0x0102030405060708n))
+  })
+
+  test('reads and writes little-endian bigint values', () => {
+    const bytes = new Uint8Array(8)
+
+    LEPutUint64(bytes, 0x0102030405060708n)
+
+    expect(Array.from(bytes)).toEqual([8, 7, 6, 5, 4, 3, 2, 1])
+    expect(LEUint64(bytes)).toBe(Number(0x0102030405060708n))
+  })
+
+  test('appends uint64 values', () => {
+    expect(Array.from(BEAppendUint64(new Uint8Array([0xaa]), 0x0102n))).toEqual([
+      0xaa, 0, 0, 0, 0, 0, 0, 1, 2,
+    ])
+    expect(Array.from(LEAppendUint64(new Uint8Array([0xaa]), 0x0102n))).toEqual([
+      0xaa, 2, 1, 0, 0, 0, 0, 0, 0,
+    ])
+  })
+})