Welcome to Linux Knowledge Base and Tutorial
"The place where you learn linux"
Child Fund

 Create an AccountHome | Submit News | Your Account  

Tutorial Menu
Linux Tutorial Home
Table of Contents

· Introduction to Operating Systems
· Linux Basics
· Working with the System
· Shells and Utilities
· Editing Files
· Basic Administration
· The Operating System
· The X Windowing System
· The Computer Itself
· Networking
· System Monitoring
· Solving Problems
· Security
· Installing and Upgrading
· Linux and Windows

Glossary
MoreInfo
Man Pages
Linux Topics
Test Your Knowledge

Site Menu
Site Map
FAQ
Copyright Info
Terms of Use
Privacy Info
Disclaimer
WorkBoard
Thanks
Donations
Advertising
Masthead / Impressum
Your Account

Communication
Feedback
Forums
Private Messages
Surveys

Features
HOWTOs
News Archive
Submit News
Topics
User Articles
Web Links

Google
Google


The Web
linux-tutorial.info

Who's Online
There are currently, 189 guest(s) and 0 member(s) that are online.

You are an Anonymous user. You can register for free by clicking here

  

perlclib




DESCRIPTION

       One thing Perl porters should note is that perl doesn't
       tend to use that much of the C standard library inter­
       nally; you'll see very little use of, for example, the
       ctype.h functions in there. This is because Perl tends to
       reimplement or abstract standard library functions, so
       that we know exactly how they're going to operate.

       This is a reference card for people who are familiar with
       the C library and who want to do things the Perl way; to
       tell them which functions they ought to use instead of the
       more normal C functions.

       Conventions

       In the following tables:

       "t"
          is a type.

       "p"
          is a pointer.

       "n"
          is a number.

       "s"
          is a string.

       "sv", "av", "hv", etc. represent variables of their
       respective types.

       File Operations

       Instead of the stdio.h functions, you should use the Perl
       abstraction layer. Instead of "FILE*" types, you need to
       be handling "PerlIO*" types.  Don't forget that with the
       new PerlIO layered I/O abstraction "FILE*" types may not
       even be available. See also the "perlapio" documentation
       for more information about the following functions:

           Instead Of:                 Use:

           stdin                       PerlIO_stdin()
           stdout                      PerlIO_stdout()
           stderr                      PerlIO_stderr()

           fopen(fn, mode)             PerlIO_open(fn, mode)
           freopen(fn, mode, stream)   PerlIO_reopen(fn, mode, perlio) (Deprecated)
           fflush(stream)              PerlIO_flush(perlio)
           fclose(stream)              PerlIO_close(perlio)
           fread(p, size, n, stream)   PerlIO_read(perlio, buf, numbytes)
           fwrite(p, size, n, stream)  PerlIO_write(perlio, buf, numbytes)

           fputs(s, stream)            PerlIO_puts(perlio, s)

       There is no equivalent to "fgets"; one should use
       "sv_gets" instead:

           fgets(s, n, stream)         sv_gets(sv, perlio, append)

       File Positioning

           Instead Of:                 Use:

           feof(stream)                PerlIO_eof(perlio)
           fseek(stream, n, whence)    PerlIO_seek(perlio, n, whence)
           rewind(stream)              PerlIO_rewind(perlio)

           fgetpos(stream, p)          PerlIO_getpos(perlio, sv)
           fsetpos(stream, p)          PerlIO_setpos(perlio, sv)

           ferror(stream)              PerlIO_error(perlio)
           clearerr(stream)            PerlIO_clearerr(perlio)

       Memory Management and String Handling

           Instead Of:                         Use:

           t* p = malloc(n)                    New(id, p, n, t)
           t* p = calloc(n, s)                 Newz(id, p, n, t)
           p = realloc(p, n)                   Renew(p, n, t)
           memcpy(dst, src, n)                 Copy(src, dst, n, t)
           memmove(dst, src, n)                Move(src, dst, n, t)
           memcpy/*(struct foo *)              StructCopy(src, dst, t)
           memset(dst, 0, n * sizeof(t))       Zero(dst, n, t)
           memzero(dst, 0)                     Zero(dst, n, char)
           free(p)                             Safefree(p)

           strdup(p)                   savepv(p)
           strndup(p, n)               savepvn(p, n) (Hey, strndup doesn't exist!)

           strstr(big, little)         instr(big, little)
           strcmp(s1, s2)              strLE(s1, s2) / strEQ(s1, s2) / strGT(s1,s2)
           strncmp(s1, s2, n)          strnNE(s1, s2, n) / strnEQ(s1, s2, n)

       Notice the different order of arguments to "Copy" and
       "Move" than used in "memcpy" and "memmove".

       Most of the time, though, you'll want to be dealing with
       SVs internally instead of raw "char *" strings:

           strlen(s)                   sv_len(sv)

       attempting to use the data without forethought will break
       sooner rather than later.  Poisoning can be done using the
       Poison() macro, which has similar arguments as Zero():

           Poison(dst, n, t)

       Character Class Tests

       There are two types of character class tests that Perl
       implements: one type deals in "char"s and are thus not
       Unicode aware (and hence deprecated unless you know you
       should use them) and the other type deal in "UV"s and know
       about Unicode properties. In the following table, "c" is a
       "char", and "u" is a Unicode codepoint.

           Instead Of:                 Use:            But better use:

           isalnum(c)                  isALNUM(c)      isALNUM_uni(u)
           isalpha(c)                  isALPHA(c)      isALPHA_uni(u)
           iscntrl(c)                  isCNTRL(c)      isCNTRL_uni(u)
           isdigit(c)                  isDIGIT(c)      isDIGIT_uni(u)
           isgraph(c)                  isGRAPH(c)      isGRAPH_uni(u)
           islower(c)                  isLOWER(c)      isLOWER_uni(u)
           isprint(c)                  isPRINT(c)      isPRINT_uni(u)
           ispunct(c)                  isPUNCT(c)      isPUNCT_uni(u)
           isspace(c)                  isSPACE(c)      isSPACE_uni(u)
           isupper(c)                  isUPPER(c)      isUPPER_uni(u)
           isxdigit(c)                 isXDIGIT(c)     isXDIGIT_uni(u)

           tolower(c)                  toLOWER(c)      toLOWER_uni(u)
           toupper(c)                  toUPPER(c)      toUPPER_uni(u)

       stdlib.h functions

           Instead Of:                 Use:

           atof(s)                     Atof(s)
           atol(s)                     Atol(s)
           strtod(s, *p)               Nothing.  Just don't use it.
           strtol(s, *p, n)            Strtol(s, *p, n)
           strtoul(s, *p, n)           Strtoul(s, *p, n)

       Notice also the "grok_bin", "grok_hex", and "grok_oct"
       functions in numeric.c for converting strings representing
       numbers in the respective bases into "NV"s.

       In theory "Strtol" and "Strtoul" may not be defined if the
       machine perl is built on doesn't actually have strtol and
       strtoul. But as those 2 functions are part of the 1989
       ANSI C spec we suspect you'll find them everywhere by now.

           int rand()                  double Drand01()

       instead.

       For "signal"/"sigaction", use "rsignal(signo, handler)".


SEE ALSO

       "perlapi", "perlapio", "perlguts"

perl v5.8.1                 2003-09-02                PERLCLIB(1)

An undefined database error occurred. SELECT distinct pages.pagepath,pages.pageid FROM pages, page2command WHERE pages.pageid = page2command.pageid AND commandid =


  

The Linux Tutorial is always looking for new contributors.


Login
Nickname

Password

Security Code
Security Code
Type Security Code


Don't have an account yet? You can create one. As a registered user you have some advantages like theme manager, comments configuration and post comments with your name.

Help if you can!


Amazon Wish List

Did You Know?
The Linux Tutorial can use your help.


Friends



Tell a Friend About Us

Bookmark and Share



Web site powered by PHP-Nuke

Is this information useful? At the very least you can help by spreading the word to your favorite newsgroups, mailing lists and forums.
All logos and trademarks in this site are property of their respective owner. The comments are property of their posters. Articles are the property of their respective owners. Unless otherwise stated in the body of the article, article content (C) 1994-2013 by James Mohr. All rights reserved. The stylized page/paper, as well as the terms "The Linux Tutorial", "The Linux Server Tutorial", "The Linux Knowledge Base and Tutorial" and "The place where you learn Linux" are service marks of James Mohr. All rights reserved.
The Linux Knowledge Base and Tutorial may contain links to sites on the Internet, which are owned and operated by third parties. The Linux Tutorial is not responsible for the content of any such third-party site. By viewing/utilizing this web site, you have agreed to our disclaimer, terms of use and privacy policy. Use of automated download software ("harvesters") such as wget, httrack, etc. causes the site to quickly exceed its bandwidth limitation and are therefore expressly prohibited. For more details on this, take a look here

PHP-Nuke Copyright © 2004 by Francisco Burzi. This is free software, and you may redistribute it under the GPL. PHP-Nuke comes with absolutely no warranty, for details, see the license.
Page Generation: 0.08 Seconds