From 054540b4def3833d87ee17320d1b7a7545c817de Mon Sep 17 00:00:00 2001 From: Arseniy Date: Thu, 3 Jul 2025 20:57:32 +0300 Subject: [PATCH] =?UTF-8?q?=D0=A1=D0=B4=D0=B5=D0=BB=D0=B0=D0=BB=20yandex?= =?UTF-8?q?=5Fsmart=5Fhome=5Fapi=20=D0=BD=D0=B0=20=D0=A1?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .gitignore | 2 + .gitmodules | 3 + .kdev4/yandex_smart_home_api_C.kdev4 | 41 + .obsidian/app.json | 1 + .obsidian/appearance.json | 1 + .obsidian/core-plugins-migration.json | 30 + .obsidian/core-plugins.json | 20 + .obsidian/workspace.json | 163 ++ CMakeLists.txt | 12 + README.md | 564 +++++ api.h | 793 +++++++ cJSON/cJSON.c | 3119 +++++++++++++++++++++++++ cJSON/cJSON.h | 300 +++ curl | 1 + huiafsdwesdfg.h | 192 ++ json/json.c | 1092 +++++++++ json/json.h | 165 ++ main.c | 298 +++ yandex_smart_home_api_C.kdev4 | 3 + 19 files changed, 6800 insertions(+) create mode 100644 .gitignore create mode 100644 .gitmodules create mode 100644 .kdev4/yandex_smart_home_api_C.kdev4 create mode 100644 .obsidian/app.json create mode 100644 .obsidian/appearance.json create mode 100644 .obsidian/core-plugins-migration.json create mode 100644 .obsidian/core-plugins.json create mode 100644 .obsidian/workspace.json create mode 100644 CMakeLists.txt create mode 100644 README.md create mode 100644 api.h create mode 100644 cJSON/cJSON.c create mode 100644 cJSON/cJSON.h create mode 160000 curl create mode 100644 huiafsdwesdfg.h create mode 100644 json/json.c create mode 100644 json/json.h create mode 100644 main.c create mode 100644 yandex_smart_home_api_C.kdev4 diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..0187b3d --- /dev/null +++ b/.gitignore @@ -0,0 +1,2 @@ +build/ +*~ diff --git a/.gitmodules b/.gitmodules new file mode 100644 index 0000000..f2308fd --- /dev/null +++ b/.gitmodules @@ -0,0 +1,3 @@ +[submodule "curl"] + path = curl + url = https://git.systemconnection.ru/romenskiy2012/curl.git diff --git a/.kdev4/yandex_smart_home_api_C.kdev4 b/.kdev4/yandex_smart_home_api_C.kdev4 new file mode 100644 index 0000000..f9766c1 --- /dev/null +++ b/.kdev4/yandex_smart_home_api_C.kdev4 @@ -0,0 +1,41 @@ +[Buildset] +BuildItems=@Variant(\x00\x00\x00\t\x00\x00\x00\x00\x01\x00\x00\x00\x0b\x00\x00\x00\x00\x01\x00\x00\x00.\x00y\x00a\x00n\x00d\x00e\x00x\x00_\x00s\x00m\x00a\x00r\x00t\x00_\x00h\x00o\x00m\x00e\x00_\x00a\x00p\x00i\x00_\x00C) + +[CMake] +Build Directory Count=1 +Current Build Directory Index-Основная система=0 + +[CMake][CMake Build Directory 0] +Build Directory Path=/home/romenskiy2012/projects/yandex_smart_home_api_C/build +Build Type=Debug +CMake Binary=/usr/bin/cmake +CMake Executable=/usr/bin/cmake +Environment Profile= +Extra Arguments= +Install Directory=/usr/local +Runtime=Основная система + +[Launch] +Launch Configurations=Launch Configuration 0 + +[Launch][Launch Configuration 0] +Configured Launch Modes=execute +Configured Launchers=nativeAppLauncher +Name=Новая конфигурация «Компилируемая программа» +Type=Native Application + +[Launch][Launch Configuration 0][Data] +Arguments= +Dependencies=@Variant(\x00\x00\x00\t\x00\x00\x00\x00\x00) +Dependency Action=Nothing +EnvironmentGroup= +Executable=file:///home/romenskiy2012/projects/yandex_smart_home_api_C +External Terminal=konsole --noclose --workdir %workdir -e %exe +Kill Before Executing Again=4194304 +Project Target=yandex_smart_home_api_C,yandex_smart_home_api_c +Use External Terminal=false +Working Directory= +isExecutable=false + +[Project] +VersionControlSupport= diff --git a/.obsidian/app.json b/.obsidian/app.json new file mode 100644 index 0000000..9e26dfe --- /dev/null +++ b/.obsidian/app.json @@ -0,0 +1 @@ +{} \ No newline at end of file diff --git a/.obsidian/appearance.json b/.obsidian/appearance.json new file mode 100644 index 0000000..9e26dfe --- /dev/null +++ b/.obsidian/appearance.json @@ -0,0 +1 @@ +{} \ No newline at end of file diff --git a/.obsidian/core-plugins-migration.json b/.obsidian/core-plugins-migration.json new file mode 100644 index 0000000..436f43c --- /dev/null +++ b/.obsidian/core-plugins-migration.json @@ -0,0 +1,30 @@ +{ + "file-explorer": true, + "global-search": true, + "switcher": true, + "graph": true, + "backlink": true, + "canvas": true, + "outgoing-link": true, + "tag-pane": true, + "properties": false, + "page-preview": true, + "daily-notes": true, + "templates": true, + "note-composer": true, + "command-palette": true, + "slash-command": false, + "editor-status": true, + "bookmarks": true, + "markdown-importer": false, + "zk-prefixer": false, + "random-note": false, + "outline": true, + "word-count": true, + "slides": false, + "audio-recorder": false, + "workspaces": false, + "file-recovery": true, + "publish": false, + "sync": false +} \ No newline at end of file diff --git a/.obsidian/core-plugins.json b/.obsidian/core-plugins.json new file mode 100644 index 0000000..9405bfd --- /dev/null +++ b/.obsidian/core-plugins.json @@ -0,0 +1,20 @@ +[ + "file-explorer", + "global-search", + "switcher", + "graph", + "backlink", + "canvas", + "outgoing-link", + "tag-pane", + "page-preview", + "daily-notes", + "templates", + "note-composer", + "command-palette", + "editor-status", + "bookmarks", + "outline", + "word-count", + "file-recovery" +] \ No newline at end of file diff --git a/.obsidian/workspace.json b/.obsidian/workspace.json new file mode 100644 index 0000000..54bf7e3 --- /dev/null +++ b/.obsidian/workspace.json @@ -0,0 +1,163 @@ +{ + "main": { + "id": "2d5cf626f99cda43", + "type": "split", + "children": [ + { + "id": "d7776d086006468e", + "type": "tabs", + "children": [ + { + "id": "575b51486935f0db", + "type": "leaf", + "state": { + "type": "markdown", + "state": { + "file": "RIDMI.md", + "mode": "preview", + "source": false + } + } + } + ] + } + ], + "direction": "vertical" + }, + "left": { + "id": "458b801bd8498e84", + "type": "split", + "children": [ + { + "id": "6d17c2629608cd4d", + "type": "tabs", + "children": [ + { + "id": "8ed24cd25ebe90ac", + "type": "leaf", + "state": { + "type": "file-explorer", + "state": { + "sortOrder": "alphabetical" + } + } + }, + { + "id": "6bedbba820948b95", + "type": "leaf", + "state": { + "type": "search", + "state": { + "query": "", + "matchingCase": false, + "explainSearch": false, + "collapseAll": false, + "extraContext": false, + "sortOrder": "alphabetical" + } + } + }, + { + "id": "0db24788e86643d0", + "type": "leaf", + "state": { + "type": "bookmarks", + "state": {} + } + } + ] + } + ], + "direction": "horizontal", + "width": 200 + }, + "right": { + "id": "3002d329aae7819c", + "type": "split", + "children": [ + { + "id": "8609e3c2b697f17b", + "type": "tabs", + "children": [ + { + "id": "a0c2048afb568895", + "type": "leaf", + "state": { + "type": "backlink", + "state": { + "file": "RIDMI.md", + "collapseAll": false, + "extraContext": false, + "sortOrder": "alphabetical", + "showSearch": false, + "searchQuery": "", + "backlinkCollapsed": false, + "unlinkedCollapsed": true + } + } + }, + { + "id": "1b8afc6222400a5d", + "type": "leaf", + "state": { + "type": "outgoing-link", + "state": { + "file": "RIDMI.md", + "linksCollapsed": false, + "unlinkedCollapsed": true + } + } + }, + { + "id": "41350e545149c90e", + "type": "leaf", + "state": { + "type": "tag", + "state": { + "sortOrder": "frequency", + "useHierarchy": true + } + } + }, + { + "id": "501a759c69354ed8", + "type": "leaf", + "state": { + "type": "outline", + "state": { + "file": "RIDMI.md" + } + } + } + ] + } + ], + "direction": "horizontal", + "width": 300, + "collapsed": true + }, + "left-ribbon": { + "hiddenItems": { + "switcher:Меню быстрого перехода": false, + "graph:Граф": false, + "canvas:Создать новый холст": false, + "daily-notes:Сегодняшняя заметка": false, + "templates:Вставить шаблон": false, + "command-palette:Открыть палитру команд": false + } + }, + "active": "575b51486935f0db", + "lastOpenFiles": [ + "build/CMakeFiles/yandex_smart_home_api_c.dir/main.c.o.d", + "build/CMakeFiles/3.30.3/CMakeCCompiler.cmake.tmp", + "build/CMakeFiles/3.30.3/CMakeDetermineCompilerABI_C.bin", + "build/CMakeFiles/3.30.3/CMakeCCompiler.cmake", + "build/CMakeFiles/3.30.3/CompilerIdC/a.out", + "build/CMakeFiles/3.30.3/CompilerIdC/tmp", + "build/CMakeFiles/3.30.3/CompilerIdC/CMakeCCompilerId.c", + "build/CMakeFiles/3.30.3/CompilerIdC", + "build/CMakeFiles/3.30.3/CMakeSystem.cmake", + "build/CMakeFiles/3.30.3", + "build/CMakeFiles/yandex_smart_home_api_c.dir/cJSON/cJSON.c.o.d" + ] +} \ No newline at end of file diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 0000000..f70aa94 --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,12 @@ +cmake_minimum_required(VERSION 4.0) + +set(CMAKE_C_STANDARD 11) +project(yandex_smart_home_api_c LANGUAGES C) +set (CMAKE_C_FLAGS "-g -O3") +add_executable(yandex_smart_home_api_c main.c json/json.c cJSON/cJSON.c) +target_link_libraries(yandex_smart_home_api_c curl) +# Правильно указываем папку с .so для линковки +target_link_directories(yandex_smart_home_api_c PRIVATE + "${CMAKE_SOURCE_DIR}/curl/build/lib/" +) +install(TARGETS yandex_smart_home_api_c RUNTIME DESTINATION bin) diff --git a/README.md b/README.md new file mode 100644 index 0000000..da8a7cd --- /dev/null +++ b/README.md @@ -0,0 +1,564 @@ +# Пролог + +Yandex api немного запутоно. +Использование формата json логично для api, но не когда вы работайте на c. +И даже так, видно что разработчики пытались сделать api ответы, а именно все девайсы и группы с комнатами максемально не избыточным. +И это накладовает некоторые проблемы. +Устройство может как и явно говорить включенно оно или нет (True/False), так и не иметь явного стстуса (None). +Или например лампочки имеют цвет, и когда они белые мы явно можем задать температуру цвета в келвенах, но когда кампочка имеет другой цвет, то тут только `hsv` или если лампа воспроизводит какуето анимированую палитру, то + + + +# Возможности +## Взаимодействие +1. Включить/выключить устройство. ✅ +2. Изменить яркость. ✅ +3. Изменить канделы. ✅ +4. Изменить цвет. ✅ +5. Изменить цветовой профиль/сценарий. ❌ +## Получить данные +1. Имя. ✅ +2. Псевдонимы. ❌ +3. Работает ли. ✅ +4. Яркость. ✅ +5. Минимальная яркостью ✅ +6. Максимальная яркость. ✅ +7. Сила канделы. ✅ +8. Максимальные канделы. ✅ +9. Минимальные канделы. ✅ +10. Поддерживает цвета ? ✅ +11. Какой цвет сейчас. ✅ +12. Поддерживает ли профиль/сценарий. ❌ +13. Какие есть профили/сценарии. ❌ +14. Список групп и устройств в них. ✅ + +## Архитектурные реализации. +1. Очистка памяти. ❔ +2. Асинхронность. ❌ + + + + +# API + +Так мы получаем структуру нашего API +```c +struct ya_api api = ya_api_create("Authorization: TOKEN"); +``` +Это даст тебе список девайсов, сейчас у тебя их нет! +```c +api.list_devices(&api); +``` +Это пример как ты можешь получить имя всех девайсов. +```c +for (int i = 0; i != api.data.devs->len; i++){ + printf("%s\n", api.data.devs->dev[i]->name); + } +``` +Вы также можете относительно удобно отправить любой API запрос через +```c +ya_api_recvest("https://api.iot.yandex.net/v1.0/user/info", NULL, api.data.tocen) +``` +Данная процедура вернёт реквест. +Третим пораметром вы можете передать ваш хэдерс, обычно это JSON. + + +Так вы можете сключать и выключать устройство: +```c +api.on_off(api.data.devs->dev[6]); +``` +Вы можете это делать с группой, использовав данную конструкцию: +```c +for (int i = 0; i != api.data.groups->len; i++){ + printf("ГРУППА: %s\n", api.data.groups->group[i]->name); + for (int a = 0; a != api.data.groups->group[i]->devs->len; a++){ + struct ya_dev_struct *dev = api.data.groups->group[i]->devs->dev[a]; + printf("\tДЕВAЙС: %s\n", dev->name); + api.on_off(dev); + } + +} +``` + + +Также вы можете менять температуру, яркость и свет: +```c +api.kelvin(dev, 6500); +``` +Изменить свет модно данной командой +```c +api.hsv(dev, 284,93,80); +``` +Получить цвет можно данным условием: +```c +struct color_struct *color = dev->capabilities->color_setting->color; +printf("HSV = %i %i %i\n", color->h, color->s, color->v); +``` +если ваше устройство сейчас не отоброжает цвеоной цвет, например включён сценарий или цвет задан в кельвинах, то вы получити такой ответ: +```c +HSV = -1 -1 -1 +``` +Узнать, какой именно тип цвета сейчас работает можно спомошью данной функции, где 1 это kelvin, 2 это color, 3 это сценарий. + + + +Вы также захотите понять, что это за устройство, вы можете сделать это так: +```c +printf("\tДЕВAЙС %s: %s\n", dev->type, dev->name); +``` +Вы получити такой ответ: +```json +ДЕВЫЙС devices.types.light: Люстра +``` +Наверное вы бы это претпочли получать как то иначе, но как по мне, так болие уневерсально, хоть вам и придётся менять свой код если Яндекс захочет изменить это. + + +```json + { + "name": "Люстра", + "room": "78dfb6d2-2183-439c-8fbe-c7a101b5ef02", + "groups": [ + "afedc785-dd02-46e6-a347-458a7121da49" + ], + "capabilities": [ + { + "parameters": { + "random_access": true, + "instance": "brightness", + "unit": "unit.percent", + "looped": false, + "range": { + "min": 1, + "max": 100, + "precision": 1 + } + }, + "state": { + "value": 100, + "instance": "brightness" + }, + "last_updated": 1722379725.960000, + "reportable": true, + "type": "devices.capabilities.range", + "retrievable": true + }, + { + "parameters": { + "color_scene": { + "scenes": [ + { + "id": "alice" + }, + { + "id": "party" + }, + { + "id": "jungle" + }, + { + "id": "neon" + }, + { + "id": "night" + }, + { + "id": "ocean" + }, + { + "id": "romance" + }, + { + "id": "candle" + }, + { + "id": "siren" + }, + { + "id": "alarm" + }, + { + "id": "fantasy" + }, + { + "id": "reading" + } + ] + }, + "color_model": "hsv", + "temperature_k": { + "min": 1500, + "max": 6500 + } + }, + "state": { + "value": { + "v": 100, + "s": 96, + "h": 135 + }, + "instance": "hsv" + }, + "last_updated": 1722379725.960000, + "reportable": true, + "type": "devices.capabilities.color_setting", + "retrievable": true + }, + { + "parameters": { + "split": false + }, + "state": { + "value": true, + "instance": "on" + }, + "last_updated": 1722378636.990000, + "reportable": true, + "type": "devices.capabilities.on_off", + "retrievable": true + } + ], + "id": "0a924ae6-b9d7-4d17-a836-ef280c771b3b", + "external_id": "47408080381f8d56fdfc", + "type": "devices.types.light", + "skill_id": "T", + "household_id": "8deb9854-5790-4036-bde3-ba7ad355624c" + }, +``` + + + +```json + "color_model": "hsv", + "temperature_k": { + "min": 1500, + "max": 6500 + } + }, + "state": { + "value": { + "v": 100, + "s": 96, + "h": 135 + }, + "instance": "hsv" + }, + "last_updated": 1722379725.960000, + "reportable": true, + "type": "devices.capabilities.color_setting", + "retrievable": true + }, + { + "parameters": { + "split": false + }, + "state": { + "value": true, + "instance": "on" + }, + "last_updated": 1722378636.990000, + "reportable": true, + "type": "devices.capabilities.on_off", + "retrievable": true + } + +////////// + "color_model": "hsv", + "temperature_k": { + "min": 1500, + "max": 6500 + } + }, + "state": { + "value": 4500, + "instance": "temperature_k" + }, + "last_updated": 1722379815.697000, + "reportable": true, + "type": "devices.capabilities.color_setting", + "retrievable": true + }, + { + "parameters": { + "split": false + }, + "state": { + "value": true, + "instance": "on" + }, + "last_updated": 1722378637.454000, + "reportable": true, + "type": "devices.capabilities.on_off", + "retrievable": true + } + ///////////// + + "color_model": "hsv", + "temperature_k": { + "min": 1500, + "max": 6500 + } + }, + "state": { + "value": "neon", + "instance": "scene" + }, + "last_updated": 1722380508.054000, + "reportable": true, + "type": "devices.capabilities.color_setting", + "retrievable": true + }, + { + "parameters": { + "split": false + }, + "state": { + "value": true, + "instance": "on" + }, + "last_updated": 1722378636.990000, + "reportable": true, + "type": "devices.capabilities.on_off", + "retrievable": true + } +``` + +```mermaid +graph LR + A[api] -->B1(data) + +B1 -->Bs2(tocen) + +B1 -->B2(devs) + +B2 --> C(["dev[int]"]) + +B2 --> C1[len] + +C --> D1[id] + +C --> D2[name] + +C --> D4[room] + +C --> D5[type] + +C --> CI1[capabilities] + +CI1 --> CI1F[color_setting] + + + +CI1F --> CI1F4[color_target] + + + + +CI1F --> CI1F1[color] + +CI1F1 --> CI1F1A1[v] + +CI1F1 --> CI1F1A2[s] + +CI1F1 --> CI1F1A3[h] + + + + +CI1F --> CI1F2[temperature_k] + +CI1F2 --> CI1F2H1[value] + +CI1F2 --> CI1F2H2[min] + +CI1F2 --> CI1F2H3[max] + +CI1F --> CI1F3[scenes] + +CI1F3 --> CI1F3A(["scenes[int]"]) + + + + +CI1 --> CI2F[on_off] + +CI2F --> CI2F1[value] + +CI1 --> CI3F[range] + +CI3F --> CI3F1[value] + +CI3F --> CI3F2[min] + +CI3F --> CI3F3[max] + + + +C --> D3((groups)) +``` + +--- + + + +```mermaid +graph LR +A[api] -->B1(data) + +B1 -->Bs2(tocen) + +B1 -->B2(devs) + +B2 --> C(["dev[int]"]) + +B2 --> C1[len] + +C --> D1[id] + +C --> D2[name] + +C --> D4[room] + +C --> D5[type] + +C --> CI1[capabilities] + +CI1 --> CI1F[color_setting] + +CI1F --> CI1F1[color] + +CI1F --> CI1F2[temperature_k] + +CI1F2 --> CI1F2H1[value] + +CI1F2 --> CI1F2H2[min] + +CI1F2 --> CI1F2H3[max] + +CI1F --> CI1F3[scenes] + +CI1 --> CI2F[on_off] + +CI2F --> CI2F1[value] + +CI1 --> CI3F[range] + +CI3F --> CI3F1[value] + +CI3F --> CI3F2[min] + +CI3F --> CI3F3[max] + + + +C --> D3((groups)) + + + + + +``` + + +```mermaid +graph LR +A[Hard edge] -->B(Round edge) + B --> C{Decision} + C -->|One| D[Result one] + C -->|Two| E[Result two] +``` + + + +```mermaid +%% Example with selection of syntaxes + gantt + dateFormat YYYY-MM-DD + title Adding GANTT diagram functionality to mermaid + + section A section + Completed task :done, des1, 2014-01-06,2014-01-08 + Active task :active, des2, 2014-01-09, 3d + Future task : des3, after des2, 5d + Future task2 : des4, after des3, 5d + + section Critical tasks + Completed task in the critical line :crit, done, 2014-01-06,24h + Implement parser and jison :crit, done, after des1, 2d + Create tests for parser :crit, active, 3d + Future task in critical line :crit, 5d + Create tests for renderer :2d + Add to mermaid :1d + + section Documentation + Describe gantt syntax :active, a1, after des1, 3d + Add gantt diagram to demo page :after a1 , 20h + Add another diagram to demo page :doc1, after a1 , 48h + + section Last section + Describe gantt syntax :after doc1, 3d + Add gantt diagram to demo page : 20h + Add another diagram to demo page : 48h +``` + +```mermaid +classDiagram + Animal <|-- Duck + Animal <|-- Fish + Animal <|-- Zebra + Animal : +int age + Animal : +String gender + Animal: +isMammal() + Animal: +mate() + class Duck{ + +String beakColor + +swim() + +quack() + } + class Fish{ + -int sizeInFeet + -canEat() + } + class Zebra{ + +bool is_wild + +run() + } +``` + + +```mermaid +stateDiagram + [*] --> Still + Still --> [*] + + Still --> Moving + Moving --> Still + Moving --> Crash + Crash --> [*] +``` + + + +```mermaid +pie + title Pie Chart + "Dogs" : 386 + "Cats" : 85 + "Rats" : 150 +``` + +```mermaid +requirementDiagram + + requirement test_req { + id: 1 + text: the test text. + risk: high + verifymethod: test + } + + element test_entity { + type: simulation + } + + test_entity - satisfies -> test_req +``` diff --git a/api.h b/api.h new file mode 100644 index 0000000..d932f97 --- /dev/null +++ b/api.h @@ -0,0 +1,793 @@ +#pragma once +#include "curl/curl.h" +#include "json/json.h" // https://github.com/forkachild/C-Simple-JSON-Parser/tree/a597dd12271d1e19761f3997eeb1479fda95f81d +#include "huiafsdwesdfg.h" + +typedef struct { + int len; + char* id[]; +} ya_list; +struct ya_list_test{ + int len; + char* id[]; +}; + +struct range_struct { + unsigned char min; + unsigned char max; + unsigned char value; +}; +struct on_off_struct { + unsigned char value; +}; +struct temperature_k_struct{ + unsigned int min; + unsigned int max; + unsigned int value; +}; +struct color_struct{ + int h; + char s; + char v; + +}; +struct scenes_struct{ + int len; + char* id[]; +}; +struct color_setting_struct{ + struct temperature_k_struct* temperature_k; + struct color_struct* color; + struct scenes_struct* scenes; + char color_target; +}; +struct capabilities_struct { + struct range_struct* range; + struct color_setting_struct* color_setting; + struct on_off_struct* on_off; +}; + +struct ya_dev_struct{ + char* id; + char* name; + char* type; + char* room; + struct groups* groups; + struct capabilities_struct* capabilities; + struct ya_api* loop; +} ya_dev; + +struct devs{ + int len; + struct ya_dev_struct* dev[]; +} devs; + +struct group{ + char* id; + char* name; + struct devs* devs; +}; +struct groups{ + int len; + struct group* group[]; +}; + + + +struct data { + char* tocen; + struct devs* devs; + struct groups* groups; +}; + +struct ya_api { + void (*devs_free) (struct devs*); + char* (*on_off) (struct ya_dev_struct*); + char* (*kelvin) (struct ya_dev_struct* dev, int k); + char* (*hsv) (struct ya_dev_struct* dev, int h, char s, char v); + char* (*brightness) (struct ya_dev_struct* dev, int b); + void (*list_devices) (struct ya_api*); + ya_list* (*list_devices_id) (); + + struct data data; +}; + + +struct MemoryStruct { + char *memory; + size_t size; +}; +static size_t WriteMemoryCallback(void *contents, size_t size, size_t nmemb, void *userp){ + size_t realsize = size * nmemb; + struct MemoryStruct *mem = (struct MemoryStruct *)userp; + + char *ptr = realloc(mem->memory, mem->size + realsize + 1); + if(!ptr) { + /* out of memory! */ + printf("not enough memory (realloc returned NULL)\n"); + return 0; + } + + mem->memory = ptr; + memcpy(&(mem->memory[mem->size]), contents, realsize); + mem->size += realsize; + mem->memory[mem->size] = 0; + + return realsize; +} + + +//char *tocen; + + + +void ya_devs_free(struct devs* devs){ + + for (int i = 0; i != devs->len; i++){ + free(devs->dev[i]->id); + free(devs->dev[i]->name); + free(devs->dev[i]->room); + free(devs->dev[i]->type); + if (devs->dev[i]->capabilities != NULL){ + if (devs->dev[i]->capabilities->color_setting != NULL){ + free(devs->dev[i]->capabilities->color_setting->temperature_k); + free(devs->dev[i]->capabilities->color_setting); + } + if (devs->dev[i]->capabilities->on_off != NULL) + free(devs->dev[i]->capabilities->on_off); + if (devs->dev[i]->capabilities->range != NULL) + free(devs->dev[i]->capabilities->range); + if (devs->dev[i]->groups != NULL) + free(devs->dev[i]->groups); + } + free(devs->dev[i]->capabilities); + free(devs->dev[i]); + } + free(devs); +} +char* ya_api_recvest(char* url, char* json_texst, char* tocen){ + struct MemoryStruct chunk; + chunk.memory = malloc(1); /* will be grown as needed by the realloc above */ + chunk.size = 0; + + struct curl_slist *headers=NULL; + + headers = curl_slist_append(headers, tocen); + headers = curl_slist_append(headers, "Content-Type: application/json"); + + CURL* handle; + CURLcode response; + handle = curl_easy_init(); + if (json_texst != NULL){ + curl_easy_setopt(handle, CURLOPT_POSTFIELDS, json_texst); + } + curl_easy_setopt(handle, CURLOPT_HTTPHEADER, headers); + curl_easy_setopt(handle, CURLOPT_URL, url); + curl_easy_setopt(handle, CURLOPT_WRITEFUNCTION, WriteMemoryCallback); + curl_easy_setopt(handle, CURLOPT_WRITEDATA, (void *)&chunk); + curl_easy_perform(handle); + return chunk.memory; +} + +/* +char* list_json(){ + struct MemoryStruct chunk; + chunk.memory = malloc(1); + chunk.size = 0; + + char url[] = "https://api.iot.yandex.net/v1.0/user/info"; + struct curl_slist *headers=NULL; + headers = curl_slist_append(headers, tocen); + headers = curl_slist_append(headers, "Content-Type: application/json"); + CURL* handle; + CURLcode response; + handle = curl_easy_init(); + curl_easy_setopt(handle, CURLOPT_HTTPHEADER, headers); + curl_easy_setopt(handle, CURLOPT_URL, url); + curl_easy_setopt(handle, CURLOPT_WRITEFUNCTION, WriteMemoryCallback); + curl_easy_setopt(handle, CURLOPT_WRITEDATA, (void *)&chunk); + curl_easy_perform(handle); + return chunk.memory; +} +*/ +/* +char* ya_dev_(struct ya_dev_struct* dev){ + printf("%s\n", yan_on_off_lampochka(dev->id, !dev->capabilities->on_off->value)); + return ya_api_recvest("https://api.iot.yandex.net/v1.0/devices/actions", yan_on_off_lampochka(dev->id, !dev->capabilities->on_off->value)); +} +*/ +char* ya_dev_on_off(struct ya_dev_struct* dev){ + if (dev->capabilities != NULL) + if (dev->capabilities->on_off != NULL){ + //printf("%i\n", dev->capabilities->on_off->value); + return ya_api_recvest("https://api.iot.yandex.net/v1.0/devices/actions", yan_on_off_lampochka(dev->id, !dev->capabilities->on_off->value), dev->loop->data.tocen); + } + return "ERROR"; +} +static char* memcpy_object_long(const char* data){ + size_t length = strlen(data); + char* sss = malloc((sizeof(char))*length); + memcpy(sss, data, (sizeof(char))*length+1); + return sss; +} + +void tesss(){ + struct ya_api api; + api.data.devs->dev[0]->groups->group[0]->id; + api.data.devs->dev[0]->groups->group[0]; // - group[i] + api.data.groups->group[0]->devs->dev[0]; // - dev[i] + + //api.data.rooms->room[0]; +} +/* + + + + +*/ +void list_devices_aa(struct ya_api* api){ + char url[] = "https://api.iot.yandex.net/v1.0/user/info"; + result(json_element) element_result = json_parse(ya_api_recvest(url, NULL, api->data.tocen)); + if(result_is_err(json_element)(&element_result)) { + typed(json_error) error = result_unwrap_err(json_element)(&element_result); + fprintf(stderr, "Error parsing JSON: %s\n", json_error_to_string(error)); + //return; + } + typed(json_element) element = result_unwrap(json_element)(&element_result); + result(json_element) groups_json = json_object_find(element.value.as_object, "groups"); + struct groups* groups_s; + //json_print(&element, 2); // PRINT + { + typed(json_element) ss = result_unwrap(json_element)(&groups_json); + typed(json_array) *arr = ss.value.as_array; + groups_s = (struct groups*)malloc(sizeof(struct groups*) + arr->count * sizeof(char*)); + groups_s->len = arr->count; + for(int i = 0; i < arr->count; i++) { + typed(json_element) element = arr->elements[i]; + typed(json_element_value) value = element.value; + struct group *group = malloc(sizeof(struct group)); + group->id = memcpy_object_long(json_object_find(value.as_object, "id").inner.value.value.as_string); + group->name = memcpy_object_long(json_object_find(value.as_object, "name").inner.value.value.as_string); + group->devs = malloc(sizeof(struct devs)); + groups_s->group[i] = group; + } + + } + + + + + result(json_element) SS = json_object_find(element.value.as_object, "devices"); + if(result_is_err(json_element)(&SS)) { + typed(json_error) error = result_unwrap_err(json_element)(&SS); + fprintf(stderr, "Error getting element \"devices\": %s\n", json_error_to_string(error)); + //return; + } + typed(json_element) ss = result_unwrap(json_element)(&SS); + typed(json_array) *arr = ss.value.as_array; + + struct devs* devs = (struct devs*)malloc(sizeof(struct devs*) + arr->count * sizeof(char*)); + for(int i = 0; i < arr->count; i++) { + ////////printf("%s", "SAS_1\n"); + typed(json_element) element = arr->elements[i]; + typed(json_element_value) value = element.value; + + struct ya_dev_struct *data; + data = malloc(sizeof(struct ya_dev_struct)); + data->id = memcpy_object_long(json_object_find(value.as_object, "id").inner.value.value.as_string); + data->name = memcpy_object_long(json_object_find(value.as_object, "name").inner.value.value.as_string); + ////////printf("%s%s", data->name, "\n"); + data->type = memcpy_object_long(json_object_find(value.as_object, "type").inner.value.value.as_string); + data->room = memcpy_object_long(json_object_find(value.as_object, "room").inner.value.value.as_string); + result(json_element) nn = json_object_find(value.as_object, "groups"); + //struct ya_list_test* fam2; + struct groups* fam2; + if(result_is_err(json_element)(&nn)) { + fam2 = NULL; + } + else{ + typed(json_array) *arr2 = result_unwrap(json_element)(&nn).value.as_array; + //fam2 = malloc(sizeof(fam2) + arr2->count * sizeof(char*)); + //fam2 = malloc(sizeof(struct groups)); + fam2 = (struct groups*)malloc(sizeof(struct groups*) + arr2->count * sizeof(struct groups*)); + for(int i = 0; i != arr2->count; i++) { + typed(json_element) element = arr2->elements[i]; + typed(json_element_value) value = element.value; + for (int ix = 0; ix != groups_s->len; ix++){ + if (strcmp(groups_s->group[ix]->id, value.as_string) == 0){ + groups_s->group[ix]->devs->dev[groups_s->group[ix]->devs->len] = data; + groups_s->group[ix]->devs->len = groups_s->group[ix]->devs->len + 1; + + fam2->group[i] = groups_s->group[ix]; + } + } + //fam2->id[i] = (char*) value.as_string; + } + fam2->len = arr2->count; + } + result(json_element) nn_2 = json_object_find(value.as_object, "capabilities"); + struct capabilities_struct* fam3; + if(result_is_err(json_element)(&nn_2)) { + fam3 = NULL; + } + else{ + typed(json_array) *arr3 = result_unwrap(json_element)(&nn_2).value.as_array; + fam3 = malloc(sizeof(struct capabilities_struct)); + typed(json_array) *arr = ss.value.as_array; + fam3->range = NULL; + fam3->color_setting = NULL; + fam3->on_off = NULL; + ////////printf("%s", "QQQ\n"); + for(int i = 0; i < arr3->count; i++) { + result(json_element) SS = json_object_find(arr3->elements[i].value.as_object, "type"); + //result(json_element) SS_state = json_object_find(arr3->elements[i].value.as_object, "state"); + //result(json_element) SS_state_instance = json_object_find(arr3->elements[i].value.as_object, "instance"); + if (strcmp(SS.inner.value.value.as_string, "devices.capabilities.range") == 0){ + struct range_struct* sasss; + sasss = malloc(sizeof(struct range_struct)); + result(json_element) SS_2 = json_object_find(arr3->elements[i].value.as_object, "parameters"); + result(json_element) SS_3 = json_object_find(SS_2.inner.value.value.as_object, "range"); + sasss->min = json_object_find(SS_3.inner.value.value.as_object, "min").inner.value.value.as_number.value.as_long; + sasss->max = json_object_find(SS_3.inner.value.value.as_object, "max").inner.value.value.as_number.value.as_long; + sasss->value = json_object_find(SS_3.inner.value.value.as_object, "precision").inner.value.value.as_number.value.as_long; + fam3->range = sasss; + } + else if (strcmp(SS.inner.value.value.as_string, "devices.capabilities.color_setting") == 0){ + struct temperature_k_struct* sasss; + sasss = malloc(sizeof(struct temperature_k_struct)); + struct color_setting_struct* sasss_2; + sasss_2 = malloc(sizeof(struct color_setting_struct)); + result(json_element) json_parameters = json_object_find(arr3->elements[i].value.as_object, "parameters"); + result(json_element) json_temperature_k = json_object_find(json_parameters.inner.value.value.as_object, "temperature_k"); + sasss->min = json_object_find(json_temperature_k.inner.value.value.as_object, "min").inner.value.value.as_number.value.as_long; + sasss->max = json_object_find(json_temperature_k.inner.value.value.as_object, "max").inner.value.value.as_number.value.as_long; + /////////json_print(&arr3->elements[i], 2); + result(json_element) color_model = json_object_find(json_parameters.inner.value.value.as_object, "color_model"); + + if(result_is_err(json_element)(&color_model)) { + printf("ID: %s \n", "0"); + sasss_2->color = NULL; + } + else{ + if (strcmp(memcpy_object_long(color_model.inner.value.value.as_string), "hsv") == 0){ + printf("ID: %s \n", data->id); + struct color_struct* color_struct_dat; + color_struct_dat = malloc(sizeof(struct color_struct)); + color_struct_dat->h = 100; + color_struct_dat->s = 100; + color_struct_dat->v = 100; + //color_struct_dat->status = true; + sasss_2->color = color_struct_dat; + //sasss_2->color_status = 2; + } + else{ + sasss_2->color = NULL; + } + } + /* + else{ + if (strcmp(memcpy_object_long(color_model.inner.value.value.as_string), "hsv") == 0){ + printf("ID: %s", data->id); + } + } + */ + //result(json_element) state = json_object_find(SS_2.inner.value.value.as_object, "state"); + //if (strcmp(memcpy_object_long(state.inner.value.value.as_string), "temperature_k") == 0) + result(json_element) nn_2_n = json_object_find(json_parameters.inner.value.value.as_object, "value"); + if(result_is_err(json_element)(&nn_2_n)) { + sasss->value = -1; + } + else{ + sasss->value = nn_2_n.inner.value.value.as_number.value.as_long; + } + sasss_2->temperature_k = sasss; + //sasss_2->color->h = 2; + fam3->color_setting = sasss_2; + } + //else if (strcmp(SS_state.inner.value.value.as_string, "hsv") == 0){ + // printf("ID: %s", data->id); + //} + else if (strcmp(SS.inner.value.value.as_string, "devices.capabilities.on_off") == 0){ + struct on_off_struct* sasss; + sasss = malloc(sizeof(struct on_off_struct)); + result(json_element) SS_2 = json_object_find(arr3->elements[i].value.as_object, "state"); + sasss->value = json_object_find(SS_2.inner.value.value.as_object, "value").inner.value.value.as_boolean; + fam3->on_off = sasss; + } + + } + } + ////////printf("%s", "SAS_4\n"); + data->loop = api; + //data->groups = NULL; + data->groups = fam2; + data->capabilities = fam3; + devs->dev[i] = data; + } + + + devs->len = arr->count; + //devs->mem = &element; + + //return devs; + ////////printf("SAS\n"); + api->data.devs = devs; + api->data.groups = groups_s; + //main_data->data->ya_devs = devs; + ////////printf("SAS\n"); + json_free(&element); +} +void list_devices(struct ya_api* api){ + int len_groups = 0; + char url[] = "https://api.iot.yandex.net/v1.0/user/info"; + result(json_element) element_result = json_parse(ya_api_recvest(url, NULL, api->data.tocen)); + if(result_is_err(json_element)(&element_result)) { + typed(json_error) error = result_unwrap_err(json_element)(&element_result); + fprintf(stderr, "Error parsing JSON: %s\n", json_error_to_string(error)); + //return; + } + typed(json_element) element = result_unwrap(json_element)(&element_result); + result(json_element) groups_json = json_object_find(element.value.as_object, "groups"); + struct groups* groups_s; + //json_print(&element, 2); // PRINT + { + typed(json_element) ss = result_unwrap(json_element)(&groups_json); + typed(json_array) *arr = ss.value.as_array; + groups_s = (struct groups*)malloc(sizeof(struct groups*) + arr->count * sizeof(char*)); + groups_s->len = arr->count; + for(int i = 0; i < arr->count; i++) { + + typed(json_element) element = arr->elements[i]; + typed(json_element_type) type = element.type; + typed(json_element_value) value = element.value; + struct group *group; + group = malloc(sizeof(struct group)); + group->id = memcpy_object_long(json_object_find(value.as_object, "id").inner.value.value.as_string); + group->name = memcpy_object_long(json_object_find(value.as_object, "name").inner.value.value.as_string); + group->devs = malloc(sizeof(struct devs)); + groups_s->group[i] = group; + } + + } + + + + + result(json_element) SS = json_object_find(element.value.as_object, "devices"); + if(result_is_err(json_element)(&SS)) { + typed(json_error) error = result_unwrap_err(json_element)(&SS); + fprintf(stderr, "Error getting element \"devices\": %s\n", json_error_to_string(error)); + //return; + } + typed(json_element) ss = result_unwrap(json_element)(&SS); + typed(json_array) *arr = ss.value.as_array; + + struct devs* devs = (struct devs*)malloc(sizeof(struct devs*) + arr->count * sizeof(char*)); + for(int i = 0; i < arr->count; i++) { + ////////printf("%s", "SAS_1\n"); + typed(json_element) element = arr->elements[i]; + typed(json_element_type) type = element.type; + typed(json_element_value) value = element.value; + + struct ya_dev_struct *data; + data = malloc(sizeof(struct ya_dev_struct)); + data->id = memcpy_object_long(json_object_find(value.as_object, "id").inner.value.value.as_string); + data->name = memcpy_object_long(json_object_find(value.as_object, "name").inner.value.value.as_string); + ////////printf("%s%s", data->name, "\n"); + data->type = memcpy_object_long(json_object_find(value.as_object, "type").inner.value.value.as_string); + data->room = memcpy_object_long(json_object_find(value.as_object, "room").inner.value.value.as_string); + result(json_element) nn = json_object_find(value.as_object, "groups"); + //struct ya_list_test* fam2; + struct groups* fam2; + if(result_is_err(json_element)(&nn)) { + fam2 = NULL; + + } + else{ + typed(json_array) *arr2 = result_unwrap(json_element)(&nn).value.as_array; + //fam2 = malloc(sizeof(fam2) + arr2->count * sizeof(char*)); + //fam2 = malloc(sizeof(struct groups)); + fam2 = (struct groups*)malloc(sizeof(struct groups*) + arr2->count * sizeof(struct groups*)); + for(int i = 0; i != arr2->count; i++) { + typed(json_element) element = arr2->elements[i]; + typed(json_element_type) type = element.type; + typed(json_element_value) value = element.value; + for (int ix = 0; ix != groups_s->len; ix++){ + if (strcmp(groups_s->group[ix]->id, value.as_string) == 0){ + groups_s->group[ix]->devs->dev[groups_s->group[ix]->devs->len] = data; + groups_s->group[ix]->devs->len = groups_s->group[ix]->devs->len + 1; + + fam2->group[i] = groups_s->group[ix]; + } + } + //fam2->id[i] = (char*) value.as_string; + } + fam2->len = arr2->count; + } + result(json_element) nn_2 = json_object_find(value.as_object, "capabilities"); + struct capabilities_struct* fam3; + if(result_is_err(json_element)(&nn_2)) { + fam3 = NULL; + } + else{ + typed(json_array) *arr3 = result_unwrap(json_element)(&nn_2).value.as_array; + fam3 = malloc(sizeof(struct capabilities_struct)); + typed(json_array) *arr = ss.value.as_array; + fam3->range = NULL; + fam3->color_setting = NULL; + fam3->on_off = NULL; + ////////printf("%s", "QQQ\n"); + for(int i = 0; i < arr3->count; i++) { + result(json_element) SS = json_object_find(arr3->elements[i].value.as_object, "type"); + //result(json_element) SS_state = json_object_find(arr3->elements[i].value.as_object, "state"); + //result(json_element) SS_state_instance = json_object_find(arr3->elements[i].value.as_object, "instance"); + if (strcmp(SS.inner.value.value.as_string, "devices.capabilities.range") == 0){ + struct range_struct* sasss; + sasss = malloc(sizeof(struct range_struct)); + result(json_element) SS_2 = json_object_find(arr3->elements[i].value.as_object, "parameters"); + result(json_element) SS_3 = json_object_find(SS_2.inner.value.value.as_object, "range"); + sasss->min = json_object_find(SS_3.inner.value.value.as_object, "min").inner.value.value.as_number.value.as_long; + sasss->max = json_object_find(SS_3.inner.value.value.as_object, "max").inner.value.value.as_number.value.as_long; + sasss->value = json_object_find(SS_3.inner.value.value.as_object, "precision").inner.value.value.as_number.value.as_long; + fam3->range = sasss; + } + else if (strcmp(SS.inner.value.value.as_string, "devices.capabilities.color_setting") == 0){ + struct temperature_k_struct* sasss; + sasss = malloc(sizeof(struct temperature_k_struct)); + struct color_setting_struct* sasss_2; + sasss_2 = malloc(sizeof(struct color_setting_struct)); + result(json_element) SS_2 = json_object_find(arr3->elements[i].value.as_object, "parameters"); + result(json_element) state = json_object_find(arr3->elements[i].value.as_object, "state"); + result(json_element) SS_3 = json_object_find(SS_2.inner.value.value.as_object, "temperature_k"); + sasss->min = json_object_find(SS_3.inner.value.value.as_object, "min").inner.value.value.as_number.value.as_long; + sasss->max = json_object_find(SS_3.inner.value.value.as_object, "max").inner.value.value.as_number.value.as_long; + /////////json_print(&arr3->elements[i], 2); + result(json_element) color_model = json_object_find(SS_2.inner.value.value.as_object, "color_model"); + + if(result_is_err(json_element)(&color_model)) { + //printf("ID: %s \n", "0"); + sasss_2->color = NULL; + } + else{ + if (strcmp(memcpy_object_long(color_model.inner.value.value.as_string), "hsv") == 0){ + //printf("ID: %s \n", data->id); + struct color_struct* color_struct_dat; + color_struct_dat = malloc(sizeof(struct color_struct)); + color_struct_dat->h = -1; + color_struct_dat->s = -1; + color_struct_dat->v = -1; + //color_struct_dat->status = true; + sasss_2->color = color_struct_dat; + } + else{ + sasss_2->color = NULL; + } + } + /* + else{ + if (strcmp(memcpy_object_long(color_model.inner.value.value.as_string), "hsv") == 0){ + printf("ID: %s", data->id); + } + } + */ + //result(json_element) state = json_object_find(SS_2.inner.value.value.as_object, "state"); + //if (strcmp(memcpy_object_long(state.inner.value.value.as_string), "temperature_k") == 0) + result(json_element) instance = json_object_find(state.inner.value.value.as_object, "instance"); + if(result_is_err(json_element)(&instance)) { + } + else{ + if (strcmp(instance.inner.value.value.as_string, "temperature_k") == 0){ + //printf("K\n"); + result(json_element) value_temperature_k= json_object_find(state.inner.value.value.as_object, "value"); + if(result_is_err(json_element)(&value_temperature_k)) { + sasss->value = -1; + //result(json_element) nn_2_naa = json_object_find(SS_2.inner.value.value.as_object, "value"); + + } + else{ + sasss->value = value_temperature_k.inner.value.value.as_number.value.as_long; + sasss_2->color_target = 1; + } + } + else if (strcmp(instance.inner.value.value.as_string, "hsv") == 0){ + //printf("hsv\n"); + result(json_element) value_vsh= json_object_find(state.inner.value.value.as_object, "value"); + sasss_2->color->h = json_object_find(value_vsh.inner.value.value.as_object, "h").inner.value.value.as_number.value.as_long; + sasss_2->color->s = json_object_find(value_vsh.inner.value.value.as_object, "s").inner.value.value.as_number.value.as_long; + sasss_2->color->v = json_object_find(value_vsh.inner.value.value.as_object, "v").inner.value.value.as_number.value.as_long; + //printf("VSH = %i %i %i\n", sasss_2->color->v,sasss_2->color->s,sasss_2->color->h); + sasss_2->color_target = 2; + } + } + sasss_2->temperature_k = sasss; + //sasss_2->color->h = 2; + fam3->color_setting = sasss_2; + } + //else if (strcmp(SS_state.inner.value.value.as_string, "hsv") == 0){ + // printf("ID: %s", data->id); + //} + else if (strcmp(SS.inner.value.value.as_string, "devices.capabilities.on_off") == 0){ + struct on_off_struct* sasss; + sasss = malloc(sizeof(struct on_off_struct)); + result(json_element) SS_2 = json_object_find(arr3->elements[i].value.as_object, "state"); + sasss->value = json_object_find(SS_2.inner.value.value.as_object, "value").inner.value.value.as_boolean; + fam3->on_off = sasss; + } + + } + } + ////////printf("%s", "SAS_4\n"); + data->loop = api; + //data->groups = NULL; + data->groups = fam2; + data->capabilities = fam3; + devs->dev[i] = data; + } + + + devs->len = arr->count; + //devs->mem = &element; + + //return devs; + ////////printf("SAS\n"); + api->data.devs = devs; + api->data.groups = groups_s; + //main_data->data->ya_devs = devs; + ////////printf("SAS\n"); + json_free(&element); +} + + +char* ya_dev_kelvin(struct ya_dev_struct* dev, int k){ + if (dev->capabilities != NULL) + if (dev->capabilities->color_setting != NULL){ + char* s = yan_kelvin_lampochka(dev->id, k); + return ya_api_recvest("https://api.iot.yandex.net/v1.0/devices/actions", s, dev->loop->data.tocen); + } + return "ERROR"; +} +char* ya_dev_hsv(struct ya_dev_struct* dev, int h, char s, char v){ + if (dev->capabilities != NULL) + if (dev->capabilities->color_setting != NULL){ + char* aaa = yan_hsv_lampochka(dev->id, h,s,v); + return ya_api_recvest("https://api.iot.yandex.net/v1.0/devices/actions", aaa, dev->loop->data.tocen); + } + return "ERROR"; +} +char* ya_dev_brightness(struct ya_dev_struct* dev, int b){ + if (dev->capabilities != NULL) + if (dev->capabilities->range != NULL){ + char* s = yan_brightness(dev->id, b); + return ya_api_recvest("https://api.iot.yandex.net/v1.0/devices/actions", s, dev->loop->data.tocen); + } + return "ERROR"; +} +ya_list* list_devices_id(struct ya_api api){ + char url[] = "https://api.iot.yandex.net/v1.0/user/info"; + result(json_element) element_result = json_parse(ya_api_recvest(url, NULL, api.data.tocen)); + if(result_is_err(json_element)(&element_result)) { + typed(json_error) error = result_unwrap_err(json_element)(&element_result); + fprintf(stderr, "Error parsing JSON: %s\n", json_error_to_string(error)); + //return; + } + typed(json_element) element = result_unwrap(json_element)(&element_result); + result(json_element) SS = json_object_find(element.value.as_object, "devices"); + if(result_is_err(json_element)(&SS)) { + typed(json_error) error = result_unwrap_err(json_element)(&SS); + fprintf(stderr, "Error getting element \"devices\": %s\n", json_error_to_string(error)); + //return; + } + typed(json_element) ss = result_unwrap(json_element)(&SS); + typed(json_array) *arr = ss.value.as_array; + + ya_list* fam1 = (ya_list*)malloc(sizeof(ya_list*) + arr->count * sizeof(char*)); + for(int i = 0; i < arr->count; i++) { + typed(json_element) element = arr->elements[i]; + typed(json_element_type) type = element.type; + typed(json_element_value) value = element.value; + result(json_element) id = json_object_find(value.as_object, "id"); + fam1->id[i] = (char*) id.inner.value.value.as_string; + } + + fam1->len = arr->count; + return fam1; +} + +//// asdsdsd +void list(){ + struct MemoryStruct chunk; + chunk.memory = malloc(1); /* will be grown as needed by the realloc above */ + chunk.size = 0; + + char url_2[100]; + char url[] = "https://api.iot.yandex.net/v1.0/user/info"; + struct curl_slist *headers=NULL; + headers = curl_slist_append(headers, "TOKEN"); + headers = curl_slist_append(headers, "Content-Type: application/json"); + CURL* handle; + CURLcode response; + handle = curl_easy_init(); + curl_easy_setopt(handle, CURLOPT_HTTPHEADER, headers); + curl_easy_setopt(handle, CURLOPT_URL, url); + curl_easy_setopt(handle, CURLOPT_WRITEFUNCTION, WriteMemoryCallback); + curl_easy_setopt(handle, CURLOPT_WRITEDATA, (void *)&chunk); + curl_easy_perform(handle); + printf("%s\n", chunk.memory); + + result(json_element) element_result = json_parse(chunk.memory); + if(result_is_err(json_element)(&element_result)) { + typed(json_error) error = result_unwrap_err(json_element)(&element_result); + fprintf(stderr, "Error parsing JSON: %s\n", json_error_to_string(error)); + return; + } + typed(json_element) element = result_unwrap(json_element)(&element_result); + result(json_element) SS = json_object_find(element.value.as_object, "devices"); + if(result_is_err(json_element)(&SS)) { + typed(json_error) error = result_unwrap_err(json_element)(&SS); + fprintf(stderr, "Error getting element \"devices\": %s\n", json_error_to_string(error)); + return; + } + typed(json_element) ss = result_unwrap(json_element)(&SS); + typed(json_array) *arr = ss.value.as_array; + int i; + for(i = 0; i < arr->count; i++) { + typed(json_element) element = arr->elements[i]; + + typed(json_element_type) type = element.type; + typed(json_element_value) value = element.value; + result(json_element) id = json_object_find(value.as_object, "id"); + result(json_element) name = json_object_find(value.as_object, "name"); + printf("name: %s \tid: %s\n", name.inner.value.value.as_string, id.inner.value.value.as_string); + } + + + + + + + + + + //json_print(&ss, 2); + //typed(json_entry) entry = SS.value.as_object->entries[0]; + //entry.element.type; + /* + result(json_element) element_result = json_parse(chunk.memory); + typed(json_element) element = result_unwrap(json_element)(&element_result); + json_print(&element, 2); + + result(json_element) hello_element_result = json_object_find(element.value.as_object, "devices"); + typed(json_element) hello_element = result_unwrap(json_element)(&hello_element_result); + printf("SAS\n"); + typed(json_entry) entry = hello_element.value.as_object->entries[0]; + int i; + typed(json_object) *obj = hello_element.value.as_object; + for(i = 0; i < obj->count; i++) { + typed(json_entry) entry = obj->entries[i]; + + typed(json_string) key = entry.key; + typed(json_element_type) type = entry.element.type; + typed(json_element_value) value = entry.element.value; + // Do something with `key`, `type` and `value` + } + //printf("\n%s\n", obj->entries[0]); + + //result(json_element) json_object_find(typed(json_object) * object, typed(json_string) key); + */ +} + + +struct ya_api ya_api_create(char* tocen){ + struct ya_api api; + api.data.tocen = tocen; + api.list_devices = list_devices; + api.on_off = ya_dev_on_off; + api.list_devices_id = list_devices_id; + api.kelvin = ya_dev_kelvin; + api.hsv = ya_dev_hsv; + api.devs_free = ya_devs_free; + api.brightness = ya_dev_brightness; + + return api; +} + diff --git a/cJSON/cJSON.c b/cJSON/cJSON.c new file mode 100644 index 0000000..f6dd11c --- /dev/null +++ b/cJSON/cJSON.c @@ -0,0 +1,3119 @@ +/* + Copyright (c) 2009-2017 Dave Gamble and cJSON contributors + + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to deal + in the Software without restriction, including without limitation the rights + to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in + all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + THE SOFTWARE. +*/ + +/* cJSON */ +/* JSON parser in C. */ + +/* disable warnings about old C89 functions in MSVC */ +#if !defined(_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) +#define _CRT_SECURE_NO_DEPRECATE +#endif + +#ifdef __GNUC__ +#pragma GCC visibility push(default) +#endif +#if defined(_MSC_VER) +#pragma warning (push) +/* disable warning about single line comments in system headers */ +#pragma warning (disable : 4001) +#endif + +#include +#include +#include +#include +#include +#include +#include + +#ifdef ENABLE_LOCALES +#include +#endif + +#if defined(_MSC_VER) +#pragma warning (pop) +#endif +#ifdef __GNUC__ +#pragma GCC visibility pop +#endif + +#include "cJSON.h" + +/* define our own boolean type */ +#ifdef true +#undef true +#endif +#define true ((cJSON_bool)1) + +#ifdef false +#undef false +#endif +#define false ((cJSON_bool)0) + +/* define isnan and isinf for ANSI C, if in C99 or above, isnan and isinf has been defined in math.h */ +#ifndef isinf +#define isinf(d) (isnan((d - d)) && !isnan(d)) +#endif +#ifndef isnan +#define isnan(d) (d != d) +#endif + +#ifndef NAN +#ifdef _WIN32 +#define NAN sqrt(-1.0) +#else +#define NAN 0.0/0.0 +#endif +#endif + +typedef struct { + const unsigned char *json; + size_t position; +} error; +static error global_error = { NULL, 0 }; + +CJSON_PUBLIC(const char *) cJSON_GetErrorPtr(void) +{ + return (const char*) (global_error.json + global_error.position); +} + +CJSON_PUBLIC(char *) cJSON_GetStringValue(const cJSON * const item) +{ + if (!cJSON_IsString(item)) + { + return NULL; + } + + return item->valuestring; +} + +CJSON_PUBLIC(double) cJSON_GetNumberValue(const cJSON * const item) +{ + if (!cJSON_IsNumber(item)) + { + return (double) NAN; + } + + return item->valuedouble; +} + +/* This is a safeguard to prevent copy-pasters from using incompatible C and header files */ +#if (CJSON_VERSION_MAJOR != 1) || (CJSON_VERSION_MINOR != 7) || (CJSON_VERSION_PATCH != 16) + #error cJSON.h and cJSON.c have different versions. Make sure that both have the same. +#endif + +CJSON_PUBLIC(const char*) cJSON_Version(void) +{ + static char version[15]; + sprintf(version, "%i.%i.%i", CJSON_VERSION_MAJOR, CJSON_VERSION_MINOR, CJSON_VERSION_PATCH); + + return version; +} + +/* Case insensitive string comparison, doesn't consider two NULL pointers equal though */ +static int case_insensitive_strcmp(const unsigned char *string1, const unsigned char *string2) +{ + if ((string1 == NULL) || (string2 == NULL)) + { + return 1; + } + + if (string1 == string2) + { + return 0; + } + + for(; tolower(*string1) == tolower(*string2); (void)string1++, string2++) + { + if (*string1 == '\0') + { + return 0; + } + } + + return tolower(*string1) - tolower(*string2); +} + +typedef struct internal_hooks +{ + void *(CJSON_CDECL *allocate)(size_t size); + void (CJSON_CDECL *deallocate)(void *pointer); + void *(CJSON_CDECL *reallocate)(void *pointer, size_t size); +} internal_hooks; + +#if defined(_MSC_VER) +/* work around MSVC error C2322: '...' address of dllimport '...' is not static */ +static void * CJSON_CDECL internal_malloc(size_t size) +{ + return malloc(size); +} +static void CJSON_CDECL internal_free(void *pointer) +{ + free(pointer); +} +static void * CJSON_CDECL internal_realloc(void *pointer, size_t size) +{ + return realloc(pointer, size); +} +#else +#define internal_malloc malloc +#define internal_free free +#define internal_realloc realloc +#endif + +/* strlen of character literals resolved at compile time */ +#define static_strlen(string_literal) (sizeof(string_literal) - sizeof("")) + +static internal_hooks global_hooks = { internal_malloc, internal_free, internal_realloc }; + +static unsigned char* cJSON_strdup(const unsigned char* string, const internal_hooks * const hooks) +{ + size_t length = 0; + unsigned char *copy = NULL; + + if (string == NULL) + { + return NULL; + } + + length = strlen((const char*)string) + sizeof(""); + copy = (unsigned char*)hooks->allocate(length); + if (copy == NULL) + { + return NULL; + } + memcpy(copy, string, length); + + return copy; +} + +CJSON_PUBLIC(void) cJSON_InitHooks(cJSON_Hooks* hooks) +{ + if (hooks == NULL) + { + /* Reset hooks */ + global_hooks.allocate = malloc; + global_hooks.deallocate = free; + global_hooks.reallocate = realloc; + return; + } + + global_hooks.allocate = malloc; + if (hooks->malloc_fn != NULL) + { + global_hooks.allocate = hooks->malloc_fn; + } + + global_hooks.deallocate = free; + if (hooks->free_fn != NULL) + { + global_hooks.deallocate = hooks->free_fn; + } + + /* use realloc only if both free and malloc are used */ + global_hooks.reallocate = NULL; + if ((global_hooks.allocate == malloc) && (global_hooks.deallocate == free)) + { + global_hooks.reallocate = realloc; + } +} + +/* Internal constructor. */ +static cJSON *cJSON_New_Item(const internal_hooks * const hooks) +{ + cJSON* node = (cJSON*)hooks->allocate(sizeof(cJSON)); + if (node) + { + memset(node, '\0', sizeof(cJSON)); + } + + return node; +} + +/* Delete a cJSON structure. */ +CJSON_PUBLIC(void) cJSON_Delete(cJSON *item) +{ + cJSON *next = NULL; + while (item != NULL) + { + next = item->next; + if (!(item->type & cJSON_IsReference) && (item->child != NULL)) + { + cJSON_Delete(item->child); + } + if (!(item->type & cJSON_IsReference) && (item->valuestring != NULL)) + { + global_hooks.deallocate(item->valuestring); + } + if (!(item->type & cJSON_StringIsConst) && (item->string != NULL)) + { + global_hooks.deallocate(item->string); + } + global_hooks.deallocate(item); + item = next; + } +} + +/* get the decimal point character of the current locale */ +static unsigned char get_decimal_point(void) +{ +#ifdef ENABLE_LOCALES + struct lconv *lconv = localeconv(); + return (unsigned char) lconv->decimal_point[0]; +#else + return '.'; +#endif +} + +typedef struct +{ + const unsigned char *content; + size_t length; + size_t offset; + size_t depth; /* How deeply nested (in arrays/objects) is the input at the current offset. */ + internal_hooks hooks; +} parse_buffer; + +/* check if the given size is left to read in a given parse buffer (starting with 1) */ +#define can_read(buffer, size) ((buffer != NULL) && (((buffer)->offset + size) <= (buffer)->length)) +/* check if the buffer can be accessed at the given index (starting with 0) */ +#define can_access_at_index(buffer, index) ((buffer != NULL) && (((buffer)->offset + index) < (buffer)->length)) +#define cannot_access_at_index(buffer, index) (!can_access_at_index(buffer, index)) +/* get a pointer to the buffer at the position */ +#define buffer_at_offset(buffer) ((buffer)->content + (buffer)->offset) + +/* Parse the input text to generate a number, and populate the result into item. */ +static cJSON_bool parse_number(cJSON * const item, parse_buffer * const input_buffer) +{ + double number = 0; + unsigned char *after_end = NULL; + unsigned char number_c_string[64]; + unsigned char decimal_point = get_decimal_point(); + size_t i = 0; + + if ((input_buffer == NULL) || (input_buffer->content == NULL)) + { + return false; + } + + /* copy the number into a temporary buffer and replace '.' with the decimal point + * of the current locale (for strtod) + * This also takes care of '\0' not necessarily being available for marking the end of the input */ + for (i = 0; (i < (sizeof(number_c_string) - 1)) && can_access_at_index(input_buffer, i); i++) + { + switch (buffer_at_offset(input_buffer)[i]) + { + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + case '+': + case '-': + case 'e': + case 'E': + number_c_string[i] = buffer_at_offset(input_buffer)[i]; + break; + + case '.': + number_c_string[i] = decimal_point; + break; + + default: + goto loop_end; + } + } +loop_end: + number_c_string[i] = '\0'; + + number = strtod((const char*)number_c_string, (char**)&after_end); + if (number_c_string == after_end) + { + return false; /* parse_error */ + } + + item->valuedouble = number; + + /* use saturation in case of overflow */ + if (number >= INT_MAX) + { + item->valueint = INT_MAX; + } + else if (number <= (double)INT_MIN) + { + item->valueint = INT_MIN; + } + else + { + item->valueint = (int)number; + } + + item->type = cJSON_Number; + + input_buffer->offset += (size_t)(after_end - number_c_string); + return true; +} + +/* don't ask me, but the original cJSON_SetNumberValue returns an integer or double */ +CJSON_PUBLIC(double) cJSON_SetNumberHelper(cJSON *object, double number) +{ + if (number >= INT_MAX) + { + object->valueint = INT_MAX; + } + else if (number <= (double)INT_MIN) + { + object->valueint = INT_MIN; + } + else + { + object->valueint = (int)number; + } + + return object->valuedouble = number; +} + +CJSON_PUBLIC(char*) cJSON_SetValuestring(cJSON *object, const char *valuestring) +{ + char *copy = NULL; + /* if object's type is not cJSON_String or is cJSON_IsReference, it should not set valuestring */ + if (!(object->type & cJSON_String) || (object->type & cJSON_IsReference)) + { + return NULL; + } + if (strlen(valuestring) <= strlen(object->valuestring)) + { + strcpy(object->valuestring, valuestring); + return object->valuestring; + } + copy = (char*) cJSON_strdup((const unsigned char*)valuestring, &global_hooks); + if (copy == NULL) + { + return NULL; + } + if (object->valuestring != NULL) + { + cJSON_free(object->valuestring); + } + object->valuestring = copy; + + return copy; +} + +typedef struct +{ + unsigned char *buffer; + size_t length; + size_t offset; + size_t depth; /* current nesting depth (for formatted printing) */ + cJSON_bool noalloc; + cJSON_bool format; /* is this print a formatted print */ + internal_hooks hooks; +} printbuffer; + +/* realloc printbuffer if necessary to have at least "needed" bytes more */ +static unsigned char* ensure(printbuffer * const p, size_t needed) +{ + unsigned char *newbuffer = NULL; + size_t newsize = 0; + + if ((p == NULL) || (p->buffer == NULL)) + { + return NULL; + } + + if ((p->length > 0) && (p->offset >= p->length)) + { + /* make sure that offset is valid */ + return NULL; + } + + if (needed > INT_MAX) + { + /* sizes bigger than INT_MAX are currently not supported */ + return NULL; + } + + needed += p->offset + 1; + if (needed <= p->length) + { + return p->buffer + p->offset; + } + + if (p->noalloc) { + return NULL; + } + + /* calculate new buffer size */ + if (needed > (INT_MAX / 2)) + { + /* overflow of int, use INT_MAX if possible */ + if (needed <= INT_MAX) + { + newsize = INT_MAX; + } + else + { + return NULL; + } + } + else + { + newsize = needed * 2; + } + + if (p->hooks.reallocate != NULL) + { + /* reallocate with realloc if available */ + newbuffer = (unsigned char*)p->hooks.reallocate(p->buffer, newsize); + if (newbuffer == NULL) + { + p->hooks.deallocate(p->buffer); + p->length = 0; + p->buffer = NULL; + + return NULL; + } + } + else + { + /* otherwise reallocate manually */ + newbuffer = (unsigned char*)p->hooks.allocate(newsize); + if (!newbuffer) + { + p->hooks.deallocate(p->buffer); + p->length = 0; + p->buffer = NULL; + + return NULL; + } + + memcpy(newbuffer, p->buffer, p->offset + 1); + p->hooks.deallocate(p->buffer); + } + p->length = newsize; + p->buffer = newbuffer; + + return newbuffer + p->offset; +} + +/* calculate the new length of the string in a printbuffer and update the offset */ +static void update_offset(printbuffer * const buffer) +{ + const unsigned char *buffer_pointer = NULL; + if ((buffer == NULL) || (buffer->buffer == NULL)) + { + return; + } + buffer_pointer = buffer->buffer + buffer->offset; + + buffer->offset += strlen((const char*)buffer_pointer); +} + +/* securely comparison of floating-point variables */ +static cJSON_bool compare_double(double a, double b) +{ + double maxVal = fabs(a) > fabs(b) ? fabs(a) : fabs(b); + return (fabs(a - b) <= maxVal * DBL_EPSILON); +} + +/* Render the number nicely from the given item into a string. */ +static cJSON_bool print_number(const cJSON * const item, printbuffer * const output_buffer) +{ + unsigned char *output_pointer = NULL; + double d = item->valuedouble; + int length = 0; + size_t i = 0; + unsigned char number_buffer[26] = {0}; /* temporary buffer to print the number into */ + unsigned char decimal_point = get_decimal_point(); + double test = 0.0; + + if (output_buffer == NULL) + { + return false; + } + + /* This checks for NaN and Infinity */ + if (isnan(d) || isinf(d)) + { + length = sprintf((char*)number_buffer, "null"); + } + else if(d == (double)item->valueint) + { + length = sprintf((char*)number_buffer, "%d", item->valueint); + } + else + { + /* Try 15 decimal places of precision to avoid nonsignificant nonzero digits */ + length = sprintf((char*)number_buffer, "%1.15g", d); + + /* Check whether the original double can be recovered */ + if ((sscanf((char*)number_buffer, "%lg", &test) != 1) || !compare_double((double)test, d)) + { + /* If not, print with 17 decimal places of precision */ + length = sprintf((char*)number_buffer, "%1.17g", d); + } + } + + /* sprintf failed or buffer overrun occurred */ + if ((length < 0) || (length > (int)(sizeof(number_buffer) - 1))) + { + return false; + } + + /* reserve appropriate space in the output */ + output_pointer = ensure(output_buffer, (size_t)length + sizeof("")); + if (output_pointer == NULL) + { + return false; + } + + /* copy the printed number to the output and replace locale + * dependent decimal point with '.' */ + for (i = 0; i < ((size_t)length); i++) + { + if (number_buffer[i] == decimal_point) + { + output_pointer[i] = '.'; + continue; + } + + output_pointer[i] = number_buffer[i]; + } + output_pointer[i] = '\0'; + + output_buffer->offset += (size_t)length; + + return true; +} + +/* parse 4 digit hexadecimal number */ +static unsigned parse_hex4(const unsigned char * const input) +{ + unsigned int h = 0; + size_t i = 0; + + for (i = 0; i < 4; i++) + { + /* parse digit */ + if ((input[i] >= '0') && (input[i] <= '9')) + { + h += (unsigned int) input[i] - '0'; + } + else if ((input[i] >= 'A') && (input[i] <= 'F')) + { + h += (unsigned int) 10 + input[i] - 'A'; + } + else if ((input[i] >= 'a') && (input[i] <= 'f')) + { + h += (unsigned int) 10 + input[i] - 'a'; + } + else /* invalid */ + { + return 0; + } + + if (i < 3) + { + /* shift left to make place for the next nibble */ + h = h << 4; + } + } + + return h; +} + +/* converts a UTF-16 literal to UTF-8 + * A literal can be one or two sequences of the form \uXXXX */ +static unsigned char utf16_literal_to_utf8(const unsigned char * const input_pointer, const unsigned char * const input_end, unsigned char **output_pointer) +{ + long unsigned int codepoint = 0; + unsigned int first_code = 0; + const unsigned char *first_sequence = input_pointer; + unsigned char utf8_length = 0; + unsigned char utf8_position = 0; + unsigned char sequence_length = 0; + unsigned char first_byte_mark = 0; + + if ((input_end - first_sequence) < 6) + { + /* input ends unexpectedly */ + goto fail; + } + + /* get the first utf16 sequence */ + first_code = parse_hex4(first_sequence + 2); + + /* check that the code is valid */ + if (((first_code >= 0xDC00) && (first_code <= 0xDFFF))) + { + goto fail; + } + + /* UTF16 surrogate pair */ + if ((first_code >= 0xD800) && (first_code <= 0xDBFF)) + { + const unsigned char *second_sequence = first_sequence + 6; + unsigned int second_code = 0; + sequence_length = 12; /* \uXXXX\uXXXX */ + + if ((input_end - second_sequence) < 6) + { + /* input ends unexpectedly */ + goto fail; + } + + if ((second_sequence[0] != '\\') || (second_sequence[1] != 'u')) + { + /* missing second half of the surrogate pair */ + goto fail; + } + + /* get the second utf16 sequence */ + second_code = parse_hex4(second_sequence + 2); + /* check that the code is valid */ + if ((second_code < 0xDC00) || (second_code > 0xDFFF)) + { + /* invalid second half of the surrogate pair */ + goto fail; + } + + + /* calculate the unicode codepoint from the surrogate pair */ + codepoint = 0x10000 + (((first_code & 0x3FF) << 10) | (second_code & 0x3FF)); + } + else + { + sequence_length = 6; /* \uXXXX */ + codepoint = first_code; + } + + /* encode as UTF-8 + * takes at maximum 4 bytes to encode: + * 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx */ + if (codepoint < 0x80) + { + /* normal ascii, encoding 0xxxxxxx */ + utf8_length = 1; + } + else if (codepoint < 0x800) + { + /* two bytes, encoding 110xxxxx 10xxxxxx */ + utf8_length = 2; + first_byte_mark = 0xC0; /* 11000000 */ + } + else if (codepoint < 0x10000) + { + /* three bytes, encoding 1110xxxx 10xxxxxx 10xxxxxx */ + utf8_length = 3; + first_byte_mark = 0xE0; /* 11100000 */ + } + else if (codepoint <= 0x10FFFF) + { + /* four bytes, encoding 1110xxxx 10xxxxxx 10xxxxxx 10xxxxxx */ + utf8_length = 4; + first_byte_mark = 0xF0; /* 11110000 */ + } + else + { + /* invalid unicode codepoint */ + goto fail; + } + + /* encode as utf8 */ + for (utf8_position = (unsigned char)(utf8_length - 1); utf8_position > 0; utf8_position--) + { + /* 10xxxxxx */ + (*output_pointer)[utf8_position] = (unsigned char)((codepoint | 0x80) & 0xBF); + codepoint >>= 6; + } + /* encode first byte */ + if (utf8_length > 1) + { + (*output_pointer)[0] = (unsigned char)((codepoint | first_byte_mark) & 0xFF); + } + else + { + (*output_pointer)[0] = (unsigned char)(codepoint & 0x7F); + } + + *output_pointer += utf8_length; + + return sequence_length; + +fail: + return 0; +} + +/* Parse the input text into an unescaped cinput, and populate item. */ +static cJSON_bool parse_string(cJSON * const item, parse_buffer * const input_buffer) +{ + const unsigned char *input_pointer = buffer_at_offset(input_buffer) + 1; + const unsigned char *input_end = buffer_at_offset(input_buffer) + 1; + unsigned char *output_pointer = NULL; + unsigned char *output = NULL; + + /* not a string */ + if (buffer_at_offset(input_buffer)[0] != '\"') + { + goto fail; + } + + { + /* calculate approximate size of the output (overestimate) */ + size_t allocation_length = 0; + size_t skipped_bytes = 0; + while (((size_t)(input_end - input_buffer->content) < input_buffer->length) && (*input_end != '\"')) + { + /* is escape sequence */ + if (input_end[0] == '\\') + { + if ((size_t)(input_end + 1 - input_buffer->content) >= input_buffer->length) + { + /* prevent buffer overflow when last input character is a backslash */ + goto fail; + } + skipped_bytes++; + input_end++; + } + input_end++; + } + if (((size_t)(input_end - input_buffer->content) >= input_buffer->length) || (*input_end != '\"')) + { + goto fail; /* string ended unexpectedly */ + } + + /* This is at most how much we need for the output */ + allocation_length = (size_t) (input_end - buffer_at_offset(input_buffer)) - skipped_bytes; + output = (unsigned char*)input_buffer->hooks.allocate(allocation_length + sizeof("")); + if (output == NULL) + { + goto fail; /* allocation failure */ + } + } + + output_pointer = output; + /* loop through the string literal */ + while (input_pointer < input_end) + { + if (*input_pointer != '\\') + { + *output_pointer++ = *input_pointer++; + } + /* escape sequence */ + else + { + unsigned char sequence_length = 2; + if ((input_end - input_pointer) < 1) + { + goto fail; + } + + switch (input_pointer[1]) + { + case 'b': + *output_pointer++ = '\b'; + break; + case 'f': + *output_pointer++ = '\f'; + break; + case 'n': + *output_pointer++ = '\n'; + break; + case 'r': + *output_pointer++ = '\r'; + break; + case 't': + *output_pointer++ = '\t'; + break; + case '\"': + case '\\': + case '/': + *output_pointer++ = input_pointer[1]; + break; + + /* UTF-16 literal */ + case 'u': + sequence_length = utf16_literal_to_utf8(input_pointer, input_end, &output_pointer); + if (sequence_length == 0) + { + /* failed to convert UTF16-literal to UTF-8 */ + goto fail; + } + break; + + default: + goto fail; + } + input_pointer += sequence_length; + } + } + + /* zero terminate the output */ + *output_pointer = '\0'; + + item->type = cJSON_String; + item->valuestring = (char*)output; + + input_buffer->offset = (size_t) (input_end - input_buffer->content); + input_buffer->offset++; + + return true; + +fail: + if (output != NULL) + { + input_buffer->hooks.deallocate(output); + } + + if (input_pointer != NULL) + { + input_buffer->offset = (size_t)(input_pointer - input_buffer->content); + } + + return false; +} + +/* Render the cstring provided to an escaped version that can be printed. */ +static cJSON_bool print_string_ptr(const unsigned char * const input, printbuffer * const output_buffer) +{ + const unsigned char *input_pointer = NULL; + unsigned char *output = NULL; + unsigned char *output_pointer = NULL; + size_t output_length = 0; + /* numbers of additional characters needed for escaping */ + size_t escape_characters = 0; + + if (output_buffer == NULL) + { + return false; + } + + /* empty string */ + if (input == NULL) + { + output = ensure(output_buffer, sizeof("\"\"")); + if (output == NULL) + { + return false; + } + strcpy((char*)output, "\"\""); + + return true; + } + + /* set "flag" to 1 if something needs to be escaped */ + for (input_pointer = input; *input_pointer; input_pointer++) + { + switch (*input_pointer) + { + case '\"': + case '\\': + case '\b': + case '\f': + case '\n': + case '\r': + case '\t': + /* one character escape sequence */ + escape_characters++; + break; + default: + if (*input_pointer < 32) + { + /* UTF-16 escape sequence uXXXX */ + escape_characters += 5; + } + break; + } + } + output_length = (size_t)(input_pointer - input) + escape_characters; + + output = ensure(output_buffer, output_length + sizeof("\"\"")); + if (output == NULL) + { + return false; + } + + /* no characters have to be escaped */ + if (escape_characters == 0) + { + output[0] = '\"'; + memcpy(output + 1, input, output_length); + output[output_length + 1] = '\"'; + output[output_length + 2] = '\0'; + + return true; + } + + output[0] = '\"'; + output_pointer = output + 1; + /* copy the string */ + for (input_pointer = input; *input_pointer != '\0'; (void)input_pointer++, output_pointer++) + { + if ((*input_pointer > 31) && (*input_pointer != '\"') && (*input_pointer != '\\')) + { + /* normal character, copy */ + *output_pointer = *input_pointer; + } + else + { + /* character needs to be escaped */ + *output_pointer++ = '\\'; + switch (*input_pointer) + { + case '\\': + *output_pointer = '\\'; + break; + case '\"': + *output_pointer = '\"'; + break; + case '\b': + *output_pointer = 'b'; + break; + case '\f': + *output_pointer = 'f'; + break; + case '\n': + *output_pointer = 'n'; + break; + case '\r': + *output_pointer = 'r'; + break; + case '\t': + *output_pointer = 't'; + break; + default: + /* escape and print as unicode codepoint */ + sprintf((char*)output_pointer, "u%04x", *input_pointer); + output_pointer += 4; + break; + } + } + } + output[output_length + 1] = '\"'; + output[output_length + 2] = '\0'; + + return true; +} + +/* Invoke print_string_ptr (which is useful) on an item. */ +static cJSON_bool print_string(const cJSON * const item, printbuffer * const p) +{ + return print_string_ptr((unsigned char*)item->valuestring, p); +} + +/* Predeclare these prototypes. */ +static cJSON_bool parse_value(cJSON * const item, parse_buffer * const input_buffer); +static cJSON_bool print_value(const cJSON * const item, printbuffer * const output_buffer); +static cJSON_bool parse_array(cJSON * const item, parse_buffer * const input_buffer); +static cJSON_bool print_array(const cJSON * const item, printbuffer * const output_buffer); +static cJSON_bool parse_object(cJSON * const item, parse_buffer * const input_buffer); +static cJSON_bool print_object(const cJSON * const item, printbuffer * const output_buffer); + +/* Utility to jump whitespace and cr/lf */ +static parse_buffer *buffer_skip_whitespace(parse_buffer * const buffer) +{ + if ((buffer == NULL) || (buffer->content == NULL)) + { + return NULL; + } + + if (cannot_access_at_index(buffer, 0)) + { + return buffer; + } + + while (can_access_at_index(buffer, 0) && (buffer_at_offset(buffer)[0] <= 32)) + { + buffer->offset++; + } + + if (buffer->offset == buffer->length) + { + buffer->offset--; + } + + return buffer; +} + +/* skip the UTF-8 BOM (byte order mark) if it is at the beginning of a buffer */ +static parse_buffer *skip_utf8_bom(parse_buffer * const buffer) +{ + if ((buffer == NULL) || (buffer->content == NULL) || (buffer->offset != 0)) + { + return NULL; + } + + if (can_access_at_index(buffer, 4) && (strncmp((const char*)buffer_at_offset(buffer), "\xEF\xBB\xBF", 3) == 0)) + { + buffer->offset += 3; + } + + return buffer; +} + +CJSON_PUBLIC(cJSON *) cJSON_ParseWithOpts(const char *value, const char **return_parse_end, cJSON_bool require_null_terminated) +{ + size_t buffer_length; + + if (NULL == value) + { + return NULL; + } + + /* Adding null character size due to require_null_terminated. */ + buffer_length = strlen(value) + sizeof(""); + + return cJSON_ParseWithLengthOpts(value, buffer_length, return_parse_end, require_null_terminated); +} + +/* Parse an object - create a new root, and populate. */ +CJSON_PUBLIC(cJSON *) cJSON_ParseWithLengthOpts(const char *value, size_t buffer_length, const char **return_parse_end, cJSON_bool require_null_terminated) +{ + parse_buffer buffer = { 0, 0, 0, 0, { 0, 0, 0 } }; + cJSON *item = NULL; + + /* reset error position */ + global_error.json = NULL; + global_error.position = 0; + + if (value == NULL || 0 == buffer_length) + { + goto fail; + } + + buffer.content = (const unsigned char*)value; + buffer.length = buffer_length; + buffer.offset = 0; + buffer.hooks = global_hooks; + + item = cJSON_New_Item(&global_hooks); + if (item == NULL) /* memory fail */ + { + goto fail; + } + + if (!parse_value(item, buffer_skip_whitespace(skip_utf8_bom(&buffer)))) + { + /* parse failure. ep is set. */ + goto fail; + } + + /* if we require null-terminated JSON without appended garbage, skip and then check for a null terminator */ + if (require_null_terminated) + { + buffer_skip_whitespace(&buffer); + if ((buffer.offset >= buffer.length) || buffer_at_offset(&buffer)[0] != '\0') + { + goto fail; + } + } + if (return_parse_end) + { + *return_parse_end = (const char*)buffer_at_offset(&buffer); + } + + return item; + +fail: + if (item != NULL) + { + cJSON_Delete(item); + } + + if (value != NULL) + { + error local_error; + local_error.json = (const unsigned char*)value; + local_error.position = 0; + + if (buffer.offset < buffer.length) + { + local_error.position = buffer.offset; + } + else if (buffer.length > 0) + { + local_error.position = buffer.length - 1; + } + + if (return_parse_end != NULL) + { + *return_parse_end = (const char*)local_error.json + local_error.position; + } + + global_error = local_error; + } + + return NULL; +} + +/* Default options for cJSON_Parse */ +CJSON_PUBLIC(cJSON *) cJSON_Parse(const char *value) +{ + return cJSON_ParseWithOpts(value, 0, 0); +} + +CJSON_PUBLIC(cJSON *) cJSON_ParseWithLength(const char *value, size_t buffer_length) +{ + return cJSON_ParseWithLengthOpts(value, buffer_length, 0, 0); +} + +#define cjson_min(a, b) (((a) < (b)) ? (a) : (b)) + +static unsigned char *print(const cJSON * const item, cJSON_bool format, const internal_hooks * const hooks) +{ + static const size_t default_buffer_size = 256; + printbuffer buffer[1]; + unsigned char *printed = NULL; + + memset(buffer, 0, sizeof(buffer)); + + /* create buffer */ + buffer->buffer = (unsigned char*) hooks->allocate(default_buffer_size); + buffer->length = default_buffer_size; + buffer->format = format; + buffer->hooks = *hooks; + if (buffer->buffer == NULL) + { + goto fail; + } + + /* print the value */ + if (!print_value(item, buffer)) + { + goto fail; + } + update_offset(buffer); + + /* check if reallocate is available */ + if (hooks->reallocate != NULL) + { + printed = (unsigned char*) hooks->reallocate(buffer->buffer, buffer->offset + 1); + if (printed == NULL) { + goto fail; + } + buffer->buffer = NULL; + } + else /* otherwise copy the JSON over to a new buffer */ + { + printed = (unsigned char*) hooks->allocate(buffer->offset + 1); + if (printed == NULL) + { + goto fail; + } + memcpy(printed, buffer->buffer, cjson_min(buffer->length, buffer->offset + 1)); + printed[buffer->offset] = '\0'; /* just to be sure */ + + /* free the buffer */ + hooks->deallocate(buffer->buffer); + } + + return printed; + +fail: + if (buffer->buffer != NULL) + { + hooks->deallocate(buffer->buffer); + } + + if (printed != NULL) + { + hooks->deallocate(printed); + } + + return NULL; +} + +/* Render a cJSON item/entity/structure to text. */ +CJSON_PUBLIC(char *) cJSON_Print(const cJSON *item) +{ + return (char*)print(item, true, &global_hooks); +} + +CJSON_PUBLIC(char *) cJSON_PrintUnformatted(const cJSON *item) +{ + return (char*)print(item, false, &global_hooks); +} + +CJSON_PUBLIC(char *) cJSON_PrintBuffered(const cJSON *item, int prebuffer, cJSON_bool fmt) +{ + printbuffer p = { 0, 0, 0, 0, 0, 0, { 0, 0, 0 } }; + + if (prebuffer < 0) + { + return NULL; + } + + p.buffer = (unsigned char*)global_hooks.allocate((size_t)prebuffer); + if (!p.buffer) + { + return NULL; + } + + p.length = (size_t)prebuffer; + p.offset = 0; + p.noalloc = false; + p.format = fmt; + p.hooks = global_hooks; + + if (!print_value(item, &p)) + { + global_hooks.deallocate(p.buffer); + return NULL; + } + + return (char*)p.buffer; +} + +CJSON_PUBLIC(cJSON_bool) cJSON_PrintPreallocated(cJSON *item, char *buffer, const int length, const cJSON_bool format) +{ + printbuffer p = { 0, 0, 0, 0, 0, 0, { 0, 0, 0 } }; + + if ((length < 0) || (buffer == NULL)) + { + return false; + } + + p.buffer = (unsigned char*)buffer; + p.length = (size_t)length; + p.offset = 0; + p.noalloc = true; + p.format = format; + p.hooks = global_hooks; + + return print_value(item, &p); +} + +/* Parser core - when encountering text, process appropriately. */ +static cJSON_bool parse_value(cJSON * const item, parse_buffer * const input_buffer) +{ + if ((input_buffer == NULL) || (input_buffer->content == NULL)) + { + return false; /* no input */ + } + + /* parse the different types of values */ + /* null */ + if (can_read(input_buffer, 4) && (strncmp((const char*)buffer_at_offset(input_buffer), "null", 4) == 0)) + { + item->type = cJSON_NULL; + input_buffer->offset += 4; + return true; + } + /* false */ + if (can_read(input_buffer, 5) && (strncmp((const char*)buffer_at_offset(input_buffer), "false", 5) == 0)) + { + item->type = cJSON_False; + input_buffer->offset += 5; + return true; + } + /* true */ + if (can_read(input_buffer, 4) && (strncmp((const char*)buffer_at_offset(input_buffer), "true", 4) == 0)) + { + item->type = cJSON_True; + item->valueint = 1; + input_buffer->offset += 4; + return true; + } + /* string */ + if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '\"')) + { + return parse_string(item, input_buffer); + } + /* number */ + if (can_access_at_index(input_buffer, 0) && ((buffer_at_offset(input_buffer)[0] == '-') || ((buffer_at_offset(input_buffer)[0] >= '0') && (buffer_at_offset(input_buffer)[0] <= '9')))) + { + return parse_number(item, input_buffer); + } + /* array */ + if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '[')) + { + return parse_array(item, input_buffer); + } + /* object */ + if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '{')) + { + return parse_object(item, input_buffer); + } + + return false; +} + +/* Render a value to text. */ +static cJSON_bool print_value(const cJSON * const item, printbuffer * const output_buffer) +{ + unsigned char *output = NULL; + + if ((item == NULL) || (output_buffer == NULL)) + { + return false; + } + + switch ((item->type) & 0xFF) + { + case cJSON_NULL: + output = ensure(output_buffer, 5); + if (output == NULL) + { + return false; + } + strcpy((char*)output, "null"); + return true; + + case cJSON_False: + output = ensure(output_buffer, 6); + if (output == NULL) + { + return false; + } + strcpy((char*)output, "false"); + return true; + + case cJSON_True: + output = ensure(output_buffer, 5); + if (output == NULL) + { + return false; + } + strcpy((char*)output, "true"); + return true; + + case cJSON_Number: + return print_number(item, output_buffer); + + case cJSON_Raw: + { + size_t raw_length = 0; + if (item->valuestring == NULL) + { + return false; + } + + raw_length = strlen(item->valuestring) + sizeof(""); + output = ensure(output_buffer, raw_length); + if (output == NULL) + { + return false; + } + memcpy(output, item->valuestring, raw_length); + return true; + } + + case cJSON_String: + return print_string(item, output_buffer); + + case cJSON_Array: + return print_array(item, output_buffer); + + case cJSON_Object: + return print_object(item, output_buffer); + + default: + return false; + } +} + +/* Build an array from input text. */ +static cJSON_bool parse_array(cJSON * const item, parse_buffer * const input_buffer) +{ + cJSON *head = NULL; /* head of the linked list */ + cJSON *current_item = NULL; + + if (input_buffer->depth >= CJSON_NESTING_LIMIT) + { + return false; /* to deeply nested */ + } + input_buffer->depth++; + + if (buffer_at_offset(input_buffer)[0] != '[') + { + /* not an array */ + goto fail; + } + + input_buffer->offset++; + buffer_skip_whitespace(input_buffer); + if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == ']')) + { + /* empty array */ + goto success; + } + + /* check if we skipped to the end of the buffer */ + if (cannot_access_at_index(input_buffer, 0)) + { + input_buffer->offset--; + goto fail; + } + + /* step back to character in front of the first element */ + input_buffer->offset--; + /* loop through the comma separated array elements */ + do + { + /* allocate next item */ + cJSON *new_item = cJSON_New_Item(&(input_buffer->hooks)); + if (new_item == NULL) + { + goto fail; /* allocation failure */ + } + + /* attach next item to list */ + if (head == NULL) + { + /* start the linked list */ + current_item = head = new_item; + } + else + { + /* add to the end and advance */ + current_item->next = new_item; + new_item->prev = current_item; + current_item = new_item; + } + + /* parse next value */ + input_buffer->offset++; + buffer_skip_whitespace(input_buffer); + if (!parse_value(current_item, input_buffer)) + { + goto fail; /* failed to parse value */ + } + buffer_skip_whitespace(input_buffer); + } + while (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == ',')); + + if (cannot_access_at_index(input_buffer, 0) || buffer_at_offset(input_buffer)[0] != ']') + { + goto fail; /* expected end of array */ + } + +success: + input_buffer->depth--; + + if (head != NULL) { + head->prev = current_item; + } + + item->type = cJSON_Array; + item->child = head; + + input_buffer->offset++; + + return true; + +fail: + if (head != NULL) + { + cJSON_Delete(head); + } + + return false; +} + +/* Render an array to text */ +static cJSON_bool print_array(const cJSON * const item, printbuffer * const output_buffer) +{ + unsigned char *output_pointer = NULL; + size_t length = 0; + cJSON *current_element = item->child; + + if (output_buffer == NULL) + { + return false; + } + + /* Compose the output array. */ + /* opening square bracket */ + output_pointer = ensure(output_buffer, 1); + if (output_pointer == NULL) + { + return false; + } + + *output_pointer = '['; + output_buffer->offset++; + output_buffer->depth++; + + while (current_element != NULL) + { + if (!print_value(current_element, output_buffer)) + { + return false; + } + update_offset(output_buffer); + if (current_element->next) + { + length = (size_t) (output_buffer->format ? 2 : 1); + output_pointer = ensure(output_buffer, length + 1); + if (output_pointer == NULL) + { + return false; + } + *output_pointer++ = ','; + if(output_buffer->format) + { + *output_pointer++ = ' '; + } + *output_pointer = '\0'; + output_buffer->offset += length; + } + current_element = current_element->next; + } + + output_pointer = ensure(output_buffer, 2); + if (output_pointer == NULL) + { + return false; + } + *output_pointer++ = ']'; + *output_pointer = '\0'; + output_buffer->depth--; + + return true; +} + +/* Build an object from the text. */ +static cJSON_bool parse_object(cJSON * const item, parse_buffer * const input_buffer) +{ + cJSON *head = NULL; /* linked list head */ + cJSON *current_item = NULL; + + if (input_buffer->depth >= CJSON_NESTING_LIMIT) + { + return false; /* to deeply nested */ + } + input_buffer->depth++; + + if (cannot_access_at_index(input_buffer, 0) || (buffer_at_offset(input_buffer)[0] != '{')) + { + goto fail; /* not an object */ + } + + input_buffer->offset++; + buffer_skip_whitespace(input_buffer); + if (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == '}')) + { + goto success; /* empty object */ + } + + /* check if we skipped to the end of the buffer */ + if (cannot_access_at_index(input_buffer, 0)) + { + input_buffer->offset--; + goto fail; + } + + /* step back to character in front of the first element */ + input_buffer->offset--; + /* loop through the comma separated array elements */ + do + { + /* allocate next item */ + cJSON *new_item = cJSON_New_Item(&(input_buffer->hooks)); + if (new_item == NULL) + { + goto fail; /* allocation failure */ + } + + /* attach next item to list */ + if (head == NULL) + { + /* start the linked list */ + current_item = head = new_item; + } + else + { + /* add to the end and advance */ + current_item->next = new_item; + new_item->prev = current_item; + current_item = new_item; + } + + /* parse the name of the child */ + input_buffer->offset++; + buffer_skip_whitespace(input_buffer); + if (!parse_string(current_item, input_buffer)) + { + goto fail; /* failed to parse name */ + } + buffer_skip_whitespace(input_buffer); + + /* swap valuestring and string, because we parsed the name */ + current_item->string = current_item->valuestring; + current_item->valuestring = NULL; + + if (cannot_access_at_index(input_buffer, 0) || (buffer_at_offset(input_buffer)[0] != ':')) + { + goto fail; /* invalid object */ + } + + /* parse the value */ + input_buffer->offset++; + buffer_skip_whitespace(input_buffer); + if (!parse_value(current_item, input_buffer)) + { + goto fail; /* failed to parse value */ + } + buffer_skip_whitespace(input_buffer); + } + while (can_access_at_index(input_buffer, 0) && (buffer_at_offset(input_buffer)[0] == ',')); + + if (cannot_access_at_index(input_buffer, 0) || (buffer_at_offset(input_buffer)[0] != '}')) + { + goto fail; /* expected end of object */ + } + +success: + input_buffer->depth--; + + if (head != NULL) { + head->prev = current_item; + } + + item->type = cJSON_Object; + item->child = head; + + input_buffer->offset++; + return true; + +fail: + if (head != NULL) + { + cJSON_Delete(head); + } + + return false; +} + +/* Render an object to text. */ +static cJSON_bool print_object(const cJSON * const item, printbuffer * const output_buffer) +{ + unsigned char *output_pointer = NULL; + size_t length = 0; + cJSON *current_item = item->child; + + if (output_buffer == NULL) + { + return false; + } + + /* Compose the output: */ + length = (size_t) (output_buffer->format ? 2 : 1); /* fmt: {\n */ + output_pointer = ensure(output_buffer, length + 1); + if (output_pointer == NULL) + { + return false; + } + + *output_pointer++ = '{'; + output_buffer->depth++; + if (output_buffer->format) + { + *output_pointer++ = '\n'; + } + output_buffer->offset += length; + + while (current_item) + { + if (output_buffer->format) + { + size_t i; + output_pointer = ensure(output_buffer, output_buffer->depth); + if (output_pointer == NULL) + { + return false; + } + for (i = 0; i < output_buffer->depth; i++) + { + *output_pointer++ = '\t'; + } + output_buffer->offset += output_buffer->depth; + } + + /* print key */ + if (!print_string_ptr((unsigned char*)current_item->string, output_buffer)) + { + return false; + } + update_offset(output_buffer); + + length = (size_t) (output_buffer->format ? 2 : 1); + output_pointer = ensure(output_buffer, length); + if (output_pointer == NULL) + { + return false; + } + *output_pointer++ = ':'; + if (output_buffer->format) + { + *output_pointer++ = '\t'; + } + output_buffer->offset += length; + + /* print value */ + if (!print_value(current_item, output_buffer)) + { + return false; + } + update_offset(output_buffer); + + /* print comma if not last */ + length = ((size_t)(output_buffer->format ? 1 : 0) + (size_t)(current_item->next ? 1 : 0)); + output_pointer = ensure(output_buffer, length + 1); + if (output_pointer == NULL) + { + return false; + } + if (current_item->next) + { + *output_pointer++ = ','; + } + + if (output_buffer->format) + { + *output_pointer++ = '\n'; + } + *output_pointer = '\0'; + output_buffer->offset += length; + + current_item = current_item->next; + } + + output_pointer = ensure(output_buffer, output_buffer->format ? (output_buffer->depth + 1) : 2); + if (output_pointer == NULL) + { + return false; + } + if (output_buffer->format) + { + size_t i; + for (i = 0; i < (output_buffer->depth - 1); i++) + { + *output_pointer++ = '\t'; + } + } + *output_pointer++ = '}'; + *output_pointer = '\0'; + output_buffer->depth--; + + return true; +} + +/* Get Array size/item / object item. */ +CJSON_PUBLIC(int) cJSON_GetArraySize(const cJSON *array) +{ + cJSON *child = NULL; + size_t size = 0; + + if (array == NULL) + { + return 0; + } + + child = array->child; + + while(child != NULL) + { + size++; + child = child->next; + } + + /* FIXME: Can overflow here. Cannot be fixed without breaking the API */ + + return (int)size; +} + +static cJSON* get_array_item(const cJSON *array, size_t index) +{ + cJSON *current_child = NULL; + + if (array == NULL) + { + return NULL; + } + + current_child = array->child; + while ((current_child != NULL) && (index > 0)) + { + index--; + current_child = current_child->next; + } + + return current_child; +} + +CJSON_PUBLIC(cJSON *) cJSON_GetArrayItem(const cJSON *array, int index) +{ + if (index < 0) + { + return NULL; + } + + return get_array_item(array, (size_t)index); +} + +static cJSON *get_object_item(const cJSON * const object, const char * const name, const cJSON_bool case_sensitive) +{ + cJSON *current_element = NULL; + + if ((object == NULL) || (name == NULL)) + { + return NULL; + } + + current_element = object->child; + if (case_sensitive) + { + while ((current_element != NULL) && (current_element->string != NULL) && (strcmp(name, current_element->string) != 0)) + { + current_element = current_element->next; + } + } + else + { + while ((current_element != NULL) && (case_insensitive_strcmp((const unsigned char*)name, (const unsigned char*)(current_element->string)) != 0)) + { + current_element = current_element->next; + } + } + + if ((current_element == NULL) || (current_element->string == NULL)) { + return NULL; + } + + return current_element; +} + +CJSON_PUBLIC(cJSON *) cJSON_GetObjectItem(const cJSON * const object, const char * const string) +{ + return get_object_item(object, string, false); +} + +CJSON_PUBLIC(cJSON *) cJSON_GetObjectItemCaseSensitive(const cJSON * const object, const char * const string) +{ + return get_object_item(object, string, true); +} + +CJSON_PUBLIC(cJSON_bool) cJSON_HasObjectItem(const cJSON *object, const char *string) +{ + return cJSON_GetObjectItem(object, string) ? 1 : 0; +} + +/* Utility for array list handling. */ +static void suffix_object(cJSON *prev, cJSON *item) +{ + prev->next = item; + item->prev = prev; +} + +/* Utility for handling references. */ +static cJSON *create_reference(const cJSON *item, const internal_hooks * const hooks) +{ + cJSON *reference = NULL; + if (item == NULL) + { + return NULL; + } + + reference = cJSON_New_Item(hooks); + if (reference == NULL) + { + return NULL; + } + + memcpy(reference, item, sizeof(cJSON)); + reference->string = NULL; + reference->type |= cJSON_IsReference; + reference->next = reference->prev = NULL; + return reference; +} + +static cJSON_bool add_item_to_array(cJSON *array, cJSON *item) +{ + cJSON *child = NULL; + + if ((item == NULL) || (array == NULL) || (array == item)) + { + return false; + } + + child = array->child; + /* + * To find the last item in array quickly, we use prev in array + */ + if (child == NULL) + { + /* list is empty, start new one */ + array->child = item; + item->prev = item; + item->next = NULL; + } + else + { + /* append to the end */ + if (child->prev) + { + suffix_object(child->prev, item); + array->child->prev = item; + } + } + + return true; +} + +/* Add item to array/object. */ +CJSON_PUBLIC(cJSON_bool) cJSON_AddItemToArray(cJSON *array, cJSON *item) +{ + return add_item_to_array(array, item); +} + +#if defined(__clang__) || (defined(__GNUC__) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 5)))) + #pragma GCC diagnostic push +#endif +#ifdef __GNUC__ +#pragma GCC diagnostic ignored "-Wcast-qual" +#endif +/* helper function to cast away const */ +static void* cast_away_const(const void* string) +{ + return (void*)string; +} +#if defined(__clang__) || (defined(__GNUC__) && ((__GNUC__ > 4) || ((__GNUC__ == 4) && (__GNUC_MINOR__ > 5)))) + #pragma GCC diagnostic pop +#endif + + +static cJSON_bool add_item_to_object(cJSON * const object, const char * const string, cJSON * const item, const internal_hooks * const hooks, const cJSON_bool constant_key) +{ + char *new_key = NULL; + int new_type = cJSON_Invalid; + + if ((object == NULL) || (string == NULL) || (item == NULL) || (object == item)) + { + return false; + } + + if (constant_key) + { + new_key = (char*)cast_away_const(string); + new_type = item->type | cJSON_StringIsConst; + } + else + { + new_key = (char*)cJSON_strdup((const unsigned char*)string, hooks); + if (new_key == NULL) + { + return false; + } + + new_type = item->type & ~cJSON_StringIsConst; + } + + if (!(item->type & cJSON_StringIsConst) && (item->string != NULL)) + { + hooks->deallocate(item->string); + } + + item->string = new_key; + item->type = new_type; + + return add_item_to_array(object, item); +} + +CJSON_PUBLIC(cJSON_bool) cJSON_AddItemToObject(cJSON *object, const char *string, cJSON *item) +{ + return add_item_to_object(object, string, item, &global_hooks, false); +} + +/* Add an item to an object with constant string as key */ +CJSON_PUBLIC(cJSON_bool) cJSON_AddItemToObjectCS(cJSON *object, const char *string, cJSON *item) +{ + return add_item_to_object(object, string, item, &global_hooks, true); +} + +CJSON_PUBLIC(cJSON_bool) cJSON_AddItemReferenceToArray(cJSON *array, cJSON *item) +{ + if (array == NULL) + { + return false; + } + + return add_item_to_array(array, create_reference(item, &global_hooks)); +} + +CJSON_PUBLIC(cJSON_bool) cJSON_AddItemReferenceToObject(cJSON *object, const char *string, cJSON *item) +{ + if ((object == NULL) || (string == NULL)) + { + return false; + } + + return add_item_to_object(object, string, create_reference(item, &global_hooks), &global_hooks, false); +} + +CJSON_PUBLIC(cJSON*) cJSON_AddNullToObject(cJSON * const object, const char * const name) +{ + cJSON *null = cJSON_CreateNull(); + if (add_item_to_object(object, name, null, &global_hooks, false)) + { + return null; + } + + cJSON_Delete(null); + return NULL; +} + +CJSON_PUBLIC(cJSON*) cJSON_AddTrueToObject(cJSON * const object, const char * const name) +{ + cJSON *true_item = cJSON_CreateTrue(); + if (add_item_to_object(object, name, true_item, &global_hooks, false)) + { + return true_item; + } + + cJSON_Delete(true_item); + return NULL; +} + +CJSON_PUBLIC(cJSON*) cJSON_AddFalseToObject(cJSON * const object, const char * const name) +{ + cJSON *false_item = cJSON_CreateFalse(); + if (add_item_to_object(object, name, false_item, &global_hooks, false)) + { + return false_item; + } + + cJSON_Delete(false_item); + return NULL; +} + +CJSON_PUBLIC(cJSON*) cJSON_AddBoolToObject(cJSON * const object, const char * const name, const cJSON_bool boolean) +{ + cJSON *bool_item = cJSON_CreateBool(boolean); + if (add_item_to_object(object, name, bool_item, &global_hooks, false)) + { + return bool_item; + } + + cJSON_Delete(bool_item); + return NULL; +} + +CJSON_PUBLIC(cJSON*) cJSON_AddNumberToObject(cJSON * const object, const char * const name, const double number) +{ + cJSON *number_item = cJSON_CreateNumber(number); + if (add_item_to_object(object, name, number_item, &global_hooks, false)) + { + return number_item; + } + + cJSON_Delete(number_item); + return NULL; +} + +CJSON_PUBLIC(cJSON*) cJSON_AddStringToObject(cJSON * const object, const char * const name, const char * const string) +{ + cJSON *string_item = cJSON_CreateString(string); + if (add_item_to_object(object, name, string_item, &global_hooks, false)) + { + return string_item; + } + + cJSON_Delete(string_item); + return NULL; +} + +CJSON_PUBLIC(cJSON*) cJSON_AddRawToObject(cJSON * const object, const char * const name, const char * const raw) +{ + cJSON *raw_item = cJSON_CreateRaw(raw); + if (add_item_to_object(object, name, raw_item, &global_hooks, false)) + { + return raw_item; + } + + cJSON_Delete(raw_item); + return NULL; +} + +CJSON_PUBLIC(cJSON*) cJSON_AddObjectToObject(cJSON * const object, const char * const name) +{ + cJSON *object_item = cJSON_CreateObject(); + if (add_item_to_object(object, name, object_item, &global_hooks, false)) + { + return object_item; + } + + cJSON_Delete(object_item); + return NULL; +} + +CJSON_PUBLIC(cJSON*) cJSON_AddArrayToObject(cJSON * const object, const char * const name) +{ + cJSON *array = cJSON_CreateArray(); + if (add_item_to_object(object, name, array, &global_hooks, false)) + { + return array; + } + + cJSON_Delete(array); + return NULL; +} + +CJSON_PUBLIC(cJSON *) cJSON_DetachItemViaPointer(cJSON *parent, cJSON * const item) +{ + if ((parent == NULL) || (item == NULL)) + { + return NULL; + } + + if (item != parent->child) + { + /* not the first element */ + item->prev->next = item->next; + } + if (item->next != NULL) + { + /* not the last element */ + item->next->prev = item->prev; + } + + if (item == parent->child) + { + /* first element */ + parent->child = item->next; + } + else if (item->next == NULL) + { + /* last element */ + parent->child->prev = item->prev; + } + + /* make sure the detached item doesn't point anywhere anymore */ + item->prev = NULL; + item->next = NULL; + + return item; +} + +CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromArray(cJSON *array, int which) +{ + if (which < 0) + { + return NULL; + } + + return cJSON_DetachItemViaPointer(array, get_array_item(array, (size_t)which)); +} + +CJSON_PUBLIC(void) cJSON_DeleteItemFromArray(cJSON *array, int which) +{ + cJSON_Delete(cJSON_DetachItemFromArray(array, which)); +} + +CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromObject(cJSON *object, const char *string) +{ + cJSON *to_detach = cJSON_GetObjectItem(object, string); + + return cJSON_DetachItemViaPointer(object, to_detach); +} + +CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromObjectCaseSensitive(cJSON *object, const char *string) +{ + cJSON *to_detach = cJSON_GetObjectItemCaseSensitive(object, string); + + return cJSON_DetachItemViaPointer(object, to_detach); +} + +CJSON_PUBLIC(void) cJSON_DeleteItemFromObject(cJSON *object, const char *string) +{ + cJSON_Delete(cJSON_DetachItemFromObject(object, string)); +} + +CJSON_PUBLIC(void) cJSON_DeleteItemFromObjectCaseSensitive(cJSON *object, const char *string) +{ + cJSON_Delete(cJSON_DetachItemFromObjectCaseSensitive(object, string)); +} + +/* Replace array/object items with new ones. */ +CJSON_PUBLIC(cJSON_bool) cJSON_InsertItemInArray(cJSON *array, int which, cJSON *newitem) +{ + cJSON *after_inserted = NULL; + + if (which < 0) + { + return false; + } + + after_inserted = get_array_item(array, (size_t)which); + if (after_inserted == NULL) + { + return add_item_to_array(array, newitem); + } + + newitem->next = after_inserted; + newitem->prev = after_inserted->prev; + after_inserted->prev = newitem; + if (after_inserted == array->child) + { + array->child = newitem; + } + else + { + newitem->prev->next = newitem; + } + return true; +} + +CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemViaPointer(cJSON * const parent, cJSON * const item, cJSON * replacement) +{ + if ((parent == NULL) || (parent->child == NULL) || (replacement == NULL) || (item == NULL)) + { + return false; + } + + if (replacement == item) + { + return true; + } + + replacement->next = item->next; + replacement->prev = item->prev; + + if (replacement->next != NULL) + { + replacement->next->prev = replacement; + } + if (parent->child == item) + { + if (parent->child->prev == parent->child) + { + replacement->prev = replacement; + } + parent->child = replacement; + } + else + { /* + * To find the last item in array quickly, we use prev in array. + * We can't modify the last item's next pointer where this item was the parent's child + */ + if (replacement->prev != NULL) + { + replacement->prev->next = replacement; + } + if (replacement->next == NULL) + { + parent->child->prev = replacement; + } + } + + item->next = NULL; + item->prev = NULL; + cJSON_Delete(item); + + return true; +} + +CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemInArray(cJSON *array, int which, cJSON *newitem) +{ + if (which < 0) + { + return false; + } + + return cJSON_ReplaceItemViaPointer(array, get_array_item(array, (size_t)which), newitem); +} + +static cJSON_bool replace_item_in_object(cJSON *object, const char *string, cJSON *replacement, cJSON_bool case_sensitive) +{ + if ((replacement == NULL) || (string == NULL)) + { + return false; + } + + /* replace the name in the replacement */ + if (!(replacement->type & cJSON_StringIsConst) && (replacement->string != NULL)) + { + cJSON_free(replacement->string); + } + replacement->string = (char*)cJSON_strdup((const unsigned char*)string, &global_hooks); + if (replacement->string == NULL) + { + return false; + } + + replacement->type &= ~cJSON_StringIsConst; + + return cJSON_ReplaceItemViaPointer(object, get_object_item(object, string, case_sensitive), replacement); +} + +CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemInObject(cJSON *object, const char *string, cJSON *newitem) +{ + return replace_item_in_object(object, string, newitem, false); +} + +CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemInObjectCaseSensitive(cJSON *object, const char *string, cJSON *newitem) +{ + return replace_item_in_object(object, string, newitem, true); +} + +/* Create basic types: */ +CJSON_PUBLIC(cJSON *) cJSON_CreateNull(void) +{ + cJSON *item = cJSON_New_Item(&global_hooks); + if(item) + { + item->type = cJSON_NULL; + } + + return item; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateTrue(void) +{ + cJSON *item = cJSON_New_Item(&global_hooks); + if(item) + { + item->type = cJSON_True; + } + + return item; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateFalse(void) +{ + cJSON *item = cJSON_New_Item(&global_hooks); + if(item) + { + item->type = cJSON_False; + } + + return item; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateBool(cJSON_bool boolean) +{ + cJSON *item = cJSON_New_Item(&global_hooks); + if(item) + { + item->type = boolean ? cJSON_True : cJSON_False; + } + + return item; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateNumber(double num) +{ + cJSON *item = cJSON_New_Item(&global_hooks); + if(item) + { + item->type = cJSON_Number; + item->valuedouble = num; + + /* use saturation in case of overflow */ + if (num >= INT_MAX) + { + item->valueint = INT_MAX; + } + else if (num <= (double)INT_MIN) + { + item->valueint = INT_MIN; + } + else + { + item->valueint = (int)num; + } + } + + return item; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateString(const char *string) +{ + cJSON *item = cJSON_New_Item(&global_hooks); + if(item) + { + item->type = cJSON_String; + item->valuestring = (char*)cJSON_strdup((const unsigned char*)string, &global_hooks); + if(!item->valuestring) + { + cJSON_Delete(item); + return NULL; + } + } + + return item; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateStringReference(const char *string) +{ + cJSON *item = cJSON_New_Item(&global_hooks); + if (item != NULL) + { + item->type = cJSON_String | cJSON_IsReference; + item->valuestring = (char*)cast_away_const(string); + } + + return item; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateObjectReference(const cJSON *child) +{ + cJSON *item = cJSON_New_Item(&global_hooks); + if (item != NULL) { + item->type = cJSON_Object | cJSON_IsReference; + item->child = (cJSON*)cast_away_const(child); + } + + return item; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateArrayReference(const cJSON *child) { + cJSON *item = cJSON_New_Item(&global_hooks); + if (item != NULL) { + item->type = cJSON_Array | cJSON_IsReference; + item->child = (cJSON*)cast_away_const(child); + } + + return item; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateRaw(const char *raw) +{ + cJSON *item = cJSON_New_Item(&global_hooks); + if(item) + { + item->type = cJSON_Raw; + item->valuestring = (char*)cJSON_strdup((const unsigned char*)raw, &global_hooks); + if(!item->valuestring) + { + cJSON_Delete(item); + return NULL; + } + } + + return item; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateArray(void) +{ + cJSON *item = cJSON_New_Item(&global_hooks); + if(item) + { + item->type=cJSON_Array; + } + + return item; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateObject(void) +{ + cJSON *item = cJSON_New_Item(&global_hooks); + if (item) + { + item->type = cJSON_Object; + } + + return item; +} + +/* Create Arrays: */ +CJSON_PUBLIC(cJSON *) cJSON_CreateIntArray(const int *numbers, int count) +{ + size_t i = 0; + cJSON *n = NULL; + cJSON *p = NULL; + cJSON *a = NULL; + + if ((count < 0) || (numbers == NULL)) + { + return NULL; + } + + a = cJSON_CreateArray(); + + for(i = 0; a && (i < (size_t)count); i++) + { + n = cJSON_CreateNumber(numbers[i]); + if (!n) + { + cJSON_Delete(a); + return NULL; + } + if(!i) + { + a->child = n; + } + else + { + suffix_object(p, n); + } + p = n; + } + + if (a && a->child) { + a->child->prev = n; + } + + return a; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateFloatArray(const float *numbers, int count) +{ + size_t i = 0; + cJSON *n = NULL; + cJSON *p = NULL; + cJSON *a = NULL; + + if ((count < 0) || (numbers == NULL)) + { + return NULL; + } + + a = cJSON_CreateArray(); + + for(i = 0; a && (i < (size_t)count); i++) + { + n = cJSON_CreateNumber((double)numbers[i]); + if(!n) + { + cJSON_Delete(a); + return NULL; + } + if(!i) + { + a->child = n; + } + else + { + suffix_object(p, n); + } + p = n; + } + + if (a && a->child) { + a->child->prev = n; + } + + return a; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateDoubleArray(const double *numbers, int count) +{ + size_t i = 0; + cJSON *n = NULL; + cJSON *p = NULL; + cJSON *a = NULL; + + if ((count < 0) || (numbers == NULL)) + { + return NULL; + } + + a = cJSON_CreateArray(); + + for(i = 0; a && (i < (size_t)count); i++) + { + n = cJSON_CreateNumber(numbers[i]); + if(!n) + { + cJSON_Delete(a); + return NULL; + } + if(!i) + { + a->child = n; + } + else + { + suffix_object(p, n); + } + p = n; + } + + if (a && a->child) { + a->child->prev = n; + } + + return a; +} + +CJSON_PUBLIC(cJSON *) cJSON_CreateStringArray(const char *const *strings, int count) +{ + size_t i = 0; + cJSON *n = NULL; + cJSON *p = NULL; + cJSON *a = NULL; + + if ((count < 0) || (strings == NULL)) + { + return NULL; + } + + a = cJSON_CreateArray(); + + for (i = 0; a && (i < (size_t)count); i++) + { + n = cJSON_CreateString(strings[i]); + if(!n) + { + cJSON_Delete(a); + return NULL; + } + if(!i) + { + a->child = n; + } + else + { + suffix_object(p,n); + } + p = n; + } + + if (a && a->child) { + a->child->prev = n; + } + + return a; +} + +/* Duplication */ +CJSON_PUBLIC(cJSON *) cJSON_Duplicate(const cJSON *item, cJSON_bool recurse) +{ + cJSON *newitem = NULL; + cJSON *child = NULL; + cJSON *next = NULL; + cJSON *newchild = NULL; + + /* Bail on bad ptr */ + if (!item) + { + goto fail; + } + /* Create new item */ + newitem = cJSON_New_Item(&global_hooks); + if (!newitem) + { + goto fail; + } + /* Copy over all vars */ + newitem->type = item->type & (~cJSON_IsReference); + newitem->valueint = item->valueint; + newitem->valuedouble = item->valuedouble; + if (item->valuestring) + { + newitem->valuestring = (char*)cJSON_strdup((unsigned char*)item->valuestring, &global_hooks); + if (!newitem->valuestring) + { + goto fail; + } + } + if (item->string) + { + newitem->string = (item->type&cJSON_StringIsConst) ? item->string : (char*)cJSON_strdup((unsigned char*)item->string, &global_hooks); + if (!newitem->string) + { + goto fail; + } + } + /* If non-recursive, then we're done! */ + if (!recurse) + { + return newitem; + } + /* Walk the ->next chain for the child. */ + child = item->child; + while (child != NULL) + { + newchild = cJSON_Duplicate(child, true); /* Duplicate (with recurse) each item in the ->next chain */ + if (!newchild) + { + goto fail; + } + if (next != NULL) + { + /* If newitem->child already set, then crosswire ->prev and ->next and move on */ + next->next = newchild; + newchild->prev = next; + next = newchild; + } + else + { + /* Set newitem->child and move to it */ + newitem->child = newchild; + next = newchild; + } + child = child->next; + } + if (newitem && newitem->child) + { + newitem->child->prev = newchild; + } + + return newitem; + +fail: + if (newitem != NULL) + { + cJSON_Delete(newitem); + } + + return NULL; +} + +static void skip_oneline_comment(char **input) +{ + *input += static_strlen("//"); + + for (; (*input)[0] != '\0'; ++(*input)) + { + if ((*input)[0] == '\n') { + *input += static_strlen("\n"); + return; + } + } +} + +static void skip_multiline_comment(char **input) +{ + *input += static_strlen("/*"); + + for (; (*input)[0] != '\0'; ++(*input)) + { + if (((*input)[0] == '*') && ((*input)[1] == '/')) + { + *input += static_strlen("*/"); + return; + } + } +} + +static void minify_string(char **input, char **output) { + (*output)[0] = (*input)[0]; + *input += static_strlen("\""); + *output += static_strlen("\""); + + + for (; (*input)[0] != '\0'; (void)++(*input), ++(*output)) { + (*output)[0] = (*input)[0]; + + if ((*input)[0] == '\"') { + (*output)[0] = '\"'; + *input += static_strlen("\""); + *output += static_strlen("\""); + return; + } else if (((*input)[0] == '\\') && ((*input)[1] == '\"')) { + (*output)[1] = (*input)[1]; + *input += static_strlen("\""); + *output += static_strlen("\""); + } + } +} + +CJSON_PUBLIC(void) cJSON_Minify(char *json) +{ + char *into = json; + + if (json == NULL) + { + return; + } + + while (json[0] != '\0') + { + switch (json[0]) + { + case ' ': + case '\t': + case '\r': + case '\n': + json++; + break; + + case '/': + if (json[1] == '/') + { + skip_oneline_comment(&json); + } + else if (json[1] == '*') + { + skip_multiline_comment(&json); + } else { + json++; + } + break; + + case '\"': + minify_string(&json, (char**)&into); + break; + + default: + into[0] = json[0]; + json++; + into++; + } + } + + /* and null-terminate. */ + *into = '\0'; +} + +CJSON_PUBLIC(cJSON_bool) cJSON_IsInvalid(const cJSON * const item) +{ + if (item == NULL) + { + return false; + } + + return (item->type & 0xFF) == cJSON_Invalid; +} + +CJSON_PUBLIC(cJSON_bool) cJSON_IsFalse(const cJSON * const item) +{ + if (item == NULL) + { + return false; + } + + return (item->type & 0xFF) == cJSON_False; +} + +CJSON_PUBLIC(cJSON_bool) cJSON_IsTrue(const cJSON * const item) +{ + if (item == NULL) + { + return false; + } + + return (item->type & 0xff) == cJSON_True; +} + + +CJSON_PUBLIC(cJSON_bool) cJSON_IsBool(const cJSON * const item) +{ + if (item == NULL) + { + return false; + } + + return (item->type & (cJSON_True | cJSON_False)) != 0; +} +CJSON_PUBLIC(cJSON_bool) cJSON_IsNull(const cJSON * const item) +{ + if (item == NULL) + { + return false; + } + + return (item->type & 0xFF) == cJSON_NULL; +} + +CJSON_PUBLIC(cJSON_bool) cJSON_IsNumber(const cJSON * const item) +{ + if (item == NULL) + { + return false; + } + + return (item->type & 0xFF) == cJSON_Number; +} + +CJSON_PUBLIC(cJSON_bool) cJSON_IsString(const cJSON * const item) +{ + if (item == NULL) + { + return false; + } + + return (item->type & 0xFF) == cJSON_String; +} + +CJSON_PUBLIC(cJSON_bool) cJSON_IsArray(const cJSON * const item) +{ + if (item == NULL) + { + return false; + } + + return (item->type & 0xFF) == cJSON_Array; +} + +CJSON_PUBLIC(cJSON_bool) cJSON_IsObject(const cJSON * const item) +{ + if (item == NULL) + { + return false; + } + + return (item->type & 0xFF) == cJSON_Object; +} + +CJSON_PUBLIC(cJSON_bool) cJSON_IsRaw(const cJSON * const item) +{ + if (item == NULL) + { + return false; + } + + return (item->type & 0xFF) == cJSON_Raw; +} + +CJSON_PUBLIC(cJSON_bool) cJSON_Compare(const cJSON * const a, const cJSON * const b, const cJSON_bool case_sensitive) +{ + if ((a == NULL) || (b == NULL) || ((a->type & 0xFF) != (b->type & 0xFF))) + { + return false; + } + + /* check if type is valid */ + switch (a->type & 0xFF) + { + case cJSON_False: + case cJSON_True: + case cJSON_NULL: + case cJSON_Number: + case cJSON_String: + case cJSON_Raw: + case cJSON_Array: + case cJSON_Object: + break; + + default: + return false; + } + + /* identical objects are equal */ + if (a == b) + { + return true; + } + + switch (a->type & 0xFF) + { + /* in these cases and equal type is enough */ + case cJSON_False: + case cJSON_True: + case cJSON_NULL: + return true; + + case cJSON_Number: + if (compare_double(a->valuedouble, b->valuedouble)) + { + return true; + } + return false; + + case cJSON_String: + case cJSON_Raw: + if ((a->valuestring == NULL) || (b->valuestring == NULL)) + { + return false; + } + if (strcmp(a->valuestring, b->valuestring) == 0) + { + return true; + } + + return false; + + case cJSON_Array: + { + cJSON *a_element = a->child; + cJSON *b_element = b->child; + + for (; (a_element != NULL) && (b_element != NULL);) + { + if (!cJSON_Compare(a_element, b_element, case_sensitive)) + { + return false; + } + + a_element = a_element->next; + b_element = b_element->next; + } + + /* one of the arrays is longer than the other */ + if (a_element != b_element) { + return false; + } + + return true; + } + + case cJSON_Object: + { + cJSON *a_element = NULL; + cJSON *b_element = NULL; + cJSON_ArrayForEach(a_element, a) + { + /* TODO This has O(n^2) runtime, which is horrible! */ + b_element = get_object_item(b, a_element->string, case_sensitive); + if (b_element == NULL) + { + return false; + } + + if (!cJSON_Compare(a_element, b_element, case_sensitive)) + { + return false; + } + } + + /* doing this twice, once on a and b to prevent true comparison if a subset of b + * TODO: Do this the proper way, this is just a fix for now */ + cJSON_ArrayForEach(b_element, b) + { + a_element = get_object_item(a, b_element->string, case_sensitive); + if (a_element == NULL) + { + return false; + } + + if (!cJSON_Compare(b_element, a_element, case_sensitive)) + { + return false; + } + } + + return true; + } + + default: + return false; + } +} + +CJSON_PUBLIC(void *) cJSON_malloc(size_t size) +{ + return global_hooks.allocate(size); +} + +CJSON_PUBLIC(void) cJSON_free(void *object) +{ + global_hooks.deallocate(object); +} diff --git a/cJSON/cJSON.h b/cJSON/cJSON.h new file mode 100644 index 0000000..2628d76 --- /dev/null +++ b/cJSON/cJSON.h @@ -0,0 +1,300 @@ +/* + Copyright (c) 2009-2017 Dave Gamble and cJSON contributors + + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to deal + in the Software without restriction, including without limitation the rights + to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in + all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN + THE SOFTWARE. +*/ + +#ifndef cJSON__h +#define cJSON__h + +#ifdef __cplusplus +extern "C" +{ +#endif + +#if !defined(__WINDOWS__) && (defined(WIN32) || defined(WIN64) || defined(_MSC_VER) || defined(_WIN32)) +#define __WINDOWS__ +#endif + +#ifdef __WINDOWS__ + +/* When compiling for windows, we specify a specific calling convention to avoid issues where we are being called from a project with a different default calling convention. For windows you have 3 define options: + +CJSON_HIDE_SYMBOLS - Define this in the case where you don't want to ever dllexport symbols +CJSON_EXPORT_SYMBOLS - Define this on library build when you want to dllexport symbols (default) +CJSON_IMPORT_SYMBOLS - Define this if you want to dllimport symbol + +For *nix builds that support visibility attribute, you can define similar behavior by + +setting default visibility to hidden by adding +-fvisibility=hidden (for gcc) +or +-xldscope=hidden (for sun cc) +to CFLAGS + +then using the CJSON_API_VISIBILITY flag to "export" the same symbols the way CJSON_EXPORT_SYMBOLS does + +*/ + +#define CJSON_CDECL __cdecl +#define CJSON_STDCALL __stdcall + +/* export symbols by default, this is necessary for copy pasting the C and header file */ +#if !defined(CJSON_HIDE_SYMBOLS) && !defined(CJSON_IMPORT_SYMBOLS) && !defined(CJSON_EXPORT_SYMBOLS) +#define CJSON_EXPORT_SYMBOLS +#endif + +#if defined(CJSON_HIDE_SYMBOLS) +#define CJSON_PUBLIC(type) type CJSON_STDCALL +#elif defined(CJSON_EXPORT_SYMBOLS) +#define CJSON_PUBLIC(type) __declspec(dllexport) type CJSON_STDCALL +#elif defined(CJSON_IMPORT_SYMBOLS) +#define CJSON_PUBLIC(type) __declspec(dllimport) type CJSON_STDCALL +#endif +#else /* !__WINDOWS__ */ +#define CJSON_CDECL +#define CJSON_STDCALL + +#if (defined(__GNUC__) || defined(__SUNPRO_CC) || defined (__SUNPRO_C)) && defined(CJSON_API_VISIBILITY) +#define CJSON_PUBLIC(type) __attribute__((visibility("default"))) type +#else +#define CJSON_PUBLIC(type) type +#endif +#endif + +/* project version */ +#define CJSON_VERSION_MAJOR 1 +#define CJSON_VERSION_MINOR 7 +#define CJSON_VERSION_PATCH 16 + +#include + +/* cJSON Types: */ +#define cJSON_Invalid (0) +#define cJSON_False (1 << 0) +#define cJSON_True (1 << 1) +#define cJSON_NULL (1 << 2) +#define cJSON_Number (1 << 3) +#define cJSON_String (1 << 4) +#define cJSON_Array (1 << 5) +#define cJSON_Object (1 << 6) +#define cJSON_Raw (1 << 7) /* raw json */ + +#define cJSON_IsReference 256 +#define cJSON_StringIsConst 512 + +/* The cJSON structure: */ +typedef struct cJSON +{ + /* next/prev allow you to walk array/object chains. Alternatively, use GetArraySize/GetArrayItem/GetObjectItem */ + struct cJSON *next; + struct cJSON *prev; + /* An array or object item will have a child pointer pointing to a chain of the items in the array/object. */ + struct cJSON *child; + + /* The type of the item, as above. */ + int type; + + /* The item's string, if type==cJSON_String and type == cJSON_Raw */ + char *valuestring; + /* writing to valueint is DEPRECATED, use cJSON_SetNumberValue instead */ + int valueint; + /* The item's number, if type==cJSON_Number */ + double valuedouble; + + /* The item's name string, if this item is the child of, or is in the list of subitems of an object. */ + char *string; +} cJSON; + +typedef struct cJSON_Hooks +{ + /* malloc/free are CDECL on Windows regardless of the default calling convention of the compiler, so ensure the hooks allow passing those functions directly. */ + void *(CJSON_CDECL *malloc_fn)(size_t sz); + void (CJSON_CDECL *free_fn)(void *ptr); +} cJSON_Hooks; + +typedef int cJSON_bool; + +/* Limits how deeply nested arrays/objects can be before cJSON rejects to parse them. + * This is to prevent stack overflows. */ +#ifndef CJSON_NESTING_LIMIT +#define CJSON_NESTING_LIMIT 1000 +#endif + +/* returns the version of cJSON as a string */ +CJSON_PUBLIC(const char*) cJSON_Version(void); + +/* Supply malloc, realloc and free functions to cJSON */ +CJSON_PUBLIC(void) cJSON_InitHooks(cJSON_Hooks* hooks); + +/* Memory Management: the caller is always responsible to free the results from all variants of cJSON_Parse (with cJSON_Delete) and cJSON_Print (with stdlib free, cJSON_Hooks.free_fn, or cJSON_free as appropriate). The exception is cJSON_PrintPreallocated, where the caller has full responsibility of the buffer. */ +/* Supply a block of JSON, and this returns a cJSON object you can interrogate. */ +CJSON_PUBLIC(cJSON *) cJSON_Parse(const char *value); +CJSON_PUBLIC(cJSON *) cJSON_ParseWithLength(const char *value, size_t buffer_length); +/* ParseWithOpts allows you to require (and check) that the JSON is null terminated, and to retrieve the pointer to the final byte parsed. */ +/* If you supply a ptr in return_parse_end and parsing fails, then return_parse_end will contain a pointer to the error so will match cJSON_GetErrorPtr(). */ +CJSON_PUBLIC(cJSON *) cJSON_ParseWithOpts(const char *value, const char **return_parse_end, cJSON_bool require_null_terminated); +CJSON_PUBLIC(cJSON *) cJSON_ParseWithLengthOpts(const char *value, size_t buffer_length, const char **return_parse_end, cJSON_bool require_null_terminated); + +/* Render a cJSON entity to text for transfer/storage. */ +CJSON_PUBLIC(char *) cJSON_Print(const cJSON *item); +/* Render a cJSON entity to text for transfer/storage without any formatting. */ +CJSON_PUBLIC(char *) cJSON_PrintUnformatted(const cJSON *item); +/* Render a cJSON entity to text using a buffered strategy. prebuffer is a guess at the final size. guessing well reduces reallocation. fmt=0 gives unformatted, =1 gives formatted */ +CJSON_PUBLIC(char *) cJSON_PrintBuffered(const cJSON *item, int prebuffer, cJSON_bool fmt); +/* Render a cJSON entity to text using a buffer already allocated in memory with given length. Returns 1 on success and 0 on failure. */ +/* NOTE: cJSON is not always 100% accurate in estimating how much memory it will use, so to be safe allocate 5 bytes more than you actually need */ +CJSON_PUBLIC(cJSON_bool) cJSON_PrintPreallocated(cJSON *item, char *buffer, const int length, const cJSON_bool format); +/* Delete a cJSON entity and all subentities. */ +CJSON_PUBLIC(void) cJSON_Delete(cJSON *item); + +/* Returns the number of items in an array (or object). */ +CJSON_PUBLIC(int) cJSON_GetArraySize(const cJSON *array); +/* Retrieve item number "index" from array "array". Returns NULL if unsuccessful. */ +CJSON_PUBLIC(cJSON *) cJSON_GetArrayItem(const cJSON *array, int index); +/* Get item "string" from object. Case insensitive. */ +CJSON_PUBLIC(cJSON *) cJSON_GetObjectItem(const cJSON * const object, const char * const string); +CJSON_PUBLIC(cJSON *) cJSON_GetObjectItemCaseSensitive(const cJSON * const object, const char * const string); +CJSON_PUBLIC(cJSON_bool) cJSON_HasObjectItem(const cJSON *object, const char *string); +/* For analysing failed parses. This returns a pointer to the parse error. You'll probably need to look a few chars back to make sense of it. Defined when cJSON_Parse() returns 0. 0 when cJSON_Parse() succeeds. */ +CJSON_PUBLIC(const char *) cJSON_GetErrorPtr(void); + +/* Check item type and return its value */ +CJSON_PUBLIC(char *) cJSON_GetStringValue(const cJSON * const item); +CJSON_PUBLIC(double) cJSON_GetNumberValue(const cJSON * const item); + +/* These functions check the type of an item */ +CJSON_PUBLIC(cJSON_bool) cJSON_IsInvalid(const cJSON * const item); +CJSON_PUBLIC(cJSON_bool) cJSON_IsFalse(const cJSON * const item); +CJSON_PUBLIC(cJSON_bool) cJSON_IsTrue(const cJSON * const item); +CJSON_PUBLIC(cJSON_bool) cJSON_IsBool(const cJSON * const item); +CJSON_PUBLIC(cJSON_bool) cJSON_IsNull(const cJSON * const item); +CJSON_PUBLIC(cJSON_bool) cJSON_IsNumber(const cJSON * const item); +CJSON_PUBLIC(cJSON_bool) cJSON_IsString(const cJSON * const item); +CJSON_PUBLIC(cJSON_bool) cJSON_IsArray(const cJSON * const item); +CJSON_PUBLIC(cJSON_bool) cJSON_IsObject(const cJSON * const item); +CJSON_PUBLIC(cJSON_bool) cJSON_IsRaw(const cJSON * const item); + +/* These calls create a cJSON item of the appropriate type. */ +CJSON_PUBLIC(cJSON *) cJSON_CreateNull(void); +CJSON_PUBLIC(cJSON *) cJSON_CreateTrue(void); +CJSON_PUBLIC(cJSON *) cJSON_CreateFalse(void); +CJSON_PUBLIC(cJSON *) cJSON_CreateBool(cJSON_bool boolean); +CJSON_PUBLIC(cJSON *) cJSON_CreateNumber(double num); +CJSON_PUBLIC(cJSON *) cJSON_CreateString(const char *string); +/* raw json */ +CJSON_PUBLIC(cJSON *) cJSON_CreateRaw(const char *raw); +CJSON_PUBLIC(cJSON *) cJSON_CreateArray(void); +CJSON_PUBLIC(cJSON *) cJSON_CreateObject(void); + +/* Create a string where valuestring references a string so + * it will not be freed by cJSON_Delete */ +CJSON_PUBLIC(cJSON *) cJSON_CreateStringReference(const char *string); +/* Create an object/array that only references it's elements so + * they will not be freed by cJSON_Delete */ +CJSON_PUBLIC(cJSON *) cJSON_CreateObjectReference(const cJSON *child); +CJSON_PUBLIC(cJSON *) cJSON_CreateArrayReference(const cJSON *child); + +/* These utilities create an Array of count items. + * The parameter count cannot be greater than the number of elements in the number array, otherwise array access will be out of bounds.*/ +CJSON_PUBLIC(cJSON *) cJSON_CreateIntArray(const int *numbers, int count); +CJSON_PUBLIC(cJSON *) cJSON_CreateFloatArray(const float *numbers, int count); +CJSON_PUBLIC(cJSON *) cJSON_CreateDoubleArray(const double *numbers, int count); +CJSON_PUBLIC(cJSON *) cJSON_CreateStringArray(const char *const *strings, int count); + +/* Append item to the specified array/object. */ +CJSON_PUBLIC(cJSON_bool) cJSON_AddItemToArray(cJSON *array, cJSON *item); +CJSON_PUBLIC(cJSON_bool) cJSON_AddItemToObject(cJSON *object, const char *string, cJSON *item); +/* Use this when string is definitely const (i.e. a literal, or as good as), and will definitely survive the cJSON object. + * WARNING: When this function was used, make sure to always check that (item->type & cJSON_StringIsConst) is zero before + * writing to `item->string` */ +CJSON_PUBLIC(cJSON_bool) cJSON_AddItemToObjectCS(cJSON *object, const char *string, cJSON *item); +/* Append reference to item to the specified array/object. Use this when you want to add an existing cJSON to a new cJSON, but don't want to corrupt your existing cJSON. */ +CJSON_PUBLIC(cJSON_bool) cJSON_AddItemReferenceToArray(cJSON *array, cJSON *item); +CJSON_PUBLIC(cJSON_bool) cJSON_AddItemReferenceToObject(cJSON *object, const char *string, cJSON *item); + +/* Remove/Detach items from Arrays/Objects. */ +CJSON_PUBLIC(cJSON *) cJSON_DetachItemViaPointer(cJSON *parent, cJSON * const item); +CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromArray(cJSON *array, int which); +CJSON_PUBLIC(void) cJSON_DeleteItemFromArray(cJSON *array, int which); +CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromObject(cJSON *object, const char *string); +CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromObjectCaseSensitive(cJSON *object, const char *string); +CJSON_PUBLIC(void) cJSON_DeleteItemFromObject(cJSON *object, const char *string); +CJSON_PUBLIC(void) cJSON_DeleteItemFromObjectCaseSensitive(cJSON *object, const char *string); + +/* Update array items. */ +CJSON_PUBLIC(cJSON_bool) cJSON_InsertItemInArray(cJSON *array, int which, cJSON *newitem); /* Shifts pre-existing items to the right. */ +CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemViaPointer(cJSON * const parent, cJSON * const item, cJSON * replacement); +CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemInArray(cJSON *array, int which, cJSON *newitem); +CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemInObject(cJSON *object,const char *string,cJSON *newitem); +CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemInObjectCaseSensitive(cJSON *object,const char *string,cJSON *newitem); + +/* Duplicate a cJSON item */ +CJSON_PUBLIC(cJSON *) cJSON_Duplicate(const cJSON *item, cJSON_bool recurse); +/* Duplicate will create a new, identical cJSON item to the one you pass, in new memory that will + * need to be released. With recurse!=0, it will duplicate any children connected to the item. + * The item->next and ->prev pointers are always zero on return from Duplicate. */ +/* Recursively compare two cJSON items for equality. If either a or b is NULL or invalid, they will be considered unequal. + * case_sensitive determines if object keys are treated case sensitive (1) or case insensitive (0) */ +CJSON_PUBLIC(cJSON_bool) cJSON_Compare(const cJSON * const a, const cJSON * const b, const cJSON_bool case_sensitive); + +/* Minify a strings, remove blank characters(such as ' ', '\t', '\r', '\n') from strings. + * The input pointer json cannot point to a read-only address area, such as a string constant, + * but should point to a readable and writable address area. */ +CJSON_PUBLIC(void) cJSON_Minify(char *json); + +/* Helper functions for creating and adding items to an object at the same time. + * They return the added item or NULL on failure. */ +CJSON_PUBLIC(cJSON*) cJSON_AddNullToObject(cJSON * const object, const char * const name); +CJSON_PUBLIC(cJSON*) cJSON_AddTrueToObject(cJSON * const object, const char * const name); +CJSON_PUBLIC(cJSON*) cJSON_AddFalseToObject(cJSON * const object, const char * const name); +CJSON_PUBLIC(cJSON*) cJSON_AddBoolToObject(cJSON * const object, const char * const name, const cJSON_bool boolean); +CJSON_PUBLIC(cJSON*) cJSON_AddNumberToObject(cJSON * const object, const char * const name, const double number); +CJSON_PUBLIC(cJSON*) cJSON_AddStringToObject(cJSON * const object, const char * const name, const char * const string); +CJSON_PUBLIC(cJSON*) cJSON_AddRawToObject(cJSON * const object, const char * const name, const char * const raw); +CJSON_PUBLIC(cJSON*) cJSON_AddObjectToObject(cJSON * const object, const char * const name); +CJSON_PUBLIC(cJSON*) cJSON_AddArrayToObject(cJSON * const object, const char * const name); + +/* When assigning an integer value, it needs to be propagated to valuedouble too. */ +#define cJSON_SetIntValue(object, number) ((object) ? (object)->valueint = (object)->valuedouble = (number) : (number)) +/* helper for the cJSON_SetNumberValue macro */ +CJSON_PUBLIC(double) cJSON_SetNumberHelper(cJSON *object, double number); +#define cJSON_SetNumberValue(object, number) ((object != NULL) ? cJSON_SetNumberHelper(object, (double)number) : (number)) +/* Change the valuestring of a cJSON_String object, only takes effect when type of object is cJSON_String */ +CJSON_PUBLIC(char*) cJSON_SetValuestring(cJSON *object, const char *valuestring); + +/* If the object is not a boolean type this does nothing and returns cJSON_Invalid else it returns the new type*/ +#define cJSON_SetBoolValue(object, boolValue) ( \ + (object != NULL && ((object)->type & (cJSON_False|cJSON_True))) ? \ + (object)->type=((object)->type &(~(cJSON_False|cJSON_True)))|((boolValue)?cJSON_True:cJSON_False) : \ + cJSON_Invalid\ +) + +/* Macro for iterating over an array or object */ +#define cJSON_ArrayForEach(element, array) for(element = (array != NULL) ? (array)->child : NULL; element != NULL; element = element->next) + +/* malloc/free objects using the malloc/free functions that have been set with cJSON_InitHooks */ +CJSON_PUBLIC(void *) cJSON_malloc(size_t size); +CJSON_PUBLIC(void) cJSON_free(void *object); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/curl b/curl new file mode 160000 index 0000000..a88907f --- /dev/null +++ b/curl @@ -0,0 +1 @@ +Subproject commit a88907fd96c946d17867a491b4cf7c72a1982be4 diff --git a/huiafsdwesdfg.h b/huiafsdwesdfg.h new file mode 100644 index 0000000..7da5c94 --- /dev/null +++ b/huiafsdwesdfg.h @@ -0,0 +1,192 @@ +#include "cJSON/cJSON.h" +#pragma once + +static cJSON* ya_json_hed(char* id_dev, char* type_a, cJSON* state_a){ + cJSON *device = cJSON_CreateObject(); + cJSON* devices = cJSON_CreateArray(); + cJSON_AddItemToObject(device, "devices", devices); + + cJSON* id = cJSON_CreateObject(); + cJSON_AddItemToArray(devices, id); + + cJSON* real_id = cJSON_CreateString(id_dev); + cJSON_AddItemToObject(id, "id", real_id); + + cJSON* actions_a = cJSON_CreateArray(); + cJSON_AddItemToObject(id, "actions", actions_a); + + cJSON* actions_b = cJSON_CreateObject(); + cJSON_AddItemToArray(actions_a, actions_b); + + cJSON* type = cJSON_CreateString(type_a); + cJSON_AddItemToObject(actions_b, "type", type); + + cJSON_AddItemToObject(actions_b, "state", state_a); + return device; +} + +char *yan_on_off_lampochka(char* id_dev, char on_off){ + char *string = NULL; + char type_a[] = "devices.capabilities.on_off"; // Операция проводимая + cJSON* state_a = cJSON_CreateObject(); + + cJSON* instance = cJSON_CreateString("on"); + cJSON_AddItemToObject(state_a, "instance", instance); + + cJSON* value = cJSON_CreateBool(on_off); + cJSON_AddItemToObject(state_a, "value", value); + cJSON* device = ya_json_hed(id_dev, type_a, state_a); + string = cJSON_Print(device); + end: + cJSON_Delete(device); + return string; +} +char *yan_kelvin_lampochka(char* id_dev, int value_n){ + char *string = NULL; + char type_a[] = "devices.capabilities.color_setting"; // Операция проводимая + cJSON* state_a = cJSON_CreateObject(); + + cJSON* instance = cJSON_CreateString("temperature_k"); + cJSON_AddItemToObject(state_a, "instance", instance); + + cJSON* value = cJSON_CreateNumber(value_n); + cJSON_AddItemToObject(state_a, "value", value); + cJSON* device = ya_json_hed(id_dev, type_a, state_a); + string = cJSON_Print(device); + end: + cJSON_Delete(device); + return string; +} +char *yan_brightness(char* id_dev, char value_n){ + char *string = NULL; + char type_a[] = "devices.capabilities.range"; // Операция проводимая + cJSON* state_a = cJSON_CreateObject(); + + cJSON* instance = cJSON_CreateString("brightness"); + cJSON_AddItemToObject(state_a, "instance", instance); + + cJSON* value = cJSON_CreateNumber(value_n); + cJSON_AddItemToObject(state_a, "value", value); + cJSON* device = ya_json_hed(id_dev, type_a, state_a); + string = cJSON_Print(device); + end: + cJSON_Delete(device); + return string; +} +char *yan_rgb_lampochka(void){ + char *string = NULL; + char idyan[] = "ff5e379a-03d9-42fc-a0e1-822a8310be92"; // ID сюда + char type_a[] = "devices.capabilities.color_setting"; // Операция проводимая + char region[] = "rus"; + int value_n = 14210514; + size_t index = 0; + + cJSON *objkt = cJSON_CreateObject(); + + cJSON *payload = cJSON_CreateArray(); + cJSON_AddItemToObject(objkt, "payload", payload); + cJSON *payload_a = cJSON_CreateObject(); + cJSON_AddItemToArray(payload, payload_a); + cJSON *devices = cJSON_CreateArray(); + cJSON_AddItemToObject(payload_a, "devices", devices); + cJSON *devices_a = cJSON_CreateObject(); + cJSON_AddItemToArray(devices, devices_a); + cJSON *id = cJSON_CreateString(idyan); + cJSON_AddItemToObject(devices_a, "id", id); + cJSON *custom_data = cJSON_CreateArray(); + cJSON_AddItemToObject(devices_a, "custom_data", custom_data); + cJSON *custom_data_a = cJSON_CreateObject(); + cJSON_AddItemToArray(custom_data, custom_data_a); + cJSON *api_location = cJSON_CreateString(region); + cJSON_AddItemToObject(custom_data_a,"api_location", api_location); + cJSON *capabilities = cJSON_CreateArray(); + cJSON_AddItemToObject(devices_a, "capabilities", capabilities); + cJSON *capabilities_a = cJSON_CreateObject(); + cJSON_AddItemToArray(capabilities, capabilities_a); + cJSON *type = cJSON_CreateString(type_a); + cJSON_AddItemToObject(capabilities_a, "type", type); + cJSON *state = cJSON_CreateArray(); + cJSON_AddItemToObject(capabilities_a, "state", state); + cJSON *state_a = cJSON_CreateObject(); + cJSON_AddItemToArray(state, state_a); + cJSON *instance = cJSON_CreateString("rgb"); + cJSON_AddItemToObject(state_a, "instance", instance); + //cJSON *value = cJSON_C; + cJSON *value = cJSON_CreateNumber(value_n); + cJSON_AddItemToObject(state_a, "value", value);//reateNumber(value_n); + cJSON_AddItemToObject(state_a, "value", value); + + + + string = cJSON_Print(objkt); + + end: + cJSON_Delete(objkt); + return string; +} + +char *yan_hsv_lampochka(char* idyan, int h_a, char s_a, char v_a){ + char *string = NULL; + //char idyan[] = "ff5e379a-03d9-42fc-a0e1-822a8310be92"; // ID сюда + char type_a[] = "devices.capabilities.color_setting"; // Операция проводимая + char region[] = "rus"; + //int h_a = 125; + //int s_a = 20; + //int v_a = 100; + cJSON *devices = NULL; + cJSON *id = NULL; + cJSON *real_id = NULL; + cJSON *actions_a = NULL; + cJSON *actions_b = NULL; + cJSON *type = NULL; + cJSON *state_a = NULL; + cJSON *state_b = NULL; + cJSON *instance = NULL; + cJSON *value = NULL; + size_t index = 0; + + cJSON *device = cJSON_CreateObject(); + devices = cJSON_CreateArray(); + cJSON_AddItemToObject(device, "devices", devices); + + id = cJSON_CreateObject(); + cJSON_AddItemToArray(devices, id); + + real_id = cJSON_CreateString(idyan); + cJSON_AddItemToObject(id, "id", real_id); + + actions_a = cJSON_CreateArray(); + cJSON_AddItemToObject(id, "actions", actions_a); + + actions_b = cJSON_CreateObject(); + cJSON_AddItemToArray(actions_a, actions_b); + + type = cJSON_CreateString(type_a); + cJSON_AddItemToObject(actions_b, "type", type); + + state_a = cJSON_CreateObject(); + cJSON_AddItemToObject(actions_b, "state", state_a); + + instance = cJSON_CreateString("hsv"); + cJSON_AddItemToObject(state_a, "instance", instance); + + cJSON *value_a = cJSON_CreateObject(); + + cJSON_AddItemToObject(state_a, "value", value_a); + + cJSON_AddItemToArray(value, value_a); + + cJSON *h = cJSON_CreateNumber(h_a); + cJSON_AddItemToObject(value_a, "h", h); + cJSON *s = cJSON_CreateNumber(s_a); + cJSON_AddItemToObject(value_a, "s", s); + cJSON *v = cJSON_CreateNumber(v_a); + cJSON_AddItemToObject(value_a, "v", v); + + string = cJSON_Print(device); + + end: + cJSON_Delete(device); + return string; +} + diff --git a/json/json.c b/json/json.c new file mode 100644 index 0000000..64edfdb --- /dev/null +++ b/json/json.c @@ -0,0 +1,1092 @@ +#include "json.h" + +#include +#include +#include +#include +#include +#include + +#ifdef JSON_SKIP_WHITESPACE +#define json_skip_whitespace(arg) json_skip_whitespace_actual(arg) +#else +#define json_skip_whitespace(arg) +#endif + +#ifdef JSON_DEBUG +#define log(str, ...) printf(str "\n", ##__VA_ARGS__) +#else +#define log(str, ...) +#endif + +#define define_result_type(name) \ + result(name) result_ok(name)(typed(name) value) { \ + result(name) retval = { \ + .is_ok = true, \ + .inner = \ + { \ + .value = value, \ + }, \ + }; \ + return retval; \ + } \ + result(name) result_err(name)(typed(json_error) err) { \ + result(name) retval = { \ + .is_ok = false, \ + .inner = \ + { \ + .err = err, \ + }, \ + }; \ + return retval; \ + } \ + typed(json_boolean) result_is_ok(name)(result(name) * result) { \ + return result->is_ok; \ + } \ + typed(json_boolean) result_is_err(name)(result(name) * result) { \ + return !result->is_ok; \ + } \ + typed(name) result_unwrap(name)(result(name) * result) { \ + return result->inner.value; \ + } \ + typed(json_error) result_unwrap_err(name)(result(name) * result) { \ + return result->inner.err; \ + } + +/** + * @brief Allocate `count` number of items of `type` in memory + * and return the pointer to the newly allocated memory + */ +#define allocN(type, count) (type *)malloc((count) * sizeof(type)) + +/** + * @brief Allocate an item of `type` in memory and return the + * pointer to the newly allocated memory + */ +#define alloc(type) allocN(type, 1) + +/** + * @brief Re-allocate `count` number of items of `type` in memory + * and return the pointer to the newly allocated memory + */ +#define reallocN(ptr, type, count) (type *)realloc(ptr, (count) * sizeof(type)) + +/** + * @brief Determines whether a character `ch` is whitespace + */ +#define is_whitespace(ch) (ch == ' ' || ch == '\n' || ch == '\r' || ch == '\t') + +/** + * @brief Parses a JSON element {json_element_t} and moves the string + * pointer to the end of the parsed element + */ +static result(json_entry) json_parse_entry(typed(json_string) *); + +/** + * @brief Guesses the element type at the start of a string + */ +static result(json_element_type) json_guess_element_type(typed(json_string)); + +/** + * @brief Whether a token represents a string. Like '"' + */ +static bool json_is_string(char); + +/** + * @brief Whether a token represents a number. Like '0' + */ +static bool json_is_number(char); + +/** + * @brief Whether a token represents a object. Like '"' + */ +static bool json_is_object(char); + +/** + * @brief Whether a token represents a array. Like '[' + */ +static bool json_is_array(char); + +/** + * @brief Whether a token represents a boolean. Like 't' + */ +static bool json_is_boolean(char); + +/** + * @brief Whether a token represents a null. Like 'n' + */ +static bool json_is_null(char); + +/** + * @brief Parses a JSON element value {json_element_value_t} based + * on the `type` parameter passed and moves the string pointer + * to end of the parsed element + */ +static result(json_element_value) + json_parse_element_value(typed(json_string) *, typed(json_element_type)); + +/** + * @brief Parses a `String` {json_string_t} and moves the string + * pointer to the end of the parsed string + */ +static result(json_element_value) json_parse_string(typed(json_string) *); + +/** + * @brief Parses a `Number` {json_number_t} and moves the string + * pointer to the end of the parsed number + */ +static result(json_element_value) json_parse_number(typed(json_string) *); + +/** + * @brief Parses a `Object` {json_object_t} and moves the string + * pointer to the end of the parsed object + */ +static result(json_element_value) json_parse_object(typed(json_string) *); + +static typed(uint64) json_key_hash(typed(json_string)); + +/** + * @brief Parses a `Array` {json_array_t} and moves the string + * pointer to the end of the parsed array + */ +static result(json_element_value) json_parse_array(typed(json_string) *); + +/** + * @brief Parses a `Boolean` {json_boolean_t} and moves the string + * pointer to the end of the parsed boolean + */ +static result(json_element_value) json_parse_boolean(typed(json_string) *); + +/** + * @brief Skips a Key-Value pair + * + * @return true If a valid entry is skipped + * @return false If entry was invalid (still skips) + */ +static bool json_skip_entry(typed(json_string) *); + +/** + * @brief Skips an element value + * + * @return true If a valid element is skipped + * @return false If element was invalid (still skips) + */ +static bool json_skip_element_value(typed(json_string) *, + typed(json_element_type)); + +/** + * @brief Skips a string value + * + * @return true If a valid string is skipped + * @return false If string was invalid (still skips) + */ +static bool json_skip_string(typed(json_string) *); + +/** + * @brief Skips a number value + * + * @return true If a valid number is skipped + * @return false If number was invalid (still skips) + */ +static bool json_skip_number(typed(json_string) *); + +/** + * @brief Skips an object value + * + * @return true If a valid object is skipped + * @return false If object was invalid (still skips) + */ +static bool json_skip_object(typed(json_string) *); + +/** + * @brief Skips an array value + * + * @return true If a valid array is skipped + * @return false If array was invalid (still skips) + */ +static bool json_skip_array(typed(json_string) *); + +/** + * @brief Skips a boolean value + * + * @return true If a valid boolean is skipped + * @return false If boolean was invalid (still skips) + */ +static bool json_skip_boolean(typed(json_string) *); + +/** + * @brief Moves a JSON string pointer beyond any whitespace + */ +static void json_skip_whitespace_actual(typed(json_string) *); + +/** + * @brief Moves a JSON string pointer beyond `null` literal + * + */ +static void json_skip_null(typed(json_string) *); + +/** + * @brief Prints a JSON element {json_element_t} type + */ +static void json_print_element(typed(json_element) *, int, int); + +/** + * @brief Prints a `String` {json_string_t} type + */ +static void json_print_string(typed(json_string)); + +/** + * @brief Prints a `Number` {json_number_t} type + */ +static void json_print_number(typed(json_number)); + +/** + * @brief Prints an `Object` {json_object_t} type + */ +static void json_print_object(typed(json_object) *, int, int); + +/** + * @brief Prints an `Array` {json_array_t} type + */ +static void json_print_array(typed(json_array) *, int, int); + +/** + * @brief Prints a `Boolean` {json_boolean_t} type + */ +static void json_print_boolean(typed(json_boolean)); + +/** + * @brief Frees a `String` (json_string_t) from memory + */ +static void json_free_string(typed(json_string)); + +/** + * @brief Frees an `Object` (json_object_t) from memory + */ +static void json_free_object(typed(json_object) *); + +/** + * @brief Frees an `Array` (json_array_t) from memory + */ +static void json_free_array(typed(json_array) *); + +/** + * @brief Utility function to convert an escaped string to a formatted string + */ +static result(json_string) + json_unescape_string(typed(json_string), typed(size)); + +/** + * @brief Offset to the last `"` of a JSON string + */ +static typed(size) json_string_len(typed(json_string)); + +/** + * @brief Debug print some characters from a string + */ +static void json_debug_print(typed(json_string) str, typed(size) len); + +result(json_element) json_parse(typed(json_string) json_str) { + if (json_str == NULL) { + return result_err(json_element)(JSON_ERROR_EMPTY); + } + + typed(size) len = strlen(json_str); + if (len == 0) { + return result_err(json_element)(JSON_ERROR_EMPTY); + } + + result_try(json_element, json_element_type, type, + json_guess_element_type(json_str)); + result_try(json_element, json_element_value, value, + json_parse_element_value(&json_str, type)); + + const typed(json_element) element = { + .type = type, + .value = value, + }; + + return result_ok(json_element)(element); +} + +result(json_entry) json_parse_entry(typed(json_string) * str_ptr) { + result_try(json_entry, json_element_value, key, json_parse_string(str_ptr)); + json_skip_whitespace(str_ptr); + + // Skip the ':' delimiter + (*str_ptr)++; + + json_skip_whitespace(str_ptr); + + result(json_element_type) type_result = json_guess_element_type(*str_ptr); + if (result_is_err(json_element_type)(&type_result)) { + free((void *)key.as_string); + return result_map_err(json_entry, json_element_type, &type_result); + } + typed(json_element_type) type = + result_unwrap(json_element_type)(&type_result); + + result(json_element_value) value_result = + json_parse_element_value(str_ptr, type); + if (result_is_err(json_element_value)(&value_result)) { + free((void *)key.as_string); + return result_map_err(json_entry, json_element_value, &value_result); + } + typed(json_element_value) value = + result_unwrap(json_element_value)(&value_result); + + typed(json_entry) entry = { + .key = key.as_string, + .element = + { + .type = type, + .value = value, + }, + }; + + return result_ok(json_entry)(entry); +} + +result(json_element_type) json_guess_element_type(typed(json_string) str) { + const char ch = *str; + typed(json_element_type) type; + + if (json_is_string(ch)) + type = JSON_ELEMENT_TYPE_STRING; + else if (json_is_object(ch)) + type = JSON_ELEMENT_TYPE_OBJECT; + else if (json_is_array(ch)) + type = JSON_ELEMENT_TYPE_ARRAY; + else if (json_is_null(ch)) + type = JSON_ELEMENT_TYPE_NULL; + else if (json_is_number(ch)) + type = JSON_ELEMENT_TYPE_NUMBER; + else if (json_is_boolean(ch)) + type = JSON_ELEMENT_TYPE_BOOLEAN; + else + return result_err(json_element_type)(JSON_ERROR_INVALID_TYPE); + + return result_ok(json_element_type)(type); +} + +bool json_is_string(char ch) { return ch == '"'; } + +bool json_is_number(char ch) { + return (ch >= '0' && ch <= '9') || ch == '+' || ch == '-' || ch == '.' || + ch == 'e' || ch == 'E'; +} + +bool json_is_object(char ch) { return ch == '{'; } + +bool json_is_array(char ch) { return ch == '['; } + +bool json_is_boolean(char ch) { return ch == 't' || ch == 'f'; } + +bool json_is_null(char ch) { return ch == 'n'; } + +result(json_element_value) + json_parse_element_value(typed(json_string) * str_ptr, + typed(json_element_type) type) { + switch (type) { + case JSON_ELEMENT_TYPE_STRING: + return json_parse_string(str_ptr); + case JSON_ELEMENT_TYPE_NUMBER: + return json_parse_number(str_ptr); + case JSON_ELEMENT_TYPE_OBJECT: + return json_parse_object(str_ptr); + case JSON_ELEMENT_TYPE_ARRAY: + return json_parse_array(str_ptr); + case JSON_ELEMENT_TYPE_BOOLEAN: + return json_parse_boolean(str_ptr); + case JSON_ELEMENT_TYPE_NULL: + json_skip_null(str_ptr); + return result_err(json_element_value)(JSON_ERROR_EMPTY); + default: + return result_err(json_element_value)(JSON_ERROR_INVALID_TYPE); + } +} + +result(json_element_value) json_parse_string(typed(json_string) * str_ptr) { + // Skip the first '"' character + (*str_ptr)++; + + typed(size) len = json_string_len(*str_ptr); + if (len == 0) { + // Skip the end quote + (*str_ptr)++; + return result_err(json_element_value)(JSON_ERROR_EMPTY); + } + + result_try(json_element_value, json_string, output, + json_unescape_string(*str_ptr, len)); + + // Skip to beyond the string + (*str_ptr) += len + 1; + + return result_ok(json_element_value)((typed(json_element_value))output); +} + +result(json_element_value) json_parse_number(typed(json_string) * str_ptr) { + typed(json_string) temp_str = *str_ptr; + bool has_decimal = false; + + while (json_is_number(*temp_str)) { + if (*temp_str == '.') { + has_decimal = true; + } + + temp_str++; + } + + typed(json_number) number = {}; + + if (has_decimal) { + errno = 0; + + number.type = JSON_NUMBER_TYPE_DOUBLE; + number.value = (typed(json_number_value))strtod(*str_ptr, (char **)str_ptr); + + if (errno == EINVAL || errno == ERANGE) + return result_err(json_element_value)(JSON_ERROR_INVALID_VALUE); + } else { + errno = 0; + + number.type = JSON_NUMBER_TYPE_LONG; + number.value = + (typed(json_number_value))strtol(*str_ptr, (char **)str_ptr, 10); + + if (errno == EINVAL || errno == ERANGE) + return result_err(json_element_value)(JSON_ERROR_INVALID_VALUE); + } + + return result_ok(json_element_value)((typed(json_element_value))number); +} + +result(json_element_value) json_parse_object(typed(json_string) * str_ptr) { + typed(json_string) temp_str = *str_ptr; + + // ******* First find the number of valid entries ******* + // Skip the first '{' character + temp_str++; + + json_skip_whitespace(&temp_str); + + if (*temp_str == '}') { + // Skip the end '}' in the actual pointer + (*str_ptr) = temp_str + 1; + return result_err(json_element_value)(JSON_ERROR_EMPTY); + } + + typed(size) count = 0; + + while (*temp_str != '\0') { + // Skip any accidental whitespace + json_skip_whitespace(&temp_str); + + // If the entry could be skipped + if (json_skip_entry(&temp_str)) { + count++; + } + + // Skip any accidental whitespace + json_skip_whitespace(&temp_str); + + if (*temp_str == '}') + break; + + // Skip the ',' to move to the next entry + temp_str++; + } + + if (count == 0) + return result_err(json_element_value)(JSON_ERROR_EMPTY); + + // ******* Initialize the hash map ******* + // Now we have a perfectly sized hash map + typed(json_entry) **entries = allocN(typed(json_entry) *, count); + for (size_t i = 0; i < count; i++) + entries[i] = NULL; + + // Skip the first '{' character + (*str_ptr)++; + + json_skip_whitespace(str_ptr); + + while (**str_ptr != '\0') { + // Skip any accidental whitespace + json_skip_whitespace(str_ptr); + result(json_entry) entry_result = json_parse_entry(str_ptr); + + if (result_is_ok(json_entry)(&entry_result)) { + typed(json_entry) entry = result_unwrap(json_entry)(&entry_result); + typed(uint64) bucket = json_key_hash(entry.key) % count; + + // Bucket size is exactly count. So there will be at max + // count misses in the worst case + for (size_t i = 0; i < count; i++) { + if (entries[bucket] == NULL) { + typed(json_entry) *temp_entry = alloc(typed(json_entry)); + memcpy(temp_entry, &entry, sizeof(typed(json_entry))); + entries[bucket] = temp_entry; + break; + } + + bucket = (bucket + 1) % count; + } + } + + // Skip any accidental whitespace + json_skip_whitespace(str_ptr); + + if (**str_ptr == '}') + break; + + // Skip the ',' to move to the next entry + (*str_ptr)++; + } + + // Skip the '}' closing brace + (*str_ptr)++; + + typed(json_object) *object = alloc(typed(json_object)); + object->count = count; + object->entries = entries; + + return result_ok(json_element_value)((typed(json_element_value))object); +} + +typed(uint64) json_key_hash(typed(json_string) str) { + typed(uint64) hash = 0; + + while (*str != '\0') + hash += (hash * 31) + *str++; + + return hash; +} + +result(json_element_value) json_parse_array(typed(json_string) * str_ptr) { + // Skip the starting '[' character + (*str_ptr)++; + + json_skip_whitespace(str_ptr); + + // Unfortunately the array is empty + if (**str_ptr == ']') { + // Skip the end ']' + (*str_ptr)++; + return result_err(json_element_value)(JSON_ERROR_EMPTY); + } + + typed(size) count = 0; + typed(json_element) *elements = NULL; + + while (**str_ptr != '\0') { + json_skip_whitespace(str_ptr); + + // Guess the type + result(json_element_type) type_result = json_guess_element_type(*str_ptr); + if (result_is_ok(json_element_type)(&type_result)) { + typed(json_element_type) type = + result_unwrap(json_element_type)(&type_result); + + // Parse the value based on guessed type + result(json_element_value) value_result = + json_parse_element_value(str_ptr, type); + if (result_is_ok(json_element_value)(&value_result)) { + typed(json_element_value) value = + result_unwrap(json_element_value)(&value_result); + + count++; + elements = reallocN(elements, typed(json_element), count); + elements[count - 1].type = type; + elements[count - 1].value = value; + } + + json_skip_whitespace(str_ptr); + } + + // Reached the end + if (**str_ptr == ']') + break; + + // Skip the ',' + (*str_ptr)++; + } + + // Skip the ']' closing array + (*str_ptr)++; + + if (count == 0) + return result_err(json_element_value)(JSON_ERROR_EMPTY); + + typed(json_array) *array = alloc(typed(json_array)); + array->count = count; + array->elements = elements; + + return result_ok(json_element_value)((typed(json_element_value))array); +} + +result(json_element_value) json_parse_boolean(typed(json_string) * str_ptr) { + typed(json_boolean) output; + + switch (**str_ptr) { + case 't': + output = true; + (*str_ptr) += 4; + break; + + case 'f': + output = false; + (*str_ptr) += 5; + break; + } + + return result_ok(json_element_value)((typed(json_element_value))output); +} + +result(json_element) + json_object_find(typed(json_object) * obj, typed(json_string) key) { + if (key == NULL || strlen(key) == 0) + return result_err(json_element)(JSON_ERROR_INVALID_KEY); + + typed(uint64) bucket = json_key_hash(key) % obj->count; + + // Bucket size is exactly obj->count. So there will be at max + // obj->count misses in the worst case + for (size_t i = 0; i < obj->count; i++) { + typed(json_entry) *entry = obj->entries[bucket]; + if (strcmp(key, entry->key) == 0) + return result_ok(json_element)(entry->element); + + bucket = (bucket + 1) % obj->count; + } + + return result_err(json_element)(JSON_ERROR_INVALID_KEY); +} + +bool json_skip_entry(typed(json_string) * str_ptr) { + json_skip_string(str_ptr); + + json_skip_whitespace(str_ptr); + + // Skip the ':' delimiter + (*str_ptr)++; + + json_skip_whitespace(str_ptr); + + result(json_element_type) type_result = json_guess_element_type(*str_ptr); + if (result_is_err(json_element_type)(&type_result)) + return false; + + typed(json_element_type) type = + result_unwrap(json_element_type)(&type_result); + + return json_skip_element_value(str_ptr, type); +} + +bool json_skip_element_value(typed(json_string) * str_ptr, + typed(json_element_type) type) { + switch (type) { + case JSON_ELEMENT_TYPE_STRING: + return json_skip_string(str_ptr); + case JSON_ELEMENT_TYPE_NUMBER: + return json_skip_number(str_ptr); + case JSON_ELEMENT_TYPE_OBJECT: + return json_skip_object(str_ptr); + case JSON_ELEMENT_TYPE_ARRAY: + return json_skip_array(str_ptr); + case JSON_ELEMENT_TYPE_BOOLEAN: + return json_skip_boolean(str_ptr); + case JSON_ELEMENT_TYPE_NULL: + json_skip_null(str_ptr); + return false; + + default: + return false; + } +} + +bool json_skip_string(typed(json_string) * str_ptr) { + // Skip the initial '"' + (*str_ptr)++; + + // Find the length till the last '"' + typed(size) len = json_string_len(*str_ptr); + + // Skip till the end of the string + (*str_ptr) += len + 1; + + return len > 0; +} + +bool json_skip_number(typed(json_string) * str_ptr) { + while (json_is_number(**str_ptr)) { + (*str_ptr)++; + } + + return true; +} + +bool json_skip_object(typed(json_string) * str_ptr) { + // Skip the first '{' character + (*str_ptr)++; + + json_skip_whitespace(str_ptr); + + if (**str_ptr == '}') { + // Skip the end '}' + (*str_ptr)++; + return false; + } + + while (**str_ptr != '\0') { + // Skip any accidental whitespace + json_skip_whitespace(str_ptr); + + json_skip_entry(str_ptr); + + // Skip any accidental whitespace + json_skip_whitespace(str_ptr); + + if (**str_ptr == '}') + break; + + // Skip the ',' to move to the next entry + (*str_ptr)++; + } + + // Skip the '}' closing brace + (*str_ptr)++; + + return true; +} + +bool json_skip_array(typed(json_string) * str_ptr) { + // Skip the starting '[' character + (*str_ptr)++; + + json_skip_whitespace(str_ptr); + + // Unfortunately the array is empty + if (**str_ptr == ']') { + // Skip the end ']' + (*str_ptr)++; + return false; + } + + while (**str_ptr != '\0') { + json_skip_whitespace(str_ptr); + + // Guess the type + result(json_element_type) type_result = json_guess_element_type(*str_ptr); + if (result_is_ok(json_element_type)(&type_result)) { + typed(json_element_type) type = + result_unwrap(json_element_type)(&type_result); + + // Parse the value based on guessed type + json_skip_element_value(str_ptr, type); + + json_skip_whitespace(str_ptr); + } + + // Reached the end + if (**str_ptr == ']') + break; + + // Skip the ',' + (*str_ptr)++; + } + + // Skip the ']' closing array + (*str_ptr)++; + + return true; +} + +bool json_skip_boolean(typed(json_string) * str_ptr) { + switch (**str_ptr) { + case 't': + (*str_ptr) += 4; + return true; + + case 'f': + (*str_ptr) += 5; + return true; + } + + return false; +} + +void json_skip_whitespace_actual(typed(json_string) * str_ptr) { + while (is_whitespace(**str_ptr)) + (*str_ptr)++; +} + +void json_skip_null(typed(json_string) * str_ptr) { (*str_ptr) += 4; } + +void json_print(typed(json_element) * element, int indent) { + json_print_element(element, indent, 0); +} + +void json_print_element(typed(json_element) * element, int indent, + int indent_level) { + + switch (element->type) { + case JSON_ELEMENT_TYPE_STRING: + json_print_string(element->value.as_string); + break; + case JSON_ELEMENT_TYPE_NUMBER: + json_print_number(element->value.as_number); + break; + case JSON_ELEMENT_TYPE_OBJECT: + json_print_object(element->value.as_object, indent, indent_level); + break; + case JSON_ELEMENT_TYPE_ARRAY: + json_print_array(element->value.as_array, indent, indent_level); + break; + case JSON_ELEMENT_TYPE_BOOLEAN: + json_print_boolean(element->value.as_boolean); + break; + case JSON_ELEMENT_TYPE_NULL: + break; + // Do nothing + } +} + +void json_print_string(typed(json_string) string) { printf("\"%s\"", string); } + +void json_print_number(typed(json_number) number) { + switch (number.type) { + case JSON_NUMBER_TYPE_DOUBLE: + printf("%f", number.value.as_double); + break; + + case JSON_NUMBER_TYPE_LONG: + printf("%ld", number.value.as_long); + break; + } +} + +void json_print_object(typed(json_object) * object, int indent, + int indent_level) { + printf("{\n"); + + for (size_t i = 0; i < object->count; i++) { + for (int j = 0; j < indent * (indent_level + 1); j++) + printf(" "); + + typed(json_entry) *entry = object->entries[i]; + + json_print_string(entry->key); + printf(": "); + json_print_element(&entry->element, indent, indent_level + 1); + + if (i != object->count - 1) + printf(","); + printf("\n"); + } + + for (int j = 0; j < indent * indent_level; j++) + printf(" "); + printf("}"); +} + +void json_print_array(typed(json_array) * array, int indent, int indent_level) { + printf("[\n"); + + for (size_t i = 0; i < array->count; i++) { + typed(json_element) element = array->elements[i]; + for (int j = 0; j < indent * (indent_level + 1); j++) + printf(" "); + json_print_element(&element, indent, indent_level + 1); + + if (i != array->count - 1) + printf(","); + printf("\n"); + } + + for (int i = 0; i < indent * indent_level; i++) + printf(" "); + printf("]"); +} + +void json_print_boolean(typed(json_boolean) boolean) { + printf("%s", boolean ? "true" : "false"); +} + +void json_free(typed(json_element) * element) { + switch (element->type) { + case JSON_ELEMENT_TYPE_STRING: + json_free_string(element->value.as_string); + break; + + case JSON_ELEMENT_TYPE_OBJECT: + json_free_object(element->value.as_object); + break; + + case JSON_ELEMENT_TYPE_ARRAY: + json_free_array(element->value.as_array); + break; + + case JSON_ELEMENT_TYPE_NUMBER: + case JSON_ELEMENT_TYPE_BOOLEAN: + case JSON_ELEMENT_TYPE_NULL: + // Do nothing + break; + } +} + +void json_free_string(typed(json_string) string) { free((void *)string); } + +void json_free_object(typed(json_object) * object) { + if (object == NULL) + return; + + if (object->count == 0) { + free(object); + return; + } + + for (size_t i = 0; i < object->count; i++) { + typed(json_entry) *entry = object->entries[i]; + + if (entry != NULL) { + free((void *)entry->key); + json_free(&entry->element); + free(entry); + } + } + + free(object->entries); + free(object); +} + +void json_free_array(typed(json_array) * array) { + if (array == NULL) + return; + + if (array->count == 0) { + free(array); + return; + } + + // Recursively free each element in the array + for (size_t i = 0; i < array->count; i++) { + typed(json_element) element = array->elements[i]; + json_free(&element); + } + + // Lastly free + free(array->elements); + free(array); +} + +typed(json_string) json_error_to_string(typed(json_error) error) { + switch (error) { + case JSON_ERROR_EMPTY: + return "Empty"; + case JSON_ERROR_INVALID_KEY: + return "Invalid key"; + case JSON_ERROR_INVALID_TYPE: + return "Invalid type"; + case JSON_ERROR_INVALID_VALUE: + return "Invalid value"; + + default: + return "Unknown error"; + } +} + +typed(size) json_string_len(typed(json_string) str) { + typed(size) len = 0; + + typed(json_string) iter = str; + while (*iter != '\0') { + if (*iter == '\\') + iter += 2; + + if (*iter == '"') { + len = iter - str; + break; + } + + iter++; + } + + return len; +} + +result(json_string) + json_unescape_string(typed(json_string) str, typed(size) len) { + typed(size) count = 0; + typed(json_string) iter = str; + + while ((size_t)(iter - str) < len) { + if (*iter == '\\') + iter++; + + count++; + iter++; + } + + char *output = allocN(char, count + 1); + typed(size) offset = 0; + iter = str; + + while ((size_t)(iter - str) < len) { + if (*iter == '\\') { + iter++; + + switch (*iter) { + case 'b': + output[offset] = '\b'; + break; + case 'f': + output[offset] = '\f'; + break; + case 'n': + output[offset] = '\n'; + break; + case 'r': + output[offset] = '\r'; + break; + case 't': + output[offset] = '\t'; + break; + case '"': + output[offset] = '"'; + break; + case '\\': + output[offset] = '\\'; + break; + default: + return result_err(json_string)(JSON_ERROR_INVALID_VALUE); + } + } else { + output[offset] = *iter; + } + + offset++; + iter++; + } + + output[offset] = '\0'; + return result_ok(json_string)((typed(json_string))output); +} + +void json_debug_print(typed(json_string) str, typed(size) len) { + for (size_t i = 0; i < len; i++) { + if (str[i] == '\0') + break; + + putchar(str[i]); + } + printf("\n"); +} + +define_result_type(json_element_type); +define_result_type(json_element_value); +define_result_type(json_element); +define_result_type(json_entry); +define_result_type(json_string); +define_result_type(size); \ No newline at end of file diff --git a/json/json.h b/json/json.h new file mode 100644 index 0000000..3e5d4d9 --- /dev/null +++ b/json/json.h @@ -0,0 +1,165 @@ +#pragma once + +#include + +#ifndef __cplusplus +typedef unsigned int bool; +#define true (1) +#define false (0) +#endif + +#define typed(name) name##_t + +typedef const char *typed(json_string); +typedef bool typed(json_boolean); + +typedef enum json_number_type_e typed(json_number_type); +typedef union json_number_value_u typed(json_number_value); +typedef signed long typed(json_number_long); +typedef double typed(json_number_double); +typedef struct json_number_s typed(json_number); +typedef enum json_element_type_e typed(json_element_type); +typedef union json_element_value_u typed(json_element_value); +typedef enum json_error_e typed(json_error); +typedef struct json_element_s typed(json_element); +typedef struct json_entry_s typed(json_entry); +typedef struct json_object_s typed(json_object); +typedef struct json_array_s typed(json_array); + +#define result(name) name##_result_t +#define result_ok(name) name##_result_ok +#define result_err(name) name##_result_err +#define result_is_ok(name) name##_result_is_ok +#define result_is_err(name) name##_result_is_err +#define result_unwrap(name) name##_result_unwrap +#define result_unwrap_err(name) name##_result_unwrap_err +#define result_map_err(outer_name, inner_name, value) \ + result_err(outer_name)(result_unwrap_err(inner_name)(value)) +#define result_try(outer_name, inner_name, lvalue, rvalue) \ + result(inner_name) lvalue##_result = rvalue; \ + if (result_is_err(inner_name)(&lvalue##_result)) \ + return result_map_err(outer_name, inner_name, &lvalue##_result); \ + const typed(inner_name) lvalue = result_unwrap(inner_name)(&lvalue##_result); +#define declare_result_type(name) \ + typedef struct name##_result_s { \ + typed(json_boolean) is_ok; \ + union { \ + typed(name) value; \ + typed(json_error) err; \ + } inner; \ + } result(name); \ + result(name) result_ok(name)(typed(name)); \ + result(name) result_err(name)(typed(json_error)); \ + typed(json_boolean) result_is_ok(name)(result(name) *); \ + typed(json_boolean) result_is_err(name)(result(name) *); \ + typed(name) result_unwrap(name)(result(name) *); \ + typed(json_error) result_unwrap_err(name)(result(name) *); + +enum json_element_type_e { + JSON_ELEMENT_TYPE_STRING = 0, + JSON_ELEMENT_TYPE_NUMBER, + JSON_ELEMENT_TYPE_OBJECT, + JSON_ELEMENT_TYPE_ARRAY, + JSON_ELEMENT_TYPE_BOOLEAN, + JSON_ELEMENT_TYPE_NULL +}; + +enum json_number_type_e { + JSON_NUMBER_TYPE_LONG = 0, + JSON_NUMBER_TYPE_DOUBLE, +}; + +union json_number_value_u { + typed(json_number_long) as_long; + typed(json_number_double) as_double; +}; + +struct json_number_s { + typed(json_number_type) type; + typed(json_number_value) value; +}; + +union json_element_value_u { + typed(json_string) as_string; + typed(json_number) as_number; + typed(json_object) * as_object; + typed(json_array) * as_array; + typed(json_boolean) as_boolean; +}; + +struct json_element_s { + typed(json_element_type) type; + typed(json_element_value) value; +}; + +struct json_entry_s { + typed(json_string) key; + typed(json_element) element; +}; + +struct json_object_s { + typed(size) count; + typed(json_entry) * *entries; +}; + +struct json_array_s { + typed(size) count; + typed(json_element) * elements; +}; + +enum json_error_e { + JSON_ERROR_EMPTY = 0, + JSON_ERROR_INVALID_TYPE, + JSON_ERROR_INVALID_KEY, + JSON_ERROR_INVALID_VALUE +}; + +declare_result_type(json_element_type); +declare_result_type(json_element_value); +declare_result_type(json_element); +declare_result_type(json_entry); +declare_result_type(json_string); +declare_result_type(size); + +/** + * @brief Parses a JSON string into a JSON element {json_element_t} + * with a fallible `result` type + * + * @param json_str The raw JSON string + * @return The parsed {json_element_t} wrapped in a `result` type + */ +result(json_element) json_parse(typed(json_string) json_str); + +/** + * @brief Tries to get the element by key. If not found, returns + * a {JSON_ERROR_INVALID_KEY} error + * + * @param object The object to find the key in + * @param key The key of the element to be found + * @return Either a {json_element_t} or {json_error_t} + */ +result(json_element) + json_object_find(typed(json_object) * object, typed(json_string) key); + +/** + * @brief Prints a JSON element {json_element_t} with proper + * indentation + * + * @param indent The number of spaces to indent each level by + */ +void json_print(typed(json_element) * element, int indent); + +/** + * @brief Frees a JSON element {json_element_t} from memory + * + * @param element The JSON element {json_element_t} to free + */ +void json_free(typed(json_element) * element); + +/** + * @brief Returns a string representation of JSON error {json_error_t} type + * + * @param error The JSON error enum {json_error_t} type + * @return The string representation + */ +typed(json_string) json_error_to_string(typed(json_error) error); \ No newline at end of file diff --git a/main.c b/main.c new file mode 100644 index 0000000..5a408dc --- /dev/null +++ b/main.c @@ -0,0 +1,298 @@ +#include + +#include +#include + + +#include "api.h" + + +void s(){ + struct ya_api api = ya_api_create("Authorization: Bearer ---------------------------"); + api.list_devices(&api); + printf("SAS@@@\n"); + for (int i = 0; i != api.data.devs->len; i++){ + struct ya_dev_struct *dev = api.data.devs->dev[i]; + if (dev->capabilities != NULL && dev->capabilities->color_setting != NULL){ + if (dev->capabilities->color_setting->color_target == 2){ + struct color_struct *color = dev->capabilities->color_setting->color; + printf("%s\n", dev->name); + printf("HSV = %i %i %i\n", color->h, color->s, color->v); + //ya_dev_hsv(dev, 177,93,80); // hsv(177, 93%, 80%) + api.hsv(dev, 284,93,80); + } + if (dev->capabilities->color_setting->color_target == 1){ + struct temperature_k_struct *temperature_k = dev->capabilities->color_setting->temperature_k; + printf("%s\n", dev->name); + printf("temperature_k = %i \n", temperature_k->value); + } + + } + //api.data.devs->dev[i]->capabilities->color_setting->color_status; + } + //perror("Пиздец!!!\n"); + + + /* + for (int i = 0; i != api.data.groups->len; i++){ + printf("ГРУППА: %s\n", api.data.groups->group[i]->name); + //printf("S%s\n", api.data.groups->group[i]->devs->len); + + //printf("S%s\n", api.data.groups->group[i]->devs->dev[0]->id); + //printf("S%i\n", api.data.groups->group[i]->devs->len); + //printf(" ДЕВЫЙС: %s\n", api.data.groups->group[i]->devs->dev[0]->name); + for (int a = 0; a != api.data.groups->group[i]->devs->len; a++){ + struct ya_dev_struct *dev = api.data.groups->group[i]->devs->dev[a]; + printf("\tДЕВЫЙС %s: %s\n", dev->type, dev->name); + //api.brightness(dev, 100); + //dev->capabilities->color_setting->temperature_k-> + + } + + } + */ + //api.on_off(3); + //api.list_devices(&api); + //printf("%s\n", ya_api_recvest("https://api.iot.yandex.net/v1.0/user/info", NULL, api.data.tocen)); + + + + + //api.on_off(api.data.devs->dev[6]); + /* + for (int i = 0; i != api.data.groups->len; i++){ + printf("ГРУППА: %s\n", api.data.groups->group[i]->name); + //printf("S%s\n", api.data.groups->group[i]->devs->len); + + //printf("S%s\n", api.data.groups->group[i]->devs->dev[0]->id); + //printf("S%i\n", api.data.groups->group[i]->devs->len); + //printf(" ДЕВЫЙС: %s\n", api.data.groups->group[i]->devs->dev[0]->name); + for (int a = 0; a != api.data.groups->group[i]->devs->len; a++){ + printf(" ДЕВАЙС: %s\n", api.data.groups->group[i]->devs->dev[a]->name); + printf(" Мин: %i\n", api.data.groups->group[i]->devs->dev[a]->capabilities->color_setting->temperature_k->min); + printf(" Макс: %i\n", api.data.groups->group[i]->devs->dev[a]->capabilities->color_setting->temperature_k->max); + //api.kelvin(api.data.groups->group[i]->devs->dev[a], 6500); + + //api.on_off(api.data.groups->group[i]->devs->dev[a]); + } + + } + */ + + + + //api.data.devs + //struct ya_dev_struct* dev = api.data.devs->dev[0]; + //for (int i = 0; i != api.data.devs->len; i++){ + // printf("%s\n", api.data.devs->dev[i]->name); + //} + + //printf("%i\n", api.data.groups->len); + /* + printf("%s\n", api.data.groups->group[0]->id); + + printf("%s\n", api.data.devs->dev[0]->groups->group[0]->name); + + printf("%s\n", api.data.groups->group[0]->id); + */ + /* + api.on_off(api.data.devs->dev[0]); + api.on_off(api.data.devs->dev[3]); + api.on_off(api.data.devs->dev[4]); + */ + + //api.brightness(dev, 100); + //api.kelvin(dev, 4500); + //api.dev_id(dev); + + //printf("%s\n", dev->loop->data.tocen); +} + + + + + + + +int sas_1(int a){}; +int sas_2(int a, int b){}; +int sas_3(int a, ...){ + + return a; +}; +struct test{ + int (*sas) (int, ...); +}; + + +int main(int argc, char *argv[]){ + /* + struct test t; + t.sas = sas_3; + int a = t.sas(1,2); + printf("%i\n", a); + */ + s(); + + + //struct ya_api api = ya_api_create("TOKEN"); + //api.data.ya_devs->dev[0]->ol->data.ya_devs->dev[0]->ol->data.ya_devs->dev[0]->ol->data.ya_devs->dev[0]->ol-> + + + ///struct ya_api api = ya_api_create("Authorization: Bearer --------------------------"); + //api.list_devices(&api); + //api.brightness(api.data.ya_devs->dev[0], 100); + //api.kelvin(api.data.ya_devs->dev[0], 6500); + //api.on_off(api.data.ya_devs->dev[0]); + //printf("%s\n", api.data.ya_devs->dev[0]->ol->data.tocen); + + + //api.list_devices(&api); + //api.on_off(api.data.ya_devs->dev[0]); + //api.brightness(api.data.ya_devs->dev[0], 100); + + //api.kelvin(api.data.ya_devs->dev[0], 6500); + + + + //api.ya_dev_on_off(api.data.ya_devs->dev[0]); + //printf("%s\n", api.ya_dev_kelvin(api.data.ya_devs->dev[0], 6500)); + //char* s = yan_brightness(api.data.ya_devs->dev[0]->id, 100); + //printf("%s\n",ya_api_recvest("https://api.iot.yandex.net/v1.0/devices/actions", s)); + //printf("%s\n", api.ya_dev_kelvin(api.data.ya_devs->dev[0], 6500)); + + //printf("%s\n", api.data.ya_devs->dev[0]->capabilities->range->value); + //char* s = yan_hsv_lampochka(api.data.ya_devs->dev[0]->id, 0,0,100); + //printf("%s\n", s); + //printf("%s\n",ya_api_recvest("https://api.iot.yandex.net/v1.0/devices/actions", s)); + /* + struct ya_api api = ya_api_create("Authorization: Bearer -----------------------------"); + api.list_devices(&api); + printf("1\n"); + //api.ya_dev_on_off(api.data.ya_devs->dev[5]); + printf("2\n"); + //api.ya_dev_on_off(api.data.ya_devs->dev[0]); + printf("3\n"); + api.ya_dev_kelvin(api.data.ya_devs->dev[0], 6500); + */ + + + + + + + //printf("%s\n", ya_dev_kelvin(api.data.ya_devs->dev[0], 6500)); + + + //printf("max: %i\n", api.data.ya_devs->dev[0]->capabilities->color_setting->temperature_k->max); + //printf("min: %i\n", api.data.ya_devs->dev[0]->capabilities->color_setting->temperature_k->min); + + //api.ya_devs_free(&api);// dsdsdsd + + + + /* + for (int i = 0; i != s->len; i++){ + printf("%s\n", s->dev[i]->name); + } + + api.ya_devs_free(s); + */ + //ya_devs_free(s); + //api.ya_dev_on_off(api.list_devices()->dev[0]); + //api.ya_devs_free(); + + + //struct test api; + //ya_devs* devs = list_devices(); + //ya_dev_on_off(devs->dev[0]); + //api.TEST = TEST; + //api.TEST(); + //api.ya_dev_on_off(devs->dev[0]); + /* + ya_devs* devs = list_devices(); + //printf("%s\n", devs->dev[0]->id); + for (int i = 0; i != devs->len; i++){ + printf("%s\n", devs->dev[i]->name); + } + + printf("%s\n", ya_dev_on_off(devs->dev[3])); + + ya_devs_free(devs); + */ + + /* + char* sdsd = list_json(); + printf("SSS%s\n", sdsd); + for (int i = 0; i != 1000000; i++){ + ya_dev* devs = list_devices(sdsd); + for (int i = 0; i != devs->len; i++){ + //printf("%s\n", devs->dev[i]->name); + } + ya_dev_free(devs); + //free(devs); + } + */ + //struct ya_list sas; + //char* stdjson = list_json(); + //ya_list* dev_id = list_devices_id(); + + + + + //dev_off(id); + //dev_on(id); + + + + /* + ya_dev* devs = list_devices(); + for (int i = 0; i != devs->len; i++){ + if (devs->dev[i]->capabilities != NULL){ //printf("%i\n", devs->dev[i]->capabilities->color_setting->temperature_k->max); + if (devs->dev[i]->capabilities->color_setting != NULL){ + printf("%s\n", devs->dev[i]->name);// + printf("%i\n", devs->dev[i]->capabilities->color_setting->temperature_k->value); + //printf("%i\n", devs->dev[i]->capabilities->color_setting->temperature_k->max); + } + //printf("%i\n", devs->dev[i]->capabilities->color_setting->temperature_k->max); + //printf("SAS\n"); + } + } + free(devs); + */ + + + /* + //printf("%i\n", devs->dev[2]->groups->len); + + if (devs->dev[1]->groups != NULL){ + + printf("SASMMM\n"); + //printf("%s\n", devs->dev[0]->groups->id[0]); + //printf("%s\n", devs->dev[0]->groups->len); + } + for (int i = 0; i != devs->len; i++){ + printf("id: %s\t name: %s\n",devs->dev[i]->id, devs->dev[i]->name); + //if (devs->dev[0]->groups != NULL) printf("SAS\n"); + + if (devs->dev[i]->groups != NULL){ + for (int n = 0; n != devs->dev[i]->groups->len; n++) printf("%s\n", devs->dev[i]->groups->id[n]); + + } + + } + */ + + /* + ya_list* dev_id = list_devices_id(); + + for (int i = 0; i != dev_id->len; i++){ + printf("%s\n", dev_id->id[i]); + } + */ + + + + + return 0; +} diff --git a/yandex_smart_home_api_C.kdev4 b/yandex_smart_home_api_C.kdev4 new file mode 100644 index 0000000..75a0c8b --- /dev/null +++ b/yandex_smart_home_api_C.kdev4 @@ -0,0 +1,3 @@ +[Project] +Name=yandex_smart_home_api_C +Manager=KDevCMakeManager