int
accept_listener_source_address(struct Listener *listener, char *source) {
if (listener->source_address != NULL) {
err("Duplicate source address: %s", source);
return 0;
}
listener->source_address = new_address(source);
if (listener->source_address == NULL) {
err("Unable to parse source address: %s", source);
return 0;
}
if (!address_is_sockaddr(listener->source_address)) {
err("Only source socket addresses permitted");
free(listener->source_address);
listener->source_address = NULL;
return 0;
}
if (address_port(listener->source_address) != 0) {
char address[256];
err("Source address on listener %s set to non zero port, "
"this prevents multiple connection to each backend server.",
display_address(listener->address, address, sizeof(address)));
}
return 1;
}
int
accept_listener_arg(struct Listener *listener, char *arg) {
if (listener->address == NULL && !is_numeric(arg)) {
listener->address = new_address(arg);
if (listener->address == NULL ||
!address_is_sockaddr(listener->address)) {
fprintf(stderr, "Invalid listener argument %s\n", arg);
return -1;
}
} else if (listener->address == NULL && is_numeric(arg)) {
listener->address = new_address("[::]");
if (listener->address == NULL ||
!address_is_sockaddr(listener->address)) {
fprintf(stderr, "Unable to initialize default address\n");
return -1;
}
address_set_port(listener->address, atoi(arg));
} else if (address_port(listener->address) == 0 && is_numeric(arg)) {
address_set_port(listener->address, atoi(arg));
} else {
fprintf(stderr, "Invalid listener argument %s\n", arg);
}
return 1;
}
int main() {
/* using volatile variables so we can example core dumps */
struct Address *addr;
char buffer[255];
int port;
for (volatile unsigned int i = 0; i < sizeof(good) / sizeof(struct Test); i++) {
addr = new_address(good[i].input);
assert(addr != NULL);
if (good[i].expected_type & TYPE_HOSTNAME && !address_is_hostname(addr)) {
fprintf(stderr, "Expected %s to be a hostname\n", buffer);
return 1;
}
if (good[i].expected_type & TYPE_SOCKADDR && !address_is_sockaddr(addr)) {
fprintf(stderr, "Expected %s to be a sockaddr\n", buffer);
return 1;
}
if (good[i].expected_type & TYPE_WILDCARD && !address_is_wildcard(addr)) {
fprintf(stderr, "Expected %s to be a wildcard\n", buffer);
return 1;
}
display_address(addr, buffer, sizeof(buffer));
if (strcmp(buffer, good[i].output)) {
fprintf(stderr, "display_address(%p) returned \"%s\", expected \"%s\"\n", addr, buffer, good[i].output);
return 1;
}
port = address_port(addr);
if (good[i].port != port) {
fprintf(stderr, "address_port(%p) return %d, expected %d\n", addr, port, good[i].port);
return 1;
}
free(addr);
}
for (volatile unsigned int i = 0; i < sizeof(bad) / sizeof(const char *); i++) {
addr = new_address(bad[i]);
if (addr != NULL) {
fprintf(stderr, "Accepted bad hostname \"%s\"\n", bad[i]);
return 1;
}
}
return 0;
}
int compare_address_strings(const char *a, const char *b) {
struct Address *addr_a = new_address(a);
struct Address *addr_b = new_address(b);
int result = address_compare(addr_a, addr_b);
free(addr_a);
free(addr_b);
return result;
}
int
accept_listener_fallback_address(struct Listener *listener, char *fallback) {
if (listener->fallback_address != NULL) {
err("Duplicate fallback address: %s", fallback);
return 0;
}
listener->fallback_address = new_address(fallback);
if (listener->fallback_address == NULL) {
err("Unable to parse fallback address: %s", fallback);
return 0;
}
#ifndef HAVE_LIBUDNS
if (!address_is_sockaddr(listener->fallback_address)) {
err("Only fallback socket addresses permitted when compiled without libudns");
free(listener->fallback_address);
listener->fallback_address = NULL;
return 0;
}
#endif
if (address_is_wildcard(listener->fallback_address)) {
free(listener->fallback_address);
listener->fallback_address = NULL;
/* The wildcard functionality requires successfully parsing the
* hostname from the client's request, if we couldn't find the
* hostname and are using a fallback address it doesn't make
* much sense to configure it as a wildcard. */
err("Wildcard address prohibited as fallback address");
return 0;
}
return 1;
}
static void collect_addresses_into(InternetAddressList *ilist, AddressesList *addr_list, guint size) {
g_return_if_fail(ilist != NULL);
g_return_if_fail(addr_list != NULL);
g_return_if_fail(size != 0);
guint i;
for (i = 0; i < size; i++) {
InternetAddress *address = internet_address_list_get_address(ilist, i); // transfer none
if (INTERNET_ADDRESS_IS_GROUP(address)) {
InternetAddressGroup *group = INTERNET_ADDRESS_GROUP(address);
InternetAddressList *group_list = internet_address_group_get_members(group); // transer none
if (group_list) {
guint gsize = internet_address_list_length(group_list);
if (gsize)
collect_addresses_into(group_list, addr_list, gsize);
}
} else if (INTERNET_ADDRESS_IS_MAILBOX(address)) {
InternetAddressMailbox *mailbox = INTERNET_ADDRESS_MAILBOX(address);
const gchar *name = internet_address_get_name(address);
const gchar *address = internet_address_mailbox_get_addr(mailbox);
Address *addr = new_address(address, name);
addresses_list_add(addr_list, addr);
}
}
}
int
accept_backend_arg(struct Backend *backend, const char *arg) {
if (backend->pattern == NULL) {
backend->pattern = strdup(arg);
if (backend->pattern == NULL) {
err("strdup failed");
return -1;
}
} else if (backend->address == NULL) {
backend->address = new_address(arg);
if (backend->address == NULL) {
err("invalid address: %s", arg);
return -1;
}
#ifndef HAVE_LIBUDNS
if (!address_is_sockaddr(backend->address)) {
err("Only socket address backends are permitted when compiled without libudns");
return -1;
}
#endif
} else if (address_port(backend->address) == 0 && is_numeric(arg)) {
address_set_port(backend->address, atoi(arg));
} else {
err("Unexpected table backend argument: %s", arg);
return -1;
}
return 1;
}
int
accept_backend_arg(struct Backend *backend, char *arg) {
if (backend->hostname == NULL) {
backend->hostname = strdup(arg);
if (backend->hostname == NULL) {
err("strdup failed");
return -1;
}
} else if (backend->address == NULL) {
/* Store address in lower case */
for (char *c = arg; *c == '\0'; c++)
*c = tolower(*c);
backend->address = new_address(arg);
if (backend->address == NULL) {
err("invalid address: %s\n", arg);
return -1;
}
} else if (address_port(backend->address) == 0 && is_numeric(arg)) {
address_set_port(backend->address, atoi(arg));
} else {
err("Unexpected table backend argument: %s\n", arg);
return -1;
}
return 1;
}
static void process_or(ast_node node){
quad or_quad = create_quad(or);
add_quad(node, or_quad);
// the value of the OR will be stored here:
char * or_address = new_address();
node->location = or_address;
char * left = process_left(node);
char * right = process_right(node);
// add the code for the left child
add_quad_list(node, node->left_child->code);
// if the left child is false, go to test for right child
quad if_false = create_quad(ifFalse);
char * loc = strdup(left);
if_false->address1 = loc;
add_quad(node, if_false);
// unconditional jump (short circuiting)
quad short_circuit = create_quad(jumpTo);
add_quad(node, short_circuit);
// add the code for the right child - if_false jumps here!
add_quad_list(node, node->left_child->right_sibling->code);
int if_false_jumps_here = node->left_child->right_sibling->code->first->num;
char * buffer = malloc(10);
sprintf(buffer, "%d", if_false_jumps_here);
if_false->address2 = buffer;
// OR gets the value of the right child
quad assign_from_right = create_quad(assn);
assign_from_right->address1 = or_address;
assign_from_right->address2 = right;
add_quad(node, assign_from_right);
// unconditional jump (done)
quad done_jump = create_quad(jumpTo);
add_quad(node, done_jump);
// OR gets the value of the left child - short circuit jumps here!
quad assign_from_left = create_quad(assn);
assign_from_left->address1 = or_address;
assign_from_left->address2 = left;
add_quad(node, assign_from_left);
// backpatch short_circuit
buffer = malloc(10);
sprintf(buffer, "%d", assign_from_left->num);
short_circuit->address1 = buffer;
// backpatch done_jump (goes to next generated quad)
buffer = malloc(10);
sprintf(buffer, "%d", num_quads);
done_jump->address1 = buffer;
quad end_or_quad = create_quad(end_or);
add_quad(node, end_or_quad);
}
int
accept_backend_arg(struct Backend *backend, char *arg) {
if (backend->name == NULL) {
backend->name = strdup(arg);
if (backend->name == NULL) {
err("strdup failed");
return -1;
}
} else if (backend->address == NULL) {
/* Store address in lower case */
for (char *c = arg; *c != '\0'; c++)
*c = tolower(*c);
backend->address = new_address(arg);
if (backend->address == NULL) {
err("invalid address: %s", arg);
return -1;
}
#ifndef HAVE_LIBUDNS
if (!address_is_sockaddr(backend->address)) {
err("Only socket address backends are permitted when compiled without libudns");
return -1;
}
#endif
} else if (address_port(backend->address) == 0 && is_numeric(arg)) {
address_set_port(backend->address, atoi(arg));
} else {
err("Unexpected table backend argument: %s", arg);
return -1;
}
return 1;
}
struct Address *
listener_lookup_server_address(const struct Listener *listener,
const char *name, size_t name_len) {
struct Address *new_addr = NULL;
short set_to_fallback = 0;
const struct Address *addr =
table_lookup_server_address(listener->table, name, name_len);
if (addr == NULL)
addr = listener->fallback_address;
if (addr == NULL)
return NULL;
int port = address_port(addr);
if (address_is_wildcard(addr)) {
new_addr = new_address(name);
if (new_addr == NULL) {
warn("Invalid hostname %.*s in client request",
(int)name_len, name);
set_to_fallback = 1;
} else if (address_is_sockaddr(new_addr)) {
warn("Refusing to proxy to socket address literal %.*s in request",
(int)name_len, name);
set_to_fallback = 1;
}
if (!set_to_fallback && port != 0)
address_set_port(new_addr, port);
} else {
size_t len = address_len(addr);
new_addr = malloc(len);
if (new_addr == NULL) {
err("%s: malloc", __func__);
set_to_fallback = 1;
}
memcpy(new_addr, addr, len);
}
if (set_to_fallback) {
size_t len = address_len(listener->fallback_address);
new_addr = malloc(len);
if (new_addr == NULL) {
err("%s: malloc", __func__);
return NULL;
}
memcpy(new_addr, listener->fallback_address, len);
}
if (!set_to_fallback && port == 0)
address_set_port(new_addr, address_port(listener->address));
return new_addr;
}
// Format: (array_lkup, target, name, index)
static void process_array(ast_node node){
quad array_quad = create_quad(array_lkup);
// where you'll put value of array once you look it up
array_quad->address1 = new_address();
array_quad->address2 = process_left(node);
array_quad->address3 = process_right(node);
add_quad(node, array_quad);
node->location = array_quad->address1;
}
static void process_and(ast_node node){
quad and_quad = create_quad(and);
add_quad(node, and_quad);
// address the value of the and will be stored here:
char * and_address = new_address();
node->location = and_address;
char * left = process_left(node);
char * right = process_right(node);
// do the code for the left child
add_quad_list(node, node->left_child->code);
// if the left child is false, short circuit
quad if_false = create_quad(ifFalse);
char * loc = strdup(left);
if_false->address1 = loc;
add_quad(node, if_false);
// do the code for the right child
add_quad_list(node, node->left_child->right_sibling->code);
quad assign = create_quad(assn);
assign->address1 = and_address;
assign->address2 = right;
add_quad(node, assign);
// unconditional jump to code after the and
quad jump_to = create_quad(jumpTo);
add_quad(node, jump_to);
// first was false, so the value is false (short circuited)
quad assign2 = create_quad(assn);
assign2->address1 = and_address;
assign2->address2 = left;
add_quad(node, assign2);
int short_circuit = assign2->num;
// backpatch the unconditional jump:
char * buffer = malloc(10);
sprintf(buffer, "%d", num_quads);
jump_to->address1 = buffer;
// backpatch the short circuit
buffer = malloc(10);
sprintf(buffer, "%d", short_circuit);
if_false->address2 = buffer;
quad end_and_quad = create_quad(end_and);
add_quad(node, end_and_quad);
}
// process float math
static void process_float_math(ast_node node){
quad new_quad = NULL;
switch (node->node_type){
case OP_PLUS:
new_quad = create_quad(f_add);
break;
case OP_MINUS:
new_quad = create_quad(f_sub);
break;
case OP_TIMES:
new_quad = create_quad(f_mult);
break;
case OP_DIVIDE:
new_quad = create_quad(f_divide);
break;
case OP_EQUALS:
new_quad = create_quad(f_eq);
break;
case OP_NEQUALS:
new_quad = create_quad(f_neq);
break;
case OP_LT:
new_quad = create_quad(f_lt);
break;
case OP_LEQ:
new_quad = create_quad(f_leq);
break;
case OP_GT:
new_quad = create_quad(f_gt);
break;
case OP_GEQ:
new_quad = create_quad(f_geq);
break;
}
// location being assigned to is new!
char *target = new_address();
char * left = process_left(node);
char *right = process_right(node);
if (new_quad != NULL && target != NULL && left != NULL && right != NULL){
build_code(node, new_quad, target, left, right);
}
else {
destroy_quad(new_quad);
error("process_float_math");
}
}
static void process_negate(ast_node node){
quad new_quad = create_quad(mult);
char * target = new_address();
char * value = process_left(node);
char * multby = strdup("-1");
if (value != NULL){
build_code(node, new_quad, target, value, multby);
}
else{
destroy_quad(new_quad);
error("process_negate");
}
}
/* processes a call
* 1. push the params onto the stack
* 2. goto_sub the function (location will be stored in symbol table maybe?)
* 3. get the return value (will be in a register)
*/
static void process_call(ast_node node){
// 1. push the params onto the stack in reverse order
ast_node args = node->left_child->right_sibling;
quad goto_sub_quad = create_quad(goto_sub);
goto_sub_quad->address1 = node->left_child->value.string;
add_quad(node, goto_sub_quad);
ast_node curr;
for (curr = args->left_child; curr != NULL; curr = curr->right_sibling){
quad push_quad = create_quad(push);
push_quad->address1 = curr->location;
// it's a literal!
if (push_quad->address1 == NULL){
char buffer[MAX_LEN];
char *val;
if (curr->type == Int){
snprintf(buffer, MAX_LEN, "%d", curr->value.int_value);
val = strdup(buffer);
push_quad->address1 = val;
}
else{
snprintf(buffer, MAX_LEN, "%f", curr->value.double_value);
val = strdup(buffer);
push_quad->address1 = val;
}
}
add_quad_to_beginning(node, push_quad);
add_quad_list_to_beginning(node, curr->code);
//add_quad_list(node, curr->code);
}
// 2. jump to the function's subroutine
/* quad goto_sub_quad = create_quad(goto_sub);
goto_sub_quad->address1 = node->left_child->value.string;
add_quad(node, goto_sub_quad);
*/
// 3. get the return value
quad get_return = create_quad(get_rtrn);
get_return->address1 = new_address();
node->location = get_return->address1;
add_quad(node, get_return);
}
struct Address *
listener_lookup_server_address(const struct Listener *listener,
const char *name, size_t name_len) {
struct Address *new_addr = NULL;
const struct Address *addr =
table_lookup_server_address(listener->table, name, name_len);
if (addr == NULL)
addr = listener->fallback_address;
if (addr == NULL)
return NULL;
int port = address_port(addr);
if (address_is_wildcard(addr)) {
new_addr = new_address(name);
if (new_addr == NULL) {
warn("Invalid hostname %.*s", (int)name_len, name);
return listener->fallback_address;
}
if (port != 0)
address_set_port(new_addr, port);
} else {
size_t len = address_len(addr);
new_addr = malloc(len);
if (new_addr == NULL) {
err("%s: malloc", __func__);
return listener->fallback_address;
}
memcpy(new_addr, addr, len);
}
if (port == 0)
address_set_port(new_addr, address_port(listener->address));
return new_addr;
}
int
accept_listener_fallback_address(struct Listener *listener, char *fallback) {
if (listener->fallback_address != NULL) {
fprintf(stderr, "Duplicate fallback address: %s\n", fallback);
return 0;
}
listener->fallback_address = new_address(fallback);
if (listener->fallback_address == NULL) {
fprintf(stderr, "Unable to parse fallback address: %s\n", fallback);
return 0;
}
if (address_is_wildcard(listener->fallback_address)) {
free(listener->fallback_address);
listener->fallback_address = NULL;
/* The wildcard functionality requires successfully parsing the
* hostname from the client's request, if we couldn't find the
* hostname and are using a fallback address it doesn't make
* much sense to configure it as a wildcard. */
fprintf(stderr, "Wildcard address prohibited as fallback address\n");
return 0;
}
return 1;
}
int
accept_listener_fallback_address(struct Listener *listener, char *fallback) {
if (listener->fallback_address != NULL) {
err("Duplicate fallback address: %s", fallback);
return 0;
}
struct Address *fallback_address = new_address(fallback);
if (fallback_address == NULL) {
err("Unable to parse fallback address: %s", fallback);
return 0;
} else if (address_is_sockaddr(fallback_address)) {
listener->fallback_address = fallback_address;
return 1;
} else if (address_is_hostname(fallback_address)) {
#ifndef HAVE_LIBUDNS
err("Only fallback socket addresses permitted when compiled without libudns");
free(fallback_address);
return 0;
#else
warn("Using hostname as fallback address is strongly discouraged");
listener->fallback_address = fallback_address;
return 1;
#endif
} else if (address_is_wildcard(fallback_address)) {
/* The wildcard functionality requires successfully parsing the
* hostname from the client's request, if we couldn't find the
* hostname and are using a fallback address it doesn't make
* much sense to configure it as a wildcard. */
err("Wildcard address prohibited as fallback address");
free(fallback_address);
return 0;
} else {
fatal("Unexpected fallback address type");
return 0;
}
}
// The address book is not practical enough yet to be of much use
// Leave all this code commented until it gets improved
address_book::address_book (QWidget *parent) : QWidget(parent)
{
m_is_modified = false;
Q3BoxLayout* top_layout = new Q3VBoxLayout (this);
top_layout->setMargin (4);
top_layout->setSpacing (4);
Q3HBox* hb = new Q3HBox (this);
hb->setSpacing (6);
top_layout->addWidget (hb);
Q3VBox* box_left = new Q3VBox (hb);
Q3VBox* box_right = new Q3VBox (hb);
// left pane: search criteria and results
Q3GroupBox* search_box = new Q3GroupBox (3, Qt::Horizontal, tr("Search"), box_left);
Q3VBox* labels_box = new Q3VBox(search_box);
Q3VBox* fields_box = new Q3VBox(search_box);
m_email_search_w = new QLineEdit (fields_box);
(void)new QLabel (tr("Address"), labels_box);
m_name_search_w = new QLineEdit (fields_box);
(void)new QLabel (tr("Name"), labels_box);
m_nick_search_w = new QLineEdit (fields_box);
(void)new QLabel (tr("Alias"), labels_box);
QPushButton* button_search = new QPushButton (tr("Search"), search_box);
connect (button_search, SIGNAL(clicked()), this, SLOT(search()));
Q3GroupBox* result_box = new Q3GroupBox (1, Qt::Vertical, tr("Results"), box_left);
m_result_list_w = new Q3ListView (result_box);
m_result_list_w->addColumn (tr("Email address"));
m_result_list_w->addColumn (tr("# msgs"), 50);
connect(m_result_list_w, SIGNAL(selectionChanged()),
this, SLOT(address_selected()));
// right pane: properties of the selected address
Q3GroupBox* prop_box = new Q3GroupBox (tr("Properties"), box_right);
Q3GridLayout *grid_layout = new Q3GridLayout (prop_box, 6, 2);
grid_layout->setSpacing (4);
// set a marging big enough for the QGroupBox title not being overwritten
grid_layout->setMargin (15);
int g_row = 0; // grid row
m_email_w = new QLineEdit (prop_box);
grid_layout->addWidget (new QLabel (tr("Address:"), prop_box),g_row,0);
grid_layout->addWidget (m_email_w, g_row, 1);
g_row++;
m_name_w = new QLineEdit (prop_box);
grid_layout->addWidget (new QLabel (tr("Name:"), prop_box), g_row, 0);
grid_layout->addWidget (m_name_w, g_row, 1);
g_row++;
m_nick_w = new QLineEdit (prop_box);
grid_layout->addWidget (new QLabel (tr("Alias:"), prop_box), g_row, 0);
grid_layout->addWidget (m_nick_w, g_row, 1);
g_row++;
m_notes_w = new Q3MultiLineEdit (prop_box);
grid_layout->addWidget (new QLabel (tr("Notes:"), prop_box), g_row, 0);
grid_layout->addWidget (m_notes_w, g_row, 1);
g_row++;
m_invalid_w = new QCheckBox (prop_box);
grid_layout->addWidget (new QLabel (tr("Invalid:"), prop_box), g_row, 0);
grid_layout->addWidget (m_invalid_w, g_row, 1);
g_row++;
QPushButton* button_aliases = new QPushButton(tr("Other addresses..."), prop_box);
grid_layout->addWidget (button_aliases, 5, 1);
connect (button_aliases, SIGNAL(clicked()), this, SLOT(aliases()));
// buttons at the bottom of the window
Q3HBox* buttons_box = new Q3HBox (this);
buttons_box->setSpacing (4);
top_layout->addWidget (buttons_box);
new Q3HBox (buttons_box); // takes the left space
QPushButton* b1 = new QPushButton (tr("New"), buttons_box);
connect (b1, SIGNAL(clicked()), this, SLOT(new_address()));
QPushButton* b2 = new QPushButton (tr("Apply"), buttons_box);
connect (b2, SIGNAL(clicked()), this, SLOT(apply()));
QPushButton* b3 = new QPushButton (tr("OK"), buttons_box);
connect (b3, SIGNAL(clicked()), this, SLOT(OK()));
QPushButton* b4 = new QPushButton (tr("Cancel"), buttons_box);
connect (b4, SIGNAL(clicked()), this, SLOT(cancel()));
}
int main() {
/* using volatile variables so we can example core dumps */
for (volatile unsigned int i = 0; i < sizeof(good) / sizeof(struct Test); i++) {
int port;
char buffer[255];
struct Address *addr = new_address(good[i].input);
assert(addr != NULL);
assert(address_compare(addr, addr) == 0);
assert(address_compare(NULL, addr) < 0);
assert(address_compare(addr, NULL) > 0);
assert(address_len(addr) > 0);
if (good[i].expected_type & TYPE_HOSTNAME) {
assert(address_is_hostname(addr));
assert(!address_is_sockaddr(addr));
assert(!address_is_wildcard(addr));
assert(address_hostname(addr) != NULL);
assert(address_sa(addr) == NULL);
assert(address_sa_len(addr) == 0);
} else if (good[i].expected_type & TYPE_SOCKADDR) {
assert(!address_is_hostname(addr));
assert(address_is_sockaddr(addr));
assert(!address_is_wildcard(addr));
assert(address_hostname(addr) == NULL);
assert(address_sa(addr) != NULL);
assert(address_sa_len(addr) > 0);
} else if (good[i].expected_type & TYPE_WILDCARD) {
assert(!address_is_hostname(addr));
assert(!address_is_sockaddr(addr));
assert(address_is_wildcard(addr));
assert(address_hostname(addr) == NULL);
assert(address_sa(addr) == NULL);
assert(address_sa_len(addr) == 0);
}
display_address(addr, buffer, sizeof(buffer));
if (strcmp(buffer, good[i].output)) {
fprintf(stderr, "display_address(%p) returned \"%s\", expected \"%s\"\n", addr, buffer, good[i].output);
return 1;
}
assert(display_address(addr, NULL, 0) == NULL);
port = address_port(addr);
if (good[i].port != port) {
fprintf(stderr, "address_port(%p) return %d, expected %d\n", addr, port, good[i].port);
return 1;
}
address_set_port(addr, port);
if (good[i].port != port) {
fprintf(stderr, "address_port(%p) return %d, expected %d\n", addr, port, good[i].port);
return 1;
}
free(addr);
}
for (volatile unsigned int i = 0; i < sizeof(bad) / sizeof(const char *); i++) {
struct Address *addr = new_address(bad[i]);
if (addr != NULL) {
fprintf(stderr, "Accepted bad hostname \"%s\"\n", bad[i]);
return 1;
}
}
assert(compare_address_strings("unix:/dev/log", "127.0.0.1") < 0);
assert(compare_address_strings("unix:/dev/log", "unix:/dev/logsocket") < 0);
assert(compare_address_strings("0.0.0.0", "127.0.0.1") < 0);
assert(compare_address_strings("127.0.0.1", "0.0.0.0") > 0);
assert(compare_address_strings("127.0.0.1", "127.0.0.1") == 0);
assert(compare_address_strings("127.0.0.1:80", "127.0.0.1:81") < 0);
assert(compare_address_strings("*:80", "*:81") < 0);
assert(compare_address_strings("*:81", "*:80") > 0);
assert(compare_address_strings("example.com", "example.net") < 0);
assert(compare_address_strings("example.net", "example.com") > 0);
assert(compare_address_strings("example.com", "example.com.net") < 0);
assert(compare_address_strings("example.com.net", "example.com") > 0);
assert(compare_address_strings("example.com", "example.com:80") < 0);
assert(compare_address_strings("example.com:80", "example.com") > 0);
assert(compare_address_strings(NULL, "example.com") < 0);
assert(compare_address_strings("example.com", NULL) > 0);
assert(compare_address_strings("example.com", "::") < 0);
assert(compare_address_strings("::", "example.com") > 0);
assert(compare_address_strings("0.0.0.0", "*") < 0);
assert(compare_address_strings("*", "0.0.0.0") > 0);
do {
struct Address *addr = new_address("*");
assert(addr != NULL);
assert(address_len(addr) > 0);
free(addr);
} while (0);
return 0;
}
/* Handles mathy operations (all the same pattern)
* Format: (operation, target location, left argument, right argument)
*/
static void process_math(ast_node node){
// if its a float - process float math
if (node->type == Double){
process_float_math(node);
return;
}
quad new_quad = NULL;
if (node->node_type == OP_PLUS){
new_quad = create_quad(add);
}
else if (node->node_type == OP_MINUS){
new_quad = create_quad(sub);
}
else if (node->node_type == OP_TIMES){
new_quad = create_quad(mult);
}
else if (node->node_type == OP_DIVIDE){
new_quad = create_quad(divide);
}
else if (node->node_type == OP_MOD){
new_quad = create_quad(mod);
}
else if (node->node_type == OP_EQUALS){
new_quad = create_quad(eq);
}
else if (node->node_type == OP_NEQUALS){
new_quad = create_quad(neq);
}
else if (node->node_type == OP_LT){
new_quad = create_quad(lt);
}
else if (node->node_type == OP_LEQ){
new_quad = create_quad(leq);
}
else if (node->node_type == OP_GT){
new_quad = create_quad(gt);
}
else if (node->node_type == OP_GEQ){
new_quad = create_quad(geq);
}
else if (node->node_type == OP_NOT){
new_quad = create_quad(not);
}
// location being assigned to is new!
char * target = new_address();
// get left argument
char * left = process_left(node);
// get right argument (if it's not OP_NOT)
char * right = NULL;
if (node->node_type != OP_NOT)
right = process_right(node);
if (new_quad != NULL && target != NULL && left != NULL){
build_code(node, new_quad, target, left, right);
}
else {
destroy_quad(new_quad);
error("process math");
}
}
