rdn

KO | EN

gitlite — search

#golang #nodejs #html #api #editor #devops #web #swift #privacy #css

(★ 9)

A stack-based programming language like forth/porth with a stack-based virtual machine for scripting and embedded software.

파일 탐색기

ZIP 다운로드

- rdn.png
- - index.html
- - Makefile
  - manual.pdf
  - manual.tex
  - README.md
- - rdn-mode.el
- - vimplugrdn.md
- - todo.rdn
  - todo_tui.rdn
- - main.c
- all.rdn
- and_or.rdn
- base64.rdn
- dbg.rdn
- eprint.rdn
- flags.rdn
- fmt.rdn
- foo.rdn
- funcs.rdn
- gcd_ppcm.rdn
- get_module.rdn
- integer.rdn
- json.rdn
- list_extends.rdn
- MAIN.rdn
- module.rdn
- nested_modules.rdn
- person.json
- rdn_sqrt.rdn
- re.rdn
- snips10.rdn
- snips11.rdn
- snips12.rdn
- snips13.rdn
- snips14.rdn
- snips15.rdn
- snips16.rdn
- vuln.rdn
- rdn.h
- rdn_native.h
- base64.rdn
- bint.rdn
- core.rdn
- coroutines.rdn
- files.rdn
- flag.rdn
- integer.rdn
- io.rdn
- json.rdn
- lists.rdn
- log.rdn
- map.rdn
- math.rdn
- net.rdn
- os.rdn
- path.rdn
- process.rdn
- queue.rdn
- regex.rdn
- strconv.rdn
- strings.rdn
- time.rdn
- typecheck.rdn
- unix.rdn
- utf8.rdn
- bint.c
- coroutines.c
- files.c
- io.c
- json.c
- map.c
- math.c
- net.c
- path.c
- process.c
- strconv.c
- strings.c
- syscall.c
- unix.c
- utf8.c
- arena.h
- ht.h
- rdn.c
- stack.h
- - adv_enum.out
  - apply_keyword.out
  - argv.out
  - bint.out
  - booleans.out
  - bugs.out
  - const_reassign_error.out
  - const_reassign_error.status
  - consts.out
  - coroutines_native.out
  - demac.out
  - do_file_and_do_string.out
  - doubles.out
  - dup.out
  - enums.out
  - error.out
  - exit_test.out
  - exit_test.status
  - files_native.out
  - files_text_native.out
  - flag_lib.out
  - func_name.out
  - function_error_report.out
  - function_error_report.status
  - function_variable_call.out
  - functions.out
  - if_else.out
  - io_input.out
  - io_lib.out
  - json_native.out
  - line_col.out
  - lists.out
  - lists_lib.out
  - load.out
  - log.out
  - loop.out
  - map_lib.out
  - map_lib_error.out
  - map_lib_error.status
  - match.out
  - math_native_stdlib.out
  - math_pow.out
  - module_system.out
  - native_load.out
  - nested_modules.out
  - net_native.out
  - nulls.out
  - open_selective.out
  - operations.out
  - os_native.out
  - path_native.out
  - pcall.out
  - process_native.out
  - rdn_file_path.out
  - recursion_function.out
  - recursion_self_load.out
  - recursion_self_load.status
  - ret.out
  - rule_110.out
  - search_path_custom.out
  - search_path_defaults.out
  - set.out
  - stack_size.out
  - strconv_native.out
  - string_sequences.out
  - strings_and_type.out
  - strings_lib.out
  - strings_native_goish.out
  - swap_and_pop.out
  - test.out
  - time.out
  - to_string.out
  - todo_tui_app.out
  - typecheck_lib.out
  - unix_native.out
  - unlet.out
  - utf8.out
  - vars.out
- - search_helper.rdn
- - native_test_module.c
  - native_test_module.so
- adv_enum.rdn
- apply_keyword.rdn
- argv.rdn
- bint.rdn
- booleans.rdn
- bugs.rdn
- const_reassign_error.rdn
- consts.rdn
- coroutines.rdn
- coroutines_native.rdn
- demac.rdn
- do_file_and_do_string.rdn
- doubles.rdn
- dup.rdn
- enums.rdn
- error.rdn
- exit_test.rdn
- file_string_test.rdn
- files_native.rdn
- files_text_native.rdn
- flag_lib.rdn
- foo.rdn
- func_name.rdn
- function_error_report.rdn
- function_variable_call.rdn
- functions.rdn
- functions_helper.rdn
- if_else.rdn
- io_input.rdn
- io_input.stdin
- io_lib.rdn
- json_native.rdn
- line_col.rdn
- lists.rdn
- lists_lib.rdn
- load.rdn
- log.rdn
- loop.rdn
- map_lib.rdn
- map_lib_error.rdn
- match.rdn
- math_native_stdlib.rdn
- math_pow.rdn
- module_system.rdn
- native_load.rdn
- nested_modules.rdn
- net_native.rdn
- nulls.rdn
- open_selective.rdn
- operations.rdn
- os_native.rdn
- path_native.rdn
- pcall.rdn
- process_native.rdn
- rdn_file_path.rdn
- recursion_function.rdn
- recursion_self_load.rdn
- ret.rdn
- rule_110.rdn
- run.py
- run.sh
- search_path_custom.rdn
- search_path_defaults.rdn
- set.rdn
- stack_size.rdn
- strconv_native.rdn
- string_sequences.rdn
- strings_and_type.rdn
- strings_lib.rdn
- strings_native_goish.rdn
- swap_and_pop.rdn
- test.rdn
- test_apply.rdn
- test_debug.rdn
- test_load.rdn
- test_log.rdn
- test_log2.rdn
- test_minimal.rdn
- test_str.rdn
- test_str2.rdn
- test_str3.rdn
- test_str4.rdn
- test_str5.rdn
- test_str6.rdn
- test_time2.rdn
- test_typed.rdn
- test_typed2.rdn
- test_typed3.rdn
- test_typed4.rdn
- time.rdn
- tmp_loop_list.rdn
- to_string.rdn
- todo_tui_app.rdn
- todo_tui_app.stdin
- typecheck_debug.rdn
- typecheck_debug2.rdn
- typecheck_debug3.rdn
- typecheck_lib.rdn
- unix_native.rdn
- unlet.rdn
- utf8.rdn
- vars.rdn
.gitignore
build.sh
CHANGELOG.md
install
LICENSE
main.c
Makefile
README.md

# CDN으로 사용하기

jsDelivr

jsDelivr는 공개 GitHub 리포지토리를 별도 설정 없이 CDN으로 즉시 서빙합니다. 버전과 파일을 고르면 웹페이지에 바로 붙일 수 있는 링크와 예시 코드가 만들어집니다.

버전

파일

링크

예시

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

rdn is a small stack-based scripting language.

It is built around a simple value stack, a small interpreter written in C, and a native module API for extending the language from shared libraries.

## Build

Build the interpreter:

- using make:

```sh
make
```

- using bash installer:

```sh
sudo ./build.sh all # compile and install interpreter with it's runtime
```

Run a script:

```sh
./main examples/snips7.rdn # or rdn
```

Run the test suite:

```sh
bash test/run.sh # or python3 test/run.py
```

Build a native module manually:

```sh
gcc -Wall -Wextra -Werror -ggdb -std=c11 -fPIC -shared nativelibs/files.c -I. -o nativelibs/files.so
```

## Language Basics

Raden is postfix and stack-based. Values are pushed first, then operations consume them.

Example:

```raden
2 3 + print
```

This pushes `2`, pushes `3`, applies `+`, then prints the result.

### Values

Raden supports:

- integers
- doubles
- strings
- booleans
- lists
- identifiers

Examples:

```raden
10
2.5
"hello"
true
(1 2 "x")
```

### Variables

Use `let` to bind a value:

```raden
10 n let
n print
```

Use `set` to update an existing variable:

```raden
n 1 + n set
```

Use `const` for constants:

```raden
3 limit const
```

### Control Flow

`if` consumes a boolean:

```raden
true if
    "yes" print
else
    "no" print
end
```

`loop` repeats while the condition value at the end of the body stays true:

```raden
0 i let
i 5 < cond let

cond loop
    i print "\n" print
    i 1 + i let
    i 5 < cond set
    cond
end
```

### Functions

Define a function with `defun` and call it with `call`:

```raden
hello defun
    "hello\n" print
end

hello call
```

Use `ret` inside a function to stop executing that function early. Any values already left on the stack are the return values:

```raden
check-less-three defun
    n let
    n 3 < if
        true
        ret
    end
    false
end
```

### Modules

Define a named namespace with `module` and expose its members with `open`:

```raden
MyModule module
    func1 defun
        "hello\n" print
    end
end

MyModule::func1 call

MyModule open
func1 call
```

Functions and apply-words use `::` prefix, variables also use `::`:

```raden
Cfg module
    10 limit let
end

Cfg::limit print
```

Modules nest with `::` chaining:

```raden
Mod1 module
    NestedMod1 module
        nm apply
            "nm\n" print
        end
    end
end

Mod1::NestedMod1::nm
```

### Builtins

Common builtins include:

- arithmetic: `+ - * /`
- comparisons: `< > <= >= = !=`
- boolean ops: `! | &`
- bitwise ops: `<< >> ^`
- stack ops: `pop swap dup`
- variables: `let set const`
- functions: `defun call ret`
- conversion: `type to_string`
- containers: `append index remove len`
- string matching: `match`
- loading: `load loadnative`
- modules: `module open`

## Lists And Strings

Lists are written with parentheses:

```raden
(1 2 3)
```

You can index, remove, append, and get length:

```raden
(10 20 30) 1 index print "\n" print
(1 2 3) 1 remove print "\n" print
(1 2) 3 append print "\n" print
(1 2 3) len print
```

The same sequence builtins also work with strings:

```raden
"abcd" 1 index print "\n" print
"abcd" 1 remove print "\n" print
"ab" "cd" append print "\n" print
"hello" len print
```

### String Matching

Use `match` for glob-style pattern matching (`*` for any, `?` for single char, `[...]` for character classes):

```raden
"hello.txt" "*.txt" match print   [* true *]
"hello.md" "*.txt" match print    [* false *]
"abc" "a?c" match print           [* true *]
"test5.txt" "test[0-9].txt" match print   [* true *]
```

For string variables, `append` and `remove` mutate the variable in place:

```raden
"hi" text let
text "!" append
text print "\n" print

text 1 remove
text print
```

## argv
```raden

[* access global variable *]

__argv print [* (script.rdn foo bar) *]

```

## enumerations
```raden

enum ONE const      [* ONE == 0 *]
enum TWO const      [* TWO == 1 *]
enum THREE const    [* THREE == 2 *]
reset [* reset the enum to 0 again *]

```

## Example Script

[`MAIN.rdn`](./MAIN.rdn) shows several language features together:

- loops
- lists
- string manipulation
- `loadnative`
- file IO via a native module

Example from it:

```raden
"./nativelibs/files.so" loadnative
"./Makefile" readLines call lines let

lines len print
"\n" print
lines 0 index print
```

The result of `readLines` is a normal Raden list, so you treat it with `len`, `index`, `append`, and `remove` just like any other list.

## Loading Scripts

Use `load` to execute another `.rdn` file:

```raden
"./libs/math.rdn" load
2 6 pow call print
```

Paths are resolved relative to the currently running source file.

## Native Modules

Use `loadnative` to load a shared library:

```raden
"./nativelibs/files.so" loadnative
"./nativelibs/math.so" loadnative
```

Native functions are registered by name, then called with normal `call` syntax:

```raden
"./nativelibs/files.so" loadnative
"./Makefile" readLines call print
```

## Native Module API

The public header is [`include/rdn_native.h`](./include/rdn_native.h).

A module must export:

```c
bool rdn_module_init(RDNModule *module);
```

Inside `rdn_module_init`, register native functions:

```c
if (!module->register_function(module, "myFunc", myFunc)) {
    return false;
}
```

Native functions use this signature:

```c
static bool myFunc(RDNApi *api);
```

### Stack Indexing

The API uses stack indices:

- `-1` means top of stack
- `-2` means one below top
- positive indices start at `1`

### Scalar API

Available helpers include:

- `api->stack_size(api)`
- `api->type(api, index)`
- `api->to_integer(api, index, &out)`
- `api->to_number(api, index, &out)`
- `api->to_boolean(api, index, &out)`
- `api->to_string(api, index)`
- `api->pop(api, count)`
- `api->push_integer(api, value)`
- `api->push_number(api, value)`
- `api->push_boolean(api, value)`
- `api->push_string(api, value)`
- `api->raise_error(api, message)`

### List API

The API also supports list creation and mutation:

- `api->push_list(api)`
- `api->list_len(api, index, &len)`
- `api->list_append(api, list_index, value_index)`
- `api->list_index(api, list_index, item_index)`
- `api->list_remove(api, list_index, item_index)`

`list_index` pushes a cloned item onto the stack.

`list_append` clones the source value before inserting it.

## Native Module Example

Minimal example:

```c
#include "../include/rdn_native.h"

static bool native_add(RDNApi *api) {
    long left = 0;
    long right = 0;

if (api->stack_size(api) < 2) {
        return api->raise_error(api, "native_add requires 2 operands");
    }

if (!api->to_integer(api, -2, &left) || !api->to_integer(api, -1, &right)) {
        return api->raise_error(api, "native_add requires integers");
    }

if (!api->pop(api, 2)) {
        return false;
    }

return api->push_integer(api, left + right);
}

bool rdn_module_init(RDNModule *module) {
    return module->register_function(module, "native_add", native_add);
}
```

There is a fuller example in [`test/native/native_test_module.c`](./test/native/native_test_module.c).

## Implementing `readLines`

`readLines` in [`nativelibs/files.c`](./nativelibs/files.c) is a good reference for returning a list from native code:

1. read the file
2. `push_list`
3. `push_string` for each line
4. `list_append` into the list
5. `pop` the temporary pushed string

That pattern is also what you use for functions like `split`, `glob`, or directory listing APIs.

## Embedding Raden

The current embedding entry point is:

```c
int rdn_main(int argc, char **argv);
```

It is declared in [`include/rdn.h`](./include/rdn.h).

At the moment, embedding is very lightweight and file-oriented: you invoke `rdn_main` with a script path just like the `main` executable does.

Example host program:

```c
#include "./include/rdn.h"

int main(void) {
    char *argv[] = {
        "host",
        "./MAIN.rdn",
    };

return rdn_main(2, argv);
}
```

Current embedding notes:

- the public embedding surface is still minimal
- `rdn_main` executes a file path
- native modules are loaded with `loadnative`
- source-relative `load` and `loadnative` path resolution already works in the interpreter

If you want a stronger embedding API later, the next logical step is exposing helpers like:

- `rdn_eval_file(...)`
- `rdn_eval_string(...)`
- `rdn_state_new(...)`
- `rdn_state_free(...)`

## Project Layout

- [`main.c`](./main.c): thin entry point
- [`src/rdn.c`](./src/rdn.c): interpreter implementation
- [`include/rdn.h`](./include/rdn.h): internal interpreter declarations
- [`include/rdn_native.h`](./include/rdn_native.h): native module API
- [`nativelibs/`](./nativelibs): native module examples
- [`libs/`](./libs): Raden library scripts
- [`test/`](./test): regression tests

## Neovim Support

This repo includes a simple Neovim runtime package for `.rdn` files under [`editor/nvim/`](./editor/nvim):

- file detection
- syntax highlighting
- ftplugin defaults
- basic indent rules

To use it locally:

```sh
mkdir -p ~/.config/nvim
cp -r ./nvim/* ~/.config/nvim/
```

### LazyVim / lazy.nvim

Use a local plugin spec like:

```lua
return {
  {
    dir = "<path>/rdn/editor/nvim",
    name = "raden.nvim",
    ft = "raden",
  },
}
```

The repo exposes these runtime directories at the root for Lazy compatibility:

- `ftdetect/`
- `ftplugin/`
- `indent/`
- `syntax/`

rdn

파일 탐색기

# CDN으로 사용하기

Was this content helpful?

Recent Feedback

Download README