char const *args_multiarg(int optchar)
{
if (optchar) // new option:
{
if (!str)
str = (char *)string_str(&args.d_option); // use full string
option = optchar; // save the option char
}
register char *pos = strchr(str, option);
if (pos)
{
size_t idx = pos - str;
*pos = ' '; // this option has now
// been processed.
return args.d_optarg[idx]; // return optionstr.
}
return PFAILED; // or return PFAILED
// in which case there was
// no option argument
}
void p_insert_chartab_ostream(register Parser *pp, char const *txt)
{
register String *sp = chartab_apply(txt);
ostream_insert(pp->d_outs_ptr, string_str(sp));
string_destructor(sp);
}
char const *args_optarg(int optchar)
{
register char const *opt = string_str(&args.d_option);
register char const *pos = strchr(opt, optchar);
return pos ? args.d_optarg[pos - opt] : 0;
}
char const *s_state_insert(register State *sp, char const *key,
char const *subst)
{
while (*key)
{
register char const *cp;
/* if key is in the set, switch to */
if ((cp = strchr(sp->d_str, *key)) != 0) /* that state */
sp = sp->d_next[cp - sp->d_str];
else
{ /* if not, add a new state to the */
size_t last = string_length(&sp->d_set); /* set */
string_addchar(&sp->d_set, (char)*key); /* add key's 1st char */
sp->d_str = string_str(&sp->d_set); /* and set the state's ptr */
/* add a new state */
new_size(&sp->d_next, last + 1, last, sizeof(State *));
sp = sp->d_next[last] = s_state_new();
}
key++; /* inspect the next key char */
}
/* all key chars exhausted: insert */
/* replacement text */
if (sp->d_replacement) /* oops, it's already there */
return sp->d_replacement; /* return the one found */
sp->d_replacement = new_str(subst);
return 0; /* here 0 indicates SUCCESS */
}
string GLFuncs::getVersionFromStr(char* str) {
string result;
if (str == NULL) {
result = "";
}
else {
string string_str(str);
regex re("^(\\d+)\\.(\\d+).*$");
// This will return a string with an integer with the Major and minor part of the version.
result = regex_replace(string_str, re, "$1$2");
}
return result;
}
void do_stack(const char *dirpath)
{
struct dirent *ent = NULL;
DIR *dir;
char path[BUFFSIZE];
stack *dirs;
string dirname;
dirs = stack_new(sizeof(string));
stack_push(dirs, string_str(dirpath));
while (!stack_empty(dirs)) {
stack_pop(dirs, &dirname);
if (!dirname.data) continue;
if ((dir = opendir(dirname.data)) == NULL) {
snprintf(path, BUFFSIZE, "目录打开失败 '%s'", dirname.data);
perror(path);
continue;
}
while ((ent = readdir(dir)) != NULL) {
snprintf(path, BUFFSIZE, "%s/%s", dirname.data, ent->d_name);
if (ent->d_type & DT_REG) {
calc_hash(path);
} else if (ent->d_type & DT_DIR) {
if (strcmp(ent->d_name, ".") != 0 &&
strcmp(ent->d_name, "..") != 0) {
stack_push(dirs, string_str(path));
}
}
}
closedir(dir);
}
}
HashItem *construct_tocentry(char const *key, char *rest)
{
size_t level;
char *section = string_firstword(&rest);
if (!section)
{
message_error("incomplete tocentry");
return 0;
}
string_strip(&rest);
/* find the section's index */
level = lines_find(section, section_levels, sizeofSectionLevels);
if (level == UFAILED) /* no section given is err. */
{
message_error("unknown toc-section `%s'", section);
free(section);
return 0;
}
free(section);
/* write <dd><dl> for deeper
levels */
for (; level > global.d_toclevel; ++global.d_toclevel)
lines_add(&global.d_toc, "<dd><dl>");
/* write </dl></dd> when returning
to shallower levels */
for (; level < global.d_toclevel; --global.d_toclevel)
lines_add(&global.d_toc, "</dl></dd>");
/* add a new entry */
lines_format(&global.d_toc,
"<dt>%s<a href=\"%s#l%u\">%s</a>%s</dt>",
toc_section[global.d_doctype][level][0],
string_str(&global.d_outName),
(unsigned)++s_lastLabelNr,
rest,
toc_section[global.d_doctype][level][1]);
return hashitem_construct(VOIDPTR, "", (void *)s_lastLabelNr, root_nop);
}
int main(int argc, char **argv)
{
String *cmd = string_new(0);
String *input = NULL;
if (argc == 1)
{
fprintf(stderr,
"Usage: %s [-s] prog [arg(s)]\n"
" -s: use system call, not std-input\n"
" prog: program or system call to execute\n"
" arg(s): optional arguments to prog\n"
"Input to prog is read from stdin, unless -s was specified\n"
" (don't make this too long, it's stored in a String first)\n"
"\n",
argv[0]);
exit(1);
}
bool syscall = !strcmp(argv[1], "-s");
if (syscall)
{
argc--;
argv++;
}
else
{
input = string_new(0);
char buffer[100];
fprintf(stderr, "Reading input from stdin...\n");
while (fgets(buffer, 100, stdin))
string_addstr(input, buffer);
fprintf(stderr, "Input will be:\n"
"`%s'\n", string_str(input));
}
while (*++argv)
{
string_addstr(cmd, *argv);
string_addchar(cmd, ' ');
}
fprintf(stderr, "Command will be:\n"
"`%s'\n", string_str(cmd));
message_setseverity(MSG_ALL);
message(MSG_NOTICE, "Creating Process");
Process process;
process_construct(&process, "process-demo", cmd,
input);
if (syscall)
process_system(&process);
else
process_fork(&process);
String const *out = process_output(&process);
fprintf(stderr, "Output from process: '\n"
"%s\n"
"'\n", string_str(out));
process_destroy(&process);
return 0;
}
int main (int argc, char **argv)
{
char const *doctype;
char const **ptr;
args_data = postqueue_data = message_data;
message_construct(argv[0]);
args_construct(argc, argv, "?x:l:", 0);
hashmap_construct(&symtab);
lines_construct(&global.d_toc);
lines_construct(&global.d_section);
lines_add(&global.d_section, "");
hashmap_constructText(&global.d_symbol, default_symbols);
if (!args_ok() || args_nArgs() < 2) /* check arguments */
usage();
if (args_nArgs() == 2) /* file name specified */
{
global.d_out = stdout;
global.d_noext = 0;
}
else
{
global.d_noext = file_rmExtension(args_arg(2));
global.d_ext = file_extension(args_arg(2));
if (!global.d_ext)
{
global.d_ext = new_str(args_optarg('x'));
if (!global.d_ext)
global.d_ext = "ypp"; /* Yodl Post Processor */
}
}
string_construct(&global.d_outName, 0);
postqueue_construct(task);
if (global.d_noext)
{
string_format(&global.d_outName, "%s.%s",
global.d_noext, global.d_ext);
global.d_out = file_open(string_str(&global.d_outName), "w");
}
doctypes[sizeofDocType - 1] =
doctype = hashmap_textOf(&global.d_symbol, "documenttype");
for
(
ptr = doctypes, global.d_doctype = 1;
strcmp(doctype, *ptr);
ptr++, global.d_doctype <<= 1
)
;
postqueue_process();
fclose(global.d_out);
return 0;
}
