In this video, we're going to look at how we can change the behavior of a program after we've compiled and released it on.

I'm going to do this by looking at using an external scripting language to augment the functionality of our original program.

In this case, I'm going to be using Luis because, like Louis, it integrates with c++ very well.

And it's a very quick language, and it's also sent tactically, quite simple.

The practice of using scripts toward mentor programs is getting more and more common, particularly in the gaming world, where the modification of games is actually becoming a business in its own right.

It's also very useful for businesses and industry to be able to modify the program's rapidly without needing to re compile original source or get hold of the original developers.

So I'm going to take a very quick look at how we can get Lewis and C++ talking to each other, but I should point out that this video is not intended to be a lewd tutorial.

I believe Louis sent tactically simply enough that if you've got even the most basic programming knowledge, you'll be able to look at some Louis code and understand its purpose.

I'm going to start with an empty c++ program.

It's just a in Maine, but so I don't have to answer the same question 1000 times over.

I'm just going to quickly show how we get hold of Lewis and set it up.

Firstly, go to the loo it dot org's Web site.

This is the home of all things Lewis and click the download button.

Now you can download the entire source for Louis, but I'm not going to do that.

Instead, what I suggest is you go to binary and you download the binaries and said, What we don't want to do is compile all of the source.

If you're linens, she might want to do that, but I don't and then click on the latest version of Louis.

So in this case, it's 5.3 point five ongoing download what you need.

So in my case, it's Windows Library.

I went to download the dynamic version of Louis.

It's going to be loaded in a za dll on.

I'm going to choose the 32 bit version, which is this top one here.

And here is the Zip file.

I've just downloaded it.

Contained a static library, a dynamic library on an include folder with some head of files in.

At this point, I should probably mention that I'm showing you how to do things the way I do it, which might not necessarily be the best way.

In fact, when it comes to embedding external languages, there are many, many, many ways to achieve the same thing.

How you come to that decision depends on the application of your building on how you intend it to be used.

Since Liu is so small, I like to include a local copy of it in my C++ project On the right here I have my visual studio solution.

So I'm going to create a new folder in here.

I'm going to call it blew up 535 which represents the version we just downloaded on into that folder.

I'm going to copy the contents of the ZIP file.

I'm then going to take a copy of the deal l file and paste it directly into the project folder.

And as I've just mentioned, there are 1,000,001 ways of achieving the same result, particularly on linen.

She may want to install Luis to a known location on always referenced that one instance of Louis Louis, fundamentally a C library.

So I need to tell the compile that I'm going to be dealing with C defined functions.

I do that using the ex turn key word.

And then I'm going to include the loo ahead of fasters I need directly referenced to the local Lou a 535 path of the visual studio project.

After we've included the head of files we need to link to the library now in Windows and Visual Studio, I can use the hash pragmatist for this will be lots of people complaining about that because not all compilers supported some guarding it with Win 30 to this approach saves me from having to alter any of the project properties directly.

Depending on the building tool chain that you're using, you may need to include additional directives to the compiler toe linked to this library, and that's it.

That's all we need to start using Luis.

One of the nice things about Louis is it doesn't really get compiled until you need it, so it always exists in a nice text form on.

This is perfect for modification because it allows other people to edit that Texan an understandable way.

Let's start with a very simple example to demonstrate what I mean.

Well, to create a standard string called Command on, I'm going to define something in that command A equals seven plus 11.

The goal here is to get Lou to execute this expression on return.

The result.

To do anything with Louis, you need to create a Louis ST Now, the function syntax for interfacing with Luke is a little bit old school and wordy.

But actually using Luis is quite simple and intuitive.

On Louis convention, it takes that a single capital l represents a single instance of allure virtual machine.

So here I have created that Lou a virtual machine.

I'm not going to tell that instance of the virtual machine to do something, and it'll return an error code whether it could do it or not.

In the simplest possible way, I'm going to tell Louis to simply execute that string with the Do String Command.

I pass in an instance of the loo, a virtual machine, and I'm also going to pass in my strength now because it's a C function.

Standard string doesn't really apply, so I need to actually get that as a character buffer using the sea strip method.

And now we've reached the first and most important lesson When embedding any external scripting language, you must validate what's happening because you've got ultimately no control of what the end user.

In light of scripted, the script could contain syntax errors.

It could contain malicious code.

It could contain code that locks up, freezes your program.

And there are other things, too, regarding the information transferred from the C plus plus to May to the scripting language to May, and we'll look at that in a bit more detail later.

So the first thing I'm going to do is make sure that that string executed successfully by checking the value that was returned.

In this case, we can check to see if our was equal to lure.

Okay, if it wasn't okay, I'm going to interrogate the virtual machine about the nature of the problem, and to do that, I'm going to interrogate the Louis stack on.

I will go through what the Louis stack is in a minute, but right now, just stay with me.

Assuming the script did execute successfully, we want to get the value A from our command.

Well, in this case exists globally within the loo, a virtual machine.

So I'm going to use the glue it get global function to give me access to the variable, eh?

On here in lies.

Another round of validation.

I don't know what type A is bluer fundamentally is reasonably type lis.

This is very different to C plus plus where everything is quite explicitly defined, what it is and how it's stored in memory.

Now I am expecting the result.

A to be a number.

And so I'm going to test explicitly.

Is it a number?

And again, we see this strange notation on I will describe what that is in a minute, knowing that a is now definitely a number, I can reasonably safely convert it to a C plus plus float to hear I've created a variable a in c++ on I've used the Louis to number Command to convert whatever a waas into a number and I'm casting it to afloat.

I'm now just going to output that value to the council.

Now there's a further little bit of housekeeping to do before people start writing in and complaining.

Whenever we've created a lua virtual machine, we should also clean it up.

We can use the loo a close function.

To do that on this will make people really angry.

I'm also going to throw in a system pause just because it makes making the video of it easier.

So here we've got a simple program.

We take a command A equals seven plus 11.

We create a lua virtual machine and we tell it to execute that command within check.

Did it successfully execute the command?

And if it did, we try and extract the value A as a number so we can display it in C++.

If it didn't successfully execute the command, then I'm going to display any error messages that the loo a virtual machine has returned.

So let's take a quick look.

Well, we can see that Lou Awas successful in that It added seven and 11 and gave us the result.

18.

But let's see how helpful Lucan be by having a syntax error to our command.

In fact, it even returns on line one of our command.

The number was malformed.

So what's this all about?

Them?

Lewin C++ talk to each other Various stack.

And if you remember, a stack is a first in last out data structure.

So as data gets put in, it starts filling up the box.

And in principle, you can only take data out of the box if it was the last item put in it.

However, the Louis Stack does kind of break this rule as its allows us to index individual elements within the stacks buffer.

And this is quite an elegant solution to a particular problem.

As I've already mentioned, a in Louis could be anything we've not declared a type for it.

A is simply some object with a value on this present c++ with a problem because it likes everything organized and defined.

So I want us to conceptually envisage that each element on this stack is actually a box that contains some data and a description of how that data might be interpreted.

And so when we call functions like Louis is number, what we're doing is asking the box to test its contents to see if it can be interpreted as a number.

When we called the Lewis get global function, and if you remember, we passed to it the little virtual machine and are variable.

An interesting transaction occurred into the stack.

We put the variable, eh?

Louis then went away and popped a off the stack and pushed onto the stack.

The box that it has that defines what a is and in this case is also associate it with a value 18.

The Louis stack could be indexed in two ways.

One is explicitly starting at one.

Hardly that's a 123456 which implies that zero is an empty stack.

Herbert Lewis also provides a second way to index a stack, and you can index it relative to the top of the stack to the top is minus one.

The next one down is minus two minus three, minus four minus five, etcetera, etcetera, etcetera.

This is a convenient notation to make sure you're always working with data near the top of the stack, which is likely given the functions that you've been calling.

No doubt this does take a bit of getting used to on.

We'll see.

It does become reasonably complicated when you start exchanging more sophisticated data structures.

But what is quite nice is it is always deterministic, so you can always work out where you are on the stack.

So looking at our get global function, we can see that we're effectively pushing the name of a box a onto our stack.

Louis then looks for a box named A and replaces it on this stack with the contents of that box.

We know that the minus one index is going to be the top of the stack, so I can interrogate that location on the stack to see.

Can that box be interpreted as a number?

Well, in this case, it can because it contains the value 18.

Since it can be interpreted as a number.

I then asked Louis to go and directly convert its contents of that box to a number that C plus plus can understand.

When we put the syntax error into the command, it didn't know how to execute the command, and it placed an error message as a string on the top of the stack.

I wouldn't blame you for thinking well, so what?

The source seems like a lot of effort to add 7 to 11 but Lou is actually quite a powerful and well supported language, so we can use more complicated functions within the framework.

So let's say I wanted to take the sine function off some value.

Let's see what happens this time.

Oh, well, we've got the syntax error attempted to index and nil value.

It doesn't have any representation.

For what math waas in that command?

Well, math is in fact, one of many Lou libraries, but we need to tell our lunar machine which libraries it can have access to, because don't forget being safe when you're running people's code and you don't know what they've written is very important.

Explicitly listing all of the library by hand could be quite tedious.

So Louis, thankfully provides the function Lewis Open Lives, which opens sort of the basic set of libraries that most programs will use.

This has now added math to the virtual machine.

So let's try it again, and we see this time it's quite happy to compute it, and we end up with well, whatever the result is, the standard libraries in Louis provide all of the basic things that you might expect a programming language to provide, including things such as file handling on operating system manipulation.

But since Lewis has a robust community around it, many other third party libraries are also available.

That can do pretty much anything and everything you needed to do.

Since I'm going to be checking the status of the loo, a virtual machine quite frequently, I'm going to create a little utility function to help do that.

It just checks for an error message, which means I can simplify my program.

I think it's important at this point to demonstrate that the lure virtual machine is persistent, so any changes to it last between calls.

So in the first command, we executed this mass expression.

But let's say, on the second command, I want to use the result from the 1st 1 So a equals a plus 100 for example.

I'm not going to reuse the code I've created to execute the next line so we could see the first time we got the original result.

Then we got the same result, plus 100 with a little bit of floating point.

Rounding on this implies that weaken sequence instructions to the loo, a virtual machine which makes sense.

It is after all, a fully functional programming language in its own right.

But it also means that we could construct these instruction commands as necessary in our c++ code.

But let's be honest, doing things line by line sucks.

What we actually want to run is a Louis script.

I'm going to add a new text file to my program.

I'm going to save it.

As in this case, I'm going to be video example Don Luis.

Then I'm going to add that text file video example dot lewis still got the text of the end of it.

You're scared of that.

I'm going to add that to my visual studio work space now, Basically, visual studio can syntax highlight Louis, so things get a bit simpler to read.