doom2fan / echelonscript Goto Github PK
View Code? Open in Web Editor NEWThe programming language for Echelon Engine.
License: Mozilla Public License 2.0
The programming language for Echelon Engine.
License: Mozilla Public License 2.0
The WPF UI can only run on Windows, and it'd be better if we could run the tests on any platform.
The export and GC tests are an obvious case for moving to unit tests, since those don't need an UI or code editor.
Basically, sorta like lexical macros. Taken from D.
Not sure if I should add those. Maybe yes, maybe not.
As is, the backends consume a slightly modified AST that passed through the frontend.
The frontend could instead generate some form of simplified IR, for the benefit of both the backend and itself. Things like implicit casts could be made explicit, default args could be filled in, implicit args made explicit, etc.
It'd be a major refactoring, but it should make both the frontend and backend(s) much cleaner and simpler.
Right now, the usage of the shared string pool means those strings will never be released. That's quite wasteful, and it'd be better if they were only pooled relative to the compiler's lifetime.
With a dedicated slicing operator.
This would make comparison faster and simpler, as well as abstracting them.
Should be named something like intN
or nint
.
Basically, namespaces that span the whole file. This would be pretty useful for when the whole file uses only a single namespace. (i.e., most files)
Inspired by D. Would require strong CTFE.
We could have traits instead of interfaces, while still allowing "trait inheritance". This would mean classes and structs can explicitly implement a trait internally, while also allowing external "extension" of types with traits. e.g.
trait Iterator!(T, TState) {
TState InitialState ();
T? TryGetNext (ref TState state);
}
extends IList!(T) with Iteratable!(T, intN) {
intN InitialState => 0;
T? TryGetNext (ref intN index) => index < length ? this[index] : null;
}
class ClassWithIterator : Iterator<T, int32> {
// [...]
}
This should work quite well:
public unsafe interface IEchelonScriptType {
public static abstract ES_TypeInfo* TypeInfo { get; }
}
(i.e., @global::foo
-> foo
, @generated::foo&
-> foo&
)
C# has #line, so we can do this. The IR will need to be changed to carry the line number, however.
While the caching is nice for decreasing the amount of waste, it might be desirable to be able to get rid of the cached data.
Maybe make the cache local to the compiler object? We could also maybe make it cache pointers to make more nodes cacheable.
Line numbers could pose a problem for caching.
Maybe make it unmanaged? Shouldn't be too hard. Could then more easily restrict their lifetime to the compiler or environment.
Would allow bypassing the GC fairly often, with no runtime cost.
A declarative, efficient, and flexible JavaScript library for building user interfaces.
๐ Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.
TypeScript is a superset of JavaScript that compiles to clean JavaScript output.
An Open Source Machine Learning Framework for Everyone
The Web framework for perfectionists with deadlines.
A PHP framework for web artisans
Bring data to life with SVG, Canvas and HTML. ๐๐๐
JavaScript (JS) is a lightweight interpreted programming language with first-class functions.
Some thing interesting about web. New door for the world.
A server is a program made to process requests and deliver data to clients.
Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.
Some thing interesting about visualization, use data art
Some thing interesting about game, make everyone happy.
We are working to build community through open source technology. NB: members must have two-factor auth.
Open source projects and samples from Microsoft.
Google โค๏ธ Open Source for everyone.
Alibaba Open Source for everyone
Data-Driven Documents codes.
China tencent open source team.