--- /dev/null
+/**
+ * @file apidef.y
+ * @brief RPC tools--API definition file syntax definition and read/front-end processing
+ *
+ */
+
+/*---------------------------------------------------------------------------*/
+/* C declarative statement */
+/*---------------------------------------------------------------------------*/
+%{
+#define YYDEBUG 1
+#define YYERROR_VERBOSE 1
+
+#include <stdio.h>
+#include <stdlib.h>
+
+/*
+ * YACC to C I/F functions
+ */
+extern int yylex(void); /* LEX I/F */
+extern int yyerror(const char *); /* dummy */
+
+#include "apidef.h"
+
+/* YACC to C I/F functions */
+static void AddHeader(const char *header_file);
+static int push_function_arg(int arg_type, int num_of_bytes,
+ int is_pointer,
+ int is_vararray, int is_array_size,
+ const char *var_type_name,
+ int is_out, const char *var_name);
+static void process_function(const char *funcname);
+static void free_string(char *funcname);
+
+static int var_type;
+static int num_of_bytes;
+static int is_pointer;
+static int in_out;
+static int is_vararray;
+static int is_array_size;
+static char *var_type_name = NULL;
+
+%}
+
+/*---------------------------------------------------------------------------*/
+/* Bison declarations */
+/*---------------------------------------------------------------------------*/
+%union {
+ int ival;
+ char *strval;
+}
+
+%token '"'
+%left ','
+%left '('
+%right ')'
+%left '*'
+%token '{'
+%token '}'
+%token ';'
+%token '\n'
+%token <strval> rpc_INCLUDE 257
+%token <strval> RPC_RESULT 258
+%token <strval> rpc_NAME_DOT 259
+%token <strval> rpc_NAME 260
+%type <strval> funcdefs funcdef args
+%type <strval> nonvoid_args arg var_type
+%type <strval> var_primitive_type var_string_type var_user_defined_type
+/*
+%token <strval> rpc_OUT
+*/
+%token <strval> rpc_INOUT 261
+%token <strval> rpc_CONST 262
+%token <strval> rpc_VARARRAY 263
+%token <strval> rpc_ARRAYSIZE 264
+%token <ival> rpc_NUM 265
+%token <strval> rpc_VOID 266
+%token <ival> rpc_CHAR 267
+%token <ival> rpc_INT 268
+%token <ival> rpc_SINT 269
+%token <ival> rpc_UINT 270
+%token <ival> rpc_INT8 271
+%token <ival> rpc_INT16 272
+%token <ival> rpc_INT32 273
+%token <ival> rpc_INT64 274
+%token <ival> rpc_UINT8 275
+%token <ival> rpc_UINT16 276
+%token <ival> rpc_UINT32 277
+%token <ival> rpc_UINT64 278
+%token <ival> rpc_FLOAT 279
+%token <ival> rpc_DOUBLE 280
+%token <ival> rpc_STRING 281
+%token <ival> rpc_USER_DEFINED 282
+%token <ival> rpc_UNKNOWN 283
+
+/*---------------------------------------------------------------------------*/
+/* Grammar rule */
+/*---------------------------------------------------------------------------*/
+%%
+input: includes funcdefs
+;
+
+includes: /* empty input */
+ | includes include
+;
+
+include: rpc_INCLUDE '<' rpc_NAME_DOT '>'
+ { AddHeader($3); free_string($3); }
+;
+
+funcdefs: funcdef
+ | funcdefs funcdef
+;
+
+funcdef: RPC_RESULT rpc_NAME '(' args ')' ';'
+ { process_function($2); free_string($2);}
+;
+
+args: rpc_VOID
+ | nonvoid_args
+;
+
+nonvoid_args: arg
+ | nonvoid_args ',' arg
+;
+
+arg: var_type rpc_NAME
+ {
+ if (push_function_arg(var_type, num_of_bytes, is_pointer,
+ is_vararray, is_array_size,
+ var_type_name, in_out, $2) < 0) {
+ YYERROR;
+ }
+ if (var_type_name) { free_string(var_type_name); }
+ var_type_name = NULL;
+ free_string($2);
+ }
+ | var_type
+ {
+ if (push_function_arg(var_type, num_of_bytes, is_pointer,
+ is_vararray, is_array_size,
+ var_type_name, in_out, NULL) < 0) {
+ YYERROR;
+ }
+ if (var_type_name) { free_string(var_type_name); }
+ var_type_name = NULL;
+ }
+;
+
+/*
+ * Standard IN pointers are not allowed.
+ * When used as an array address, it is not clear how many bytes to copy.
+ * ->You are asked to declare the type and pass the address.
+ * Otherwise, you can simply pass it by value.
+ */
+var_type: var_primitive_type /* INT8, .. DOUBLE */
+ { is_pointer = 0; is_vararray = 0; is_array_size = 0; in_out =RPC_IN_ARG; }
+ | var_primitive_type '*' /* OUT INT8 *, ... OUT DOUBLE * */
+ { is_pointer = 1; is_vararray = 0; is_array_size = 0; in_out = RPC_OUT_ARG; }
+ /* if allow primitive IN pointer
+ | rpc_CONST var_primitive_type '*'
+ { is_pointer = 1; in_out = RPC_IN_ARG; }
+ */
+ | var_string_type
+ /* OUT STRING128, ... */
+ { is_pointer = 1; is_vararray = 0; is_array_size = 0; in_out = RPC_OUT_ARG; }
+ | rpc_CONST var_string_type
+ /* IN STRING128, ... */
+ { is_pointer = 1; is_vararray = 0; is_array_size = 0; in_out = RPC_IN_ARG; }
+ | var_user_defined_type
+ { is_pointer = 0; is_vararray = 0; is_array_size = 0; in_out = RPC_IN_ARG; }
+ | var_user_defined_type '*'
+ { is_pointer = 1; is_vararray = 0; is_array_size = 0; in_out = RPC_OUT_ARG; }
+ | rpc_CONST var_user_defined_type '*'
+ { is_pointer = 1; is_vararray = 0; is_array_size = 0; in_out = RPC_IN_ARG; }
+
+ /* INOUT specification */
+ | rpc_INOUT var_string_type
+ /* IN STRING128, ... */
+ { is_pointer = 1; is_vararray = 0; is_array_size = 0; in_out = RPC_INOUT_ARG; }
+ | rpc_INOUT var_user_defined_type '*'
+ { is_pointer = 1; is_vararray = 0; is_array_size = 0; in_out = RPC_INOUT_ARG; }
+
+ /* Variable-length arrays */
+ | rpc_CONST rpc_VARARRAY var_primitive_type '*'
+ { is_pointer = 1; is_vararray = 1; is_array_size = 0; in_out = RPC_IN_ARG; }
+ | rpc_VARARRAY var_primitive_type '*'
+ { is_pointer = 1; is_vararray = 1; is_array_size = 0; in_out = RPC_OUT_ARG; }
+ | rpc_INOUT rpc_VARARRAY var_primitive_type '*'
+ { is_pointer = 1; is_vararray = 1; is_array_size = 0; in_out = RPC_INOUT_ARG; }
+ | rpc_CONST rpc_VARARRAY var_user_defined_type '*'
+ { is_pointer = 1; is_vararray = 1; is_array_size = 0; in_out = RPC_IN_ARG; }
+ | rpc_VARARRAY var_user_defined_type '*'
+ { is_pointer = 1; is_vararray = 1; is_array_size = 0; in_out = RPC_OUT_ARG; }
+ | rpc_INOUT rpc_VARARRAY var_user_defined_type '*'
+ { is_pointer = 1; is_vararray = 1; is_array_size = 0; in_out = RPC_INOUT_ARG; }
+
+ /* Variable length array size */
+ | rpc_ARRAYSIZE var_primitive_type
+ { is_pointer = 0; is_vararray = 0; is_array_size = 1; in_out = RPC_IN_ARG; }
+;
+
+var_primitive_type:
+ rpc_CHAR { var_type = $1; num_of_bytes = 0; var_type_name = NULL; }
+ | rpc_INT { var_type = $1; num_of_bytes = 0; var_type_name = NULL; }
+ | rpc_SINT { var_type = $1; num_of_bytes = 0; var_type_name = NULL; }
+ | rpc_UINT { var_type = $1; num_of_bytes = 0; var_type_name = NULL; }
+ | rpc_INT8 { var_type = $1; num_of_bytes = 0; var_type_name = NULL; }
+ | rpc_UINT8 { var_type = $1; num_of_bytes = 0; var_type_name = NULL; }
+ | rpc_INT16 { var_type = $1; num_of_bytes = 0; var_type_name = NULL; }
+ | rpc_UINT16 { var_type = $1; num_of_bytes = 0; var_type_name = NULL; }
+ | rpc_INT32 { var_type = $1; num_of_bytes = 0; var_type_name = NULL; }
+ | rpc_UINT32 { var_type = $1; num_of_bytes = 0; var_type_name = NULL; }
+ | rpc_INT64 { var_type = $1; num_of_bytes = 0; var_type_name = NULL; }
+ | rpc_UINT64 { var_type = $1; num_of_bytes = 0; var_type_name = NULL; }
+ | rpc_FLOAT { var_type = $1; num_of_bytes = 0; var_type_name = NULL; }
+ | rpc_DOUBLE { var_type = $1; num_of_bytes = 0; var_type_name = NULL; }
+;
+
+var_string_type: rpc_STRING rpc_NUM
+ { var_type = $1; num_of_bytes = $2; var_type_name = NULL; }
+;
+
+var_user_defined_type: rpc_NAME
+ { var_type = rpc_USER_DEFINED; num_of_bytes = 0; var_type_name = $1; }
+;
+
+%%
+
+/*---------------------------------------------------------------------------*/
+/* C additional code */
+/*---------------------------------------------------------------------------*/
+/* Including an older bison results in an error */
+/*#include "apidef.tab.h"*/
+
+#include <unistd.h>
+#include <assert.h>
+#include <string.h>
+/*
+ * YACC/Lex interface functions/variables
+ */
+extern int yydebug; /* for YACC debug */
+extern int yyparse(void);
+extern FILE *yyin;
+extern int yy_flex_debug; /* for FLEX debug */
+/* my own function to free the buffer flex allocates */
+extern void free_flex_buffer(void);
+
+#ifdef DBG_ENABLE
+char rpc_log_enable;
+#endif
+
+/**/
+static void
+AddHeader(const char *filename)
+{
+ ApidefAddHeader(filename);
+}
+
+static int
+push_function_arg(int arg_type, int num_of_bytes, int is_pointer,
+ int is_vararray, int is_array_size,
+ const char *var_type_name, int in_out, const char *var_name)
+{
+ switch(arg_type) {
+ case rpc_CHAR:
+ case rpc_INT:
+ case rpc_SINT:
+ case rpc_UINT:
+ case rpc_INT8:
+ case rpc_INT16:
+ case rpc_INT32:
+ case rpc_INT64:
+ case rpc_UINT8:
+ case rpc_UINT16:
+ case rpc_UINT32:
+ case rpc_UINT64:
+ case rpc_FLOAT:
+ case rpc_DOUBLE:
+ case rpc_STRING:
+ case rpc_USER_DEFINED:
+ return ApidefPushFunctionArg(arg_type, num_of_bytes, is_pointer,
+ is_vararray, is_array_size,
+ var_type_name, in_out, var_name);
+ break;
+
+ default:
+ return -1;
+ break;
+ }
+}
+
+static void
+process_function(const char *funcname)
+{
+ ApidefProcessFunction(funcname);
+}
+
+static void
+free_string(char *s)
+{
+#ifdef DEBUG
+ fprintf(stderr, "freed %s\n", s);
+#endif
+ free(s);
+}
+
+static void
+extract_id(const char *filename, char **id)
+{
+ char *dotapi;
+ char *slash;
+ const char *start;
+
+ if (id == NULL) {
+ return;
+ }
+ dotapi = strrchr(filename, '.');
+ if (dotapi == NULL) {
+ return;
+ }
+ if (strcmp(dotapi, ".api")) {
+ return;
+ }
+
+ slash = strrchr(filename, '/');
+ start = filename;
+ if (slash != NULL) {
+ start = slash + 1;
+ }
+
+ *id = malloc((size_t)(dotapi - start + 1));
+ if (*id == NULL) {
+ return;
+ }
+ strncpy(*id, start, (size_t)(dotapi - start));
+ (*id)[dotapi - start] = '\0';
+}
+
+static void
+usage(const char *prog)
+{
+ fprintf(stdout,
+ "How to use: %s [CPPFLAGS] ... API definition file name\n",
+ prog);
+ fprintf(stdout, "Examples1: %s XXX.api\n", prog);
+ fprintf(stdout, "Examples2: %s -DSOME_DEFINES XXX.api\n", prog);
+}
+
+#define CPP_PROG "cpp"
+static void free_cpp_argv(char **argv);
+
+static char **
+prepare_cpp_argv(int argc, char *argv[])
+{
+ char **cpp_argv;
+ char **ret;
+
+ cpp_argv = malloc(sizeof(char *) * (long unsigned int)(argc+1));
+ if (cpp_argv == NULL) {
+ return NULL;
+ }
+ memset(cpp_argv, 0, sizeof(char *) * (long unsigned int)(argc+1));
+ ret = cpp_argv;
+
+ cpp_argv[0] = malloc(strlen(CPP_PROG)+1);
+ if (cpp_argv[0] == NULL) {
+ free_cpp_argv(ret);
+ return NULL;
+ }
+ strcpy(cpp_argv[0], CPP_PROG);
+ cpp_argv++;
+
+ for( ; *argv != NULL ; argv++, cpp_argv++) {
+ *cpp_argv = malloc(strlen(*argv)+1);
+ if (*cpp_argv == NULL) {
+ free_cpp_argv(ret);
+ return NULL;
+ }
+ strcpy(*cpp_argv, *argv);
+ }
+ *cpp_argv = NULL;
+ return ret;
+}
+
+static void
+free_cpp_argv(char **argv)
+{
+ char **orig; orig = argv;
+ while(*argv != NULL) {
+ free(*argv);
+ argv++;
+ }
+ free(orig);
+}
+
+/** @ingroup RPCtool
+ * @brief RPCtool main functions
+ *
+ * Perform the following processing.
+ *
+ * - Lexical context analysis of the API definition file(See apidef.y and apidef.l)
+ * - The API function definition read from the definition file is stored in the APIDef class.
+ * - Outputs stub and header files from function definitions stored in APIDef after a successful read
+ */
+int
+main(int argc, char *argv[])
+{
+ int start;
+ char **cpp_argv;
+ int pipefd[2];
+ int pid;
+ int ret;
+
+ if (argc < 2) {
+ usage(argv[0]);
+ return 1;
+ }
+
+ start = 1;
+ yy_flex_debug = 0;
+
+ if (!strcmp(argv[1], "-d")) {
+ yydebug=1;
+ yy_flex_debug = 1;
+ if (argc > 2) {
+ start++;
+ } else {
+ usage(argv[0]);
+ return 1;
+ }
+ }
+
+#ifdef DBG_ENABLE
+ /*
+ * If the second-to-last argument is a log specification
+ */
+ if ( ( argc >= 2 ) && (!strcmp(argv[argc-2], "-log")) ) {
+ rpc_log_enable = 1;
+ } else {
+ rpc_log_enable = 0;
+ }
+#endif
+
+ /*
+ * Extract ID from last argument (API definition file name)
+ */
+ {
+ char *moduleid;
+ moduleid = NULL;
+ extract_id(argv[argc-1], &moduleid);
+ if (moduleid == NULL) {
+ fprintf(stdout, "%s: The API definition file name is invalid.\n", argv[0]);
+ usage(argv[0]);
+ return 1;
+ }
+ ApidefDefineId(moduleid);
+ free(moduleid);
+ }
+
+ /*
+ * Preparing options to exec CPPs
+ */
+ cpp_argv = prepare_cpp_argv(argc, argv + start);
+ if (cpp_argv == NULL) {
+ printf("No Memory!\n");
+ return 1;
+ }
+
+#define PIPE_READ 0
+#define PIPE_WRITE 1
+
+ if (pipe(pipefd) != 0) {
+ perror("pipe");
+ return 1;
+ }
+
+ pid = fork();
+ if (pid < 0) {/* fork error */
+ close(pipefd[PIPE_READ]);
+ close(pipefd[PIPE_WRITE]);
+ perror("fork");
+ return 1;
+ }
+ if (pid == 0) {/* child process */
+ int must_be_1;
+ /*
+ * force stdout to be pipefd[PIPE_WRITE]
+ */
+ close(pipefd[PIPE_READ]);
+ close(1);
+ must_be_1 = dup(pipefd[PIPE_WRITE]);
+ assert(must_be_1 == 1);
+ close(pipefd[PIPE_WRITE]);
+ /*
+ * invoke C preprocessor with flags
+ */
+ execvp(CPP_PROG, cpp_argv);
+ perror("execvp");
+ exit(0);
+ } else {
+ /*
+ * parent process
+ */
+ int must_be_0;
+ free_cpp_argv(cpp_argv);
+
+ /*
+ * force stdin to be pipefd[PIPE_READ]
+ */
+ close(pipefd[PIPE_WRITE]);
+ close(0);
+ must_be_0 = dup(pipefd[PIPE_READ]);
+ assert(must_be_0 == 0);
+ close(pipefd[PIPE_READ]);
+ }
+
+ ret = yyparse();
+
+ free_flex_buffer();
+
+ if (ret == 0) {/* Parsed successfully */
+ //ApidefListFunctions(1);
+ ApidefMakeStubs();
+ } else {/* Parse error occurred */
+ fputs("The APIs that have been analyzed so far are as follows.\n", stdout);
+ fputs("-----start-----\n", stdout);
+ ApidefListFunctions(0);
+ fputs("------end------\n", stdout);
+ fputs("Check this API definition\n", stdout);
+ }
+ ApidefFreeAllocation();
+
+ return ret;
+}
+
+int
+yyerror(const char *s)
+{
+ printf("\nError: %s\n", s);
+ return 0;
+}
+
+int
+yywrap()
+{
+ return 1;
+}
+
+static char const *Types[] = {
+ "char",
+ "int",
+ "signed int",
+ "unsigned int",
+ "INT8",
+ "INT16",
+ "INT32",
+ "INT64",
+ "UINT8",
+ "UINT16",
+ "UINT32",
+ "UINT64",
+ "float",
+ "double",
+ "char *",
+};
+
+static const int TypeCodes[] = {
+ rpc_CHAR,
+ rpc_INT,
+ rpc_SINT,
+ rpc_UINT,
+ rpc_INT8,
+ rpc_INT16,
+ rpc_INT32,
+ rpc_INT64,
+ rpc_UINT8,
+ rpc_UINT16,
+ rpc_UINT32,
+ rpc_UINT64,
+ rpc_FLOAT,
+ rpc_DOUBLE,
+ rpc_STRING,
+};
+
+const char *
+TypeCodeString(const int code)
+{
+ int i;
+ int num;
+ num = sizeof(TypeCodes) / sizeof(int);
+
+ for(i = 0 ; i < num ; i++) {
+ if (code == TypeCodes[i]) {
+ return Types[i];
+ }
+ }
+ return NULL;
+}
+
+int
+IsTypeCodeNumeric( const int code )
+{
+ int i;
+
+ for(i = 0 ; i < sizeof(TypeCodes) / sizeof(TypeCodes[0]) ; i++) {
+ if (TypeCodes[i] == rpc_FLOAT) {
+ break;
+ }
+ if (code == TypeCodes[i]) {
+ return 1;
+ }
+ }
+ return 0;
+}
Code Review / staging / basesystem.git / blobdiff