static int print_socket_options(void) {
int fd, len;
SOCK_OPT *ptr;
OPT_UNION val;
char line[STRLEN];
fd=socket(AF_INET, SOCK_STREAM, 0);
log_raw("Socket option defaults:");
log_raw(" %-16s%-10s%-10s%-10s%-10s",
"Option", "Accept", "Local", "Remote", "OS default");
for(ptr=sock_opts; ptr->opt_str; ptr++) {
/* display option name */
sprintf(line, " %-16s", ptr->opt_str);
/* display stunnel default values */
print_option(line, ptr->opt_type, ptr->opt_val[0]);
print_option(line, ptr->opt_type, ptr->opt_val[1]);
print_option(line, ptr->opt_type, ptr->opt_val[2]);
/* display OS default value */
len = sizeof(val);
if(getsockopt(fd, ptr->opt_level, ptr->opt_name, (void *)&val, &len)) {
if(get_last_socket_error()!=ENOPROTOOPT) {
log_raw("%s", line); /* dump the name and assigned values */
sockerror("getsockopt");
return 0; /* FAILED */
}
safeconcat(line, " -- "); /* write-only value */
} else
print_option(line, ptr->opt_type, &val);
log_raw("%s", line);
}
return 1; /* OK */
}
void options::print_help()
{
cout << endl << "Help menu for MCSL converter" << endl;
cout << "\tMandatory options:" << endl;
print_option('f',"The file containing the scheduling problem.");
cout << "\tOptional options:" << endl;
print_option('o',"Specify the output directory for VHDL routing tables.");
print_option('s',"Specify the overallocation constant sigma");
print_option('h',"Shows the help menu, I guess you know that.");
cout << endl;
return exit(0);
}
void help(void)
{
printf("usage: gammu-smsd-inject [OPTION]... MSGTYPE RECIPIENT [MESSAGE_PARAMETER]...\n");
printf("options:\n");
print_option("h", "help", "shows this help");
print_option("v", "version", "shows version information");
print_option("l", "use-log", "use logging configuration from config file");
print_option("L", "no-use-log", "do not use logging configuration from config file (default)");
print_option_param("c", "config", "CONFIG_FILE",
"defines path to config file");
printf("\n");
printf("MSGTYPE and it's parameters are described in man page and Gammu documentation\n");
}
void help(void)
{
printf("usage: gammu-smsd-monitor [OPTION]...\n");
printf("options:\n");
print_option("h", "help", "shows this help");
print_option("v", "version", "shows version information");
print_option("C", "csv", "CSV output");
print_option_param("c", "config", "CONFIG_FILE",
"defines path to config file");
print_option_param("d", "delay", "DELAY",
"delay in seconds between loops");
print_option_param("l", "loops", "NUMBER",
"delay in seconds between loops");
}
int main(int argc, char *argv[])
{
region_t r;
cap_t fs_server;
if(argc != 2 && argc != 4) {
printf(_("Usage: %s /x=shell_options [OPTION_NAME on/off]\n"), argv[0]);
return 1;
}
if(get_process_caps("fs_op", &fs_server, NULL) < 0)
return 1;
{
cap_t opts;
struct cap_args result;
r = region_make();
cap_call(fs_server, r,
cap_args_make(cat2(r, mk_int(r, METHOD_FSOP_GET_OBJ),
mk_string(r, argv[1])),
caps_empty, fds_empty),
&result);
filesys_obj_free(fs_server);
if(expect_cap1(result, &opts) < 0) {
fprintf(stderr, _("%s: couldn't get options object\n"), argv[0]);
return 1;
}
if(argc == 2) {
print_option(r, opts, "log_summary");
print_option(r, opts, "log_into_xterm");
print_option(r, opts, "print_fs_tree");
print_option(r, opts, "enable_x11");
}
else if(argc == 4) {
int x;
if(!strcmp(argv[3], "on")) x = 1;
else if(!strcmp(argv[3], "off")) x = 0;
else {
fprintf(stderr, _("value `%s' not recognised\n"), argv[3]);
return 1;
}
set_option(r, opts, argv[2], x);
}
else assert(0);
}
return 0;
}
static std::ostream&
operator<<(
std::ostream& stream
, const tfilter_description& fd)
{
print_option(stream, fd.name, fd.description);
BOOST_FOREACH(const tfilter_description::tparameter& p, fd.parameters) {
print_option(
stream
, " * " + p.name + " (" + p.type + ")"
, p.descripton);
}
return stream;
}
void show_directives(void)
{
while(mini_next(ini)) {
if(!ini->key) { print_section(ini); }
else { print_option(ini); }
}
}
static void
options_cmd (int func_no, cuc_func * f)
{
int b, i;
char tmp[30];
char *name = prof_func[func_no].name;
PRINTF
("-----------------------------------------------------------------------------\n");
PRINTF ("|%-28s|pre/unrolled|shared| time | gates |old_time|\n",
strstrip (tmp, name, 28));
PRINTF ("| BASE |%4i / %4i | %4i |%8i|%8.f|%8i|\n", 1,
1, 0, f->timings.new_time, f->timings.size, f->orig_time);
for (b = 0; b < f->num_bb; b++)
{
/* Print out results */
for (i = 1; i < f->bb[b].ntim; i++)
{ /* First one is base option */
int time = f->bb[b].tim[i].new_time - f->timings.new_time;
double size = f->bb[b].tim[i].size - f->timings.size;
PRINTF ("| ");
print_option (b, i);
PRINTF (" |%4i / %4i | %4i |%+8i|%+8.f| |\n",
f->bb[b].tim[i].preroll, f->bb[b].tim[i].unroll,
f->bb[b].tim[i].nshared, time, size);
}
}
}
static void urlinfo_set_params (urlinfo *u, CGIOpt opt,
const char *fname,
const char *series,
int filter)
{
strcat(u->url, "?opt=");
strcat(u->url, print_option(opt));
if (fname != NULL) {
if (opt == GRAB_FILE || opt == GRAB_FUNC ||
opt == GRAB_FUNC_INFO || opt == FUNC_FULLNAME) {
strcat(u->url, "&fname=");
} else {
strcat(u->url, "&dbase=");
}
strcat(u->url, fname);
}
if (series != NULL) {
strcat(u->url, "&series=");
strcat(u->url, series);
}
if (filter > 0) {
char fstr[8];
sprintf(fstr, "%d", filter);
strcat(u->url, "&filter=");
strcat(u->url, fstr);
}
}
static void
dccp_print(const void *ip, const struct xt_entry_match *match, int numeric)
{
const struct xt_dccp_info *einfo =
(const struct xt_dccp_info *)match->data;
printf(" dccp");
if (einfo->flags & XT_DCCP_SRC_PORTS) {
print_ports("spt", einfo->spts[0], einfo->spts[1],
einfo->invflags & XT_DCCP_SRC_PORTS,
numeric);
}
if (einfo->flags & XT_DCCP_DEST_PORTS) {
print_ports("dpt", einfo->dpts[0], einfo->dpts[1],
einfo->invflags & XT_DCCP_DEST_PORTS,
numeric);
}
if (einfo->flags & XT_DCCP_TYPE) {
print_types(einfo->typemask,
einfo->invflags & XT_DCCP_TYPE,
numeric);
}
if (einfo->flags & XT_DCCP_OPTION) {
print_option(einfo->option,
einfo->invflags & XT_DCCP_OPTION, numeric);
}
}
void print_options ( void )
{
// Check output filedescriptor
int is_term = isatty ( fileno ( stdout ) );
unsigned int entries = sizeof ( xrmOptions ) / sizeof ( *xrmOptions );
for ( unsigned int i = 0; i < entries; ++i ) {
if ( ( i + 1 ) < entries ) {
if ( xrmOptions[i].value.str == xrmOptions[i + 1].value.str ) {
continue;
}
}
print_option ( &xrmOptions[i], is_term );
}
for ( unsigned int i = 0; i < num_extra_options; i++ ) {
print_option ( &extra_options[i], is_term );
}
}
void print_options(mc_options_list_t* list) {
uint32_t ioption;
for (ioption = 0; ioption < list->noptions; ioption++) {
print_option(list->options + ioption);
}
}
int main(int argc, char **argv){
struct option opt;
FILE *IN;
char *str;
char cc;
int len = 0;
/* (* option setting */
init_option(&opt);
get_option(argc-1, argv+1, &opt);
if(opt.help == 1){
help();
}
if(opt.check == 1){
print_option(opt);
}
if((opt.help == 1)||(opt.check == 1)||(strlen(opt.file) < 1)){
exit(0);
}
/* *) */
/* (* allocation */
if((str = malloc(sizeof(char) * opt.total_size)) == NULL){
fprintf(stderr,"failed: malloc() -- exit.\n");
exit(1);
}
/* *) */
IN = fopen(opt.file,"r");
if(opt.fasta == 1){
cc = getc(IN);
if(cc == '>'){
while((cc = getc(IN)) != '\n'){
}
}else{
fprintf(stderr,"not FASTA format.\n");
*(str+len) = cc;
len++;
}
}
if(opt.space == 0){
while((cc = getc(IN)) != EOF){
if((cc != '\n')&&(cc != ' ')&&(cc != '\t')){
*(str+len) = cc;
len++;
}
}
}else if(opt.space == 1){
while((cc = getc(IN)) != EOF){
*(str+len) = cc;
len++;
}
}
fclose(IN);
if(opt.header == 0){
print_frg(opt.segment_size, opt.gap_size, opt.offset, str);
}else if(opt.header == 1){
print_frg_h(opt.segment_size, opt.gap_size, opt.offset, str, opt.head, opt.count_start, opt.format);
}
return(0);
}
static void print_usage(char*name) {
warning("\n");
warning("USAGE\t: %s $file [$options]\n", name);
warning("OPTIONS\t:\n");
print_option("-o $dst_file\t: place output in file $dst_file");
print_option("-l [$lst_file]\t: place list output in file $lst_file");
print_option("-b $line_num\t: output binary string");
print_option("-x $line_num\t: output hexadecimal string");
print_option("-c $line_num\t: output coe format string");
print_option("-p\t: pad nop for pocore");
print_option("-h\t: print this usage information");
print_option("-m\t: output code after expanding mnemonic");
print_option("-q\t: don't print configure information");
warning("\n");
}
static void show_opts(const AVOption *opts, int per_stream)
{
const AVOption *o;
printf("@table @option\n");
for (o = opts; o->name; o++) {
if (o->type != AV_OPT_TYPE_CONST)
print_option(opts, o, per_stream);
}
printf("@end table\n");
}
void show_section(void)
{
int in_section = (section_name[0] == '\0');
while(mini_next(ini)) {
if(!ini->key) {
const char *section = ini->section ? ini->section : "";
in_section = (strcmp(section, section_name) == 0);
} else if(in_section) {
print_option(ini);
}
}
}
int print_options_list(OptionsListPtr options_list)
{
if(options_list == NULL)
return 1;
OptionPtr opt_ptr;
for(opt_ptr = options_list -> lh_first; opt_ptr != NULL; opt_ptr = opt_ptr -> entries.le_next)
print_option(opt_ptr);
return 0;
}
/** @brief Display usage message and options list
*/
void optparse_help(void)
{
option_decl_t *opt = options;
printf("Usage: %s [options] [arguments]\n\n", prg_name);
printf("Options:\n");
printf(" --help display help\n");
printf(" --version display version information\n");
for (opt = options; opt->name_short != 0 && opt->name_long != NULL; opt++) {
print_option(opt);
}
}
void bootmenu_hook(int activity)
{
static int next = 1, on = 1;
static const struct option *option = options;
static int seconds = 0;
int tmp;
if (activity)
seconds = 0;
tmp = setup->next_key(setup->user);
if (tmp && !next) {
print_option(option, 0);
option++;
if (option == options+num_options)
option = options;
print_option(option, 1);
seconds = 0;
}
next = tmp;
tmp = setup->enter_key(setup->user);
if (tmp && !on) {
do_option(option);
option = options;
seconds = 0;
}
on = tmp;
if (setup->seconds(setup->user)) {
int timeout;
timeout = get_var_positive_int("boot_menu_timeout",
BOOT_MENU_TIMEOUT);
if (timeout < MIN_BOOT_MENU_TIMEOUT)
timeout = MIN_BOOT_MENU_TIMEOUT;
if (++seconds > timeout) {
setup->idle_action(setup->idle_action);
seconds = 0;
}
}
}
int tui_check_notice(const char *board_name)
{
screen_move_clear(-1);
prints("\033[m\xb2\xe9\xbf\xb4:");
int replies, mentions;
notice_count(&replies, &mentions);
print_option("\xc8\xa1\xcf\xfb", NULL, 0, 0);
print_option("\xbb\xd8\xb8\xb4", "\xc6\xaa", replies, 1);
print_option("\xcc\xe1\xbc\xb0", "\xc6\xaa", mentions, 2);
int choice = 0;
if (replies)
choice = 1;
else if (mentions)
choice = 2;
prints(" [%d]: ", choice);
char ans[2];
int x, y;
screen_coordinates(&x, &y);
getdata(x, y, "", ans, sizeof(ans), true, true);
if (*ans == '\0')
*ans = '0' + choice;
if (*ans == '1') {
post_list_reply();
brc_init(currentuser.userid, board_name);
return FULLUPDATE;
}
if (*ans == '2') {
post_list_mention();
brc_init(currentuser.userid, board_name);
return FULLUPDATE;
}
return MINIUPDATE;
}
static size_t
dhcp_envoption1(char **env, const char *prefix,
const struct dhcp_opt *opt, int vname, const uint8_t *od, int ol,
const char *ifname)
{
ssize_t len;
size_t e;
char *v, *val;
if (opt->len && opt->len < ol)
ol = opt->len;
len = print_option(NULL, 0, opt->type, ol, od, ifname);
if (len < 0)
return 0;
if (vname)
e = strlen(opt->var) + 1;
else
e = 0;
if (prefix)
e += strlen(prefix);
e += len + 4;
if (env == NULL)
return e;
v = val = *env = malloc(e);
if (v == NULL) {
syslog(LOG_ERR, "%s: %m", __func__);
return 0;
}
if (vname)
v += snprintf(val, e, "%s_%s=", prefix, opt->var);
else
v += snprintf(val, e, "%s=", prefix);
if (len != 0)
print_option(v, len, opt->type, ol, od, ifname);
return e;
}
void
handle_suboption(unsigned char *suboptp, int subsize)
{
unsigned char subopt = *suboptp;
print_option(subopt);
switch (subopt) {
case NVT_COM_PORT_OPTION:
handle_com_port_command(++suboptp);
subsize--;
break;
default:
sysmessage(MSG_WARNING, "suboption not supported: %d\n", subopt);
break;
}
}
int main(int argc, char *argv[])
{
SPU *spu;
SPUOptions *opt;
int pythonMode = 0;
int i = 1;
while (i < argc) {
if (crStrcmp(argv[i], "--pythonmode") == 0) {
pythonMode = 1;
}
else {
const char *spuName = argv[i];
int i;
/* loop to walk up the inheritance tree */
for (i = 0; ; i++) {
spu = SPULoadLite( NULL, 1, spuName, NULL, NULL );
if (i == 0) {
print_spu_header( spu, pythonMode );
}
for ( opt = &spu->options[0] ; opt->option ; opt++ )
print_option( opt, pythonMode );
if (spu && spu->super_name) {
/* traverse up to parent SPU class to get its options */
spuName = spu->super_name;
}
else {
break;
}
}
print_spu_footer( spu, pythonMode );
/* How to unload the spu???
*/
}
i++;
}
return 0;
}
static void show_bootmenu(void)
{
const struct option *option;
bm_printf(ANSI_CLEAR ANSI_GOTOYX "\n\n%s", TOP_ROW, 1, version_string);
if (setup->comment)
bm_printf(ANSI_GOTOYX "\n*** BOOT MENU (%s) ***",
TOP_ROW+3, 1, setup->comment);
else
bm_printf(ANSI_GOTOYX "\n*** BOOT MENU ***", TOP_ROW+3, 1);
bm_printf(ANSI_GOTOYX, MENU_0_ROW, 1);
for (option = options; option != options+num_options; option++)
print_option(option, option == options);
bm_printf("\n\n%s to select, %s to execute.\n",
setup->next_key_action, setup->enter_key_name);
}
static void
tcp_print(const void *ip, const struct xt_entry_match *match, int numeric)
{
const struct xt_tcp *tcp = (struct xt_tcp *)match->data;
printf("tcp ");
print_ports("spt", tcp->spts[0], tcp->spts[1],
tcp->invflags & XT_TCP_INV_SRCPT,
numeric);
print_ports("dpt", tcp->dpts[0], tcp->dpts[1],
tcp->invflags & XT_TCP_INV_DSTPT,
numeric);
print_option(tcp->option,
tcp->invflags & XT_TCP_INV_OPTION,
numeric);
print_flags(tcp->flg_mask, tcp->flg_cmp,
tcp->invflags & XT_TCP_INV_FLAGS,
numeric);
if (tcp->invflags & ~XT_TCP_INV_MASK)
printf("Unknown invflags: 0x%X ",
tcp->invflags & ~XT_TCP_INV_MASK);
}
int main(int argc, char *argv[])
{
int argi;
char buf[4096];
struct clopt *opt;
optparse_print(&g_options, buf, sizeof(buf));
printf("usage: %s [options] [args]\n%s\n", argv[0], buf);
optparse_reset(&g_options, argc, argv);
while ( !(argi = optparse_next(&g_options, &opt)) ) {
print_option(opt);
}
if ( argi < 0 ) {
err("Error -- %s\n", g_options.errbuf);
return -1;
}
for ( ; argi < argc ; ++argi )
printf("Argument: '%s'\n", argv[argi]);
return 0;
}
/** check config file */
static void
checkconf(const char* cfgfile, const char* opt)
{
struct config_file* cfg = config_create();
if(!cfg)
fatal_exit("out of memory");
if(!config_read(cfg, cfgfile, NULL)) {
/* config_read prints messages to stderr */
config_delete(cfg);
exit(1);
}
morechecks(cfg, cfgfile);
check_mod(cfg, iter_get_funcblock());
check_mod(cfg, val_get_funcblock());
#ifdef WITH_PYTHONMODULE
if(strstr(cfg->module_conf, "python"))
check_mod(cfg, pythonmod_get_funcblock());
#endif
check_fwd(cfg);
check_hints(cfg);
if(opt) print_option(cfg, opt);
else printf("unbound-checkconf: no errors in %s\n", cfgfile);
config_delete(cfg);
}
ssize_t
print_option(char *s, ssize_t len, int type, int dl, const uint8_t *data,
const char *ifname)
{
const uint8_t *e, *t;
uint16_t u16;
int16_t s16;
uint32_t u32;
int32_t s32;
struct in_addr addr;
ssize_t bytes = 0;
ssize_t l;
char *tmp;
if (type & RFC3397) {
l = decode_rfc3397(NULL, 0, dl, data);
if (l < 1)
return l;
tmp = malloc(l);
if (tmp == NULL)
return -1;
decode_rfc3397(tmp, l, dl, data);
l = print_string(s, len, l - 1, (uint8_t *)tmp);
free(tmp);
return l;
}
#ifdef INET
if (type & RFC3361) {
if ((tmp = decode_rfc3361(dl, data)) == NULL)
return -1;
l = strlen(tmp);
l = print_string(s, len, l - 1, (uint8_t *)tmp);
free(tmp);
return l;
}
if (type & RFC3442)
return decode_rfc3442(s, len, dl, data);
if (type & RFC5969)
return decode_rfc5969(s, len, dl, data);
#endif
if (type & STRING) {
/* Some DHCP servers return NULL strings */
if (*data == '\0')
return 0;
return print_string(s, len, dl, data);
}
if (type & FLAG) {
if (s) {
*s++ = '1';
*s = '\0';
}
return 2;
}
/* DHCPv6 status code */
if (type & SCODE && dl >= (int)sizeof(u16)) {
if (s) {
memcpy(&u16, data, sizeof(u16));
u16 = ntohs(u16);
l = snprintf(s, len, "%d ", u16);
len -= l;
} else
l = 7;
data += sizeof(u16);
dl -= sizeof(u16);
if (dl)
l += print_option(s, len, STRING, dl, data, ifname);
return l;
}
if (!s) {
if (type & UINT8)
l = 3;
else if (type & UINT16) {
l = 5;
dl /= 2;
} else if (type & SINT16) {
l = 6;
dl /= 2;
} else if (type & UINT32) {
l = 10;
dl /= 4;
} else if (type & SINT32) {
l = 11;
dl /= 4;
} else if (type & ADDRIPV4) {
l = 16;
dl /= 4;
}
#ifdef INET6
else if (type & ADDRIPV6) {
e = data + dl;
l = 0;
while (data < e) {
if (l)
l++; /* space */
dl = ipv6_printaddr(NULL, 0, data, ifname);
if (dl != -1)
l += dl;
data += 16;
}
return l + 1;
}
#endif
else if (type & BINHEX) {
l = 2;
} else {
errno = EINVAL;
return -1;
}
return (l + 1) * dl;
}
t = data;
e = data + dl;
while (data < e) {
if (data != t && type != BINHEX) {
*s++ = ' ';
bytes++;
len--;
}
if (type & UINT8) {
l = snprintf(s, len, "%d", *data);
data++;
} else if (type & UINT16) {
memcpy(&u16, data, sizeof(u16));
u16 = ntohs(u16);
l = snprintf(s, len, "%d", u16);
data += sizeof(u16);
} else if (type & SINT16) {
memcpy(&s16, data, sizeof(s16));
s16 = ntohs(s16);
l = snprintf(s, len, "%d", s16);
data += sizeof(s16);
} else if (type & UINT32) {
memcpy(&u32, data, sizeof(u32));
u32 = ntohl(u32);
l = snprintf(s, len, "%d", u32);
data += sizeof(u32);
} else if (type & SINT32) {
memcpy(&s32, data, sizeof(s32));
s32 = ntohl(s32);
l = snprintf(s, len, "%d", s32);
data += sizeof(s32);
} else if (type & ADDRIPV4) {
memcpy(&addr.s_addr, data, sizeof(addr.s_addr));
l = snprintf(s, len, "%s", inet_ntoa(addr));
data += sizeof(addr.s_addr);
}
#ifdef INET6
else if (type & ADDRIPV6) {
dl = ipv6_printaddr(s, len, data, ifname);
if (dl != -1)
l = dl;
else
l = 0;
data += 16;
}
#endif
else if (type & BINHEX) {
l = snprintf(s, len, "%.2x", data[0]);
data++;
} else
l = 0;
len -= l;
bytes += l;
s += l;
}
return bytes;
}
int
tel_getdata(void)
{
int i;
int ret;
struct buffer *bp = Nvt.inbuff;
unsigned char c;
if ((ret = sock_read(Comibuf, Nvt.iosize)) <= 0)
return -1;
if (Debug > 2) {
sysmessage(MSG_DEBUG,
"Sock_read, %d bytes: %02X %02X %02X %02X %02X %02X %02X %02X\n",
ret, Comibuf[0], Comibuf[1], Comibuf[2], Comibuf[3],
Comibuf[4], Comibuf[5], Comibuf[6], Comibuf[7]);
}
if (Nvt.servertype == SRV_SOCKET) {
COPY_TO_BUFFER(bp, Comibuf, ret);
SET_EVENT(EV_RN, EV_RNDATA, 0, 0);
return (0);
}
for (i = 0; i < ret; i++) {
c = Comibuf[i];
switch (S_state) {
case S_DATA:
if (c == IAC) {
S_state = S_IAC;
print_control(c);
}
else {
PUT_BUFFER(bp, c);
/* Event EV_RNDATA will be set at end */
}
break;
case S_IAC:
switch (c) {
case DO:
S_state = S_DO;
print_control(c);
break;
case DONT:
S_state = S_DONT;
print_control(c);
break;
case WILL:
S_state = S_WILL;
print_control(c);
break;
case WONT:
S_state = S_WONT;
print_control(c);
break;
case SB:
S_state = S_SB;
print_control(c);
Suboptsize = 0;
break;
case IAC:
default:
S_state = S_DATA;
PUT_BUFFER(bp, c);
break;
}
break;
case S_DO:
print_option(c);
S_state = S_DATA;
do_option(c);
break;
case S_DONT:
print_option(c);
S_state = S_DATA;
dont_option(c);
break;
case S_WILL:
print_option(c);
S_state = S_DATA;
will_option(c);
break;
case S_WONT:
print_option(c);
S_state = S_DATA;
wont_option(c);
break;
case S_SB:
if (c == IAC) {
S_state = S_SE;
print_control(c);
}
else {
if (Suboptsize > SUBOPT_MAXSIZE) {
sysmessage(MSG_WARNING, "Suboption too large\n");
}
else {
Suboptbuf[Suboptsize++] = c;
}
}
break;
case S_SE:
if (c == SE) {
S_state = S_DATA;
print_control(c);
handle_suboption(Suboptbuf, Suboptsize);
Suboptsize = 0;
}
else {
S_state = S_DATA;
sysmessage(MSG_WARNING, "Suboption not terminated: %d", c);
}
break;
}
}
if (bp->b_hold) {
SET_EVENT(EV_RN, EV_RNDATA, 0, 0);
}
print_all();
return (0);
}
void
print_help(const char *basename) {
/* usage */
printf("Usage: %s [OPTION]... [FILE]\n\n", basename);
/* description */
printf("Process the Markdown in FILE (or standard input) and render it to standard output, using the Hoedown library. "
"Parsing and rendering can be customized through the options below. The default is to parse pure markdown and output HTML.\n\n");
/* main options */
printf("Main options:\n");
print_option('n', "max-nesting=N", "Maximum level of block nesting parsed. Default is " str(DEF_MAX_NESTING) ".");
print_option('t', "toc-level=N", "Maximum level for headers included in the TOC. Zero disables TOC (the default).");
print_option( 0, "html", "Render (X)HTML. The default.");
print_option( 0, "html-toc", "Render the Table of Contents in (X)HTML.");
print_option( 0, "null", "Use a special \"null\" renderer that has no callbacks.");
print_option('T', "time", "Show time spent in rendering.");
print_option('i', "input-unit=N", "Reading block size. Default is " str(DEF_IUNIT) ".");
print_option('o', "output-unit=N", "Writing block size. Default is " str(DEF_OUNIT) ".");
print_option('h', "help", "Print this help text.");
print_option('v', "version", "Print Hoedown version.");
printf("\n");
/* extensions */
size_t i;
size_t e;
for (i = 0; i < count_of(categories_info); i++) {
struct extension_category_info *category = categories_info+i;
printf("%s (--%s%s):\n", category->label, category_prefix, category->option_name);
for (e = 0; e < count_of(extensions_info); e++) {
struct extension_info *extension = extensions_info+e;
if (extension->flag & category->flags) {
print_option( 0, extension->option_name, extension->description);
}
}
printf("\n");
}
/* html-specific */
printf("HTML-specific options:\n");
for (i = 0; i < count_of(html_flags_info); i++) {
struct html_flag_info *html_flag = html_flags_info+i;
print_option( 0, html_flag->option_name, html_flag->description);
}
printf("\n");
/* ending */
printf("Flags and extensions can be negated by prepending 'no' to them, as in '--no-tables', '--no-span' or '--no-escape'. "
"Options are processed in order, so in case of contradictory options the last specified stands.\n\n");
printf("When FILE is '-', read standard input. If no FILE was given, read standard input. Use '--' to signal end of option parsing. "
"Exit status is 0 if no errors occured, 1 with option parsing errors, 4 with memory allocation errors or 5 with I/O errors.\n\n");
}