about summary refs log blame commit diff stats
path: root/marco.c
blob: 12828ef3b10be02a83f91ded92335c3990fa4d0b (plain) (tree) 
b323713 ^
















77b17b2 ^

b323713 ^





1562350 ^





e172912 ^











b323713 ^













a8d1299 ^



















1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

17

18
19
20
21
22

23
24
25
26
27

28
29
30
31
32
33
34
35
36
37
38

39
40
41
42
43
44
45
46
47
48
49
50
51

52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
















                                                                           
                     




                                                                            




                                                                            










                                                                                        












                                                                              


















                                                               
/*
 * Copyright (c) 2011 Todd T. Fries <todd@fries.net>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include <xombrero.h>

static const char *message[] = {
	"I fully support your right to put restrictions on how I can modify"
	" or distribute something you created. Calling these restrictions "
	"\"liberty,\" however, is just Orwellian doublespeak",
	"GET OFF MY INTERNET LAWN!!!!",
	"here is your list of restrictions -> freedom!!!!",
	"i am all for it being free; i am all for not allowing abuse",
	"webkit 1.4 is a huge step backwards",
	"i honestly dont get how people equate gpl with liberty or freedom",
	"I have no idea where you came up with the idea that you have to "
	"continuously patch OpenBSD. Last time I cared about that was when "
	"I was still dicking around with Linux.",
	"Problem with discussion is that it doesn't add any code to cvs.",
	"I can insult you some more but I am not sure you'd get it.",
	"the mouse is for copy/paste and the interwebs",
	"You could run openbsd and be done with it. Unlike linux is doesn't "
	"suck so that helps that decision.",
	"Twitter is the dumbest fucking thing that has ever happened to the Internet.",
	"[speaking of {open,libre}office] it is an obese crack whore with herpes boils "
	"that are about to explode"
};

const char *
marco_message(int *len)
{
	const char	*str;

	str = message[arc4random_uniform(sizeof(message)/sizeof(message[0]))];
	*len = strlen(str);

	return str;
}

int
marco(struct tab *t, struct karg *args)
{
	char			*page, line[64 * 1024];
	int			len;

	if (t == NULL)
		show_oops(NULL, "marco invalid parameters");

	line[0] = '\0';
	snprintf(line, sizeof line, "%s", marco_message(&len));

	page = get_html_page("Marco Sez...", line, "", 0);

	load_webkit_string(t, page, XT_URI_ABOUT_MARCO);
	g_free(page);

	return (0);
}
generated by cgit-pink 1.4.1-2-gfad0 (git 2.36.2.497.gbbea4dcf42) at 2024-11-16 03:15:51 +0000
an> { // this is the functionality later layers will provide // currently no automated tests for commandline arg parsing cerr << "To load files and run 'main':\n" << " mu file1.mu file2.mu ...\n" << "To run all tests:\n" << " mu test\n" << "To load files and then run all tests:\n" << " mu test file1.mu file2.mu ...\n" << "To load all files with a numeric prefix in a directory:\n" << " mu directory1\n" << "You can test directories just like files.\n" << "To pass ingredients to a mu program, provide them after '--':\n" << " mu file_or_dir1 file_or_dir2 ... -- ingredient1 ingredient2 ...\n" ; return 0; } //:: Helper function used by the above fragment of code (and later layers too, //:: who knows?). //: The :(code) directive appends function definitions to the end of the //: project. Regardless of where functions are defined, we can call them //: anywhere we like as long as we format the function header in a specific //: way: put it all on a single line without indent, end the line with ') {' //: and no trailing whitespace. As long as functions uniformly start this //: way, our makefile contains a little command to automatically generate //: declarations for them. :(code) bool is_equal(char* s, const char* lit) { return strncmp(s, lit, strlen(lit)) == 0; } //: I'll throw some style conventions here for want of a better place for them. //: As a rule I hate style guides. Do what you want, that's my motto. But since //: we're dealing with C/C++, the one big thing we want to avoid is undefined //: behavior. If a compiler ever encounters undefined behavior it can make //: your program do anything it wants. //: //: For reference, my checklist of undefined behaviors to watch out for: //: out-of-bounds access //: uninitialized variables //: use after free //: dereferencing invalid pointers: null, a new of size 0, others //: //: casting a large number to a type too small to hold it //: //: integer overflow //: division by zero and other undefined expressions //: left-shift by negative count //: shifting values by more than or equal to the number of bits they contain //: bitwise operations on signed numbers //: //: Converting pointers to types of different alignment requirements //: T* -> void* -> T*: defined //: T* -> U* -> T*: defined if non-function pointers and alignment requirements are same //: function pointers may be cast to other function pointers //: //: Casting a numeric value into a value that can't be represented by the target type (either directly or via static_cast) //: //: To guard against these, some conventions: //: //: 0. Initialize all primitive variables in functions and constructors. //: //: 1. Minimize use of pointers and pointer arithmetic. Avoid 'new' and //: 'delete' as far as possible. Rely on STL to perform memory management to //: avoid use-after-free issues (and memory leaks). //: //: 2. Avoid naked arrays to avoid out-of-bounds access. Never use operator[] //: except with map. Use at() with STL vectors and so on. //: //: 3. Valgrind all the things. //: //: 4. Avoid unsigned numbers. Not strictly an undefined-behavior issue, but //: the extra range doesn't matter, and it's one less confusing category of //: interaction gotchas to worry about. //: //: Corollary: don't use the size() method on containers, since it returns an //: unsigned and that'll cause warnings about mixing signed and unsigned, //: yadda-yadda. Instead use this macro below to perform an unsafe cast to //: signed. We'll just give up immediately if a container's ever too large. :(before "End Includes") #define SIZE(X) (assert((X).size() < (1LL<<(sizeof(long long int)*8-2))), static_cast<long long int>((X).size())) //: //: 5. Integer overflow is still impossible to guard against. Maybe after //: reading http://www.cs.utah.edu/~regehr/papers/overflow12.pdf //: //: 6. Map's operator[] being non-const is fucking evil. :(before "Globals") // can't generate prototypes for these // from http://stackoverflow.com/questions/152643/idiomatic-c-for-reading-from-a-const-map template<typename T> typename T::mapped_type& get(T& map, typename T::key_type const& key) { typename T::iterator iter(map.find(key)); assert(iter != map.end()); return iter->second; } template<typename T> typename T::mapped_type const& put(T& map, typename T::key_type const& key, typename T::mapped_type const& value) { map[key] = value; return map[key]; } template<typename T> bool contains_key(T& map, typename T::key_type const& key) { return map.find(key) != map.end(); } template<typename T> typename T::mapped_type& get_or_insert(T& map, typename T::key_type const& key) { return map[key]; } //: The contract: any container that relies on get_or_insert should never call //: contains_key. :(before "End Includes") #include<assert.h> #include<iostream> using std::istream; using std::ostream; using std::iostream; using std::cin; using std::cout; using std::cerr; #include<cstring> #include<string> using std::string;
generated by cgit-pink 1.4.1-2-gfad0 (git 2.36.2.497.gbbea4dcf42) at 2024-11-16 03:15:49 +0000