This project has moved and is read-only. For the latest updates, please go here.
This software is :
  • Automated writing programs and / or documents,
  • A RAD tool ( indefinitely) configurable and resulting in a reliable and clean source code,
  • A knowledge base (Knowledge Management ) for programming (shell, C / C ++, C #, .NET, etc.)
  • A very dynamic architecture and modular absolutely,
  • Greater freedom in the design of program models (based on oriented programming model)
  • Ability to design models appearance ( with injectors )
  • Ease of operating instructions ( re playable and parameter )
  • Extended naming means and multiple options for variability,
  • A simple reading, clear and concise language,
  • Personal creation DSL (Domain Specific Language) by programming analysis tools and conversions,
  • Explanations of supplements beyond the simple comment (with a caption for each variable)
  • Many instructions beyond the current programming languages ​​(even for .NET)
  • Parallelism, shared variables and Training of semaphore,
  • The declaration of properties attached to variables - such as the type to use,
  • The rapid development of lexical analysis and grammar programs
  • The development of new functions and virtual models for HMI (2D and 3D)
  • Transcription of the instructions in many other programming languages.

The language that I created using a variable name list with indications and value.
The indications are:
  • When the variable is calculable (we know exactly calculate its value). a variable
is calculable when all terms are calculated. There are only two cases where the
variable can be calculable
  • When the variable or one of its terms is charged by a given dictionary
  • When the variable or one of its terms is an iteration factor ( identified thanks to
default controls flow models )
  • When the variable is global (the range of the variable is global and is known everywhere).

Variables have a relative scope: declared in a process, a variable is known
and editable in any known process from this initial process. The variable is
destroyed at the end of the process if created in this process.
If the variable is not known by a process, the name of the variable is considered
as a string constant in the case of an operator on integers,
the value is 0 .

A process can be created at any time and used everywhere. Recursion is now
possible ( from version 1.4).

In contrast, when the conversion to some programming languages ​​, it is preferable
have already implemented the process before the first call (for the formal parameters of a process
or procedure are automatically determined at the time of implementation) .

The value of a variable is still in the form of a string.
It is the evaluation of an expression which infers the type of the variable (integer or string ;
Boolean is actually a whole '0' - false - or '1' - true - with the exception
another whole - positive or negative - is considered true).

At present, a variable has an integer value or not. Decimal numbers are not recognized.
Moreover, the characters { , } and { . }. are already used as operators. However, it remains possible
implement decimal numbers with a surcharge toInt () function returns the integer value
a number. I note that even without being able to declare decimals, division
two integers is still intact.

Since the application is to write programs, integers are sufficient.
However, decimals mathematical calculations allow for the generation of curves and
graphics ( for example). However, the decimal numbers could be better defined
as in a rational or irrational number .

A variable whose value can not give an integer always returns 0.

A unique feature in this new language is that constant strings
are framed by quotation marks. A character string is regarded as constant
when the system is not exactly the name of a variable.

The possible operators in an expression are:

 * The sum of two integers (+)
 * The subtraction between two integers (-)
 * Multiplication of two integers (*)
 * The division between two integers (/) - However, if the divisor is not zero and 0 otherwise the result will .
 * Comparison > between integers
 * Comparison < between two integers
 * Equality between two integers (=)
   I note that comparisons >= and <= are not defined
 * Equality between two strings (?). The result will be 0 or 1.
 * The concatenation of two strings (.)
Warning: The expression 1. 2 will always 12. On the other hand a + b will always 0 if a and b
are not variable names. Likewise, a. b give 00 if a and b are 0
 * Extraction of a character in a string or a number (:)
I note that a: x extracts the x -th character is beginning with 1 .
   Also, Hello World 2 return the e character if the Hello World string is not the name of a variable.
 * The parentheses are evaluated normally and can change the default precedence of operators.
   The default precedence of operators is as follows

',', '<', '>', '=', '+', '-', '/', '*', '.', '?', ':'

I note that the division has priority over multiplication: also, 6/3 * 2 = 6 / (3 * 2) = 1
Exceptionally, -x is considered a negative integer.

Parentheses are also used to call a function with parameters.
  • A comma in expression between two expressions to give away.
  The suite enables the use of multi-parameter functions and array () will return
  always result in the form of each result with a string separated by commas.
  For each separate element by a comma, it is possible to use the model / String / Split.

   It is likely that future versions implement decimal numbers, operators
   more than one character (>= and <=) and unary operators .

   Also, the spaces on both sides of an operator are always eliminated.
   This is the entire term isolated by operators who is either a constant or
   the name of a variable (if it exists).

   I notice that if I want to display a character that is an operator, it is
   as global variables that will display that character. These variables are modifiable
   but it is likely that it is not possible to change after conversion into a
   other programming language.

The language that I created is able to be translated in many other programming languages.
This conversion requires some adjustments including the addition of specific methods for
the proper functioning primarily so that the result remains iso- executed.

Not to be confused: this is programming language which is converted to another. To be clear,
the execution of the program translated into another language give the same files written transcript
with the program that interprets and executes instructions.

For this, the basic models that are installed in / CodeCommander / ... (like for each or while)
can convert all these models in other programming languages ​​they are object-oriented or not .

Including: VBScript, PowerShell, Perl, Python, C ++ (MacOS or Unix or Microsoft .NET), C #,
            Java, ASP, ASP.NET, PHP, JavaScript, XSLT, T4 Writing ( Microsoft)

Depending on the destination programming language is strongly typed or not,
defined variables will have a particular type or not. The types used are only
simple types. All expressions are iso- convertible, that is to say they
give the same results in all languages ​​translated .

A variable is identified by:
  • It is passed as a parameter ( by value or by reference - so mutable )
  • It is declared in the implementation current function (it is editable). If it is passed as a parameter to another function, the variable is transcribed in passing by value or by reference (with the correct syntax of language) whether it is modified during its life cycle .

The variable name does not change if the conversion language is not strongly typed. if
language is strongly typed, the variable uses a prefix that identifies each
typing and the use of multiple simultaneous type is controlled by the last assignment.
If the variable then has several names, conversion for each data type is permitted by
implementing a class called ' SimpleType ' ( in C ++ and C #).

For non- typed languages ​​like VBScript, the variable name is always the same subject
that the name does not conflict with the naming conventions.
For languages ​​such as Perl or Python, operators are redefined to type inference
depending on the service used .

Finally, the parallel launch of instruction, I was taken to create new structures
according to the syntax of the language and passed by reference to different shared tasks.

The first function called in starting a new task receives structure
reference and the following features are different variables extracted from individual unit
structure .

Converting the program in another language is carried out in two steps:
  1. the creation of process implementation,
  • If the implementation of a process is changed between two calls,
re implementation of a new function with the addition of an instance number,
  • Monitoring of various processes calls ( non- recursive test )
  • Management of the variables used and / or modified ( ex post reporting parameters for each function )
  • A never called process is never implemented
  1. update using variables by:
  • For the left side of an assignment, by:
  • If the left side is a variable declared value :
  • The right to be by value,
  • The right can not be by reference unless the expression is a single variable reference ( de reference )
  • If the left side is a variable declared by reference, de reference the left and:
  • The right to be by value,
  • The right can not be by reference unless the expression is a single variable reference ( de reference )
  • To the right side of an assignment, by:
  • If the expression is complex:
  • Always de reference when the variable is a reference,
  • Use the variable when passing by value,
  • Replace or not the variable name when it is calculable
  • If the expression is simple:
  • De reference if the variable is by reference,
  • The left side is still value
  • Value by passing it to a function:
  • For a declared value variable,
  • De reference if declared reference ( after a parameter)
  • Passed by reference to a function:
  • For a declared value variable, the variable is mutable,
  • Leave as if the variable is declared in reference ( after a parameter)
    • A variable by value or by reference can not be calculable after the call.

The first step in the conversion writes the implementation of each function with a descriptor
for each variable. Depending on the language, this descriptor may vary. For example, in PowerShell
the variable name is framed by { S[] } in C ++, it is { $[] }. According to the variable is
left or right of an assignment or in an expression, I add to left: or ByValue:
There also ifptr: indicating that the contents of the variable is an object
as a value expression of type or a pointer type (specific to C ++).

If nothing is specified, the specified variable can be provided as an expression of type
value or reference type.

Last edited Dec 21, 2014 at 8:37 PM by skercrow, version 4