xxq250
/
Nasal-Interpreter
mirror of https://github.com/ValKmjolnir/Nasal-Interpreter.git
1
0
Fork 0
Code Issues Actions 1 Packages Projects Releases Wiki Activity

Parser is really comming.

This commit is contained in:
Valk Richard Li 2019-08-12 23:22:02 +08:00 committed by GitHub
parent e4b4086984
commit 9d56a418c8
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
20 changed files with 1954 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

110
version0.3/ebnf.cpp Normal file
View File

@ -0,0 +1,110 @@
/*
<>术语符号
[]最多出现一次
{}可以出现任意次，包括0次
()分组
|并列选项，只能选一个
*/
<long long int> ::= <long long int>
<double> ::= <double>
<char> ::= <char>
<string> ::= <string>
<array> ::= <array>
<hash> ::= <hash>
<key> ::= <identifier>
<number> ::= <long long int>|<double>
<class_function> ::= <identifier> [<(> { <,> <identifier> } <)>] <{> { <statement> <;> } <}>
<initial_value> ::= <number>|<char>|<string>
<array_initial_value> ::= <[> { <,> <number>|<char>|<string>|<array>|<hash> } <]>
<hash_initial_value> ::= <{> { <string_as_name> <:> <number>|<char>|<string>|<array>|<hash> } <}>
<class_initial_value> ::= <{> { <string_as_name> <:> <number>|<char>|<string>|<array>|<hash>|<class_function> } <}>
<definition_var> ::= <var> <identifier> <=> <initial_value>|<array_initial_value>|<hash_initial_value> <;>
<definition_class> ::= <var> <identifier> <=> <class_initial_value> <;>
<change_var> ::= <identifier> <=> <initial_value>|<array_initial_value>|<hash_initial_value> <;>
<not_global_var> ::= <identifier> <=> <initial_value>|<array_initial_value>|<hash_initial_value> <;>
<change_array> ::= <array> <[> <long long int> <]> <=> <initial_value>|<array_initial_value>|<hash_initial_value> <;>
<change_hash> ::= <hash> <[> <key> <]> <=> <initial_value>|<array_initial_value>|<hash_initial_value> <;>
<append> ::= <(><array> { <,> <number>|<char>|<string>|<array>|<hash> } <)> <;>
<setsize> ::= <(> <array> <,> <long long int> <)> <;>
<subvec> ::= <(> <array> <,> <long long int> <,> <long long int> <)> <;>
<pop> ::= <(> <array> <)> <;>
<sort> ::= <(> <array> <,> <func> <(> <identifier> <,> <identifier> <)> (<identifier> <-> <identifier>)|(<cmp> <(> <identifier> <,> <identifier> <)>) <)> <;>
<contains> ::= <(> <hash> <,> <key> <)> <;>
<delete> ::= <(> <hash> <,> <key> <)> <;>
<keys> ::= <(> <hash> <)> <;>
<choose> ::= [ <if> ] <(> <condition> <)> (<statement> <;>)|(<{> { <statement> <;> } <}>)
{ (<else> <if>)|<elsif> }|[ <else> ] <(> <condition> <)> (<statement> <;>)|(<{> { <statement> <;> } <}>)
<loop> ::= <for> <(> <var> <identifier> <=> <number> <;> <condition> <;> <identifier> <=> <identifier> <+> <number> <)>
<{>
{ <statement> <;> }
<}>
<loop> ::= <while> <(> <condition> <)>
<{>
{ <statement> <;> }
<}>
<loop> ::= <foreach>|<forindex> <(> <identifier> <,> <array> <)>
<{>
{ <statement> <;> }
<}>
<function_definition> ::= <var> <identifier> <func> [<(> { <identifier> } <)>]
<{>
{ <statement> <;> }
<}>
<function_use> ::= <identifier> <(> { ({<,> <number>|<char>|<string>|<array>|<hash>})|({<,> <identifier> <:> <number>|<char>|<string>|<array>|<hash>}) } <)>
<function_reload> ::= <var> <identifier> <func> [<(> { <identifier> } <)>]
<{>
{ <if> <(> <typeof> <(> <identifier> <)> <==> <typename_string> <)> ([<{> {<statement> <;>} <}>])|(<statement> <;>) }
<die> <(> <string> <)> <;>
<}>
<function_dynamic_spawn> ::= <var> <identifier> <func> [<(> { <identifier> } <)>]
<{>
{ <statement> <;> }
<return> <func> [<(> {<,> <identifier>} <)>]
<{>
{ <statement> <;> }
<}>
<}>
<array_print> ::= <array> <[> <number> <]>|[ <.> <key>|<array_print> ]
<hash_print> ::= <hash> <.> <key>|<array_print>
<print> ::= <(> { <,> <identifier>|<string>|<array_print>|<hash_print> } <)> <;>
<error_occur> ::= <die> <(> <string> <)> <;>
<multiple_declare> ::= <(> <var> { <,> <identifier> [<[> <number>|<string> <]>] } <)> <=> <(> { <number>|<char>|<string>|<array>|<hash> } <)> <;>
<multiple_declare> ::= <var> <(> { <,> <identifier> [<[> <number>|<string> <]>] } <)> <=> <(> { <number>|<char>|<string>|<array>|<hash> } <)> <;>
<swap_multiple_var> ::= <(> { <,> <identifier> [<[> <number>|<string> <]>] } <)> <=> <(> { <,> <identifier> [<[> <number>|<string> <]>] } <)> <;>
<var_from_array> ::= <var> <(> { <,> <identifier> [<[> <number>|<string> <]>] } <)> <=> <array> <;>
<sub_array> ::= <var> <identifier> <=> <identifier> <[> { <,> <number> }|(<number> <:> [ <number> ])|<number> <]> <;>
<language type> nasal--
<long long int> ::= <long long int>
<double> ::= <double>
<string> ::= <string>
<array> ::= <array>
<hash> ::= <hash>
<number> ::= <long long int>|<double>
<use_void_function> ::= <identifier> <(> {<identifier>} <)> <;>
<use_return_function> ::= <identifier> <(> {<identifier>} <)>
<definition> ::= <var> <identifier> <=> <number>|<string>|<array>|<hash>|<identifier>|<use_return_function> <;>
<assignment> ::= <identifier> <=> <number>|<string>|<array>|<hash>|<identifier>|<use_function> <;>
<function> ::= <var> <identifier> <=> <func> <(> {<identifier>} <)> <{> {<statement> <;>} <}>
<loop> ::= <for> <(> <var> <identifier> <=> <number> <;> <condition> <;> <identifier> <=> <identifier> <+> <number> <)>
<{>
{ <statement> <;> }
<}>
<loop> ::= <while> <(> <condition> <)>
<{>
{ <statement> <;> }
<}>
<choose> ::= [ <if> ] <(> <condition> <)> (<statement> <;>)|(<{> { <statement> <;> } <}>)
{ (<else> <if>)|<elsif> }|[ <else> ] <(> <condition> <)> (<statement> <;>)|(<{> { <statement> <;> } <}>)

27
version0.3/ide.txt Normal file
View File

@ -0,0 +1,27 @@
var inum=2;
var hnum=5;
var onum=1;
var neuron={
w:[],
b:0,
in:0,
out:0,
diff:0
new:func(last_layer_num){
setsize(w,last_layer_num);
return { parents:[neuron] };
}
};
var bp={
input_layer:[],
hidden_layer:[],
output_layer:[],
new:func(in_num,hidden_num,output_num){
setsize(input_layer,in_num);
for(var i=0;i<hidden_num;i=i+1)
append(hidden_layer,neuron.func(inum));
for(var i=0;i<output_num;i=i+1)
append(output_layer,neuron.func(hnum));
return { parents:[bp] };
}
};

35
version0.3/nasal.h Normal file
View File

@ -0,0 +1,35 @@
#ifndef __NASAL_H__
#define __NASAL_H__
#include <iostream>
#include <fstream>
#include <cstdlib>
#include <cstring>
#include <thread>
#include <ctime>
#include <cmath>
namespace nasal
{
#include "nasal_functional.h"
#include "nasal_var.h"
#include "nasal_list.h"
#include "nasal_hash.h"
#include "nasal_token.h"
#include "nasal_func.h"
#include "nasal_var.cpp"
#include "nasal_list.cpp"
#include "nasal_hash.cpp"
#include "nasal_print.h"
#include "nasal_var_stack.h"
#include "nasal_func_stack.h"
#include "nasal_token.cpp"
#include "nasal_func.cpp"
#include "nasal_lexer.h"
#include "nasal_parse.h"
}
#endif

174
version0.3/nasal_func.cpp Normal file
View File

@ -0,0 +1,174 @@
#ifndef __NASAL_FUNC_CPP__
#define __NASAL_FUNC_CPP__
#include "nasal_func.h"
func::func()
{
statement_head=new token_unit;
statement_head->line=0;
statement_head->type=FUNC_BEGIN;
statement_head->content="__func_begin";
statement_head->next=NULL;
parameter_head=new parameter;
parameter_head->param_var.type=VAR_NONE;
parameter_head->param_var.data=NULL;
parameter_head->var_name="__null_var";
parameter_head->next=NULL;
}
func::func(const func& temp)
{
token_unit *statement_temp=statement_head;
token_unit *temp_state=temp.statement_head;
parameter *parameter_temp=parameter_head;
parameter *temp_param=temp.parameter_head;
while(temp_state->next)
{
temp_state=temp_state->next;
statement_temp->next=new token_unit;
statement_temp=statement_temp->next;
statement_temp->line=temp_state->line;
statement_temp->content=temp_state->content;
statement_temp->type=temp_state->type;
statement_temp->next=NULL;
}
while(temp_param->next)
{
temp_param=temp_param->next;
parameter_temp->next=new parameter;
parameter_temp=parameter_temp->next;
parameter_temp->param_var=temp_param->param_var;
parameter_temp->var_name=temp_param->var_name;
parameter_temp->next=NULL;
}
}
func::~func()
{
token_unit *statement_temp=statement_head;
token_unit *statement_last_unit=NULL;
parameter *parameter_temp=parameter_head;
parameter *parameter_last_unit=NULL;
while(statement_temp->next)
{
statement_last_unit=statement_temp;
statement_temp=statement_temp->next;
delete statement_last_unit;
}
delete statement_temp;
while(parameter_temp->next)
{
parameter_last_unit=parameter_temp;
parameter_temp=parameter_temp->next;
delete parameter_last_unit;
}
delete parameter_temp;
}
func& func::operator=(const func& temp)
{
token_unit *statement_temp=statement_head->next;
token_unit *temp_state=temp.statement_head;
parameter *parameter_temp=parameter_head->next;
parameter *temp_param=temp.parameter_head;
token_unit *statement_last=NULL;
parameter *parameter_last=NULL;
if(statement_temp)
{
while(statement_temp->next)
{
statement_last=statement_temp;
statement_temp=statement_temp->next;
delete statement_last;
}
delete statement_temp;
}
if(parameter_temp)
{
while(parameter_temp->next)
{
parameter_last=parameter_temp;
parameter_temp=parameter_temp->next;
delete parameter_last;
}
delete parameter_temp;
}
statement_head->next=NULL;
parameter_head->next=NULL;
statement_temp=statement_head;
parameter_temp=parameter_head;
while(temp_state->next)
{
temp_state=temp_state->next;
statement_temp->next=new token_unit;
statement_temp=statement_temp->next;
statement_temp->line=temp_state->line;
statement_temp->content=temp_state->content;
statement_temp->type=temp_state->type;
statement_temp->next=NULL;
}
while(temp_param->next)
{
temp_param=temp_param->next;
parameter_temp->next=new parameter;
parameter_temp=parameter_temp->next;
parameter_temp->param_var=temp_param->param_var;
parameter_temp->var_name=temp_param->var_name;
parameter_temp->next=NULL;
}
return *this;
}
void func::append_var(std::string& varia_name,var& p)
{
parameter *parameter_temp=parameter_head;
while(parameter_temp->next)
{
parameter_temp=parameter_temp->next;
if(parameter_temp->var_name==varia_name)
{
std::cout<<"[Error] Redefinition of var \""<<varia_name<<"\" ."<<std::endl;
return;
}
}
parameter_temp->next=new parameter;
parameter_temp=parameter_temp->next;
parameter_temp->param_var=p;
parameter_temp->var_name=varia_name;
parameter_temp->next=NULL;
return;
}
void func::append_token(const int _line,const int _type,std::string &_content)
{
token_unit *statement_temp=statement_head;
while(statement_temp->next)
statement_temp=statement_temp->next;
statement_temp->next=new token_unit;
statement_temp=statement_temp->next;
statement_temp->line=_line;
statement_temp->type=_type;
statement_temp->content=_content;
statement_temp->next=NULL;
return;
}
void func::print_info()
{
parameter *para_temp=parameter_head;
token_unit *token_temp=statement_head;
std::cout<<"\n\t[parameter] :";
while(para_temp->next)
{
para_temp=para_temp->next;
std::cout<<para_temp->var_name<<" ";
}
std::cout<<"\n\t[statement] :";
while(token_temp->next)
{
token_temp=token_temp->next;
std::cout<<token_temp->content<<" ";
}
std::cout<<std::endl;
return;
}
#endif

36
version0.3/nasal_func.h Normal file
View File

@ -0,0 +1,36 @@
#ifndef __NASAL_FUNC_H__
#define __NASAL_FUNC_H__
#include "nasal_token.h"
//for function
#define FUNC_BEGIN 0
#define FUNC_OPERATOR 1
#define FUNC_IDENTIFIER 2
#define FUNC_NUMBER 3
#define FUNC_RESERVEWORD 4
#define FUNC_STRING 5
struct parameter
{
std::string var_name;
var param_var;
parameter *next;
};
class func
{
private:
token_unit *statement_head;
parameter *parameter_head;
public:
func();
func(const func&);
~func();
func& operator=(const func&);
void append_var(std::string&,var&);
void append_token(const int,const int,std::string &);
void print_info();
};
#endif

116
version0.3/nasal_func_stack.h Normal file
View File

@ -0,0 +1,116 @@
#ifndef __NASAL_FUNC_STACK_H__
#define __NASAL_FUNC_STACK_H__
#include "nasal_token.h"
#include "nasal_func.h"
struct func_stack_unit
{
std::string func_name;
func func_statement;
func_stack_unit *next;
};
class func_stack
{
private:
func_stack_unit *head;
public:
func_stack()
{
head=new func_stack_unit;
head->func_name="null";
head->next=NULL;
}
~func_stack()
{
func_stack_unit *temp=head;
func_stack_unit *this_node=NULL;
while(temp->next)
{
this_node=temp;
temp=temp->next;
delete this_node;
}
delete temp;
}
void append_function(std::string &function_name,func &temp_func)
{
func_stack_unit *temp=head;
while(temp->next)
{
temp=temp->next;
if(temp->func_name==function_name)
{
std::cout<<"[Error] Redeclaration of function \""<<function_name<<"\""<<std::endl;
return;
}
}
temp->next=new func_stack_unit;
temp=temp->next;
temp->next=NULL;
temp->func_name=function_name;
temp->func_statement=temp_func;
return;
}
// void run_function(std::string &function_name)
// {
// func_stack_unit *temp=head;
// while(temp->next)
// {
// temp=temp->next;
// if(temp->func_name==function_name)
// {
// temp->func_statement.run();
// return;
// }
// }
// std::cout<<"[Error] Could not find this function."<<std::endl;
// return;
// }
void print_function()
{
func_stack_unit *temp=head;
while(temp->next)
{
temp=temp->next;
std::cout<<"function: "<<temp->func_name;
temp->func_statement.print_info();
}
return;
}
void pop_function()
{
func_stack_unit *temp=head;
func_stack_unit *end_temp;
if(!head->next)
return;
while(temp->next)
{
end_temp=temp;
temp=temp->next;
}
end_temp->next=NULL;
delete temp;
}
void delete_all()
{
func_stack_unit *temp=head->next;
func_stack_unit *this_node=NULL;
head->next=NULL;
if(!temp)
return;
while(temp->next)
{
this_node=temp;
temp=temp->next;
delete this_node;
}
delete temp;
return;
}
};
func_stack nasal_func_stack;
#endif

62
version0.3/nasal_functional.h Normal file
View File

@ -0,0 +1,62 @@
#ifndef __NASAL_FUNCTIONAL_H__
#define __NASAL_FUNCTIONAL_H__
#include <iostream>
#include <cstring>
bool is_float(std::string &str)
{
for(int i=0;i<(int)str.length();++i)
if(str[i]=='.')
return true;
return false;
}
long long int int_str2num(std::string &str)
{
for(int i=0;i<(int)str.length();++i)
if(!(('0'<=str[i]) && (str[i]<='9') || (str[i]=='.')))
{
std::cout<<"[Error] Non-numeric string."<<std::endl;
return 0;
}
long long int num=0;
long long int acc=1;
for(int i=(int)str.length()-1;i>=0;--i)
{
num+=acc*((long long int)(str[i]-'0'));
acc*=10;
}
return num;
}
double double_str2num(std::string &str)
{
for(int i=0;i<(int)str.length();++i)
if(!(('0'<=str[i]) && (str[i]<='9') || (str[i]=='.')))
{
std::cout<<"[Error] Non-numeric string."<<std::endl;
return 0;
}
int DotPlace=0;
for(int i=0;i<(int)str.length();++i)
if(str[i]=='.')
{
DotPlace=i;
break;
}
double num=0;
double acc=1;
double aff=0.1;
for(int i=DotPlace+1;i<(int)str.length();++i)
{
num+=aff*((double)(str[i]-'0'));
aff*=0.1;
}
for(int i=DotPlace-1;i>=0;--i)
{
num+=acc*((double)(str[i]-'0'));
acc*=10;
}
return num;
}
#endif

113
version0.3/nasal_hash.cpp Normal file
View File

@ -0,0 +1,113 @@
#ifndef __NASAL_HASH_CPP__
#define __NASAL_HASH_CPP__
#include "nasal_hash.h"
nasal_hash::nasal_hash()
{
head=new nasal_hash_unit;
head->name="";
head->hash_var.type=VAR_NONE;
head->hash_var.data=NULL;
head->next=NULL;
}
nasal_hash::~nasal_hash()
{
nasal_hash_unit *temp=head;
nasal_hash_unit *this_node=NULL;
while(temp->next)
{
this_node=temp;
temp=temp->next;
delete this_node;
}
delete temp;
}
nasal_hash& nasal_hash::operator=(const nasal_hash &p)
{
nasal_hash_unit *temp=head;
nasal_hash_unit *this_node=NULL;
if(head->next)
{
temp=temp->next;
head->next=NULL;
while(temp->next)
{
this_node=temp;
temp=temp->next;
delete this_node;
}
delete temp;
}
temp=head;
nasal_hash_unit *temp_p=p.head;
while(temp_p->next)
{
temp_p=temp_p->next;
temp->next=new nasal_hash_unit;
temp=temp->next;
temp->next=NULL;
temp->hash_var=temp_p->hash_var;
temp->name=temp_p->name;
}
return *this;
}
void nasal_hash::append(std::string& var_name,var& p)
{
nasal_hash_unit *temp=head;
while(temp->next)
temp=temp->next;
temp->next=new nasal_hash_unit;
temp=temp->next;
temp->next=NULL;
temp->hash_var=p;
temp->name=var_name;
return;
}
int nasal_hash::contains(std::string& var_name)
{
nasal_hash_unit *temp=head;
while(temp->next)
{
temp=temp->next;
if(temp->name==var_name)
return 1;
}
return 0;
}
int nasal_hash::delete_element(std::string& var_name)
{
nasal_hash_unit *temp=head;
nasal_hash_unit *last_node=NULL;
while(temp->next)
{
last_node=temp;
temp=temp->next;
if(temp->name==var_name)
{
last_node->next=temp->next;
delete temp;
return 1;
}
}
return 0;
}
nasal_list nasal_hash::keys()
{
var assist_var;
assist_var.type=VAR_STRING;
nasal_list temp_list;
nasal_hash_unit *temp=head;
while(temp->next)
{
temp=temp->next;
assist_var.data=new std::string;
*((std::string *)assist_var.data)=temp->name;
temp_list.append(assist_var);
}
return temp_list;
}
#endif

27
version0.3/nasal_hash.h Normal file
View File

@ -0,0 +1,27 @@
#ifndef __NASAL_HASH_H__
#define __NASAL_HASH_H__
#include "nasal_var.h"
struct nasal_hash_unit
{
std::string name;
var hash_var;
nasal_hash_unit *next;
};
class nasal_hash
{
private:
nasal_hash_unit *head;
public:
nasal_hash();
~nasal_hash();
nasal_hash& operator=(const nasal_hash&);
void append(std::string&,var&);
int contains(std::string&);
int delete_element(std::string&);
nasal_list keys();
};
#endif

53
version0.3/nasal_interpreter.cpp Normal file
View File

@ -0,0 +1,53 @@
#include <iostream>
#include <cstring>
#include <cstdlib>
#include "nasal.h"
int main()
{
std::string command;
std::cout<<">> input \"help\" to find help."<<std::endl;
while(1)
{
std::cout<<">> ";
std::getline(std::cin,command);
if(command=="help")
{
std::cout<<">> 1. input file name to run the nasal script."<<std::endl;
std::cout<<">> 2. command cls to clear the screen."<<std::endl;
std::cout<<">> 3. command exit to shut down the program."<<std::endl;
std::cout<<">> 4. command lexer to see tokens in stack."<<std::endl;
std::cout<<">> 5. command del to delete all elements in stack."<<std::endl;
std::cout<<">> 6. command run to run the programme in stack."<<std::endl;
std::cout<<">> 7. command rs to check the source program."<<std::endl;
}
else if(command=="cls")
{
system("cls");
//linux system("clear");
//macOS system("clear");
}
else if(command=="rs")
nasal::PrintSourceFile();
else if(command=="exit")
{
break;
}
else if(command=="lexer")
nasal::nasal_lexer.print();
else if(command=="del")
{
nasal::nasal_lexer.delete_all();
nasal::nasal_var_stack.delete_all();
nasal::nasal_func_stack.delete_all();
}
else if(command=="run")
{
nasal::nasal_var_stack.delete_all();
nasal::nasal_func_stack.delete_all();
}
else
nasal::RunProcess(command);
}
return 0;
}

272
version0.3/nasal_lexer.h Normal file
View File

@ -0,0 +1,272 @@
#ifndef __NASAL_LEXER_H__
#define __NASAL_LEXER_H__
#include <iostream>
#include <fstream>
#include <cstring>
#include "nasal_functional.h"
#define FAIL -1 //ʧ°Ü
#define SCANEND -2 //ɨÃèÍê³É
#define ERRORFOUND -3 //Òì³£´íÎó
std::string ReserveWord[26]=
{
"for","foreach","forindex","while",
"var","func","break","continue","return",
"if","else","elsif","nil","and","or",
"print","cmp","append","setsize","subvec","pop",
"sort","contains","delete","keys","typeof"
};
std::string OperatorOrDelimiter[40]=
{
"+","-","*","/","=","+=","-=","*=","/=",
"\n","\t","\r","\\","\'","\"",".",
"<","<=",">",">=","==","!=","~=","!","~",
",",";","(",")","[","]","{","}","#","?",":",
"&","|","%","^"
};
std::string IdentifierTable[1000]={""};
char ResourceProgram[16777216];
int isReserveWord(std::string &p)
{
for(int i=0;i<26;++i)
if(ReserveWord[i]==p)
return i+1;
return FAIL;
}
int isOperatorOrDelimiter(std::string &p)
{
for(int i=0;i<40;++i)
if(OperatorOrDelimiter[i]==p)
return i+1;
return FAIL;
}
bool isLetter(char t)
{
return (('a'<=t) && (t<='z') || ('A'<=t) && (t<='Z'));
}
bool isNumber(char t)
{
return (('0'<=t) && (t<='9'));
}
void InputFile(std::string &FileName)
{
std::ifstream fin(FileName);
int i=0;
bool FindNote=false;
while(!fin.eof())
{
ResourceProgram[i]=fin.get();
if(ResourceProgram[i]=='\n')
FindNote=false;
if(ResourceProgram[i]!='#' && !FindNote)
++i;
else if(ResourceProgram[i]=='#')
{
FindNote=true;
}
if(fin.eof())
break;
}
ResourceProgram[i]=0;
fin.close();
return;
}
void PrintSourceFile()
{
int line=1;
std::cout<<line<<" ";
for(int i=0;i<16777216;++i)
{
if(!ResourceProgram[i])
break;
std::cout<<ResourceProgram[i];
if(ResourceProgram[i]=='\n')
{
++line;
std::cout<<line<<" ";
}
}
std::cout<<std::endl;
}
void Scanner(int &Syn,const char Source[],std::string &token,int &ptr,int &line)
{
char temp;
temp=Source[ptr];
while(temp==' ' || temp=='\n' || temp=='\t' || temp=='\r' || temp<0 || temp>127)
{
++ptr;
if(temp=='\n')
++line;
temp=Source[ptr];
}
token="";
if(isLetter(temp) || temp=='_')
{
token+=temp;
++ptr;
temp=Source[ptr];
while(isLetter(temp) || isNumber(temp) || temp=='_')
{
token+=temp;
++ptr;
temp=Source[ptr];
}
Syn=isReserveWord(token);
if(Syn==FAIL)
Syn=IDENTIFIER;
else
Syn=RESERVEWORD;
}
else if(isNumber(temp))
{
int PointCnt=0;
while(isNumber(temp))
{
token+=temp;
++ptr;
temp=Source[ptr];
if(temp=='.' && !PointCnt)
{
++PointCnt;
token+=temp;
++ptr;
temp=Source[ptr];
}
}
Syn=NUMBER;
}
else if(temp=='(' || temp==')' || temp=='[' || temp==']' || temp=='{' ||
temp=='}' || temp==',' || temp==';' || temp=='|' || temp==':' ||
temp=='?' || temp=='.' || temp=='`' || temp=='\'' || temp=='&'||
temp=='%' || temp=='$' || temp=='^')
{
token+=temp;
++ptr;
Syn=OPERATOR;
}
else if(temp=='=' || temp=='+' || temp=='-' || temp=='*' || temp=='!' || temp=='/' || temp=='<' || temp=='>' || temp=='~')
{
Syn=OPERATOR;
token+=temp;
++ptr;
temp=Source[ptr];
if(temp=='=')
{
token+=temp;
++ptr;
}
}
else if(temp=='\\')
{
Syn=OPERATOR;
token+=temp;
++ptr;
temp=Source[ptr];
if(temp=='=' || temp=='n' || temp=='t' || temp=='r' || temp=='\\' || temp=='\'' || temp=='\"')
{
token+=temp;
++ptr;
}
}
else if(temp=='\"')
{
Syn=STRING;
token+=temp;
++ptr;
temp=Source[ptr];
while(temp!='\"')
{
if(temp=='\\')
{
token+=temp;
++ptr;
temp=Source[ptr];
token+=temp;
++ptr;
temp=Source[ptr];
}
else
{
token+=temp;
++ptr;
temp=Source[ptr];
}
if(temp==0 || temp=='\n')
break;
}
//add the last char \"
if(temp=='\"')
{
token+=temp;
++ptr;
}
else
token+=" __missing_end_of_string";
}
else if(temp==0)
{
Syn=SCANEND;
return;
}
else
{
Syn=FAIL;
std::cout<<"[Error] Unexpected error occurred: "<<temp<<std::endl;
system("pause");
++ptr;
return;
}
if(token=="")
{
Syn=ERRORFOUND;
std::cout<<"[Error] Cannot identify "<<std::endl;
}
return;
}
void RunProcess(std::string &FileName)
{
int Syn=0;//token type
int Ptr=0;//pointer to one char in ResourcePrograme
int line=1;
std::string token;
std::ifstream fin(FileName);
if(fin.fail())
{
std::cout<<"[Error] Failed to load file: "<<FileName<<std::endl;
fin.close();
return;
}
else
fin.close();
ResourceProgram[0]=0;
nasal_lexer.delete_all();
InputFile(FileName);
while(Syn!=SCANEND && Syn!=ERRORFOUND)
{
Scanner(Syn,ResourceProgram,token,Ptr,line);
if(Syn>0)//all Syn type is larger than zero
nasal_lexer.append(line,Syn,token);
}
//nasal_lexer.print(); //for debug mode
std::cout<<">> Complete scanning \""<<FileName<<"\"."<<std::endl;
return;
}
#endif

300
version0.3/nasal_list.cpp Normal file
View File

@ -0,0 +1,300 @@
#ifndef __NASAL_LIST_CPP__
#define __NASAL_LIST_CPP__
#include "nasal_var.h"
#include "nasal_list.h"
nasal_list::nasal_list()
{
head=new nasal_list_unit;
head->list_var.type=VAR_NONE;
head->list_var.data=NULL;
head->next=NULL;
}
nasal_list::~nasal_list()
{
nasal_list_unit *temp=head;
nasal_list_unit *this_node=NULL;
while(temp->next)
{
this_node=temp;
temp=temp->next;
delete this_node;
}
delete temp;
}
nasal_list& nasal_list::operator=(const nasal_list &p)
{
nasal_list_unit *temp=head;
nasal_list_unit *this_node=NULL;
if(head->next)
{
temp=temp->next;
head->next=NULL;
while(temp->next)
{
this_node=temp;
temp=temp->next;
delete this_node;
}
delete temp;
}
temp=head;
nasal_list_unit *temp_p=p.head;
while(temp_p->next)
{
temp_p=temp_p->next;
temp->next=new nasal_list_unit;
temp=temp->next;
temp->next=NULL;
temp->list_var=temp_p->list_var;
}
return *this;
}
void nasal_list::append(var& p)
{
nasal_list_unit *temp=head;
while(temp->next)
temp=temp->next;
temp->next=new nasal_list_unit;
temp=temp->next;
temp->next=NULL;
temp->list_var=p;
return;
}
void nasal_list::setsize(const int list_size)
{
nasal_list_unit *temp=head;
int cnt=0;
while(temp->next)
{
temp=temp->next;
++cnt;
if(cnt==list_size)
{
nasal_list_unit *this_node=NULL;
nasal_list_unit *t=temp->next;
temp->next=NULL;
if(!t)
return;
while(t->next)
{
this_node=t;
t=t->next;
delete this_node;
}
delete t;
return;
}
}
while(cnt<list_size)
{
temp->next=new nasal_list_unit;
temp=temp->next;
temp->list_var.type=VAR_NONE;
temp->list_var.data=NULL;
temp->next=NULL;
++cnt;
}
return;
}
nasal_list nasal_list::subvec(const int list_begin=0,const int list_end=-1)
{
nasal_list temp_list;
int cnt=-1;
nasal_list_unit *temp=head;
int beg=list_begin;
int end=list_end;
if(list_end==-1)
{
int end_place=-1;
while(temp->next)
{
temp=temp->next;
++end_place;
}
temp=head;
end=end_place;
}
while(temp->next)
{
temp=temp->next;
++cnt;
if(beg<=cnt && cnt<=end)
temp_list.append(temp->list_var);
}
return temp_list;
}
var nasal_list::pop()
{
nasal_list_unit *temp=head;
nasal_list_unit *this_node;
while(temp->next)
{
this_node=temp;
temp=temp->next;
}
this_node->next=NULL;
var temp_var=temp->list_var;
delete temp;
return temp_var;
}
nasal_list nasal_list::sort_list(const int sort_type,const int _cmp=1)
{
nasal_list temp_list;
if(sort_type==SORT_INT)
{
nasal_list_unit *temp=head;
while(temp->next)
{
temp=temp->next;
if(temp->list_var.type!=VAR_LLINT)
{
std::cout<<"[Error] Incorrect type inside: "<<temp->list_var.type<<".But type must be long int."<<std::endl;
temp_list.setsize(1);
return temp_list;
}
}
if(temp->list_var.type!=VAR_LLINT)
{
std::cout<<"[Error] Incorrect type inside: "<<temp->list_var.type<<".But type must be long int."<<std::endl;
temp_list.setsize(1);
return temp_list;
}
temp_list=*this;
nasal_list_unit *first_temp_this;
nasal_list_unit *second_temp_this;
nasal_list_unit *node_this;
first_temp_this=temp_list.head->next;
while(first_temp_this->next)
{
node_this=first_temp_this;
second_temp_this=first_temp_this->next;
while(second_temp_this->next)
{
if(_cmp>0 && *((int *)node_this->list_var.data)>*((int *)second_temp_this->list_var.data))//from small to large
node_this=second_temp_this;
else if(_cmp<=0 && *((int *)node_this->list_var.data)<*((int *)second_temp_this->list_var.data))//from large to small
node_this=second_temp_this;
second_temp_this=second_temp_this->next;
}
if(_cmp>0 && *((int *)node_this->list_var.data)>*((int *)second_temp_this->list_var.data))//from small to large func(a,b) a-b
node_this=second_temp_this;
else if(_cmp<=0 && *((int *)node_this->list_var.data)<*((int *)second_temp_this->list_var.data))//from large to small func(a,b) b-a
node_this=second_temp_this;
if(node_this!=first_temp_this)
{
int t;
t=*((int *)first_temp_this->list_var.data);
*((int *)first_temp_this->list_var.data)=*((int *)node_this->list_var.data);
*((int *)node_this->list_var.data)=t;
}
first_temp_this=first_temp_this->next;
}
}
else if(sort_type==SORT_DBL)
{
nasal_list_unit *temp=head;
while(temp->next)
{
temp=temp->next;
if(temp->list_var.type!=VAR_DOUBLE)
{
std::cout<<"[Error] Incorrect type inside: "<<temp->list_var.type<<".But type must be float."<<std::endl;
temp_list.setsize(1);
return temp_list;
}
}
if(temp->list_var.type!=VAR_DOUBLE)
{
std::cout<<"[Error] Incorrect type inside: "<<temp->list_var.type<<".But type must be float."<<std::endl;
temp_list.setsize(1);
return temp_list;
}
temp_list=*this;
nasal_list_unit *first_temp_this;
nasal_list_unit *second_temp_this;
nasal_list_unit *node_this;
first_temp_this=temp_list.head->next;
while(first_temp_this->next)
{
node_this=first_temp_this;
second_temp_this=first_temp_this->next;
while(second_temp_this->next)
{
if(_cmp>0 && *((double *)node_this->list_var.data)>*((double *)second_temp_this->list_var.data))//from small to large
node_this=second_temp_this;
else if(_cmp<=0 && *((double *)node_this->list_var.data)<*((double *)second_temp_this->list_var.data))//from large to small
node_this=second_temp_this;
second_temp_this=second_temp_this->next;
}
if(_cmp>0 && *((double *)node_this->list_var.data)>*((double *)second_temp_this->list_var.data))//from small to large func(a,b) a-b
node_this=second_temp_this;
else if(_cmp<=0 && *((double *)node_this->list_var.data)<*((double *)second_temp_this->list_var.data))//from large to small func(a,b) b-a
node_this=second_temp_this;
if(node_this!=first_temp_this)
{
double t;
t=*((double *)first_temp_this->list_var.data);
*((double *)first_temp_this->list_var.data)=*((double *)node_this->list_var.data);
*((double *)node_this->list_var.data)=t;
}
first_temp_this=first_temp_this->next;
}
}
else if(sort_type==SORT_STR)
{
nasal_list_unit *temp=head;
while(temp->next)
{
temp=temp->next;
if(temp->list_var.type!=VAR_STRING)
{
std::cout<<"[Error] Incorrect type inside: "<<temp->list_var.type<<".But type must be string."<<std::endl;
temp_list.setsize(1);
return temp_list;
}
}
if(temp->list_var.type!=VAR_STRING)
{
std::cout<<"[Error] Incorrect type inside: "<<temp->list_var.type<<".But type must be string."<<std::endl;
temp_list.setsize(1);
return temp_list;
}
temp_list=*this;
nasal_list_unit *first_temp_this;
nasal_list_unit *second_temp_this;
nasal_list_unit *node_this;
first_temp_this=temp_list.head->next;
while(first_temp_this->next)
{
node_this=first_temp_this;
second_temp_this=first_temp_this->next;
while(second_temp_this->next)
{
if(_cmp>0 && *((std::string *)node_this->list_var.data)>*((std::string *)second_temp_this->list_var.data))//from small to large
node_this=second_temp_this;
else if(_cmp<=0 && *((std::string *)node_this->list_var.data)<*((std::string *)second_temp_this->list_var.data))//from large to small
node_this=second_temp_this;
second_temp_this=second_temp_this->next;
}
if(_cmp>0 && *((std::string *)node_this->list_var.data)>*((std::string *)second_temp_this->list_var.data))//from small to large func(a,b) cmp(a,b)
node_this=second_temp_this;
else if(_cmp<=0 && *((std::string *)node_this->list_var.data)<*((std::string *)second_temp_this->list_var.data))//from large to small func(a,b) cmp(b,a) or -cmp(a,b)
node_this=second_temp_this;
if(node_this!=first_temp_this)
{
std::string t;
t=*((std::string *)first_temp_this->list_var.data);
*((std::string *)first_temp_this->list_var.data)=*((std::string *)node_this->list_var.data);
*((std::string *)node_this->list_var.data)=t;
}
first_temp_this=first_temp_this->next;
}
}
return temp_list;
}
#endif

33
version0.3/nasal_list.h Normal file
View File

@ -0,0 +1,33 @@
#ifndef __NASAL_LIST_H__
#define __NASAL_LIST_H__
#include "nasal_var.h"
#define SORT_INT 1
#define SORT_DBL 2
#define SORT_STR 3
class nasal_hash;
struct nasal_list_unit
{
var list_var;
nasal_list_unit *next;
};
class nasal_list
{
private:
nasal_list_unit *head;
public:
nasal_list();
~nasal_list();
nasal_list& operator=(const nasal_list&);
void append(var&);
void setsize(const int);
nasal_list subvec(const int,const int);
var pop();
nasal_list sort_list(const int,const int);
};
#endif

59
version0.3/nasal_parse.h Normal file
View File

@ -0,0 +1,59 @@
#ifndef __NASAL_PARSE_H__
#define __NASAL_PARSE_H__
#include "nasal_lexer.h"
struct parse_unit
{
int type;
std::string content;
int line;
};
class parse
{
private:
parse_unit *content_array;
parse_unit *statement;
int len;
public:
parse();
~parse();
void content_array_set_empty();
void statement_set_empty();
};
parse::parse()
{
len=0;
content_array=new parse_unit[4096];
statement=new parse_unit[1024];
}
parse::~parse()
{
if(content_array)
delete []content_array;
if(statement)
delete []statement;
}
void parse::content_array_set_empty()
{
for(int i=0;i<4096;++i)
{
content_array[i].line=0;
content_array[i].type=0;
}
return;
}
void parse::statement_set_empty()
{
for(int i=0;i<1024;++i)
{
statement[i].line=0;
statement[i].type=0;
}
return;
}
parse nasal_parse;
#endif

76
version0.3/nasal_print.h Normal file
View File

@ -0,0 +1,76 @@
#ifndef __NASAL_PRINT_H__
#define __NASAL_PRINT_H__
#include<iostream>
#include<cstring>
#include "nasal_hash.cpp"
#include "nasal_list.cpp"
void PrintString(std::string &PrintInfo)
{
for(int i=0;i<(int)PrintInfo.length();++i)
{
if(PrintInfo[i]=='\\' && i+1<(int)PrintInfo.length())
{
switch(PrintInfo[i+1])
{
case 'n':
std::cout<<"\n";
++i;
break;
case 't':
std::cout<<"\t";
++i;
break;
case 'r':
std::cout<<"\r";
++i;
break;
case '\\':
std::cout<<"\\";
++i;
break;
case '\'':
std::cout<<"\'";
++i;
break;
case '\"':
std::cout<<"\"";
++i;
break;
default:
//error occurred
std::cout<<"[Error]: Incorrect escape character \'"<<PrintInfo[i]<<PrintInfo[i+1]<<"\' .";
++i;
break;
}
}
else if(PrintInfo[i]=='\\' && i+1>=(int)PrintInfo.length())
{
//error occurred
std::cout<<"[Error]: Missing character after \'\\\'";
}
else
std::cout<<PrintInfo[i];
}
return;
}
void PrintVar(var Var)
{
if(Var.type==VAR_LLINT)
std::cout<<*((long long int *)Var.data);
else if(Var.type==VAR_DOUBLE)
std::cout<<*((double *)Var.data);
else if(Var.type==VAR_CHAR)
std::cout<<*((char *)Var.data);
else if(Var.type==VAR_STRING)
PrintString(*((std::string *)Var.data));
else if(Var.type==VAR_LIST)
;//((nasal_list *)Var.data)->print_list();
else if(Var.type==VAR_HASH)
;//((nasal_hash *)Var.data)->PrintHash();
else
std::cout<<"[Error] Null type or function";
}
#endif

108
version0.3/nasal_token.cpp Normal file
View File

@ -0,0 +1,108 @@
#ifndef __NASAL_TOKEN_CPP__
#define __NASAL_TOKEN_CPP__
#include "nasal_token.h"
#include "nasal_var_stack.h"
#include "nasal_func_stack.h"
token_list::token_list()
{
list_range=0;
head=new token_unit;
head->type=FUNC_BEGIN;
head->content="__process_begin";
head->line=0;
head->next=NULL;
}
token_list::~token_list()
{
token_unit *temp=head;
token_unit *this_node=NULL;
while(temp->next)
{
this_node=temp;
temp=temp->next;
delete this_node;
}
delete temp;
}
token_unit* token_list::get_head()
{
return head;
}
int token_list::get_list_range()
{
return list_range;
}
void token_list::print_line_token(const int _line)
{
std::cout<<"line "<<_line<<": ";
token_unit *temp=head;
while(temp->next)
{
temp=temp->next;
if(temp->line==_line)
std::cout<<temp->content<<" ";
else if(temp->line>_line)
break;
}
std::cout<<std::endl;
return;
}
void token_list::delete_all()
{
if(!head->next)
return;
token_unit *temp=head;
token_unit *this_node=NULL;
temp=temp->next;
head->next=NULL;
while(temp->next)
{
this_node=temp;
temp=temp->next;
delete this_node;
}
delete temp;
return;
}
void token_list::append(const int _line,const int _type,std::string &_content)
{
token_unit *temp=head;
while(temp->next)
temp=temp->next;
++list_range;
temp->next=new token_unit;
temp=temp->next;
temp->next=NULL;
temp->type=_type;
temp->line=_line;
temp->content=_content;
return;
}
void token_list::print()
{
token_unit *temp=head;
std::cout<<"line "<<temp->line<<": "<<"( ProcessBegin | "<<temp->content<<" )"<<std::endl;
if(!head->next)
return;
while(temp->next)
{
temp=temp->next;
std::cout<<"line "<<temp->line<<": ";
if(temp->type==OPERATOR)
std::cout<<"( Operator | ";
else if(temp->type==IDENTIFIER)
std::cout<<"( Identifier | ";
else if(temp->type==NUMBER)
std::cout<<"( Number | ";
else if(temp->type==RESERVEWORD)
std::cout<<"( ReserveWord | ";
else if(temp->type==STRING)
std::cout<<"( String | ";
std::cout<<temp->content<<" )"<<std::endl;
}
return;
}
#endif

38
version0.3/nasal_token.h Normal file
View File

@ -0,0 +1,38 @@
#ifndef __NASAL_TOKEN_H__
#define __NASAL_TOKEN_H__
#include "nasal_var.h"
//for token and lexer
#define OPERATOR 1 //界符 or 运算符
#define IDENTIFIER 2 //自定义标识符
#define NUMBER 3 //数字
#define RESERVEWORD 4 //关键字
#define STRING 5 //字符串类型
struct token_unit
{
int type;
std::string content;
int line;
token_unit *next;
};
class token_list
{
private:
token_unit *head;
int list_range;
public:
token_list();
~token_list();
token_unit* get_head();
int get_list_range();
void print_line_token(const int);
void delete_all();
void append(const int,const int,std::string&);
void print();
};
token_list nasal_lexer;
#endif

140
version0.3/nasal_var.cpp Normal file
View File

@ -0,0 +1,140 @@
#ifndef __NASAL_VAR_CPP__
#define __NASAL_VAR_CPP__
var::var()
{
type=VAR_NONE;
data=NULL;
}
var::var(const var &temp)
{
type=temp.type;
switch(type)
{
case VAR_NONE:
data=NULL;
break;
case VAR_LLINT:
data=new long long int;
*((long long int *)data)=*((long long int *)temp.data);
break;
case VAR_DOUBLE:
data=new double;
*((double *)data)=*((double *)temp.data);
break;
case VAR_CHAR:
data=new char;
*((char *)data)=*((char *)temp.data);
break;
case VAR_STRING:
data=new std::string;
*((std::string *)data)=*((std::string *)temp.data);
break;
case VAR_LIST:
data=new nasal_list;
*((nasal_list *)data)=*((nasal_list *)temp.data);
break;
case VAR_HASH:
data=new nasal_hash;
*((nasal_hash *)data)=*((nasal_hash *)temp.data);
break;
case VAR_FUNC:
data=new func;
*((func *)data)=*((func *)temp.data);
break;
}
}
var::~var()
{
if(data)
switch(type)
{
case VAR_LLINT:
delete (long long int *)data;
break;
case VAR_DOUBLE:
delete (double *)data;
break;
case VAR_CHAR:
delete (char *)data;
break;
case VAR_STRING:
delete (std::string *)data;
break;
case VAR_LIST:
delete (nasal_list *)data;
break;
case VAR_HASH:
delete (nasal_hash *)data;
break;
case VAR_FUNC:
delete (func *)data;
break;
}
}
var& var::operator=(const var &temp)
{
if(data)
switch(type)
{
case VAR_LLINT:
delete (long long int *)data;
break;
case VAR_DOUBLE:
delete (double *)data;
break;
case VAR_CHAR:
delete (char *)data;
break;
case VAR_STRING:
delete (std::string *)data;
break;
case VAR_LIST:
delete (nasal_list *)data;
break;
case VAR_HASH:
delete (nasal_hash *)data;
break;
case VAR_FUNC:
delete (func *)data;
break;
}
type=temp.type;
switch(type)
{
case VAR_NONE:
data=NULL;
break;
case VAR_LLINT:
data=new long long int;
*((long long int *)data)=*((long long int *)temp.data);
break;
case VAR_DOUBLE:
data=new double;
*((double *)data)=*((double *)temp.data);
break;
case VAR_CHAR:
data=new char;
*((char *)data)=*((char *)temp.data);
break;
case VAR_STRING:
data=new std::string;
*((std::string *)data)=*((std::string *)temp.data);
break;
case VAR_LIST:
data=new nasal_list;
*((nasal_list *)data)=*((nasal_list *)temp.data);
break;
case VAR_HASH:
data=new nasal_hash;
*((nasal_hash *)data)=*((nasal_hash *)temp.data);
break;
case VAR_FUNC:
data=new func;
*((func *)data)=*((func *)temp.data);
break;
}
return *this;
}
#endif

24
version0.3/nasal_var.h Normal file
View File

@ -0,0 +1,24 @@
#ifndef __NASAL_VAR_H__
#define __NASAL_VAR_H__
#define VAR_NONE 0
#define VAR_LLINT 1
#define VAR_DOUBLE 2
#define VAR_CHAR 3
#define VAR_STRING 4
#define VAR_LIST 5
#define VAR_HASH 6
#define VAR_FUNC 7
class var
{
public:
int type;
void *data;
var();
var(const var&);
~var();
var& operator=(const var&);
};
#endif

151
version0.3/nasal_var_stack.h Normal file
View File

@ -0,0 +1,151 @@
#ifndef __NASAL_VAR_STACK_H__
#define __NASAL_VAR_STACK_H__
#include "nasal_print.h"
struct var_stack_unit
{
std::string var_name;
var var_detail;
var_stack_unit *next;
};
class var_stack
{
private:
var_stack_unit *head;
public:
var_stack()
{
head=new var_stack_unit;
head->var_name="null";
head->next=NULL;
}
~var_stack()
{
var_stack_unit *temp=head;
var_stack_unit *this_node=NULL;
while(temp->next)
{
this_node=temp;
temp=temp->next;
delete this_node;
}
delete temp;
}
void append_var(std::string& varia_name,var& temp_var)
{
var_stack_unit *temp=head;
while(temp->next)
temp=temp->next;
temp->next=new var_stack_unit;
temp=temp->next;
temp->var_name=varia_name;
temp->var_detail=temp_var;
temp->next=NULL;
}
void print_var()
{
var_stack_unit *temp=head;
while(temp->next)
{
temp=temp->next;
std::cout<<"[";
switch(temp->var_detail.type)
{
case VAR_NONE:
std::cout<<"null";
break;
case VAR_LLINT:
std::cout<<"int";
break;
case VAR_DOUBLE:
std::cout<<"float";
break;
case VAR_CHAR:
std::cout<<"char";
break;
case VAR_STRING:
std::cout<<"string";
break;
case VAR_LIST:
std::cout<<"array";
break;
case VAR_HASH:
std::cout<<"hash";
break;
}
std::cout<<"]: "<<temp->var_name<<" : ";
if(temp->var_detail.type!=VAR_STRING)
PrintVar(temp->var_detail);
else
std::cout<<*((std::string *)temp->var_detail.data);
std::cout<<std::endl;
}
return;
}
var search_var(std::string varia_name)
{
var temp_var;
temp_var.data=NULL;
temp_var.type=VAR_NONE;
var_stack_unit *temp=head;
while(temp->next)
{
temp=temp->next;
if(temp->var_name==varia_name)
{
temp_var=temp->var_detail;
break;
}
}
return temp_var;
}
void edit_var(std::string varia_name,var &temp_var)
{
var_stack_unit *temp=head;
while(temp->next)
{
temp=temp->next;
if(temp->var_name==varia_name)
{
temp->var_detail=temp_var;
break;
}
}
return;
}
void pop_var()
{
var_stack_unit *temp=head;
var_stack_unit *end_temp;
if(!head->next)
return;
while(temp->next)
{
end_temp=temp;
temp=temp->next;
}
end_temp->next=NULL;
delete temp;
}
void delete_all()
{
var_stack_unit *temp=head->next;
var_stack_unit *this_node=NULL;
head->next=NULL;
if(!temp)
return;
while(temp->next)
{
this_node=temp;
temp=temp->next;
delete this_node;
}
delete temp;
return;
}
};
var_stack nasal_var_stack;
#endif