Xceno.io

Unable to resolve symbol ZWNBSP in this context

Mon, 20 Nov 2023 13:57:01 GMT

So, you got a mysterious compile error and if you're lucky, your compiler will at least show you ZWNBSP instead of just a space.

Chances are your file got encoded in UTF-8 BOM instead of just UTF-8, and your compiler is choking on the Byte order mark.

To fix it, convert the file to UTF-8 without BOM.

This has happened to me several times over my career in various languages and has cost me hours of senseless debugging. Maybe you're lucky enough to find this post quickly when it happened to you.

As an example, here's an error message from the Clojure compiler:

Syntax error compiling at (somefile.clj:3:1)
Unable to resolve symbol: ZWNBSP in this context

Convert to UTF-8 without BOM

VIM

:set fileencoding=utf8
:set nobomb
Save the file.

IntelliJ

You should see your current encoding in the lower right status line. Click on it and choose Remove BOM.

Configure IntelliJ to prevent this

Open Settings -> Editor -> File Encodings
Set Create UTF-8 files to wih NO BOM

References

Configure zig fmt in a JetBrains IDE

Sat, 28 Oct 2023 16:05:11 GMT

How to use zig fmt with any JetBrains IDE in 2023.

TL;DR

Add a new custom file watcher in your IDE settings and configure it to run zig fmt.

Detailed version

As of today, Zig is at version 0.11.0 and has some support for various editors via its language server zls.

I'm personally using the ZigBrains extension for JetBrains Rider right now (also works in CLion, IntelliJ, etc.), which seems to only support formatting for .zon but not .zig files as of version 0.8.1.

However it may be, you can add file watchers to run zig fmt anyway.

Here's how:

Open Settings -> Tools -> File Watchers
Add a new <custom> watcher.
Set the File Type to ZigLang file.
Set Scope to Current file.
Set Program to zig
Set Arguments to fmt $FileName$
Set Working directory to $FileDir$
(optional) Disable auto-save ... in the Advanced Options tab.

This will run zig fmt whenever you save a file.

Happy hacking!

Install lombok to Eclipse snap

Tue, 14 May 2019 15:04:41 GMT

A short tutorial on how to install lombok for a snap install of the Eclipse IDE.

TL;DR

Download lombok
Extract to wherever
Customize a .desktop file to let eclipse start with lombok or a customized eclipse.ini

Detailed version

First download lombok and extract it to wherver you see fit. I chose ~/bin/lombok.jar.

If you try to run the installer it won't find your eclipse installation and pointing it to your snap install also won't work. But have a look at *Show me what this installer will do to my IDE installation." You should see the following message:

1. First, I copy myself (lombok.jar) to your Eclipse install directory.
2. Then, I edit the eclipse.ini file to add the following entry:
   -javaagent:lombok.jar

So this is what we'll end up doing (sort of). Since snaps are immutable we cannot copy lombok.jar to the installation directory. That's why we've chosen another dir. Now all that's left to do is pointing eclipse to it.

To do this, create or copy an eclipse.ini file to your preferred location and add the following line to the bottom:
-javaagent:/PATH/TO/YOUR/LOMBOK.jar. You can copy the original one from /snap/eclipse/current/eclipse.ini.

Now create a .desktop file like ~/.local/share/applications/eclipse_eclipse.desktop with the following content:

[Desktop Entry]
X-SnapInstanceName=eclipse
Version=1.0
Type=Application
Name=Eclipse+Lombok
Icon=/snap/eclipse/40/icon.xpm
Exec=env BAMF_DESKTOP_FILE_HINT=/var/lib/snapd/desktop/applications/eclipse_eclipse.desktop /snap/bin/eclipse --launcher.ini /PATH/TO/YOUR/ECLIPSE.INI %U
Comment=Eclipse IDE
Categories=Development;IDE;
Terminal=false
StartupWMClass=eclipse

With this in place you'll find an Eclipse+Lombok entry in your applications menu. Happy coding!

References

Developing with UnrealEngine 4 on Linux

Thu, 25 Apr 2019 23:55:29 GMT

EpicGames has a neat little QuickStart Guide for getting UnrealEngine up and running on Linux, but you might still run into some gotchas. Unfortunately, the new Docs aren't accepting PRs (yet?), so here's a quick braindump of what I've run into.

Getting started

I was following the guide mentioned above on a fresh install of Pop!_OS 19.04.

By all means, read the official Linux Quick Start first. After you're done, continue here.

If you're lucky and use UE >= 4.20 check out the Native Toolchain provided by Epic Games.

Various problems I ran into

Problem 1: UE can't be built with clang-8

While running make i noticed that pop comes installed with clang-8 which is currently unsupported by UE. You can easily solve this by installing clang-7 and setting it up as an alternative like so:

sudo update-alternatives
  --install /usr/bin/clang clang /usr/bin/clang-7 100
  --slave /usr/bin/clang++ clang++ /usr/bin/clang++-7

sudo update-alternatives
  --install /usr/bin/clang clang /usr/bin/clang-8 100
  --slave /usr/bin/clang++ clang++ /usr/bin/clang++-8

This results in clang++ following the version of clang so you can easily switch between your installs by running sudo update-alternatives --config clang, which in my case looks like this:

There are 2 choices for the alternative clang (providing /usr/bin/clang).

  Selection    Path              Priority   Status
------------------------------------------------------------
* 0            /usr/bin/clang-7   100       auto mode
  1            /usr/bin/clang-7   100       manual mode
  2            /usr/bin/clang-8   100       manual mode

I do this for a lot of tools and SDKs and it works beautifully. If you find yourself changing alternatives often, register yourself an alias in .bashrc like so: alias change-clang="sudo update-alternatives --config clang.

Problem 2: Fresh install of QTCreator 5 + QT5

The quick start guide jumps from compiling the engine straight into the project setup inside QTCreator. However, only installing QTCreator via apt is not enough - Run the official QT5 setup instead, which comes with all necessary dependencies (qt 5.12.3 at the time of writing).

Problem 3: clang error: invalid linker name in argument '-fuse-ld=lld'

You're missing LLD on your system. Either run SetupToolchain.sh in the engines root folder or install lld via your package manager.

Wrapping up

That's basically it. If you're lucky you won't even need to read this post!

All in all, it was surprisingly easy considering that Linux isn't exactly a first class citizen for game development yet.

What comes next is setting up a CI environment, but I'll save that for another post.

Orchard CMS: Strongly typed WebApi routing

Mon, 04 Dec 2017 22:12:45 GMT

If you're developing WebApi projects in Orchard, you're probably used to declare your API routes as a simple string array. However, we can get fully compile-time checked routes that are also easy to refactor.

If you check the Orchard Docs or any tutorials for setting up API routes you'll quickly end up with a RouteConfig like this:

public class ApiRoutes : IHttpRouteProvider
{
    public IEnumerable<RouteDescriptor> GetRoutes()
    {
        return new RouteDescriptor[]
        {
            new HttpRouteDescriptor
            {
              Name = "Default Api",
              Priority = 0,
              RouteTemplate = "api/users",
              Defaults = new
              {
                area = "MyCustomModule",
                controller = "Users"
              }
            },

            new HttpRouteDescriptor
            {
              Name = "Default Api",
              Priority = 0,
              RouteTemplate = "api/users/{id}",
              Defaults = new
              {
                area = "MyCustomModule",
                controller = "Users",
                id = RouteParameter.Optional
              }
            },

            // etc...

        };
    }

  // ...
}

I have some problems with this approach: It becomes quite unwieldy pretty soon, it's hard to refactor and easy to introduce bugs.
If you've ever searched for hours on end why a route isn't hit, called with wrong or messed up parameters just to find a dumb typo in your RouteConfig, you know what I'm talking about.

So what to do about it?

Initially, I spent some time trying to implement my own AttributeRouting in Orchard, but it just didn't go too well. So after a while I ditched that idea and began from scratch. You can see the result below:

// C#7 syntax for brevity
public class ExampleController : ApiController
{
    public IHttpActionResult GetList() => this.Ok(new string[] { "value1", "value2" });

    public GetDetails(int id) => this.Ok("value");

    public IHttpActionResult Post([FromBody]string value) => this.Created("example", value);

    public IHttpActionResult Put(int id, [FromBody]string value) => this.Ok();

    public IHttpActionResult Delete(int id) => this.Ok();
}

public class ApiRoutes : IHttpRouteProvider
{
    public IEnumerable<RouteDescriptor> GetRoutes()
    {
        var route = new ApiRouteFactory(Statics.ModuleAreaName, "api");

        return new[] {
            route.BuildRoute<ExampleController>              (x => x.GetList,    "example"),
            route.BuildRoute<ExampleController, int>         (x => x.GetDetails, "example", "{id:int}"),
            route.BuildRoute<ExampleController, string>      (x => x.Post,       "example"),
            route.BuildRoute<ExampleController, int, string> (x => x.Put,        "example", "{id:int}"),
            route.BuildRoute<ExampleController, int>         (x => x.Delete,     "example", "{id:int}"),
        };
    }

    //...
}

If you're in a hurry, go grab the source from Github and get back coding. Read on for some details about the implementation.

How it works

Let's start with the call to BuildRoute and dig deeper from there.

// ExampleController.cs
public IHttpActionResult GetDetails(int id) => this.Ok("value");


// ApiRoutes.cs
route.BuildRoute<ExampleController, int> (x => x.GetDetails, "example", "{id:int}"),


// ApiRouteFactory.cs
public HttpRouteDescriptor BuildRoute<TController, TParam>(
    Expression<Func<TController, Func<TParam, IHttpActionResult>>> expression,
    params string[] routeParts)
    where TController : ApiController
{
    var actionName = ReflectOnMethod<TController>.NameOf(expression);
    return this.MakeRouteDescriptor(typeof(TController), string.Join("/", routeParts), actionName);
}

If you're not familiar with Func<T, TResult> MSDN explains it pretty good:

[Func] encapsulates a method that has one parameter and returns a value of the type specified by the TResult parameter.

Therefore, BuildRoutes first parameter is an expression that takes a controller as input and expects a function as result, which itself takes one parameter and returns IHttpActionResult. (Yeah, read that again slowly.)

This expression is what brings us all the intellisense, type safety and refactoring goodness. If we change the signature of GetDetails, our module will no longer compile. The code that makes this possible resides in ReflectOnMethod and was shamelessly stolen from this excellent StackOverflow answer. (Thanks kędrzu!)

MakeRouteDescriptor

At this point, all that remains is some string parsing and building the HttpRouteDescriptor.

public HttpRouteDescriptor MakeRouteDescriptor(Type controller, string routeSlug, string action)
{
    var route = this.routePrefix + routeSlug;
    var ctrlIndex = controller.Name.LastIndexOf("Controller", StringComparison.Ordinal);
    var controllerName = controller.Name.Substring(0, ctrlIndex);

    return MakeRouteDescriptor(
        this.moduleAreaName,
        route,
        controllerName,
        action,
        httpMethod: HttpMethodOfAction(action));
}

public static HttpRouteDescriptor MakeRouteDescriptor(
    string area,
    string route,
    string controller,
    string action,
    int priority = 5,
    HttpMethod httpMethod = null)
{
    var defaults = new ExpandoObject();
    var underlyingObject = (IDictionary<string, object>)defaults;
    underlyingObject.Add("area", area);
    underlyingObject.Add("controller", controller);
    underlyingObject.Add("action", action);

    var constraints = ParseRouteAttributeConstraints(route, defaults, httpMethod);

    return new HttpRouteDescriptor
    {
        RouteTemplate = CleanupRoute(route),
        Defaults = defaults,
        Priority = priority,
        Constraints = constraints
    };
}

There are two interesting things going on, but first things first. You're probably asking yourself: WTF is the ExpandoObject doing here? Well, in this example absolutely nothing. You could use a dictionary instead. It just happened that I wrote some modules which fiddle around with the generated routes and having an ExpandoObject makes it easier to do so.

With that out of the way, let's continue.

HttpMethodOfAction

Maybe you noticed that every action in the ExampleController starts with a HttpVerb. This is the only important thing you'll need to remember when using the module.

The BuildRoute<TController>(...) function will parse the action name for the verb and assign it to the resulting RouteDescriptor. Sounds fancy, but again, there's absolutely no magic going on there:

// The inner workings of the ApiRouteFactory
// when determining the HTTP Verb for a controller action.
private static HttpMethod HttpMethodOfAction(string actionName)
{
    if (actionName.StartsWith(HttpMethod.Post.Method, StringComparison.OrdinalIgnoreCase))
        return HttpMethod.Post;

    if (actionName.StartsWith(HttpMethod.Put.Method, StringComparison.OrdinalIgnoreCase))
        return HttpMethod.Put;

    // Yep, there is no official HttpMethod.Patch!
    if (actionName.StartsWith("Patch", StringComparison.OrdinalIgnoreCase))
        return new HttpMethod("PATCH");

    if (actionName.StartsWith(HttpMethod.Delete.Method, StringComparison.OrdinalIgnoreCase))
        return HttpMethod.Delete;

    return HttpMethod.Get;
}

So an actionName of "GetSomething" will result in HttpMethod.Get and so on.

ParseRouteAttributeConstraints

And once again some string parsing. When defining routes, we can use RouteContstraints to narrow down the request that matches a particular route. So if we define a route like this: GET "api/example/{id}", any requests that fill in anything for the id parameter will match. This may be wanted in some cases, but most of the time it's a good idea to restrict parameters to a certain type, like an integer: GET "api/example/{id:int}".

This is exactly what the following code does. It looks at all the parts of our route and extracts the RouteContstraints.

/// <summary>
/// <para>
/// Creates route constraints from the given route.
/// Use the return value as input for <c>HttpRouteDescriptor.Contraints</c>.
/// </para>
/// <example>
/// "http://example.com/api/users/{id:int}" will create an integer contstraint for the id parameter.
/// </example>
/// </summary>
/// <param name="route">The absolute route to be parsed.</param>
/// <param name="defaults">
/// An object that will be filled with all optional parameters.
/// Should be used as value for <c>HttpRouteDescriptor.Defaults</c>.</param>
/// <param name="httpMethod">The routes http-verb.</param>
private static dynamic ParseRouteAttributeConstraints(string route, ExpandoObject defaults, HttpMethod httpMethod = null)
{
    var split = route.Split(new[] { '/' }, StringSplitOptions.RemoveEmptyEntries);
    var attributes = split.Where(x => x.StartsWith("{") && x.EndsWith("}"));

    dynamic constraints = new ExpandoObject();
    var underlyingObject = (IDictionary<string, object>)constraints;

    foreach (var attr in attributes)
    {
        var tmpSplit = attr.Trim('{', '}').Split(':');
        var key = tmpSplit[0];
        if (tmpSplit.Length == 2 && !underlyingObject.ContainsKey(key))
        {
            var typeName = tmpSplit[1];
            var isOptional = typeName.EndsWith("?");

            if (isOptional)
            {
                typeName = typeName.TrimEnd('?');
                ((IDictionary<string, object>)defaults).Add(key, RouteParameter.Optional);
            }

            var constraint = GetConstraintForTypename(typeName, isOptional);
            if (constraint != null)
            {
                underlyingObject.Add(key, constraint);
            }
            else
            {
                Debug.WriteLine("No matching IHttpRouteConstraint found for type '{0}'", typeName);
            }
        }
    }

    if (httpMethod != null)
    {
        underlyingObject.Add("httpMethod", new HttpMethodConstraint(httpMethod, HttpMethod.Options));
    }

    return constraints;
}

private static IHttpRouteConstraint GetConstraintForTypename(string typename, bool isOptional)
{
    /* List of all route constraints:
        * https://msdn.microsoft.com/en-us/library/system.web.http.routing.constraints(v=vs.118).aspx
        */

    IHttpRouteConstraint constraint = null;
    switch (typename)
    {
        case "bool":
        case "boolean":
            constraint = new BoolRouteConstraint();
            break;
        case "int":
            constraint = new IntRouteConstraint();
            break;
        case "long":
            constraint = new LongRouteConstraint();
            break;
        case "float":
            constraint = new FloatRouteConstraint();
            break;
        case "double":
            constraint = new DoubleRouteConstraint();
            break;
        case "string":
            constraint = new AlphaRouteConstraint();
            break;
    }

    return isOptional ? new OptionalRouteConstraint(constraint) : constraint;
}

I chose to only implement the most commonly used constraints, but feel free to extend the code above by going through this list on MSDN.

The TLDR version of this code: Take an attribute like {id:int}, split it into key = "id" and constraint = "int", and update the RouteConstraints and RouteDefaults accordingly.

And that's it!

If you read until this point, thanks!
I'd warmly welcome any comments, ideas, and bug reports. Just Shoot me a mail. Also, check out the full source on Github.

Over and out.

Orchard CMS: Beware of SQL Keywords

Fri, 01 Dec 2017 19:23:20 GMT

Just a quick reminder, before you debug hours on end (like me).

Sometimes while developing a new Orchard module I get carried away and forget about other stuff. Reserved SQL keywords for example. Then we might end up with a class like this:

public class ShoppingCartEntryPart : ContentPart<ShoppingCartEntryRecord>
{
  public int Order
  {
    get { return this.Retrieve(x => x.Order); }
    set { this.Store(x => x.Order, value); }
  }

  public int Price
  {
    get { return this.Retrieve(x => x.Price); }
    set { this.Store(x => x.Price, value); }
  }
}

and a migration like this:

public int Create()
{
  SchemaBuilder.CreateTable(
    "ShoppingCartEntryRecord",
    table => table
      .ContentPartRecord()
      .Column<int>("Price")
      .Column<int>("Order"));

  ContentDefinitionManager.AlterPartDefinition(
    typeof(ShoppingCartEntryPart).Name,
    config => config.Attachable());

  return 1;
}

The module will of course compile, but as soon as we use the ContentManager to retrieve or store it, it will crash with an exception like this:

NHibernate.Exceptions.GenericADOException:
'could not insert: [ReservedKeywordsTest.Models.ShoppingCartEntryRecord#12][sql: insert into reservedkeywordstest_shoppingcartentryrecord (price, order, id) values (?, ?, ?)]'

InnerException
SqlCeException: There was an error parsing the query.
[ Token line number = 1, Token line offset = 66, Token in error = Order ]

That's because we're using SQL-Server or SQLCE where ORDER is a reserved keyword. Check this list on MSDN for all reserved keywords.

In the example above we'd just need to rename Order to something like SortOrder and we're good to go again.

Orchard CMS: Overriding the Admin Theme

Sun, 12 Nov 2017 20:02:34 GMT

Overriding the admin theme is easy, but no one seems to talk about it. Let's change that here.

Almost everything in Orchard is achieved by implementing an interface. Orchard will collect all the implementations and loop through them, or it selects the one with the highest priority; depending on the feature.

Good news everybody, it's the same for overriding themes!

TLDR;

Implement IThemeSelector
Make sure you check the AdminFilter
Return a ThemeSelectorResult with a higher priority than the default admin theme.
Activate your custom admin theme. (Do not click Set current)

namespace MyAwesomeAdminTheme
{
    using System.Web.Routing;

    using Orchard.Themes;
    using Orchard.UI.Admin;

    public class OverrideTheAdmin : IThemeSelector
    {
        public ThemeSelectorResult GetTheme(RequestContext context)
        {
            if ( AdminFilter.IsApplied(context) )
            {
                return new ThemeSelectorResult
                {
                  Priority = 110,
                  ThemeName = "MyAwesomeAdminTheme"
                };
            }

            return null;
        }
    }
}

And that's about it, from here on it's customizing as usual.

How it works

This section shines a little light on the code above. If you've got some time and want to know what you're doing (I hope you do), this is for you.

To get a list of all implementations of a certain interface, simply inject it as IEnumberable<ISomeInterface> and autofac will take care of the rest.

So on every request that returns a themed result, Orchard will collect all IThemeSelector implementations, including your new admin theme selector. Because of this, it's important to check that the current route is actually the admin dashboard by calling AdminFilter.IsApplied. Otherwise you would also override your active frontend themes.

It will then order them by priority (highest first), and take the first active theme that matches the name of the current ThemeSelectorResult. The result is assigned as current theme to the current request.

Happy coding!

Fun fact

For some reason there are two identical implementations of the GetRequestTheme function. One in Orchard.Themes/Services/ThemeService.cs the other in Orchard/Themes/ThemeManager.cs.