IncludeCPP 4.2.2__py3-none-any.whl → 4.5.2__py3-none-any.whl

includecpp/core/cssl/cpp/cssl_core.cp

@@ -0,0 +1,108 @@
+SOURCE(include/cssl_core.cpp) cssl_core
+
+PUBLIC(
+    // Full Interpreter - Main Entry Point
+    cssl_core FUNC(run_cssl)
+    cssl_core FUNC(version)
+    cssl_core FUNC(is_keyword)
+
+    // Lexer & Token Classes
+    cssl_core CLASS(Lexer) {
+        CONSTRUCTOR(const std::string&)
+        METHOD(tokenize)
+    }
+    cssl_core CLASS(Token) {
+        CONSTRUCTOR()
+        CONSTRUCTOR(int, int, int)
+        CONSTRUCTOR(int, const std::string&, int, int)
+        CONSTRUCTOR(int, double, int, int)
+        CONSTRUCTOR(int, bool, int, int)
+        FIELD(type)
+        FIELD(str_value)
+        FIELD(num_value)
+        FIELD(bool_value)
+        FIELD(value_type)
+        FIELD(line)
+        FIELD(column)
+    }
+
+    // Full Interpreter Class
+    cssl_core CLASS(Interpreter) {
+        CONSTRUCTOR()
+        METHOD(run)
+        METHOD(run_string)
+    }
+
+    // Value Class (for advanced usage)
+    cssl_core CLASS(Value) {
+        CONSTRUCTOR()
+        CONSTRUCTOR(bool)
+        CONSTRUCTOR(int64_t)
+        CONSTRUCTOR(double)
+        CONSTRUCTOR(const std::string&)
+        METHOD_CONST(as_bool)
+        METHOD_CONST(as_float)
+        METHOD_CONST(as_int)
+        METHOD_CONST(as_string)
+        METHOD_CONST(get_type)
+        METHOD_CONST(is_bool)
+        METHOD_CONST(is_dict)
+        METHOD_CONST(is_float)
+        METHOD_CONST(is_int)
+        METHOD_CONST(is_list)
+        METHOD_CONST(is_null)
+        METHOD_CONST(is_number)
+        METHOD_CONST(is_string)
+        METHOD_CONST(to_bool)
+        METHOD_CONST(to_string)
+    }
+
+    // String Operations
+    cssl_core FUNC(str_concat)
+    cssl_core FUNC(str_contains)
+    cssl_core FUNC(str_join)
+    cssl_core FUNC(str_lower)
+    cssl_core FUNC(str_replace)
+    cssl_core FUNC(str_split)
+    cssl_core FUNC(str_trim)
+    cssl_core FUNC(str_upper)
+    cssl_core FUNC(str_reverse)
+    cssl_core FUNC(str_len)
+    cssl_core FUNC(str_repeat)
+    cssl_core FUNC(str_startswith)
+    cssl_core FUNC(str_endswith)
+    cssl_core FUNC(str_indexof)
+    cssl_core FUNC(str_substr)
+    cssl_core FUNC(str_cmp)
+
+    // Math Operations
+    cssl_core FUNC(math_clamp)
+    cssl_core FUNC(math_ipow)
+    cssl_core FUNC(math_pow)
+    cssl_core FUNC(math_mod)
+    cssl_core FUNC(math_abs)
+    cssl_core FUNC(math_min)
+    cssl_core FUNC(math_max)
+    cssl_core FUNC(math_floor)
+    cssl_core FUNC(math_ceil)
+
+    // Array Operations
+    cssl_core FUNC(array_sum)
+    cssl_core FUNC(array_isum)
+    cssl_core FUNC(array_avg)
+    cssl_core FUNC(array_min)
+    cssl_core FUNC(array_max)
+    cssl_core FUNC(range)
+
+    // Loop Helpers
+    cssl_core FUNC(loop_check_lt)
+    cssl_core FUNC(loop_check_le)
+    cssl_core FUNC(loop_check_gt)
+    cssl_core FUNC(loop_check_ge)
+
+    // Comparison Helpers
+    cssl_core FUNC(num_cmp)
+    cssl_core FUNC(eq_int)
+    cssl_core FUNC(eq_float)
+    cssl_core FUNC(eq_str)
+)

includecpp/core/cssl/cpp/cssl_lexer.hpp

@@ -0,0 +1,280 @@
+/**
+ * CSSL Lexer - High-performance tokenizer for CSSL language
+ *
+ * Part of IncludeCPP's self-hosting optimization strategy.
+ * This C++ implementation provides 10-20x speedup over Python.
+ *
+ * Copyright (c) 2024-2026 Lilias Hatterscheidt
+ * Licensed under MIT License
+ */
+
+#pragma once
+
+#include <string>
+#include <string_view>
+#include <vector>
+#include <variant>
+#include <unordered_set>
+#include <cstdint>
+#include <stdexcept>
+
+namespace cssl {
+
+/**
+ * Token types matching Python cssl_parser.py TokenType enum
+ */
+enum class TokenType {
+    // Basic types
+    KEYWORD,
+    IDENTIFIER,
+    STRING,
+    STRING_INTERP,      // <variable> in strings
+    NUMBER,
+    BOOLEAN,
+    NULL_T,
+    TYPE_LITERAL,       // list, dict as type literals
+    TYPE_GENERIC,       // datastruct<T>, shuffled<T>, etc.
+
+    // Injection operators
+    INJECT_LEFT,        // <==
+    INJECT_RIGHT,       // ==>
+    INJECT_PLUS_LEFT,   // +<==
+    INJECT_PLUS_RIGHT,  // ==>+
+    INJECT_MINUS_LEFT,  // -<==
+    INJECT_MINUS_RIGHT, // ===>-
+
+    // Code Infusion operators
+    INFUSE_LEFT,        // <<==
+    INFUSE_RIGHT,       // ==>>
+    INFUSE_PLUS_LEFT,   // +<<==
+    INFUSE_PLUS_RIGHT,  // ==>>+
+    INFUSE_MINUS_LEFT,  // -<<==
+    INFUSE_MINUS_RIGHT, // ==>>-
+
+    // Flow operators
+    FLOW_RIGHT,         // ->
+    FLOW_LEFT,          // <-
+
+    // Assignment and comparison
+    EQUALS,             // =
+    COMPARE_EQ,         // ==
+    COMPARE_NE,         // !=
+    COMPARE_LT,         // <
+    COMPARE_GT,         // >
+    COMPARE_LE,         // <=
+    COMPARE_GE,         // >=
+
+    // Arithmetic
+    PLUS,               // +
+    MINUS,              // -
+    MULTIPLY,           // *
+    DIVIDE,             // /
+    MODULO,             // %
+
+    // Logical
+    AND,                // && or 'and'
+    OR,                 // || or 'or'
+    NOT,                // ! or 'not'
+    AMPERSAND,          // & (reference/bitwise)
+
+    // Delimiters
+    BLOCK_START,        // {
+    BLOCK_END,          // }
+    PAREN_START,        // (
+    PAREN_END,          // )
+    BRACKET_START,      // [
+    BRACKET_END,        // ]
+    SEMICOLON,          // ;
+    COLON,              // :
+    DOUBLE_COLON,       // ::
+    COMMA,              // ,
+    DOT,                // .
+
+    // References
+    AT,                 // @
+    GLOBAL_REF,         // r@name
+    SELF_REF,           // s@name
+    SHARED_REF,         // $name
+    CAPTURED_REF,       // %name
+    THIS_REF,           // this->
+
+    // Package/module
+    PACKAGE,
+    PACKAGE_INCLUDES,
+    AS,
+
+    // Special
+    COMMENT,
+    NEWLINE,
+    EOF_T,
+
+    // Super-functions (payload files)
+    SUPER_FUNC,         // #$run(), #$exec(), etc.
+
+    // Append/extension operators
+    PLUS_PLUS,          // ++ (constructor/function extension)
+    MINUS_MINUS,        // --
+
+    // Multi-language support
+    LANG_INSTANCE_REF   // cpp$InstanceName, py$Object
+};
+
+/**
+ * Token value - can hold string, number, or boolean
+ */
+using TokenValue = std::variant<std::monostate, std::string, double, bool>;
+
+/**
+ * Token structure
+ */
+struct Token {
+    TokenType type;
+    TokenValue value;
+    uint32_t line;
+    uint32_t column;
+
+    // Convenience getters
+    bool has_string() const { return std::holds_alternative<std::string>(value); }
+    bool has_number() const { return std::holds_alternative<double>(value); }
+    bool has_bool() const { return std::holds_alternative<bool>(value); }
+
+    const std::string& as_string() const { return std::get<std::string>(value); }
+    double as_number() const { return std::get<double>(value); }
+    bool as_bool() const { return std::get<bool>(value); }
+};
+
+/**
+ * Lexer error with source location
+ */
+class LexerError : public std::runtime_error {
+public:
+    LexerError(const std::string& message, uint32_t line, uint32_t column,
+               const std::string& source_line = "")
+        : std::runtime_error(build_message(message, line, column, source_line)),
+          line_(line), column_(column) {}
+
+    uint32_t line() const { return line_; }
+    uint32_t column() const { return column_; }
+
+private:
+    uint32_t line_;
+    uint32_t column_;
+
+    static std::string build_message(const std::string& msg, uint32_t line, uint32_t col,
+                                     const std::string& src_line) {
+        std::string result = "CSSL Lexer Error at line " + std::to_string(line) +
+                            ", column " + std::to_string(col) + ": " + msg;
+        if (!src_line.empty()) {
+            result += "\n  " + src_line;
+            if (col > 0) {
+                result += "\n  " + std::string(col - 1, ' ') + "^";
+            }
+        }
+        return result;
+    }
+};
+
+/**
+ * High-performance CSSL Lexer
+ *
+ * Converts CSSL source code into a vector of tokens.
+ * Optimized for speed with minimal allocations.
+ */
+class Lexer {
+public:
+    /**
+     * Construct lexer with source code
+     * @param source CSSL source code (must remain valid during tokenization)
+     */
+    explicit Lexer(std::string_view source);
+
+    /**
+     * Tokenize entire source and return all tokens
+     * @return Vector of tokens including EOF token at end
+     */
+    std::vector<Token> tokenize();
+
+    /**
+     * Get next token (streaming mode)
+     * @return Next token, EOF_T when done
+     */
+    Token next_token();
+
+    /**
+     * Check if more tokens available
+     */
+    bool has_more() const { return pos_ < source_.size(); }
+
+    /**
+     * Reset lexer to beginning
+     */
+    void reset();
+
+private:
+    std::string_view source_;
+    size_t pos_ = 0;
+    uint32_t line_ = 1;
+    uint32_t column_ = 1;
+
+    // Current character helpers
+    char current() const;
+    char peek(size_t offset = 1) const;
+    void advance(size_t count = 1);
+    bool at_end() const { return pos_ >= source_.size(); }
+
+    // Whitespace and comment handling
+    void skip_whitespace();
+    void skip_comment();
+    void skip_block_comment();
+
+    // Token readers
+    Token read_string(char quote);
+    Token read_raw_string();
+    Token read_number();
+    Token read_identifier();
+    Token read_operator();
+
+    // Special token readers
+    Token read_super_function();
+    Token read_global_ref();
+    Token read_self_ref();
+    Token read_shared_ref();
+    Token read_captured_ref();
+
+    // Operator readers
+    Token read_less_than();
+    Token read_greater_than();
+    Token read_equals();
+    Token read_not();
+    Token read_minus();
+    Token read_plus();
+
+    // Token creation helpers
+    Token make_token(TokenType type, TokenValue value = {}) const;
+
+    // Error helper
+    [[noreturn]] void error(const std::string& message) const;
+
+    // Static keyword sets (initialized once)
+    static const std::unordered_set<std::string> keywords_;
+    static const std::unordered_set<std::string> type_literals_;
+    static const std::unordered_set<std::string> type_generics_;
+    static const std::unordered_set<std::string> language_ids_;
+};
+
+/**
+ * Utility function: Tokenize source code
+ * @param source CSSL source code
+ * @return Vector of tokens
+ */
+inline std::vector<Token> tokenize(const std::string& source) {
+    Lexer lexer(source);
+    return lexer.tokenize();
+}
+
+/**
+ * Get string representation of token type
+ */
+const char* token_type_name(TokenType type);
+
+} // namespace cssl