gtcaca 0.0.2__tar.gz

gtcaca-0.0.2/.github/workflows/release.yml

@@ -0,0 +1,111 @@
+name: Build & publish wheels
+
+# Wheels are built on every push/PR to catch breakage early, but only
+# *published* to PyPI when you push a version tag like `v0.1.0`.
+on:
+  push:
+    branches: [master]
+    tags: ["v*"]
+  pull_request:
+  workflow_dispatch:
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  build_wheels:
+    name: wheels · ${{ matrix.name }}
+    runs-on: ${{ matrix.runner }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - { name: linux-x86_64,  runner: ubuntu-latest,    archs: x86_64 }
+          - { name: linux-aarch64, runner: ubuntu-24.04-arm, archs: aarch64 }
+          - { name: macos-arm64,   runner: macos-14,         archs: arm64 }
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0          # setuptools-scm needs full history/tags
+
+      - name: Build wheels
+        uses: pypa/cibuildwheel@v2.23.3
+        env:
+          CIBW_ARCHS: ${{ matrix.archs }}
+        # All other config lives in [tool.cibuildwheel] in pyproject.toml.
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: wheels-${{ matrix.name }}
+          path: ./wheelhouse/*.whl
+
+  # Windows x86_64 is experimental: libcaca has no MSVC build, so we cross-build
+  # it with MSYS2/mingw-w64 and link the MSVC extension against a generated
+  # import lib. continue-on-error keeps a broken Windows build from blocking the
+  # Linux/macOS release; its wheel still publishes when the job goes green.
+  build_wheels_windows:
+    name: wheels · win-amd64 (experimental)
+    runs-on: windows-latest
+    continue-on-error: true
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - uses: msys2/setup-msys2@v2
+        with:
+          msystem: MINGW64
+          update: true
+          install: >-
+            base-devel autoconf automake libtool make tar
+            mingw-w64-x86_64-gcc
+            mingw-w64-x86_64-pkgconf mingw-w64-x86_64-tools-git
+
+      - name: Build libcaca (mingw) + MSVC import lib
+        shell: msys2 {0}
+        run: CACA_ROOT=C:/caca-dist bash scripts/ci/build-libcaca-win.sh
+
+      - name: Build wheels
+        uses: pypa/cibuildwheel@v2.23.3
+        env:
+          CIBW_ARCHS: AMD64
+          CIBW_ENVIRONMENT_WINDOWS: CACA_ROOT=C:/caca-dist
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: wheels-win-amd64
+          path: ./wheelhouse/*.whl
+
+  build_sdist:
+    name: sdist
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - name: Build sdist
+        run: pipx run build --sdist
+      - uses: actions/upload-artifact@v4
+        with:
+          name: sdist
+          path: ./dist/*.tar.gz
+
+  publish:
+    name: publish to PyPI
+    needs: [build_wheels, build_wheels_windows, build_sdist]
+    runs-on: ubuntu-latest
+    # Only on a version tag.
+    if: github.event_name == 'push' && startsWith(github.ref, 'refs/tags/v')
+    environment:
+      name: pypi
+      url: https://pypi.org/p/gtcaca
+    permissions:
+      id-token: write            # OIDC token for PyPI Trusted Publishing
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          path: dist
+          pattern: "*"
+          merge-multiple: true   # collect all wheels + the sdist into dist/
+      - uses: pypa/gh-action-pypi-publish@release/v1

gtcaca-0.0.2/.gitignore

@@ -0,0 +1,10 @@
+*~
+build/*
+
+# Python packaging artifacts
+dist/
+wheelhouse/
+*.egg-info/
+__pycache__/
+*.so
+.DS_Store

gtcaca-0.0.2/CMakeLists.txt

@@ -0,0 +1,149 @@
+cmake_minimum_required(VERSION 3.20)
+
+# Detect the actual macOS SDK path before project() initialises the toolchain,
+# so CMake never warns about a stale/missing CMAKE_OSX_SYSROOT value.
+if(APPLE)
+  execute_process(
+    COMMAND xcrun --show-sdk-path
+    OUTPUT_VARIABLE _detected_sysroot
+    OUTPUT_STRIP_TRAILING_WHITESPACE
+    ERROR_QUIET
+  )
+  if(_detected_sysroot)
+    set(CMAKE_OSX_SYSROOT "${_detected_sysroot}" CACHE PATH "macOS SDK path" FORCE)
+  endif()
+endif()
+
+project(gtcaca-project)
+
+message("CMake system name: ${CMAKE_SYSTEM_NAME}")
+
+if(${CMAKE_CURRENT_SOURCE_DIR} STREQUAL ${CMAKE_CURRENT_BINARY_DIR})
+message(FATAL_ERROR "CMake generation is not allowed within the source directory!
+Remove the CMakeCache.txt file and try again from another folder, e.g.:
+
+   rm CMakeCache.txt
+   mkdir build
+   cd build
+   cmake ..
+")
+endif()
+
+set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${gtcaca-project_SOURCE_DIR}/cmake)
+
+include(GNUInstallDirs)
+
+if(APPLE)
+  set(CMAKE_MACOSX_RPATH ON)
+  set(CMAKE_BUILD_RPATH "${CMAKE_BINARY_DIR}/src")
+endif()
+
+#set(CMAKE_BUILD_TYPE "Release")
+set(CMAKE_BUILD_TYPE "Debug")
+
+set(GTCACA_VERSION "0.0.0")
+
+include(FindPkgConfig)
+configure_file("${gtcaca-project_SOURCE_DIR}/gtcaca.pc.cmake" "${gtcaca-project_BINARY_DIR}/gtcaca.pc")
+message("pkg config path:${PKG_CONFIG_PATH}")
+install(FILES "${gtcaca-project_BINARY_DIR}/gtcaca.pc" DESTINATION "${CMAKE_INSTALL_LIBDIR}/pkgconfig" COMPONENT Headers)
+
+if (DEBUG_MODE)
+add_definitions(-DGTCACA_DEBUG=1)
+set(CMAKE_BUILD_TYPE "Debug")
+        if(NOT WIN32)
+                add_definitions(-g)
+        endif()
+else()
+        if(NOT WIN32)
+                add_definitions(-O3)
+        endif()
+endif()
+if (NOT WIN32)
+	add_definitions(-std=c99 -fPIC)
+endif()
+
+include(CTest)
+
+include(CheckIncludeFiles)
+include(CheckFunctionExists)
+include(CheckLibraryExists)
+
+include(GNUInstallDirs)
+
+include(TestBigEndian)
+TEST_BIG_ENDIAN(BIGENDIAN)
+if (${BIGENDIAN})
+  add_definitions(-DHAVE_LITTLE_ENDIAN=0)
+  add_definitions(-DHAVE_BIG_ENDIAN=1)
+else()
+  add_definitions(-DHAVE_LITTLE_ENDIAN=1)
+  add_definitions(-DHAVE_BIG_ENDIAN=0)
+endif()
+
+pkg_check_modules(LIBCACA REQUIRED caca)
+message("libcaca link library: ${LIBCACA_LDFLAGS}")
+
+# Oniguruma (optional): enables TextMate grammar (.tmLanguage.json) colourization.
+pkg_check_modules(ONIG oniguruma)
+if(ONIG_FOUND)
+  message("oniguruma found: ${ONIG_LDFLAGS}")
+  add_compile_definitions(GTCACA_HAVE_ONIG=1)
+endif()
+
+message("CMake system: ${CMAKE_SYSTEM_NAME}")
+# Mac OS Specifics
+if(${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
+  add_definitions(-DMACOS=1)
+endif()
+
+if(${CMAKE_SYSTEM_NAME} MATCHES "WIN32")
+  add_definitions(-DWIN32=1)
+endif()
+
+if(${CMAKE_SYSTEM_NAME} MATCHES "Linux")
+  add_definitions(-DLINUX=1)
+  set(GTCACA_LINK_LIBRARIES pthread m)
+endif()
+
+set(GTCACA_INCLUDE_DIRS "${gtcaca-project_SOURCE_DIR}/src/include/" "${gtcaca-project_BINARY_DIR}/src/include")
+
+set(GTCACA_LIBRARY gtcaca)
+if(WIN32)
+	set(GTCACA_LIBRARY "${gtcaca-project_BINARY_DIR}/src/${CMAKE_BUILD_TYPE}/gtcaca_static.lib")
+endif(WIN32)
+if(APPLE)
+	set(GTCACA_LIBRARY "${gtcaca-project_BINARY_DIR}/src/libgtcaca.dylib")
+endif(APPLE)
+
+# Set our env variables
+set(GTCACA_DATA_DIR "${CMAKE_INSTALL_PREFIX}/share/gtcaca/")
+add_definitions(-DGTCACA_DATA_DIR="${GTCACA_DATA_DIR}")
+
+add_subdirectory(src)
+add_subdirectory(demo)
+add_subdirectory(apps)
+
+# Theme data (so installed apps find their default theme rather than falling
+# back to the built-in defaults with a warning).
+install(FILES "${gtcaca-project_SOURCE_DIR}/themes/default"
+        DESTINATION "${CMAKE_INSTALL_DATADIR}/gtcaca/themes" COMPONENT Applications)
+
+# ── packaging: `make package` ────────────────────────────────────────────────
+#   macOS : a productbuild .pkg INSTALLER that installs gtcaca + the apps under
+#           /usr/local (so cacamacs/cacasheet/rfmind/rtodo are on $PATH).
+#   else  : a .tar.gz of the same tree.
+set(CPACK_PACKAGE_NAME "gtcaca")
+set(CPACK_PACKAGE_VENDOR "gtcaca")
+set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "gtcaca libcaca TUI toolkit and apps (cacamacs, cacasheet, rfmind, rtodo)")
+set(CPACK_PACKAGE_VERSION "${GTCACA_VERSION}")
+set(CPACK_PACKAGE_FILE_NAME "gtcaca-${GTCACA_VERSION}-${CMAKE_SYSTEM_NAME}")
+# install everything in one shot rather than offering per-component choices
+set(CPACK_COMPONENTS_GROUPING "ALL_COMPONENTS_IN_ONE")
+if(APPLE)
+  set(CPACK_GENERATOR "productbuild")
+  set(CPACK_PACKAGING_INSTALL_PREFIX "/usr/local")
+else()
+  set(CPACK_GENERATOR "TGZ")
+endif()
+include(CPack)

gtcaca-0.0.2/PKG-INFO

@@ -0,0 +1,132 @@
+Metadata-Version: 2.2
+Name: gtcaca
+Version: 0.0.2
+Summary: Python bindings for GTCaca, a libcaca-based terminal UI toolkit
+Keywords: tui,libcaca,terminal,ui,ncurses,widgets
+Author-Email: Seb Tricaud <sebastien.tricaud@proton.me>
+License: Public Domain
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console :: Curses
+Classifier: License :: Public Domain
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: C
+Classifier: Topic :: Software Development :: User Interfaces
+Project-URL: Homepage, https://github.com/stricaud/gtcaca
+Project-URL: Repository, https://github.com/stricaud/gtcaca
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# GTCaca Python bindings
+
+[pybind11](https://pybind11.readthedocs.io/) bindings for **GTCaca**, the
+libcaca-based terminal UI toolkit in this repository.
+
+The bindings compile the GTCaca C sources directly into the extension module,
+so the only external runtime dependency is **libcaca** itself — no separately
+installed `libgtcaca` is required.
+
+## Requirements
+
+- A C/C++ toolchain and CMake ≥ 3.20
+- `libcaca` with its development headers, discoverable via `pkg-config`
+  (`pkg-config --exists caca` should succeed)
+- Python ≥ 3.8 and `pybind11`
+- *(optional)* `oniguruma` — not needed; only the editor widget uses it and it
+  is not exposed here
+
+## Install
+
+From this directory (`src/bindings/python`):
+
+```sh
+pip install .
+```
+
+This uses [scikit-build-core](https://scikit-build-core.readthedocs.io/) to drive
+CMake and produces an importable `gtcaca` package.
+
+### Building in-tree without installing
+
+```sh
+cmake -S . -B build \
+  -Dpybind11_DIR="$(python -m pybind11 --cmakedir)"
+cmake --build build -j
+# the compiled _gtcaca*.so lands in build/; add it to PYTHONPATH or copy it
+# next to the gtcaca/ package directory.
+```
+
+## Usage
+
+```python
+import gtcaca as gt
+
+gt.init()
+gt.application_new("Hello")
+win = gt.window_new(None, "Demo", 0, 1, 40, 10)
+gt.label_new(win, "Press q to quit", 2, 2)
+
+btn = gt.button_new(win, "  OK  ", 2, 4)
+def on_key(key):
+    if key == gt.KEY_RETURN:
+        gt.main_quit()
+    return 0          # 0 = event not consumed
+btn.on_key(on_key)
+
+win.set_focus()
+gt.main()             # blocking event loop
+```
+
+See [`example.py`](example.py) for a fuller form with a menu, entries,
+checkbox, progress bar and status bar.
+
+## API overview
+
+Factory functions create widgets and return widget objects; the first argument
+is the parent (a widget object, or `None` for top-level / canvas-anchored
+widgets):
+
+| Factory | Returns | Key methods |
+| --- | --- | --- |
+| `init()`, `main()`, `main_quit()`, `redraw()` | — | lifecycle |
+| `canvas_width()`, `canvas_height()` | `int` | canvas size in cells |
+| `application_new(title)` | `Application` | `draw()` |
+| `window_new(parent, title, x, y, w, h)` | `Window` | `set_focus`, `set_focused_child`, `set_default`, `focus_next_child`, `close` |
+| `window_new_centered(parent, title, w, h)` | `Window` | — |
+| `label_new(parent, text, x, y)` | `Label` | — |
+| `button_new(parent, label, x, y)` | `Button` | `on_key(cb)` |
+| `entry_new(parent, x, y, w)` | `Entry` | `get_text`, `set_text`, `set_secret`, `on_key` |
+| `checkbox_new(parent, label, x, y)` | `Checkbox` | `get_checked`, `set_checked`, `on_key` |
+| `radiobutton_new(parent, label, group_id, x, y)` | `RadioButton` | `get_active`, `set_active`, `on_key` |
+| `combobox_new(parent, x, y, w)` | `ComboBox` | `append`, `get_selected`, `get_selected_index`, `on_key` |
+| `progressbar_new(parent, x, y, w)` | `ProgressBar` | `set_value`, `get_value` |
+| `textview_new(parent, x, y, w, h)` | `TextView` | `append`, `clear`, `set_mode`, `on_key` |
+| `statusbar_new(text)` | `StatusBar` | `set_text`, `set_rows_from_bottom` |
+| `menu_new()` | `Menu` | `add_entry`, `add_item`, `add_separator`, `handle_key` |
+
+Every widget exposes the shared preamble (`x`, `y`, `width`, `height`,
+`has_focus`, `is_visible`, `id`) plus `show()`, `hide()`, and `as_widget()`
+(used internally for parent passing).
+
+### Callbacks
+
+- **Key callbacks** (`on_key`) receive the integer key and may return an `int`
+  (`0` = not consumed, the default if you return `None`). Key constants are
+  exposed as module attributes: `KEY_RETURN`, `KEY_ESCAPE`, `KEY_TAB`,
+  `KEY_UP`/`KEY_DOWN`/`KEY_LEFT`/`KEY_RIGHT`, `KEY_F1`, `KEY_F10`, etc.
+- **Menu actions** (the last argument to `menu.add_item`) take no arguments.
+- Exceptions raised inside a callback are reported via `sys.unraisablehook`
+  and do not abort the event loop.
+
+The GIL is released while `gt.main()` runs and re-acquired inside every
+callback, so callbacks can safely touch other Python state.
+
+## Scope
+
+The toolkit ships ~40 widgets; these bindings currently cover the core
+lifecycle plus the widgets used in the C demo (`demo/demo.c`). Additional
+widgets (tree, table, tabs, calendar, charts, editor, hexview, …) follow the
+exact same pattern in [`gtcaca_module.cpp`](gtcaca_module.cpp) — bind the struct
+with `bind_common`, add a `*_new` factory with a `return_value_policy::reference`,
+and wire any callback through the shared trampoline.

gtcaca-0.0.2/README.md

@@ -0,0 +1,120 @@
+# GTcaca
+
+Graphical Toolkit on top of libcaca.
+
+It allows you to use widgets and have an amazing interface using code like this:
+
+    #include <gtcaca/main.h>
+    #include <gtcaca/window.h>
+    
+    int main(int argc, char **argv)
+    {
+      gtcaca_init(&argc, &argv);
+    
+      gtcaca_window_new("My first window", 1, 1, 50, 20);
+
+      gtcaca_main();
+      return 0;
+    }
+
+
+Which will make the following:
+
+<p align="center"><img src="docs/firstwindow.png"/></p>
+
+## Text List widget
+
+This code:
+
+    #include <gtcaca/main.h>
+    #include <gtcaca/window.h>
+    #include <gtcaca/textlist.h>
+    
+    int textlist_key_press(gtcaca_textlist_widget_t *widget, int key, void *userdata)
+    {
+      switch(key) {
+      case CACA_KEY_RETURN:
+        caca_printf(gmo.cv, widget->x, widget->y + 20, "Value:%s", gtcaca_textlist_get_selected(widget));
+        break;
+      }
+    }
+    
+    int main(int argc, char **argv)
+    {
+      gtcaca_textlist_widget_t *textlist;
+      
+      gtcaca_init(&argc, &argv);
+    
+      gtcaca_window_new("coucou", 1, 1, 50, 20);
+    
+      textlist = gtcaca_textlist_new(2, 2);
+      gtcaca_textlist_append(textlist, "myfirst");
+      gtcaca_textlist_append(textlist, "mysecond");
+      gtcaca_textlist_append(textlist, "mythird");
+    
+      gtcaca_textlist_key_cb_register(textlist, textlist_key_press);
+      
+      gtcaca_main();
+      return 0;
+    }
+
+Which will make this:
+
+<p align="center"><img src="docs/textlistcb.png"/></p>
+
+When the user pressed the RETURN key, we printed the value of the selection.
+
+## Widgets
+
+### Application
+
+This is a special widget, describing your application to which you can attach the other widgets.
+
+### Text List
+
+Choose-able list
+
+### Button
+
+Button
+
+### Label
+
+Label
+
+### Window
+
+A Window.
+
+### Editor
+
+A multi-line text-editing widget: caret/selection, undo/redo, scrolling, syntax
+colourization (VSCode language configs, TextMate `.tmLanguage.json` grammars via
+Oniguruma, and a built-in JSON mode), autocompletion, folding, annotations and
+Scintilla-style search/replace. See [docs/editor.md](docs/editor.md). The
+[cacamacs](apps/cacamacs.c) app ([docs/cacamacs.md](docs/cacamacs.md)) is an
+Emacs-keybinding editor built on it, reusing installed VSCode extensions for
+language support.
+
+## Layout (vbox / hbox)
+
+Widgets can be placed by hand (explicit `x, y` in every constructor) or arranged
+automatically with vertical/horizontal box layouts, à la Qt's `QVBoxLayout` /
+`QHBoxLayout`:
+
+    #include <gtcaca/box.h>
+
+    gtcaca_box_t *vb = gtcaca_vbox_new();
+    gtcaca_box_add(vb, GTCACA_WIDGET(label));
+    gtcaca_box_add(vb, GTCACA_WIDGET(entry));
+    gtcaca_box_add(vb, GTCACA_WIDGET(button));
+    gtcaca_box_apply_window(vb, win);   /* compute positions */
+    gtcaca_box_free(vb);
+
+See [docs/layout.md](docs/layout.md) for the full guide and
+[tests/simple_layout.c](tests/simple_layout.c) for a runnable demo.
+
+
+# License
+
+This is released under public domain.

gtcaca-0.0.2/demo.sh

@@ -0,0 +1,32 @@
+#!/bin/sh
+#
+# Run a gtcaca demo against the freshly-built LOCAL library, not the (possibly
+# stale) system one in /usr/local/lib — the same fix as runccm.sh.
+#
+# Usage:  ./demo.sh <name> [args…]     e.g.  ./demo.sh gallery   ./demo.sh tabs
+#         BUILD=/path/to/build ./demo.sh …   to point at a different build dir
+set -e
+HERE="$(cd "$(dirname "$0")" && pwd)"
+BUILD="${BUILD:-$HERE/build}"
+
+list() {
+  echo "available demos:" >&2
+  ls "$BUILD/demo" 2>/dev/null | grep -E '^demo_' | sed 's/^demo_/  /' >&2
+}
+
+name="$1"
+if [ -z "$name" ]; then
+  echo "usage: ./demo.sh <name> [args…]   (runs build/demo/demo_<name> with the fresh lib)" >&2
+  list; exit 1
+fi
+shift
+
+bin="$BUILD/demo/demo_$name"
+[ -x "$bin" ] || bin="$BUILD/demo/$name"      # also accept the full "demo_xxx" name
+if [ ! -x "$bin" ]; then
+  echo "demo.sh: no demo '$name' in $BUILD/demo (build it first?)" >&2
+  list; exit 1
+fi
+
+# build/src first so the fresh libgtcaca wins; keep any existing path after it
+exec env DYLD_LIBRARY_PATH="$BUILD/src${DYLD_LIBRARY_PATH:+:$DYLD_LIBRARY_PATH}" "$bin" "$@"

gtcaca-0.0.2/examples/cacamacs-config.json

@@ -0,0 +1,12 @@
+{
+  "//": "Copy to ~/.cacamacs/config.json",
+  "tabSize": 4,
+  "insertSpaces": true,
+  "indentSize": 4,
+  "edgeColumn": 80,
+  "languages": {
+    ".py": { "tabSize": 4, "insertSpaces": true, "indentSize": 4 },
+    ".c":  { "insertSpaces": false, "tabSize": 8 },
+    ".md": { "insertSpaces": true, "indentSize": 2 }
+  }
+}

gtcaca-0.0.2/examples/cacamacs-extensions/c-lang-0.0.1/language-configuration.json

@@ -0,0 +1,27 @@
+{
+  // A standard VSCode language-configuration.json. cacamacs reads the parts it
+  // can colourize from: comment delimiters, brackets and auto-closing quotes.
+  "comments": {
+    "lineComment": "//",
+    "blockComment": ["/*", "*/"]
+  },
+  "brackets": [
+    ["{", "}"],
+    ["[", "]"],
+    ["(", ")"]
+  ],
+  "autoClosingPairs": [
+    { "open": "{", "close": "}" },
+    { "open": "[", "close": "]" },
+    { "open": "(", "close": ")" },
+    { "open": "\"", "close": "\"", "notIn": ["string"] },
+    { "open": "'", "close": "'", "notIn": ["string", "comment"] }
+  ],
+  "surroundingPairs": [
+    ["{", "}"],
+    ["[", "]"],
+    ["(", ")"],
+    ["\"", "\""],
+    ["'", "'"]
+  ]
+}

gtcaca-0.0.2/examples/cacamacs-extensions/c-lang-0.0.1/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "c-lang",
+  "displayName": "C/C++ Language Basics",
+  "version": "0.0.1",
+  "engines": { "cacamacs": "*" },
+  "contributes": {
+    "languages": [
+      {
+        "id": "c",
+        "aliases": ["C"],
+        "extensions": [".c", ".h"],
+        "configuration": "./language-configuration.json"
+      },
+      {
+        "id": "cpp",
+        "aliases": ["C++", "Cpp"],
+        "extensions": [".cpp", ".cc", ".hpp"],
+        "configuration": "./language-configuration.json"
+      }
+    ],
+    "grammars": [
+      {
+        "language": "c",
+        "scopeName": "source.c",
+        "path": "./syntaxes/c.tmLanguage.json"
+      }
+    ]
+  }
+}

gtcaca-0.0.2/examples/cacamacs-extensions/c-lang-0.0.1/syntaxes/c.tmLanguage.json

@@ -0,0 +1,44 @@
+{
+  "scopeName": "source.c",
+  "name": "C",
+  "patterns": [
+    { "include": "#comments" },
+    { "include": "#keywords" },
+    { "include": "#types" },
+    { "include": "#strings" },
+    { "include": "#numbers" },
+    { "include": "#preprocessor" }
+  ],
+  "repository": {
+    "comments": {
+      "patterns": [
+        { "name": "comment.line.double-slash.c", "match": "//.*$" },
+        { "name": "comment.block.c", "begin": "/\\*", "end": "\\*/" }
+      ]
+    },
+    "keywords": {
+      "name": "keyword.control.c",
+      "match": "\\b(if|else|for|while|do|switch|case|default|break|continue|return|goto|sizeof|typedef|struct|union|enum)\\b"
+    },
+    "types": {
+      "name": "storage.type.c",
+      "match": "\\b(void|char|short|int|long|float|double|signed|unsigned|const|static|extern|register|volatile|inline|bool|size_t)\\b"
+    },
+    "strings": {
+      "patterns": [
+        { "name": "string.quoted.double.c", "begin": "\"", "end": "\"",
+          "patterns": [ { "name": "constant.character.escape.c", "match": "\\\\." } ] },
+        { "name": "string.quoted.single.c", "begin": "'", "end": "'",
+          "patterns": [ { "name": "constant.character.escape.c", "match": "\\\\." } ] }
+      ]
+    },
+    "numbers": {
+      "name": "constant.numeric.c",
+      "match": "\\b(0[xX][0-9a-fA-F]+|[0-9]+(\\.[0-9]+)?([eE][-+]?[0-9]+)?[fFuUlL]*)\\b"
+    },
+    "preprocessor": {
+      "name": "keyword.control.directive.c",
+      "match": "^\\s*#\\s*(include|define|undef|if|ifdef|ifndef|else|elif|endif|pragma|error)\\b"
+    }
+  }
+}