Vertex* Vertex::adjacent( std::size_t connector_id ) const
{
const auto pc = Connector::look_up(connector_id) ;
if(pc)
{
Vertex* v1 = look_up( pc->vertex_pair.first ) ;
Vertex* v2 = look_up( pc->vertex_pair.second ) ;
if( v1 != this && v2 != this ) throw std::logic_error("bad connector") ;
return v1 == this ? v2 : v1 ;
}
return nullptr ;
}
int main(int argc, char **argv)
{
FILE *boot, *img;
char boot_buf[512];
short buf2[512];
short blocks[256];
struct inode inode;
int i = 0;
if (argc != 3) {
fprintf(stderr, "install-boot boot.bin dev_name\n");
exit(0);
}
boot = fopen(argv[1], "rb");
if (boot == NULL) {
fprintf(stderr, "File Open Error:%s", argv[3]);
exit(0);
}
img = fopen(argv[2], "r+");
if (img == NULL) {
fprintf(stderr, "File Open Error:%s", argv[1]);
exit(0);
}
fread(boot_buf, 512, 1, boot);
fclose(boot);
read_super(img);
read_inode(img, 1, &inode);
look_up(img, &inode, "boot");
look_up(img, &inode, "kernel");
memset(blocks, 0, 512);
for (i = 0; i < 7; i++)
blocks[i] = inode.i_zone[i];
read_block(img, inode.i_zone[7], (char*) buf2);
while (i * 1024 < inode.i_size) {
blocks[i] = buf2[i - 7];
i++;
}
fseek(img, 0, 0);
fwrite(boot_buf, 1, 512, img);
fwrite(blocks, 1, 512, img);
fclose(img);
}
/* Get a token. */
get_token()
{
register char *temp;
token_type=0; tok=0;
temp=token;
if(*prog=='\0') { /* end of file */
*token=0;
tok = FINISHED;
return(token_type=DELIMITER);
}
while(iswhite(*prog)) ++prog; /* skip over white space */
if(*prog=='\r') { /* crlf */
++prog; ++prog;
tok = EOL; *token='\r';
token[1]='\n'; token[2]=0;
return (token_type = DELIMITER);
}
if(strchr("+-*^/%=;(),><", *prog)){ /* delimiter */
*temp=*prog;
prog++; /* advance to next position */
temp++;
*temp=0;
return (token_type=DELIMITER);
}
if(*prog=='"') { /* quoted string */
prog++;
while(*prog!='"'&& *prog!='\r') *temp++=*prog++;
if(*prog=='\r') serror(1);
prog++;*temp=0;
return(token_type=QUOTE);
}
if(isdigit(*prog)) { /* number */
while(!isdelim(*prog)) *temp++=*prog++;
*temp = '\0';
return(token_type = NUMBER);
}
if(isalpha(*prog)) { /* var or command */
while(!isdelim(*prog)) *temp++=*prog++;
token_type=STRING;
}
*temp = '\0';
/* see if a string is a command or a variable */
if(token_type==STRING) {
tok=look_up(token); /* convert to internal rep */
if(!tok) token_type = VARIABLE;
else token_type = COMMAND; /* is a command */
}
return token_type;
}
codec_c const
codec_c::look_up(fourcc_c const &fourcc) {
initialize();
auto itr = brng::find_if(ms_codecs, [&fourcc](codec_c const &c) { return brng::find(c.m_fourccs, fourcc) != c.m_fourccs.end(); });
return itr != ms_codecs.end() ? *itr : look_up(fourcc.str());
}
int uninstall(void *tag,HASH_TABLE hash_table)
{
HASH_CELL **tmp,*mem;
if((hash_table==NULL)||((mem=*(tmp=look_up(tag,hash_table)))==NULL))
return(-1);
if(hash_table->destructor!=NULL)
hash_table->destructor(&(mem->tag),&(mem->cell));
(*tmp)=(*tmp)->next;
free(mem);
(hash_table->n)--;
return(0);
}/*uninstall*/
int get_token()
{
int tok;
char *temp;
(token_type) = 0;
tok = 0;
temp = (token);
if (*(prog) == '\0')
{
*(token) = 0;
tok = FINISHED;
return ((token_type) = DELIMITER);
}
while (iswhite(*(prog))) ++(prog);
if (isdelim(*(prog)))
{
char t=*temp = *(prog);
(prog)++;
temp++;
if ((t == '>' || t == '<' || t == '!') && (*prog) && (*prog == '='))
{
*temp = *(prog);
(prog)++;
temp++;
}
*temp = 0;
return ((token_type) = DELIMITER);
}
if (isdigit(*(prog)))
{
while (!isdelim(*(prog)))
*temp++=*(prog)++;
*temp = '\0';
return ((token_type) = NUMBER);
}
if (isalpha2(*(prog)))
{
while (!isdelim(*(prog)))
*temp++=*(prog)++;
(token_type) = VARIABLE;
}
*temp = '\0';
if ((token_type) == VARIABLE)
{
tok = look_up((token));
if (tok)
(token_type) = FUNCTION;
}
return (token_type);
}
/*void Initialize()
{
struct entry *ptr;
for(ptr=keywords;ptr->token;ptr+1)
insert(ptr->lexptr,ptr->token);
}*/
int lexer()
{
int t;
int val,i=0;
while(1)
{
t=getchar();
if(t==' '||t=='\t');
else
if(t=='\n')
lineno=lineno+1;
else
if(isdigit(t))
{
ungetc(t,stdin);
scanf("%d",&tokenval);
return NUM;
}
else
if(isalpha(t))
{
while(isalnum(t))
{
buffer[i]=t;
t=getchar();
i=i+1;
if(i>=SIZE)
Error_Message("Compiler error");
}
buffer[i]=EOS;
if(t!=EOF)
ungetc(t,stdin);
val=look_up(buffer);
if(val==0)
val=insert(buffer,ID);
tokenval=val;
return symtable[val].token;
}
else
if(t==EOF)
return DONE;
else
{
tokenval=NONE;
return t;
}
}
}
Lexeme * evaluate(Lexeme * tree, Lexeme * env) {
char * type = getType(tree);
//fprintf(stdout, " >> "); printOut(tree);
if (is_a_primary(type)) {
return tree;
}
else if (type == CLOSURE) {
// If this is a new closure, link it to its defining scope (this one).
if (get_closure_environment(tree) == NULL) {
tree = set_closure_environment(tree, env);
}
return tree;
}
else if (type == IDENTIFIER) {
return look_up(env, tree);
}
else if (type == CALL) {
// Function calls are evaluated by the function evaluator module.
return evaluate_function_call(tree, env);
}
else if (type == BUILT_IN) {
// Built-ins are executed directly by the built-ins module.
return execute(tree, env);
}
else if (type == BINDING) {
return evaluate_binding(tree, env);
}
else if (type == REBINDING) {
return evaluate_rebinding(tree, env);
}
else if (type == IF_CLAUSE) {
return evaluate_if_control(tree, env);
}
else if (type == WHILE_LOOP) {
return evaluate_while_control(tree, env);
}
//else if (type == FOR_LOOP) {
// return evaluate_for_control(tree, env);
//}
else if (type == EXPRESSION_LIST) {
return evaluate_expression_list(tree, env);
}
else {
fprintf(stderr, "Evaluation error: I don't know what to do with type <%s>.\n", type);
exit(-1);
}
}
int install(void *tag,void *cell, HASH_TABLE hash_table)
{
HASH_CELL **tmp;
if(hash_table==NULL)return(-1);
if((*(tmp=look_up(tag,hash_table)))==NULL){
/*new element*/
(*tmp)=get_mem(1,sizeof(HASH_CELL));/*Here the "next" field probably is assigned!*/
(*tmp)->next=NULL;(*tmp)->cell=cell;(*tmp)->tag=tag;
(hash_table->n)++;
return(0);
}else{
/*replace existing element*/
if(hash_table->destructor!=NULL)
hash_table->destructor(&((*tmp)->tag),&((*tmp)->cell));
(*tmp)->cell=cell;(*tmp)->tag=tag;
return(1);
}
}/*install*/
/*Resizes an existing hash table. Returns 0 in success:*/
int resize_hash_table(HASH_TABLE hash_table,word newSize)
{
word i;
HASH_CELL *m1,**tmp;
struct hash_tab_struct tmpTable;
if(hash_table==NULL)return -1;
if(newSize==0)return -2;
if(hash_table->table==NULL){
hash_table->table=get_mem(newSize,sizeof(HASH_CELL *));
hash_table->tablesize=newSize;
return 0;
}/*if(hash_table->table==NULL)*/
/*Allocate new table with the same attributes as incoming hash_table
except tablesize:*/
tmpTable.tablesize=newSize;
tmpTable.hash=hash_table->hash;
tmpTable.cmp=hash_table->cmp;
tmpTable.destructor=hash_table->destructor;
tmpTable.new_tag=hash_table->new_tag;
tmpTable.new_cell=hash_table->new_cell;
/* The table itself must be of a new size:*/
tmpTable.table=get_mem(newSize,sizeof(HASH_CELL *));
for(i=0;i<hash_table->tablesize;i++)
if((m1=(hash_table->table)[i])!=NULL){
do{
tmp=look_up(m1->tag,&tmpTable);
(*tmp)=m1;/*Here the "next" field probably is assigned!*/
m1=m1->next;
(*tmp)->next=NULL;
}while(m1!=NULL);
}
/*Clear old table:*/
free_mem(&(hash_table->table));
/*And set up the new one:*/
hash_table->table=tmpTable.table;
hash_table->tablesize=newSize;
return 0;
}/*resize_hash_table*/
node_idx UniqueTable::add(const level k, const node_idx p)
{
node_idx r;
TableNode *newNode;
unsigned int idx;
r = look_up(k, p);
if (r != -1)
return r;
idx = m_forest->hashnode(k, p) % TABLE_SIZE;
newNode = new TableNode;
newNode->k = k;
newNode->p = p;
newNode->next = m_table[k][idx];
m_table[k][idx] = newNode;
return p;
}
codec_c const
codec_c::look_up_object_type_id(unsigned int object_type_id) {
return look_up( ( (MP4OTI_MPEG4Audio == object_type_id)
|| (MP4OTI_MPEG2AudioMain == object_type_id)
|| (MP4OTI_MPEG2AudioLowComplexity == object_type_id)
|| (MP4OTI_MPEG2AudioScaleableSamplingRate == object_type_id)) ? type_e::A_AAC
: MP4OTI_MPEG1Audio == object_type_id ? type_e::A_MP2
: MP4OTI_MPEG2AudioPart3 == object_type_id ? type_e::A_MP3
: MP4OTI_DTS == object_type_id ? type_e::A_DTS
: ( (MP4OTI_MPEG2VisualSimple == object_type_id)
|| (MP4OTI_MPEG2VisualMain == object_type_id)
|| (MP4OTI_MPEG2VisualSNR == object_type_id)
|| (MP4OTI_MPEG2VisualSpatial == object_type_id)
|| (MP4OTI_MPEG2VisualHigh == object_type_id)
|| (MP4OTI_MPEG2Visual422 == object_type_id)
|| (MP4OTI_MPEG1Visual == object_type_id)) ? type_e::V_MPEG12
: MP4OTI_MPEG4Visual == object_type_id ? type_e::V_MPEG4_P2
: MP4OTI_VOBSUB == object_type_id ? type_e::S_VOBSUB
: type_e::UNKNOWN);
}
bool list<T>::remove(T t)
{
node* del = look_up(t);
if (del == 0)
return false;
else if (del == head_)
pop_front();
else if (del == tail_)
pop_back();
else {
del->prev_->next_ = del->next_;
del->next_->prev_ = del->prev_;
destroy(del);
FreeMemory(del);
--sz_;
}
return true;
}
static int copy_iterator(void *info,HASH_CELL *m, word index_in_tbl, word index_in_chain)
{
if( ((COPY_ITERATOR_PARAMETERS *)info)->from_to_priors<0)/*from overrides*/
install(
((COPY_ITERATOR_PARAMETERS *)info)->copy_tag(m->tag),
((COPY_ITERATOR_PARAMETERS *)info)->copy_cell(m->cell),
((COPY_ITERATOR_PARAMETERS *)info)->to_table
);
else if( ((COPY_ITERATOR_PARAMETERS *)info)->from_to_priors>0){/*to overrides*/
if(
*look_up(
m->tag,
((COPY_ITERATOR_PARAMETERS *)info)->to_table) == NULL)/*absent!*/
install(
((COPY_ITERATOR_PARAMETERS *)info)->copy_tag(m->tag),
((COPY_ITERATOR_PARAMETERS *)info)->copy_cell(m->cell),
((COPY_ITERATOR_PARAMETERS *)info)->to_table
);
}else /* == 0, just delete "from" from "to": */
uninstall(m->tag,((COPY_ITERATOR_PARAMETERS *)info)->to_table);
return 0;
}/*copy_iterator*/
std::string const
codec_c::get_name(type_e type,
std::string const &fallback) {
auto codec = look_up(type);
return codec ? codec.m_name : fallback;
}
std::string const
codec_c::get_name(std::string const &fourcc_or_codec_id,
std::string const &fallback) {
auto codec = look_up(fourcc_or_codec_id);
return codec ? codec.m_name : fallback;
}
codec_c const
codec_c::look_up(char const *fourcc_or_codec_id) {
return look_up(std::string{fourcc_or_codec_id});
}
/* Чтение лексемы */
char get_token()
{
register char *temp;
token_type = 0; tok = 0;
temp = token;
if( *prog == '\0' )
{
/* Конец файла */
*token = 0;
tok = FINISHED;
return( token_type = DELIMITER );
}
while( iswhite(*prog) ) ++prog; /* Пропуск пробелов */
if( *prog == '\r' )
{
/* конец строки программы */
++prog; ++prog;
tok = EOL; *token = '\r';
token[1] = '\n'; token[2] = 0;
return (token_type = DELIMITER );
}
if( strchr("+-*^/%=;(),<>", *prog ) )
{
/* Разделитель */
*temp = *prog;
prog++; /* Переход на следующу позицию */
temp++;
*temp = 0;
return ( token_type = DELIMITER );
}
if ( *prog == '"' )
{
/* строка кавычек */
prog ++;
while( *prog != '"' && *prog != '\r' ) *temp++ = *prog++;
if( *prog == '\r' ) serror(1);
prog++; *temp = 0;
return( token_type = QUOTE );
}
if( isdigit(*prog) )
{
/* число */
while( !isdelim( *prog ) ) *temp++ = *prog++;
*temp = '\0';
return( token_type = NUMBER );
}
if( isalpha( *prog ) )
{
/* переменная или команда */
while( !isdelim( *prog ) ) *temp++ = *prog++;
token_type = STRING;
}
*temp = '\0';
/* просматривается, если строка - переменная или команда */
if ( token_type == STRING )
{
tok = look_up( token ); /* Преобразование во внутренний формат */ //Пока что таблица table не заполнена, посему look_up === 0
if ( !tok ) token_type = VARIABLE;
else token_type = COMMAND; /* это команда */
}
return token_type;
}
void calc_function(double *hold)
{
double_list *args = NULL, *last = NULL, *t;
double d;
int i,argc=0,save_code;
save_code = code;
code = 0;
i = look_up(token);
if (i == 0)
serror(ERR_BADFUNCTION); // error
get_token();
if (*(token) != '(')
serror(ERR_NOBRACKET); // error
//get_token();
if (functions[i].args == STR_ARG)
{
get_token();
d = ((matfunc_str)(functions[i].f))(token);
*hold = d;
get_token();
if (save_code)
code = save_code;
return;
}
//last = args = (double_list*)malloc(sizeof(double_list));
//args->next = NULL;
//level1(&args->val);
//get_token();
argc=0;
do
{
get_token();
if (*token == ')')
break;
t = (double_list*)allocmem(sizeof(double_list));
code = 0;
level1(&t->val);
t->code = code;
t->next = NULL;
if (last)
last->next = t;
else
args = t;
last = t;
argc++;
} while (*token == ',');
code = save_code;
if (argc != functions[i].args && functions[i].args >= 0)
{
serror(ERR_BADPARAM);
}
else
{
switch (functions[i].args)
{
case 0:
d = ((matfunc0)(functions[i].f))();
break;
case 1:
d = ((matfunc)(functions[i].f))(args->val);
break;
case 2:
d = ((matfunc2)(functions[i].f))(args->val,args->next->val);
break;
case 3:
d = ((matfunc3)(functions[i].f))(args->val,args->next->val,args->next->next->val);
break;
case INF_ARGS:
d = ((matfunc_inf)(functions[i].f))(args);
break;
}
}
t = args;
while (t)
{
args = t->next;
freemem(t);
t = args;
}
*hold = d;
// else
// serror( ERR_OVERFLOW);
}
int main()
{
buf_pool *sp ;
sp = buf_init(pool_num,sizeof(double));
#if 0 //for test
int i = 4 ;
sp = add(sp,&i);
look_up(sp);
#endif
int res ;
pthread_t tid[thread_num] ; //store to child pthread
pthread_t master_tid ;
#if 0 //int
int test_arry[] = {10,11,12,13};
#endif
#if 1
double test_arry[] = {10.0,11.0,12.0,13.0};
#endif
master_thread_param *mtp;
mtp = (master_thread_param *)malloc(sizeof(master_thread_param));//apply memery
mtp->master_sp = sp ; //point to buf_pool
mtp->param = test_arry; //address of a test_array
mtp->num = sizeof(test_arry)/sizeof(test_arry[0]);//array length
res = pthread_create(&master_tid,NULL,master_thread_function,mtp);
if (res != 0)
{
fprintf(stderr,"pthread was create error \n");
exit(EXIT_FAILURE);
}
pthread_join(master_tid,NULL);
#if 1 //for test
look_up(sp);
#endif
// double double_test_array[thread_num] ;
// memset(double_test_array,0.0,thread_num);
// child_thread_param *ctp ;
// ctp->child_sp = sp ;
// ctp->value = double_test_array;
for(int i = 0 ;i < thread_num ;i++) //the child thread
{
res = pthread_create(&tid[i],NULL,thread_function,sp);
if (res != 0)
{
fprintf(stderr,"pthread was create error \n");
exit(EXIT_FAILURE);
}
}
for(int i = 0 ;i < thread_num ;i++) //joinable thread
{
res = pthread_join(tid[i],NULL);
if(res != 0)
{
fprintf(stderr,"thread join failed \n");
exit(EXIT_FAILURE);
}
}
release(sp);
free(mtp);
return 0;
}
// Get a token.
tok_types get_token()
{
char *temp;
token_type = UNDEFTT; tok = UNDEFTOK;
temp = token;
*temp = '\0';
// Skip over white space.
while (isspace(*prog) && *prog) ++prog;
// Skip over newline.
while (*prog == '\r') {
++prog;
++prog;
// Again, skip over white space.
while (isspace(*prog) && *prog) ++prog;
}
// Check for end of program.
if (*prog == '\0') {
*token = '\0';
tok = END;
return (token_type = DELIMITER);
}
// Check for block delimiters.
if (strchr("{}", *prog)) {
*temp = *prog;
temp++;
*temp = '\0';
prog++;
return (token_type = BLOCK);
}
// Look for comments.
if (*prog == '/')
if (*(prog + 1) == '*') { // is a /* comment
prog += 2;
do { // find end of comment
while (*prog != '*') prog++;
prog++;
} while (*prog != '/');
prog++;
return (token_type = DELIMITER);
}
else if (*(prog + 1) == '/') { // is a // comment
prog += 2;
// Find end of comment.
while (*prog != '\r' && *prog != '\0') prog++;
if (*prog == '\r') prog += 2;
return (token_type = DELIMITER);
}
// Check for double-ops.
if (strchr("!<>=+-", *prog)) {
switch (*prog) {
case '=':
if (*(prog + 1) == '=') {
prog++; prog++;
*temp = EQ;
temp++; *temp = EQ; temp++;
*temp = '\0';
}
break;
case '!':
if (*(prog + 1) == '=') {
prog++; prog++;
*temp = NE;
temp++; *temp = NE; temp++;
*temp = '\0';
}
break;
case '<':
if (*(prog + 1) == '=') {
prog++; prog++;
*temp = LE; temp++; *temp = LE;
}
else if (*(prog + 1) == '<') {
prog++; prog++;
*temp = LS; temp++; *temp = LS;
}
else {
prog++;
*temp = LT;
}
temp++;
*temp = '\0';
break;
case '>':
if (*(prog + 1) == '=') {
prog++; prog++;
*temp = GE; temp++; *temp = GE;
}
else if (*(prog + 1) == '>') {
prog++; prog++;
*temp = RS; temp++; *temp = RS;
}
else {
prog++;
*temp = GT;
}
temp++;
*temp = '\0';
break;
case '+':
if (*(prog + 1) == '+') {
prog++; prog++;
*temp = INC; temp++; *temp = INC;
temp++;
*temp = '\0';
}
break;
case '-':
if (*(prog + 1) == '-') {
prog++; prog++;
*temp = DEC; temp++; *temp = DEC;
temp++;
*temp = '\0';
}
break;
}
if (*token) return(token_type = DELIMITER);
}
// Check for other delimiters.
if (strchr("+-*^/%=;:(),'", *prog)) {
*temp = *prog;
prog++;
temp++;
*temp = '\0';
return (token_type = DELIMITER);
}
// Read a quoted string.
if (*prog == '"') {
prog++;
while (*prog != '"' && *prog != '\r' && *prog) {
// Check for \n escape sequence.
if (*prog == '\\') {
if (*(prog + 1) == 'n') {
prog++;
*temp++ = '\n';
}
}
else if ((temp - token) < MAX_T_LEN)
*temp++ = *prog;
prog++;
}
if (*prog == '\r' || *prog == 0)
throw InterpExc(SYNTAX);
prog++; *temp = '\0';
return (token_type = STRING);
}
// Read an integer number.
if (isdigit(*prog)) {
while (!isdelim(*prog)) {
if ((temp - token) < MAX_ID_LEN)
*temp++ = *prog;
prog++;
}
*temp = '\0';
return (token_type = NUMBER);
}
// Read identifier or keyword.
if (isalpha(*prog)) {
while (!isdelim(*prog)) {
if ((temp - token) < MAX_ID_LEN)
*temp++ = *prog;
prog++;
}
token_type = TEMP;
}
*temp = '\0';
// Determine if token is a keyword or identifier.
if (token_type == TEMP) {
tok = look_up(token); // convert to internal form
if (tok) token_type = KEYWORD; // is a keyword
else token_type = IDENTIFIER;
}
// Check for unidentified character in file.
if (token_type == UNDEFTT)
throw InterpExc(SYNTAX);
return token_type;
}
/* Get a token. */
char get_token(void)
{
register char *temp;
token_type = 0; tok = 0;
temp = token;
*temp = '\0';
/* skip over white space */
while (iswhite(*prog) && *prog) ++prog;
/* Handle Windows and Mac newlines */
if (*prog == '\r') {
++prog;
/* Only skip \n if it exists (if it doesn't, we are running on mac) */
if (*prog == '\n') {
++prog;
}
/* skip over white space */
while (iswhite(*prog) && *prog) ++prog;
}
/* Handle Unix newlines */
if (*prog == '\n') {
++prog;
/* skip over white space */
while (iswhite(*prog) && *prog) ++prog;
}
if (*prog == '\0') { /* end of file */
*token = '\0';
tok = FINISHED;
return (token_type = DELIMITER);
}
if (strchr("{}", *prog)) { /* block delimiters */
*temp = *prog;
temp++;
*temp = '\0';
prog++;
return (token_type = BLOCK);
}
/* look for comments */
if (*prog == '/')
if (*(prog + 1) == '*') { /* is a comment */
prog += 2;
do { /* find end of comment */
while (*prog != '*' && *prog != '\0') prog++;
if (*prog == '\0') {
prog--;
break;
}
prog++;
} while (*prog != '/');
prog++;
}
/* look for C++ style comments */
if (*prog == '/')
if (*(prog + 1) == '/') { /* is a comment */
prog += 2;
/* find end of line */
while (*prog != '\r' && *prog != '\n' && *prog != '\0') prog++;
if (*prog == '\r' && *(prog + 1) == '\n') {
prog++;
}
}
/* look for the end of file after a comment */
if (*prog == '\0') { /* end of file */
*token = '\0';
tok = FINISHED;
return (token_type = DELIMITER);
}
if (strchr("!<>=", *prog)) { /* is or might be
a relational operator */
switch (*prog) {
case '=': if (*(prog + 1) == '=') {
prog++; prog++;
*temp = EQ;
temp++; *temp = EQ; temp++;
*temp = '\0';
}
break;
case '!': if (*(prog + 1) == '=') {
prog++; prog++;
*temp = NE;
temp++; *temp = NE; temp++;
*temp = '\0';
}
break;
case '<': if (*(prog + 1) == '=') {
prog++; prog++;
*temp = LE; temp++; *temp = LE;
}
else {
prog++;
*temp = LT;
}
temp++;
*temp = '\0';
break;
case '>': if (*(prog + 1) == '=') {
prog++; prog++;
*temp = GE; temp++; *temp = GE;
}
else {
prog++;
*temp = GT;
}
temp++;
*temp = '\0';
break;
}
if (*token) return(token_type = DELIMITER);
}
if (strchr("+-*^/%=;(),'", *prog)) { /* delimiter */
*temp = *prog;
prog++; /* advance to next position */
temp++;
*temp = '\0';
return (token_type = DELIMITER);
}
if (*prog == '"') { /* quoted string */
prog++;
while ((*prog != '"' && *prog != '\r' && *prog != '\n' && *prog != '\0') || (*prog == '"' && *(prog - 1) == '\\')) *temp++ = *prog++;
if (*prog == '\r' || *prog == '\n' || *prog == '\0') sntx_err(SYNTAX);
prog++; *temp = '\0';
str_replace(token, "\\a", "\a");
str_replace(token, "\\b", "\b");
str_replace(token, "\\f", "\f");
str_replace(token, "\\n", "\n");
str_replace(token, "\\r", "\r");
str_replace(token, "\\t", "\t");
str_replace(token, "\\v", "\v");
str_replace(token, "\\\\", "\\");
str_replace(token, "\\\'", "\'");
str_replace(token, "\\\"", "\"");
return (token_type = STRING);
}
if (isdigit((int)*prog)) { /* number */
while (!isdelim(*prog)) *temp++ = *prog++;
*temp = '\0';
return (token_type = NUMBER);
}
if (isalpha((int)*prog)) { /* var or command */
while (!isdelim(*prog)) *temp++ = *prog++;
token_type = TEMP;
}
*temp = '\0';
/* see if a string is a command or a variable */
if (token_type == TEMP) {
tok = look_up(token); /* convert to internal rep */
if (tok) token_type = KEYWORD; /* is a keyword */
else token_type = IDENTIFIER;
}
return token_type;
}
/* Get a bas_token. */
int get_token(){
char *temp;
bas_token_type=0; bas_tok=0;
temp=bas_token;
// printf( "gettoken: <%c>\n", *prog );
if(*prog=='\0') { /* end of file */
*bas_token=0;
bas_tok = FINISHED;
return(bas_token_type=DELIMITER);
}
while(iswhite(*prog)) ++prog; /* skip over white space */
/*
if(*prog=='\r') { /
++prog; ++prog;
bas_tok = EOL; *bas_token='\r';
bas_token[1]='\n'; bas_token[2]=0;
return (bas_token_type = DELIMITER);
}
*/
if(*prog=='\n') { // lf
++prog;
//currentline++; // just for debug
bas_tok = EOL; *bas_token='\n';
bas_token[1]=0;
// printf("...EOL found ...%s" , "");
return (bas_token_type = DELIMITER);
}
if(*prog=='#') { /* lf */
++prog;
bas_tok = COMMENT; *bas_token='#';
bas_token[1]=0;
return (bas_token_type = DELIMITER);
}
if(strchr("!+-*^/%=;(),><&|", *prog)){ /* delimiter */
*temp=*prog;
//if there is NOT double delimiter
if(strchr("+-*^/%;(),", *prog)){ /* delimiter */
// if (strchr("(", *prog)){ printf("delim found %c \n", *prog); }
// if (strchr(")", *prog)){ printf("delim found %c \n", *prog); }
prog++; /* advance to next position */
temp++;
*temp=0;
return (bas_token_type=DELIMITER);
}// was single delimiter
/* DOUBLE DELIMITERS WILL BE SINGLFIED.......HERE
*
*/
// printf("case of dd may come <%c> <%c>\n", *prog, prog[1] );
if((strchr("=", *prog))&&(strchr("=",prog[1]) )){ /* double delimiter == is ~ */
bas_token[0]='~'; bas_token[1]='\0';
prog++; /* advance to next position */
temp++;
prog++; /* advance to next position */
temp++;
*temp=0;
return (bas_token_type=DELIMITER);
}
if((strchr("!", *prog))&&(strchr("=",prog[1]) )){ /* double delimiter != is ! */
bas_token[0]='!'; bas_token[1]='\0';
prog++; /* advance to next position */
temp++;
prog++; /* advance to next position */
temp++;
*temp=0;
return (bas_token_type=DELIMITER);
}
if((strchr("&", *prog))&&(strchr("&",prog[1]) )){ /* double delimiter && is @ */
bas_token[0]='@'; bas_token[1]='\0';
prog++; /* advance to next position */
temp++;
prog++; /* advance to next position */
temp++;
*temp=0;
return (bas_token_type=DELIMITER);
}
if((strchr("|", *prog))&&(strchr("|",prog[1]) )){ /* double delimiter || is $*/
bas_token[0]='$'; bas_token[1]='\0';
prog++; /* advance to next position */
temp++;
prog++; /* advance to next position */
temp++;
*temp=0;
return (bas_token_type=DELIMITER);
}
if((strchr(">", *prog))&&(strchr("=",prog[1]) )){ /* double delimiter >= is :*/
bas_token[0]=':'; bas_token[1]='\0';
prog++; /* advance to next position */
temp++;
prog++; /* advance to next position */
temp++;
*temp=0;
return (bas_token_type=DELIMITER);
}
if((strchr("<", *prog))&&(strchr("=",prog[1]) )){ /* double delimiter <= is _ */
bas_token[0]='_'; bas_token[1]='\0';
prog++; /* advance to next position */
temp++;
prog++; /* advance to next position */
temp++;
*temp=0;
return (bas_token_type=DELIMITER);
}
prog++; /* advance to next position */
temp++;
*temp=0;
return (bas_token_type=DELIMITER);
}// DELIMITERS - DOUBLE DELIMITERS-------------------END-----DOUBLE
/* 20100419 - now | and & are unabiguous
*
*/
//if there is NOT double delimiter
if(strchr("|&", *prog)){ /* delimiter */
// if (strchr("(", *prog)){ printf("delim found %c \n", *prog); }
// if (strchr(")", *prog)){ printf("delim found %c \n", *prog); }
prog++; /* advance to next position */
temp++;
*temp=0;
return (bas_token_type=DELIMITER);
}// was single delimiter
if(*prog=='"') { /* quoted string */
prog++;
while(*prog!='"'&& *prog!='\n') *temp++=*prog++;
if(*prog=='\n') serror(1);
prog++;*temp=0;
return(bas_token_type=QUOTE);
}
if(isdigit(*prog)) { /* number */
while(!isdelim(*prog)) *temp++=*prog++;
*temp = '\0';
// printf("temp=%s\n", bas_token);
return(bas_token_type = NUMBER);
}
if(isalpha(*prog)) { /* var or command */
while(!isdelim(*prog)) *temp++=*prog++;
bas_token_type=STRING;
}
*temp = '\0';
/* see if a string is a command or a variable */
if(bas_token_type==STRING) {
bas_tok=look_up(bas_token); /* convert to internal rep */
if(!bas_tok) bas_token_type = VARIABLE;
else bas_token_type = COMMAND; /* is a command */
}
return bas_token_type;
}//------------------------get_token
const char* isis::sys::to_string(Directory e)
{
return look_up(directory_to_string, e);
}
}
static int
mach_init(const char *service, void **ctx)
{
struct mach_ctx *ipc;
mach_port_t sport;
int ret;
dispatch_once(&jobqinited, ^{
jobq = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
syncq = dispatch_queue_create("heim-ipc-syncq", NULL);
});
ret = look_up(service, &sport);
if (ret)
return ret;
ipc = malloc(sizeof(*ipc));
if (ipc == NULL) {
mach_port_destroy(mach_task_self(), sport);
return ENOMEM;
}
ipc->server = sport;
ipc->name = strdup(service);
if (ipc->name == NULL) {
mach_release(ipc);
return ENOMEM;
}
/* Get a token. */
get_token(void)
{
register char *temp;
token_type = 0; tok = 0;
temp = token;
*temp = '\0';
/* skip over white space */
while(iswhite(*prog) && *prog) ++prog;
if(*prog==0x0a) {
++prog;
// ++prog;
/* skip over white space */
while(iswhite(*prog) && *prog) ++prog;
}
if(*prog=='\0') { /* end of file */
*token = '\0';
tok = FINISHED;
return(token_type=DELIMITER);
}
if(strchr("{}", *prog)) { /* block delimiters */
*temp = *prog;
temp++;
*temp = '\0';
prog++;
return (token_type = BLOCK);
}
/* look for comments */
if(*prog=='/')
if(*(prog+1)=='*') { /* is a comment */
prog += 2;
do { /* find end of comment */
while(*prog!='*') prog++;
prog++;
} while (*prog!='/');
prog++;
}
if(strchr("!<>=", *prog)) { /* is or might be
a relation operator */
switch(*prog) {
case '=': if(*(prog+1)=='=') {
prog++; prog++;
*temp = EQ;
temp++; *temp = EQ; temp++;
*temp = '\0';
}
break;
case '!': if(*(prog+1)=='=') {
prog++; prog++;
*temp = NE;
temp++; *temp = NE; temp++;
*temp = '\0';
}
break;
case '<': if(*(prog+1)=='=') {
prog++; prog++;
*temp = LE; temp++; *temp = LE;
}
else {
prog++;
*temp = LT;
}
temp++;
*temp = '\0';
break;
case '>': if(*(prog+1)=='=') {
prog++; prog++;
*temp = GE; temp++; *temp = GE;
}
else {
prog++;
*temp = GT;
}
temp++;
*temp = '\0';
break;
}
if(*token) return(token_type = DELIMITER);
}
if(strchr("+-*^/%=;(),'", *prog)){ /* delimiter */
*temp = *prog;
prog++; /* advance to next position */
temp++;
*temp = '\0';
return (token_type=DELIMITER);
}
if(*prog=='"') { /* quoted string */
prog++;
while(*prog!='"'&& *prog!=0x0a) *temp++ = *prog++;
if(*prog==0x0a) sntx_err(SYNTAX);
prog++; *temp = '\0';
return(token_type=STRING);
}
if(isdigit(*prog)) { /* number */
while(!isdelim(*prog)) *temp++ = *prog++;
*temp = '\0';
return(token_type = NUMBER);
}
if(isalpha(*prog)) { /* var or command */
while(!isdelim(*prog)) *temp++ = *prog++;
token_type=TEMP;
}
*temp = '\0';
/* see if a string is a command or a variable */
if(token_type==TEMP) {
tok = look_up(token); /* convert to internal rep */
if(tok) token_type = KEYWORD; /* is a keyword */
else token_type = IDENTIFIER;
}
return token_type;
}
/**
* @brief Changes the vertical angle to look downwards.
* @param angle the angle change in radians
*/
void camera::look_down(double angle) {
look_up(-angle);
}
int get_token()
{
char *temp;
token_type = 0;
tok = 0;
temp = token;
*temp = '\0';
while(iswhite(*prog) && *prog)
++prog;
if(*prog=='\n') {
++prog;
while(iswhite(*prog) && *prog)
++prog;
}
if(*prog=='\0') {
*token = '\0';
tok = FINISHED;
return(token_type=DELIMITER);
}
if(strchr1("{}", *prog)) {
*temp = *prog;
temp++;
*temp = '\0';
prog++;
return (token_type = BLOCK);
}
if(*prog=='/') {
if(*(prog+1)=='*') {
prog += 2;
do {
while(*prog!='*')
prog++;
prog++;
} while (*prog!='/');
prog++;
}
}
if(strchr1("!<>=", *prog)) {
switch(*prog) {
case '=':
if(*(prog+1)=='=') {
prog++; prog++;
*temp = EQ;
temp++; *temp = EQ; temp++;
*temp = '\0';
}
break;
case '!':
if(*(prog+1)=='=') {
prog++; prog++;
*temp = NE;
temp++; *temp = NE; temp++;
*temp = '\0';
}
break;
case '<':
if(*(prog+1)=='=') {
prog++; prog++;
*temp = LE; temp++; *temp = LE;
} else {
prog++;
*temp = LT;
}
temp++;
*temp = '\0';
break;
case '>':
if(*(prog+1)=='=') {
prog++; prog++;
*temp = GE; temp++; *temp = GE;
} else {
prog++;
*temp = GT;
}
temp++;
*temp = '\0';
break;
}
if(*token)
return(token_type = DELIMITER);
}
if(strchr1("+-*^&|/%=;(),'", *prog)){
*temp = *prog;
prog++;
temp++;
*temp = '\0';
return (token_type=DELIMITER);
}
if(*prog=='"') {
prog++;
while(*prog!='"'&& *prog!='\n')
*temp++ = *prog++;
if(*prog=='\n')
sntx_err(SYNTAX);
prog++; *temp = '\0';
return(token_type=STRING);
}
if(isdigit(*prog)) {
while(!isdelim(*prog))
*temp++ = *prog++;
*temp = '\0';
return(token_type = NUMBER);
}
if(isalph(*prog)) {
while(!isdelim(*prog))
*temp++ = *prog++;
token_type=TEMP;
}
*temp = '\0';
if(token_type==TEMP) {
tok = look_up(token);
if(tok)
token_type = KEYWORD;
else
token_type = IDENTIFIER;
}
return token_type;
}
/* Считывание лексемы из входного потока. */
int get_token(void) {
register char *temp;
token_type = 0;
tok = 0;
temp = token;
*temp = '\0';
/* пропуск пробелов, символов табуляции и пустой строки */
while(iswhite(*prog) && *prog) {
++prog;
}
while(*prog == '\r' || *prog == '\n') {
++prog;
// COMPILER_SPECIFIC
while(iswhite(*prog) && *prog) {
++prog;
}
}
/* конец файла */
if(*prog == '\0') {
*token = '\0';
tok = FINISHED;
return (token_type = DELIMITER);
}
/* блок кода */
if(strchr("{}", *prog)) { /* ограничение блока */
*temp = *prog;
temp++;
*temp = '\0';
prog++;
return (token_type = BLOCK);
}
/* массив */
if(strchr("[]", *prog)) {
*temp = *prog;
temp++;
*temp = '\0';
prog++;
return (token_type = ARRAY);
}
/* комментарий */
if(*prog == '/') {
if(*(prog+1) == '*') {
prog += 2;
do {
while(*prog != '*') {
prog++;
}
prog++;
} while(*prog != '/');
prog++;
}
}
/* оператор сравнения */
if(strchr("!<>=", *prog)) {
switch(*prog) {
case '=':
if(*(prog+1) == '=') { // ==
prog++;
prog++;
*temp = EQ;
temp++;
*temp = EQ;
temp++;
*temp = '\0';
}
break;
case '!':
if(*(prog+1) == '=') { // !=
prog++;
prog++;
*temp = NE;
temp++;
*temp = NE;
temp++;
*temp = '\0';
}
break;
case '<':
if(*(prog+1) == '=') { // <=
prog++;
prog++;
*temp = LE;
temp++;
*temp = LE;
} else { // <
prog++;
*temp = LT;
}
temp++;
*temp = '\0';
break;
case '>':
if(*(prog+1) == '=') { // >=
prog++;
prog++;
*temp = GE;
temp++;
*temp = GE;
} else { // >
prog++;
*temp = GT;
}
temp++;
*temp = '\0';
break;
}
if(*token) {
return(token_type = DELIMITER);
}
}
/* разделитель */
if(strchr("+-*^/%=;(),'", *prog)) {
*temp = *prog;
prog++; /* продвижение на следующую позицию */
temp++;
*temp = '\0';
return (token_type = DELIMITER);
}
/* строка в кавычках */
if(*prog=='"') {
prog++;
while(*prog != '"' && *prog != '\r') {
*temp++ = *prog++;
}
if(*prog == '\r') {
sntx_err(SYNTAX);
}
prog++;
*temp = '\0';
return (token_type = STRING);
}
/* число */
if(isdigit(*prog)) {
while(!isdelim(*prog)) {
*temp++ = *prog++;
}
*temp = '\0';
return (token_type = NUMBER);
}
/* переменная или оператор */
if(isalpha(*prog)) {
while(!isdelim(*prog)) {
*temp++ = *prog++;
}
token_type = TEMP;
}
*temp = '\0';
/* ключевое слово или имя */
if(token_type==TEMP) {
tok = look_up(token); /* преобразовать во внутренее представление */
if(tok) {
token_type = KEYWORD; /* это зарезервированное слово */
} else {
token_type = IDENTIFIER;
}
}
return token_type;
}
