const char *host = getenv ("DATA_HOST");
if (!host) host = "";

const char *path = getenv ("DATA_PATH");
if (!path) path = "";

const char *file = /* got from a drop down box, can possibly be "" */;

char cmd[256];
sprintf (cmd, "rsh %s /bin/rm -rf %s/%s &", host, path, file);

FILE *ptr = popen (cmd, "r");
if (ptr) {
  char buf[256];
  while (fgets (buf, sizeof (buf), ptr) != NULL) {
    (void) fprintf (stderr, "%s", buf);
  }
  int rc = pclose (ptr);
} else {
  perror ("popen");
}

if (0 != rc) {
  char message[256];
  sprintf (message, "unable to delete %s", file);
  fprintf (stderr, "%s", message);
}

Lexical Unit fucked around with this message at 22:57 on Feb 27, 2009

export DATA_HOST=${DATA_HOST:-"ERROR: undefined"}
export DATA_PATH=${DATA_PATH:-"ERROR: undefined"}

Lexical Unit fucked around with this message at 23:55 on Feb 27, 2009

string foo = returns_a_string ();
if (!strcmp (foo.c_str (), "test")) { ...
// foo used nowhere else in the program

struct bar {
	int uid;
	/* megaobject */
};
map<int, bar> m; // global

void handle_event_a(some data)
{
	while(/* we still have some data to consume */)
	{
		bar new_bar;
		// extract a bar from the remaining data, store it in new_bar
		m[new_bar.uid] = new_bar;
	}
}

// at no point in the program is m used like a map
// the only methods ever used on m are operator[](), begin(), and end().
// operator[]() is never called on the map besides to insert/update data, seen above.
// here is where begin() and end() are used:
void handle_event_b()
{
	vector<bar> bars;
	map<int, bar>::iterator i;
	for (i = m.begin (); i != m.end (); i++)
	{
		bars.push_back (i->second);
	}
	do_stuff (bars);
}

void do_stuff(vector<bar> bars)
{
	// simply iterates over bars to do stuff
}

int pants_size = 0; // global
int pants_type = 0; // global

void handle_pants_event(int size, int type)
{
	if (pants_size == 0 && pants_type == 0)
	{
		pants_type = type;
		pants_size = size;
	}
	else if (pants_size != size || pants_type != type)
	{
		pants_type = type;
		pants_size = size;
	}
}

void handle_input(void* data, unsigned long size)
{
	object o = object::parse (data, size); // allocates and copies memory
	
	switch (o.type)
	{
		case 1: foo (data, size); break;
		case 2: bar (data, size); break;
		case 3: baz (data, size); break;
	}
}

void foo(void* data, unsigned long size)
{
	object o = object::parse (data, size);
	if (o.type != 1) return;
	// use object o
}

void bar(void* data, unsigned long size)
{
	object o = object::parse (data, size);
	if (o.type != 2) return;
	// use object o
}

void baz(void* data, unsigned long size)
{
	object o = object::parse (data, size);
	if (o.type != 3) return;
	// use object o
}

Lexical Unit fucked around with this message at 21:57 on Jun 2, 2009

Lexical Unit fucked around with this message at 00:59 on Jun 12, 2009

// ugly:
vector<int> ints = get_some_ints ();
swap_data (&ints.front (), ints.size () * sizeof (ints.front ()));

// why not this instead:
vector<int> ints = get_some_ints ();
swap_data (ints.begin (), ints.end ());

// and this too:
size_t n = get_n ();
int* ints = get_n_ints (n);
swap_data (ints, ints + n);

Lexical Unit fucked around with this message at 04:06 on Jul 8, 2009

Lexical Unit fucked around with this message at 04:29 on Jul 8, 2009

Lexical Unit fucked around with this message at 05:50 on Jul 8, 2009

ImageMap::ImageMap()
{
    memset (this, 0, sizeof (*this));
}

Lexical Unit fucked around with this message at 21:15 on Jul 23, 2009