diff --git a/src/common/action.h b/src/common/action.h
index 6da3341..e898354 100644
--- a/src/common/action.h
+++ b/src/common/action.h
@@ -51,9 +51,9 @@ class Action {
   // Generates std::string representation of the action and stores in "buff".
   // It does not append '\n' at the end of. the std::string
   void printActionNN(std::ostringstream & buff) {
-    std::string type = " R ";
-    if ( is_write_action ) type = " W ";
-    buff << accessing_task_id << type <<  destination_address << " " << value_written
+    std::string action_type = " R ";
+    if ( is_write_action ) action_type = " W ";
+    buff << accessing_task_id << action_type <<  destination_address << " " << value_written
          << " " << source_line_num << " " << source_func_id;
   }
 
diff --git a/src/common/instruction.h b/src/common/instruction.h
index e539658..7903c6e 100644
--- a/src/common/instruction.h
+++ b/src/common/instruction.h
@@ -20,7 +20,7 @@
 
 class Instruction {
   public:
-  INTEGER lineNo;
+  INTEGER source_line_num;
   std::string destination;
   std::string type;
   OPERATION oper;
@@ -128,7 +128,7 @@ class Instruction {
   }
 
   void print() {
-    std::cout << "LineNo: " << lineNo
+    std::cout << "source_line_num: " << source_line_num
          << ", type: " << type
          << ", oper: " << OperRepresentation(oper)
          << ", dest: " << destination
diff --git a/src/detector/commutativity/CommutativityChecker.cc b/src/detector/commutativity/CommutativityChecker.cc
index 597f1b7..237a666 100644
--- a/src/detector/commutativity/CommutativityChecker.cc
+++ b/src/detector/commutativity/CommutativityChecker.cc
@@ -29,14 +29,14 @@ VOID CommutativityChecker::parseTasksIR(char * IRlogName) {
 
     sttmt = Instruction::trim( sttmt );        // trim spaces
     if ( isValidStatement(sttmt) ) {           // check if normal statement
-      INTEGER lineNo = getLineNumber( sttmt );
+      INTEGER source_line_num = getLineNumber( sttmt );
       // skip instruction with line # 0: args to task body
-      if (lineNo <= 0) continue;
+      if (source_line_num <= 0) continue;
 
       sttmt = sttmt.substr(sttmt.find_first_not_of(' ',
                            sttmt.find_first_of(' ')));
       Instruction instr( sttmt );
-      instr.lineNo = lineNo;
+      instr.source_line_num = source_line_num;
       currentTask.push_back(instr);
       continue;
     } // if
@@ -87,8 +87,8 @@ BOOL CommutativityChecker::involveSimpleOperations(
   INTEGER index = -1;
 
   for (auto i = taskBody->begin(); i != taskBody->end(); i++) {
-     if (i->lineNo > lineNumber) break;
-     if (i->lineNo == lineNumber) instr  = *i;
+     if (i->source_line_num > lineNumber) break;
+     if (i->source_line_num == lineNumber) instr  = *i;
      index++;
   }
   
diff --git a/src/detector/commutativity/CriticalSectionBody.h b/src/detector/commutativity/CriticalSectionBody.h
index 27eec35..9015500 100644
--- a/src/detector/commutativity/CriticalSectionBody.h
+++ b/src/detector/commutativity/CriticalSectionBody.h
@@ -36,16 +36,16 @@ class CriticalSectionBody {
 
   CriticalSectionBody(std::vector<Instruction> _body) {
     if( _body.size() > 0 ) {
-      setStartLineNo( _body.front().lineNo );
-      setEndLineNo  ( _body.back().lineNo  );
+      setStartLineNo( _body.front().source_line_num );
+      setEndLineNo  ( _body.back().source_line_num  );
       body = _body;
     } else {
       throw "Critical section must contain at least one statement";
     }
   }
-  void   setStartLineNo(int lineNo) { startLineNo = lineNo; }
-  void   setEndLineNo(int lineNo) {
-    endLineNo = lineNo;
+  void   setStartLineNo(int source_line_num) { startLineNo = source_line_num; }
+  void   setEndLineNo(int source_line_num) {
+    endLineNo = source_line_num;
     assert(endLineNo >= startLineNo);
   }
   int    getStartLineNo()           { return startLineNo;   }
diff --git a/src/detector/commutativity/CriticalSections.h b/src/detector/commutativity/CriticalSections.h
index eb6ccd2..c9255c4 100644
--- a/src/detector/commutativity/CriticalSections.h
+++ b/src/detector/commutativity/CriticalSections.h
@@ -39,19 +39,19 @@ class CriticalSections {
 
   size_t getSize() { return sections.size(); }
 
-  CriticalSectionBody *find(int lineNo) {
+  CriticalSectionBody *find(int source_line_num) {
     if (0 == sections.size()) return end();
 
     for (auto &cr : sections) {
-      if (cr.second.getStartLineNo() <= lineNo
-          && lineNo <= cr.second.getEndLineNo()) {
+      if (cr.second.getStartLineNo() <= source_line_num
+          && source_line_num <= cr.second.getEndLineNo()) {
         return &cr.second;
       }
     }
-    auto start = sections.lower_bound(lineNo);
+    auto start = sections.lower_bound(source_line_num);
     if (start == sections.end()) return end();
-    if ( lineNo >= start->second.getStartLineNo() &&
-        lineNo <= start->second.getEndLineNo() ) {
+    if ( source_line_num >= start->second.getStartLineNo() &&
+        source_line_num <= start->second.getEndLineNo() ) {
       return &start->second;
     }
 
diff --git a/src/functionengine/FunctionEngine.h b/src/functionengine/FunctionEngine.h
index 2e89af5..fc77d5e 100644
--- a/src/functionengine/FunctionEngine.h
+++ b/src/functionengine/FunctionEngine.h
@@ -23,7 +23,7 @@
 
 class FunctionEngine {
   public:
-    void pushFunction(std::string name, unsigned taskID, int lineNo);
+    void pushFunction(std::string name, unsigned taskID, int source_line_num);
     void popFunction(std::string name, unsigned taskID);
     CallStack &getStack(unsigned taskID);
     void removeStack(unsigned taskID);
diff --git a/src/instrumentor/callbacks/InstrumentationCallbacks.cc b/src/instrumentor/callbacks/InstrumentationCallbacks.cc
index 0e364c7..c2f5753 100644
--- a/src/instrumentor/callbacks/InstrumentationCallbacks.cc
+++ b/src/instrumentor/callbacks/InstrumentationCallbacks.cc
@@ -68,23 +68,23 @@ static TaskInfo * getTaskInfo(int * _type = NULL) {
 inline void INS_MemRead(
   address addr,
     ulong size,
-    int lineNo,
+    int source_line_num,
     address funcName) {
 
-  if (!lineNo) return;
+  if (!source_line_num) return;
 
   TaskInfo * taskInfo = getTaskInfo();
   //lint value = getMemoryValue( addr, size );
   //uint threadID = (uint)pthread_self();
 
   if ( taskInfo && taskInfo->active ) {
-    INS::Read(*taskInfo, addr, lineNo, (char*)funcName);
+    INS::Read(*taskInfo, addr, source_line_num, (char*)funcName);
 #ifdef DEBUG
     std::stringstream ss;
     ss << std::hex << addr;
     PRINT_DEBUG("READ: addr: " + ss.str() +
         " taskID: " + std::to_string(taskInfo->taskID) +
-        " line no: " + std::to_string(lineNo));
+        " line no: " + std::to_string(source_line_num));
 #endif
   }
 }
@@ -93,23 +93,23 @@ inline void INS_MemRead(
 inline void INS_MemWrite(
     address addr,
     lint value,
-    int lineNo,
+    int source_line_num,
     address funcName ) {
 
-  if (!lineNo) return;
+  if (!source_line_num) return;
 
   TaskInfo * taskInfo = getTaskInfo();
   //uint threadID = (uint)pthread_self();
 
   if ( taskInfo && taskInfo->active ) {
-    INS::Write(*taskInfo, addr, (lint)value, lineNo, (char*)funcName );
+    INS::Write(*taskInfo, addr, (lint)value, source_line_num, (char*)funcName );
 #ifdef DEBUG
     std::stringstream ss;
     ss << std::hex << addr;
     PRINT_DEBUG("= WRITE: addr: " + ss.str() +
         ", value: " + std::to_string((lint)value) +
         ", taskID: " + std::to_string(taskInfo->taskID) +
-        ", line number: " + std::to_string(lineNo) +
+        ", line number: " + std::to_string(source_line_num) +
         ", func name: " + std::string((char*)funcName));
 #endif
   }
@@ -119,9 +119,9 @@ inline void INS_MemWrite(
 void __tasksan_write_float(
     address addr,
     float value,
-    int lineNo,
+    int source_line_num,
     address funcName) {
-  INS_MemWrite(addr, (lint)value, lineNo, funcName);
+  INS_MemWrite(addr, (lint)value, source_line_num, funcName);
 }
 
 void __tasksan_register_iir_file(void * fileName) {
@@ -132,52 +132,52 @@ void __tasksan_register_iir_file(void * fileName) {
 void __tasksan_write_double(
     address addr,
     double value,
-    int lineNo,
+    int source_line_num,
     address funcName) {
-  INS_MemWrite(addr, (lint)value, lineNo, funcName);
+  INS_MemWrite(addr, (lint)value, source_line_num, funcName);
 }
 
 void __tasksan_flush_memory() {
   PRINT_DEBUG("  TaskSanitizer: flush memory");
 }
 
-void __tasksan_read1(void *addr, int lineNo, address funcName) {
-  INS_MemRead(addr, 1, lineNo, funcName);
+void __tasksan_read1(void *addr, int source_line_num, address funcName) {
+  INS_MemRead(addr, 1, source_line_num, funcName);
 }
-void __tasksan_read2(void *addr, int lineNo, address funcName) {
-  INS_MemRead(addr, 2, lineNo, funcName);
+void __tasksan_read2(void *addr, int source_line_num, address funcName) {
+  INS_MemRead(addr, 2, source_line_num, funcName);
 }
 
-void __tasksan_read4(void *addr, int lineNo, address funcName) {
-  INS_MemRead(addr, 4, lineNo, funcName);
+void __tasksan_read4(void *addr, int source_line_num, address funcName) {
+  INS_MemRead(addr, 4, source_line_num, funcName);
 }
 
-void __tasksan_read8(void *addr, int lineNo, address funcName) {
-  INS_MemRead( addr, 8, lineNo, funcName );
+void __tasksan_read8(void *addr, int source_line_num, address funcName) {
+  INS_MemRead( addr, 8, source_line_num, funcName );
 }
 
-void __tasksan_read16(void *addr, int lineNo, address funcName) {
-  INS_MemRead( addr, 16, lineNo, funcName );
+void __tasksan_read16(void *addr, int source_line_num, address funcName) {
+  INS_MemRead( addr, 16, source_line_num, funcName );
 }
 
-void __tasksan_write1(void *addr, lint value, int lineNo, address funcName) {
-  INS_MemWrite((address)addr, value, lineNo, funcName);
+void __tasksan_write1(void *addr, lint value, int source_line_num, address funcName) {
+  INS_MemWrite((address)addr, value, source_line_num, funcName);
 }
 
-void __tasksan_write2(void *addr, lint value, int lineNo, address funcName) {
-  INS_MemWrite((address)addr, value, lineNo, funcName);
+void __tasksan_write2(void *addr, lint value, int source_line_num, address funcName) {
+  INS_MemWrite((address)addr, value, source_line_num, funcName);
 }
 
-void __tasksan_write4(void *addr, lint value, int lineNo, address funcName) {
-  INS_MemWrite((address)addr, value, lineNo, funcName);
+void __tasksan_write4(void *addr, lint value, int source_line_num, address funcName) {
+  INS_MemWrite((address)addr, value, source_line_num, funcName);
 }
 
-void __tasksan_write8(void *addr, lint value, int lineNo, address funcName) {
-  INS_MemWrite((address)addr, value, lineNo, funcName);
+void __tasksan_write8(void *addr, lint value, int source_line_num, address funcName) {
+  INS_MemWrite((address)addr, value, source_line_num, funcName);
 }
 
-void __tasksan_write16(void *addr, lint value, int lineNo, address funcName) {
-  INS_MemWrite((address)addr, value, lineNo, funcName);
+void __tasksan_write16(void *addr, lint value, int source_line_num, address funcName) {
+  INS_MemWrite((address)addr, value, source_line_num, funcName);
 }
 
 void __tasksan_unaligned_read2(const void *addr) {
diff --git a/src/instrumentor/callbacks/InstrumentationCallbacks.h b/src/instrumentor/callbacks/InstrumentationCallbacks.h
index fc34627..85de790 100644
--- a/src/instrumentor/callbacks/InstrumentationCallbacks.h
+++ b/src/instrumentor/callbacks/InstrumentationCallbacks.h
@@ -42,9 +42,9 @@ extern "C" {
                         unsigned long size);
 
   // callbacks for memory access, race detection
-  void INS_MemRead8(void *addr, int lineNo, void *fName);
-  void INS_MemRead4(void *addr, int lineNo, void *fName);
-  void INS_MemRead1(void *addr, int lineNo, void *fName);
+  void INS_MemRead8(void *addr, int source_line_num, void *fName);
+  void INS_MemRead4(void *addr, int source_line_num, void *fName);
+  void INS_MemRead1(void *addr, int source_line_num, void *fName);
   void INS_MemWrite8(void *addr, long int v, int lnNo, void *fName);
   void INS_MemWrite4(void *addr, long int v, int lnNo, void *fName);
   void INS_MemWrite1(void *addr, long int v, int lnNo, void *fName);
@@ -74,17 +74,17 @@ extern "C" {
 
   void __tasksan_flush_memory();
 
-  void __tasksan_read1(void *addr, int lineNo, address funcName);
-  void __tasksan_read2(void *addr, int lineNo, address funcName);
-  void __tasksan_read4(void *addr, int lineNo, address funcName);
-  void __tasksan_read8(void *addr, int lineNo, address funcName);
-  void __tasksan_read16(void *addr, int lineNo, address funcName);
-
-  void __tasksan_write1(void *addr, long int value, int lineNo, address funcName);
-  void __tasksan_write2(void *addr, long int value, int lineNo, address funcName);
-  void __tasksan_write4(void *addr, long int value, int lineNo, address funcName);
-  void __tasksan_write8(void *addr, long int value, int lineNo, address funcName);
-  void __tasksan_write16(void *addr, long int value, int lineNo, address funcName);
+  void __tasksan_read1(void *addr, int source_line_num, address funcName);
+  void __tasksan_read2(void *addr, int source_line_num, address funcName);
+  void __tasksan_read4(void *addr, int source_line_num, address funcName);
+  void __tasksan_read8(void *addr, int source_line_num, address funcName);
+  void __tasksan_read16(void *addr, int source_line_num, address funcName);
+
+  void __tasksan_write1(void *addr, long int value, int source_line_num, address funcName);
+  void __tasksan_write2(void *addr, long int value, int source_line_num, address funcName);
+  void __tasksan_write4(void *addr, long int value, int source_line_num, address funcName);
+  void __tasksan_write8(void *addr, long int value, int source_line_num, address funcName);
+  void __tasksan_write16(void *addr, long int value, int source_line_num, address funcName);
 
   void __tasksan_unaligned_read2(const void *addr);
   void __tasksan_unaligned_read4(const void *addr);
diff --git a/src/instrumentor/eventlogger/Logger.h b/src/instrumentor/eventlogger/Logger.h
index 3cd19aa..85e5833 100644
--- a/src/instrumentor/eventlogger/Logger.h
+++ b/src/instrumentor/eventlogger/Logger.h
@@ -182,7 +182,7 @@ class INS {
 
     // provides the address of memory a task reads from
     static inline VOID Read( TaskInfo & task,
-        ADDRESS addr, INTEGER lineNo, STRING funcName ) {
+        ADDRESS addr, INTEGER source_line_num, STRING funcName ) {
       INTEGER funcID = task.getFunctionId( funcName );
 
       // register function if not registered yet
@@ -191,9 +191,9 @@ class INS {
         task.registerFunction( funcName, funcID );
       }
 
-      //task.saveReadAction(addr, lineNo, funcID);
+      //task.saveReadAction(addr, source_line_num, funcID);
       std::stringstream ssin(std::to_string((VALUE)addr) + " 0 " +
-          std::to_string(lineNo) + " " + std::to_string(funcID));
+          std::to_string(source_line_num) + " " + std::to_string(funcID));
 
       guardLock.lock();
       onlineChecker.detectRaceOnMem(task.taskID, "R", ssin);
@@ -202,7 +202,7 @@ class INS {
 
     // stores a write action
     static inline VOID Write(TaskInfo & task, ADDRESS addr,
-        INTEGER value, INTEGER lineNo, STRING funcName) {
+        INTEGER value, INTEGER source_line_num, STRING funcName) {
 
       INTEGER funcID = task.getFunctionId( funcName );
 
@@ -212,9 +212,9 @@ class INS {
         task.registerFunction( funcName, funcID );
       }
 
-      //task.saveWriteAction(addr, value, lineNo, funcID);
+      //task.saveWriteAction(addr, value, source_line_num, funcID);
       std::stringstream ssin(std::to_string((VALUE)addr) + " " +
-          std::to_string(value) + " " + std::to_string(lineNo) +
+          std::to_string(value) + " " + std::to_string(source_line_num) +
           " " + std::to_string(funcID));
 
       guardLock.lock();
diff --git a/src/instrumentor/eventlogger/TaskInfo.h b/src/instrumentor/eventlogger/TaskInfo.h
index 649eb63..4bccceb 100644
--- a/src/instrumentor/eventlogger/TaskInfo.h
+++ b/src/instrumentor/eventlogger/TaskInfo.h
@@ -49,12 +49,12 @@ typedef struct TaskInfo {
   }
 
   inline void saveReadAction(ADDRESS & addr,
-      INTEGER & lineNo,
+      INTEGER & source_line_num,
       const INTEGER funcID) {
 
     MemoryActions & loc = memoryLocations[addr];
     if ( !loc.hasWrite() ) {
-      Action action( taskID, addr, 0, lineNo, funcID );
+      Action action( taskID, addr, 0, source_line_num, funcID );
       action.is_write_action = false;
       loc.storeAction( action );
     }
@@ -63,12 +63,12 @@ typedef struct TaskInfo {
   inline void saveWriteAction(
       ADDRESS addr,
       INTEGER value,
-      INTEGER lineNo,
+      INTEGER source_line_num,
       INTEGER funcID) {
 
      MemoryActions & loc = memoryLocations[addr];
      bool is_write_action = true;
-     loc.storeAction(taskID, addr, value, lineNo, funcID, is_write_action);
+     loc.storeAction(taskID, addr, value, source_line_num, funcID, is_write_action);
   }
 
   // Prints to ostringstream all memory access actions recorded.
diff --git a/src/instrumentor/pass/IIRlogger.h b/src/instrumentor/pass/IIRlogger.h
index bb6b3b7..06967e6 100644
--- a/src/instrumentor/pass/IIRlogger.h
+++ b/src/instrumentor/pass/IIRlogger.h
@@ -58,12 +58,12 @@ namespace IIRlog {
   //
   // This function is used in logging instructions which
   // are in critical sections of a program.
-  void LogNewIIRcode(int lineNo, llvm::Instruction& IIRcode ) {
-    //errs() << lineNo << ": " << IIRcode.str() << "\n";
+  void LogNewIIRcode(int source_line_num, llvm::Instruction& IIRcode ) {
+    //errs() << source_line_num << ": " << IIRcode.str() << "\n";
     std::string tempBuf;
     llvm::raw_string_ostream rso(tempBuf);
     IIRcode.print(rso);
-    logFile << lineNo << ": " << tempBuf << std::endl;
+    logFile << source_line_num << ": " << tempBuf << std::endl;
   }
 
   // Returns signature (function name) of call being made
@@ -135,11 +135,11 @@ namespace IIRlog {
             IIRlog::SaveToLogFile( tasksan::getEndCriticalSignature() );
           }
         } else if (in_critical_section > 0) { // in critical section
-          unsigned lineNo = 0;
+          unsigned source_line_num = 0;
           if (auto Loc = Inst.getDebugLoc()) {
-            lineNo = Loc->getLine();
+            source_line_num = Loc->getLine();
           }
-          IIRlog::LogNewIIRcode(lineNo, Inst);
+          IIRlog::LogNewIIRcode(source_line_num, Inst);
         }
       }
     }
diff --git a/src/unittests/CommutativityUnittests.cc b/src/unittests/CommutativityUnittests.cc
index 449129c..4cd2756 100644
--- a/src/unittests/CommutativityUnittests.cc
+++ b/src/unittests/CommutativityUnittests.cc
@@ -21,9 +21,9 @@ int main() {
 
   // first body
   Instruction instr1;
-  instr1.lineNo = 3;
+  instr1.source_line_num = 3;
   Instruction instr2;
-  instr2.lineNo = 6;
+  instr2.source_line_num = 6;
   std::vector<Instruction> body = {instr1, instr2};
   tasksan::commute::CriticalSectionBody body1(body);
   body1.setStartLineNo(3);
diff --git a/test/MemoryActions_gtest.cc b/test/MemoryActions_gtest.cc
index 69e267c..f7cc6f0 100644
--- a/test/MemoryActions_gtest.cc
+++ b/test/MemoryActions_gtest.cc
@@ -10,7 +10,7 @@ class TestMemoryActionsFixture : public ::testing::Test {
   INTEGER taskId = 123;
   ADDRESS addr = 0x033;
   VALUE value = 42;
-  VALUE lineNo = 100;
+  VALUE source_line_num = 100;
   INTEGER funcId = 6;
   std::string funcName = "some_function";
   bool is_write_action = true;
@@ -18,7 +18,7 @@ class TestMemoryActionsFixture : public ::testing::Test {
   Action m_act;
 
   virtual void SetUp() {
-    m_act = Action(accessing_task_id, addr, value, lineNo, funcId);
+    m_act = Action(taskId, addr, value, source_line_num, funcId);
   }
 };
 
@@ -30,14 +30,14 @@ TEST_F(TestMemoryActionsFixture, CheckConstructorIsEmptyTrue) {
 TEST_F(TestMemoryActionsFixture, CheckConstructorWithActionArgument) {
   MemoryActions m_actions(m_act);
   EXPECT_FALSE(m_actions.isEmpty);
-  EXPECT_EQ(accessing_task_id, m_actions.accessing_task_id);
+  EXPECT_EQ(taskId, m_actions.accessing_task_id);
   EXPECT_EQ(addr, m_actions.destination_address);
 }
 
 TEST_F(TestMemoryActionsFixture, CheckStoreActionFunction) {
   MemoryActions m_actions(m_act);
   EXPECT_FALSE(m_actions.isEmpty);
-  EXPECT_EQ(accessing_task_id, m_actions.accessing_task_id);
+  EXPECT_EQ(taskId, m_actions.accessing_task_id);
   EXPECT_EQ(addr, m_actions.destination_address);
 }
 
@@ -46,18 +46,18 @@ TEST_F(TestMemoryActionsFixture, CheckStoreActionFunctionWithParamsRead) {
   EXPECT_TRUE(m_actions.isEmpty);
 
   // store
-  uint ut = accessing_task_id;
-  m_actions.storeAction(ut, addr, value, lineNo, funcId, false);
+  uint ut = taskId;
+  m_actions.storeAction(ut, addr, value, source_line_num, funcId, false);
 
-  EXPECT_EQ(accessing_task_id, m_actions.accessing_task_id);
+  EXPECT_EQ(taskId, m_actions.accessing_task_id);
   EXPECT_EQ(addr, m_actions.destination_address);
   EXPECT_FALSE(m_actions.isEmpty);
 
-  EXPECT_EQ(accessing_task_id, m_actions.action.accessing_task_id);
+  EXPECT_EQ(taskId, m_actions.action.accessing_task_id);
   EXPECT_EQ(addr, m_actions.action.destination_address);
   EXPECT_EQ(funcId, m_actions.action.source_func_id);
   EXPECT_EQ(value, m_actions.action.value_written);
-  EXPECT_EQ(lineNo, m_actions.action.source_line_num);
+  EXPECT_EQ(source_line_num, m_actions.action.source_line_num);
 }
 
 TEST_F(TestMemoryActionsFixture, CheckHasWrite) {