Hi, I really want to use at my python code, and for that I need to compile shared libr

Create shared library about handlebars.c HOT 1 OPEN

terkin commented on July 19, 2024

Create shared library

from handlebars.c.

Comments (1)

jbboehr commented on July 19, 2024

I'm not really familiar with Python or Heroku unfortunately.

What sort of undefined references are you getting? Can you go into a bit more detail on what you've tried?

Depending on which flags you compile it with, libhandlebars.so does depend on several other shared libraries (libyaml, json-c, talloc - use readelf -d /path/to/libhandlebars.so to see which are required) in the environment.

Assuming you want the full execution pipeline, you can see my other project here for implementing this in PHP, although it's a bit more in-depth than the bare-minimum required functionality:
https://github.com/jbboehr/php-handlebars

If the data is JSON-like and can be converted to the types internally used by handlebars.c, the implementation can be fairly simple:

handlebars.c/bin/handlebarsc.c

Lines 632 to 744 in 7acdab0

 static int do_execute(void) 

 { 

 struct handlebars_context * ctx; 

 struct handlebars_parser * parser; 

 struct handlebars_compiler * compiler; 

 struct handlebars_string * tmpl; 

 struct handlebars_ast_node * ast; 

 struct handlebars_program * program; 

 HANDLEBARS_VALUE_DECL(partials); 

 jmp_buf jmp; 

 ctx = handlebars_context_ctor_ex(root); 

 // Save jump buffer 

 if( handlebars_setjmp_ex(ctx, &jmp) ) { 

 fprintf(stderr, "ERROR: %s\n", handlebars_error_message(ctx)); 

 handlebars_context_dtor(ctx); 

 return 1; 

 } 

 parser = handlebars_parser_ctor(ctx); 

 compiler = handlebars_compiler_ctor(ctx); 

 if (enable_partial_loader) { 

 struct handlebars_string *partial_path_str = NULL; 

 struct handlebars_string *partial_extension_str = NULL; 

 partial_path_str = handlebars_string_ctor(ctx, partial_path, strlen(partial_path)); 

 partial_extension_str = handlebars_string_ctor(ctx, partial_extension, strlen(partial_extension)); 

 (void) handlebars_value_partial_loader_init(ctx, partial_path_str, partial_extension_str, partials); 

 } 

 handlebars_compiler_set_flags(compiler, compiler_flags); 

 // Read 

 readInput(); 

 tmpl = handlebars_string_ctor(HBSCTX(parser), input_buf, strlen(input_buf)); 

 // Preprocess 

 if( compiler_flags & handlebars_compiler_flag_compat ) { 

 tmpl = handlebars_preprocess_delimiters(ctx, tmpl, NULL, NULL); 

 } 

 // Read context 

 HANDLEBARS_VALUE_DECL(input); 

 if( input_data_name ) { 

 size_t input_data_name_len = strlen(input_data_name); 

 char * input_str = file_get_contents(input_data_name); 

 if (input_str && strlen(input_str)) { 

 if (handlebars_value_is_empty(input) && input_data_name_len > 5 && (0 == strcmp(input_data_name + input_data_name_len - 5, ".yaml") || 

 0 == strcmp(input_data_name + input_data_name_len - 4, ".yml"))) { 

 #ifdef HANDLEBARS_HAVE_YAML 

 handlebars_value_init_yaml_string(ctx, input, input_str); 

 #else 

 fprintf(stderr, "Failed to process input data: YAML support is disabled"); 

 exit(1); 

 #endif 

 } 

 if (handlebars_value_is_empty(input)) { 

 #ifdef HANDLEBARS_HAVE_JSON 

 // assume json 

 handlebars_value_init_json_string(ctx, input, input_str); 

 if (convert_input) { 

 handlebars_value_convert(input); 

 } 

 #else 

 fprintf(stderr, "Failed to process input data: JSON support is disabled"); 

 exit(1); 

 #endif 

 } 

 } 

 } 

 // Parse 

 ast = handlebars_parse_ex(parser, tmpl, compiler_flags); 

 // Compile 

 program = handlebars_compiler_compile_ex(compiler, ast); 

 // Serialize 

 struct handlebars_module * module = handlebars_program_serialize(ctx, program); 

 // Execute 

 struct handlebars_string * buffer = NULL; 

 do { 

 if (buffer) { 

 handlebars_talloc_free(buffer); 

 buffer = NULL; 

 } 

 struct handlebars_vm * vm; 

 vm = handlebars_vm_ctor(ctx); 

 handlebars_vm_set_flags(vm, compiler_flags); 

 handlebars_vm_set_partials(vm, partials); 

 buffer = handlebars_vm_execute(vm, module, input); 

 buffer = talloc_steal(ctx, buffer); 

 handlebars_vm_dtor(vm); 

 } while(--run_count > 0); 

 if (buffer) { 

 fwrite(hbs_str_val(buffer), sizeof(char), hbs_str_len(buffer), stdout); 

 } 

 if (newline_at_eof) { 

 fwrite("\n", sizeof(char), 1, stdout); 

 } 

 HANDLEBARS_VALUE_UNDECL(input); 

 HANDLEBARS_VALUE_UNDECL(partials); 

 handlebars_context_dtor(ctx); 

 return 0; 

 }

The data would have to be converted to a JSON string first, or the equivalent of handlebars_value_init_json_string for python types would have to be implemented.

from handlebars.c.

Create shared library about handlebars.c HOT 1 OPEN

Comments (1)

Related Issues (20)

Recommend Projects

React

Vue.js

Typescript

TensorFlow

Django

Laravel

D3

Recommend Topics

javascript

web

server

Machine learning

Visualization

Game

Recommend Org

Facebook

Microsoft

Google

Alibaba

D3

Tencent

	static int do_execute(void)
	{
	struct handlebars_context * ctx;
	struct handlebars_parser * parser;
	struct handlebars_compiler * compiler;
	struct handlebars_string * tmpl;
	struct handlebars_ast_node * ast;
	struct handlebars_program * program;
	HANDLEBARS_VALUE_DECL(partials);
	jmp_buf jmp;

	ctx = handlebars_context_ctor_ex(root);

	// Save jump buffer
	if( handlebars_setjmp_ex(ctx, &jmp) ) {
	fprintf(stderr, "ERROR: %s\n", handlebars_error_message(ctx));
	handlebars_context_dtor(ctx);
	return 1;
	}

	parser = handlebars_parser_ctor(ctx);
	compiler = handlebars_compiler_ctor(ctx);

	if (enable_partial_loader) {
	struct handlebars_string *partial_path_str = NULL;
	struct handlebars_string *partial_extension_str = NULL;
	partial_path_str = handlebars_string_ctor(ctx, partial_path, strlen(partial_path));
	partial_extension_str = handlebars_string_ctor(ctx, partial_extension, strlen(partial_extension));
	(void) handlebars_value_partial_loader_init(ctx, partial_path_str, partial_extension_str, partials);
	}

	handlebars_compiler_set_flags(compiler, compiler_flags);

	// Read
	readInput();
	tmpl = handlebars_string_ctor(HBSCTX(parser), input_buf, strlen(input_buf));

	// Preprocess
	if( compiler_flags & handlebars_compiler_flag_compat ) {
	tmpl = handlebars_preprocess_delimiters(ctx, tmpl, NULL, NULL);
	}

	// Read context
	HANDLEBARS_VALUE_DECL(input);
	if( input_data_name ) {
	size_t input_data_name_len = strlen(input_data_name);
	char * input_str = file_get_contents(input_data_name);
	if (input_str && strlen(input_str)) {
	if (handlebars_value_is_empty(input) && input_data_name_len > 5 && (0 == strcmp(input_data_name + input_data_name_len - 5, ".yaml") \|\|
	0 == strcmp(input_data_name + input_data_name_len - 4, ".yml"))) {
	#ifdef HANDLEBARS_HAVE_YAML
	handlebars_value_init_yaml_string(ctx, input, input_str);
	#else
	fprintf(stderr, "Failed to process input data: YAML support is disabled");
	exit(1);
	#endif
	}
	if (handlebars_value_is_empty(input)) {
	#ifdef HANDLEBARS_HAVE_JSON
	// assume json
	handlebars_value_init_json_string(ctx, input, input_str);
	if (convert_input) {
	handlebars_value_convert(input);
	}
	#else
	fprintf(stderr, "Failed to process input data: JSON support is disabled");
	exit(1);
	#endif
	}
	}
	}

	// Parse
	ast = handlebars_parse_ex(parser, tmpl, compiler_flags);

	// Compile
	program = handlebars_compiler_compile_ex(compiler, ast);

	// Serialize
	struct handlebars_module * module = handlebars_program_serialize(ctx, program);

	// Execute
	struct handlebars_string * buffer = NULL;
	do {
	if (buffer) {
	handlebars_talloc_free(buffer);
	buffer = NULL;
	}

	struct handlebars_vm * vm;
	vm = handlebars_vm_ctor(ctx);
	handlebars_vm_set_flags(vm, compiler_flags);
	handlebars_vm_set_partials(vm, partials);

	buffer = handlebars_vm_execute(vm, module, input);
	buffer = talloc_steal(ctx, buffer);

	handlebars_vm_dtor(vm);
	} while(--run_count > 0);

	if (buffer) {
	fwrite(hbs_str_val(buffer), sizeof(char), hbs_str_len(buffer), stdout);
	}

	if (newline_at_eof) {
	fwrite("\n", sizeof(char), 1, stdout);
	}

	HANDLEBARS_VALUE_UNDECL(input);
	HANDLEBARS_VALUE_UNDECL(partials);
	handlebars_context_dtor(ctx);
	return 0;
	}