static int
compare_lists (char **ret, char **expected,
int (*compare) (const char *, const char *))
{
size_t i;
for (i = 0; ret[i] != NULL; ++i) {
if (!expected[i]) {
fprintf (stderr, "test failed: returned list is too long\n");
goto fail;
}
if (compare (ret[i], expected[i]) != 0) {
fprintf (stderr, "test failed: elements differ at position %zu\n", i);
goto fail;
}
}
if (expected[i]) {
fprintf (stderr, "test failed: returned list is too short\n");
goto fail;
}
return 1; /* test expecting true for OK */
fail:
fprintf (stderr, "returned list was:\n");
print_strings (ret);
fprintf (stderr, "expected list was:\n");
print_strings (expected);
return 0; /* test expecting false for failure */
}
static bool test_set_get_includes(struct smbconf_ctx *ctx)
{
sbcErr err;
uint32_t count;
bool ret = false;
const char *set_includes[] = {
"/path/to/include1",
"/path/to/include2"
};
uint32_t set_num_includes = 2;
char **get_includes = NULL;
uint32_t get_num_includes = 0;
TALLOC_CTX *mem_ctx = talloc_stackframe();
printf("TEST: set_get_includes\n");
err = smbconf_set_global_includes(ctx, set_num_includes, set_includes);
if (!SBC_ERROR_IS_OK(err)) {
printf("FAIL: get_set_includes (setting includes) - %s\n",
sbcErrorString(err));
goto done;
}
err = smbconf_get_global_includes(ctx, mem_ctx, &get_num_includes,
&get_includes);
if (!SBC_ERROR_IS_OK(err)) {
printf("FAIL: get_set_includes (getting includes) - %s\n",
sbcErrorString(err));
goto done;
}
if (get_num_includes != set_num_includes) {
printf("FAIL: get_set_includes - set %d includes, got %d\n",
set_num_includes, get_num_includes);
goto done;
}
for (count = 0; count < get_num_includes; count++) {
if (!strequal(set_includes[count], get_includes[count])) {
printf("expected: \n");
print_strings("* ", set_num_includes,
(const char * const *)set_includes);
printf("got: \n");
print_strings("* ", get_num_includes,
(const char * const *)get_includes);
printf("FAIL: get_set_includes - data mismatch:\n");
goto done;
}
}
printf("OK: set_includes\n");
ret = true;
done:
talloc_free(mem_ctx);
return ret;
}
static bool test_set_get_includes(struct smbconf_ctx *ctx)
{
WERROR werr;
uint32_t count;
bool ret = false;
const char *set_includes[] = {
"/path/to/include1",
"/path/to/include2"
};
uint32_t set_num_includes = 2;
char **get_includes = NULL;
uint32_t get_num_includes = 0;
TALLOC_CTX *mem_ctx = talloc_stackframe();
printf("test: set_get_includes\n");
werr = smbconf_set_global_includes(ctx, set_num_includes, set_includes);
if (!W_ERROR_IS_OK(werr)) {
printf("failure: get_set_includes (setting includes) - %s\n",
dos_errstr(werr));
goto done;
}
werr = smbconf_get_global_includes(ctx, mem_ctx, &get_num_includes,
&get_includes);
if (!W_ERROR_IS_OK(werr)) {
printf("failure: get_set_includes (getting includes) - %s\n",
dos_errstr(werr));
goto done;
}
if (get_num_includes != set_num_includes) {
printf("failure: get_set_includes - set %d includes, got %d\n",
set_num_includes, get_num_includes);
goto done;
}
for (count = 0; count < get_num_includes; count++) {
if (!strequal(set_includes[count], get_includes[count])) {
printf("expected: \n");
print_strings("* ", set_num_includes, set_includes);
printf("got: \n");
print_strings("* ", get_num_includes,
(const char **)get_includes);
printf("failure: get_set_includes - data mismatch:\n");
goto done;
}
}
printf("success: set_includes\n");
ret = true;
done:
TALLOC_FREE(mem_ctx);
return ret;
}
static bool test_get_includes(struct smbconf_ctx *ctx)
{
sbcErr err;
bool ret = false;
uint32_t num_includes = 0;
char **includes = NULL;
TALLOC_CTX *mem_ctx = talloc_stackframe();
printf("TEST: get_includes\n");
err = smbconf_get_global_includes(ctx, mem_ctx,
&num_includes, &includes);
if (!SBC_ERROR_IS_OK(err)) {
printf("FAIL: get_includes - %s\n", sbcErrorString(err));
goto done;
}
printf("got %u includes%s\n", num_includes,
(num_includes > 0) ? ":" : ".");
print_strings("", num_includes, (const char **)includes);
printf("OK: get_includes\n");
ret = true;
done:
talloc_free(mem_ctx);
return ret;
}
static bool test_get_includes(struct smbconf_ctx *ctx)
{
WERROR werr;
bool ret = false;
uint32_t num_includes = 0;
char **includes = NULL;
TALLOC_CTX *mem_ctx = talloc_stackframe();
printf("test: get_includes\n");
werr = smbconf_get_global_includes(ctx, mem_ctx,
&num_includes, &includes);
if (!W_ERROR_IS_OK(werr)) {
printf("failure: get_includes - %s\n", dos_errstr(werr));
goto done;
}
printf("got %u includes%s\n", num_includes,
(num_includes > 0) ? ":" : ".");
print_strings("", num_includes, (const char **)includes);
printf("success: get_includes\n");
ret = true;
done:
TALLOC_FREE(mem_ctx);
return ret;
}
int main(void)
{
char *message[8] = { "Four", "score", "and", "seven",
"years", "ago,", "our", "forefathers" };
print_strings(message, 8);
printf ("\n");
return 0;
}
static void normalize(int n) {
const int p = page;
if (n < 0 ) n = 0;
if (n >= rl.cur_entries ) n = rl.cur_entries - 1;
x = N2X(n);
y = N2Y(n);
page = N2P(n);
if ( p != page ) print_strings();
}
int main() {
print_strings("print_strings", "a", "b", "c", NULL);
print_strings("print_strings", "a", "b", "c", (void *)NULL);
/* WARN: missing sentinel. */
/*print_strings("a", "b", "c");*/
/* Nope, 0 does not work, need the pointer. */
/*print_strings("a", "b", "c", 0);*/
/*
execl is a prototypical example of null termination of vararg..
It is impemented as a GCC 5.2 built-in.
*/
{
/*execl("/usr/bin/env", "echo", "a", "b");*/
}
return EXIT_SUCCESS;
}
int main(){
int number_of_lines;
number_of_lines = get_lines(lines);
if(number_of_lines < 0)
{
puts("Erreur d'Allocation mémoire");
exit(EXIT_FAILURE);
}
sort(lines, number_of_lines);
print_strings(lines, number_of_lines);
return 0;
}
void
print_rc_style (GtkRcStyle *rc, GtkStyle *style)
{
if (print_rc_colors ("fg", rc->fg, 5, rc->color_flags, GTK_RC_FG))
print_colors ("fg", style->fg, 5);
if (print_rc_colors ("bg", rc->bg, 5, rc->color_flags, GTK_RC_BG))
print_colors ("bg", style->bg, 5);
if (print_rc_colors ("text", rc->text, 5, rc->color_flags, GTK_RC_TEXT))
print_colors ("text", style->text, 5);
if (print_rc_colors ("base", rc->base, 5, rc->color_flags, GTK_RC_BASE))
print_colors ("base", style->base, 5);
print_colors ("light", style->light, 5);
print_colors ("dark", style->dark, 5);
print_colors ("mid", style->mid, 5);
print_strings ("bg-pixmap", rc->bg_pixmap_name, 5);
}
int main(void)
{
int ret;
LIBXML_TEST_VERSION
fill_strings();
#ifdef WITH_PRINT
print_strings();
#endif
ret = run_test1();
if (ret == 0) {
printf("dictionary tests succeeded %d strings\n", 2 * NB_STRINGS_MAX);
} else {
printf("dictionary tests failed with %d errors\n", nbErrors);
}
clean_strings();
xmlCleanupParser();
xmlMemoryDump();
return(ret);
}
void Testbench::test(){
int x, y , ci;
cout<<"Time\tx\ty\tci\tz\tco"<<endl;
cout<<"--------------------------------------------"<<endl;
srand(time(NULL));
for(int i =0; i<10; i++){
x = rand()%4;
y = rand()%4;
ci= rand()%2;
x_out.write(x);
y_out.write(y);
ci_out.write(ci);
wait();
print_strings();
print_integers();
}
sc_stop();
}
/**
* This is the C task that is created multiple times. Each task receives its
* own parameter therefore differentiating between different tasks.
*/
void scheduler_c_task_private(void *task_ptr)
{
scheduler_task& task = *(scheduler_task*)task_ptr;
/* Have the responsible task call taskEntry() for each task */
if (mTaskEntryTaskHandle == task.mHandle) {
bool failure = false;
print_strings(task.mName, " task calling taskEntry() for all tasks ... ");
for (uint32_t i=0; i < gTaskList->size(); i++)
{
scheduler_task *t = gTaskList->at(i);
if (!t->taskEntry()) {
print_strings(t->mName, " --> FAILED taskEntry()");
failure = true;
}
}
if (failure) {
puts("ERROR: Killing FreeRTOS due to error(s)");
vTaskEndScheduler();
} else {
/* Give permission for everyone to start the run() loop */
for (uint32_t i=0; i < gTaskList->size(); i++)
{
xSemaphoreGive(mRunTask);
}
}
}
// Wait until we're given the go ahead by the task giving semaphore above
xSemaphoreTake(mRunTask, portMAX_DELAY);
portTickType xLastWakeTime = xTaskGetTickCount();
portTickType xNextStatTime = 0;
for (;;)
{
#if (0 != configUSE_QUEUE_SETS)
if (task.mQueueSet) {
task.mQueueSetType = xQueueSelectFromSet(task.mQueueSet, task.mQueueSetBlockTime);
}
#endif
// Run the task code and suspend when an error occurs
if (!task.run((void*)task.mParam)) {
print_strings(task.mName, " --> FAILURE detected; suspending this task ...");
vTaskSuspend(0);
}
++(task.mRunCount);
// Update the task statistics once in a short while :
if (xTaskGetTickCount() > xNextStatTime) {
xNextStatTime = xTaskGetTickCount() + OS_MS(task.mStatUpdateRateMs);
task.mFreeStack = uxTaskGetStackHighWaterMark(task.mHandle);
task.mCpuPercent = uxTaskGetCpuUsage(task.mHandle);
}
// Delay if set
if (task.mTaskDelayMs) {
vTaskDelayUntil( &xLastWakeTime, OS_MS(task.mTaskDelayMs));
}
}
}
bool scheduler_init_all(bool register_internal_tlm)
{
bool failure = false;
/* If not tasks ... */
if (0 == gTaskList || 0 == gTaskList->size()) {
puts("ERROR: NO tasks added by scheduler_add_task()");
failure = true;
return failure;
}
/* Initialize all tasks */
puts("* Initializing tasks ...");
for (uint32_t i=0; i < gTaskList->size(); i++)
{
scheduler_task *task = gTaskList->at(i);
if (!task->init()) {
print_strings(task->getTaskName(), " --> FAILED init()");
failure = true;
}
}
/* Register telemetry for all tasks */
#if ENABLE_TELEMETRY
puts("* Registering tasks' telemetry ...");
for (uint32_t i=0; i < gTaskList->size(); i++)
{
scheduler_task *task = gTaskList->at(i);
if (!task->regTlm()) {
failure = true;
}
/* Register statistical variables of this task */
if (register_internal_tlm) {
tlm_component *comp = tlm_component_add(task->mName);
if (!tlm_variable_register(comp, "cpu_percent", &(task->mCpuPercent),
sizeof(task->mCpuPercent), 1, tlm_uint)) {
failure = true;
}
if (!tlm_variable_register(comp, "free_stack", &(task->mFreeStack),
sizeof(task->mFreeStack), 1, tlm_uint)) {
failure = true;
}
if (!tlm_variable_register(comp, "run_count", &(task->mRunCount),
sizeof(task->mRunCount), 1, tlm_uint)) {
failure = true;
}
}
if (failure) {
print_strings(task->mName, " --> FAILED telemetry registration");
}
}
puts("* Restoring disk telemetry");
// Restore telemetry registered by "disk" component
FILE *fd = fopen(DISK_TLM_NAME, "r");
if (fd) {
tlm_stream_decode_file(fd);
fclose(fd);
}
#endif
puts("* Creating tasks ...");
mRunTask = xSemaphoreCreateCounting(gTaskList->size(), 0);
if (NULL == mRunTask) {
failure = true;
}
for (uint32_t i=0; i < gTaskList->size(); i++)
{
scheduler_task *task = gTaskList->at(i);
if (!xTaskCreate(scheduler_c_task_private,
(signed char*)task->mName, /* Name */
STACK_BYTES(task->mStackSize), /* Stack */
task, /* Task param */
task->mPriority, /* Task priority */
&(task->mHandle))) /* Task Handle */
{
print_strings(task->mName, " --> FAILED xTaskCreate()");
failure = true;
}
}
/* Find the task with highest stack, and this task will then be used
* to call taskEntry() for everyone once FreeRTOS starts.
* We have one task do taskEntry() for all because otherwise tasks will perform
* taskEntry() independent of each other, and one task might complete it and
* start running without other tasks completing their taskEntry().
*/
uint32_t highestStack = 0;
for (uint32_t i=0; i < gTaskList->size(); i++)
{
scheduler_task *task = gTaskList->at(i);
if (task->mStackSize > highestStack) {
highestStack = task->mStackSize;
mTaskEntryTaskHandle = task->mHandle;
}
}
return failure;
}
void Quads_to_Assembly(qnode **head, FILE *f) {
fp = f;
qnode *temp;
temp = *head;
quad *x ;
quad *y ;
quad *z ;
char *MainName;
MainName = (char *)malloc(246);
snprintf(MainName, 256, "_%s", main_program->id);
fprintf(fp, "xseg\tsegment public 'code'\n"
"\tassume\tcs:xseg, ds:xseg, ss:xseg\n"
"\torg\t100h\n"
"main\tproc near\n"
"\tcall\tnear ptr %s\n"
"\tmov\tax, 4C00h\n"
"\tint\t21h\n"
"main\tendp\n\n", MainName);
free(MainName);
if (temp == NULL)
fprintf(stdout, "\nThe list is empty!\n");
else {
while (temp != NULL) {
fprintf(fp, "@%d:\n", temp->n);
x = temp->x;
y = temp->y;
z = temp->z;
switch(temp->op) {
case OP_UNIT:
{
char *nm = name(x);
fprintf(fp, "%s proc near\n"
"\tpush\tbp\n"
"\tmov\tbp, sp\n"
"\tsub\tsp, %d\n", nm, -temp->negOffset);
free(nm);
break;
}
case OP_ENDU:
{
char *end = endof(x->value.se, temp->nestingLevel);
fprintf(fp, "\tjmp\t%s\n", end);
char *nm = name(x);
fprintf(fp, "%s:\n"
"\tmov\tsp, bp\n"
"\tpop\tbp\n"
"\tret\n"
"%s\tendp\n", end, nm);
free(nm);
free(end);
break;
}
case OP_JUMP:
{
char *lbl = label(z);
fprintf(fp, "\tjmp\t%s\n", lbl);
free(lbl);
break;
}
case OP_JUMPL:
{
char *lbl = label(z);
fprintf(fp, "\tjmp\t%s\n", lbl);
free(lbl);
break;
}
case OP_LABEL:
{
char *lbl = label(z);
free(lbl);
break;
}
case OP_IFB:
{
load("al", x, temp);
char *lbl = label(z);
fprintf(fp, "\tor\tal, al\n"
"\tjnz\t%s\n", lbl);
free(lbl);
break;
}
case OP_CALL:
{
/*If z is procedure*/
if (equalType(z->value.se->u.eFunction.resultType, typeVoid))
fprintf(fp, "\tsub\tsp, 2\n");
fprintf(fp, "\tsub\tsp, 2\n");
/*updateAL(temp, z->value.se);
*/
char *nm = name(z);
fprintf(fp, "\tcall\tnear ptr %s\n"
"\tadd\tsp, %d\n", nm, size + 4);
free(nm);
size = 0;
break;
}
case OP_PAR:
{
if (x->type == QUAD_SE)
size += sizeOfType(x->value.se->u.eParameter.type);
else if (x->type == QUAD_POINTER)
size += sizeOfType(x->value.se->u.eParameter.type->refType);
else
size += (x->type == QUAD_INTEGER) ?
(sizeOfType(typeInteger)) : (sizeOfType(typeChar));
if (y->mode == PASS_BY_VALUE) {
if (x->type == QUAD_INTEGER || (x->type == QUAD_SE &&
equalType(x->value.se->u.eParameter.type, typeInteger))) {
load("ax", x, temp);
fprintf(fp, "\tpush ax\n");
}
else if (x->type == QUAD_CHAR || x->type == QUAD_BOOL ||
(x->type == QUAD_SE &&
(equalType(x->value.se->u.eParameter.type, typeChar) ||
equalType(x->value.se->u.eParameter.type, typeBoolean)))) {
load("al", x, temp);
fprintf(fp, "\tsub\tsp, 1\n"
"\tmov\tsi, sp\n"
"\tmov\tbyte ptr [si], al\n");
}
else fprintf(fp, "Error 1");
}
else if (y->mode == PASS_BY_REFERENCE || y->mode == RET) {
loadAddr("si", x, temp);
fprintf(fp, "\tpush\tsi\n");
}
else {
fprintf(fp, "Error 2\n");
return;
}
break;
}
case OP_RET:
{
char *end = endof(temp->inFunction, temp->nestingLevel);
fprintf(fp, "\tjmp %s\n", end);
free(end);
break;
}
case OP_RETV:
{
if (x->type == QUAD_INTEGER || (x->type == QUAD_SE &&
equalType(x->value.se->u.eVariable.type, typeInteger))) {
fprintf(fp, "\tmov\tsi, word ptr [bp+6]\n"); // Address of result
load("ax", x, temp);
fprintf(fp, "\tmov\tword ptr [si], ax\n"); // store it
}
else if (x->type == QUAD_CHAR || x->type == QUAD_BOOL ||
(x->type == QUAD_SE &&
(equalType(x->value.se->u.eVariable.type, typeChar) ||
equalType(x->value.se->u.eVariable.type, typeBoolean)))) {
fprintf(fp, "\tmov\tsi, byte ptr [bp+6]\n"); // Address of result
load("al", x, temp);
fprintf(fp, "\tmov\tbyte ptr [si], al\n"); // store it
}
break;
}
case OP_eq:
{
load("ax", x, temp);
load("dx", y, temp);
fprintf(fp, "cmp\tax, dx\n");
fprintf(fp, "\tje\t");
char *lbl = label(z);
fprintf(fp, "%s\n", lbl);
free(lbl);
break;
}
case OP_neq:
{
load("ax", x, temp);
load("dx", y, temp);
fprintf(fp, "\tcmp\tax, dx\n");
fprintf(fp, "\tjne\t");
char *lbl = label(z);
fprintf(fp, "%s\n", lbl);
free(lbl);
break;
}
case OP_less:
{
load("ax", x, temp);
load("dx", y, temp);
fprintf(fp, "\tcmp\tax, dx\n");
fprintf(fp, "\tjl\t");
char *lbl = label(z);
fprintf(fp, "%s\n", lbl);
free(lbl);
break;
}
case OP_greater:
{
load("ax", x, temp);
load("dx", y, temp);
fprintf(fp, "\tcmp\tax, dx\n");
fprintf(fp, "\tjg\t");
char *lbl = label(z);
fprintf(fp, "%s\n", lbl);
free(lbl);
break;
}
case OP_leq:
{
load("ax", x, temp);
load("dx", y, temp);
fprintf(fp, "\tcmp\tax, dx\n");
fprintf(fp, "\tjle\t");
char *lbl = label(z);
fprintf(fp, "%s\n", lbl);
free(lbl);
break;
}
case OP_geq:
{
load("ax", x, temp);
load("dx", y, temp);
fprintf(fp, "\tcmp\tax, dx\n");
fprintf(fp, "\tjge\t");
char *lbl = label(z);
fprintf(fp, "%s\n", lbl);
free(lbl);
break;
}
case OP_PLUS:
{
load("ax", x, temp);
load("dx", y, temp);
fprintf(fp, "\tadd\tax, dx\n");
store("ax", z, temp);
break;
}
case OP_MINUS:
{
load("ax", x, temp);
load("dx", y, temp);
fprintf(fp, "\tsub\tax, dx\n");
store("ax", z, temp);
break;
}
case OP_bmul:
{
load("ax", x, temp);
load("cx", y, temp);
fprintf(fp, "\timul\tcx\n");
store("ax", z, temp);
break;
}
case OP_bdiv:
{
load("ax", x, temp);
fprintf(fp, "\tcwd\n");
load("cx", y, temp);
fprintf(fp, "\tidiv\tcx\n");
store("ax", z, temp);
break;
}
case OP_bmod:
{
load("ax", x, temp);
fprintf(fp, "cwd\n");
load("cx", y, temp);
fprintf(fp, "\tidiv\tcx\n");
store("dx", z, temp);
break;
}
case OP_mod:
{
load("ax", x, temp);
fprintf(fp, "\tcwd\n");
load("cx", y, temp);
fprintf(fp, "\tidiv\tcx\n");
store("dx", z, temp);
break;
}
case OP_assign:
{
/*Fix this*/
if (x->type == QUAD_SE || x->type == QUAD_POINTER) {
if (equalType(x->value.se->u.eVariable.type, typeInteger) ||
equalType(x->value.se->u.eVariable.type, typePointer(typeInteger))) {
load("ax", x, temp);
store("ax", z, temp);
} else if (equalType(x->value.se->u.eVariable.type, typeChar) ||
equalType(x->value.se->u.eVariable.type, typePointer(typeChar)) ||
equalType(x->value.se->u.eVariable.type, typeBoolean) ||
equalType(x->value.se->u.eVariable.type, typePointer(typeBoolean))) {
load("al", x, temp);
store("al", z, temp);
}
}
else if (x->type == QUAD_INTEGER) {
load("ax", x, temp);
store("ax", z, temp);
}
else if (x->type == QUAD_CHAR || x->type == QUAD_BOOL) {
load("al", x, temp);
store("al", z, temp);
}
break;
}
case OP_ARRAY:
{
load("ax", y, temp);
fprintf(fp, "\tmov\tcx, %d\n"
"\timul cx\n", size);
loadAddr("cx", x, temp);
fprintf(fp, "\tadd\tax, cx\n");
store("ax", z, temp);
break;
}
default:
fprintf(fp, "For debugging\n");
break;
}
temp = temp->next;
}
}
fprintf(fp, //"extrn\t_putchar:proc\n"
//"extrn\t_puts:proc\n"
"extrn\t_writeInteger:proc\n"
"extrn\t_writeBoolean:proc\n"
"extrn\t_writeChar:proc\n"
"extrn\t_writeReal:proc\n"
"extrn\t_writeString:proc\n"
"extrn\t_READ_INT:proc\n"
"extrn\t_READ_BOOL:proc\n"
"extrn\t_READ_CHAR:proc\n"
"extrn\t_READ_REAL:proc\n"
"extrn\t_READ_STRING:proc\n"
"extrn\t_abs:proc\n"
"extrn\t_fabs:proc\n"
"extrn\t_sqrt:proc\n"
"extrn\t_sin:proc\n"
"extrn\t_cos:proc\n"
"extrn\t_tan:proc\n"
"extrn\t_arctan:proc\n"
"extrn\t_exp:proc\n"
"extrn\t_ln:proc\n"
"extrn\t_pi:proc\n"
"extrn\t_trunc:proc\n"
"extrn\t_round:proc\n"
"extrn\t_TRUNC:proc\n"
"extrn\t_ROUND:proc\n"
//"extrn\t_strlen:proc\n"
//"extrn\t_strcmp:proc\n"
//"extrn\t_strcpy:proc\n"
//"extrn\t_strcat:proc\n"
);
print_strings(fp, head_str);
fprintf(fp, "xseg ends\n"
"\tend\tmain\n");
}
/**
* main program. Processes all files and returns one string
* for each file in strings[]. In the process, all strings are
* used to construct the trie we use to get the substring with
* great f value.
*/
int main (int argc, char **argv)
{
extern int optind;
extern char *optarg;
int opt;
int i;
int n_passes = MAX_PASSES;
FILE *out = stdout;
time_t now;
time(&now);
while ((opt = getopt(argc, argv, "dhPp:o:s")) != EOF) {
switch(opt) {
case 'h': do_usage(); exit(0);
case 'P': flags |= FLAG_PROGRESS; break;
case 'p': n_passes = atol(optarg); break;
case 'd': flags |= FLAG_DEBUG; break;
case 'o': out = fopen(optarg, "wb"); break;
case 's': flags |= FLAG_PRINT_STATE; break;
} /* switch */
} /* while */
if (n_passes > MAX_PASSES) n_passes = MAX_PASSES;
if (n_passes < 1) n_passes = 1;
if (argc > optind) {
for (i = optind; i < argc; i++)
process_file(argv[i]);
} else process_file(stdin_name);
mark = strings_n; /* beginning of macros */
/* print the strings in the begining */
if (flags & FLAG_PRINT_STATE)
print_strings();
for(i = 0; i < n_passes; i++) {
struct trie_node *root_trie, *max;
int j;
char *o;
struct ref_buff *ref;
if (flags & FLAG_DEBUG) {
fprintf(stderr, D("PASS #%d:\n"), i);
} /* if */
/* INITIALIZE THE TRIE */
assert(root_trie = new_trie());
for (j = 0; j < strings_n; j++) {
const byte *s;
int l;
for (s = strings[j], l = strings_sz[j]; l; s++, l--) {
add_string(s, l, root_trie, j);
if (*s == ESCAPE) {
s++; l--;
} /* if */
} /* for */
if (flags & FLAG_PROGRESS) {
static char *progress[] = {
"\\", "|", "/", "-",
};
fprintf(stderr,
"\r%s %d/%d",
progress[j % 4], j+1, strings_n);
} /* if */
} /* for */
/* SEARCH FOR THE MOST EFFICIENT MACRO SUBSTITUTION */
max = walk_trie(root_trie, savings_calculation);
/* IF NOT FOUND, FINISH */
if (max == root_trie) {
if (flags & FLAG_DEBUG) {
fprintf(stderr,
D("MACRO NOT FOUND, FINISHING\n"));
} /* if */
break;
} /* if */
if (flags & FLAG_DEBUG) {
/* WRITE THE MACRO FOUND */
fprintbuf(stderr,
max->l, max->refs->b,
D("MACRO FOUND: len=%d, nrep=%d, savings=%d"),
max->l, max->n, savings_calculation(max));
} /* if */
/* copy the string macro as a new string. */
strings[strings_n] = buffer + bs;
memcpy(strings[strings_n], max->refs->b, max->l);
bs += max->l;
strings_sz[strings_n] = max->l;
strings_n++;
/* print the substitutions to be made. */
if (flags & FLAG_DEBUG) {
#define FOREACHSUBST(X) \
for (ref = max->refs; ref; ref = ref->nxt) { \
int ix = ref->ix; \
const byte *src = ref->b + max->l; \
byte *dst = (byte *)ref->b; \
const byte *end = strings[ix] + strings_sz[ix]; \
int n = end - src; \
X \
} /* for */
FOREACHSUBST(
fprintf(stderr,
D("SUBST: string[%d], beg_hole=0x%lx, end_hole=0x%lx, hole_sz=%ld, end=0x%lx\n"),
ix, dst - strings[ix], src - strings[ix], src - dst, end - strings[ix]);
) /* FOREACHSUBST */
} /* if */
/* substitute the strings as macro calls */
FOREACHSUBST(
assert((strings[ix] <= dst) && (dst + MACRO_SIZE < src) && (src <= end));
*dst++ = ESCAPE;
*dst++ = i + OFFSET; /* i is the macro index */
assert(n >= 0);
while (n--) *dst++ = *src++;
strings_sz[ix] -= max->l - MACRO_SIZE;
) /* FOREACHSUBST */
int main() {
print_strings("Lel", "Wot", "Lelling");
}
void print_strings(std::string str, Args... args) {
std::cout << str << ", ";
print_strings(args...);
}
int request_strings(req_list *rlp0, int n) {
assert(rlp0->cur_entries > 0);
int ne_lines0 = 0, ne_columns0 = 0;
bool reordered = false;
max_names_per_line = max_names_per_col = x = y = page = fuzz_len = 0;
if ( ! request_strings_init(rlp0) ) return ERROR;
const int dx = rl.max_entry_len + 1 + (rl.suffix ? 1 : 0);
while(true) {
if (ne_lines0 != ne_lines || ne_columns0 != ne_columns) {
if (ne_lines0 && ne_columns0 ) n = PXY2N(page,x,y);
if (!(max_names_per_line = ne_columns / dx)) max_names_per_line = 1;
max_names_per_col = ne_lines - 1;
names_per_page = max_names_per_line * max_names_per_col;
ne_lines0 = ne_lines;
ne_columns0 = ne_columns;
page = N2P(n);
x = N2X(n);
y = N2Y(n);
print_strings();
print_message(NULL);
}
n = PXY2N(page,x,y);
assert(fuzz_len >= 0);
fuzz_len = min(fuzz_len, strlen(rl.entries[n]));
move_cursor(y, x * dx + fuzz_len);
int c;
input_class ic;
do c = get_key_code(); while((ic = CHAR_CLASS(c)) == IGNORE || ic == INVALID);
switch(ic) {
case ALPHA:
if (n >= rl.cur_entries) n = rl.cur_entries - 1;
c = localised_up_case[(unsigned char)c];
fuzz_forward( c );
break;
case TAB:
if (! rlp0->ignore_tab) {
n = request_strings_cleanup(reordered);
if (n >= rlp0->cur_entries) return ERROR;
else return -n - 2;
}
break;
case RETURN:
n = request_strings_cleanup(reordered);
if (n >= rlp0->cur_entries) return ERROR;
else return n;
case COMMAND:
if (c < 0) c = -c - 1;
const int a = parse_command_line(key_binding[c], NULL, NULL, false);
if (a >= 0) {
switch(a) {
case BACKSPACE_A:
fuzz_back();
break;
case MOVERIGHT_A:
request_move_right();
break;
case MOVELEFT_A:
request_move_left();
break;
case MOVESOL_A:
request_move_to_sol();
break;
case MOVEEOL_A:
request_move_to_eol();
break;
case TOGGLESEOL_A:
if (x != 0) x = 0;
else request_move_to_eol();
break;
case LINEUP_A:
request_move_up();
break;
case LINEDOWN_A:
request_move_down();
break;
case MOVEINCUP_A:
request_move_inc_up();
break;
case MOVEINCDOWN_A:
request_move_inc_down();
break;
case PAGEUP_A:
case PREVPAGE_A:
request_prev_page();
break;
case PAGEDOWN_A:
case NEXTPAGE_A:
request_next_page();
break;
case MOVESOF_A:
request_move_to_sof();
break;
case MOVEEOF_A:
request_move_to_eof();
break;
case TOGGLESEOF_A:
request_toggle_seof();
break;
case NEXTWORD_A:
request_move_next();
break;
case PREVWORD_A:
request_move_previous();
break;
case NEXTDOC_A:
reordered |= request_reorder(1);
break;
case PREVDOC_A:
reordered |= request_reorder(-1);
break;
case INSERT_A:
case DELETECHAR_A:
prune = !prune;
break;
case CLOSEDOC_A:
case ESCAPE_A:
case QUIT_A:
case SELECTDOC_A:
request_strings_cleanup(reordered);
return -1;
}
}
break;
default:
break;
}
}
}
/* If mark_char is not '\0', we bold names ending with it. */
int request_strings(const char * const * const _entries, const int _num_entries, int n, const int _max_name_len, int _mark_char) {
action a;
input_class ic;
int c, i, ne_lines0, ne_columns0;
assert(_num_entries > 0);
ne_lines0 = ne_columns0 = max_names_per_line = max_names_per_col = x = y = page = 0;
entries = _entries;
num_entries = _num_entries;
max_name_len = _max_name_len + 1;
mark_char = _mark_char;
while(TRUE) {
if (ne_lines0 != ne_lines || ne_columns0 != ne_columns) {
if (ne_lines0 && ne_columns0 ) n = PXY2N(page,x,y);
if (!(max_names_per_line = ne_columns / (max_name_len))) max_names_per_line = 1;
max_names_per_col = ne_lines - 1;
names_per_page = max_names_per_line * max_names_per_col;
ne_lines0 = ne_lines;
ne_columns0 = ne_columns;
page = N2P(n);
x = N2X(n);
y = N2Y(n);
print_strings();
print_message(NULL);
}
move_cursor(y, x * max_name_len);
do c = get_key_code(); while((ic = CHAR_CLASS(c)) == IGNORE || ic == INVALID);
n = PXY2N(page,x,y);
switch(ic) {
case ALPHA:
if (n >= num_entries) n = num_entries - 1;
c = localised_up_case[(unsigned char)c];
for(i = 1; i < num_entries; i++)
if (localised_up_case[(unsigned char)entries[(n + i) % num_entries][0]] == c) {
normalize((n + i) % num_entries);
break;
}
break;
case TAB:
if (n >= num_entries) return ERROR;
else return -n - 2;
case RETURN:
if (n >= num_entries) return ERROR;
else return n;
case COMMAND:
if (c < 0) c = -c - 1;
if ((a = parse_command_line(key_binding[c], NULL, NULL, FALSE))>=0) {
switch(a) {
case MOVERIGHT_A:
request_move_right();
break;
case MOVELEFT_A:
request_move_left();
break;
case MOVESOL_A:
request_move_to_sol();
break;
case MOVEEOL_A:
request_move_to_eol();
break;
case TOGGLESEOL_A:
if (x != 0) x = 0;
else request_move_to_eol();
break;
case LINEUP_A:
request_move_up();
break;
case LINEDOWN_A:
request_move_down();
break;
case MOVEINCUP_A:
request_move_inc_up();
break;
case MOVEINCDOWN_A:
request_move_inc_down();
break;
case PAGEUP_A:
case PREVPAGE_A:
request_prev_page();
break;
case PAGEDOWN_A:
case NEXTPAGE_A:
request_next_page();
break;
case MOVESOF_A:
request_move_to_sof();
break;
case MOVEEOF_A:
request_move_to_eof();
break;
case TOGGLESEOF_A:
request_toggle_seof();
break;
case ESCAPE_A:
return -1;
}
}
break;
default:
break;
}
}
}
