flatcc
0.6.1 Bugfix and maintenance release
Ubuntu, MacOS 및 Windows : Windows : Weekly :
JSON 파서는 향후 릴리스에서 코드 생성이 라이브러리 버전과 일치하도록 코드 생성이 필요한 미래 릴리스에서 구문 분석 Union 벡터에 대한 인터페이스를 변경할 수 있습니다.
flatcc 에는 빌드 및 컴파일러 도구 및 C 런타임 라이브러리를 제외하고 외부 종속성이 없습니다. 동시 닌자 빌드를 사용하면 소규모 클라이언트 프로젝트는 라이브러리로 FlatCC를 구축하고, 스키마 코드를 생성하고, 프로젝트를 연결하고, 몇 초 안에 테스트 케이스를 실행하고, 15K에서 60K 사이의 이항을 생산하고, 30NS에서 작은 버퍼를 읽고, 약 600ns에서 평평한 버퍼를 구축하고, 더 큰 실행 가능 JSON Parsing 또는 Life Type Type Type Type Type Type 메시지를 처리 할 수 있습니다.
이 프로젝트는 FlatBuffer 스키마 파일이 주어진 C에 대한 FlatBuffers 코드를 생성하는 컴파일러 인 FlatCC를 구축합니다. 이 소개는 또한 C 버전의 전통적인 몬스터 예제와 함께 별도의 테스트 프로젝트를 만듭니다.
현재는 Unix와 같은 시스템이 일반적인 요구 사항은 아니지만 건물도 참조하십시오. git, cmake, bash, c 컴파일러 및 닌자 빌드 시스템 또는 제작이 필요합니다.
git clone https://github.com/dvidelabs/flatcc.git
cd flatcc
# scripts/initbuild.sh ninja
scripts/initbuild.sh make
scripts/setup.sh -a ../mymonster
ls bin
ls lib
cd ../mymonster
ls src
scripts/build.sh
ls generated
scripts/initbuild.sh 선택 사항이며 닌자로 기본적으로 빌드 백엔드를 선택합니다.
설정 스크립트는 CMake를 사용하여 FlatCC를 빌드 한 다음 Monster 예제와 함께 테스트 프로젝트 디렉토리와 작은 쉘 스크립트 인 빌드 스크립트를 만듭니다. 헤더와 라이브러리는 상징적으로 테스트 프로젝트에 연결되어 있습니다. FlatCC가 컴파일되면 자신의 프로젝트를 구축하기 위해 CMAKE가 필요하지 않습니다.
foobar라는 다른 테스트 프로젝트를 만들려면 scripts/setup.sh -s -x ../foobar 호출하십시오. 이것은 FlatCC 프로젝트를 처음부터 재건하지 않습니다.
참고 : ChangeLog를 참조하십시오. API 불일치가 발견되면 때때로 사소한 파괴 변경이 있습니다. 명확하게 언급되지 않는 한 변경 사항은 컴파일 된 런타임 라이브러리에 영향을 미치지 않으며 헤더 파일 만 영향을 미치지 않습니다. 문제가 발생하면 flatcc 도구가 include/flatcc 경로와 동일한 버전인지 확인하십시오.
프로젝트에는 다음이 포함됩니다.
flatcc FlatBuffers 스키마 컴파일러 및 해당 라이브러리 libflatcc.a . 컴파일러는 C 헤더 파일 또는 바이너리 플랫 버퍼 스키마를 생성합니다.libflatccrt.a 이 라이브러리에 따라 다릅니다. 다른 언어 인터페이스에도 유용 할 수도 있습니다. 라이브러리는 파서 또는 이와 유사한 버퍼를 쉽게 빌드 할 수 있도록 스택 상태를 유지합니다.flatcc/portable 헤더 전용 라이브러리 및 엔디언 핸들링 및 숫자 인쇄 및 구문 분석을 포함한 모든 컴파일러 용 소형 도우미.또한 참조 :
보고 버그
Google Flatbuffers
지침을 작성하십시오
QuickStart
빌더 인터페이스 참조
벤치 마크
flatcc 컴파일러는 장기적으로 실행되는 프로세스에서 학대 입력에 대해 기꺼이 실패하도록 설계된 스키마 컴파일러의 순수한 휴대용 C 라이브러리 구현을 위해 Googles flatc 컴파일러를 확장하는 대신 독립형 도구로 구현됩니다. 또한 C 버전은 C ++보다 C와 인터페이스를 더 쉽게 찾는 다른 언어 인터페이스에 스키마 파싱을 제공하는 데 도움이 될 수 있다고 생각됩니다. Googles FPL Lab의 Flatbuffers 팀은 피드백을 제공하고 가능한 최상의 호환성을 보장하기 위해 많은 질문에 대답하는 데 매우 도움이되었습니다. flatcc (FlatBuffers C 컴파일러) vs Googles flatc 라는 이름에 주목하십시오.
JSON 형식은 Googles flatc 도구와 호환됩니다. flatc 도구는 스키마와 버퍼를 입력으로 사용하여 명령 줄에서 JSON을 변환합니다. flatcc 런타임에 JSON을 읽고 쓰는 스키마 특정 코드를 생성합니다. flatcc 접근 방식이 훨씬 빠르고 배포하기 쉽지만, 게임 장면 편집과 같은 JSON과 수동으로 작업 할 때 flatc 접근 방식이 더 편리 할 수 있습니다. 두 도구 모두 자리를 잡고 있습니다.
참고 : 빅 엔디 언 플랫폼은 릴리스 0.4.0에 만 지원됩니다.
Meson 빌드 시스템에 대한 지원을 추가하는 것으로 간주되고 있지만 문제 #56을 통해이 문제에 대한 피드백이 좋을 것입니다.
가능하면 짧은 재현 가능한 스키마 및 소스 파일을 메인 프로그램과 함께 오류의 반환 1, 성공시 0 및 작은 빌드 스크립트를 제공하십시오. 바람직하게는 hexdump를 생성하고 버퍼 검증기를 호출하여 입력이 유효하고 디버그 라이브러리 flatccrt_d 와 연결됩니다.
버퍼 디버깅 및 readfile.h도 참조하여 기존 버퍼를 읽는 데 유용합니다.
예:
샘플/버그보고
eclectic.fbs :
namespace Eclectic ;
enum Fruit : byte { Banana = -1 , Orange = 42 }
table FooBar {
meal : Fruit = Banana ;
density : long ( deprecated );
say : string ;
height : short ;
}
file_identifier "NOOB" ;
root_type FooBar ;myissue.c :
/* Minimal test with all headers generated into a single file. */
#include "build/myissue_generated.h"
#include "flatcc/support/hexdump.h"
int main ( int argc , char * argv [])
{
int ret ;
void * buf ;
size_t size ;
flatcc_builder_t builder , * B ;
( void ) argc ;
( void ) argv ;
B = & builder ;
flatcc_builder_init ( B );
Eclectic_FooBar_start_as_root ( B );
Eclectic_FooBar_say_create_str ( B , "hello" );
Eclectic_FooBar_meal_add ( B , Eclectic_Fruit_Orange );
Eclectic_FooBar_height_add ( B , -8000 );
Eclectic_FooBar_end_as_root ( B );
buf = flatcc_builder_get_direct_buffer ( B , & size );
#if defined( PROVOKE_ERROR ) || 0
/* Provoke error for testing. */
(( char * ) buf )[ 0 ] = 42 ;
#endif
ret = Eclectic_FooBar_verify_as_root ( buf , size );
if ( ret ) {
hexdump ( "Eclectic.FooBar buffer for myissue" , buf , size , stdout );
printf ( "could not verify Electic.FooBar table, got %sn" , flatcc_verify_error_string ( ret ));
}
flatcc_builder_clear ( B );
return ret ;
}build.sh :
#! /bin/sh
cd $( dirname $0 )
FLATBUFFERS_DIR=../..
NAME=myissue
SCHEMA=eclectic.fbs
OUT=build
FLATCC_EXE= $FLATBUFFERS_DIR /bin/flatcc
FLATCC_INCLUDE= $FLATBUFFERS_DIR /include
FLATCC_LIB= $FLATBUFFERS_DIR /lib
mkdir -p $OUT
$FLATCC_EXE --outfile $OUT / ${NAME} _generated.h -a $SCHEMA || exit 1
cc -I $FLATCC_INCLUDE -g -o $OUT / $NAME $NAME .c -L $FLATCC_LIB -lflatccrt_d || exit 1
echo " running $OUT / $NAME "
if $OUT / $NAME ; then
echo " success "
else
echo " failed "
exit 1
fi 릴리스 0.6.2 (개발 중)는 주로 버그 수정 릴리스입니다. 자세한 내용은 changelog를 참조하십시오. _create_as_root로 호출하기 전에 생성 된 객체가 제대로 정렬되지 않는 곳에서 긴 스탠딩 버그가 고정되었으며, 버퍼 끝은 이제 버퍼 내에서 볼 수있는 가장 큰 물체로 패딩됩니다. Clang Debug 빌드의 경우 -fsanitize = undefined가 추가되었으며이를 위해서는 링커 기호가 누락되지 않도록 해당 플래그를 사용하려면 종속 소스 코드가 필요할 수 있습니다. 이 기능은 cmakelists.txt에서 비활성화 할 수 있습니다.
릴리스 0.6.1에는 플랫폼 에지 케이스를 처리하기 위해 주로 버그 수정 및 커뮤니티의 기여가 포함되어 있습니다. 또한 GCC가 너무 공격적이기 때문에 Clang 대신 의존하는 Pendantic GCC 경고가 비활성화되어 있으며, GCC는 자주 빌드를 중단하고 이식성에 대비하여 작동합니다. 기존 C ++ 테스트 케이스는 C 코드가 공통 C ++ 컴파일러와도 작동하도록하지만 일부 환경을 깨뜨릴 수 있으므로 이제 모든 테스트를 비활성화하지 않고 해당 테스트를 비활성화하는 플래그가 있습니다. 플랫 버퍼 형식의 옵션 스칼라 값에 대한 지원이 추가되었습니다. 다양한 플랫폼에서 추상 메모리 할당에 대한 지원이 향상되었습니다. <table>_identifier identifier 인해 쉽게 갈등을 초래하기 때문에 생성 된 코드로 <table>_file_identifier 호의적으로 더 이상 사용되지 않았습니다. 생성 된 코드의 file_extension 은 이제 접두사가없는 점 (.)이 없습니다.
릴리스 0.6.0은 키 속성과 함께 사용할 "기본"속성을 소개하여 기본 키를 찾아서 정렬 할 수 있습니다. 기본이 없으면 ID가 가장 낮은 키가 기본이됩니다. 테이블과 벡터는 이제 기본 키에서 재귀 적으로 정렬 할 수 있습니다. 브레이킹 : 이전에는 가장 낮은 ID가 아닌 첫 번째 나열된 것이 기본 키입니다. 또한 구조장에서 고정 길이 스칼라 어레이를 소개합니다 (구조 및 열거 요소는 지원되지 않음). Structs는 숯 어레이를 포함하여 고정 길이 배열 필드를 지원합니다. 빈 스트러크는 완전히 작동하지 않았으며 더 이상 지원되지 않으며 더 이상 Flatc에 의해 지원되지 않습니다. 참고 : Char Array는 현재 Googles Flatc 컴파일러의 일부가 아닙니다. Int8 배열 대신 사용될 수 있습니다. 브레이킹 : 빈 스트러크는 더 이상 지원되지 않습니다. Googles Flatc 컴파일러에서도 유효하지 않습니다. 추가 변경 사항은 Changelog를 참조하십시오. 감가 상각 된 : flatcc_accessors.h 의 함수에서 낮은 수준 cast_to/from read/write_from/to 유리하게 제거됩니다. 이것은 정상적인 사용에 영향을 미치지 않아야하지만이 릴리스에서 유효합니다.
릴리스 0.5.3은 다양한 버그 수정 (ChangeLog 참조)과 하나의 파단이지만 영향이 낮을 가능성이 낮을 가능성이 낮을 수 있습니다. Breaking : Breaking : 0.5.3 변경 Builder의 동작은 전화를 생성하므로 ID 속성을 사용할 때 필드 ID에 의해 인수가 항상 주문됩니다 MyGame_Example_Monster_create() 예 : monster_test.fbs ). 숫자 키 필드로 테이블을 정렬 할 때 정의되지 않은 동작을 수정합니다.
릴리스 0.5.2는 옵션 _get 접미사를 리더 메소드에 소개합니다. flatcc -g 사용하면 _get 메소드 만 유효합니다. 이것은 일부 필드 이름에 대한 잠재적 이름 혼란을 제거합니다. 0.5.2는 또한 테이블 및 벡터에 대한 오랫동안 기다려온 클론 작업을 소개합니다. C ++ Smoketest refmap.c 추가되었습니다.
릴리스 0.5.1은 JSON 프린터에서 버퍼 오버런을 수정하고 휴대용 라이브러리 <stdalign.h> C ++ 및 내장 된 newlib 표준 라이브러리와의 호환성을 향상시킵니다. JSON 인쇄 및 구문 분석은 test_json.c의 테스트 드라이버에서 볼 수 있듯이 스키마 루트 이외의 테이블을 구문 분석하고 인쇄하는 데 도움이되었습니다. Monster_test.fbs 파일은 Googles Flatc 버전과 더 일치하는 몬스터 테이블을 더 일치시키기 위해 재구성되었으며 결과적으로 작은 스키마 네임 스페이스 불일치가 해결되었습니다. 휴대용 헤더에 대한 명시 적 참조는 생성 된 소스에서 벗어났습니다. 외부 "C"C ++ 가드가 생성 된 헤더 주위에 추가되었습니다. 0.5.1은 또한 저수준 Union 인터페이스를 정리하여 {type, value}이라는 용어가 {type, member} 및 {type, members}를 통해 일관되게 사용됩니다.
be Branch에서 활성화.프로젝트가 안정되면 자주 업데이트 할 계획은 없지만, 특히 다른 대상 플랫폼에서의 테스트와 관련하여 관련이있는 곳에있는 릴리스에 항상 환영 받고 릴리스에 포함됩니다.
이 목록은 다소 구식이며, 더 최근의 컴파일러 버전은 추가로 CI 플랫폼이 더 이상 지원되지 않지만 대부분의 지원되는 대상은 변경되지 않은 상태로 유지되면 일부 오래된 버전이 제거됩니다. MSVC 2010은 앞으로 더 이상 사용되지 않을 수 있습니다.
CI-MORE 브랜치는 추가 컴파일러를 테스트합니다.
C11/C ++ 11은 항상 작동 할 것으로 예상되는 참조입니다.
GCC --pedantic 컴파일러 옵션은 포트가 불가능한 코드가 변경되기 때문에 GCC-8+로 지원되지 않습니다.
MSVC 2017은 CI 환경이 MSVC 2010을 지원하지 않기 때문에 항상 테스트되지는 않습니다.
C ++ 컴파일러의 구형/비표준 버전은 static_assert 와 alignas 예상대로 결석하거나 완전히 작동하지 않는 이상한 방식으로 행동하기 때문에 문제를 일으 킵니다. 종종 해결 방법이 있지만 -std=c++11 또는 -std=c++14 사용하는 것이 더 신뢰할 수 있습니다.
휴대용 라이브러리는 GCC 4.7 이전에 stdalign.h 및 stdint.h의 C ++ 제한을 중심으로 작동하지 않기 때문에 Portabilith Library는 GCC C ++ Pre 4.7을 지원하지 않습니다. 이것은 고정 될 수 있지만 우선 순위는 아닙니다.
CI 환경이 업데이트 될 때 이전에 일부 Test Compiler 버전이 은퇴했을 수 있습니다. 현재 구성에 대해 ci-more 브랜치의 .travis.yml 및 appveyor.yml 참조하십시오.
Monster Sample은 C99 스타일 코드를 사용하여 C ++ 버전을 더 잘 팔로우하기 때문에 MSVC 2010에서는 작동하지 않습니다.
빌드 옵션 FLATCC_TEST 문제가되는 플랫폼에서 FlatCC를 컴파일 할 수있는 모든 테스트를 비활성화하는 데 사용될 수 있습니다. BULD 옵션 FLATCC_CXX_TEST C ++ 테스트 (생성 된 C 코드를 포함하는 간단한 C ++ 파일)에 대해 특별히 비활성화 될 수 있습니다.
다른 또는 오래된 컴파일러를 지원할 수없는 이유는 없지만 빌드 구성에서 일부 작업이 필요하고 휴대용 라이브러리에 대한 업데이트가 필요할 수 있습니다. 위는 단순히 테스트 및 구성된 것입니다.
이식성 레이어에는 Endian Handling과 같은 것들에 일반적으로 중요한 기능이 있으며 다른 기능은 선택 사항 및 누락 된 C11 기능에 대한 호환성을 제공하는 것입니다. 함께 이것은 대부분의 C 컴파일러를 지원해야하지만 성숙도에 대한 커뮤니티 피드백에 의존합니다.
런타임의 필요한 크기는 -std = c11을 사용하고 JSON (많은 숫자 구문 분석 지원이 필요한)을 피하고, 이진 스키마 파일의 처리를 지원하기 위해 존재하는 include/flatcc/reflection 제거하여 파일을 크게 줄일 수 있으며, reflection/reflection.fbs 하고 FBS에서만 생성 될 수 있으며, include/flatcc/support 테스트 및 샘플에만 사용될 수 있습니다. 필요한 파일의 정확한 세트는 릴리스에서 릴리스로 변경 될 수 있으며 컴파일 된 코드 크기와 관련하여 중요하지 않습니다.
우선 순위는 서버와 임베디드 장치 모두에 적합하지만 절대 성능에 비해 유용성으로 합리적으로 빠르고 사용하기 쉬운 C 빌더 인터페이스를 설계하는 것이 우선 순위가 있습니다. 여전히 작은 버퍼 출력 속도는 초당 밀런으로 측정되며 대략적인 추정치에서 초당 10-100 밀롱 버퍼를 읽습니다. 플랫 버퍼를 읽는 것은 구축하는 것보다 훨씬 빠른 순서 이상입니다.
1000 명의 몬스터, 동적으로 확장 된 몬스터 이름, 몬스터 벡터 및 인벤토리 벡터가있는 100MB 버퍼의 경우, 대역폭은 2.2GHz Haswell Core i7 CPU에서 약 2.2GB/s 및 45ms/버퍼에 도달합니다. 여기에는 모든 데이터를 읽고 검증하는 것이 포함됩니다. 몇 가지 주요 필드 만 읽으면 대역폭이 2.7GB/s 및 37ms/op로 증가합니다. 10MB 버퍼의 경우 대역폭 대역폭이 높을 수 있지만 결국 더 작은 버퍼는 통화 오버 헤드에 의해 히트되므로 작은 버퍼를 인코딩하는 약 150ns/op에서 300MB/s로 줄어 듭니다. 이 숫자는 대략적인 가이드 라인 일뿐입니다. 분명히 하드웨어, 컴파일러 및 인코딩 된 데이터에 의존합니다. 측정은 초기 워밍업 단계를 제외합니다.
생성 된 JSON 파서는 C 또는 C ++에 직접 플랫 버퍼를 구축하는 것보다 약 4 배나 느립니다. 따라서 JSON 구문 분석은 Google Flatbuffers 벤치 마크 페이지에보고 된 바와 같이 동등한 프로토콜 버퍼를 읽는 것보다 대략 2 배 더 빠릅니다. LZ4 압축은 JSON 구문 분석의 전체 처리 시간의 두 배로 추정됩니다. JSON 인쇄는 구문 분석보다 빠르지 만 크게는 그렇지 않습니다. JSON은 큰 버퍼에서 압축 된 플랫 버퍼의 크기의 약 절반으로 압축되지만 작은 버퍼에서는 압축 할 수 없습니다 (압축 할 때는 말할 것도 없습니다).
Flatbuffer 읽기 성능은 JSON 파서 및 프로토콜 버퍼가 본질적으로 그 특성에 포함시키는 검증을 제외한다는 점에 유의해야합니다. 검증은 벤치마킹되지 않았지만 큰 버퍼의 일부만 읽지 않는 한 50% 미만의 읽기 오버 헤드를 추가 할 것입니다.
또한 벤치 마크를 참조하십시오.
클라이언트 C 코드는 빌더 스택이 객체를 커밋하기 전에 확장 가능한 경기장을 제공하기 때문에 버퍼를 빌드하기 위해 거의 모든 종류의 할당을 피할 수 있습니다 (예 : 줄이나 벡터 단편). 이 스택은 대부분의 엔트 디안 플랫폼의 정수 배열에서 벡터와 같이 직접 구성 할 수있는 경우 대부분 우회됩니다.
독자 인터페이스는 개선 성능의 공간이 적은 것처럼 매우 빠르야합니다. 건축업자보다 훨씬 간단합니다.
유용성은 또한 가능한 가장 작은 생성 된 소스 코드 및 컴파일 시간보다 우선 순위를 정했습니다. 컴파일 된 크기에 크게 영향을 미치지 않아야합니다.
컴파일 된 이진 출력은 가장 제한적인 마이크로 컨트롤러를 제외하고는 모든 것에 대해 합리적으로 작아야합니다. 33k 몬스터 소스 테스트 파일 (생성 된 헤더 및 빌더 라이브러리 외에)은 Printf 문 및 기타 지원 로그에 대한 오버 헤드 또는 빌더 라이브러리를 제외한 30K 객체 파일을 포함한 50K 미만의 최적화 된 이진 실행 파일을 초래합니다.
읽기 전용 바이너리는 작품을 덜 수행한다는 점을 고려하면 건축업자보다 작지만 반드시 훨씬 작을 필요는 없습니다. 호환성 테스트는 사전 생성 된 이진 monsterdata_test.golden Monster 파일을 읽고 모든 컨텐츠가 예상되는지 확인합니다. 이로 인해 13K 최적의 이진 실행 가능 또는 6K 객체 파일이 발생합니다. 이 점검의 소스는 헤더 파일을 제외한 5K입니다. 독자는 도서관과 연결할 필요가 없습니다.
JSON 파서는 구문 분석 트리를 인화하기 때문에 순수한 플랫 버퍼 사용에 비해 컴파일 된 C 바이너리를 팽창시킵니다. Monster.fbs의 JSON 파서는 실행 가능한 바이너리에 100K +/- 최적화 설정을 추가 할 수 있습니다.
Flatbuffers를 구축하고 플랫 버퍼를 구문 분석하고 인쇄하기위한 생성 된 코드는 모두 include/flatcc 에 대한 액세스가 필요합니다. 독자는 도서관에 의존하지 않지만 다른 모든 생성 된 파일은 libflatccrt.a 런타임 라이브러리에 의존합니다. libflatcc.a 는 FlatCC 컴파일러 자체가 라이브러리로 필요한 경우에만 필요합니다.
리더와 빌더는 생성 된 공통 리더 및 빌더 헤더 파일에 의존합니다. 이 공통 파일을 사용하면 글로벌 네임 스페이스를 변경하고 기본 유형 ( uoffset_t 등)을 재정의 할 수 있습니다. 앞으로 이것은 라이브러리 코드로 이동하여 이러한 추상화에 매크로를 사용할 수 있으며 결국 표준 32 비트 부호없는 오프셋 ( uoffset_t ) 이외의 유형에 대한 사전 정의 된 파일 세트가 있습니다. 런타임 라이브러리는 하나의 유형 정의 세트에만 해당됩니다.
사용에 대한 자세한 지침은 monster_test.c와 생성 된 파일을 참조하십시오. 이 프로젝트에 사용 된 몬스터 스키마는 일부 추가 에지 케이스를 테스트하기 위해 원본에 약간의 적응입니다.
FlatBuffers를 구축하려면 스키마 당 별도의 빌더 헤더 파일이 생성됩니다. flatbuffers_common_builder.h 파일이 필요합니다. 컴파일러와 작은 런타임 라이브러리 libflatccrt.a 에서도 생성됩니다. 이 요구 사항 때문에 독자와 빌더 생성 코드가 별도로 유지되기 때문입니다. 일반적인 용도는 monster_test.c 파일에서 볼 수 있습니다. 빌더는 컨텐츠를 벡터 또는 문자열로 반복적으로 푸시 할 수있게하고 포함 테이블이 업데이트되어 외부 형식의 구문 분석을 단순화합니다. 인라인으로 중첩 된 버퍼를 빌드 할 수도 있습니다. 처음에는 과도하게 들릴 수 있지만 네트워크 인터페이스에서 버퍼의 결합을 포장 할 때 유용하며 모든 버퍼 레벨의 적절한 정렬을 보장합니다.
flatbuffers를 확인하기 위해 myschema_verifier.h 가 생성됩니다. 런타임 라이브러리와 리더 헤더에 따라 다릅니다.
JSON 파서 및 프린터는 스키마 파일 당 하나의 파일을 생성하며 포함 된 스키마에는 파서와 프린터를 포함하여 구문 분석기와 프린터를 포함하여 자체 파서와 프린터가 있으며 건축업자 작동 방식과 유사합니다.
낮은 레벨 참고 : 빌더는 각 테이블 앞에서 애드에서 애드에서 애드에서 모든 vtables를 생성하지만 그렇지 않으면 vtables와 동일하게 수행합니다. 이를 통해 핫 캐시에서 vtables를 클러스터링하거나 버퍼를 부분적으로 전송할 때 모든 vtables를 사용할 수 있는지 확인할 수 있습니다. 이 동작은 런타임 플래그로 비활성화 될 수 있습니다.
일부 사용 사례에는 매우 제한된 임베디드 장치가 포함될 수 있으므로 빌더 라이브러리는 할당 자체와 버퍼 이미 터 객체로 사용자 정의 할 수 있습니다. 별도의 이미 터는 원하는 경우 전체 버퍼를 메모리에 한 번에 존재하지 않고 버퍼를 구성 할 수 있도록합니다.
유형이없는 Builder 라이브러리는 Flatcc_builder.h 및 FlatCC_Mitter.h에 문서화되어 있으며 C에 대한 생성 된 유형의 빌더 API는 Builder Interface Reference에 문서화됩니다.
때때로 생성 된 코드에 사용 된 매크로의 조밀 한 특성에 대한 우려가 제기됩니다. 이 매크로는 실제로 사용 가능한 기능을 이해하기가 어렵습니다. 빌더 인터페이스 참조는 일반적인 방식으로 작업을 문서화하려고 시도합니다. 보다 자세한 정보를 얻으려면 scripts/flatcc-doc.sh 스크립트로 생성 된 기능 프로토 타입을 추출 할 수 있습니다.
일부는 또한 매크로가 "안전하지 않은"것에 관심이 있습니다. 정적 또는 정적 인라인 함수를 생성하기 때문에 FlatCC와 함께 사용될 때 매크로는 안전하지 않습니다. 직접 C 코드에서 동일한 확장으로 잘못 사용하면 컴파일 시간 오류가 발생합니다.
확장은 소스 제어 하의 코드가 폭발하지 않도록하는 요인 10 이상으로 생성 된 출력을 압축하여 생성 된 코드의 버전을 의미있는 방식으로 비교하고 의도 된 스키마와 일치하는지 확인할 수 있습니다. 매크로는 또한 휴대용 헤더를 통한 플랫폼 추상화를 처리하는 데 중요합니다.
그럼에도 불구하고 빌드 시스템에서 직접 지원하지는 않지만 생성 된 출력을 볼 수 있습니다. 예를 들어, include/flatcc/reflection 반사 스키마에 대한 사전 생성 헤더 파일이 포함되어 있습니다. clang 컴파일러 도구 체인을 사용하여 확장 된 출력을 보려면 실행하십시오.
clang -E -DNDEBUG -I include
include/flatcc/reflection/reflection_reader.h |
clang-format
Clang을 지원하지 않는 플랫폼에서 다른 유사한 명령을 사용할 수 있습니다.
컴파일러는 생성 된 거의 모든 코드를 최적화하고 기능이 정적 또는 정적 인라인이기 때문에 실제로 최종 사용자 코드에서 참조 된 논리 만 사용합니다. 나머지 부분은 일반적으로 응용 프로그램 코드에 효율적으로 인라인으로 인라인으로 합리적으로 작은 이진 코드 크기를 만듭니다.
자세한 내용은 #88에서 확인할 수 있습니다
생성 된 코드의 확장은 특정 객체 유형에 대한 문서를 얻는 데 사용될 수 있습니다.
다음 스크립트는이 프로세스를 자동화합니다.
scripts/flatcc-doc.sh <schema-file> <name-prefix> [<outdir>]
<outdir>/<name-prefix>.doc 에 대한 기능 프로토 타입을 작성합니다.
스크립트에는 Clang 컴파일러와 Clang-format 도구가 필요하지만 스크립트는 다른 도구 체인에도 적응할 수 있습니다.
스크립트 뒤의 원리는 객체 테이블에 대한 문서가 추출되는 예제로 반사 스키마를 사용하여 설명 할 수 있습니다.
bin/flatcc reflection/reflection.fbs -a --json --stdout |
clang - -E -DNDEBUG -I include |
clang-format -style="WebKit" |
grep "^static.* reflection_Object_w*(" |
cut -f 1 -d '{' |
grep -v deprecated |
grep -v ");" |
sed 's/__tmp//g' |
sed 's/)/);/g'
Clang-Format의 WebKit 스타일은 매개 변수와 리턴 유형이 모두 같은 줄에 배치되도록합니다. Grep은 기능 헤더를 추출하고 같은 줄에서 시작하는 스트립 기능 본문을 추출합니다. SED 스트립 __tmp 접미사는 매크로 이름 충돌을 피하기 위해 사용되는 매개 변수 이름의 접미사입니다. grep 스트립 ); 중복 전진 선언을 제거하고 SED를 추가합니다. 각 라인을 유효한 C 프로토 타입으로 만들려면.
위의 내용은 출력이 변경 될 수 있으므로 항상 작동하는 것은 아니지만 먼 길을 가야합니다.
FlatCC-V0.5.2에서 출력의 작은 추출물
static inline size_t reflection_Object_vec_len(reflection_Object_vec_t vec);
static inline reflection_Object_table_t reflection_Object_vec_at(reflection_Object_vec_t vec, size_t i);
static inline reflection_Object_table_t reflection_Object_as_root_with_identifier(const void* buffer, const char* fid);
static inline reflection_Object_table_t reflection_Object_as_root_with_type_hash(const void* buffer, flatbuffers_thash_t thash);
static inline reflection_Object_table_t reflection_Object_as_root(const void* buffer);
static inline reflection_Object_table_t reflection_Object_as_typed_root(const void* buffer);
static inline flatbuffers_string_t reflection_Object_name_get(reflection_Object_table_t t);
static inline flatbuffers_string_t reflection_Object_name(reflection_Object_table_t t);
static inline int reflection_Object_name_is_present(reflection_Object_table_t t);
static inline size_t reflection_Object_vec_scan_by_name(reflection_Object_vec_t vec, const char* s);
static inline size_t reflection_Object_vec_scan_n_by_name(reflection_Object_vec_t vec, const char* s, int n);
...
예제는 반사 및 몬스터 스키마를 사용하여 다음 스크립트에 제공됩니다.
scripts/reflection-doc-example.sh
scripts/monster-doc-example.sh
Monster Doc 예제는 본질적으로 다음을 호출합니다.
scripts/flatcc-doc.sh samples/monster/monster.fbs MyGame_Sample_Monster_
MyGame_Sample_Monster_.doc 파일에서 결과
static inline size_t MyGame_Sample_Monster_vec_len(MyGame_Sample_Monster_vec_t vec);
static inline MyGame_Sample_Monster_table_t MyGame_Sample_Monster_vec_at(MyGame_Sample_Monster_vec_t vec, size_t i);
static inline MyGame_Sample_Monster_table_t MyGame_Sample_Monster_as_root_with_identifier(const void* buffer, const char* fid);
static inline MyGame_Sample_Monster_table_t MyGame_Sample_Monster_as_root_with_type_hash(const void* buffer, flatbuffers_thash_t thash);
static inline MyGame_Sample_Monster_table_t MyGame_Sample_Monster_as_root(const void* buffer);
static inline MyGame_Sample_Monster_table_t MyGame_Sample_Monster_as_typed_root(const void* buffer);
static inline MyGame_Sample_Vec3_struct_t MyGame_Sample_Monster_pos_get(MyGame_Sample_Monster_table_t t);
static inline MyGame_Sample_Vec3_struct_t MyGame_Sample_Monster_pos(MyGame_Sample_Monster_table_t t);
static inline int MyGame_Sample_Monster_pos_is_present(MyGame_Sample_Monster_table_t t);
static inline int16_t MyGame_Sample_Monster_mana_get(MyGame_Sample_Monster_table_t t);
static inline int16_t MyGame_Sample_Monster_mana(MyGame_Sample_Monster_table_t t);
static inline const int16_t* MyGame_Sample_Monster_mana_get_ptr(MyGame_Sample_Monster_table_t t);
static inline int MyGame_Sample_Monster_mana_is_present(MyGame_Sample_Monster_table_t t);
static inline size_t MyGame_Sample_Monster_vec_scan_by_mana(MyGame_Sample_Monster_vec_t vec, int16_t key);
static inline size_t MyGame_Sample_Monster_vec_scan_ex_by_mana(MyGame_Sample_Monster_vec_t vec, size_t begin, size_t end, int16_t key);
...
Flatbuffer 기본 유형도 추출 할 수 있습니다 (예 : 문자열 작업).
scripts/flatcc-doc.sh samples/monster/monster.fbs flatbuffers_string_
flatbuffers_string_.doc 의 결과 :
static inline size_t flatbuffers_string_len(flatbuffers_string_t s);
static inline size_t flatbuffers_string_vec_len(flatbuffers_string_vec_t vec);
static inline flatbuffers_string_t flatbuffers_string_vec_at(flatbuffers_string_vec_t vec, size_t i);
static inline flatbuffers_string_t flatbuffers_string_cast_from_generic(const flatbuffers_generic_t p);
static inline flatbuffers_string_t flatbuffers_string_cast_from_union(const flatbuffers_union_t u);
static inline size_t flatbuffers_string_vec_find(flatbuffers_string_vec_t vec, const char* s);
static inline size_t flatbuffers_string_vec_find_n(flatbuffers_string_vec_t vec, const char* s, size_t n);
static inline size_t flatbuffers_string_vec_scan(flatbuffers_string_vec_t vec, const char* s);
static inline size_t flatbuffers_string_vec_scan_n(flatbuffers_string_vec_t vec, const char* s, size_t n);
static inline size_t flatbuffers_string_vec_scan_ex(flatbuffers_string_vec_t vec, size_t begin, size_t end, const char* s);
...
자세한 내용은 flatcc -h 를 참조하십시오.
여기에 나열된 온라인 버전 : flatcc -help.md이지만 최신 참조를 위해 flatcc -h 사용하십시오.
컴파일러는 포함 된 모든 스키마 및 공통 파일에 대한 단일 헤더 파일 또는 헤더를 생성 할 수 있으며 읽기 (기본값) 및 쓰기 (-W) Flatbuffers를 모두 지원하거나 지원하지 않아도됩니다. 가장 간단한 옵션은 모두 (-a)를 사용하고 myschema_builder.h 파일을 포함시키는 것입니다.
(-a) 또는 (-v)도 검증 자 파일을 생성합니다.
C 컴파일러에서 include 폴더 아래의 flatcc 가 FlatBuffer Builders를 컴파일 할 때 경로를 포함하는지 확인하십시오.
flatcc (-i) 포함 경로는 기본 이름 (Case Insentive)을 가진 모든 스키마 파일이 동일하며 첫 번째를 포함한다고 가정합니다. 생성 된 모든 파일은 입력베이스 이름을 사용하며 작업 디렉토리 또는 (-o)에 의해 설정된 경로에 착륙합니다.
(-stdout)을 사용하여 STDOUT에 파일을 생성 할 수 있습니다. C 헤더는 주문하고 연결되지만 별도의 파일 출력과 동일합니다. 각 포함 된 명령문이 보호되므로 파일이 포함되지 않습니다.
생성 된 코드, 특히 -stdout과 결합 된 모든 코드는 크게 보일 수 있지만 실제로 사용 된 부품 만 최종 실행 파일 또는 객체 파일을 차지합니다. 최신 컴파일러는 인라인이며 정적으로 연결된 빌더 라이브러리의 필요한 부분 만 포함합니다.
JSON 프린터와 파서는 -json 플래그 또는 -json-printer 또는 json-parser를 사용하여 생성 할 수 있습니다. 인쇄 기호 열거를 최적화 할 수있는 특정 런타임 라이브러리 컴파일 타임 플래그가 있지만 런타임에 비활성화 할 수도 있습니다.
libflatccrt (스키마 컴파일러)가 아닌 libflatcc (런타임의 RT)와 연결하십시오. 그렇지 않으면 빌더를 사용할 수 없습니다. 또한 포함 경로에 FlatCC 프로젝트 루트의 '포함'을 확인하십시오.
FlatCC는 기본적으로 버퍼를 읽거나 확인할 때 버퍼의 file_identifier 기대합니다.
버퍼는 오프셋 4에 예기치 않은 4 바이트 식별자를 가질 수 있거나 식별자가 없을 수 있습니다.
모든 언어 인터페이스가 버퍼에서 파일 식별자를 지원하는 것은 아니며, 그렇다면 이전 버전에서는 그렇게하지 않을 수 있습니다. 사용자는 Python 및 LUA 인터페이스 모두에서 문제를보고했지만 쉽게 해결됩니다.
검증 자의 반환 값을 확인하십시오.
int ret;
char *s;
ret = MyTable_verify_as_root(buf, size);
if (ret) {
s = flatcc_verify_error_string(ret);
printf("buffer failed: %sn", s);
}
식별자가없는 버퍼를 확인하거나 다른 식별자를 무시하려면 _ull 식별자가있는 검증기의 _with_identifier 버전을 사용하십시오.
char *identifier = 0;
MyTable_verify_as_root_with_identifier(buf, size, identifier);
버퍼 사용을 읽으려면 :
MyTable_as_root_with_identifier(buf, 0);
식별자 사용없이 버퍼를 구축하려면 다음과 같습니다.
MyTable_start_as_root_with_identifier(builder, 0);
...
MyTable_end_as_root_with_identifier(builder, 0);
다른 as_root CALL에는 JSON 인쇄를 포함하여 as_root_with_identifier 버전이 있습니다.
flatcc tool 구축 한 후 바이너리는 flatcc 소스 트리 아래의 bin 및 lib 디렉토리에 있습니다.
Googles Flatbuffers 튜토리얼에 따른 Monster 예제로 직접 점프하거나 아래의 QuickStart 안내서를 따라 읽을 수 있습니다. Monster 튜토리얼을 따르면 FlatCC를 복제하고 빌드하여 소스를 다음과 같이 별도의 프로젝트 디렉토리로 복사 할 수 있습니다.
git clone https://github.com/dvidelabs/flatcc.git
flatcc/scripts/setup.sh -a mymonster
cd mymonster
scripts/build.sh
build/mymonster
scripts/setup.sh 는 라이브러리와 도구를 mymonster , 여기에서 라이브러리와 도구를 사용자 정의 디렉토리로 연결합니다. (-a)를 사용하면 간단한 빌드 스크립트를 추가하고 예제를 복사하며 업데이트 .gitignore scripts/setup.sh -h 참조하십시오. 설정은 FlatCC를 빌드 할 수도 있지만 여전히 시스템에 대한 빌드 환경이 구성되어 있는지 확인해야합니다.
자신의 스키마 파일을 작성하려면 스키마 파일 작성에 대한 주요 FlatBuffers 프로젝트 문서를 따르십시오.
빌더 인터페이스 참조는 몬스터 샘플을 연구 한 후 유용 할 수 있으며 아래의 퀵 스테이트.
키로 벡터를 분류하고 요소를 찾는 것과 같은 고급 예제를 찾을 때 test/monster_test 프로젝트에서 찾을 수 있어야합니다.
다음 QuickStart 안내서는 test/monster_test 프로젝트의 광범위한 단순화입니다. 스키마는 자습서와 약간 다릅니다. 초점은 일반적인 플랫 버퍼 개념보다는 C 특정 프레임 워크에 있습니다.
여전히 설정 도구를 사용하여 빈 프로젝트를 만들고 따라갈 수 있지만 아래 텍스트에는 이에 대한 가정이 없습니다.
여기에서는 Monster Flatbuffer에 대한 읽기 전용 액세스의 빠른 예를 제공합니다. Monster_test.c 파일의 적응 된 추출물입니다.
먼저 Common (-C) 지원 헤더로 스키마 읽기 전용을 컴파일하고 Monster_test.fbs에 다른 파일이 포함되어 있기 때문에 재귀를 추가합니다.
flatcc -cr --reader test/monster_test/monster_test.fbs
단순화를 위해 프로젝트 루트 폴더에서 예제 프로젝트를 작성한다고 가정하지만 Praxis에서는 몇 가지 경로를 변경하려고합니다.
mkdir -p build/example
flatcc -cr --reader -o build/example test/monster_test/monster_test.fbs
cd build/example
우리는 얻는다 :
flatbuffers_common_reader.h
include_test1_reader.h
include_test2_reader.h
monster_test_reader.h
(더 간단한 samples/monster/monster.fbs 도 있지만 스키마 파일이 포함되지 않습니다).
네임 스페이스가 길어서 선택적으로 매크로를 사용하여이를 관리합니다.
#include "monster_test_reader.h"
#undef ns
#define ns(x) FLATBUFFERS_WRAP_NAMESPACE(MyGame_Example, x)
int verify_monster(void *buffer)
{
ns(Monster_table_t) monster;
/* This is a read-only reference to a flatbuffer encoded struct. */
ns(Vec3_struct_t) vec;
flatbuffers_string_t name;
size_t offset;
if (!(monster = ns(Monster_as_root(buffer)))) {
printf("Monster not availablen");
return -1;
}
if (ns(Monster_hp(monster)) != 80) {
printf("Health points are not as expectedn");
return -1;
}
if (!(vec = ns(Monster_pos(monster)))) {
printf("Position is absentn");
return -1;
}
/* -3.2f is actually -3.20000005 and not -3.2 due to representation loss. */
if (ns(Vec3_z(vec)) != -3.2f) {
printf("Position failing on z coordinaten");
return -1;
}
/* Verify force_align relative to buffer start. */
offset = (char *)vec - (char *)buffer;
if (offset & 15) {
printf("Force align of Vec3 struct not correctn");
return -1;
}
/*
* If we retrieved the buffer using `flatcc_builder_finalize_aligned_buffer` or
* `flatcc_builder_get_direct_buffer` the struct should also
* be aligned without subtracting the buffer.
*/
if (vec & 15) {
printf("warning: buffer not aligned in memoryn");
}
/* ... */
return 0;
}
/* main() {...} */
위의 파일이 monster_example.c 라고 가정하면 다음은 읽기 전용 프로젝트를 컴파일하는 몇 가지 방법입니다.
cc -I include monster_example.c -o monster_example
cc -std=c11 -I include monster_example.c -o monster_example
cc -D FLATCC_PORTABLE -I include monster_example.c -o monster_example
포함 경로 또는 소스 경로는 다를 수 있습니다. include/flatcc/portable 의 일부 파일은 항상 사용되지만 -D FLATCC_PORTABLE 플래그에는 C11 기능이없는 컴파일러를 지원하는 추가 파일이 포함되어 있습니다.
참고 : 일부 Clang/GCC 플랫폼에서는 링커 posix_memalign 찾을 수없는 경우 -std = gnu99 또는 -std = gnu11을 사용해야 할 수도 있습니다.
여기서 우리는 버퍼를 만드는 방법에 대한 매우 제한된 예를 제공합니다. 몇 개의 필드 만 업데이트됩니다. Pleaser 자세한 내용은 monster_test.c와 doc 디렉토리를 참조하십시오.
먼저 파일을 생성해야합니다.
flatcc -a monster_test.fbs
이것은 생성됩니다 :
flatbuffers_common_reader.h
flatbuffers_common_builder.h
include_test1_reader.h
include_test1_builder.h
include_test1_verifier.h
include_test2_reader.h
include_test2_builder.h
include_test2_verifier.h
monster_test_reader.h
monster_test_builder.h
monster_test_verifier.h
참고 : 우리는 버퍼 만 읽으려고하지 않는 한 이전에 표시된 세대를 실제로 수행하지 않을 것입니다. 빌더 생성은 항상 읽기 Acces를 생성합니다.
"monster_test_builder.h" 포함시켜 다른 모든 파일이 자동으로 포함됩니다. C 컴파일러에는 프로젝트 루트가 현재 디렉토리라고 가정 할 때 flatcc/flatcc_builder.h , flatcc/flatcc_verifier.h 및 기타 파일에 액세스 할 수있는 지침 -I include .
검증자는 -A 옵션을 게으르게 선택했기 때문에 필요하지 않으며 방금 생성됩니다.
빌더는 먼저 버퍼를 효율적으로 구축하는 데 필요한 런타임 환경을 설정하려면 먼저 초기화되어야합니다. 빌더는 이미 터 객체에 따라 실제 버퍼를 구성합니다. 여기서 우리는 기본값을 암시 적으로 사용합니다. 일단 우리가 그 일단, 우리는 버퍼를 마무리 할 때까지 빌더를 핸들로 고려하고 플랫 버퍼 생성 된 API에 집중할 수 있습니다 (즉, 결과에 액세스). 사소한 용도로는 사용자 정의 에미 터를 제공하는 것이 좋습니다. 예를 들어 flatcc_builder_finalize_buffer 사용하여 모든 페이지를 단일 버퍼로 병합하지 않고 완료 flatcc_builder_get_direct_buffer 네트워크를 통해 페이지를 방출하는 것이 좋습니다. Flatcc_builder.h 및 flatcc_emitter.h의 문서 주석도 참조하십시오. See also flatc_builder_finalize_aligned_buffer in builder.h and the Builder Interface Reference when malloc aligned buffers are insufficent.
#include "monster_test_builder.h"
/* See [monster_test.c] for more advanced examples. */
void build_monster(flatcc_builder_t *B)
{
ns(Vec3_t *vec);
/* Here we use a table, but structs can also be roots. */
ns(Monster_start_as_root(B));
ns(Monster_hp_add(B, 80));
/* The vec struct is zero-initalized. */
vec = ns(Monster_pos_start(B));
/* Native endian. */
vec->x = 1, vec->y = 2, vec->z = -3.2f;
/* _end call converts to protocol endian format - for LE it is a nop. */
ns(Monster_pos_end(B));
/* Name is required, or we get an assertion in debug builds. */
ns(Monster_name_create_str(B, "MyMonster"));
ns(Monster_end_as_root(B));
}
#include "flatcc/support/hexdump.h"
int main(int argc, char *argv[])
{
flatcc_builder_t builder;
void *buffer;
size_t size;
flatcc_builder_init(&builder);
build_monster(&builder);
/* We could also use `flatcc_builder_finalize_buffer` and free the buffer later. */
buffer = flatcc_builder_get_direct_buffer(&builder, &size);
assert(buffer);
verify_monster(buffer);
/* Visualize what we got ... */
hexdump("monster example", buffer, size, stdout);
/*
* Here we can call `flatcc_builder_reset(&builder) if
* we wish to build more buffers before deallocating
* internal memory with `flatcc_builder_clear`.
*/
flatcc_builder_clear(&builder);
return 0;
}
Compile the example project:
cc -std=c11 -I include monster_example.c lib/libflatccrt.a -o monster_example
Note that the runtime library is required for building buffers, but not for reading them. If it is incovenient to distribute the runtime library for a given target, source files may be used instead. Each feature has its own source file, so not all runtime files are needed for building a buffer:
cc -std=c11 -I include monster_example.c
src/runtime/emitter.c src/runtime/builder.c
-o monster_example
Other features such as the verifier and the JSON printer and parser would each need a different file in src/runtime. Which file should be obvious from the filenames except that JSON parsing also requires the builder and emitter source files.
A buffer can be verified to ensure it does not contain any ranges that point outside the the given buffer size, that all data structures are aligned according to the flatbuffer principles, that strings are zero terminated, and that required fields are present.
In the builder example above, we can apply a verifier to the output:
#include "monster_test_builder.h"
#include "monster_test_verifier.h"
int ret;
...
... finalize
if ((ret = ns(Monster_verify_as_root_with_identifier(buffer, size,
"MONS")))) {
printf("Monster buffer is invalid: %sn",
flatcc_verify_error_string(ret));
}
The readfile.h utility may also be helpful in reading an existing buffer for verification.
Flatbuffers can optionally leave out the identifier, here "MONS". Use a null pointer as identifier argument to ignore any existing identifiers and allow for missing identifiers.
Nested flatbuffers are always verified with a null identifier, but it may be checked later when accessing the buffer.
The verifier does NOT verify that two datastructures are not overlapping. Sometimes this is indeed valid, such as a DAG (directed acyclic graph) where for example two string references refer to the same string in the buffer. In other cases an attacker may maliciously construct overlapping datastructures such that in-place updates may cause subsequent invalid buffers. Therefore an untrusted buffer should never be updated in-place without first rewriting it to a new buffer.
The CMake build system has build option to enable assertions in the verifier. This will break debug builds and not usually what is desired, but it can be very useful when debugging why a buffer is invalid. Traces can also be enabled so table offset and field id can be reported.
See also include/flatcc/flatcc_verifier.h .
When verifying buffers returned directly from the builder, it may be necessary to use the flatcc_builder_finalize_aligned_buffer to ensure proper alignment and use aligned_free to free the buffer (or as of v0.5.0 also flatcc_builder_aligned_free ), see also the Builder Interface Reference. Buffers may also be copied into aligned memory via mmap or using the portable layers paligned_alloc.h feature which is available when including generated headers. test/flatc_compat/flatc_compat.c is an example of how this can be done. For the majority of use cases, standard allocation would be sufficient, but for example standard 32-bit Windows only allocates on an 8-byte boundary and can break the monster schema because it has 16-byte aligned fields.
NOTE: as of August 2024 it has been discovered that C++ writer code has been aligning empty vectors to the size field only, even if elements require greater alignment like the double type which requires 8. This would cause the FlatCC verifier to (correctly) reject these vectors because it would result in an invalid C pointer type on some architectures. However, because this has been in effect for over 10 years, the consensus is to have verifiers tolerate this behaviour even if C++ will eventually fix this issue. The FlatCC verifier has been updated to accept such buffers by default with an optional compile time flag to enforce the strict behaviour as well ( FLATCC_ENFORCE_ALIGNED_EMPTY_VECTORS ). In principle the misaligned vectors can potentially lead to undefined behaviour in agressively optimized C compilers. As of now it appears to be safe to read such buffers on common platforms and it is preferable to avoid additional runtime reader overhead to deal with this. For more, see FlatCC #287, Google Flatbuffers #8374, FlatCC #289.
If unfortunate, it is possible to have a read accessor method conflict with other generated methods and typenames. Usually a small change in the schema will resolve this issue.
As of flatcc 0.5.2 read accors are generated with and without a _get suffix so it is also possible to use Monster_pos_get(monster) instead of Monster_pos(monster) . When calling flatcc with option -g the read accesors will only be generated with _get suffix. This avoids potential name conflicts. An example of a conflict is a field name like pos_add when there is also a pos field because the builder interface generates the add suffix. Using the -g option avoids this problem, but it is preferable to choose another name such as added_pos when the schema can be modified.
The -g option only changes the content of the flatbuffers_common_reader.h file, so it is technically possible to use different versions of this file if they are not mixed.
If an external code generator depends on flatcc output, it should use the _get suffix because it will work with and without the -g option, but only as of version 0.5.2 or later. For human readable code it is probaly simpler to stick to the orignal naming convention without the _get suffix.
Even with the above, it is still possible to have a conflict with the union type field. If a union field is named foo , an additional field is automatically - this field is named foo_type and holds, unsurprisingly, the type of the union.
Namespaces can also cause conflicts. If a schema has the namespace Foo.Bar and table named MyTable with a field name hello, then a read accessor will be named: Foo_Bar_MyTable_hello_get . It is also possible to have a table named Bar_MyTable because _ are allowed in FlatBuffers schema names, but in this case we have name conflict in the generated the C code. FlatCC does not attempt to avoid such conflicts so such schema are considered invalid.
Notably several users have experienced conflicts with a table or struct field named 'identifier' because <table-name>_identifier has been defined to be the file identifier to be used when creating a buffer with that table (or struct) as root. As of 0.6.1, the name is <table-name>_file_identifier to reduce the risk of conflicts. The old form is deprecated but still generated for tables without a field named 'identifier' for backwards compatibility. Mostly this macro is used for higher level functions such as mytable_create_as_root which need to know what identifier to use.
When reading a FlatBuffer does not provide the expected results, the first line of defense is to ensure that the code being tested is linked against flatccrt_d , the debug build of the runtime library. This will raise an assertion if calls to the builder are not properly balanced or if required fields are not being set.
To dig further into a buffer, call the buffer verifier and see if the buffer is actually valid with respect to the expected buffer type.
Strings and tables will be returned as null pointers when their corresponding field is not set in the buffer. User code should test for this but it might also be helpful to temporarily or permanently set the required attribute in the schema. The builder will then detect missing fields when cerating buffers and the verifier can will detect their absence in an existing buffer.
If the verifier rejects a buffer, the error can be printed (see Verifying a Buffer), but it will not say exactly where the problem was found. To go further, the verifier can be made to assert where the problem is encountered so the buffer content can be analyzed. This is enabled with:
-DFLATCC_DEBUG_VERIFY=1
Note that this will break test cases where a buffer is expected to fail verification.
To dump detailed contents of a valid buffer, or the valid contents up to the point of failure, use:
-DFLATCC_TRACE_VERIFY=1
Both of these options can be set as CMake options, or in the flatcc_rtconfig.h file.
When reporting bugs, output from the above might also prove helpful.
The JSON parser and printer can also be used to create and display buffers. The parser will use the builder API correctly or issue a syntax error or an error on required field missing. This can rule out some uncertainty about using the api correctly. The test_json.c file and test_json_parser.c have test functions that can be adapted for custom tests.
For advanced debugging the hexdump.h file can be used to dump the buffer contents. It is used in test_json.c and also in monster_test.c. See also FlatBuffers Binary Format.
As of April 2022, Googles flatc tool has implemented an --annotate feature. This provides an annotated hex dump given a binary buffer and a schema. The output can be used to troubleshoot and rule out or confirm suspected encoding bugs in the buffer at hand. The eclectic example in the FlatBuffers Binary Format document contains a hand written annotated example which inspired the --annotate feature, but it is not the exact same output format. Note also that flatc generated buffers tend to have vtables before the table it is referenced by, while flatcc normally packs all vtables at the end of the buffer for better padding and cache efficiency.
See also flatc --annotate.
Note: There is experimental support for text editor that supports clangd language server or similar. You can edit CMakeList.txt to generate build/Debug/compile_comands.json , at least when using clang as a compiler, and copy or symlink it from root. Or come with a better suggestion. There are .gitignore entries for compile_flags.txt and compile_commands.json in project root.
There are two ways to identify the content of a FlatBuffer. The first is to use file identifiers which are defined in the schema. The second is to use type identifiers which are calculated hashes based on each tables name prefixed with its namespace, if any. In either case the identifier is stored at offset 4 in binary FlatBuffers, when present. Type identifiers are not to be confused with union types.
The FlatBuffers schema language has the optional file_identifier declaration which accepts a 4 characer ASCII string. It is intended to be human readable. When absent, the buffer potentially becomes 4 bytes shorter (depending on padding).
The file_identifier is intended to match the root_type schema declaration, but this does not take into account that it is convenient to create FlatBuffers for other types as well. flatcc makes no special destinction for the root_type while Googles flatc JSON parser uses it to determine the JSON root object type.
As a consequence, the file identifier is ambigous. Included schema may have separate file_identifier declarations. To at least make sure each type is associated with its own schemas file_identifier , a symbol is defined for each type. If the schema has such identifier, it will be defined as the null identifier.
The generated code defines the identifiers for a given table:
#ifndef MyGame_Example_Monster_file_identifier
#define MyGame_Example_Monster_file_identifier "MONS"
#endif
The user can now override the identifier for a given type, for example:
#define MyGame_Example_Vec3_file_identifier "VEC3"
#include "monster_test_builder.h"
...
MyGame_Example_Vec3_create_as_root(B, ...);
The create_as_root method uses the identifier for the type in question, and so does other _as_root methods.
The file_extension is handled in a similar manner:
#ifndef MyGame_Example_Monster_file_extension
#define MyGame_Example_Monster_file_extension "mon"
#endif
To better deal with the ambigouties of file identifiers, type identifiers have been introduced as an alternative 4 byte buffer identifier. The hash is standardized on FNV-1a for interoperability.
The type identifier use a type hash which maps a fully qualified type name into a 4 byte hash. The type hash is a 32-bit native value and the type identifier is a 4 character little endian encoded string of the same value.
In this example the type hash is derived from the string "MyGame.Example.Monster" and is the same for all FlatBuffer code generators that supports type hashes.
The value 0 is used to indicate that one does not care about the identifier in the buffer.
...
MyGame_Example_Monster_create_as_typed_root(B, ...);
buffer = flatcc_builder_get_direct_buffer(B);
MyGame_Example_Monster_verify_as_typed_root(buffer, size);
// read back
monster = MyGame_Example_Monster_as_typed_root(buffer);
switch (flatbuffers_get_type_hash(buffer)) {
case MyGame_Example_Monster_type_hash:
...
}
...
if (flatbuffers_get_type_hash(buffer) ==
flatbuffers_type_hash_from_name("Some.Old.Buffer")) {
printf("Buffer is the old version, not supported.n");
}
More API calls are available to naturally extend the existing API. See monster_test.c for more.
The type identifiers are defined like:
#define MyGame_Example_Monster_type_hash ((flatbuffers_thash_t)0x330ef481)
#define MyGame_Example_Monster_type_identifier "x81xf4x0ex33"
The type_identifier can be used anywhere the original 4 character file identifier would be used, but a buffer must choose which system, if any, to use. This will not affect the file_extension .
NOTE: The generated _type_identifier strings should not normally be used when an identifier string is expected in the generated API because it may contain null bytes which will be zero padded after the first null before comparison. Use the API calls that take a type hash instead. The type_identifier can be used in low level flatcc_builder.h calls because it handles identifiers as a fixed byte array and handles type hashes and strings the same.
NOTE: it is possible to compile the flatcc runtime to encode buffers in big endian format rather than the standard little endian format regardless of the host platforms endianness. If this is done, the identifier field in the buffer is always byte swapped regardless of the identifier method chosen. The API calls make this transparent, so "MONS" will be stored as "SNOM" but should still be verified as "MONS" in API calls. This safeguards against mixing little- and big-endian buffers. Likewise, type hashes are always tested in native (host) endian format.
The flatcc/flatcc_identifier.h file contains an implementation of the FNV-1a hash used. The hash was chosen for simplicity, availability, and collision resistance. For better distribution, and for internal use only, a dispersion function is also provided, mostly to discourage use of alternative hashes in transmission since the type hash is normally good enough as is.
Note: there is a potential for collisions in the type hash values because the hash is only 4 bytes.
JSON support files are generated with flatcc --json .
This section is not a tutorial on JSON printing and parsing, it merely covers some non-obvious aspects. The best source to get started quickly is the test file:
test/json_test/json_test.c
For detailed usage, please refer to:
test/json_test/test_json_printer.c
test/json_test/test_json_parser.c
test/json_test/json_test.c
test/benchmark/benchflatccjson
See also JSON parsing section in the Googles FlatBuffers schema documentation.
By using the flatbuffer schema it is possible to generate schema specific JSON printers and parsers. This differs for better and worse from Googles flatc tool which takes a binary schema as input and processes JSON input and output. Here that parser and printer only rely on the flatcc runtime library, is faster (probably significantly so), but requires recompilition when new JSON formats are to be supported - this is not as bad as it sounds - it would for example not be difficult to create a Docker container to process a specific schema in a web server context.
The parser always takes a text buffer as input and produces output according to how the builder object is initialized. The printer has different init functions: one for printing to a file pointer, including stdout, one for printing to a fixed length external buffer, and one for printing to a dynamically growing buffer. The dynamic buffer may be reused between prints via the reset function. See flatcc_json_parser.h for details.
The parser will accept unquoted names (not strings) and trailing commas, ie non-strict JSON and also allows for hex x03 in strings. Strict mode must be enabled by a compile time flag. In addition the parser schema specific symbolic enum values that can optionally be unquoted where a numeric value is expected:
color: Green
color: Color.Green
color: MyGame.Example.Color.Green
color: 2
The symbolic values do not have to be quoted (unless required by runtime or compile time configuration), but can be while numeric values cannot be quoted. If no namespace is provided, like color: Green , the symbol must match the receiving enum type. Any scalar value may receive a symbolic value either in a relative namespace like hp: Color.Green , or an absolute namespace like hp: MyGame.Example.Color.Green , but not hp: Green (since hp in the monster example schema) is not an enum type with a Green value). A namespace is relative to the namespace of the receiving object.
It is also possible to have multiple values, but these always have to be quoted in order to be compatible with Googles flatc tool for Flatbuffers 1.1:
color: "Green Red"
Unquoted multi-valued enums can be enabled at compile time but this is deprecated because it is incompatible with both Googles flatc JSON and also with other possible future extensions: color: Green Red
These value-valued expressions were originally intended for enums that have the bit flag attribute defined (which Color does have), but this is tricky to process, so therefore any symblic value can be listed in a sequence with or without namespace as appropriate. Because this further causes problems with signed symbols the exact definition is that all symbols are first coerced to the target type (or fail), then added to the target type if not the first this results in:
color: "Green Blue Red Blue"
color: 19
Because Green is 2, Red is 1, Blue is 8 and repeated.
NOTE : Duplicate values should be considered implemention dependent as it cannot be guaranteed that all flatbuffer JSON parsers will handle this the same. It may also be that this implementation will change in the future, for example to use bitwise or when all members and target are of bit flag type.
It is not valid to specify an empty set like:
color: ""
because it might be understood as 0 or the default value, and it does not unquote very well.
The printer will by default print valid json without any spaces and everything quoted. Use the non-strict formatting option (see headers and test examples) to produce pretty printing. It is possibly to disable symbolic enum values using the noenum option.
Only enums will print symbolic values are there is no history of any parsed symbolic values at all. Furthermore, symbolic values are only printed if the stored value maps cleanly to one value, or in the case of bit-flags, cleanly to multiple values. For exmaple if parsing color: Green Red it will print as "color":"Red Green" by default, while color: Green Blue Red Blue will print as color:19 .
Both printer and parser are limited to roughly 100 table nesting levels and an additional 100 nested struct depths. This can be changed by configuration flags but must fit in the runtime stack since the operation is recursive descent. Exceedning the limits will result in an error.
Numeric values are coerced to the receiving type. Integer types will fail if the assignment does not fit the target while floating point values may loose precision silently. Integer types never accepts floating point values. Strings only accept strings.
Nested flatbuffers may either by arrays of byte sized integers, or a table or a struct of the target type. See test cases for details.
The parser will by default fail on unknown fields, but these can also be skipped silently with a runtime option.
Unions are difficult to parse. A union is two json fields: a table as usual, and an enum to indicate the type which has the same name with a _type suffix and accepts a numeric or symbolic type code:
{
name: "Container Monster",
test_type: Monster,
test: { name: "Contained Monster" }
}
based on the schema is defined in monster_test.fbs.
Because other json processors may sort fields, it is possible to receive the type field after the test field. The parser does not store temporary datastructures. It constructs a flatbuffer directly. This is not possible when the type is late. This is handled by parsing the field as a skipped field on a first pass, followed by a typed back-tracking second pass once the type is known (only the table is parsed twice, but for nested unions this can still expand). Needless to say this slows down parsing. It is an error to provide only the table field or the type field alone, except if the type is NONE or 0 in which case the table is not allowed to be present.
Union vectors are supported as of v0.5.0. A union vector is represented as two vectors, one with a vector of tables and one with a vector of types, similar to ordinary unions. It is more efficient to place the type vector first because it avoids backtracking. Because a union of type NONE cannot be represented by absence of table field when dealing with vectors of unions, a table must have the value null if its type is NONE in the corresponding type vector. In other cases a table should be absent, and not null.
Here is an example of JSON containing Monster root table with a union vector field named manyany which is a vector of Any unions in the monster_test.fbs schema:
{
"name": "Monster",
"manyany_type": [ "Monster", "NONE" ],
"manyany": [{"name": "Joe"}, null]
}
As of v0.5.0 it is possible to encode and decode a vector of type [uint8] (aka [ubyte] ) as a base64 encoded string or a base64url encoded string as documented in RFC 4648. Any other type, notably the string type, do not handle base64 encoding.
Limiting the support to [uint8] avoids introducing binary data into strings and also avoids dealing with sign and endian encoding of binary data of other types. Furthermore, array encoding of values larger than 8 bits are not necessarily less efficient than base64.
Base64 padding is always printed and is optional when parsed. Spaces, linebreaks, JSON string escape character '', or any other character not in the base64(url) alphabet are rejected as a parse error.
The schema must add the attribute (base64) or (base64url) to the field holding the vector, for example:
table Monster {
name: string;
sprite: [uint8] (base64);
token: [uint8] (base64url);
}
If more complex data needs to be encoded as base64 such as vectors of structs, this can be done via nested FlatBuffers which are also of type [uint8] .
Note that for some use cases it might be desireable to read binary data as base64 into memory aligned to more than 8 bits. This is not currently possible, but it is recognized that a (force_align: n) attribute on [ubyte] vectors could be useful, but it can also be handled via nested flatbuffers which also align data.
Fixed length arrays introduced in 0.6.0 allow for structs containing arrays of fixed length scalars, structs and chars. Arrays are parsed like vectors for of similar type but are zero padded if shorter than expected and fails if longer than expected. The flag reject_array_underflow will error if an array is shorter than expected instead of zero padding. The flag skip_array_overflow will allow overlong arrays and simply drop extra elements.
Char arrays are parsed like strings and zero padded if short than expected, but they are not zero terminated. A string like "hello" will exactly fit into a field of type [char:5] . Trailing zero characters are not printed, but embedded zero characters are. This allows for loss-less roundtrips without having to zero pad strings. Note that other arrays are always printed in full. If the flag skip_array_overflow is set, a string might be truncated in the middle of a multi-byte character. This is not checked nor enforced by the verifier.
Both the printer and the parser have the ability to accept runtime flags that modifies their behavior. Please refer to header file comments for documentation and test cases for examples. Notably it is possible to print unquoted symbols and to ignore unknown fields when parsing instead of generating an error.
Note that deprecated fields are considered unknown fields during parsing so in order to process JSON from an old schema version with deprecated fields present, unknown symbols must be skipped.
As of v0.5.1 test_json.c demonstrates how a single parser driver can be used to parse different table types without changes to the driver or to the schema.
For example, the following layout can be used to configure a generic parser or printer.
struct json_scope {
const char *identifier;
flatcc_json_parser_table_f *parser;
flatcc_json_printer_table_f *printer;
flatcc_table_verifier_f *verifier;
};
static const struct json_scope Monster = {
/* The is the schema global file identifier. */
ns(Monster_identifier),
ns(Monster_parse_json_table),
ns(Monster_print_json_table),
ns(Monster_verify_table)
};
The Monster scope can now be used by a driver or replaced with a new scope as needed:
/* Abbreviated ... */
struct json_scope = Monster;
flatcc_json_parser_table_as_root(B, &parser_ctx, json, strlen(json), parse_flags,
scope->identifier, scope->parser);
/* Printing and verifying works roughly the same. */
The generated table MyGame_Example_Monster_parse_json_as_root is a thin convenience wrapper roughly implementing the above.
The generated monster_test_parse_json is a higher level convenience wrapper named of the schema file itself, not any specific table. It parses the root_type configured in the schema. This is how the test_json.c test driver operated prior to v0.5.1 but it made it hard to test parsing and printing distinct table types.
Note that verification is not really needed for JSON parsing because a generated JSON parser is supposed to build buffers that always verify (except for binary encoded nested buffers), but it is useful for testing.
Note that json parsing and printing is very fast reaching 500MB/s for printing and about 300 MB/s for parsing. Floating point parsing can signficantly skew these numbers. The integer and floating point parsing and printing are handled via support functions in the portable library. In addition the floating point include/flatcc/portable/grisu3_* library is used unless explicitly disable by a compile time flag. Disabling grisu3 will revert to sprintf and strtod . Grisu3 will fall back to strtod and grisu3 in some rare special cases. Due to the reliance on strtod and because strtod cannot efficiently handle non-zero-terminated buffers, it is recommended to zero terminate buffers. Alternatively, grisu3 can be compiled with a flag that allows errors in conversion. These errors are very small and still correct, but may break some checksums. Allowing for these errors can significantly improve parsing speed and moves the benchmark from below half a million parses to above half a million parses per second on 700 byte json string, on a 2.2 GHz core-i7.
While unquoted strings may sound more efficient due to the compact size, it is actually slower to process. Furthermore, large flatbuffer generated JSON files may compress by a factor 8 using gzip or a factor 4 using LZ4 so this is probably the better place to optimize. For small buffers it may be more efficient to compress flatbuffer binaries, but for large files, json may actually compress significantly better due to the absence of pointers in the format.
SSE 4.2 has been experimentally added, but it the gains are limited because it works best when parsing space, and the space parsing is already fast without SSE 4.2 and because one might just leave out the spaces if in a hurry. For parsing strings, trivial use of SSE 4.2 string scanning doesn't work well becasuse all the escape codes below ASCII 32 must be detected rather than just searching for and " . That is not to say there are not gains, they just don't seem worthwhile.
The parser is heavily optimized for 64-bit because it implements an 8-byte wide trie directly in code. It might work well for 32-bit compilers too, but this hasn't been tested. The large trie does put some strain on compile time. Optimizing beyond -O2 leads to too large binaries which offsets any speed gains.
Attributes included in the schema are viewed in a global namespace and each include file adds to this namespace so a schema file can use included attributes without namespace prefixes.
Each included schema will also add types to a global scope until it sees a namespace declaration. An included schema does not inherit the namespace of an including file or an earlier included file, so all schema files starts in the global scope. An included file can, however, see other types previously defined in the global scope. Because include statements always appear first in a schema, this can only be earlier included files, not types from a containing schema.
The generated output for any included schema is indendent of how it was included, but it might not compile without the earlier included files being present and included first. By including the toplevel myschema.h or myschema_builder.h all these dependencies are handled correctly.
Note: libflatcc.a can only parse a single schema when the schema is given as a memory buffer, but can handle the above when given a filename. It is possible to concatenate schema files, but a namespace; declaration must be inserted as a separator to revert to global namespace at the start of each included file. This can lead to subtle errors because if one parent schema includes two child schema a.fbs and b.fbs , then b.fbs should not be able to see anything in a.fbs even if they share namespaces. This would rarely be a problem in praxis, but it means that schema compilation from memory buffers cannot authoratively validate a schema. The reason the schema must be isolated is that otherwise code generation for a given schema could change with how it is being used leading to very strange errors in user code.
If a field is required such as Monster.name, the table end call will assert in debug mode and create incorrect tables in non-debug builds. The assertion may not be easy to decipher as it happens in library code and it will not tell which field is missing.
When reading the name, debug mode will again assert and non-debug builds will return a default value.
Writing the same field twice will also trigger an assertion in debug builds.
Buffers can be used for high speed communication by using the ability to create buffers with structs as root. In addition the default emitter supports flatcc_emitter_direct_buffer for small buffers so no extra copy step is required to get a linear buffer in memory. Preliminary measurements suggests there is a limit to how fast this can go (about 6-7 mill. buffers/sec) because the builder object must be reset between buffers which involves zeroing allocated buffers. Small tables with a simple vector achieve roughly half that speed. For really high speed a dedicated builder for structs would be needed. See also monster_test.c.
All types stored in a buffer has a type suffix such as Monster_table_t or Vec3_struct_t (and namespace prefix which we leave out here). These types are read-only pointers into endian encoded data. Enum types are just constants easily grasped from the generated code. Tables are dense so they are never accessed directly.
Enums support schema evolution meaning that more names can be added to the enumeration in a future schema version. As of v0.5.0 the function _is_known_value can be used ot check if an enum value is known to the current schema version.
Structs have a dual purpose because they are also valid types in native format, yet the native reprsention has a slightly different purpose. Thus the convention is that a const pointer to a struct encoded in a flatbuffer has the type Vec3_struct_t where as a writeable pointer to a native struct has the type Vec3_t * or struct Vec3 * .
All types have a _vec_t suffix which is a const pointer to the underlying type. For example Monster_table_t has the vector type Monster_vec_t . There is also a non-const variant with suffix _mutable_vec_t which is rarely used. However, it is possible to sort vectors in-place in a buffer, and for this to work, the vector must be cast to mutable first. A vector (or string) type points to the element with index 0 in the buffer, just after the length field, and it may be cast to a native type for direct access with attention to endian encoding. (Note that table_t types do point to the header field unlike vectors.) These types are all for the reader interface. Corresponding types with a _ref_t suffix such as _vec_ref_t are used during the construction of buffers.
Native scalar types are mapped from the FlatBuffers schema type names such as ubyte to uint8_t and so forth. These types also have vector types provided in the common namespace (default flatbuffers_ ) so a [ubyte] vector has type flatbuffers_uint8_vec_t which is defined as const uint8_t * .
The FlatBuffers boolean type is strictly 8 bits wide so we cannot use or emulate <stdbool.h> where sizeof(bool) is implementation dependent. Therefore flatbuffers_bool_t is defined as uint8_t and used to represent FlatBuffers boolean values and the constants of same type: flatbuffers_true = 1 and flatbuffers_false = 0 . Even so, pstdbool.h is available in the include/flatcc/portable directory if bool , true , and false are desired in user code and <stdbool.h> is unavailable.
flatbuffers_string_t is const char * but imply the returned pointer has a length prefix just before the pointer. flatbuffers_string_vec_t is a vector of strings. The flatbufers_string_t type guarantees that a length field is present using flatbuffers_string_len(s) and that the string is zero terminated. It also suggests that it is in utf-8 format according to the FlatBuffers specification, but not checks are done and the flatbuffers_create_string(B, s, n) call explicitly allows for storing embedded null characters and other binary data.
All vector types have operations defined as the typename with _vec_t replaced by _vec_at and _vec_len . For example flatbuffers_uint8_vec_at(inv, 1) or Monster_vec_len(inv) . The length or _vec_len will be 0 if the vector is missing whereas _vec_at will assert in debug or behave undefined in release builds following out of bounds access. This also applies to related string operations.
The FlatBuffers schema uses the following scalar types: ubyte , byte , ushort , short, uint , int , ulong , and long to represent unsigned and signed integer types of length 8, 16, 32, and 64 respectively. The schema syntax has been updated to also support the type aliases uint8 , int8 , uint16 , int16 , uint32 , int32 , uint64 , int64 to represent the same basic types. Likewise, the schema uses the types float and double to represent IEEE-754 binary32 and binary64 floating point formats where the updated syntax also supports the type aliases float32 and float64 .
The C interface uses the standard C types such as uint8 and double to represent scalar types and this is unaffected by the schema type name used, so the schema vector type [float64] is represented as flatbuffers_double_vec_t the same as [double] would be.
Note that the C standard does not guarantee that the C types float and double are represented by the IEEE-754 binary32 single precision format and the binary64 double precision format respectively, although they usually are. If this is not the case FlatCC cannot work correctly with FlatBuffers floating point values. (If someone really has this problem, it would be possible to fix).
Unions are represented with a two table fields, one with a table field and one with a type field. See separate section on Unions. As of flatcc v0.5.0 union vectors are also supported.
A union represents one of several possible tables. A table with a union field such as Monster.equipped in the samples schema will have two accessors: MyGame_Sample_Monster_equipped(t) of type flatbuffers_generic_t and MyGame_Sample_Monster_equipped_type(t) of type MyGame_Sample_Equipment_union_type_t . A generic type is is just a const void pointer that can be assigned to the expected table type, struct type, or string type. The enumeration has a type code for member of the union and also MyGame_Sample_Equipment_NONE which has the value 0.
The union interface were changed in 0.5.0 and 0.5.1 to use a consistent { type, value } naming convention for both unions and union vectors in all interfaces and to support unions and union vectors of multiple types.
A union can be accessed by its field name, like Monster MyGame_Sample_Monster_equipped(t) and its type is given by MyGame_Sample_Monster_type(t) , or a flatbuffers_union_t struct can be returned with MyGame_Sample_monster_union(t) with the fields { type, value }. A union vector is accessed in the same way but { type, value } represents a type vector and a vector of the given type, eg a vector Monster tables or a vector of strings.
There is a test in monster_test.c covering union vectors and a separate test focusing on mixed type unions that also has union vectors.
Googles monster_test.fbs schema has the union (details left out):
namespace MyGame.Example2;
table Monster{}
namespace MyGame.Example;
table Monster{}
union Any { Monster, MyGame.Example2.Monster }
where the two Monster tables are defined in separate namespaces.
flatcc rejects this schema due to a name conflict because it uses the basename of a union type, here Monster to generate the union member names which are also used in JSON parsing. This can be resolved by adding an explicit name such as Monster2 to resolve the conflict:
union Any { Monster, Monster2: MyGame.Example2.Monster }
This syntax is accepted by both flatc and flatcc .
Both versions will implement the same union with the same type codes in the binary format but generated code will differ in how the types are referred to.
In JSON the monster type values are now identified by MyGame.Example.Any.Monster , or just Monster , when assigning the first monster type to an Any union field, and MyGame.Example.Any.Monster2 , or just Monster2 when assigning the second monster type. C uses the usual enum namespace prefixed symbols like MyGame_Example_Any_Monster2 .
Fixed Length Arrays is a late feature to the FlatBuffers format introduced in flatc and flatcc mid 2019. Currently only scalars arrays are supported, and only as struct fields. To use fixed length arrays as a table field wrap it in a struct first. It would make sense to support struct elements and enum elements, but that has not been implemented. Char arrays are more controversial due to verification and zero termination and are also not supported. Arrays are aligned to the size of the first field and are equivalent to repeating elements within the struct.
The schema syntax is:
struct MyStruct {
my_array : [float:10];
}
See test_fixed_array in monster_test.c for an example of how to work with these arrays.
Flatcc opts to allow arbitrary length fixed length arrays but limit the entire struct to 2^16-1 bytes. Tables cannot hold larger structs, and the C language does not guarantee support for larger structs. Other implementations might have different limits on maximum array size. Arrays of 0 length are not permitted.
Optional scalar table fields were introduced to FlatBuffers mid 2020 in order to better handle null values also for scalar data types, as is common in SQL databases. Before describing optional values, first understand how ordinary scalar values work in FlatBuffers:
Imagine a FlatBuffer table with a mana field from the monster sample schema. Ordinarily a scalar table field has implicit default value of 0 like mana : uint8; , or an explicit default value specified in the schema like mana : uint8 = 100; . When a value is absent from a table field, the default value is returned, and when a value is added during buffer construction, it will not actually be stored if the value matches the default value, unless the force_add option is used to write a value even if it matches the default value. Likewise the is_present method can be used to test if a field was actually stored in the buffer when reading it.
When a table has many fields, most of which just hold default settings, signficant space can be saved using default values, but it also means that an absent value does not indicate null. Field absence is essentially just a data compression technique, not a semantic change to the data. However, it is possible to use force_add and is_present to interpret values as null when not present, except that this is not a standardized technique. Optional fields represents a standardized way to achieve this.
Scalar fields can be marked as optional by assigning null as a default value. For example, some objects might not have a meaningful mana value, so it could be represented as lifeforce : uint8 = null . Now the lifeforce field has become an optional field. In the FlatCC implementation this means that the field is written, it will always be written also if the value is 0 or any other representable value. It also means that the force_add method is not available for the field because force_add is essentially always in effect for the field. On the read side, optional scalar fields behave exactly is ordinary scalar fields that have not specified a default value, that is, if the field is absent, 0 will be returned and is_present will return false. Instead optional scalar fields get a new accessor method with the suffix _option() which returns a struct with two fiels: { is_null, value } where _option().is_null == !is_present() and _option().value is the same value is the _get() method, which will be 0 if is_null is true. The option struct is named after the type similar to unions, for example flatbuffers_uint8_option_t or MyGame_Example_Color_option_t , and the option accessor method also works similar to unions. Note that _get() will also return 0 for optional enum values that are null (ie absent), even if the enum value does not have an enumerated element with the value 0. Normally enums without a 0 element is not allowed in the schema unless a default value is specified, but in this case it is null, and _get() needs some value to return in this case.
By keeping the original accessors, read logic can be made simpler and faster when it is not important whether a value is null or 0 and at the same time the option value can be returned and stored.
Note that struct fields cannot be optional. Also note that, non-scalar table fields are not declared optional because these types can already represent null via a null pointer or a NONE union type.
JSON parsing and printing change behavior for scalar fields by treating absent fields differently according the optional semantics. For example parsing a missing field will not store a default value even if the parser is executed with a flag to force default values to be stored and the printer will not print absent optional fields even if otherwise flagged to print default values. Currenlty the JSON printers and parsers do not print or parse JSON null and can only represent null be absence of a field.
For an example of reading and writing, as well as printing and parsing JSON, optional scalar fields, please refer to optional_scalars_test.fbs and optional_scalars_test.c.
The pendian_detect.h` file detects endianness for popular compilers and provides a runtime fallback detection for others. In most cases even the runtime detection will be optimized out at compile time in release builds.
The FLATBUFFERS_LITTLEENDIAN flag is respected for compatibility with Googles flatc compiler, but it is recommended to avoid its use and work with the mostly standard flags defined and/or used in pendian_detect.h , or to provide for additional compiler support.
As of flatcc 0.4.0 there is support for flatbuffers running natively on big endian hosts. This has been tested on IBM AIX. However, always run tests against the system of interest - the release process does not cover automated tests on any BE platform.
As of flatcc 0.4.0 there is also support for compiling the flatbuffers runtime library with flatbuffers encoded in big endian format regardless of the host platforms endianness. Longer term this should probably be placed in a separate library with separate name prefixes or suffixes, but it is usable as is. Redefine FLATBUFFERS_PROTOCOL_IS_LE/BE accordingly in flatcc_types.h. This is already done in the be branch. This branch is not maintained but the master branch can be merged into it as needed.
Note that standard flatbuffers are always encoded in little endian but in situations where all buffer producers and consumers are big endian, the non standard big endian encoding may be faster, depending on intrinsic byteswap support. As a curiosity, the load_test actually runs faster with big endian buffers on a little endian MacOS platform for reasons only the optimizer will know, but read performance of small buffers drop to 40% while writing buffers generally drops to 80-90% performance. For platforms without compiler intrinsics for byteswapping, this can be much worse.
Flatbuffers encoded in big endian will have the optional file identifier byteswapped. The interface should make this transparent, but details are still being worked out. For example, a buffer should always verify the monster buffer has the identifier "MONS", but internally the buffer will store the identifier as "SNOM" on big endian encoded buffers.
Because buffers can be encode in two ways, flatcc uses the term native endianness and protocol endianess. _pe is a suffix used in various low level API calls to convert between native and protocol endianness without caring about whether host or buffer is little or big endian.
If it is necessary to write application code that behaves differently if the native encoding differs from protocol encoding, use flatbuffers_is_pe_native() . This is a function, not a define, but for all practical purposes it will have same efficience while also supporting runtime endian detection where necessary.
The flatbuffer environment only supports reading either big or little endian for the time being. To test which is supported, use the define FLATBUFFERS_PROTOCOL_IS_LE or FLATBUFFERS_PROTOCOL_IS_BE . They are defines as 1 and 0 respectively.
The builder API often returns a reference or a pointer where null is considered an error or at least a missing object default. However, some operations do not have a meaningful object or value to return. These follow the convention of 0 for success and non-zero for failure. Also, if anything fails, it is not safe to proceed with building a buffer. However, to avoid overheads, there is no hand holding here. On the upside, failures only happen with incorrect use or allocation failure and since the allocator can be customized, it is possible to provide a central error state there or to guarantee no failure will happen depending on use case, assuming the API is otherwise used correctly. By not checking error codes, this logic also optimizes out for better performance.
The builder API does not support sorting due to the complexity of customizable emitters, but the reader API does support sorting so a buffer can be sorted at a later stage. This requires casting a vector to mutable and calling the sort method available for fields with keys.
The sort uses heap sort and can sort a vector in-place without using external memory or recursion. Due to the lack of external memory, the sort is not stable. The corresponding find operation returns the lowest index of any matching key, or flatbuffers_not_found .
When configured in config.h (the default), the flatcc compiler allows multiple keyed fields unlike Googles flatc compiler. This works transparently by providing <table_name>_vec_sort_by_<field_name> and <table_name>_vec_find_by_<field_name> methods for all keyed fields. The first field maps to <table_name>_vec_sort and <table_name>_vec_find . Obviously the chosen find method must match the chosen sort method. The find operation is O(logN).
As of v0.6.0 the default key used for find and and sort without the by_name suffix is the field with the smaller id instead of the first listed in the schema which is often but not always the same thing.
v0.6.0 also introduces the primary_key attribute that can be used instead of the key attribute on at most one field. The two attributes are mutually exclusive. This can be used if a key field with a higher id should be the default key. There is no difference when only one field has a key or primary_key attribute, so in that case choose key for compatiblity. Googles flatc compiler does not recognize the primary_key attribute.
As of v0.6.0 a 'sorted' attribute has been introduced together with the sort operations <table_name>_sort and <union_name>_sort . If a table or a union, directly or indirectly, contains a vector with the 'sorted' attribute, then the sort operation is made available. The sort will recursively visit all children with vectors marked sorted. The sort operatoin will use the default (primary) key. A table or union must first be cast to mutable, for example ns(Monster_sort((ns(Monster_mutable_table_t))monster) . The actual vector sort operations are the same as before, they are just called automatically. The sorted attribute can only be set on vectors that are not unions. The vector can be of scalar, string, struct, or table type. sorted is only valid for a struct or table vector if the struct or table has a field with a key or primary_key attribute. NOTE: A FlatBuffer can reference the same object multiple times. The sort operation will be repeated if this is the case. Sometimes that is OK, but if it is a concern, remove the sorted attribute and sort the vector manually. Note that sharing can also happen via a shared containing object. The sort operations are generated in _reader.h files and only for objects directly or indirectly affected by the sorted attribute. Unions have a new mutable case operator for use with sorting unions: ns(Any_sort(ns(Any_mutable_cast)(my_any_union)) . Usually unions will be sorted via a containing table which performs this cast automatically. See also test_recursive_sort in monster_test.c.
As of v0.4.1 <table_name>_vec_scan_by_<field_name> and the default <table_name>_vec_scan are also provided, similar to find , but as a linear search that does not require the vector to be sorted. This is especially useful for searching by a secondary key (multiple keys is a non-standard flatcc feature). _scan_ex searches a sub-range [a, b) where b is an exclusive index. b = flatbuffers_end == flatbuffers_not_found == (size_t)-1 may be used when searching from a position to the end, and b can also conveniently be the result of a previous search.
rscan searches in the opposite direction starting from the last element. rscan_ex accepts the same range arguments as scan_ex . If a >= b or a >= len the range is considered empty and flatbuffers_not_found is returned. [r]scan[_ex]_n[_by_name] is for length terminated string keys. See monster_test.c for examples.
Note that find requires key attribute in the schema. scan is also available on keyed fields. By default flatcc will also enable scan by any other field but this can be disabled by a compile time flag.
Basic types such as uint8_vec also have search operations.
See also Builder Interface Reference and monster_test.c.
The FlatBuffers format does not fully distinguish between default values and missing or null values but it is possible to force values to be written to the buffer. This is discussed further in the Builder Interface Reference. For SQL data roundtrips this may be more important that having compact data.
The _is_present suffix on table access methods can be used to detect if value is present in a vtable, for example Monster_hp_present . Unions return true of the type field is present, even if it holds the value None.
The add methods have corresponding force_add methods for scalar and enum values to force storing the value even if it is default and thus making it detectable by is_present .
The portable library is placed under include/flatcc/portable and is required by flatcc, but isn't strictly part of the flatcc project. It is intended as an independent light-weight header-only library to deal with compiler and platform variations. It is placed under the flatcc include path to simplify flatcc runtime distribution and to avoid name and versioning conflicts if used by other projects.
The license of portable is different from flatcc . It is mostly MIT or Apache depending on the original source of the various parts.
A larger set of portable files is included if FLATCC_PORTABLE is defined by the user when building.
cc -D FLATCC_PORTABLE -I include monster_test.c -o monster_test
Otherwise a targeted subset is included by flatcc_flatbuffers.h in order to deal with non-standard behavior of some C11 compilers.
pwarnings.h is also always included so compiler specific warnings can be disabled where necessary.
The portable library includes the essential parts of the grisu3 library found in external/grisu3 , but excludes the test cases. The JSON printer and parser relies on fast portable numeric print and parse operations based mostly on grisu3.
If a specific platform has been tested, it would be good with feedback and possibly patches to the portability layer so these can be made available to other users.
Note: if a test fails, see Strict Aliasing for a possible resolution.
To initialize and run the build (see required build tools below):
scripts/build.sh
The bin and lib folders will be created with debug and release build products.
The build depends on CMake . By default the Ninja build tool is also required, but alternatively make can be used.
Optionally switch to a different build tool by choosing one of:
scripts/initbuild.sh make
scripts/initbuild.sh make-concurrent
scripts/initbuild.sh ninja
where ninja is the default and make-concurrent is make with the -j flag.
To enforce a 32-bit build on a 64-bit machine the following configuration can be used:
scripts/initbuild.sh make-32bit
which uses make and provides the -m32 flag to the compiler. A custom build configuration X can be added by adding a scripts/build.cfg.X file.
scripts/initbuild.sh cleans the build if a specific build configuration is given as argument. Without arguments it only ensures that CMake is initialized and is therefore fast to run on subsequent calls. This is used by all test scripts.
To install build tools on OS-X, and build:
brew update
brew install cmake ninja
git clone https://github.com/dvidelabs/flatcc.git
cd flatcc
scripts/build.sh
To install build tools on Ubuntu, and build:
sudo apt-get update
sudo apt-get install cmake ninja-build
git clone https://github.com/dvidelabs/flatcc.git
cd flatcc
scripts/build.sh
To install build tools on Centos, and build:
sudo yum group install "Development Tools"
sudo yum install cmake
git clone https://github.com/dvidelabs/flatcc.git
cd flatcc
scripts/initbuild.sh make # there is no ninja build tool
scripts/build.sh
OS-X also has a HomeBrew package:
brew update
brew install flatcc
or for the bleeding edge:
brew update
brew install flatcc --HEAD
Install CMake, MSVC, and git (tested with MSVC 14 2015).
In PowerShell:
git clone https://github.com/dvidelabs/flatcc.git
cd flatcc
mkdir buildMSVC
cd buildMSVC
cmake -G "Visual Studio 14 2015" ....
Optionally also build from the command line (in buildMSVC):
cmake --build . --target --config Debug
cmake --build . --target --config Release
In Visual Studio:
open flatccbuildMSVCFlatCC.sln
build solution
choose Release build configuration menu
rebuild solution
Note that flatccCMakeList.txt sets the -DFLATCC_PORTABLE flag and that includeflatccportablepwarnings.h disable certain warnings for warning level -W3.
Docker image:
Users have been reporting some degree of success using cross compiles from Linux x86 host to embedded ARM Linux devices.
For this to work, FLATCC_TEST option should be disabled in part because cross-compilation cannot run the cross-compiled flatcc tool, and in part because there appears to be some issues with CMake custom build steps needed when building test and sample projects.
2024-03-08: WARNING: -O2 -mcpu=cortex-m7 targets using the arm-none-eabi 13.2.Rel1 toolchain can result in uninitialized stack access when not compiled with -fno-strict-aliasing -mcpu=cortex-m0 and -mcpu=cortex-m1 appears to be unaffected. See also issue #274. 2024-10-03: Fix available on flatcc master branch when you read this. See also CHANGELOG comments for release 0.6.2.
The option FLATCC_RTONLY will disable tests and only build the runtime library.
The following is not well tested, but may be a starting point:
mkdir -p build/xbuild
cd build/xbuild
cmake ../.. -DBUILD_SHARED_LIBS=on -DFLATCC_RTONLY=on
-DCMAKE_BUILD_TYPE=Release
Overall, it may be simpler to create a separate Makefile and just compile the few src/runtime/*.c into a library and distribute the headers as for other platforms, unless flatcc is also required for the target. Or to simply include the runtime source and header files in the user project.
Note that no tests will be built nor run with FLATCC_RTONLY enabled. It is highly recommended to at least run the tests/monster_test project on a new platform.
Some target systems will not work with Posix malloc , realloc , free and C11 aligned_alloc . Or they might, but more allocation control is desired. The best approach is to use flatcc_builder_custom_init to provide a custom allocator and emitter object, but for simpler case or while piloting a new platform flatcc_alloc.h can be used to override runtime allocation functions. Carefully read the comments in this file if doing so. There is a test case implementing a new emitter, and a custom allocator can be copied from the one embedded in the builder library source.
On systems where the default POSIX assert call is unavailable, or when a different assert behaviour is desirable, it is possible to override the default behaviour in runtime part of flatcc library via logic defined in flatcc_assert.h.
By default Posix assert is beeing used. It can be changed by preprocessor definition:
-DFLATCC_ASSERT=own_assert
but it will not override assertions used in the portable library, notably the Grisu3 fast numerical conversion library used with JSON parsing.
Runtime assertions can be disabled using:
-DFLATCC_NO_ASSERT
This will also disable Grisu3 assertions. See flatcc_assert.h for details.
The <assert.h> file will in all cases remain a dependency for C11 style static assertions. Static assertions are needed to ensure the generated structs have the correct physical layout on all compilers. The portable library has a generic static assert implementation for older compilers.
By default libraries are built statically.
Occasionally there are requests #42 for also building shared libraries. It is not clear how to build both static and shared libraries at the same time without choosing some unconvential naming scheme that might affect install targets unexpectedly.
CMake supports building shared libraries out of the box using the standard library name using the following option:
CMAKE ... -DBUILD_SHARED_LIBS=ON ...
See also CMake Gold: Static + shared.
The Flatcc build files should take care of strict aliasing issues on common platforms, but it is not a solved problem, so here is some background information.
In most cases this is a non-issue with the current flatcc code base, but that does not help in the cases where it is an issue.
Compilers have become increasingly aggressive with applying, and defaulting to, strict aliasing rules.
FlatCC does not guarantee that strict aliasing rules are followed, but the code base is updated as issues are detected. If a test fails or segfaults the first thing to check is -fno-strict-aliasing , or the platform equivalent, or to disable pointer casts, as discussed below.
Strict aliasing means that a cast like p2 = *(T *)p1 is not valid because the compiler thinks that p2 does not depend on data pointed to by p1. In most cases compilers are sensible enough to handle this, but not always. It can, and will, lead to reading from uninitialized memory or segfaults. There are two ways around this, one is to use unions to convert from integer to float, which is valid in C, but not in C++, and the other is to use memcpy for small constant sizes, which is guaranteed safe, but can be slow if not optimized, and it is not always optimized. (Not strictly memcpy but access via cast to char * or other "narrow" type).
FlatCC manages this in flatcc_accessors.h which forwards to platform dependent code in pmemaccess.h. Note that is applies to the runtime code base only. For compile time the only issue should be hash tables and these should also be safe.
FlatCC either uses optimized memcpy or non-compliant pointer casts depending on the platform. Essentially, buffer memory is first copied, or pointer cast, into an unsigned integer of a given size. This integer is then endian converted into another unsigned integer. Then that integer is converted into a final integer type or floating point type using union casts. This generally optimizes out to very few assembly instructions, but when it does not, code size and execution time can grow significantly.
It has been observed that targets both default to strict aliasing with -O2 optimization, and at the same to uses a function call for memcpy(dest, src, sizeof(uint32_t)) , but where __builtin_memcpy does optimize well, hence requiring detection of a fast memcpy operation.
This is a game between being reasonably performant and compliant.
-DPORTABLE_MEM_PTR_ACCESS=0 will force the runtime code to not use pointer casts but it can potentially generate suboptimal code and can be set 1 if the compiler and build configuration is known to not have issues with strict aliasing. It is set to 1 for most x86/64 targets since this has been working for a long time in FlatCC builds and tests, while memcpy might not work efficient.
Install targes may be built with:
mkdir -p build/install
cd build/install
cmake ../.. -DBUILD_SHARED_LIBS=on -DFLATCC_RTONLY=on
-DCMAKE_BUILD_TYPE=Release -DFLATCC_INSTALL=on
make install
However, this is not well tested and should be seen as a starting point. The normal scripts/build.sh places files in bin and lib of the source tree.
By default lib files a built into the lib subdirectory of the project. This can be changed, for example like -DFLATCC_INSTALL_LIB=lib64 .
To distribute the compiled binaries the following files are required:
컴파일러:
bin/flatcc (command line interface to schema compiler)
lib/libflatcc.a (optional, for linking with schema compiler)
include/flatcc/flatcc.h (optional, header and doc for libflatcc.a)
실행 시간:
include/flatcc/** (runtime header files)
include/flatcc/reflection (optional)
include/flatcc/support (optional, only used for test and samples)
lib/libflatccrt.a (runtime library)
In addition the runtime library source files may be used instead of libflatccrt.a . This may be handy when packaging the runtime library along with schema specific generated files for a foreign target that is not binary compatible with the host system:
src/runtime/*.c
The build products from MSVC are placed in the bin and lib subdirectories:
flatccbinDebugflatcc.exe
flatcclibDebugflatcc_d.lib
flatcclibDebugflatccrt_d.lib
flatccbinReleaseflatcc.exe
flatcclibReleaseflatcc.lib
flatcclibReleaseflatccrt.lib
Runtime includeflatcc directory is distributed like other platforms.
달리다
scripts/test.sh [--no-clean]
NOTE: The test script will clean everything in the build directy before initializing CMake with the chosen or default build configuration, then build Debug and Release builds, and run tests for both.
The script must end with TEST PASSED , or it didn't pass.
To make sure everything works, also run the benchmarks:
scripts/benchmark.sh
In Visual Studio the test can be run as follows: first build the main project, the right click the RUN_TESTS target and chose build. See the output window for test results.
It is also possible to run tests from the command line after the project has been built:
cd buildMSVC
ctest
Note that the monster example is disabled for MSVC 2010.
Be aware that tests copy and generate certain files which are not automatically cleaned by Visual Studio. Close the solution and wipe the MSVC directory, and start over to get a guaranteed clean build.
Please also observe that the file .gitattributes is used to prevent certain files from getting CRLF line endings. Using another source control systems might break tests, notably test/flatc_compat/monsterdata_test.golden .
Note: Benchmarks have not been ported to Windows.
The configuration
config/config.h
drives the permitted syntax and semantics of the schema compiler and code generator. These generally default to be compatible with Googles flatc compiler. It also sets things like permitted nesting depth of structs and tables.
The runtime library has a separate configuration file
include/flatcc/flatcc_rtconfig.h
This file can modify certain aspects of JSON parsing and printing such as disabling the Grisu3 library or requiring that all names in JSON are quoted.
For most users, it should not be relevant to modify these configuration settings. If changes are required, they can be given in the build system - it is not necessary to edit the config files, for example to disable trailing comma in the JSON parser:
cc -DFLATCC_JSON_PARSE_ALLOW_TRAILING_COMMA=0 ...
The compiler library libflatcc.a can compile schemas provided in a memory buffer or as a filename. When given as a buffer, the schema cannot contain include statements - these will cause a compile error.
When given a filename the behavior is similar to the commandline flatcc interface, but with more options - see flatcc.h and config/config.h .
libflatcc.a supports functions named flatcc_... . reflection... may also be available which are simple the C generated interface for the binary schema. The builder library is also included. These last two interfaces are only present because the library supports binary schema generation.
The standalone runtime library libflatccrt.a is a collection of the src/runtime/*.c files. This supports the generated C headers for various features. It is also possible to distribute and compile with the source files directly. For debugging, it is useful to use the libflatccrt_d.a version because it catches a lot of incorrect API use in assertions.
The runtime library may also be used by other languages. See comments in flatcc_builder.h. JSON parsing is on example of an alternative use of the builder library so it may help to inspect the generated JSON parser source and runtime source.
Mostly for implementers: FlatBuffers Binary Format
See Security Considerations.
FlatCC coding style is largely similar to the WebKit Style, with the following notable exceptions:
<stdint.h> types are made available.if (err) return -1; .0 ./* A comment. */true and false keywords are not used (pre C99).snake_case is used over camelCase .#pragma once because it is non-standard and not always reliable in filesystems with ambigious paths.config.h inclusion might be handled differently in that flatbuffers.h includes the config file.unsigned is not used without int for historical reasons. Generally a type like uint32_t is preferred.TODO: instead of FIXME: in comments for historical reasons.All the main source code in compiler and runtime aim to be C11 compatible and uses many C11 constructs. This is made possible through the included portable library such that older compilers can also function. Therefore any platform specific adaptations will be provided by updating the portable library rather than introducing compile time flags in the main source code.
See Benchmarks
