root/trunk/orca/boot.c

// Automatically created by boot.r

static char _natives[] =
  "sizeof: native []\n"
  "comment: native [value]\n"
  "set: native [\n"
  "    word\n"
  "    value\n"
  "]\n"
  "unset: native [\n"
  "    word [word! block!]\n"
  "]\n"
  "value?: native [val]\n"
  "any-word?: native [val]\n"
  "get: native [\n"
  "    word\n"
  "]\n"
  "do: native [\n"
  "    \"Evaluates a block or any other value.\"\n"
  "    value\n"
  "    /args arg\n"
  "]\n"
  "make: native [\n"
  "    \"Construct new value\"\n"
  "    type\n"
  "    spec\n"
  "]\n"
  "bind: native [\n"
  "    words [block! word!]\n"
  "    known-word [word! object!]\n"
  "    /copy\n"
  "]\n"
  "in: native [\n"
  "    object [object!]\n"
  "    word [word!]\n"
  "]\n"
  "use: native [\n"
  "    words [block! word!]\n"
  "    body [block!]\n"
  "]\n"
  "copy: native [\n"
  "    value [series! bitset! matrix!]\n"
  "    /part\n"
  "    range [integer! series!]\n"
  "    /deep\n"
  "]\n"
  "change: native [\n"
  "    series [series!]\n"
  "    value\n"
  "    /part\n"
  "    range [integer! series!]\n"
  "    /only\n"
  "]\n"
  "find: native [\n"
  "    series [series!]\n"
  "    value\n"
  "    /match\n"
  "    /last\n"
  "    /skip size [integer!]\n"
  "]\n"
  "reduce: native [\n"
  "    value\n"
  "]\n"
  "compose: native [\n"
  "    value\n"
  "    /deep\n"
  "    /only\n"
  "]\n"
  "form: native [\n"
  "    value\n"
  "]\n"
  "mold: native [\n"
  "    value\n"
  "    /only\n"
  "]\n"
  "not: native [value]\n"
  "print: native [value]\n"
  "prin: native [value]\n"
  "clear: native [\n"
  "    series [series! none!]\n"
  "]\n"
  "skip: native [\n"
  "    series [series!]\n"
  "    offset [number! logic!]\n"
  "]\n"
  "at: native [\n"
  "    series [series!]\n"
  "    index [number! logic!]\n"
  "]\n"
  "pick: native [\n"
  "    series [series! tuple! matrix!]\n"
  "    index [number! logic!]\n"
  "]\n"
  "poke: native [\n"
  "    value\n"
  "    index [number! logic!]\n"
  "    data\n"
  "]\n"
  "select: native [\n"
  "    series [series!]\n"
  "    value\n"
  "]\n"
  "first: native [value]\n"
  "second: native [value]\n"
  "third: native [value]\n"
  "last: native [value [series! tuple!]]\n"
  "reverse: native [\n"
  "    value [series! tuple! pair!]\n"
  "    /part\n"
  "    range [integer! series!]\n"
  "]\n"
  "parse: native [\n"
  "    input [series!]\n"
  "    rules [block! string! none!]\n"
  "    /all\n"
  "    /case\n"
  "]\n"
  "type?: native [value /word]\n"
  "length?: native [value [series! tuple!]]\n"
  "any-string?: native [value]\n"
  "any-block?: native [value]\n"
  "binary?:\n"
  "bitset?:\n"
  "block?:\n"
  "char?:\n"
  "datatype?:\n"
  "decimal?:\n"
  "error?:\n"
  "file?:\n"
  "function?:\n"
  "getword?:\n"
  "hash?:\n"
  "integer?:\n"
  "issue?:\n"
  "list?:\n"
  "litpath?:\n"
  "litword?:\n"
  "logic?:\n"
  "native?:\n"
  "none?:\n"
  "number?:\n"
  "object?:\n"
  "op?:\n"
  "pair?:\n"
  "paren?:\n"
  "path?:\n"
  "refinement?:\n"
  "series?:\n"
  "setpath?:\n"
  "setword?:\n"
  "string?:\n"
  "tag?:\n"
  "time?:\n"
  "tuple?:\n"
  "unset?:\n"
  "word?: native [value]\n"
  "to: native [\n"
  "    type\n"
  "    value\n"
  "]\n"
  "disarm: native [error [error!]]\n"
  "try: native [block [block!]]\n"
  "catch: native [\n"
  "    block [block!]\n"
  "    /name word [word!]\n"
  "]\n"
  "throw: native [value /name word [word!]]\n"
  "does: native [value]\n"
  "func: native [\n"
  "    spec [block!]\n"
  "    body [block!]\n"
  "]\n"
  "if: native [\n"
  "    condition\n"
  "    then-block [block!]\n"
  "]\n"
  "unless: native [\n"
  "    condition\n"
  "    then-block [block!]\n"
  "]\n"
  "either: native [\n"
  "    condition\n"
  "    then-block [block!]\n"
  "    else-block [block!]\n"
  "]\n"
  "any: native [\n"
  "    block [block!]\n"
  "]\n"
  "all: native [\n"
  "    block [block!]\n"
  "]\n"
  "loop: native [\n"
  "    count [integer!]\n"
  "    block [block!]\n"
  "]\n"
  "repeat: native [\n"
  "    'word [word!]\n"
  "    value [integer! series!]\n"
  "    block [block!]\n"
  "]\n"
  "foreach: native [\n"
  "    'word [word! block!]\n"
  "    data [series!]\n"
  "    body [block!]\n"
  "]\n"
  "remove-each: native [\n"
  "    'word [word! block!]\n"
  "    data [series!]\n"
  "    body [block!]\n"
  "]\n"
  "while: native [\n"
  "    cond [block!]\n"
  "    body [block!]\n"
  "]\n"
  "until: native [\n"
  "    cond [block!]\n"
  "]\n"
  "break: native [\n"
  "    /return\n"
  "    value\n"
  "]\n"
  "return: native [\n"
  "    value\n"
  "]\n"
  "exit: native []\n"
  "back: native [\n"
  "    series [series!]\n"
  "]\n"
  "next: native [\n"
  "    series [series!]\n"
  "]\n"
  "head: native [\n"
  "    series [series!]\n"
  "]\n"
  "tail: native [\n"
  "    series [series!]\n"
  "]\n"
  "index?: native [\n"
  "    series [series!]\n"
  "]\n"
  "head?: native [\n"
  "    series [series!]\n"
  "]\n"
  "tail?: native [\n"
  "    series [series!]\n"
  "]\n"
  "insert: native [\n"
  "    series [series!]\n"
  "    value\n"
  "    /part\n"
  "    range [integer! series!]\n"
  "    /only\n"
  "]\n"
  "remove: native [\n"
  "    series [series! none!]\n"
  "    /part\n"
  "    range [integer! series! pair!]\n"
  "]\n"
  "lowercase: native [\n"
  "    string [string! file!]\n"
  "    /part range [integer!]\n"
  "]\n"
  "uppercase: native [\n"
  "    string [string! file!]\n"
  "    /part range [integer!]\n"
  "]\n"
  "load: native [\n"
  "    source [file! string!]\n"
  "]\n"
  "open: native [what]\n"
  "close: native [port [port!]]\n"
  "read: native [\n"
  "    source [file! port!]\n"
  "    /binary\n"
  "    /lines\n"
  "    /skip length [number!]\n"
  "    /part size [number!]\n"
  "]\n"
  "write: native [\n"
  "    dest [file! port! object! block!]\n"
  "    value\n"
  "    /binary\n"
  "    /append\n"
  "]\n"
  "rename: native [\n"
  "    old [file!]\n"
  "    new [file! string!]\n"
  "]\n"
  "delete: native [\n"
  "    what [file!]\n"
  "]\n"
  "exists?: native [\n"
  "    target [file!]\n"
  "]\n"
  "size?: native [\n"
  "    target [file!]\n"
  "]\n"
  "dir?: native [\n"
  "    target [file!]\n"
  "]\n"
  "modified?: native [\n"
  "    target [file!]\n"
  "]\n"
  "getenv: native [name [string!]]\n"
  "change-dir: native [value]\n"
  "what-dir: native []\n"
  "make-dir: native [path [file!]]\n"
  "clean-path: native [path [file!]]\n"
  "recycle: native [/off /on]\n"
  "halt: native []\n"
  "quit: native [/return code]\n"
  "protect: native [\n"
  "    value [word! block!]\n"
  "]\n"
  "now: native [\n"
  "    /time\n"
  "]\n"
  "trim: native [\n"
  "    string [string! series!]\n"
  "    /auto\n"
  "    /head\n"
  "    /tail\n"
  "]\n"
  "dump: native [val]\n"
  "same?: native [v1 v2]\n"
  "equal?: native [v1 v2]\n"
  "strict-equal?: native [v1 v2]\n"
  "greater-or-equal?: native [v1 v2]\n"
  "greater?: native [v1 v2]\n"
  "lesser-or-equal?: native [v1 v2]\n"
  "lesser?: native [v1 v2]\n"
  "odd?: native [number [number! char!]]\n"
  "even?: native [number [number! char!]]\n"
  "abs: native [number [number! pair!]]\n"
  "complement: native [value [logic! integer! bitset!]]\n"
  "negate: native [number [number! pair! bitset! vec3!]]\n"
  "sine: native [value [number!] /radians]\n"
  "cosine: native [value [number!] /radians]\n"
  "arcsine: native [value [number!] /radians]\n"
  "arccosine: native [value [number!] /radians]\n"
  "tangent: native [value [number!] /radians]\n"
  "arctangent: native [value [number!] /radians]\n"
  "square-root: native [value [number!]]\n"
  "random: native [value /seed /only]\n"
  "power: native [x [number!] y [number!]]\n"
  "remainder: native [\n"
  "    x [number!]\n"
  "    y [number!]\n"
  "]\n"
  "compress: native [data [string! binary!]]\n"
  "decompress: native [data [binary!]]\n"
  "dot: native [a [vec3!] b [vec3!]]\n"
  "cross: native [a [vec3!] b [vec3!]]\n"
  "normalize: native [vec [vec3!]]\n"
;

static char _boot[] =
  "context: func [blk [block!]] [make object! blk]\n"
  "probe: func [value] [print mold :value :value]\n"
  "source: func ['word] [\n"
  "    prin rejoin [word \": \"]\n"
  "    either function? get word [\n"
  "        print mold get word\n"
  "    ] [\n"
  "        either native? get word\n"
  "        [print mold get word]\n"
  "        [print \"is not a function\"]\n"
  "    ]\n"
  "]\n"
  "function: func [\n"
  "    spec [block!]\n"
  "    vars [block!]\n"
  "    body [block!]\n"
  "] [\n"
  "    func head insert insert tail copy spec /local vars body\n"
  "]\n"
  "true: yes: on: make logic! 1\n"
  "false: no: off: make logic! 0\n"
  "newline: #\"^/\"\n"
  "empty?: :tail?\n"
  "q: :quit\n"
  "orca: true\n"
  "system: context [\n"
  "    version: 0.0.23\n"
  "    os: none\n"
  "    error: context [\n"
  "        msg: type: id: near: none\n"
  "    ]\n"
  "    error-types: ['syntax 'script 'math 'access 'internal]\n"
  "    words: none\n"
  "    script-proto: context [\n"
  "        args:\n"
  "        path:\n"
  "        parent:\n"
  "        header: none\n"
  "    ]\n"
  "    script: none\n"
  "]\n"
  "protect 'system\n"
  "protect 'datatypes\n"
  "to-binary: func [value] [to binary! :value]\n"
  "to-bitset: func [value] [to bitset! :value]\n"
  "to-block: func [value] [to block! :value]\n"
  "to-char: func [value] [to char! :value]\n"
  "to-decimal: func [value] [to decimal! :value]\n"
  "to-file: func [value] [to file! :value]\n"
  "to-get-word: func [value] [to get-word! :value]\n"
  "to-integer: func [value] [to integer! :value]\n"
  "to-issue: func [value] [to issue! :value]\n"
  "to-lit-path: func [value] [to lit-path! :value]\n"
  "to-lit-word: func [value] [to lit-word! :value]\n"
  "to-logic: func [value] [to logic! :value]\n"
  "to-paren: func [value] [to paren! :value]\n"
  "to-path: func [value] [to path! :value]\n"
  "to-refinement: func [value] [to refinement! :value]\n"
  "to-set-path: func [value] [to set-path! :value]\n"
  "to-set-word: func [value] [to set-word! :value]\n"
  "to-string: func [value] [to string! :value]\n"
  "to-tag: func [value] [to tag! :value]\n"
  "to-time: func [value] [to time! :value]\n"
  "to-tuple: func [value] [to tuple! :value]\n"
  "to-word: func [value] [to word! :value]\n"
  "charset: func [str [string! block!]] [make bitset! str]\n"
  "append: func [\n"
  "    series [series!]\n"
  "    value\n"
  "    /only\n"
  "] [\n"
  "    head either only\n"
  "    [insert/only tail series :value]\n"
  "    [insert tail series :value]\n"
  "]\n"
  "rejoin: func [\n"
  "    block [block!]\n"
  "] [\n"
  "    if empty? block: reduce block [return block]\n"
  "    append either series? first block\n"
  "    [copy first block]\n"
  "    [form first block]\n"
  "    next block\n"
  "]\n"
  "replace: func [\n"
  "    series [series!]\n"
  "    pattern\n"
  "    with\n"
  "    /all\n"
  "    /local orig len\n"
  "] [\n"
  "    orig: series\n"
  "    if (any-string? series) and any [not any-string? :pattern tag? :pattern] [\n"
  "        pattern: form :pattern\n"
  "    ]\n"
  "    len: either any [any-string? series any-block? :pattern]\n"
  "    [length? :pattern]\n"
  "    [1]\n"
  "    while [series: find series :pattern] [\n"
  "        series: change/part series :with len\n"
  "        if not all [break]\n"
  "    ]\n"
  "    orig\n"
  "]\n"
  "forall: func [\n"
  "    [throw]\n"
  "    'word [word!]\n"
  "    body [block!]\n"
  "] [\n"
  "    while [not tail? get word] [\n"
  "        do body\n"
  "        set word next get word\n"
  "    ]\n"
  "]\n"
  "switch: func [\n"
  "    [throw]\n"
  "    value\n"
  "    options [block!]\n"
  "    /default else\n"
  "] [\n"
  "    either value: select options value\n"
  "    [do value]\n"
  "    [either default [do else] [none]]\n"
  "]\n"
  "forever: func [\n"
  "    [throw]\n"
  "    body [block!]\n"
  "] [\n"
  "    while [1] body\n"
  "]\n"
  "forskip: func [\n"
  "    [throw]\n"
  "    'iter [word!]\n"
  "    mod [integer!]\n"
  "    body [block!]\n"
  "] [\n"
  "    while [not tail? get iter] [\n"
  "        do body\n"
  "        set iter skip get iter mod\n"
  "    ]\n"
  "]\n"
  "join: func [a b] [\n"
  "    a: either series? a [copy a] [form a]\n"
  "    head insert tail a reduce :b\n"
  "]\n"
  "reform: func [value] [\n"
  "    form reduce value\n"
  "]\n"
  "repend: func [\n"
  "    series [series!]\n"
  "    value\n"
  "    /only\n"
  "] [\n"
  "    head either only\n"
  "    [insert/only tail series reduce :value]\n"
  "    [insert tail series reduce :value]\n"
  "]\n"
  "save: func [\n"
  "    file [file!]\n"
  "    data\n"
  "] [\n"
  "    write file mold/only data\n"
  "]\n"
  "dirize: func [path [file! string!] /local end]\n"
  "[\n"
  "    end: last path\n"
  "    either all [\n"
  "        end <> #\"/\"\n"
  "        end <> #\"\\\"\n"
  "    ] [append path #\"/\"] [path]\n"
  "]\n"
  "time-block: func [blk /local a b] [a: now/time do blk b: now/time b - a]\n"
;