Commit dc162c7f8385d82f1e5513a5412b98ec8c70e993 | zig

author	Andrew Kelley <andrew@ziglang.org> 2016-01-15 18:45:52-07:00
committer	Andrew Kelley <andrew@ziglang.org> 2016-01-15 18:45:52-07:00
log	dc162c7f8385d82f1e5513a5412b98ec8c70e993
tree	f79da2773613dd9907367c590f861b5d7033f8eb
parent	86f55bce536b6ed678497890f5bd0eed76ebfbb3

rename "use" to "import"

12 files changed, 59 insertions(+), 94 deletions(-)

doc
- langref.md
example
- guess_number
  - main.zig
- hello_world
  - hello.zig
- maybe_type
  - main.zig
- multiple_files
  - foo.zig
  - main.zig
src
std
- bootstrap.zig
- std.zig
test
- run_tests.cpp

doc/langref.md+2-2

...	...	@@ -32,7 +32,7 @@ zig \| C equivalent \| Description
32	32	```
33	33	Root : many(TopLevelDecl) token(EOF)
34	34
35		TopLevelDecl : FnDef \| ExternBlock \| RootExportDecl \| Use \| ContainerDecl \| VariableDeclaration
	35	TopLevelDecl : FnDef \| ExternBlock \| RootExportDecl \| Import \| ContainerDecl \| VariableDeclaration
36	36
37	37	VariableDeclaration : option(FnVisibleMod) (token(Var) \| token(Const)) token(Symbol) (token(Eq) Expression \| token(Colon) PrefixOpExpression option(token(Eq) Expression))
38	38
...	...	@@ -42,7 +42,7 @@ StructMember: StructField \| FnDecl
42	42
43	43	StructField : token(Symbol) option(token(Colon) Expression) token(Comma))
44	44
45		Use : many(Directive) token(Use) token(String) token(Semicolon)
	45	Import : many(Directive) token(Import) token(String) token(Semicolon)
46	46
47	47	RootExportDecl : many(Directive) token(Export) token(Symbol) token(String) token(Semicolon)
48	48

example/guess_number/main.zig+2-2

...	...	@@ -1,7 +1,7 @@
1	1	export executable "guess_number";
2	2
3		use "std.zig";
4		use "rand.zig";
	3	import "std.zig";
	4	import "rand.zig";
5	5
6	6	pub fn main(argc: isize, argv: &&u8, env: &&u8) i32 => {
7	7	print_str("Welcome to the Guess Number Game in Zig.\n");

example/hello_world/hello.zig+1-1

...	...	@@ -1,6 +1,6 @@
1	1	export executable "hello";
2	2
3		use "std.zig";
	3	import "std.zig";
4	4
5	5	pub fn main(argc: isize, argv: &&u8, env: &&u8) i32 => {
6	6	print_str("Hello, world!\n");

example/maybe_type/main.zig deleted-35

...	...	@@ -1,35 +0,0 @@
1		export executable "maybe_type";
2
3		use "std.zig";
4
5		pub fn main(argc: isize, argv: &&u8, env: &&u8) i32 => {
6		const x : ?bool = true;
7
8		if (const y ?= x) {
9		if (y) {
10		print_str("x is true\n");
11		} else {
12		print_str("x is false\n");
13		}
14		} else {
15		print_str("x is none\n");
16		}
17
18		const next_x : ?i32 = null;
19
20		const z = next_x ?? 1234;
21
22		if (z != 1234) {
23		print_str("BAD\n");
24		}
25
26		const final_x : ?i32 = 13;
27
28		const num = final_x ?? unreachable{};
29
30		if (num != 13) {
31		print_str("BAD\n");
32		}
33
34		return 0;
35		}

example/multiple_files/foo.zig+1-1

...	...	@@ -1,4 +1,4 @@
1		use "std.zig";
	1	import "std.zig";
2	2
3	3	// purposefully conflicting function with main.zig
4	4	// but it's private so it should be OK

example/multiple_files/main.zig+2-2

...	...	@@ -1,7 +1,7 @@
1	1	export executable "test-multiple-files";
2	2
3		use "std.zig";
4		use "foo.zig";
	3	import "std.zig";
	4	import "foo.zig";
5	5
6	6	pub fn main(argc: isize, argv: &&u8, env: &&u8) i32 => {
7	7	private_function();

src/parser.cpp+1-1

...	...	@@ -2542,7 +2542,7 @@ Use : many(Directive) token(Use) token(String) token(Semicolon)
2542	2542	*/
2543	2543	static AstNode ast_parse_use(ParseContext pc, int *token_index) {
2544	2544	Token use_kw = &pc->tokens->at(token_index);
2545		if (use_kw->id != TokenIdKeywordUse)
	2545	if (use_kw->id != TokenIdKeywordImport)
2546	2546	return nullptr;
2547	2547	*token_index += 1;
2548	2548

src/tokenizer.cpp+3-3

...	...	@@ -211,8 +211,8 @@ static void end_token(Tokenize *t) {
211	211	t->cur_tok->id = TokenIdKeywordPub;
212	212	} else if (mem_eql_str(token_mem, token_len, "export")) {
213	213	t->cur_tok->id = TokenIdKeywordExport;
214		} else if (mem_eql_str(token_mem, token_len, "use")) {
215		t->cur_tok->id = TokenIdKeywordUse;
	214	} else if (mem_eql_str(token_mem, token_len, "import")) {
	215	t->cur_tok->id = TokenIdKeywordImport;
216	216	} else if (mem_eql_str(token_mem, token_len, "true")) {
217	217	t->cur_tok->id = TokenIdKeywordTrue;
218	218	} else if (mem_eql_str(token_mem, token_len, "false")) {
...	...	@@ -1017,7 +1017,7 @@ const char * token_name(TokenId id) {
1017	1017	case TokenIdKeywordExtern: return "extern";
1018	1018	case TokenIdKeywordPub: return "pub";
1019	1019	case TokenIdKeywordExport: return "export";
1020		case TokenIdKeywordUse: return "use";
	1020	case TokenIdKeywordImport: return "import";
1021	1021	case TokenIdKeywordTrue: return "true";
1022	1022	case TokenIdKeywordFalse: return "false";
1023	1023	case TokenIdKeywordIf: return "if";

src/tokenizer.hpp+1-1

...	...	@@ -20,7 +20,7 @@ enum TokenId {
20	20	TokenIdKeywordExtern,
21	21	TokenIdKeywordPub,
22	22	TokenIdKeywordExport,
23		TokenIdKeywordUse,
	23	TokenIdKeywordImport,
24	24	TokenIdKeywordTrue,
25	25	TokenIdKeywordFalse,
26	26	TokenIdKeywordIf,

std/bootstrap.zig+1-1

...	...	@@ -1,4 +1,4 @@
1		use "syscall.zig";
	1	import "syscall.zig";
2	2
3	3	// The compiler treats this file special by implicitly importing the function `main`
4	4	// from the root source file.

std/std.zig+1-1

...	...	@@ -1,4 +1,4 @@
1		use "syscall.zig";
	1	import "syscall.zig";
2	2
3	3	pub const stdin_fileno : isize = 0;
4	4	pub const stdout_fileno : isize = 1;

test/run_tests.cpp+44-44

...	...	@@ -108,8 +108,8 @@ export fn main(argc: i32, argv: &&u8, env: &&u8) i32 => {
108	108	)SOURCE", "Hello, world!\n");
109	109
110	110	add_simple_case("function call", R"SOURCE(
111		use "std.zig";
112		use "syscall.zig";
	111	import "std.zig";
	112	import "syscall.zig";
113	113
114	114	fn empty_function_1() => {}
115	115	fn empty_function_2() => { return; }
...	...	@@ -127,7 +127,7 @@ fn this_is_a_function() unreachable => {
127	127	)SOURCE", "OK\n");
128	128
129	129	add_simple_case("comments", R"SOURCE(
130		use "std.zig";
	130	import "std.zig";
131	131
132	132	/**
133	133	* multi line doc comment
...	...	@@ -144,8 +144,8 @@ pub fn main(argc: isize, argv: &&u8, env: &&u8) i32 => {
144	144
145	145	{
146	146	TestCase *tc = add_simple_case("multiple files with private function", R"SOURCE(
147		use "std.zig";
148		use "foo.zig";
	147	import "std.zig";
	148	import "foo.zig";
149	149
150	150	pub fn main(argc: isize, argv: &&u8, env: &&u8) i32 => {
151	151	private_function();
...	...	@@ -159,7 +159,7 @@ fn private_function() => {
159	159	)SOURCE", "OK 1\nOK 2\n");
160	160
161	161	add_source_file(tc, "foo.zig", R"SOURCE(
162		use "std.zig";
	162	import "std.zig";
163	163
164	164	// purposefully conflicting function with main.zig
165	165	// but it's private so it should be OK
...	...	@@ -175,8 +175,8 @@ pub fn print_text() => {
175	175
176	176	{
177	177	TestCase *tc = add_simple_case("import segregation", R"SOURCE(
178		use "foo.zig";
179		use "bar.zig";
	178	import "foo.zig";
	179	import "bar.zig";
180	180
181	181	pub fn main(argc: isize, argv: &&u8, env: &&u8) i32 => {
182	182	foo_function();
...	...	@@ -186,15 +186,15 @@ pub fn main(argc: isize, argv: &&u8, env: &&u8) i32 => {
186	186	)SOURCE", "OK\nOK\n");
187	187
188	188	add_source_file(tc, "foo.zig", R"SOURCE(
189		use "std.zig";
	189	import "std.zig";
190	190	pub fn foo_function() => {
191	191	print_str("OK\n");
192	192	}
193	193	)SOURCE");
194	194
195	195	add_source_file(tc, "bar.zig", R"SOURCE(
196		use "other.zig";
197		use "std.zig";
	196	import "other.zig";
	197	import "std.zig";
198	198
199	199	pub fn bar_function() => {
200	200	if (foo_function()) {
...	...	@@ -212,7 +212,7 @@ pub fn foo_function() bool => {
212	212	}
213	213
214	214	add_simple_case("if statements", R"SOURCE(
215		use "std.zig";
	215	import "std.zig";
216	216
217	217	pub fn main(argc: isize, argv: &&u8, env: &&u8) i32 => {
218	218	if (1 != 0) {
...	...	@@ -233,7 +233,7 @@ pub fn main(argc: isize, argv: &&u8, env: &&u8) i32 => {
233	233	)SOURCE", "1 is true\n!0 is true\n");
234	234
235	235	add_simple_case("params", R"SOURCE(
236		use "std.zig";
	236	import "std.zig";
237	237
238	238	fn add(a: i32, b: i32) i32 => {
239	239	a + b
...	...	@@ -248,7 +248,7 @@ pub fn main(argc: isize, argv: &&u8, env: &&u8) i32 => {
248	248	)SOURCE", "pass\n");
249	249
250	250	add_simple_case("goto", R"SOURCE(
251		use "std.zig";
	251	import "std.zig";
252	252
253	253	fn loop(a : i32) => {
254	254	if (a == 0) {
...	...	@@ -268,7 +268,7 @@ pub fn main(argc: isize, argv: &&u8, env: &&u8) i32 => {
268	268	)SOURCE", "loop\nloop\nloop\n");
269	269
270	270	add_simple_case("local variables", R"SOURCE(
271		use "std.zig";
	271	import "std.zig";
272	272
273	273	pub fn main(argc: isize, argv: &&u8, env: &&u8) i32 => {
274	274	const a : i32 = 1;
...	...	@@ -281,7 +281,7 @@ pub fn main(argc: isize, argv: &&u8, env: &&u8) i32 => {
281	281	)SOURCE", "OK\n");
282	282
283	283	add_simple_case("bool literals", R"SOURCE(
284		use "std.zig";
	284	import "std.zig";
285	285
286	286	pub fn main(argc: isize, argv: &&u8, env: &&u8) i32 => {
287	287	if (true) { print_str("OK 1\n"); }
...	...	@@ -293,7 +293,7 @@ pub fn main(argc: isize, argv: &&u8, env: &&u8) i32 => {
293	293	)SOURCE", "OK 1\nOK 2\n");
294	294
295	295	add_simple_case("separate block scopes", R"SOURCE(
296		use "std.zig";
	296	import "std.zig";
297	297
298	298	pub fn main(argc: isize, argv: &&u8, env: &&u8) i32 => {
299	299	if (true) {
...	...	@@ -311,7 +311,7 @@ pub fn main(argc: isize, argv: &&u8, env: &&u8) i32 => {
311	311	)SOURCE", "OK 1\nOK 2\n");
312	312
313	313	add_simple_case("void parameters", R"SOURCE(
314		use "std.zig";
	314	import "std.zig";
315	315
316	316	pub fn main(argc: isize, argv: &&u8, env: &&u8) i32 => {
317	317	void_fun(1, void{}, 2);
...	...	@@ -327,7 +327,7 @@ fn void_fun(a : i32, b : void, c : i32) => {
327	327	)SOURCE", "OK\n");
328	328
329	329	add_simple_case("void struct fields", R"SOURCE(
330		use "std.zig";
	330	import "std.zig";
331	331	struct Foo {
332	332	a : void,
333	333	b : i32,
...	...	@@ -352,7 +352,7 @@ pub fn main(argc: isize, argv: &&u8, env: &&u8) i32 => {
352	352	)SOURCE", "OK\n");
353	353
354	354	add_simple_case("void arrays", R"SOURCE(
355		use "std.zig";
	355	import "std.zig";
356	356
357	357	pub fn main(argc: isize, argv: &&u8, env: &&u8) i32 => {
358	358	var array: [4]void;
...	...	@@ -371,7 +371,7 @@ pub fn main(argc: isize, argv: &&u8, env: &&u8) i32 => {
371	371
372	372
373	373	add_simple_case("mutable local variables", R"SOURCE(
374		use "std.zig";
	374	import "std.zig";
375	375
376	376	pub fn main(argc: isize, argv: &&u8, env: &&u8) i32 => {
377	377	var zero : i32 = 0;
...	...	@@ -391,7 +391,7 @@ done:
391	391	)SOURCE", "zero\nloop\nloop\nloop\n");
392	392
393	393	add_simple_case("arrays", R"SOURCE(
394		use "std.zig";
	394	import "std.zig";
395	395
396	396	pub fn main(argc: isize, argv: &&u8, env: &&u8) i32 => {
397	397	var array : [5]u32;
...	...	@@ -427,7 +427,7 @@ fn get_array_len(a: []u32) usize => {
427	427
428	428
429	429	add_simple_case("hello world without libc", R"SOURCE(
430		use "std.zig";
	430	import "std.zig";
431	431
432	432	pub fn main(argc : isize, argv : &&u8, env : &&u8) i32 => {
433	433	print_str("Hello, world!\n");
...	...	@@ -437,7 +437,7 @@ pub fn main(argc : isize, argv : &&u8, env : &&u8) i32 => {
437	437
438	438
439	439	add_simple_case("a + b + c", R"SOURCE(
440		use "std.zig";
	440	import "std.zig";
441	441
442	442	pub fn main(argc : isize, argv : &&u8, env : &&u8) i32 => {
443	443	if (false \|\| false \|\| false) { print_str("BAD 1\n"); }
...	...	@@ -459,7 +459,7 @@ pub fn main(argc : isize, argv : &&u8, env : &&u8) i32 => {
459	459	)SOURCE", "OK\n");
460	460
461	461	add_simple_case("short circuit", R"SOURCE(
462		use "std.zig";
	462	import "std.zig";
463	463
464	464	pub fn main(argc : isize, argv : &&u8, env : &&u8) i32 => {
465	465	if (true \|\| { print_str("BAD 1\n"); false }) {
...	...	@@ -482,7 +482,7 @@ pub fn main(argc : isize, argv : &&u8, env : &&u8) i32 => {
482	482	)SOURCE", "OK 1\nOK 2\nOK 3\nOK 4\n");
483	483
484	484	add_simple_case("modify operators", R"SOURCE(
485		use "std.zig";
	485	import "std.zig";
486	486
487	487	pub fn main(argc : isize, argv : &&u8, env : &&u8) i32 => {
488	488	var i : i32 = 0;
...	...	@@ -634,7 +634,7 @@ export fn main(argc : isize, argv : &&u8, env : &&u8) i32 => {
634	634	)OUTPUT");
635	635
636	636	add_simple_case("structs", R"SOURCE(
637		use "std.zig";
	637	import "std.zig";
638	638
639	639	pub fn main(argc : isize, argv : &&u8, env : &&u8) i32 => {
640	640	var foo : Foo;
...	...	@@ -706,7 +706,7 @@ fn test_initializer() => {
706	706	)SOURCE", "OK\n");
707	707
708	708	add_simple_case("global variables", R"SOURCE(
709		use "std.zig";
	709	import "std.zig";
710	710
711	711	const g1 : i32 = 1233 + 1;
712	712	var g2 : i32 = 0;
...	...	@@ -721,7 +721,7 @@ pub fn main(argc : isize, argv : &&u8, env : &&u8) i32 => {
721	721	)SOURCE", "OK\n");
722	722
723	723	add_simple_case("while loop", R"SOURCE(
724		use "std.zig";
	724	import "std.zig";
725	725	pub fn main(argc : isize, argv : &&u8, env : &&u8) i32 => {
726	726	var i : i32 = 0;
727	727	while (i < 4) {
...	...	@@ -738,7 +738,7 @@ fn f() i32 => {
738	738	)SOURCE", "loop\nloop\nloop\nloop\n");
739	739
740	740	add_simple_case("continue and break", R"SOURCE(
741		use "std.zig";
	741	import "std.zig";
742	742	pub fn main(argc : isize, argv : &&u8, env : &&u8) i32 => {
743	743	var i : i32 = 0;
744	744	while (true) {
...	...	@@ -754,7 +754,7 @@ pub fn main(argc : isize, argv : &&u8, env : &&u8) i32 => {
754	754	)SOURCE", "loop\nloop\nloop\nloop\n");
755	755
756	756	add_simple_case("maybe type", R"SOURCE(
757		use "std.zig";
	757	import "std.zig";
758	758	pub fn main(argc: isize, argv: &&u8, env: &&u8) i32 => {
759	759	const x : ?bool = true;
760	760
...	...	@@ -789,7 +789,7 @@ pub fn main(argc: isize, argv: &&u8, env: &&u8) i32 => {
789	789	)SOURCE", "x is true\n");
790	790
791	791	add_simple_case("implicit cast after unreachable", R"SOURCE(
792		use "std.zig";
	792	import "std.zig";
793	793	pub fn main(argc : isize, argv : &&u8, env : &&u8) i32 => {
794	794	const x = outer();
795	795	if (x == 1234) {
...	...	@@ -804,7 +804,7 @@ fn outer() isize => {
804	804	)SOURCE", "OK\n");
805	805
806	806	add_simple_case("@sizeof() and @typeof()", R"SOURCE(
807		use "std.zig";
	807	import "std.zig";
808	808	const x: u16 = 13;
809	809	const z: @typeof(x) = 19;
810	810	pub fn main(argc : isize, argv : &&u8, env : &&u8) i32 => {
...	...	@@ -816,7 +816,7 @@ pub fn main(argc : isize, argv : &&u8, env : &&u8) i32 => {
816	816	)SOURCE", "2\n");
817	817
818	818	add_simple_case("member functions", R"SOURCE(
819		use "std.zig";
	819	import "std.zig";
820	820	struct Rand {
821	821	seed: u32,
822	822	pub fn get_seed(r: Rand) u32 => {
...	...	@@ -834,7 +834,7 @@ pub fn main(argc : isize, argv : &&u8, env : &&u8) i32 => {
834	834	)SOURCE", "OK\n");
835	835
836	836	add_simple_case("pointer dereferencing", R"SOURCE(
837		use "std.zig";
	837	import "std.zig";
838	838
839	839	pub fn main(argc: isize, argv: &&u8, env: &&u8) i32 => {
840	840	var x = i32(3);
...	...	@@ -854,7 +854,7 @@ pub fn main(argc: isize, argv: &&u8, env: &&u8) i32 => {
854	854	)SOURCE", "OK\n");
855	855
856	856	add_simple_case("constant expressions", R"SOURCE(
857		use "std.zig";
	857	import "std.zig";
858	858
859	859	const ARRAY_SIZE : u8 = 20;
860	860
...	...	@@ -867,7 +867,7 @@ pub fn main(argc: isize, argv: &&u8, env: &&u8) i32 => {
867	867	)SOURCE", "20\n");
868	868
869	869	add_simple_case("#min_value() and #max_value()", R"SOURCE(
870		use "std.zig";
	870	import "std.zig";
871	871	pub fn main(argc: isize, argv: &&u8, env: &&u8) i32 => {
872	872	print_str("max u8: ");
873	873	print_u64(@max_value(u8));
...	...	@@ -955,7 +955,7 @@ pub fn main(argc: isize, argv: &&u8, env: &&u8) i32 => {
955	955
956	956
957	957	add_simple_case("slicing", R"SOURCE(
958		use "std.zig";
	958	import "std.zig";
959	959	pub fn main(argc: isize, argv: &&u8, env: &&u8) i32 => {
960	960	var array : [20]i32;
961	961
...	...	@@ -983,7 +983,7 @@ pub fn main(argc: isize, argv: &&u8, env: &&u8) i32 => {
983	983
984	984
985	985	add_simple_case("else if expression", R"SOURCE(
986		use "std.zig";
	986	import "std.zig";
987	987	pub fn main(argc: isize, argv: &&u8, env: &&u8) i32 => {
988	988	if (f(1) == 1) {
989	989	print_str("OK\n");
...	...	@@ -1002,7 +1002,7 @@ fn f(c: u8) u8 => {
1002	1002	)SOURCE", "OK\n");
1003	1003
1004	1004	add_simple_case("overflow intrinsics", R"SOURCE(
1005		use "std.zig";
	1005	import "std.zig";
1006	1006	pub fn main(argc: isize, argv: &&u8, env: &&u8) i32 => {
1007	1007	var result: u8;
1008	1008	if (!@add_with_overflow(u8, 250, 100, &result)) {
...	...	@@ -1020,7 +1020,7 @@ pub fn main(argc: isize, argv: &&u8, env: &&u8) i32 => {
1020	1020	)SOURCE", "OK\n");
1021	1021
1022	1022	add_simple_case("memcpy and memset intrinsics", R"SOURCE(
1023		use "std.zig";
	1023	import "std.zig";
1024	1024	pub fn main(argc: isize, argv: &&u8, env: &&u8) i32 => {
1025	1025	var foo : [20]u8;
1026	1026	var bar : [20]u8;
...	...	@@ -1038,7 +1038,7 @@ pub fn main(argc: isize, argv: &&u8, env: &&u8) i32 => {
1038	1038	)SOURCE", "OK\n");
1039	1039
1040	1040	add_simple_case("order-independent declarations", R"SOURCE(
1041		use "std.zig";
	1041	import "std.zig";
1042	1042	const z : @typeof(stdin_fileno) = 0;
1043	1043	const x : @typeof(y) = 1234;
1044	1044	const y : u16 = 5678;
...	...	@@ -1053,7 +1053,7 @@ const foo : i32 = 0;
1053	1053	)SOURCE", "OK\n");
1054	1054
1055	1055	add_simple_case("enum type", R"SOURCE(
1056		use "std.zig";
	1056	import "std.zig";
1057	1057
1058	1058	struct Point {
1059	1059	x: u64,
...	...	@@ -1167,7 +1167,7 @@ export executable "test";
1167	1167	)SOURCE", 1, ".tmp_source.zig:2:1: error: invalid version string");
1168	1168
1169	1169	add_compile_fail_case("bad import", R"SOURCE(
1170		use "bogus-does-not-exist.zig";
	1170	import "bogus-does-not-exist.zig";
1171	1171	)SOURCE", 1, ".tmp_source.zig:2:1: error: unable to find 'bogus-does-not-exist.zig'");
1172	1172
1173	1173	add_compile_fail_case("undeclared identifier", R"SOURCE(