Sign up using Facebook. Sign up using Email and Password. Post as a guest Name. Email Required, but never shown. The Overflow Blog. Podcast Making Agile work for data science. Stack Gives Back Featured on Meta. New post summary designs on greatest hits now, everywhere else eventually.
Linked Related 3. Hot Network Questions. Can you help us improve? Resolved my issue. Clear instructions. Easy to follow. No jargon. Pictures helped. Didn't match my screen. Incorrect instructions. Thanks NeilD. It fixed it for me too. It would be nice to port GIT to Windows a bit more. Who knows? Add a comment. Paul Nikonowicz Paul Nikonowicz 3, 18 18 silver badges 38 38 bronze badges. Similar for me. Eclipse needed to be closed before running git gc.
Garrett Smith Garrett Smith 1 1 gold badge 6 6 silver badges 24 24 bronze badges. Try to restart you Apache or other web server as it may have locked some of your files.
Arvind Bhardwaj Arvind Bhardwaj 5, 5 5 gold badges 32 32 silver badges 48 48 bronze badges. Closed Visual Studio and Rubymine and didn't get the error again. One of them was the culprit. Bikey Bikey 7 7 silver badges 12 12 bronze badges. Close your IDE then do git pull. It will work. Naushad Alam Md. Naushad Alam 7, 6 6 gold badges 23 23 silver badges 23 23 bronze badges.
After I closed UltraEdit, the problem never happened again. Ruobin Wang Ruobin Wang 3 3 silver badges 9 9 bronze badges. You have to close it in the systray. Sebastian Thomas Sebastian Thomas 1, 12 12 silver badges 20 20 bronze badges. Juha Hanka Juha Hanka 6 6 silver badges 5 5 bronze badges. I have an suggestion that you should use the Unlocker to find the program that's handling it: Unlocker. Envil Envil 2, 1 1 gold badge 28 28 silver badges 40 40 bronze badges.
Ivan Ivan 3, 30 30 silver badges 26 26 bronze badges. I had PHPStorm open, closed that and all was well. Tisch Tisch 2, 4 4 gold badges 27 27 silver badges 34 34 bronze badges.
In-young Choung In-young Choung 2 2 gold badges 8 8 silver badges 22 22 bronze badges. Harshad Sindhav Harshad Sindhav 1 1 silver badge 6 6 bronze badges. Special directory names are used to denote which file system you're referring to. You can even define your own file system that uses your own user-defined rules if you wish! But, we won't be covering that in this book. With the exception of the original "library" file system, most of the file systems in the IFS store their objects in the "loosely-defined" file structure that's common in Windows and UNIX environments.
This type of object is known as a "stream file" because the data in it is thought of as "one continuous stream of bytes. A program can use this big, long string of bytes for any purpose that it likes. There are many file systems defined to work in the IFS. Here we will just list a few of them, so that you get the idea:. Rest assured that all of these file systems can be accessed from an RPG program using the same Integrated File System interfaces that we use in this book.
Unfortunately, since most UNIX programming is done in the C programming language, almost all of the documentation assumes that you are a C programmer. Throughout this book, we will be looking at the C documentation, and translating it into RPG for our purposes. We will make our RPG implementation as much like the C implementation as possible, so that it will be relatively easy to use the IBM manuals to find the information you're looking for in the future.
Don't worry if you're not a C programmer! For general information about the Integrated File System, such as the concepts behind it, follow these steps:. Tip: If your web browser has trouble with the navigation bar, and many do you can get to the same place by clicking on the "Site Map" instead. I don't know about you, but I'm falling asleep reading this book. I'm not a historian, I'm a programmer!
Lets go! Let's write some code, already! You typed all of that already? Wow, that was quick, good job! The instructions at the top tell you how to compile it. But, of course, you'll need to substitute the source library that you used for the "XXX" that I put in the comments.
If a problem occurs when you run this program, you'll get a DSPLY message on the screen telling you that something failed. If nothing happens on your screen, rejoice! That's what we wanted to happen! In the next topic, we'll talk about what that program did, and verify that things worked. In our hello world example, we defined a bunch of prototypes in our D-specs that told the system what APIs we wanted to call, and how the parameters were to be passed to them.
If you don't understand how prototypes work, this might be a good time to whip out a book on prototypes and brush up. All it does is delete any data that currently exists in the file. Because this "mode" is confusing, and hard-to-read, I use named constants to make it clearer.
If you look at the previous example, you'll see that I used named constants to make it easier to read. I'll use some more standardized though, arguably harder to read constants in a later chapter.
We'll talk more about file modes in the upcoming chapter. Depending on what's stored here on your system, there could be many pages of information. Find the file called 'helloworld' in the list of object links. You should now see that it contains the words "Hello World! Unless you have some nifty use for the helloworld file you created, let's delete it now, by putting a 4 next to it to delete it.
Yes, it's really that simple! Aside from the prototypes and maybe the file mode, this program is really short and easy to follow. Using this same technique, you can write almost anything to a stream file! We'll cover this more in depth, and show you how to read a stream file in the next chapter. More than half of the code in our "Hello World" program was prototypes and other definitions.
After we've done that, we'll no longer need to type those prototypes into every program. It looks like this:. Fortunately, if you read IBM's documentation, you find out that there are only two optional parameters that follow, and they are both unsigned integers.
Now that we know how the C prototype works, we can write our own RPG prototype. Here's what I came up with:. The first thing that you might notice is that all of the parameters are passed by value. That's because C is expecting to receive a pointer, an integer, an unsigned integer and another unsigned integer.
If we passed these parameters by reference, it would actually receive 4 memory addresses, rather than receiving the actual data. As a general rule, when a C program expects to receive something by value, it will simply list the data type followed by the variable.
Wait a minute! Yes, that's true. In fact, we could've coded path as:. However, if we did that, we'd have to assign a length to "path", and the C version allows path to be of any length. The trick is, passing a pointer by value is the same thing as passing a variable by reference. In either case, what actually gets passed from procedure to procedure is an address in memory. This saves us some work. This means that they're optional, and we only need to pass them when we need them.
It is the path to the file in the IFS that we want to open. Thereafter, each section of the path refers to a directory name until we reach the last component, which specifies the filename. If it was not specified, the path name would actually start at whatever our current working directory was, and continue from there. The word "ifsebook" refers to a directory.
The word "chapter2" refers to a sub-directory that's inside the "ifsebook" directory. The word "examples" refers to another sub-directory, this one is inside the "chapter2" directory, and finally, "myfile. What we're actually passing here is a string of 32 bits, each of which specifies a different option. The rightmost bit specifies "Read only", then moving one bit to the left, that bit specifies "Write only", and the next bit specifies "reading and writing" and the next bit specifies "create the file if it doesn't exist," etc.
In order to make our lives easier, rather than actually specifying the bits manually, we define a series of flags, that when added together, will turn on the bits that we desire. For example, we use the number 8 to signify "create if the file doesn't exist" and the number 2 to signify "write only". This makes more sense if you convert those numbers to binary. The decimal number 8 is in binary. The decimal number 2 is 10 in binary. So you see, when we specify the number 8, we actually specify that we want the 4th bit counting from the right to be turned on.
When we specify 2, we are specifying that the 2nd bit be turned on. If you convert the decimal 10 to binary you get bits 4 and 2 are both on. Because each of these numbers turns on a single bit, we refer to them as "flags", and they supply us with a convenient way to which options we want to pass to the open API.
This is what we need to add:. Like the "oflag" parameter, this parameter is treated as a series of bits. The rightmost 9 bits are the ones that we're concerned with, and they're laid out like this:. These bits specify Read, Write and Execute access to 3 types of users. The first is the file's owner, the second is users with the same group profile as the file's owner, and the third is all other users. For example, if I wanted to specify that the owner of the file can read and write to the file, that people in his group can only read the file, and that everyone else has no access at all, I'd specify the following bits: If you look at those bits as the binary number , and convert it to decimal, you'd get So, to assign those permissions to the file, you'd call open with a 3rd parameter of Just as we did for the "oflags" parameter, we'll also specify bit-flags for the mode, which we can add together to make our programs easier to read.
The return value of the open API is a "file descriptor". It is an integer that we will pass to all of the other IFS APIs that we call so that they know which file we are referring to. If something goes wrong, and the system is not able to open the file that we requested, it will return a value of -1 instead of a file descriptor.
So, whenever we call open we will check for this, and treat -1 as an error. If your head is spinning after reading about the open API, you'll be glad to know that the close API is comparatively simple. Simple, yes? The "int" is the return value. The "close" is the name of the procedure. The "int fildes" is the only parameter to the procedure, and it's just an integer, which is "10I 0" in RPG.
It returns a "10I 0", because the C prototype returned an "int". It accepts one parameter, which is also a "10I 0" because the C prototype's only parameter was an "int". The parameter is passed by value because we don't want to pass the address, and we use "extproc " to make sure the compiler doesn't try to call "CLOSE" instead of "close".
There's one small problem. That's a problem because if you ever tried to use both sockets and IFS in the same program, the definitions would conflict, and the program wouldn't compile. So, we're going to use a little "compiler directive" magic to make sure that the two close prototypes never conflict, by making the prototype look like this:. Do you see how it works? Pretty cool eh? The reason that I say "bytes" as opposed to saying "letters" or "words" is that a byte containing any value can be written.
We are not limited to just alphanumeric strings of text. We can write the contents of a packed decimal variable, for example, or an entire data structure. All you have to tell write is an area of memory and again, it doesn't care what's in that area and length.
It copies the bytes from memory to disk. It's a "user-defined" type. It's similar in some ways to the "like" keyword in RPG. The idea is that on different platforms, the way that a byte size is stored may be different. In other words, it's the same as the RPG "10U 0" data type. Now that we've covered that, here's the RPG version of the prototype. It reads bytes of data from a stream file, and stores them into the area of memory that you point it to.
From reading about write , you should already understand. So, without any more long-winded ramblings, here's the RPG prototype:. In many ways, read is very similar to write. Like it's counterpart, it can be used to work with any byte values.
It does not care if the data is numeric or character or part of a graphic or sound format. And, like write it takes 3 parameters, and returns an integer.
There are, however, some crucial differences:. Note that the "buf" argument is no longer marked as "const". That means that the API definitely can change the contents of the variable that buf points to!
The "nbyte" parameter tells read the size of the variable that the "buf" parameter is pointing to. It's true that read will try to read that many bytes from the disk, but if you're at the end of the stream file, read may read fewer bytes than you've specified in the "nbyte" argument. Don't treat that as an error! The last few topics have probably given you lots of new things to think about.
It's time to play with them! First of all, let's create a directory to write all of our stream files to. This will keep us from cluttering up the root directory of the IFS with our tests. Let's call this new directory "ifstest. If you get an error that you do not have sufficient authority to create it, or something like that, you may need to speak with your system administrator. Tell him that you need a sandbox to play in!
Here's a program which both writes and reads data from a stream file. It also demonstrates one of the properties of a stream file -- the data is stored as a continuous stream of bytes, not in records. As before, there are instructions on compiling the program near the top of the source. Give it a try. I'll be right back, I'm going to go get a cold beverage. The world is an imperfect place. Things go wrong. Sometimes a file can't be opened, or sometimes a tyrannical system administrator won't let us access something.
It can be rough. One of the problems with the example programs that we've written so far is that, although they detect when something went wrong, they couldn't tell us what the problem was. They know something happened, but they don't know what. The idea is that there is a global variable called "errno" which a C program can check after something has gone wrong. The result is an integer that corresponds to a specific error message. So, for us to check errno, all we have to do is call that sub-procedure, and get the return value.
The "void" signifies that there are no parameters. In RPG, you can't start a sub-procedure name with the underscore character, so we'll add another symbol to the front of the prototype to make it work. The result looks like this:. Now, you'll note that although we're looking for an integer, this procedure actually returns a pointer.
So what we'll do is create a simple sub-procedure that gets an integer from the area of memory that the pointer points at.
That's a very simple sub-procedure, and it looks like this:. So, now we know that errno can be called, and it will give us an integer that tells us which error has occurred. But, what does the number mean? For example, if we got back the number , how would we know what went wrong?
In C, there's a source member which programmers use that contains constants for each error number. The C program can compare errno to EACCES, and if they match, it knows that the user does not have enough access or "authority" to carry out the function. In fact, if you look at the text in the IBM Information Center that explains for example the write API, you'll see that under "Error Conditions" it says "If write is not successful, errno usually indicates one of the following errors.
These error conditions are nothing more than the named constants that I mentioned above. Since the "errno" stuff can be used by other APIs besides the ones that this book covers, we will place these in their own header member.
That way, you can include them into your future programs without also including the code that's IFS-specific. If at all possible you should consider using the one that I provide with this book. Since it would be tedious for you to find all of these values and type them in, you may as well just use mine! In addition to the named constants for each error number, it's useful to have a "human-readable" error message that corresponds to each error number.
For example, when you want to print a message on the screen explaining what went wrong, you'd probably rather say "No such path or directory" rather than "Error has occurred.
When you call strerror with an error number as a parameter, it returns a pointer to a variable length, null-terminated, error message. Here's the C and RPG prototype for strerror :. When an error occurs which causes a program to fail, the program usually sends back a program message of type "escape" to it's caller. The first utility is called "die". It will send back any user supplied error message under a message number of CPF This is useful for supplying simple text error messages in our example programs.
Here's the code:. The other utility function is called "EscErrno". We will pass an error number as an argument to this function, and it will send back the appropriate CPExxxx error message as an escape message to the calling program.
0コメント