Arc

Arc is a small programming language project written in C. It focuses on building a clean and reliable frontend pipeline, along with a simple interpreter for evaluating expressions and basic variable assignments.

---

Current Features

• Interactive REPL (src/repl) with clear and exit commands

• File execution (supports .arc files)

• File importing (using IMPORT keyword)

• Lexer for arithmetic expressions, identifiers, and string literals

• Parser with AST generation, supporting multiple statements

• Expression evaluation (interpreter)

• Integer and floating-point number support

• String literal support

• List literal support

• Support for operations on strings:

  • + (concatenation), * (repetition)

• Support for operations on lists:

  • Indexing
  • Slicing (TODO)

• Functions:

  • Define functions using the FN keyword.
  • Supports parameters.
  • Call functions using function_name(arg1, arg2).
  • Support for Native Functions implemented in C.

• Variables and identifiers (using VAR keyword)

• Conditional statements: IF, THEN, ELIF, ELSE, END

• Looping: WHILE, THEN, END

• Multi-line support: Bodies of IF, ELIF, ELSE, and WHILE can contain multiple statements.

• Basic arithmetic operators:

  • +, -, *, /, ^
  • Parentheses ( )

• Comparison operators:

  • ==, !=, <, >, <=, >=

• Logical operators:

  • AND, OR

• Assignment operator =

• Token system (include/token.h)

• Structured error handling with position tracking:

  • File name
  • Line number
  • Column number

• Debug mode for inspecting tokens and AST

• Configurable floating-point precision

• Execute code from string via CLI

• Option to disable colored output

• Focus on memory-safe design

---

Example

Normal Mode

### File Execution Example

Create a file named `script.arc`:

```text
VAR x = 0

WHILE x < 5 THEN
    x = x + 1
END

IF x == 5 THEN
    "Five"
ELSE
    "Not Five"
END

Running this file (./arc script.arc) will output:

Five

Arc Arc Arc Arc > "Hello " + "World" Hello World Arc > VAR y = (x + 2) ^ 2 49.000000 Arc > y / 7 7.000000 Arc > x == 5 1 Arc > x > 10 OR x == 5 1

---

## Command-line Arguments

Arc provides access to command-line arguments through built-in variables:

* `argc`: The number of positional arguments (including the script file).
* `argv`: List of positional arguments. (including the script file).

Example usage in a script:
```text
VAR i = 1

IF argc > 1 THEN
    argv[0]
ELSE
    "No arguments provided"
END

If you run arc script.arc hello world:

• argc will be 3
• argv[0] will be "script.arc" (or the path to the executable)
• argv[1] will be "hello"
• argv[2] will be "world"

---

Functions

FN add(a, b) THEN
    a + b
END

VAR result = add(5, 3)
result

Running this code will output:

8

Importing files

You can import other .arc files using the IMPORT keyword.

IMPORT "math.arc"

This will execute the code in math.arc and make its defined variables and functions available in the current scope.

---

Debug Mode

Run with:

arc -d
# or
arc --debug

Example session:

Arc > 1-1

Tokens: INT MINUS INT 
AST tree: (1 MINUS 1)

0

Arc > VAR a = 10

Tokens: KEYWORD IDENTIFIER EQ INT 
AST tree: [a = 10]

10

---

Error Handling

Arc > s
Name Error: Undefined variable "s"
File <stdin>, line 1, column 1

s
^

---

Design Philosophy

Arc is intentionally designed to stay simple and easy to reason about. The main goals are:

• No external dependencies
• Clear separation of components:
  • Lexer
  • Tokens
  • Parser
  • AST nodes (including support for multiple statements)
  • Interpreter
  • Symbol table (for variables)
  • Error handling
  • Position tracking
  • REPL
• Predictable memory ownership
• Debuggability over cleverness

---

Project Structure

.
├── include
│   ├── ansi-colors.h
│   ├── error.h
│   ├── interpretator.h
│   ├── lexer.h
│   ├── node.h
│   ├── object.h
│   ├── parser.h
│   ├── position.h
│   ├── repl
│   │   ├── help.h
│   │   ├── input.h
│   │   ├── printast.h
│   │   └── repl.h
│   ├── symbol-table.h
│   ├── token.h
│   └── utils.h
├── LICENSE
├── makefile
├── README.md
└── src
    ├── error.c
    ├── interpretator.c
    ├── lexer.c
    ├── node.c
    ├── object.c
    ├── objects
    │   ├── list.c
    │   ├── number.c
    │   └── string.c
    ├── parser.c
    ├── position.c
    ├── repl
    │   ├── help.c
    │   ├── input.c
    │   ├── main.c
    │   └── printast.c
    ├── symbol-table.c
    ├── token.c
    └── utils.c

---

Build

Arc uses a makefile with several build targets:

• dev (default): Builds with optimizations disabled and debug symbols enabled.

  make dev
  # or simply
  make

• debug: Builds with AddressSanitizer and UndefinedBehaviorSanitizer for deep debugging.

  make debug

• release: Builds with full optimizations (-O3, -flto, -march=native) for maximum performance.

  make release

Run

Arc can be run using the arc command if installed, or via the local executable.

arc
# or
./arc

Options

• Debug mode:

  arc -d
  # or
  arc --debug

• Float precision:

  arc -p 10
  # or
  arc --float-precision 10

• Execute code:

  arc -c "5 + 5"
  # or
  arc --code "VAR x = 10"

• Disable colors:

  arc -n
  # or
  arc --disable-colored-formatting

• Run a file:

  arc script.arc

Install

The install target builds the release version and installs it to /usr/bin (by default).

sudo make install

You can also install specific versions:

sudo make dev-install
sudo make debug-install
sudo make release-install

Uninstall

sudo make uninstall

---

Memory Safety

Arc is regularly tested with Valgrind to ensure:

• No memory leaks
• No invalid reads or writes
• Clear and consistent ownership rules

valgrind --leak-check=full --show-leak-kinds=all arc

---

Roadmap

• Lexer
• Token system
• REPL
• Error reporting with position tracking
• Parser (AST generation)
• Expression evaluation
• Variables and identifiers
• String literals
• Comparison and Logical operators
• IF, THEN, ELIF, ELSE statements
• WHILE loop
• Logical NOT operator
• Scoped environments
• Functions
• Native Functions support
• Basic runtime system
• Bytecode virtual machine (long-term goal)

---

Notes

Arc is still early in development. The current focus is correctness, memory safety, and building a solid foundation for parsing and evaluation before moving toward more advanced language features.

---

License

GPL-3.0