int
main (int argc, char *argv[])
{
ret_t ret;
http2d_server_t srv;
http2d_init();
ret = process_parameters (argc, argv);
if (ret != ret_ok)
return EXIT_ERROR;
http2d_trace_init();
ret = http2d_server_init (&srv);
if (ret != ret_ok)
return EXIT_ERROR;
ret = http2d_server_read_conf (&srv, &config_file);
if (ret != ret_ok)
return EXIT_ERROR;
ret = http2d_server_initialize (&srv);
if (ret != ret_ok)
return EXIT_ERROR;
http2d_server_run (&srv);
SHOULDNT_HAPPEN;
return EXIT_OK;
}
/* The main program. */
int main (int argc, char **argv) {
identify_program(argc, argv);
process_options(argc, argv);
process_parameters(argc, argv);
assign_defaults();
compose_tunes();
monitor_locks(foreground_task, poll_interval);
}
int
main (int argc, char **argv)
{
ret_t ret;
struct sigaction act;
ret = check_for_python();
if (ret != ret_ok) {
PRINT_MSG ("ERROR: Couldn't find python.\n");
exit (EXIT_ERROR);
}
/* Signal handling */
act.sa_handler = SIG_IGN;
sigaction (SIGPIPE, &act, NULL);
memset(&act, 0, sizeof(act));
act.sa_sigaction = signals_handler;
act.sa_flags = SA_SIGINFO;
sigaction (SIGCHLD, &act, NULL);
sigaction (SIGINT, &act, NULL);
sigaction (SIGTERM, &act, NULL);
/* Initialize the embedded server */
cherokee_init();
cherokee_spawner_set_active (false);
process_parameters (argc, argv);
ret = cherokee_server_new (&srv);
if (ret != ret_ok)
exit (EXIT_ERROR);
ret = config_server (srv);
if (ret != ret_ok)
exit (EXIT_ERROR);
ret = cherokee_server_initialize (srv);
if (ret != ret_ok)
exit (EXIT_ERROR);
print_connection_info();
ret = cherokee_server_unlock_threads (srv);
if (ret != ret_ok)
exit (EXIT_ERROR);
do {
ret = cherokee_server_step (srv);
} while (ret == ret_eagain);
cherokee_server_stop (srv);
cherokee_server_free (srv);
cherokee_mrproper();
return EXIT_OK;
}
int
main (int argc, char **argv)
{
ret_t ret;
config_file = strdup (DEFAULT_CONFIG_FILE);
if (config_file == NULL) {
PRINT_MSG ("ERROR: Couldn't allocate memory.\n");
exit (EXIT_ERROR);
}
cherokee_init();
ret = cherokee_server_new (&srv);
if (ret < ret_ok) {
exit (EXIT_ERROR_FATAL);
}
ret = process_parameters (argc, argv);
if (ret != ret_ok) {
exit (EXIT_ERROR_FATAL);
}
if (print_modules) {
cherokee_info_build_print (srv);
exit (EXIT_OK_ONCE);
}
if (just_test) {
ret = test_configuration_file();
if (ret != ret_ok) {
exit (EXIT_ERROR);
}
exit (EXIT_OK_ONCE);
}
ret = common_server_initialization (srv);
if (ret < ret_ok) {
exit (EXIT_ERROR_FATAL);
}
do {
ret = cherokee_server_step (srv);
} while (ret == ret_eagain);
cherokee_server_stop (srv);
cherokee_server_free (srv);
free (config_file);
cherokee_mrproper();
return EXIT_OK;
}
int
main(int argc, char **argv)
{
BCPPARAMDATA params;
DBPROCESS *dbsrc;
DBPROCESS *dbtarget;
setlocale(LC_ALL, "");
memset(¶ms, '\0', sizeof(params));
if (process_parameters(argc, argv, ¶ms) == FALSE) {
pusage();
return 1;
}
if (login_to_databases(¶ms, &dbsrc, &dbtarget) == FALSE)
return 1;
if (params.cflag) {
if (create_target_table(params.src.dbobject, params.owner, params.dest.dbobject, dbsrc, dbtarget) == FALSE) {
printf("datacopy: could not create target table %s.%s . terminating\n", params.owner, params.dest.dbobject);
dbclose(dbsrc);
dbclose(dbtarget);
return 1;
}
}
if (check_table_structures(params.src.dbobject, params.dest.dbobject, dbsrc, dbtarget) == FALSE) {
printf("datacopy: table structures do not match. terminating\n");
dbclose(dbsrc);
dbclose(dbtarget);
return 1;
}
if (transfer_data(params, dbsrc, dbtarget) == FALSE) {
printf("datacopy: table copy failed.\n");
printf(" the data may have been partially copied into the target database \n");
dbclose(dbsrc);
dbclose(dbtarget);
return 1;
}
dbclose(dbsrc);
dbclose(dbtarget);
return 0;
}
int
main (int argc, char **argv)
{
ret_t ret;
cherokee_init();
ret = cherokee_server_new (&srv);
if (ret < ret_ok) return 1;
ret = process_parameters (argc, argv);
if (ret != ret_ok)
exit (EXIT_OK_ONCE);
if (print_modules) {
cherokee_info_build_print (srv);
exit (EXIT_OK_ONCE);
}
if (just_test) {
ret = test_configuration_file();
if (ret != ret_ok)
exit(EXIT_ERROR);
exit (EXIT_OK_ONCE);
}
ret = common_server_initialization (srv);
if (ret < ret_ok) return 2;
do {
ret = cherokee_server_step (srv);
} while (ret == ret_eagain);
cherokee_server_stop (srv);
cherokee_server_free (srv);
if (config_file)
free (config_file);
cherokee_mrproper();
return EXIT_OK;
}
int
main (int argc, char **argv)
{
unsigned int mapfile_fd;
hash_node **hashtable;
char reverse_mode;
if (hash_initialize(&hashtable) == ACRELCONVERT_FUNC_ERROR)
exit(EXIT_FAILURE);
if (process_parameters(argc, argv, &reverse_mode) == ACRELCONVERT_FUNC_ERROR)
exit(EXIT_FAILURE);
if ((mapfile_fd = open(argv[2], 0)) == -1) {
fprintf(stderr, "Fatal error while opening map file \"%s\"\n", argv[2]);
exit(EXIT_FAILURE);
}
if (process_map_file(mapfile_fd, hashtable, reverse_mode) == ACRELCONVERT_FUNC_ERROR)
{
close(mapfile_fd);
exit(EXIT_FAILURE);
}
close(mapfile_fd);
if (process_elf(argv[3], hashtable) == ACRELCONVERT_FUNC_ERROR)
{
hash_delete (&hashtable);
exit(EXIT_FAILURE);
}
hash_delete (&hashtable);
exit(EXIT_SUCCESS);
}
/*
main
*/
int main(int argc, char **args)
{
OMXCLIENT client;
OMX_ERRORTYPE omxError;
OMX_U32 *variance_array;
OMX_U32 variance_array_len;
memset(¶meters, 0, sizeof(OMXDECODER_PARAMETERS));
arg_count = argc;
arguments = args;
parameters.buffer_size = 0; //640 * 480 * 3 / 2;
parameters.buffer_count = 3;
omxError = process_parameters(argc, args, ¶meters);
if(omxError != OMX_ErrorNone)
{
print_usage(args[0]);
return omxError;
}
variance_array_len = 0;
variance_array = 0;
if(parameters.varfile &&
(omxError =
omxclient_read_variance_file(&variance_array, &variance_array_len,
parameters.varfile)) != OMX_ErrorNone)
{
return omxError;
}
omxError = OMX_Init();
if(omxError == OMX_ErrorNone)
{
if(parameters.jpeg_input)
{
omxError =
omxclient_component_create(&client,
"OMX.hantro.7190.image.decoder",
"image_decoder.jpeg",
parameters.buffer_count);
}
else
{
omxError =
omxclient_component_create(&client,
"OMX.hantro.7190.video.decoder",
"video_decoder.h263",
parameters.buffer_count);
}
client.store_buffers = parameters.splitted_output;
client.output_name = parameters.outfile;
if(omxError == OMX_ErrorNone)
{
omxError = omxclient_check_component_version(client.component);
}
else
{
OMX_OSAL_Trace(OMX_OSAL_TRACE_ERROR,
"Component creation failed: '%s'\n",
OMX_OSAL_TraceErrorStr(omxError));
}
if(omxError == OMX_ErrorNone)
{
if(parameters.jpeg_input)
omxError =
omxclient_component_initialize_jpeg(&client,
&omx_decoder_port_initialize);
else
omxError =
omxclient_component_initialize(&client,
&omx_decoder_port_initialize);
if(omxError == OMX_ErrorNone)
{
omxError =
omxlclient_initialize_buffers_fixed(&client,
parameters.buffer_size,
parameters.
buffer_count);
/* re-allocation of buffers after this is not properly defined, can't rely on port
* configuration */
/* omxError = omxlclient_initialize_buffers(&client); */
}
/* set rotation */
if(parameters.rotation != 0)
{
OMX_CONFIG_ROTATIONTYPE rotation;
omxclient_struct_init(&rotation, OMX_CONFIG_ROTATIONTYPE);
rotation.nPortIndex = 1;
rotation.nRotation = parameters.rotation;
if((omxError =
OMX_SetConfig(client.component, OMX_IndexConfigCommonRotate,
&rotation)) != OMX_ErrorNone)
{
OMX_OSAL_Trace(OMX_OSAL_TRACE_ERROR,
"Rotation could not be set: %s\n",
OMX_OSAL_TraceErrorStr(omxError));
return omxError;
}
}
/* set mirroring */
if(parameters.mirror != OMX_MirrorMax)
{
OMX_CONFIG_MIRRORTYPE mirror;
omxclient_struct_init(&mirror, OMX_CONFIG_MIRRORTYPE);
mirror.nPortIndex = 1;
mirror.eMirror = parameters.mirror;
if((omxError =
OMX_SetConfig(client.component, OMX_IndexConfigCommonMirror,
&mirror)) != OMX_ErrorNone)
{
OMX_OSAL_Trace(OMX_OSAL_TRACE_ERROR,
"Mirroring could not be set: %s\n",
OMX_OSAL_TraceErrorStr(omxError));
return omxError;
}
}
if(omxError == OMX_ErrorNone)
{
/* disable post-processor port */
omxError =
OMX_SendCommand(client.component, OMX_CommandPortDisable, 2,
NULL);
if(omxError != OMX_ErrorNone)
{
return omxError;
}
/* execute conversion */
if(parameters.rcv_input)
omxError =
omxclient_execute_rcv(&client, parameters.infile,
parameters.outfile);
else
omxError =
omxclient_execute(&client, parameters.infile,
variance_array, variance_array_len,
parameters.outfile);
if(omxError != OMX_ErrorNone)
{
OMX_OSAL_Trace(OMX_OSAL_TRACE_ERROR,
"Video processing failed: '%s'\n",
OMX_OSAL_TraceErrorStr(omxError));
}
}
else
{
OMX_OSAL_Trace(OMX_OSAL_TRACE_ERROR,
"Component video initialization failed: '%s'\n",
OMX_OSAL_TraceErrorStr(omxError));
}
/* destroy the component since it was succesfully created */
omxError = omxclient_component_destroy(&client);
if(omxError != OMX_ErrorNone)
{
OMX_OSAL_Trace(OMX_OSAL_TRACE_ERROR,
"Component destroy failed: '%s'\n",
OMX_OSAL_TraceErrorStr(omxError));
}
}
OMX_Deinit();
}
else
{
OMX_OSAL_Trace(OMX_OSAL_TRACE_ERROR,
"OMX initialization failed: '%s'\n",
OMX_OSAL_TraceErrorStr(omxError));
/* FAIL: OMX initialization failed, reason */
}
return omxError;
}
void process_line(struct ast_node_line* line)
{
struct instruction_mapping* insttype;
struct process_parameters_results ppresults;
struct process_parameter_results dparam;
struct ast_node_parameter* dcurrent;
uint32_t dchrproc;
uint16_t i, flimit, fchar, opos;
// Change depending on the type of line.
switch (line->type)
{
case type_keyword:
switch (line->keyword)
{
case BOUNDARY:
fprintf(stderr, ".BOUNDARY");
// Emit safety boundary of 16 NULL words.
for (i = 0; i < 16; i += 1)
aout_emit(aout_create_raw(0));
break;
case FILL:
fprintf(stderr, ".FILL");
// Emit N words with value X
flimit = expr_evaluate(line->keyword_data_expr_1, &ahalt_label_resolution_not_permitted, &ahalt_expression_exit_handler);
fchar = expr_evaluate(line->keyword_data_expr_2, &ahalt_label_resolution_not_permitted, &ahalt_expression_exit_handler);
for (i = 0; i < flimit; i++)
aout_emit(aout_create_raw(fchar));
break;
case EXTENSION:
fprintf(stderr, ".EXTENSION %s", line->keyword_data_string);
// Emit extension metadata.
aout_emit(aout_create_metadata_extension(bstr2cstr(line->keyword_data_string, '0')));
break;
case INCBIN:
fprintf(stderr, ".INCBIN %s", line->keyword_data_string);
// Emit binary include metadata.
aout_emit(aout_create_metadata_incbin(bstr2cstr(line->keyword_data_string, '0')));
break;
case ORIGIN:
opos = expr_evaluate(line->keyword_data_expr_1, &ahalt_label_resolution_not_permitted, &ahalt_expression_exit_handler);
fprintf(stderr, ".ORIGIN 0x%04X", opos);
// Emit origin set metadata.
aout_emit(aout_create_metadata_origin(opos));
break;
case EXPORT:
fprintf(stderr, ".EXPORT %s", line->keyword_data_string);
// Emit export metadata.
aout_emit(aout_create_metadata_export(bstr2cstr(line->keyword_data_string, '0')));
break;
case IMPORT:
fprintf(stderr, ".IMPORT %s", line->keyword_data_string);
// Emit export metadata.
aout_emit(aout_create_metadata_import(bstr2cstr(line->keyword_data_string, '0')));
break;
default:
fprintf(stderr, "\n");
ahalt(ERR_UNSUPPORTED_KEYWORD, NULL);
}
fprintf(stderr, "\n");
break;
case type_instruction:
// Check to see if this is DAT.
if (strcmp(line->instruction->instruction, "DAT") == 0)
{
// Handle data.
fprintf(stderr, "EMIT DAT");
// Process parameters as data.
reverse_parameters(line->instruction->parameters);
dcurrent = line->instruction->parameters->last;
while (dcurrent != NULL)
{
// Process parameter normally.
dparam = process_parameter(dcurrent);
// Output depending on what kind of parameter it was.
if (dparam.v_label != NULL) // If this is a label, output something that we need to replace.
aout_emit(aout_create_expr(expr_new_label(bautofree(bfromcstr(dparam.v_label)))));
else if (dparam.v_raw != NULL) // If the raw field is not null, get each character and output it.
{
fprintf(stderr, " \"%s\"", dparam.v_raw->data);
for (dchrproc = 0; dchrproc < blength(dparam.v_raw); dchrproc++)
aout_emit(aout_create_raw(dparam.v_raw->data[dchrproc]));
}
else if (dparam.v_extra_used == true) // Just a single address.
aout_emit(aout_create_expr(dparam.v_extra));
else // Something that isn't handled by DAT.
{
fprintf(stderr, "\n");
ahalt(ERR_DAT_UNSUPPORTED_PARAMETER, NULL);
}
dcurrent = dcurrent->prev;
}
}
else
{
// Handle instruction.
insttype = get_instruction_by_name(line->instruction->instruction);
if (insttype == NULL)
ahalt(ERR_UNKNOWN_OPCODE, line->instruction->instruction);
fprintf(stderr, "EMIT %s", insttype->name);
// Process parameters normally.
ppresults = process_parameters(line->instruction->parameters);
// Force the parameter value to be NXT if it's a label.
if (ppresults.a_label != NULL) ppresults.a = NXT_LIT;
if (ppresults.b_label != NULL) ppresults.b = NXT_LIT;
if (ppresults.a_label != NULL && ppresults.a_label_bracketed) ppresults.a = NXT;
if (ppresults.b_label != NULL && ppresults.b_label_bracketed) ppresults.b = NXT;
// Output the initial opcode.
if (insttype->opcode != OP_NONBASIC)
aout_emit(aout_create_opcode(insttype->opcode, ppresults.a, ppresults.b));
else
aout_emit(aout_create_opcode(insttype->opcode, insttype->nbopcode, ppresults.a));
// If the parameter is a label or requires an extra word, output them.
if (ppresults.b_label != NULL)
aout_emit(aout_create_expr(expr_new_label(bautofree(bfromcstr(ppresults.b_label)))));
else if (ppresults.b_extra_used)
aout_emit(aout_create_expr(ppresults.b_extra));
if (ppresults.a_label != NULL)
aout_emit(aout_create_expr(expr_new_label(bautofree(bfromcstr(ppresults.a_label)))));
else if (ppresults.a_extra_used)
aout_emit(aout_create_expr(ppresults.a_extra));
}
fprintf(stderr, "\n");
break;
case type_label:
// Handle label definition.
fprintf(stderr, ":%s\n", line->label->name);
aout_emit(aout_create_label(line->label->name));
break;
}
}
void process_line(struct ast_node_line* line)
{
struct instruction_mapping* insttype;
struct process_parameters_results ppresults;
struct process_parameter_results dparam;
struct ast_node_parameter* dcurrent;
uint32_t dchrproc;
uint16_t i, flimit, fchar, opos;
struct aout_byte* result = NULL;
struct dbg_sym* newsym;
// Change depending on the type of line.
switch (line->type)
{
case type_keyword:
switch (line->keyword)
{
case SYMBOL:
printd(LEVEL_VERBOSE, ".SYMBOL %s", bstr2cstr(line->keyword_data_string, '0'));
// Emit debugging symbol.
list_append(&newsyms, dbgfmt_create_symbol(DBGFMT_SYMBOL_STRING, dbgfmt_create_symbol_string(line->keyword_data_string, DBGFMT_UNDETERMINED)));
break;
case SECTION:
printd(LEVEL_VERBOSE, ".SECTION %s", bstr2cstr(line->keyword_data_string, '0'));
// Emit section metadata.
aout_emit(aout_create_metadata_section(bstr2cstr(line->keyword_data_string, '0')));
break;
case OUTPUT:
printd(LEVEL_VERBOSE, ".OUTPUT %s", bstr2cstr(line->keyword_data_string, '0'));
// Emit output metadata.
aout_emit(aout_create_metadata_output(bstr2cstr(line->keyword_data_string, '0')));
break;
case BOUNDARY:
printd(LEVEL_VERBOSE, ".BOUNDARY");
// Emit safety boundary of 16 NULL words.
for (i = 0; i < 16; i += 1)
aout_emit(aout_create_raw(0));
break;
case FILL:
printd(LEVEL_VERBOSE, ".FILL");
if (line->keyword_data_expr_1 == NULL || line->keyword_data_expr_2 == NULL)
{
if (line->keyword_data_string != NULL)
dhalt(ERR_LABEL_RESOLUTION_NOT_PERMITTED, line->keyword_data_string->data);
else
dhalt(ERR_LABEL_RESOLUTION_NOT_PERMITTED, "");
}
// Emit N words with value X
flimit = expr_evaluate(line->keyword_data_expr_1, &dhalt_label_resolution_not_permitted, &dhalt_expression_exit_handler);
fchar = expr_evaluate(line->keyword_data_expr_2, &dhalt_label_resolution_not_permitted, &dhalt_expression_exit_handler);
for (i = 0; i < flimit; i++)
aout_emit(aout_create_raw(fchar));
break;
case EXTENSION:
printd(LEVEL_VERBOSE, ".EXTENSION %s", bstr2cstr(line->keyword_data_string, '0'));
// Emit extension metadata.
aout_emit(aout_create_metadata_extension(bstr2cstr(line->keyword_data_string, '0')));
break;
case INCBIN:
printd(LEVEL_VERBOSE, ".INCBIN %s", bstr2cstr(line->keyword_data_string, '0'));
// Emit binary include metadata.
aout_emit(aout_create_metadata_incbin(bstr2cstr(line->keyword_data_string, '0')));
break;
case ORIGIN:
if (line->keyword_data_expr_1 == NULL)
{
if (line->keyword_data_string != NULL)
dhalt(ERR_LABEL_RESOLUTION_NOT_PERMITTED, line->keyword_data_string->data);
else
dhalt(ERR_LABEL_RESOLUTION_NOT_PERMITTED, "");
}
opos = expr_evaluate(line->keyword_data_expr_1, &dhalt_label_resolution_not_permitted, &dhalt_expression_exit_handler);
printd(LEVEL_VERBOSE, ".ORIGIN 0x%04X", opos);
// Emit origin set metadata.
aout_emit(aout_create_metadata_origin(opos));
break;
case SEEK:
if (line->keyword_data_expr_1 == NULL)
{
if (line->keyword_data_string != NULL)
dhalt(ERR_LABEL_RESOLUTION_NOT_PERMITTED, line->keyword_data_string->data);
else
dhalt(ERR_LABEL_RESOLUTION_NOT_PERMITTED, "");
}
opos = expr_evaluate(line->keyword_data_expr_1, &dhalt_label_resolution_not_permitted, &dhalt_expression_exit_handler);
printd(LEVEL_VERBOSE, ".SEEK 0x%04X", opos);
// Emit seek metadata.
aout_emit(aout_create_metadata_seek(opos));
break;
case EXPORT:
printd(LEVEL_VERBOSE, ".EXPORT %s", bstr2cstr(line->keyword_data_string, '0'));
// Emit export metadata.
aout_emit(aout_create_metadata_export(bstr2cstr(line->keyword_data_string, '0')));
break;
case IMPORT:
printd(LEVEL_VERBOSE, ".IMPORT %s", bstr2cstr(line->keyword_data_string, '0'));
// Emit import metadata.
aout_emit(aout_create_metadata_import(bstr2cstr(line->keyword_data_string, '0')));
break;
case IMPORT_OPTIONAL:
printd(LEVEL_VERBOSE, ".IMPORT OPTIONAL %s", bstr2cstr(line->keyword_data_string, '0'));
// Emit import metadata.
aout_emit(aout_create_metadata_import_optional(bstr2cstr(line->keyword_data_string, '0')));
break;
case JUMP:
if (line->keyword_data_string == NULL)
printd(LEVEL_VERBOSE, ".JUMP <table>");
else
printd(LEVEL_VERBOSE, ".JUMP %s", bstr2cstr(line->keyword_data_string, '0'));
// Emit jump metadata.
if (line->keyword_data_string == NULL)
aout_emit(aout_create_metadata_jump(NULL));
else
aout_emit(aout_create_metadata_jump(bstr2cstr(line->keyword_data_string, '0')));
break;
default:
printd(LEVEL_VERBOSE, "?? UNKNOWN KEYWORD\n");
dhalt(ERR_UNSUPPORTED_KEYWORD, NULL);
}
printd(LEVEL_VERBOSE, "\n");
break;
case type_instruction:
// Check to see if this is DAT.
if (strcmp(line->instruction->instruction, "DAT") == 0)
{
// Handle data.
printd(LEVEL_VERBOSE, "EMIT DAT");
// Process parameters as data.
reverse_parameters(line->instruction->parameters);
dcurrent = line->instruction->parameters->last;
while (dcurrent != NULL)
{
// Process parameter normally.
dparam = process_parameter(dcurrent);
// Output depending on what kind of parameter it was.
if (dparam.v_label != NULL) // If this is a label, output something that we need to replace.
aout_emit(aout_create_expr(expr_new_label(bautofree(bfromcstr(dparam.v_label)))));
else if (dparam.v_raw != NULL) // If the raw field is not null, get each character and output it.
{
printd(LEVEL_VERBOSE, " \"%s\"", dparam.v_raw->data);
for (dchrproc = 0; dchrproc < (uint32_t)blength(dparam.v_raw); dchrproc++)
aout_emit(aout_create_raw(dparam.v_raw->data[dchrproc]));
}
else if (dparam.v_extra_used == true) // Just a single address.
aout_emit(aout_create_expr(dparam.v_extra));
else // Something that isn't handled by DAT.
{
printd(LEVEL_VERBOSE, "\n");
dhalt(ERR_DAT_UNSUPPORTED_PARAMETER, NULL);
}
dcurrent = dcurrent->prev;
}
}
else
{
// Handle instruction.
insttype = get_instruction_by_name(line->instruction->instruction);
if (insttype == NULL)
dhalt(ERR_UNKNOWN_OPCODE, line->instruction->instruction);
printd(LEVEL_VERBOSE, "EMIT %s", insttype->name);
// Check parameter count.
if (line->instruction->parameters == NULL && strcmp(line->instruction->instruction, "RFI") == 0)
{
// Handle RFI (which can accept no parameters).
result = aout_emit(aout_create_opcode(insttype->opcode, insttype->nbopcode, 0x21 /* 0 literal */));
printd(LEVEL_VERBOSE, "\n");
break;
}
else if (line->instruction->parameters == NULL)
{
// Halt and error.
dhalt(ERR_INVALID_PARAMETER_COUNT, NULL);
}
// Process parameters normally.
ppresults = process_parameters(line->instruction->parameters);
// Force the parameter value to be NXT if it's a label.
if (ppresults.a_label != NULL) ppresults.a = NXT_LIT;
if (ppresults.b_label != NULL) ppresults.b = NXT_LIT;
if (ppresults.a_label != NULL && ppresults.a_label_bracketed) ppresults.a = NXT;
if (ppresults.b_label != NULL && ppresults.b_label_bracketed) ppresults.b = NXT;
// Check for relative addressing.
if ((insttype->opcode == OP_ADD || insttype->opcode == OP_SUB ||
insttype->opcode == OP_MUL || insttype->opcode == OP_DIV) && ppresults.a == PC)
{
// Warn about relative addressing portability.
dwarn(WARN_RELATIVE_PC_ADDRESSING, NULL);
}
// Output the initial opcode.
if (insttype->opcode != OP_NONBASIC)
result = aout_emit(aout_create_opcode(insttype->opcode, ppresults.a, ppresults.b));
else
result = aout_emit(aout_create_opcode(insttype->opcode, insttype->nbopcode, ppresults.a));
// If the parameter is a label or requires an extra word, output them.
if (ppresults.b_label != NULL)
aout_emit(aout_create_expr(expr_new_label(bautofree(bfromcstr(ppresults.b_label)))));
else if (ppresults.b_extra_used)
aout_emit(aout_create_expr(ppresults.b_extra));
if (ppresults.a_label != NULL)
aout_emit(aout_create_expr(expr_new_label(bautofree(bfromcstr(ppresults.a_label)))));
else if (ppresults.a_extra_used)
aout_emit(aout_create_expr(ppresults.a_extra));
}
printd(LEVEL_VERBOSE, "\n");
break;
case type_label:
// Handle label definition.
list_append(&newsyms, dbgfmt_create_symbol(DBGFMT_SYMBOL_LABEL, dbgfmt_create_symbol_label(bfromcstr(line->label->name), DBGFMT_UNDETERMINED)));
printd(LEVEL_VERBOSE, ":%s\n", line->label->name);
aout_emit(aout_create_label(line->label->name));
break;
default:
assert(false);
}
// If we can associate debugging symbols with this instruction...
if (result != NULL)
{
// While the new symbols list is not empty, copy those symbols
// into the output and associate.
while (list_size(&newsyms) > 0)
{
newsym = list_extract_at(&newsyms, 0);
printd(LEVEL_DEBUG, "Debugging custom symbol: %i\n", newsym->length);
list_append(&result->symbols, newsym);
list_append(assem_dbg_symbols, newsym);
}
// If the line information is provided, output
// debugging symbols.
if (line != NULL && line->file != NULL)
{
// Output a file / line number debugging symbol here.
newsym = dbgfmt_create_symbol(DBGFMT_SYMBOL_LINE, dbgfmt_create_symbol_line(line->file, line->line, DBGFMT_UNDETERMINED));
list_append(&result->symbols, newsym);
list_append(assem_dbg_symbols, newsym);
printd(LEVEL_DEBUG, "Debugging symbol: %i %s\n", line->line, line->file->data);
}
// If the higher-language line information is
// provided, output debugging symbols.
if (line != NULL && line->ufile != NULL)
{
// Output a file / line number debugging symbol here.
newsym = dbgfmt_create_symbol(DBGFMT_SYMBOL_LINE, dbgfmt_create_symbol_line(line->ufile, line->uline, DBGFMT_UNDETERMINED));
list_append(&result->symbols, newsym);
list_append(assem_dbg_symbols, newsym);
printd(LEVEL_DEBUG, "High-level debugging symbol: %i %s\n", line->uline, line->ufile->data);
}
}
}
int main(int argc,char **argv)
{
size_t preload_read;
const char *preload_buffer;
int yyparse_result;
tree_init();
#ifdef WITH_CGI
cgi_check_request();
if (cgi_status < 0) {
cgi_write_error_bad_req();
return 0;
}
#endif
params_set_defaults();
#ifdef WITH_CGI
if (!cgi_status)
process_parameters(argc, argv);
preload_buffer = charset_init_preload(param_inputf, &preload_read);
if (cgi_status > 0)
cgi_process_parameters(&preload_buffer, &preload_read);
charset_auto_detect(preload_read);
charset_preload_to_input(param_charset_in, preload_read);
if (cgi_status == CGI_ST_MULTIPART)
charset_cgi_boundary(boundary, boundary_len);
#else
/* process command line arguments */
process_parameters(argc, argv);
charset_init_preload(param_inputf, &preload_read);
charset_auto_detect(preload_read);
charset_preload_to_input(param_charset_in, preload_read);
#endif
/* intialize the converter */
saxStartDocument();
if (param_inputf != stdin)
parser_set_input(param_inputf);
/* parse the input file and convert it */
yyparse_result = yyparse();
if (yyparse_result) {
EXIT("Unrecoverable parse error");
}
charset_close();
saxEndDocument();
#ifdef WITH_CGI
if (!cgi_status) {
/* write the output */
if (writeOutput())
EXIT("Bad state in writeOutput()");
/* close de output file */
if (param_outputf != stdout)
fclose(param_outputf);
} else {
cgi_write_output();
}
#else
/* write the output */
if (writeOutput())
EXIT("Bad state in writeOutput()");
/* close de output file */
if (param_outputf != stdout)
fclose(param_outputf);
#endif
/* show final messages */
write_end_messages();
freeMemory();
return 0;
}
int
main (int argc, char **argv)
{
ret_t ret;
struct sigaction act;
/* Globals */
document_root = strdup (DEFAULT_DOCUMENTROOT);
config_file = strdup (DEFAULT_CONFIG_FILE);
bind_to = strdup (DEFAULT_BIND);
if ((!bind_to) || (!config_file) || (!document_root)) {
PRINT_MSG ("ERROR: Couldn't allocate memory.\n");
exit (EXIT_ERROR);
}
/* Python */
ret = check_for_python();
if (ret != ret_ok) {
PRINT_MSG ("ERROR: Couldn't find python.\n");
exit (EXIT_ERROR);
}
/* Signal handling */
act.sa_handler = SIG_IGN;
sigaction (SIGPIPE, &act, NULL);
memset(&act, 0, sizeof(act));
act.sa_sigaction = signals_handler;
act.sa_flags = SA_SIGINFO;
sigaction (SIGCHLD, &act, NULL);
sigaction (SIGINT, &act, NULL);
sigaction (SIGTERM, &act, NULL);
/* Initialize the embedded server */
cherokee_init();
/* Seed random numbers
*/
cherokee_random_seed();
cherokee_spawner_set_active (false);
process_parameters (argc, argv);
ret = cherokee_server_new (&srv);
if (ret != ret_ok)
exit (EXIT_ERROR);
ret = config_server (srv);
if (ret != ret_ok)
exit (EXIT_ERROR);
ret = cherokee_server_initialize (srv);
if (ret != ret_ok)
exit (EXIT_ERROR);
print_connection_info();
ret = cherokee_server_unlock_threads (srv);
if (ret != ret_ok)
exit (EXIT_ERROR);
do {
ret = cherokee_server_step (srv);
} while (ret == ret_eagain);
cherokee_server_stop (srv);
cherokee_server_free (srv);
cherokee_mrproper();
return EXIT_OK;
}
