int main(int argc, char * argv[])
{
int width = 640;
int height = 480;
parse_argument(argc, argv, "-w", width);
parse_argument(argc, argv, "-h", height);
Resolution::getInstance(width, height);
Bytef * decompressionBuffer = new Bytef[Resolution::getInstance().numPixels() * 2];
IplImage * deCompImage = 0;
std::string logFile;
assert(parse_argument(argc, argv, "-l", logFile) > 0 && "Please provide a log file");
RawLogReader logReader(decompressionBuffer,
deCompImage,
logFile,
find_argument(argc, argv, "-f") != -1);
cv::Mat1b tmp(height, width);
cv::Mat3b depthImg(height, width);
while(logReader.hasMore())
{
logReader.getNext();
cv::Mat3b rgbImg(height, width, (cv::Vec<unsigned char, 3> *)logReader.deCompImage->imageData);
cv::Mat1w depth(height, width, (unsigned short *)&decompressionBuffer[0]);
cv::normalize(depth, tmp, 0, 255, cv::NORM_MINMAX, 0);
cv::cvtColor(tmp, depthImg, CV_GRAY2RGB);
cv::imshow("RGB", rgbImg);
cv::imshow("Depth", depthImg);
char key = cv::waitKey(1);
if(key == 'q')
break;
else if(key == ' ')
key = cv::waitKey(0);
if(key == 'q')
break;
}
delete [] decompressionBuffer;
if(deCompImage)
{
cvReleaseImage(&deCompImage);
}
return 0;
}
int
pcl::console::parse_argument (int argc, const char * const * argv, const char * str, std::string &val)
{
int index = find_argument (argc, argv, str) + 1;
if (index > 0 && index < argc )
val = argv[index];
return index - 1;
}
int parse_argument (int argc, char** argv, const char* str, int &val)
{
int index = find_argument (argc, argv, str) + 1;
if (index > 0 && index < argc )
val = atoi (argv[index]);
return (index - 1);
}
int
pcl::console::parse_argument (int argc, const char * const * argv, const char * str, double &val)
{
int index = find_argument (argc, argv, str) + 1;
if (index > 0 && index < argc )
val = atof (argv[index]);
return (index - 1);
}
int
pcl::console::parse_argument (int argc, const char * const * argv, const char * str, float &val)
{
int index = find_argument (argc, argv, str) + 1;
if (index > 0 && index < argc )
val = static_cast<float> (atof (argv[index]));
return (index - 1);
}
int
pcl::console::parse_argument (int argc, char** argv, const char* str, bool &val)
{
int index = find_argument (argc, argv, str) + 1;
if (index > 0 && index < argc )
val = (bool)atoi (argv[index]);
return (index - 1);
}
int
pcl::console::parse_argument (int argc, char** argv, const char* str, char &val)
{
int index = find_argument (argc, argv, str) + 1;
if (index > 0 && index < argc )
val = argv[index][0];
return (index - 1);
}
int main(const int argc, const char *argv[])
{
char version_string[256];
const char *arg;
struct s_hardware hardware;
snprintf(version_string, sizeof version_string, "%s %s (%s)",
PRODUCT_NAME, VERSION, CODENAME);
/* Cleaning structures */
init_hardware(&hardware);
/* Detecting Syslinux version */
detect_syslinux(&hardware);
/* Detecting parameters */
detect_parameters(argc, argv, &hardware);
/* Opening the Syslinux console */
init_console(&hardware);
/* Clear the screen and reset position of the cursor */
clear_screen();
printf("\033[1;1H");
printf("%s\n", version_string);
if ((arg = find_argument(argv + 1, "nomenu"))
|| (find_argument(argv + 1, "auto")))
start_cli_mode(&hardware);
else {
int return_code = start_menu_mode(&hardware, version_string);
if (return_code == HDT_RETURN_TO_CLI)
start_cli_mode(&hardware);
else
return return_code;
}
return 0;
}
int main(int argc, char **argv)
{
QApplication app(argc, argv);
int width = 640;
int height = 480;
int fps = 30;
int tcp = 0;
parse_argument(argc, argv, "-w", width);
parse_argument(argc, argv, "-h", height);
parse_argument(argc, argv, "-f", fps);
tcp = find_argument(argc, argv, "-t") != -1;
MainWindow * window = new MainWindow(width, height, fps, tcp);
window->show();
return app.exec();
}
FLAC__bool parse_option(int option_index, const char *option_argument, CommandLineOptions *options)
{
const char *opt = long_options_[option_index].name;
Operation *op;
Argument *arg;
FLAC__bool ok = true;
if(0 == strcmp(opt, "preserve-modtime")) {
options->preserve_modtime = true;
}
else if(0 == strcmp(opt, "with-filename")) {
options->prefix_with_filename = true;
}
else if(0 == strcmp(opt, "no-filename")) {
options->prefix_with_filename = false;
}
else if(0 == strcmp(opt, "no-utf8-convert")) {
options->utf8_convert = false;
}
else if(0 == strcmp(opt, "dont-use-padding")) {
options->use_padding = false;
}
else if(0 == strcmp(opt, "no-cued-seekpoints")) {
options->cued_seekpoints = false;
}
else if(0 == strcmp(opt, "show-md5sum")) {
(void) append_shorthand_operation(options, OP__SHOW_MD5SUM);
}
else if(0 == strcmp(opt, "show-min-blocksize")) {
(void) append_shorthand_operation(options, OP__SHOW_MIN_BLOCKSIZE);
}
else if(0 == strcmp(opt, "show-max-blocksize")) {
(void) append_shorthand_operation(options, OP__SHOW_MAX_BLOCKSIZE);
}
else if(0 == strcmp(opt, "show-min-framesize")) {
(void) append_shorthand_operation(options, OP__SHOW_MIN_FRAMESIZE);
}
else if(0 == strcmp(opt, "show-max-framesize")) {
(void) append_shorthand_operation(options, OP__SHOW_MAX_FRAMESIZE);
}
else if(0 == strcmp(opt, "show-sample-rate")) {
(void) append_shorthand_operation(options, OP__SHOW_SAMPLE_RATE);
}
else if(0 == strcmp(opt, "show-channels")) {
(void) append_shorthand_operation(options, OP__SHOW_CHANNELS);
}
else if(0 == strcmp(opt, "show-bps")) {
(void) append_shorthand_operation(options, OP__SHOW_BPS);
}
else if(0 == strcmp(opt, "show-total-samples")) {
(void) append_shorthand_operation(options, OP__SHOW_TOTAL_SAMPLES);
}
else if(0 == strcmp(opt, "set-md5sum")) {
op = append_shorthand_operation(options, OP__SET_MD5SUM);
FLAC__ASSERT(0 != option_argument);
if(!parse_md5(option_argument, op->argument.streaminfo_md5.value)) {
flac_fprintf(stderr, "ERROR (--%s): bad MD5 sum\n", opt);
ok = false;
}
else
undocumented_warning(opt);
}
else if(0 == strcmp(opt, "set-min-blocksize")) {
op = append_shorthand_operation(options, OP__SET_MIN_BLOCKSIZE);
if(!parse_uint32(option_argument, &(op->argument.streaminfo_uint32.value)) || op->argument.streaminfo_uint32.value < FLAC__MIN_BLOCK_SIZE || op->argument.streaminfo_uint32.value > FLAC__MAX_BLOCK_SIZE) {
flac_fprintf(stderr, "ERROR (--%s): value must be >= %u and <= %u\n", opt, FLAC__MIN_BLOCK_SIZE, FLAC__MAX_BLOCK_SIZE);
ok = false;
}
else
undocumented_warning(opt);
}
else if(0 == strcmp(opt, "set-max-blocksize")) {
op = append_shorthand_operation(options, OP__SET_MAX_BLOCKSIZE);
if(!parse_uint32(option_argument, &(op->argument.streaminfo_uint32.value)) || op->argument.streaminfo_uint32.value < FLAC__MIN_BLOCK_SIZE || op->argument.streaminfo_uint32.value > FLAC__MAX_BLOCK_SIZE) {
flac_fprintf(stderr, "ERROR (--%s): value must be >= %u and <= %u\n", opt, FLAC__MIN_BLOCK_SIZE, FLAC__MAX_BLOCK_SIZE);
ok = false;
}
else
undocumented_warning(opt);
}
else if(0 == strcmp(opt, "set-min-framesize")) {
op = append_shorthand_operation(options, OP__SET_MIN_FRAMESIZE);
if(!parse_uint32(option_argument, &(op->argument.streaminfo_uint32.value)) || op->argument.streaminfo_uint32.value >= (1u<<FLAC__STREAM_METADATA_STREAMINFO_MIN_FRAME_SIZE_LEN)) {
flac_fprintf(stderr, "ERROR (--%s): value must be a %u-bit unsigned integer\n", opt, FLAC__STREAM_METADATA_STREAMINFO_MIN_FRAME_SIZE_LEN);
ok = false;
}
else
undocumented_warning(opt);
}
else if(0 == strcmp(opt, "set-max-framesize")) {
op = append_shorthand_operation(options, OP__SET_MAX_FRAMESIZE);
if(!parse_uint32(option_argument, &(op->argument.streaminfo_uint32.value)) || op->argument.streaminfo_uint32.value >= (1u<<FLAC__STREAM_METADATA_STREAMINFO_MAX_FRAME_SIZE_LEN)) {
flac_fprintf(stderr, "ERROR (--%s): value must be a %u-bit unsigned integer\n", opt, FLAC__STREAM_METADATA_STREAMINFO_MAX_FRAME_SIZE_LEN);
ok = false;
}
else
undocumented_warning(opt);
}
else if(0 == strcmp(opt, "set-sample-rate")) {
op = append_shorthand_operation(options, OP__SET_SAMPLE_RATE);
if(!parse_uint32(option_argument, &(op->argument.streaminfo_uint32.value)) || !FLAC__format_sample_rate_is_valid(op->argument.streaminfo_uint32.value)) {
flac_fprintf(stderr, "ERROR (--%s): invalid sample rate\n", opt);
ok = false;
}
else
undocumented_warning(opt);
}
else if(0 == strcmp(opt, "set-channels")) {
op = append_shorthand_operation(options, OP__SET_CHANNELS);
if(!parse_uint32(option_argument, &(op->argument.streaminfo_uint32.value)) || op->argument.streaminfo_uint32.value > FLAC__MAX_CHANNELS) {
flac_fprintf(stderr, "ERROR (--%s): value must be > 0 and <= %u\n", opt, FLAC__MAX_CHANNELS);
ok = false;
}
else
undocumented_warning(opt);
}
else if(0 == strcmp(opt, "set-bps")) {
op = append_shorthand_operation(options, OP__SET_BPS);
if(!parse_uint32(option_argument, &(op->argument.streaminfo_uint32.value)) || op->argument.streaminfo_uint32.value < FLAC__MIN_BITS_PER_SAMPLE || op->argument.streaminfo_uint32.value > FLAC__MAX_BITS_PER_SAMPLE) {
flac_fprintf(stderr, "ERROR (--%s): value must be >= %u and <= %u\n", opt, FLAC__MIN_BITS_PER_SAMPLE, FLAC__MAX_BITS_PER_SAMPLE);
ok = false;
}
else
undocumented_warning(opt);
}
else if(0 == strcmp(opt, "set-total-samples")) {
op = append_shorthand_operation(options, OP__SET_TOTAL_SAMPLES);
if(!parse_uint64(option_argument, &(op->argument.streaminfo_uint64.value)) || op->argument.streaminfo_uint64.value >= (((FLAC__uint64)1)<<FLAC__STREAM_METADATA_STREAMINFO_TOTAL_SAMPLES_LEN)) {
flac_fprintf(stderr, "ERROR (--%s): value must be a %u-bit unsigned integer\n", opt, FLAC__STREAM_METADATA_STREAMINFO_TOTAL_SAMPLES_LEN);
ok = false;
}
else
undocumented_warning(opt);
}
else if(0 == strcmp(opt, "show-vendor-tag")) {
(void) append_shorthand_operation(options, OP__SHOW_VC_VENDOR);
}
else if(0 == strcmp(opt, "show-tag")) {
const char *violation;
op = append_shorthand_operation(options, OP__SHOW_VC_FIELD);
FLAC__ASSERT(0 != option_argument);
if(!parse_vorbis_comment_field_name(option_argument, &(op->argument.vc_field_name.value), &violation)) {
FLAC__ASSERT(0 != violation);
flac_fprintf(stderr, "ERROR (--%s): malformed vorbis comment field name \"%s\",\n %s\n", opt, option_argument, violation);
ok = false;
}
}
else if(0 == strcmp(opt, "remove-all-tags")) {
(void) append_shorthand_operation(options, OP__REMOVE_VC_ALL);
}
else if(0 == strcmp(opt, "remove-tag")) {
const char *violation;
op = append_shorthand_operation(options, OP__REMOVE_VC_FIELD);
FLAC__ASSERT(0 != option_argument);
if(!parse_vorbis_comment_field_name(option_argument, &(op->argument.vc_field_name.value), &violation)) {
FLAC__ASSERT(0 != violation);
flac_fprintf(stderr, "ERROR (--%s): malformed vorbis comment field name \"%s\",\n %s\n", opt, option_argument, violation);
ok = false;
}
}
else if(0 == strcmp(opt, "remove-first-tag")) {
const char *violation;
op = append_shorthand_operation(options, OP__REMOVE_VC_FIRSTFIELD);
FLAC__ASSERT(0 != option_argument);
if(!parse_vorbis_comment_field_name(option_argument, &(op->argument.vc_field_name.value), &violation)) {
FLAC__ASSERT(0 != violation);
flac_fprintf(stderr, "ERROR (--%s): malformed vorbis comment field name \"%s\",\n %s\n", opt, option_argument, violation);
ok = false;
}
}
else if(0 == strcmp(opt, "set-tag")) {
const char *violation;
op = append_shorthand_operation(options, OP__SET_VC_FIELD);
FLAC__ASSERT(0 != option_argument);
op->argument.vc_field.field_value_from_file = false;
if(!parse_vorbis_comment_field(option_argument, &(op->argument.vc_field.field), &(op->argument.vc_field.field_name), &(op->argument.vc_field.field_value), &(op->argument.vc_field.field_value_length), &violation)) {
FLAC__ASSERT(0 != violation);
flac_fprintf(stderr, "ERROR (--%s): malformed vorbis comment field \"%s\",\n %s\n", opt, option_argument, violation);
ok = false;
}
}
else if(0 == strcmp(opt, "set-tag-from-file")) {
const char *violation;
op = append_shorthand_operation(options, OP__SET_VC_FIELD);
FLAC__ASSERT(0 != option_argument);
op->argument.vc_field.field_value_from_file = true;
if(!parse_vorbis_comment_field(option_argument, &(op->argument.vc_field.field), &(op->argument.vc_field.field_name), &(op->argument.vc_field.field_value), &(op->argument.vc_field.field_value_length), &violation)) {
FLAC__ASSERT(0 != violation);
flac_fprintf(stderr, "ERROR (--%s): malformed vorbis comment field \"%s\",\n %s\n", opt, option_argument, violation);
ok = false;
}
}
else if(0 == strcmp(opt, "import-tags-from")) {
op = append_shorthand_operation(options, OP__IMPORT_VC_FROM);
FLAC__ASSERT(0 != option_argument);
if(!parse_string(option_argument, &(op->argument.filename.value))) {
flac_fprintf(stderr, "ERROR (--%s): missing filename\n", opt);
ok = false;
}
}
else if(0 == strcmp(opt, "export-tags-to")) {
op = append_shorthand_operation(options, OP__EXPORT_VC_TO);
FLAC__ASSERT(0 != option_argument);
if(!parse_string(option_argument, &(op->argument.filename.value))) {
flac_fprintf(stderr, "ERROR (--%s): missing filename\n", opt);
ok = false;
}
}
else if(0 == strcmp(opt, "import-cuesheet-from")) {
if(0 != find_shorthand_operation(options, OP__IMPORT_CUESHEET_FROM)) {
flac_fprintf(stderr, "ERROR (--%s): may be specified only once\n", opt);
ok = false;
}
op = append_shorthand_operation(options, OP__IMPORT_CUESHEET_FROM);
FLAC__ASSERT(0 != option_argument);
if(!parse_string(option_argument, &(op->argument.import_cuesheet_from.filename))) {
flac_fprintf(stderr, "ERROR (--%s): missing filename\n", opt);
ok = false;
}
}
else if(0 == strcmp(opt, "export-cuesheet-to")) {
op = append_shorthand_operation(options, OP__EXPORT_CUESHEET_TO);
FLAC__ASSERT(0 != option_argument);
if(!parse_string(option_argument, &(op->argument.filename.value))) {
flac_fprintf(stderr, "ERROR (--%s): missing filename\n", opt);
ok = false;
}
}
else if(0 == strcmp(opt, "import-picture-from")) {
op = append_shorthand_operation(options, OP__IMPORT_PICTURE_FROM);
FLAC__ASSERT(0 != option_argument);
if(!parse_string(option_argument, &(op->argument.specification.value))) {
flac_fprintf(stderr, "ERROR (--%s): missing specification\n", opt);
ok = false;
}
}
else if(0 == strcmp(opt, "export-picture-to")) {
arg = find_argument(options, ARG__BLOCK_NUMBER);
op = append_shorthand_operation(options, OP__EXPORT_PICTURE_TO);
FLAC__ASSERT(0 != option_argument);
if(!parse_string(option_argument, &(op->argument.export_picture_to.filename))) {
flac_fprintf(stderr, "ERROR (--%s): missing filename\n", opt);
ok = false;
}
op->argument.export_picture_to.block_number_link = arg? &(arg->value.block_number) : 0;
}
else if(0 == strcmp(opt, "add-seekpoint")) {
const char *violation;
char *spec;
FLAC__ASSERT(0 != option_argument);
if(!parse_add_seekpoint(option_argument, &spec, &violation)) {
FLAC__ASSERT(0 != violation);
flac_fprintf(stderr, "ERROR (--%s): malformed seekpoint specification \"%s\",\n %s\n", opt, option_argument, violation);
ok = false;
}
else {
op = find_shorthand_operation(options, OP__ADD_SEEKPOINT);
if(0 == op)
op = append_shorthand_operation(options, OP__ADD_SEEKPOINT);
local_strcat(&(op->argument.add_seekpoint.specification), spec);
local_strcat(&(op->argument.add_seekpoint.specification), ";");
free(spec);
}
}
else if(0 == strcmp(opt, "add-replay-gain")) {
(void) append_shorthand_operation(options, OP__ADD_REPLAY_GAIN);
}
else if(0 == strcmp(opt, "remove-replay-gain")) {
const FLAC__byte * const tags[5] = {
GRABBAG__REPLAYGAIN_TAG_REFERENCE_LOUDNESS,
GRABBAG__REPLAYGAIN_TAG_TITLE_GAIN,
GRABBAG__REPLAYGAIN_TAG_TITLE_PEAK,
GRABBAG__REPLAYGAIN_TAG_ALBUM_GAIN,
GRABBAG__REPLAYGAIN_TAG_ALBUM_PEAK
};
size_t i;
for(i = 0; i < sizeof(tags)/sizeof(tags[0]); i++) {
op = append_shorthand_operation(options, OP__REMOVE_VC_FIELD);
op->argument.vc_field_name.value = local_strdup((const char *)tags[i]);
}
}
else if(0 == strcmp(opt, "add-padding")) {
op = append_shorthand_operation(options, OP__ADD_PADDING);
FLAC__ASSERT(0 != option_argument);
if(!parse_add_padding(option_argument, &(op->argument.add_padding.length))) {
flac_fprintf(stderr, "ERROR (--%s): illegal length \"%s\", length must be >= 0 and < 2^%u\n", opt, option_argument, FLAC__STREAM_METADATA_LENGTH_LEN);
ok = false;
}
}
else if(0 == strcmp(opt, "help")) {
options->show_long_help = true;
}
else if(0 == strcmp(opt, "version")) {
options->show_version = true;
}
else if(0 == strcmp(opt, "list")) {
(void) append_major_operation(options, OP__LIST);
}
else if(0 == strcmp(opt, "append")) {
(void) append_major_operation(options, OP__APPEND);
}
else if(0 == strcmp(opt, "remove")) {
(void) append_major_operation(options, OP__REMOVE);
}
else if(0 == strcmp(opt, "remove-all")) {
(void) append_major_operation(options, OP__REMOVE_ALL);
}
else if(0 == strcmp(opt, "merge-padding")) {
(void) append_major_operation(options, OP__MERGE_PADDING);
}
else if(0 == strcmp(opt, "sort-padding")) {
(void) append_major_operation(options, OP__SORT_PADDING);
}
else if(0 == strcmp(opt, "block-number")) {
arg = append_argument(options, ARG__BLOCK_NUMBER);
FLAC__ASSERT(0 != option_argument);
if(!parse_block_number(option_argument, &(arg->value.block_number))) {
flac_fprintf(stderr, "ERROR: malformed block number specification \"%s\"\n", option_argument);
ok = false;
}
}
else if(0 == strcmp(opt, "block-type")) {
arg = append_argument(options, ARG__BLOCK_TYPE);
FLAC__ASSERT(0 != option_argument);
if(!parse_block_type(option_argument, &(arg->value.block_type))) {
flac_fprintf(stderr, "ERROR (--%s): malformed block type specification \"%s\"\n", opt, option_argument);
ok = false;
}
options->args.checks.has_block_type = true;
}
else if(0 == strcmp(opt, "except-block-type")) {
arg = append_argument(options, ARG__EXCEPT_BLOCK_TYPE);
FLAC__ASSERT(0 != option_argument);
if(!parse_block_type(option_argument, &(arg->value.block_type))) {
flac_fprintf(stderr, "ERROR (--%s): malformed block type specification \"%s\"\n", opt, option_argument);
ok = false;
}
options->args.checks.has_except_block_type = true;
}
else if(0 == strcmp(opt, "data-format")) {
arg = append_argument(options, ARG__DATA_FORMAT);
FLAC__ASSERT(0 != option_argument);
if(!parse_data_format(option_argument, &(arg->value.data_format))) {
flac_fprintf(stderr, "ERROR (--%s): illegal data format \"%s\"\n", opt, option_argument);
ok = false;
}
}
else if(0 == strcmp(opt, "application-data-format")) {
FLAC__ASSERT(0 != option_argument);
if(!parse_application_data_format(option_argument, &(options->application_data_format_is_hexdump))) {
flac_fprintf(stderr, "ERROR (--%s): illegal application data format \"%s\"\n", opt, option_argument);
ok = false;
}
}
else if(0 == strcmp(opt, "from-file")) {
arg = append_argument(options, ARG__FROM_FILE);
FLAC__ASSERT(0 != option_argument);
arg->value.from_file.file_name = local_strdup(option_argument);
}
else {
FLAC__ASSERT(0);
}
return ok;
}
/* boot linux kernel and initrd */
static int sl_boot_linux(lua_State * L)
{
const char *kernel = luaL_checkstring(L, 1);
const char *cmdline = luaL_optstring(L, 2, "");
char *initrd;
void *kernel_data, *file_data;
size_t kernel_len, file_len;
struct initramfs *initramfs;
char *newcmdline;
uint32_t mem_limit = luaL_optint(L, 3, 0);
uint16_t video_mode = luaL_optint(L, 4, 0);
// int ret, i;
int ret;
char **argv, **argp, *arg, *p;
ret = __parse_argv(&argv, cmdline);
newcmdline = malloc(strlen(kernel) + 12);
if (!newcmdline)
printf("Mem alloc failed: cmdline\n");
strcpy(newcmdline, "BOOT_IMAGE=");
strcpy(newcmdline + strlen(newcmdline), kernel);
argv[0] = newcmdline;
argp = argv;
/* DEBUG
for (i=0; i<ret; i++)
printf("%d: %s\n", i, argv[i]);
*/
newcmdline = make_cmdline(argp);
if (!newcmdline)
printf("Creating command line failed!\n");
/* DEBUG
printf("Command line: %s\n", newcmdline);
msleep(1000);
*/
/* Look for specific command-line arguments we care about */
if ((arg = find_argument(argp, "mem=")))
mem_limit = saturate32(suffix_number(arg));
if ((arg = find_argument(argp, "vga="))) {
switch (arg[0] | 0x20) {
case 'a': /* "ask" */
video_mode = 0xfffd;
break;
case 'e': /* "ext" */
video_mode = 0xfffe;
break;
case 'n': /* "normal" */
video_mode = 0xffff;
break;
default:
video_mode = strtoul(arg, NULL, 0);
break;
}
}
printf("Loading kernel %s...\n", kernel);
if (loadfile(kernel, &kernel_data, &kernel_len))
printf("failed!\n");
else
printf("ok\n");
initramfs = initramfs_init();
if (!initramfs)
printf("Initializing initrd failed!\n");
if ((arg = find_argument(argp, "initrd="))) {
do {
p = strchr(arg, ',');
if (p)
*p = '\0';
initrd = arg;
printf("Loading initrd %s... ", initrd);
if (initramfs_load_archive(initramfs, initrd)) {
printf("failed!\n");
}
printf("ok\n");
if (p)
*p++ = ',';
} while ((arg = p));
}
if (!loadfile("/testfile1", &file_data, &file_len)) {
if (initramfs_add_file(initramfs, file_data, file_len, file_len,
"/testfile1", 0, 0755))
printf("Adding extra file failed\n");
} else
printf("Loading extra file failed\n");
/* DEBUG
msleep(10000);
*/
ret = syslinux_boot_linux(kernel_data, kernel_len, initramfs, newcmdline);
printf("syslinux_boot_linux returned %d\n", ret);
return 0;
}
int syslinux_boot_linux(void *kernel_buf, size_t kernel_size,
struct initramfs *initramfs, char *cmdline)
{
struct linux_header hdr, *whdr;
size_t real_mode_size, prot_mode_size;
addr_t real_mode_base, prot_mode_base;
addr_t irf_size;
size_t cmdline_size, cmdline_offset;
struct syslinux_rm_regs regs;
struct syslinux_movelist *fraglist = NULL;
struct syslinux_memmap *mmap = NULL;
struct syslinux_memmap *amap = NULL;
bool ok;
uint32_t memlimit = 0;
uint16_t video_mode = 0;
const char *arg;
cmdline_size = strlen(cmdline) + 1;
if (kernel_size < 2 * 512)
goto bail;
/* Look for specific command-line arguments we care about */
if ((arg = find_argument(cmdline, "mem=")))
memlimit = saturate32(suffix_number(arg));
if ((arg = find_argument(cmdline, "vga="))) {
switch (arg[0] | 0x20) {
case 'a': /* "ask" */
video_mode = 0xfffd;
break;
case 'e': /* "ext" */
video_mode = 0xfffe;
break;
case 'n': /* "normal" */
video_mode = 0xffff;
break;
case 'c': /* "current" */
video_mode = 0x0f04;
break;
default:
video_mode = strtoul(arg, NULL, 0);
break;
}
}
/* Copy the header into private storage */
/* Use whdr to modify the actual kernel header */
memcpy(&hdr, kernel_buf, sizeof hdr);
whdr = (struct linux_header *)kernel_buf;
if (hdr.boot_flag != BOOT_MAGIC)
goto bail;
if (hdr.header != LINUX_MAGIC) {
hdr.version = 0x0100; /* Very old kernel */
hdr.loadflags = 0;
}
whdr->vid_mode = video_mode;
if (!hdr.setup_sects)
hdr.setup_sects = 4;
if (hdr.version < 0x0203)
hdr.initrd_addr_max = 0x37ffffff;
if (!memlimit && memlimit - 1 > hdr.initrd_addr_max)
memlimit = hdr.initrd_addr_max + 1; /* Zero for no limit */
if (hdr.version < 0x0205 || !(hdr.loadflags & LOAD_HIGH))
hdr.relocatable_kernel = 0;
if (hdr.version < 0x0206)
hdr.cmdline_max_len = 256;
if (cmdline_size > hdr.cmdline_max_len) {
cmdline_size = hdr.cmdline_max_len;
cmdline[cmdline_size - 1] = '\0';
}
if (hdr.version < 0x0202 || !(hdr.loadflags & 0x01))
cmdline_offset = (0x9ff0 - cmdline_size) & ~15;
else
cmdline_offset = 0x10000;
real_mode_size = (hdr.setup_sects + 1) << 9;
real_mode_base = (hdr.loadflags & LOAD_HIGH) ? 0x10000 : 0x90000;
prot_mode_base = (hdr.loadflags & LOAD_HIGH) ? 0x100000 : 0x10000;
prot_mode_size = kernel_size - real_mode_size;
if (!(hdr.loadflags & LOAD_HIGH) && prot_mode_size > 512 * 1024)
goto bail; /* Kernel cannot be loaded low */
if (initramfs && hdr.version < 0x0200)
goto bail; /* initrd/initramfs not supported */
if (hdr.version >= 0x0200) {
whdr->type_of_loader = 0x30; /* SYSLINUX unknown module */
if (hdr.version >= 0x0201) {
whdr->heap_end_ptr = cmdline_offset - 0x0200;
whdr->loadflags |= CAN_USE_HEAP;
}
if (hdr.version >= 0x0202) {
whdr->cmd_line_ptr = real_mode_base + cmdline_offset;
} else {
whdr->old_cmd_line_magic = OLD_CMDLINE_MAGIC;
whdr->old_cmd_line_offset = cmdline_offset;
/* Be paranoid and round up to a multiple of 16 */
whdr->setup_move_size = (cmdline_offset + cmdline_size + 15) & ~15;
}
}
/* Get the memory map */
mmap = syslinux_memory_map(); /* Memory map for shuffle_boot */
amap = syslinux_dup_memmap(mmap); /* Keep track of available memory */
if (!mmap || !amap)
goto bail;
#if DEBUG
dprintf("Initial memory map:\n");
syslinux_dump_memmap(stdout, mmap);
#endif
/* If the user has specified a memory limit, mark that as unavailable.
Question: should we mark this off-limit in the mmap as well (meaning
it's unavailable to the boot loader, which probably has already touched
some of it), or just in the amap? */
if (memlimit)
if (syslinux_add_memmap(&amap, memlimit, -memlimit, SMT_RESERVED))
goto bail;
/* Place the kernel in memory */
/* First, find a suitable place for the protected-mode code */
if (syslinux_memmap_type(amap, prot_mode_base, prot_mode_size)
!= SMT_FREE) {
const struct syslinux_memmap *mp;
if (!hdr.relocatable_kernel)
goto bail; /* Can't relocate - no hope */
ok = false;
for (mp = amap; mp; mp = mp->next) {
addr_t start, end;
start = mp->start;
end = mp->next->start;
if (mp->type != SMT_FREE)
continue;
if (end <= prot_mode_base)
continue; /* Only relocate upwards */
if (start <= prot_mode_base)
start = prot_mode_base;
start = ALIGN_UP(start, hdr.kernel_alignment);
if (start >= end)
continue;
/* The 3* here is a total fudge factor... it's supposed to
account for the fact that the kernel needs to be decompressed,
and then followed by the BSS and BRK regions. This doesn't,
however, account for the fact that the kernel is decompressed
into a whole other place, either. */
if (end - start >= 3 * prot_mode_size) {
whdr->code32_start += start - prot_mode_base;
prot_mode_base = start;
ok = true;
break;
}
}
if (!ok)
goto bail;
}
/* Real mode code */
if (syslinux_memmap_type(amap, real_mode_base,
cmdline_offset + cmdline_size) != SMT_FREE) {
const struct syslinux_memmap *mp;
ok = false;
for (mp = amap; mp; mp = mp->next) {
addr_t start, end;
start = mp->start;
end = mp->next->start;
if (mp->type != SMT_FREE)
continue;
if (start < real_mode_base)
start = real_mode_base; /* Lowest address we'll use */
if (end > 640 * 1024)
end = 640 * 1024;
start = ALIGN_UP(start, 16);
if (start > 0x90000 || start >= end)
continue;
if (end - start >= cmdline_offset + cmdline_size) {
real_mode_base = start;
ok = true;
break;
}
}
}
if (syslinux_add_movelist(&fraglist, real_mode_base, (addr_t) kernel_buf,
real_mode_size))
goto bail;
if (syslinux_add_memmap
(&amap, real_mode_base, cmdline_offset + cmdline_size, SMT_ALLOC))
goto bail;
/* Zero region between real mode code and cmdline */
if (syslinux_add_memmap(&mmap, real_mode_base + real_mode_size,
cmdline_offset - real_mode_size, SMT_ZERO))
goto bail;
/* Command line */
if (syslinux_add_movelist(&fraglist, real_mode_base + cmdline_offset,
(addr_t) cmdline, cmdline_size))
goto bail;
/* Protected-mode code */
if (syslinux_add_movelist(&fraglist, prot_mode_base,
(addr_t) kernel_buf + real_mode_size,
prot_mode_size))
goto bail;
if (syslinux_add_memmap(&amap, prot_mode_base, prot_mode_size, SMT_ALLOC))
goto bail;
/* Figure out the size of the initramfs, and where to put it.
We should put it at the highest possible address which is
<= hdr.initrd_addr_max, which fits the entire initramfs. */
irf_size = initramfs_size(initramfs); /* Handles initramfs == NULL */
if (irf_size) {
addr_t best_addr = 0;
struct syslinux_memmap *ml;
const addr_t align_mask = INITRAMFS_MAX_ALIGN - 1;
if (irf_size) {
for (ml = amap; ml->type != SMT_END; ml = ml->next) {
addr_t adj_start = (ml->start + align_mask) & ~align_mask;
addr_t adj_end = ml->next->start & ~align_mask;
if (ml->type == SMT_FREE && adj_end - adj_start >= irf_size)
best_addr = (adj_end - irf_size) & ~align_mask;
}
if (!best_addr)
goto bail; /* Insufficient memory for initramfs */
whdr->ramdisk_image = best_addr;
whdr->ramdisk_size = irf_size;
if (syslinux_add_memmap(&amap, best_addr, irf_size, SMT_ALLOC))
goto bail;
if (map_initramfs(&fraglist, &mmap, initramfs, best_addr))
goto bail;
}
}
/* Set up the registers on entry */
memset(®s, 0, sizeof regs);
regs.es = regs.ds = regs.ss = regs.fs = regs.gs = real_mode_base >> 4;
regs.cs = (real_mode_base >> 4) + 0x20;
/* regs.ip = 0; */
/* Linux is OK with sp = 0 = 64K, but perhaps other things aren't... */
regs.esp.w[0] = min(cmdline_offset, (size_t) 0xfff0);
#if DEBUG
dprintf("Final memory map:\n");
syslinux_dump_memmap(stdout, mmap);
dprintf("Final available map:\n");
syslinux_dump_memmap(stdout, amap);
dprintf("Initial movelist:\n");
syslinux_dump_movelist(stdout, fraglist);
#endif
syslinux_shuffle_boot_rm(fraglist, mmap, 0, ®s);
bail:
syslinux_free_movelist(fraglist);
syslinux_free_memmap(mmap);
syslinux_free_memmap(amap);
return -1;
}
bool
pcl::console::find_switch (int argc, const char * const * argv, const char * argument_name)
{
return (find_argument (argc, argv, argument_name) != -1);
}
void main()
{
bool riesegui = false;
do
{
// Letting the user insert a string
cout << "Insert a string down here:\n";
// Catching the string
cin.getline(expression, 300);
// Rimuovo gli spazi
remove_spaces(expression);
// Checking expression
if (!CheckExpression(expression))
{
cout << "\nExpression syntax error...";
getch();
return;
}
parentesizza();
aggiorna_posizioni();
int max_level = 0;
do
{
// Finding max level
max_level = 0;
for (int i = 0; i <= max_record_number; i++)
{
if (par[i].level > max_level) max_level = par[i].level;
}
//cout << "\nMax reached level: " << max_level;
// Itering through the records with the higher level
// Questa variabile conterrà il numero di expressioni
// trovate in questo livello.
int expressionNumber = 0;
for (int a = 0; a <= max_record_number; a++)
{
// Entering here if we are enetering in the max level
if (par[a].level == max_level)
{
// Itering through the number of operators present
char tmp_expression[300];
int c = 0;
// Copying the string
for (int b = (par[a].pos_open + 1); b < par[a].pos_close; b++)
{
tmp_expression[c++] = expression[b];
}
tmp_expression[c] = '\0';
// Showing the string
cout << "\nExpression: " << tmp_expression;
// Copio la stringa in tmp_expression in splittedExpression
for (b = 0; b < DIM_STRINGA_FINALE; b++)
{
splittedExpression[expressionNumber][b] = tmp_expression[b];
}
// Incremento il numero di espressioni estrette dalle parentesi
// di livello maggiore nel ciclo corrente
expressionNumber++;
}
}
/*
A questo punto splittedExpression[][] avrà tutte le espressioni
contenute nelle parentesi più interne della prima espressione
che devo risolvere. Il numero di espressioni estratte è determinato
da (expressionNumber - 1).
*/
// Risolvo tutte le espressioni
// ============================
// Ciclo su tutte le expressioni
for (a = 0; a <= expressionNumber; a++)
{
// Ciclo su tutti gli elementi dell'array
// Prima controlla la presenza di radici
for (int b = 0; splittedExpression[a][b] != '\0';)
{
double secondoOperatore, risultato;
// Se c'è scritta la r e dopo la r c'è un numero allora svolgo la raltrimenti lascio che prima venga svolto il resto
if (splittedExpression[a][b] == 'r' && ((int)splittedExpression[a][b + 1] < 48 || (int)splittedExpression[a][b + 1] > 57) && splittedExpression[a][b + 1] != '+' && splittedExpression[a][b + 1] != '-')
{
riesegui = true;
break;
}
if (splittedExpression[a][b] == 'r' && (((int)splittedExpression[a][b + 1] >= 48 && (int)splittedExpression[a][b + 1] <= 57) || splittedExpression[a][b + 1] == '+' || splittedExpression[a][b + 1] == '-'))
{
// Ho trovato una radice
//find_first_second_operator(splittedExpression[a], b,
//primoOperatore, secondoOperatore);
secondoOperatore = find_argument(splittedExpression[a], b);
risultato = sqrt(secondoOperatore);
if (risultato < 0)
{
cout << "\nNo number to the power of 2 is negative.\nThe program is not yet able to handle complex number.\n";
return;
}
substitute_result(splittedExpression[a], b, risultato);
//b = 0;
cout << '\n' << splittedExpression[a];
continue;
}
b++;
}
// Controllo la presenza di funzione trigonometriche nell'espressione
for (b = 0; splittedExpression[a][b] != '\0';)
{
double risultato;
switch((char)splittedExpression[a][b])
{
// Se c'è scritta una di queste lettere controllo se è una funzione trigonometrica
case 's':
case 'c':
case 't':
case 'a':
{
double argomento = find_argument(splittedExpression[a], b);
short int tipo_trigonometrica = istrigonometric(b, splittedExpression[a]);
// So che è una trigonometrica, prima sapevo solamente che era una
// parola che cominciava per quella lettera.
if (tipo_trigonometrica)
{
switch(tipo_trigonometrica)
{
case 1: {risultato = sin(argomento); break;}
case 2: {risultato = cos(argomento); break;}
case 3: {risultato = tan(argomento); break;}
case 4: {risultato = asin(argomento); break;}
case 5: {risultato = acos(argomento); break;}
case 6: {risultato = atan(argomento); break;}
case 7: {risultato = 1/tan(argomento); break;}
case 8: {risultato = 1/cos(argomento); break;}
case 9: {risultato = 1/sin(argomento); break;}
}
substitute_result(splittedExpression[a], b, risultato);
b = 0;
//cout << '\n' << splittedExpression[a];
continue;
}
else
{
cout << "\nError! Not recognised symbol.";
getch();
return;
}
}
}
b++;
}
// e successivamente di potenze
for (b = 0; splittedExpression[a][b] != '\0';)
{
double primoOperatore, secondoOperatore, risultato;
if (splittedExpression[a][b] == '^')
{
// Ho trovato una potenza
find_first_second_operator(splittedExpression[a], b,
primoOperatore, secondoOperatore);
risultato = pow(primoOperatore, secondoOperatore);
sostituisci(a, b, risultato);
b = 0;
cout << '\n' << splittedExpression[a];
break;
}
b++;
}
for (b = 0; splittedExpression[a][b] != '\0';)
{
double primoOperatore, secondoOperatore, risultato;
switch((char)splittedExpression[a][b])
{
case '*':
{
find_first_second_operator(splittedExpression[a], b,
primoOperatore, secondoOperatore);
risultato = primoOperatore * secondoOperatore;
sostituisci(a, b, risultato);
b = 0;
cout << '\n' << splittedExpression[a];
break;
}
case '/':
{
find_first_second_operator(splittedExpression[a], b,
primoOperatore, secondoOperatore);
risultato = primoOperatore / secondoOperatore;
sostituisci(a, b, risultato);
b = 0;
cout << '\n' << splittedExpression[a];
break;
}
default: b++;
}
}
for (b = 0; splittedExpression[a][b] != '\0';)
{
/*
1. Trovo la posizione del simbolo
2. Trovo i valori che stanno prima e dopo
NOTA: Se non c'è ne sono allora visualizzo un msg d'errore
3. Eseguo l'operazione determinata dal simbolo tra le due variabili
contenenti i due valori.
4. Sostituisco il risultato al posto dell'operazione.
5. Continua il ciclo
*/
double primoOperatore, secondoOperatore, risultato;
// Se trovo un simbolo presente tra quelli consentiti
switch((char)splittedExpression[a][b])
{
// In caso il simbolo sia + ...
case '+':
{
// Trovo valore prima e dopo
find_first_second_operator(splittedExpression[a], b /* posizione dell'operatore */,
primoOperatore, secondoOperatore /*Passo l'indirizzo della variabile*/);
// Eseguo l'operazione
risultato = primoOperatore + secondoOperatore;
// Sostituisco il risultato al posto dell'operazione
sostituisci(a /* indice */, b /* posizione dell'operatore*/, risultato);
// Azzero b per ricominciare da capo l'itering della stringa
b = 0;
// Showing the result
cout << '\n' << splittedExpression[a];
// breaking della case
break;
}
case '-':
{
// Devo controllare che il segno sia inteso come operando
if (b == 0) {b++; break;}
// Controllo che prima ci sia un numero
if (splittedExpression[a][b - 1] < 48 || splittedExpression[a][b - 1] > 57) {b++; break;}
find_first_second_operator(splittedExpression[a], b,
primoOperatore, secondoOperatore);
risultato = primoOperatore - secondoOperatore;
sostituisci(a, b, risultato);
b = 0;
cout << '\n' << splittedExpression[a];
break;
}
default: b++;
}
}
if (riesegui == true) {a = -1; riesegui = false;}
}
// Dovrei aver ottenuto un numero di valori senza operatori pari a (expressionNumber - 1)
// Visualizzo i risultati di tutte le parentesi (quelle con il lvello più alto
/*for (int a = 0; a < expressionNumber; a++)
{
cout << splittedExpression[expressionNumber];
}*/
// Risolvo tutte le espressioni
// Riciclo sull'espressione iniziale (expression[])
// Quando incontro una parentesi di livello massimo
// sostituisco il contenuto con il suo risultato.
/*
NOTA: Se c'è un simbolo prima della parentesi allora lo
lascio, altrimenti metto il *
*/
/*
Vado a sostituire i valori risolti delle parentesi più interne all'interno
dell'espressione intera e ricomincia il ciclo.
max_record_number = numero di parentesi;
max_level = livello massimo;
splittedExpression[] = espressioni da sostituire;
expressionNumber = numero di espressioni da sostituire;
expression[] = espressione intera da risolvere;3.30
*/
int numero_parentesi = max_record_number;
int b = 0;
for (a = 0; a <= numero_parentesi; a++)
{
if (par[a].level == max_level)
{
double numero = atof(splittedExpression[b++]);
sostituisci_parentesi(par[a].pos_open, par[a].pos_close, numero);
a = 0;
}
}
}
while(max_level > 1);
cout << "\n\n";
}
while(1);
cout << '\n';
return;
}
