lexer.c

h261协议的h261编码码,lib_261.h里面提供了详细的接口和说明.

//	}
//	if (!(temp->lid = MakeStructure(ID)))
//	{
//		printf("Cannot make an id.\n");
//		exit(ERROR_MEMORY);
//	}
//	temp->next = NULL;
//	if (!(temp->lid->name =(char *)calloc(len+1,sizeof(char))))
//	{
//		printf("Cannot make a string space for the link.\n");
//		exit(ERROR_MEMORY);
//	}
//	strcpy(temp->lid->name,str);
//	temp->lid->tokentype = tokentype;
//	temp->lid->count = 1;
//	temp->lid->value = -1; /* Unreferenced yet. */
//	return(temp);
//}

/*BFUNC

enter() is used to enter a Reserved Word or ID into the hash table.

EFUNC*/

//static ID *enter(tokentype,str,len)
//     tokentype;
//     str;
//     len;
//static ID *enter(int tokentype,char *str,int len)
//{
//  BEGIN("enter");
//  int hashnum;
//  LINK *temp,*current;
//  char *ptr;
//
//  for(ptr=str;*ptr!='\0';ptr++)
//    {
//      if ((*ptr>='a') && (*ptr<='z'))
//	{
//	  *ptr = *ptr - ('a'-'A');
//	}
//    }
//  hashnum = hashpjw(str);  /* Check if in hash table */
//  for(temp=NULL,current=HashTable[hashnum];
//      current!= NULL;
//      current=current->next)
//    {
//      if (strcmp(str,current->lid->name) == 0)
//	{
//	  temp=current;
//	  break;
//	}
//    }
//  if (temp)   /* Yes, found ID then return */
//    {
//      temp->lid->count++;
//      return(temp->lid);
//    }
//  else        /* Else make our own ID and return that*/
//    {
//      temp = MakeLink(tokentype,str,len);
//      InsertLink(temp,HashTable[hashnum]);
//      return(temp->lid);
//    }
//}

//equname(number,name)
//     int number;
//     char *name;
//void equname(int number,char *name)
//{
//  ID *temp;
//  temp = enter(0,name,strlen(name));
//  temp->value=number;
//}


/*BFUNC

getstr() gets a string from the input. It copies the string to
temporary storage before it returns the pointer.

EFUNC*/

//static char *getstr()
//{
//  BEGIN("getstr");
//  char *tmp,*ptr,*bptr;
//  int i,accum,flag;
//  if (mylex() != R_STRING)
//    {
//      printf("String expected.\n");
//      if (!(tmp=(char *) malloc(sizeof(char))))
//	  //if (!(tmp=(char *) calloc(sizeof(char))))
//	  {
//		  WHEREAMI();
//		  printf("Cannot allocate for null string.\n");
//		  exit(ERROR_MEMORY);
//	  }
//      *tmp='\0';
//      return(tmp);
//    }
//  if (!(tmp=(char *)calloc(strlen(yytext)+1,sizeof(char))))
//    {
//      WHEREAMI();
//      printf("Cannot allocate %d string space.\n",yyleng);
//      exit(ERROR_MEMORY);
//    }
//  for(bptr=yytext+1,ptr=tmp;*bptr!='"';bptr++,ptr++)
//    {
//      if (*bptr=='\\')
//	{
//	  bptr++;
//	  for(flag=0,accum=0,i=0;i<3;i++)  /* Octal character lookahead */
//	    {
//	      if ((*bptr>='0')&&(*bptr<='7'))
//		{
//		  accum = (accum<<3)+(*bptr-'0');
//		  bptr++;
//		  flag=1;
//		}
//	      else {break;}
//	    }
//	  if (flag) {bptr--;*ptr=accum;}
//	  else
//	    {
//	      switch(*(bptr))
//		{
//		case '0':
//		  *ptr = 0;
//		  break;
//		case 'b':
//		  *ptr = 0x8;
//		  break;
//		case 'i':
//		  *ptr = 0x9;
//		  break;
//		case 'n':
//		  *ptr = 0xa;
//		  break;
//		case 'v':
//		  *ptr = 0xb;
//		  break;
//		case 'f':
//		  *ptr = 0xc;
//		  break;
//		case 'r':
//		  *ptr = 0xd;
//		  break;
//		default:
//		  *ptr=(*bptr);
//		}
//	    }
//	}
//      else {*ptr = (*bptr);}
//    }
//  *ptr='\0';
//  return(tmp);
//}

/*BFUNC

parser() handles all of the parsing required for the Program
Interpreter.  It is basically a {\tt while} statement with a very
large case statement for every input.  All unmatched values-- strings,
brackets, etc. are ignored.

EFUNC*/

//#define ARRAYBEGIN if (ntoken==R_LBRACKET)\
//	    {\
//	      arrayflag=1;\
//	      ntoken=mylex();\
//	    }\
//	  if (ntoken!=R_INTEGER)\
//	    {\
//	      WHEREAMI();\
//	      printf("Expected integer.\n");\
//	      break;\
//	    }\
//	  while(1)\
//	    {

//#define ARRAYEND  if (arrayflag)\
//		{\
//		  if ((ntoken=mylex())==R_RBRACKET) break;\
//		  else if (ntoken!=R_INTEGER)\
//		    {\
//		      WHEREAMI();\
//		      printf("Expected integer or right bracket.\n");\
//		      break;\
//		    }\
//		}\
//	      else break;\
//	      }

#define BINARYOP(operation)  if (DataLevel<2)\
	    {\
	      printf("Not enough operands on stack.\n");\
	      break;\
	    }\
	  accum = *(--DataPtr);\
	  *(--DataPtr) operation accum;\
	  DataPtr++;\
	  DataLevel--;

#define RELOP(operation)  if (DataLevel<2)\
	    {\
	      printf("Not enough operands on stack.\n");\
	      break;\
	    }\
	  accum = *(--DataPtr); DataPtr--;\
	  if (*(DataPtr) operation (accum)) *(DataPtr++) = 1.0;\
          else *(DataPtr++) = 0.0;\
	  DataLevel--;

#define openprogram(value)\
  PProgram=(value);\
  PLStack = ProgramLocalStack[(value)];\
  PCStack = ProgramCommandStack[(value)];\
  PLLevel = ProgramLocalLevel[(value)];\
  PLevel = ProgramLevel[(value)];


#define pushprogram(program,line)\
  SourceProgramStack[SourceLevel] = CurrentProgram;\
  SourceLineStack[SourceLevel] = CurrentLine;\
  SourceLevel++;\
  CurrentProgram = program;\
  CurrentLine = line;\
  CommandStack = ProgramCommandStack[CurrentProgram];\
  LocalStack = ProgramLocalStack[CurrentProgram];\
  LocalLevel = ProgramLocalLevel[CurrentProgram];\
  CommandLevel = ProgramLevel[CurrentProgram];

#define popprogram()\
  SourceLevel--;\
  CurrentProgram = SourceProgramStack[SourceLevel];\
  CurrentLine = SourceLineStack[SourceLevel];\
  CommandStack = ProgramCommandStack[CurrentProgram];\
  LocalStack = ProgramLocalStack[CurrentProgram];\
  LocalLevel = ProgramLocalLevel[CurrentProgram];\
  CommandLevel = ProgramLevel[CurrentProgram];


//#define GETINTEGER(retval)  (retval)=mylex();\
//  if ((retval)!=R_INTEGER)\
//    {WHEREAMI();\
//     printf("Integer expected.\n");\
//     break;}


//void parser()
//{
//  BEGIN("parser");
//  int i,dest,value,token,ntoken,arrayflag;
//  double accum;
//  int hold;
//  char *sptr;
//
//  while(token=mylex())
//    {
//      arrayflag=0;
//      switch(token)
// 	{
//	case R_INTEGER:
// 	  pushdata((double) yyint);
// 	  break;
// 	case R_REAL:
// 	  pushdata(atof(yytext));
// 	  break;
//
// 	case R_ADD:
// 	  BINARYOP(+=); 
//	  break;
// 	case R_SUB:
// 	  BINARYOP(-=);
// 	  break;
//	case R_MUL:
// 	  BINARYOP(*=);
// 	  break;
// 	case R_DIV:
// 	  BINARYOP(/=);
// 	  break;
// 	case R_NOT:
//	  accum = *(--DataPtr);
// 	  *(DataPtr++) = (accum ? 0.0 : 1.0);
// 	  break;
// 	case R_AND:
// 	  RELOP(&&);
// 	  break;
// 	case R_OR:
// 	  RELOP(||);
// 	  break;
// 	case R_XOR:
//	  if (DataLevel<2)
//	    {
//	      printf("Not enough operands on stack.\n");
//	      break;
//	    }
//	  accum = *(--DataPtr); DataPtr--;
//	  if ((*(DataPtr) && !(accum))||
//	      (!(*(DataPtr)) && (accum))) *(DataPtr++) = 1.0;
//          else *(DataPtr++) = 0.0;
//	  DataLevel--;
// 	  break;
// 	case R_LT:
//	  RELOP(<);
// 	  break;
// 	case R_LTE:
// 	  RELOP(<=);
// 	  break; 
//	case R_EQ:
// 	  RELOP(==);
// 	  break;
// 	case R_GT:
// 	  RELOP(>);
// 	  break;
// 	case R_GTE:
// 	  RELOP(>=);
// 	  break;
//
// 	case R_NEG:
// 	  accum = *(--DataPtr);
// 	  *(DataPtr++) = -(accum); 
//	  break;
// 	case R_SQRT:
// 	  accum = *(--DataPtr);
//	  *(DataPtr++) = sqrt(accum);
// 	  break;
// 	case R_ABS:
// 	  accum = *(--DataPtr);
//	  *(DataPtr++) = fabs(accum);
// 	  break;
// 	case R_FLOOR:
// 	  accum = *(--DataPtr);
//	  *(DataPtr++) = floor(accum);
// 	  break;
// 	case R_CEIL:
// 	  accum = *(--DataPtr);
//	  *(DataPtr++) = ceil(accum);
// 	  break;
// 	case R_ROUND:
// 	  accum = *(--DataPtr);
//	  *(DataPtr++) = ((accum<0)?ceil(accum-0.5):floor(accum+0.5));
// 	  break;
//
//	case R_DUP:
// 	  *(DataPtr++) = DataPtr[-1];
// 	  DataLevel++;
// 	  break;
// 	case R_POP: 
//	  if (DataLevel)
// 	    {
// 	      DataLevel--;
// 	      DataPtr--;
// 	    }
// 	  else 	{printf("Not enough stack elements.\n");}
// 	  break;
// 	case R_EXCH:
// 	  *DataPtr = DataPtr[-1];
// 	  DataPtr[-1] = DataPtr[-2];
// 	  DataPtr[-2] = *DataPtr;
// 	  break;
// 	case R_COPY:
//	  GETINTEGER(ntoken);
// 	  if (DataLevel<yyint)
// 	    {
// 	      WHEREAMI();
// 	      printf("Not enough elements\n");
// 	      break;
// 	    }
// 	  for(i=0;i<yyint;i++)
// 	    {
// 	      *(DataPtr) = DataPtr[-yyint];
// 	      DataPtr++;
// 	      DataLevel++;
// 	    }
// 	  break;
// 	case R_ROLL:
//	  GETINTEGER(ntoken);
//	  dest=yyint;
// 	  GETINTEGER(ntoken);
//	  value=yyint;
//	  value = value % dest;
// 	  if (value<0) {value+= dest;}
// 	  for(i=0;i<value;i++)
//	    {DataPtr[i] = DataPtr[i-value];}
// 	  for(i=0;i<dest-value;i++)
// 	    {DataPtr[-i-1] = DataPtr[-value-i-1];}
// 	  for(i=0;i<value;i++)
// 	    {DataPtr[i-dest] = DataPtr[i];}
// 	  break;
// 	case R_INDEX:
//	  GETINTEGER(ntoken);
//	  if (yyint > DataLevel)
// 	    {
//	      WHEREAMI();
// 	      printf("Index out of bounds\n");
// 	      break;
// 	    }
// 	  *DataPtr = DataPtr[-yyint];
// 	  DataPtr++;
// 	  DataLevel++;
// 	  break;
// 	case R_CLEAR:
// 	  DataLevel=0; 
//	  DataPtr=DataStack;
// 	  break;
//
// 	case R_STO:
// 	  if (!DataLevel)
// 	    {
// 	      printf("Not enough stack elements.\n");
// 	    }
// 	  ntoken = mylex();
// 	  if ((ntoken!=R_ID)&&(ntoken!=R_INTEGER))
// 	    { 	 
//	      printf("Integer or label expected.\n");
// 	      break;
// 	    }
// 	  Memory[yyint]= *(--DataPtr);
// 	  DataLevel--;
//	  break;
// 	case R_RCL:
// 	  ntoken = mylex();
// 	  if ((ntoken!=R_ID)&&(ntoken!=R_INTEGER))
// 	    {
//	      printf("Integer or label expected.\n");
// 	      break;
// 	    }
// 	  pushdata(Memory[yyint]);
// 	  break;
//
//	case R_GOTO:
//	case R_IFG:
//	case R_IFNG:
//	case R_EXIT:
//	  WHEREAMI();
//	  printf("Program commands not available on top-level.\n");
//	  break;
//
// 	case R_EXE:
// 	  ntoken = mylex();
// 	  if ((ntoken!=R_ID)&&(ntoken!=R_INTEGER))
//	    { 
//	      printf("Integer or label expected.\n");
//	      break;
//	    }
//	  pushprogram(yyint,0);
//	  break;
//	case R_ABORT:
//	  GETINTEGER(ntoken);
//	  exit(yyint);
//	  break;
//
// 	case R_PRINTSTACK:
// 	  for(i=0;i<DataLevel;i++)
// 	    {
// 	      printf("%d: %f\n",i,DataStack[i]);
// 	    }
// 	  break;
// 	case R_PRINTPROGRAM:
// 	  ntoken = mylex();
// 	  if ((ntoken!=R_ID)&&(ntoken!=R_INTEGER))
// 	    {
// 	      printf("Integer or label expected.\n");
// 	      break;
//	    }
// 	  openprogram(yyint);
// 	  PrintProgram();
// 	  break;
//	case R_PRINTIMAGE:
//	  PrintImage();
//	  break;
//	case R_PRINTFRAME:
//	  PrintFrame();
//	  break;
//
//	case R_ECHO:
//	  printf("%s\n",getstr());
//	  break;
// 	case R_OPEN:
// 	  ntoken = mylex();
// 	  if ((ntoken!=R_ID)&&(ntoken!=R_INTEGER))
// 	    {
// 	      printf("Integer or label expected.\n");
// 	      break;
// 	    }
// 	  hold = yyint;
//	  openprogram(hold);
// 	  PLevel=0;
// 	  MakeProgram();
// 	  CompileProgram();
// 	  ProgramLevel[hold]=PLevel;
// 	  ProgramLocalLevel[hold]=PLLevel;
//	  break;
//	case R_CLOSE:
//	  WHEREAMI();
//	  printf("Close not available on top level.\n");
//	  break;
//
// 	case R_EQU: 
//	  if (!DataLevel)
// 	    {
// 	      printf("Not enough stack elements.\n");
// 	    }
// 	  ntoken = mylex();
// 	  if ((ntoken!=R_ID))
// 	    {
// 	      printf("Label expected.\n"); 
//	      break; 
//	    }
// 	  Cid->value = (int) *(--DataPtr);
// 	  DataLevel--;
// 	  break;
//	case R_VAL:
//	  WHEREAMI();
//	  printf("VAL is not a valid id on top level.\n");
//	  break;
//
//	case R_STREAMNAME:
//	  CImage->StreamFileName=getstr();
//	  break;
//	case R_COMPONENT:
//	  ntoken=mylex();
//	  ARRAYBEGIN;
//	  dest = yyint;
//	  ntoken=mylex();
//	  if (ntoken!=R_LBRACKET)
//	    {
//	      WHEREAMI();
//	      printf("Left bracket expected.\n");
//	      break;
//	    }
//	  sptr=getstr();
//	  strcpy(CFrame->ComponentFilePrefix[dest],sptr);
//	  sptr=getstr();
//	  strcpy(CFrame->ComponentFileSuffix[dest],sptr);
//	  ntoken=mylex();
//	  if (ntoken!=R_RBRACKET)
//	    {
//	      WHEREAMI();
//	      printf("Right bracket expected.\n");
//	      break;
//	    }
//	  ARRAYEND;
//	  break;
//	case R_FRAMERATE:
//	  GETINTEGER(ntoken);
//	  FrameRate = yyint;
//	  break;
//	case R_FRAMESKIP:
//	  GETINTEGER(ntoken);
//	  FrameSkip = yyint;
//	  break;
//	case R_QUANTIZATION:
//	  GETINTEGER(ntoken);
//	  InitialQuant = yyint;
//	  break;
//	case R_SEARCHLIMIT:
//	  GETINTEGER(ntoken);
//	  SearchLimit = yyint;
//	  BoundValue(SearchLimit,1,31,"SearchLimit");
//	  break;
//	case R_NTSC:
//	  ImageType=IT_NTSC;