コード例 #1
0
ファイル: syntax.c プロジェクト: apetrunev/bclite
static struct ast_node*
stmt(void *opaque)
{
	struct ast_node *node;
	token_t	prev_token;

	prev_token = current_token;

	if (match(TOKEN_FUNCTION))

		node = process_function(opaque);
	
	else if (match(TOKEN_LOCAL))
		
		node = process_local_declaration(opaque);

	else if (match(TOKEN_IF)) 
		
		node = if_expr(opaque);
	
	else if (match(TOKEN_FOR))
			
		node = for_expr(opaque);
	
	else if (match(TOKEN_WHILE))
		
		node = while_expr(opaque);
	
	else if (match(TOKEN_BREAK))
		
		node = break_expr(opaque);

	else if (match(TOKEN_CONTINUE))
	
		node = continue_expr(opaque);

	else if (match(TOKEN_RETURN))

		node = process_return_node(opaque);

	else if (match(TOKEN_LBRACE))

		node = process_scope(opaque);

	else if (match(TOKEN_RBRACE)) 

		node = end_scope_expr(opaque);
	
	else if (match(TOKEN_UNKNOWN)) 

		node = unknown_expr(opaque);

	else	
		node = other_expr(opaque);

	return node;	
}
コード例 #2
0
ファイル: filter_env.c プロジェクト: chutz/pkgcore
static const char *
walk_dollar_expansion(const char *start, const char *p, const char *end,
					  char endchar, char disable_quote)
{
	if ('(' == *p)
		return process_scope(NULL, start, p + 1, end, NULL, NULL, ')', NULL) + 1;
	if ('\'' == *p && !disable_quote)
		return walk_statement_dollared_quote_parsing(p + 1, end, '\'') + 1;
	if ('{' != *p) {
		if ('$' == *p)
			// short circuit it.
			return p + 1;
		while (p < end && endchar != *p) {
			if (isspace(*p))
				return p;
			if ('$' == *p)
				return walk_dollar_expansion(start, p + 1, end, endchar, 0);
			if (!isalnum(*p)) {
				if ('_' != *p) {
					return p;
				}
			}
			++p;
		}

		return p >= end ? end : p;
	}
	++p;
	// shortcut ${$} to avoid going too deep. ${$a} isn't valid so no concern
	if ('$' == *p)
		return p + 1;
	while (p < end && '}' != *p) {
		if ('$' == *p)
			p = walk_dollar_expansion(start, p + 1, end, endchar, 0);
		else
			++p;
	}
	return p + 1;
}
コード例 #3
0
ファイル: aicasm.c プロジェクト: edgar-pek/PerspicuOS
int
main(int argc, char *argv[])
{
	int  ch;
	int  retval;
	char *inputfilename;
	scope_t *sentinal;

	STAILQ_INIT(&patches);
	SLIST_INIT(&search_path);
	STAILQ_INIT(&seq_program);
	TAILQ_INIT(&cs_tailq);
	SLIST_INIT(&scope_stack);

	/* Set Sentinal scope node */
	sentinal = scope_alloc();
	sentinal->type = SCOPE_ROOT;
	
	includes_search_curdir = 1;
	appname = *argv;
	regfile = NULL;
	listfile = NULL;
#if DEBUG
	yy_flex_debug = 0;
	mm_flex_debug = 0;
	yydebug = 0;
	mmdebug = 0;
#endif
	while ((ch = getopt(argc, argv, "d:i:l:n:o:p:r:I:X")) != -1) {
		switch(ch) {
		case 'd':
#if DEBUG
			if (strcmp(optarg, "s") == 0) {
				yy_flex_debug = 1;
				mm_flex_debug = 1;
			} else if (strcmp(optarg, "p") == 0) {
				yydebug = 1;
				mmdebug = 1;
			} else {
				fprintf(stderr, "%s: -d Requires either an "
					"'s' or 'p' argument\n", appname);
				usage();
			}
#else
			stop("-d: Assembler not built with debugging "
			     "information", EX_SOFTWARE);
#endif
			break;
		case 'i':
			stock_include_file = optarg;
			break;
		case 'l':
			/* Create a program listing */
			if ((listfile = fopen(optarg, "w")) == NULL) {
				perror(optarg);
				stop(NULL, EX_CANTCREAT);
			}
			listfilename = optarg;
			break;
		case 'n':
			/* Don't complain about the -nostdinc directrive */
			if (strcmp(optarg, "ostdinc")) {
				fprintf(stderr, "%s: Unknown option -%c%s\n",
					appname, ch, optarg);
				usage();
				/* NOTREACHED */
			}
			break;
		case 'o':
			if ((ofile = fopen(optarg, "w")) == NULL) {
				perror(optarg);
				stop(NULL, EX_CANTCREAT);
			}
			ofilename = optarg;
			break;
		case 'p':
			/* Create Register Diagnostic "printing" Functions */
			if ((regdiagfile = fopen(optarg, "w")) == NULL) {
				perror(optarg);
				stop(NULL, EX_CANTCREAT);
			}
			regdiagfilename = optarg;
			break;
		case 'r':
			if ((regfile = fopen(optarg, "w")) == NULL) {
				perror(optarg);
				stop(NULL, EX_CANTCREAT);
			}
			regfilename = optarg;
			break;
		case 'I':
		{
			path_entry_t include_dir;

			if (strcmp(optarg, "-") == 0) {
				if (includes_search_curdir == 0) {
					fprintf(stderr, "%s: Warning - '-I-' "
							"specified multiple "
							"times\n", appname);
				}
				includes_search_curdir = 0;
				for (include_dir = SLIST_FIRST(&search_path);
				     include_dir != NULL;
				     include_dir = SLIST_NEXT(include_dir,
							      links))
					/*
					 * All entries before a '-I-' only
					 * apply to includes specified with
					 * quotes instead of "<>".
					 */
					include_dir->quoted_includes_only = 1;
			} else {
				include_dir =
				    (path_entry_t)malloc(sizeof(*include_dir));
				if (include_dir == NULL) {
					perror(optarg);
					stop(NULL, EX_OSERR);
				}
				include_dir->directory = strdup(optarg);
				if (include_dir->directory == NULL) {
					perror(optarg);
					stop(NULL, EX_OSERR);
				}
				include_dir->quoted_includes_only = 0;
				SLIST_INSERT_HEAD(&search_path, include_dir,
						  links);
			}
			break;
		}
		case 'X':
			/* icc version of -nostdinc */
			break;
		case '?':
		default:
			usage();
			/* NOTREACHED */
		}
	}
	argc -= optind;
	argv += optind;

	if (argc != 1) {
		fprintf(stderr, "%s: No input file specifiled\n", appname);
		usage();
		/* NOTREACHED */
	}

	if (regdiagfile != NULL
	 && (regfile == NULL || stock_include_file == NULL)) {
		fprintf(stderr,
			"%s: The -p option requires the -r and -i options.\n",
			appname);
		usage();
		/* NOTREACHED */
	}
	symtable_open();
	inputfilename = *argv;
	include_file(*argv, SOURCE_FILE);
	retval = yyparse();
	if (retval == 0) {
		if (SLIST_FIRST(&scope_stack) == NULL
		 || SLIST_FIRST(&scope_stack)->type != SCOPE_ROOT) {
			stop("Unterminated conditional expression", EX_DATAERR);
			/* NOTREACHED */
		}

		/* Process outmost scope */
		process_scope(SLIST_FIRST(&scope_stack));
		/*
		 * Decend the tree of scopes and insert/emit
		 * patches as appropriate.  We perform a depth first
		 * tranversal, recursively handling each scope.
		 */
		/* start at the root scope */
		dump_scope(SLIST_FIRST(&scope_stack));

		/* Patch up forward jump addresses */
		back_patch();

		if (ofile != NULL)
			output_code();
		if (regfile != NULL)
			symtable_dump(regfile, regdiagfile);
		if (listfile != NULL)
			output_listing(inputfilename);
	}

	stop(NULL, 0);
	/* NOTREACHED */
	return (0);
}
コード例 #4
0
ファイル: filter_env.c プロジェクト: chutz/pkgcore
static PyObject *
pkgcore_filter_env_run(PyObject *self, PyObject *args, PyObject *kwargs)
{
	/* Arguments. */
	PyObject *out, *envvar_callback=NULL;
	const char *file_buff;
	PyObject *var_matcher, *func_matcher;
	Py_ssize_t file_size;

	char *res_p = NULL;

	static char *kwlist[] = {"out", "file_buff", "vsr", "fsr",
							 "global_envvar_callback", NULL};

	if (!PyArg_ParseTupleAndKeywords(args, kwargs, "Os#OO|O", kwlist,
									 &out, &file_buff, &file_size,
									 &var_matcher, &func_matcher,
									 &envvar_callback))
		return NULL;

	int result = PyObject_IsTrue(func_matcher);
	if (result < 0)
		return NULL;
	if (!result)
		func_matcher = NULL;

	result = PyObject_IsTrue(var_matcher);
	if (result < 0)
		return NULL;
	if (!result)
		var_matcher = NULL;

	if (file_buff[file_size] != '\0') {
		PyErr_SetString(PyExc_ValueError, "file_buff should end in NULL");
		return NULL;
	}

	if(envvar_callback) {
		int true_ret = PyObject_IsTrue(envvar_callback);
		if(-1 == true_ret) {
			goto filter_env_cleanup;
		}
		if(!true_ret) {
			envvar_callback = (PyObject *)NULL;
		}
	}

	res_p = (char *)process_scope(
		out, file_buff, file_buff, file_buff + file_size, var_matcher, func_matcher,
		'\0', envvar_callback);

filter_env_cleanup:

	if (!res_p) {
		if (!PyErr_Occurred()) {
			PyErr_SetString(PyExc_ValueError, "Parsing failed");
		}
		return NULL;
	}
	Py_RETURN_NONE;
}
コード例 #5
0
ファイル: filter_env.c プロジェクト: chutz/pkgcore
static const char *
process_scope(PyObject *out, const char *start, const char *buff,
			  const char *end,
			  PyObject *var_matcher, PyObject *func_matcher,
			  const char endchar, PyObject *envvar_callback)
{
	const char *p = NULL;
	const char *window_start = NULL, *window_end = NULL;
	const char *new_p = NULL;
	const char *com_start = NULL;
	char *s = NULL;
	char *e = NULL;
	char *temp_string = NULL;

	regmatch_t matches[3];
	p = buff;
	matches[0].rm_so = matches[1].rm_so = matches[2].rm_so = -1;

	window_start = buff;
	window_end = NULL;
	while (p < end && *p != endchar) {

		/* wander forward to the next non space */
		if (window_end != NULL) {
			if (out) {
				PyObject *string = PyString_FromStringAndSize(
					window_start, window_end - window_start);
				if (!string)
					return NULL;
				PyObject *result = PyObject_CallMethodObjArgs(
					out, write_str, string, NULL);
				Py_DECREF(string);
				if (!result)
					return NULL;
				Py_DECREF(result);
			}
			window_start = p;
			window_end = NULL;
		}
		com_start = p;
		if (isspace(*p)) {
			++p;
			continue;
		}

		/* ignore comments */
		if (*p == '#') {
			p = walk_statement_pound(start, p, endchar);
			continue;
		}

		if(NULL != (new_p = is_function(p, &s, &e))) {
			if(-1 == asprintf(&temp_string, "%.*s", (int)(e - s), s))
				return NULL;
			INFO("matched func name '%s'", temp_string);
			/* output it if it doesn't match */

			new_p = process_scope(
				NULL, start, new_p, end, NULL, NULL, '}', NULL);
			INFO("ended processing  '%s'", temp_string);
			if (func_matcher) {
				int regex_result = regex_matches(func_matcher, temp_string);
				if (-1 == regex_result) {
					free(temp_string);
					return NULL;
				}
				if (regex_result) {
					/* well, it matched.  so it gets skipped. */
					INFO("filtering func '%s'", temp_string);
					window_end = com_start;
				}
			}

			free(temp_string);
			if(!new_p)
				return NULL;
			p = new_p;
			++p;
			continue;
		}
		// check for env assignment
		if (NULL == (new_p = is_envvar(p, &s, &e))) {
			//exactly as it sounds, non env assignment.
			p = walk_command_complex(start, p, end,
				endchar, COMMAND_PARSING);
			if (!p)
				return NULL;
			// icky icky icky icky
			if (p < end && *p != endchar)
				++p;
		} else {
			//env assignment
			if(-1 == asprintf(&temp_string, "%.*s", (int)(e - s), s))
				return NULL;
			INFO("matched env assign '%s'", temp_string);

			do_envvar_callback(envvar_callback, temp_string);

			if (var_matcher) {
				int regex_result = regex_matches(var_matcher, temp_string);
				if (-1 == regex_result) {
					free(temp_string);
					return NULL;
				}
				if (regex_result) {
					//this would be filtered.
					INFO("filtering var '%s'", temp_string);
					window_end = com_start;
				}
			}

			free(temp_string);

			p = new_p;
			if (p >= end) {
				return p;
			}

			while(p < end && !isspace(*p) && ';' != *p) {
				if ('\'' == *p)
					p = walk_statement_no_parsing(p + 1, end, '\'') + 1;
				else if ('"' == *p || '`' == *p)
					p = walk_command_escaped_parsing(start, p + 1, end,
						*p) + 1;
				else if ('(' == *p) {
					p = walk_command_escaped_parsing(start, p + 1, end,
						')') + 1;
				} else if ('$' == *p) {
					++p;
					if (p >= end) {
						continue;
					}
					p = walk_dollar_expansion(start, p, end, endchar,
						endchar);
					continue;
				} else {
					// blah=cah ; single word.
					p = walk_command_complex(start, p, end, ' ',
						SPACE_PARSING);
					if (!p) {
						return NULL;
					}
				}
			}
		}
	}

	if (out) {
		if (window_end == NULL)
			window_end = p;
		if (window_end > end)
			window_end = end;
		PyObject *string = PyString_FromStringAndSize(
			window_start, window_end - window_start);
		if (!string)
			return NULL;
		PyObject *result = PyObject_CallMethodObjArgs(
			out, write_str, string, NULL);
		Py_DECREF(string);
		if (!result)
			return NULL;
		Py_DECREF(result);
	}

	return p;
}