I'm building a barebones Notepad-styled project (console-based, does not have a GUI as of now) and I'd like to track, display (and later use it in some ways) the number of times the console application has been launched. I don't know if this helps, but I'm building my console application on Windows 10, but I'd like it to run on Windows 7+ as well as on Linux distros such as Ubuntu and the like.
I prefer not storing the details in a file and then subsequently reading from it to maintain count. Please suggest a way or any other resource that details how to do this.
I'd put a strikethrough on my quote above, but SO doesn't have it apparently.
Note that this is my first time building such a project so I may not be familiar with advanced stuff... So, when you're answering please try to explain as is required for a not-so-experienced software developer.
Thanks & Have a great one!
Edit: It seems that the general advice is to use text files to protect portability and to account for the fact that if down-the-line, I need to store some extra info, the text file will come in super handy. In light of this, I'll focus my efforts on the text file.
Thanks to all for keeping my efforts from de-railing!
I prefer not storing the details in a file
In the comments, you wrote that the reason is security and you consider using a file as "over-kill" in this case.
Security can be solved easily - just encrypt the file. You can use a library like this to get it done.
In addition, since you are writing and reading to/from the file only once each time the application is opened/closed, and the file should take only small number of bytes to store such data, I think it's the right, portable solution.
If you still don't want to use a file, you can use windows registry to store the data, but this solution is not portable
I can't seem to find the answer, how do you create a new file in Ocaml? Do you edit your file in the terminal? Where does the source code appear?
I think you're asking how to write code in OCaml, i.e., how to create an OCaml source file. (This isn't completely clear. You could be asking how to write OCaml code that creates a file.)
The details of creating OCaml source depend on your development environment, not on the language itself. So there is no one answer.
The general answer is that you can use any tool you like that knows how to create a text file. If you like working from the command line (as I do) you can work in a terminal environment and run some kind of vintage text editor from the last millennium (as I do). If you like a GUI environment, you can run some kind of "programmer's editor" from the current millennium, or really any kind of editor that creates basic utf-8 files (or even ASCII files).
Generally the editor will have to be told where to store the files that you edit. You would probably want to make some kind of folder for the project and make sure you store the text files in there.
I hope this helps! If you have any programmers nearby, they can probably get you started a lot faster than asking on StackOverflow.
I’m hoping to port an application to open vms using HP C++7.3, but at the minute just trying out a few examples to establish if it's a potential way forward but a bit stuck. Being completely new to open vms it's being a lot of fun so far.
For starters I've not got very far building boost as a whole, after some googling I found a few mentions of people having dcl scripts to build boost but no actual scripts. I don’t suppose anyone has any or can pint me to some. I ‘only’ need asio and threading.
Currently I’m just trying to compile the asio chat examples. And as I said I’m completely new to VMS and the compiler, I managed to get a few things to compile but now get a “could not open source file "sys/select.h"’, a bit of googling suggests I may need to have an HP porting library installed or maybe I’m just missing an prepocessor directive to include the correct code, can’t see anything obvious in socket_types.hpp to set?
Any pointers in the right general direction would be gratefully appreciated.
No answers since the questio is too open ended and in a realm I know little about.
Just some thoughts.
Select can be provided by the OpenVMS TCPIP services (aka UCX), or other TCP stack.
At the dcl prompt try: $ HELP TCPIP_Services Programming_Interfaces Socket_API
Async programming on OpenVMS is typically 'event driven'.
Google for SYS$QIO and AST
There is a public access OpenVMS system which holds 'NOTES FILES' (pre-cursor to web-forums)
Try TELNET to EISNER.DECUS.ORG and you'll get sign up instructions.
Once you are in find your way to the PORTING_TO_VMS conference
Once in the NOTES conference you can issue the command DIRECTORY or DIR/TIT=xxx
Unfortunately there is not topic for select, but you can find some interesting
reading using NOTES> SEARCH "select(" followed by repeated SEARCH commands)
( $ NOTES ... OPEN PORT ... SEARCH "select(" ... SEARCH [] ... SEARCH ... )
The PERL folks did an admirable job getting open stuff to work on OpenVMS.
Good luck!
boost library on OpenVMS can be used directly from headers.
I remember one thing to make sure was that BOOST logical is defined concealed, so the relative-includes work.
I am currently developing a C++ program that does all the mathematical calculations, prints items to the screen that is scanned in by an RFID Reader, and allows the user to select a payment method. (Basically using RFID tags to replace barcodes)
I have started writing my C++ code for a keyboard entry and have no idea how to take an input from my RFID reader into my program. My RFID Reader is a DLP-RFID1 from it comes with some demo software and drivers. I got it working with windows 7 last week on the demo software(a GUI using Microsoft Visual Studio).
My question is can I take the input from my Demo GUI and some how use that as my input for my C++ program? If I can can some one push me in the right direction by links, pointers, reading material?
Also I have basic C++ experience. I am teaching myself how to program in C++ and right now only know print statements, while loops, switch/case, math functions, and etc.
That is a very specific question about hardware and software of that vendor an not really general knowledge. However, those types of devices, in my past experience with bar code readers and such, usually have a driver that comes with them which allows you to set them up as an actual keyboard (for example, you could even go into a text editor and capture the codes). If you can set them up like that, then reading them is nothing more than reading stdin. For example, cin >> stringVariable;
Assuming that you have demo software in C++:
The demo software should link against one or more libraries that comes with the demo, and include a header that declares the functions in the library. You have to (at minimum) include this header and link against that same library, and use those libraries. The demo will help you understand which functions you need to call and how.
As already said it is very dependent on how they want you to use it but some general guide lines.
Look for header file that came with their demo ( ends in ".h" or ".hpp")
you will need to #include that in your project at the very minimum
Look for a .lib file. you will need to link that to your file. With gcc you would type something like G++ -l[libname].
With MSVS there are two ways i know of. You will need to right click the project in the sidebar. Click something like options or preferences. Expand linker options. Add the library.
or you can type #pragma comment(lib, "filename.lib") in your file near your includes
If there is a .dll (windows) or .so(Linux) file you can dynamically link it. There are many ways to do this. Google search for C++ Dynamic link libraries should be some help. As a newbie try to stick with Static Linking first. that would be another good keyword to search for. The best tutorial on dynamic linking for windows i have found is actually in assembly. but its all Win32 function calls anyways so its not hard to understand. Icz DLL tutorial
I was going to create the C++ IDE Vim extendable plugin. It is not a problem to make one which will satisfy my own needs.
This plugin was going to work with workspaces, projects and its dependencies.
This is for unix like system with gcc as c++ compiler.
So my question is what is the most important things you'd need from an IDE? Please take in account that this is Vim, where almost all, almost, is possible.
Several questions:
How often do you manage different workspaces with projects inside them and their relationships between them? What is the most annoying things in this process.
Is is necessary to recreate "project" from the Makefile?
Thanks.
Reason to create this plugin:
With a bunch of plugins and self written ones we can simulate most of things. It is ok when we work on a one big "infinitive" project.
Good when we already have a makefile or jam file. Bad when we have to create our owns, mostly by copy and paste existing.
All ctags and cscope related things have to know about list of a real project files. And we create such ones. This <project#get_list_of_files()> and many similar could be a good project api function to cooperate with an existing and the future plugins.
Cooperation with an existing makefiles can help to find out the list of the real project files and the executable name.
With plugin system inside the plugin there can be different project templates.
Above are some reasons why I will start the job. I'd like to hear your one.
There are multiple problems. Most of them are already solved by independent and generic plugins.
Regarding the definition of what is a project.
Given a set of files in a same directory, each file can be the unique file of a project -- I always have a tests/ directory where I host pet projects, or where I test the behaviour of the compiler. On the opposite, the files from a set of directories can be part of a same and very big project.
In the end, what really defines a project is a (leaf) "makefile" -- And why restrict ourselves to makefiles, what about scons, autotools, ant, (b)jam, aap? And BTW, Sun-Makefiles or GNU-Makefiles ?
Moreover, I don't see any point in having vim know the exact files in the current project. And even so, the well known project.vim plugin already does the job. Personally I use a local_vimrc plugin (I'm maintaining one, and I've seen two others on SF). With this plugin, I just have to drop a _vimrc_local.vim file in a directory, and what is defined in it (:mappings, :functions, variables, :commands, :settings, ...) will apply to each file under the directory -- I work on a big project having a dozen of subcomponents, each component live in its own directory, has its own makefile (not even named Makefile, nor with a name of the directory)
Regarding C++ code understanding
Every time we want to do something complex (refactorings like rename-function, rename-variable, generate-switch-from-current-variable-which-is-an-enum, ...), we need vim to have an understanding of C++. Most of the existing plugins rely on ctags. Unfortunately, ctags comprehension of C++ is quite limited -- I have already written a few advanced things, but I'm often stopped by the poor information provided by ctags. cscope is no better. Eventually, I think we will have to integrate an advanced tool like elsa/pork/ionk/deshydrata/....
NB: That's where, now, I concentrate most of my efforts.
Regarding Doxygen
I don't known how difficult it is to jump to the doxygen definition associated to a current token. The first difficulty is to understand what the cursor is on (I guess omnicppcomplete has already done a lot of work in this direction). The second difficulty will be to understand how doxygen generate the page name for each symbol from the code.
Opening vim at the right line of code from a doxygen page should be simple with a greasemonkey plugin.
Regarding the debugger
There is the pyclewn project for those that run vim under linux, and with gdb as debugger. Unfortunately, it does not support other debuggers like dbx.
Responses to other requirements:
When I run or debug my compiled program, I'd like the option of having a dialog pop up which asks me for the command line parameters. It should remember the last 20 or so parameters I used for the project. I do not want to have to edit the project properties for this.
My BuildToolsWrapper plugin has a g:BTW_run_parameters option (easily overridden with project/local_vimrc solutions). Adding a mapping to ask the arguments to use is really simple. (see :h inputdialog())
work with source control system
There already exist several plugins addressing this issue. This has nothing to do with C++, and it must not be addressed by a C++ suite.
debugger
source code navigation tools (now I am using http://www.vim.org/scripts/script.php?script_id=1638 plugin and ctags)
compile lib/project/one source file from ide
navigation by files in project
work with source control system
easy acces to file changes history
rename file/variable/method functions
easy access to c++ help
easy change project settings (Makefiles, jam, etc)
fast autocomplette for paths/variables/methods/parameters
smart identation for new scopes (also it will be good thing if developer will have posibility to setup identation rules)
highlighting incorrect by code convenstion identation (tabs instead spaces, spaces after ";", spaces near "(" or ")", etc)
reformating selected block by convenstion
Things I'd like in an IDE that the ones I use don't provide:
When I run or debug my compiled program, I'd like the option of having a dialog pop up which asks me for the command line parameters. It should remember the last 20 or so parameters I used for the project. I do not want to have to edit the project properties for this.
A "Tools" menu that is configurable on a per-project basis
Ability to rejig the keyboard mappings for every possible command.
Ability to produce lists of project configurations in text form
Intelligent floating (not docked) windows for debugger etc. that pop up only when I need them, stay on top and then disappear when no longer needed.
Built-in code metrics analysis so I get a list of the most complex functions in the project and can click on them to jump to the code
Built-in support for Doxygen or similar so I can click in a Doxygen document and go directly to code. Sjould also reverse navigate from code to Doxygen.
No doubt someone will now say Eclipse can do this or that, but it's too slow and bloated for me.
Adding to Neil's answer:
integration with gdb as in emacs. I know of clewn, but I don't like that I have to restart vim to restart the debugger. With clewn, vim is integrated into the debugger, but not the other way around.
Not sure if you are developing on Windows, but if you are I suggest you check out Viemu. It is a pretty good VIM extension for Visual Studio. I really like Visual Studio as an IDE (although I still think VC6 is hard to beat), so a Vim extension for VS was perfect for me. Features that I would prefer worked better in a Vim IDE are:
The Macro Recording is a bit error prone, especially with indentation. I find I can easily and often record macros in Vim while I am editing code (eg. taking an enum defn from a header and cranking out a corresponding switch statement), but found that Viemu is a bit flakey in that deptartment.
The VIM code completion picks up words in the current buffer where Viemu hooks into the VS code completion stuff. This means if I have just created a method name and I want to ctrl ] to auto complete, Vim will pick it up, but Viemu won't.
For me, it's just down to the necessities
nice integration with ctags, so you can do jump to definition
intelligent completion, that also give you the function prototype
easy way to switch between code and headers
interactive debugging with breaakpoints, but maybe
maybe folding
extra bonus points for refactoring tools like rename or extract method
I'd say stay away from defining projects - just treat the entire file branch as part of the "project" and let users have a settings file to override that default
99% of the difference in speed I see between IDE and vim users is code lookup and navigation. You need to be able to grep your source tree for a phrase (or intelligently look for the right symbol using ctags), show all the hits, and switch to that file in like two or three keystrokes.
All the other crap like repository navigation or interactive debugging is nice, but there are other ways to solve those problems. I'd say drop the interactive debugging even. Just focus on what makes IDEs good editors - have a "big picture" view of your project, instead of single file.
In fact, are there any plugins for vim that already achieve this?