C++ (Cpp) compileIndexesの例

コード例 #1

ファイル: parser.c プロジェクト: NPHiep/Compiler

Type* compileLValue(void) {
  // DONE: parse a lvalue (a variable, an array element, a parameter, the current function identifier)
  Object* var;
  Type* varType;

  eat(TK_IDENT);
  // check if the identifier is a function identifier, or a variable identifier, or a parameter  
  var = checkDeclaredLValueIdent(currentToken->string);
  switch (var->kind) {
  case OBJ_VARIABLE:
    if (var->varAttrs->type->typeClass == TP_ARRAY) {
      varType = compileIndexes(var->varAttrs->type);
    }
    else
      varType = var->varAttrs->type;
    break;
  case OBJ_PARAMETER:
    varType = var->paramAttrs->type;
    break;
  case OBJ_FUNCTION:
    varType = var->funcAttrs->returnType;
    break;
  default: 
    error(ERR_INVALID_LVALUE,currentToken->lineNo, currentToken->colNo);
  }
  return varType;
}

コード例 #2

ファイル: parser.c プロジェクト: kiendt07/ctd

Type* compileLValue(void) {
  Object* var;
  Type* varType;

  eat(TK_IDENT);
  
  var = checkDeclaredLValueIdent(currentToken->string);

  switch (var->kind) {
  case OBJ_VARIABLE:
    genVariableAddress(var);

    if (var->varAttrs->type->typeClass == TP_ARRAY) {
      varType = compileIndexes(var->varAttrs->type);
    }
    else
      varType = var->varAttrs->type;
    break;
  case OBJ_PARAMETER:
    // TODO: push parameter value onto stack if the parameter is a reference (defined with keyword VAR
    //       push parameter address onto stack if the parameter is a value
    varType = var->paramAttrs->type;
    break;
  case OBJ_FUNCTION:
    // TODO: push the return value address onto the stack
    varType = var->funcAttrs->returnType;
    break;
  default: 
    error(ERR_INVALID_LVALUE,currentToken->lineNo, currentToken->colNo);
  }

  return varType;
}

コード例 #3

ファイル: parser.c プロジェクト: BichVN/Compiler

Type* compileLValue(void) {
  Object* var;
  Type* varType;

  eat(TK_IDENT);
  
  var = checkDeclaredLValueIdent(currentToken->string);

  switch (var->kind) {
  case OBJ_VARIABLE:
    if (var->varAttrs->type->typeClass == TP_ARRAY) {
      varType = compileIndexes(var->varAttrs->type);
    }
    else
      varType = var->varAttrs->type;
    break;
  case OBJ_PARAMETER:
    varType = var->paramAttrs->type;
    break;
  case OBJ_FUNCTION:
    varType = var->funcAttrs->returnType;
    break;
  default: 
    error(ERR_INVALID_LVALUE,currentToken->lineNo, currentToken->colNo);
  }

  return varType;
}

コード例 #4

ファイル: parser.c プロジェクト: leaderwing/test_repo

Type* compileLValue(void) {
  Object* var;
  Type* varType;

  eat(TK_IDENT);
  
  var = checkDeclaredLValueIdent(currentToken->string);

  switch (var->kind) {
  case OBJ_VARIABLE:
    // TODO: push the variable address onto the stack
    genVariableAddress(var);
    if (var->varAttrs->type->typeClass == TP_ARRAY) {
      // compute the element address
      varType = compileIndexes(var->varAttrs->type);
    }
    else
      varType = var->varAttrs->type;
    break;
  case OBJ_PARAMETER:
    // TEMPORARY: halt the program
    genHL();
    varType = var->paramAttrs->type;
    break;
  case OBJ_FUNCTION:
    // TEMPORARY: halt the program
    genHL();
    varType = var->funcAttrs->returnType;
    break;
  default: 
    error(ERR_INVALID_LVALUE,currentToken->lineNo, currentToken->colNo);
  }

  return varType;
}

コード例 #5

ファイル: parser.c プロジェクト: BichVN/Compiler

void compileFactor(void) {
  // TODO
  switch (lookAhead->tokenType) {
  case TK_NUMBER:
    eat(TK_NUMBER);
    break;
  case TK_IDENT:
     eat(TK_IDENT);
    compileIndexes();
    compileArguments();
    break;
  case TK_STRING:
    eat(TK_STRING);
  break;
  case TK_CHAR:
    eat(TK_CHAR);
    break;
  case SB_LPAR:
    compileExpression();
    eat(SB_RPAR);
    break;
  default:
    error(ERR_INVALIDFACTOR, lookAhead->lineNo, lookAhead->colNo);
    break;
  }
}

コード例 #6

ファイル: parser.c プロジェクト: nguyentuananh1993/chuongTrinhDich

void compileFactor(void) {
  Object* obj;

  switch (lookAhead->tokenType) {
  case TK_NUMBER:
    eat(TK_NUMBER);
    break;
  case TK_CHAR:
    eat(TK_CHAR);
    break;
  case TK_IDENT:
    eat(TK_IDENT);
    // check if the identifier is declared
    obj = checkDeclaredIdent(currentToken->string);

    switch (obj->kind) {
    case OBJ_CONSTANT:
      break;
    case OBJ_VARIABLE:
      compileIndexes();
      break;
    case OBJ_PARAMETER:
      break;
    case OBJ_FUNCTION:
      compileArguments();
      break;
    default: 
      error(ERR_INVALID_FACTOR,currentToken->lineNo, currentToken->colNo);
      break;
    }
    break;
  default:
    error(ERR_INVALID_FACTOR, lookAhead->lineNo, lookAhead->colNo);
  }
}

コード例 #7

ファイル: parser.c プロジェクト: minh93/thctd

void compileFactor(void) {
  // TODO
  Token *tmp=lookAhead;
  //de chuyen tiep lookAhead o duoi
  switch(tmp->tokenType)
    {
    case TK_NUMBER:

    case TK_CHAR:
      compileUnsignedConstant();
      break;
    case SB_LPAR:
      eat(SB_LPAR);
      compileExpression();
      eat(SB_RPAR);
      break;
    case TK_IDENT:
      eat(TK_IDENT);
      if(lookAhead->tokenType==SB_LPAR)
	{
	  compileArguments();
	}
      else if(lookAhead->tokenType==SB_LSEL)
	{
	  compileIndexes();
	}
      //else
      //compileUnsignedConstant();      
      break;
    default:
      error(ERR_INVALIDFACTOR, lookAhead->lineNo, lookAhead->colNo);
      break;
    }
  //free(tmp);
}

コード例 #8

ファイル: parser.c プロジェクト: duc17224560/CTD-20152-Shukudai.

void compileFactor(void) {
    switch (lookAhead->tokenType) {
    case TK_NUMBER:
        eat(TK_NUMBER);
        break;
    case TK_CHAR:
        eat(TK_CHAR);
        break;
    case TK_IDENT:
        eat(TK_IDENT);
        switch (lookAhead->tokenType) {
        case SB_LPAR:
            compileArguments();
            break;
        case SB_LSEL:
            compileIndexes();
            break;
        default:
            break;
        }
        break;
    default:
        error(ERR_INVALID_FACTOR, lookAhead->lineNo, lookAhead->colNo);
    }
}

コード例 #9

ファイル: parser.c プロジェクト: NPHiep/Compiler

Type* compileFactor(void) {
  // DONE: parse a factor and return the factor's type

  Object* obj;
  Type* type;

  switch (lookAhead->tokenType) {
  case TK_NUMBER:
    eat(TK_NUMBER);
    type = intType;
    break;
  case TK_CHAR:
    eat(TK_CHAR);
    type = charType;
    break;
  case TK_IDENT:
    eat(TK_IDENT);
    // check if the identifier is declared
    obj = checkDeclaredIdent(currentToken->string);

    switch (obj->kind) {
    case OBJ_CONSTANT:
      switch (obj->constAttrs->value->type) {
      case TP_INT:
        type = intType;
        break;
      case TP_CHAR:
        type = charType;
        break;
      default:
        break;
      }
      break;
    case OBJ_VARIABLE:
      if (obj->varAttrs->type->typeClass == TP_ARRAY) {
        type = compileIndexes(obj->varAttrs->type);
      } else {
        type = obj->varAttrs->type;
      }
      break;
    case OBJ_PARAMETER:
      type = obj->paramAttrs->type;
      break;
    case OBJ_FUNCTION:
      compileArguments(obj->funcAttrs->paramList);
      type = obj->funcAttrs->returnType;
      break;
    default: 
      error(ERR_INVALID_FACTOR,currentToken->lineNo, currentToken->colNo);
      break;
    }
    break;
  default:
    error(ERR_INVALID_FACTOR, lookAhead->lineNo, lookAhead->colNo);
  }
  
  return type;
}

コード例 #10

ファイル: parser.c プロジェクト: BichVN/Compiler

void compileAssignSt(void) {
  assert("Parsing an assign statement ....");
  // TODO
  eat(TK_IDENT);
  compileIndexes();
  eat(SB_ASSIGN);
  compileExpression();
  assert("Assign statement parsed ....");
}

コード例 #11

ファイル: parser.c プロジェクト: kiendt07/ctd

void compileIndexes(void) {
  // TODO
  if (lookAhead->tokenType == SB_LSEL) {
      eat(SB_LSEL);
      compileExpression();
      eat(SB_RSEL);
      compileIndexes();
  }
}

コード例 #12

ファイル: parser.c プロジェクト: nguyentuananh1993/chuongTrinhDich

void compileLValue(void) {
  Object* var;

  eat(TK_IDENT);
  // check if the identifier is a function identifier, or a variable identifier, or a parameter  
  var = checkDeclaredLValueIdent(currentToken->string);
  if (var->kind == OBJ_VARIABLE)
    compileIndexes();
}

コード例 #13

ファイル: parser.c プロジェクト: minh93/thctd

void compileAssignSt(void) {
  assert("Parsing an assign statement ....");
  // TODO
  eat(TK_IDENT);
  if(lookAhead->tokenType==SB_LSEL)	
    compileIndexes();	
  eat(SB_ASSIGN);
  compileExpression();
  assert("Assign statement parsed ....");
}

コード例 #14

ファイル: parser.c プロジェクト: duc17224560/CTD-20152-Shukudai.

Type* compileFactor(void) {
  // parse a factor and return the factor's type

  Object* obj = NULL;
  Type* type = NULL;

  switch (lookAhead->tokenType) {
  case TK_NUMBER:
    eat(TK_NUMBER);
    type = makeIntType();
    break;
  case TK_CHAR:
    eat(TK_CHAR);
    type = makeCharType();
    break;
  case TK_IDENT:
    eat(TK_IDENT);
    // check if the identifier is declared
    obj = checkDeclaredIdent(currentToken->string);

    switch (obj->kind) {
    case OBJ_CONSTANT:
      // use as an empty type
      type = makeIntType();

      // assign the type of the constant
      type->typeClass = obj->constAttrs->value->type;
      break;
    case OBJ_VARIABLE:
      if (obj->varAttrs->type->typeClass != TP_ARRAY)
        type = obj->varAttrs->type;
      else
        type = compileIndexes(obj->varAttrs->type);
      break;
    case OBJ_PARAMETER:
      type = obj->paramAttrs->type;
      break;
    case OBJ_FUNCTION:
      type = obj->funcAttrs->returnType;
      compileArguments(obj->funcAttrs->paramList);
      break;
    default: 
      error(ERR_INVALID_FACTOR,currentToken->lineNo, currentToken->colNo);
      break;
    }
    break;
  default:
    error(ERR_INVALID_FACTOR, lookAhead->lineNo, lookAhead->colNo);
  }
  
  return type;
}

コード例 #15

ファイル: parser.c プロジェクト: leaderwing/test_repo

Type* compileLValue(void) {
  // TODO: parse a lvalue (a variable, an array element, a parameter, the current function identifier)
  Object* var;
  Type* varType;

  eat(TK_IDENT);
  // check if the identifier is a function identifier, or a variable identifier, or a parameter  
  var = checkDeclaredLValueIdent(currentToken->string);
  if (var->kind == OBJ_VARIABLE)
    compileIndexes();

  return varType;
}

コード例 #16

ファイル: parser.c プロジェクト: duc17224560/CTD-20152-Shukudai.

Type* compileLValue(void) {
  // parse a lvalue (a variable, an array element, a parameter, the current function identifier)
  Object* var = NULL;
  Type* varType = NULL;

  eat(TK_IDENT);
  // check if the identifier is a function identifier, or a variable identifier, or a parameter  
  var = checkDeclaredLValueIdent(currentToken->string);
  if (var->kind == OBJ_VARIABLE)
    varType = compileIndexes(var->varAttrs->type);
  else if (var->kind == OBJ_FUNCTION)
    varType = var->funcAttrs->returnType;
  else if (var->kind == OBJ_PARAMETER)
    varType = var->paramAttrs->type;

  return varType;
}

コード例 #17

ファイル: parser.c プロジェクト: duccuongict56bkhn/CompilerLab

void compileAssignSt(void) { //khong hieu lam
  assert("Parsing an assign statement ....");
  eat(TK_IDENT);
  switch(lookAhead->tokenType){
  case SB_LSEL:  //variable
      compileIndexes();
      eat(SB_ASSIGN);
      compileExpression();
      break;
  case SB_ASSIGN: //function
      eat(SB_ASSIGN);
      compileExpression();
      break;
  default:
    error(ERR_INVALIDSTATEMENT, lookAhead->lineNo, lookAhead->colNo);
    break;
  }
  assert("Assign statement parsed ....");
}

コード例 #18

ファイル: parser.c プロジェクト: duccuongict56bkhn/CompilerLab

void compileFactor(void) {
  if(lookAhead->tokenType == TK_NUMBER || lookAhead->tokenType == TK_CHAR ){
    compileUnsignedConstant();
    }
  else if (lookAhead->tokenType == TK_IDENT){
    eat(TK_IDENT);
    if( lookAhead->tokenType == SB_LSEL){
    compileIndexes();
    }
    else if(lookAhead->tokenType == SB_LPAR){
    compileArguments();
    }
  }
  else if(lookAhead->tokenType == SB_LPAR){
    eat(SB_LPAR);
    compileExpression();
    eat(SB_RPAR);
  }
  else error(ERR_INVALIDFACTOR, lookAhead->lineNo, lookAhead->colNo);
}

コード例 #19

ファイル: parser.c プロジェクト: BichVN/Compiler

void compileIndexes(void) {
  // TODO
 switch (lookAhead->tokenType) {
  case SB_LSEL:
    eat(SB_LSEL);
    compileExpression();
    eat(SB_RSEL);
    compileIndexes();
    break;
  case SB_TIMES:
  case SB_SLASH:
  case SB_MOD:
  case SB_PLUS:
  case SB_MINUS:  
  case SB_EQ:
  case SB_NEQ:
  case SB_LE:
  case SB_LT:
  case SB_GE:
  case SB_GT:
  case KW_TO:
  case KW_DO:
  case SB_COMMA:
  case SB_LPAR:
  case SB_RSEL:
  case SB_RPAR:
  case SB_SEMICOLON:
  case KW_END:
  case KW_ELSE:
  case KW_THEN:
  case SB_ASSIGN:
    break;
  default:
    error(ERR_INVALIDSTATEMENT, lookAhead->lineNo, lookAhead->colNo);
    break;
  }
}

コード例 #20

ファイル: parser.c プロジェクト: duc17224560/CTD-20152-Shukudai.

void compileLValue(void) {
    eat(TK_IDENT);
    compileIndexes();
}

コード例 #21

ファイル: parser.c プロジェクト: kiendt07/ctd

Type* compileFactor(void) {
  Type* type;
  Object* obj;

  switch (lookAhead->tokenType) {
  case TK_NUMBER:
    eat(TK_NUMBER);
    type = intType;
    genLC(currentToken->value);
    break;
  case TK_CHAR:
    eat(TK_CHAR);
    type = charType;
    genLC(currentToken->value);
    break;
  case TK_IDENT:
    eat(TK_IDENT);
    obj = checkDeclaredIdent(currentToken->string);

    switch (obj->kind) {
    case OBJ_CONSTANT:
      switch (obj->constAttrs->value->type) {
      case TP_INT:
	type = intType;
	genLC(obj->constAttrs->value->intValue);
	break;
      case TP_CHAR:
	type = charType;
	genLC(obj->constAttrs->value->charValue);
	break;
      default:
	break;
      }
      break;
    case OBJ_VARIABLE:
      if (obj->varAttrs->type->typeClass == TP_ARRAY) {
	genVariableAddress(obj);
	type = compileIndexes(obj->varAttrs->type);
	genLI();
      } else {
	type = obj->varAttrs->type;
	genVariableValue(obj);
      }
      break;
    case OBJ_PARAMETER:
      // TODO: push parameter's value onto the stack
      type = obj->paramAttrs->type;
      break;
    case OBJ_FUNCTION:
      // TODO: generate function call
      if (isPredefinedFunction(obj)) {
	compileArguments(obj->funcAttrs->paramList);
	genPredefinedFunctionCall(obj);
      } else {
	compileArguments(obj->funcAttrs->paramList);
      }
      type = obj->funcAttrs->returnType;
      break;
    default: 
      error(ERR_INVALID_FACTOR,currentToken->lineNo, currentToken->colNo);
      break;
    }
    break;
  case SB_LPAR:
    eat(SB_LPAR);
    type = compileExpression();
    eat(SB_RPAR);
    break;
  default:
    error(ERR_INVALID_FACTOR, lookAhead->lineNo, lookAhead->colNo);
  }
  
  return type;
}