JeanCodeVanDamme Language Extension

Welcome to the JeanCodeVanDamme language extension for Visual Studio Code! This extension brings syntax highlighting, custom operators, and a uniquely French-inspired programming language experience directly to your editor.

Features

✨ Syntax Highlighting
Experience vibrant and intuitive syntax highlighting for the JeanCodeVanDamme language, including support for:

• Custom keywords like si, sinon, alors, and fonction.
• Operators such as rajoute-moi, multiplie grave par, and devient.
• Strings, numbers, booleans, and types like entier, chaine, and booleen.
• Commenting with #.

✨ Readable and Fun Syntax
Inspired by French, the syntax of JeanCodeVanDamme is designed to be both elegant and humorous, making coding a joyful experience.

✨ Comprehensive Grammar Support
Supports functions, conditionals, arithmetic, and pattern matching, all written in clear and expressive French-inspired terms.

✨ Easy-to-Use
Just open a .jcvd file, and you're ready to code in the JeanCodeVanDamme language!

Installation

1. Download and install Visual Studio Code.
2. Open the Extensions view (Ctrl+Shift+X).
3. Search for JeanCodeVanDamme.
4. Click Install.
5. Open any .jcvd file and enjoy!

Getting Started

Example Code

Language Keywords

Standard Operators

Language Functionalities

The language supports the following functionalities:

• Variables: Variables can be defined using the definir keyword. Example:

fonction x {
    definir x devient 5
}

• Data Types: The language supports data types such as characters, string, integers, floating-point numbers, strings, tuples, and booleans. Example:

fonction caractere {
    definir x devient 'a'
}

fonction entier {
    definir x devient 5
}

fonction flottant {
    definir x devient 5.5
}

fonction chaine {
    definir x devient "Bonjour"
}

fonction tuple() {
    retourner (tuple 1, 2, 3)
}

fonction booleen {
    definir x devient Vrai
}

caractere()
entier()
flottant()
chaine()
tuple()
booleen()

• Functions: Functions can be defined using the fonction keyword. Example:

fonction ajouter(x, y) {
    retourner x rajoute-moi y
}

• Conditional Statements: Conditional statements can be defined using the si, sinon, and alors keywords. Example:

fonction fibonacci(n) {
    si (n est-bien 0) {
        retourner 0
    } sinon si (n est-bien 1) {
        retourner 1
    } sinon {
        retourner fibonacci(n soustrait-moi 1) ajoute-moi fibonacci(n soustrait-moi 2)
    }
}

fibonacci(10)

• Recursion: Recursion can be used to define functions that call themselves. Example:

fonction boucle(n) {
    si (n est-bien 0) {
        retourner
    } sinon {
        afficher(n)
        boucle(n soustrait-moi 1)
    }
}

• Addition, Subtraction, Multiplication, and Division: Arithmetic operations can be performed using the rajoute-moi, soustrait-moi, multiplie-grave-par, and divise-pepere-par operators. Example:

fonction addition(x, y) {
    retourner x rajoute-moi y
}

fonction soustraction(x, y) {
    retourner x soustrait-moi y
}

fonction multiplication(x, y) {
    retourner x multiplie-grave-par y
}

fonction division(x, y) {
    retourner x divise-pepere-par y
}

addition(5, 10)
soustraction(10, 5)
multiplication(5, 10)
division(10, 5)

• Modulo Operator: The modulo operator can be used to calculate the remainder of a division. Example:

fonction modulo(x, y) {
    retourner x modulo-moi y
}

modulo(10, 3)

• Standard Operators: Standard operators such as est-bien, est-carrément-pas, plus-riquiqui-que, plus-gros-que, au-pire, au-mieux, et-aussi, and ou-au-pire can be used for comparisons. Example:

fonction auMieux() {
    definir k devient 11
    retourner k au-mieux 10
}

fonction etAussi() {
    retourner Vrai et-aussi Vrai
}

fonction auPire() {
    definir k devient 9
    retourner k au-pire 10
}

auMieux()
etAussi()
auPire()

• Calling functions: Functions can be called by using the function name followed by parentheses. Example:

fonction double() {
    definir k devient 10
    retourner k multiplie-grave-par 2
}

fonction callFunction() {
    retourner double()
}

callFunction()

Requirements

No additional requirements or dependencies are needed. Just install and start coding!

Extension Settings

This extension does not require additional configuration. However, future updates may include customizable settings for:

• Theme-specific adjustments.
• Language-specific configurations.

Known Issues

• Theme Dependency: Syntax highlighting may vary slightly depending on your selected VS Code theme. For the best experience, use a theme like Dark Modern.

If you encounter any other issues, feel free to open an issue on the GitHub repository.

Release Notes

1.0.0

• Initial release with full syntax highlighting support for JeanCodeVanDamme language.

1.1.0

• Added custom colors for operators like devient.
• Enhanced grammar support for more constructs.

For more information

• Learn more about the JeanCodeVanDamme language here.
• Explore more about creating VS Code extensions in the official documentation.

Enjoy coding in JeanCodeVanDamme! Vive la programmation ! 🎉