​
​
​
==================================================================================
GDOLLAR PROGRAMMING LANGUAGE ---GDollar Technology focused for datastuctures , compiler design
and Software Development
===================================================================================
GDollar Technology is a modern Programming Language consists of JAVA OOPS, Behave
like C/C++ ,GDollar Advanced OOPS Networking, RUN and compile at same time,it is used in Software Development , cloud computing ,Research, and ,Advanced OOPs.
It is used in case of constructing datastructures,etc.
​
SYNTAX FOR GDollar (.Gdollar) (beautiful syntax)
---------------------------------------------------------------
<GDollar>
<%
<! GDollar OOPS Logic !>
public void GDollar-Main()
{
}
?>
note: This should be saved in filename.Gdollar
----
How GDollar Technology Works for GDollar-LIB?
At first .Gdollar is compiled by GDOLLARc compiler
GDollarc convert to intermediate code called as filename.C$. and it calls
GDollarv.4 compiler.
After that GDOLLARv.4 compiles the intermediate code
to create .dll file immediately
so that user can directly use in GDollar-CWE Editor program.
​
How GDollar Technology works for GDollar-MAIN(CWE)?
​
When Gdollar compiler compilers a Gdollar program it
generates .dll and .exe file for futhure use.
​
Why you use Gdollar technology? what is the major advantage of Gdollar?
Since after compiling Gdollar code it generates
intermediate encode (.C$) files. That hacker or any body
cannot understood the code. ie) Hacker cannot take
the orginal source code.
GDollar technology prevents code stealing using this concept.
==============================================================================
GDollar -PROGRAMMING-TUTORIAL -GDOLLARPART1
------------------------------------------------------------------------------------------------------------------------
Written By
wilmix jemin j
==============================================================================
UNIT -1
--------
INTRODUCTION
------------
Why GDollar?
-------------
GDollar is a Programming Langauge and it used for constructing advanced datastructures, complex datastructures, and focused on compiler design and it is mostly by universities,colleges,companies,industries.
it is invented by wilmix jemin in JAVA ,C/C++ and editor using JDollar(JWEB) P.L at 2016.
What are Gdollar Modules?
​
Gdollar has 5 modules they are....
a) GDollar -LIB
b) GDollar -Advanced OOPS (CWE -Editor)
c) GDollarv.4 (intermediate encoder)
d) JSLASH (autogenerated technology with in few seconds) (GDOLLAR COMPILERDESIGN)
e) GDollar - CJAVA
SYNTAX-1 (used only for creating libraries - .Gdollar)
------------------------------------------------------------------------------------------------------------------
<GDollar>
<IMPORT> Packagename;
<CLIB>
​
<%
<! OOPS Logic and datastructures !>
%>
How GDollar is formed ? What are its Advantages Over Native language JAVA Programming?
-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
GDollar is formed in C++ OOPS concepts..
JAVA borrowed C++ OOPS concepts but
GDollar borrowed C++ OOPS concepts and JAVA oops and it has
Attractive syntax ; Plus in-build functions
for Program and it is responsible for creating
libraries (.dll). JAVA has attained the Programming
standards, But GDollar attains combination of C Technology
and JAVA Technology advantages.
GDollar Generates .dll files
but JAVA Generated .class files.
GDollar Has Advanced OOPS than JAVA 1.8.
==================================================================================
UNIT-2 :GDollar ADVANCED CONCEPTS
==============================================================================
ADVANCED OOPS CONCEPTS
--------------------------------------------
Example -3:
------------
Write a Program to print two String and add String 100 to
ArrayList.
and Technologies for year
2016 is C, GDollar ,GDollar,CHDOLLAR, JDOLLAR,JSTAR, JSAUCER.
​
Program :abc.Gdollar
-------------------
<GDollar>
<IMPORT> P
<%
class abc
{
public void GDollar-Main()
{
int i;
GDOLLAR.WriteLine("\nList of Technologies in year "+"2016 ");
string i1="weew";
GDOLLAR.WriteLine("wilmix"+i1);
GDOLLAR.WriteLine(" \njemin"+"is going");
}
}
%>
What will be the Output when you run using ?
>GDOLLARc abc.GDollar
Note: it will create .dll file for that.
​
Example-4:
-----------
Write a Program to add 1 lakh Natural integers using arraylist
using GDollar LIB.
Program2:
---------
<GDollar>
<CUTIL> //to load GDollar packages
<IMPORT> P
<%
public class Program2
{
public Shared void LIB( )
{
<AList> ar= <NEW> <AList> ();
for (int i=0;i<=100000;i++)
ar.add(i,i);
}
}
%>
​
what is the intermediate code when Gdollar is compiled
by GDollarc..
Program2.C$
​
<CDollar>
<CUTIL>
<IMPORT> P
<%
public class Program2
{
public *AB007 void LIB( )
{
*AB043 ar= *AB091 *AB043 ();
for (int i=0;i<=100000;i++)
ar.add(i,i);
}
}
%>
​
What is the use?
Since we can reuse the code , and which means that it is the proof
that this developer had coded it.
when GDollarc is used GDollarc compiler produces intermediate code
and which again calls CDollarv.4 and which creates .dll file.
==================================================================================
GDollar ADVANCED DATA STRUCTURES THEORY used in CWE EDITOR
=================================================================================
GDollarArrays
​
SYNTAX for GDOLLARArrays:
--------------------------------------
CARRAYS list1 = new CARRAYS(string);
to add any collection objects to array use
add (String) functions and to Display those
objects use list1.Display();
Any class that use CARRAYS you should extends Array in class...
TREEOFARRAY
---------------------
Write a Program to add 1 lakh Natural integers incremented by 10 using arraylist
and add the arraylist objects to TreeOfARRAY
what happens when you compile and execute the given the below program?
​
SYNTAX for TreeofArray:
--------------------------------------
TreeArray <name> = new TreeArray(String);
<name>.add(elements);
where elements may be string or collections....
It store other collection objects and stores huge amount of data
in tree format.
LISTOFARRAY
---------------------
SYNTAX for List of Array:
--------------------------------------
LArray <name> = new LArray(string);
<name>.add(elements);
The elements may be string or collection elements.
Ans: It store other collection objects and stores huge amount of data
in tree format and sorts the elements in descending order and allow to insert the
element in to middle of list. This means act like combination of Set and Linked List , and Tree....
==================================================================================
UNIT 3: MISC ,Fundamentals of GDollar, Keywords,Operators,loops,Datatypes,Inner class, OOPS
concepts of GDollar ,and collections
==================================================================================
GDollar OUTPUT STATEMENT
----------------------------------------------
GDollar.WriteLine(" "+" ");
It is used for printing the output followed by line.
We had to add + operator to concatenate the outputs.....
String
------------
String is represented by <Str> notation.
a) char[] obj = <NEW> char[2];
obj[0] = 'x';
obj[1] = 'x';
string eS = <NEW> string(obj);
This statement is used to create an object...
b) <Str> <strname> = value;
But this Statement will not create an object...
but it stores the value...
the differences between
a) if ( s1==s2)
== means it is used to compare the values...
b) if s1.<EQUALS>(s2)
EQ means EQUALS is used to compare objects..
EXAMPLE
======
<GDollar>
<CUTIL>
<IMPORT> P
<%
public class Program2
{
public Shared void LIB( )
{
<AList> ar= <NEW> <AList> ();
for (int i=0;i<=100000;i++)
ar.add(i,i);
if (ar.<EQUALS>(ar)) // compare two objects
GDOLLAR.WriteLine(""+ar);
}
}
%>
​
GDollar COLLECTIONS
------------------------------------
Why we use collections in our software development?
Because for various projects we will use various kinds of
datastructures that's why collections are focused.
​
Q: What are the Important concepts of Software Development?
​
ARRAYLIST
----------------
SYNTAX:
------------
<AList> arraylistobjectname = <NEW> <AList>();
But type may be Object, int, Double,String,etc.
Why we focus Arraylist ?
Since ArrayList involves Powerful insertion and search mechanism when
compared to array.
So we focus it.
Some built in functions available in ArrayList they are add and remove.
syntax : arraylistobjectname.add(loc,<datatype>);
loc means location of the arraylist.
syntax: arraylistobjectname.remove(<datatype>);
How did you iterate the ArrayList?
by using While statement ...
​
LinkedList
----------
<LList> arraylistobjectname <NEW> <LList>();
But type may be Object, int, Double,String,etc.
As according to collection concepts , built in functions are Designed for
LinkedList they are add and remove.
Actually when you study about Datastructures of LinkedList
and here we Designed the LinkedList using the LinkedList code
as mentioned in above that is LinkedList.c$. And add more functions...
and we use GDollar Generics...
What is the function of LinkedList? Why we use LinkedList?
In ArrayList You can't insert element in to the middle
or first or last so LinkedList is focused....
LinkedList is a Good example of Train....
​
VECTOR STACK
-----------------------
Here Vector implements Stack.
So we can mention in short notation as VList.
and Vector has push ,pop, and peek() apis.
push for push an element ,pop for POPing the last element.
peek for showing the firstelement in vector stack
Example:
=======
<GDollar>
<CUTIL>
<IMPORT> P
{
public class abc
{
public void lib()
{
VS s = <NEW> VS(3);
s.<PUSH>(1);
s.<PUSH>(2);
s.<PUSH>(3);
s.<PUSH>(4);
while (NOTs.empty())
{
GDOLLAR.WriteLine("Top element is " + s.peek());
GDOLLAR.WriteLine("Removed the element " + s.<POP>);
}
}
}
}
OOPS in GDollar
------------------------------
A) INHERITANCE NOT USING EXTENDS METHOD...
​
C.GDollar
-------------
<GDollar>
<CUTIL>
<IMPORT> P
{
class A
{
public A() { GDOLLAR.WriteLine("A's called"+"n"); }
}
class B
{
public B() { GDOLLAR.WriteLine("B's called"+"n"); }
}
class C
{
public C() { { GDOLLAR.WriteLine("C's called"+"n"); } }
public void lib()
{
<NEW> A();
<NEW> B();
<NEW> C();
}
}
}
​
B) POLYMORPHISM in GDollar
-----------------------------------------------
What is polymorphism?
It is Means action on method to do different things
based on the object that is action upon.
Example:
-------------
Write a Program to compute Rectangle Area and Triangle area
using Polymorphism.
Geometry.Gdollar
----------------------------
<GDollar>
<IMPORT> P
{
public class EVEN
{
public void ISEVEN(int num1)
{
for (int i=2;i<num1;i++)
{
if (num1% 2==0)
GDOLLAR.WriteLine("EVENNOS="+num1);
​
}
}
public void LIB()
{
int no = 100;
int r;
EVEN n = <NEW> EVEN();
n.ISEVEN(no);
}
}
}
​
C) Write a Progam to List Faculty , students using Diamond method in GDollar
:-
Note: Without Extends methods its calls methods and value when new ()
is intialized.
This is the Major Advantage of GDollar over native programming languages
like JAVA.
Program: TA.Gdollar
--------------
<GDollar>
<IMPORT> P
{
class Person {
Person(){}
public Person(int x) { GDOLLAR.WriteLine("Person::Person(int ) called"+x); }
}
class Faculty {
public Faculty(int x)
{
<NEW> Person(x);
GDOLLAR.WriteLine("Faculty::Faculty(int ) called"+x);
}
}
class Student {
public Student(int x) {
<NEW> Person(x);
GDOLLAR.WriteLine("Student::Student(int ) called"+ x);
}
}
class TA {
TA(int x) {
<NEW> Faculty(x);
<NEW> Student(x);
GDOLLAR.WriteLine("TA::TA(int ) called"+x);
}
public void LIB( )
{
<NEW> TA(30);
}
}
}
What will be the output ?
Tue Aug 18 07:59:57 GMT+00:00 2015*GDollar: Person::Person(int ) called 30Faculty::Faculty(int ) called
30Person::Person(int ) called 30Student::Student(int ) called 30TA::TA(int ) called 30
​
How to run this program?
GDOLLARc <Filename.Gdollar>
​
C) ABSTRACT CLASS
What did you meant by Abstract class?
Abstract class defines an Abstract concept which can't
be instanated using new Operator().
Where compare to multiple Inheritance it has an implementation
where multiple Inheritance cannot have.
<GDollar>
<IMPORT> P
{
class Programs1
{
public void LIB()
{
Subject subject = <NEW> Subject();
GDOLLAR.WriteLine(subject.Describe());
}
}
abstract class Topic
{
public virtual string Describe()
{
return "we are seeing science subject";
}
}
class Subject : Topic
{
public string Describe()
{
return "We are seeing maths Geometry subject";
}
}
}
=========================================================================
More about COLLECTIONS
---------------------------------------------
Treeset
------------
Treeset represent a collection that uses Tree datastructure for storage
Items in the collections are stored in Ascending or descending order.
<TS> objectname = new <TS>(<String>);
objectname.add(elements);
Write a GDollar Program about Treeset?
remaining things Developer should fill it.
<GDollar>
<CUTIL>
<IMPORT> P
{
class tree
{
public void lib()
{
<TS> t = <NEW> <TS>("wee");
t.add("13");
t.add("15");
t.add("12");
t.add("1");
GDOLLAR.WriteLine(""+t.ASCDisplay());
GDOLLAR.WriteLine(""+t.DESCDisplay());
}
}
}
Output:
------
Order=ASC[4][31][100][211][1123]
*******************************
Order=DESC[1123][211][100][31][4]
*******************************
Order=ASC[abraham][dion][priya][rahul][shiyam][wilmix]
*******************************
Order=DESC[wilmix][shiyam][rahul][priya][dion][abraham]
Operators conditions and loops
--------------------------------------------------
Operators
---------
+ => ADD
++=> Increment
- => Substract
--=> Substract
* => Mulitply
/ = Division
~ => bitwise unary not operator
NOT (!) => flips true values to false and false values to true.
>>, >>>, and << => IT is used to shift all the bits of a number left
or right
a Specified number of places...
Other Operators
----------------
AND => And operator
OR => OR operator
?: => value =condition ? value1 : value2 (similar to if then else)
== => compare two values...
= => Assignment operators
EQ => Compare two objects
Relational Operators
--------------------
> >= => Greater than , Greater than equals.
< <= => Less than , Less than equal
NOTEQ => Equals and not equals
NotEQ simillar to !=
CONDITIONS
----------
IF Syntax:
------------
if <condition> statements;
IF then else Syntax:
----------------------
if <condition> statements else statements1
if <condition> statements1 else if condition1 statement2 .... and soon.
SWITCH Statements:
-------------------
switch (expression)
{
case value1 :
statement1;
[break]
................
case valuen:
statementn;
[break]
-----
default:
default_statement;
}
Explanation:
------------
If the expression is equals value1
statement1 will be executed.
if you use break it comes out of the loop
otherwise it continue to execute next statement.
The default value at the end is optional. It can be included if there are other values that can be held in
your variable but that you haven't checked for elsewhere in the switch statement.
THE WHILE LOOP
-----------------------------
while (<condition> )
{
< Statements block>
}
Note: if the condition is true the block get executed.
otherwise the loop will be continued.
THE DO --- WHILE LOOP
-----------------------------
do
{
< Statements block>
}
while( <conditon> )
Note: if the condition is true the block get executed.
and it is tested at the end of the loop, but not at the
beginning. The loop will be continued until it satisfies the condition.
biggest reason to be use the do - while loop is that
when you need the body of the loop to be run atleast once.
FOR LOOP
--------
for ( identifier=value; cond1; iterator operators)
{
< Block statements >
}
For -EACH Statement
----------------------
//retrieving value using foreach loop
foreach (string <VAR> in <OBJECT>)
{
statements;
}
If you add integers (1 to 3) to arraylist
and if you wish to copy and store it in an integer variable
so that you can print the values that is copied from
arraylist.
Then follow this method of for each statements...
string[] hobies = { "twitter","cricket","footbal"};
foreach (string hob in hobies)
{
GDOLLAR.WriteLine("value="+hob);
}
Output:
-----------
value=twitter
value =cricket
value =footbal
CONTINUE and Break
---------------------------------
Break means it break out of loop
and continue means
it will continue to execute the statements;
for eg)
Program :WHILE LOOP with continue and break if statement...
--------------------------------------------------------------------------
<GDollar>
<CUTIL>
<IMPORT> P
{
public class WHILE
{
public void LIB()
{
int a=0;
while (a <=10)
{
a++;
GDOLLAR.WriteLine("value="+a);
if ( a==9) continue;
else break;
}
}
}
}
​
Output:
-------
Wed Aug 19 10:09:23 GMT+00:00 2015*
GDollar: value=1
DATATYPES and OVERLOADING and OVERRIDING CONCEPTS, INNER CLASS
----------------------------------------------------------------------------------------------------------------------------------------------------------------------
DATATYPES of GDollar are
-------------------------------
int -> accept only int value
float -> accept float value=>eg) 1.5f
bool => true or false
char => accept character value
byte -> 1 byte
short -> 2 bytes
long-> 8 bytes
double-> for eg) 1.2121233232E9 => Accept double value
ARRAY => It is used to store values and had fixed size.
ARRAY
-------
SYNTAX:
​
datatype[] object = <NEW> datatype[10];
​
​
<GDollar>
<IMPORT> P
{
public class abc
{
public void LIB()
{
​
int []a = <NEW> int[10];
for (int i=1;i<=9;i++)
{
a[i]=i;
GDOLLAR.WriteLine(a[i]);
}
}
}
}
​
OTHER KEYWORDS IN GDollar
--------------------------------------------------
AND -> AND operator
NOT -> NOT operator
# -> NOTEQUALS
RUN -> Runnable used in thread
TH-> Thread
<EXE> -> Exception
Friends -> Frend function
INNER and OUTER CLASS
-----------------------------------------
Inner class are nested inside outer class even if the fields
declared as private members.
<GDollar>
<IMPORT> P
{
class Outer {
private Shared int privInt = 10;
public void createInnerClass() {
Inner inClass = <NEW> Inner();
inClass.access();
}
class Inner {
public void access()
{
GDOLLAR.WriteLine("The outer classs privInt is " + privInt);
}
}
}
}
​
OVERLOADING AND OVERRIDING functions
-------------------------------------------
OVERLOADING
------------
A functions with same name but different signature is called
as Overloading concept.
public void display(int i , String j) {}
=> If you pass int and string values from main program it will call
this function.
ABC a = <NEW> ABC(10,"ewew");
public void display(int i, int j) {}
ABC a = <NEW> ABC(10,20);
=> If you pass int and int values it will call this function.
OVERRIDING
-----------
A function with same name and same signature
will cause overriding....
Overriding can be avoided by using super() keyword.
in another class.
<GDollar>
<IMPORT> P
{
public class section
{
public virtual string display()
{
return "CLASSA";
}
}
public class student:section
{
public override string display()
{
return "CLASSA-100students-computerscience";
}
}
}
Note: this will cause overriding
and it can be avoided by using super () keyword.
OTHER ATTRACTIVE SYMBOLS in GDollar
-------------------------------------------
--> => implements
<-- => extends
==================================================================================
UNIT 4
-------
FILE,Other collection concepts,Advanced Concepts of GDollar,MISC-2,Exception and
Error,Garbage collection,Threads,Generics,GDollar Structures.
==================================================================================
Advanced Topics in GDollar
-----------------------------
OTHER COLLECTIONS CONCEPTS
---------------------------------------------------
<M> => map MEANS IT CONTAINS KEYS AND VALUE PAIRS...
HashSet
-------------
SYNTAX:
<HASHSET> h <NEW> <HASHSET>(index);
h.add(data);
<PRINTLN>(""+h.GET());
HASHMAP
----------------
SYNTAX:
<HASHMAP> h <NEW> <HASHMAP>(index);
h.put(null, null); //you can also put null key and null value
h.put((data), null);
h.display();
HASHTABLE
----------------
SYNTAX:
HashTable h <NEW> HashTable(index);
h.put(key,value); h.display();
note: hash determines a order in which elements are
stored in the hash; SO it will display according
to hash stored order.
ADVANCED CONCEPTS of GDollar
----------------------------------------------------------
ITERATOR
----------------
Iterator iterate about collection
in the forward direction .
and it will iterate record wise from the List or collection.
foreach( int a in stringarray)
{
}
Here foreach statement is used for iterative purpose.
Exception and ERROR
-----------------------------------
Exception is a abnormal condition that arise during
the code sequence at run time.
<TRY> -> try in C/JAVA
<CATCH> -> catch in c/java
<Finally> -> final in c/java
SYNTAX:
-------------
<TRY>
{
< Executable good statements>
}
<CATCH> (<EXE> e)
{
GDollar.WriteLine(""+e);
}
<Finally>
{
<Final block statements>
}
Explanation:
-------------------
When ever the Exception is true statements inside a try
block is executed; otherwise
statements inside a catch block is executed.
Exception occurs or not
final block get executed..
FINAL in GDollar
--------------------------
UnShared keyword means final in GDollar
eg)
UnShared int i=9;
// if a variable is declared as final
that value can't be changed.
eg)
UnShared class abc
{
.......
}
if the class is declared as UnShared it can't
be overridden.
so if the method is declared as UnShared
such method can't be overriden by another class method.
Destructor:
----------
Destructor means object is going to be destroyed.
~
where ~ is the Destructor operator.
​
Operator Overloading in GDollar
------------------------------------------------
This means we can overload the operators
like + - = / > < >= <=
<GDollar>
<IMPORT> P
{
UnShared class operatoroverloading
{
public Shared void operator *(int s1 ,int s2)
{
int s3=s1 * s2;
GDOLLAR.WriteLine(""+s3);
}
public Shared void LIB( )
{
operator *(10,10);
operator *(200,10000);
}
}
}
GENERICS
---------------
GENERICS means which is used to Pass Type as argument as class
for example if you want to pass String , int, float datatypes at the
same time and if you use display method to display the value of any
datatype
so Generic is most useful in that case.
<GDollar>
<IMPORT> P
{
public class GEN<T>
{
T t;
T display(T t1)
{
t=t1;
return(t);
}
public Shared void LIB( )
{
GEN <int> i = <NEW> GEN<int> ();
GDOLLAR.WriteLine(""+ i.display(10));
}
}
}
=================================================================
GDollar STRUCTURES
-----------------------------------
GDollar structure is another user defined data type available in GDollar programming, which allows
you to combine data items of different kinds.
using the same memmory location. It also provide an efficient way of using the same
memory location for multi-purpose.
Thus GDollar Structures is Equivalent = C progamming Structures and union.
and it uses less memmory capacity than any Programming languages. IT is also
used to store collections, objecte ,etc.
IT is the most important datastructure implemented by wilmix jemin j.
He reduces the demerits of C Programming and
C child is GDollar. So GDollar has very beautiful and Advanced Concepts
than
any Programming Languages. And the Native Technology like JAVA
fails to do.
ADVANTAGES:
--------------------
Billing programs, GUI, Record wise Search and Printing ,etc...
==================================================================================
UNIT-5 :GDollar NETWORKING
==================================================================================
GDollar Networking
-------------------------------------
N/w are essential to our life. Intenet is born due to networking and
A method of Client -server communications
gives like a house - to house interaction.
​
CLIENT SERVER PROGRAM
--------------------------------
<GDollar>
<%
class CLIENTSERVER
{
public Shared void LIB( )
{
<CLIENT>("WILMIX","1099"); // Declare client and call client and pass hostname and port
<SERVER>("1099");//Declare server and server and pass portno
}
}
%>
?>
OUTPUT:
-------
Sat Aug 22 08:52:19 GMT+00:00 2015*GDollar: Connecting to WILMIX on port 1099Waiting for client on
port 1099...Socket timed out!
​
==================================================================================
UNIT -6: MISC ,Advanced Concepts
==================================================================================
Let us consider a Program to print using WHILE LOOP
Program -1
----------
<GDollar>
<%
public class WHILE
{
public Shared void LIB( )
{
int a=0;
while (a <=10)
{
a++;
GDollar.WriteLine("value="+a);
}
}
}
%>
?>
Compilation:
GDOLLARc WHILE.Gdollar
Output:
(note: at One time compilation you will get this output in windows platform)
********************************************************************
Tue Mar 01 1
3:30:08 IST 2016*JAS: Error:
***************************************************
******************************************
WHILE Tue Mar 01 13:30:09 IST 2016 GDollar:
Output: value=1value=2value=3value=4value=5value=6value=7value=8value=9value=10va
lue=11Error: value=1value=2value=3value=4value=5value=6value=7value=8value=9valu
e=10value=11
========================================
What is Pointers?
​
Variables that hold memory address are called pointers.
Why we mainly use Pointers?
Pointers reduces the length and complexity of the program,
They increase the execution speed.
It holds the memmory addres..
SYNTAX of GDollar Pointers:
---------------------------------
{*} <pointer-name> Pointers(intialvalue);
for eg)
<Str> s ="Life is beautiful";
{*} l Pointers(s);
The given above statement will store the string "Life is beautiful"
in Pointer name l;
Example:
<Str> s="dsdds";
{*} l Pointers (s);
l.add(s);
for (int i = 0; i NOT= l.size(); i = i + 1)
{
<OBJECT> obj=l.GETKEY(i);
<PRINTLN>(obj);
}
what is the output?
dsdds
dsdds
BUCKET
-------
Bucket are used to store key,value data, and Generated Random number
where datatype may be string ,object ,etc.
SYNTAX:
----------
Bucket<DATATYPE> list = <NEW> Bucket<DATATYPE>(<DATATYPEVALUE>);
list.KeyAdd(<DATATYPEVALUE>);
list.add(<DATATYPEVALUE>);
list.RandomAdd();
list.Display(list);
Advantages
----------
Using Bucket you can also Retrieve the values stored n position.
Searching and Insertion is fast than other DTS.
Random Indexing is possible.
eg) If you store a duplicate value such Random key will be different.
It also used to add many values.
EXTEND
------
Extend class is used in GDollar since to provide multiple inheritence
about 100000000 classes . Extends class also list values in methods and
constructor values.
Extend means a Bucket contains List of class and it is also
Behave like Bucket. So it is also one of the Advanced concepts in GDollar.
SYNTAX:
--------
EXTEND <<DATATYPE>> list11 = <NEW> EXTEND <<DATATYPE>> (STRING);
list.KeyAdd(<DATATYPEVALUE>);
list.add(<DATATYPEVALUE>);
list.RandomAdd();
list.Display(list);
Advantages:
It is also used to add many values
Indexing is possible
Value can also be list by index and behave like bucket.
It list only the class value and object value.
It is stateless.
PIPE:
-----
PIPE is used to maintain stateful state.
It is used for DataFlow in a Program. We can also add the values,
Constructor values of one class and other class and display it.
It also list the values from the Bucket.
​
SYNTAX:
-------
Pipe <<DATATYPE>> list11 = <NEW> Pipe <<DATATYPE>> (STRING);
list.KeyAdd(<DATATYPEVALUE>);
list.add(<DATATYPEVALUE>);
list.RandomAdd();
list.Display(list);
Why we Prefer GDollar for software Field?
Used in BILLS, Forms ,Reports,Charts, any software project , GRAPHICS to web etc.
==================================================================================
UNIT -7 :GDollar CODING STANDARDS AND ADVANTAGES OVER OTHER
PROGRAMMING LANGUAGES
==================================================================================
Coding Standards of GDollar
------------------------------
proper syntax fill it...
<GDollar>
<USE> packages;
<CUTIL>
<IMPORT> P
{
public class <classname>
{
<! LOGIC !>
}
}
​
Note :
ALL Program should Start with <GDollar> means starting of a Program and
scucceded by <IMPORT> package name
to load GDollar packages use <CUTIL>.
HIDE Unwanted code
--------------------
<------ program code ------>
MAIN Program:
-------------
public Shared void LIB( ) indicates MAIN Program
otherwise it will not run the Program
STATIC BLOCK
-------------
Shared means Static keyword.
Shared will be executed first after that Main program will
be executed.
Shared
{
}
{} => This curly braces are mostly used.
SOME OPERATOR KEYWORDS
-------------------------
AND => && in java
NOT => !
# => !=
NEW Keyword
---------------
NEW is used to create an instance in memmory.
Always concenterate on important keyword not need to
memmorize at all.
DATATYPES:
-----------
int , char, double , float are ordinary keywords of oops
Programming language like C/JAVA/C#/GDollar.
STRUCTURES:
-----------
Always use Structure DATATYPE to store your data in objects form
so that it will reduce the storage allocation in memmory.
for one object it takes only 1 byte of memmory for structures.
RECYCLE:
-------
Always use RECYCLE to make the unwanted object to be garbage collected.
//
----
If you want to describe something about your functions
use // . Don't use it unnessary at any way.
Special Characters
--------------------
@,$%,^,[] are not allowed in the CDOLLLAR program
~
---
Use Destructor keyword to specify non GDollar resource deletion code to
be goes when you it..
Other Things
-------------
for loop , if statements, while loop, do while ,
for each, Switch statements, AutoBoxing , Generics , etc
are same.
Did GDollar support pointer?
-----------------------------------
YES.
private LinkedList nextNode =null;
consider this line ; This line creates a pointer to a class
LinkedList .
nextNode=new LinkedList(datum);
This statements are use to insert first data to Linkedlist
nextNode.add(datum) is used to insert many data....
Class Inheritance
-------------------
If the Class is using another class variable in that case
you had to use <--- "extends" backward arrows
and front arrows --> for implements..
Implements is used when you use friend function.
GDollar ADvantages over JAVA and other Programming Languages
----------------------------------------------------------------------------------
1) GDOLLAR PREVENTS CODE STEALING SO IT IS WIDELY USED.
GDOLLAR intermediate code tells that this programmer had coded it.
A) GDollar is the combination of JAVA , C/C++, and Advanced OOPS.
b) GDollar will only accept the shortest attractive syntax.
c) GDollar also used for construction of any datastructures.
d) GDollar helps the developers to provide inheritance by not using extends
keyword
and call the class in main program when use in linux.
e) GDollar Solves diamond Problem with multiple Inheritance when used in linux.
f) It also supports friendly function, pointers , and structures.
g) GDollar support Virtual memmory and garbage collection.
h) It is efficient, fast and easy to understand, and it is a OOPS Technology.
i) GDollar is a High level language.
j) GDollar is highly portable language
k) Using GDollar you can create any datastructures as libraries and
use it in your Application program.
l) GDollar language is a structured and object programming language.
m) GDollar has OOPS concepts like JAVA.
n) GDollar have the concept of Packages,etc.
o) GDollar have the concept of constructor or destructor and had magic oops concepts.
p) It Support functions with Default Arguments
q) It Supports Exception handling
r) It Support Generic Programming
s) It have pointer and Nodes..
t) GDollar is much simpler oops concepts, which leads to faster development and less mental
overhead.
u) GDollar is almost always explicitly compiled
w) GDollar is easy to learn. GDollar was designed to be easy to use and is therefore easy to write,
compile, debug, and learn than other programming languages.
GDollar is object-oriented. This allows you to create modular programs and reusable code.
GDollar is platform-independent.
x) GDollar creates .exe or .dll files and it can be used with GDollar main program (CWE EDitor ) to create a complete software.
y) GDollar will compile and run at same time where other technology can't
do
z) GDollar is mainly used in complex programming , Billing the
goods,Graphics,etc
AA) GDollar is platform independant language
BB) GDollar is an interactive Technology.
CC) GDollar is used only in companies and industries.
DD) GDollar is used in compiler design and datastructures construction.
==============================================================================
UNIT -8 :GDollar MAIN Program Syntax AND ADVANCED CONCEPTS PROGRAM.
==============================================================================
Syntax:
<GDollar>
<INVOKE>
<PACK> <NAMESPACE>
<CLASS> <CLASSNAME>
{
public FLOAT GDollar-MAIN()
{
<! GDollar Logic !>
?>
BAG
=====
Bag is the extension of LinkedHashmap and it is the fastest
datastructures than
Dictionary.
SYNTAX:
=======
<GDollar>
<INVOKE>
<PACK> bags
<CLASS> bags
{
public FLOAT GDollar-MAIN()
{
Bag b <NEW> Bag();
b.PUT(1,34); // KEY AS 1 AND VALUE AS 34
b.PUT(2,444);
<PRINTLN>(""+b);
?>
Bag object = new Bag();
object .put(key,value);
Functions
getValues(key) => it is used to get the values for a particular key
get(key,loc) => it is used to get the value stored at a loc (indexing
purpose)
boolean containsValue(object Value) => To check the value present in bag or
not.
put(key,value) => it is used to add key and value in Bag
remove(key ,value) => It is used to remove key and value.
TreeList
========
TreeList simillar to Bucket but store items in tree format.
TreeList list = new TreeList ("BUCKETS");
list.KeyAdd(KEY);
list.add(VALUE1);
list.RandomAdd(RANDOMNO);
list.DisplayO(list,0);
MASK
====
It is the extension of Tree Structure and it can store many values
using mask object and we can also retrieve the values stored in mask.
Mask m = new Mask(<DATATYPE>);
m.add(multiple values);
m.getR(Loc); => Get the values stored in right position
m.getL(LOC) => Get the values stored in left position
HEAP:
====
Creates a tree , puts the data into tree in a fairly balanced way and displays
the tree's size and data in a tree by performing an inorder traversal.
Heap hob = new Heap(<datatype>);
hob.add(datum);
hob = new Heap(key,value1,value2);
Bucktist
==========
Bucktist is simillar to Bucket but it is used to addd two values with one
key.
Bucktist l = null;
l= new Bucktist(key,value1,value2);
WICKET
=======
Wicket is used to store multiple values using same object with
4 values per key.
Syntax:
Wicket list12;
list12=new Wicket(key,v1,v2,v3,v4);
list12.Display();
list12.Display(list12,location);
EXAMPLE -1: BAG
<GDollar>
<INVOKE>
<PACK> MyP
<CLASS> Programs
{
public FLOAT GDollar-MAIN()
{
Bag b <NEW> Bag();
b.PUT(1,34);
b.PUT(2,444);
<PRINTLN>(""+b);
?>
EXAMPLE:2 : GDOLLARARRAYS
==========
<GDollar>
<PACK> MyP
{
<CLASS> Programs
{
public FLOAT GDollar-MAIN()
{
<CDOLLARARRAYS> list1 <NEW> <CDOLLARARRAYS>("ANIMALS ");
list1.add("1 horse");
list1.add("2 pig");
list1.add("3 cow");
list1.add("4 goat");
list1.add("5 chicken");
list1.add("6 ostrich");
list1.Display();
?>
EXAMPLE-3: CREATE AN BOOTLOADER Using GDollar
<GDollar>
<PACK> MYOS
{
<CLASS> MYOs
{
public FLOAT GDollar-MAIN(){
<PRINTLN>("HelloWorld for booting MYOS");
</Statements>
?>
EXAMPE-4: POINTERS
<GDollar>
<PACK> MyP
{
<CLASS> Programs
{
public FLOAT GDollar-MAIN()
{
<Str> s="dsdds";
{*} l Pointers (s);
l.add(s);
for (int i = 0; i NOT= l.size(); i = i + 1)
{
<OBJECT> obj=l.GETKEY(i);
<PRINTLN>(obj);
}
?>
EXAMPLE-5: DICTIONARY
<GDollar>
<USE> CUTIL; //load CUTIL packages
<PACK> DTS
<%
<CLASS> roots
{
public FLOAT GDollar-MAIN()
{
<Dictionary> h <NEW> <Dictionary>(11);
h.Add((80), (90));
h.Add((40), (400));
h.Add((65), (650));
h.display();
h.Add((58), (580));
h.Add((24), (240));
h.display();
h.Add((2), (20));
h.Add((13), (130));
h.Add((46), (460));
h.Add((16), (160);
h.Add((7), (77));
h.Add((21), (271));
h.display();
<TRY> {h.Add((99), (990));}
<CATCH> (<EXE> e)
{<PRINTLN>(" out of memory");}
// update element
h.Add((7), (2977));
h.display();
%>
?>
Example-6: EXTEND
<GDollar>
<INVOKE>
<PACK> MyP
<CLASS> Programs
public FLOAT GDollar-MAIN()
{
EXTEND list <NEW> EXTEND("BUCKETS");
list.KeyAdd("1101");
list.add("jemin");
list.RandomAdd();
list.Display(list);
<PRINTLN>(""+list.DisplayO(list,1));
?>
EXAMPLE-7: HEAP
<GDollar>
<PACK> MyP
{
<CLASS> Programs
{
public FLOAT GDollar-MAIN()
{
Heap root <NEW> Heap("wilmix");
for (int i = 0; i <= 10; i = i + 1)
{
root.add("item " + i);
}
<PRINTLN>(root.size() );
root.printTree();
?>
Example-8: LArray
<GDollar>
<USE> CUTIL;
<PACK> MyP
{
<CLASS> Programs
{
public FLOAT GDollar-MAIN()
{
LArray root <NEW> LArray("root");
<ArrayList> ar <NEW> <ArrayList>();
for (int i=0;i<=1000;i++)
ar.add(i,i);
root.add("wilmix");
root.add("jemin");
root.add("shalom");
root.add("1010");
root.add("101");
root.add("201");
root.add(ar.StringConvert());
root.add("100000000");
//print the tree's size and contents
root.printTree();
?>
Example-9 : PIPE
<GDollar>
<PACK> MyP
{
<CLASS> Programs
{
public FLOAT GDollar-MAIN()
{
Pipe list <NEW> Pipe("BUCKETS");
list.KeyAdd("1101");
list.add("jemin");
list.RandomAdd();
list.Display(list);
<PRINTLN>(""+list.DisplayO(list,1));
?>
EXAMPLE-10: TREELIST
<GDollar>
<PACK> MyP
{
<CLASS> Programs
{
public FLOAT GDollar-MAIN()
{
TreeList list <NEW> TreeList ("BUCKETS");
list.KeyAdd("1101");
list.add("jemin");
list.RandomAdd("1111");
TreeList list2 <NEW> TreeList("BUCKETS");
list2.KeyAdd("1102");
list2.add("rahul");
list2.RandomAdd("1112");
<PRINTLN>("DATA="+list.DisplayO(list,0));
<PRINTLN>("DATA="+list2.DisplayO(list2,0));
?>
Example-11 : MASK
<GDollar>
<PACK> My
{
<CLASS> Programs
{
public FLOAT GDollar-MAIN()
{
MASK root <NEW> MASK("wilmix");
for (int i = 0; i NOT= 10; i = i + 1)
{
root.add("item " + i);
}
root <NEW> MASK("root1",1211211,54441);
root <NEW> MASK("root2",121121,5444);
root <NEW> MASK("root5",99121888,"5");
root <NEW> MASK("root3",12112,544);
root <NEW> MASK("root4",1211,54);
root <NEW> MASK("root51",121,5);
root.printTree();
?>
Example-12 : WICKET
<GDollar>
<PACK> MyPo
{
<CLASS> Programs
{
public FLOAT GDollar-MAIN()
{
Wicket list12;
list12 <NEW> Wicket(1000,10002,43433,4343,5555451);
list12 <NEW> Wicket(10001,100021,434331,4343,5555452);
list12 <NEW> Wicket(10002,100022,434332,4343,5555453);
list12 <NEW> Wicket(10003,100023,434333,4343,5555454);
list12 <NEW> Wicket(10004,100024,434334,4343,5555455);
list12 <NEW> Wicket(10005,100025,434335,4343,5555456);
list12.Display(list12);
<PRINTLN>("DATA="+list12.DisplayO(list12,0));
?>
Example-13 : STRUCTURE
<GDollar>
<PACK> MyPoi
{
<CLASS> Programs
{
public FLOAT GDollar-MAIN()
{
<Str> s="dsdds";
{*} l Pointers(s);
l.add(s);
for (int i = 0; i NOT= l.size(); i = i + 1)
{
<OBJECT> obj=l.GETKEY(i);
<PRINTLN>(obj);
}
<STRUCTURE> list <NEW> <STRUCTURE> (l.GETKEY(0));
for (int i11 = 0; i11 NOT= list.size(); i11 = i11 + 1)
{
<OBJECT> el=list.ret(i11);
<PRINTLN>("SNO= "+el);
}
?>
Example-14 : BUCKETIST
<GDollar>
<INVOKE>
<PACK> MyP
{
<CLASS> Programs
{
public FLOAT GDollar-MAIN()
{
Bucketist bp <NEW> Bucketist("wilmix");
bp <NEW> Bucketist(1,222,434);
bp <NEW> Bucketist(1,222,434);
bp.Display(bp);
<PRINTLN>("DATA="+bp.DisplayO(bp,1));
?>
==============================================================================
UNIT-9: G D O L L A R Technology focused for Compiler Design and datastructures design,Regular Expressions,Coding standards.
==============================================================================
COMPILER DESIGN USING GDollar
-------------------------------------------
Introduction of Compiler Design
----------------------------------
What is Compiler?
-------------------
A Translator which transforms a highlevel language such as CDollar, JDOLLAR, C /C++,
Fortran or COBOL into a Particular computer machine or assembly language
Is called a compiler.
What is Interpreter?
-------------------------
It Process an internal form of the source program and data at a same time.
Ie, interpretation of the internal source form occurs at run time and
No object program is generated.
A compiler must perform two major tasks.
a) Analysis of a source program
b) Synthesis of a corresponding object program
A) Analysis of a Source program
a) Lexical Analyser
------------------------------
That we know Lexical Analyser is responsible for
Splitting the statements into tokens.
For eg) If A > B then is splited as
If 20
A 21
>22
B 23
Then 24
Lexical Analyzer supplies tokens to syntax
Analyzer.
b) SYNTAX ANALYZER
------------------------------
IT's function is to take the source program from lexical
Analyzer and determine the manner in which it is
Decomposed into constituent parts.
Syntax Analyser outputs a syntax tree in
Which leaves are tokens and every nonleaf node represents
A syntactic class type.
SYNTACTIC TREE is factor, term , expression.
Semantic Analyser
------------------
It is main responsible of generation of intermediate form of source code.
Eg)
(+ ,A,B,T1)
(+,C,D,t2)
The output of semantic Analyser is passed to code Generator.
At this point the intermediate form of the source program
is usually translated to either assembly language or machine language.
The Output of Code Generator is passed on to
a code Optimizer.
THE CODE OPTIMIZER
----------------------
The Code Optimizer is responsible to produce a object or exe or class
Or wl files.
ERROR HANDLER
---------------
In compiler design Syntax error , invalid characters, out of memory exception,
Checked and unchecked exception are the exception occurs if a new
User do it. This error function f(X) is to determine the error in source code.
Without error handler no body can predict the errors..
SYMBOL TABLE
-------------
A Symbol Table will contains Variable name, Address, Type, dimensions, line declared or referenced, and pointer.
Mostly commonly performed on Symbol table are insertion and Lookup.
STORAGE ALLOCATION
--------------------
In static storage allocation strategy it is necessary to be able to decide at compile time
Exactly where each object will reside at run time.
But at dynamic storage allocation strategy the data area requirements for the program
Are not known entirely at compilation time.
Note: Parser is divided in to topdown parsing and bottom up parsingÂÂ….
That you refered through many websites .
THE GDollar for compiler Design
GDollar and it's ADVANTAGES
--------------------------------
What is GDollar? Who invented it? Who should focus it?
GDollar Technology is meant for Developing a compiler
By using GDollar Technology and itÂ’s DataStructuresÂ…
which saves time and cost and years ;
And make you to develop a compiler with in a 6 month.
GDollar Technology is invented by wilmix jemin j in cdollar at first and
Fulfilled at year 2013 and modified at C# , JAVA , C/C++ P.L at year 2016.
System programmers, Technology inventors, GDollar Professionals,
And professionals who are interested in inventing compiler
Should be focused.
ABOUT GDollar
--------------
GDollar is an Opensource compiler focused on compiler Design. GDollar belong to JAVA or C/C++ Group family.
GDollar is Invented in JAVA, C/C++, and Editor using Jdollar(JWEB)
GDollar virtual machine is used for
GDollar to run programs. G stands for Beta and Dollar stands for money.
So we called as Beta Technology.
GDollar is used by IT companies and industries in the world.
Syntax of GDollar:
------------------
<GDollar>
<USE> packages;
<%
<! OOPS statements !>
%>
?>
Merits of GDollar
------------------
> It is Good to create any compilers..
> It has simplified code
Demerits of GDollar:
It is not concenterated in creating Operating systems.
It is concenterated only in creating compilers.
How to compile and run GDollar?
GDollarc <filename>.Gdollar
Coding Standards of GDollar
------------------------------
<GDollar>
<USE> packages;
<%
<! LOGIC OF GDOLLAR !>
%>
?>
Note : <% and %> is used to write class and it's logic.
ALL Program should Start with <GDollar> means starting of a Program and succeded by <USE>
to load GDollar packages and ?> Means End of the Program.
HIDE Unwanted code
--------------------
<------ program code ------>
MAIN Program:
-------------
public void GDollar-Main( ) indicates MAIN Program
otherwise it will not run the Program
STATIC BLOCK
-------------
Shared means Static keyword.
Shared will be executed first after that Main program will
be executed.
Shared
{
}
{} => This curly braces are mostly used.
SOME OPERATOR KEYWORDS
-------------------------
AND => && in java
NOT => !
# => !=
<NEW> Keyword
---------------
<NEW> is used to create an instance in memmory.
Always concenterate on important keyword not need to
memorize at all.
DATATYPES:
-----------
int , char, double , float are ordinary keywords of oops
Programming language like C/JAVA/CDollar.
STRUCTURES:
-----------
Always use Structure DATATYPE to store your data in objects form
so that it will reduce the storage allocation in memmory.
for one object it takes only 1 byte of memmory for structures.
RECYCLE:
-------
Always use RECYCLE to make the unwanted object to be garbage collected.
//
----
If you want to describe something about your functions
use // . Don't use it unnessary at any way.
Special Characters
--------------------
@,$%,^,[] are not allowed in the GDollar program
~
---
Use Destructor keyword to specify non GDollar resource deletion code to
be goes when you it..
Other Things
-------------
for loop , if statements, while loop, do while ,
for each, Switch statements , Generics , etc
are same.
Did GDollar support pointer
-----------------------------
YES.
Class Inheritance
-------------------
If the Class is using another class variable in that case
you had to use <--- "extends" backward arrows
and front arrows --> for implements..
Implements is used when you use friend function.
==============================================================================
UNIT-10: G D O L L A R ADVANCED CONCEPTS and CJAVA
==============================================================================
UNION IN GDollar
================
SYNTAX:
==========
UNION u = new UNION(string);
UNION behave like structures but the only difference is
Union has build in functions like
a) Add(object)
b) Match(object,pos)
c) ret(Object)
d) Size() of object
Advantages:
structures is not used in the comparision of values so union is used.
USECASE in GDollar
==================
USECASE <Object> = new USECASE(datum);
datum may be datatype
eg) integer or string
<OBJECT>.Loc1(ob)
<OBJECT>.Loc2(ob)
USECASE behaves like UNION and is used for storing
objects at Loc1 ,Loc2 that has been used as a comparision with mathu1,matchu2
respectively.
and USECASE uses swithcase statement to asign values
ADVANTAGES:
i) Behave like struct
ii) compare the object
iii) Used for storing objects.
iV) it uses switch case statement
LOOP statement in GDollar:
======================
SYNTAX:
LOOP <Object> = new LOOP(datum);
datum may be datatype
eg) integer or string
<OBJECT>.Loc1(ob)
<OBJECT>.Loc2(ob)
LOOP behaves like UNION and is used for storing
objects at Loc1 ,Loc2 that has been used as a comparision with mathu1,matchu2
respectively.
ADVANTAGES:
i) Behave like struct
ii) compare the object
iii) Used for storing objects.
BOOK in GDollar
==============
SYNTAX:
BOOK <OBJECT>= new BOOK(string);
<OBJECT>.STOREA(object,object);
<OBJECT>.STOREB(object,object);
It is used for storing object with key and value in STOREA and STOREB.
And it is used to compare with match statement
ADVANTAGES
i) Book is used for storing two block of pages.
ii) it is used in case of storing large amount of notes and
it is used with database.
NOTE:
Examples for GDollar Advanced Datastructures is given in
AdvancedDatastructures folders of GDollar Software.
GDollar is powerful than CDollar.
How to compile using GDollar and see the output?
GDollarc <filename>.Gdollar
CJAVA Program
<CJAVA>
<PACK> LArrays
{
<CLASS> LArrays
{
public void main()
{
LArray root <NEW> LArray("root");
root.add("wilmix");
root.add("jemin");
root.add("shalom");
root.add("1010");
root.add("101");
root.add("100000000");
//print the tree's size and contents
root.printTree();
}
}
}
Now compile using CDollacc compiler what it will happen?
F:\xxxxxx\GDOLLARSOFTWARE\ORGINAL\GDollar\outputs>LArrays.cjava.exe
1010
wilmix
100000000
root
101
jemin
shalom
==============================================================================
UNIT-11: G D O L L A R COMPILER DESIGN
==============================================================================
Write a Gdollar Program to create a new Programming langauage?
<JSLASH> //starting Gdollar-jslash
<USE> compiler; //use compiler packages
<PACK> MyP
<%
<CLASS> Jshell
<%
Shared String[] keywords1 = { "abstract", "boolean", "byte", "case",
"catch", "char", "class", "continue", "default", "do", "double",
"else", "extends", "final", "finally", "float", "for", "if",
"implements", "import", "instanceof", "int", "interface", "long",
"native", "new", "package", "private", "protected", "public",
"return", "short", "static", "super", "switch", "synchronized",
"this", "throw", "throws", "transient", "try", "void", "volatile","main",
"while", "false", "true", "null","JSHELL","LOAD","JLOGIC;","CLOGIC","JEND" };
Shared String[] keytab1 ={"LOAD","JSHELL","JLOGIC","CLOGIC","JEND" };
//assign keywords
public void main()
<%
String t= args[0];
new Jcslash(keywords1); //assign keywords
String lext=".jshell"; // give extension
String regx="\\s+|\\.+|\\;+|\\(+|\\)+|\\\"+|\\:+|\\[+|\\]+";
String regx1="\\<JSHELL>+|\\'LOAD'+|\\'JLOGIC'+|\\'CLOGIC'+|\\<JEND>+";
String regx2="^\\<JSHELL>+^\\'LOAD'+^\\'JLOGIC'+^\\'CLOGIC'+^\\<JEND>+";
//write reqular expression to parse the statements
Jcslash.JParser(t,regx,53,regx1,regx2,lext,keytab1); // call jslash parser
String path="out.txt";
Jcslash.signature(path,lext,t); //this statement will call usedefined CDC compiler
// so rename your compiler as CDC.exe create using C/C++ or GDollar...
%>
​
​
For Research -> Download GDollar Programming Language PDF for more details...
​
​
MIT License
Copyright (c) 2016 Wilmix jemin @ GDOLLAR
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.