Initial commit

.gitignore

@@ -0,0 +1,4 @@
+lemon.dSYM/
+xx.dSYM/
+xx
+lemon

base.c

@@ -0,0 +1,363 @@
+
+#define SUCCESS 1
+#define FAILURE 0
+
+const xx_token_names xx_tokens[] =
+{
+	{ XX_T_INTEGER,       		"INTEGER" },
+	{ XX_T_DOUBLE,        		"DOUBLE" },
+	{ XX_T_STRING,        		"STRING" },
+	{ XX_T_IDENTIFIER,    		"IDENTIFIER" },
+	{ XX_T_AT,	   	    		"@" },
+	{ XX_T_COMMA,	   	    	"," },
+	{ XX_T_ASSIGN,       		"=" },
+	{ XX_T_COLON,            	":" },
+	{ XX_T_PARENTHESES_OPEN,  	"(" },
+	{ XX_T_PARENTHESES_CLOSE, 	")" },
+	{ XX_T_BRACKET_OPEN,     	"{" },
+	{ XX_T_BRACKET_CLOSE,    	"}" },
+ 	{ XX_T_SBRACKET_OPEN,    	"[" },
+	{ XX_T_SBRACKET_CLOSE,   	"]" },	
+	{  0, NULL }
+};
+
+/**
+ * Wrapper to alloc memory within the parser
+ */
+static void *xx_wrapper_alloc(size_t bytes){
+	return malloc(bytes);
+}
+
+/**
+ * Wrapper to free memory within the parser
+ */
+static void xx_wrapper_free(void *pointer){
+	//free(pointer);
+}
+
+/**
+ * Creates a parser_token to be passed to the parser
+ */
+static void xx_parse_with_token(void* xx_parser, int opcode, int parsercode, xx_scanner_token *token, xx_parser_status *parser_status){
+
+	xx_parser_token *pToken;
+
+	pToken = malloc(sizeof(xx_parser_token));
+	pToken->opcode = opcode;
+	pToken->token = token->value;
+	pToken->token_len = token->len;
+	pToken->free_flag = 1;
+
+	xx_(xx_parser, parsercode, pToken, parser_status);
+
+	token->value = NULL;
+	token->len = 0;
+}
+
+/**
+ * Creates an error message when it's triggered by the scanner
+ */
+static void xx_scanner_error_msg(xx_parser_status *parser_status){
+
+	/*char *error, *error_part;
+	XX_scanner_state *state = parser_status->scanner_state;
+
+	//PHALCON_INIT_VAR(*error_msg);
+	ALLOC_INIT_ZVAL(*error_msg);
+	if (state->start) {
+		error = emalloc(sizeof(char) * (128 + state->start_length +  Z_STRLEN_P(state->active_file)));
+		if (state->start_length > 16) {
+			error_part = estrndup(state->start, 16);
+			sprintf(error, "Parsing error before '%s...' in %s on line %d", error_part, Z_STRVAL_P(state->active_file), state->active_line);
+			efree(error_part);
+		} else {
+			sprintf(error, "Parsing error before '%s' in %s on line %d", state->start, Z_STRVAL_P(state->active_file), state->active_line);
+		}
+		ZVAL_STRING(*error_msg, error, 1);
+	} else {
+		error = emalloc(sizeof(char) * (64 + Z_STRLEN_P(state->active_file)));
+		sprintf(error, "Parsing error near to EOF in %s", Z_STRVAL_P(state->active_file));
+		ZVAL_STRING(*error_msg, error, 1);
+	}
+	efree(error);*/
+}
+
+/**
+ * Receives the comment tokenizes and parses it
+ */
+int xx_parse_annotations(){
+
+	/*zval *error_msg = NULL;
+
+	ZVAL_NULL(result);
+
+	if (Z_TYPE_P(comment) != IS_STRING) {
+		//phalcon_throw_exception_string(phalcon_annotations_exception_ce, SL("Comment must be a string") TSRMLS_CC);
+		return FAILURE;
+	}
+
+	if(XX_internal_parse_annotations(&result, comment, file_path, line, &error_msg TSRMLS_CC) == FAILURE){
+		//phalcon_throw_exception_string(phalcon_annotations_exception_ce, Z_STRVAL_P(error_msg), Z_STRLEN_P(error_msg) TSRMLS_CC);
+		return FAILURE;
+	}*/
+
+	return SUCCESS;
+}
+
+/**
+ * Parses a comment returning an intermediate array representation
+ */
+int xx_parse_program(char *program, unsigned int program_length) {
+
+	char *error;
+	xx_scanner_state *state;
+	xx_scanner_token token;
+	int scanner_status, status = SUCCESS, start_lines;
+	xx_parser_status *parser_status = NULL;
+	void* xx_parser;
+	/*zval processed_comment;*/
+
+	/**
+	 * Check if the comment has content
+	 */
+	/*if (!Z_STRVAL_P(comment)) {
+		ZVAL_BOOL(*result, 0);
+		return FAILURE;
+	}
+
+	if (Z_STRLEN_P(comment) < 2) {
+		ZVAL_BOOL(*result, 0);
+		return SUCCESS;
+	}*/
+
+	/**
+	 * Start the reentrant parser
+	 */
+	xx_parser = xx_Alloc(xx_wrapper_alloc);
+
+	parser_status = malloc(sizeof(xx_parser_status));
+	state = malloc(sizeof(xx_scanner_state));
+
+	parser_status->status = XX_PARSING_OK;
+	parser_status->scanner_state = state;
+	parser_status->ret = NULL;
+	parser_status->token = &token;
+	parser_status->syntax_error = NULL;
+
+	/**
+	 * Initialize the scanner state
+	 */
+	state->active_token = 0;
+	state->start = program;
+	state->start_length = 0;
+	state->mode = XX_MODE_RAW;
+	//state->active_file = file_path;
+
+	/**
+	 * Possible start line
+	 */
+	/*if (Z_TYPE_P(line) == IS_LONG) {
+		state->active_line = Z_LVAL_P(line) - start_lines;
+	} else {
+		state->active_line = 1;
+	}*/
+
+	state->end = state->start;
+
+	while (0 <= (scanner_status = xx_get_token(state, &token))) {
+
+		state->active_token = token.opcode;
+
+		state->start_length = (program + program_length - state->start);
+
+		switch (token.opcode) {
+
+			case XX_T_IGNORE:
+				break;
+
+			case XX_T_NAMESPACE:
+				xx_(xx_parser, XX_NAMESPACE, NULL, parser_status);
+				break;
+			case XX_T_CLASS:
+				xx_(xx_parser, XX_CLASS, NULL, parser_status);
+				break;
+			case XX_T_PUBLIC:
+				xx_(xx_parser, XX_PUBLIC, NULL, parser_status);
+				break;
+			case XX_T_PROTECTED:
+				xx_(xx_parser, XX_PROTECTED, NULL, parser_status);
+				break;
+			case XX_T_FUNCTION:
+				xx_(xx_parser, XX_FUNCTION, NULL, parser_status);
+				break;
+			case XX_T_LET:
+				xx_(xx_parser, XX_LET, NULL, parser_status);
+				break;
+			case XX_T_DOTCOMMA:
+				xx_(xx_parser, XX_DOTCOMMA, NULL, parser_status);
+				break;
+			/*case XX_T_COMMA:
+				xx_(xx_parser, XX_COMMA, NULL, parser_status);
+				break;*/
+			case XX_T_ASSIGN:
+				xx_(xx_parser, XX_ASSIGN, NULL, parser_status);
+				break;
+			/*case XX_T_COLON:
+				xx_(xx_parser, XX_COLON, NULL, parser_status);
+				break;*/
+
+			case XX_T_PARENTHESES_OPEN:
+				xx_(xx_parser, XX_PARENTHESES_OPEN, NULL, parser_status);
+				break;
+			case XX_T_PARENTHESES_CLOSE:
+				xx_(xx_parser, XX_PARENTHESES_CLOSE, NULL, parser_status);
+				break;
+
+			case XX_T_BRACKET_OPEN:
+				xx_(xx_parser, XX_BRACKET_OPEN, NULL, parser_status);
+				break;
+			case XX_T_BRACKET_CLOSE:
+				xx_(xx_parser, XX_BRACKET_CLOSE, NULL, parser_status);
+				break;
+
+			/*case XX_T_SBRACKET_OPEN:
+				xx_(xx_parser, XX_SBRACKET_OPEN, NULL, parser_status);
+				break;
+			case XX_T_SBRACKET_CLOSE:
+				xx_(xx_parser, XX_SBRACKET_CLOSE, NULL, parser_status);
+				break;*/
+
+			case XX_T_NULL:
+				xx_(xx_parser, XX_NULL, NULL, parser_status);
+				break;
+			case XX_T_TRUE:
+				xx_(xx_parser, XX_TRUE, NULL, parser_status);
+				break;
+			case XX_T_FALSE:
+				xx_(xx_parser, XX_FALSE, NULL, parser_status);
+				break;
+
+			case XX_T_INTEGER:
+				xx_parse_with_token(xx_parser, XX_T_INTEGER, XX_INTEGER, &token, parser_status);
+				break;
+			case XX_T_DOUBLE:
+				xx_parse_with_token(xx_parser, XX_T_DOUBLE, XX_DOUBLE, &token, parser_status);
+				break;
+			case XX_T_STRING:
+				xx_parse_with_token(xx_parser, XX_T_STRING, XX_STRING, &token, parser_status);
+				break;
+			case XX_T_IDENTIFIER:
+				xx_parse_with_token(xx_parser, XX_T_IDENTIFIER, XX_IDENTIFIER, &token, parser_status);
+				break;
+			/*case XX_T_ARBITRARY_TEXT:
+				XX_parse_with_token(xx_parser, XX_T_ARBITRARY_TEXT, XX_ARBITRARY_TEXT, &token, parser_status);
+				break;*/
+
+			default:
+				parser_status->status = XX_PARSING_FAILED;
+				fprintf(stderr, "Scanner: unknown opcode %d\n", token.opcode);
+				/*if (!*error_msg) {
+					error = emalloc(sizeof(char) * (48 + Z_STRLEN_P(state->active_file)));
+					sprintf(error, "Scanner: unknown opcode %d on in %s line %d", token.opcode, Z_STRVAL_P(state->active_file), state->active_line);
+					//PHALCON_INIT_VAR(*error_msg);
+					ALLOC_INIT_ZVAL(*error_msg);
+					ZVAL_STRING(*error_msg, error, 1);
+					efree(error);
+				}*/				
+				break;
+		}
+
+		if (parser_status->status != XX_PARSING_OK) {
+			status = FAILURE;
+			break;
+		}
+
+		state->end = state->start;
+	}
+
+	if (status != FAILURE) {
+		switch (scanner_status) {
+			case XX_SCANNER_RETCODE_ERR:
+			case XX_SCANNER_RETCODE_IMPOSSIBLE:
+				//if (!*error_msg) {
+					//XX_scanner_error_msg(parser_status, error_msg TSRMLS_CC);
+				//}
+				fprintf(stderr, "scanner error\n");
+				status = FAILURE;
+				break;
+			default:
+				xx_(xx_parser, 0, NULL, parser_status);
+		}
+	}
+
+	state->active_token = 0;
+	state->start = NULL;
+
+	if (parser_status->status != XX_PARSING_OK) {
+		status = FAILURE;
+		/*if (parser_status->syntax_error) {
+			if (!*error_msg) {
+				//PHALCON_INIT_VAR(*error_msg);
+				ALLOC_INIT_ZVAL(*error_msg);
+				ZVAL_STRING(*error_msg, parser_status->syntax_error, 1);
+			}
+			efree(parser_status->syntax_error);
+		}*/
+		fprintf(stderr, "error!\n");
+	}
+
+
+
+	xx_Free(xx_parser, xx_wrapper_free);
+
+	if (status != FAILURE) {
+		if (parser_status->status == XX_PARSING_OK) {
+			fprintf(stderr, "%s\n", json_object_to_json_string(parser_status->ret));
+			/*if (parser_status->ret) {
+				ZVAL_ZVAL(*result, parser_status->ret, 0, 0);
+				ZVAL_NULL(parser_status->ret);
+				zval_ptr_dtor(&parser_status->ret);
+			} else {
+				array_init(*result);
+			}*/
+		}
+	}
+
+	//efree(Z_STRVAL(processed_comment));*/
+
+	free(parser_status);
+	free(state);
+
+	return status;
+}
+
+int main(int argc, char **argv) {
+
+	FILE *fp;
+	char ch;
+	char *program;
+	int i;
+
+	program = malloc(sizeof(char) * 2048);
+
+	if (argc > 0) {		
+
+		fp = fopen(argv[1], "r");
+		if (!fp) {
+			fprintf(stderr, "Cant open file\n");
+			exit(1);
+		}
+
+		i = 0;
+		while (!feof(fp)) {
+			ch = fgetc(fp);
+			program[i++] = ch;
+		}
+		program[i - 1] = '\0';
+		fclose(fp);
+
+		//fprintf(stderr, "%s\n", program);
+
+		xx_parse_program(program, i - 1);
+	}
+}