kandi X-RAY | makeJs Summary
kandi X-RAY | makeJs Summary
Top functions reviewed by kandi - BETA
makeJs Key Features
makeJs Examples and Code Snippets
Trending Discussions on Interpreter
I have two Python concurrent-related questions that want someone's clarification.
Let us say I set up two py scripts. Each script is running two IO-bound tasks (API Calls) with multithreading (max workers as 2).
If I don't use a virtual environment, and run both scripts through the global Python interpreter (the one in system-wide Python installation). Does this make the task I described the single process and multithreaded? Since we are using one interpreter (single process) and have two scripts running a total of 4 threads?
If I use the Pycharm to create two separate projects where each project has its own Python interpreter. Does such a setting turn the task into multiprocessing and multithreaded? Since we have two Python interpreters running and each running two threads?
ANSWERAnswered 2022-Apr-10 at 00:21
Each running interpreter process has its own GIL that's separate from any other GILs in other interpreters that happen to be running. The project and virtual environment associated with the script being run are irrelevant. Virtual environments are to isolate different versions of Python and libraries so libraries from one project don't interfere with libraries in another.
If you run two scripts separately like
python script.py, this will start two independent interpreters that will be unaffected by the other.
Does such a setting turn the task into multiprocessing and multithreaded?
I don't think it's really meaningful to call it a "multiprocess task" if the two processes are completely independent of each other and never talk. You have multiple processes running, but "multiprocessing" within the context of a Python program typically means one coherant program that makes use of multiple processes for a common task.
Very new to sml. My problem is that I'm trying to make my own datatype, but I can not use ints in the naming convention of the items that are appart of the datatype...
ANSWERAnswered 2022-Apr-01 at 06:35
As noted in comments, identifiers in SML (as in many other programming languages) cannot begin with digits.
I'm trying to write an optimisation feature for my brainf*ck interpreter. It basically combines same instructions into 1 instruction.
I wrote this function but It doesn't work properly:...
ANSWERAnswered 2022-Mar-26 at 16:58
First off, just to rain a little on your parade I just want to point out that Wilfred already made a brainf*ck compiler in Rust that can compile to a native binary through LLVM (
bfc). If you are getting stuck, you may want to check his implementation to see how he does it. If you ignore the LLVM part, it isn't too difficult to read through and he has a good approach.
When broken down into its core components, this problem revolves around merging two elements together. The most elegant way I have come across to solve this is use an iterator with a merge function. I wrote an example of what I imagine that would look like below. I shortened some of the variable names since they were a bit long but the general idea is the same. The merge function has a very simple job. When given two elements, attempt to merge them into a single new element. The iterator then handles putting them through that function and returning items once they can no longer be merged. A sort of optional fold if you will.
If I try the below code in command prompt , I get correct results, however, the same code using IDE(Atom) do not produce any results....
ANSWERAnswered 2021-Sep-18 at 20:10
Using the command prompt to code is different than using IDE. When you use the command prompt you use something called
interpreter, it will execute every line you write right after you click
enter. You can write an object like that:
So I use pycharm to produce my code and was wondering if there's a way to configure a default, universal interpreter, rather than having to configure a new one for every batch of code I work on, seeing as I have had to configure nearly 5/6 of them so far ...
ANSWERAnswered 2022-Mar-11 at 09:24
Go to File | New Projects Setup | Preferences for New Projects (Settings for New Projects on Windows). Select Python Interpreter settings.
I recently have been looking to make a Prolog meta-interpreter with a certain set of features, but I am starting to see that I don't have the theoretical knowledge to work on it.
The features are as follows :
- Depth-first search.
- Interprets any non-recursive Prolog program the same way a classic interpreter would.
- Guarantees breaking out of any infinite recursion. This most-likely means breaking Turing-completeness, and I'm okay with that.
- As long as each step of the recursion reduces the complexity of the expression, keep evaluating it. To be more specific, I want predicates to be allowed to call themselves, but I want to prevent a clause to be able to call a similarly or more complex version of itself.
Obviously, (3) and (4) are the ones I am having problems with. I am not sure if those 2 features are compatible. I am not even sure if there is a way to define complexity such that (4) makes logical sense.
In my researches, I have come across the concept of "unavoidable pattern", which, I believe, provides a way to ensure feature (3), as long as feature (4) has a well-formed definition.
I specifically want to know if this kind of interpreter has been proven impossible, and, if not, if theoretical or concrete work on similar interpreters has been done in the past.Extra features
Provided the above features are possible to implement, I have extra features I want to add, and would be grateful if you could enlighten me on the feasibility of such features as well :
- Systematically characterize and describe those recursions, such that, when one is detected, a user-defined predicate or clause could be called that matches this specific form of recursion.
- Detect patterns that result in an exponential number of combinatorial choices, prevent evaluation, and characterize them in the same way as step (5), such that they can be handled by a built-in or user-defined predicate.
Here is a simple predicate that obviously results in infinite recursion in a normal Prolog interpreter in all but the simplest of cases. This interpreter should be able to evaluate it in at most PSPACE (and, I believe, at most P if (6) is possible to implement), while still giving relevant results....
ANSWERAnswered 2022-Feb-25 at 17:06
If you want to guarantee termination you can conservatively assume any input goal is nonterminating until proven otherwise, using a decidable proof procedure. Basically, define some small class of goals which you know halt, and expand it over time with clever ideas.
Here are three examples, which guarantee or force three different kinds of termination respectively (also see the Power of Prolog chapter on termination):
- existential-existential: at least one answer is reached before potentially diverging
- universal-existential: no branches diverge but there may be an infinite number of them, so the goal may not be universally terminating
- universal-universal: after a finite number of steps, every answer will be reached, so in particular there must be a finite number of answers
In the following,
halts(Goal) is assumed to correctly test a goal for existential-existential termination.
halts/1 to prove existential termination of a modest class of goals. The current evaluator
eval/1 just falls back to the underlying engine:
How would it be possible to build a complete C# application with the feature of creating new functionalities thru new VB files. Those files shouldn't have to be compiled but interpreted in runtime.
I think of it as an embedded VB interpreter, but don't know how it can be accomplished. You could build a robust base application and then let your technicians adapt it to the particularities of each client (databases, tables, filters, network services,...)
A client of mine has a software with that open functionality but I ignore the details.
It also be great if python could be integrated!...
ANSWERAnswered 2022-Feb-17 at 00:02
Using VBCodeProvider you can compile VB.NET code at run-time.
The following example, compiles a piece of VB.NET code at run-time and run it:
I'm deleting the virtual environment and creating it again and again but in bin, the python and python3 file is not recreating. It's showing the installation time of those 2 files are the same as the first time it was installed. why is this happening? as I'm deleting it completely but again those 2 files carry the same installation time.
ANSWERAnswered 2022-Feb-09 at 11:48
The files have been copied from the base Python installation and carries the modification time from there.
The files' modification times shouldn't cause any "problems in selecting interpreters".
I am trying to create a simple programming language from scratch (interpreter) but I wonder why I should use a lexer. For me, it looks like it would be easier to create a parser that directly parses the code. what am I overlooking?...
ANSWERAnswered 2022-Feb-08 at 10:44
I think you'll agree that most languages (likely including the one you are implementing) have conceptual tokens:
- operators, e.g * (usually multiply), '(', ')', ;
- keywords, e.g., "IF", "GOTO"
- identifiers, e.g. FOO, count, ...
- numbers, e.g. 0, -527.23E-41
- comments, e.g., /* this text is ignored in your file */
- whitespace, e.g., sequences of blanks, tabs and newlines, that are ignored
As a practical matter, it takes a specific chunk of code to scan for/collect the characters that make each individual token. You'll need such a code chunk for each type of token your language has.
If you write a parser without a lexer, at each point where your parser is trying to decide what comes next, you'll have to have ALL the code that recognize the tokens that might occur at that point in the parse. At the next parser point, you'll need all the code to recognize the tokens that are possible there. This gives you an immense amount of code duplication; how many times do you want the code for blanks to occur in your parser?
If you think that's not a good way, the obvious cure to is remove all the duplication: place the code for each token in a subroutine for that token, and at each parser place, call the subroutines for the tokens. At this point, in some sense, you already have a lexer: an isolated collection of code to recognize tokens. You can code perfectly fine recursive descent parsers this way.
The next thing you'll discover is that you call the token subroutines for many of the tokens at each parser point. Even that seems like a lot of work and duplication. So, replace all the calls with a single "GetNextToken" call, that itself invokes the token recognizing code for all tokens, and returns a enum that identifies the specific token encountered. Now your parser starts to look reasonable: at each parser point, it makes one call on GetNextToken, and then branches on enum returned. This is basically the interface that people have standardized on as a "lexer".
One thing you will discover is the token-lexers sometimes have trouble with overlaps; keywords and identifiers usually have this trouble. It is actually easier to merge all the token recognizers into a single finite state machine, which can then distinguish the tokens more easily. This also turns out to be spectacularly fast when processing the programming language source text. Your toy language may never parse more than 100 lines, but real compilers process millions of lines of code a day, and most of that time is spent doing token recognition ("lexing") esp. white space suppression.
You can code this state machine by hand. This isn't hard, but it is rather tedious. Or, you can use a tool like FLEX to do it for you, that's just a matter of convenience. As the number of different kinds of tokens in your language grows, the FLEX solution gets more and more attractive.
TLDR: Your parser is easier to write, and less bulky, if you use a lexer. In addition, if you compile the individual lexemes into a state machine (by hand or using a "lexer generator"), it will run faster and that's important.
I am doing an attempt to create a custom-interpreted programming language. It works by going over every line of code that the user has written in a script. But that is done in a function. The problem is that at the end of the function it calls itself to run the next line, and it keeps doing that until the interpreter reaches the end of the script. This is fine for small programs but if it reaches around 430 lines of code, the interpreter throws a StackOverflowException because the Execute() function was called too much. Currently, the interpreter supports variable declaration + assignment (boolean and float), if statements, comparisons, and calculations. So basically my question is how to prevent that StackOverflowException? Or is there any other way to do this interpreter thing without needing to rewrite the whole thing? This is done in C#-Dotnet 6.0 If someone could take a look at my code, that would be very nice.
Preprocess() is called first:...
ANSWERAnswered 2022-Jan-28 at 16:21
You are going to have to change your logic to not use recursion for reading each line. If you use recursion you will add a new function call to the stack for every layer of recursion, and the prior function calls will not be removed until the exit condition is met. If you make it 500 or so calls deep you can expect a stackoverflow exception.
Now, I don't have time to read over your code, but I can tell you what you need to do: Turn your recursive call into a loop.
Your code can probably be broken down into something like this:
No vulnerabilities reported
Reuse Trending Solutions
Subscribe to our newsletter for trending solutions and developer bootcamps
Share this Page