cluaupp 0.1.2 → 0.1.5

package/docs/oop/file-tags.md

@@ -0,0 +1,48 @@
+---
+title: File tags
+sidebar_position: 2
+---
+
+# File tags
+
+The **filename** decides the Roblox instance. This is the same key idea as roblox-ts (`*.server.ts` → Script).
+
+| Source | Instance | RunContext |
+| --- | --- | --- |
+| `LeaderstatsServer.server.cpp` | **Script** | **Server** |
+| `DataBoot.client.cpp` | **LocalScript** | Client |
+| `Tools.plugin.cpp` | **Script** | Plugin |
+| `Boot.legacy.cpp` | Script | **Legacy** |
+| `Boot.legacy.server.cpp` | Script | **Legacy** |
+| `Boot.legacy.client.cpp` | LocalScript | Legacy |
+| `Damage.cpp` (no tag) | **ModuleScript** | — |
+| `LeaderstatsServer.h` | **ModuleScript** (types) | — |
+| `LeaderstatsServer.cpp` (sibling of `.h`) | **ModuleScript** (`*Impl`) | — |
+
+## One file in, one file out
+
+Rojo infers the instance from the filename key: `*.server.luau` is a Script, `*.client.luau` is a LocalScript, untagged `.luau` is a ModuleScript.
+
+```
+src/server/boot/DataBoot.server.cpp  →  out/server/boot/DataBoot.server.luau
+src/client/boot/DataBoot.client.cpp  →  out/client/boot/DataBoot.client.luau
+src/shared/damage.cpp                →  out/shared/Damage.luau
+src/server/services/leaderstats/LeaderstatsServer.h   →  LeaderstatsServer.luau  (export type)
+src/server/services/leaderstats/LeaderstatsServer.cpp →  LeaderstatsServerImpl.luau
+```
+
+`.legacy.server.cpp` still emits a Legacy Script (`boot.server.luau`). `.client.cpp` stays a LocalScript. Do not invent `init.meta.json` on the default 1:1 path.
+
+## Where files live
+
+```
+src/server/.../*.server.cpp   → out/server  (ServerScriptService.Cluaupp)
+src/client/.../*.client.cpp   → out/client  (StarterPlayerScripts.Cluaupp)
+src/shared/.../*.cpp          → out/shared  (ReplicatedStorage.Cluaupp)
+```
+
+Name the **system**, not `init.server.cpp`. `LeaderstatsServer.server.cpp` and `DataBoot.server.cpp` are two files.
+
+## Opt-in planner
+
+`"architecture": true` in `cluaupp.config.json` restores PascalCase service folders (`Main`, Controller, Types). Default is off.

package/docs/oop/index.md

@@ -0,0 +1,22 @@
+---
+title: OOP structure
+sidebar_position: 1
+---
+
+# OOP structure
+
+The **live site** (not just these markdown files) is GitHub Pages:
+
+- [Learn → OOP structure](https://kartzrbx.github.io/Cluaupp/learn/index.html)
+- [Guide → OOP](https://kartzrbx.github.io/Cluaupp/guide/oop.html)
+- [Examples](https://kartzrbx.github.io/Cluaupp/guide/examples.html)
+
+Cluaupp does **not** compile custom C++ `class` types yet. “OOP” here is how you **lay out systems** so Studio gets Script / LocalScript / ModuleScript from the filename tag — the same idea as roblox-ts. Flamework-style Start/Stop folders are opt-in (`"architecture": true`).
+
+| Page | What you learn |
+| --- | --- |
+| [File tags](file-tags.md) | `.server` / `.client` / `.plugin` / `.legacy` / untagged |
+| [Services](services.md) | One `.server.cpp` → one `.server.luau` |
+| [Modules](modules.md) | Untagged files, structs, named functions as methods |
+
+Planner details: [Architecture](../architecture.md). Folder layout: [Organization](../cpp-organization.md). Full services: [Examples](../examples/index.md).

package/docs/oop/modules.md

@@ -0,0 +1,88 @@
+---
+title: Modules and structs
+sidebar_position: 4
+---
+
+# Modules and structs
+
+Use this when you want a **reusable object** without a tagged Script.
+
+## Untagged `.cpp` = ModuleScript
+
+```
+src/shared/util/Coins.cpp
+```
+
+```cpp
+#include <cluaupp/roblox.hpp>
+
+int DoubleCoins(int coins) {
+	return coins;
+}
+```
+
+```
+out/shared/util/Coins.luau   -- ModuleScript, exported functions
+```
+
+Quoted `#include "TemplateData.hpp"` is not inlined when the header has a sibling `.cpp` or is a shared module: `cluaupp build` emits `require(ReplicatedStorage.Cluaupp.constants.TemplateData)` / `require(ServerScriptService.Cluaupp.configurations.PlayerDataVersion)` (Rojo roots from `default.project.json`), never `script.Parent.Parent.shared`.
+
+`.h` / `.hpp` are **type modules**. A service header becomes `export type Name = { init: (self: Name) -> (), … }` and a typed table. The sibling `.cpp` is the construction (`NameImpl.luau`); the header `require`s that impl and binds the functions. Data-only structs still emit a constructor so `TemplateData()` works. Untagged `.cpp` without a header is a ModuleScript other Luau can `require`. Prefer headers for the public type, tagged `.server.cpp` / `.client.cpp` for scripts, and the sibling `.cpp` for method bodies.
+
+## Structs = data, not classes
+
+The subset allows structs for IntelliSense and designated initializers (tables):
+
+```cpp
+struct TemplateData {
+	struct Currencies {
+		int Money = 0;
+		int Level = 1;
+	} Currencies;
+};
+
+TemplateData playerData = TemplateData {};
+```
+
+That is your “class fields”. Methods are **named functions** next to them (`EnsureStat`, `ApplyCurrencies`). Cluaupp does not emit `function TemplateData:GetMoney()`.
+
+## Methods as functions
+
+```cpp
+void EnsureStat(Folder* folder, string name, int value) {
+	auto* stat = folder->FindFirstChild(name);
+	if (stat == nullptr) {
+		cout::print << "EnsureStat: " << name << " not found" << endl;
+		return;
+	}
+}
+```
+
+Pass the instance in (`folder`, `player`). That is composition: the Folder is the object, the function is the method.
+
+## Janitor as the destructor
+
+There is no C++ destructor. Pair “construct” with a Janitor:
+
+```cpp
+auto* janitor = new Janitor();
+janitor->LinkToInstance(player);
+janitor->Add(player->AncestryChanged.Connect(OnAncestry));
+```
+
+When the player leaves, `LinkToInstance` runs `Cleanup`. That is RAII for Roblox.
+
+## Start / Stop
+
+On generated services, `Main.Start` / `Main.Stop` are the constructor / destructor of the **system**. Put connections in Start (or in `init()` / `PlayersManager`). Do not leak `Connect` without a Janitor.
+
+## What not to write
+
+```cpp
+class Shop {
+	int price;
+	void Buy(Player* player);
+};
+```
+
+Custom classes are **not supported**. Split into a struct (fields) + functions (methods) + a `.server.cpp` or untagged module (lifetime).

package/docs/oop/services.md

@@ -0,0 +1,76 @@
+---
+title: Services
+sidebar_position: 3
+---
+
+# Services
+
+Write **one tagged file per system**. Cluaupp emits **one** Luau instance: `LeaderstatsServer.server.luau` from `LeaderstatsServer.server.cpp`. It does not invent Main / Controller / Types unless `"architecture": true`.
+
+## Example: leaderstats
+
+```cpp
+#include <cluaupp/roblox.hpp>
+#include <cluaupp/libs/janitor.hpp>
+#include <cluaupp/libs/dataservice.hpp>
+
+void EnsureStat(Folder* folder, string name, int value) {
+	return;
+}
+
+void ApplyCurrencies(Player* player, Data* data) {
+	return;
+}
+
+void OnCurrenciesChanged() {
+	return;
+}
+
+void SetupPlayerManager(Player* player) {
+	Data* data = DataService::Server.WaitFor(player);
+	if (data == nullptr) {
+		return;
+	}
+	ApplyCurrencies(player, data);
+	data->GetChangedSignal(DataService::Server.Paths.Currencies).Connect(OnCurrenciesChanged);
+}
+
+void init() {
+	auto* players = GetService<Players>();
+	players->PlayerAdded.Connect(SetupPlayerManager);
+}
+```
+
+Typical output:
+
+```
+out/server/services/leaderstats/LeaderstatsServer.server.luau
+```
+
+Your functions stay in that file. `init()` runs at the end. There is no fake `Main` that only forwards to a Controller.
+
+## Lifecycle
+
+You own `init` and Janitor cleanup in the same file. You do not write `class LeaderstatsServer` — name the **file** `LeaderstatsServer.server.cpp` and keep **functions** as the public API.
+
+`"architecture": true` is the old ForeverHD split (`Main.Start` / `Main.Stop`, Managers, Types). Leave it off unless you want that.
+
+## Boot vs gameplay
+
+Keep DataService `Init` in `DataBoot.server.cpp` / `DataBoot.client.cpp`. Keep leaderstats / combat in their own `.server.cpp`. Services `WaitFor` after boot has run.
+
+## Opt-in roles (`"architecture": true`)
+
+| Your C++ | Generated role |
+| --- | --- |
+| `PlayerAdded`, `GetPlayers` | `PlayersManager` |
+| `Folder` + `IntValue` | `CacheController` |
+| `DataService`, `GetChangedSignal` | `DataController` |
+| `TakeDamage`, `Humanoid` | `CombatController` |
+| `Net::Event` | `NetController` |
+| `UserInputService` | `InputController` |
+| wiring | `Main.Start` / `Main.Stop` |
+
+A tiny `print` in `init.client.cpp` stays a single LocalScript.
+
+Copy-paste: [Examples](../examples/index.md).

package/docs/print-cout.md

@@ -0,0 +1,91 @@
+---
+title: print and cout
+sidebar_position: 8
+---
+
+# print and cout
+
+Cluaupp has no `<iostream>`. Logging is Roblox `print` / `warn` / `error`. You can still write C++-style `cout` / `cerr` / `endl` — the compiler flattens them.
+
+## Globals
+
+```cpp
+print("ok");
+warn("careful");
+error("fail");
+```
+
+```luau
+print("ok")
+warn("careful")
+error("fail")
+```
+
+`print` in C++ takes a string (and chained `cout` pieces). Do not expect full C++ `std::cout` overloads.
+
+## Stream: `cout << … << endl`
+
+Each `<<` is another argument. `endl` ends the statement (no extra `"\n"`).
+
+```cpp
+cout << "EnsureStat: " << name << " not found" << endl;
+```
+
+```luau
+print("EnsureStat: ", name, " not found")
+```
+
+`cerr` is the same chain, emitted as `warn`:
+
+```cpp
+cerr << "failed to load " << player->Name << endl;
+```
+
+```luau
+warn("failed to load ", player.Name)
+```
+
+## Levels: `cout::print` / `warn` / `error` / `ping`
+
+Use `::` to pick the Roblox function. The stream still concatenates with `<<`.
+
+```cpp
+cout::print << "EnsureStat test: " << name << " not found" << endl;
+cout::warn << "missing folder for " << player->Name << endl;
+cout::error << "profile failed" << endl;
+cout::ping << "here" << endl;
+```
+
+```luau
+print("EnsureStat test: ", name, " not found")
+warn("missing folder for ", player.Name)
+error("profile failed")
+print("here")
+```
+
+| C++ | Luau |
+| --- | --- |
+| `cout << … << endl` | `print(…)` |
+| `cout::print << … << endl` | `print(…)` |
+| `cout::warn << … << endl` | `warn(…)` |
+| `cout::error << … << endl` | `error(…)` |
+| `cout::ping << … << endl` | `print(…)` |
+| `cerr << … << endl` | `warn(…)` |
+
+`cout::ping` is a debug alias of `print` (no extra Studio highlight).
+
+## Call form (no `<<`)
+
+```cpp
+cout::print("ok");
+cout::warn("careful");
+cout::error("fail");
+cout::ping("here");
+cout::endl();
+```
+
+`cout::endl()` is a no-op in Luau (flush is already the statement). Prefer `<< endl` on a stream.
+
+## IntelliSense
+
+`struct cout` / `cerr` and `endl` live in `<cluaupp/roblox.hpp>`. Include that header so clangd knows `cout::print` and `operator<<`.

package/docs/syntax.md

@@ -2,15 +2,16 @@
 
 Cluaupp is not a full C++ compiler. It is a **subset** aimed at Roblox scripts, in the same spirit as roblox-ts (restricted TypeScript → Luau).
 
-Generated Luau follows the current language: [`--!strict`](https://luau.org/getting-started), `local`, and `const`.
+Generated Luau follows the current language: [`local`](https://luau.org/getting-started), `const`, and `const function`. Injected `require` / `GetService` lines are `const`. `--!strict` is emitted only when the file has `#pragma strict` (or `"strict": true` in config).
 
 ## Files
 
 - Extensions: `.cpp`, `.h`, `.hpp` (also `.cc`, `.hh`)
-- Quoted `#include "file.h"` is inlined (C preprocessor)
+- Quoted `#include "file.h"` becomes a Rojo `require` (or is inlined for a header that belongs to the same `.cpp`)
 - `#include <cluaupp/roblox.hpp>` and `<cluaupp/libs/*.hpp>` are IntelliSense only; library headers also inject `require(CluauppLibs.*)`
-- Other `#` lines (`#pragma once`) are ignored
-- Function prototypes (`void foo();`) are skipped; only functions with a body are emitted
+- `#pragma once` is ignored
+- `#pragma strict` / `#pragma nstrict` control `--!strict` for that compilation unit
+- Function prototypes in a `.h` / `.hpp` become `export type` fields (`init: (self: Name) -> ()`). Only `.cpp` files emit function bodies.
 
 ## Functions
 
@@ -25,11 +26,11 @@ int doubleCoins(int coins) {
 ```
 
 ```luau
-local function CreateLeaderstats(player: Player)
+const function CreateLeaderstats(player: Player)
 	return
 end
 
-local function doubleCoins(coins: number): number
+const function doubleCoins(coins: number): number
 	return coins
 end
 ```
@@ -73,6 +74,22 @@ while (true) {
 for (auto* player : players->GetPlayers()) {
 	CreateLeaderstats(player);
 }
+
+switch (action) {
+case "buy":
+case "purchase":
+	Grant(player);
+	break;
+case "sell":
+	if (amount <= 0) {
+		break;
+	}
+	Take(player);
+	break;
+default:
+	warn("unknown");
+	break;
+}
 ```
 
 ```luau
@@ -89,9 +106,22 @@ end
 for _, player in players:GetPlayers() do
 	CreateLeaderstats(player)
 end
+
+repeat
+	if action == "buy" or action == "purchase" then
+		Grant(player)
+	elseif action == "sell" then
+		if amount <= 0 then
+			break
+		end
+		Take(player)
+	else
+		warn("unknown")
+	end
+until true
 ```
 
-The only `for` accepted today is **range-for**: `for (auto* x : list)`. C-style `for (int i = 0; i < n; i++)` is not supported yet.
+`switch` evaluates the discriminant **once**, then becomes `if` / `elseif` / `else` inside `repeat … until true` so `break` still exits the switch (even from inside an `if`). Stacked `case` labels share a body (`case "buy": case "purchase":`). There is no C-style fall-through into the next case’s statements. C-style `for (int i = 0; i < n; i++)` is not supported yet.
 
 ## Expressions
 
@@ -143,8 +173,33 @@ local players: Players = game:GetService("Players")
 
 The first argument of `new Class(parent)` becomes `.Parent`. With no argument: `Instance.new("Class")` only.
 
+## print / cout
+
+`print`, `warn`, and `error` work as in Luau. `cout << … << endl` is the C++ spelling — each `<<` is another argument, `endl` ends the line. `cout::warn` / `cout::error` / `cout::ping` pick the Roblox function.
+
+```cpp
+cout << "EnsureStat: " << name << " not found" << endl;
+cout::print << "EnsureStat: " << name << " not found" << endl;
+cerr << "failed";
+cout::print("ok");
+cout::warn("careful");
+cout::error("fail");
+cout::ping("here");
+```
+
+```luau
+print("EnsureStat: ", name, " not found")
+warn("failed")
+print("ok")
+warn("careful")
+error("fail")
+print("here")
+```
+
+Full table and IntelliSense notes: [print and cout](print-cout.md).
+
 ## Not supported yet
 
-Custom C++ classes, generic templates besides `GetService<T>`, pointer arithmetic, `switch`, `std::`, overloading, macros (except skipping `#` lines).
+Custom C++ classes, generic templates besides `GetService<T>`, pointer arithmetic, `std::`, overloading, macros (except `#pragma strict` / `#pragma nstrict` / `#pragma once`).
 
 If you need one of those patterns, open an issue with the C++ and the expected Luau.

package/editors/vscode/extension.js

@@ -0,0 +1,146 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const vscode = require("vscode");
+
+function loadEngine(context) {
+	const folders = vscode.workspace.workspaceFolders || [];
+	const workspaceFolder = folders[0] ? folders[0].uri.fsPath : null;
+	const rootFile = path.join(context.extensionPath, "cluaupp.root");
+	const roots = [];
+	if (fs.existsSync(rootFile)) {
+		roots.push(fs.readFileSync(rootFile, "utf8").trim());
+	}
+	if (workspaceFolder) {
+		roots.push(path.join(workspaceFolder, "..", "Cluaupp"));
+		roots.push(path.join(workspaceFolder, "node_modules", "cluaupp"));
+	}
+	roots.push(path.join(context.extensionPath, "..", ".."));
+	for (const root of roots) {
+		const engine = path.join(root, "src", "intellisense.js");
+		if (fs.existsSync(engine)) {
+			return { engine: require(engine), root, workspaceFolder };
+		}
+	}
+	throw new Error("Cluaupp IntelliSense engine not found. Run `cluaupp intellisense` in the game folder.");
+}
+
+function kindOf(kind) {
+	const map = {
+		method: vscode.CompletionItemKind.Method,
+		function: vscode.CompletionItemKind.Function,
+		constructor: vscode.CompletionItemKind.Constructor,
+		property: vscode.CompletionItemKind.Property,
+		variable: vscode.CompletionItemKind.Variable,
+		class: vscode.CompletionItemKind.Class,
+		enum: vscode.CompletionItemKind.Enum,
+		keyword: vscode.CompletionItemKind.Keyword,
+		event: vscode.CompletionItemKind.Event,
+		file: vscode.CompletionItemKind.File,
+	};
+	return map[kind] || vscode.CompletionItemKind.Text;
+}
+
+function activate(context) {
+	let loaded;
+	try {
+		loaded = loadEngine(context);
+	} catch (err) {
+		vscode.window.showWarningMessage(String(err.message || err));
+		return;
+	}
+
+	const selector = { language: "cpp", scheme: "file" };
+	const diagnostics = vscode.languages.createDiagnosticCollection("cluaupp");
+	context.subscriptions.push(diagnostics);
+
+	const optionsFor = (document) => ({
+		projectRoot: loaded.workspaceFolder || path.dirname(document.uri.fsPath),
+		file: document.uri.fsPath,
+		filePath: document.uri.fsPath,
+		includeDirs: [
+			path.dirname(document.uri.fsPath),
+			path.join(loaded.workspaceFolder || "", "src"),
+			path.join(loaded.workspaceFolder || "", "include"),
+		],
+	});
+
+	const refreshDiagnostics = (document) => {
+		if (!document || document.languageId !== "cpp") {
+			return;
+		}
+		const items = loaded.engine.diagnosticsFor(document.getText(), document.uri.fsPath, optionsFor(document));
+		diagnostics.set(
+			document.uri,
+			items.map((item) => {
+				const line = Math.max(0, (item.line || 1) - 1);
+				const col = Math.max(0, (item.col || 1) - 1);
+				const range = new vscode.Range(line, col, line, col + 1);
+				return new vscode.Diagnostic(range, item.message, vscode.DiagnosticSeverity.Error);
+			}),
+		);
+	};
+
+	context.subscriptions.push(
+		vscode.languages.registerCompletionItemProvider(
+			selector,
+			{
+				provideCompletionItems(document, position) {
+					const offset = document.offsetAt(position);
+					const items = loaded.engine.completeAt(document.getText(), offset, optionsFor(document));
+					return items.map((item) => {
+						const completion = new vscode.CompletionItem(item.name, kindOf(item.kind));
+						completion.detail = item.detail || item.type || "";
+						completion.sortText = `${item.kind === "keyword" ? "2" : "0"}_${item.name}`;
+						completion.insertText = item.name;
+						return completion;
+					});
+				},
+			},
+			".",
+			":",
+			">",
+			"<",
+			'"',
+			"/",
+		),
+		vscode.languages.registerHoverProvider(selector, {
+			provideHover(document, position) {
+				const hover = loaded.engine.hoverAt(document.getText(), document.offsetAt(position), optionsFor(document));
+				if (!hover) {
+					return null;
+				}
+				return new vscode.Hover(new vscode.MarkdownString(`**${hover.name}**\n\n\`${hover.detail || hover.type || ""}\``));
+			},
+		}),
+		vscode.languages.registerDefinitionProvider(selector, {
+			provideDefinition(document, position) {
+				const def = loaded.engine.definitionAt(document.getText(), document.offsetAt(position), optionsFor(document));
+				if (!def || !def.file) {
+					return null;
+				}
+				return new vscode.Location(vscode.Uri.file(def.file), new vscode.Position(Math.max(0, (def.line || 1) - 1), 0));
+			},
+		}),
+		vscode.workspace.onDidChangeTextDocument((event) => refreshDiagnostics(event.document)),
+		vscode.workspace.onDidOpenTextDocument(refreshDiagnostics),
+		vscode.commands.registerCommand("cluaupp.restartIntelliSense", () => {
+			try {
+				delete require.cache[require.resolve(path.join(loaded.root, "src", "intellisense.js"))];
+				loaded = loadEngine(context);
+				vscode.window.showInformationMessage("Cluaupp IntelliSense reloaded.");
+			} catch (err) {
+				vscode.window.showErrorMessage(String(err.message || err));
+			}
+		}),
+	);
+
+	for (const document of vscode.workspace.textDocuments) {
+		refreshDiagnostics(document);
+	}
+}
+
+function deactivate() {}
+
+module.exports = { activate, deactivate };

package/editors/vscode/package.json

@@ -0,0 +1,25 @@
+{
+	"name": "cluaupp-intellisense",
+	"displayName": "Cluaupp IntelliSense",
+	"description": "Completions, hover, and go-to-definition for Cluaupp C++ (Roblox APIs, DataService paths, project structs).",
+	"version": "0.1.4",
+	"publisher": "kartzdev",
+	"engines": {
+		"vscode": "^1.74.0"
+	},
+	"categories": [
+		"Programming Languages"
+	],
+	"activationEvents": [
+		"onLanguage:cpp"
+	],
+	"main": "./extension.js",
+	"contributes": {
+		"commands": [
+			{
+				"command": "cluaupp.restartIntelliSense",
+				"title": "Cluaupp: Restart IntelliSense"
+			}
+		]
+	}
+}

package/include/cluaupp/libs/janitor.hpp

@@ -10,6 +10,8 @@ public:
 	template <typename T>
 	T Add(T object);
 	template <typename T>
+	T Add(T object, bool callDirectly);
+	template <typename T>
 	T Add(T object, string methodName);
 	template <typename T>
 	T Add(T object, string methodName, string index);
@@ -17,14 +19,15 @@ public:
 	T AddObject(T constructor);
 	template <typename P>
 	P AddPromise(P promise);
+	template <typename P>
+	P AddPromise(P promise, string index);
 	Janitor* Remove(string index);
 	Janitor* RemoveNoClean(string index);
 	Janitor* RemoveList(string index);
+	Janitor* RemoveListNoClean(string index);
 	template <typename T>
 	T Get(string index);
-	template <typename T>
-	T GetAll();
-	bool Has(string index);
+	void GetAll();
 	void Cleanup();
 	void Destroy();
 	RBXScriptConnection LinkToInstance(Instance* object);
@@ -32,4 +35,5 @@ public:
 	Janitor* LinkToInstances(Instance* object);
 	static bool Is(Instance* value);
 	static bool Is(string value);
+	static bool instanceof(Instance* value);
 };

package/include/cluaupp/roblox.hpp

@@ -21,6 +21,25 @@ extern LuaSourceContainer* script;
 void print(string message);
 void warn(string message);
 void error(string message);
+
+struct cout {
+	static void print(string message);
+	static void warn(string message);
+	static void error(string message);
+	static void ping(string message);
+	static void endl();
+	cout& operator<<(string value);
+	cout& operator<<(int value);
+	cout& operator<<(double value);
+	cout& operator<<(bool value);
+} cout;
+
+struct cerr {
+	cerr& operator<<(string value);
+	cerr& operator<<(int value);
+} cerr;
+
+const int endl = 0;
 double tick();
 double time();
 void wait(double seconds = 0);