void
log_set_peer_addr(const char *addr)
{
/*
* XXX: Turn it into assertion?
*/
if (peer_addr != NULL)
log_errx(1, "%s called twice", __func__);
peer_addr = checked_strdup(addr);
}
void
keys_add(struct keys *keys, const char *name, const char *value)
{
int i;
log_debugx("key to send: \"%s=%s\"", name, value);
/*
* Note that we don't check for duplicates here, as they are perfectly
* fine in responses, e.g. the "TargetName" keys in discovery sesion
* response.
*/
for (i = 0; i < KEYS_MAX; i++) {
if (keys->keys_names[i] == NULL) {
keys->keys_names[i] = checked_strdup(name);
keys->keys_values[i] = checked_strdup(value);
return;
}
}
log_errx(1, "too many keys");
}
struct rchap *
rchap_new(const char *secret)
{
struct rchap *rchap;
rchap = calloc(1, sizeof(*rchap));
if (rchap == NULL)
log_err(1, "calloc");
rchap->rchap_secret = checked_strdup(secret);
return (rchap);
}
void
log_set_peer_name(const char *name)
{
/*
* XXX: Turn it into assertion?
*/
if (peer_name != NULL)
log_errx(1, "%s called twice", __func__);
if (peer_addr == NULL)
log_errx(1, "%s called before log_set_peer_addr", __func__);
peer_name = checked_strdup(name);
}
static void
resolve_addr(const struct connection *conn, const char *address,
struct addrinfo **ai, bool initiator_side)
{
struct addrinfo hints;
char *arg, *addr, *ch;
const char *port;
int error, colons = 0;
arg = checked_strdup(address);
if (arg[0] == '\0') {
fail(conn, "empty address");
log_errx(1, "empty address");
}
if (arg[0] == '[') {
/*
* IPv6 address in square brackets, perhaps with port.
*/
arg++;
addr = strsep(&arg, "]");
if (arg == NULL) {
fail(conn, "malformed address");
log_errx(1, "malformed address %s", address);
}
if (arg[0] == '\0') {
port = NULL;
} else if (arg[0] == ':') {
port = arg + 1;
} else {
fail(conn, "malformed address");
log_errx(1, "malformed address %s", address);
}
} else {
/*
* Either IPv6 address without brackets - and without
* a port - or IPv4 address. Just count the colons.
*/
for (ch = arg; *ch != '\0'; ch++) {
if (*ch == ':')
colons++;
}
if (colons > 1) {
addr = arg;
port = NULL;
} else {
addr = strsep(&arg, ":");
if (arg == NULL)
port = NULL;
else
port = arg;
}
}
if (port == NULL && !initiator_side)
port = "3260";
memset(&hints, 0, sizeof(hints));
hints.ai_family = PF_UNSPEC;
hints.ai_socktype = SOCK_STREAM;
hints.ai_flags = AI_ADDRCONFIG | AI_NUMERICSERV;
if (initiator_side)
hints.ai_flags |= AI_PASSIVE;
error = getaddrinfo(addr, port, &hints, ai);
if (error != 0) {
fail(conn, gai_strerror(error));
log_errx(1, "getaddrinfo for %s failed: %s",
address, gai_strerror(error));
}
}
static void
process_init_file(const char *filename)
{
/*
** The strings that are supposed to be followed by other information
** (INIT, REQUIRED_INIT, and REQUIRED_FINAL) should end with
** the space that separates the keyword from the following data.
** The string that is not supposed to be following by other information
** (ENDINIT) should not have a following space, since llds_out.m and
** mlds_to_c.m do not add that space.
*/
const char * const init_str = "INIT ";
const char * const reqinit_str = "REQUIRED_INIT ";
const char * const reqfinal_str = "REQUIRED_FINAL ";
const char * const envvar_str = "ENVVAR ";
const char * const endinit_str = "ENDINIT";
const int init_strlen = strlen(init_str);
const int reqinit_strlen = strlen(reqinit_str);
const int reqfinal_strlen = strlen(reqfinal_str);
const int envvar_strlen = strlen(envvar_str);
const int endinit_strlen = strlen(endinit_str);
char line[MAXLINE];
FILE *cfile;
cfile = fopen(filename, "r");
if (cfile == NULL) {
fprintf(stderr, "%s: error opening file `%s': %s\n",
MR_progname, filename, strerror(errno));
num_errors++;
return;
}
while (get_line(cfile, line, MAXLINE) > 0) {
if (strncmp(line, init_str, init_strlen) == 0) {
char *func_name;
int func_name_len;
int j;
MR_bool special;
for (j = init_strlen; MR_isalnumunder(line[j]); j++) {
/* VOID */
}
line[j] = '\0';
func_name = line + init_strlen;
func_name_len = strlen(func_name);
if (MR_strneq(&func_name[func_name_len - 4], "init", 4)) {
func_name[func_name_len - 4] = '\0';
MR_ensure_room_for_next(std_module, const char *,
MR_INIT_STD_MODULE_SIZE);
std_modules[std_module_next] = checked_strdup(func_name);
std_module_next++;
} else {
MR_ensure_room_for_next(special_module, const char *,
MR_INIT_SPECIAL_MODULE_SIZE);
special_modules[special_module_next] =
checked_strdupcat(func_name, "_");
special_module_next++;
}
} else if (strncmp(line, reqinit_str, reqinit_strlen) == 0) {
char *func_name;
int j;
for (j = reqinit_strlen; MR_isalnumunder(line[j]); j++) {
/* VOID */
}
line[j] = '\0';
func_name = line + reqinit_strlen;
MR_ensure_room_for_next(req_init_module, const char *,
MR_INIT_REQ_MODULE_SIZE);
req_init_modules[req_init_module_next] = checked_strdup(func_name);
req_init_module_next++;
} else if (strncmp(line, reqfinal_str, reqfinal_strlen) == 0) {
char *func_name;
int j;
for (j = reqfinal_strlen; MR_isalnumunder(line[j]); j++) {
/* VOID */
}
line[j] = '\0';
func_name = line + reqfinal_strlen;
MR_ensure_room_for_next(req_final_module, const char *,
MR_FINAL_REQ_MODULE_SIZE);
req_final_modules[req_final_module_next] =
checked_strdup(func_name);
req_final_module_next++;
} else if (strncmp(line, envvar_str, envvar_strlen) == 0) {
char *envvar_name;
int i;
int j;
MR_bool found;
/*
** Check that all characters in the name of the environment
** variable are acceptable as components of a C variable name.
** Note that the variable name doesn't have to start with a letter
** because the variable name has a prefix.
*/
for (j = envvar_strlen; MR_isalnumunder(line[j]); j++) {
/* VOID */
}
if (line[j] != '\n') {
printf("mkinit: error: bad environment variable name %s\n",
line);
}
line[j] = '\0'; /* overwrite the newline */
envvar_name = line + envvar_strlen;
/*
** Since the number of distinct environment variables used by
** a program is likely to be in the single digits, linear search
** should be efficient enough.
*/
found = MR_FALSE;
for (i = 0; i < mercury_env_var_next; i++) {
if (strcmp(envvar_name, mercury_env_vars[i]) == 0) {
found = MR_TRUE;
break;
}
}
if (!found) {
MR_ensure_room_for_next(mercury_env_var, const char *,
MR_ENV_VAR_LIST_SIZE);
mercury_env_vars[mercury_env_var_next] =
checked_strdup(envvar_name);
mercury_env_var_next++;
}
} else if (strncmp(line, endinit_str, endinit_strlen) == 0) {
break;
}
}
fclose(cfile);
}
int
main(int argc, char **argv)
{
int ch, error;
bool Vflag = false, vflag = false;
const char *certpath = NULL, *keypath = NULL, *outpath = NULL, *inpath = NULL;
FILE *certfp = NULL, *keyfp = NULL;
X509 *cert = NULL;
EVP_PKEY *key = NULL;
pid_t pid;
int pipefds[2];
while ((ch = getopt(argc, argv, "Vc:k:o:v")) != -1) {
switch (ch) {
case 'V':
Vflag = true;
break;
case 'c':
certpath = checked_strdup(optarg);
break;
case 'k':
keypath = checked_strdup(optarg);
break;
case 'o':
outpath = checked_strdup(optarg);
break;
case 'v':
vflag = true;
break;
default:
usage();
}
}
argc -= optind;
argv += optind;
if (argc != 1)
usage();
if (Vflag) {
if (certpath != NULL)
errx(1, "-V and -c are mutually exclusive");
if (keypath != NULL)
errx(1, "-V and -k are mutually exclusive");
if (outpath != NULL)
errx(1, "-V and -o are mutually exclusive");
} else {
if (certpath == NULL)
errx(1, "-c option is mandatory");
if (keypath == NULL)
errx(1, "-k option is mandatory");
if (outpath == NULL)
errx(1, "-o option is mandatory");
}
inpath = argv[0];
OPENSSL_config(NULL);
ERR_load_crypto_strings();
OpenSSL_add_all_algorithms();
error = pipe(pipefds);
if (error != 0)
err(1, "pipe");
pid = fork();
if (pid < 0)
err(1, "fork");
if (pid == 0)
return (child(inpath, outpath, pipefds[1], Vflag, vflag));
if (!Vflag) {
certfp = checked_fopen(certpath, "r");
cert = PEM_read_X509(certfp, NULL, NULL, NULL);
if (cert == NULL) {
ERR_print_errors_fp(stderr);
errx(1, "failed to load certificate from %s", certpath);
}
keyfp = checked_fopen(keypath, "r");
key = PEM_read_PrivateKey(keyfp, NULL, NULL, NULL);
if (key == NULL) {
ERR_print_errors_fp(stderr);
errx(1, "failed to load private key from %s", keypath);
}
sign(cert, key, pipefds[0]);
}
return (wait_for_child(pid));
}
static void
process_init_file(const char *filename, const char *prefix_str)
{
/*
** The strings that are supposed to be followed by other information
** (INIT, REQUIRED_INIT, and REQUIRED_FINAL) should end with
** the space that separates the keyword from the following data.
** The string that is not supposed to be following by other information
** (ENDINIT) should not have a following space, since elds_to_erlang.m
** does not add that space.
*/
const char * const init_str = "INIT ";
const char * const reqinit_str = "REQUIRED_INIT ";
const char * const reqfinal_str = "REQUIRED_FINAL ";
const char * const envvar_str = "ENVVAR ";
const char * const endinit_str = "ENDINIT";
const size_t prefix_strlen = strlen(prefix_str);
const size_t init_strlen = strlen(init_str);
const size_t reqinit_strlen = strlen(reqinit_str);
const size_t reqfinal_strlen = strlen(reqfinal_str);
const size_t envvar_strlen = strlen(envvar_str);
const size_t endinit_strlen = strlen(endinit_str);
char line0[MAXLINE];
char * line;
size_t len;
FILE *erl_file;
erl_file = fopen(filename, "r");
if (erl_file == NULL) {
fprintf(stderr, "%s: error opening file `%s': %s\n",
MR_progname, filename, strerror(errno));
num_errors++;
return;
}
while (get_line(erl_file, line0, MAXLINE) > 0) {
if (strncmp(line0, prefix_str, prefix_strlen) != 0) {
continue;
}
line = line0 + prefix_strlen;
/* Remove trailing whitespace. */
len = strlen(line);
while (len > 0 && isspace((int)line[len - 1])) {
line[len - 1] = '\0';
len--;
}
if (strncmp(line, init_str, init_strlen) == 0) {
char *func_name;
size_t func_name_len;
func_name = line + init_strlen;
func_name_len = strlen(func_name);
func_name[func_name_len - 4] = '\0';
MR_ensure_room_for_next(std_module, const char *,
MR_INIT_STD_MODULE_SIZE);
std_modules[std_module_next] = checked_strdup(func_name);
std_module_next++;
} else if (strncmp(line, reqinit_str, reqinit_strlen) == 0) {
char *func_name;
func_name = line + reqinit_strlen;
MR_ensure_room_for_next(req_init_module, const char *,
MR_INIT_REQ_MODULE_SIZE);
req_init_modules[req_init_module_next] = checked_strdup(func_name);
req_init_module_next++;
} else if (strncmp(line, reqfinal_str, reqfinal_strlen) == 0) {
char *func_name;
func_name = line + reqfinal_strlen;
MR_ensure_room_for_next(req_final_module, const char *,
MR_FINAL_REQ_MODULE_SIZE);
req_final_modules[req_final_module_next] =
checked_strdup(func_name);
req_final_module_next++;
} else if (strncmp(line, envvar_str, envvar_strlen) == 0) {
char *envvar_name;
int i;
MR_bool found;
envvar_name = line + envvar_strlen;
/*
** Since the number of distinct environment variables used by
** a program is likely to be in the single digits, linear search
** should be efficient enough.
*/
found = MR_FALSE;
for (i = 0; i < mercury_env_var_next; i++) {
if (strcmp(envvar_name, mercury_env_vars[i]) == 0) {
found = MR_TRUE;
break;
}
}
if (!found) {
MR_ensure_room_for_next(mercury_env_var, const char *,
MR_ENV_VAR_LIST_SIZE);
mercury_env_vars[mercury_env_var_next] =
checked_strdup(envvar_name);
mercury_env_var_next++;
}
} else if (strncmp(line, endinit_str, endinit_strlen) == 0) {
break;
}
}
fclose(erl_file);
}
void syntax(string filename) {
S_token_stack t_stack = checked_malloc( sizeof *t_stack );
t_stack->size = 0;
for(int i=0; i<STACK_SIZE; i++) t_stack->contents[i] = NULL;
S_state_stack s_stack = checked_malloc( sizeof *s_stack );
s_stack->size = 0;
for(int i=0; i<STACK_SIZE; i++) s_stack->contents[i] = -1;
//stack_push(t_stack, getToken(token_find_id("$")));
stack_push(s_stack, 0);
assert(start(filename));
int state = -1;
S_token token = NULL;
act_type act = -1;
int act_num = -1;
token = getToken(token_lex());
while( TRUE ) {
state = stack_top(s_stack);
act_num = action_table[state]->actions[token->id];
act = action_table[state]->type[token->id];
if( SHIFT == act ) {
stack_push(s_stack, act_num);
stack_push(t_stack, token);
token = getToken(token_lex());
// printf("New TOKEN: %s\n", tokens_text[token->id]);
// if(token->type == S_IDENTIFIER) {
// printf("NAME: %s\n\n", token->val->s);
// }
// else {
// printf("\n");
// }
}
else if( REDUCE == act ) {
S_token head_token = getToken(rules[act_num]->head_token_nr); // new token, the target
/* do semantic action here */
// printf("Token is :%s\n", tokens_text[token->id]);
printf("Reduce by rule %d : %s\n", act_num, rules_text[act_num]);
// "primary_expression: IDENTIFIER ", symref
if( 1 == act_num ) {
//head_token->ast = (E_ast)E_newstr(E_SYM_REF, val->s );
head_token->ast = E_newast(E_SYM_REF, NULL, NULL);
head_token->ast->s = checked_strdup(val->s);
}
// "primary_expression: CONSTANT ", numval
if( 2 == act_num ) {
// head_token->ast = (E_ast)E_newnum(E_NUM, val->s, val->num_t);
head_token->ast = E_newast(E_NUM, NULL, NULL);
head_token->ast->s = checked_strdup( val->s );
head_token->ast->num_t = val->num_t;
}
// "primary_expression: STRING_LITERAL ", strval
if( 3 == act_num ) {
// head_token->ast = (E_ast)E_newstr(E_STRING, val->s);
head_token->ast = E_newast(E_STRING, NULL, NULL);
head_token->ast->s = checked_strdup( val->s );
}
// "postfix_expression: primary_expression ",
if( 5 == act_num ) {
head_token->ast = $(1)->ast;
}
// "postfix_expression: postfix_expression [ expression ] ", E_ARRAY_REF
if( 6 == act_num ) {
head_token->ast = E_newast(E_ARRAY_REF, $(4)->ast, $(2)->ast);
}
// "postfix_expression: postfix_expression ( argument_expression_list ) ", E_FUNC_REF
if( 8 == act_num ) {
head_token->ast = E_newast(E_FUNC_REF, $(4)->ast, $(2)->ast);
}
// "postfix_expression: postfix_expression INC_OP ",
if( 11 == act_num ) {
assert($(2)->ast != NULL);
head_token->ast = E_newast(E_INC_OP, $(2)->ast, NULL);
}
// "argument_expression_list: assignment_expression ",
if( 15 == act_num ) {
head_token->ast = E_newast(E_ARG_END, $(1)->ast, NULL);
}
// "argument_expression_list: argument_expression_list , assignment_expression ",
if( 16 == act_num ) {
printf("list.\n");
head_token->ast = E_newast(E_ARG_LIST, $(3)->ast, $(1)->ast); // TODO is this ok? direction?
//head_token->ast = E_newast();
}
// "unary_expression: postfix_expression ",
if( 17 == act_num ) {
//TODO make new node for processing
head_token->ast = $(1)->ast;
}
// "unary_expression: unary_operator cast_expression ",
if( 20 == act_num ) {
head_token->ast = E_newast(E_UNARY_EXP, $(2)->ast, $(1)->ast);
}
// "unary_operator: & ",
if( 21 == act_num ) {
head_token->ast = E_newast(E_TAKE_ADDR, NULL, NULL);
}
// "cast_expression: unary_expression ",
if( 27 == act_num ) {
head_token->ast = $(1)->ast;
}
// "multiplicative_expression: cast_expression ",
if( 29 == act_num ) {
head_token->ast = $(1)->ast;
}
// "multiplicative_expression: multiplicative_expression * cast_expression ",
if( 30 == act_num ) {
head_token->ast = E_newast(E_MUL, $(3)->ast, $(1)->ast);
}
// "multiplicative_expression: multiplicative_expression / cast_expression ",
if( 31 == act_num ) {
head_token->ast = E_newast(E_DIV, $(3)->ast, $(1)->ast);
}
// "additive_expression: multiplicative_expression ",
if( 33 == act_num ) {
head_token->ast = $(1)->ast;
}
// "additive_expression: additive_expression + multiplicative_expression ",
if( 34 == act_num ) {
head_token->ast = E_newast(E_ADD, $(3)->ast, $(1)->ast);
// head_token->ast->pending = TRUE;
}
// "additive_expression: additive_expression - multiplicative_expression ",
if( 35 == act_num ) {
head_token->ast = E_newast(E_MINUS, $(3)->ast, $(1)->ast);
}
// "shift_expression: additive_expression ",
if( 36 == act_num ) {
head_token->ast = $(1)->ast;
}
// "relational_expression: shift_expression ",
if( 39 == act_num ) {
head_token->ast = $(1)->ast;
}
// "relational_expression: relational_expression < shift_expression ",
if( 40 == act_num ) {
head_token->ast = E_newast(E_REL_L, $(3)->ast, $(1)->ast);
}
// "relational_expression: relational_expression GE_OP shift_expression ",
if( 43 == act_num ) {
head_token->ast = E_newast(E_REL_GE, $(3)->ast, $(1)->ast);
}
// "equality_expression: relational_expression ",
if( 44 == act_num ) {
head_token->ast = $(1)->ast;
}
// "and_expression: equality_expression ",
if( 47 == act_num ) {
head_token->ast = $(1)->ast;
}
// "exclusive_or_expression: and_expression ",
if( 49 == act_num ) {
head_token->ast = $(1)->ast;
}
// "inclusive_or_expression: exclusive_or_expression ",
if( 51 == act_num ) {
head_token->ast = $(1)->ast;
}
// "logical_and_expression: inclusive_or_expression ",
if( 53 == act_num ) {
head_token->ast = $(1)->ast;
}
// "logical_or_expression: logical_and_expression ",
if( 55 == act_num ) {
head_token->ast = $(1)->ast;
}
// "conditional_expression: logical_or_expression ",
if( 57 == act_num ) {
head_token->ast = $(1)->ast;
}
// "assignment_expression: conditional_expression ",
if( 59 == act_num ) {
head_token->ast = $(1)->ast;
}
// "assignment_expression: unary_expression assignment_operator assignment_expression ",
if( 60 == act_num ) {
head_token->ast = E_newast($(2)->ast->type, $(3)->ast, $(1)->ast);
}
// "assignment_operator: = ",
if( 61 == act_num ) {
// head_token->ast = E_newsinglet(E_ASSIGN_EQL);
head_token->ast = E_newast(E_ASSIGN_EQL, NULL, NULL);
}
// "expression: assignment_expression ",
if( 71 == act_num ) {
head_token->ast = $(1)->ast;
}
// "declaration_specifiers: type_specifier ",
if( 74 == act_num ) {
head_token->ast = $(1)->ast;
}
// "declaration: declaration_specifiers init_declarator_list ; ",
if( 77 == act_num ) {
head_token->ast = E_newast(E_DECLARATION, $(3)->ast, $(2)->ast);
}
// "init_declarator_list: init_declarator ",
if( 78 == act_num ) {
head_token->ast = $(1)->ast;
}
// "init_declarator_list: init_declarator_list , init_declarator ",
if( 79 == act_num ) {
}
// "init_declarator: declarator ",
if( 80 == act_num ) {
//TODO make new node for processing
head_token->ast = $(1)->ast;
}
// "init_declarator: declarator = initializer ",
if( 81 == act_num ) {
head_token->ast = E_newast(E_INIT_DECL, $(3)->ast, $(1)->ast);
}
// "type_specifier: INT ",
if( 82 == act_num ) {
head_token->ast = E_newast(E_SPEC, NULL, NULL);
head_token->ast->m.ch = 0;
head_token->ast->m.bit.b_int = 1;
// head_token->ast = E_newspec(E_SPEC);
// ((E_spec)(head_token->ast))->m.bit.b_int = 1;
// head_token->id = ;
// head_token->val
}
// "type_specifier: FLOAT ",
if( 83 == act_num ) { //TODO do real float
head_token->ast = E_newast(E_SPEC, NULL, NULL);
head_token->ast->m.ch = 0;
head_token->ast->m.bit.b_int = 1;
}
// "declarator: direct_declarator ",
if( 84 == act_num ) {
head_token->ast = E_newast(E_DECLAR_STORAGE, $(1)->ast, NULL);
}
// "direct_declarator: IDENTIFIER ",
if( 85 == act_num ) {
// head_token->ast = (E_ast)E_newstr(E_SYM, val->s);
head_token->ast = E_newast(E_SYM, NULL, NULL);
head_token->ast->s = checked_strdup( val->s );
printf("new id: %s\n", val->s);
//assert(0);
}
// "direct_declarator: direct_declarator [ assignment_expression ] ", // E_ARRAY
if( 87 == act_num ) {
head_token->ast = E_newast(E_ARRAY_BODY, $(4)->ast, $(2)->ast);
// head_token->ast->pending = TRUE;
}
// "direct_declarator: direct_declarator ( parameter_type_list ) ",
if( 90 == act_num ) {
head_token->ast = E_newast(E_FUNC_BODY, $(4)->ast, $(2)->ast);
// $(4)->ast->isfunc = TRUE;
// head_token->ast->pending = TRUE;
}
// "direct_declarator: direct_declarator ( ) ",
if( 92 == act_num ) {
head_token->ast = $(3)->ast;
// head_token->ast = E_newast(E_DECLAR_LIST, $(3)->ast, NULL);
}
// "parameter_type_list: parameter_list ",
if( 93 == act_num ) {
head_token->ast = $(1)->ast;
}
// "parameter_list: parameter_declaration ",
if( 95 == act_num ) {
head_token->ast = $(1)->ast;
}
// "parameter_list: parameter_list , parameter_declaration ",
if( 96 == act_num ) {
assert(0);
}
// "parameter_declaration: declaration_specifiers declarator ",
if( 97 == act_num ) {
assert(0);
}
// "initializer: assignment_expression ",
if( 114 == act_num ) {
head_token->ast = $(1)->ast;
}
// "initializer: { initializer_list } ",
if( 115 == act_num ) {
head_token->ast = $(2)->ast;
}
// "initializer_list: initializer ",
if( 117 == act_num ) {
head_token->ast = E_newast(E_INIT_VAL_LIST, NULL, $(1)->ast);
}
// "initializer_list: initializer_list , initializer ",
if( 119 == act_num ) {
head_token->ast = E_newast(E_INIT_VAL_LIST, $(3)->ast, $(1)->ast);
}
// "statement: compound_statement ",
if( 126 == act_num ) {
head_token->ast = $(1)->ast;
}
// "statement: expression_statement ",
if( 127 == act_num ) {
head_token->ast = $(1)->ast;
}
// "statement: selection_statement ",
if( 128 == act_num ) {
head_token->ast = $(1)->ast;
}
// "statement: iteration_statement ",
if( 129 == act_num ) {
head_token->ast = $(1)->ast;
}
// "statement: jump_statement ",
if( 130 == act_num ) {
head_token->ast = $(1)->ast;
}
// "compound_statement: { block_item_list } ",
if( 132 == act_num ) {
head_token->ast = $(2)->ast;
}
// "block_item_list: block_item ",
if( 133 == act_num ) {
head_token->ast = $(1)->ast;
}
// "block_item_list: block_item_list block_item ",
if( 134 == act_num ) {
head_token->ast = (E_ast)E_newast(E_BLK_ITM_LIST, $(2)->ast, $(1)->ast);
}
// "block_item: declaration ",
if( 135 == act_num ) {
head_token->ast = $(1)->ast;
}
// "block_item: statement ",
if( 136 == act_num ) {
head_token->ast = $(1)->ast;
}
// "expression_statement: expression ; ",
if( 138 == act_num ) {
head_token->ast = $(2)->ast;
}
// "selection_statement: IF ( expression ) statement ELSE statement ",
if( 140 == act_num ) {
head_token->ast = E_newast(E_CONT_IF, NULL, NULL);
head_token->ast->bool_exp = $(5)->ast;
head_token->ast->true_stat = $(3)->ast;
head_token->ast->false_stat = $(1)->ast;
}
// "iteration_statement: FOR ( expression_statement expression_statement expression ) statement ",
if( 144 == act_num ) {
head_token->ast = E_newast(E_CONT_FOR, NULL, NULL);
head_token->ast->init_stat = $(5)->ast;
head_token->ast->bool_exp = $(4)->ast;
head_token->ast->step_state = $(3)->ast;
head_token->ast->ast = $(1)->ast;
}
// "jump_statement: RETURN expression ; ",
if( 149 == act_num ) {
head_token->ast = E_newast(E_RET, $(3)->ast, NULL);
}
// "translation_unit: external_declaration ",
if( 150 == act_num ) {
// assert($(1));
head_token->ast = $(1)->ast;
}
// "translation_unit: translation_unit external_declaration ",
if( 151 == act_num ) {
assert(0);
}
// "external_declaration: function_definition ",
if( 152 == act_num ) {
assert( $(1) );
head_token->ast = $(1)->ast;
}
// "function_definition: declaration_specifiers declarator compound_statement ",
if( 155 == act_num ) {
// head_token->ast = E_newast(E_FUNC, $(3)->ast, $(2)->ast, $(1)->ast);
head_token->ast = E_newast(E_FUNC, NULL, NULL);
head_token->ast->spcifiers = $(3)->ast;
head_token->ast->declarator = $(2)->ast;
head_token->ast->ast = $(1)->ast;
}
/* end */
/*** clear up ***/
C_token_list head = NULL;
for( head = rules[act_num]->list; head; head = head->next ) {
stack_pop(t_stack);
stack_pop(s_stack);
}
state = stack_top(s_stack);
act_num = action_table[state]->actions[head_token->id];
act = action_table[state]->type[head_token->id];
assert( GOTO == act );
assert(head_token->ast);
stack_push(t_stack, head_token);
stack_push(s_stack, act_num);
}
else if( ACC == act ) {
assert( $(1) );
S_token s = checked_malloc( sizeof *s );
s->ast = $(1)->ast;
/*** translate begins ***/
assert( NULL == E_lookup("printf") && NULL == E_lookup("scanf") );
E_symbol sym = E_install("printf");
sym->addr = sym->name;
sym = E_install("scanf");
sym->addr = sym->name;
translate(s->ast);
// printf("body is here: \n%s", s->ast->code);
string result = checked_malloc( strlen($(1)->ast->code) + 500);
sprintf( result, "\t.file \"simple1.c\"\n"
"\t.text\n"
"%s"
"\t.ident \"GCC: (Ubuntu/Linaro 4.6.3-1ubuntu5) 4.6.3\"\n"
"\t.section\t.note.GNU-stack,\"\",@progbits\n" , s->ast->code);
printf("LAST !!!\n");
printf("%s", result);
FILE * file_out = fopen("result.s", "w");
fprintf(file_out, "%s", result);
fclose(file_out);
printf("Yahoo!!!\n");
return;
}
else {
if( GOTO == act ) assert(0); // strange
if( ERROR == act ) {
printf("STATE: %d\n", stack_top(s_stack));
printf("Token is: %s\n", tokens_text[stack_top(t_stack)->id]);
assert(0); // Ooops
}
assert(0); // WTF?
}
}
/**
*lex的值出来了之后，建立一个相应的S_token，这个作为堆栈里的符号
*状态栈里面压的是数字， 然后根据状态栈里的东西，选择action表的项目
*/
}
void process_arguments(int argc, char** argv, struct program_options* options)
{
/*
* Usage: progname [-h hostname] [-p port] [-t port] ssh_hostname ssh_port
*
* Options:
* -h hostname
* sets proxy_host : hostname of both the SOCKS5 proxy *and* the ssh-tunneld process
* -p port
* sets proxy_port : port for the SOCKS5 proxy
* -t port
* sets tun_port : port for the ssh-tunneld process
*
* ssh_hostname and ssh_port are set from the remaining values of argv after option
* processing has completed. These must always be present.
*/
int opt;
int set_proxy_host = 0;
int set_proxy_port = 0;
int set_tun_port = 0;
while ((opt = getopt(argc, argv, "h:p:t:")) != -1)
{
switch (opt)
{
case 'h':
/* Set proxy host */
if (! set_proxy_host)
{
options->proxy_host = optarg;
set_proxy_host = 1;
}
break;
case 'p':
if (! set_proxy_port)
{
options->proxy_port = optarg;
set_proxy_port = 1;
}
break;
case 't':
if (! set_tun_port)
{
options->tunnel_port = optarg;
set_tun_port = 1;
}
break;
default:
print_usage(argv[0]);
exit(EXIT_FAILURE);
break;
}
}
if (optind + 2 > argc)
{
print_usage(argv[0]);
exit(EXIT_FAILURE);
}
/* The remaining options should now be the ssh host and port */
options->remote_host = argv[optind];
options->remote_port = argv[optind+1];
/* And set default values if we didn't receive them from the options */
if (! set_proxy_host)
{
char* default_proxy_host = "127.0.0.1";
options->proxy_host = checked_strdup(default_proxy_host);
}
if (! set_proxy_port)
{
char* default_proxy_port = "1080";
options->proxy_port = checked_strdup(default_proxy_port);
}
if (! set_tun_port)
{
char* default_tun_port = "1081";
options->tunnel_port = checked_strdup(default_tun_port);
}
}
int
main(int argc, char **argv)
{
int i;
int opt;
int threads = -1;
int cpu;
char *needle = NULL;
char *dir = NULL;
struct kmp_table table;
struct queue q;
struct produce_arg parg;
struct consume_arg carg;
pthread_t producer;
pthread_t *consumers;
while ((opt = getopt(argc, argv, "n:s:d:")) != -1) {
switch (opt) {
case 'n':
threads = atoi(optarg);
break;
case 's':
needle = checked_strdup(optarg);
break;
case 'd':
dir = checked_strdup(optarg);
break;
case '?':
default:
usage(argv[0]);
return (1);
}
}
if (!needle || strlen(needle) <= 0) {
usage(argv[0]);
return (1);
}
if (!dir) {
dir = checked_malloc(sizeof (char) * 2);
dir[0] = '.';
dir[1] = 0;
}
if (threads <= 0) {
cpu = sysconf(_SC_NPROCESSORS_ONLN);
if (cpu <= 1) {
threads = 1;
} else if (cpu >= 20) {
threads = 20;
} else {
threads = cpu;
}
}
alloc_table(&table, needle);
fill_table(&table);
alloc_queue(&q, INITIAL_CAPACITY);
parg.q = &q;
parg.path = dir;
parg.consumer_count = threads;
carg.q = &q;
carg.t = &table;
consumers = checked_malloc(sizeof (pthread_t) * threads);
checked_thread_create(&producer, NULL, &produce, &parg);
for (i = 0; i < threads; i++) {
checked_thread_create(consumers + i, NULL, &consume, &carg);
}
checked_thread_join(producer, NULL);
for (i = 0; i < threads; i++) {
checked_thread_join(consumers[i], NULL);
}
free_queue(&q);
free_table(&table);
free(consumers);
free(needle);
free(dir);
return (0);
}
