PLEX and AXE system

PLEX (Programming Language for EXchanges) is a special-purpose, pseudo-parallel and event-driven real-time programming language. Dedicated for AXE telephone exchanges, it was developed by Göran Hemdahl at Ericsson. Originally designed in the 1970s, it has been continuously evolving since then. The language has two variants: Plex-C used for AXE Central Processors (CP) and Plex-M used for Extension Module Regional Processors (EMRP).

Clearcase Client Commands

Configure user aliases:
File: $HOME/.bashrc

alias ct=/usr/atria/bin/cleartool
alias sv='/usr/atria/bin/cleartool setview'
umask 022

File: $HOME/.cshrc

alias ct /usr/atria/bin/cleartool
alias sv '/usr/atria/bin/cleartool setview'
umask 022


alias .. 'cd ..'
alias ... 'cd ../..'

alias shw 'ct lsco -rec -me -cview /vobs/HW'
alias sst 'ct lsco -rec -me -cview /vobs/HWStage'

alias ll 'ls -alt --color=auto'
alias ct 'cleartool'
alias ctll 'ct ls'
alias ctsv '/home/xviengu/bin/ctsv.sh'
alias ctrv 'ct rmview -tag'
alias sv 'ct setview'
alias ev 'ct endview'
alias scs 'ct setcs'
alias ccs 'ct catcs'
alias edcs 'ct edcs'
alias pwv 'ct pwv'
alias myview 'cleartool lsview | grep $USER'

cleartool lsview -long xviengu_apz15_dummy

[xviengu@seasx031 /home/xviengu]# cleartool lsview -long xviengu_apz15_dummy

Tag: xviengu_apz15_dummy

  Global path: /cc/seasna06_view11/xviengu_apz15_dummy.vws

  Server host: seasx012.rnd.as.sw.ericsson.se

  Region: ASUAB

  Active: NO

  View tag uuid:0e8a50d0.d4f111df.96e5.00:01:84:85:db:c4

View on host: seasx012.rnd.as.sw.ericsson.se

View server access path: /cc/seasna06_view11/xviengu_apz15_dummy.vws

View uuid: 0e8a50d0.d4f111df.96e5.00:01:84:85:db:c4

View owner: rnd.as.sw.ericsson.se/xviengu

cleartool rmview -vob /cc/seasna06_view11/ -uuid 0e8a50d0.d4f111df.96e5.00:01:84:85:db:c4

cleartool rmtag -view xviengu_apz15_dummy  <========== good

ct unregister -view /cc/seasna06_view11/xviengu_apz15_dummy.vws

See more: http://www.yolinux.com/TUTORIALS/ClearcaseCommands.html
https://publib.boulder.ibm.com/infocenter/cchelp/v7r1m2/index.jsp?topic=/com.ibm.rational.clearcase.ccrc.help.doc/topics/u_ccchangeset.htm

Tags: Clearcase commands, cmd, alias, cleartool, setview

Disposable email services

Guerrilla Mail: disposable e-mail addresses which expire after 15 Minutes.


http://10minutemail.com/

http://www.mailinator.com/

http://www.mintemail.com/

https://addons.mozilla.org/vi/firefox/tag/disposable%20email
 
 
Tags: disposable, e-mail addresses, disposable e-mail addresses, Guerrilla Mail, 10minutemail, mailinator, mintemail
 
 

PLEX-C programming language

PLEX is an acronym for Programming Language for EXchanges and is a highlevel language developed by Ericsson in the 1970s, and extended in 1983. Programs in the AXE central processors use the Plex version Plex-C. The EMRP, which controls the subscriber stage, runs programs in Plex-M, a different dialect of Plex.

Plex is a high-level, real-time, language with very strict requirements regarding execution time.

DeviceIoControl

DeviceIoControl Function: Sends a control code directly to a specified device driver, causing the corresponding device to perform the corresponding operation.

Serial: CRT debug report

Report type: _CRT_WARN, _CRT_ERROR, _CRT_ASSERT

Required Header: crtdbg.h

_CRT_WARN: Warnings, messages, and information that does not need immediate attention.
_CRT_ERROR: Errors, unrecoverable problems, and issues that require immediate attention.
_CRT_ASSERT: Assertion failures (asserted expressions that evaluate to FALSE).

Serial: DCB structure

DCB sructure detects the management settings for the serial port of the connection device.

The most critical phase in serial communications programming is configuring the port settings with the DCB structure.

Do not apply pointer arithmetic to pointers

Pointer arithmetic shall only be applied to pointers that address an array or array element (misra2004_17_1_PointerArithmeticOnNotPointers.rule)


Description:

"Pointer arithmetic shall only be applied to pointers that address an array or array element. Addition and subtraction of integers (including increment and decrement) from pointers that do not point to an array or array element results in undefined behaviour."

Benefits:

Rule makes the code more readable and less confusing.

Example:

void foo( int a[] ) {
   int* p1 = 0;
   int* p2;
   int* p3 = a;

   a++;     // OK
   p1++;    // Violation
   p2 = a;
   p2++;    // OK
   p3++;    // OK
}

Repair:

Do not apply pointer arithmetic to pointers.

References:
MISRA-C:2004 Guidelines for the use of the C language in critical systems

Chapter 6, Section 17
Author
ParaSoft


Tags: Pointer arithmetic, less confusing, more readable
 

switch shall have at least one case

Every switch statement shall have at least one case clause (misra2004_15_5_AvoidSwitchWithNoCase.rule)


Description

Every switch statement shall have at least one case.

Benefits:

Provides maintainability of 'switch' statement.

Example:

void foo(int i)
{

   switch(i)      /* Violation */
   {

       default:
           ;
   }

}

Repair:

void foo(int i)
{
   switch(i)      /* OK */
   {
     case 1:
     {

     }
     default:
           ;

   }

}

References:

MISRA-C:2004 Guidelines for the use of the C language in critical systems
Chapter 6, Section 15

Author
ParaSoft
 
 
 
Tags: switch, case, maintainability, Guidelines, critical systems
 
 

Do not convert pointer to pointer

A cast should not be performed between a pointer to object type and a different pointer to object type (misra2004_11_4_DoNotConvertPointerToPointer.rule)


Description:

"A cast should not be performed between a pointer to object type and a different pointer to object type. Conversions of this type may be invalid if the new pointer type requires a stricter alignment."

Note: This rule skips casting of void type.

Benefits:

Prevents incorrect pointer alignment.

Example:

void foo( ) {
   int* pi;
   char* i;

   i = (char*) pi; // Violation
   i = (char*) &i; // Violation
}

Repair:

Do not convert pointer to different pointer.

References:
MISRA-C:2004 Guidelines for the use of the C language in critical systems
Chapter 6, Section 11

Author
ParaSoft


Tags: cast, pointer, void, pointer alignment, MISRA, critical systems

Avoid using unsafe string functions

Avoid using unsafe string functions (UsageOfStringFunctions.rule)


Description

This rule detects code that uses unsafe string functions from C library.

Benefits:

Prevents the use of functions which may cause buffer overflows.

According to David A. Wheeler (see reference below), "C functions users must avoid using dangerous functions that do not check bounds unless they've ensured that the bounds will never get exceed.

Functions to avoid in most cases (or ensure protection) include the functions strcpy(), strcat(), sprintf() (with cousin vsprintf()), and gets().

These should be replaced with functions such as strncpy(), strncat(), snprintf(), fgets(), respectively."

Example:

#include
void main( void )
{
char* str1 = "testcase";
char* str2 = "testcase";
char* str3=0;

str3 = strcat( str1, str2 ); // Violation
}

Repair:

#include
void main( void )
{
char* str1 = "testcase";
char* str2 = "testcase";
char* str3=0;

str3 = strncat( str1, str2, 16 ); // OK
}

References:
http://www.dwheeler.com/secure-programs/Secure-Programs-HOWTO/dangers-c.html

Author
ParaSoft


Tags: Avoid, unsafe, string, function, unsafe string, C library, buffer overflows, dangerous functions, strncpy, strncat, snprintf, fgets

Modular programming in C

What is Modular programming ?

- A programming technique to break down program functions into separate modules/parts/layers.
- Module, have to accomplishes one function by containing the source codes and input/output variables needed to accomplish that function.

Do NOT check floats for equality

Don't check floats for equality; check for greater than or less than (EqualityFloatLeft.rule)


Description:
This rule checks whether you check floats for equality instead of checking for greater than or less than.

Benefits:

If you check floats for equality, you make your code more susceptible to rounding errors.

Example:

void func(float a, int b)
{
   if (a==b) { }     // Violation

   while (a!=b) { }  // Violation
}



Repair:

void func(float a, int b)
{
   if (a>=b) { }     // OK

   while (a<=b) { }  // OK
}

Author
ParaSoft


My comment for repairing:

void func(const float a, const int b)
{
    if ( a > b ) { }
    else if ( a < b ) {}
    else {}
    // while (a > b) { };
    // while (a < b) { };
}

Ref: http://www.c-faq.com/fp/fpequal.html
Tags: vav.vn, vav, float, float equality, check float values equality, floating point, absolute, epsilon

domain co.cc

http://www.zebrazone.co.cc/,
http://www.fansipan.co.cc/,
http://www.zebrazoo.co.cc/

altonjuve_shift_2_yahoo_dot_com

Avoid Directly Access Globals

Do not directly access global data from a constructor (AvoidDirectlyAccessGlobals.rule)


Description:

Directly accessing global data from a constructor is risky because the global object may not yet exist when the "other" static object is initialized. This rule detects if you directly access global data from a constructor.

Function call order

The value of an expression shall be the same under any order of evaluation that the standard permits (misra2004_12_2_4_FunctionsCallOrder.rule)


Description

"Apart from a few operators (notably the function call operator (), &&, , ?: and , (comma)) the order in which sub-expressions are evaluated is unspecified and can vary. This means that no reliance can be placed on the order of evaluation of sub-expressions, and in particular no reliance can be placed on the order in which side effects occur. Those points in the evaluation of an expression at which all previous side effects can be guaranteed to have taken place are called “sequence points”. Sequence points and side effects are described in sections 5.1.2.3, 6.3 and 6.6 of ISO 9899:1990 [2].

Note that the order of evaluation problem is not solved by the use of parentheses, as this is not a precedence issue." "Functions may have additional effects when they are called (e.g. modifying some global data). Dependence on order of evaluation could be avoided by invoking the function prior to the expression that uses it, making use of a temporary variable for the value.

Avoid indexing pointer

Array indexing shall be the only allowed form of pointer arithmetic (misra2004_17_4_AvoidIndexingPointerAsArray.rule)


Description:

"Array indexing is the only acceptable form of pointer arithmetic, because it is clearer and hence less error prone than pointer manipulation. This rule bans the explicit calculation of pointer values. Array indexing shall only be applied to objects defined as an array type. Any explicitly calculated pointer value has the potential to access unintended or invalid memory addresses. Pointers may go out of bounds of arrays or structures, or may even point to effectively arbitrary locations."

Drawbacks: For more complex code rule may not be able to check if there is indexed pointer which points to array. For such cases the rule may report false positives.

Dev-cpp: stray '\160' in program

The message "stray '\160' in program" when building by Dev-Cpp is occurred when using "Copy and Paste" action.

So, finally, DO NOT copy and paste source code. Please type line by line.

Avoid assignment in if

Avoid assignment in if statement condition (IfAssign.rule)


Description:

This rule checks whether your code has assignment within an if statement condition. This rule is enabled by default.

Benefits:

Legibility and maintainability.

Assignment in the context of an if statement is easily confused with equality.

Example:

void foo(int a, int b) {

  if ( a = b ) {}  // Violation

}

Repair:

void foo(int a, int b) {

  if ( a == b ) {} // OK
}

Author
ParaSoft

Avoid nested assignment statements

The value of an expression shall be the same under any order of evaluation that the standard permits (misra2004_12_2_5_AvoidNestedAssignment.rule)


Description

"Apart from a few operators (notably the function call operator (), &&, , ?: and , (comma)) the order in which sub-expressions are evaluated is unspecified and can vary. This means that no reliance can be placed on the order of evaluation of sub-expressions, and in particular no reliance can be placed on the order in which side effects occur. Those points in the evaluation of an expression at which all previous side effects can be guaranteed to have taken place are called “sequence points”. Sequence points and side effects are described in sections 5.1.2.3, 6.3 and 6.6 of ISO 9899:1990 [2].

Note that the order of evaluation problem is not solved by the use of parentheses, as this is not a precedence issue."

"Assignments nested within expressions cause additional side effects. The best way to avoid any chance of this leading to a dependence on order of evaluation is to not embed assignments within expressions.

For example, the following is not recommended:

x = y = y = z / 3;

x = y = y++;"

Benefits:

Rule prevents evaluation of expression dependent on compiler version.

Example:

void foo( int x, int y, int z ) {

   x = y = z / 3;  // Violation
}

Repair:

void foo( int x, int y, int z ) {
   y = z / 3;  // OK
   x = y;      // OK
}

References:

MISRA-C:2004 Guidelines for the use of the C language in critical systems

Chapter 6, Section 12

Author
ParaSoft